core/bin_api/vpe/vpe.go

   1 // Package vpe represents the VPP binary API of the 'vpe' VPP module.
   2 // DO NOT EDIT. Generated from 'bin_api/vpe.api.json'
   3 package vpe
   4
   5 import "git.fd.io/govpp.git/api"
   6
   7 // VlApiVersion contains version of the API.
   8 const VlAPIVersion = 0x50d987fe
   9
  10 // IP4FibCounter represents the VPP binary API data type 'ip4_fib_counter'.
  11 // Generated from 'bin_api/vpe.api.json', line 3:
  12 //
  13 //        ["ip4_fib_counter",
  14 //            ["u32", "address"],
  15 //            ["u8", "address_length"],
  16 //            ["u64", "packets"],
  17 //            ["u64", "bytes"],
  18 //            {"crc" : "0xb2739495"}
  19 //        ],
  20 //
  21 type IP4FibCounter struct {
  22         Address       uint32
  23         AddressLength uint8
  24         Packets       uint64
  25         Bytes         uint64
  26 }
  27
  28 func (*IP4FibCounter) GetTypeName() string {
  29         return "ip4_fib_counter"
  30 }
  31 func (*IP4FibCounter) GetCrcString() string {
  32         return "b2739495"
  33 }
  34
  35 // IP4NbrCounter represents the VPP binary API data type 'ip4_nbr_counter'.
  36 // Generated from 'bin_api/vpe.api.json', line 10:
  37 //
  38 //        ["ip4_nbr_counter",
  39 //            ["u32", "address"],
  40 //            ["u8", "link_type"],
  41 //            ["u64", "packets"],
  42 //            ["u64", "bytes"],
  43 //            {"crc" : "0x487e2e85"}
  44 //        ],
  45 //
  46 type IP4NbrCounter struct {
  47         Address  uint32
  48         LinkType uint8
  49         Packets  uint64
  50         Bytes    uint64
  51 }
  52
  53 func (*IP4NbrCounter) GetTypeName() string {
  54         return "ip4_nbr_counter"
  55 }
  56 func (*IP4NbrCounter) GetCrcString() string {
  57         return "487e2e85"
  58 }
  59
  60 // IP6FibCounter represents the VPP binary API data type 'ip6_fib_counter'.
  61 // Generated from 'bin_api/vpe.api.json', line 17:
  62 //
  63 //        ["ip6_fib_counter",
  64 //            ["u64", "address", 2],
  65 //            ["u8", "address_length"],
  66 //            ["u64", "packets"],
  67 //            ["u64", "bytes"],
  68 //            {"crc" : "0xcf35769b"}
  69 //        ],
  70 //
  71 type IP6FibCounter struct {
  72         Address       []uint64 `struc:"[2]uint64"`
  73         AddressLength uint8
  74         Packets       uint64
  75         Bytes         uint64
  76 }
  77
  78 func (*IP6FibCounter) GetTypeName() string {
  79         return "ip6_fib_counter"
  80 }
  81 func (*IP6FibCounter) GetCrcString() string {
  82         return "cf35769b"
  83 }
  84
  85 // IP6NbrCounter represents the VPP binary API data type 'ip6_nbr_counter'.
  86 // Generated from 'bin_api/vpe.api.json', line 24:
  87 //
  88 //        ["ip6_nbr_counter",
  89 //            ["u64", "address", 2],
  90 //            ["u8", "link_type"],
  91 //            ["u64", "packets"],
  92 //            ["u64", "bytes"],
  93 //            {"crc" : "0xefca741e"}
  94 //        ]
  95 //
  96 type IP6NbrCounter struct {
  97         Address  []uint64 `struc:"[2]uint64"`
  98         LinkType uint8
  99         Packets  uint64
 100         Bytes    uint64
 101 }
 102
 103 func (*IP6NbrCounter) GetTypeName() string {
 104         return "ip6_nbr_counter"
 105 }
 106 func (*IP6NbrCounter) GetCrcString() string {
 107         return "efca741e"
 108 }
 109
 110 // CreateVlanSubif represents the VPP binary API message 'create_vlan_subif'.
 111 // Generated from 'bin_api/vpe.api.json', line 33:
 112 //
 113 //        ["create_vlan_subif",
 114 //            ["u16", "_vl_msg_id"],
 115 //            ["u32", "client_index"],
 116 //            ["u32", "context"],
 117 //            ["u32", "sw_if_index"],
 118 //            ["u32", "vlan_id"],
 119 //            {"crc" : "0xaf9ae1e9"}
 120 //        ],
 121 //
 122 type CreateVlanSubif struct {
 123         SwIfIndex uint32
 124         VlanID    uint32
 125 }
 126
 127 func (*CreateVlanSubif) GetMessageName() string {
 128         return "create_vlan_subif"
 129 }
 130 func (*CreateVlanSubif) GetMessageType() api.MessageType {
 131         return api.RequestMessage
 132 }
 133 func (*CreateVlanSubif) GetCrcString() string {
 134         return "af9ae1e9"
 135 }
 136 func NewCreateVlanSubif() api.Message {
 137         return &CreateVlanSubif{}
 138 }
 139
 140 // CreateVlanSubifReply represents the VPP binary API message 'create_vlan_subif_reply'.
 141 // Generated from 'bin_api/vpe.api.json', line 41:
 142 //
 143 //        ["create_vlan_subif_reply",
 144 //            ["u16", "_vl_msg_id"],
 145 //            ["u32", "context"],
 146 //            ["i32", "retval"],
 147 //            ["u32", "sw_if_index"],
 148 //            {"crc" : "0x8f36b888"}
 149 //        ],
 150 //
 151 type CreateVlanSubifReply struct {
 152         Retval    int32
 153         SwIfIndex uint32
 154 }
 155
 156 func (*CreateVlanSubifReply) GetMessageName() string {
 157         return "create_vlan_subif_reply"
 158 }
 159 func (*CreateVlanSubifReply) GetMessageType() api.MessageType {
 160         return api.ReplyMessage
 161 }
 162 func (*CreateVlanSubifReply) GetCrcString() string {
 163         return "8f36b888"
 164 }
 165 func NewCreateVlanSubifReply() api.Message {
 166         return &CreateVlanSubifReply{}
 167 }
 168
 169 // SwInterfaceSetMplsEnable represents the VPP binary API message 'sw_interface_set_mpls_enable'.
 170 // Generated from 'bin_api/vpe.api.json', line 48:
 171 //
 172 //        ["sw_interface_set_mpls_enable",
 173 //            ["u16", "_vl_msg_id"],
 174 //            ["u32", "client_index"],
 175 //            ["u32", "context"],
 176 //            ["u32", "sw_if_index"],
 177 //            ["u8", "enable"],
 178 //            {"crc" : "0x37f6357e"}
 179 //        ],
 180 //
 181 type SwInterfaceSetMplsEnable struct {
 182         SwIfIndex uint32
 183         Enable    uint8
 184 }
 185
 186 func (*SwInterfaceSetMplsEnable) GetMessageName() string {
 187         return "sw_interface_set_mpls_enable"
 188 }
 189 func (*SwInterfaceSetMplsEnable) GetMessageType() api.MessageType {
 190         return api.RequestMessage
 191 }
 192 func (*SwInterfaceSetMplsEnable) GetCrcString() string {
 193         return "37f6357e"
 194 }
 195 func NewSwInterfaceSetMplsEnable() api.Message {
 196         return &SwInterfaceSetMplsEnable{}
 197 }
 198
 199 // SwInterfaceSetMplsEnableReply represents the VPP binary API message 'sw_interface_set_mpls_enable_reply'.
 200 // Generated from 'bin_api/vpe.api.json', line 56:
 201 //
 202 //        ["sw_interface_set_mpls_enable_reply",
 203 //            ["u16", "_vl_msg_id"],
 204 //            ["u32", "context"],
 205 //            ["i32", "retval"],
 206 //            {"crc" : "0x5ffd3ca9"}
 207 //        ],
 208 //
 209 type SwInterfaceSetMplsEnableReply struct {
 210         Retval int32
 211 }
 212
 213 func (*SwInterfaceSetMplsEnableReply) GetMessageName() string {
 214         return "sw_interface_set_mpls_enable_reply"
 215 }
 216 func (*SwInterfaceSetMplsEnableReply) GetMessageType() api.MessageType {
 217         return api.ReplyMessage
 218 }
 219 func (*SwInterfaceSetMplsEnableReply) GetCrcString() string {
 220         return "5ffd3ca9"
 221 }
 222 func NewSwInterfaceSetMplsEnableReply() api.Message {
 223         return &SwInterfaceSetMplsEnableReply{}
 224 }
 225
 226 // ProxyArpAddDel represents the VPP binary API message 'proxy_arp_add_del'.
 227 // Generated from 'bin_api/vpe.api.json', line 62:
 228 //
 229 //        ["proxy_arp_add_del",
 230 //            ["u16", "_vl_msg_id"],
 231 //            ["u32", "client_index"],
 232 //            ["u32", "context"],
 233 //            ["u32", "vrf_id"],
 234 //            ["u8", "is_add"],
 235 //            ["u8", "low_address", 4],
 236 //            ["u8", "hi_address", 4],
 237 //            {"crc" : "0x4bef9951"}
 238 //        ],
 239 //
 240 type ProxyArpAddDel struct {
 241         VrfID      uint32
 242         IsAdd      uint8
 243         LowAddress []byte `struc:"[4]byte"`
 244         HiAddress  []byte `struc:"[4]byte"`
 245 }
 246
 247 func (*ProxyArpAddDel) GetMessageName() string {
 248         return "proxy_arp_add_del"
 249 }
 250 func (*ProxyArpAddDel) GetMessageType() api.MessageType {
 251         return api.RequestMessage
 252 }
 253 func (*ProxyArpAddDel) GetCrcString() string {
 254         return "4bef9951"
 255 }
 256 func NewProxyArpAddDel() api.Message {
 257         return &ProxyArpAddDel{}
 258 }
 259
 260 // ProxyArpAddDelReply represents the VPP binary API message 'proxy_arp_add_del_reply'.
 261 // Generated from 'bin_api/vpe.api.json', line 72:
 262 //
 263 //        ["proxy_arp_add_del_reply",
 264 //            ["u16", "_vl_msg_id"],
 265 //            ["u32", "context"],
 266 //            ["i32", "retval"],
 267 //            {"crc" : "0x8e2d621d"}
 268 //        ],
 269 //
 270 type ProxyArpAddDelReply struct {
 271         Retval int32
 272 }
 273
 274 func (*ProxyArpAddDelReply) GetMessageName() string {
 275         return "proxy_arp_add_del_reply"
 276 }
 277 func (*ProxyArpAddDelReply) GetMessageType() api.MessageType {
 278         return api.ReplyMessage
 279 }
 280 func (*ProxyArpAddDelReply) GetCrcString() string {
 281         return "8e2d621d"
 282 }
 283 func NewProxyArpAddDelReply() api.Message {
 284         return &ProxyArpAddDelReply{}
 285 }
 286
 287 // ProxyArpIntfcEnableDisable represents the VPP binary API message 'proxy_arp_intfc_enable_disable'.
 288 // Generated from 'bin_api/vpe.api.json', line 78:
 289 //
 290 //        ["proxy_arp_intfc_enable_disable",
 291 //            ["u16", "_vl_msg_id"],
 292 //            ["u32", "client_index"],
 293 //            ["u32", "context"],
 294 //            ["u32", "sw_if_index"],
 295 //            ["u8", "enable_disable"],
 296 //            {"crc" : "0x3ee1998e"}
 297 //        ],
 298 //
 299 type ProxyArpIntfcEnableDisable struct {
 300         SwIfIndex     uint32
 301         EnableDisable uint8
 302 }
 303
 304 func (*ProxyArpIntfcEnableDisable) GetMessageName() string {
 305         return "proxy_arp_intfc_enable_disable"
 306 }
 307 func (*ProxyArpIntfcEnableDisable) GetMessageType() api.MessageType {
 308         return api.RequestMessage
 309 }
 310 func (*ProxyArpIntfcEnableDisable) GetCrcString() string {
 311         return "3ee1998e"
 312 }
 313 func NewProxyArpIntfcEnableDisable() api.Message {
 314         return &ProxyArpIntfcEnableDisable{}
 315 }
 316
 317 // ProxyArpIntfcEnableDisableReply represents the VPP binary API message 'proxy_arp_intfc_enable_disable_reply'.
 318 // Generated from 'bin_api/vpe.api.json', line 86:
 319 //
 320 //        ["proxy_arp_intfc_enable_disable_reply",
 321 //            ["u16", "_vl_msg_id"],
 322 //            ["u32", "context"],
 323 //            ["i32", "retval"],
 324 //            {"crc" : "0x23d273cd"}
 325 //        ],
 326 //
 327 type ProxyArpIntfcEnableDisableReply struct {
 328         Retval int32
 329 }
 330
 331 func (*ProxyArpIntfcEnableDisableReply) GetMessageName() string {
 332         return "proxy_arp_intfc_enable_disable_reply"
 333 }
 334 func (*ProxyArpIntfcEnableDisableReply) GetMessageType() api.MessageType {
 335         return api.ReplyMessage
 336 }
 337 func (*ProxyArpIntfcEnableDisableReply) GetCrcString() string {
 338         return "23d273cd"
 339 }
 340 func NewProxyArpIntfcEnableDisableReply() api.Message {
 341         return &ProxyArpIntfcEnableDisableReply{}
 342 }
 343
 344 // ResetVrf represents the VPP binary API message 'reset_vrf'.
 345 // Generated from 'bin_api/vpe.api.json', line 92:
 346 //
 347 //        ["reset_vrf",
 348 //            ["u16", "_vl_msg_id"],
 349 //            ["u32", "client_index"],
 350 //            ["u32", "context"],
 351 //            ["u8", "is_ipv6"],
 352 //            ["u32", "vrf_id"],
 353 //            {"crc" : "0xeb07deb0"}
 354 //        ],
 355 //
 356 type ResetVrf struct {
 357         IsIpv6 uint8
 358         VrfID  uint32
 359 }
 360
 361 func (*ResetVrf) GetMessageName() string {
 362         return "reset_vrf"
 363 }
 364 func (*ResetVrf) GetMessageType() api.MessageType {
 365         return api.RequestMessage
 366 }
 367 func (*ResetVrf) GetCrcString() string {
 368         return "eb07deb0"
 369 }
 370 func NewResetVrf() api.Message {
 371         return &ResetVrf{}
 372 }
 373
 374 // ResetVrfReply represents the VPP binary API message 'reset_vrf_reply'.
 375 // Generated from 'bin_api/vpe.api.json', line 100:
 376 //
 377 //        ["reset_vrf_reply",
 378 //            ["u16", "_vl_msg_id"],
 379 //            ["u32", "context"],
 380 //            ["i32", "retval"],
 381 //            {"crc" : "0x5f283863"}
 382 //        ],
 383 //
 384 type ResetVrfReply struct {
 385         Retval int32
 386 }
 387
 388 func (*ResetVrfReply) GetMessageName() string {
 389         return "reset_vrf_reply"
 390 }
 391 func (*ResetVrfReply) GetMessageType() api.MessageType {
 392         return api.ReplyMessage
 393 }
 394 func (*ResetVrfReply) GetCrcString() string {
 395         return "5f283863"
 396 }
 397 func NewResetVrfReply() api.Message {
 398         return &ResetVrfReply{}
 399 }
 400
 401 // WantStats represents the VPP binary API message 'want_stats'.
 402 // Generated from 'bin_api/vpe.api.json', line 106:
 403 //
 404 //        ["want_stats",
 405 //            ["u16", "_vl_msg_id"],
 406 //            ["u32", "client_index"],
 407 //            ["u32", "context"],
 408 //            ["u32", "enable_disable"],
 409 //            ["u32", "pid"],
 410 //            {"crc" : "0x4f2effb4"}
 411 //        ],
 412 //
 413 type WantStats struct {
 414         EnableDisable uint32
 415         Pid           uint32
 416 }
 417
 418 func (*WantStats) GetMessageName() string {
 419         return "want_stats"
 420 }
 421 func (*WantStats) GetMessageType() api.MessageType {
 422         return api.RequestMessage
 423 }
 424 func (*WantStats) GetCrcString() string {
 425         return "4f2effb4"
 426 }
 427 func NewWantStats() api.Message {
 428         return &WantStats{}
 429 }
 430
 431 // WantStatsReply represents the VPP binary API message 'want_stats_reply'.
 432 // Generated from 'bin_api/vpe.api.json', line 114:
 433 //
 434 //        ["want_stats_reply",
 435 //            ["u16", "_vl_msg_id"],
 436 //            ["u32", "context"],
 437 //            ["i32", "retval"],
 438 //            {"crc" : "0xb36abf5f"}
 439 //        ],
 440 //
 441 type WantStatsReply struct {
 442         Retval int32
 443 }
 444
 445 func (*WantStatsReply) GetMessageName() string {
 446         return "want_stats_reply"
 447 }
 448 func (*WantStatsReply) GetMessageType() api.MessageType {
 449         return api.ReplyMessage
 450 }
 451 func (*WantStatsReply) GetCrcString() string {
 452         return "b36abf5f"
 453 }
 454 func NewWantStatsReply() api.Message {
 455         return &WantStatsReply{}
 456 }
 457
 458 // VnetIP4FibCounters represents the VPP binary API message 'vnet_ip4_fib_counters'.
 459 // Generated from 'bin_api/vpe.api.json', line 120:
 460 //
 461 //        ["vnet_ip4_fib_counters",
 462 //            ["u16", "_vl_msg_id"],
 463 //            ["u32", "vrf_id"],
 464 //            ["u32", "count"],
 465 //            ["vl_api_ip4_fib_counter_t", "c", 0, "count"],
 466 //            {"crc" : "0x1ab9d6c5"}
 467 //        ],
 468 //
 469 type VnetIP4FibCounters struct {
 470         VrfID uint32
 471         Count uint32 `struc:"sizeof=C"`
 472         C     []IP4FibCounter
 473 }
 474
 475 func (*VnetIP4FibCounters) GetMessageName() string {
 476         return "vnet_ip4_fib_counters"
 477 }
 478 func (*VnetIP4FibCounters) GetMessageType() api.MessageType {
 479         return api.OtherMessage
 480 }
 481 func (*VnetIP4FibCounters) GetCrcString() string {
 482         return "1ab9d6c5"
 483 }
 484 func NewVnetIP4FibCounters() api.Message {
 485         return &VnetIP4FibCounters{}
 486 }
 487
 488 // VnetIP4NbrCounters represents the VPP binary API message 'vnet_ip4_nbr_counters'.
 489 // Generated from 'bin_api/vpe.api.json', line 127:
 490 //
 491 //        ["vnet_ip4_nbr_counters",
 492 //            ["u16", "_vl_msg_id"],
 493 //            ["u32", "count"],
 494 //            ["u32", "sw_if_index"],
 495 //            ["u8", "begin"],
 496 //            ["vl_api_ip4_nbr_counter_t", "c", 0, "count"],
 497 //            {"crc" : "0xfc2b5092"}
 498 //        ],
 499 //
 500 type VnetIP4NbrCounters struct {
 501         Count     uint32 `struc:"sizeof=C"`
 502         SwIfIndex uint32
 503         Begin     uint8
 504         C         []IP4NbrCounter
 505 }
 506
 507 func (*VnetIP4NbrCounters) GetMessageName() string {
 508         return "vnet_ip4_nbr_counters"
 509 }
 510 func (*VnetIP4NbrCounters) GetMessageType() api.MessageType {
 511         return api.OtherMessage
 512 }
 513 func (*VnetIP4NbrCounters) GetCrcString() string {
 514         return "fc2b5092"
 515 }
 516 func NewVnetIP4NbrCounters() api.Message {
 517         return &VnetIP4NbrCounters{}
 518 }
 519
 520 // VnetIP6FibCounters represents the VPP binary API message 'vnet_ip6_fib_counters'.
 521 // Generated from 'bin_api/vpe.api.json', line 135:
 522 //
 523 //        ["vnet_ip6_fib_counters",
 524 //            ["u16", "_vl_msg_id"],
 525 //            ["u32", "vrf_id"],
 526 //            ["u32", "count"],
 527 //            ["vl_api_ip6_fib_counter_t", "c", 0, "count"],
 528 //            {"crc" : "0x9ab453ae"}
 529 //        ],
 530 //
 531 type VnetIP6FibCounters struct {
 532         VrfID uint32
 533         Count uint32 `struc:"sizeof=C"`
 534         C     []IP6FibCounter
 535 }
 536
 537 func (*VnetIP6FibCounters) GetMessageName() string {
 538         return "vnet_ip6_fib_counters"
 539 }
 540 func (*VnetIP6FibCounters) GetMessageType() api.MessageType {
 541         return api.OtherMessage
 542 }
 543 func (*VnetIP6FibCounters) GetCrcString() string {
 544         return "9ab453ae"
 545 }
 546 func NewVnetIP6FibCounters() api.Message {
 547         return &VnetIP6FibCounters{}
 548 }
 549
 550 // VnetIP6NbrCounters represents the VPP binary API message 'vnet_ip6_nbr_counters'.
 551 // Generated from 'bin_api/vpe.api.json', line 142:
 552 //
 553 //        ["vnet_ip6_nbr_counters",
 554 //            ["u16", "_vl_msg_id"],
 555 //            ["u32", "count"],
 556 //            ["u32", "sw_if_index"],
 557 //            ["u8", "begin"],
 558 //            ["vl_api_ip6_nbr_counter_t", "c", 0, "count"],
 559 //            {"crc" : "0x181b673f"}
 560 //        ],
 561 //
 562 type VnetIP6NbrCounters struct {
 563         Count     uint32 `struc:"sizeof=C"`
 564         SwIfIndex uint32
 565         Begin     uint8
 566         C         []IP6NbrCounter
 567 }
 568
 569 func (*VnetIP6NbrCounters) GetMessageName() string {
 570         return "vnet_ip6_nbr_counters"
 571 }
 572 func (*VnetIP6NbrCounters) GetMessageType() api.MessageType {
 573         return api.OtherMessage
 574 }
 575 func (*VnetIP6NbrCounters) GetCrcString() string {
 576         return "181b673f"
 577 }
 578 func NewVnetIP6NbrCounters() api.Message {
 579         return &VnetIP6NbrCounters{}
 580 }
 581
 582 // VnetGetSummaryStats represents the VPP binary API message 'vnet_get_summary_stats'.
 583 // Generated from 'bin_api/vpe.api.json', line 150:
 584 //
 585 //        ["vnet_get_summary_stats",
 586 //            ["u16", "_vl_msg_id"],
 587 //            ["u32", "client_index"],
 588 //            ["u32", "context"],
 589 //            {"crc" : "0x16435c20"}
 590 //        ],
 591 //
 592 type VnetGetSummaryStats struct {
 593 }
 594
 595 func (*VnetGetSummaryStats) GetMessageName() string {
 596         return "vnet_get_summary_stats"
 597 }
 598 func (*VnetGetSummaryStats) GetMessageType() api.MessageType {
 599         return api.RequestMessage
 600 }
 601 func (*VnetGetSummaryStats) GetCrcString() string {
 602         return "16435c20"
 603 }
 604 func NewVnetGetSummaryStats() api.Message {
 605         return &VnetGetSummaryStats{}
 606 }
 607
 608 // VnetGetSummaryStatsReply represents the VPP binary API message 'vnet_get_summary_stats_reply'.
 609 // Generated from 'bin_api/vpe.api.json', line 156:
 610 //
 611 //        ["vnet_get_summary_stats_reply",
 612 //            ["u16", "_vl_msg_id"],
 613 //            ["u32", "context"],
 614 //            ["i32", "retval"],
 615 //            ["u64", "total_pkts", 2],
 616 //            ["u64", "total_bytes", 2],
 617 //            ["f64", "vector_rate"],
 618 //            {"crc" : "0x675ce280"}
 619 //        ],
 620 //
 621 type VnetGetSummaryStatsReply struct {
 622         Retval     int32
 623         TotalPkts  []uint64 `struc:"[2]uint64"`
 624         TotalBytes []uint64 `struc:"[2]uint64"`
 625         VectorRate float64
 626 }
 627
 628 func (*VnetGetSummaryStatsReply) GetMessageName() string {
 629         return "vnet_get_summary_stats_reply"
 630 }
 631 func (*VnetGetSummaryStatsReply) GetMessageType() api.MessageType {
 632         return api.ReplyMessage
 633 }
 634 func (*VnetGetSummaryStatsReply) GetCrcString() string {
 635         return "675ce280"
 636 }
 637 func NewVnetGetSummaryStatsReply() api.Message {
 638         return &VnetGetSummaryStatsReply{}
 639 }
 640
 641 // OamEvent represents the VPP binary API message 'oam_event'.
 642 // Generated from 'bin_api/vpe.api.json', line 165:
 643 //
 644 //        ["oam_event",
 645 //            ["u16", "_vl_msg_id"],
 646 //            ["u8", "dst_address", 4],
 647 //            ["u8", "state"],
 648 //            {"crc" : "0x4f285ade"}
 649 //        ],
 650 //
 651 type OamEvent struct {
 652         DstAddress []byte `struc:"[4]byte"`
 653         State      uint8
 654 }
 655
 656 func (*OamEvent) GetMessageName() string {
 657         return "oam_event"
 658 }
 659 func (*OamEvent) GetMessageType() api.MessageType {
 660         return api.OtherMessage
 661 }
 662 func (*OamEvent) GetCrcString() string {
 663         return "4f285ade"
 664 }
 665 func NewOamEvent() api.Message {
 666         return &OamEvent{}
 667 }
 668
 669 // WantOamEvents represents the VPP binary API message 'want_oam_events'.
 670 // Generated from 'bin_api/vpe.api.json', line 171:
 671 //
 672 //        ["want_oam_events",
 673 //            ["u16", "_vl_msg_id"],
 674 //            ["u32", "client_index"],
 675 //            ["u32", "context"],
 676 //            ["u32", "enable_disable"],
 677 //            ["u32", "pid"],
 678 //            {"crc" : "0x948ef12a"}
 679 //        ],
 680 //
 681 type WantOamEvents struct {
 682         EnableDisable uint32
 683         Pid           uint32
 684 }
 685
 686 func (*WantOamEvents) GetMessageName() string {
 687         return "want_oam_events"
 688 }
 689 func (*WantOamEvents) GetMessageType() api.MessageType {
 690         return api.RequestMessage
 691 }
 692 func (*WantOamEvents) GetCrcString() string {
 693         return "948ef12a"
 694 }
 695 func NewWantOamEvents() api.Message {
 696         return &WantOamEvents{}
 697 }
 698
 699 // WantOamEventsReply represents the VPP binary API message 'want_oam_events_reply'.
 700 // Generated from 'bin_api/vpe.api.json', line 179:
 701 //
 702 //        ["want_oam_events_reply",
 703 //            ["u16", "_vl_msg_id"],
 704 //            ["u32", "context"],
 705 //            ["i32", "retval"],
 706 //            {"crc" : "0x266a677d"}
 707 //        ],
 708 //
 709 type WantOamEventsReply struct {
 710         Retval int32
 711 }
 712
 713 func (*WantOamEventsReply) GetMessageName() string {
 714         return "want_oam_events_reply"
 715 }
 716 func (*WantOamEventsReply) GetMessageType() api.MessageType {
 717         return api.ReplyMessage
 718 }
 719 func (*WantOamEventsReply) GetCrcString() string {
 720         return "266a677d"
 721 }
 722 func NewWantOamEventsReply() api.Message {
 723         return &WantOamEventsReply{}
 724 }
 725
 726 // OamAddDel represents the VPP binary API message 'oam_add_del'.
 727 // Generated from 'bin_api/vpe.api.json', line 185:
 728 //
 729 //        ["oam_add_del",
 730 //            ["u16", "_vl_msg_id"],
 731 //            ["u32", "client_index"],
 732 //            ["u32", "context"],
 733 //            ["u32", "vrf_id"],
 734 //            ["u8", "src_address", 4],
 735 //            ["u8", "dst_address", 4],
 736 //            ["u8", "is_add"],
 737 //            {"crc" : "0xb14bc7df"}
 738 //        ],
 739 //
 740 type OamAddDel struct {
 741         VrfID      uint32
 742         SrcAddress []byte `struc:"[4]byte"`
 743         DstAddress []byte `struc:"[4]byte"`
 744         IsAdd      uint8
 745 }
 746
 747 func (*OamAddDel) GetMessageName() string {
 748         return "oam_add_del"
 749 }
 750 func (*OamAddDel) GetMessageType() api.MessageType {
 751         return api.RequestMessage
 752 }
 753 func (*OamAddDel) GetCrcString() string {
 754         return "b14bc7df"
 755 }
 756 func NewOamAddDel() api.Message {
 757         return &OamAddDel{}
 758 }
 759
 760 // OamAddDelReply represents the VPP binary API message 'oam_add_del_reply'.
 761 // Generated from 'bin_api/vpe.api.json', line 195:
 762 //
 763 //        ["oam_add_del_reply",
 764 //            ["u16", "_vl_msg_id"],
 765 //            ["u32", "context"],
 766 //            ["i32", "retval"],
 767 //            {"crc" : "0xc5594eec"}
 768 //        ],
 769 //
 770 type OamAddDelReply struct {
 771         Retval int32
 772 }
 773
 774 func (*OamAddDelReply) GetMessageName() string {
 775         return "oam_add_del_reply"
 776 }
 777 func (*OamAddDelReply) GetMessageType() api.MessageType {
 778         return api.ReplyMessage
 779 }
 780 func (*OamAddDelReply) GetCrcString() string {
 781         return "c5594eec"
 782 }
 783 func NewOamAddDelReply() api.Message {
 784         return &OamAddDelReply{}
 785 }
 786
 787 // ResetFib represents the VPP binary API message 'reset_fib'.
 788 // Generated from 'bin_api/vpe.api.json', line 201:
 789 //
 790 //        ["reset_fib",
 791 //            ["u16", "_vl_msg_id"],
 792 //            ["u32", "client_index"],
 793 //            ["u32", "context"],
 794 //            ["u32", "vrf_id"],
 795 //            ["u8", "is_ipv6"],
 796 //            {"crc" : "0x6f17106b"}
 797 //        ],
 798 //
 799 type ResetFib struct {
 800         VrfID  uint32
 801         IsIpv6 uint8
 802 }
 803
 804 func (*ResetFib) GetMessageName() string {
 805         return "reset_fib"
 806 }
 807 func (*ResetFib) GetMessageType() api.MessageType {
 808         return api.RequestMessage
 809 }
 810 func (*ResetFib) GetCrcString() string {
 811         return "6f17106b"
 812 }
 813 func NewResetFib() api.Message {
 814         return &ResetFib{}
 815 }
 816
 817 // ResetFibReply represents the VPP binary API message 'reset_fib_reply'.
 818 // Generated from 'bin_api/vpe.api.json', line 209:
 819 //
 820 //        ["reset_fib_reply",
 821 //            ["u16", "_vl_msg_id"],
 822 //            ["u32", "context"],
 823 //            ["i32", "retval"],
 824 //            {"crc" : "0x990dcbf8"}
 825 //        ],
 826 //
 827 type ResetFibReply struct {
 828         Retval int32
 829 }
 830
 831 func (*ResetFibReply) GetMessageName() string {
 832         return "reset_fib_reply"
 833 }
 834 func (*ResetFibReply) GetMessageType() api.MessageType {
 835         return api.ReplyMessage
 836 }
 837 func (*ResetFibReply) GetCrcString() string {
 838         return "990dcbf8"
 839 }
 840 func NewResetFibReply() api.Message {
 841         return &ResetFibReply{}
 842 }
 843
 844 // CreateLoopback represents the VPP binary API message 'create_loopback'.
 845 // Generated from 'bin_api/vpe.api.json', line 215:
 846 //
 847 //        ["create_loopback",
 848 //            ["u16", "_vl_msg_id"],
 849 //            ["u32", "client_index"],
 850 //            ["u32", "context"],
 851 //            ["u8", "mac_address", 6],
 852 //            {"crc" : "0xb2602de5"}
 853 //        ],
 854 //
 855 type CreateLoopback struct {
 856         MacAddress []byte `struc:"[6]byte"`
 857 }
 858
 859 func (*CreateLoopback) GetMessageName() string {
 860         return "create_loopback"
 861 }
 862 func (*CreateLoopback) GetMessageType() api.MessageType {
 863         return api.RequestMessage
 864 }
 865 func (*CreateLoopback) GetCrcString() string {
 866         return "b2602de5"
 867 }
 868 func NewCreateLoopback() api.Message {
 869         return &CreateLoopback{}
 870 }
 871
 872 // CreateLoopbackReply represents the VPP binary API message 'create_loopback_reply'.
 873 // Generated from 'bin_api/vpe.api.json', line 222:
 874 //
 875 //        ["create_loopback_reply",
 876 //            ["u16", "_vl_msg_id"],
 877 //            ["u32", "context"],
 878 //            ["i32", "retval"],
 879 //            ["u32", "sw_if_index"],
 880 //            {"crc" : "0x9520f804"}
 881 //        ],
 882 //
 883 type CreateLoopbackReply struct {
 884         Retval    int32
 885         SwIfIndex uint32
 886 }
 887
 888 func (*CreateLoopbackReply) GetMessageName() string {
 889         return "create_loopback_reply"
 890 }
 891 func (*CreateLoopbackReply) GetMessageType() api.MessageType {
 892         return api.ReplyMessage
 893 }
 894 func (*CreateLoopbackReply) GetCrcString() string {
 895         return "9520f804"
 896 }
 897 func NewCreateLoopbackReply() api.Message {
 898         return &CreateLoopbackReply{}
 899 }
 900
 901 // CreateLoopbackInstance represents the VPP binary API message 'create_loopback_instance'.
 902 // Generated from 'bin_api/vpe.api.json', line 229:
 903 //
 904 //        ["create_loopback_instance",
 905 //            ["u16", "_vl_msg_id"],
 906 //            ["u32", "client_index"],
 907 //            ["u32", "context"],
 908 //            ["u8", "mac_address", 6],
 909 //            ["u8", "is_specified"],
 910 //            ["u32", "user_instance"],
 911 //            {"crc" : "0x967694f1"}
 912 //        ],
 913 //
 914 type CreateLoopbackInstance struct {
 915         MacAddress   []byte `struc:"[6]byte"`
 916         IsSpecified  uint8
 917         UserInstance uint32
 918 }
 919
 920 func (*CreateLoopbackInstance) GetMessageName() string {
 921         return "create_loopback_instance"
 922 }
 923 func (*CreateLoopbackInstance) GetMessageType() api.MessageType {
 924         return api.RequestMessage
 925 }
 926 func (*CreateLoopbackInstance) GetCrcString() string {
 927         return "967694f1"
 928 }
 929 func NewCreateLoopbackInstance() api.Message {
 930         return &CreateLoopbackInstance{}
 931 }
 932
 933 // CreateLoopbackInstanceReply represents the VPP binary API message 'create_loopback_instance_reply'.
 934 // Generated from 'bin_api/vpe.api.json', line 238:
 935 //
 936 //        ["create_loopback_instance_reply",
 937 //            ["u16", "_vl_msg_id"],
 938 //            ["u32", "context"],
 939 //            ["i32", "retval"],
 940 //            ["u32", "sw_if_index"],
 941 //            {"crc" : "0xd52c63b6"}
 942 //        ],
 943 //
 944 type CreateLoopbackInstanceReply struct {
 945         Retval    int32
 946         SwIfIndex uint32
 947 }
 948
 949 func (*CreateLoopbackInstanceReply) GetMessageName() string {
 950         return "create_loopback_instance_reply"
 951 }
 952 func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType {
 953         return api.ReplyMessage
 954 }
 955 func (*CreateLoopbackInstanceReply) GetCrcString() string {
 956         return "d52c63b6"
 957 }
 958 func NewCreateLoopbackInstanceReply() api.Message {
 959         return &CreateLoopbackInstanceReply{}
 960 }
 961
 962 // DeleteLoopback represents the VPP binary API message 'delete_loopback'.
 963 // Generated from 'bin_api/vpe.api.json', line 245:
 964 //
 965 //        ["delete_loopback",
 966 //            ["u16", "_vl_msg_id"],
 967 //            ["u32", "client_index"],
 968 //            ["u32", "context"],
 969 //            ["u32", "sw_if_index"],
 970 //            {"crc" : "0xded428b0"}
 971 //        ],
 972 //
 973 type DeleteLoopback struct {
 974         SwIfIndex uint32
 975 }
 976
 977 func (*DeleteLoopback) GetMessageName() string {
 978         return "delete_loopback"
 979 }
 980 func (*DeleteLoopback) GetMessageType() api.MessageType {
 981         return api.RequestMessage
 982 }
 983 func (*DeleteLoopback) GetCrcString() string {
 984         return "ded428b0"
 985 }
 986 func NewDeleteLoopback() api.Message {
 987         return &DeleteLoopback{}
 988 }
 989
 990 // DeleteLoopbackReply represents the VPP binary API message 'delete_loopback_reply'.
 991 // Generated from 'bin_api/vpe.api.json', line 252:
 992 //
 993 //        ["delete_loopback_reply",
 994 //            ["u16", "_vl_msg_id"],
 995 //            ["u32", "context"],
 996 //            ["i32", "retval"],
 997 //            {"crc" : "0xc91dafa5"}
 998 //        ],
 999 //
