examples/bin_api/interfaces/interfaces.go

   1 // Code generated by govpp binapi-generator DO NOT EDIT.
   2 // Package interfaces represents the VPP binary API of the 'interfaces' VPP module.
   3 // Generated from '../../bin_api/interface.api.json'
   4 package interfaces
   5
   6 import "git.fd.io/govpp.git/api"
   7
   8 // VlApiVersion contains version of the API.
   9 const VlAPIVersion = 0x2a74f256
  10
  11 // VlibCounter represents the VPP binary API data type 'vlib_counter'.
  12 // Generated from '../../bin_api/interface.api.json', line 3:
  13 //
  14 //        ["vlib_counter",
  15 //            ["u64", "packets"],
  16 //            ["u64", "bytes"],
  17 //            {"crc" : "0x62db67f0"}
  18 //        ],
  19 //
  20 type VlibCounter struct {
  21         Packets uint64
  22         Bytes   uint64
  23 }
  24
  25 func (*VlibCounter) GetTypeName() string {
  26         return "vlib_counter"
  27 }
  28 func (*VlibCounter) GetCrcString() string {
  29         return "62db67f0"
  30 }
  31
  32 // VnetCombinedCounter represents the VPP binary API data type 'vnet_combined_counter'.
  33 // Generated from '../../bin_api/interface.api.json', line 8:
  34 //
  35 //        ["vnet_combined_counter",
  36 //            ["u32", "sw_if_index"],
  37 //            ["u64", "rx_packets"],
  38 //            ["u64", "rx_bytes"],
  39 //            ["u64", "tx_packets"],
  40 //            ["u64", "tx_bytes"],
  41 //            {"crc" : "0x0f3c951b"}
  42 //        ],
  43 //
  44 type VnetCombinedCounter struct {
  45         SwIfIndex uint32
  46         RxPackets uint64
  47         RxBytes   uint64
  48         TxPackets uint64
  49         TxBytes   uint64
  50 }
  51
  52 func (*VnetCombinedCounter) GetTypeName() string {
  53         return "vnet_combined_counter"
  54 }
  55 func (*VnetCombinedCounter) GetCrcString() string {
  56         return "0f3c951b"
  57 }
  58
  59 // VnetSimpleCounter represents the VPP binary API data type 'vnet_simple_counter'.
  60 // Generated from '../../bin_api/interface.api.json', line 16:
  61 //
  62 //        ["vnet_simple_counter",
  63 //            ["u32", "sw_if_index"],
  64 //            ["u64", "drop"],
  65 //            ["u64", "punt"],
  66 //            ["u64", "rx_ip4"],
  67 //            ["u64", "rx_ip6"],
  68 //            ["u64", "rx_no_buffer"],
  69 //            ["u64", "rx_miss"],
  70 //            ["u64", "rx_error"],
  71 //            ["u64", "tx_error"],
  72 //            ["u64", "rx_mpls"],
  73 //            {"crc" : "0x84763938"}
  74 //        ]
  75 //
  76 type VnetSimpleCounter struct {
  77         SwIfIndex  uint32
  78         Drop       uint64
  79         Punt       uint64
  80         RxIP4      uint64
  81         RxIP6      uint64
  82         RxNoBuffer uint64
  83         RxMiss     uint64
  84         RxError    uint64
  85         TxError    uint64
  86         RxMpls     uint64
  87 }
  88
  89 func (*VnetSimpleCounter) GetTypeName() string {
  90         return "vnet_simple_counter"
  91 }
  92 func (*VnetSimpleCounter) GetCrcString() string {
  93         return "84763938"
  94 }
  95
  96 // SwInterfaceSetFlags represents the VPP binary API message 'sw_interface_set_flags'.
  97 // Generated from '../../bin_api/interface.api.json', line 31:
  98 //
  99 //        ["sw_interface_set_flags",
 100 //            ["u16", "_vl_msg_id"],
 101 //            ["u32", "client_index"],
 102 //            ["u32", "context"],
 103 //            ["u32", "sw_if_index"],
 104 //            ["u8", "admin_up_down"],
 105 //            {"crc" : "0xf890584a"}
 106 //        ],
 107 //
 108 type SwInterfaceSetFlags struct {
 109         SwIfIndex   uint32
 110         AdminUpDown uint8
 111 }
 112
 113 func (*SwInterfaceSetFlags) GetMessageName() string {
 114         return "sw_interface_set_flags"
 115 }
 116 func (*SwInterfaceSetFlags) GetMessageType() api.MessageType {
 117         return api.RequestMessage
 118 }
 119 func (*SwInterfaceSetFlags) GetCrcString() string {
 120         return "f890584a"
 121 }
 122 func NewSwInterfaceSetFlags() api.Message {
 123         return &SwInterfaceSetFlags{}
 124 }
 125
 126 // SwInterfaceSetFlagsReply represents the VPP binary API message 'sw_interface_set_flags_reply'.
 127 // Generated from '../../bin_api/interface.api.json', line 39:
 128 //
 129 //        ["sw_interface_set_flags_reply",
 130 //            ["u16", "_vl_msg_id"],
 131 //            ["u32", "context"],
 132 //            ["i32", "retval"],
 133 //            {"crc" : "0xdfbf3afa"}
 134 //        ],
 135 //
 136 type SwInterfaceSetFlagsReply struct {
 137         Retval int32
 138 }
 139
 140 func (*SwInterfaceSetFlagsReply) GetMessageName() string {
 141         return "sw_interface_set_flags_reply"
 142 }
 143 func (*SwInterfaceSetFlagsReply) GetMessageType() api.MessageType {
 144         return api.ReplyMessage
 145 }
 146 func (*SwInterfaceSetFlagsReply) GetCrcString() string {
 147         return "dfbf3afa"
 148 }
 149 func NewSwInterfaceSetFlagsReply() api.Message {
 150         return &SwInterfaceSetFlagsReply{}
 151 }
 152
 153 // SwInterfaceSetMtu represents the VPP binary API message 'sw_interface_set_mtu'.
 154 // Generated from '../../bin_api/interface.api.json', line 45:
 155 //
 156 //        ["sw_interface_set_mtu",
 157 //            ["u16", "_vl_msg_id"],
 158 //            ["u32", "client_index"],
 159 //            ["u32", "context"],
 160 //            ["u32", "sw_if_index"],
 161 //            ["u16", "mtu"],
 162 //            {"crc" : "0x535dab1d"}
 163 //        ],
 164 //
 165 type SwInterfaceSetMtu struct {
 166         SwIfIndex uint32
 167         Mtu       uint16
 168 }
 169
 170 func (*SwInterfaceSetMtu) GetMessageName() string {
 171         return "sw_interface_set_mtu"
 172 }
 173 func (*SwInterfaceSetMtu) GetMessageType() api.MessageType {
 174         return api.RequestMessage
 175 }
 176 func (*SwInterfaceSetMtu) GetCrcString() string {
 177         return "535dab1d"
 178 }
 179 func NewSwInterfaceSetMtu() api.Message {
 180         return &SwInterfaceSetMtu{}
 181 }
 182
 183 // SwInterfaceSetMtuReply represents the VPP binary API message 'sw_interface_set_mtu_reply'.
 184 // Generated from '../../bin_api/interface.api.json', line 53:
 185 //
 186 //        ["sw_interface_set_mtu_reply",
 187 //            ["u16", "_vl_msg_id"],
 188 //            ["u32", "context"],
 189 //            ["i32", "retval"],
 190 //            {"crc" : "0x0cc22552"}
 191 //        ],
 192 //
 193 type SwInterfaceSetMtuReply struct {
 194         Retval int32
 195 }
 196
 197 func (*SwInterfaceSetMtuReply) GetMessageName() string {
 198         return "sw_interface_set_mtu_reply"
 199 }
 200 func (*SwInterfaceSetMtuReply) GetMessageType() api.MessageType {
 201         return api.ReplyMessage
 202 }
 203 func (*SwInterfaceSetMtuReply) GetCrcString() string {
 204         return "0cc22552"
 205 }
 206 func NewSwInterfaceSetMtuReply() api.Message {
 207         return &SwInterfaceSetMtuReply{}
 208 }
 209
 210 // SwInterfaceEvent represents the VPP binary API message 'sw_interface_event'.
 211 // Generated from '../../bin_api/interface.api.json', line 59:
 212 //
 213 //        ["sw_interface_event",
 214 //            ["u16", "_vl_msg_id"],
 215 //            ["u32", "client_index"],
 216 //            ["u32", "pid"],
 217 //            ["u32", "sw_if_index"],
 218 //            ["u8", "admin_up_down"],
 219 //            ["u8", "link_up_down"],
 220 //            ["u8", "deleted"],
 221 //            {"crc" : "0xbf7f46f2"}
 222 //        ],
 223 //
 224 type SwInterfaceEvent struct {
 225         Pid         uint32
 226         SwIfIndex   uint32
 227         AdminUpDown uint8
 228         LinkUpDown  uint8
 229         Deleted     uint8
 230 }
 231
 232 func (*SwInterfaceEvent) GetMessageName() string {
 233         return "sw_interface_event"
 234 }
 235 func (*SwInterfaceEvent) GetMessageType() api.MessageType {
 236         return api.EventMessage
 237 }
 238 func (*SwInterfaceEvent) GetCrcString() string {
 239         return "bf7f46f2"
 240 }
 241 func NewSwInterfaceEvent() api.Message {
 242         return &SwInterfaceEvent{}
 243 }
 244
 245 // WantInterfaceEvents represents the VPP binary API message 'want_interface_events'.
 246 // Generated from '../../bin_api/interface.api.json', line 69:
 247 //
 248 //        ["want_interface_events",
 249 //            ["u16", "_vl_msg_id"],
 250 //            ["u32", "client_index"],
 251 //            ["u32", "context"],
 252 //            ["u32", "enable_disable"],
 253 //            ["u32", "pid"],
 254 //            {"crc" : "0xa0cbf57e"}
 255 //        ],
 256 //
 257 type WantInterfaceEvents struct {
 258         EnableDisable uint32
 259         Pid           uint32
 260 }
 261
 262 func (*WantInterfaceEvents) GetMessageName() string {
 263         return "want_interface_events"
 264 }
 265 func (*WantInterfaceEvents) GetMessageType() api.MessageType {
 266         return api.RequestMessage
 267 }
 268 func (*WantInterfaceEvents) GetCrcString() string {
 269         return "a0cbf57e"
 270 }
 271 func NewWantInterfaceEvents() api.Message {
 272         return &WantInterfaceEvents{}
 273 }
 274
 275 // WantInterfaceEventsReply represents the VPP binary API message 'want_interface_events_reply'.
 276 // Generated from '../../bin_api/interface.api.json', line 77:
 277 //
 278 //        ["want_interface_events_reply",
 279 //            ["u16", "_vl_msg_id"],
 280 //            ["u32", "context"],
 281 //            ["i32", "retval"],
 282 //            {"crc" : "0x33788c73"}
 283 //        ],
 284 //
 285 type WantInterfaceEventsReply struct {
 286         Retval int32
 287 }
 288
 289 func (*WantInterfaceEventsReply) GetMessageName() string {
 290         return "want_interface_events_reply"
 291 }
 292 func (*WantInterfaceEventsReply) GetMessageType() api.MessageType {
 293         return api.ReplyMessage
 294 }
 295 func (*WantInterfaceEventsReply) GetCrcString() string {
 296         return "33788c73"
 297 }
 298 func NewWantInterfaceEventsReply() api.Message {
 299         return &WantInterfaceEventsReply{}
 300 }
 301
 302 // SwInterfaceDetails represents the VPP binary API message 'sw_interface_details'.
 303 // Generated from '../../bin_api/interface.api.json', line 83:
 304 //
 305 //        ["sw_interface_details",
 306 //            ["u16", "_vl_msg_id"],
 307 //            ["u32", "context"],
 308 //            ["u32", "sw_if_index"],
 309 //            ["u32", "sup_sw_if_index"],
 310 //            ["u32", "l2_address_length"],
 311 //            ["u8", "l2_address", 8],
 312 //            ["u8", "interface_name", 64],
 313 //            ["u8", "admin_up_down"],
 314 //            ["u8", "link_up_down"],
 315 //            ["u8", "link_duplex"],
 316 //            ["u8", "link_speed"],
 317 //            ["u16", "link_mtu"],
 318 //            ["u32", "sub_id"],
 319 //            ["u8", "sub_dot1ad"],
 320 //            ["u8", "sub_dot1ah"],
 321 //            ["u8", "sub_number_of_tags"],
 322 //            ["u16", "sub_outer_vlan_id"],
 323 //            ["u16", "sub_inner_vlan_id"],
 324 //            ["u8", "sub_exact_match"],
 325 //            ["u8", "sub_default"],
 326 //            ["u8", "sub_outer_vlan_id_any"],
 327 //            ["u8", "sub_inner_vlan_id_any"],
 328 //            ["u32", "vtr_op"],
 329 //            ["u32", "vtr_push_dot1q"],
 330 //            ["u32", "vtr_tag1"],
 331 //            ["u32", "vtr_tag2"],
 332 //            ["u8", "tag", 64],
 333 //            ["u16", "outer_tag"],
 334 //            ["u8", "b_dmac", 6],
 335 //            ["u8", "b_smac", 6],
 336 //            ["u16", "b_vlanid"],
 337 //            ["u32", "i_sid"],
 338 //            {"crc" : "0xe2d855bb"}
 339 //        ],
 340 //
 341 type SwInterfaceDetails struct {
 342         SwIfIndex         uint32
 343         SupSwIfIndex      uint32
 344         L2AddressLength   uint32
 345         L2Address         []byte `struc:"[8]byte"`
 346         InterfaceName     []byte `struc:"[64]byte"`
 347         AdminUpDown       uint8
 348         LinkUpDown        uint8
 349         LinkDuplex        uint8
 350         LinkSpeed         uint8
 351         LinkMtu           uint16
 352         SubID             uint32
 353         SubDot1ad         uint8
 354         SubDot1ah         uint8
 355         SubNumberOfTags   uint8
 356         SubOuterVlanID    uint16
 357         SubInnerVlanID    uint16
 358         SubExactMatch     uint8
 359         SubDefault        uint8
 360         SubOuterVlanIDAny uint8
 361         SubInnerVlanIDAny uint8
 362         VtrOp             uint32
 363         VtrPushDot1q      uint32
 364         VtrTag1           uint32
 365         VtrTag2           uint32
 366         Tag               []byte `struc:"[64]byte"`
 367         OuterTag          uint16
 368         BDmac             []byte `struc:"[6]byte"`
 369         BSmac             []byte `struc:"[6]byte"`
 370         BVlanid           uint16
 371         ISid              uint32
 372 }
 373
 374 func (*SwInterfaceDetails) GetMessageName() string {
 375         return "sw_interface_details"
 376 }
 377 func (*SwInterfaceDetails) GetMessageType() api.MessageType {
 378         return api.ReplyMessage
 379 }
 380 func (*SwInterfaceDetails) GetCrcString() string {
 381         return "e2d855bb"
 382 }
 383 func NewSwInterfaceDetails() api.Message {
 384         return &SwInterfaceDetails{}
 385 }
 386
 387 // SwInterfaceDump represents the VPP binary API message 'sw_interface_dump'.
 388 // Generated from '../../bin_api/interface.api.json', line 118:
 389 //
 390 //        ["sw_interface_dump",
 391 //            ["u16", "_vl_msg_id"],
 392 //            ["u32", "client_index"],
 393 //            ["u32", "context"],
 394 //            ["u8", "name_filter_valid"],
 395 //            ["u8", "name_filter", 49],
 396 //            {"crc" : "0x9a2f9d4d"}
 397 //        ],
 398 //
 399 type SwInterfaceDump struct {
 400         NameFilterValid uint8
 401         NameFilter      []byte `struc:"[49]byte"`
 402 }
 403
 404 func (*SwInterfaceDump) GetMessageName() string {
 405         return "sw_interface_dump"
 406 }
 407 func (*SwInterfaceDump) GetMessageType() api.MessageType {
 408         return api.RequestMessage
 409 }
 410 func (*SwInterfaceDump) GetCrcString() string {
 411         return "9a2f9d4d"
 412 }
 413 func NewSwInterfaceDump() api.Message {
 414         return &SwInterfaceDump{}
 415 }
 416
 417 // SwInterfaceAddDelAddress represents the VPP binary API message 'sw_interface_add_del_address'.
 418 // Generated from '../../bin_api/interface.api.json', line 126:
 419 //
 420 //        ["sw_interface_add_del_address",
 421 //            ["u16", "_vl_msg_id"],
 422 //            ["u32", "client_index"],
 423 //            ["u32", "context"],
 424 //            ["u32", "sw_if_index"],
 425 //            ["u8", "is_add"],
 426 //            ["u8", "is_ipv6"],
 427 //            ["u8", "del_all"],
 428 //            ["u8", "address_length"],
 429 //            ["u8", "address", 16],
 430 //            {"crc" : "0x4e24d2df"}
 431 //        ],
 432 //
 433 type SwInterfaceAddDelAddress struct {
 434         SwIfIndex     uint32
 435         IsAdd         uint8
 436         IsIpv6        uint8
 437         DelAll        uint8
 438         AddressLength uint8
 439         Address       []byte `struc:"[16]byte"`
 440 }
 441
 442 func (*SwInterfaceAddDelAddress) GetMessageName() string {
 443         return "sw_interface_add_del_address"
 444 }
 445 func (*SwInterfaceAddDelAddress) GetMessageType() api.MessageType {
 446         return api.RequestMessage
 447 }
 448 func (*SwInterfaceAddDelAddress) GetCrcString() string {
 449         return "4e24d2df"
 450 }
 451 func NewSwInterfaceAddDelAddress() api.Message {
 452         return &SwInterfaceAddDelAddress{}
 453 }
 454
 455 // SwInterfaceAddDelAddressReply represents the VPP binary API message 'sw_interface_add_del_address_reply'.
 456 // Generated from '../../bin_api/interface.api.json', line 138:
 457 //
 458 //        ["sw_interface_add_del_address_reply",
 459 //            ["u16", "_vl_msg_id"],
 460 //            ["u32", "context"],
 461 //            ["i32", "retval"],
 462 //            {"crc" : "0xabe29452"}
 463 //        ],
 464 //
 465 type SwInterfaceAddDelAddressReply struct {
 466         Retval int32
 467 }
 468
 469 func (*SwInterfaceAddDelAddressReply) GetMessageName() string {
 470         return "sw_interface_add_del_address_reply"
 471 }
 472 func (*SwInterfaceAddDelAddressReply) GetMessageType() api.MessageType {
 473         return api.ReplyMessage
 474 }
 475 func (*SwInterfaceAddDelAddressReply) GetCrcString() string {
 476         return "abe29452"
 477 }
 478 func NewSwInterfaceAddDelAddressReply() api.Message {
 479         return &SwInterfaceAddDelAddressReply{}
 480 }
 481
 482 // SwInterfaceSetTable represents the VPP binary API message 'sw_interface_set_table'.
 483 // Generated from '../../bin_api/interface.api.json', line 144:
 484 //
 485 //        ["sw_interface_set_table",
 486 //            ["u16", "_vl_msg_id"],
 487 //            ["u32", "client_index"],
 488 //            ["u32", "context"],
 489 //            ["u32", "sw_if_index"],
 490 //            ["u8", "is_ipv6"],
 491 //            ["u32", "vrf_id"],
 492 //            {"crc" : "0xa94df510"}
 493 //        ],
 494 //
 495 type SwInterfaceSetTable struct {
 496         SwIfIndex uint32
 497         IsIpv6    uint8
 498         VrfID     uint32
 499 }
 500
 501 func (*SwInterfaceSetTable) GetMessageName() string {
 502         return "sw_interface_set_table"
 503 }
 504 func (*SwInterfaceSetTable) GetMessageType() api.MessageType {
 505         return api.RequestMessage
 506 }
 507 func (*SwInterfaceSetTable) GetCrcString() string {
 508         return "a94df510"
 509 }
 510 func NewSwInterfaceSetTable() api.Message {
 511         return &SwInterfaceSetTable{}
 512 }
 513
 514 // SwInterfaceSetTableReply represents the VPP binary API message 'sw_interface_set_table_reply'.
 515 // Generated from '../../bin_api/interface.api.json', line 153:
 516 //
 517 //        ["sw_interface_set_table_reply",
 518 //            ["u16", "_vl_msg_id"],
 519 //            ["u32", "context"],
 520 //            ["i32", "retval"],
 521 //            {"crc" : "0x99df273c"}
 522 //        ],
 523 //
 524 type SwInterfaceSetTableReply struct {
 525         Retval int32
 526 }
 527
 528 func (*SwInterfaceSetTableReply) GetMessageName() string {
 529         return "sw_interface_set_table_reply"
 530 }
 531 func (*SwInterfaceSetTableReply) GetMessageType() api.MessageType {
 532         return api.ReplyMessage
 533 }
 534 func (*SwInterfaceSetTableReply) GetCrcString() string {
 535         return "99df273c"
 536 }
 537 func NewSwInterfaceSetTableReply() api.Message {
 538         return &SwInterfaceSetTableReply{}
 539 }
 540
 541 // SwInterfaceGetTable represents the VPP binary API message 'sw_interface_get_table'.
 542 // Generated from '../../bin_api/interface.api.json', line 159:
 543 //
 544 //        ["sw_interface_get_table",
 545 //            ["u16", "_vl_msg_id"],
 546 //            ["u32", "client_index"],
 547 //            ["u32", "context"],
 548 //            ["u32", "sw_if_index"],
 549 //            ["u8", "is_ipv6"],
 550 //            {"crc" : "0xf5a1d557"}
 551 //        ],
 552 //
 553 type SwInterfaceGetTable struct {
 554         SwIfIndex uint32
 555         IsIpv6    uint8
 556 }
 557
 558 func (*SwInterfaceGetTable) GetMessageName() string {
 559         return "sw_interface_get_table"
 560 }
 561 func (*SwInterfaceGetTable) GetMessageType() api.MessageType {
 562         return api.RequestMessage
 563 }
 564 func (*SwInterfaceGetTable) GetCrcString() string {
 565         return "f5a1d557"
 566 }
 567 func NewSwInterfaceGetTable() api.Message {
 568         return &SwInterfaceGetTable{}
 569 }
 570
 571 // SwInterfaceGetTableReply represents the VPP binary API message 'sw_interface_get_table_reply'.
 572 // Generated from '../../bin_api/interface.api.json', line 167:
 573 //
 574 //        ["sw_interface_get_table_reply",
 575 //            ["u16", "_vl_msg_id"],
 576 //            ["u32", "context"],
 577 //            ["i32", "retval"],
 578 //            ["u32", "vrf_id"],
 579 //            {"crc" : "0xab44111d"}
 580 //        ],
 581 //
 582 type SwInterfaceGetTableReply struct {
 583         Retval int32
 584         VrfID  uint32
 585 }
 586
 587 func (*SwInterfaceGetTableReply) GetMessageName() string {
 588         return "sw_interface_get_table_reply"
 589 }
 590 func (*SwInterfaceGetTableReply) GetMessageType() api.MessageType {
 591         return api.ReplyMessage
 592 }
 593 func (*SwInterfaceGetTableReply) GetCrcString() string {
 594         return "ab44111d"
 595 }
 596 func NewSwInterfaceGetTableReply() api.Message {
 597         return &SwInterfaceGetTableReply{}
 598 }
 599
 600 // VnetInterfaceSimpleCounters represents the VPP binary API message 'vnet_interface_simple_counters'.
 601 // Generated from '../../bin_api/interface.api.json', line 174:
 602 //
 603 //        ["vnet_interface_simple_counters",
 604 //            ["u16", "_vl_msg_id"],
 605 //            ["u8", "vnet_counter_type"],
 606 //            ["u32", "first_sw_if_index"],
 607 //            ["u32", "count"],
 608 //            ["u64", "data", 0, "count"],
 609 //            {"crc" : "0x302f0983"}
 610 //        ],
 611 //
 612 type VnetInterfaceSimpleCounters struct {
 613         VnetCounterType uint8
 614         FirstSwIfIndex  uint32
 615         Count           uint32 `struc:"sizeof=Data"`
 616         Data            []uint64
 617 }
 618
 619 func (*VnetInterfaceSimpleCounters) GetMessageName() string {
 620         return "vnet_interface_simple_counters"
 621 }
 622 func (*VnetInterfaceSimpleCounters) GetMessageType() api.MessageType {
 623         return api.OtherMessage
 624 }
 625 func (*VnetInterfaceSimpleCounters) GetCrcString() string {
 626         return "302f0983"
 627 }
 628 func NewVnetInterfaceSimpleCounters() api.Message {
 629         return &VnetInterfaceSimpleCounters{}
 630 }
 631
 632 // VnetInterfaceCombinedCounters represents the VPP binary API message 'vnet_interface_combined_counters'.
 633 // Generated from '../../bin_api/interface.api.json', line 182:
 634 //
 635 //        ["vnet_interface_combined_counters",
 636 //            ["u16", "_vl_msg_id"],
 637 //            ["u8", "vnet_counter_type"],
 638 //            ["u32", "first_sw_if_index"],
 639 //            ["u32", "count"],
 640 //            ["vl_api_vlib_counter_t", "data", 0, "count"],
 641 //            {"crc" : "0xd82426e3"}
 642 //        ],
 643 //
 644 type VnetInterfaceCombinedCounters struct {
 645         VnetCounterType uint8
 646         FirstSwIfIndex  uint32
 647         Count           uint32 `struc:"sizeof=Data"`
 648         Data            []VlibCounter
 649 }
 650
 651 func (*VnetInterfaceCombinedCounters) GetMessageName() string {
 652         return "vnet_interface_combined_counters"
 653 }
 654 func (*VnetInterfaceCombinedCounters) GetMessageType() api.MessageType {
 655         return api.OtherMessage
 656 }
 657 func (*VnetInterfaceCombinedCounters) GetCrcString() string {
 658         return "d82426e3"
 659 }
 660 func NewVnetInterfaceCombinedCounters() api.Message {
 661         return &VnetInterfaceCombinedCounters{}
 662 }
 663
 664 // VnetPerInterfaceSimpleCounters represents the VPP binary API message 'vnet_per_interface_simple_counters'.
 665 // Generated from '../../bin_api/interface.api.json', line 190:
 666 //
 667 //        ["vnet_per_interface_simple_counters",
 668 //            ["u16", "_vl_msg_id"],
 669 //            ["u32", "count"],
 670 //            ["u32", "timestamp"],
 671 //            ["vl_api_vnet_simple_counter_t", "data", 0, "count"],
 672 //            {"crc" : "0x7df05633"}
 673 //        ],
 674 //
 675 type VnetPerInterfaceSimpleCounters struct {
 676         Count     uint32 `struc:"sizeof=Data"`
 677         Timestamp uint32
 678         Data      []VnetSimpleCounter
 679 }
 680
 681 func (*VnetPerInterfaceSimpleCounters) GetMessageName() string {
 682         return "vnet_per_interface_simple_counters"
 683 }
 684 func (*VnetPerInterfaceSimpleCounters) GetMessageType() api.MessageType {
 685         return api.OtherMessage
 686 }
 687 func (*VnetPerInterfaceSimpleCounters) GetCrcString() string {
 688         return "7df05633"
 689 }
 690 func NewVnetPerInterfaceSimpleCounters() api.Message {
 691         return &VnetPerInterfaceSimpleCounters{}
 692 }
 693
 694 // VnetPerInterfaceCombinedCounters represents the VPP binary API message 'vnet_per_interface_combined_counters'.
 695 // Generated from '../../bin_api/interface.api.json', line 197:
 696 //
 697 //        ["vnet_per_interface_combined_counters",
 698 //            ["u16", "_vl_msg_id"],
 699 //            ["u32", "count"],
 700 //            ["u32", "timestamp"],
 701 //            ["vl_api_vnet_combined_counter_t", "data", 0, "count"],
 702 //            {"crc" : "0xbf35dfbe"}
 703 //        ],
 704 //
 705 type VnetPerInterfaceCombinedCounters struct {
 706         Count     uint32 `struc:"sizeof=Data"`
 707         Timestamp uint32
 708         Data      []VnetCombinedCounter
 709 }
 710
 711 func (*VnetPerInterfaceCombinedCounters) GetMessageName() string {
 712         return "vnet_per_interface_combined_counters"
 713 }
 714 func (*VnetPerInterfaceCombinedCounters) GetMessageType() api.MessageType {
 715         return api.OtherMessage
 716 }
 717 func (*VnetPerInterfaceCombinedCounters) GetCrcString() string {
 718         return "bf35dfbe"
 719 }
 720 func NewVnetPerInterfaceCombinedCounters() api.Message {
 721         return &VnetPerInterfaceCombinedCounters{}
 722 }
 723
 724 // SwInterfaceSetUnnumbered represents the VPP binary API message 'sw_interface_set_unnumbered'.
 725 // Generated from '../../bin_api/interface.api.json', line 204:
 726 //
 727 //        ["sw_interface_set_unnumbered",
 728 //            ["u16", "_vl_msg_id"],
 729 //            ["u32", "client_index"],
 730 //            ["u32", "context"],
 731 //            ["u32", "sw_if_index"],
 732 //            ["u32", "unnumbered_sw_if_index"],
 733 //            ["u8", "is_add"],
 734 //            {"crc" : "0xee0047b0"}
 735 //        ],
 736 //
 737 type SwInterfaceSetUnnumbered struct {
 738         SwIfIndex           uint32
 739         UnnumberedSwIfIndex uint32
 740         IsAdd               uint8
 741 }
 742
 743 func (*SwInterfaceSetUnnumbered) GetMessageName() string {
 744         return "sw_interface_set_unnumbered"
 745 }
 746 func (*SwInterfaceSetUnnumbered) GetMessageType() api.MessageType {
 747         return api.RequestMessage
 748 }
 749 func (*SwInterfaceSetUnnumbered) GetCrcString() string {
 750         return "ee0047b0"
 751 }
 752 func NewSwInterfaceSetUnnumbered() api.Message {
 753         return &SwInterfaceSetUnnumbered{}
 754 }
 755
 756 // SwInterfaceSetUnnumberedReply represents the VPP binary API message 'sw_interface_set_unnumbered_reply'.
 757 // Generated from '../../bin_api/interface.api.json', line 213:
 758 //
 759 //        ["sw_interface_set_unnumbered_reply",
 760 //            ["u16", "_vl_msg_id"],
 761 //            ["u32", "context"],
 762 //            ["i32", "retval"],
 763 //            {"crc" : "0x5b2275e1"}
 764 //        ],
 765 //
 766 type SwInterfaceSetUnnumberedReply struct {
 767         Retval int32
 768 }
 769
 770 func (*SwInterfaceSetUnnumberedReply) GetMessageName() string {
 771         return "sw_interface_set_unnumbered_reply"
 772 }
 773 func (*SwInterfaceSetUnnumberedReply) GetMessageType() api.MessageType {
 774         return api.ReplyMessage
 775 }
 776 func (*SwInterfaceSetUnnumberedReply) GetCrcString() string {
 777         return "5b2275e1"
 778 }
 779 func NewSwInterfaceSetUnnumberedReply() api.Message {
 780         return &SwInterfaceSetUnnumberedReply{}
 781 }
 782
 783 // SwInterfaceClearStats represents the VPP binary API message 'sw_interface_clear_stats'.
 784 // Generated from '../../bin_api/interface.api.json', line 219:
 785 //
 786 //        ["sw_interface_clear_stats",
 787 //            ["u16", "_vl_msg_id"],
 788 //            ["u32", "client_index"],
 789 //            ["u32", "context"],
 790 //            ["u32", "sw_if_index"],
 791 //            {"crc" : "0x9600fd50"}
 792 //        ],
 793 //
 794 type SwInterfaceClearStats struct {
 795         SwIfIndex uint32
 796 }
 797
 798 func (*SwInterfaceClearStats) GetMessageName() string {
 799         return "sw_interface_clear_stats"
 800 }
 801 func (*SwInterfaceClearStats) GetMessageType() api.MessageType {
 802         return api.RequestMessage
 803 }
 804 func (*SwInterfaceClearStats) GetCrcString() string {
 805         return "9600fd50"
 806 }
 807 func NewSwInterfaceClearStats() api.Message {
 808         return &SwInterfaceClearStats{}
 809 }
 810
 811 // SwInterfaceClearStatsReply represents the VPP binary API message 'sw_interface_clear_stats_reply'.
 812 // Generated from '../../bin_api/interface.api.json', line 226:
 813 //
 814 //        ["sw_interface_clear_stats_reply",
 815 //            ["u16", "_vl_msg_id"],
 816 //            ["u32", "context"],
 817 //            ["i32", "retval"],
 818 //            {"crc" : "0x21f50dd9"}
 819 //        ],
 820 //
 821 type SwInterfaceClearStatsReply struct {
 822         Retval int32
 823 }
 824
 825 func (*SwInterfaceClearStatsReply) GetMessageName() string {
 826         return "sw_interface_clear_stats_reply"
 827 }
 828 func (*SwInterfaceClearStatsReply) GetMessageType() api.MessageType {
 829         return api.ReplyMessage
 830 }
 831 func (*SwInterfaceClearStatsReply) GetCrcString() string {
 832         return "21f50dd9"
 833 }
 834 func NewSwInterfaceClearStatsReply() api.Message {
 835         return &SwInterfaceClearStatsReply{}
 836 }
 837
 838 // SwInterfaceTagAddDel represents the VPP binary API message 'sw_interface_tag_add_del'.
 839 // Generated from '../../bin_api/interface.api.json', line 232:
 840 //
 841 //        ["sw_interface_tag_add_del",
 842 //            ["u16", "_vl_msg_id"],
 843 //            ["u32", "client_index"],
 844 //            ["u32", "context"],
 845 //            ["u8", "is_add"],
 846 //            ["u32", "sw_if_index"],
 847 //            ["u8", "tag", 64],
 848 //            {"crc" : "0x50ae8d92"}
 849 //        ],
 850 //
 851 type SwInterfaceTagAddDel struct {
 852         IsAdd     uint8
 853         SwIfIndex uint32
 854         Tag       []byte `struc:"[64]byte"`
 855 }
 856
 857 func (*SwInterfaceTagAddDel) GetMessageName() string {
 858         return "sw_interface_tag_add_del"
 859 }
 860 func (*SwInterfaceTagAddDel) GetMessageType() api.MessageType {
 861         return api.RequestMessage
 862 }
 863 func (*SwInterfaceTagAddDel) GetCrcString() string {
 864         return "50ae8d92"
 865 }
 866 func NewSwInterfaceTagAddDel() api.Message {
 867         return &SwInterfaceTagAddDel{}
 868 }
 869
 870 // SwInterfaceTagAddDelReply represents the VPP binary API message 'sw_interface_tag_add_del_reply'.
 871 // Generated from '../../bin_api/interface.api.json', line 241:
 872 //
 873 //        ["sw_interface_tag_add_del_reply",
 874 //            ["u16", "_vl_msg_id"],
 875 //            ["u32", "context"],
 876 //            ["i32", "retval"],
 877 //            {"crc" : "0x761cbcb0"}
 878 //        ],
 879 //
 880 type SwInterfaceTagAddDelReply struct {
 881         Retval int32
 882 }
 883
 884 func (*SwInterfaceTagAddDelReply) GetMessageName() string {
 885         return "sw_interface_tag_add_del_reply"
 886 }
 887 func (*SwInterfaceTagAddDelReply) GetMessageType() api.MessageType {
 888         return api.ReplyMessage
 889 }
 890 func (*SwInterfaceTagAddDelReply) GetCrcString() string {
 891         return "761cbcb0"
 892 }
 893 func NewSwInterfaceTagAddDelReply() api.Message {
 894         return &SwInterfaceTagAddDelReply{}
 895 }
 896
 897 // SwInterfaceSetMacAddress represents the VPP binary API message 'sw_interface_set_mac_address'.
 898 // Generated from '../../bin_api/interface.api.json', line 247:
 899 //
 900 //        ["sw_interface_set_mac_address",
 901 //            ["u16", "_vl_msg_id"],
 902 //            ["u32", "client_index"],
 903 //            ["u32", "context"],
 904 //            ["u32", "sw_if_index"],
 905 //            ["u8", "mac_address", 6],
 906 //            {"crc" : "0xe4f22660"}
 907 //        ],
 908 //
 909 type SwInterfaceSetMacAddress struct {
 910         SwIfIndex  uint32
 911         MacAddress []byte `struc:"[6]byte"`
 912 }
 913
 914 func (*SwInterfaceSetMacAddress) GetMessageName() string {
 915         return "sw_interface_set_mac_address"
 916 }
 917 func (*SwInterfaceSetMacAddress) GetMessageType() api.MessageType {
 918         return api.RequestMessage
 919 }
 920 func (*SwInterfaceSetMacAddress) GetCrcString() string {
 921         return "e4f22660"
 922 }
 923 func NewSwInterfaceSetMacAddress() api.Message {
 924         return &SwInterfaceSetMacAddress{}
 925 }
 926
 927 // SwInterfaceSetMacAddressReply represents the VPP binary API message 'sw_interface_set_mac_address_reply'.
 928 // Generated from '../../bin_api/interface.api.json', line 255:
 929 //
 930 //        ["sw_interface_set_mac_address_reply",
 931 //            ["u16", "_vl_msg_id"],
 932 //            ["u32", "context"],
 933 //            ["i32", "retval"],
 934 //            {"crc" : "0x9dc8a452"}
 935 //        ],
 936 //
 937 type SwInterfaceSetMacAddressReply struct {
 938         Retval int32
 939 }
 940
 941 func (*SwInterfaceSetMacAddressReply) GetMessageName() string {
 942         return "sw_interface_set_mac_address_reply"
 943 }
 944 func (*SwInterfaceSetMacAddressReply) GetMessageType() api.MessageType {
 945         return api.ReplyMessage
 946 }
 947 func (*SwInterfaceSetMacAddressReply) GetCrcString() string {
 948         return "9dc8a452"
 949 }
 950 func NewSwInterfaceSetMacAddressReply() api.Message {
 951         return &SwInterfaceSetMacAddressReply{}
 952 }
 953
 954 // SwInterfaceSetRxMode represents the VPP binary API message 'sw_interface_set_rx_mode'.
 955 // Generated from '../../bin_api/interface.api.json', line 261:
 956 //
 957 //        ["sw_interface_set_rx_mode",
 958 //            ["u16", "_vl_msg_id"],
 959 //            ["u32", "client_index"],
 960 //            ["u32", "context"],
 961 //            ["u32", "sw_if_index"],
 962 //            ["u8", "queue_id_valid"],
 963 //            ["u32", "queue_id"],
 964 //            ["u8", "mode"],
 965 //            {"crc" : "0xc5aa8dda"}
 966 //        ],
 967 //
 968 type SwInterfaceSetRxMode struct {
 969         SwIfIndex    uint32
 970         QueueIDValid uint8
 971         QueueID      uint32
 972         Mode         uint8
 973 }
 974
 975 func (*SwInterfaceSetRxMode) GetMessageName() string {
 976         return "sw_interface_set_rx_mode"
 977 }
 978 func (*SwInterfaceSetRxMode) GetMessageType() api.MessageType {
 979         return api.RequestMessage
 980 }
 981 func (*SwInterfaceSetRxMode) GetCrcString() string {
 982         return "c5aa8dda"
 983 }
 984 func NewSwInterfaceSetRxMode() api.Message {
 985         return &SwInterfaceSetRxMode{}
 986 }
 987
 988 // SwInterfaceSetRxModeReply represents the VPP binary API message 'sw_interface_set_rx_mode_reply'.
 989 // Generated from '../../bin_api/interface.api.json', line 271:
 990 //
 991 //        ["sw_interface_set_rx_mode_reply",
 992 //            ["u16", "_vl_msg_id"],
 993 //            ["u32", "context"],
 994 //            ["i32", "retval"],
 995 //            {"crc" : "0x5fc3e318"}
 996 //        ],
 997 //
 998 type SwInterfaceSetRxModeReply struct {
 999         Retval int32
1000 }
1001
1002 func (*SwInterfaceSetRxModeReply) GetMessageName() string {
1003         return "sw_interface_set_rx_mode_reply"
1004 }
1005 func (*SwInterfaceSetRxModeReply) GetMessageType() api.MessageType {
1006         return api.ReplyMessage
1007 }
1008 func (*SwInterfaceSetRxModeReply) GetCrcString() string {
1009         return "5fc3e318"
1010 }
1011 func NewSwInterfaceSetRxModeReply() api.Message {
1012         return &SwInterfaceSetRxModeReply{}
1013 }
1014
1015 // InterfaceNameRenumber represents the VPP binary API message 'interface_name_renumber'.
1016 // Generated from '../../bin_api/interface.api.json', line 277:
1017 //
1018 //        ["interface_name_renumber",
1019 //            ["u16", "_vl_msg_id"],
1020 //            ["u32", "client_index"],
1021 //            ["u32", "context"],
1022 //            ["u32", "sw_if_index"],
1023 //            ["u32", "new_show_dev_instance"],
1024 //            {"crc" : "0x11b7bcec"}
1025 //        ],
1026 //
1027 type InterfaceNameRenumber struct {
1028         SwIfIndex          uint32
1029         NewShowDevInstance uint32
1030 }
1031
1032 func (*InterfaceNameRenumber) GetMessageName() string {
1033         return "interface_name_renumber"
1034 }
1035 func (*InterfaceNameRenumber) GetMessageType() api.MessageType {
1036         return api.RequestMessage
1037 }
1038 func (*InterfaceNameRenumber) GetCrcString() string {
1039         return "11b7bcec"
1040 }
1041 func NewInterfaceNameRenumber() api.Message {
1042         return &InterfaceNameRenumber{}
1043 }
1044
1045 // InterfaceNameRenumberReply represents the VPP binary API message 'interface_name_renumber_reply'.
1046 // Generated from '../../bin_api/interface.api.json', line 285:
1047 //
1048 //        ["interface_name_renumber_reply",
1049 //            ["u16", "_vl_msg_id"],
1050 //            ["u32", "context"],
1051 //            ["i32", "retval"],
1052 //            {"crc" : "0x31594963"}
1053 //        ],
1054 //
1055 type InterfaceNameRenumberReply struct {
1056         Retval int32
1057 }
1058
1059 func (*InterfaceNameRenumberReply) GetMessageName() string {
1060         return "interface_name_renumber_reply"
1061 }
1062 func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType {
1063         return api.ReplyMessage
1064 }
1065 func (*InterfaceNameRenumberReply) GetCrcString() string {
1066         return "31594963"
1067 }
1068 func NewInterfaceNameRenumberReply() api.Message {
1069         return &InterfaceNameRenumberReply{}
1070 }
1071
1072 // CreateSubif represents the VPP binary API message 'create_subif'.
1073 // Generated from '../../bin_api/interface.api.json', line 291:
1074 //
1075 //        ["create_subif",
1076 //            ["u16", "_vl_msg_id"],
1077 //            ["u32", "client_index"],
1078 //            ["u32", "context"],
1079 //            ["u32", "sw_if_index"],
1080 //            ["u32", "sub_id"],
1081 //            ["u8", "no_tags"],
1082 //            ["u8", "one_tag"],
1083 //            ["u8", "two_tags"],
1084 //            ["u8", "dot1ad"],
1085 //            ["u8", "exact_match"],
1086 //            ["u8", "default_sub"],
1087 //            ["u8", "outer_vlan_id_any"],
1088 //            ["u8", "inner_vlan_id_any"],
1089 //            ["u16", "outer_vlan_id"],
1090 //            ["u16", "inner_vlan_id"],
1091 //            {"crc" : "0x150e6757"}
1092 //        ],
1093 //
1094 type CreateSubif struct {
1095         SwIfIndex      uint32
1096         SubID          uint32
1097         NoTags         uint8
1098         OneTag         uint8
1099         TwoTags        uint8
1100         Dot1ad         uint8
1101         ExactMatch     uint8
1102         DefaultSub     uint8
1103         OuterVlanIDAny uint8
1104         InnerVlanIDAny uint8
1105         OuterVlanID    uint16
1106         InnerVlanID    uint16
1107 }
1108
1109 func (*CreateSubif) GetMessageName() string {
1110         return "create_subif"
1111 }
1112 func (*CreateSubif) GetMessageType() api.MessageType {
1113         return api.RequestMessage
1114 }
1115 func (*CreateSubif) GetCrcString() string {
1116         return "150e6757"
1117 }
1118 func NewCreateSubif() api.Message {
1119         return &CreateSubif{}
1120 }
1121
1122 // CreateSubifReply represents the VPP binary API message 'create_subif_reply'.
1123 // Generated from '../../bin_api/interface.api.json', line 309:
1124 //
1125 //        ["create_subif_reply",
1126 //            ["u16", "_vl_msg_id"],
1127 //            ["u32", "context"],
1128 //            ["i32", "retval"],
1129 //            ["u32", "sw_if_index"],
1130 //            {"crc" : "0x92272bcb"}
1131 //        ],
1132 //
1133 type CreateSubifReply struct {
1134         Retval    int32
1135         SwIfIndex uint32
1136 }
1137
1138 func (*CreateSubifReply) GetMessageName() string {
1139         return "create_subif_reply"
1140 }
1141 func (*CreateSubifReply) GetMessageType() api.MessageType {
1142         return api.ReplyMessage
1143 }
1144 func (*CreateSubifReply) GetCrcString() string {
1145         return "92272bcb"
1146 }
1147 func NewCreateSubifReply() api.Message {
1148         return &CreateSubifReply{}
1149 }
1150
1151 // CreateVlanSubif represents the VPP binary API message 'create_vlan_subif'.
1152 // Generated from '../../bin_api/interface.api.json', line 316:
1153 //
1154 //        ["create_vlan_subif",
1155 //            ["u16", "_vl_msg_id"],
1156 //            ["u32", "client_index"],
1157 //            ["u32", "context"],
1158 //            ["u32", "sw_if_index"],
1159 //            ["u32", "vlan_id"],
1160 //            {"crc" : "0xaf9ae1e9"}
1161 //        ],
1162 //
1163 type CreateVlanSubif struct {
1164         SwIfIndex uint32
1165         VlanID    uint32
1166 }
1167
1168 func (*CreateVlanSubif) GetMessageName() string {
1169         return "create_vlan_subif"
1170 }
1171 func (*CreateVlanSubif) GetMessageType() api.MessageType {
1172         return api.RequestMessage
1173 }
1174 func (*CreateVlanSubif) GetCrcString() string {
1175         return "af9ae1e9"
1176 }
1177 func NewCreateVlanSubif() api.Message {
1178         return &CreateVlanSubif{}
1179 }
1180
1181 // CreateVlanSubifReply represents the VPP binary API message 'create_vlan_subif_reply'.
1182 // Generated from '../../bin_api/interface.api.json', line 324:
1183 //
1184 //        ["create_vlan_subif_reply",
1185 //            ["u16", "_vl_msg_id"],
1186 //            ["u32", "context"],
1187 //            ["i32", "retval"],
1188 //            ["u32", "sw_if_index"],
1189 //            {"crc" : "0x8f36b888"}
1190 //        ],
1191 //
1192 type CreateVlanSubifReply struct {
1193         Retval    int32
1194         SwIfIndex uint32
1195 }
1196
1197 func (*CreateVlanSubifReply) GetMessageName() string {
1198         return "create_vlan_subif_reply"
1199 }
1200 func (*CreateVlanSubifReply) GetMessageType() api.MessageType {
1201         return api.ReplyMessage
1202 }
1203 func (*CreateVlanSubifReply) GetCrcString() string {
1204         return "8f36b888"
1205 }
1206 func NewCreateVlanSubifReply() api.Message {
1207         return &CreateVlanSubifReply{}
1208 }
1209
1210 // DeleteSubif represents the VPP binary API message 'delete_subif'.
1211 // Generated from '../../bin_api/interface.api.json', line 331:
1212 //
1213 //        ["delete_subif",
1214 //            ["u16", "_vl_msg_id"],
1215 //            ["u32", "client_index"],
1216 //            ["u32", "context"],
1217 //            ["u32", "sw_if_index"],
1218 //            {"crc" : "0x6038f848"}
1219 //        ],
1220 //
1221 type DeleteSubif struct {
1222         SwIfIndex uint32
1223 }
1224
1225 func (*DeleteSubif) GetMessageName() string {
1226         return "delete_subif"
1227 }
1228 func (*DeleteSubif) GetMessageType() api.MessageType {
1229         return api.RequestMessage
1230 }
1231 func (*DeleteSubif) GetCrcString() string {
1232         return "6038f848"
1233 }
1234 func NewDeleteSubif() api.Message {
1235         return &DeleteSubif{}
1236 }
1237
1238 // DeleteSubifReply represents the VPP binary API message 'delete_subif_reply'.
1239 // Generated from '../../bin_api/interface.api.json', line 338:
1240 //
1241 //        ["delete_subif_reply",
1242 //            ["u16", "_vl_msg_id"],
1243 //            ["u32", "context"],
1244 //            ["i32", "retval"],
1245 //            {"crc" : "0x9d6015dc"}
1246 //        ],
1247 //
1248 type DeleteSubifReply struct {
1249         Retval int32
1250 }
1251
1252 func (*DeleteSubifReply) GetMessageName() string {
1253         return "delete_subif_reply"
1254 }
1255 func (*DeleteSubifReply) GetMessageType() api.MessageType {
1256         return api.ReplyMessage
1257 }
1258 func (*DeleteSubifReply) GetCrcString() string {
1259         return "9d6015dc"
1260 }
1261 func NewDeleteSubifReply() api.Message {
1262         return &DeleteSubifReply{}
1263 }
1264
1265 // CreateLoopback represents the VPP binary API message 'create_loopback'.
1266 // Generated from '../../bin_api/interface.api.json', line 344:
1267 //
1268 //        ["create_loopback",
1269 //            ["u16", "_vl_msg_id"],
1270 //            ["u32", "client_index"],
1271 //            ["u32", "context"],
1272 //            ["u8", "mac_address", 6],
1273 //            {"crc" : "0xb2602de5"}
1274 //        ],
1275 //
1276 type CreateLoopback struct {
1277         MacAddress []byte `struc:"[6]byte"`
1278 }
1279
1280 func (*CreateLoopback) GetMessageName() string {
1281         return "create_loopback"
1282 }
1283 func (*CreateLoopback) GetMessageType() api.MessageType {
1284         return api.RequestMessage
1285 }
1286 func (*CreateLoopback) GetCrcString() string {
1287         return "b2602de5"
1288 }
1289 func NewCreateLoopback() api.Message {
1290         return &CreateLoopback{}
1291 }
1292
1293 // CreateLoopbackReply represents the VPP binary API message 'create_loopback_reply'.
1294 // Generated from '../../bin_api/interface.api.json', line 351:
1295 //
1296 //        ["create_loopback_reply",
1297 //            ["u16", "_vl_msg_id"],
1298 //            ["u32", "context"],
1299 //            ["i32", "retval"],
1300 //            ["u32", "sw_if_index"],
1301 //            {"crc" : "0x9520f804"}
1302 //        ],
1303 //
1304 type CreateLoopbackReply struct {
1305         Retval    int32
1306         SwIfIndex uint32
1307 }
1308
1309 func (*CreateLoopbackReply) GetMessageName() string {
1310         return "create_loopback_reply"
1311 }
1312 func (*CreateLoopbackReply) GetMessageType() api.MessageType {
1313         return api.ReplyMessage
1314 }
1315 func (*CreateLoopbackReply) GetCrcString() string {
1316         return "9520f804"
1317 }
1318 func NewCreateLoopbackReply() api.Message {
1319         return &CreateLoopbackReply{}
1320 }
1321
1322 // CreateLoopbackInstance represents the VPP binary API message 'create_loopback_instance'.
1323 // Generated from '../../bin_api/interface.api.json', line 358:
1324 //
1325 //        ["create_loopback_instance",
1326 //            ["u16", "_vl_msg_id"],
1327 //            ["u32", "client_index"],
1328 //            ["u32", "context"],
1329 //            ["u8", "mac_address", 6],
1330 //            ["u8", "is_specified"],
1331 //            ["u32", "user_instance"],
1332 //            {"crc" : "0x967694f1"}
1333 //        ],
1334 //
1335 type CreateLoopbackInstance struct {
1336         MacAddress   []byte `struc:"[6]byte"`
1337         IsSpecified  uint8
1338         UserInstance uint32
1339 }
1340
1341 func (*CreateLoopbackInstance) GetMessageName() string {
1342         return "create_loopback_instance"
1343 }
1344 func (*CreateLoopbackInstance) GetMessageType() api.MessageType {
1345         return api.RequestMessage
1346 }
1347 func (*CreateLoopbackInstance) GetCrcString() string {
1348         return "967694f1"
1349 }
1350 func NewCreateLoopbackInstance() api.Message {
1351         return &CreateLoopbackInstance{}
1352 }
1353
1354 // CreateLoopbackInstanceReply represents the VPP binary API message 'create_loopback_instance_reply'.
1355 // Generated from '../../bin_api/interface.api.json', line 367:
1356 //
1357 //        ["create_loopback_instance_reply",
1358 //            ["u16", "_vl_msg_id"],
1359 //            ["u32", "context"],
1360 //            ["i32", "retval"],
1361 //            ["u32", "sw_if_index"],
1362 //            {"crc" : "0xd52c63b6"}
1363 //        ],
1364 //
1365 type CreateLoopbackInstanceReply struct {
1366         Retval    int32
1367         SwIfIndex uint32
1368 }
1369
1370 func (*CreateLoopbackInstanceReply) GetMessageName() string {
1371         return "create_loopback_instance_reply"
1372 }
1373 func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType {
1374         return api.ReplyMessage
1375 }
1376 func (*CreateLoopbackInstanceReply) GetCrcString() string {
1377         return "d52c63b6"
1378 }
1379 func NewCreateLoopbackInstanceReply() api.Message {
1380         return &CreateLoopbackInstanceReply{}
1381 }
1382
1383 // DeleteLoopback represents the VPP binary API message 'delete_loopback'.
1384 // Generated from '../../bin_api/interface.api.json', line 374:
1385 //
1386 //        ["delete_loopback",
1387 //            ["u16", "_vl_msg_id"],
1388 //            ["u32", "client_index"],
1389 //            ["u32", "context"],
1390 //            ["u32", "sw_if_index"],
1391 //            {"crc" : "0xded428b0"}
1392 //        ],
1393 //
1394 type DeleteLoopback struct {
1395         SwIfIndex uint32
1396 }
1397
1398 func (*DeleteLoopback) GetMessageName() string {
1399         return "delete_loopback"
1400 }
1401 func (*DeleteLoopback) GetMessageType() api.MessageType {
1402         return api.RequestMessage
1403 }
1404 func (*DeleteLoopback) GetCrcString() string {
1405         return "ded428b0"
1406 }
1407 func NewDeleteLoopback() api.Message {
1408         return &DeleteLoopback{}
1409 }
1410
1411 // DeleteLoopbackReply represents the VPP binary API message 'delete_loopback_reply'.
1412 // Generated from '../../bin_api/interface.api.json', line 381:
1413 //
1414 //        ["delete_loopback_reply",
1415 //            ["u16", "_vl_msg_id"],
1416 //            ["u32", "context"],
1417 //            ["i32", "retval"],
1418 //            {"crc" : "0xc91dafa5"}
1419 //        ]
1420 //
1421 type DeleteLoopbackReply struct {
1422         Retval int32
1423 }
1424
1425 func (*DeleteLoopbackReply) GetMessageName() string {
1426         return "delete_loopback_reply"
1427 }
1428 func (*DeleteLoopbackReply) GetMessageType() api.MessageType {
1429         return api.ReplyMessage
1430 }
1431 func (*DeleteLoopbackReply) GetCrcString() string {
1432         return "c91dafa5"
1433 }
1434 func NewDeleteLoopbackReply() api.Message {
1435         return &DeleteLoopbackReply{}
1436 }