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' on Thu, 04 May 2017 13:11:57 CEST.
   3 package ip
   4
   5 import "gerrit.fd.io/r/govpp.git/api"
   6
   7 // VlApiVersion contains version of the API.
   8 const VlAPIVersion = 0x6a819870
   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", "vrf_id"],
 236 //            ["u32", "sw_if_index"],
 237 //            ["u8", "is_add"],
 238 //            ["u8", "is_ipv6"],
 239 //            ["u8", "is_static"],
 240 //            ["u8", "mac_address", 6],
 241 //            ["u8", "dst_address", 16],
 242 //            {"crc" : "0x66f2112c"}
 243 //        ],
 244 //
 245 type IPNeighborAddDel struct {
 246         VrfID      uint32
 247         SwIfIndex  uint32
 248         IsAdd      uint8
 249         IsIpv6     uint8
 250         IsStatic   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 "66f2112c"
 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 // SwInterfaceIP6EnableDisable represents the VPP binary API message 'sw_interface_ip6_enable_disable'.
 521 // Generated from 'bin_api/ip.api.json', line 153:
 522 //
 523 //        ["sw_interface_ip6_enable_disable",
 524 //            ["u16", "_vl_msg_id"],
 525 //            ["u32", "client_index"],
 526 //            ["u32", "context"],
 527 //            ["u32", "sw_if_index"],
 528 //            ["u8", "enable"],
 529 //            {"crc" : "0x4a4e5405"}
 530 //        ],
 531 //
 532 type SwInterfaceIP6EnableDisable struct {
 533         SwIfIndex uint32
 534         Enable    uint8
 535 }
 536
 537 func (*SwInterfaceIP6EnableDisable) GetMessageName() string {
 538         return "sw_interface_ip6_enable_disable"
 539 }
 540 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType {
 541         return api.RequestMessage
 542 }
 543 func (*SwInterfaceIP6EnableDisable) GetCrcString() string {
 544         return "4a4e5405"
 545 }
 546 func NewSwInterfaceIP6EnableDisable() api.Message {
 547         return &SwInterfaceIP6EnableDisable{}
 548 }
 549
 550 // SwInterfaceIP6EnableDisableReply represents the VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
 551 // Generated from 'bin_api/ip.api.json', line 161:
 552 //
 553 //        ["sw_interface_ip6_enable_disable_reply",
 554 //            ["u16", "_vl_msg_id"],
 555 //            ["u32", "context"],
 556 //            ["i32", "retval"],
 557 //            {"crc" : "0xeb8b4a40"}
 558 //        ],
 559 //
 560 type SwInterfaceIP6EnableDisableReply struct {
 561         Retval int32
 562 }
 563
 564 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
 565         return "sw_interface_ip6_enable_disable_reply"
 566 }
 567 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType {
 568         return api.ReplyMessage
 569 }
 570 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string {
 571         return "eb8b4a40"
 572 }
 573 func NewSwInterfaceIP6EnableDisableReply() api.Message {
 574         return &SwInterfaceIP6EnableDisableReply{}
 575 }
 576
 577 // SwInterfaceIP6SetLinkLocalAddress represents the VPP binary API message 'sw_interface_ip6_set_link_local_address'.
 578 // Generated from 'bin_api/ip.api.json', line 167:
 579 //
 580 //        ["sw_interface_ip6_set_link_local_address",
 581 //            ["u16", "_vl_msg_id"],
 582 //            ["u32", "client_index"],
 583 //            ["u32", "context"],
 584 //            ["u32", "sw_if_index"],
 585 //            ["u8", "address", 16],
 586 //            {"crc" : "0x3db6d52b"}
 587 //        ],
 588 //
 589 type SwInterfaceIP6SetLinkLocalAddress struct {
 590         SwIfIndex uint32
 591         Address   []byte `struc:"[16]byte"`
 592 }
 593
 594 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
 595         return "sw_interface_ip6_set_link_local_address"
 596 }
 597 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType {
 598         return api.RequestMessage
 599 }
 600 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string {
 601         return "3db6d52b"
 602 }
 603 func NewSwInterfaceIP6SetLinkLocalAddress() api.Message {
 604         return &SwInterfaceIP6SetLinkLocalAddress{}
 605 }
 606
 607 // SwInterfaceIP6SetLinkLocalAddressReply represents the VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
 608 // Generated from 'bin_api/ip.api.json', line 175:
 609 //
 610 //        ["sw_interface_ip6_set_link_local_address_reply",
 611 //            ["u16", "_vl_msg_id"],
 612 //            ["u32", "context"],
 613 //            ["i32", "retval"],
 614 //            {"crc" : "0x0a781e17"}
 615 //        ],
 616 //
 617 type SwInterfaceIP6SetLinkLocalAddressReply struct {
 618         Retval int32
 619 }
 620
 621 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
 622         return "sw_interface_ip6_set_link_local_address_reply"
 623 }
 624 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
 625         return api.ReplyMessage
 626 }
 627 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string {
 628         return "0a781e17"
 629 }
 630 func NewSwInterfaceIP6SetLinkLocalAddressReply() api.Message {
 631         return &SwInterfaceIP6SetLinkLocalAddressReply{}
 632 }
 633
 634 // IPAddDelRoute represents the VPP binary API message 'ip_add_del_route'.
 635 // Generated from 'bin_api/ip.api.json', line 181:
 636 //
 637 //        ["ip_add_del_route",
 638 //            ["u16", "_vl_msg_id"],
 639 //            ["u32", "client_index"],
 640 //            ["u32", "context"],
 641 //            ["u32", "next_hop_sw_if_index"],
 642 //            ["u32", "table_id"],
 643 //            ["u32", "classify_table_index"],
 644 //            ["u32", "next_hop_table_id"],
 645 //            ["u8", "create_vrf_if_needed"],
 646 //            ["u8", "is_add"],
 647 //            ["u8", "is_drop"],
 648 //            ["u8", "is_unreach"],
 649 //            ["u8", "is_prohibit"],
 650 //            ["u8", "is_ipv6"],
 651 //            ["u8", "is_local"],
 652 //            ["u8", "is_classify"],
 653 //            ["u8", "is_multipath"],
 654 //            ["u8", "is_resolve_host"],
 655 //            ["u8", "is_resolve_attached"],
 656 //            ["u8", "not_last"],
 657 //            ["u8", "next_hop_weight"],
 658 //            ["u8", "dst_address_length"],
 659 //            ["u8", "dst_address", 16],
 660 //            ["u8", "next_hop_address", 16],
 661 //            ["u8", "next_hop_n_out_labels"],
 662 //            ["u32", "next_hop_via_label"],
 663 //            ["u32", "next_hop_out_label_stack", 0, "next_hop_n_out_labels"],
 664 //            {"crc" : "0xa0ab24bf"}
 665 //        ],
 666 //
 667 type IPAddDelRoute struct {
 668         NextHopSwIfIndex     uint32
 669         TableID              uint32
 670         ClassifyTableIndex   uint32
 671         NextHopTableID       uint32
 672         CreateVrfIfNeeded    uint8
 673         IsAdd                uint8
 674         IsDrop               uint8
 675         IsUnreach            uint8
 676         IsProhibit           uint8
 677         IsIpv6               uint8
 678         IsLocal              uint8
 679         IsClassify           uint8
 680         IsMultipath          uint8
 681         IsResolveHost        uint8
 682         IsResolveAttached    uint8
 683         NotLast              uint8
 684         NextHopWeight        uint8
 685         DstAddressLength     uint8
 686         DstAddress           []byte `struc:"[16]byte"`
 687         NextHopAddress       []byte `struc:"[16]byte"`
 688         NextHopNOutLabels    uint8  `struc:"sizeof=NextHopOutLabelStack"`
 689         NextHopViaLabel      uint32
 690         NextHopOutLabelStack []uint32
 691 }
 692
 693 func (*IPAddDelRoute) GetMessageName() string {
 694         return "ip_add_del_route"
 695 }
 696 func (*IPAddDelRoute) GetMessageType() api.MessageType {
 697         return api.RequestMessage
 698 }
 699 func (*IPAddDelRoute) GetCrcString() string {
 700         return "a0ab24bf"
 701 }
 702 func NewIPAddDelRoute() api.Message {
 703         return &IPAddDelRoute{}
 704 }
 705
 706 // IPAddDelRouteReply represents the VPP binary API message 'ip_add_del_route_reply'.
 707 // Generated from 'bin_api/ip.api.json', line 210:
 708 //
 709 //        ["ip_add_del_route_reply",
 710 //            ["u16", "_vl_msg_id"],
 711 //            ["u32", "context"],
 712 //            ["i32", "retval"],
 713 //            {"crc" : "0xea57492b"}
 714 //        ],
 715 //
 716 type IPAddDelRouteReply struct {
 717         Retval int32
 718 }
 719
 720 func (*IPAddDelRouteReply) GetMessageName() string {
 721         return "ip_add_del_route_reply"
 722 }
 723 func (*IPAddDelRouteReply) GetMessageType() api.MessageType {
 724         return api.ReplyMessage
 725 }
 726 func (*IPAddDelRouteReply) GetCrcString() string {
 727         return "ea57492b"
 728 }
 729 func NewIPAddDelRouteReply() api.Message {
 730         return &IPAddDelRouteReply{}
 731 }
 732
 733 // IPMrouteAddDel represents the VPP binary API message 'ip_mroute_add_del'.
 734 // Generated from 'bin_api/ip.api.json', line 216:
 735 //
 736 //        ["ip_mroute_add_del",
 737 //            ["u16", "_vl_msg_id"],
 738 //            ["u32", "client_index"],
 739 //            ["u32", "context"],
 740 //            ["u32", "next_hop_sw_if_index"],
 741 //            ["u32", "table_id"],
 742 //            ["u32", "entry_flags"],
 743 //            ["u32", "itf_flags"],
 744 //            ["u16", "grp_address_length"],
 745 //            ["u8", "create_vrf_if_needed"],
 746 //            ["u8", "is_add"],
 747 //            ["u8", "is_ipv6"],
 748 //            ["u8", "is_local"],
 749 //            ["u8", "grp_address", 16],
 750 //            ["u8", "src_address", 16],
 751 //            {"crc" : "0x8312830f"}
 752 //        ],
 753 //
 754 type IPMrouteAddDel struct {
 755         NextHopSwIfIndex  uint32
 756         TableID           uint32
 757         EntryFlags        uint32
 758         ItfFlags          uint32
 759         GrpAddressLength  uint16
 760         CreateVrfIfNeeded uint8
 761         IsAdd             uint8
 762         IsIpv6            uint8
 763         IsLocal           uint8
 764         GrpAddress        []byte `struc:"[16]byte"`
 765         SrcAddress        []byte `struc:"[16]byte"`
 766 }
 767
 768 func (*IPMrouteAddDel) GetMessageName() string {
 769         return "ip_mroute_add_del"
 770 }
 771 func (*IPMrouteAddDel) GetMessageType() api.MessageType {
 772         return api.RequestMessage
 773 }
 774 func (*IPMrouteAddDel) GetCrcString() string {
 775         return "8312830f"
 776 }
 777 func NewIPMrouteAddDel() api.Message {
 778         return &IPMrouteAddDel{}
 779 }
 780
 781 // IPMrouteAddDelReply represents the VPP binary API message 'ip_mroute_add_del_reply'.
 782 // Generated from 'bin_api/ip.api.json', line 233:
 783 //
 784 //        ["ip_mroute_add_del_reply",
 785 //            ["u16", "_vl_msg_id"],
 786 //            ["u32", "context"],
 787 //            ["i32", "retval"],
 788 //            {"crc" : "0x8cabe02c"}
 789 //        ],
 790 //
 791 type IPMrouteAddDelReply struct {
 792         Retval int32
 793 }
 794
 795 func (*IPMrouteAddDelReply) GetMessageName() string {
 796         return "ip_mroute_add_del_reply"
 797 }
 798 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType {
 799         return api.ReplyMessage
 800 }
 801 func (*IPMrouteAddDelReply) GetCrcString() string {
 802         return "8cabe02c"
 803 }
 804 func NewIPMrouteAddDelReply() api.Message {
 805         return &IPMrouteAddDelReply{}
 806 }
 807
 808 // IPAddressDetails represents the VPP binary API message 'ip_address_details'.
 809 // Generated from 'bin_api/ip.api.json', line 239:
 810 //
 811 //        ["ip_address_details",
 812 //            ["u16", "_vl_msg_id"],
 813 //            ["u32", "client_index"],
 814 //            ["u32", "context"],
 815 //            ["u8", "ip", 16],
 816 //            ["u8", "prefix_length"],
 817 //            ["u32", "sw_if_index"],
 818 //            ["u8", "is_ipv6"],
 819 //            {"crc" : "0x190d4266"}
 820 //        ],
 821 //
 822 type IPAddressDetails struct {
 823         IP           []byte `struc:"[16]byte"`
 824         PrefixLength uint8
 825         SwIfIndex    uint32
 826         IsIpv6       uint8
 827 }
 828
 829 func (*IPAddressDetails) GetMessageName() string {
 830         return "ip_address_details"
 831 }
 832 func (*IPAddressDetails) GetMessageType() api.MessageType {
 833         return api.RequestMessage
 834 }
 835 func (*IPAddressDetails) GetCrcString() string {
 836         return "190d4266"
 837 }
 838 func NewIPAddressDetails() api.Message {
 839         return &IPAddressDetails{}
 840 }
 841
 842 // IPAddressDump represents the VPP binary API message 'ip_address_dump'.
 843 // Generated from 'bin_api/ip.api.json', line 249:
 844 //
 845 //        ["ip_address_dump",
 846 //            ["u16", "_vl_msg_id"],
 847 //            ["u32", "client_index"],
 848 //            ["u32", "context"],
 849 //            ["u32", "sw_if_index"],
 850 //            ["u8", "is_ipv6"],
 851 //            {"crc" : "0x632e859a"}
 852 //        ],
 853 //
 854 type IPAddressDump struct {
 855         SwIfIndex uint32
 856         IsIpv6    uint8
 857 }
 858
 859 func (*IPAddressDump) GetMessageName() string {
 860         return "ip_address_dump"
 861 }
 862 func (*IPAddressDump) GetMessageType() api.MessageType {
 863         return api.RequestMessage
 864 }
 865 func (*IPAddressDump) GetCrcString() string {
 866         return "632e859a"
 867 }
 868 func NewIPAddressDump() api.Message {
 869         return &IPAddressDump{}
 870 }
 871
 872 // IPDetails represents the VPP binary API message 'ip_details'.
 873 // Generated from 'bin_api/ip.api.json', line 257:
 874 //
 875 //        ["ip_details",
 876 //            ["u16", "_vl_msg_id"],
 877 //            ["u32", "sw_if_index"],
 878 //            ["u32", "context"],
 879 //            ["u8", "is_ipv6"],
 880 //            {"crc" : "0x695c8227"}
 881 //        ],
 882 //
 883 type IPDetails struct {
 884         SwIfIndex uint32
 885         Context   uint32
 886         IsIpv6    uint8
 887 }
 888
 889 func (*IPDetails) GetMessageName() string {
 890         return "ip_details"
 891 }
 892 func (*IPDetails) GetMessageType() api.MessageType {
 893         return api.OtherMessage
 894 }
 895 func (*IPDetails) GetCrcString() string {
 896         return "695c8227"
 897 }
 898 func NewIPDetails() api.Message {
 899         return &IPDetails{}
 900 }
 901
 902 // IPDump represents the VPP binary API message 'ip_dump'.
 903 // Generated from 'bin_api/ip.api.json', line 264:
 904 //
 905 //        ["ip_dump",
 906 //            ["u16", "_vl_msg_id"],
 907 //            ["u32", "client_index"],
 908 //            ["u32", "context"],
 909 //            ["u8", "is_ipv6"],
 910 //            {"crc" : "0x3c1e33e0"}
 911 //        ],
 912 //
 913 type IPDump struct {
 914         IsIpv6 uint8
 915 }
 916
 917 func (*IPDump) GetMessageName() string {
 918         return "ip_dump"
 919 }
 920 func (*IPDump) GetMessageType() api.MessageType {
 921         return api.RequestMessage
 922 }
 923 func (*IPDump) GetCrcString() string {
 924         return "3c1e33e0"
 925 }
 926 func NewIPDump() api.Message {
 927         return &IPDump{}
 928 }
 929
 930 // MfibSignalDump represents the VPP binary API message 'mfib_signal_dump'.
 931 // Generated from 'bin_api/ip.api.json', line 271:
 932 //
 933 //        ["mfib_signal_dump",
 934 //            ["u16", "_vl_msg_id"],
 935 //            ["u32", "client_index"],
 936 //            ["u32", "context"],
 937 //            {"crc" : "0xbbbbd40d"}
 938 //        ],
 939 //
 940 type MfibSignalDump struct {
 941 }
 942
 943 func (*MfibSignalDump) GetMessageName() string {
 944         return "mfib_signal_dump"
 945 }
 946 func (*MfibSignalDump) GetMessageType() api.MessageType {
 947         return api.RequestMessage
 948 }
 949 func (*MfibSignalDump) GetCrcString() string {
 950         return "bbbbd40d"
 951 }
 952 func NewMfibSignalDump() api.Message {
 953         return &MfibSignalDump{}
 954 }
 955
 956 // MfibSignalDetails represents the VPP binary API message 'mfib_signal_details'.
 957 // Generated from 'bin_api/ip.api.json', line 277:
 958 //
 959 //        ["mfib_signal_details",
 960 //            ["u16", "_vl_msg_id"],
 961 //            ["u32", "client_index"],
 962 //            ["u32", "context"],
 963 //            ["u32", "sw_if_index"],
 964 //            ["u32", "table_id"],
 965 //            ["u16", "grp_address_len"],
 966 //            ["u8", "grp_address", 16],
 967 //            ["u8", "src_address", 16],
 968 //            ["u16", "ip_packet_len"],
 969 //            ["u8", "ip_packet_data", 256],
 970 //            {"crc" : "0x6ba92c72"}
 971 //        ]
 972 //
 973 type MfibSignalDetails struct {
 974         SwIfIndex     uint32
 975         TableID       uint32
 976         GrpAddressLen uint16
 977         GrpAddress    []byte `struc:"[16]byte"`
 978         SrcAddress    []byte `struc:"[16]byte"`
 979         IPPacketLen   uint16
 980         IPPacketData  []byte `struc:"[256]byte"`
 981 }
 982
 983 func (*MfibSignalDetails) GetMessageName() string {
 984         return "mfib_signal_details"
 985 }
 986 func (*MfibSignalDetails) GetMessageType() api.MessageType {
 987         return api.RequestMessage
 988 }
 989 func (*MfibSignalDetails) GetCrcString() string {
 990         return "6ba92c72"
 991 }
 992 func NewMfibSignalDetails() api.Message {
 993         return &MfibSignalDetails{}
 994 }