examples/bin_api/interfaces/interfaces.go

   1 // Package interfaces represents the VPP binary API of the 'interfaces' VPP module.
   2 // DO NOT EDIT. Generated from 'bin_api/interface.api.json' on Fri, 21 Apr 2017 17:10:06 CEST.
   3 package interfaces
   4
   5 import "gerrit.fd.io/r/govpp/api"
   6
   7 // VlApiVersion contains version of the API.
   8 const VlAPIVersion = 0x6857f668
   9
  10 // SwInterfaceSetFlags represents the VPP binary API message 'sw_interface_set_flags'.
  11 // Generated from 'bin_api/interface.api.json', line 6:
  12 //
  13 //        ["sw_interface_set_flags",
  14 //            ["u16", "_vl_msg_id"],
  15 //            ["u32", "client_index"],
  16 //            ["u32", "context"],
  17 //            ["u32", "sw_if_index"],
  18 //            ["u8", "admin_up_down"],
  19 //            ["u8", "link_up_down"],
  20 //            ["u8", "deleted"],
  21 //            {"crc" : "0xc230f9b1"}
  22 //        ],
  23 //
  24 type SwInterfaceSetFlags struct {
  25         SwIfIndex   uint32
  26         AdminUpDown uint8
  27         LinkUpDown  uint8
  28         Deleted     uint8
  29 }
  30
  31 func (*SwInterfaceSetFlags) GetMessageName() string {
  32         return "sw_interface_set_flags"
  33 }
  34 func (*SwInterfaceSetFlags) GetMessageType() api.MessageType {
  35         return api.RequestMessage
  36 }
  37 func (*SwInterfaceSetFlags) GetCrcString() string {
  38         return "c230f9b1"
  39 }
  40 func NewSwInterfaceSetFlags() api.Message {
  41         return &SwInterfaceSetFlags{}
  42 }
  43
  44 // SwInterfaceSetFlagsReply represents the VPP binary API message 'sw_interface_set_flags_reply'.
  45 // Generated from 'bin_api/interface.api.json', line 16:
  46 //
  47 //        ["sw_interface_set_flags_reply",
  48 //            ["u16", "_vl_msg_id"],
  49 //            ["u32", "context"],
  50 //            ["i32", "retval"],
  51 //            {"crc" : "0xdfbf3afa"}
  52 //        ],
  53 //
  54 type SwInterfaceSetFlagsReply struct {
  55         Retval int32
  56 }
  57
  58 func (*SwInterfaceSetFlagsReply) GetMessageName() string {
  59         return "sw_interface_set_flags_reply"
  60 }
  61 func (*SwInterfaceSetFlagsReply) GetMessageType() api.MessageType {
  62         return api.ReplyMessage
  63 }
  64 func (*SwInterfaceSetFlagsReply) GetCrcString() string {
  65         return "dfbf3afa"
  66 }
  67 func NewSwInterfaceSetFlagsReply() api.Message {
  68         return &SwInterfaceSetFlagsReply{}
  69 }
  70
  71 // SwInterfaceSetMtu represents the VPP binary API message 'sw_interface_set_mtu'.
  72 // Generated from 'bin_api/interface.api.json', line 22:
  73 //
  74 //        ["sw_interface_set_mtu",
  75 //            ["u16", "_vl_msg_id"],
  76 //            ["u32", "client_index"],
  77 //            ["u32", "context"],
  78 //            ["u32", "sw_if_index"],
  79 //            ["u16", "mtu"],
  80 //            {"crc" : "0x535dab1d"}
  81 //        ],
  82 //
  83 type SwInterfaceSetMtu struct {
  84         SwIfIndex uint32
  85         Mtu       uint16
  86 }
  87
  88 func (*SwInterfaceSetMtu) GetMessageName() string {
  89         return "sw_interface_set_mtu"
  90 }
  91 func (*SwInterfaceSetMtu) GetMessageType() api.MessageType {
  92         return api.RequestMessage
  93 }
  94 func (*SwInterfaceSetMtu) GetCrcString() string {
  95         return "535dab1d"
  96 }
  97 func NewSwInterfaceSetMtu() api.Message {
  98         return &SwInterfaceSetMtu{}
  99 }
 100
 101 // SwInterfaceSetMtuReply represents the VPP binary API message 'sw_interface_set_mtu_reply'.
 102 // Generated from 'bin_api/interface.api.json', line 30:
 103 //
 104 //        ["sw_interface_set_mtu_reply",
 105 //            ["u16", "_vl_msg_id"],
 106 //            ["u32", "context"],
 107 //            ["i32", "retval"],
 108 //            {"crc" : "0x0cc22552"}
 109 //        ],
 110 //
 111 type SwInterfaceSetMtuReply struct {
 112         Retval int32
 113 }
 114
 115 func (*SwInterfaceSetMtuReply) GetMessageName() string {
 116         return "sw_interface_set_mtu_reply"
 117 }
 118 func (*SwInterfaceSetMtuReply) GetMessageType() api.MessageType {
 119         return api.ReplyMessage
 120 }
 121 func (*SwInterfaceSetMtuReply) GetCrcString() string {
 122         return "0cc22552"
 123 }
 124 func NewSwInterfaceSetMtuReply() api.Message {
 125         return &SwInterfaceSetMtuReply{}
 126 }
 127
 128 // WantInterfaceEvents represents the VPP binary API message 'want_interface_events'.
 129 // Generated from 'bin_api/interface.api.json', line 36:
 130 //
 131 //        ["want_interface_events",
 132 //            ["u16", "_vl_msg_id"],
 133 //            ["u32", "client_index"],
 134 //            ["u32", "context"],
 135 //            ["u32", "enable_disable"],
 136 //            ["u32", "pid"],
 137 //            {"crc" : "0xa0cbf57e"}
 138 //        ],
 139 //
 140 type WantInterfaceEvents struct {
 141         EnableDisable uint32
 142         Pid           uint32
 143 }
 144
 145 func (*WantInterfaceEvents) GetMessageName() string {
 146         return "want_interface_events"
 147 }
 148 func (*WantInterfaceEvents) GetMessageType() api.MessageType {
 149         return api.RequestMessage
 150 }
 151 func (*WantInterfaceEvents) GetCrcString() string {
 152         return "a0cbf57e"
 153 }
 154 func NewWantInterfaceEvents() api.Message {
 155         return &WantInterfaceEvents{}
 156 }
 157
 158 // WantInterfaceEventsReply represents the VPP binary API message 'want_interface_events_reply'.
 159 // Generated from 'bin_api/interface.api.json', line 44:
 160 //
 161 //        ["want_interface_events_reply",
 162 //            ["u16", "_vl_msg_id"],
 163 //            ["u32", "context"],
 164 //            ["i32", "retval"],
 165 //            {"crc" : "0x33788c73"}
 166 //        ],
 167 //
 168 type WantInterfaceEventsReply struct {
 169         Retval int32
 170 }
 171
 172 func (*WantInterfaceEventsReply) GetMessageName() string {
 173         return "want_interface_events_reply"
 174 }
 175 func (*WantInterfaceEventsReply) GetMessageType() api.MessageType {
 176         return api.ReplyMessage
 177 }
 178 func (*WantInterfaceEventsReply) GetCrcString() string {
 179         return "33788c73"
 180 }
 181 func NewWantInterfaceEventsReply() api.Message {
 182         return &WantInterfaceEventsReply{}
 183 }
 184
 185 // SwInterfaceDetails represents the VPP binary API message 'sw_interface_details'.
 186 // Generated from 'bin_api/interface.api.json', line 50:
 187 //
 188 //        ["sw_interface_details",
 189 //            ["u16", "_vl_msg_id"],
 190 //            ["u32", "context"],
 191 //            ["u32", "sw_if_index"],
 192 //            ["u32", "sup_sw_if_index"],
 193 //            ["u32", "l2_address_length"],
 194 //            ["u8", "l2_address", 8],
 195 //            ["u8", "interface_name", 64],
 196 //            ["u8", "admin_up_down"],
 197 //            ["u8", "link_up_down"],
 198 //            ["u8", "link_duplex"],
 199 //            ["u8", "link_speed"],
 200 //            ["u16", "link_mtu"],
 201 //            ["u32", "sub_id"],
 202 //            ["u8", "sub_dot1ad"],
 203 //            ["u8", "sub_dot1ah"],
 204 //            ["u8", "sub_number_of_tags"],
 205 //            ["u16", "sub_outer_vlan_id"],
 206 //            ["u16", "sub_inner_vlan_id"],
 207 //            ["u8", "sub_exact_match"],
 208 //            ["u8", "sub_default"],
 209 //            ["u8", "sub_outer_vlan_id_any"],
 210 //            ["u8", "sub_inner_vlan_id_any"],
 211 //            ["u32", "vtr_op"],
 212 //            ["u32", "vtr_push_dot1q"],
 213 //            ["u32", "vtr_tag1"],
 214 //            ["u32", "vtr_tag2"],
 215 //            ["u8", "tag", 64],
 216 //            ["u16", "outer_tag"],
 217 //            ["u8", "b_dmac", 6],
 218 //            ["u8", "b_smac", 6],
 219 //            ["u16", "b_vlanid"],
 220 //            ["u32", "i_sid"],
 221 //            {"crc" : "0xe2d855bb"}
 222 //        ],
 223 //
 224 type SwInterfaceDetails struct {
 225         SwIfIndex         uint32
 226         SupSwIfIndex      uint32
 227         L2AddressLength   uint32
 228         L2Address         []byte `struc:"[8]byte"`
 229         InterfaceName     []byte `struc:"[64]byte"`
 230         AdminUpDown       uint8
 231         LinkUpDown        uint8
 232         LinkDuplex        uint8
 233         LinkSpeed         uint8
 234         LinkMtu           uint16
 235         SubID             uint32
 236         SubDot1ad         uint8
 237         SubDot1ah         uint8
 238         SubNumberOfTags   uint8
 239         SubOuterVlanID    uint16
 240         SubInnerVlanID    uint16
 241         SubExactMatch     uint8
 242         SubDefault        uint8
 243         SubOuterVlanIDAny uint8
 244         SubInnerVlanIDAny uint8
 245         VtrOp             uint32
 246         VtrPushDot1q      uint32
 247         VtrTag1           uint32
 248         VtrTag2           uint32
 249         Tag               []byte `struc:"[64]byte"`
 250         OuterTag          uint16
 251         BDmac             []byte `struc:"[6]byte"`
 252         BSmac             []byte `struc:"[6]byte"`
 253         BVlanid           uint16
 254         ISid              uint32
 255 }
 256
 257 func (*SwInterfaceDetails) GetMessageName() string {
 258         return "sw_interface_details"
 259 }
 260 func (*SwInterfaceDetails) GetMessageType() api.MessageType {
 261         return api.ReplyMessage
 262 }
 263 func (*SwInterfaceDetails) GetCrcString() string {
 264         return "e2d855bb"
 265 }
 266 func NewSwInterfaceDetails() api.Message {
 267         return &SwInterfaceDetails{}
 268 }
 269
 270 // SwInterfaceDump represents the VPP binary API message 'sw_interface_dump'.
 271 // Generated from 'bin_api/interface.api.json', line 85:
 272 //
 273 //        ["sw_interface_dump",
 274 //            ["u16", "_vl_msg_id"],
 275 //            ["u32", "client_index"],
 276 //            ["u32", "context"],
 277 //            ["u8", "name_filter_valid"],
 278 //            ["u8", "name_filter", 49],
 279 //            {"crc" : "0x9a2f9d4d"}
 280 //        ],
 281 //
 282 type SwInterfaceDump struct {
 283         NameFilterValid uint8
 284         NameFilter      []byte `struc:"[49]byte"`
 285 }
 286
 287 func (*SwInterfaceDump) GetMessageName() string {
 288         return "sw_interface_dump"
 289 }
 290 func (*SwInterfaceDump) GetMessageType() api.MessageType {
 291         return api.RequestMessage
 292 }
 293 func (*SwInterfaceDump) GetCrcString() string {
 294         return "9a2f9d4d"
 295 }
 296 func NewSwInterfaceDump() api.Message {
 297         return &SwInterfaceDump{}
 298 }
 299
 300 // SwInterfaceAddDelAddress represents the VPP binary API message 'sw_interface_add_del_address'.
 301 // Generated from 'bin_api/interface.api.json', line 93:
 302 //
 303 //        ["sw_interface_add_del_address",
 304 //            ["u16", "_vl_msg_id"],
 305 //            ["u32", "client_index"],
 306 //            ["u32", "context"],
 307 //            ["u32", "sw_if_index"],
 308 //            ["u8", "is_add"],
 309 //            ["u8", "is_ipv6"],
 310 //            ["u8", "del_all"],
 311 //            ["u8", "address_length"],
 312 //            ["u8", "address", 16],
 313 //            {"crc" : "0x4e24d2df"}
 314 //        ],
 315 //
 316 type SwInterfaceAddDelAddress struct {
 317         SwIfIndex     uint32
 318         IsAdd         uint8
 319         IsIpv6        uint8
 320         DelAll        uint8
 321         AddressLength uint8
 322         Address       []byte `struc:"[16]byte"`
 323 }
 324
 325 func (*SwInterfaceAddDelAddress) GetMessageName() string {
 326         return "sw_interface_add_del_address"
 327 }
 328 func (*SwInterfaceAddDelAddress) GetMessageType() api.MessageType {
 329         return api.RequestMessage
 330 }
 331 func (*SwInterfaceAddDelAddress) GetCrcString() string {
 332         return "4e24d2df"
 333 }
 334 func NewSwInterfaceAddDelAddress() api.Message {
 335         return &SwInterfaceAddDelAddress{}
 336 }
 337
 338 // SwInterfaceAddDelAddressReply represents the VPP binary API message 'sw_interface_add_del_address_reply'.
 339 // Generated from 'bin_api/interface.api.json', line 105:
 340 //
 341 //        ["sw_interface_add_del_address_reply",
 342 //            ["u16", "_vl_msg_id"],
 343 //            ["u32", "context"],
 344 //            ["i32", "retval"],
 345 //            {"crc" : "0xabe29452"}
 346 //        ],
 347 //
 348 type SwInterfaceAddDelAddressReply struct {
 349         Retval int32
 350 }
 351
 352 func (*SwInterfaceAddDelAddressReply) GetMessageName() string {
 353         return "sw_interface_add_del_address_reply"
 354 }
 355 func (*SwInterfaceAddDelAddressReply) GetMessageType() api.MessageType {
 356         return api.ReplyMessage
 357 }
 358 func (*SwInterfaceAddDelAddressReply) GetCrcString() string {
 359         return "abe29452"
 360 }
 361 func NewSwInterfaceAddDelAddressReply() api.Message {
 362         return &SwInterfaceAddDelAddressReply{}
 363 }
 364
 365 // SwInterfaceSetTable represents the VPP binary API message 'sw_interface_set_table'.
 366 // Generated from 'bin_api/interface.api.json', line 111:
 367 //
 368 //        ["sw_interface_set_table",
 369 //            ["u16", "_vl_msg_id"],
 370 //            ["u32", "client_index"],
 371 //            ["u32", "context"],
 372 //            ["u32", "sw_if_index"],
 373 //            ["u8", "is_ipv6"],
 374 //            ["u32", "vrf_id"],
 375 //            {"crc" : "0xa94df510"}
 376 //        ],
 377 //
 378 type SwInterfaceSetTable struct {
 379         SwIfIndex uint32
 380         IsIpv6    uint8
 381         VrfID     uint32
 382 }
 383
 384 func (*SwInterfaceSetTable) GetMessageName() string {
 385         return "sw_interface_set_table"
 386 }
 387 func (*SwInterfaceSetTable) GetMessageType() api.MessageType {
 388         return api.RequestMessage
 389 }
 390 func (*SwInterfaceSetTable) GetCrcString() string {
 391         return "a94df510"
 392 }
 393 func NewSwInterfaceSetTable() api.Message {
 394         return &SwInterfaceSetTable{}
 395 }
 396
 397 // SwInterfaceSetTableReply represents the VPP binary API message 'sw_interface_set_table_reply'.
 398 // Generated from 'bin_api/interface.api.json', line 120:
 399 //
 400 //        ["sw_interface_set_table_reply",
 401 //            ["u16", "_vl_msg_id"],
 402 //            ["u32", "context"],
 403 //            ["i32", "retval"],
 404 //            {"crc" : "0x99df273c"}
 405 //        ],
 406 //
 407 type SwInterfaceSetTableReply struct {
 408         Retval int32
 409 }
 410
 411 func (*SwInterfaceSetTableReply) GetMessageName() string {
 412         return "sw_interface_set_table_reply"
 413 }
 414 func (*SwInterfaceSetTableReply) GetMessageType() api.MessageType {
 415         return api.ReplyMessage
 416 }
 417 func (*SwInterfaceSetTableReply) GetCrcString() string {
 418         return "99df273c"
 419 }
 420 func NewSwInterfaceSetTableReply() api.Message {
 421         return &SwInterfaceSetTableReply{}
 422 }
 423
 424 // SwInterfaceGetTable represents the VPP binary API message 'sw_interface_get_table'.
 425 // Generated from 'bin_api/interface.api.json', line 126:
 426 //
 427 //        ["sw_interface_get_table",
 428 //            ["u16", "_vl_msg_id"],
 429 //            ["u32", "client_index"],
 430 //            ["u32", "context"],
 431 //            ["u32", "sw_if_index"],
 432 //            ["u8", "is_ipv6"],
 433 //            {"crc" : "0xf5a1d557"}
 434 //        ],
 435 //
 436 type SwInterfaceGetTable struct {
 437         SwIfIndex uint32
 438         IsIpv6    uint8
 439 }
 440
 441 func (*SwInterfaceGetTable) GetMessageName() string {
 442         return "sw_interface_get_table"
 443 }
 444 func (*SwInterfaceGetTable) GetMessageType() api.MessageType {
 445         return api.RequestMessage
 446 }
 447 func (*SwInterfaceGetTable) GetCrcString() string {
 448         return "f5a1d557"
 449 }
 450 func NewSwInterfaceGetTable() api.Message {
 451         return &SwInterfaceGetTable{}
 452 }
 453
 454 // SwInterfaceGetTableReply represents the VPP binary API message 'sw_interface_get_table_reply'.
 455 // Generated from 'bin_api/interface.api.json', line 134:
 456 //
 457 //        ["sw_interface_get_table_reply",
 458 //            ["u16", "_vl_msg_id"],
 459 //            ["u32", "context"],
 460 //            ["i32", "retval"],
 461 //            ["u32", "vrf_id"],
 462 //            {"crc" : "0xab44111d"}
 463 //        ],
 464 //
 465 type SwInterfaceGetTableReply struct {
 466         Retval int32
 467         VrfID  uint32
 468 }
 469
 470 func (*SwInterfaceGetTableReply) GetMessageName() string {
 471         return "sw_interface_get_table_reply"
 472 }
 473 func (*SwInterfaceGetTableReply) GetMessageType() api.MessageType {
 474         return api.ReplyMessage
 475 }
 476 func (*SwInterfaceGetTableReply) GetCrcString() string {
 477         return "ab44111d"
 478 }
 479 func NewSwInterfaceGetTableReply() api.Message {
 480         return &SwInterfaceGetTableReply{}
 481 }
 482
 483 // VnetInterfaceCounters represents the VPP binary API message 'vnet_interface_counters'.
 484 // Generated from 'bin_api/interface.api.json', line 141:
 485 //
 486 //        ["vnet_interface_counters",
 487 //            ["u16", "_vl_msg_id"],
 488 //            ["u8", "vnet_counter_type"],
 489 //            ["u8", "is_combined"],
 490 //            ["u32", "first_sw_if_index"],
 491 //            ["u32", "count"],
 492 //            ["u8", "data", 0, "count"],
 493 //            {"crc" : "0x312082b4"}
 494 //        ],
 495 //
 496 type VnetInterfaceCounters struct {
 497         VnetCounterType uint8
 498         IsCombined      uint8
 499         FirstSwIfIndex  uint32
 500         Count           uint32 `struc:"sizeof=Data"`
 501         Data            []byte
 502 }
 503
 504 func (*VnetInterfaceCounters) GetMessageName() string {
 505         return "vnet_interface_counters"
 506 }
 507 func (*VnetInterfaceCounters) GetMessageType() api.MessageType {
 508         return api.OtherMessage
 509 }
 510 func (*VnetInterfaceCounters) GetCrcString() string {
 511         return "312082b4"
 512 }
 513 func NewVnetInterfaceCounters() api.Message {
 514         return &VnetInterfaceCounters{}
 515 }
 516
 517 // SwInterfaceSetUnnumbered represents the VPP binary API message 'sw_interface_set_unnumbered'.
 518 // Generated from 'bin_api/interface.api.json', line 150:
 519 //
 520 //        ["sw_interface_set_unnumbered",
 521 //            ["u16", "_vl_msg_id"],
 522 //            ["u32", "client_index"],
 523 //            ["u32", "context"],
 524 //            ["u32", "sw_if_index"],
 525 //            ["u32", "unnumbered_sw_if_index"],
 526 //            ["u8", "is_add"],
 527 //            {"crc" : "0xee0047b0"}
 528 //        ],
 529 //
 530 type SwInterfaceSetUnnumbered struct {
 531         SwIfIndex           uint32
 532         UnnumberedSwIfIndex uint32
 533         IsAdd               uint8
 534 }
 535
 536 func (*SwInterfaceSetUnnumbered) GetMessageName() string {
 537         return "sw_interface_set_unnumbered"
 538 }
 539 func (*SwInterfaceSetUnnumbered) GetMessageType() api.MessageType {
 540         return api.RequestMessage
 541 }
 542 func (*SwInterfaceSetUnnumbered) GetCrcString() string {
 543         return "ee0047b0"
 544 }
 545 func NewSwInterfaceSetUnnumbered() api.Message {
 546         return &SwInterfaceSetUnnumbered{}
 547 }
 548
 549 // SwInterfaceSetUnnumberedReply represents the VPP binary API message 'sw_interface_set_unnumbered_reply'.
 550 // Generated from 'bin_api/interface.api.json', line 159:
 551 //
 552 //        ["sw_interface_set_unnumbered_reply",
 553 //            ["u16", "_vl_msg_id"],
 554 //            ["u32", "context"],
 555 //            ["i32", "retval"],
 556 //            {"crc" : "0x5b2275e1"}
 557 //        ],
 558 //
 559 type SwInterfaceSetUnnumberedReply struct {
 560         Retval int32
 561 }
 562
 563 func (*SwInterfaceSetUnnumberedReply) GetMessageName() string {
 564         return "sw_interface_set_unnumbered_reply"
 565 }
 566 func (*SwInterfaceSetUnnumberedReply) GetMessageType() api.MessageType {
 567         return api.ReplyMessage
 568 }
 569 func (*SwInterfaceSetUnnumberedReply) GetCrcString() string {
 570         return "5b2275e1"
 571 }
 572 func NewSwInterfaceSetUnnumberedReply() api.Message {
 573         return &SwInterfaceSetUnnumberedReply{}
 574 }
 575
 576 // SwInterfaceClearStats represents the VPP binary API message 'sw_interface_clear_stats'.
 577 // Generated from 'bin_api/interface.api.json', line 165:
 578 //
 579 //        ["sw_interface_clear_stats",
 580 //            ["u16", "_vl_msg_id"],
 581 //            ["u32", "client_index"],
 582 //            ["u32", "context"],
 583 //            ["u32", "sw_if_index"],
 584 //            {"crc" : "0x9600fd50"}
 585 //        ],
 586 //
 587 type SwInterfaceClearStats struct {
 588         SwIfIndex uint32
 589 }
 590
 591 func (*SwInterfaceClearStats) GetMessageName() string {
 592         return "sw_interface_clear_stats"
 593 }
 594 func (*SwInterfaceClearStats) GetMessageType() api.MessageType {
 595         return api.RequestMessage
 596 }
 597 func (*SwInterfaceClearStats) GetCrcString() string {
 598         return "9600fd50"
 599 }
 600 func NewSwInterfaceClearStats() api.Message {
 601         return &SwInterfaceClearStats{}
 602 }
 603
 604 // SwInterfaceClearStatsReply represents the VPP binary API message 'sw_interface_clear_stats_reply'.
 605 // Generated from 'bin_api/interface.api.json', line 172:
 606 //
 607 //        ["sw_interface_clear_stats_reply",
 608 //            ["u16", "_vl_msg_id"],
 609 //            ["u32", "context"],
 610 //            ["i32", "retval"],
 611 //            {"crc" : "0x21f50dd9"}
 612 //        ],
 613 //
 614 type SwInterfaceClearStatsReply struct {
 615         Retval int32
 616 }
 617
 618 func (*SwInterfaceClearStatsReply) GetMessageName() string {
 619         return "sw_interface_clear_stats_reply"
 620 }
 621 func (*SwInterfaceClearStatsReply) GetMessageType() api.MessageType {
 622         return api.ReplyMessage
 623 }
 624 func (*SwInterfaceClearStatsReply) GetCrcString() string {
 625         return "21f50dd9"
 626 }
 627 func NewSwInterfaceClearStatsReply() api.Message {
 628         return &SwInterfaceClearStatsReply{}
 629 }
 630
 631 // SwInterfaceTagAddDel represents the VPP binary API message 'sw_interface_tag_add_del'.
 632 // Generated from 'bin_api/interface.api.json', line 178:
 633 //
 634 //        ["sw_interface_tag_add_del",
 635 //            ["u16", "_vl_msg_id"],
 636 //            ["u32", "client_index"],
 637 //            ["u32", "context"],
 638 //            ["u8", "is_add"],
 639 //            ["u32", "sw_if_index"],
 640 //            ["u8", "tag", 64],
 641 //            {"crc" : "0x50ae8d92"}
 642 //        ],
 643 //
 644 type SwInterfaceTagAddDel struct {
 645         IsAdd     uint8
 646         SwIfIndex uint32
 647         Tag       []byte `struc:"[64]byte"`
 648 }
 649
 650 func (*SwInterfaceTagAddDel) GetMessageName() string {
 651         return "sw_interface_tag_add_del"
 652 }
 653 func (*SwInterfaceTagAddDel) GetMessageType() api.MessageType {
 654         return api.RequestMessage
 655 }
 656 func (*SwInterfaceTagAddDel) GetCrcString() string {
 657         return "50ae8d92"
 658 }
 659 func NewSwInterfaceTagAddDel() api.Message {
 660         return &SwInterfaceTagAddDel{}
 661 }
 662
 663 // SwInterfaceTagAddDelReply represents the VPP binary API message 'sw_interface_tag_add_del_reply'.
 664 // Generated from 'bin_api/interface.api.json', line 187:
 665 //
 666 //        ["sw_interface_tag_add_del_reply",
 667 //            ["u16", "_vl_msg_id"],
 668 //            ["u32", "context"],
 669 //            ["i32", "retval"],
 670 //            {"crc" : "0x761cbcb0"}
 671 //        ]
 672 //
 673 type SwInterfaceTagAddDelReply struct {
 674         Retval int32
 675 }
 676
 677 func (*SwInterfaceTagAddDelReply) GetMessageName() string {
 678         return "sw_interface_tag_add_del_reply"
 679 }
 680 func (*SwInterfaceTagAddDelReply) GetMessageType() api.MessageType {
 681         return api.ReplyMessage
 682 }
 683 func (*SwInterfaceTagAddDelReply) GetCrcString() string {
 684         return "761cbcb0"
 685 }
 686 func NewSwInterfaceTagAddDelReply() api.Message {
 687         return &SwInterfaceTagAddDelReply{}
 688 }