examples/bin_api/ip/ip.go

   1 // Package ip represents the VPP binary API of the 'ip' VPP module.
   2 // DO NOT EDIT. Generated from 'bin_api/ip.api.json'
   3 package ip
   4
   5 import "git.fd.io/govpp.git/api"
   6
   7 // VlApiVersion contains version of the API.
   8 const VlAPIVersion = 0x50fe2434
   9
  10 // FibPath represents the VPP binary API data type 'fib_path'.
  11 // Generated from 'bin_api/ip.api.json', line 3:
  12 //
  13 //        ["fib_path",
  14 //            ["u32", "sw_if_index"],
  15 //            ["u32", "weight"],
  16 //            ["u8", "is_local"],
  17 //            ["u8", "is_drop"],
  18 //            ["u8", "is_unreach"],
  19 //            ["u8", "is_prohibit"],
  20 //            ["u8", "afi"],
  21 //            ["u8", "next_hop", 16],
  22 //            {"crc" : "0x315b1889"}
  23 //        ]
  24 //
  25 type FibPath struct {
  26         SwIfIndex  uint32
  27         Weight     uint32
  28         IsLocal    uint8
  29         IsDrop     uint8
  30         IsUnreach  uint8
  31         IsProhibit uint8
  32         Afi        uint8
  33         NextHop    []byte `struc:"[16]byte"`
  34 }
  35
  36 func (*FibPath) GetTypeName() string {
  37         return "fib_path"
  38 }
  39 func (*FibPath) GetCrcString() string {
  40         return "315b1889"
  41 }
  42
  43 // IPFibDump represents the VPP binary API message 'ip_fib_dump'.
  44 // Generated from 'bin_api/ip.api.json', line 16:
  45 //
  46 //        ["ip_fib_dump",
  47 //            ["u16", "_vl_msg_id"],
  48 //            ["u32", "client_index"],
  49 //            ["u32", "context"],
  50 //            {"crc" : "0x5fe56ca3"}
  51 //        ],
  52 //
  53 type IPFibDump struct {
  54 }
  55
  56 func (*IPFibDump) GetMessageName() string {
  57         return "ip_fib_dump"
  58 }
  59 func (*IPFibDump) GetMessageType() api.MessageType {
  60         return api.RequestMessage
  61 }
  62 func (*IPFibDump) GetCrcString() string {
  63         return "5fe56ca3"
  64 }
  65 func NewIPFibDump() api.Message {
  66         return &IPFibDump{}
  67 }
  68
  69 // IPFibDetails represents the VPP binary API message 'ip_fib_details'.
  70 // Generated from 'bin_api/ip.api.json', line 22:
  71 //
  72 //        ["ip_fib_details",
  73 //            ["u16", "_vl_msg_id"],
  74 //            ["u32", "context"],
  75 //            ["u32", "table_id"],
  76 //            ["u8", "address_length"],
  77 //            ["u8", "address", 4],
  78 //            ["u32", "count"],
  79 //            ["vl_api_fib_path_t", "path", 0, "count"],
  80 //            {"crc" : "0xfd8c6584"}
  81 //        ],
  82 //
  83 type IPFibDetails struct {
  84         TableID       uint32
  85         AddressLength uint8
  86         Address       []byte `struc:"[4]byte"`
  87         Count         uint32 `struc:"sizeof=Path"`
  88         Path          []FibPath
  89 }
  90
  91 func (*IPFibDetails) GetMessageName() string {
  92         return "ip_fib_details"
  93 }
  94 func (*IPFibDetails) GetMessageType() api.MessageType {
  95         return api.ReplyMessage
  96 }
  97 func (*IPFibDetails) GetCrcString() string {
  98         return "fd8c6584"
  99 }
 100 func NewIPFibDetails() api.Message {
 101         return &IPFibDetails{}
 102 }
 103
 104 // IP6FibDump represents the VPP binary API message 'ip6_fib_dump'.
 105 // Generated from 'bin_api/ip.api.json', line 32:
 106 //
 107 //        ["ip6_fib_dump",
 108 //            ["u16", "_vl_msg_id"],
 109 //            ["u32", "client_index"],
 110 //            ["u32", "context"],
 111 //            {"crc" : "0x25c89676"}
 112 //        ],
 113 //
 114 type IP6FibDump struct {
 115 }
 116
 117 func (*IP6FibDump) GetMessageName() string {
 118         return "ip6_fib_dump"
 119 }
 120 func (*IP6FibDump) GetMessageType() api.MessageType {
 121         return api.RequestMessage
 122 }
 123 func (*IP6FibDump) GetCrcString() string {
 124         return "25c89676"
 125 }
 126 func NewIP6FibDump() api.Message {
 127         return &IP6FibDump{}
 128 }
 129
 130 // IP6FibDetails represents the VPP binary API message 'ip6_fib_details'.
 131 // Generated from 'bin_api/ip.api.json', line 38:
 132 //
 133 //        ["ip6_fib_details",
 134 //            ["u16", "_vl_msg_id"],
 135 //            ["u32", "context"],
 136 //            ["u32", "table_id"],
 137 //            ["u8", "address_length"],
 138 //            ["u8", "address", 16],
 139 //            ["u32", "count"],
 140 //            ["vl_api_fib_path_t", "path", 0, "count"],
 141 //            {"crc" : "0xe0825cb5"}
 142 //        ],
 143 //
 144 type IP6FibDetails struct {
 145         TableID       uint32
 146         AddressLength uint8
 147         Address       []byte `struc:"[16]byte"`
 148         Count         uint32 `struc:"sizeof=Path"`
 149         Path          []FibPath
 150 }
 151
 152 func (*IP6FibDetails) GetMessageName() string {
 153         return "ip6_fib_details"
 154 }
 155 func (*IP6FibDetails) GetMessageType() api.MessageType {
 156         return api.ReplyMessage
 157 }
 158 func (*IP6FibDetails) GetCrcString() string {
 159         return "e0825cb5"
 160 }
 161 func NewIP6FibDetails() api.Message {
 162         return &IP6FibDetails{}
 163 }
 164
 165 // IPNeighborDump represents the VPP binary API message 'ip_neighbor_dump'.
 166 // Generated from 'bin_api/ip.api.json', line 48:
 167 //
 168 //        ["ip_neighbor_dump",
 169 //            ["u16", "_vl_msg_id"],
 170 //            ["u32", "client_index"],
 171 //            ["u32", "context"],
 172 //            ["u32", "sw_if_index"],
 173 //            ["u8", "is_ipv6"],
 174 //            {"crc" : "0x3289e160"}
 175 //        ],
 176 //
 177 type IPNeighborDump struct {
 178         SwIfIndex uint32
 179         IsIpv6    uint8
 180 }
 181
 182 func (*IPNeighborDump) GetMessageName() string {
 183         return "ip_neighbor_dump"
 184 }
 185 func (*IPNeighborDump) GetMessageType() api.MessageType {
 186         return api.RequestMessage
 187 }
 188 func (*IPNeighborDump) GetCrcString() string {
 189         return "3289e160"
 190 }
 191 func NewIPNeighborDump() api.Message {
 192         return &IPNeighborDump{}
 193 }
 194
 195 // IPNeighborDetails represents the VPP binary API message 'ip_neighbor_details'.
 196 // Generated from 'bin_api/ip.api.json', line 56:
 197 //
 198 //        ["ip_neighbor_details",
 199 //            ["u16", "_vl_msg_id"],
 200 //            ["u32", "context"],
 201 //            ["u8", "is_static"],
 202 //            ["u8", "is_ipv6"],
 203 //            ["u8", "mac_address", 6],
 204 //            ["u8", "ip_address", 16],
 205 //            {"crc" : "0x3a00e32a"}
 206 //        ],
 207 //
 208 type IPNeighborDetails struct {
 209         IsStatic   uint8
 210         IsIpv6     uint8
 211         MacAddress []byte `struc:"[6]byte"`
 212         IPAddress  []byte `struc:"[16]byte"`
 213 }
 214
 215 func (*IPNeighborDetails) GetMessageName() string {
 216         return "ip_neighbor_details"
 217 }
 218 func (*IPNeighborDetails) GetMessageType() api.MessageType {
 219         return api.ReplyMessage
 220 }
 221 func (*IPNeighborDetails) GetCrcString() string {
 222         return "3a00e32a"
 223 }
 224 func NewIPNeighborDetails() api.Message {
 225         return &IPNeighborDetails{}
 226 }
 227
 228 // IPNeighborAddDel represents the VPP binary API message 'ip_neighbor_add_del'.
 229 // Generated from 'bin_api/ip.api.json', line 65:
 230 //
 231 //        ["ip_neighbor_add_del",
 232 //            ["u16", "_vl_msg_id"],
 233 //            ["u32", "client_index"],
 234 //            ["u32", "context"],
 235 //            ["u32", "sw_if_index"],
 236 //            ["u8", "is_add"],
 237 //            ["u8", "is_ipv6"],
 238 //            ["u8", "is_static"],
 239 //            ["u8", "is_no_adj_fib"],
 240 //            ["u8", "mac_address", 6],
 241 //            ["u8", "dst_address", 16],
 242 //            {"crc" : "0x5a0d070b"}
 243 //        ],
 244 //
 245 type IPNeighborAddDel struct {
 246         SwIfIndex  uint32
 247         IsAdd      uint8
 248         IsIpv6     uint8
 249         IsStatic   uint8
 250         IsNoAdjFib uint8
 251         MacAddress []byte `struc:"[6]byte"`
 252         DstAddress []byte `struc:"[16]byte"`
 253 }
 254
 255 func (*IPNeighborAddDel) GetMessageName() string {
 256         return "ip_neighbor_add_del"
 257 }
 258 func (*IPNeighborAddDel) GetMessageType() api.MessageType {
 259         return api.RequestMessage
 260 }
 261 func (*IPNeighborAddDel) GetCrcString() string {
 262         return "5a0d070b"
 263 }
 264 func NewIPNeighborAddDel() api.Message {
 265         return &IPNeighborAddDel{}
 266 }
 267
 268 // IPNeighborAddDelReply represents the VPP binary API message 'ip_neighbor_add_del_reply'.
 269 // Generated from 'bin_api/ip.api.json', line 78:
 270 //
 271 //        ["ip_neighbor_add_del_reply",
 272 //            ["u16", "_vl_msg_id"],
 273 //            ["u32", "context"],
 274 //            ["i32", "retval"],
 275 //            {"crc" : "0xe5b0f318"}
 276 //        ],
 277 //
 278 type IPNeighborAddDelReply struct {
 279         Retval int32
 280 }
 281
 282 func (*IPNeighborAddDelReply) GetMessageName() string {
 283         return "ip_neighbor_add_del_reply"
 284 }
 285 func (*IPNeighborAddDelReply) GetMessageType() api.MessageType {
 286         return api.ReplyMessage
 287 }
 288 func (*IPNeighborAddDelReply) GetCrcString() string {
 289         return "e5b0f318"
 290 }
 291 func NewIPNeighborAddDelReply() api.Message {
 292         return &IPNeighborAddDelReply{}
 293 }
 294
 295 // SetIPFlowHash represents the VPP binary API message 'set_ip_flow_hash'.
 296 // Generated from 'bin_api/ip.api.json', line 84:
 297 //
 298 //        ["set_ip_flow_hash",
 299 //            ["u16", "_vl_msg_id"],
 300 //            ["u32", "client_index"],
 301 //            ["u32", "context"],
 302 //            ["u32", "vrf_id"],
 303 //            ["u8", "is_ipv6"],
 304 //            ["u8", "src"],
 305 //            ["u8", "dst"],
 306 //            ["u8", "sport"],
 307 //            ["u8", "dport"],
 308 //            ["u8", "proto"],
 309 //            ["u8", "reverse"],
 310 //            {"crc" : "0x92ad3798"}
 311 //        ],
 312 //
 313 type SetIPFlowHash struct {
 314         VrfID   uint32
 315         IsIpv6  uint8
 316         Src     uint8
 317         Dst     uint8
 318         Sport   uint8
 319         Dport   uint8
 320         Proto   uint8
 321         Reverse uint8
 322 }
 323
 324 func (*SetIPFlowHash) GetMessageName() string {
 325         return "set_ip_flow_hash"
 326 }
 327 func (*SetIPFlowHash) GetMessageType() api.MessageType {
 328         return api.RequestMessage
 329 }
 330 func (*SetIPFlowHash) GetCrcString() string {
 331         return "92ad3798"
 332 }
 333 func NewSetIPFlowHash() api.Message {
 334         return &SetIPFlowHash{}
 335 }
 336
 337 // SetIPFlowHashReply represents the VPP binary API message 'set_ip_flow_hash_reply'.
 338 // Generated from 'bin_api/ip.api.json', line 98:
 339 //
 340 //        ["set_ip_flow_hash_reply",
 341 //            ["u16", "_vl_msg_id"],
 342 //            ["u32", "context"],
 343 //            ["i32", "retval"],
 344 //            {"crc" : "0x35a9e5eb"}
 345 //        ],
 346 //
 347 type SetIPFlowHashReply struct {
 348         Retval int32
 349 }
 350
 351 func (*SetIPFlowHashReply) GetMessageName() string {
 352         return "set_ip_flow_hash_reply"
 353 }
 354 func (*SetIPFlowHashReply) GetMessageType() api.MessageType {
 355         return api.ReplyMessage
 356 }
 357 func (*SetIPFlowHashReply) GetCrcString() string {
 358         return "35a9e5eb"
 359 }
 360 func NewSetIPFlowHashReply() api.Message {
 361         return &SetIPFlowHashReply{}
 362 }
 363
 364 // SwInterfaceIP6ndRaConfig represents the VPP binary API message 'sw_interface_ip6nd_ra_config'.
 365 // Generated from 'bin_api/ip.api.json', line 104:
 366 //
 367 //        ["sw_interface_ip6nd_ra_config",
 368 //            ["u16", "_vl_msg_id"],
 369 //            ["u32", "client_index"],
 370 //            ["u32", "context"],
 371 //            ["u32", "sw_if_index"],
 372 //            ["u8", "suppress"],
 373 //            ["u8", "managed"],
 374 //            ["u8", "other"],
 375 //            ["u8", "ll_option"],
 376 //            ["u8", "send_unicast"],
 377 //            ["u8", "cease"],
 378 //            ["u8", "is_no"],
 379 //            ["u8", "default_router"],
 380 //            ["u32", "max_interval"],
 381 //            ["u32", "min_interval"],
 382 //            ["u32", "lifetime"],
 383 //            ["u32", "initial_count"],
 384 //            ["u32", "initial_interval"],
 385 //            {"crc" : "0xec4a29f6"}
 386 //        ],
 387 //
 388 type SwInterfaceIP6ndRaConfig struct {
 389         SwIfIndex       uint32
 390         Suppress        uint8
 391         Managed         uint8
 392         Other           uint8
 393         LlOption        uint8
 394         SendUnicast     uint8
 395         Cease           uint8
 396         IsNo            uint8
 397         DefaultRouter   uint8
 398         MaxInterval     uint32
 399         MinInterval     uint32
 400         Lifetime        uint32
 401         InitialCount    uint32
 402         InitialInterval uint32
 403 }
 404
 405 func (*SwInterfaceIP6ndRaConfig) GetMessageName() string {
 406         return "sw_interface_ip6nd_ra_config"
 407 }
 408 func (*SwInterfaceIP6ndRaConfig) GetMessageType() api.MessageType {
 409         return api.RequestMessage
 410 }
 411 func (*SwInterfaceIP6ndRaConfig) GetCrcString() string {
 412         return "ec4a29f6"
 413 }
 414 func NewSwInterfaceIP6ndRaConfig() api.Message {
 415         return &SwInterfaceIP6ndRaConfig{}
 416 }
 417
 418 // SwInterfaceIP6ndRaConfigReply represents the VPP binary API message 'sw_interface_ip6nd_ra_config_reply'.
 419 // Generated from 'bin_api/ip.api.json', line 124:
 420 //
 421 //        ["sw_interface_ip6nd_ra_config_reply",
 422 //            ["u16", "_vl_msg_id"],
 423 //            ["u32", "context"],
 424 //            ["i32", "retval"],
 425 //            {"crc" : "0x16e25c5b"}
 426 //        ],
 427 //
 428 type SwInterfaceIP6ndRaConfigReply struct {
 429         Retval int32
 430 }
 431
 432 func (*SwInterfaceIP6ndRaConfigReply) GetMessageName() string {
 433         return "sw_interface_ip6nd_ra_config_reply"
 434 }
 435 func (*SwInterfaceIP6ndRaConfigReply) GetMessageType() api.MessageType {
 436         return api.ReplyMessage
 437 }
 438 func (*SwInterfaceIP6ndRaConfigReply) GetCrcString() string {
 439         return "16e25c5b"
 440 }
 441 func NewSwInterfaceIP6ndRaConfigReply() api.Message {
 442         return &SwInterfaceIP6ndRaConfigReply{}
 443 }
 444
 445 // SwInterfaceIP6ndRaPrefix represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix'.
 446 // Generated from 'bin_api/ip.api.json', line 130:
 447 //
 448 //        ["sw_interface_ip6nd_ra_prefix",
 449 //            ["u16", "_vl_msg_id"],
 450 //            ["u32", "client_index"],
 451 //            ["u32", "context"],
 452 //            ["u32", "sw_if_index"],
 453 //            ["u8", "address", 16],
 454 //            ["u8", "address_length"],
 455 //            ["u8", "use_default"],
 456 //            ["u8", "no_advertise"],
 457 //            ["u8", "off_link"],
 458 //            ["u8", "no_autoconfig"],
 459 //            ["u8", "no_onlink"],
 460 //            ["u8", "is_no"],
 461 //            ["u32", "val_lifetime"],
 462 //            ["u32", "pref_lifetime"],
 463 //            {"crc" : "0x5db6555c"}
 464 //        ],
 465 //
 466 type SwInterfaceIP6ndRaPrefix struct {
 467         SwIfIndex     uint32
 468         Address       []byte `struc:"[16]byte"`
 469         AddressLength uint8
 470         UseDefault    uint8
 471         NoAdvertise   uint8
 472         OffLink       uint8
 473         NoAutoconfig  uint8
 474         NoOnlink      uint8
 475         IsNo          uint8
 476         ValLifetime   uint32
 477         PrefLifetime  uint32
 478 }
 479
 480 func (*SwInterfaceIP6ndRaPrefix) GetMessageName() string {
 481         return "sw_interface_ip6nd_ra_prefix"
 482 }
 483 func (*SwInterfaceIP6ndRaPrefix) GetMessageType() api.MessageType {
 484         return api.RequestMessage
 485 }
 486 func (*SwInterfaceIP6ndRaPrefix) GetCrcString() string {
 487         return "5db6555c"
 488 }
 489 func NewSwInterfaceIP6ndRaPrefix() api.Message {
 490         return &SwInterfaceIP6ndRaPrefix{}
 491 }
 492
 493 // SwInterfaceIP6ndRaPrefixReply represents the VPP binary API message 'sw_interface_ip6nd_ra_prefix_reply'.
 494 // Generated from 'bin_api/ip.api.json', line 147:
 495 //
 496 //        ["sw_interface_ip6nd_ra_prefix_reply",
 497 //            ["u16", "_vl_msg_id"],
 498 //            ["u32", "context"],
 499 //            ["i32", "retval"],
 500 //            {"crc" : "0x8050adb3"}
 501 //        ],
 502 //
 503 type SwInterfaceIP6ndRaPrefixReply struct {
 504         Retval int32
 505 }
 506
 507 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageName() string {
 508         return "sw_interface_ip6nd_ra_prefix_reply"
 509 }
 510 func (*SwInterfaceIP6ndRaPrefixReply) GetMessageType() api.MessageType {
 511         return api.ReplyMessage
 512 }
 513 func (*SwInterfaceIP6ndRaPrefixReply) GetCrcString() string {
 514         return "8050adb3"
 515 }
 516 func NewSwInterfaceIP6ndRaPrefixReply() api.Message {
 517         return &SwInterfaceIP6ndRaPrefixReply{}
 518 }
 519
 520 // IP6ndProxyAddDel represents the VPP binary API message 'ip6nd_proxy_add_del'.
 521 // Generated from 'bin_api/ip.api.json', line 153:
 522 //
 523 //        ["ip6nd_proxy_add_del",
 524 //            ["u16", "_vl_msg_id"],
 525 //            ["u32", "client_index"],
 526 //            ["u32", "context"],
 527 //            ["u32", "sw_if_index"],
 528 //            ["u8", "is_del"],
 529 //            ["u8", "address", 16],
 530 //            {"crc" : "0xc56f802d"}
 531 //        ],
 532 //
 533 type IP6ndProxyAddDel struct {
 534         SwIfIndex uint32
 535         IsDel     uint8
 536         Address   []byte `struc:"[16]byte"`
 537 }
 538
 539 func (*IP6ndProxyAddDel) GetMessageName() string {
 540         return "ip6nd_proxy_add_del"
 541 }
 542 func (*IP6ndProxyAddDel) GetMessageType() api.MessageType {
 543         return api.RequestMessage
 544 }
 545 func (*IP6ndProxyAddDel) GetCrcString() string {
 546         return "c56f802d"
 547 }
 548 func NewIP6ndProxyAddDel() api.Message {
 549         return &IP6ndProxyAddDel{}
 550 }
 551
 552 // IP6ndProxyAddDelReply represents the VPP binary API message 'ip6nd_proxy_add_del_reply'.
 553 // Generated from 'bin_api/ip.api.json', line 162:
 554 //
 555 //        ["ip6nd_proxy_add_del_reply",
 556 //            ["u16", "_vl_msg_id"],
 557 //            ["u32", "context"],
 558 //            ["i32", "retval"],
 559 //            {"crc" : "0x00ddc2d5"}
 560 //        ],
 561 //
 562 type IP6ndProxyAddDelReply struct {
 563         Retval int32
 564 }
 565
 566 func (*IP6ndProxyAddDelReply) GetMessageName() string {
 567         return "ip6nd_proxy_add_del_reply"
 568 }
 569 func (*IP6ndProxyAddDelReply) GetMessageType() api.MessageType {
 570         return api.ReplyMessage
 571 }
 572 func (*IP6ndProxyAddDelReply) GetCrcString() string {
 573         return "00ddc2d5"
 574 }
 575 func NewIP6ndProxyAddDelReply() api.Message {
 576         return &IP6ndProxyAddDelReply{}
 577 }
 578
 579 // IP6ndProxyDetails represents the VPP binary API message 'ip6nd_proxy_details'.
 580 // Generated from 'bin_api/ip.api.json', line 168:
 581 //
 582 //        ["ip6nd_proxy_details",
 583 //            ["u16", "_vl_msg_id"],
 584 //            ["u32", "client_index"],
 585 //            ["u32", "context"],
 586 //            ["u32", "sw_if_index"],
 587 //            ["u8", "address", 16],
 588 //            {"crc" : "0xf805ccc1"}
 589 //        ],
 590 //
 591 type IP6ndProxyDetails struct {
 592         SwIfIndex uint32
 593         Address   []byte `struc:"[16]byte"`
 594 }
 595
 596 func (*IP6ndProxyDetails) GetMessageName() string {
 597         return "ip6nd_proxy_details"
 598 }
 599 func (*IP6ndProxyDetails) GetMessageType() api.MessageType {
 600         return api.RequestMessage
 601 }
 602 func (*IP6ndProxyDetails) GetCrcString() string {
 603         return "f805ccc1"
 604 }
 605 func NewIP6ndProxyDetails() api.Message {
 606         return &IP6ndProxyDetails{}
 607 }
 608
 609 // IP6ndProxyDump represents the VPP binary API message 'ip6nd_proxy_dump'.
 610 // Generated from 'bin_api/ip.api.json', line 176:
 611 //
 612 //        ["ip6nd_proxy_dump",
 613 //            ["u16", "_vl_msg_id"],
 614 //            ["u32", "client_index"],
 615 //            ["u32", "context"],
 616 //            {"crc" : "0x21597d88"}
 617 //        ],
 618 //
 619 type IP6ndProxyDump struct {
 620 }
 621
 622 func (*IP6ndProxyDump) GetMessageName() string {
 623         return "ip6nd_proxy_dump"
 624 }
 625 func (*IP6ndProxyDump) GetMessageType() api.MessageType {
 626         return api.RequestMessage
 627 }
 628 func (*IP6ndProxyDump) GetCrcString() string {
 629         return "21597d88"
 630 }
 631 func NewIP6ndProxyDump() api.Message {
 632         return &IP6ndProxyDump{}
 633 }
 634
 635 // SwInterfaceIP6EnableDisable represents the VPP binary API message 'sw_interface_ip6_enable_disable'.
 636 // Generated from 'bin_api/ip.api.json', line 182:
 637 //
 638 //        ["sw_interface_ip6_enable_disable",
 639 //            ["u16", "_vl_msg_id"],
 640 //            ["u32", "client_index"],
 641 //            ["u32", "context"],
 642 //            ["u32", "sw_if_index"],
 643 //            ["u8", "enable"],
 644 //            {"crc" : "0x4a4e5405"}
 645 //        ],
 646 //
 647 type SwInterfaceIP6EnableDisable struct {
 648         SwIfIndex uint32
 649         Enable    uint8
 650 }
 651
 652 func (*SwInterfaceIP6EnableDisable) GetMessageName() string {
 653         return "sw_interface_ip6_enable_disable"
 654 }
 655 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
 656         return api.RequestMessage
 657 }
 658 func (*SwInterfaceIP6EnableDisable) GetCrcString() string {
 659         return "4a4e5405"
 660 }
 661 func NewSwInterfaceIP6EnableDisable() api.Message {
 662         return &SwInterfaceIP6EnableDisable{}
 663 }
 664
 665 // SwInterfaceIP6EnableDisableReply represents the VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
 666 // Generated from 'bin_api/ip.api.json', line 190:
 667 //
 668 //        ["sw_interface_ip6_enable_disable_reply",
 669 //            ["u16", "_vl_msg_id"],
 670 //            ["u32", "context"],
 671 //            ["i32", "retval"],
 672 //            {"crc" : "0xeb8b4a40"}
 673 //        ],
 674 //
 675 type SwInterfaceIP6EnableDisableReply struct {
 676         Retval int32
 677 }
 678
 679 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
 680         return "sw_interface_ip6_enable_disable_reply"
 681 }
 682 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
 683         return api.ReplyMessage
 684 }
 685 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string {
 686         return "eb8b4a40"
 687 }
 688 func NewSwInterfaceIP6EnableDisableReply() api.Message {
 689         return &SwInterfaceIP6EnableDisableReply{}
 690 }
 691
 692 // SwInterfaceIP6SetLinkLocalAddress represents the VPP binary API message 'sw_interface_ip6_set_link_local_address'.
 693 // Generated from 'bin_api/ip.api.json', line 196:
 694 //
 695 //        ["sw_interface_ip6_set_link_local_address",
 696 //            ["u16", "_vl_msg_id"],
 697 //            ["u32", "client_index"],
 698 //            ["u32", "context"],
 699 //            ["u32", "sw_if_index"],
 700 //            ["u8", "address", 16],
 701 //            {"crc" : "0x3db6d52b"}
 702 //        ],
 703 //
 704 type SwInterfaceIP6SetLinkLocalAddress struct {
 705         SwIfIndex uint32
 706         Address   []byte `struc:"[16]byte"`
 707 }
 708
 709 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
 710         return "sw_interface_ip6_set_link_local_address"
 711 }
 712 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
 713         return api.RequestMessage
 714 }
 715 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string {
 716         return "3db6d52b"
 717 }
 718 func NewSwInterfaceIP6SetLinkLocalAddress() api.Message {
 719         return &SwInterfaceIP6SetLinkLocalAddress{}
 720 }
 721
 722 // SwInterfaceIP6SetLinkLocalAddressReply represents the VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
 723 // Generated from 'bin_api/ip.api.json', line 204:
 724 //
 725 //        ["sw_interface_ip6_set_link_local_address_reply",
 726 //            ["u16", "_vl_msg_id"],
 727 //            ["u32", "context"],
 728 //            ["i32", "retval"],
 729 //            {"crc" : "0x0a781e17"}
 730 //        ],
 731 //
 732 type SwInterfaceIP6SetLinkLocalAddressReply struct {
 733         Retval int32
 734 }
 735
 736 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
 737         return "sw_interface_ip6_set_link_local_address_reply"
 738 }
 739 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
 740         return api.ReplyMessage
 741 }
 742 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string {
 743         return "0a781e17"
 744 }
 745 func NewSwInterfaceIP6SetLinkLocalAddressReply() api.Message {
 746         return &SwInterfaceIP6SetLinkLocalAddressReply{}
 747 }
 748
 749 // IPAddDelRoute represents the VPP binary API message 'ip_add_del_route'.
 750 // Generated from 'bin_api/ip.api.json', line 210:
 751 //
 752 //        ["ip_add_del_route",
 753 //            ["u16", "_vl_msg_id"],
 754 //            ["u32", "client_index"],
 755 //            ["u32", "context"],
 756 //            ["u32", "next_hop_sw_if_index"],
 757 //            ["u32", "table_id"],
 758 //            ["u32", "classify_table_index"],
 759 //            ["u32", "next_hop_table_id"],
 760 //            ["u8", "create_vrf_if_needed"],
 761 //            ["u8", "is_add"],
 762 //            ["u8", "is_drop"],
 763 //            ["u8", "is_unreach"],
 764 //            ["u8", "is_prohibit"],
 765 //            ["u8", "is_ipv6"],
 766 //            ["u8", "is_local"],
 767 //            ["u8", "is_classify"],
 768 //            ["u8", "is_multipath"],
 769 //            ["u8", "is_resolve_host"],
 770 //            ["u8", "is_resolve_attached"],
 771 //            ["u8", "not_last"],
 772 //            ["u8", "next_hop_weight"],
 773 //            ["u8", "dst_address_length"],
 774 //            ["u8", "dst_address", 16],
 775 //            ["u8", "next_hop_address", 16],
 776 //            ["u8", "next_hop_n_out_labels"],
 777 //            ["u32", "next_hop_via_label"],
 778 //            ["u32", "next_hop_out_label_stack", 0, "next_hop_n_out_labels"],
 779 //            {"crc" : "0xa0ab24bf"}
 780 //        ],
 781 //
 782 type IPAddDelRoute struct {
 783         NextHopSwIfIndex     uint32
 784         TableID              uint32
 785         ClassifyTableIndex   uint32
 786         NextHopTableID       uint32
 787         CreateVrfIfNeeded    uint8
 788         IsAdd                uint8
 789         IsDrop               uint8
 790         IsUnreach            uint8
 791         IsProhibit           uint8
 792         IsIpv6               uint8
 793         IsLocal              uint8
 794         IsClassify           uint8
 795         IsMultipath          uint8
 796         IsResolveHost        uint8
 797         IsResolveAttached    uint8
 798         NotLast              uint8
 799         NextHopWeight        uint8
 800         DstAddressLength     uint8
 801         DstAddress           []byte `struc:"[16]byte"`
 802         NextHopAddress       []byte `struc:"[16]byte"`
 803         NextHopNOutLabels    uint8  `struc:"sizeof=NextHopOutLabelStack"`
 804         NextHopViaLabel      uint32
 805         NextHopOutLabelStack []uint32
 806 }
 807
 808 func (*IPAddDelRoute) GetMessageName() string {
 809         return "ip_add_del_route"
 810 }
 811 func (*IPAddDelRoute) GetMessageType() api.MessageType {
 812         return api.RequestMessage
 813 }
 814 func (*IPAddDelRoute) GetCrcString() string {
 815         return "a0ab24bf"
 816 }
 817 func NewIPAddDelRoute() api.Message {
 818         return &IPAddDelRoute{}
 819 }
 820
 821 // IPAddDelRouteReply represents the VPP binary API message 'ip_add_del_route_reply'.
 822 // Generated from 'bin_api/ip.api.json', line 239:
 823 //
 824 //        ["ip_add_del_route_reply",
 825 //            ["u16", "_vl_msg_id"],
 826 //            ["u32", "context"],
 827 //            ["i32", "retval"],
 828 //            {"crc" : "0xea57492b"}
 829 //        ],
 830 //
 831 type IPAddDelRouteReply struct {
 832         Retval int32
 833 }
 834
 835 func (*IPAddDelRouteReply) GetMessageName() string {
 836         return "ip_add_del_route_reply"
 837 }
 838 func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
 839         return api.ReplyMessage
 840 }
 841 func (*IPAddDelRouteReply) GetCrcString() string {
 842         return "ea57492b"
 843 }
 844 func NewIPAddDelRouteReply() api.Message {
 845         return &IPAddDelRouteReply{}
 846 }
 847
 848 // IPMrouteAddDel represents the VPP binary API message 'ip_mroute_add_del'.
 849 // Generated from 'bin_api/ip.api.json', line 245:
 850 //
 851 //        ["ip_mroute_add_del",
 852 //            ["u16", "_vl_msg_id"],
 853 //            ["u32", "client_index"],
 854 //            ["u32", "context"],
 855 //            ["u32", "next_hop_sw_if_index"],
 856 //            ["u32", "table_id"],
 857 //            ["u32", "entry_flags"],
 858 //            ["u32", "itf_flags"],
 859 //            ["u32", "rpf_id"],
 860 //            ["u16", "grp_address_length"],
 861 //            ["u8", "create_vrf_if_needed"],
 862 //            ["u8", "is_add"],
 863 //            ["u8", "is_ipv6"],
 864 //            ["u8", "is_local"],
 865 //            ["u8", "grp_address", 16],
 866 //            ["u8", "src_address", 16],
 867 //            {"crc" : "0x8f5f21a8"}
 868 //        ],
 869 //
 870 type IPMrouteAddDel struct {
 871         NextHopSwIfIndex  uint32
 872         TableID           uint32
 873         EntryFlags        uint32
 874         ItfFlags          uint32
 875         RpfID             uint32
 876         GrpAddressLength  uint16
 877         CreateVrfIfNeeded uint8
 878         IsAdd             uint8
 879         IsIpv6            uint8
 880         IsLocal           uint8
 881         GrpAddress        []byte `struc:"[16]byte"`
 882         SrcAddress        []byte `struc:"[16]byte"`
 883 }
 884
 885 func (*IPMrouteAddDel) GetMessageName() string {
 886         return "ip_mroute_add_del"
 887 }
 888 func (*IPMrouteAddDel) GetMessageType() api.MessageType {
 889         return api.RequestMessage
 890 }
 891 func (*IPMrouteAddDel) GetCrcString() string {
 892         return "8f5f21a8"
 893 }
 894 func NewIPMrouteAddDel() api.Message {
 895         return &IPMrouteAddDel{}
 896 }
 897
 898 // IPMrouteAddDelReply represents the VPP binary API message 'ip_mroute_add_del_reply'.
 899 // Generated from 'bin_api/ip.api.json', line 263:
 900 //
 901 //        ["ip_mroute_add_del_reply",
 902 //            ["u16", "_vl_msg_id"],
 903 //            ["u32", "context"],
 904 //            ["i32", "retval"],
 905 //            {"crc" : "0x8cabe02c"}
 906 //        ],
 907 //
 908 type IPMrouteAddDelReply struct {
 909         Retval int32
 910 }
 911
 912 func (*IPMrouteAddDelReply) GetMessageName() string {
 913         return "ip_mroute_add_del_reply"
 914 }
 915 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
 916         return api.ReplyMessage
 917 }
 918 func (*IPMrouteAddDelReply) GetCrcString() string {
 919         return "8cabe02c"
 920 }
 921 func NewIPMrouteAddDelReply() api.Message {
 922         return &IPMrouteAddDelReply{}
 923 }
 924
 925 // IPMfibDump represents the VPP binary API message 'ip_mfib_dump'.
 926 // Generated from 'bin_api/ip.api.json', line 269:
 927 //
 928 //        ["ip_mfib_dump",
 929 //            ["u16", "_vl_msg_id"],
 930 //            ["u32", "client_index"],
 931 //            ["u32", "context"],
 932 //            {"crc" : "0xee61390e"}
 933 //        ],
 934 //
 935 type IPMfibDump struct {
 936 }
 937
 938 func (*IPMfibDump) GetMessageName() string {
 939         return "ip_mfib_dump"
 940 }
 941 func (*IPMfibDump) GetMessageType() api.MessageType {
 942         return api.RequestMessage
 943 }
 944 func (*IPMfibDump) GetCrcString() string {
 945         return "ee61390e"
 946 }
 947 func NewIPMfibDump() api.Message {
 948         return &IPMfibDump{}
 949 }
 950
 951 // IPMfibDetails represents the VPP binary API message 'ip_mfib_details'.
 952 // Generated from 'bin_api/ip.api.json', line 275:
 953 //
 954 //        ["ip_mfib_details",
 955 //            ["u16", "_vl_msg_id"],
 956 //            ["u32", "context"],
 957 //            ["u32", "table_id"],
 958 //            ["u32", "entry_flags"],
 959 //            ["u32", "rpf_id"],
 960 //            ["u8", "address_length"],
 961 //            ["u8", "grp_address", 4],
 962 //            ["u8", "src_address", 4],
 963 //            ["u32", "count"],
 964 //            ["vl_api_fib_path_t", "path", 0, "count"],
 965 //            {"crc" : "0x395e5699"}
 966 //        ],
 967 //
 968 type IPMfibDetails struct {
 969         TableID       uint32
 970         EntryFlags    uint32
 971         RpfID         uint32
 972         AddressLength uint8
 973         GrpAddress    []byte `struc:"[4]byte"`
 974         SrcAddress    []byte `struc:"[4]byte"`
 975         Count         uint32 `struc:"sizeof=Path"`
 976         Path          []FibPath
 977 }
 978
 979 func (*IPMfibDetails) GetMessageName() string {
 980         return "ip_mfib_details"
 981 }
 982 func (*IPMfibDetails) GetMessageType() api.MessageType {
 983         return api.ReplyMessage
 984 }
 985 func (*IPMfibDetails) GetCrcString() string {
 986         return "395e5699"
 987 }
 988 func NewIPMfibDetails() api.Message {
 989         return &IPMfibDetails{}
 990 }
 991
 992 // IP6MfibDump represents the VPP binary API message 'ip6_mfib_dump'.
 993 // Generated from 'bin_api/ip.api.json', line 288:
 994 //
 995 //        ["ip6_mfib_dump",
 996 //            ["u16", "_vl_msg_id"],
 997 //            ["u32", "client_index"],
 998 //            ["u32", "context"],
 999 //            {"crc" : "0x0839e143"}
