core/bin_api/vpe/vpe.go

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