examples/bin_api/ip/ip.ba.go

   1 // Code generated by GoVPP binapi-generator. DO NOT EDIT.
   2 //  source: ip.api.json
   3
   4 /*
   5  Package ip is a generated from VPP binary API module 'ip'.
   6
   7  It contains following objects:
   8          87 messages
   9           8 types
  10           1 enum
  11           1 union
  12          42 services
  13
  14 */
  15 package ip
  16
  17 import "git.fd.io/govpp.git/api"
  18 import "github.com/lunixbochs/struc"
  19 import "bytes"
  20
  21 // Reference imports to suppress errors if they are not otherwise used.
  22 var _ = api.RegisterMessage
  23 var _ = struc.Pack
  24 var _ = bytes.NewBuffer
  25
  26 /* Enums */
  27
  28 // AddressFamily represents the VPP binary API enum 'address_family'.
  29 //
  30 //            "address_family",
  31 //            [
  32 //                "ADDRESS_IP4",
  33 //                0
  34 //            ],
  35 //            [
  36 //                "ADDRESS_IP6",
  37 //                1
  38 //            ],
  39 //            {
  40 //                "enumtype": "u32"
  41 //            }
  42 //
  43 type AddressFamily uint32
  44
  45 const (
  46         ADDRESS_IP4 AddressFamily = 0
  47         ADDRESS_IP6 AddressFamily = 1
  48 )
  49
  50 /* Types */
  51
  52 // IP4Address represents the VPP binary API type 'ip4_address'.
  53 //
  54 //            "ip4_address",
  55 //            [
  56 //                "u8",
  57 //                "address",
  58 //                4
  59 //            ],
  60 //            {
  61 //                "crc": "0xfc4baa28"
  62 //            }
  63 //
  64 type IP4Address struct {
  65         Address []byte `struc:"[4]byte"`
  66 }
  67
  68 func (*IP4Address) GetTypeName() string {
  69         return "ip4_address"
  70 }
  71 func (*IP4Address) GetCrcString() string {
  72         return "fc4baa28"
  73 }
  74
  75 // IP6Address represents the VPP binary API type 'ip6_address'.
  76 //
  77 //            "ip6_address",
  78 //            [
  79 //                "u8",
  80 //                "address",
  81 //                16
  82 //            ],
  83 //            {
  84 //                "crc": "0xad99ccc2"
  85 //            }
  86 //
  87 type IP6Address struct {
  88         Address []byte `struc:"[16]byte"`
  89 }
  90
  91 func (*IP6Address) GetTypeName() string {
  92         return "ip6_address"
  93 }
  94 func (*IP6Address) GetCrcString() string {
  95         return "ad99ccc2"
  96 }
  97
  98 // Address represents the VPP binary API type 'address'.
  99 //
 100 //            "address",
 101 //            [
 102 //                "vl_api_address_family_t",
 103 //                "af"
 104 //            ],
 105 //            [
 106 //                "vl_api_address_union_t",
 107 //                "un"
 108 //            ],
 109 //            {
 110 //                "crc": "0x09f11671"
 111 //            }
 112 //
 113 type Address struct {
 114         Af AddressFamily
 115         Un AddressUnion
 116 }
 117
 118 func (*Address) GetTypeName() string {
 119         return "address"
 120 }
 121 func (*Address) GetCrcString() string {
 122         return "09f11671"
 123 }
 124
 125 // Prefix represents the VPP binary API type 'prefix'.
 126 //
 127 //            "prefix",
 128 //            [
 129 //                "vl_api_address_t",
 130 //                "address"
 131 //            ],
 132 //            [
 133 //                "u8",
 134 //                "address_length"
 135 //            ],
 136 //            {
 137 //                "crc": "0x0403aebc"
 138 //            }
 139 //
 140 type Prefix struct {
 141         Address       Address
 142         AddressLength uint8
 143 }
 144
 145 func (*Prefix) GetTypeName() string {
 146         return "prefix"
 147 }
 148 func (*Prefix) GetCrcString() string {
 149         return "0403aebc"
 150 }
 151
 152 // FibMplsLabel represents the VPP binary API type 'fib_mpls_label'.
 153 //
 154 //            "fib_mpls_label",
 155 //            [
 156 //                "u8",
 157 //                "is_uniform"
 158 //            ],
 159 //            [
 160 //                "u32",
 161 //                "label"
 162 //            ],
 163 //            [
 164 //                "u8",
 165 //                "ttl"
 166 //            ],
 167 //            [
 168 //                "u8",
 169 //                "exp"
 170 //            ],
 171 //            {
 172 //                "crc": "0xc93bf35c"
 173 //            }
 174 //
 175 type FibMplsLabel struct {
 176         IsUniform uint8
 177         Label     uint32
 178         TTL       uint8
 179         Exp       uint8
 180 }
 181
 182 func (*FibMplsLabel) GetTypeName() string {
 183         return "fib_mpls_label"
 184 }
 185 func (*FibMplsLabel) GetCrcString() string {
 186         return "c93bf35c"
 187 }
 188
 189 // FibPath represents the VPP binary API type 'fib_path'.
 190 //
 191 //            "fib_path",
 192 //            [
 193 //                "u32",
 194 //                "sw_if_index"
 195 //            ],
 196 //            [
 197 //                "u32",
 198 //                "table_id"
 199 //            ],
 200 //            [
 201 //                "u8",
 202 //                "weight"
 203 //            ],
 204 //            [
 205 //                "u8",
 206 //                "preference"
 207 //            ],
 208 //            [
 209 //                "u8",
 210 //                "is_local"
 211 //            ],
 212 //            [
 213 //                "u8",
 214 //                "is_drop"
 215 //            ],
 216 //            [
 217 //                "u8",
 218 //                "is_udp_encap"
 219 //            ],
 220 //            [
 221 //                "u8",
 222 //                "is_unreach"
 223 //            ],
 224 //            [
 225 //                "u8",
 226 //                "is_prohibit"
 227 //            ],
 228 //            [
 229 //                "u8",
 230 //                "is_resolve_host"
 231 //            ],
 232 //            [
 233 //                "u8",
 234 //                "is_resolve_attached"
 235 //            ],
 236 //            [
 237 //                "u8",
 238 //                "is_dvr"
 239 //            ],
 240 //            [
 241 //                "u8",
 242 //                "is_source_lookup"
 243 //            ],
 244 //            [
 245 //                "u8",
 246 //                "afi"
 247 //            ],
 248 //            [
 249 //                "u8",
 250 //                "next_hop",
 251 //                16
 252 //            ],
 253 //            [
 254 //                "u32",
 255 //                "next_hop_id"
 256 //            ],
 257 //            [
 258 //                "u32",
 259 //                "rpf_id"
 260 //            ],
 261 //            [
 262 //                "u32",
 263 //                "via_label"
 264 //            ],
 265 //            [
 266 //                "u8",
 267 //                "n_labels"
 268 //            ],
 269 //            [
 270 //                "vl_api_fib_mpls_label_t",
 271 //                "label_stack",
 272 //                16
 273 //            ],
 274 //            {
 275 //                "crc": "0xabe483ef"
 276 //            }
 277 //
 278 type FibPath struct {
 279         SwIfIndex         uint32
 280         TableID           uint32
 281         Weight            uint8
 282         Preference        uint8
 283         IsLocal           uint8
 284         IsDrop            uint8
 285         IsUDPEncap        uint8
 286         IsUnreach         uint8
 287         IsProhibit        uint8
 288         IsResolveHost     uint8
 289         IsResolveAttached uint8
 290         IsDvr             uint8
 291         IsSourceLookup    uint8
 292         Afi               uint8
 293         NextHop           []byte `struc:"[16]byte"`
 294         NextHopID         uint32
 295         RpfID             uint32
 296         ViaLabel          uint32
 297         NLabels           uint8
 298         LabelStack        []FibMplsLabel `struc:"[16]FibMplsLabel"`
 299 }
 300
 301 func (*FibPath) GetTypeName() string {
 302         return "fib_path"
 303 }
 304 func (*FibPath) GetCrcString() string {
 305         return "abe483ef"
 306 }
 307
 308 // IP6RaPrefixInfo represents the VPP binary API type 'ip6_ra_prefix_info'.
 309 //
 310 //            "ip6_ra_prefix_info",
 311 //            [
 312 //                "u8",
 313 //                "dst_address",
 314 //                16
 315 //            ],
 316 //            [
 317 //                "u8",
 318 //                "dst_address_length"
 319 //            ],
 320 //            [
 321 //                "u8",
 322 //                "flags"
 323 //            ],
 324 //            [
 325 //                "u32",
 326 //                "valid_time"
 327 //            ],
 328 //            [
 329 //                "u32",
 330 //                "preferred_time"
 331 //            ],
 332 //            {
 333 //                "crc": "0x83d7c6e5"
 334 //            }
 335 //
 336 type IP6RaPrefixInfo struct {
 337         DstAddress       []byte `struc:"[16]byte"`
 338         DstAddressLength uint8
 339         Flags            uint8
 340         ValidTime        uint32
 341         PreferredTime    uint32
 342 }
 343
 344 func (*IP6RaPrefixInfo) GetTypeName() string {
 345         return "ip6_ra_prefix_info"
 346 }
 347 func (*IP6RaPrefixInfo) GetCrcString() string {
 348         return "83d7c6e5"
 349 }
 350
 351 // ProxyArp represents the VPP binary API type 'proxy_arp'.
 352 //
 353 //            "proxy_arp",
 354 //            [
 355 //                "u32",
 356 //                "vrf_id"
 357 //            ],
 358 //            [
 359 //                "u8",
 360 //                "low_address",
 361 //                4
 362 //            ],
 363 //            [
 364 //                "u8",
 365 //                "hi_address",
 366 //                4
 367 //            ],
 368 //            {
 369 //                "crc": "0x6d88106e"
 370 //            }
 371 //
 372 type ProxyArp struct {
 373         VrfID      uint32
 374         LowAddress []byte `struc:"[4]byte"`
 375         HiAddress  []byte `struc:"[4]byte"`
 376 }
 377
 378 func (*ProxyArp) GetTypeName() string {
 379         return "proxy_arp"
 380 }
 381 func (*ProxyArp) GetCrcString() string {
 382         return "6d88106e"
 383 }
 384
 385 /* Unions */
 386
 387 // AddressUnion represents the VPP binary API union 'address_union'.
 388 //
 389 //            "address_union",
 390 //            [
 391 //                "vl_api_ip4_address_t",
 392 //                "ip4"
 393 //            ],
 394 //            [
 395 //                "vl_api_ip6_address_t",
 396 //                "ip6"
 397 //            ],
 398 //            {
 399 //                "crc": "0xd68a2fb4"
 400 //            }
 401 //
 402 type AddressUnion struct {
 403         Union_data [16]byte
 404 }
 405
 406 func (*AddressUnion) GetTypeName() string {
 407         return "address_union"
 408 }
 409 func (*AddressUnion) GetCrcString() string {
 410         return "d68a2fb4"
 411 }
 412
 413 func (u *AddressUnion) SetIP4(a IP4Address) {
 414         var b = new(bytes.Buffer)
 415         if err := struc.Pack(b, &a); err != nil {
 416                 return
 417         }
 418         copy(u.Union_data[:], b.Bytes())
 419 }
 420 func (u *AddressUnion) GetIP4() (a IP4Address) {
 421         var b = bytes.NewReader(u.Union_data[:])
 422         struc.Unpack(b, &a)
 423         return
 424 }
 425
 426 func (u *AddressUnion) SetIP6(a IP6Address) {
 427         var b = new(bytes.Buffer)
 428         if err := struc.Pack(b, &a); err != nil {
 429                 return
 430         }
 431         copy(u.Union_data[:], b.Bytes())
 432 }
 433 func (u *AddressUnion) GetIP6() (a IP6Address) {
 434         var b = bytes.NewReader(u.Union_data[:])
 435         struc.Unpack(b, &a)
 436         return
 437 }
 438
 439 /* Messages */
 440
 441 // IPTableAddDel represents the VPP binary API message 'ip_table_add_del'.
 442 //
 443 //            "ip_table_add_del",
 444 //            [
 445 //                "u16",
 446 //                "_vl_msg_id"
 447 //            ],
 448 //            [
 449 //                "u32",
 450 //                "client_index"
 451 //            ],
 452 //            [
 453 //                "u32",
 454 //                "context"
 455 //            ],
 456 //            [
 457 //                "u32",
 458 //                "table_id"
 459 //            ],
 460 //            [
 461 //                "u8",
 462 //                "is_ipv6"
 463 //            ],
 464 //            [
 465 //                "u8",
 466 //                "is_add"
 467 //            ],
 468 //            [
 469 //                "u8",
 470 //                "name",
 471 //                64
 472 //            ],
 473 //            {
 474 //                "crc": "0x0240c89d"
 475 //            }
 476 //
 477 type IPTableAddDel struct {
 478         TableID uint32
 479         IsIPv6  uint8
 480         IsAdd   uint8
 481         Name    []byte `struc:"[64]byte"`
 482 }
 483
 484 func (*IPTableAddDel) GetMessageName() string {
 485         return "ip_table_add_del"
 486 }
 487 func (*IPTableAddDel) GetCrcString() string {
 488         return "0240c89d"
 489 }
 490 func (*IPTableAddDel) GetMessageType() api.MessageType {
 491         return api.RequestMessage
 492 }
 493
 494 // IPTableAddDelReply represents the VPP binary API message 'ip_table_add_del_reply'.
 495 //
 496 //            "ip_table_add_del_reply",
 497 //            [
 498 //                "u16",
 499 //                "_vl_msg_id"
 500 //            ],
 501 //            [
 502 //                "u32",
 503 //                "context"
 504 //            ],
 505 //            [
 506 //                "i32",
 507 //                "retval"
 508 //            ],
 509 //            {
 510 //                "crc": "0xe8d4e804"
 511 //            }
 512 //
 513 type IPTableAddDelReply struct {
 514         Retval int32
 515 }
 516
 517 func (*IPTableAddDelReply) GetMessageName() string {
 518         return "ip_table_add_del_reply"
 519 }
 520 func (*IPTableAddDelReply) GetCrcString() string {
 521         return "e8d4e804"
 522 }
 523 func (*IPTableAddDelReply) GetMessageType() api.MessageType {
 524         return api.ReplyMessage
 525 }
 526
 527 // IPFibDump represents the VPP binary API message 'ip_fib_dump'.
 528 //
 529 //            "ip_fib_dump",
 530 //            [
 531 //                "u16",
 532 //                "_vl_msg_id"
 533 //            ],
 534 //            [
 535 //                "u32",
 536 //                "client_index"
 537 //            ],
 538 //            [
 539 //                "u32",
 540 //                "context"
 541 //            ],
 542 //            {
 543 //                "crc": "0x51077d14"
 544 //            }
 545 //
 546 type IPFibDump struct{}
 547
 548 func (*IPFibDump) GetMessageName() string {
 549         return "ip_fib_dump"
 550 }
 551 func (*IPFibDump) GetCrcString() string {
 552         return "51077d14"
 553 }
 554 func (*IPFibDump) GetMessageType() api.MessageType {
 555         return api.RequestMessage
 556 }
 557
 558 // IPFibDetails represents the VPP binary API message 'ip_fib_details'.
 559 //
 560 //            "ip_fib_details",
 561 //            [
 562 //                "u16",
 563 //                "_vl_msg_id"
 564 //            ],
 565 //            [
 566 //                "u32",
 567 //                "context"
 568 //            ],
 569 //            [
 570 //                "u32",
 571 //                "table_id"
 572 //            ],
 573 //            [
 574 //                "u8",
 575 //                "table_name",
 576 //                64
 577 //            ],
 578 //            [
 579 //                "u8",
 580 //                "address_length"
 581 //            ],
 582 //            [
 583 //                "u8",
 584 //                "address",
 585 //                4
 586 //            ],
 587 //            [
 588 //                "u32",
 589 //                "count"
 590 //            ],
 591 //            [
 592 //                "vl_api_fib_path_t",
 593 //                "path",
 594 //                0,
 595 //                "count"
 596 //            ],
 597 //            {
 598 //                "crc": "0x99dfd73b"
 599 //            }
 600 //
 601 type IPFibDetails struct {
 602         TableID       uint32
 603         TableName     []byte `struc:"[64]byte"`
 604         AddressLength uint8
 605         Address       []byte `struc:"[4]byte"`
 606         Count         uint32 `struc:"sizeof=Path"`
 607         Path          []FibPath
 608 }
 609
 610 func (*IPFibDetails) GetMessageName() string {
 611         return "ip_fib_details"
 612 }
 613 func (*IPFibDetails) GetCrcString() string {
 614         return "99dfd73b"
 615 }
 616 func (*IPFibDetails) GetMessageType() api.MessageType {
 617         return api.ReplyMessage
 618 }
 619
 620 // IP6FibDump represents the VPP binary API message 'ip6_fib_dump'.
 621 //
 622 //            "ip6_fib_dump",
 623 //            [
 624 //                "u16",
 625 //                "_vl_msg_id"
 626 //            ],
 627 //            [
 628 //                "u32",
 629 //                "client_index"
 630 //            ],
 631 //            [
 632 //                "u32",
 633 //                "context"
 634 //            ],
 635 //            {
 636 //                "crc": "0x51077d14"
 637 //            }
 638 //
 639 type IP6FibDump struct{}
 640
 641 func (*IP6FibDump) GetMessageName() string {
 642         return "ip6_fib_dump"
 643 }
 644 func (*IP6FibDump) GetCrcString() string {
 645         return "51077d14"
 646 }
 647 func (*IP6FibDump) GetMessageType() api.MessageType {
 648         return api.RequestMessage
 649 }
 650
 651 // IP6FibDetails represents the VPP binary API message 'ip6_fib_details'.
 652 //
 653 //            "ip6_fib_details",
 654 //            [
 655 //                "u16",
 656 //                "_vl_msg_id"
 657 //            ],
 658 //            [
 659 //                "u32",
 660 //                "context"
 661 //            ],
 662 //            [
 663 //                "u32",
 664 //                "table_id"
 665 //            ],
 666 //            [
 667 //                "u8",
 668 //                "table_name",
 669 //                64
 670 //            ],
 671 //            [
 672 //                "u8",
 673 //                "address_length"
 674 //            ],
 675 //            [
 676 //                "u8",
 677 //                "address",
 678 //                16
 679 //            ],
 680 //            [
 681 //                "u32",
 682 //                "count"
 683 //            ],
 684 //            [
 685 //                "vl_api_fib_path_t",
 686 //                "path",
 687 //                0,
 688 //                "count"
 689 //            ],
 690 //            {
 691 //                "crc": "0xabd0060e"
 692 //            }
 693 //
 694 type IP6FibDetails struct {
 695         TableID       uint32
 696         TableName     []byte `struc:"[64]byte"`
 697         AddressLength uint8
 698         Address       []byte `struc:"[16]byte"`
 699         Count         uint32 `struc:"sizeof=Path"`
 700         Path          []FibPath
 701 }
 702
 703 func (*IP6FibDetails) GetMessageName() string {
 704         return "ip6_fib_details"
 705 }
 706 func (*IP6FibDetails) GetCrcString() string {
 707         return "abd0060e"
 708 }
 709 func (*IP6FibDetails) GetMessageType() api.MessageType {
 710         return api.ReplyMessage
 711 }
 712
 713 // IPNeighborDump represents the VPP binary API message 'ip_neighbor_dump'.
 714 //
 715 //            "ip_neighbor_dump",
 716 //            [
 717 //                "u16",
 718 //                "_vl_msg_id"
 719 //            ],
 720 //            [
 721 //                "u32",
 722 //                "client_index"
 723 //            ],
 724 //            [
 725 //                "u32",
 726 //                "context"
 727 //            ],
 728 //            [
 729 //                "u32",
 730 //                "sw_if_index"
 731 //            ],
 732 //            [
 733 //                "u8",
 734 //                "is_ipv6"
 735 //            ],
 736 //            {
 737 //                "crc": "0x6b7bcd0a"
 738 //            }
 739 //
 740 type IPNeighborDump struct {
 741         SwIfIndex uint32
 742         IsIPv6    uint8
 743 }
 744
 745 func (*IPNeighborDump) GetMessageName() string {
 746         return "ip_neighbor_dump"
 747 }
 748 func (*IPNeighborDump) GetCrcString() string {
 749         return "6b7bcd0a"
 750 }
 751 func (*IPNeighborDump) GetMessageType() api.MessageType {
 752         return api.RequestMessage
 753 }
 754
 755 // IPNeighborDetails represents the VPP binary API message 'ip_neighbor_details'.
 756 //
 757 //            "ip_neighbor_details",
 758 //            [
 759 //                "u16",
 760 //                "_vl_msg_id"
 761 //            ],
 762 //            [
 763 //                "u32",
 764 //                "context"
 765 //            ],
 766 //            [
 767 //                "u32",
 768 //                "sw_if_index"
 769 //            ],
 770 //            [
 771 //                "u8",
 772 //                "is_static"
 773 //            ],
 774 //            [
 775 //                "u8",
 776 //                "is_ipv6"
 777 //            ],
 778 //            [
 779 //                "u8",
 780 //                "mac_address",
 781 //                6
 782 //            ],
 783 //            [
 784 //                "u8",
 785 //                "ip_address",
 786 //                16
 787 //            ],
 788 //            {
 789 //                "crc": "0x85e32a72"
 790 //            }
 791 //
 792 type IPNeighborDetails struct {
 793         SwIfIndex  uint32
 794         IsStatic   uint8
 795         IsIPv6     uint8
 796         MacAddress []byte `struc:"[6]byte"`
 797         IPAddress  []byte `struc:"[16]byte"`
 798 }
 799
 800 func (*IPNeighborDetails) GetMessageName() string {
 801         return "ip_neighbor_details"
 802 }
 803 func (*IPNeighborDetails) GetCrcString() string {
 804         return "85e32a72"
 805 }
 806 func (*IPNeighborDetails) GetMessageType() api.MessageType {
 807         return api.ReplyMessage
 808 }
 809
 810 // IPNeighborAddDel represents the VPP binary API message 'ip_neighbor_add_del'.
 811 //
 812 //            "ip_neighbor_add_del",
 813 //            [
 814 //                "u16",
 815 //                "_vl_msg_id"
 816 //            ],
 817 //            [
 818 //                "u32",
 819 //                "client_index"
 820 //            ],
 821 //            [
 822 //                "u32",
 823 //                "context"
 824 //            ],
 825 //            [
 826 //                "u32",
 827 //                "sw_if_index"
 828 //            ],
 829 //            [
 830 //                "u8",
 831 //                "is_add"
 832 //            ],
 833 //            [
 834 //                "u8",
 835 //                "is_ipv6"
 836 //            ],
 837 //            [
 838 //                "u8",
 839 //                "is_static"
 840 //            ],
 841 //            [
 842 //                "u8",
 843 //                "is_no_adj_fib"
 844 //            ],
 845 //            [
 846 //                "u8",
 847 //                "mac_address",
 848 //                6
 849 //            ],
 850 //            [
 851 //                "u8",
 852 //                "dst_address",
 853 //                16
 854 //            ],
 855 //            {
 856 //                "crc": "0x4711eb25"
 857 //            }
 858 //
 859 type IPNeighborAddDel struct {
 860         SwIfIndex  uint32
 861         IsAdd      uint8
 862         IsIPv6     uint8
 863         IsStatic   uint8
 864         IsNoAdjFib uint8
 865         MacAddress []byte `struc:"[6]byte"`
 866         DstAddress []byte `struc:"[16]byte"`
 867 }
 868
 869 func (*IPNeighborAddDel) GetMessageName() string {
 870         return "ip_neighbor_add_del"
 871 }
 872 func (*IPNeighborAddDel) GetCrcString() string {
 873         return "4711eb25"
 874 }
 875 func (*IPNeighborAddDel) GetMessageType() api.MessageType {
 876         return api.RequestMessage
 877 }
 878
 879 // IPNeighborAddDelReply represents the VPP binary API message 'ip_neighbor_add_del_reply'.
 880 //
 881 //            "ip_neighbor_add_del_reply",
 882 //            [
 883 //                "u16",
 884 //                "_vl_msg_id"
 885 //            ],
 886 //            [
 887 //                "u32",
 888 //                "context"
 889 //            ],
 890 //            [
 891 //                "i32",
 892 //                "retval"
 893 //            ],
 894 //            {
 895 //                "crc": "0xe8d4e804"
 896 //            }
 897 //
 898 type IPNeighborAddDelReply struct {
 899         Retval int32
 900 }
 901
 902 func (*IPNeighborAddDelReply) GetMessageName() string {
 903         return "ip_neighbor_add_del_reply"
 904 }
 905 func (*IPNeighborAddDelReply) GetCrcString() string {
 906         return "e8d4e804"
 907 }
 908 func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
 909         return api.ReplyMessage
 910 }
 911
 912 // SetIPFlowHash represents the VPP binary API message 'set_ip_flow_hash'.
 913 //
 914 //            "set_ip_flow_hash",
 915 //            [
 916 //                "u16",
 917 //                "_vl_msg_id"
 918 //            ],
 919 //            [
 920 //                "u32",
 921 //                "client_index"
 922 //            ],
 923 //            [
 924 //                "u32",
 925 //                "context"
 926 //            ],
 927 //            [
 928 //                "u32",
 929 //                "vrf_id"
 930 //            ],
 931 //            [
 932 //                "u8",
 933 //                "is_ipv6"
 934 //            ],
 935 //            [
 936 //                "u8",
 937 //                "src"
 938 //            ],
 939 //            [
 940 //                "u8",
 941 //                "dst"
 942 //            ],
 943 //            [
 944 //                "u8",
 945 //                "sport"
 946 //            ],
 947 //            [
 948 //                "u8",
 949 //                "dport"
 950 //            ],
 951 //            [
 952 //                "u8",
 953 //                "proto"
 954 //            ],
 955 //            [
 956 //                "u8",
 957 //                "reverse"
 958 //            ],
 959 //            {
 960 //                "crc": "0x32ebf737"
 961 //            }
 962 //
 963 type SetIPFlowHash struct {
 964         VrfID   uint32
 965         IsIPv6  uint8
 966         Src     uint8
 967         Dst     uint8
 968         Sport   uint8
 969         Dport   uint8
 970         Proto   uint8
 971         Reverse uint8
 972 }
 973
 974 func (*SetIPFlowHash) GetMessageName() string {
 975         return "set_ip_flow_hash"
 976 }
 977 func (*SetIPFlowHash) GetCrcString() string {
 978         return "32ebf737"
 979 }
 980 func (*SetIPFlowHash) GetMessageType() api.MessageType {
 981         return api.RequestMessage
 982 }
 983
 984 // SetIPFlowHashReply represents the VPP binary API message 'set_ip_flow_hash_reply'.
 985 //
 986 //            "set_ip_flow_hash_reply",
 987 //            [
 988 //                "u16",
 989 //                "_vl_msg_id"
 990 //            ],
 991 //            [
 992 //                "u32",
 993 //                "context"
 994 //            ],
 995 //            [
 996 //                "i32",
 997 //                "retval"
 998 //            ],
 999 //            {