1000 //        ],
1001 //
1002 type IP6MfibDump struct {
1003 }
1004
1005 func (*IP6MfibDump) GetMessageName() string {
1006         return "ip6_mfib_dump"
1007 }
1008 func (*IP6MfibDump) GetMessageType() api.MessageType {
1009         return api.RequestMessage
1010 }
1011 func (*IP6MfibDump) GetCrcString() string {
1012         return "0839e143"
1013 }
1014 func NewIP6MfibDump() api.Message {
1015         return &IP6MfibDump{}
1016 }
1017
1018 // IP6MfibDetails represents the VPP binary API message 'ip6_mfib_details'.
1019 // Generated from 'bin_api/ip.api.json', line 294:
1020 //
1021 //        ["ip6_mfib_details",
1022 //            ["u16", "_vl_msg_id"],
1023 //            ["u32", "context"],
1024 //            ["u32", "table_id"],
1025 //            ["u8", "address_length"],
1026 //            ["u8", "grp_address", 16],
1027 //            ["u8", "src_address", 16],
1028 //            ["u32", "count"],
1029 //            ["vl_api_fib_path_t", "path", 0, "count"],
1030 //            {"crc" : "0x921b153f"}
1031 //        ],
1032 //
1033 type IP6MfibDetails struct {
1034         TableID       uint32
1035         AddressLength uint8
1036         GrpAddress    []byte `struc:"[16]byte"`
1037         SrcAddress    []byte `struc:"[16]byte"`
1038         Count         uint32 `struc:"sizeof=Path"`
1039         Path          []FibPath
1040 }
1041
1042 func (*IP6MfibDetails) GetMessageName() string {
1043         return "ip6_mfib_details"
1044 }
1045 func (*IP6MfibDetails) GetMessageType() api.MessageType {
1046         return api.ReplyMessage
1047 }
1048 func (*IP6MfibDetails) GetCrcString() string {
1049         return "921b153f"
1050 }
1051 func NewIP6MfibDetails() api.Message {
1052         return &IP6MfibDetails{}
1053 }
1054
1055 // IPAddressDetails represents the VPP binary API message 'ip_address_details'.
1056 // Generated from 'bin_api/ip.api.json', line 305:
1057 //
1058 //        ["ip_address_details",
1059 //            ["u16", "_vl_msg_id"],
1060 //            ["u32", "client_index"],
1061 //            ["u32", "context"],
1062 //            ["u8", "ip", 16],
1063 //            ["u8", "prefix_length"],
1064 //            ["u32", "sw_if_index"],
1065 //            ["u8", "is_ipv6"],
1066 //            {"crc" : "0x190d4266"}
1067 //        ],
1068 //
1069 type IPAddressDetails struct {
1070         IP           []byte `struc:"[16]byte"`
1071         PrefixLength uint8
1072         SwIfIndex    uint32
1073         IsIpv6       uint8
1074 }
1075
1076 func (*IPAddressDetails) GetMessageName() string {
1077         return "ip_address_details"
1078 }
1079 func (*IPAddressDetails) GetMessageType() api.MessageType {
1080         return api.RequestMessage
1081 }
1082 func (*IPAddressDetails) GetCrcString() string {
1083         return "190d4266"
1084 }
1085 func NewIPAddressDetails() api.Message {
1086         return &IPAddressDetails{}
1087 }
1088
1089 // IPAddressDump represents the VPP binary API message 'ip_address_dump'.
1090 // Generated from 'bin_api/ip.api.json', line 315:
1091 //
1092 //        ["ip_address_dump",
1093 //            ["u16", "_vl_msg_id"],
1094 //            ["u32", "client_index"],
1095 //            ["u32", "context"],
1096 //            ["u32", "sw_if_index"],
1097 //            ["u8", "is_ipv6"],
1098 //            {"crc" : "0x632e859a"}
1099 //        ],
1100 //
1101 type IPAddressDump struct {
1102         SwIfIndex uint32
1103         IsIpv6    uint8
1104 }
1105
1106 func (*IPAddressDump) GetMessageName() string {
1107         return "ip_address_dump"
1108 }
1109 func (*IPAddressDump) GetMessageType() api.MessageType {
1110         return api.RequestMessage
1111 }
1112 func (*IPAddressDump) GetCrcString() string {
1113         return "632e859a"
1114 }
1115 func NewIPAddressDump() api.Message {
1116         return &IPAddressDump{}
1117 }
1118
1119 // IPDetails represents the VPP binary API message 'ip_details'.
1120 // Generated from 'bin_api/ip.api.json', line 323:
1121 //
1122 //        ["ip_details",
1123 //            ["u16", "_vl_msg_id"],
1124 //            ["u32", "sw_if_index"],
1125 //            ["u32", "context"],
1126 //            ["u8", "is_ipv6"],
1127 //            {"crc" : "0x695c8227"}
1128 //        ],
1129 //
1130 type IPDetails struct {
1131         SwIfIndex uint32
1132         Context   uint32
1133         IsIpv6    uint8
1134 }
1135
1136 func (*IPDetails) GetMessageName() string {
1137         return "ip_details"
1138 }
1139 func (*IPDetails) GetMessageType() api.MessageType {
1140         return api.OtherMessage
1141 }
1142 func (*IPDetails) GetCrcString() string {
1143         return "695c8227"
1144 }
1145 func NewIPDetails() api.Message {
1146         return &IPDetails{}
1147 }
1148
1149 // IPDump represents the VPP binary API message 'ip_dump'.
1150 // Generated from 'bin_api/ip.api.json', line 330:
1151 //
1152 //        ["ip_dump",
1153 //            ["u16", "_vl_msg_id"],
1154 //            ["u32", "client_index"],
1155 //            ["u32", "context"],
1156 //            ["u8", "is_ipv6"],
1157 //            {"crc" : "0x3c1e33e0"}
1158 //        ],
1159 //
1160 type IPDump struct {
1161         IsIpv6 uint8
1162 }
1163
1164 func (*IPDump) GetMessageName() string {
1165         return "ip_dump"
1166 }
1167 func (*IPDump) GetMessageType() api.MessageType {
1168         return api.RequestMessage
1169 }
1170 func (*IPDump) GetCrcString() string {
1171         return "3c1e33e0"
1172 }
1173 func NewIPDump() api.Message {
1174         return &IPDump{}
1175 }
1176
1177 // MfibSignalDump represents the VPP binary API message 'mfib_signal_dump'.
1178 // Generated from 'bin_api/ip.api.json', line 337:
1179 //
1180 //        ["mfib_signal_dump",
1181 //            ["u16", "_vl_msg_id"],
1182 //            ["u32", "client_index"],
1183 //            ["u32", "context"],
1184 //            {"crc" : "0xbbbbd40d"}
1185 //        ],
1186 //
1187 type MfibSignalDump struct {
1188 }
1189
1190 func (*MfibSignalDump) GetMessageName() string {
1191         return "mfib_signal_dump"
1192 }
1193 func (*MfibSignalDump) GetMessageType() api.MessageType {
1194         return api.RequestMessage
1195 }
1196 func (*MfibSignalDump) GetCrcString() string {
1197         return "bbbbd40d"
1198 }
1199 func NewMfibSignalDump() api.Message {
1200         return &MfibSignalDump{}
1201 }
1202
1203 // MfibSignalDetails represents the VPP binary API message 'mfib_signal_details'.
1204 // Generated from 'bin_api/ip.api.json', line 343:
1205 //
1206 //        ["mfib_signal_details",
1207 //            ["u16", "_vl_msg_id"],
1208 //            ["u32", "client_index"],
1209 //            ["u32", "context"],
1210 //            ["u32", "sw_if_index"],
1211 //            ["u32", "table_id"],
1212 //            ["u16", "grp_address_len"],
1213 //            ["u8", "grp_address", 16],
1214 //            ["u8", "src_address", 16],
1215 //            ["u16", "ip_packet_len"],
1216 //            ["u8", "ip_packet_data", 256],
1217 //            {"crc" : "0x6ba92c72"}
1218 //        ]
1219 //
1220 type MfibSignalDetails struct {
1221         SwIfIndex     uint32
1222         TableID       uint32
1223         GrpAddressLen uint16
1224         GrpAddress    []byte `struc:"[16]byte"`
1225         SrcAddress    []byte `struc:"[16]byte"`
1226         IPPacketLen   uint16
1227         IPPacketData  []byte `struc:"[256]byte"`
1228 }
1229
1230 func (*MfibSignalDetails) GetMessageName() string {
1231         return "mfib_signal_details"
1232 }
1233 func (*MfibSignalDetails) GetMessageType() api.MessageType {
1234         return api.RequestMessage
1235 }
1236 func (*MfibSignalDetails) GetCrcString() string {
1237         return "6ba92c72"
1238 }
1239 func NewMfibSignalDetails() api.Message {
1240         return &MfibSignalDetails{}
1241 }