1000 type DeleteLoopbackReply struct {
1001         Retval int32
1002 }
1003
1004 func (*DeleteLoopbackReply) GetMessageName() string {
1005         return "delete_loopback_reply"
1006 }
1007 func (*DeleteLoopbackReply) GetMessageType() api.MessageType {
1008         return api.ReplyMessage
1009 }
1010 func (*DeleteLoopbackReply) GetCrcString() string {
1011         return "c91dafa5"
1012 }
1013 func NewDeleteLoopbackReply() api.Message {
1014         return &DeleteLoopbackReply{}
1015 }
1016
1017 // ControlPing represents the VPP binary API message 'control_ping'.
1018 // Generated from 'bin_api/vpe.api.json', line 258:
1019 //
1020 //        ["control_ping",
1021 //            ["u16", "_vl_msg_id"],
1022 //            ["u32", "client_index"],
1023 //            ["u32", "context"],
1024 //            {"crc" : "0xea1bf4f7"}
1025 //        ],
1026 //
1027 type ControlPing struct {
1028 }
1029
1030 func (*ControlPing) GetMessageName() string {
1031         return "control_ping"
1032 }
1033 func (*ControlPing) GetMessageType() api.MessageType {
1034         return api.RequestMessage
1035 }
1036 func (*ControlPing) GetCrcString() string {
1037         return "ea1bf4f7"
1038 }
1039 func NewControlPing() api.Message {
1040         return &ControlPing{}
1041 }
1042
1043 // ControlPingReply represents the VPP binary API message 'control_ping_reply'.
1044 // Generated from 'bin_api/vpe.api.json', line 264:
1045 //
1046 //        ["control_ping_reply",
1047 //            ["u16", "_vl_msg_id"],
1048 //            ["u32", "context"],
1049 //            ["i32", "retval"],
1050 //            ["u32", "client_index"],
1051 //            ["u32", "vpe_pid"],
1052 //            {"crc" : "0xaa016e7b"}
1053 //        ],
1054 //
1055 type ControlPingReply struct {
1056         Retval      int32
1057         ClientIndex uint32
1058         VpePid      uint32
1059 }
1060
1061 func (*ControlPingReply) GetMessageName() string {
1062         return "control_ping_reply"
1063 }
1064 func (*ControlPingReply) GetMessageType() api.MessageType {
1065         return api.ReplyMessage
1066 }
1067 func (*ControlPingReply) GetCrcString() string {
1068         return "aa016e7b"
1069 }
1070 func NewControlPingReply() api.Message {
1071         return &ControlPingReply{}
1072 }
1073
1074 // Cli represents the VPP binary API message 'cli'.
1075 // Generated from 'bin_api/vpe.api.json', line 272:
1076 //
1077 //        ["cli",
1078 //            ["u16", "_vl_msg_id"],
1079 //            ["u32", "client_index"],
1080 //            ["u32", "context"],
1081 //            ["u64", "cmd_in_shmem"],
1082 //            {"crc" : "0x543d8e2e"}
1083 //        ],
1084 //
1085 type Cli struct {
1086         CmdInShmem uint64
1087 }
1088
1089 func (*Cli) GetMessageName() string {
1090         return "cli"
1091 }
1092 func (*Cli) GetMessageType() api.MessageType {
1093         return api.RequestMessage
1094 }
1095 func (*Cli) GetCrcString() string {
1096         return "543d8e2e"
1097 }
1098 func NewCli() api.Message {
1099         return &Cli{}
1100 }
1101
1102 // CliInband represents the VPP binary API message 'cli_inband'.
1103 // Generated from 'bin_api/vpe.api.json', line 279:
1104 //
1105 //        ["cli_inband",
1106 //            ["u16", "_vl_msg_id"],
1107 //            ["u32", "client_index"],
1108 //            ["u32", "context"],
1109 //            ["u32", "length"],
1110 //            ["u8", "cmd", 0, "length"],
1111 //            {"crc" : "0x22345937"}
1112 //        ],
1113 //
1114 type CliInband struct {
1115         Length uint32 `struc:"sizeof=Cmd"`
1116         Cmd    []byte
1117 }
1118
1119 func (*CliInband) GetMessageName() string {
1120         return "cli_inband"
1121 }
1122 func (*CliInband) GetMessageType() api.MessageType {
1123         return api.RequestMessage
1124 }
1125 func (*CliInband) GetCrcString() string {
1126         return "22345937"
1127 }
1128 func NewCliInband() api.Message {
1129         return &CliInband{}
1130 }
1131
1132 // CliReply represents the VPP binary API message 'cli_reply'.
1133 // Generated from 'bin_api/vpe.api.json', line 287:
1134 //
1135 //        ["cli_reply",
1136 //            ["u16", "_vl_msg_id"],
1137 //            ["u32", "context"],
1138 //            ["i32", "retval"],
1139 //            ["u64", "reply_in_shmem"],
1140 //            {"crc" : "0x594a0b2e"}
1141 //        ],
1142 //
1143 type CliReply struct {
1144         Retval       int32
1145         ReplyInShmem uint64
1146 }
1147
1148 func (*CliReply) GetMessageName() string {
1149         return "cli_reply"
1150 }
1151 func (*CliReply) GetMessageType() api.MessageType {
1152         return api.ReplyMessage
1153 }
1154 func (*CliReply) GetCrcString() string {
1155         return "594a0b2e"
1156 }
1157 func NewCliReply() api.Message {
1158         return &CliReply{}
1159 }
1160
1161 // CliInbandReply represents the VPP binary API message 'cli_inband_reply'.
1162 // Generated from 'bin_api/vpe.api.json', line 294:
1163 //
1164 //        ["cli_inband_reply",
1165 //            ["u16", "_vl_msg_id"],
1166 //            ["u32", "context"],
1167 //            ["i32", "retval"],
1168 //            ["u32", "length"],
1169 //            ["u8", "reply", 0, "length"],
1170 //            {"crc" : "0xc1835761"}
1171 //        ],
1172 //
1173 type CliInbandReply struct {
1174         Retval int32
1175         Length uint32 `struc:"sizeof=Reply"`
1176         Reply  []byte
1177 }
1178
1179 func (*CliInbandReply) GetMessageName() string {
1180         return "cli_inband_reply"
1181 }
1182 func (*CliInbandReply) GetMessageType() api.MessageType {
1183         return api.ReplyMessage
1184 }
1185 func (*CliInbandReply) GetCrcString() string {
1186         return "c1835761"
1187 }
1188 func NewCliInbandReply() api.Message {
1189         return &CliInbandReply{}
1190 }
1191
1192 // SetArpNeighborLimit represents the VPP binary API message 'set_arp_neighbor_limit'.
1193 // Generated from 'bin_api/vpe.api.json', line 302:
1194 //
1195 //        ["set_arp_neighbor_limit",
1196 //            ["u16", "_vl_msg_id"],
1197 //            ["u32", "client_index"],
1198 //            ["u32", "context"],
1199 //            ["u8", "is_ipv6"],
1200 //            ["u32", "arp_neighbor_limit"],
1201 //            {"crc" : "0xc1690cb4"}
1202 //        ],
1203 //
1204 type SetArpNeighborLimit struct {
1205         IsIpv6           uint8
1206         ArpNeighborLimit uint32
1207 }
1208
1209 func (*SetArpNeighborLimit) GetMessageName() string {
1210         return "set_arp_neighbor_limit"
1211 }
1212 func (*SetArpNeighborLimit) GetMessageType() api.MessageType {
1213         return api.RequestMessage
1214 }
1215 func (*SetArpNeighborLimit) GetCrcString() string {
1216         return "c1690cb4"
1217 }
1218 func NewSetArpNeighborLimit() api.Message {
1219         return &SetArpNeighborLimit{}
1220 }
1221
1222 // SetArpNeighborLimitReply represents the VPP binary API message 'set_arp_neighbor_limit_reply'.
1223 // Generated from 'bin_api/vpe.api.json', line 310:
1224 //
1225 //        ["set_arp_neighbor_limit_reply",
1226 //            ["u16", "_vl_msg_id"],
1227 //            ["u32", "context"],
1228 //            ["i32", "retval"],
1229 //            {"crc" : "0xa6b30518"}
1230 //        ],
1231 //
1232 type SetArpNeighborLimitReply struct {
1233         Retval int32
1234 }
1235
1236 func (*SetArpNeighborLimitReply) GetMessageName() string {
1237         return "set_arp_neighbor_limit_reply"
1238 }
1239 func (*SetArpNeighborLimitReply) GetMessageType() api.MessageType {
1240         return api.ReplyMessage
1241 }
1242 func (*SetArpNeighborLimitReply) GetCrcString() string {
1243         return "a6b30518"
1244 }
1245 func NewSetArpNeighborLimitReply() api.Message {
1246         return &SetArpNeighborLimitReply{}
1247 }
1248
1249 // L2PatchAddDel represents the VPP binary API message 'l2_patch_add_del'.
1250 // Generated from 'bin_api/vpe.api.json', line 316:
1251 //
1252 //        ["l2_patch_add_del",
1253 //            ["u16", "_vl_msg_id"],
1254 //            ["u32", "client_index"],
1255 //            ["u32", "context"],
1256 //            ["u32", "rx_sw_if_index"],
1257 //            ["u32", "tx_sw_if_index"],
1258 //            ["u8", "is_add"],
1259 //            {"crc" : "0x9b10029a"}
1260 //        ],
1261 //
1262 type L2PatchAddDel struct {
1263         RxSwIfIndex uint32
1264         TxSwIfIndex uint32
1265         IsAdd       uint8
1266 }
1267
1268 func (*L2PatchAddDel) GetMessageName() string {
1269         return "l2_patch_add_del"
1270 }
1271 func (*L2PatchAddDel) GetMessageType() api.MessageType {
1272         return api.RequestMessage
1273 }
1274 func (*L2PatchAddDel) GetCrcString() string {
1275         return "9b10029a"
1276 }
1277 func NewL2PatchAddDel() api.Message {
1278         return &L2PatchAddDel{}
1279 }
1280
1281 // L2PatchAddDelReply represents the VPP binary API message 'l2_patch_add_del_reply'.
1282 // Generated from 'bin_api/vpe.api.json', line 325:
1283 //
1284 //        ["l2_patch_add_del_reply",
1285 //            ["u16", "_vl_msg_id"],
1286 //            ["u32", "context"],
1287 //            ["i32", "retval"],
1288 //            {"crc" : "0xa85e37be"}
1289 //        ],
1290 //
1291 type L2PatchAddDelReply struct {
1292         Retval int32
1293 }
1294
1295 func (*L2PatchAddDelReply) GetMessageName() string {
1296         return "l2_patch_add_del_reply"
1297 }
1298 func (*L2PatchAddDelReply) GetMessageType() api.MessageType {
1299         return api.ReplyMessage
1300 }
1301 func (*L2PatchAddDelReply) GetCrcString() string {
1302         return "a85e37be"
1303 }
1304 func NewL2PatchAddDelReply() api.Message {
1305         return &L2PatchAddDelReply{}
1306 }
1307
1308 // SwInterfaceSetVpath represents the VPP binary API message 'sw_interface_set_vpath'.
1309 // Generated from 'bin_api/vpe.api.json', line 331:
1310 //
1311 //        ["sw_interface_set_vpath",
1312 //            ["u16", "_vl_msg_id"],
1313 //            ["u32", "client_index"],
1314 //            ["u32", "context"],
1315 //            ["u32", "sw_if_index"],
1316 //            ["u8", "enable"],
1317 //            {"crc" : "0x1bc2fd5e"}
1318 //        ],
1319 //
1320 type SwInterfaceSetVpath struct {
1321         SwIfIndex uint32
1322         Enable    uint8
1323 }
1324
1325 func (*SwInterfaceSetVpath) GetMessageName() string {
1326         return "sw_interface_set_vpath"
1327 }
1328 func (*SwInterfaceSetVpath) GetMessageType() api.MessageType {
1329         return api.RequestMessage
1330 }
1331 func (*SwInterfaceSetVpath) GetCrcString() string {
1332         return "1bc2fd5e"
1333 }
1334 func NewSwInterfaceSetVpath() api.Message {
1335         return &SwInterfaceSetVpath{}
1336 }
1337
1338 // SwInterfaceSetVpathReply represents the VPP binary API message 'sw_interface_set_vpath_reply'.
1339 // Generated from 'bin_api/vpe.api.json', line 339:
1340 //
1341 //        ["sw_interface_set_vpath_reply",
1342 //            ["u16", "_vl_msg_id"],
1343 //            ["u32", "context"],
1344 //            ["i32", "retval"],
1345 //            {"crc" : "0x828dbe62"}
1346 //        ],
1347 //
1348 type SwInterfaceSetVpathReply struct {
1349         Retval int32
1350 }
1351
1352 func (*SwInterfaceSetVpathReply) GetMessageName() string {
1353         return "sw_interface_set_vpath_reply"
1354 }
1355 func (*SwInterfaceSetVpathReply) GetMessageType() api.MessageType {
1356         return api.ReplyMessage
1357 }
1358 func (*SwInterfaceSetVpathReply) GetCrcString() string {
1359         return "828dbe62"
1360 }
1361 func NewSwInterfaceSetVpathReply() api.Message {
1362         return &SwInterfaceSetVpathReply{}
1363 }
1364
1365 // SwInterfaceSetL2Xconnect represents the VPP binary API message 'sw_interface_set_l2_xconnect'.
1366 // Generated from 'bin_api/vpe.api.json', line 345:
1367 //
1368 //        ["sw_interface_set_l2_xconnect",
1369 //            ["u16", "_vl_msg_id"],
1370 //            ["u32", "client_index"],
1371 //            ["u32", "context"],
1372 //            ["u32", "rx_sw_if_index"],
1373 //            ["u32", "tx_sw_if_index"],
1374 //            ["u8", "enable"],
1375 //            {"crc" : "0x48a4c4c8"}
1376 //        ],
1377 //
1378 type SwInterfaceSetL2Xconnect struct {
1379         RxSwIfIndex uint32
1380         TxSwIfIndex uint32
1381         Enable      uint8
1382 }
1383
1384 func (*SwInterfaceSetL2Xconnect) GetMessageName() string {
1385         return "sw_interface_set_l2_xconnect"
1386 }
1387 func (*SwInterfaceSetL2Xconnect) GetMessageType() api.MessageType {
1388         return api.RequestMessage
1389 }
1390 func (*SwInterfaceSetL2Xconnect) GetCrcString() string {
1391         return "48a4c4c8"
1392 }
1393 func NewSwInterfaceSetL2Xconnect() api.Message {
1394         return &SwInterfaceSetL2Xconnect{}
1395 }
1396
1397 // SwInterfaceSetL2XconnectReply represents the VPP binary API message 'sw_interface_set_l2_xconnect_reply'.
1398 // Generated from 'bin_api/vpe.api.json', line 354:
1399 //
1400 //        ["sw_interface_set_l2_xconnect_reply",
1401 //            ["u16", "_vl_msg_id"],
1402 //            ["u32", "context"],
1403 //            ["i32", "retval"],
1404 //            {"crc" : "0x6e45eed4"}
1405 //        ],
1406 //
1407 type SwInterfaceSetL2XconnectReply struct {
1408         Retval int32
1409 }
1410
1411 func (*SwInterfaceSetL2XconnectReply) GetMessageName() string {
1412         return "sw_interface_set_l2_xconnect_reply"
1413 }
1414 func (*SwInterfaceSetL2XconnectReply) GetMessageType() api.MessageType {
1415         return api.ReplyMessage
1416 }
1417 func (*SwInterfaceSetL2XconnectReply) GetCrcString() string {
1418         return "6e45eed4"
1419 }
1420 func NewSwInterfaceSetL2XconnectReply() api.Message {
1421         return &SwInterfaceSetL2XconnectReply{}
1422 }
1423
1424 // SwInterfaceSetL2Bridge represents the VPP binary API message 'sw_interface_set_l2_bridge'.
1425 // Generated from 'bin_api/vpe.api.json', line 360:
1426 //
1427 //        ["sw_interface_set_l2_bridge",
1428 //            ["u16", "_vl_msg_id"],
1429 //            ["u32", "client_index"],
1430 //            ["u32", "context"],
1431 //            ["u32", "rx_sw_if_index"],
1432 //            ["u32", "bd_id"],
1433 //            ["u8", "shg"],
1434 //            ["u8", "bvi"],
1435 //            ["u8", "enable"],
1436 //            {"crc" : "0x36c739e8"}
1437 //        ],
1438 //
1439 type SwInterfaceSetL2Bridge struct {
1440         RxSwIfIndex uint32
1441         BdID        uint32
1442         Shg         uint8
1443         Bvi         uint8
1444         Enable      uint8
1445 }
1446
1447 func (*SwInterfaceSetL2Bridge) GetMessageName() string {
1448         return "sw_interface_set_l2_bridge"
1449 }
1450 func (*SwInterfaceSetL2Bridge) GetMessageType() api.MessageType {
1451         return api.RequestMessage
1452 }
1453 func (*SwInterfaceSetL2Bridge) GetCrcString() string {
1454         return "36c739e8"
1455 }
1456 func NewSwInterfaceSetL2Bridge() api.Message {
1457         return &SwInterfaceSetL2Bridge{}
1458 }
1459
1460 // SwInterfaceSetL2BridgeReply represents the VPP binary API message 'sw_interface_set_l2_bridge_reply'.
1461 // Generated from 'bin_api/vpe.api.json', line 371:
1462 //
1463 //        ["sw_interface_set_l2_bridge_reply",
1464 //            ["u16", "_vl_msg_id"],
1465 //            ["u32", "context"],
1466 //            ["i32", "retval"],
1467 //            {"crc" : "0x347e08d9"}
1468 //        ],
1469 //
1470 type SwInterfaceSetL2BridgeReply struct {
1471         Retval int32
1472 }
1473
1474 func (*SwInterfaceSetL2BridgeReply) GetMessageName() string {
1475         return "sw_interface_set_l2_bridge_reply"
1476 }
1477 func (*SwInterfaceSetL2BridgeReply) GetMessageType() api.MessageType {
1478         return api.ReplyMessage
1479 }
1480 func (*SwInterfaceSetL2BridgeReply) GetCrcString() string {
1481         return "347e08d9"
1482 }
1483 func NewSwInterfaceSetL2BridgeReply() api.Message {
1484         return &SwInterfaceSetL2BridgeReply{}
1485 }
1486
1487 // BdIPMacAddDel represents the VPP binary API message 'bd_ip_mac_add_del'.
1488 // Generated from 'bin_api/vpe.api.json', line 377:
1489 //
1490 //        ["bd_ip_mac_add_del",
1491 //            ["u16", "_vl_msg_id"],
1492 //            ["u32", "client_index"],
1493 //            ["u32", "context"],
1494 //            ["u32", "bd_id"],
1495 //            ["u8", "is_add"],
1496 //            ["u8", "is_ipv6"],
1497 //            ["u8", "ip_address", 16],
1498 //            ["u8", "mac_address", 6],
1499 //            {"crc" : "0xad819817"}
1500 //        ],
1501 //
1502 type BdIPMacAddDel struct {
1503         BdID       uint32
1504         IsAdd      uint8
1505         IsIpv6     uint8
1506         IPAddress  []byte `struc:"[16]byte"`
1507         MacAddress []byte `struc:"[6]byte"`
1508 }
1509
1510 func (*BdIPMacAddDel) GetMessageName() string {
1511         return "bd_ip_mac_add_del"
1512 }
1513 func (*BdIPMacAddDel) GetMessageType() api.MessageType {
1514         return api.RequestMessage
1515 }
1516 func (*BdIPMacAddDel) GetCrcString() string {
1517         return "ad819817"
1518 }
1519 func NewBdIPMacAddDel() api.Message {
1520         return &BdIPMacAddDel{}
1521 }
1522
1523 // BdIPMacAddDelReply represents the VPP binary API message 'bd_ip_mac_add_del_reply'.
1524 // Generated from 'bin_api/vpe.api.json', line 388:
1525 //
1526 //        ["bd_ip_mac_add_del_reply",
1527 //            ["u16", "_vl_msg_id"],
1528 //            ["u32", "context"],
1529 //            ["i32", "retval"],
1530 //            {"crc" : "0x55bab3b4"}
1531 //        ],
1532 //
1533 type BdIPMacAddDelReply struct {
1534         Retval int32
1535 }
1536
1537 func (*BdIPMacAddDelReply) GetMessageName() string {
1538         return "bd_ip_mac_add_del_reply"
1539 }
1540 func (*BdIPMacAddDelReply) GetMessageType() api.MessageType {
1541         return api.ReplyMessage
1542 }
1543 func (*BdIPMacAddDelReply) GetCrcString() string {
1544         return "55bab3b4"
1545 }
1546 func NewBdIPMacAddDelReply() api.Message {
1547         return &BdIPMacAddDelReply{}
1548 }
1549
1550 // ClassifySetInterfaceIPTable represents the VPP binary API message 'classify_set_interface_ip_table'.
1551 // Generated from 'bin_api/vpe.api.json', line 394:
1552 //
1553 //        ["classify_set_interface_ip_table",
1554 //            ["u16", "_vl_msg_id"],
1555 //            ["u32", "client_index"],
1556 //            ["u32", "context"],
1557 //            ["u8", "is_ipv6"],
1558 //            ["u32", "sw_if_index"],
1559 //            ["u32", "table_index"],
1560 //            {"crc" : "0x0dc45308"}
1561 //        ],
1562 //
1563 type ClassifySetInterfaceIPTable struct {
1564         IsIpv6     uint8
1565         SwIfIndex  uint32
1566         TableIndex uint32
1567 }
1568
1569 func (*ClassifySetInterfaceIPTable) GetMessageName() string {
1570         return "classify_set_interface_ip_table"
1571 }
1572 func (*ClassifySetInterfaceIPTable) GetMessageType() api.MessageType {
1573         return api.RequestMessage
1574 }
1575 func (*ClassifySetInterfaceIPTable) GetCrcString() string {
1576         return "0dc45308"
1577 }
1578 func NewClassifySetInterfaceIPTable() api.Message {
1579         return &ClassifySetInterfaceIPTable{}
1580 }
1581
1582 // ClassifySetInterfaceIPTableReply represents the VPP binary API message 'classify_set_interface_ip_table_reply'.
1583 // Generated from 'bin_api/vpe.api.json', line 403:
1584 //
1585 //        ["classify_set_interface_ip_table_reply",
1586 //            ["u16", "_vl_msg_id"],
1587 //            ["u32", "context"],
1588 //            ["i32", "retval"],
1589 //            {"crc" : "0xdc391c34"}
1590 //        ],
1591 //
1592 type ClassifySetInterfaceIPTableReply struct {
1593         Retval int32
1594 }
1595
1596 func (*ClassifySetInterfaceIPTableReply) GetMessageName() string {
1597         return "classify_set_interface_ip_table_reply"
1598 }
1599 func (*ClassifySetInterfaceIPTableReply) GetMessageType() api.MessageType {
1600         return api.ReplyMessage
1601 }
1602 func (*ClassifySetInterfaceIPTableReply) GetCrcString() string {
1603         return "dc391c34"
1604 }
1605 func NewClassifySetInterfaceIPTableReply() api.Message {
1606         return &ClassifySetInterfaceIPTableReply{}
1607 }
1608
1609 // ClassifySetInterfaceL2Tables represents the VPP binary API message 'classify_set_interface_l2_tables'.
1610 // Generated from 'bin_api/vpe.api.json', line 409:
1611 //
1612 //        ["classify_set_interface_l2_tables",
1613 //            ["u16", "_vl_msg_id"],
1614 //            ["u32", "client_index"],
1615 //            ["u32", "context"],
1616 //            ["u32", "sw_if_index"],
1617 //            ["u32", "ip4_table_index"],
1618 //            ["u32", "ip6_table_index"],
1619 //            ["u32", "other_table_index"],
1620 //            ["u8", "is_input"],
1621 //            {"crc" : "0xed9ccf0d"}
1622 //        ],
1623 //
1624 type ClassifySetInterfaceL2Tables struct {
1625         SwIfIndex       uint32
1626         IP4TableIndex   uint32
1627         IP6TableIndex   uint32
1628         OtherTableIndex uint32
1629         IsInput         uint8
1630 }
1631
1632 func (*ClassifySetInterfaceL2Tables) GetMessageName() string {
1633         return "classify_set_interface_l2_tables"
1634 }
1635 func (*ClassifySetInterfaceL2Tables) GetMessageType() api.MessageType {
1636         return api.RequestMessage
1637 }
1638 func (*ClassifySetInterfaceL2Tables) GetCrcString() string {
1639         return "ed9ccf0d"
1640 }
1641 func NewClassifySetInterfaceL2Tables() api.Message {
1642         return &ClassifySetInterfaceL2Tables{}
1643 }
1644
1645 // ClassifySetInterfaceL2TablesReply represents the VPP binary API message 'classify_set_interface_l2_tables_reply'.
1646 // Generated from 'bin_api/vpe.api.json', line 420:
1647 //
1648 //        ["classify_set_interface_l2_tables_reply",
1649 //            ["u16", "_vl_msg_id"],
1650 //            ["u32", "context"],
1651 //            ["i32", "retval"],
1652 //            {"crc" : "0x8df20579"}
1653 //        ],
1654 //
1655 type ClassifySetInterfaceL2TablesReply struct {
1656         Retval int32
1657 }
1658
1659 func (*ClassifySetInterfaceL2TablesReply) GetMessageName() string {
1660         return "classify_set_interface_l2_tables_reply"
1661 }
1662 func (*ClassifySetInterfaceL2TablesReply) GetMessageType() api.MessageType {
1663         return api.ReplyMessage
1664 }
1665 func (*ClassifySetInterfaceL2TablesReply) GetCrcString() string {
1666         return "8df20579"
1667 }
1668 func NewClassifySetInterfaceL2TablesReply() api.Message {
1669         return &ClassifySetInterfaceL2TablesReply{}
1670 }
1671
1672 // GetNodeIndex represents the VPP binary API message 'get_node_index'.
1673 // Generated from 'bin_api/vpe.api.json', line 426:
1674 //
1675 //        ["get_node_index",
1676 //            ["u16", "_vl_msg_id"],
1677 //            ["u32", "client_index"],
1678 //            ["u32", "context"],
1679 //            ["u8", "node_name", 64],
1680 //            {"crc" : "0x226d3f8c"}
1681 //        ],
1682 //
1683 type GetNodeIndex struct {
1684         NodeName []byte `struc:"[64]byte"`
1685 }
1686
1687 func (*GetNodeIndex) GetMessageName() string {
1688         return "get_node_index"
1689 }
1690 func (*GetNodeIndex) GetMessageType() api.MessageType {
1691         return api.RequestMessage
1692 }
1693 func (*GetNodeIndex) GetCrcString() string {
1694         return "226d3f8c"
1695 }
1696 func NewGetNodeIndex() api.Message {
1697         return &GetNodeIndex{}
1698 }
1699
1700 // GetNodeIndexReply represents the VPP binary API message 'get_node_index_reply'.
1701 // Generated from 'bin_api/vpe.api.json', line 433:
1702 //
1703 //        ["get_node_index_reply",
1704 //            ["u16", "_vl_msg_id"],
1705 //            ["u32", "context"],
1706 //            ["i32", "retval"],
1707 //            ["u32", "node_index"],
1708 //            {"crc" : "0x29116865"}
1709 //        ],
1710 //
1711 type GetNodeIndexReply struct {
1712         Retval    int32
1713         NodeIndex uint32
1714 }
1715
1716 func (*GetNodeIndexReply) GetMessageName() string {
1717         return "get_node_index_reply"
1718 }
1719 func (*GetNodeIndexReply) GetMessageType() api.MessageType {
1720         return api.ReplyMessage
1721 }
1722 func (*GetNodeIndexReply) GetCrcString() string {
1723         return "29116865"
1724 }
1725 func NewGetNodeIndexReply() api.Message {
1726         return &GetNodeIndexReply{}
1727 }
1728
1729 // AddNodeNext represents the VPP binary API message 'add_node_next'.
1730 // Generated from 'bin_api/vpe.api.json', line 440:
1731 //
1732 //        ["add_node_next",
1733 //            ["u16", "_vl_msg_id"],
1734 //            ["u32", "client_index"],
1735 //            ["u32", "context"],
1736 //            ["u8", "node_name", 64],
1737 //            ["u8", "next_name", 64],
1738 //            {"crc" : "0xe4202993"}
1739 //        ],
1740 //
1741 type AddNodeNext struct {
1742         NodeName []byte `struc:"[64]byte"`
1743         NextName []byte `struc:"[64]byte"`
1744 }
1745
1746 func (*AddNodeNext) GetMessageName() string {
1747         return "add_node_next"
1748 }
1749 func (*AddNodeNext) GetMessageType() api.MessageType {
1750         return api.RequestMessage
1751 }
1752 func (*AddNodeNext) GetCrcString() string {
1753         return "e4202993"
1754 }
1755 func NewAddNodeNext() api.Message {
1756         return &AddNodeNext{}
1757 }
1758
1759 // AddNodeNextReply represents the VPP binary API message 'add_node_next_reply'.
1760 // Generated from 'bin_api/vpe.api.json', line 448:
1761 //
1762 //        ["add_node_next_reply",
1763 //            ["u16", "_vl_msg_id"],
1764 //            ["u32", "context"],
1765 //            ["i32", "retval"],
1766 //            ["u32", "next_index"],
1767 //            {"crc" : "0xe89d6eed"}
1768 //        ],
1769 //
1770 type AddNodeNextReply struct {
1771         Retval    int32
1772         NextIndex uint32
1773 }
1774
1775 func (*AddNodeNextReply) GetMessageName() string {
1776         return "add_node_next_reply"
1777 }
1778 func (*AddNodeNextReply) GetMessageType() api.MessageType {
1779         return api.ReplyMessage
1780 }
1781 func (*AddNodeNextReply) GetCrcString() string {
1782         return "e89d6eed"
1783 }
1784 func NewAddNodeNextReply() api.Message {
1785         return &AddNodeNextReply{}
1786 }
1787
1788 // L2InterfaceEfpFilter represents the VPP binary API message 'l2_interface_efp_filter'.
1789 // Generated from 'bin_api/vpe.api.json', line 455:
1790 //
1791 //        ["l2_interface_efp_filter",
1792 //            ["u16", "_vl_msg_id"],
1793 //            ["u32", "client_index"],
1794 //            ["u32", "context"],
1795 //            ["u32", "sw_if_index"],
1796 //            ["u32", "enable_disable"],
1797 //            {"crc" : "0x07c9d601"}
1798 //        ],
1799 //
1800 type L2InterfaceEfpFilter struct {
1801         SwIfIndex     uint32
1802         EnableDisable uint32
1803 }
1804
1805 func (*L2InterfaceEfpFilter) GetMessageName() string {
1806         return "l2_interface_efp_filter"
1807 }
1808 func (*L2InterfaceEfpFilter) GetMessageType() api.MessageType {
1809         return api.RequestMessage
1810 }
1811 func (*L2InterfaceEfpFilter) GetCrcString() string {
1812         return "07c9d601"
1813 }
1814 func NewL2InterfaceEfpFilter() api.Message {
1815         return &L2InterfaceEfpFilter{}
1816 }
1817
1818 // L2InterfaceEfpFilterReply represents the VPP binary API message 'l2_interface_efp_filter_reply'.
1819 // Generated from 'bin_api/vpe.api.json', line 463:
1820 //
1821 //        ["l2_interface_efp_filter_reply",
1822 //            ["u16", "_vl_msg_id"],
1823 //            ["u32", "context"],
1824 //            ["i32", "retval"],
1825 //            {"crc" : "0x0f4bb0c0"}
1826 //        ],
1827 //
1828 type L2InterfaceEfpFilterReply struct {
1829         Retval int32
1830 }
1831
1832 func (*L2InterfaceEfpFilterReply) GetMessageName() string {
1833         return "l2_interface_efp_filter_reply"
1834 }
1835 func (*L2InterfaceEfpFilterReply) GetMessageType() api.MessageType {
1836         return api.ReplyMessage
1837 }
1838 func (*L2InterfaceEfpFilterReply) GetCrcString() string {
1839         return "0f4bb0c0"
1840 }
1841 func NewL2InterfaceEfpFilterReply() api.Message {
1842         return &L2InterfaceEfpFilterReply{}
1843 }
1844
1845 // CreateSubif represents the VPP binary API message 'create_subif'.
1846 // Generated from 'bin_api/vpe.api.json', line 469:
1847 //
1848 //        ["create_subif",
1849 //            ["u16", "_vl_msg_id"],
1850 //            ["u32", "client_index"],
1851 //            ["u32", "context"],
1852 //            ["u32", "sw_if_index"],
1853 //            ["u32", "sub_id"],
1854 //            ["u8", "no_tags"],
1855 //            ["u8", "one_tag"],
1856 //            ["u8", "two_tags"],
1857 //            ["u8", "dot1ad"],
1858 //            ["u8", "exact_match"],
1859 //            ["u8", "default_sub"],
1860 //            ["u8", "outer_vlan_id_any"],
1861 //            ["u8", "inner_vlan_id_any"],
1862 //            ["u16", "outer_vlan_id"],
1863 //            ["u16", "inner_vlan_id"],
1864 //            {"crc" : "0x150e6757"}
1865 //        ],
1866 //
1867 type CreateSubif struct {
1868         SwIfIndex      uint32
1869         SubID          uint32
1870         NoTags         uint8
1871         OneTag         uint8
1872         TwoTags        uint8
1873         Dot1ad         uint8
1874         ExactMatch     uint8
1875         DefaultSub     uint8
1876         OuterVlanIDAny uint8
1877         InnerVlanIDAny uint8
1878         OuterVlanID    uint16
1879         InnerVlanID    uint16
1880 }
1881
1882 func (*CreateSubif) GetMessageName() string {
1883         return "create_subif"
1884 }
1885 func (*CreateSubif) GetMessageType() api.MessageType {
1886         return api.RequestMessage
1887 }
1888 func (*CreateSubif) GetCrcString() string {
1889         return "150e6757"
1890 }
1891 func NewCreateSubif() api.Message {
1892         return &CreateSubif{}
1893 }
1894
1895 // CreateSubifReply represents the VPP binary API message 'create_subif_reply'.
1896 // Generated from 'bin_api/vpe.api.json', line 487:
1897 //
1898 //        ["create_subif_reply",
1899 //            ["u16", "_vl_msg_id"],
1900 //            ["u32", "context"],
1901 //            ["i32", "retval"],
1902 //            ["u32", "sw_if_index"],
1903 //            {"crc" : "0x92272bcb"}
1904 //        ],
1905 //
1906 type CreateSubifReply struct {
1907         Retval    int32
1908         SwIfIndex uint32
1909 }
1910
1911 func (*CreateSubifReply) GetMessageName() string {
1912         return "create_subif_reply"
1913 }
1914 func (*CreateSubifReply) GetMessageType() api.MessageType {
1915         return api.ReplyMessage
1916 }
1917 func (*CreateSubifReply) GetCrcString() string {
1918         return "92272bcb"
1919 }
1920 func NewCreateSubifReply() api.Message {
1921         return &CreateSubifReply{}
1922 }
1923
1924 // ShowVersion represents the VPP binary API message 'show_version'.
1925 // Generated from 'bin_api/vpe.api.json', line 494:
1926 //
1927 //        ["show_version",
1928 //            ["u16", "_vl_msg_id"],
1929 //            ["u32", "client_index"],
1930 //            ["u32", "context"],
1931 //            {"crc" : "0xf18f9480"}
1932 //        ],
1933 //
1934 type ShowVersion struct {
1935 }
1936
1937 func (*ShowVersion) GetMessageName() string {
1938         return "show_version"
1939 }
1940 func (*ShowVersion) GetMessageType() api.MessageType {
1941         return api.RequestMessage
1942 }
1943 func (*ShowVersion) GetCrcString() string {
1944         return "f18f9480"
1945 }
1946 func NewShowVersion() api.Message {
1947         return &ShowVersion{}
1948 }
1949
1950 // ShowVersionReply represents the VPP binary API message 'show_version_reply'.
1951 // Generated from 'bin_api/vpe.api.json', line 500:
1952 //
1953 //        ["show_version_reply",
1954 //            ["u16", "_vl_msg_id"],
1955 //            ["u32", "context"],
1956 //            ["i32", "retval"],
1957 //            ["u8", "program", 32],
1958 //            ["u8", "version", 32],
1959 //            ["u8", "build_date", 32],
1960 //            ["u8", "build_directory", 256],
1961 //            {"crc" : "0x83186d9e"}
1962 //        ],
1963 //
1964 type ShowVersionReply struct {
1965         Retval         int32
1966         Program        []byte `struc:"[32]byte"`
1967         Version        []byte `struc:"[32]byte"`
1968         BuildDate      []byte `struc:"[32]byte"`
1969         BuildDirectory []byte `struc:"[256]byte"`
1970 }
1971
1972 func (*ShowVersionReply) GetMessageName() string {
1973         return "show_version_reply"
1974 }
1975 func (*ShowVersionReply) GetMessageType() api.MessageType {
1976         return api.ReplyMessage
1977 }
1978 func (*ShowVersionReply) GetCrcString() string {
1979         return "83186d9e"
1980 }
1981 func NewShowVersionReply() api.Message {
1982         return &ShowVersionReply{}
1983 }
1984
1985 // InterfaceNameRenumber represents the VPP binary API message 'interface_name_renumber'.
1986 // Generated from 'bin_api/vpe.api.json', line 510:
1987 //
1988 //        ["interface_name_renumber",
1989 //            ["u16", "_vl_msg_id"],
1990 //            ["u32", "client_index"],
1991 //            ["u32", "context"],
1992 //            ["u32", "sw_if_index"],
1993 //            ["u32", "new_show_dev_instance"],
1994 //            {"crc" : "0x11b7bcec"}
1995 //        ],
1996 //
1997 type InterfaceNameRenumber struct {
1998         SwIfIndex          uint32
1999         NewShowDevInstance uint32
2000 }
2001
2002 func (*InterfaceNameRenumber) GetMessageName() string {
2003         return "interface_name_renumber"
2004 }
2005 func (*InterfaceNameRenumber) GetMessageType() api.MessageType {
2006         return api.RequestMessage
2007 }
2008 func (*InterfaceNameRenumber) GetCrcString() string {
2009         return "11b7bcec"
2010 }
2011 func NewInterfaceNameRenumber() api.Message {
2012         return &InterfaceNameRenumber{}
2013 }
2014
2015 // InterfaceNameRenumberReply represents the VPP binary API message 'interface_name_renumber_reply'.
2016 // Generated from 'bin_api/vpe.api.json', line 518:
2017 //
2018 //        ["interface_name_renumber_reply",
2019 //            ["u16", "_vl_msg_id"],
2020 //            ["u32", "context"],
2021 //            ["i32", "retval"],
2022 //            {"crc" : "0x31594963"}
2023 //        ],
2024 //
2025 type InterfaceNameRenumberReply struct {
2026         Retval int32
2027 }
2028
2029 func (*InterfaceNameRenumberReply) GetMessageName() string {
2030         return "interface_name_renumber_reply"
2031 }
2032 func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType {
2033         return api.ReplyMessage
2034 }
2035 func (*InterfaceNameRenumberReply) GetCrcString() string {
2036         return "31594963"
2037 }
2038 func NewInterfaceNameRenumberReply() api.Message {
2039         return &InterfaceNameRenumberReply{}
2040 }
2041
2042 // WantIP4ArpEvents represents the VPP binary API message 'want_ip4_arp_events'.
2043 // Generated from 'bin_api/vpe.api.json', line 524:
2044 //
2045 //        ["want_ip4_arp_events",
2046 //            ["u16", "_vl_msg_id"],
2047 //            ["u32", "client_index"],
2048 //            ["u32", "context"],
2049 //            ["u8", "enable_disable"],
2050 //            ["u32", "pid"],
2051 //            ["u32", "address"],
2052 //            {"crc" : "0x5ae044c2"}
2053 //        ],
2054 //
2055 type WantIP4ArpEvents struct {
2056         EnableDisable uint8
2057         Pid           uint32
2058         Address       uint32
2059 }
2060
2061 func (*WantIP4ArpEvents) GetMessageName() string {
2062         return "want_ip4_arp_events"
2063 }
2064 func (*WantIP4ArpEvents) GetMessageType() api.MessageType {
2065         return api.RequestMessage
2066 }
2067 func (*WantIP4ArpEvents) GetCrcString() string {
2068         return "5ae044c2"
2069 }
2070 func NewWantIP4ArpEvents() api.Message {
2071         return &WantIP4ArpEvents{}
2072 }
2073
2074 // WantIP4ArpEventsReply represents the VPP binary API message 'want_ip4_arp_events_reply'.
2075 // Generated from 'bin_api/vpe.api.json', line 533:
2076 //
2077 //        ["want_ip4_arp_events_reply",
2078 //            ["u16", "_vl_msg_id"],
2079 //            ["u32", "context"],
2080 //            ["i32", "retval"],
2081 //            {"crc" : "0xe1c0b59e"}
2082 //        ],
2083 //
2084 type WantIP4ArpEventsReply struct {
2085         Retval int32
2086 }
2087
2088 func (*WantIP4ArpEventsReply) GetMessageName() string {
2089         return "want_ip4_arp_events_reply"
2090 }
2091 func (*WantIP4ArpEventsReply) GetMessageType() api.MessageType {
2092         return api.ReplyMessage
2093 }
2094 func (*WantIP4ArpEventsReply) GetCrcString() string {
2095         return "e1c0b59e"
2096 }
2097 func NewWantIP4ArpEventsReply() api.Message {
2098         return &WantIP4ArpEventsReply{}
2099 }
2100
2101 // IP4ArpEvent represents the VPP binary API message 'ip4_arp_event'.
2102 // Generated from 'bin_api/vpe.api.json', line 539:
2103 //
2104 //        ["ip4_arp_event",
2105 //            ["u16", "_vl_msg_id"],
2106 //            ["u32", "client_index"],
2107 //            ["u32", "context"],
2108 //            ["u32", "address"],
2109 //            ["u32", "pid"],
2110 //            ["u32", "sw_if_index"],
2111 //            ["u8", "new_mac", 6],
2112 //            ["u8", "mac_ip"],
2113 //            {"crc" : "0x7de1837b"}
2114 //        ],
2115 //
2116 type IP4ArpEvent struct {
2117         Address   uint32
2118         Pid       uint32
2119         SwIfIndex uint32
2120         NewMac    []byte `struc:"[6]byte"`
2121         MacIP     uint8
2122 }
2123
2124 func (*IP4ArpEvent) GetMessageName() string {
2125         return "ip4_arp_event"
2126 }
2127 func (*IP4ArpEvent) GetMessageType() api.MessageType {
2128         return api.RequestMessage
2129 }
2130 func (*IP4ArpEvent) GetCrcString() string {
2131         return "7de1837b"
2132 }
2133 func NewIP4ArpEvent() api.Message {
2134         return &IP4ArpEvent{}
2135 }
2136
2137 // WantIP6NdEvents represents the VPP binary API message 'want_ip6_nd_events'.
2138 // Generated from 'bin_api/vpe.api.json', line 550:
2139 //
2140 //        ["want_ip6_nd_events",
2141 //            ["u16", "_vl_msg_id"],
2142 //            ["u32", "client_index"],
2143 //            ["u32", "context"],
2144 //            ["u8", "enable_disable"],
2145 //            ["u32", "pid"],
2146 //            ["u8", "address", 16],
2147 //            {"crc" : "0x9586ba55"}
2148 //        ],
2149 //
2150 type WantIP6NdEvents struct {
2151         EnableDisable uint8
2152         Pid           uint32
2153         Address       []byte `struc:"[16]byte"`
2154 }
2155
2156 func (*WantIP6NdEvents) GetMessageName() string {
2157         return "want_ip6_nd_events"
2158 }
2159 func (*WantIP6NdEvents) GetMessageType() api.MessageType {
2160         return api.RequestMessage
2161 }
2162 func (*WantIP6NdEvents) GetCrcString() string {
2163         return "9586ba55"
2164 }
2165 func NewWantIP6NdEvents() api.Message {
2166         return &WantIP6NdEvents{}
2167 }
2168
2169 // WantIP6NdEventsReply represents the VPP binary API message 'want_ip6_nd_events_reply'.
2170 // Generated from 'bin_api/vpe.api.json', line 559:
2171 //
2172 //        ["want_ip6_nd_events_reply",
2173 //            ["u16", "_vl_msg_id"],
2174 //            ["u32", "context"],
2175 //            ["i32", "retval"],
2176 //            {"crc" : "0x95458aad"}
2177 //        ],
2178 //
2179 type WantIP6NdEventsReply struct {
2180         Retval int32
2181 }
2182
2183 func (*WantIP6NdEventsReply) GetMessageName() string {
2184         return "want_ip6_nd_events_reply"
2185 }
2186 func (*WantIP6NdEventsReply) GetMessageType() api.MessageType {
2187         return api.ReplyMessage
2188 }
2189 func (*WantIP6NdEventsReply) GetCrcString() string {
2190         return "95458aad"
2191 }
2192 func NewWantIP6NdEventsReply() api.Message {
2193         return &WantIP6NdEventsReply{}
2194 }
2195
2196 // IP6NdEvent represents the VPP binary API message 'ip6_nd_event'.
2197 // Generated from 'bin_api/vpe.api.json', line 565:
2198 //
2199 //        ["ip6_nd_event",
2200 //            ["u16", "_vl_msg_id"],
2201 //            ["u32", "client_index"],
2202 //            ["u32", "context"],
2203 //            ["u32", "pid"],
2204 //            ["u32", "sw_if_index"],
2205 //            ["u8", "address", 16],
2206 //            ["u8", "new_mac", 6],
2207 //            ["u8", "mac_ip"],
2208 //            {"crc" : "0x777bb71c"}
2209 //        ],
2210 //
2211 type IP6NdEvent struct {
2212         Pid       uint32
2213         SwIfIndex uint32
2214         Address   []byte `struc:"[16]byte"`
2215         NewMac    []byte `struc:"[6]byte"`
2216         MacIP     uint8
2217 }
2218
2219 func (*IP6NdEvent) GetMessageName() string {
2220         return "ip6_nd_event"
2221 }
2222 func (*IP6NdEvent) GetMessageType() api.MessageType {
2223         return api.RequestMessage
2224 }
2225 func (*IP6NdEvent) GetCrcString() string {
2226         return "777bb71c"
2227 }
2228 func NewIP6NdEvent() api.Message {
2229         return &IP6NdEvent{}
2230 }
2231
2232 // InputACLSetInterface represents the VPP binary API message 'input_acl_set_interface'.
2233 // Generated from 'bin_api/vpe.api.json', line 576:
2234 //
2235 //        ["input_acl_set_interface",
2236 //            ["u16", "_vl_msg_id"],
2237 //            ["u32", "client_index"],
2238 //            ["u32", "context"],
2239 //            ["u32", "sw_if_index"],
2240 //            ["u32", "ip4_table_index"],
2241 //            ["u32", "ip6_table_index"],
2242 //            ["u32", "l2_table_index"],
2243 //            ["u8", "is_add"],
2244 //            {"crc" : "0x34d2fc33"}
2245 //        ],
2246 //
2247 type InputACLSetInterface struct {
2248         SwIfIndex     uint32
2249         IP4TableIndex uint32
2250         IP6TableIndex uint32
2251         L2TableIndex  uint32
2252         IsAdd         uint8
2253 }
2254
2255 func (*InputACLSetInterface) GetMessageName() string {
2256         return "input_acl_set_interface"
2257 }
2258 func (*InputACLSetInterface) GetMessageType() api.MessageType {
2259         return api.RequestMessage
2260 }
2261 func (*InputACLSetInterface) GetCrcString() string {
2262         return "34d2fc33"
2263 }
2264 func NewInputACLSetInterface() api.Message {
2265         return &InputACLSetInterface{}
2266 }
2267
2268 // InputACLSetInterfaceReply represents the VPP binary API message 'input_acl_set_interface_reply'.
2269 // Generated from 'bin_api/vpe.api.json', line 587:
2270 //
2271 //        ["input_acl_set_interface_reply",
2272 //            ["u16", "_vl_msg_id"],
2273 //            ["u32", "context"],
2274 //            ["i32", "retval"],
2275 //            {"crc" : "0xba0110e3"}
2276 //        ],
2277 //
2278 type InputACLSetInterfaceReply struct {
2279         Retval int32
2280 }
2281
2282 func (*InputACLSetInterfaceReply) GetMessageName() string {
2283         return "input_acl_set_interface_reply"
2284 }
2285 func (*InputACLSetInterfaceReply) GetMessageType() api.MessageType {
2286         return api.ReplyMessage
2287 }
2288 func (*InputACLSetInterfaceReply) GetCrcString() string {
2289         return "ba0110e3"
2290 }
2291 func NewInputACLSetInterfaceReply() api.Message {
2292         return &InputACLSetInterfaceReply{}
2293 }
2294
2295 // GetNodeGraph represents the VPP binary API message 'get_node_graph'.
2296 // Generated from 'bin_api/vpe.api.json', line 593:
2297 //
2298 //        ["get_node_graph",
2299 //            ["u16", "_vl_msg_id"],
2300 //            ["u32", "client_index"],
2301 //            ["u32", "context"],
2302 //            {"crc" : "0xf8636a76"}
2303 //        ],
2304 //
2305 type GetNodeGraph struct {
2306 }
2307
2308 func (*GetNodeGraph) GetMessageName() string {
2309         return "get_node_graph"
2310 }
2311 func (*GetNodeGraph) GetMessageType() api.MessageType {
2312         return api.RequestMessage
2313 }
2314 func (*GetNodeGraph) GetCrcString() string {
2315         return "f8636a76"
2316 }
2317 func NewGetNodeGraph() api.Message {
2318         return &GetNodeGraph{}
2319 }
2320
2321 // GetNodeGraphReply represents the VPP binary API message 'get_node_graph_reply'.
2322 // Generated from 'bin_api/vpe.api.json', line 599:
2323 //
2324 //        ["get_node_graph_reply",
2325 //            ["u16", "_vl_msg_id"],
2326 //            ["u32", "context"],
2327 //            ["i32", "retval"],
2328 //            ["u64", "reply_in_shmem"],
2329 //            {"crc" : "0x816d91b6"}
2330 //        ],
2331 //
2332 type GetNodeGraphReply struct {
2333         Retval       int32
2334         ReplyInShmem uint64
2335 }
2336
2337 func (*GetNodeGraphReply) GetMessageName() string {
2338         return "get_node_graph_reply"
2339 }
2340 func (*GetNodeGraphReply) GetMessageType() api.MessageType {
2341         return api.ReplyMessage
2342 }
2343 func (*GetNodeGraphReply) GetCrcString() string {
2344         return "816d91b6"
2345 }
2346 func NewGetNodeGraphReply() api.Message {
2347         return &GetNodeGraphReply{}
2348 }
2349
2350 // IoamEnable represents the VPP binary API message 'ioam_enable'.
2351 // Generated from 'bin_api/vpe.api.json', line 606:
2352 //
2353 //        ["ioam_enable",
2354 //            ["u16", "_vl_msg_id"],
2355 //            ["u32", "client_index"],
2356 //            ["u32", "context"],
2357 //            ["u16", "id"],
2358 //            ["u8", "seqno"],
2359 //            ["u8", "analyse"],
2360 //            ["u8", "pot_enable"],
2361 //            ["u8", "trace_enable"],
2362 //            ["u32", "node_id"],
2363 //            {"crc" : "0x7bd4abf9"}
2364 //        ],
2365 //
2366 type IoamEnable struct {
2367         ID          uint16
2368         Seqno       uint8
2369         Analyse     uint8
2370         PotEnable   uint8
2371         TraceEnable uint8
2372         NodeID      uint32
2373 }
2374
2375 func (*IoamEnable) GetMessageName() string {
2376         return "ioam_enable"
2377 }
2378 func (*IoamEnable) GetMessageType() api.MessageType {
2379         return api.RequestMessage
2380 }
2381 func (*IoamEnable) GetCrcString() string {
2382         return "7bd4abf9"
2383 }
2384 func NewIoamEnable() api.Message {
2385         return &IoamEnable{}
2386 }
2387
2388 // IoamEnableReply represents the VPP binary API message 'ioam_enable_reply'.
2389 // Generated from 'bin_api/vpe.api.json', line 618:
2390 //
2391 //        ["ioam_enable_reply",
2392 //            ["u16", "_vl_msg_id"],
2393 //            ["u32", "context"],
2394 //            ["i32", "retval"],
2395 //            {"crc" : "0x58a8fedc"}
2396 //        ],
2397 //
2398 type IoamEnableReply struct {
2399         Retval int32
2400 }
2401
2402 func (*IoamEnableReply) GetMessageName() string {
2403         return "ioam_enable_reply"
2404 }
2405 func (*IoamEnableReply) GetMessageType() api.MessageType {
2406         return api.ReplyMessage
2407 }
2408 func (*IoamEnableReply) GetCrcString() string {
2409         return "58a8fedc"
2410 }
2411 func NewIoamEnableReply() api.Message {
2412         return &IoamEnableReply{}
2413 }
2414
2415 // IoamDisable represents the VPP binary API message 'ioam_disable'.
2416 // Generated from 'bin_api/vpe.api.json', line 624:
2417 //
2418 //        ["ioam_disable",
2419 //            ["u16", "_vl_msg_id"],
2420 //            ["u32", "client_index"],
2421 //            ["u32", "context"],
2422 //            ["u16", "id"],
2423 //            {"crc" : "0xaff26d33"}
2424 //        ],
2425 //
2426 type IoamDisable struct {
2427         ID uint16
2428 }
2429
2430 func (*IoamDisable) GetMessageName() string {
2431         return "ioam_disable"
2432 }
2433 func (*IoamDisable) GetMessageType() api.MessageType {
2434         return api.RequestMessage
2435 }
2436 func (*IoamDisable) GetCrcString() string {
2437         return "aff26d33"
2438 }
2439 func NewIoamDisable() api.Message {
2440         return &IoamDisable{}
2441 }
2442
2443 // IoamDisableReply represents the VPP binary API message 'ioam_disable_reply'.
2444 // Generated from 'bin_api/vpe.api.json', line 631:
2445 //
2446 //        ["ioam_disable_reply",
2447 //            ["u16", "_vl_msg_id"],
2448 //            ["u32", "context"],
2449 //            ["i32", "retval"],
2450 //            {"crc" : "0xef118a9d"}
2451 //        ],
2452 //
2453 type IoamDisableReply struct {
2454         Retval int32
2455 }
2456
2457 func (*IoamDisableReply) GetMessageName() string {
2458         return "ioam_disable_reply"
2459 }
2460 func (*IoamDisableReply) GetMessageType() api.MessageType {
2461         return api.ReplyMessage
2462 }
2463 func (*IoamDisableReply) GetCrcString() string {
2464         return "ef118a9d"
2465 }
2466 func NewIoamDisableReply() api.Message {
2467         return &IoamDisableReply{}
2468 }
2469
2470 // GetNextIndex represents the VPP binary API message 'get_next_index'.
2471 // Generated from 'bin_api/vpe.api.json', line 637:
2472 //
2473 //        ["get_next_index",
2474 //            ["u16", "_vl_msg_id"],
2475 //            ["u32", "client_index"],
2476 //            ["u32", "context"],
2477 //            ["u8", "node_name", 64],
2478 //            ["u8", "next_name", 64],
2479 //            {"crc" : "0x52f0e416"}
2480 //        ],
2481 //
2482 type GetNextIndex struct {
2483         NodeName []byte `struc:"[64]byte"`
2484         NextName []byte `struc:"[64]byte"`
2485 }
2486
2487 func (*GetNextIndex) GetMessageName() string {
2488         return "get_next_index"
2489 }
2490 func (*GetNextIndex) GetMessageType() api.MessageType {
2491         return api.RequestMessage
2492 }
2493 func (*GetNextIndex) GetCrcString() string {
2494         return "52f0e416"
2495 }
2496 func NewGetNextIndex() api.Message {
2497         return &GetNextIndex{}
2498 }
2499
2500 // GetNextIndexReply represents the VPP binary API message 'get_next_index_reply'.
2501 // Generated from 'bin_api/vpe.api.json', line 645:
2502 //
2503 //        ["get_next_index_reply",
2504 //            ["u16", "_vl_msg_id"],
2505 //            ["u32", "context"],
2506 //            ["i32", "retval"],
2507 //            ["u32", "next_index"],
2508 //            {"crc" : "0x671fbdb1"}
2509 //        ],
2510 //
2511 type GetNextIndexReply struct {
2512         Retval    int32
2513         NextIndex uint32
2514 }
2515
2516 func (*GetNextIndexReply) GetMessageName() string {
2517         return "get_next_index_reply"
2518 }
2519 func (*GetNextIndexReply) GetMessageType() api.MessageType {
2520         return api.ReplyMessage
2521 }
2522 func (*GetNextIndexReply) GetCrcString() string {
2523         return "671fbdb1"
2524 }
2525 func NewGetNextIndexReply() api.Message {
2526         return &GetNextIndexReply{}
2527 }
2528
2529 // PgCreateInterface represents the VPP binary API message 'pg_create_interface'.
2530 // Generated from 'bin_api/vpe.api.json', line 652:
2531 //
2532 //        ["pg_create_interface",
2533 //            ["u16", "_vl_msg_id"],
2534 //            ["u32", "client_index"],
2535 //            ["u32", "context"],
2536 //            ["u32", "interface_id"],
2537 //            {"crc" : "0x253c5959"}
2538 //        ],
2539 //
2540 type PgCreateInterface struct {
2541         InterfaceID uint32
2542 }
2543
2544 func (*PgCreateInterface) GetMessageName() string {
2545         return "pg_create_interface"
2546 }
2547 func (*PgCreateInterface) GetMessageType() api.MessageType {
2548         return api.RequestMessage
2549 }
2550 func (*PgCreateInterface) GetCrcString() string {
2551         return "253c5959"
2552 }
2553 func NewPgCreateInterface() api.Message {
2554         return &PgCreateInterface{}
2555 }
2556
2557 // PgCreateInterfaceReply represents the VPP binary API message 'pg_create_interface_reply'.
2558 // Generated from 'bin_api/vpe.api.json', line 659:
2559 //
2560 //        ["pg_create_interface_reply",
2561 //            ["u16", "_vl_msg_id"],
2562 //            ["u32", "context"],
2563 //            ["i32", "retval"],
2564 //            ["u32", "sw_if_index"],
2565 //            {"crc" : "0x21b4f949"}
2566 //        ],
2567 //
2568 type PgCreateInterfaceReply struct {
2569         Retval    int32
2570         SwIfIndex uint32
2571 }
2572
2573 func (*PgCreateInterfaceReply) GetMessageName() string {
2574         return "pg_create_interface_reply"
2575 }
2576 func (*PgCreateInterfaceReply) GetMessageType() api.MessageType {
2577         return api.ReplyMessage
2578 }
2579 func (*PgCreateInterfaceReply) GetCrcString() string {
2580         return "21b4f949"
2581 }
2582 func NewPgCreateInterfaceReply() api.Message {
2583         return &PgCreateInterfaceReply{}
2584 }
2585
2586 // PgCapture represents the VPP binary API message 'pg_capture'.
2587 // Generated from 'bin_api/vpe.api.json', line 666:
2588 //
2589 //        ["pg_capture",
2590 //            ["u16", "_vl_msg_id"],
2591 //            ["u32", "client_index"],
2592 //            ["u32", "context"],
2593 //            ["u32", "interface_id"],
2594 //            ["u8", "is_enabled"],
2595 //            ["u32", "count"],
2596 //            ["u32", "pcap_name_length"],
2597 //            ["u8", "pcap_file_name", 0, "pcap_name_length"],
2598 //            {"crc" : "0x6ac7fe78"}
2599 //        ],
2600 //
2601 type PgCapture struct {
2602         InterfaceID    uint32
2603         IsEnabled      uint8
2604         Count          uint32
2605         PcapNameLength uint32 `struc:"sizeof=PcapFileName"`
2606         PcapFileName   []byte
2607 }
2608
2609 func (*PgCapture) GetMessageName() string {
2610         return "pg_capture"
2611 }
2612 func (*PgCapture) GetMessageType() api.MessageType {
2613         return api.RequestMessage
2614 }
2615 func (*PgCapture) GetCrcString() string {
2616         return "6ac7fe78"
2617 }
2618 func NewPgCapture() api.Message {
2619         return &PgCapture{}
2620 }
2621
2622 // PgCaptureReply represents the VPP binary API message 'pg_capture_reply'.
2623 // Generated from 'bin_api/vpe.api.json', line 677:
2624 //
2625 //        ["pg_capture_reply",
2626 //            ["u16", "_vl_msg_id"],
2627 //            ["u32", "context"],
2628 //            ["i32", "retval"],
2629 //            {"crc" : "0xf403693b"}
2630 //        ],
2631 //
2632 type PgCaptureReply struct {
2633         Retval int32
2634 }
2635
2636 func (*PgCaptureReply) GetMessageName() string {
2637         return "pg_capture_reply"
2638 }
2639 func (*PgCaptureReply) GetMessageType() api.MessageType {
2640         return api.ReplyMessage
2641 }
2642 func (*PgCaptureReply) GetCrcString() string {
2643         return "f403693b"
2644 }
2645 func NewPgCaptureReply() api.Message {
2646         return &PgCaptureReply{}
2647 }
2648
2649 // PgEnableDisable represents the VPP binary API message 'pg_enable_disable'.
2650 // Generated from 'bin_api/vpe.api.json', line 683:
2651 //
2652 //        ["pg_enable_disable",
2653 //            ["u16", "_vl_msg_id"],
2654 //            ["u32", "client_index"],
2655 //            ["u32", "context"],
2656 //            ["u8", "is_enabled"],
2657 //            ["u32", "stream_name_length"],
2658 //            ["u8", "stream_name", 0, "stream_name_length"],
2659 //            {"crc" : "0x7d0b90ff"}
2660 //        ],
2661 //
2662 type PgEnableDisable struct {
2663         IsEnabled        uint8
2664         StreamNameLength uint32 `struc:"sizeof=StreamName"`
2665         StreamName       []byte
2666 }
2667
2668 func (*PgEnableDisable) GetMessageName() string {
2669         return "pg_enable_disable"
2670 }
2671 func (*PgEnableDisable) GetMessageType() api.MessageType {
2672         return api.RequestMessage
2673 }
2674 func (*PgEnableDisable) GetCrcString() string {
2675         return "7d0b90ff"
2676 }
2677 func NewPgEnableDisable() api.Message {
2678         return &PgEnableDisable{}
2679 }
2680
2681 // PgEnableDisableReply represents the VPP binary API message 'pg_enable_disable_reply'.
2682 // Generated from 'bin_api/vpe.api.json', line 692:
2683 //
2684 //        ["pg_enable_disable_reply",
2685 //            ["u16", "_vl_msg_id"],
2686 //            ["u32", "context"],
2687 //            ["i32", "retval"],
2688 //            {"crc" : "0x02253bd6"}
2689 //        ],
2690 //
2691 type PgEnableDisableReply struct {
2692         Retval int32
2693 }
2694
2695 func (*PgEnableDisableReply) GetMessageName() string {
2696         return "pg_enable_disable_reply"
2697 }
2698 func (*PgEnableDisableReply) GetMessageType() api.MessageType {
2699         return api.ReplyMessage
2700 }
2701 func (*PgEnableDisableReply) GetCrcString() string {
2702         return "02253bd6"
2703 }
2704 func NewPgEnableDisableReply() api.Message {
2705         return &PgEnableDisableReply{}
2706 }
2707
2708 // IPSourceAndPortRangeCheckAddDel represents the VPP binary API message 'ip_source_and_port_range_check_add_del'.
2709 // Generated from 'bin_api/vpe.api.json', line 698:
2710 //
2711 //        ["ip_source_and_port_range_check_add_del",
2712 //            ["u16", "_vl_msg_id"],
2713 //            ["u32", "client_index"],
2714 //            ["u32", "context"],
2715 //            ["u8", "is_ipv6"],
2716 //            ["u8", "is_add"],
2717 //            ["u8", "mask_length"],
2718 //            ["u8", "address", 16],
2719 //            ["u8", "number_of_ranges"],
2720 //            ["u16", "low_ports", 32],
2721 //            ["u16", "high_ports", 32],
2722 //            ["u32", "vrf_id"],
2723 //            {"crc" : "0x0f8c6ba0"}
2724 //        ],
2725 //
2726 type IPSourceAndPortRangeCheckAddDel struct {
2727         IsIpv6         uint8
2728         IsAdd          uint8
2729         MaskLength     uint8
2730         Address        []byte `struc:"[16]byte"`
2731         NumberOfRanges uint8
2732         LowPorts       []uint16 `struc:"[32]uint16"`
2733         HighPorts      []uint16 `struc:"[32]uint16"`
2734         VrfID          uint32
2735 }
2736
2737 func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
2738         return "ip_source_and_port_range_check_add_del"
2739 }
2740 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType {
2741         return api.RequestMessage
2742 }
2743 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string {
2744         return "0f8c6ba0"
2745 }
2746 func NewIPSourceAndPortRangeCheckAddDel() api.Message {
2747         return &IPSourceAndPortRangeCheckAddDel{}
2748 }
2749
2750 // IPSourceAndPortRangeCheckAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
2751 // Generated from 'bin_api/vpe.api.json', line 712:
2752 //
2753 //        ["ip_source_and_port_range_check_add_del_reply",
2754 //            ["u16", "_vl_msg_id"],
2755 //            ["u32", "context"],
2756 //            ["i32", "retval"],
2757 //            {"crc" : "0x35df8160"}
2758 //        ],
2759 //
2760 type IPSourceAndPortRangeCheckAddDelReply struct {
2761         Retval int32
2762 }
2763
2764 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
2765         return "ip_source_and_port_range_check_add_del_reply"
2766 }
2767 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
2768         return api.ReplyMessage
2769 }
2770 func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string {
2771         return "35df8160"
2772 }
2773 func NewIPSourceAndPortRangeCheckAddDelReply() api.Message {
2774         return &IPSourceAndPortRangeCheckAddDelReply{}
2775 }
2776
2777 // IPSourceAndPortRangeCheckInterfaceAddDel represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
2778 // Generated from 'bin_api/vpe.api.json', line 718:
2779 //
2780 //        ["ip_source_and_port_range_check_interface_add_del",
2781 //            ["u16", "_vl_msg_id"],
2782 //            ["u32", "client_index"],
2783 //            ["u32", "context"],
2784 //            ["u8", "is_add"],
2785 //            ["u32", "sw_if_index"],
2786 //            ["u32", "tcp_in_vrf_id"],
2787 //            ["u32", "tcp_out_vrf_id"],
2788 //            ["u32", "udp_in_vrf_id"],
2789 //            ["u32", "udp_out_vrf_id"],
2790 //            {"crc" : "0x4a6438f1"}
2791 //        ],
2792 //
2793 type IPSourceAndPortRangeCheckInterfaceAddDel struct {
2794         IsAdd       uint8
2795         SwIfIndex   uint32
2796         TCPInVrfID  uint32
2797         TCPOutVrfID uint32
2798         UDPInVrfID  uint32
2799         UDPOutVrfID uint32
2800 }
2801
2802 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
2803         return "ip_source_and_port_range_check_interface_add_del"
2804 }
2805 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
2806         return api.RequestMessage
2807 }
2808 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string {
2809         return "4a6438f1"
2810 }
2811 func NewIPSourceAndPortRangeCheckInterfaceAddDel() api.Message {
2812         return &IPSourceAndPortRangeCheckInterfaceAddDel{}
2813 }
2814
2815 // IPSourceAndPortRangeCheckInterfaceAddDelReply represents the VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
2816 // Generated from 'bin_api/vpe.api.json', line 730:
2817 //
2818 //        ["ip_source_and_port_range_check_interface_add_del_reply",
2819 //            ["u16", "_vl_msg_id"],
2820 //            ["u32", "context"],
2821 //            ["i32", "retval"],
2822 //            {"crc" : "0x6b940f04"}
2823 //        ],
2824 //
2825 type IPSourceAndPortRangeCheckInterfaceAddDelReply struct {
2826         Retval int32
2827 }
2828
2829 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
2830         return "ip_source_and_port_range_check_interface_add_del_reply"
2831 }
2832 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
2833         return api.ReplyMessage
2834 }
2835 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string {
2836         return "6b940f04"
2837 }
2838 func NewIPSourceAndPortRangeCheckInterfaceAddDelReply() api.Message {
2839         return &IPSourceAndPortRangeCheckInterfaceAddDelReply{}
2840 }
2841
2842 // DeleteSubif represents the VPP binary API message 'delete_subif'.
2843 // Generated from 'bin_api/vpe.api.json', line 736:
2844 //
2845 //        ["delete_subif",
2846 //            ["u16", "_vl_msg_id"],
2847 //            ["u32", "client_index"],
2848 //            ["u32", "context"],
2849 //            ["u32", "sw_if_index"],
2850 //            {"crc" : "0x6038f848"}
2851 //        ],
2852 //
2853 type DeleteSubif struct {
2854         SwIfIndex uint32
2855 }
2856
2857 func (*DeleteSubif) GetMessageName() string {
2858         return "delete_subif"
2859 }
2860 func (*DeleteSubif) GetMessageType() api.MessageType {
2861         return api.RequestMessage
2862 }
2863 func (*DeleteSubif) GetCrcString() string {
2864         return "6038f848"
2865 }
2866 func NewDeleteSubif() api.Message {
2867         return &DeleteSubif{}
2868 }
2869
2870 // DeleteSubifReply represents the VPP binary API message 'delete_subif_reply'.
2871 // Generated from 'bin_api/vpe.api.json', line 743:
2872 //
2873 //        ["delete_subif_reply",
2874 //            ["u16", "_vl_msg_id"],
2875 //            ["u32", "context"],
2876 //            ["i32", "retval"],
2877 //            {"crc" : "0x9d6015dc"}
2878 //        ],
2879 //
2880 type DeleteSubifReply struct {
2881         Retval int32
2882 }
2883
2884 func (*DeleteSubifReply) GetMessageName() string {
2885         return "delete_subif_reply"
2886 }
2887 func (*DeleteSubifReply) GetMessageType() api.MessageType {
2888         return api.ReplyMessage
2889 }
2890 func (*DeleteSubifReply) GetCrcString() string {
2891         return "9d6015dc"
2892 }
2893 func NewDeleteSubifReply() api.Message {
2894         return &DeleteSubifReply{}
2895 }
2896
2897 // Punt represents the VPP binary API message 'punt'.
2898 // Generated from 'bin_api/vpe.api.json', line 749:
2899 //
2900 //        ["punt",
2901 //            ["u16", "_vl_msg_id"],
2902 //            ["u32", "client_index"],
2903 //            ["u32", "context"],
2904 //            ["u8", "is_add"],
2905 //            ["u8", "ipv"],
2906 //            ["u8", "l4_protocol"],
2907 //            ["u16", "l4_port"],
2908 //            {"crc" : "0x4559c976"}
2909 //        ],
2910 //
2911 type Punt struct {
2912         IsAdd      uint8
2913         Ipv        uint8
2914         L4Protocol uint8
2915         L4Port     uint16
2916 }
2917
2918 func (*Punt) GetMessageName() string {
2919         return "punt"
2920 }
2921 func (*Punt) GetMessageType() api.MessageType {
2922         return api.RequestMessage
2923 }
2924 func (*Punt) GetCrcString() string {
2925         return "4559c976"
2926 }
2927 func NewPunt() api.Message {
2928         return &Punt{}
2929 }
2930
2931 // PuntReply represents the VPP binary API message 'punt_reply'.
2932 // Generated from 'bin_api/vpe.api.json', line 759:
2933 //
2934 //        ["punt_reply",
2935 //            ["u16", "_vl_msg_id"],
2936 //            ["u32", "context"],
2937 //            ["i32", "retval"],
2938 //            {"crc" : "0xcca27fbe"}
2939 //        ],
2940 //
2941 type PuntReply struct {
2942         Retval int32
2943 }
2944
2945 func (*PuntReply) GetMessageName() string {
2946         return "punt_reply"
2947 }
2948 func (*PuntReply) GetMessageType() api.MessageType {
2949         return api.ReplyMessage
2950 }
2951 func (*PuntReply) GetCrcString() string {
2952         return "cca27fbe"
2953 }
2954 func NewPuntReply() api.Message {
2955         return &PuntReply{}
2956 }
2957
2958 // FeatureEnableDisable represents the VPP binary API message 'feature_enable_disable'.
2959 // Generated from 'bin_api/vpe.api.json', line 765:
2960 //
2961 //        ["feature_enable_disable",
2962 //            ["u16", "_vl_msg_id"],
2963 //            ["u32", "client_index"],
2964 //            ["u32", "context"],
2965 //            ["u32", "sw_if_index"],
2966 //            ["u8", "enable"],
2967 //            ["u8", "arc_name", 64],
2968 //            ["u8", "feature_name", 64],
2969 //            {"crc" : "0xbc86393b"}
2970 //        ],
2971 //
2972 type FeatureEnableDisable struct {
2973         SwIfIndex   uint32
2974         Enable      uint8
2975         ArcName     []byte `struc:"[64]byte"`
2976         FeatureName []byte `struc:"[64]byte"`
2977 }
2978
2979 func (*FeatureEnableDisable) GetMessageName() string {
2980         return "feature_enable_disable"
2981 }
2982 func (*FeatureEnableDisable) GetMessageType() api.MessageType {
2983         return api.RequestMessage
2984 }
2985 func (*FeatureEnableDisable) GetCrcString() string {
2986         return "bc86393b"
2987 }
2988 func NewFeatureEnableDisable() api.Message {
2989         return &FeatureEnableDisable{}
2990 }
2991
2992 // FeatureEnableDisableReply represents the VPP binary API message 'feature_enable_disable_reply'.
2993 // Generated from 'bin_api/vpe.api.json', line 775:
2994 //
2995 //        ["feature_enable_disable_reply",
2996 //            ["u16", "_vl_msg_id"],
2997 //            ["u32", "context"],
2998 //            ["i32", "retval"],
2999 //            {"crc" : "0xf6e14373"}
3000 //        ]
3001 //
3002 type FeatureEnableDisableReply struct {
3003         Retval int32
3004 }
3005
3006 func (*FeatureEnableDisableReply) GetMessageName() string {
3007         return "feature_enable_disable_reply"
3008 }
3009 func (*FeatureEnableDisableReply) GetMessageType() api.MessageType {
3010         return api.ReplyMessage
3011 }
3012 func (*FeatureEnableDisableReply) GetCrcString() string {
3013         return "f6e14373"
3014 }
3015 func NewFeatureEnableDisableReply() api.Message {
3016         return &FeatureEnableDisableReply{}
3017 }