1000 //                "crc": "0xe8d4e804"
1001 //            }
1002 //
1003 type SetIPFlowHashReply struct {
1004         Retval int32
1005 }
1006
1007 func (*SetIPFlowHashReply) GetMessageName() string {
1008         return "set_ip_flow_hash_reply"
1009 }
1010 func (*SetIPFlowHashReply) GetCrcString() string {
1011         return "e8d4e804"
1012 }
1013 func (*SetIPFlowHashReply) GetMessageType() api.MessageType {
1014         return api.ReplyMessage
1015 }
1016
1017 // SwInterfaceIP6ndRaConfig represents the VPP binary API message 'sw_interface_ip6nd_ra_config'.
1018 //
1019 //            "sw_interface_ip6nd_ra_config",
1020 //            [
1021 //                "u16",
1022 //                "_vl_msg_id"
1023 //            ],
1024 //            [
1025 //                "u32",
1026 //                "client_index"
1027 //            ],
1028 //            [
1029 //                "u32",
1030 //                "context"
1031 //            ],
1032 //            [
1033 //                "u32",
1034 //                "sw_if_index"
1035 //            ],
1036 //            [
1037 //                "u8",
1038 //                "suppress"
1039 //            ],
1040 //            [
1041 //                "u8",
1042 //                "managed"
1043 //            ],
1044 //            [
1045 //                "u8",
1046 //                "other"
1047 //            ],
1048 //            [
1049 //                "u8",
1050 //                "ll_option"
1051 //            ],
1052 //            [
1053 //                "u8",
1054 //                "send_unicast"
1055 //            ],
1056 //            [
1057 //                "u8",
1058 //                "cease"
1059 //            ],
1060 //            [
1061 //                "u8",
1062 //                "is_no"
1063 //            ],
1064 //            [
1065 //                "u8",
1066 //                "default_router"
1067 //            ],
1068 //            [
1069 //                "u32",
1070 //                "max_interval"
1071 //            ],
1072 //            [
1073 //                "u32",
1074 //                "min_interval"
1075 //            ],
1076 //            [
1077 //                "u32",
1078 //                "lifetime"
1079 //            ],
1080 //            [
1081 //                "u32",
1082 //                "initial_count"
1083 //            ],
1084 //            [
1085 //                "u32",
1086 //                "initial_interval"
1087 //            ],
1088 //            {
1089 //                "crc": "0xc3f02daa"
1090 //            }
1091 //
1092 type SwInterfaceIP6ndRaConfig struct {
1093         SwIfIndex       uint32
1094         Suppress        uint8
1095         Managed         uint8
1096         Other           uint8
1097         LlOption        uint8
1098         SendUnicast     uint8
1099         Cease           uint8
1100         IsNo            uint8
1101         DefaultRouter   uint8
1102         MaxInterval     uint32
1103         MinInterval     uint32
1104         Lifetime        uint32
1105         InitialCount    uint32
1106         InitialInterval uint32
1107 }
1108
1109 func (*SwInterfaceIP6ndRaConfig) GetMessageName() string {
1110         return "sw_interface_ip6nd_ra_config"
1111 }
1112 func (*SwInterfaceIP6ndRaConfig) GetCrcString() string {
1113         return "c3f02daa"
1114 }
1115 func (*SwInterfaceIP6ndRaConfig) GetMessageType() api.MessageType {
1116         return api.RequestMessage
1117 }
1118
1119 // SwInterfaceIP6ndRaConfigReply represents the VPP binary API message 'sw_interface_ip6nd_ra_config_reply'.
1120 //
1121 //            "sw_interface_ip6nd_ra_config_reply",
1122 //            [
1123 //                "u16",
1124 //                "_vl_msg_id"
1125 //            ],
1126 //            [
1127 //                "u32",
1128 //                "context"
1129 //            ],
1130 //            [
1131 //                "i32",
1132 //                "retval"
1133 //            ],
1134 //            {
1135 //                "crc": "0xe8d4e804"
1136 //            }
1137 //
1138 type SwInterfaceIP6ndRaConfigReply struct {
1139         Retval int32
1140 }
1141
1142 func (*SwInterfaceIP6ndRaConfigReply) GetMessageName() string {
1143         return "sw_interface_ip6nd_ra_config_reply"
1144 }
1145 func (*SwInterfaceIP6ndRaConfigReply) GetCrcString() string {
1146         return "e8d4e804"
1147 }
1148 func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
1149         return api.ReplyMessage
1150 }
1151
1152 // SwInterfaceIP6ndRaPrefix represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix'.
1153 //
1154 //            "sw_interface_ip6nd_ra_prefix",
1155 //            [
1156 //                "u16",
1157 //                "_vl_msg_id"
1158 //            ],
1159 //            [
1160 //                "u32",
1161 //                "client_index"
1162 //            ],
1163 //            [
1164 //                "u32",
1165 //                "context"
1166 //            ],
1167 //            [
1168 //                "u32",
1169 //                "sw_if_index"
1170 //            ],
1171 //            [
1172 //                "u8",
1173 //                "address",
1174 //                16
1175 //            ],
1176 //            [
1177 //                "u8",
1178 //                "address_length"
1179 //            ],
1180 //            [
1181 //                "u8",
1182 //                "use_default"
1183 //            ],
1184 //            [
1185 //                "u8",
1186 //                "no_advertise"
1187 //            ],
1188 //            [
1189 //                "u8",
1190 //                "off_link"
1191 //            ],
1192 //            [
1193 //                "u8",
1194 //                "no_autoconfig"
1195 //            ],
1196 //            [
1197 //                "u8",
1198 //                "no_onlink"
1199 //            ],
1200 //            [
1201 //                "u8",
1202 //                "is_no"
1203 //            ],
1204 //            [
1205 //                "u32",
1206 //                "val_lifetime"
1207 //            ],
1208 //            [
1209 //                "u32",
1210 //                "pref_lifetime"
1211 //            ],
1212 //            {
1213 //                "crc": "0xca763c9a"
1214 //            }
1215 //
1216 type SwInterfaceIP6ndRaPrefix struct {
1217         SwIfIndex     uint32
1218         Address       []byte `struc:"[16]byte"`
1219         AddressLength uint8
1220         UseDefault    uint8
1221         NoAdvertise   uint8
1222         OffLink       uint8
1223         NoAutoconfig  uint8
1224         NoOnlink      uint8
1225         IsNo          uint8
1226         ValLifetime   uint32
1227         PrefLifetime  uint32
1228 }
1229
1230 func (*SwInterfaceIP6ndRaPrefix) GetMessageName() string {
1231         return "sw_interface_ip6nd_ra_prefix"
1232 }
1233 func (*SwInterfaceIP6ndRaPrefix) GetCrcString() string {
1234         return "ca763c9a"
1235 }
1236 func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
1237         return api.RequestMessage
1238 }
1239
1240 // SwInterfaceIP6ndRaPrefixReply represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix_reply'.
1241 //
1242 //            "sw_interface_ip6nd_ra_prefix_reply",
1243 //            [
1244 //                "u16",
1245 //                "_vl_msg_id"
1246 //            ],
1247 //            [
1248 //                "u32",
1249 //                "context"
1250 //            ],
1251 //            [
1252 //                "i32",
1253 //                "retval"
1254 //            ],
1255 //            {
1256 //                "crc": "0xe8d4e804"
1257 //            }
1258 //
1259 type SwInterfaceIP6ndRaPrefixReply struct {
1260         Retval int32
1261 }
1262
1263 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageName() string {
1264         return "sw_interface_ip6nd_ra_prefix_reply"
1265 }
1266 func (*SwInterfaceIP6ndRaPrefixReply) GetCrcString() string {
1267         return "e8d4e804"
1268 }
1269 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
1270         return api.ReplyMessage
1271 }
1272
1273 // IP6ndProxyAddDel represents the VPP binary API message 'ip6nd_proxy_add_del'.
1274 //
1275 //            "ip6nd_proxy_add_del",
1276 //            [
1277 //                "u16",
1278 //                "_vl_msg_id"
1279 //            ],
1280 //            [
1281 //                "u32",
1282 //                "client_index"
1283 //            ],
1284 //            [
1285 //                "u32",
1286 //                "context"
1287 //            ],
1288 //            [
1289 //                "u32",
1290 //                "sw_if_index"
1291 //            ],
1292 //            [
1293 //                "u8",
1294 //                "is_del"
1295 //            ],
1296 //            [
1297 //                "u8",
1298 //                "address",
1299 //                16
1300 //            ],
1301 //            {
1302 //                "crc": "0xd95f0fa0"
1303 //            }
1304 //
1305 type IP6ndProxyAddDel struct {
1306         SwIfIndex uint32
1307         IsDel     uint8
1308         Address   []byte `struc:"[16]byte"`
1309 }
1310
1311 func (*IP6ndProxyAddDel) GetMessageName() string {
1312         return "ip6nd_proxy_add_del"
1313 }
1314 func (*IP6ndProxyAddDel) GetCrcString() string {
1315         return "d95f0fa0"
1316 }
1317 func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
1318         return api.RequestMessage
1319 }
1320
1321 // IP6ndProxyAddDelReply represents the VPP binary API message 'ip6nd_proxy_add_del_reply'.
1322 //
1323 //            "ip6nd_proxy_add_del_reply",
1324 //            [
1325 //                "u16",
1326 //                "_vl_msg_id"
1327 //            ],
1328 //            [
1329 //                "u32",
1330 //                "context"
1331 //            ],
1332 //            [
1333 //                "i32",
1334 //                "retval"
1335 //            ],
1336 //            {
1337 //                "crc": "0xe8d4e804"
1338 //            }
1339 //
1340 type IP6ndProxyAddDelReply struct {
1341         Retval int32
1342 }
1343
1344 func (*IP6ndProxyAddDelReply) GetMessageName() string {
1345         return "ip6nd_proxy_add_del_reply"
1346 }
1347 func (*IP6ndProxyAddDelReply) GetCrcString() string {
1348         return "e8d4e804"
1349 }
1350 func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
1351         return api.ReplyMessage
1352 }
1353
1354 // IP6ndProxyDetails represents the VPP binary API message 'ip6nd_proxy_details'.
1355 //
1356 //            "ip6nd_proxy_details",
1357 //            [
1358 //                "u16",
1359 //                "_vl_msg_id"
1360 //            ],
1361 //            [
1362 //                "u32",
1363 //                "client_index"
1364 //            ],
1365 //            [
1366 //                "u32",
1367 //                "context"
1368 //            ],
1369 //            [
1370 //                "u32",
1371 //                "sw_if_index"
1372 //            ],
1373 //            [
1374 //                "u8",
1375 //                "address",
1376 //                16
1377 //            ],
1378 //            {
1379 //                "crc": "0xd73bf1ab"
1380 //            }
1381 //
1382 type IP6ndProxyDetails struct {
1383         SwIfIndex uint32
1384         Address   []byte `struc:"[16]byte"`
1385 }
1386
1387 func (*IP6ndProxyDetails) GetMessageName() string {
1388         return "ip6nd_proxy_details"
1389 }
1390 func (*IP6ndProxyDetails) GetCrcString() string {
1391         return "d73bf1ab"
1392 }
1393 func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
1394         return api.RequestMessage
1395 }
1396
1397 // IP6ndProxyDump represents the VPP binary API message 'ip6nd_proxy_dump'.
1398 //
1399 //            "ip6nd_proxy_dump",
1400 //            [
1401 //                "u16",
1402 //                "_vl_msg_id"
1403 //            ],
1404 //            [
1405 //                "u32",
1406 //                "client_index"
1407 //            ],
1408 //            [
1409 //                "u32",
1410 //                "context"
1411 //            ],
1412 //            {
1413 //                "crc": "0x51077d14"
1414 //            }
1415 //
1416 type IP6ndProxyDump struct{}
1417
1418 func (*IP6ndProxyDump) GetMessageName() string {
1419         return "ip6nd_proxy_dump"
1420 }
1421 func (*IP6ndProxyDump) GetCrcString() string {
1422         return "51077d14"
1423 }
1424 func (*IP6ndProxyDump) GetMessageType() api.MessageType {
1425         return api.RequestMessage
1426 }
1427
1428 // IP6ndSendRouterSolicitation represents the VPP binary API message 'ip6nd_send_router_solicitation'.
1429 //
1430 //            "ip6nd_send_router_solicitation",
1431 //            [
1432 //                "u16",
1433 //                "_vl_msg_id"
1434 //            ],
1435 //            [
1436 //                "u32",
1437 //                "client_index"
1438 //            ],
1439 //            [
1440 //                "u32",
1441 //                "context"
1442 //            ],
1443 //            [
1444 //                "u32",
1445 //                "irt"
1446 //            ],
1447 //            [
1448 //                "u32",
1449 //                "mrt"
1450 //            ],
1451 //            [
1452 //                "u32",
1453 //                "mrc"
1454 //            ],
1455 //            [
1456 //                "u32",
1457 //                "mrd"
1458 //            ],
1459 //            [
1460 //                "u32",
1461 //                "sw_if_index"
1462 //            ],
1463 //            [
1464 //                "u8",
1465 //                "stop"
1466 //            ],
1467 //            {
1468 //                "crc": "0xbd968917"
1469 //            }
1470 //
1471 type IP6ndSendRouterSolicitation struct {
1472         Irt       uint32
1473         Mrt       uint32
1474         Mrc       uint32
1475         Mrd       uint32
1476         SwIfIndex uint32
1477         Stop      uint8
1478 }
1479
1480 func (*IP6ndSendRouterSolicitation) GetMessageName() string {
1481         return "ip6nd_send_router_solicitation"
1482 }
1483 func (*IP6ndSendRouterSolicitation) GetCrcString() string {
1484         return "bd968917"
1485 }
1486 func (*IP6ndSendRouterSolicitation) GetMessageType() api.MessageType {
1487         return api.RequestMessage
1488 }
1489
1490 // IP6ndSendRouterSolicitationReply represents the VPP binary API message 'ip6nd_send_router_solicitation_reply'.
1491 //
1492 //            "ip6nd_send_router_solicitation_reply",
1493 //            [
1494 //                "u16",
1495 //                "_vl_msg_id"
1496 //            ],
1497 //            [
1498 //                "u32",
1499 //                "context"
1500 //            ],
1501 //            [
1502 //                "i32",
1503 //                "retval"
1504 //            ],
1505 //            {
1506 //                "crc": "0xe8d4e804"
1507 //            }
1508 //
1509 type IP6ndSendRouterSolicitationReply struct {
1510         Retval int32
1511 }
1512
1513 func (*IP6ndSendRouterSolicitationReply) GetMessageName() string {
1514         return "ip6nd_send_router_solicitation_reply"
1515 }
1516 func (*IP6ndSendRouterSolicitationReply) GetCrcString() string {
1517         return "e8d4e804"
1518 }
1519 func (*IP6ndSendRouterSolicitationReply) GetMessageType() api.MessageType {
1520         return api.ReplyMessage
1521 }
1522
1523 // SwInterfaceIP6EnableDisable represents the VPP binary API message 'sw_interface_ip6_enable_disable'.
1524 //
1525 //            "sw_interface_ip6_enable_disable",
1526 //            [
1527 //                "u16",
1528 //                "_vl_msg_id"
1529 //            ],
1530 //            [
1531 //                "u32",
1532 //                "client_index"
1533 //            ],
1534 //            [
1535 //                "u32",
1536 //                "context"
1537 //            ],
1538 //            [
1539 //                "u32",
1540 //                "sw_if_index"
1541 //            ],
1542 //            [
1543 //                "u8",
1544 //                "enable"
1545 //            ],
1546 //            {
1547 //                "crc": "0xa36fadc0"
1548 //            }
1549 //
1550 type SwInterfaceIP6EnableDisable struct {
1551         SwIfIndex uint32
1552         Enable    uint8
1553 }
1554
1555 func (*SwInterfaceIP6EnableDisable) GetMessageName() string {
1556         return "sw_interface_ip6_enable_disable"
1557 }
1558 func (*SwInterfaceIP6EnableDisable) GetCrcString() string {
1559         return "a36fadc0"
1560 }
1561 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
1562         return api.RequestMessage
1563 }
1564
1565 // SwInterfaceIP6EnableDisableReply represents the VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
1566 //
1567 //            "sw_interface_ip6_enable_disable_reply",
1568 //            [
1569 //                "u16",
1570 //                "_vl_msg_id"
1571 //            ],
1572 //            [
1573 //                "u32",
1574 //                "context"
1575 //            ],
1576 //            [
1577 //                "i32",
1578 //                "retval"
1579 //            ],
1580 //            {
1581 //                "crc": "0xe8d4e804"
1582 //            }
1583 //
1584 type SwInterfaceIP6EnableDisableReply struct {
1585         Retval int32
1586 }
1587
1588 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
1589         return "sw_interface_ip6_enable_disable_reply"
1590 }
1591 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string {
1592         return "e8d4e804"
1593 }
1594 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
1595         return api.ReplyMessage
1596 }
1597
1598 // SwInterfaceIP6SetLinkLocalAddress represents the VPP binary API message 'sw_interface_ip6_set_link_local_address'.
1599 //
1600 //            "sw_interface_ip6_set_link_local_address",
1601 //            [
1602 //                "u16",
1603 //                "_vl_msg_id"
1604 //            ],
1605 //            [
1606 //                "u32",
1607 //                "client_index"
1608 //            ],
1609 //            [
1610 //                "u32",
1611 //                "context"
1612 //            ],
1613 //            [
1614 //                "u32",
1615 //                "sw_if_index"
1616 //            ],
1617 //            [
1618 //                "u8",
1619 //                "address",
1620 //                16
1621 //            ],
1622 //            {
1623 //                "crc": "0xd73bf1ab"
1624 //            }
1625 //
1626 type SwInterfaceIP6SetLinkLocalAddress struct {
1627         SwIfIndex uint32
1628         Address   []byte `struc:"[16]byte"`
1629 }
1630
1631 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
1632         return "sw_interface_ip6_set_link_local_address"
1633 }
1634 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string {
1635         return "d73bf1ab"
1636 }
1637 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
1638         return api.RequestMessage
1639 }
1640
1641 // SwInterfaceIP6SetLinkLocalAddressReply represents the VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
1642 //
1643 //            "sw_interface_ip6_set_link_local_address_reply",
1644 //            [
1645 //                "u16",
1646 //                "_vl_msg_id"
1647 //            ],
1648 //            [
1649 //                "u32",
1650 //                "context"
1651 //            ],
1652 //            [
1653 //                "i32",
1654 //                "retval"
1655 //            ],
1656 //            {
1657 //                "crc": "0xe8d4e804"
1658 //            }
1659 //
1660 type SwInterfaceIP6SetLinkLocalAddressReply struct {
1661         Retval int32
1662 }
1663
1664 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
1665         return "sw_interface_ip6_set_link_local_address_reply"
1666 }
1667 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string {
1668         return "e8d4e804"
1669 }
1670 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
1671         return api.ReplyMessage
1672 }
1673
1674 // IPAddDelRoute represents the VPP binary API message 'ip_add_del_route'.
1675 //
1676 //            "ip_add_del_route",
1677 //            [
1678 //                "u16",
1679 //                "_vl_msg_id"
1680 //            ],
1681 //            [
1682 //                "u32",
1683 //                "client_index"
1684 //            ],
1685 //            [
1686 //                "u32",
1687 //                "context"
1688 //            ],
1689 //            [
1690 //                "u32",
1691 //                "next_hop_sw_if_index"
1692 //            ],
1693 //            [
1694 //                "u32",
1695 //                "table_id"
1696 //            ],
1697 //            [
1698 //                "u32",
1699 //                "classify_table_index"
1700 //            ],
1701 //            [
1702 //                "u32",
1703 //                "next_hop_table_id"
1704 //            ],
1705 //            [
1706 //                "u32",
1707 //                "next_hop_id"
1708 //            ],
1709 //            [
1710 //                "u8",
1711 //                "is_add"
1712 //            ],
1713 //            [
1714 //                "u8",
1715 //                "is_drop"
1716 //            ],
1717 //            [
1718 //                "u8",
1719 //                "is_unreach"
1720 //            ],
1721 //            [
1722 //                "u8",
1723 //                "is_prohibit"
1724 //            ],
1725 //            [
1726 //                "u8",
1727 //                "is_ipv6"
1728 //            ],
1729 //            [
1730 //                "u8",
1731 //                "is_local"
1732 //            ],
1733 //            [
1734 //                "u8",
1735 //                "is_classify"
1736 //            ],
1737 //            [
1738 //                "u8",
1739 //                "is_multipath"
1740 //            ],
1741 //            [
1742 //                "u8",
1743 //                "is_resolve_host"
1744 //            ],
1745 //            [
1746 //                "u8",
1747 //                "is_resolve_attached"
1748 //            ],
1749 //            [
1750 //                "u8",
1751 //                "is_dvr"
1752 //            ],
1753 //            [
1754 //                "u8",
1755 //                "is_source_lookup"
1756 //            ],
1757 //            [
1758 //                "u8",
1759 //                "is_udp_encap"
1760 //            ],
1761 //            [
1762 //                "u8",
1763 //                "next_hop_weight"
1764 //            ],
1765 //            [
1766 //                "u8",
1767 //                "next_hop_preference"
1768 //            ],
1769 //            [
1770 //                "u8",
1771 //                "next_hop_proto"
1772 //            ],
1773 //            [
1774 //                "u8",
1775 //                "dst_address_length"
1776 //            ],
1777 //            [
1778 //                "u8",
1779 //                "dst_address",
1780 //                16
1781 //            ],
1782 //            [
1783 //                "u8",
1784 //                "next_hop_address",
1785 //                16
1786 //            ],
1787 //            [
1788 //                "u8",
1789 //                "next_hop_n_out_labels"
1790 //            ],
1791 //            [
1792 //                "u32",
1793 //                "next_hop_via_label"
1794 //            ],
1795 //            [
1796 //                "vl_api_fib_mpls_label_t",
1797 //                "next_hop_out_label_stack",
1798 //                0,
1799 //                "next_hop_n_out_labels"
1800 //            ],
1801 //            {
1802 //                "crc": "0x4219d62d"
1803 //            }
1804 //
1805 type IPAddDelRoute struct {
1806         NextHopSwIfIndex     uint32
1807         TableID              uint32
1808         ClassifyTableIndex   uint32
1809         NextHopTableID       uint32
1810         NextHopID            uint32
1811         IsAdd                uint8
1812         IsDrop               uint8
1813         IsUnreach            uint8
1814         IsProhibit           uint8
1815         IsIPv6               uint8
1816         IsLocal              uint8
1817         IsClassify           uint8
1818         IsMultipath          uint8
1819         IsResolveHost        uint8
1820         IsResolveAttached    uint8
1821         IsDvr                uint8
1822         IsSourceLookup       uint8
1823         IsUDPEncap           uint8
1824         NextHopWeight        uint8
1825         NextHopPreference    uint8
1826         NextHopProto         uint8
1827         DstAddressLength     uint8
1828         DstAddress           []byte `struc:"[16]byte"`
1829         NextHopAddress       []byte `struc:"[16]byte"`
1830         NextHopNOutLabels    uint8  `struc:"sizeof=NextHopOutLabelStack"`
1831         NextHopViaLabel      uint32
1832         NextHopOutLabelStack []FibMplsLabel
1833 }
1834
1835 func (*IPAddDelRoute) GetMessageName() string {
1836         return "ip_add_del_route"
1837 }
1838 func (*IPAddDelRoute) GetCrcString() string {
1839         return "4219d62d"
1840 }
1841 func (*IPAddDelRoute) GetMessageType() api.MessageType {
1842         return api.RequestMessage
1843 }
1844
1845 // IPAddDelRouteReply represents the VPP binary API message 'ip_add_del_route_reply'.
1846 //
1847 //            "ip_add_del_route_reply",
1848 //            [
1849 //                "u16",
1850 //                "_vl_msg_id"
1851 //            ],
1852 //            [
1853 //                "u32",
1854 //                "context"
1855 //            ],
1856 //            [
1857 //                "i32",
1858 //                "retval"
1859 //            ],
1860 //            {
1861 //                "crc": "0xe8d4e804"
1862 //            }
1863 //
1864 type IPAddDelRouteReply struct {
1865         Retval int32
1866 }
1867
1868 func (*IPAddDelRouteReply) GetMessageName() string {
1869         return "ip_add_del_route_reply"
1870 }
1871 func (*IPAddDelRouteReply) GetCrcString() string {
1872         return "e8d4e804"
1873 }
1874 func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
1875         return api.ReplyMessage
1876 }
1877
1878 // IPMrouteAddDel represents the VPP binary API message 'ip_mroute_add_del'.
1879 //
1880 //            "ip_mroute_add_del",
1881 //            [
1882 //                "u16",
1883 //                "_vl_msg_id"
1884 //            ],
1885 //            [
1886 //                "u32",
1887 //                "client_index"
1888 //            ],
1889 //            [
1890 //                "u32",
1891 //                "context"
1892 //            ],
1893 //            [
1894 //                "u32",
1895 //                "next_hop_sw_if_index"
1896 //            ],
1897 //            [
1898 //                "u32",
1899 //                "table_id"
1900 //            ],
1901 //            [
1902 //                "u32",
1903 //                "entry_flags"
1904 //            ],
1905 //            [
1906 //                "u32",
1907 //                "itf_flags"
1908 //            ],
1909 //            [
1910 //                "u32",
1911 //                "rpf_id"
1912 //            ],
1913 //            [
1914 //                "u32",
1915 //                "bier_imp"
1916 //            ],
1917 //            [
1918 //                "u16",
1919 //                "grp_address_length"
1920 //            ],
1921 //            [
1922 //                "u8",
1923 //                "next_hop_afi"
1924 //            ],
1925 //            [
1926 //                "u8",
1927 //                "is_add"
1928 //            ],
1929 //            [
1930 //                "u8",
1931 //                "is_ipv6"
1932 //            ],
1933 //            [
1934 //                "u8",
1935 //                "is_local"
1936 //            ],
1937 //            [
1938 //                "u8",
1939 //                "grp_address",
1940 //                16
1941 //            ],
1942 //            [
1943 //                "u8",
1944 //                "src_address",
1945 //                16
1946 //            ],
1947 //            [
1948 //                "u8",
1949 //                "nh_address",
1950 //                16
1951 //            ],
1952 //            {
1953 //                "crc": "0xf44c17b1"
1954 //            }
1955 //
1956 type IPMrouteAddDel struct {
1957         NextHopSwIfIndex uint32
1958         TableID          uint32
1959         EntryFlags       uint32
1960         ItfFlags         uint32
1961         RpfID            uint32
1962         BierImp          uint32
1963         GrpAddressLength uint16
1964         NextHopAfi       uint8
1965         IsAdd            uint8
1966         IsIPv6           uint8
1967         IsLocal          uint8
1968         GrpAddress       []byte `struc:"[16]byte"`
1969         SrcAddress       []byte `struc:"[16]byte"`
1970         NhAddress        []byte `struc:"[16]byte"`
1971 }
1972
1973 func (*IPMrouteAddDel) GetMessageName() string {
1974         return "ip_mroute_add_del"
1975 }
1976 func (*IPMrouteAddDel) GetCrcString() string {
1977         return "f44c17b1"
1978 }
1979 func (*IPMrouteAddDel) GetMessageType() api.MessageType {
1980         return api.RequestMessage
1981 }
1982
1983 // IPMrouteAddDelReply represents the VPP binary API message 'ip_mroute_add_del_reply'.
1984 //
1985 //            "ip_mroute_add_del_reply",
1986 //            [
1987 //                "u16",
1988 //                "_vl_msg_id"
1989 //            ],
1990 //            [
1991 //                "u32",
1992 //                "context"
1993 //            ],
1994 //            [
1995 //                "i32",
1996 //                "retval"
1997 //            ],
1998 //            {
1999 //                "crc": "0xe8d4e804"
2000 //            }
2001 //
2002 type IPMrouteAddDelReply struct {
2003         Retval int32
2004 }
2005
2006 func (*IPMrouteAddDelReply) GetMessageName() string {
2007         return "ip_mroute_add_del_reply"
2008 }
2009 func (*IPMrouteAddDelReply) GetCrcString() string {
2010         return "e8d4e804"
2011 }
2012 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
2013         return api.ReplyMessage
2014 }
2015
2016 // IPMfibDump represents the VPP binary API message 'ip_mfib_dump'.
2017 //
2018 //            "ip_mfib_dump",
2019 //            [
2020 //                "u16",
2021 //                "_vl_msg_id"
2022 //            ],
2023 //            [
2024 //                "u32",
2025 //                "client_index"
2026 //            ],
2027 //            [
2028 //                "u32",
2029 //                "context"
2030 //            ],
2031 //            {
2032 //                "crc": "0x51077d14"
2033 //            }
2034 //
2035 type IPMfibDump struct{}
2036
2037 func (*IPMfibDump) GetMessageName() string {
2038         return "ip_mfib_dump"
2039 }
2040 func (*IPMfibDump) GetCrcString() string {
2041         return "51077d14"
2042 }
2043 func (*IPMfibDump) GetMessageType() api.MessageType {
2044         return api.RequestMessage
2045 }
2046
2047 // IPMfibDetails represents the VPP binary API message 'ip_mfib_details'.
2048 //
2049 //            "ip_mfib_details",
2050 //            [
2051 //                "u16",
2052 //                "_vl_msg_id"
2053 //            ],
2054 //            [
2055 //                "u32",
2056 //                "context"
2057 //            ],
2058 //            [
2059 //                "u32",
2060 //                "table_id"
2061 //            ],
2062 //            [
2063 //                "u32",
2064 //                "entry_flags"
2065 //            ],
2066 //            [
2067 //                "u32",
2068 //                "rpf_id"
2069 //            ],
2070 //            [
2071 //                "u8",
2072 //                "address_length"
2073 //            ],
2074 //            [
2075 //                "u8",
2076 //                "grp_address",
2077 //                4
2078 //            ],
2079 //            [
2080 //                "u8",
2081 //                "src_address",
2082 //                4
2083 //            ],
2084 //            [
2085 //                "u32",
2086 //                "count"
2087 //            ],
2088 //            [
2089 //                "vl_api_fib_path_t",
2090 //                "path",
2091 //                0,
2092 //                "count"
2093 //            ],
2094 //            {
2095 //                "crc": "0x5e530d5e"
2096 //            }
2097 //
2098 type IPMfibDetails struct {
2099         TableID       uint32
2100         EntryFlags    uint32
2101         RpfID         uint32
2102         AddressLength uint8
2103         GrpAddress    []byte `struc:"[4]byte"`
2104         SrcAddress    []byte `struc:"[4]byte"`
2105         Count         uint32 `struc:"sizeof=Path"`
2106         Path          []FibPath
2107 }
2108
2109 func (*IPMfibDetails) GetMessageName() string {
2110         return "ip_mfib_details"
2111 }
2112 func (*IPMfibDetails) GetCrcString() string {
2113         return "5e530d5e"
2114 }
2115 func (*IPMfibDetails) GetMessageType() api.MessageType {
2116         return api.ReplyMessage
2117 }
2118
2119 // IP6MfibDump represents the VPP binary API message 'ip6_mfib_dump'.
2120 //
2121 //            "ip6_mfib_dump",
2122 //            [
2123 //                "u16",
2124 //                "_vl_msg_id"
2125 //            ],
2126 //            [
2127 //                "u32",
2128 //                "client_index"
2129 //            ],
2130 //            [
2131 //                "u32",
2132 //                "context"
2133 //            ],
2134 //            {
2135 //                "crc": "0x51077d14"
2136 //            }
2137 //
2138 type IP6MfibDump struct{}
2139
2140 func (*IP6MfibDump) GetMessageName() string {
2141         return "ip6_mfib_dump"
2142 }
2143 func (*IP6MfibDump) GetCrcString() string {
2144         return "51077d14"
2145 }
2146 func (*IP6MfibDump) GetMessageType() api.MessageType {
2147         return api.RequestMessage
2148 }
2149
2150 // IP6MfibDetails represents the VPP binary API message 'ip6_mfib_details'.
2151 //
2152 //            "ip6_mfib_details",
2153 //            [
2154 //                "u16",
2155 //                "_vl_msg_id"
2156 //            ],
2157 //            [
2158 //                "u32",
2159 //                "context"
2160 //            ],
2161 //            [
2162 //                "u32",
2163 //                "table_id"
2164 //            ],
2165 //            [
2166 //                "u8",
2167 //                "address_length"
2168 //            ],
2169 //            [
2170 //                "u8",
2171 //                "grp_address",
2172 //                16
2173 //            ],
2174 //            [
2175 //                "u8",
2176 //                "src_address",
2177 //                16
2178 //            ],
2179 //            [
2180 //                "u32",
2181 //                "count"
2182 //            ],
2183 //            [
2184 //                "vl_api_fib_path_t",
2185 //                "path",
2186 //                0,
2187 //                "count"
2188 //            ],
2189 //            {
2190 //                "crc": "0xe02dcb4b"
2191 //            }
2192 //
2193 type IP6MfibDetails struct {
2194         TableID       uint32
2195         AddressLength uint8
2196         GrpAddress    []byte `struc:"[16]byte"`
2197         SrcAddress    []byte `struc:"[16]byte"`
2198         Count         uint32 `struc:"sizeof=Path"`
2199         Path          []FibPath
2200 }
2201
2202 func (*IP6MfibDetails) GetMessageName() string {
2203         return "ip6_mfib_details"
2204 }
2205 func (*IP6MfibDetails) GetCrcString() string {
2206         return "e02dcb4b"
2207 }
2208 func (*IP6MfibDetails) GetMessageType() api.MessageType {
2209         return api.ReplyMessage
2210 }
2211
2212 // IPAddressDetails represents the VPP binary API message 'ip_address_details'.
2213 //
2214 //            "ip_address_details",
2215 //            [
2216 //                "u16",
2217 //                "_vl_msg_id"
2218 //            ],
2219 //            [
2220 //                "u32",
2221 //                "client_index"
2222 //            ],
2223 //            [
2224 //                "u32",
2225 //                "context"
2226 //            ],
2227 //            [
2228 //                "u8",
2229 //                "ip",
2230 //                16
2231 //            ],
2232 //            [
2233 //                "u8",
2234 //                "prefix_length"
2235 //            ],
2236 //            [
2237 //                "u32",
2238 //                "sw_if_index"
2239 //            ],
2240 //            [
2241 //                "u8",
2242 //                "is_ipv6"
2243 //            ],
2244 //            {
2245 //                "crc": "0xbc7442f2"
2246 //            }
2247 //
2248 type IPAddressDetails struct {
2249         IP           []byte `struc:"[16]byte"`
2250         PrefixLength uint8
2251         SwIfIndex    uint32
2252         IsIPv6       uint8
2253 }
2254
2255 func (*IPAddressDetails) GetMessageName() string {
2256         return "ip_address_details"
2257 }
2258 func (*IPAddressDetails) GetCrcString() string {
2259         return "bc7442f2"
2260 }
2261 func (*IPAddressDetails) GetMessageType() api.MessageType {
2262         return api.RequestMessage
2263 }
2264
2265 // IPAddressDump represents the VPP binary API message 'ip_address_dump'.
2266 //
2267 //            "ip_address_dump",
2268 //            [
2269 //                "u16",
2270 //                "_vl_msg_id"
2271 //            ],
2272 //            [
2273 //                "u32",
2274 //                "client_index"
2275 //            ],
2276 //            [
2277 //                "u32",
2278 //                "context"
2279 //            ],
2280 //            [
2281 //                "u32",
2282 //                "sw_if_index"
2283 //            ],
2284 //            [
2285 //                "u8",
2286 //                "is_ipv6"
2287 //            ],
2288 //            {
2289 //                "crc": "0x6b7bcd0a"
2290 //            }
2291 //
2292 type IPAddressDump struct {
2293         SwIfIndex uint32
2294         IsIPv6    uint8
2295 }
2296
2297 func (*IPAddressDump) GetMessageName() string {
2298         return "ip_address_dump"
2299 }
2300 func (*IPAddressDump) GetCrcString() string {
2301         return "6b7bcd0a"
2302 }
2303 func (*IPAddressDump) GetMessageType() api.MessageType {
2304         return api.RequestMessage
2305 }
2306
2307 // IPUnnumberedDetails represents the VPP binary API message 'ip_unnumbered_details'.
2308 //
2309 //            "ip_unnumbered_details",
2310 //            [
2311 //                "u16",
2312 //                "_vl_msg_id"
2313 //            ],
2314 //            [
2315 //                "u32",
2316 //                "client_index"
2317 //            ],
2318 //            [
2319 //                "u32",
2320 //                "context"
2321 //            ],
2322 //            [
2323 //                "u32",
2324 //                "sw_if_index"
2325 //            ],
2326 //            [
2327 //                "u32",
2328 //                "ip_sw_if_index"
2329 //            ],
2330 //            {
2331 //                "crc": "0x05b717ca"
2332 //            }
2333 //
2334 type IPUnnumberedDetails struct {
2335         SwIfIndex   uint32
2336         IPSwIfIndex uint32
2337 }
2338
2339 func (*IPUnnumberedDetails) GetMessageName() string {
2340         return "ip_unnumbered_details"
2341 }
2342 func (*IPUnnumberedDetails) GetCrcString() string {
2343         return "05b717ca"
2344 }
2345 func (*IPUnnumberedDetails) GetMessageType() api.MessageType {
2346         return api.RequestMessage
2347 }
2348
2349 // IPUnnumberedDump represents the VPP binary API message 'ip_unnumbered_dump'.
2350 //
2351 //            "ip_unnumbered_dump",
2352 //            [
2353 //                "u16",
2354 //                "_vl_msg_id"
2355 //            ],
2356 //            [
2357 //                "u32",
2358 //                "client_index"
2359 //            ],
2360 //            [
2361 //                "u32",
2362 //                "context"
2363 //            ],
2364 //            [
2365 //                "u32",
2366 //                "sw_if_index"
2367 //            ],
2368 //            {
2369 //                "crc": "0x529cb13f"
2370 //            }
2371 //
2372 type IPUnnumberedDump struct {
2373         SwIfIndex uint32
2374 }
2375
2376 func (*IPUnnumberedDump) GetMessageName() string {
2377         return "ip_unnumbered_dump"
2378 }
2379 func (*IPUnnumberedDump) GetCrcString() string {
2380         return "529cb13f"
2381 }
2382 func (*IPUnnumberedDump) GetMessageType() api.MessageType {
2383         return api.RequestMessage
2384 }
2385
2386 // IPDetails represents the VPP binary API message 'ip_details'.
2387 //
2388 //            "ip_details",
2389 //            [
2390 //                "u16",
2391 //                "_vl_msg_id"
2392 //            ],
2393 //            [
2394 //                "u32",
2395 //                "sw_if_index"
2396 //            ],
2397 //            [
2398 //                "u32",
2399 //                "context"
2400 //            ],
2401 //            [
2402 //                "u8",
2403 //                "is_ipv6"
2404 //            ],
2405 //            {
2406 //                "crc": "0x452ffc5a"
2407 //            }
2408 //
2409 type IPDetails struct {
2410         SwIfIndex uint32
2411         Context   uint32
2412         IsIPv6    uint8
2413 }
2414
2415 func (*IPDetails) GetMessageName() string {
2416         return "ip_details"
2417 }
2418 func (*IPDetails) GetCrcString() string {
2419         return "452ffc5a"
2420 }
2421 func (*IPDetails) GetMessageType() api.MessageType {
2422         return api.OtherMessage
2423 }
2424
2425 // IPDump represents the VPP binary API message 'ip_dump'.
2426 //
2427 //            "ip_dump",
2428 //            [
2429 //                "u16",
2430 //                "_vl_msg_id"
2431 //            ],
2432 //            [
2433 //                "u32",
2434 //                "client_index"
2435 //            ],
2436 //            [
2437 //                "u32",
2438 //                "context"
2439 //            ],
2440 //            [
2441 //                "u8",
2442 //                "is_ipv6"
2443 //            ],
2444 //            {
2445 //                "crc": "0xde883da4"
2446 //            }
2447 //
2448 type IPDump struct {
2449         IsIPv6 uint8
2450 }
2451
2452 func (*IPDump) GetMessageName() string {
2453         return "ip_dump"
2454 }
2455 func (*IPDump) GetCrcString() string {
2456         return "de883da4"
2457 }
2458 func (*IPDump) GetMessageType() api.MessageType {
2459         return api.RequestMessage
2460 }
2461
2462 // MfibSignalDump represents the VPP binary API message 'mfib_signal_dump'.
2463 //
2464 //            "mfib_signal_dump",
2465 //            [
2466 //                "u16",
2467 //                "_vl_msg_id"
2468 //            ],
2469 //            [
2470 //                "u32",
2471 //                "client_index"
2472 //            ],
2473 //            [
2474 //                "u32",
2475 //                "context"
2476 //            ],
2477 //            {
2478 //                "crc": "0x51077d14"
2479 //            }
2480 //
2481 type MfibSignalDump struct{}
2482
2483 func (*MfibSignalDump) GetMessageName() string {
2484         return "mfib_signal_dump"
2485 }
2486 func (*MfibSignalDump) GetCrcString() string {
2487         return "51077d14"
2488 }
2489 func (*MfibSignalDump) GetMessageType() api.MessageType {
2490         return api.RequestMessage
2491 }
2492
2493 // MfibSignalDetails represents the VPP binary API message 'mfib_signal_details'.
2494 //
2495 //            "mfib_signal_details",
2496 //            [
2497 //                "u16",
2498 //                "_vl_msg_id"
2499 //            ],
2500 //            [
2501 //                "u32",
2502 //                "client_index"
2503 //            ],
2504 //            [
2505 //                "u32",
2506 //                "context"
2507 //            ],
2508 //            [
2509 //                "u32",
2510 //                "sw_if_index"
2511 //            ],
2512 //            [
2513 //                "u32",
2514 //                "table_id"
2515 //            ],
2516 //            [
2517 //                "u16",
2518 //                "grp_address_len"
2519 //            ],
2520 //            [
2521 //                "u8",
2522 //                "grp_address",
2523 //                16
2524 //            ],
2525 //            [
2526 //                "u8",
2527 //                "src_address",
2528 //                16
2529 //            ],
2530 //            [
2531 //                "u16",
2532 //                "ip_packet_len"
2533 //            ],
2534 //            [
2535 //                "u8",
2536 //                "ip_packet_data",
2537 //                256
2538 //            ],
2539 //            {
2540 //                "crc": "0x791bbeab"
2541 //            }
2542 //
2543 type MfibSignalDetails struct {
2544         SwIfIndex     uint32
2545         TableID       uint32
2546         GrpAddressLen uint16
2547         GrpAddress    []byte `struc:"[16]byte"`
2548         SrcAddress    []byte `struc:"[16]byte"`
2549         IPPacketLen   uint16
2550         IPPacketData  []byte `struc:"[256]byte"`
2551 }
2552
2553 func (*MfibSignalDetails) GetMessageName() string {
2554         return "mfib_signal_details"
2555 }
2556 func (*MfibSignalDetails) GetCrcString() string {
2557         return "791bbeab"
2558 }
2559 func (*MfibSignalDetails) GetMessageType() api.MessageType {
2560         return api.RequestMessage
2561 }
2562
2563 // IPPuntPolice represents the VPP binary API message 'ip_punt_police'.
2564 //
2565 //            "ip_punt_police",
2566 //            [
2567 //                "u16",
2568 //                "_vl_msg_id"
2569 //            ],
2570 //            [
2571 //                "u32",
2572 //                "client_index"
2573 //            ],
2574 //            [
2575 //                "u32",
2576 //                "context"
2577 //            ],
2578 //            [
2579 //                "u32",
2580 //                "policer_index"
2581 //            ],
2582 //            [
2583 //                "u8",
2584 //                "is_add"
2585 //            ],
2586 //            [
2587 //                "u8",
2588 //                "is_ip6"
2589 //            ],
2590 //            {
2591 //                "crc": "0x38691592"
2592 //            }
2593 //
2594 type IPPuntPolice struct {
2595         PolicerIndex uint32
2596         IsAdd        uint8
2597         IsIP6        uint8
2598 }
2599
2600 func (*IPPuntPolice) GetMessageName() string {
2601         return "ip_punt_police"
2602 }
2603 func (*IPPuntPolice) GetCrcString() string {
2604         return "38691592"
2605 }
2606 func (*IPPuntPolice) GetMessageType() api.MessageType {
2607         return api.RequestMessage
2608 }
2609
2610 // IPPuntPoliceReply represents the VPP binary API message 'ip_punt_police_reply'.
2611 //
2612 //            "ip_punt_police_reply",
2613 //            [
2614 //                "u16",
2615 //                "_vl_msg_id"
2616 //            ],
2617 //            [
2618 //                "u32",
2619 //                "context"
2620 //            ],
2621 //            [
2622 //                "i32",
2623 //                "retval"
2624 //            ],
2625 //            {
2626 //                "crc": "0xe8d4e804"
2627 //            }
2628 //
2629 type IPPuntPoliceReply struct {
2630         Retval int32
2631 }
2632
2633 func (*IPPuntPoliceReply) GetMessageName() string {
2634         return "ip_punt_police_reply"
2635 }
2636 func (*IPPuntPoliceReply) GetCrcString() string {
2637         return "e8d4e804"
2638 }
2639 func (*IPPuntPoliceReply) GetMessageType() api.MessageType {
2640         return api.ReplyMessage
2641 }
2642
2643 // IPPuntRedirect represents the VPP binary API message 'ip_punt_redirect'.
2644 //
2645 //            "ip_punt_redirect",
2646 //            [
2647 //                "u16",
2648 //                "_vl_msg_id"
2649 //            ],
2650 //            [
2651 //                "u32",
2652 //                "client_index"
2653 //            ],
2654 //            [
2655 //                "u32",
2656 //                "context"
2657 //            ],
2658 //            [
2659 //                "u32",
2660 //                "rx_sw_if_index"
2661 //            ],
2662 //            [
2663 //                "u32",
2664 //                "tx_sw_if_index"
2665 //            ],
2666 //            [
2667 //                "u8",
2668 //                "is_add"
2669 //            ],
2670 //            [
2671 //                "u8",
2672 //                "is_ip6"
2673 //            ],
2674 //            [
2675 //                "u8",
2676 //                "nh",
2677 //                16
2678 //            ],
2679 //            {
2680 //                "crc": "0x996b6603"
2681 //            }
2682 //
2683 type IPPuntRedirect struct {
2684         RxSwIfIndex uint32
2685         TxSwIfIndex uint32
2686         IsAdd       uint8
2687         IsIP6       uint8
2688         Nh          []byte `struc:"[16]byte"`
2689 }
2690
2691 func (*IPPuntRedirect) GetMessageName() string {
2692         return "ip_punt_redirect"
2693 }
2694 func (*IPPuntRedirect) GetCrcString() string {
2695         return "996b6603"
2696 }
2697 func (*IPPuntRedirect) GetMessageType() api.MessageType {
2698         return api.RequestMessage
2699 }
2700
2701 // IPPuntRedirectReply represents the VPP binary API message 'ip_punt_redirect_reply'.
2702 //
2703 //            "ip_punt_redirect_reply",
2704 //            [
2705 //                "u16",
2706 //                "_vl_msg_id"
2707 //            ],
2708 //            [
2709 //                "u32",
2710 //                "context"
2711 //            ],
2712 //            [
2713 //                "i32",
2714 //                "retval"
2715 //            ],
2716 //            {
2717 //                "crc": "0xe8d4e804"
2718 //            }
2719 //
2720 type IPPuntRedirectReply struct {
2721         Retval int32
2722 }
2723
2724 func (*IPPuntRedirectReply) GetMessageName() string {
2725         return "ip_punt_redirect_reply"
2726 }
2727 func (*IPPuntRedirectReply) GetCrcString() string {
2728         return "e8d4e804"
2729 }
2730 func (*IPPuntRedirectReply) GetMessageType() api.MessageType {
2731         return api.ReplyMessage
2732 }
2733
2734 // IPContainerProxyAddDel represents the VPP binary API message 'ip_container_proxy_add_del'.
2735 //
2736 //            "ip_container_proxy_add_del",
2737 //            [
2738 //                "u16",
2739 //                "_vl_msg_id"
2740 //            ],
2741 //            [
2742 //                "u32",
2743 //                "client_index"
2744 //            ],
2745 //            [
2746 //                "u32",
2747 //                "context"
2748 //            ],
2749 //            [
2750 //                "u8",
2751 //                "ip",
2752 //                16
2753 //            ],
2754 //            [
2755 //                "u8",
2756 //                "is_ip4"
2757 //            ],
2758 //            [
2759 //                "u8",
2760 //                "plen"
2761 //            ],
2762 //            [
2763 //                "u32",
2764 //                "sw_if_index"
2765 //            ],
2766 //            [
2767 //                "u8",
2768 //                "is_add"
2769 //            ],
2770 //            {
2771 //                "crc": "0x0a355d39"
2772 //            }
2773 //
2774 type IPContainerProxyAddDel struct {
2775         IP        []byte `struc:"[16]byte"`
2776         IsIP4     uint8
2777         Plen      uint8
2778         SwIfIndex uint32
2779         IsAdd     uint8
2780 }
2781
2782 func (*IPContainerProxyAddDel) GetMessageName() string {
2783         return "ip_container_proxy_add_del"
2784 }
2785 func (*IPContainerProxyAddDel) GetCrcString() string {
2786         return "0a355d39"
2787 }
2788 func (*IPContainerProxyAddDel) GetMessageType() api.MessageType {
2789         return api.RequestMessage
2790 }
2791
2792 // IPContainerProxyAddDelReply represents the VPP binary API message 'ip_container_proxy_add_del_reply'.
2793 //
2794 //            "ip_container_proxy_add_del_reply",
2795 //            [
2796 //                "u16",
2797 //                "_vl_msg_id"
2798 //            ],
2799 //            [
2800 //                "u32",
2801 //                "context"
2802 //            ],
2803 //            [
2804 //                "i32",
2805 //                "retval"
2806 //            ],
2807 //            {
2808 //                "crc": "0xe8d4e804"
2809 //            }
2810 //
2811 type IPContainerProxyAddDelReply struct {
2812         Retval int32
2813 }
2814
2815 func (*IPContainerProxyAddDelReply) GetMessageName() string {
2816         return "ip_container_proxy_add_del_reply"
2817 }
2818 func (*IPContainerProxyAddDelReply) GetCrcString() string {
2819         return "e8d4e804"
2820 }
2821 func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType {
2822         return api.ReplyMessage
2823 }
2824
2825 // IPSourceAndPortRangeCheckAddDel represents the VPP binary API message 'ip_source_and_port_range_check_add_del'.
2826 //
2827 //            "ip_source_and_port_range_check_add_del",
2828 //            [
2829 //                "u16",
2830 //                "_vl_msg_id"
2831 //            ],
2832 //            [
2833 //                "u32",
2834 //                "client_index"
2835 //            ],
2836 //            [
2837 //                "u32",
2838 //                "context"
2839 //            ],
2840 //            [
2841 //                "u8",
2842 //                "is_ipv6"
2843 //            ],
2844 //            [
2845 //                "u8",
2846 //                "is_add"
2847 //            ],
2848 //            [
2849 //                "u8",
2850 //                "mask_length"
2851 //            ],
2852 //            [
2853 //                "u8",
2854 //                "address",
2855 //                16
2856 //            ],
2857 //            [
2858 //                "u8",
2859 //                "number_of_ranges"
2860 //            ],
2861 //            [
2862 //                "u16",
2863 //                "low_ports",
2864 //                32
2865 //            ],
2866 //            [
2867 //                "u16",
2868 //                "high_ports",
2869 //                32
2870 //            ],
2871 //            [
2872 //                "u32",
2873 //                "vrf_id"
2874 //            ],
2875 //            {
2876 //                "crc": "0x03d6b03a"
2877 //            }
2878 //
2879 type IPSourceAndPortRangeCheckAddDel struct {
2880         IsIPv6         uint8
2881         IsAdd          uint8
2882         MaskLength     uint8
2883         Address        []byte `struc:"[16]byte"`
2884         NumberOfRanges uint8
2885         LowPorts       []uint16 `struc:"[32]uint16"`
2886         HighPorts      []uint16 `struc:"[32]uint16"`
2887         VrfID          uint32
2888 }
2889
2890 func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
2891         return "ip_source_and_port_range_check_add_del"
2892 }
2893 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string {
2894         return "03d6b03a"
2895 }
2896 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
2897         return api.RequestMessage
2898 }
2899
2900 // IPSourceAndPortRangeCheckAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
2901 //
2902 //            "ip_source_and_port_range_check_add_del_reply",
2903 //            [
2904 //                "u16",
2905 //                "_vl_msg_id"
2906 //            ],
2907 //            [
2908 //                "u32",
2909 //                "context"
2910 //            ],
2911 //            [
2912 //                "i32",
2913 //                "retval"
2914 //            ],
2915 //            {
2916 //                "crc": "0xe8d4e804"
2917 //            }
2918 //
2919 type IPSourceAndPortRangeCheckAddDelReply struct {
2920         Retval int32
2921 }
2922
2923 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
2924         return "ip_source_and_port_range_check_add_del_reply"
2925 }
2926 func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string {
2927         return "e8d4e804"
2928 }
2929 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
2930         return api.ReplyMessage
2931 }
2932
2933 // IPSourceAndPortRangeCheckInterfaceAddDel represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
2934 //
2935 //            "ip_source_and_port_range_check_interface_add_del",
2936 //            [
2937 //                "u16",
2938 //                "_vl_msg_id"
2939 //            ],
2940 //            [
2941 //                "u32",
2942 //                "client_index"
2943 //            ],
2944 //            [
2945 //                "u32",
2946 //                "context"
2947 //            ],
2948 //            [
2949 //                "u8",
2950 //                "is_add"
2951 //            ],
2952 //            [
2953 //                "u32",
2954 //                "sw_if_index"
2955 //            ],
2956 //            [
2957 //                "u32",
2958 //                "tcp_in_vrf_id"
2959 //            ],
2960 //            [
2961 //                "u32",
2962 //                "tcp_out_vrf_id"
2963 //            ],
2964 //            [
2965 //                "u32",
2966 //                "udp_in_vrf_id"
2967 //            ],
2968 //            [
2969 //                "u32",
2970 //                "udp_out_vrf_id"
2971 //            ],
2972 //            {
2973 //                "crc": "0x6966bc44"
2974 //            }
2975 //
2976 type IPSourceAndPortRangeCheckInterfaceAddDel struct {
2977         IsAdd       uint8
2978         SwIfIndex   uint32
2979         TCPInVrfID  uint32
2980         TCPOutVrfID uint32
2981         UDPInVrfID  uint32
2982         UDPOutVrfID uint32
2983 }
2984
2985 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
2986         return "ip_source_and_port_range_check_interface_add_del"
2987 }
2988 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string {
2989         return "6966bc44"
2990 }
2991 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
2992         return api.RequestMessage
2993 }
2994
2995 // IPSourceAndPortRangeCheckInterfaceAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
2996 //
2997 //            "ip_source_and_port_range_check_interface_add_del_reply",
2998 //            [
2999 //                "u16",
3000 //                "_vl_msg_id"
3001 //            ],
3002 //            [
3003 //                "u32",
3004 //                "context"
3005 //            ],
3006 //            [
3007 //                "i32",
3008 //                "retval"
3009 //            ],
3010 //            {
3011 //                "crc": "0xe8d4e804"
3012 //            }
3013 //
3014 type IPSourceAndPortRangeCheckInterfaceAddDelReply struct {
3015         Retval int32
3016 }
3017
3018 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
3019         return "ip_source_and_port_range_check_interface_add_del_reply"
3020 }
3021 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string {
3022         return "e8d4e804"
3023 }
3024 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
3025         return api.ReplyMessage
3026 }
3027
3028 // IPScanNeighborEnableDisable represents the VPP binary API message 'ip_scan_neighbor_enable_disable'.
3029 //
3030 //            "ip_scan_neighbor_enable_disable",
3031 //            [
3032 //                "u16",
3033 //                "_vl_msg_id"
3034 //            ],
3035 //            [
3036 //                "u32",
3037 //                "client_index"
3038 //            ],
3039 //            [
3040 //                "u32",
3041 //                "context"
3042 //            ],
3043 //            [
3044 //                "u8",
3045 //                "mode"
3046 //            ],
3047 //            [
3048 //                "u8",
3049 //                "scan_interval"
3050 //            ],
3051 //            [
3052 //                "u8",
3053 //                "max_proc_time"
3054 //            ],
3055 //            [
3056 //                "u8",
3057 //                "max_update"
3058 //            ],
3059 //            [
3060 //                "u8",
3061 //                "scan_int_delay"
3062 //            ],
3063 //            [
3064 //                "u8",
3065 //                "stale_threshold"
3066 //            ],
3067 //            {
3068 //                "crc": "0x0a6bf57a"
3069 //            }
3070 //
3071 type IPScanNeighborEnableDisable struct {
3072         Mode           uint8
3073         ScanInterval   uint8
3074         MaxProcTime    uint8
3075         MaxUpdate      uint8
3076         ScanIntDelay   uint8
3077         StaleThreshold uint8
3078 }
3079
3080 func (*IPScanNeighborEnableDisable) GetMessageName() string {
3081         return "ip_scan_neighbor_enable_disable"
3082 }
3083 func (*IPScanNeighborEnableDisable) GetCrcString() string {
3084         return "0a6bf57a"
3085 }
3086 func (*IPScanNeighborEnableDisable) GetMessageType() api.MessageType {
3087         return api.RequestMessage
3088 }
3089
3090 // IPScanNeighborEnableDisableReply represents the VPP binary API message 'ip_scan_neighbor_enable_disable_reply'.
3091 //
3092 //            "ip_scan_neighbor_enable_disable_reply",
3093 //            [
3094 //                "u16",
3095 //                "_vl_msg_id"
3096 //            ],
3097 //            [
3098 //                "u32",
3099 //                "context"
3100 //            ],
3101 //            [
3102 //                "i32",
3103 //                "retval"
3104 //            ],
3105 //            {
3106 //                "crc": "0xe8d4e804"
3107 //            }
3108 //
3109 type IPScanNeighborEnableDisableReply struct {
3110         Retval int32
3111 }
3112
3113 func (*IPScanNeighborEnableDisableReply) GetMessageName() string {
3114         return "ip_scan_neighbor_enable_disable_reply"
3115 }
3116 func (*IPScanNeighborEnableDisableReply) GetCrcString() string {
3117         return "e8d4e804"
3118 }
3119 func (*IPScanNeighborEnableDisableReply) GetMessageType() api.MessageType {
3120         return api.ReplyMessage
3121 }
3122
3123 // IPProbeNeighbor represents the VPP binary API message 'ip_probe_neighbor'.
3124 //
3125 //            "ip_probe_neighbor",
3126 //            [
3127 //                "u16",
3128 //                "_vl_msg_id"
3129 //            ],
3130 //            [
3131 //                "u32",
3132 //                "client_index"
3133 //            ],
3134 //            [
3135 //                "u32",
3136 //                "context"
3137 //            ],
3138 //            [
3139 //                "u32",
3140 //                "sw_if_index"
3141 //            ],
3142 //            [
3143 //                "u8",
3144 //                "dst_address",
3145 //                16
3146 //            ],
3147 //            [
3148 //                "u8",
3149 //                "is_ipv6"
3150 //            ],
3151 //            {
3152 //                "crc": "0x1e44bfd7"
3153 //            }
3154 //
3155 type IPProbeNeighbor struct {
3156         SwIfIndex  uint32
3157         DstAddress []byte `struc:"[16]byte"`
3158         IsIPv6     uint8
3159 }
3160
3161 func (*IPProbeNeighbor) GetMessageName() string {
3162         return "ip_probe_neighbor"
3163 }
3164 func (*IPProbeNeighbor) GetCrcString() string {
3165         return "1e44bfd7"
3166 }
3167 func (*IPProbeNeighbor) GetMessageType() api.MessageType {
3168         return api.RequestMessage
3169 }
3170
3171 // IPProbeNeighborReply represents the VPP binary API message 'ip_probe_neighbor_reply'.
3172 //
3173 //            "ip_probe_neighbor_reply",
3174 //            [
3175 //                "u16",
3176 //                "_vl_msg_id"
3177 //            ],
3178 //            [
3179 //                "u32",
3180 //                "context"
3181 //            ],
3182 //            [
3183 //                "i32",
3184 //                "retval"
3185 //            ],
3186 //            {
3187 //                "crc": "0xe8d4e804"
3188 //            }
3189 //
3190 type IPProbeNeighborReply struct {
3191         Retval int32
3192 }
3193
3194 func (*IPProbeNeighborReply) GetMessageName() string {
3195         return "ip_probe_neighbor_reply"
3196 }
3197 func (*IPProbeNeighborReply) GetCrcString() string {
3198         return "e8d4e804"
3199 }
3200 func (*IPProbeNeighborReply) GetMessageType() api.MessageType {
3201         return api.ReplyMessage
3202 }
3203
3204 // WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'.
3205 //
3206 //            "want_ip4_arp_events",
3207 //            [
3208 //                "u16",
3209 //                "_vl_msg_id"
3210 //            ],
3211 //            [
3212 //                "u32",
3213 //                "client_index"
3214 //            ],
3215 //            [
3216 //                "u32",
3217 //                "context"
3218 //            ],
3219 //            [
3220 //                "u8",
3221 //                "enable_disable"
3222 //            ],
3223 //            [
3224 //                "u32",
3225 //                "pid"
3226 //            ],
3227 //            [
3228 //                "u32",
3229 //                "address"
3230 //            ],
3231 //            {
3232 //                "crc": "0x77e06379"
3233 //            }
3234 //
3235 type WantIP4ArpEvents struct {
3236         EnableDisable uint8
3237         PID           uint32
3238         Address       uint32
3239 }
3240
3241 func (*WantIP4ArpEvents) GetMessageName() string {
3242         return "want_ip4_arp_events"
3243 }
3244 func (*WantIP4ArpEvents) GetCrcString() string {
3245         return "77e06379"
3246 }
3247 func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
3248         return api.RequestMessage
3249 }
3250
3251 // WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'.
3252 //
3253 //            "want_ip4_arp_events_reply",
3254 //            [
3255 //                "u16",
3256 //                "_vl_msg_id"
3257 //            ],
3258 //            [
3259 //                "u32",
3260 //                "context"
3261 //            ],
3262 //            [
3263 //                "i32",
3264 //                "retval"
3265 //            ],
3266 //            {
3267 //                "crc": "0xe8d4e804"
3268 //            }
3269 //
3270 type WantIP4ArpEventsReply struct {
3271         Retval int32
3272 }
3273
3274 func (*WantIP4ArpEventsReply) GetMessageName() string {
3275         return "want_ip4_arp_events_reply"
3276 }
3277 func (*WantIP4ArpEventsReply) GetCrcString() string {
3278         return "e8d4e804"
3279 }
3280 func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
3281         return api.ReplyMessage
3282 }
3283
3284 // IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'.
3285 //
3286 //            "ip4_arp_event",
3287 //            [
3288 //                "u16",
3289 //                "_vl_msg_id"
3290 //            ],
3291 //            [
3292 //                "u32",
3293 //                "client_index"
3294 //            ],
3295 //            [
3296 //                "u32",
3297 //                "address"
3298 //            ],
3299 //            [
3300 //                "u32",
3301 //                "pid"
3302 //            ],
3303 //            [
3304 //                "u32",
3305 //                "sw_if_index"
3306 //            ],
3307 //            [
3308 //                "u8",
3309 //                "new_mac",
3310 //                6
3311 //            ],
3312 //            [
3313 //                "u8",
3314 //                "mac_ip"
3315 //            ],
3316 //            {
3317 //                "crc": "0xef7235f7"
3318 //            }
3319 //
3320 type IP4ArpEvent struct {
3321         Address   uint32
3322         PID       uint32
3323         SwIfIndex uint32
3324         NewMac    []byte `struc:"[6]byte"`
3325         MacIP     uint8
3326 }
3327
3328 func (*IP4ArpEvent) GetMessageName() string {
3329         return "ip4_arp_event"
3330 }
3331 func (*IP4ArpEvent) GetCrcString() string {
3332         return "ef7235f7"
3333 }
3334 func (*IP4ArpEvent) GetMessageType() api.MessageType {
3335         return api.EventMessage
3336 }
3337
3338 // WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'.
3339 //
3340 //            "want_ip6_nd_events",
3341 //            [
3342 //                "u16",
3343 //                "_vl_msg_id"
3344 //            ],
3345 //            [
3346 //                "u32",
3347 //                "client_index"
3348 //            ],
3349 //            [
3350 //                "u32",
3351 //                "context"
3352 //            ],
3353 //            [
3354 //                "u8",
3355 //                "enable_disable"
3356 //            ],
3357 //            [
3358 //                "u32",
3359 //                "pid"
3360 //            ],
3361 //            [
3362 //                "u8",
3363 //                "address",
3364 //                16
3365 //            ],
3366 //            {
3367 //                "crc": "0x1cf65fbb"
3368 //            }
3369 //
3370 type WantIP6NdEvents struct {
3371         EnableDisable uint8
3372         PID           uint32
3373         Address       []byte `struc:"[16]byte"`
3374 }
3375
3376 func (*WantIP6NdEvents) GetMessageName() string {
3377         return "want_ip6_nd_events"
3378 }
3379 func (*WantIP6NdEvents) GetCrcString() string {
3380         return "1cf65fbb"
3381 }
3382 func (*WantIP6NdEvents) GetMessageType() api.MessageType {
3383         return api.RequestMessage
3384 }
3385
3386 // WantIP6NdEventsReply represents the VPP binary API message 'want_ip6_nd_events_reply'.
3387 //
3388 //            "want_ip6_nd_events_reply",
3389 //            [
3390 //                "u16",
3391 //                "_vl_msg_id"
3392 //            ],
3393 //            [
3394 //                "u32",
3395 //                "context"
3396 //            ],
3397 //            [
3398 //                "i32",
3399 //                "retval"
3400 //            ],
3401 //            {
3402 //                "crc": "0xe8d4e804"
3403 //            }
3404 //
3405 type WantIP6NdEventsReply struct {
3406         Retval int32
3407 }
3408
3409 func (*WantIP6NdEventsReply) GetMessageName() string {
3410         return "want_ip6_nd_events_reply"
3411 }
3412 func (*WantIP6NdEventsReply) GetCrcString() string {
3413         return "e8d4e804"
3414 }
3415 func (*WantIP6NdEventsReply) GetMessageType() api.MessageType {
3416         return api.ReplyMessage
3417 }
3418
3419 // IP6NdEvent represents the VPP binary API message 'ip6_nd_event'.
3420 //
3421 //            "ip6_nd_event",
3422 //            [
3423 //                "u16",
3424 //                "_vl_msg_id"
3425 //            ],
3426 //            [
3427 //                "u32",
3428 //                "client_index"
3429 //            ],
3430 //            [
3431 //                "u32",
3432 //                "pid"
3433 //            ],
3434 //            [
3435 //                "u32",
3436 //                "sw_if_index"
3437 //            ],
3438 //            [
3439 //                "u8",
3440 //                "address",
3441 //                16
3442 //            ],
3443 //            [
3444 //                "u8",
3445 //                "new_mac",
3446 //                6
3447 //            ],
3448 //            [
3449 //                "u8",
3450 //                "mac_ip"
3451 //            ],
3452 //            {
3453 //                "crc": "0x96ab2fdd"
3454 //            }
3455 //
3456 type IP6NdEvent struct {
3457         PID       uint32
3458         SwIfIndex uint32
3459         Address   []byte `struc:"[16]byte"`
3460         NewMac    []byte `struc:"[6]byte"`
3461         MacIP     uint8
3462 }
3463
3464 func (*IP6NdEvent) GetMessageName() string {
3465         return "ip6_nd_event"
3466 }
3467 func (*IP6NdEvent) GetCrcString() string {
3468         return "96ab2fdd"
3469 }
3470 func (*IP6NdEvent) GetMessageType() api.MessageType {
3471         return api.EventMessage
3472 }
3473
3474 // WantIP6RaEvents represents the VPP binary API message 'want_ip6_ra_events'.
3475 //
3476 //            "want_ip6_ra_events",
3477 //            [
3478 //                "u16",
3479 //                "_vl_msg_id"
3480 //            ],
3481 //            [
3482 //                "u32",
3483 //                "client_index"
3484 //            ],
3485 //            [
3486 //                "u32",
3487 //                "context"
3488 //            ],
3489 //            [
3490 //                "u8",
3491 //                "enable_disable"
3492 //            ],
3493 //            [
3494 //                "u32",
3495 //                "pid"
3496 //            ],
3497 //            {
3498 //                "crc": "0x05b454b5"
3499 //            }
3500 //
3501 type WantIP6RaEvents struct {
3502         EnableDisable uint8
3503         PID           uint32
3504 }
3505
3506 func (*WantIP6RaEvents) GetMessageName() string {
3507         return "want_ip6_ra_events"
3508 }
3509 func (*WantIP6RaEvents) GetCrcString() string {
3510         return "05b454b5"
3511 }
3512 func (*WantIP6RaEvents) GetMessageType() api.MessageType {
3513         return api.RequestMessage
3514 }
3515
3516 // WantIP6RaEventsReply represents the VPP binary API message 'want_ip6_ra_events_reply'.
3517 //
3518 //            "want_ip6_ra_events_reply",
3519 //            [
3520 //                "u16",
3521 //                "_vl_msg_id"
3522 //            ],
3523 //            [
3524 //                "u32",
3525 //                "context"
3526 //            ],
3527 //            [
3528 //                "i32",
3529 //                "retval"
3530 //            ],
3531 //            {
3532 //                "crc": "0xe8d4e804"
3533 //            }
3534 //
3535 type WantIP6RaEventsReply struct {
3536         Retval int32
3537 }
3538
3539 func (*WantIP6RaEventsReply) GetMessageName() string {
3540         return "want_ip6_ra_events_reply"
3541 }
3542 func (*WantIP6RaEventsReply) GetCrcString() string {
3543         return "e8d4e804"
3544 }
3545 func (*WantIP6RaEventsReply) GetMessageType() api.MessageType {
3546         return api.ReplyMessage
3547 }
3548
3549 // IP6RaEvent represents the VPP binary API message 'ip6_ra_event'.
3550 //
3551 //            "ip6_ra_event",
3552 //            [
3553 //                "u16",
3554 //                "_vl_msg_id"
3555 //            ],
3556 //            [
3557 //                "u32",
3558 //                "client_index"
3559 //            ],
3560 //            [
3561 //                "u32",
3562 //                "pid"
3563 //            ],
3564 //            [
3565 //                "u32",
3566 //                "sw_if_index"
3567 //            ],
3568 //            [
3569 //                "u8",
3570 //                "router_address",
3571 //                16
3572 //            ],
3573 //            [
3574 //                "u8",
3575 //                "current_hop_limit"
3576 //            ],
3577 //            [
3578 //                "u8",
3579 //                "flags"
3580 //            ],
3581 //            [
3582 //                "u16",
3583 //                "router_lifetime_in_sec"
3584 //            ],
3585 //            [
3586 //                "u32",
3587 //                "neighbor_reachable_time_in_msec"
3588 //            ],
3589 //            [
3590 //                "u32",
3591 //                "time_in_msec_between_retransmitted_neighbor_solicitations"
3592 //            ],
3593 //            [
3594 //                "u32",
3595 //                "n_prefixes"
3596 //            ],
3597 //            [
3598 //                "vl_api_ip6_ra_prefix_info_t",
3599 //                "prefixes",
3600 //                0,
3601 //                "n_prefixes"
3602 //            ],
3603 //            {
3604 //                "crc": "0xc5e54257"
3605 //            }
3606 //
3607 type IP6RaEvent struct {
3608         PID                                                 uint32
3609         SwIfIndex                                           uint32
3610         RouterAddress                                       []byte `struc:"[16]byte"`
3611         CurrentHopLimit                                     uint8
3612         Flags                                               uint8
3613         RouterLifetimeInSec                                 uint16
3614         NeighborReachableTimeInMsec                         uint32
3615         TimeInMsecBetweenRetransmittedNeighborSolicitations uint32
3616         NPrefixes                                           uint32 `struc:"sizeof=Prefixes"`
3617         Prefixes                                            []IP6RaPrefixInfo
3618 }
3619
3620 func (*IP6RaEvent) GetMessageName() string {
3621         return "ip6_ra_event"
3622 }
3623 func (*IP6RaEvent) GetCrcString() string {
3624         return "c5e54257"
3625 }
3626 func (*IP6RaEvent) GetMessageType() api.MessageType {
3627         return api.EventMessage
3628 }
3629
3630 // ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'.
3631 //
3632 //            "proxy_arp_add_del",
3633 //            [
3634 //                "u16",
3635 //                "_vl_msg_id"
3636 //            ],
3637 //            [
3638 //                "u32",
3639 //                "client_index"
3640 //            ],
3641 //            [
3642 //                "u32",
3643 //                "context"
3644 //            ],
3645 //            [
3646 //                "u8",
3647 //                "is_add"
3648 //            ],
3649 //            [
3650 //                "vl_api_proxy_arp_t",
3651 //                "proxy"
3652 //            ],
3653 //            {
3654 //                "crc": "0x227988d9"
3655 //            }
3656 //
3657 type ProxyArpAddDel struct {
3658         IsAdd uint8
3659         Proxy ProxyArp
3660 }
3661
3662 func (*ProxyArpAddDel) GetMessageName() string {
3663         return "proxy_arp_add_del"
3664 }
3665 func (*ProxyArpAddDel) GetCrcString() string {
3666         return "227988d9"
3667 }
3668 func (*ProxyArpAddDel) GetMessageType() api.MessageType {
3669         return api.RequestMessage
3670 }
3671
3672 // ProxyArpAddDelReply represents the VPP binary API message 'proxy_arp_add_del_reply'.
3673 //
3674 //            "proxy_arp_add_del_reply",
3675 //            [
3676 //                "u16",
3677 //                "_vl_msg_id"
3678 //            ],
3679 //            [
3680 //                "u32",
3681 //                "context"
3682 //            ],
3683 //            [
3684 //                "i32",
3685 //                "retval"
3686 //            ],
3687 //            {
3688 //                "crc": "0xe8d4e804"
3689 //            }
3690 //
3691 type ProxyArpAddDelReply struct {
3692         Retval int32
3693 }
3694
3695 func (*ProxyArpAddDelReply) GetMessageName() string {
3696         return "proxy_arp_add_del_reply"
3697 }
3698 func (*ProxyArpAddDelReply) GetCrcString() string {
3699         return "e8d4e804"
3700 }
3701 func (*ProxyArpAddDelReply) GetMessageType() api.MessageType {
3702         return api.ReplyMessage
3703 }
3704
3705 // ProxyArpDump represents the VPP binary API message 'proxy_arp_dump'.
3706 //
3707 //            "proxy_arp_dump",
3708 //            [
3709 //                "u16",
3710 //                "_vl_msg_id"
3711 //            ],
3712 //            [
3713 //                "u32",
3714 //                "client_index"
3715 //            ],
3716 //            [
3717 //                "u32",
3718 //                "context"
3719 //            ],
3720 //            {
3721 //                "crc": "0x51077d14"
3722 //            }
3723 //
3724 type ProxyArpDump struct{}
3725
3726 func (*ProxyArpDump) GetMessageName() string {
3727         return "proxy_arp_dump"
3728 }
3729 func (*ProxyArpDump) GetCrcString() string {
3730         return "51077d14"
3731 }
3732 func (*ProxyArpDump) GetMessageType() api.MessageType {
3733         return api.RequestMessage
3734 }
3735
3736 // ProxyArpDetails represents the VPP binary API message 'proxy_arp_details'.
3737 //
3738 //            "proxy_arp_details",
3739 //            [
3740 //                "u16",
3741 //                "_vl_msg_id"
3742 //            ],
3743 //            [
3744 //                "u32",
3745 //                "context"
3746 //            ],
3747 //            [
3748 //                "vl_api_proxy_arp_t",
3749 //                "proxy"
3750 //            ],
3751 //            {
3752 //                "crc": "0x9b707c77"
3753 //            }
3754 //
3755 type ProxyArpDetails struct {
3756         Proxy ProxyArp
3757 }
3758
3759 func (*ProxyArpDetails) GetMessageName() string {
3760         return "proxy_arp_details"
3761 }
3762 func (*ProxyArpDetails) GetCrcString() string {
3763         return "9b707c77"
3764 }
3765 func (*ProxyArpDetails) GetMessageType() api.MessageType {
3766         return api.ReplyMessage
3767 }
3768
3769 // ProxyArpIntfcEnableDisable represents the VPP binary API message 'proxy_arp_intfc_enable_disable'.
3770 //
3771 //            "proxy_arp_intfc_enable_disable",
3772 //            [
3773 //                "u16",
3774 //                "_vl_msg_id"
3775 //            ],
3776 //            [
3777 //                "u32",
3778 //                "client_index"
3779 //            ],
3780 //            [
3781 //                "u32",
3782 //                "context"
3783 //            ],
3784 //            [
3785 //                "u32",
3786 //                "sw_if_index"
3787 //            ],
3788 //            [
3789 //                "u8",
3790 //                "enable_disable"
3791 //            ],
3792 //            {
3793 //                "crc": "0x69d24598"
3794 //            }
3795 //
3796 type ProxyArpIntfcEnableDisable struct {
3797         SwIfIndex     uint32
3798         EnableDisable uint8
3799 }
3800
3801 func (*ProxyArpIntfcEnableDisable) GetMessageName() string {
3802         return "proxy_arp_intfc_enable_disable"
3803 }
3804 func (*ProxyArpIntfcEnableDisable) GetCrcString() string {
3805         return "69d24598"
3806 }
3807 func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType {
3808         return api.RequestMessage
3809 }
3810
3811 // ProxyArpIntfcEnableDisableReply represents the VPP binary API message 'proxy_arp_intfc_enable_disable_reply'.
3812 //
3813 //            "proxy_arp_intfc_enable_disable_reply",
3814 //            [
3815 //                "u16",
3816 //                "_vl_msg_id"
3817 //            ],
3818 //            [
3819 //                "u32",
3820 //                "context"
3821 //            ],
3822 //            [
3823 //                "i32",
3824 //                "retval"
3825 //            ],
3826 //            {
3827 //                "crc": "0xe8d4e804"
3828 //            }
3829 //
3830 type ProxyArpIntfcEnableDisableReply struct {
3831         Retval int32
3832 }
3833
3834 func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string {
3835         return "proxy_arp_intfc_enable_disable_reply"
3836 }
3837 func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string {
3838         return "e8d4e804"
3839 }
3840 func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType {
3841         return api.ReplyMessage
3842 }
3843
3844 // ProxyArpIntfcDump represents the VPP binary API message 'proxy_arp_intfc_dump'.
3845 //
3846 //            "proxy_arp_intfc_dump",
3847 //            [
3848 //                "u16",
3849 //                "_vl_msg_id"
3850 //            ],
3851 //            [
3852 //                "u32",
3853 //                "client_index"
3854 //            ],
3855 //            [
3856 //                "u32",
3857 //                "context"
3858 //            ],
3859 //            {
3860 //                "crc": "0x51077d14"
3861 //            }
3862 //
3863 type ProxyArpIntfcDump struct{}
3864
3865 func (*ProxyArpIntfcDump) GetMessageName() string {
3866         return "proxy_arp_intfc_dump"
3867 }
3868 func (*ProxyArpIntfcDump) GetCrcString() string {
3869         return "51077d14"
3870 }
3871 func (*ProxyArpIntfcDump) GetMessageType() api.MessageType {
3872         return api.RequestMessage
3873 }
3874
3875 // ProxyArpIntfcDetails represents the VPP binary API message 'proxy_arp_intfc_details'.
3876 //
3877 //            "proxy_arp_intfc_details",
3878 //            [
3879 //                "u16",
3880 //                "_vl_msg_id"
3881 //            ],
3882 //            [
3883 //                "u32",
3884 //                "context"
3885 //            ],
3886 //            [
3887 //                "u32",
3888 //                "sw_if_index"
3889 //            ],
3890 //            {
3891 //                "crc": "0xf6458e5f"
3892 //            }
3893 //
3894 type ProxyArpIntfcDetails struct {
3895         SwIfIndex uint32
3896 }
3897
3898 func (*ProxyArpIntfcDetails) GetMessageName() string {
3899         return "proxy_arp_intfc_details"
3900 }
3901 func (*ProxyArpIntfcDetails) GetCrcString() string {
3902         return "f6458e5f"
3903 }
3904 func (*ProxyArpIntfcDetails) GetMessageType() api.MessageType {
3905         return api.ReplyMessage
3906 }
3907
3908 // ResetFib represents the VPP binary API message 'reset_fib'.
3909 //
3910 //            "reset_fib",
3911 //            [
3912 //                "u16",
3913 //                "_vl_msg_id"
3914 //            ],
3915 //            [
3916 //                "u32",
3917 //                "client_index"
3918 //            ],
3919 //            [
3920 //                "u32",
3921 //                "context"
3922 //            ],
3923 //            [
3924 //                "u32",
3925 //                "vrf_id"
3926 //            ],
3927 //            [
3928 //                "u8",
3929 //                "is_ipv6"
3930 //            ],
3931 //            {
3932 //                "crc": "0x8553ebd9"
3933 //            }
3934 //
3935 type ResetFib struct {
3936         VrfID  uint32
3937         IsIPv6 uint8
3938 }
3939
3940 func (*ResetFib) GetMessageName() string {
3941         return "reset_fib"
3942 }
3943 func (*ResetFib) GetCrcString() string {
3944         return "8553ebd9"
3945 }
3946 func (*ResetFib) GetMessageType() api.MessageType {
3947         return api.RequestMessage
3948 }
3949
3950 // ResetFibReply represents the VPP binary API message 'reset_fib_reply'.
3951 //
3952 //            "reset_fib_reply",
3953 //            [
3954 //                "u16",
3955 //                "_vl_msg_id"
3956 //            ],
3957 //            [
3958 //                "u32",
3959 //                "context"
3960 //            ],
3961 //            [
3962 //                "i32",
3963 //                "retval"
3964 //            ],
3965 //            {
3966 //                "crc": "0xe8d4e804"
3967 //            }
3968 //
3969 type ResetFibReply struct {
3970         Retval int32
3971 }
3972
3973 func (*ResetFibReply) GetMessageName() string {
3974         return "reset_fib_reply"
3975 }
3976 func (*ResetFibReply) GetCrcString() string {
3977         return "e8d4e804"
3978 }
3979 func (*ResetFibReply) GetMessageType() api.MessageType {
3980         return api.ReplyMessage
3981 }
3982
3983 // SetArpNeighborLimit represents the VPP binary API message 'set_arp_neighbor_limit'.
3984 //
3985 //            "set_arp_neighbor_limit",
3986 //            [
3987 //                "u16",
3988 //                "_vl_msg_id"
3989 //            ],
3990 //            [
3991 //                "u32",
3992 //                "client_index"
3993 //            ],
3994 //            [
3995 //                "u32",
3996 //                "context"
3997 //            ],
3998 //            [
3999 //                "u8",
4000 //                "is_ipv6"
4001 //            ],
4002 //            [
4003 //                "u32",
4004 //                "arp_neighbor_limit"
4005 //            ],
4006 //            {
4007 //                "crc": "0x97d01fd6"
4008 //            }
4009 //
4010 type SetArpNeighborLimit struct {
4011         IsIPv6           uint8
4012         ArpNeighborLimit uint32
4013 }
4014
4015 func (*SetArpNeighborLimit) GetMessageName() string {
4016         return "set_arp_neighbor_limit"
4017 }
4018 func (*SetArpNeighborLimit) GetCrcString() string {
4019         return "97d01fd6"
4020 }
4021 func (*SetArpNeighborLimit) GetMessageType() api.MessageType {
4022         return api.RequestMessage
4023 }
4024
4025 // SetArpNeighborLimitReply represents the VPP binary API message 'set_arp_neighbor_limit_reply'.
4026 //
4027 //            "set_arp_neighbor_limit_reply",
4028 //            [
4029 //                "u16",
4030 //                "_vl_msg_id"
4031 //            ],
4032 //            [
4033 //                "u32",
4034 //                "context"
4035 //            ],
4036 //            [
4037 //                "i32",
4038 //                "retval"
4039 //            ],
4040 //            {
4041 //                "crc": "0xe8d4e804"
4042 //            }
4043 //
4044 type SetArpNeighborLimitReply struct {
4045         Retval int32
4046 }
4047
4048 func (*SetArpNeighborLimitReply) GetMessageName() string {
4049         return "set_arp_neighbor_limit_reply"
4050 }
4051 func (*SetArpNeighborLimitReply) GetCrcString() string {
4052         return "e8d4e804"
4053 }
4054 func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType {
4055         return api.ReplyMessage
4056 }
4057
4058 // IoamEnable represents the VPP binary API message 'ioam_enable'.
4059 //
4060 //            "ioam_enable",
4061 //            [
4062 //                "u16",
4063 //                "_vl_msg_id"
4064 //            ],
4065 //            [
4066 //                "u32",
4067 //                "client_index"
4068 //            ],
4069 //            [
4070 //                "u32",
4071 //                "context"
4072 //            ],
4073 //            [
4074 //                "u16",
4075 //                "id"
4076 //            ],
4077 //            [
4078 //                "u8",
4079 //                "seqno"
4080 //            ],
4081 //            [
4082 //                "u8",
4083 //                "analyse"
4084 //            ],
4085 //            [
4086 //                "u8",
4087 //                "pot_enable"
4088 //            ],
4089 //            [
4090 //                "u8",
4091 //                "trace_enable"
4092 //            ],
4093 //            [
4094 //                "u32",
4095 //                "node_id"
4096 //            ],
4097 //            {
4098 //                "crc": "0x9392e032"
4099 //            }
4100 //
4101 type IoamEnable struct {
4102         ID          uint16
4103         Seqno       uint8
4104         Analyse     uint8
4105         PotEnable   uint8
4106         TraceEnable uint8
4107         NodeID      uint32
4108 }
4109
4110 func (*IoamEnable) GetMessageName() string {
4111         return "ioam_enable"
4112 }
4113 func (*IoamEnable) GetCrcString() string {
4114         return "9392e032"
4115 }
4116 func (*IoamEnable) GetMessageType() api.MessageType {
4117         return api.RequestMessage
4118 }
4119
4120 // IoamEnableReply represents the VPP binary API message 'ioam_enable_reply'.
4121 //
4122 //            "ioam_enable_reply",
4123 //            [
4124 //                "u16",
4125 //                "_vl_msg_id"
4126 //            ],
4127 //            [
4128 //                "u32",
4129 //                "context"
4130 //            ],
4131 //            [
4132 //                "i32",
4133 //                "retval"
4134 //            ],
4135 //            {
4136 //                "crc": "0xe8d4e804"
4137 //            }
4138 //
4139 type IoamEnableReply struct {
4140         Retval int32
4141 }
4142
4143 func (*IoamEnableReply) GetMessageName() string {
4144         return "ioam_enable_reply"
4145 }
4146 func (*IoamEnableReply) GetCrcString() string {
4147         return "e8d4e804"
4148 }
4149 func (*IoamEnableReply) GetMessageType() api.MessageType {
4150         return api.ReplyMessage
4151 }
4152
4153 // IoamDisable represents the VPP binary API message 'ioam_disable'.
4154 //
4155 //            "ioam_disable",
4156 //            [
4157 //                "u16",
4158 //                "_vl_msg_id"
4159 //            ],
4160 //            [
4161 //                "u32",
4162 //                "client_index"
4163 //            ],
4164 //            [
4165 //                "u32",
4166 //                "context"
4167 //            ],
4168 //            [
4169 //                "u16",
4170 //                "id"
4171 //            ],
4172 //            {
4173 //                "crc": "0x6b16a45e"
4174 //            }
4175 //
4176 type IoamDisable struct {
4177         ID uint16
4178 }
4179
4180 func (*IoamDisable) GetMessageName() string {
4181         return "ioam_disable"
4182 }
4183 func (*IoamDisable) GetCrcString() string {
4184         return "6b16a45e"
4185 }
4186 func (*IoamDisable) GetMessageType() api.MessageType {
4187         return api.RequestMessage
4188 }
4189
4190 // IoamDisableReply represents the VPP binary API message 'ioam_disable_reply'.
4191 //
4192 //            "ioam_disable_reply",
4193 //            [
4194 //                "u16",
4195 //                "_vl_msg_id"
4196 //            ],
4197 //            [
4198 //                "u32",
4199 //                "context"
4200 //            ],
4201 //            [
4202 //                "i32",
4203 //                "retval"
4204 //            ],
4205 //            {
4206 //                "crc": "0xe8d4e804"
4207 //            }
4208 //
4209 type IoamDisableReply struct {
4210         Retval int32
4211 }
4212
4213 func (*IoamDisableReply) GetMessageName() string {
4214         return "ioam_disable_reply"
4215 }
4216 func (*IoamDisableReply) GetCrcString() string {
4217         return "e8d4e804"
4218 }
4219 func (*IoamDisableReply) GetMessageType() api.MessageType {
4220         return api.ReplyMessage
4221 }
4222
4223 // IPReassemblySet represents the VPP binary API message 'ip_reassembly_set'.
4224 //
4225 //            "ip_reassembly_set",
4226 //            [
4227 //                "u16",
4228 //                "_vl_msg_id"
4229 //            ],
4230 //            [
4231 //                "u32",
4232 //                "client_index"
4233 //            ],
4234 //            [
4235 //                "u32",
4236 //                "context"
4237 //            ],
4238 //            [
4239 //                "u32",
4240 //                "timeout_ms"
4241 //            ],
4242 //            [
4243 //                "u32",
4244 //                "max_reassemblies"
4245 //            ],
4246 //            [
4247 //                "u32",
4248 //                "expire_walk_interval_ms"
4249 //            ],
4250 //            [
4251 //                "u8",
4252 //                "is_ip6"
4253 //            ],
4254 //            {
4255 //                "crc": "0x1db184de"
4256 //            }
4257 //
4258 type IPReassemblySet struct {
4259         TimeoutMs            uint32
4260         MaxReassemblies      uint32
4261         ExpireWalkIntervalMs uint32
4262         IsIP6                uint8
4263 }
4264
4265 func (*IPReassemblySet) GetMessageName() string {
4266         return "ip_reassembly_set"
4267 }
4268 func (*IPReassemblySet) GetCrcString() string {
4269         return "1db184de"
4270 }
4271 func (*IPReassemblySet) GetMessageType() api.MessageType {
4272         return api.RequestMessage
4273 }
4274
4275 // IPReassemblySetReply represents the VPP binary API message 'ip_reassembly_set_reply'.
4276 //
4277 //            "ip_reassembly_set_reply",
4278 //            [
4279 //                "u16",
4280 //                "_vl_msg_id"
4281 //            ],
4282 //            [
4283 //                "u32",
4284 //                "context"
4285 //            ],
4286 //            [
4287 //                "i32",
4288 //                "retval"
4289 //            ],
4290 //            {
4291 //                "crc": "0xe8d4e804"
4292 //            }
4293 //
4294 type IPReassemblySetReply struct {
4295         Retval int32
4296 }
4297
4298 func (*IPReassemblySetReply) GetMessageName() string {
4299         return "ip_reassembly_set_reply"
4300 }
4301 func (*IPReassemblySetReply) GetCrcString() string {
4302         return "e8d4e804"
4303 }
4304 func (*IPReassemblySetReply) GetMessageType() api.MessageType {
4305         return api.ReplyMessage
4306 }
4307
4308 // IPReassemblyGet represents the VPP binary API message 'ip_reassembly_get'.
4309 //
4310 //            "ip_reassembly_get",
4311 //            [
4312 //                "u16",
4313 //                "_vl_msg_id"
4314 //            ],
4315 //            [
4316 //                "u32",
4317 //                "client_index"
4318 //            ],
4319 //            [
4320 //                "u32",
4321 //                "context"
4322 //            ],
4323 //            [
4324 //                "u8",
4325 //                "is_ip6"
4326 //            ],
4327 //            {
4328 //                "crc": "0x6fe91190"
4329 //            }
4330 //
4331 type IPReassemblyGet struct {
4332         IsIP6 uint8
4333 }
4334
4335 func (*IPReassemblyGet) GetMessageName() string {
4336         return "ip_reassembly_get"
4337 }
4338 func (*IPReassemblyGet) GetCrcString() string {
4339         return "6fe91190"
4340 }
4341 func (*IPReassemblyGet) GetMessageType() api.MessageType {
4342         return api.RequestMessage
4343 }
4344
4345 // IPReassemblyGetReply represents the VPP binary API message 'ip_reassembly_get_reply'.
4346 //
4347 //            "ip_reassembly_get_reply",
4348 //            [
4349 //                "u16",
4350 //                "_vl_msg_id"
4351 //            ],
4352 //            [
4353 //                "u32",
4354 //                "client_index"
4355 //            ],
4356 //            [
4357 //                "u32",
4358 //                "context"
4359 //            ],
4360 //            [
4361 //                "i32",
4362 //                "retval"
4363 //            ],
4364 //            [
4365 //                "u32",
4366 //                "timeout_ms"
4367 //            ],
4368 //            [
4369 //                "u32",
4370 //                "max_reassemblies"
4371 //            ],
4372 //            [
4373 //                "u32",
4374 //                "expire_walk_interval_ms"
4375 //            ],
4376 //            [
4377 //                "u8",
4378 //                "is_ip6"
4379 //            ],
4380 //            {
4381 //                "crc": "0xd746fc57"
4382 //            }
4383 //
4384 type IPReassemblyGetReply struct {
4385         Retval               int32
4386         TimeoutMs            uint32
4387         MaxReassemblies      uint32
4388         ExpireWalkIntervalMs uint32
4389         IsIP6                uint8
4390 }
4391
4392 func (*IPReassemblyGetReply) GetMessageName() string {
4393         return "ip_reassembly_get_reply"
4394 }
4395 func (*IPReassemblyGetReply) GetCrcString() string {
4396         return "d746fc57"
4397 }
4398 func (*IPReassemblyGetReply) GetMessageType() api.MessageType {
4399         return api.RequestMessage
4400 }
4401
4402 // IPReassemblyEnableDisable represents the VPP binary API message 'ip_reassembly_enable_disable'.
4403 //
4404 //            "ip_reassembly_enable_disable",
4405 //            [
4406 //                "u16",
4407 //                "_vl_msg_id"
4408 //            ],
4409 //            [
4410 //                "u32",
4411 //                "client_index"
4412 //            ],
4413 //            [
4414 //                "u32",
4415 //                "context"
4416 //            ],
4417 //            [
4418 //                "u32",
4419 //                "sw_if_index"
4420 //            ],
4421 //            [
4422 //                "u8",
4423 //                "enable_ip4"
4424 //            ],
4425 //            [
4426 //                "u8",
4427 //                "enable_ip6"
4428 //            ],
4429 //            {
4430 //                "crc": "0xbb8dc5d0"
4431 //            }
4432 //
4433 type IPReassemblyEnableDisable struct {
4434         SwIfIndex uint32
4435         EnableIP4 uint8
4436         EnableIP6 uint8
4437 }
4438
4439 func (*IPReassemblyEnableDisable) GetMessageName() string {
4440         return "ip_reassembly_enable_disable"
4441 }
4442 func (*IPReassemblyEnableDisable) GetCrcString() string {
4443         return "bb8dc5d0"
4444 }
4445 func (*IPReassemblyEnableDisable) GetMessageType() api.MessageType {
4446         return api.RequestMessage
4447 }
4448
4449 // IPReassemblyEnableDisableReply represents the VPP binary API message 'ip_reassembly_enable_disable_reply'.
4450 //
4451 //            "ip_reassembly_enable_disable_reply",
4452 //            [
4453 //                "u16",
4454 //                "_vl_msg_id"
4455 //            ],
4456 //            [
4457 //                "u32",
4458 //                "context"
4459 //            ],
4460 //            [
4461 //                "i32",
4462 //                "retval"
4463 //            ],
4464 //            {
4465 //                "crc": "0xe8d4e804"
4466 //            }
4467 //
4468 type IPReassemblyEnableDisableReply struct {
4469         Retval int32
4470 }
4471
4472 func (*IPReassemblyEnableDisableReply) GetMessageName() string {
4473         return "ip_reassembly_enable_disable_reply"
4474 }
4475 func (*IPReassemblyEnableDisableReply) GetCrcString() string {
4476         return "e8d4e804"
4477 }
4478 func (*IPReassemblyEnableDisableReply) GetMessageType() api.MessageType {
4479         return api.ReplyMessage
4480 }
4481
4482 /* Services */
4483
4484 type Services interface {
4485         DumpIP6Fib(*IP6FibDump) (*IP6FibDetails, error)
4486         DumpIP6Mfib(*IP6MfibDump) (*IP6MfibDetails, error)
4487         DumpIP6ndProxy(*IP6ndProxyDump) (*IP6ndProxyDetails, error)
4488         DumpIPAddress(*IPAddressDump) (*IPAddressDetails, error)
4489         DumpIP(*IPDump) (*IPDetails, error)
4490         DumpIPFib(*IPFibDump) (*IPFibDetails, error)
4491         DumpIPMfib(*IPMfibDump) (*IPMfibDetails, error)
4492         DumpIPNeighbor(*IPNeighborDump) (*IPNeighborDetails, error)
4493         DumpIPUnnumbered(*IPUnnumberedDump) (*IPUnnumberedDetails, error)
4494         DumpMfibSignal(*MfibSignalDump) (*MfibSignalDetails, error)
4495         DumpProxyArp(*ProxyArpDump) (*ProxyArpDetails, error)
4496         DumpProxyArpIntfc(*ProxyArpIntfcDump) (*ProxyArpIntfcDetails, error)
4497         IoamDisable(*IoamDisable) (*IoamDisableReply, error)
4498         IoamEnable(*IoamEnable) (*IoamEnableReply, error)
4499         IP6ndProxyAddDel(*IP6ndProxyAddDel) (*IP6ndProxyAddDelReply, error)
4500         IP6ndSendRouterSolicitation(*IP6ndSendRouterSolicitation) (*IP6ndSendRouterSolicitationReply, error)
4501         IPAddDelRoute(*IPAddDelRoute) (*IPAddDelRouteReply, error)
4502         IPContainerProxyAddDel(*IPContainerProxyAddDel) (*IPContainerProxyAddDelReply, error)
4503         IPMrouteAddDel(*IPMrouteAddDel) (*IPMrouteAddDelReply, error)
4504         IPNeighborAddDel(*IPNeighborAddDel) (*IPNeighborAddDelReply, error)
4505         IPProbeNeighbor(*IPProbeNeighbor) (*IPProbeNeighborReply, error)
4506         IPPuntPolice(*IPPuntPolice) (*IPPuntPoliceReply, error)
4507         IPPuntRedirect(*IPPuntRedirect) (*IPPuntRedirectReply, error)
4508         IPReassemblyEnableDisable(*IPReassemblyEnableDisable) (*IPReassemblyEnableDisableReply, error)
4509         IPReassemblyGet(*IPReassemblyGet) (*IPReassemblyGetReply, error)
4510         IPReassemblySet(*IPReassemblySet) (*IPReassemblySetReply, error)
4511         IPScanNeighborEnableDisable(*IPScanNeighborEnableDisable) (*IPScanNeighborEnableDisableReply, error)
4512         IPSourceAndPortRangeCheckAddDel(*IPSourceAndPortRangeCheckAddDel) (*IPSourceAndPortRangeCheckAddDelReply, error)
4513         IPSourceAndPortRangeCheckInterfaceAddDel(*IPSourceAndPortRangeCheckInterfaceAddDel) (*IPSourceAndPortRangeCheckInterfaceAddDelReply, error)
4514         IPTableAddDel(*IPTableAddDel) (*IPTableAddDelReply, error)
4515         ProxyArpAddDel(*ProxyArpAddDel) (*ProxyArpAddDelReply, error)
4516         ProxyArpIntfcEnableDisable(*ProxyArpIntfcEnableDisable) (*ProxyArpIntfcEnableDisableReply, error)
4517         ResetFib(*ResetFib) (*ResetFibReply, error)
4518         SetArpNeighborLimit(*SetArpNeighborLimit) (*SetArpNeighborLimitReply, error)
4519         SetIPFlowHash(*SetIPFlowHash) (*SetIPFlowHashReply, error)
4520         SwInterfaceIP6EnableDisable(*SwInterfaceIP6EnableDisable) (*SwInterfaceIP6EnableDisableReply, error)
4521         SwInterfaceIP6SetLinkLocalAddress(*SwInterfaceIP6SetLinkLocalAddress) (*SwInterfaceIP6SetLinkLocalAddressReply, error)
4522         SwInterfaceIP6ndRaConfig(*SwInterfaceIP6ndRaConfig) (*SwInterfaceIP6ndRaConfigReply, error)
4523         SwInterfaceIP6ndRaPrefix(*SwInterfaceIP6ndRaPrefix) (*SwInterfaceIP6ndRaPrefixReply, error)
4524         WantIP4ArpEvents(*WantIP4ArpEvents) (*WantIP4ArpEventsReply, error)
4525         WantIP6NdEvents(*WantIP6NdEvents) (*WantIP6NdEventsReply, error)
4526         WantIP6RaEvents(*WantIP6RaEvents) (*WantIP6RaEventsReply, error)
4527 }
4528
4529 func init() {
4530         api.RegisterMessage((*IPTableAddDel)(nil), "ip.IPTableAddDel")
4531         api.RegisterMessage((*IPTableAddDelReply)(nil), "ip.IPTableAddDelReply")
4532         api.RegisterMessage((*IPFibDump)(nil), "ip.IPFibDump")
4533         api.RegisterMessage((*IPFibDetails)(nil), "ip.IPFibDetails")
4534         api.RegisterMessage((*IP6FibDump)(nil), "ip.IP6FibDump")
4535         api.RegisterMessage((*IP6FibDetails)(nil), "ip.IP6FibDetails")
4536         api.RegisterMessage((*IPNeighborDump)(nil), "ip.IPNeighborDump")
4537         api.RegisterMessage((*IPNeighborDetails)(nil), "ip.IPNeighborDetails")
4538         api.RegisterMessage((*IPNeighborAddDel)(nil), "ip.IPNeighborAddDel")
4539         api.RegisterMessage((*IPNeighborAddDelReply)(nil), "ip.IPNeighborAddDelReply")
4540         api.RegisterMessage((*SetIPFlowHash)(nil), "ip.SetIPFlowHash")
4541         api.RegisterMessage((*SetIPFlowHashReply)(nil), "ip.SetIPFlowHashReply")
4542         api.RegisterMessage((*SwInterfaceIP6ndRaConfig)(nil), "ip.SwInterfaceIP6ndRaConfig")
4543         api.RegisterMessage((*SwInterfaceIP6ndRaConfigReply)(nil), "ip.SwInterfaceIP6ndRaConfigReply")
4544         api.RegisterMessage((*SwInterfaceIP6ndRaPrefix)(nil), "ip.SwInterfaceIP6ndRaPrefix")
4545         api.RegisterMessage((*SwInterfaceIP6ndRaPrefixReply)(nil), "ip.SwInterfaceIP6ndRaPrefixReply")
4546         api.RegisterMessage((*IP6ndProxyAddDel)(nil), "ip.IP6ndProxyAddDel")
4547         api.RegisterMessage((*IP6ndProxyAddDelReply)(nil), "ip.IP6ndProxyAddDelReply")
4548         api.RegisterMessage((*IP6ndProxyDetails)(nil), "ip.IP6ndProxyDetails")
4549         api.RegisterMessage((*IP6ndProxyDump)(nil), "ip.IP6ndProxyDump")
4550         api.RegisterMessage((*IP6ndSendRouterSolicitation)(nil), "ip.IP6ndSendRouterSolicitation")
4551         api.RegisterMessage((*IP6ndSendRouterSolicitationReply)(nil), "ip.IP6ndSendRouterSolicitationReply")
4552         api.RegisterMessage((*SwInterfaceIP6EnableDisable)(nil), "ip.SwInterfaceIP6EnableDisable")
4553         api.RegisterMessage((*SwInterfaceIP6EnableDisableReply)(nil), "ip.SwInterfaceIP6EnableDisableReply")
4554         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddress)(nil), "ip.SwInterfaceIP6SetLinkLocalAddress")
4555         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddressReply)(nil), "ip.SwInterfaceIP6SetLinkLocalAddressReply")
4556         api.RegisterMessage((*IPAddDelRoute)(nil), "ip.IPAddDelRoute")
4557         api.RegisterMessage((*IPAddDelRouteReply)(nil), "ip.IPAddDelRouteReply")
4558         api.RegisterMessage((*IPMrouteAddDel)(nil), "ip.IPMrouteAddDel")
4559         api.RegisterMessage((*IPMrouteAddDelReply)(nil), "ip.IPMrouteAddDelReply")
4560         api.RegisterMessage((*IPMfibDump)(nil), "ip.IPMfibDump")
4561         api.RegisterMessage((*IPMfibDetails)(nil), "ip.IPMfibDetails")
4562         api.RegisterMessage((*IP6MfibDump)(nil), "ip.IP6MfibDump")
4563         api.RegisterMessage((*IP6MfibDetails)(nil), "ip.IP6MfibDetails")
4564         api.RegisterMessage((*IPAddressDetails)(nil), "ip.IPAddressDetails")
4565         api.RegisterMessage((*IPAddressDump)(nil), "ip.IPAddressDump")
4566         api.RegisterMessage((*IPUnnumberedDetails)(nil), "ip.IPUnnumberedDetails")
4567         api.RegisterMessage((*IPUnnumberedDump)(nil), "ip.IPUnnumberedDump")
4568         api.RegisterMessage((*IPDetails)(nil), "ip.IPDetails")
4569         api.RegisterMessage((*IPDump)(nil), "ip.IPDump")
4570         api.RegisterMessage((*MfibSignalDump)(nil), "ip.MfibSignalDump")
4571         api.RegisterMessage((*MfibSignalDetails)(nil), "ip.MfibSignalDetails")
4572         api.RegisterMessage((*IPPuntPolice)(nil), "ip.IPPuntPolice")
4573         api.RegisterMessage((*IPPuntPoliceReply)(nil), "ip.IPPuntPoliceReply")
4574         api.RegisterMessage((*IPPuntRedirect)(nil), "ip.IPPuntRedirect")
4575         api.RegisterMessage((*IPPuntRedirectReply)(nil), "ip.IPPuntRedirectReply")
4576         api.RegisterMessage((*IPContainerProxyAddDel)(nil), "ip.IPContainerProxyAddDel")
4577         api.RegisterMessage((*IPContainerProxyAddDelReply)(nil), "ip.IPContainerProxyAddDelReply")
4578         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDel)(nil), "ip.IPSourceAndPortRangeCheckAddDel")
4579         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckAddDelReply")
4580         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDel)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDel")
4581         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDelReply")
4582         api.RegisterMessage((*IPScanNeighborEnableDisable)(nil), "ip.IPScanNeighborEnableDisable")
4583         api.RegisterMessage((*IPScanNeighborEnableDisableReply)(nil), "ip.IPScanNeighborEnableDisableReply")
4584         api.RegisterMessage((*IPProbeNeighbor)(nil), "ip.IPProbeNeighbor")
4585         api.RegisterMessage((*IPProbeNeighborReply)(nil), "ip.IPProbeNeighborReply")
4586         api.RegisterMessage((*WantIP4ArpEvents)(nil), "ip.WantIP4ArpEvents")
4587         api.RegisterMessage((*WantIP4ArpEventsReply)(nil), "ip.WantIP4ArpEventsReply")
4588         api.RegisterMessage((*IP4ArpEvent)(nil), "ip.IP4ArpEvent")
4589         api.RegisterMessage((*WantIP6NdEvents)(nil), "ip.WantIP6NdEvents")
4590         api.RegisterMessage((*WantIP6NdEventsReply)(nil), "ip.WantIP6NdEventsReply")
4591         api.RegisterMessage((*IP6NdEvent)(nil), "ip.IP6NdEvent")
4592         api.RegisterMessage((*WantIP6RaEvents)(nil), "ip.WantIP6RaEvents")
4593         api.RegisterMessage((*WantIP6RaEventsReply)(nil), "ip.WantIP6RaEventsReply")
4594         api.RegisterMessage((*IP6RaEvent)(nil), "ip.IP6RaEvent")
4595         api.RegisterMessage((*ProxyArpAddDel)(nil), "ip.ProxyArpAddDel")
4596         api.RegisterMessage((*ProxyArpAddDelReply)(nil), "ip.ProxyArpAddDelReply")
4597         api.RegisterMessage((*ProxyArpDump)(nil), "ip.ProxyArpDump")
4598         api.RegisterMessage((*ProxyArpDetails)(nil), "ip.ProxyArpDetails")
4599         api.RegisterMessage((*ProxyArpIntfcEnableDisable)(nil), "ip.ProxyArpIntfcEnableDisable")
4600         api.RegisterMessage((*ProxyArpIntfcEnableDisableReply)(nil), "ip.ProxyArpIntfcEnableDisableReply")
4601         api.RegisterMessage((*ProxyArpIntfcDump)(nil), "ip.ProxyArpIntfcDump")
4602         api.RegisterMessage((*ProxyArpIntfcDetails)(nil), "ip.ProxyArpIntfcDetails")
4603         api.RegisterMessage((*ResetFib)(nil), "ip.ResetFib")
4604         api.RegisterMessage((*ResetFibReply)(nil), "ip.ResetFibReply")
4605         api.RegisterMessage((*SetArpNeighborLimit)(nil), "ip.SetArpNeighborLimit")
4606         api.RegisterMessage((*SetArpNeighborLimitReply)(nil), "ip.SetArpNeighborLimitReply")
4607         api.RegisterMessage((*IoamEnable)(nil), "ip.IoamEnable")
4608         api.RegisterMessage((*IoamEnableReply)(nil), "ip.IoamEnableReply")
4609         api.RegisterMessage((*IoamDisable)(nil), "ip.IoamDisable")
4610         api.RegisterMessage((*IoamDisableReply)(nil), "ip.IoamDisableReply")
4611         api.RegisterMessage((*IPReassemblySet)(nil), "ip.IPReassemblySet")
4612         api.RegisterMessage((*IPReassemblySetReply)(nil), "ip.IPReassemblySetReply")
4613         api.RegisterMessage((*IPReassemblyGet)(nil), "ip.IPReassemblyGet")
4614         api.RegisterMessage((*IPReassemblyGetReply)(nil), "ip.IPReassemblyGetReply")
4615         api.RegisterMessage((*IPReassemblyEnableDisable)(nil), "ip.IPReassemblyEnableDisable")
4616         api.RegisterMessage((*IPReassemblyEnableDisableReply)(nil), "ip.IPReassemblyEnableDisableReply")
4617 }