examples/binapi/ip/ip.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.4.0-dev
   4 //  VPP:              20.05-release
   5 // source: /usr/share/vpp/api/core/ip.api.json
   6
   7 /*
   8 Package ip contains generated code for VPP API file ip.api (3.0.1).
   9
  10 It consists of:
  11           7 aliases
  12          15 enums
  13          60 messages
  14          14 types
  15           1 union
  16 */
  17 package ip
  18
  19 import (
  20         "bytes"
  21         "context"
  22         "encoding/binary"
  23         "fmt"
  24         "io"
  25         "math"
  26         "net"
  27         "strconv"
  28         "strings"
  29
  30         api "git.fd.io/govpp.git/api"
  31         codec "git.fd.io/govpp.git/codec"
  32         struc "github.com/lunixbochs/struc"
  33
  34         fib_types "git.fd.io/govpp.git/examples/binapi/fib_types"
  35         interface_types "git.fd.io/govpp.git/examples/binapi/interface_types"
  36 )
  37
  38 // This is a compile-time assertion to ensure that this generated file
  39 // is compatible with the GoVPP api package it is being compiled against.
  40 // A compilation error at this line likely means your copy of the
  41 // GoVPP api package needs to be updated.
  42 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  43
  44 const (
  45         // ModuleName is the name of this module.
  46         ModuleName = "ip"
  47         // APIVersion is the API version of this module.
  48         APIVersion = "3.0.1"
  49         // VersionCrc is the CRC of this module.
  50         VersionCrc = 0x765d74b1
  51 )
  52
  53 // IPReassType represents VPP binary API enum 'ip_reass_type'.
  54 type IPReassType uint32
  55
  56 const (
  57         IP_REASS_TYPE_FULL            IPReassType = 0
  58         IP_REASS_TYPE_SHALLOW_VIRTUAL IPReassType = 1
  59 )
  60
  61 var (
  62         IPReassType_name = map[uint32]string{
  63                 0: "IP_REASS_TYPE_FULL",
  64                 1: "IP_REASS_TYPE_SHALLOW_VIRTUAL",
  65         }
  66         IPReassType_value = map[string]uint32{
  67                 "IP_REASS_TYPE_FULL":            0,
  68                 "IP_REASS_TYPE_SHALLOW_VIRTUAL": 1,
  69         }
  70 )
  71
  72 func (x IPReassType) String() string {
  73         s, ok := IPReassType_name[uint32(x)]
  74         if ok {
  75                 return s
  76         }
  77         return "IPReassType(" + strconv.Itoa(int(x)) + ")"
  78 }
  79
  80 // MfibItfFlags represents VPP binary API enum 'mfib_itf_flags'.
  81 type MfibItfFlags uint32
  82
  83 const (
  84         MFIB_API_ITF_FLAG_NONE           MfibItfFlags = 0
  85         MFIB_API_ITF_FLAG_NEGATE_SIGNAL  MfibItfFlags = 1
  86         MFIB_API_ITF_FLAG_ACCEPT         MfibItfFlags = 2
  87         MFIB_API_ITF_FLAG_FORWARD        MfibItfFlags = 4
  88         MFIB_API_ITF_FLAG_SIGNAL_PRESENT MfibItfFlags = 8
  89         MFIB_API_ITF_FLAG_DONT_PRESERVE  MfibItfFlags = 16
  90 )
  91
  92 var (
  93         MfibItfFlags_name = map[uint32]string{
  94                 0:  "MFIB_API_ITF_FLAG_NONE",
  95                 1:  "MFIB_API_ITF_FLAG_NEGATE_SIGNAL",
  96                 2:  "MFIB_API_ITF_FLAG_ACCEPT",
  97                 4:  "MFIB_API_ITF_FLAG_FORWARD",
  98                 8:  "MFIB_API_ITF_FLAG_SIGNAL_PRESENT",
  99                 16: "MFIB_API_ITF_FLAG_DONT_PRESERVE",
 100         }
 101         MfibItfFlags_value = map[string]uint32{
 102                 "MFIB_API_ITF_FLAG_NONE":           0,
 103                 "MFIB_API_ITF_FLAG_NEGATE_SIGNAL":  1,
 104                 "MFIB_API_ITF_FLAG_ACCEPT":         2,
 105                 "MFIB_API_ITF_FLAG_FORWARD":        4,
 106                 "MFIB_API_ITF_FLAG_SIGNAL_PRESENT": 8,
 107                 "MFIB_API_ITF_FLAG_DONT_PRESERVE":  16,
 108         }
 109 )
 110
 111 func (x MfibItfFlags) String() string {
 112         s, ok := MfibItfFlags_name[uint32(x)]
 113         if ok {
 114                 return s
 115         }
 116         return "MfibItfFlags(" + strconv.Itoa(int(x)) + ")"
 117 }
 118
 119 // MacAddress represents VPP binary API alias 'mac_address'.
 120 type MacAddress [6]uint8
 121
 122 func ParseMAC(mac string) (parsed MacAddress, err error) {
 123         var hw net.HardwareAddr
 124         if hw, err = net.ParseMAC(mac); err != nil {
 125                 return
 126         }
 127         copy(parsed[:], hw[:])
 128         return
 129 }
 130
 131 func (m *MacAddress) ToString() string {
 132         return net.HardwareAddr(m[:]).String()
 133 }
 134
 135 // IPMroute represents VPP binary API type 'ip_mroute'.
 136 type IPMroute struct {
 137         TableID    uint32            `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 138         EntryFlags uint32            `binapi:"u32,name=entry_flags" json:"entry_flags,omitempty"`
 139         RpfID      uint32            `binapi:"u32,name=rpf_id" json:"rpf_id,omitempty"`
 140         Prefix     fib_types.Mprefix `binapi:"mprefix,name=prefix" json:"prefix,omitempty"`
 141         NPaths     uint8             `binapi:"u8,name=n_paths" json:"n_paths,omitempty" struc:"sizeof=Paths"`
 142         Paths      []MfibPath        `binapi:"mfib_path[n_paths],name=paths" json:"paths,omitempty"`
 143 }
 144
 145 func (*IPMroute) GetTypeName() string { return "ip_mroute" }
 146
 147 // IPRoute represents VPP binary API type 'ip_route'.
 148 type IPRoute struct {
 149         TableID    uint32              `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 150         StatsIndex uint32              `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
 151         Prefix     fib_types.Prefix    `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
 152         NPaths     uint8               `binapi:"u8,name=n_paths" json:"n_paths,omitempty" struc:"sizeof=Paths"`
 153         Paths      []fib_types.FibPath `binapi:"fib_path[n_paths],name=paths" json:"paths,omitempty"`
 154 }
 155
 156 func (*IPRoute) GetTypeName() string { return "ip_route" }
 157
 158 // IPTable represents VPP binary API type 'ip_table'.
 159 type IPTable struct {
 160         TableID uint32 `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 161         IsIP6   bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
 162         Name    string `binapi:"string[64],name=name" json:"name,omitempty" struc:"[64]byte"`
 163 }
 164
 165 func (*IPTable) GetTypeName() string { return "ip_table" }
 166
 167 // MfibPath represents VPP binary API type 'mfib_path'.
 168 type MfibPath struct {
 169         ItfFlags MfibItfFlags      `binapi:"mfib_itf_flags,name=itf_flags" json:"itf_flags,omitempty"`
 170         Path     fib_types.FibPath `binapi:"fib_path,name=path" json:"path,omitempty"`
 171 }
 172
 173 func (*MfibPath) GetTypeName() string { return "mfib_path" }
 174
 175 // PuntRedirect represents VPP binary API type 'punt_redirect'.
 176 type PuntRedirect struct {
 177         RxSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=rx_sw_if_index" json:"rx_sw_if_index,omitempty"`
 178         TxSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=tx_sw_if_index" json:"tx_sw_if_index,omitempty"`
 179         Nh          fib_types.Address              `binapi:"address,name=nh" json:"nh,omitempty"`
 180 }
 181
 182 func (*PuntRedirect) GetTypeName() string { return "punt_redirect" }
 183
 184 // IoamDisable represents VPP binary API message 'ioam_disable'.
 185 type IoamDisable struct {
 186         ID uint16 `binapi:"u16,name=id" json:"id,omitempty"`
 187 }
 188
 189 func (m *IoamDisable) Reset()                        { *m = IoamDisable{} }
 190 func (*IoamDisable) GetMessageName() string          { return "ioam_disable" }
 191 func (*IoamDisable) GetCrcString() string            { return "6b16a45e" }
 192 func (*IoamDisable) GetMessageType() api.MessageType { return api.RequestMessage }
 193
 194 func (m *IoamDisable) Size() int {
 195         if m == nil {
 196                 return 0
 197         }
 198         var size int
 199         // field[1] m.ID
 200         size += 2
 201         return size
 202 }
 203 func (m *IoamDisable) Marshal(b []byte) ([]byte, error) {
 204         o := binary.BigEndian
 205         _ = o
 206         pos := 0
 207         _ = pos
 208         var buf []byte
 209         if b == nil {
 210                 buf = make([]byte, m.Size())
 211         } else {
 212                 buf = b
 213         }
 214         // field[1] m.ID
 215         o.PutUint16(buf[pos:pos+2], uint16(m.ID))
 216         pos += 2
 217         return buf, nil
 218 }
 219 func (m *IoamDisable) Unmarshal(tmp []byte) error {
 220         o := binary.BigEndian
 221         _ = o
 222         pos := 0
 223         _ = pos
 224         // field[1] m.ID
 225         m.ID = uint16(o.Uint16(tmp[pos : pos+2]))
 226         pos += 2
 227         return nil
 228 }
 229
 230 // IoamDisableReply represents VPP binary API message 'ioam_disable_reply'.
 231 type IoamDisableReply struct {
 232         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 233 }
 234
 235 func (m *IoamDisableReply) Reset()                        { *m = IoamDisableReply{} }
 236 func (*IoamDisableReply) GetMessageName() string          { return "ioam_disable_reply" }
 237 func (*IoamDisableReply) GetCrcString() string            { return "e8d4e804" }
 238 func (*IoamDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 239
 240 func (m *IoamDisableReply) Size() int {
 241         if m == nil {
 242                 return 0
 243         }
 244         var size int
 245         // field[1] m.Retval
 246         size += 4
 247         return size
 248 }
 249 func (m *IoamDisableReply) Marshal(b []byte) ([]byte, error) {
 250         o := binary.BigEndian
 251         _ = o
 252         pos := 0
 253         _ = pos
 254         var buf []byte
 255         if b == nil {
 256                 buf = make([]byte, m.Size())
 257         } else {
 258                 buf = b
 259         }
 260         // field[1] m.Retval
 261         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 262         pos += 4
 263         return buf, nil
 264 }
 265 func (m *IoamDisableReply) Unmarshal(tmp []byte) error {
 266         o := binary.BigEndian
 267         _ = o
 268         pos := 0
 269         _ = pos
 270         // field[1] m.Retval
 271         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 272         pos += 4
 273         return nil
 274 }
 275
 276 // IoamEnable represents VPP binary API message 'ioam_enable'.
 277 type IoamEnable struct {
 278         ID          uint16 `binapi:"u16,name=id" json:"id,omitempty"`
 279         Seqno       bool   `binapi:"bool,name=seqno" json:"seqno,omitempty"`
 280         Analyse     bool   `binapi:"bool,name=analyse" json:"analyse,omitempty"`
 281         PotEnable   bool   `binapi:"bool,name=pot_enable" json:"pot_enable,omitempty"`
 282         TraceEnable bool   `binapi:"bool,name=trace_enable" json:"trace_enable,omitempty"`
 283         NodeID      uint32 `binapi:"u32,name=node_id" json:"node_id,omitempty"`
 284 }
 285
 286 func (m *IoamEnable) Reset()                        { *m = IoamEnable{} }
 287 func (*IoamEnable) GetMessageName() string          { return "ioam_enable" }
 288 func (*IoamEnable) GetCrcString() string            { return "51ccd868" }
 289 func (*IoamEnable) GetMessageType() api.MessageType { return api.RequestMessage }
 290
 291 func (m *IoamEnable) Size() int {
 292         if m == nil {
 293                 return 0
 294         }
 295         var size int
 296         // field[1] m.ID
 297         size += 2
 298         // field[1] m.Seqno
 299         size += 1
 300         // field[1] m.Analyse
 301         size += 1
 302         // field[1] m.PotEnable
 303         size += 1
 304         // field[1] m.TraceEnable
 305         size += 1
 306         // field[1] m.NodeID
 307         size += 4
 308         return size
 309 }
 310 func (m *IoamEnable) Marshal(b []byte) ([]byte, error) {
 311         o := binary.BigEndian
 312         _ = o
 313         pos := 0
 314         _ = pos
 315         var buf []byte
 316         if b == nil {
 317                 buf = make([]byte, m.Size())
 318         } else {
 319                 buf = b
 320         }
 321         // field[1] m.ID
 322         o.PutUint16(buf[pos:pos+2], uint16(m.ID))
 323         pos += 2
 324         // field[1] m.Seqno
 325         if m.Seqno {
 326                 buf[pos] = 1
 327         }
 328         pos += 1
 329         // field[1] m.Analyse
 330         if m.Analyse {
 331                 buf[pos] = 1
 332         }
 333         pos += 1
 334         // field[1] m.PotEnable
 335         if m.PotEnable {
 336                 buf[pos] = 1
 337         }
 338         pos += 1
 339         // field[1] m.TraceEnable
 340         if m.TraceEnable {
 341                 buf[pos] = 1
 342         }
 343         pos += 1
 344         // field[1] m.NodeID
 345         o.PutUint32(buf[pos:pos+4], uint32(m.NodeID))
 346         pos += 4
 347         return buf, nil
 348 }
 349 func (m *IoamEnable) Unmarshal(tmp []byte) error {
 350         o := binary.BigEndian
 351         _ = o
 352         pos := 0
 353         _ = pos
 354         // field[1] m.ID
 355         m.ID = uint16(o.Uint16(tmp[pos : pos+2]))
 356         pos += 2
 357         // field[1] m.Seqno
 358         m.Seqno = tmp[pos] != 0
 359         pos += 1
 360         // field[1] m.Analyse
 361         m.Analyse = tmp[pos] != 0
 362         pos += 1
 363         // field[1] m.PotEnable
 364         m.PotEnable = tmp[pos] != 0
 365         pos += 1
 366         // field[1] m.TraceEnable
 367         m.TraceEnable = tmp[pos] != 0
 368         pos += 1
 369         // field[1] m.NodeID
 370         m.NodeID = uint32(o.Uint32(tmp[pos : pos+4]))
 371         pos += 4
 372         return nil
 373 }
 374
 375 // IoamEnableReply represents VPP binary API message 'ioam_enable_reply'.
 376 type IoamEnableReply struct {
 377         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 378 }
 379
 380 func (m *IoamEnableReply) Reset()                        { *m = IoamEnableReply{} }
 381 func (*IoamEnableReply) GetMessageName() string          { return "ioam_enable_reply" }
 382 func (*IoamEnableReply) GetCrcString() string            { return "e8d4e804" }
 383 func (*IoamEnableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 384
 385 func (m *IoamEnableReply) Size() int {
 386         if m == nil {
 387                 return 0
 388         }
 389         var size int
 390         // field[1] m.Retval
 391         size += 4
 392         return size
 393 }
 394 func (m *IoamEnableReply) Marshal(b []byte) ([]byte, error) {
 395         o := binary.BigEndian
 396         _ = o
 397         pos := 0
 398         _ = pos
 399         var buf []byte
 400         if b == nil {
 401                 buf = make([]byte, m.Size())
 402         } else {
 403                 buf = b
 404         }
 405         // field[1] m.Retval
 406         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 407         pos += 4
 408         return buf, nil
 409 }
 410 func (m *IoamEnableReply) Unmarshal(tmp []byte) error {
 411         o := binary.BigEndian
 412         _ = o
 413         pos := 0
 414         _ = pos
 415         // field[1] m.Retval
 416         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 417         pos += 4
 418         return nil
 419 }
 420
 421 // IPAddressDetails represents VPP binary API message 'ip_address_details'.
 422 type IPAddressDetails struct {
 423         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 424         Prefix    fib_types.AddressWithPrefix    `binapi:"address_with_prefix,name=prefix" json:"prefix,omitempty"`
 425 }
 426
 427 func (m *IPAddressDetails) Reset()                        { *m = IPAddressDetails{} }
 428 func (*IPAddressDetails) GetMessageName() string          { return "ip_address_details" }
 429 func (*IPAddressDetails) GetCrcString() string            { return "b1199745" }
 430 func (*IPAddressDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 431
 432 func (m *IPAddressDetails) Size() int {
 433         if m == nil {
 434                 return 0
 435         }
 436         var size int
 437         // field[1] m.SwIfIndex
 438         size += 4
 439         // field[1] m.Prefix
 440         // field[2] m.Prefix.Address
 441         // field[3] m.Prefix.Address.Af
 442         size += 1
 443         // field[3] m.Prefix.Address.Un
 444         size += 16
 445         // field[2] m.Prefix.Len
 446         size += 1
 447         return size
 448 }
 449 func (m *IPAddressDetails) Marshal(b []byte) ([]byte, error) {
 450         o := binary.BigEndian
 451         _ = o
 452         pos := 0
 453         _ = pos
 454         var buf []byte
 455         if b == nil {
 456                 buf = make([]byte, m.Size())
 457         } else {
 458                 buf = b
 459         }
 460         // field[1] m.SwIfIndex
 461         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 462         pos += 4
 463         // field[1] m.Prefix
 464         // field[2] m.Prefix.Address
 465         // field[3] m.Prefix.Address.Af
 466         buf[pos] = uint8(m.Prefix.Address.Af)
 467         pos += 1
 468         // field[3] m.Prefix.Address.Un
 469         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
 470         pos += 16
 471         // field[2] m.Prefix.Len
 472         buf[pos] = uint8(m.Prefix.Len)
 473         pos += 1
 474         return buf, nil
 475 }
 476 func (m *IPAddressDetails) Unmarshal(tmp []byte) error {
 477         o := binary.BigEndian
 478         _ = o
 479         pos := 0
 480         _ = pos
 481         // field[1] m.SwIfIndex
 482         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 483         pos += 4
 484         // field[1] m.Prefix
 485         // field[2] m.Prefix.Address
 486         // field[3] m.Prefix.Address.Af
 487         m.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
 488         pos += 1
 489         // field[3] m.Prefix.Address.Un
 490         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 491         pos += 16
 492         // field[2] m.Prefix.Len
 493         m.Prefix.Len = uint8(tmp[pos])
 494         pos += 1
 495         return nil
 496 }
 497
 498 // IPAddressDump represents VPP binary API message 'ip_address_dump'.
 499 type IPAddressDump struct {
 500         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 501         IsIPv6    bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
 502 }
 503
 504 func (m *IPAddressDump) Reset()                        { *m = IPAddressDump{} }
 505 func (*IPAddressDump) GetMessageName() string          { return "ip_address_dump" }
 506 func (*IPAddressDump) GetCrcString() string            { return "2d033de4" }
 507 func (*IPAddressDump) GetMessageType() api.MessageType { return api.RequestMessage }
 508
 509 func (m *IPAddressDump) Size() int {
 510         if m == nil {
 511                 return 0
 512         }
 513         var size int
 514         // field[1] m.SwIfIndex
 515         size += 4
 516         // field[1] m.IsIPv6
 517         size += 1
 518         return size
 519 }
 520 func (m *IPAddressDump) Marshal(b []byte) ([]byte, error) {
 521         o := binary.BigEndian
 522         _ = o
 523         pos := 0
 524         _ = pos
 525         var buf []byte
 526         if b == nil {
 527                 buf = make([]byte, m.Size())
 528         } else {
 529                 buf = b
 530         }
 531         // field[1] m.SwIfIndex
 532         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 533         pos += 4
 534         // field[1] m.IsIPv6
 535         if m.IsIPv6 {
 536                 buf[pos] = 1
 537         }
 538         pos += 1
 539         return buf, nil
 540 }
 541 func (m *IPAddressDump) Unmarshal(tmp []byte) error {
 542         o := binary.BigEndian
 543         _ = o
 544         pos := 0
 545         _ = pos
 546         // field[1] m.SwIfIndex
 547         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 548         pos += 4
 549         // field[1] m.IsIPv6
 550         m.IsIPv6 = tmp[pos] != 0
 551         pos += 1
 552         return nil
 553 }
 554
 555 // IPContainerProxyAddDel represents VPP binary API message 'ip_container_proxy_add_del'.
 556 type IPContainerProxyAddDel struct {
 557         Pfx       fib_types.Prefix               `binapi:"prefix,name=pfx" json:"pfx,omitempty"`
 558         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 559         IsAdd     bool                           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 560 }
 561
 562 func (m *IPContainerProxyAddDel) Reset()                        { *m = IPContainerProxyAddDel{} }
 563 func (*IPContainerProxyAddDel) GetMessageName() string          { return "ip_container_proxy_add_del" }
 564 func (*IPContainerProxyAddDel) GetCrcString() string            { return "91189f40" }
 565 func (*IPContainerProxyAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
 566
 567 func (m *IPContainerProxyAddDel) Size() int {
 568         if m == nil {
 569                 return 0
 570         }
 571         var size int
 572         // field[1] m.Pfx
 573         // field[2] m.Pfx.Address
 574         // field[3] m.Pfx.Address.Af
 575         size += 1
 576         // field[3] m.Pfx.Address.Un
 577         size += 16
 578         // field[2] m.Pfx.Len
 579         size += 1
 580         // field[1] m.SwIfIndex
 581         size += 4
 582         // field[1] m.IsAdd
 583         size += 1
 584         return size
 585 }
 586 func (m *IPContainerProxyAddDel) Marshal(b []byte) ([]byte, error) {
 587         o := binary.BigEndian
 588         _ = o
 589         pos := 0
 590         _ = pos
 591         var buf []byte
 592         if b == nil {
 593                 buf = make([]byte, m.Size())
 594         } else {
 595                 buf = b
 596         }
 597         // field[1] m.Pfx
 598         // field[2] m.Pfx.Address
 599         // field[3] m.Pfx.Address.Af
 600         buf[pos] = uint8(m.Pfx.Address.Af)
 601         pos += 1
 602         // field[3] m.Pfx.Address.Un
 603         copy(buf[pos:pos+16], m.Pfx.Address.Un.XXX_UnionData[:])
 604         pos += 16
 605         // field[2] m.Pfx.Len
 606         buf[pos] = uint8(m.Pfx.Len)
 607         pos += 1
 608         // field[1] m.SwIfIndex
 609         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 610         pos += 4
 611         // field[1] m.IsAdd
 612         if m.IsAdd {
 613                 buf[pos] = 1
 614         }
 615         pos += 1
 616         return buf, nil
 617 }
 618 func (m *IPContainerProxyAddDel) Unmarshal(tmp []byte) error {
 619         o := binary.BigEndian
 620         _ = o
 621         pos := 0
 622         _ = pos
 623         // field[1] m.Pfx
 624         // field[2] m.Pfx.Address
 625         // field[3] m.Pfx.Address.Af
 626         m.Pfx.Address.Af = fib_types.AddressFamily(tmp[pos])
 627         pos += 1
 628         // field[3] m.Pfx.Address.Un
 629         copy(m.Pfx.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 630         pos += 16
 631         // field[2] m.Pfx.Len
 632         m.Pfx.Len = uint8(tmp[pos])
 633         pos += 1
 634         // field[1] m.SwIfIndex
 635         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 636         pos += 4
 637         // field[1] m.IsAdd
 638         m.IsAdd = tmp[pos] != 0
 639         pos += 1
 640         return nil
 641 }
 642
 643 // IPContainerProxyAddDelReply represents VPP binary API message 'ip_container_proxy_add_del_reply'.
 644 type IPContainerProxyAddDelReply struct {
 645         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 646 }
 647
 648 func (m *IPContainerProxyAddDelReply) Reset() { *m = IPContainerProxyAddDelReply{} }
 649 func (*IPContainerProxyAddDelReply) GetMessageName() string {
 650         return "ip_container_proxy_add_del_reply"
 651 }
 652 func (*IPContainerProxyAddDelReply) GetCrcString() string            { return "e8d4e804" }
 653 func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 654
 655 func (m *IPContainerProxyAddDelReply) Size() int {
 656         if m == nil {
 657                 return 0
 658         }
 659         var size int
 660         // field[1] m.Retval
 661         size += 4
 662         return size
 663 }
 664 func (m *IPContainerProxyAddDelReply) Marshal(b []byte) ([]byte, error) {
 665         o := binary.BigEndian
 666         _ = o
 667         pos := 0
 668         _ = pos
 669         var buf []byte
 670         if b == nil {
 671                 buf = make([]byte, m.Size())
 672         } else {
 673                 buf = b
 674         }
 675         // field[1] m.Retval
 676         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 677         pos += 4
 678         return buf, nil
 679 }
 680 func (m *IPContainerProxyAddDelReply) Unmarshal(tmp []byte) error {
 681         o := binary.BigEndian
 682         _ = o
 683         pos := 0
 684         _ = pos
 685         // field[1] m.Retval
 686         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 687         pos += 4
 688         return nil
 689 }
 690
 691 // IPContainerProxyDetails represents VPP binary API message 'ip_container_proxy_details'.
 692 type IPContainerProxyDetails struct {
 693         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 694         Prefix    fib_types.Prefix               `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
 695 }
 696
 697 func (m *IPContainerProxyDetails) Reset()                        { *m = IPContainerProxyDetails{} }
 698 func (*IPContainerProxyDetails) GetMessageName() string          { return "ip_container_proxy_details" }
 699 func (*IPContainerProxyDetails) GetCrcString() string            { return "0ee460e8" }
 700 func (*IPContainerProxyDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 701
 702 func (m *IPContainerProxyDetails) Size() int {
 703         if m == nil {
 704                 return 0
 705         }
 706         var size int
 707         // field[1] m.SwIfIndex
 708         size += 4
 709         // field[1] m.Prefix
 710         // field[2] m.Prefix.Address
 711         // field[3] m.Prefix.Address.Af
 712         size += 1
 713         // field[3] m.Prefix.Address.Un
 714         size += 16
 715         // field[2] m.Prefix.Len
 716         size += 1
 717         return size
 718 }
 719 func (m *IPContainerProxyDetails) Marshal(b []byte) ([]byte, error) {
 720         o := binary.BigEndian
 721         _ = o
 722         pos := 0
 723         _ = pos
 724         var buf []byte
 725         if b == nil {
 726                 buf = make([]byte, m.Size())
 727         } else {
 728                 buf = b
 729         }
 730         // field[1] m.SwIfIndex
 731         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 732         pos += 4
 733         // field[1] m.Prefix
 734         // field[2] m.Prefix.Address
 735         // field[3] m.Prefix.Address.Af
 736         buf[pos] = uint8(m.Prefix.Address.Af)
 737         pos += 1
 738         // field[3] m.Prefix.Address.Un
 739         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
 740         pos += 16
 741         // field[2] m.Prefix.Len
 742         buf[pos] = uint8(m.Prefix.Len)
 743         pos += 1
 744         return buf, nil
 745 }
 746 func (m *IPContainerProxyDetails) Unmarshal(tmp []byte) error {
 747         o := binary.BigEndian
 748         _ = o
 749         pos := 0
 750         _ = pos
 751         // field[1] m.SwIfIndex
 752         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 753         pos += 4
 754         // field[1] m.Prefix
 755         // field[2] m.Prefix.Address
 756         // field[3] m.Prefix.Address.Af
 757         m.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
 758         pos += 1
 759         // field[3] m.Prefix.Address.Un
 760         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 761         pos += 16
 762         // field[2] m.Prefix.Len
 763         m.Prefix.Len = uint8(tmp[pos])
 764         pos += 1
 765         return nil
 766 }
 767
 768 // IPContainerProxyDump represents VPP binary API message 'ip_container_proxy_dump'.
 769 type IPContainerProxyDump struct{}
 770
 771 func (m *IPContainerProxyDump) Reset()                        { *m = IPContainerProxyDump{} }
 772 func (*IPContainerProxyDump) GetMessageName() string          { return "ip_container_proxy_dump" }
 773 func (*IPContainerProxyDump) GetCrcString() string            { return "51077d14" }
 774 func (*IPContainerProxyDump) GetMessageType() api.MessageType { return api.RequestMessage }
 775
 776 func (m *IPContainerProxyDump) Size() int {
 777         if m == nil {
 778                 return 0
 779         }
 780         var size int
 781         return size
 782 }
 783 func (m *IPContainerProxyDump) Marshal(b []byte) ([]byte, error) {
 784         o := binary.BigEndian
 785         _ = o
 786         pos := 0
 787         _ = pos
 788         var buf []byte
 789         if b == nil {
 790                 buf = make([]byte, m.Size())
 791         } else {
 792                 buf = b
 793         }
 794         return buf, nil
 795 }
 796 func (m *IPContainerProxyDump) Unmarshal(tmp []byte) error {
 797         o := binary.BigEndian
 798         _ = o
 799         pos := 0
 800         _ = pos
 801         return nil
 802 }
 803
 804 // IPDetails represents VPP binary API message 'ip_details'.
 805 type IPDetails struct {
 806         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 807         IsIPv6    bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
 808 }
 809
 810 func (m *IPDetails) Reset()                        { *m = IPDetails{} }
 811 func (*IPDetails) GetMessageName() string          { return "ip_details" }
 812 func (*IPDetails) GetCrcString() string            { return "eb152d07" }
 813 func (*IPDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 814
 815 func (m *IPDetails) Size() int {
 816         if m == nil {
 817                 return 0
 818         }
 819         var size int
 820         // field[1] m.SwIfIndex
 821         size += 4
 822         // field[1] m.IsIPv6
 823         size += 1
 824         return size
 825 }
 826 func (m *IPDetails) Marshal(b []byte) ([]byte, error) {
 827         o := binary.BigEndian
 828         _ = o
 829         pos := 0
 830         _ = pos
 831         var buf []byte
 832         if b == nil {
 833                 buf = make([]byte, m.Size())
 834         } else {
 835                 buf = b
 836         }
 837         // field[1] m.SwIfIndex
 838         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 839         pos += 4
 840         // field[1] m.IsIPv6
 841         if m.IsIPv6 {
 842                 buf[pos] = 1
 843         }
 844         pos += 1
 845         return buf, nil
 846 }
 847 func (m *IPDetails) Unmarshal(tmp []byte) error {
 848         o := binary.BigEndian
 849         _ = o
 850         pos := 0
 851         _ = pos
 852         // field[1] m.SwIfIndex
 853         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 854         pos += 4
 855         // field[1] m.IsIPv6
 856         m.IsIPv6 = tmp[pos] != 0
 857         pos += 1
 858         return nil
 859 }
 860
 861 // IPDump represents VPP binary API message 'ip_dump'.
 862 type IPDump struct {
 863         IsIPv6 bool `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
 864 }
 865
 866 func (m *IPDump) Reset()                        { *m = IPDump{} }
 867 func (*IPDump) GetMessageName() string          { return "ip_dump" }
 868 func (*IPDump) GetCrcString() string            { return "98d231ca" }
 869 func (*IPDump) GetMessageType() api.MessageType { return api.RequestMessage }
 870
 871 func (m *IPDump) Size() int {
 872         if m == nil {
 873                 return 0
 874         }
 875         var size int
 876         // field[1] m.IsIPv6
 877         size += 1
 878         return size
 879 }
 880 func (m *IPDump) Marshal(b []byte) ([]byte, error) {
 881         o := binary.BigEndian
 882         _ = o
 883         pos := 0
 884         _ = pos
 885         var buf []byte
 886         if b == nil {
 887                 buf = make([]byte, m.Size())
 888         } else {
 889                 buf = b
 890         }
 891         // field[1] m.IsIPv6
 892         if m.IsIPv6 {
 893                 buf[pos] = 1
 894         }
 895         pos += 1
 896         return buf, nil
 897 }
 898 func (m *IPDump) Unmarshal(tmp []byte) error {
 899         o := binary.BigEndian
 900         _ = o
 901         pos := 0
 902         _ = pos
 903         // field[1] m.IsIPv6
 904         m.IsIPv6 = tmp[pos] != 0
 905         pos += 1
 906         return nil
 907 }
 908
 909 // IPMrouteAddDel represents VPP binary API message 'ip_mroute_add_del'.
 910 type IPMrouteAddDel struct {
 911         IsAdd       bool     `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 912         IsMultipath bool     `binapi:"bool,name=is_multipath" json:"is_multipath,omitempty"`
 913         Route       IPMroute `binapi:"ip_mroute,name=route" json:"route,omitempty"`
 914 }
 915
 916 func (m *IPMrouteAddDel) Reset()                        { *m = IPMrouteAddDel{} }
 917 func (*IPMrouteAddDel) GetMessageName() string          { return "ip_mroute_add_del" }
 918 func (*IPMrouteAddDel) GetCrcString() string            { return "f6627d17" }
 919 func (*IPMrouteAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
 920
 921 func (m *IPMrouteAddDel) Size() int {
 922         if m == nil {
 923                 return 0
 924         }
 925         var size int
 926         // field[1] m.IsAdd
 927         size += 1
 928         // field[1] m.IsMultipath
 929         size += 1
 930         // field[1] m.Route
 931         // field[2] m.Route.TableID
 932         size += 4
 933         // field[2] m.Route.EntryFlags
 934         size += 4
 935         // field[2] m.Route.RpfID
 936         size += 4
 937         // field[2] m.Route.Prefix
 938         // field[3] m.Route.Prefix.Af
 939         size += 1
 940         // field[3] m.Route.Prefix.GrpAddressLength
 941         size += 2
 942         // field[3] m.Route.Prefix.GrpAddress
 943         size += 16
 944         // field[3] m.Route.Prefix.SrcAddress
 945         size += 16
 946         // field[2] m.Route.NPaths
 947         size += 1
 948         // field[2] m.Route.Paths
 949         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
 950                 var s2 MfibPath
 951                 _ = s2
 952                 if j2 < len(m.Route.Paths) {
 953                         s2 = m.Route.Paths[j2]
 954                 }
 955                 // field[3] s2.ItfFlags
 956                 size += 4
 957                 // field[3] s2.Path
 958                 // field[4] s2.Path.SwIfIndex
 959                 size += 4
 960                 // field[4] s2.Path.TableID
 961                 size += 4
 962                 // field[4] s2.Path.RpfID
 963                 size += 4
 964                 // field[4] s2.Path.Weight
 965                 size += 1
 966                 // field[4] s2.Path.Preference
 967                 size += 1
 968                 // field[4] s2.Path.Type
 969                 size += 4
 970                 // field[4] s2.Path.Flags
 971                 size += 4
 972                 // field[4] s2.Path.Proto
 973                 size += 4
 974                 // field[4] s2.Path.Nh
 975                 // field[5] s2.Path.Nh.Address
 976                 size += 16
 977                 // field[5] s2.Path.Nh.ViaLabel
 978                 size += 4
 979                 // field[5] s2.Path.Nh.ObjID
 980                 size += 4
 981                 // field[5] s2.Path.Nh.ClassifyTableIndex
 982                 size += 4
 983                 // field[4] s2.Path.NLabels
 984                 size += 1
 985                 // field[4] s2.Path.LabelStack
 986                 for j4 := 0; j4 < 16; j4++ {
 987                         var s4 fib_types.FibMplsLabel
 988                         _ = s4
 989                         if j4 < len(s2.Path.LabelStack) {
 990                                 s4 = s2.Path.LabelStack[j4]
 991                         }
 992                         // field[5] s4.IsUniform
 993                         size += 1
 994                         // field[5] s4.Label
 995                         size += 4
 996                         // field[5] s4.TTL
 997                         size += 1
 998                         // field[5] s4.Exp
 999                         size += 1
1000                 }
1001         }
1002         return size
1003 }
1004 func (m *IPMrouteAddDel) Marshal(b []byte) ([]byte, error) {
1005         o := binary.BigEndian
1006         _ = o
1007         pos := 0
1008         _ = pos
1009         var buf []byte
1010         if b == nil {
1011                 buf = make([]byte, m.Size())
1012         } else {
1013                 buf = b
1014         }
1015         // field[1] m.IsAdd
1016         if m.IsAdd {
1017                 buf[pos] = 1
1018         }
1019         pos += 1
1020         // field[1] m.IsMultipath
1021         if m.IsMultipath {
1022                 buf[pos] = 1
1023         }
1024         pos += 1
1025         // field[1] m.Route
1026         // field[2] m.Route.TableID
1027         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
1028         pos += 4
1029         // field[2] m.Route.EntryFlags
1030         o.PutUint32(buf[pos:pos+4], uint32(m.Route.EntryFlags))
1031         pos += 4
1032         // field[2] m.Route.RpfID
1033         o.PutUint32(buf[pos:pos+4], uint32(m.Route.RpfID))
1034         pos += 4
1035         // field[2] m.Route.Prefix
1036         // field[3] m.Route.Prefix.Af
1037         buf[pos] = uint8(m.Route.Prefix.Af)
1038         pos += 1
1039         // field[3] m.Route.Prefix.GrpAddressLength
1040         o.PutUint16(buf[pos:pos+2], uint16(m.Route.Prefix.GrpAddressLength))
1041         pos += 2
1042         // field[3] m.Route.Prefix.GrpAddress
1043         copy(buf[pos:pos+16], m.Route.Prefix.GrpAddress.XXX_UnionData[:])
1044         pos += 16
1045         // field[3] m.Route.Prefix.SrcAddress
1046         copy(buf[pos:pos+16], m.Route.Prefix.SrcAddress.XXX_UnionData[:])
1047         pos += 16
1048         // field[2] m.Route.NPaths
1049         buf[pos] = uint8(len(m.Route.Paths))
1050         pos += 1
1051         // field[2] m.Route.Paths
1052         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1053                 var v2 MfibPath
1054                 if j2 < len(m.Route.Paths) {
1055                         v2 = m.Route.Paths[j2]
1056                 }
1057                 // field[3] v2.ItfFlags
1058                 o.PutUint32(buf[pos:pos+4], uint32(v2.ItfFlags))
1059                 pos += 4
1060                 // field[3] v2.Path
1061                 // field[4] v2.Path.SwIfIndex
1062                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.SwIfIndex))
1063                 pos += 4
1064                 // field[4] v2.Path.TableID
1065                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.TableID))
1066                 pos += 4
1067                 // field[4] v2.Path.RpfID
1068                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.RpfID))
1069                 pos += 4
1070                 // field[4] v2.Path.Weight
1071                 buf[pos] = uint8(v2.Path.Weight)
1072                 pos += 1
1073                 // field[4] v2.Path.Preference
1074                 buf[pos] = uint8(v2.Path.Preference)
1075                 pos += 1
1076                 // field[4] v2.Path.Type
1077                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Type))
1078                 pos += 4
1079                 // field[4] v2.Path.Flags
1080                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Flags))
1081                 pos += 4
1082                 // field[4] v2.Path.Proto
1083                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Proto))
1084                 pos += 4
1085                 // field[4] v2.Path.Nh
1086                 // field[5] v2.Path.Nh.Address
1087                 copy(buf[pos:pos+16], v2.Path.Nh.Address.XXX_UnionData[:])
1088                 pos += 16
1089                 // field[5] v2.Path.Nh.ViaLabel
1090                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ViaLabel))
1091                 pos += 4
1092                 // field[5] v2.Path.Nh.ObjID
1093                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ObjID))
1094                 pos += 4
1095                 // field[5] v2.Path.Nh.ClassifyTableIndex
1096                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ClassifyTableIndex))
1097                 pos += 4
1098                 // field[4] v2.Path.NLabels
1099                 buf[pos] = uint8(v2.Path.NLabels)
1100                 pos += 1
1101                 // field[4] v2.Path.LabelStack
1102                 for j4 := 0; j4 < 16; j4++ {
1103                         var v4 fib_types.FibMplsLabel
1104                         if j4 < len(v2.Path.LabelStack) {
1105                                 v4 = v2.Path.LabelStack[j4]
1106                         }
1107                         // field[5] v4.IsUniform
1108                         buf[pos] = uint8(v4.IsUniform)
1109                         pos += 1
1110                         // field[5] v4.Label
1111                         o.PutUint32(buf[pos:pos+4], uint32(v4.Label))
1112                         pos += 4
1113                         // field[5] v4.TTL
1114                         buf[pos] = uint8(v4.TTL)
1115                         pos += 1
1116                         // field[5] v4.Exp
1117                         buf[pos] = uint8(v4.Exp)
1118                         pos += 1
1119                 }
1120         }
1121         return buf, nil
1122 }
1123 func (m *IPMrouteAddDel) Unmarshal(tmp []byte) error {
1124         o := binary.BigEndian
1125         _ = o
1126         pos := 0
1127         _ = pos
1128         // field[1] m.IsAdd
1129         m.IsAdd = tmp[pos] != 0
1130         pos += 1
1131         // field[1] m.IsMultipath
1132         m.IsMultipath = tmp[pos] != 0
1133         pos += 1
1134         // field[1] m.Route
1135         // field[2] m.Route.TableID
1136         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1137         pos += 4
1138         // field[2] m.Route.EntryFlags
1139         m.Route.EntryFlags = uint32(o.Uint32(tmp[pos : pos+4]))
1140         pos += 4
1141         // field[2] m.Route.RpfID
1142         m.Route.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1143         pos += 4
1144         // field[2] m.Route.Prefix
1145         // field[3] m.Route.Prefix.Af
1146         m.Route.Prefix.Af = fib_types.AddressFamily(tmp[pos])
1147         pos += 1
1148         // field[3] m.Route.Prefix.GrpAddressLength
1149         m.Route.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
1150         pos += 2
1151         // field[3] m.Route.Prefix.GrpAddress
1152         copy(m.Route.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
1153         pos += 16
1154         // field[3] m.Route.Prefix.SrcAddress
1155         copy(m.Route.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
1156         pos += 16
1157         // field[2] m.Route.NPaths
1158         m.Route.NPaths = uint8(tmp[pos])
1159         pos += 1
1160         // field[2] m.Route.Paths
1161         m.Route.Paths = make([]MfibPath, int(m.Route.NPaths))
1162         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
1163                 // field[3] m.Route.Paths[j2].ItfFlags
1164                 m.Route.Paths[j2].ItfFlags = MfibItfFlags(o.Uint32(tmp[pos : pos+4]))
1165                 pos += 4
1166                 // field[3] m.Route.Paths[j2].Path
1167                 // field[4] m.Route.Paths[j2].Path.SwIfIndex
1168                 m.Route.Paths[j2].Path.SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1169                 pos += 4
1170                 // field[4] m.Route.Paths[j2].Path.TableID
1171                 m.Route.Paths[j2].Path.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1172                 pos += 4
1173                 // field[4] m.Route.Paths[j2].Path.RpfID
1174                 m.Route.Paths[j2].Path.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1175                 pos += 4
1176                 // field[4] m.Route.Paths[j2].Path.Weight
1177                 m.Route.Paths[j2].Path.Weight = uint8(tmp[pos])
1178                 pos += 1
1179                 // field[4] m.Route.Paths[j2].Path.Preference
1180                 m.Route.Paths[j2].Path.Preference = uint8(tmp[pos])
1181                 pos += 1
1182                 // field[4] m.Route.Paths[j2].Path.Type
1183                 m.Route.Paths[j2].Path.Type = fib_types.FibPathType(o.Uint32(tmp[pos : pos+4]))
1184                 pos += 4
1185                 // field[4] m.Route.Paths[j2].Path.Flags
1186                 m.Route.Paths[j2].Path.Flags = fib_types.FibPathFlags(o.Uint32(tmp[pos : pos+4]))
1187                 pos += 4
1188                 // field[4] m.Route.Paths[j2].Path.Proto
1189                 m.Route.Paths[j2].Path.Proto = fib_types.FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
1190                 pos += 4
1191                 // field[4] m.Route.Paths[j2].Path.Nh
1192                 // field[5] m.Route.Paths[j2].Path.Nh.Address
1193                 copy(m.Route.Paths[j2].Path.Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
1194                 pos += 16
1195                 // field[5] m.Route.Paths[j2].Path.Nh.ViaLabel
1196                 m.Route.Paths[j2].Path.Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
1197                 pos += 4
1198                 // field[5] m.Route.Paths[j2].Path.Nh.ObjID
1199                 m.Route.Paths[j2].Path.Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
1200                 pos += 4
1201                 // field[5] m.Route.Paths[j2].Path.Nh.ClassifyTableIndex
1202                 m.Route.Paths[j2].Path.Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1203                 pos += 4
1204                 // field[4] m.Route.Paths[j2].Path.NLabels
1205                 m.Route.Paths[j2].Path.NLabels = uint8(tmp[pos])
1206                 pos += 1
1207                 // field[4] m.Route.Paths[j2].Path.LabelStack
1208                 for j4 := 0; j4 < 16; j4++ {
1209                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].IsUniform
1210                         m.Route.Paths[j2].Path.LabelStack[j4].IsUniform = uint8(tmp[pos])
1211                         pos += 1
1212                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Label
1213                         m.Route.Paths[j2].Path.LabelStack[j4].Label = uint32(o.Uint32(tmp[pos : pos+4]))
1214                         pos += 4
1215                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].TTL
1216                         m.Route.Paths[j2].Path.LabelStack[j4].TTL = uint8(tmp[pos])
1217                         pos += 1
1218                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Exp
1219                         m.Route.Paths[j2].Path.LabelStack[j4].Exp = uint8(tmp[pos])
1220                         pos += 1
1221                 }
1222         }
1223         return nil
1224 }
1225
1226 // IPMrouteAddDelReply represents VPP binary API message 'ip_mroute_add_del_reply'.
1227 type IPMrouteAddDelReply struct {
1228         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1229         StatsIndex uint32 `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
1230 }
1231
1232 func (m *IPMrouteAddDelReply) Reset()                        { *m = IPMrouteAddDelReply{} }
1233 func (*IPMrouteAddDelReply) GetMessageName() string          { return "ip_mroute_add_del_reply" }
1234 func (*IPMrouteAddDelReply) GetCrcString() string            { return "1992deab" }
1235 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1236
1237 func (m *IPMrouteAddDelReply) Size() int {
1238         if m == nil {
1239                 return 0
1240         }
1241         var size int
1242         // field[1] m.Retval
1243         size += 4
1244         // field[1] m.StatsIndex
1245         size += 4
1246         return size
1247 }
1248 func (m *IPMrouteAddDelReply) Marshal(b []byte) ([]byte, error) {
1249         o := binary.BigEndian
1250         _ = o
1251         pos := 0
1252         _ = pos
1253         var buf []byte
1254         if b == nil {
1255                 buf = make([]byte, m.Size())
1256         } else {
1257                 buf = b
1258         }
1259         // field[1] m.Retval
1260         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1261         pos += 4
1262         // field[1] m.StatsIndex
1263         o.PutUint32(buf[pos:pos+4], uint32(m.StatsIndex))
1264         pos += 4
1265         return buf, nil
1266 }
1267 func (m *IPMrouteAddDelReply) Unmarshal(tmp []byte) error {
1268         o := binary.BigEndian
1269         _ = o
1270         pos := 0
1271         _ = pos
1272         // field[1] m.Retval
1273         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1274         pos += 4
1275         // field[1] m.StatsIndex
1276         m.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1277         pos += 4
1278         return nil
1279 }
1280
1281 // IPMrouteDetails represents VPP binary API message 'ip_mroute_details'.
1282 type IPMrouteDetails struct {
1283         Route IPMroute `binapi:"ip_mroute,name=route" json:"route,omitempty"`
1284 }
1285
1286 func (m *IPMrouteDetails) Reset()                        { *m = IPMrouteDetails{} }
1287 func (*IPMrouteDetails) GetMessageName() string          { return "ip_mroute_details" }
1288 func (*IPMrouteDetails) GetCrcString() string            { return "c1cb4b44" }
1289 func (*IPMrouteDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1290
1291 func (m *IPMrouteDetails) Size() int {
1292         if m == nil {
1293                 return 0
1294         }
1295         var size int
1296         // field[1] m.Route
1297         // field[2] m.Route.TableID
1298         size += 4
1299         // field[2] m.Route.EntryFlags
1300         size += 4
1301         // field[2] m.Route.RpfID
1302         size += 4
1303         // field[2] m.Route.Prefix
1304         // field[3] m.Route.Prefix.Af
1305         size += 1
1306         // field[3] m.Route.Prefix.GrpAddressLength
1307         size += 2
1308         // field[3] m.Route.Prefix.GrpAddress
1309         size += 16
1310         // field[3] m.Route.Prefix.SrcAddress
1311         size += 16
1312         // field[2] m.Route.NPaths
1313         size += 1
1314         // field[2] m.Route.Paths
1315         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1316                 var s2 MfibPath
1317                 _ = s2
1318                 if j2 < len(m.Route.Paths) {
1319                         s2 = m.Route.Paths[j2]
1320                 }
1321                 // field[3] s2.ItfFlags
1322                 size += 4
1323                 // field[3] s2.Path
1324                 // field[4] s2.Path.SwIfIndex
1325                 size += 4
1326                 // field[4] s2.Path.TableID
1327                 size += 4
1328                 // field[4] s2.Path.RpfID
1329                 size += 4
1330                 // field[4] s2.Path.Weight
1331                 size += 1
1332                 // field[4] s2.Path.Preference
1333                 size += 1
1334                 // field[4] s2.Path.Type
1335                 size += 4
1336                 // field[4] s2.Path.Flags
1337                 size += 4
1338                 // field[4] s2.Path.Proto
1339                 size += 4
1340                 // field[4] s2.Path.Nh
1341                 // field[5] s2.Path.Nh.Address
1342                 size += 16
1343                 // field[5] s2.Path.Nh.ViaLabel
1344                 size += 4
1345                 // field[5] s2.Path.Nh.ObjID
1346                 size += 4
1347                 // field[5] s2.Path.Nh.ClassifyTableIndex
1348                 size += 4
1349                 // field[4] s2.Path.NLabels
1350                 size += 1
1351                 // field[4] s2.Path.LabelStack
1352                 for j4 := 0; j4 < 16; j4++ {
1353                         var s4 fib_types.FibMplsLabel
1354                         _ = s4
1355                         if j4 < len(s2.Path.LabelStack) {
1356                                 s4 = s2.Path.LabelStack[j4]
1357                         }
1358                         // field[5] s4.IsUniform
1359                         size += 1
1360                         // field[5] s4.Label
1361                         size += 4
1362                         // field[5] s4.TTL
1363                         size += 1
1364                         // field[5] s4.Exp
1365                         size += 1
1366                 }
1367         }
1368         return size
1369 }
1370 func (m *IPMrouteDetails) Marshal(b []byte) ([]byte, error) {
1371         o := binary.BigEndian
1372         _ = o
1373         pos := 0
1374         _ = pos
1375         var buf []byte
1376         if b == nil {
1377                 buf = make([]byte, m.Size())
1378         } else {
1379                 buf = b
1380         }
1381         // field[1] m.Route
1382         // field[2] m.Route.TableID
1383         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
1384         pos += 4
1385         // field[2] m.Route.EntryFlags
1386         o.PutUint32(buf[pos:pos+4], uint32(m.Route.EntryFlags))
1387         pos += 4
1388         // field[2] m.Route.RpfID
1389         o.PutUint32(buf[pos:pos+4], uint32(m.Route.RpfID))
1390         pos += 4
1391         // field[2] m.Route.Prefix
1392         // field[3] m.Route.Prefix.Af
1393         buf[pos] = uint8(m.Route.Prefix.Af)
1394         pos += 1
1395         // field[3] m.Route.Prefix.GrpAddressLength
1396         o.PutUint16(buf[pos:pos+2], uint16(m.Route.Prefix.GrpAddressLength))
1397         pos += 2
1398         // field[3] m.Route.Prefix.GrpAddress
1399         copy(buf[pos:pos+16], m.Route.Prefix.GrpAddress.XXX_UnionData[:])
1400         pos += 16
1401         // field[3] m.Route.Prefix.SrcAddress
1402         copy(buf[pos:pos+16], m.Route.Prefix.SrcAddress.XXX_UnionData[:])
1403         pos += 16
1404         // field[2] m.Route.NPaths
1405         buf[pos] = uint8(len(m.Route.Paths))
1406         pos += 1
1407         // field[2] m.Route.Paths
1408         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1409                 var v2 MfibPath
1410                 if j2 < len(m.Route.Paths) {
1411                         v2 = m.Route.Paths[j2]
1412                 }
1413                 // field[3] v2.ItfFlags
1414                 o.PutUint32(buf[pos:pos+4], uint32(v2.ItfFlags))
1415                 pos += 4
1416                 // field[3] v2.Path
1417                 // field[4] v2.Path.SwIfIndex
1418                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.SwIfIndex))
1419                 pos += 4
1420                 // field[4] v2.Path.TableID
1421                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.TableID))
1422                 pos += 4
1423                 // field[4] v2.Path.RpfID
1424                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.RpfID))
1425                 pos += 4
1426                 // field[4] v2.Path.Weight
1427                 buf[pos] = uint8(v2.Path.Weight)
1428                 pos += 1
1429                 // field[4] v2.Path.Preference
1430                 buf[pos] = uint8(v2.Path.Preference)
1431                 pos += 1
1432                 // field[4] v2.Path.Type
1433                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Type))
1434                 pos += 4
1435                 // field[4] v2.Path.Flags
1436                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Flags))
1437                 pos += 4
1438                 // field[4] v2.Path.Proto
1439                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Proto))
1440                 pos += 4
1441                 // field[4] v2.Path.Nh
1442                 // field[5] v2.Path.Nh.Address
1443                 copy(buf[pos:pos+16], v2.Path.Nh.Address.XXX_UnionData[:])
1444                 pos += 16
1445                 // field[5] v2.Path.Nh.ViaLabel
1446                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ViaLabel))
1447                 pos += 4
1448                 // field[5] v2.Path.Nh.ObjID
1449                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ObjID))
1450                 pos += 4
1451                 // field[5] v2.Path.Nh.ClassifyTableIndex
1452                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ClassifyTableIndex))
1453                 pos += 4
1454                 // field[4] v2.Path.NLabels
1455                 buf[pos] = uint8(v2.Path.NLabels)
1456                 pos += 1
1457                 // field[4] v2.Path.LabelStack
1458                 for j4 := 0; j4 < 16; j4++ {
1459                         var v4 fib_types.FibMplsLabel
1460                         if j4 < len(v2.Path.LabelStack) {
1461                                 v4 = v2.Path.LabelStack[j4]
1462                         }
1463                         // field[5] v4.IsUniform
1464                         buf[pos] = uint8(v4.IsUniform)
1465                         pos += 1
1466                         // field[5] v4.Label
1467                         o.PutUint32(buf[pos:pos+4], uint32(v4.Label))
1468                         pos += 4
1469                         // field[5] v4.TTL
1470                         buf[pos] = uint8(v4.TTL)
1471                         pos += 1
1472                         // field[5] v4.Exp
1473                         buf[pos] = uint8(v4.Exp)
1474                         pos += 1
1475                 }
1476         }
1477         return buf, nil
1478 }
1479 func (m *IPMrouteDetails) Unmarshal(tmp []byte) error {
1480         o := binary.BigEndian
1481         _ = o
1482         pos := 0
1483         _ = pos
1484         // field[1] m.Route
1485         // field[2] m.Route.TableID
1486         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1487         pos += 4
1488         // field[2] m.Route.EntryFlags
1489         m.Route.EntryFlags = uint32(o.Uint32(tmp[pos : pos+4]))
1490         pos += 4
1491         // field[2] m.Route.RpfID
1492         m.Route.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1493         pos += 4
1494         // field[2] m.Route.Prefix
1495         // field[3] m.Route.Prefix.Af
1496         m.Route.Prefix.Af = fib_types.AddressFamily(tmp[pos])
1497         pos += 1
1498         // field[3] m.Route.Prefix.GrpAddressLength
1499         m.Route.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
1500         pos += 2
1501         // field[3] m.Route.Prefix.GrpAddress
1502         copy(m.Route.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
1503         pos += 16
1504         // field[3] m.Route.Prefix.SrcAddress
1505         copy(m.Route.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
1506         pos += 16
1507         // field[2] m.Route.NPaths
1508         m.Route.NPaths = uint8(tmp[pos])
1509         pos += 1
1510         // field[2] m.Route.Paths
1511         m.Route.Paths = make([]MfibPath, int(m.Route.NPaths))
1512         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
1513                 // field[3] m.Route.Paths[j2].ItfFlags
1514                 m.Route.Paths[j2].ItfFlags = MfibItfFlags(o.Uint32(tmp[pos : pos+4]))
1515                 pos += 4
1516                 // field[3] m.Route.Paths[j2].Path
1517                 // field[4] m.Route.Paths[j2].Path.SwIfIndex
1518                 m.Route.Paths[j2].Path.SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1519                 pos += 4
1520                 // field[4] m.Route.Paths[j2].Path.TableID
1521                 m.Route.Paths[j2].Path.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1522                 pos += 4
1523                 // field[4] m.Route.Paths[j2].Path.RpfID
1524                 m.Route.Paths[j2].Path.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1525                 pos += 4
1526                 // field[4] m.Route.Paths[j2].Path.Weight
1527                 m.Route.Paths[j2].Path.Weight = uint8(tmp[pos])
1528                 pos += 1
1529                 // field[4] m.Route.Paths[j2].Path.Preference
1530                 m.Route.Paths[j2].Path.Preference = uint8(tmp[pos])
1531                 pos += 1
1532                 // field[4] m.Route.Paths[j2].Path.Type
1533                 m.Route.Paths[j2].Path.Type = fib_types.FibPathType(o.Uint32(tmp[pos : pos+4]))
1534                 pos += 4
1535                 // field[4] m.Route.Paths[j2].Path.Flags
1536                 m.Route.Paths[j2].Path.Flags = fib_types.FibPathFlags(o.Uint32(tmp[pos : pos+4]))
1537                 pos += 4
1538                 // field[4] m.Route.Paths[j2].Path.Proto
1539                 m.Route.Paths[j2].Path.Proto = fib_types.FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
1540                 pos += 4
1541                 // field[4] m.Route.Paths[j2].Path.Nh
1542                 // field[5] m.Route.Paths[j2].Path.Nh.Address
1543                 copy(m.Route.Paths[j2].Path.Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
1544                 pos += 16
1545                 // field[5] m.Route.Paths[j2].Path.Nh.ViaLabel
1546                 m.Route.Paths[j2].Path.Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
1547                 pos += 4
1548                 // field[5] m.Route.Paths[j2].Path.Nh.ObjID
1549                 m.Route.Paths[j2].Path.Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
1550                 pos += 4
1551                 // field[5] m.Route.Paths[j2].Path.Nh.ClassifyTableIndex
1552                 m.Route.Paths[j2].Path.Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1553                 pos += 4
1554                 // field[4] m.Route.Paths[j2].Path.NLabels
1555                 m.Route.Paths[j2].Path.NLabels = uint8(tmp[pos])
1556                 pos += 1
1557                 // field[4] m.Route.Paths[j2].Path.LabelStack
1558                 for j4 := 0; j4 < 16; j4++ {
1559                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].IsUniform
1560                         m.Route.Paths[j2].Path.LabelStack[j4].IsUniform = uint8(tmp[pos])
1561                         pos += 1
1562                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Label
1563                         m.Route.Paths[j2].Path.LabelStack[j4].Label = uint32(o.Uint32(tmp[pos : pos+4]))
1564                         pos += 4
1565                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].TTL
1566                         m.Route.Paths[j2].Path.LabelStack[j4].TTL = uint8(tmp[pos])
1567                         pos += 1
1568                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Exp
1569                         m.Route.Paths[j2].Path.LabelStack[j4].Exp = uint8(tmp[pos])
1570                         pos += 1
1571                 }
1572         }
1573         return nil
1574 }
1575
1576 // IPMrouteDump represents VPP binary API message 'ip_mroute_dump'.
1577 type IPMrouteDump struct {
1578         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
1579 }
1580
1581 func (m *IPMrouteDump) Reset()                        { *m = IPMrouteDump{} }
1582 func (*IPMrouteDump) GetMessageName() string          { return "ip_mroute_dump" }
1583 func (*IPMrouteDump) GetCrcString() string            { return "b9d2e09e" }
1584 func (*IPMrouteDump) GetMessageType() api.MessageType { return api.RequestMessage }
1585
1586 func (m *IPMrouteDump) Size() int {
1587         if m == nil {
1588                 return 0
1589         }
1590         var size int
1591         // field[1] m.Table
1592         // field[2] m.Table.TableID
1593         size += 4
1594         // field[2] m.Table.IsIP6
1595         size += 1
1596         // field[2] m.Table.Name
1597         size += 64
1598         return size
1599 }
1600 func (m *IPMrouteDump) Marshal(b []byte) ([]byte, error) {
1601         o := binary.BigEndian
1602         _ = o
1603         pos := 0
1604         _ = pos
1605         var buf []byte
1606         if b == nil {
1607                 buf = make([]byte, m.Size())
1608         } else {
1609                 buf = b
1610         }
1611         // field[1] m.Table
1612         // field[2] m.Table.TableID
1613         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
1614         pos += 4
1615         // field[2] m.Table.IsIP6
1616         if m.Table.IsIP6 {
1617                 buf[pos] = 1
1618         }
1619         pos += 1
1620         // field[2] m.Table.Name
1621         copy(buf[pos:pos+64], m.Table.Name)
1622         pos += 64
1623         return buf, nil
1624 }
1625 func (m *IPMrouteDump) Unmarshal(tmp []byte) error {
1626         o := binary.BigEndian
1627         _ = o
1628         pos := 0
1629         _ = pos
1630         // field[1] m.Table
1631         // field[2] m.Table.TableID
1632         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1633         pos += 4
1634         // field[2] m.Table.IsIP6
1635         m.Table.IsIP6 = tmp[pos] != 0
1636         pos += 1
1637         // field[2] m.Table.Name
1638         {
1639                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1640                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
1641                 pos += 64
1642         }
1643         return nil
1644 }
1645
1646 // IPMtableDetails represents VPP binary API message 'ip_mtable_details'.
1647 type IPMtableDetails struct {
1648         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
1649 }
1650
1651 func (m *IPMtableDetails) Reset()                        { *m = IPMtableDetails{} }
1652 func (*IPMtableDetails) GetMessageName() string          { return "ip_mtable_details" }
1653 func (*IPMtableDetails) GetCrcString() string            { return "b9d2e09e" }
1654 func (*IPMtableDetails) GetMessageType() api.MessageType { return api.RequestMessage }
1655
1656 func (m *IPMtableDetails) Size() int {
1657         if m == nil {
1658                 return 0
1659         }
1660         var size int
1661         // field[1] m.Table
1662         // field[2] m.Table.TableID
1663         size += 4
1664         // field[2] m.Table.IsIP6
1665         size += 1
1666         // field[2] m.Table.Name
1667         size += 64
1668         return size
1669 }
1670 func (m *IPMtableDetails) Marshal(b []byte) ([]byte, error) {
1671         o := binary.BigEndian
1672         _ = o
1673         pos := 0
1674         _ = pos
1675         var buf []byte
1676         if b == nil {
1677                 buf = make([]byte, m.Size())
1678         } else {
1679                 buf = b
1680         }
1681         // field[1] m.Table
1682         // field[2] m.Table.TableID
1683         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
1684         pos += 4
1685         // field[2] m.Table.IsIP6
1686         if m.Table.IsIP6 {
1687                 buf[pos] = 1
1688         }
1689         pos += 1
1690         // field[2] m.Table.Name
1691         copy(buf[pos:pos+64], m.Table.Name)
1692         pos += 64
1693         return buf, nil
1694 }
1695 func (m *IPMtableDetails) Unmarshal(tmp []byte) error {
1696         o := binary.BigEndian
1697         _ = o
1698         pos := 0
1699         _ = pos
1700         // field[1] m.Table
1701         // field[2] m.Table.TableID
1702         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1703         pos += 4
1704         // field[2] m.Table.IsIP6
1705         m.Table.IsIP6 = tmp[pos] != 0
1706         pos += 1
1707         // field[2] m.Table.Name
1708         {
1709                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1710                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
1711                 pos += 64
1712         }
1713         return nil
1714 }
1715
1716 // IPMtableDump represents VPP binary API message 'ip_mtable_dump'.
1717 type IPMtableDump struct{}
1718
1719 func (m *IPMtableDump) Reset()                        { *m = IPMtableDump{} }
1720 func (*IPMtableDump) GetMessageName() string          { return "ip_mtable_dump" }
1721 func (*IPMtableDump) GetCrcString() string            { return "51077d14" }
1722 func (*IPMtableDump) GetMessageType() api.MessageType { return api.RequestMessage }
1723
1724 func (m *IPMtableDump) Size() int {
1725         if m == nil {
1726                 return 0
1727         }
1728         var size int
1729         return size
1730 }
1731 func (m *IPMtableDump) Marshal(b []byte) ([]byte, error) {
1732         o := binary.BigEndian
1733         _ = o
1734         pos := 0
1735         _ = pos
1736         var buf []byte
1737         if b == nil {
1738                 buf = make([]byte, m.Size())
1739         } else {
1740                 buf = b
1741         }
1742         return buf, nil
1743 }
1744 func (m *IPMtableDump) Unmarshal(tmp []byte) error {
1745         o := binary.BigEndian
1746         _ = o
1747         pos := 0
1748         _ = pos
1749         return nil
1750 }
1751
1752 // IPPuntPolice represents VPP binary API message 'ip_punt_police'.
1753 type IPPuntPolice struct {
1754         PolicerIndex uint32 `binapi:"u32,name=policer_index" json:"policer_index,omitempty"`
1755         IsAdd        bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1756         IsIP6        bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
1757 }
1758
1759 func (m *IPPuntPolice) Reset()                        { *m = IPPuntPolice{} }
1760 func (*IPPuntPolice) GetMessageName() string          { return "ip_punt_police" }
1761 func (*IPPuntPolice) GetCrcString() string            { return "db867cea" }
1762 func (*IPPuntPolice) GetMessageType() api.MessageType { return api.RequestMessage }
1763
1764 func (m *IPPuntPolice) Size() int {
1765         if m == nil {
1766                 return 0
1767         }
1768         var size int
1769         // field[1] m.PolicerIndex
1770         size += 4
1771         // field[1] m.IsAdd
1772         size += 1
1773         // field[1] m.IsIP6
1774         size += 1
1775         return size
1776 }
1777 func (m *IPPuntPolice) Marshal(b []byte) ([]byte, error) {
1778         o := binary.BigEndian
1779         _ = o
1780         pos := 0
1781         _ = pos
1782         var buf []byte
1783         if b == nil {
1784                 buf = make([]byte, m.Size())
1785         } else {
1786                 buf = b
1787         }
1788         // field[1] m.PolicerIndex
1789         o.PutUint32(buf[pos:pos+4], uint32(m.PolicerIndex))
1790         pos += 4
1791         // field[1] m.IsAdd
1792         if m.IsAdd {
1793                 buf[pos] = 1
1794         }
1795         pos += 1
1796         // field[1] m.IsIP6
1797         if m.IsIP6 {
1798                 buf[pos] = 1
1799         }
1800         pos += 1
1801         return buf, nil
1802 }
1803 func (m *IPPuntPolice) Unmarshal(tmp []byte) error {
1804         o := binary.BigEndian
1805         _ = o
1806         pos := 0
1807         _ = pos
1808         // field[1] m.PolicerIndex
1809         m.PolicerIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1810         pos += 4
1811         // field[1] m.IsAdd
1812         m.IsAdd = tmp[pos] != 0
1813         pos += 1
1814         // field[1] m.IsIP6
1815         m.IsIP6 = tmp[pos] != 0
1816         pos += 1
1817         return nil
1818 }
1819
1820 // IPPuntPoliceReply represents VPP binary API message 'ip_punt_police_reply'.
1821 type IPPuntPoliceReply struct {
1822         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1823 }
1824
1825 func (m *IPPuntPoliceReply) Reset()                        { *m = IPPuntPoliceReply{} }
1826 func (*IPPuntPoliceReply) GetMessageName() string          { return "ip_punt_police_reply" }
1827 func (*IPPuntPoliceReply) GetCrcString() string            { return "e8d4e804" }
1828 func (*IPPuntPoliceReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1829
1830 func (m *IPPuntPoliceReply) Size() int {
1831         if m == nil {
1832                 return 0
1833         }
1834         var size int
1835         // field[1] m.Retval
1836         size += 4
1837         return size
1838 }
1839 func (m *IPPuntPoliceReply) Marshal(b []byte) ([]byte, error) {
1840         o := binary.BigEndian
1841         _ = o
1842         pos := 0
1843         _ = pos
1844         var buf []byte
1845         if b == nil {
1846                 buf = make([]byte, m.Size())
1847         } else {
1848                 buf = b
1849         }
1850         // field[1] m.Retval
1851         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1852         pos += 4
1853         return buf, nil
1854 }
1855 func (m *IPPuntPoliceReply) Unmarshal(tmp []byte) error {
1856         o := binary.BigEndian
1857         _ = o
1858         pos := 0
1859         _ = pos
1860         // field[1] m.Retval
1861         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1862         pos += 4
1863         return nil
1864 }
1865
1866 // IPPuntRedirect represents VPP binary API message 'ip_punt_redirect'.
1867 type IPPuntRedirect struct {
1868         Punt  PuntRedirect `binapi:"punt_redirect,name=punt" json:"punt,omitempty"`
1869         IsAdd bool         `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1870 }
1871
1872 func (m *IPPuntRedirect) Reset()                        { *m = IPPuntRedirect{} }
1873 func (*IPPuntRedirect) GetMessageName() string          { return "ip_punt_redirect" }
1874 func (*IPPuntRedirect) GetCrcString() string            { return "a9a5592c" }
1875 func (*IPPuntRedirect) GetMessageType() api.MessageType { return api.RequestMessage }
1876
1877 func (m *IPPuntRedirect) Size() int {
1878         if m == nil {
1879                 return 0
1880         }
1881         var size int
1882         // field[1] m.Punt
1883         // field[2] m.Punt.RxSwIfIndex
1884         size += 4
1885         // field[2] m.Punt.TxSwIfIndex
1886         size += 4
1887         // field[2] m.Punt.Nh
1888         // field[3] m.Punt.Nh.Af
1889         size += 1
1890         // field[3] m.Punt.Nh.Un
1891         size += 16
1892         // field[1] m.IsAdd
1893         size += 1
1894         return size
1895 }
1896 func (m *IPPuntRedirect) Marshal(b []byte) ([]byte, error) {
1897         o := binary.BigEndian
1898         _ = o
1899         pos := 0
1900         _ = pos
1901         var buf []byte
1902         if b == nil {
1903                 buf = make([]byte, m.Size())
1904         } else {
1905                 buf = b
1906         }
1907         // field[1] m.Punt
1908         // field[2] m.Punt.RxSwIfIndex
1909         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.RxSwIfIndex))
1910         pos += 4
1911         // field[2] m.Punt.TxSwIfIndex
1912         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.TxSwIfIndex))
1913         pos += 4
1914         // field[2] m.Punt.Nh
1915         // field[3] m.Punt.Nh.Af
1916         buf[pos] = uint8(m.Punt.Nh.Af)
1917         pos += 1
1918         // field[3] m.Punt.Nh.Un
1919         copy(buf[pos:pos+16], m.Punt.Nh.Un.XXX_UnionData[:])
1920         pos += 16
1921         // field[1] m.IsAdd
1922         if m.IsAdd {
1923                 buf[pos] = 1
1924         }
1925         pos += 1
1926         return buf, nil
1927 }
1928 func (m *IPPuntRedirect) Unmarshal(tmp []byte) error {
1929         o := binary.BigEndian
1930         _ = o
1931         pos := 0
1932         _ = pos
1933         // field[1] m.Punt
1934         // field[2] m.Punt.RxSwIfIndex
1935         m.Punt.RxSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1936         pos += 4
1937         // field[2] m.Punt.TxSwIfIndex
1938         m.Punt.TxSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1939         pos += 4
1940         // field[2] m.Punt.Nh
1941         // field[3] m.Punt.Nh.Af
1942         m.Punt.Nh.Af = fib_types.AddressFamily(tmp[pos])
1943         pos += 1
1944         // field[3] m.Punt.Nh.Un
1945         copy(m.Punt.Nh.Un.XXX_UnionData[:], tmp[pos:pos+16])
1946         pos += 16
1947         // field[1] m.IsAdd
1948         m.IsAdd = tmp[pos] != 0
1949         pos += 1
1950         return nil
1951 }
1952
1953 // IPPuntRedirectDetails represents VPP binary API message 'ip_punt_redirect_details'.
1954 type IPPuntRedirectDetails struct {
1955         Punt PuntRedirect `binapi:"punt_redirect,name=punt" json:"punt,omitempty"`
1956 }
1957
1958 func (m *IPPuntRedirectDetails) Reset()                        { *m = IPPuntRedirectDetails{} }
1959 func (*IPPuntRedirectDetails) GetMessageName() string          { return "ip_punt_redirect_details" }
1960 func (*IPPuntRedirectDetails) GetCrcString() string            { return "3924f5d3" }
1961 func (*IPPuntRedirectDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1962
1963 func (m *IPPuntRedirectDetails) Size() int {
1964         if m == nil {
1965                 return 0
1966         }
1967         var size int
1968         // field[1] m.Punt
1969         // field[2] m.Punt.RxSwIfIndex
1970         size += 4
1971         // field[2] m.Punt.TxSwIfIndex
1972         size += 4
1973         // field[2] m.Punt.Nh
1974         // field[3] m.Punt.Nh.Af
1975         size += 1
1976         // field[3] m.Punt.Nh.Un
1977         size += 16
1978         return size
1979 }
1980 func (m *IPPuntRedirectDetails) Marshal(b []byte) ([]byte, error) {
1981         o := binary.BigEndian
1982         _ = o
1983         pos := 0
1984         _ = pos
1985         var buf []byte
1986         if b == nil {
1987                 buf = make([]byte, m.Size())
1988         } else {
1989                 buf = b
1990         }
1991         // field[1] m.Punt
1992         // field[2] m.Punt.RxSwIfIndex
1993         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.RxSwIfIndex))
1994         pos += 4
1995         // field[2] m.Punt.TxSwIfIndex
1996         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.TxSwIfIndex))
1997         pos += 4
1998         // field[2] m.Punt.Nh
1999         // field[3] m.Punt.Nh.Af
2000         buf[pos] = uint8(m.Punt.Nh.Af)
2001         pos += 1
2002         // field[3] m.Punt.Nh.Un
2003         copy(buf[pos:pos+16], m.Punt.Nh.Un.XXX_UnionData[:])
2004         pos += 16
2005         return buf, nil
2006 }
2007 func (m *IPPuntRedirectDetails) Unmarshal(tmp []byte) error {
2008         o := binary.BigEndian
2009         _ = o
2010         pos := 0
2011         _ = pos
2012         // field[1] m.Punt
2013         // field[2] m.Punt.RxSwIfIndex
2014         m.Punt.RxSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2015         pos += 4
2016         // field[2] m.Punt.TxSwIfIndex
2017         m.Punt.TxSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2018         pos += 4
2019         // field[2] m.Punt.Nh
2020         // field[3] m.Punt.Nh.Af
2021         m.Punt.Nh.Af = fib_types.AddressFamily(tmp[pos])
2022         pos += 1
2023         // field[3] m.Punt.Nh.Un
2024         copy(m.Punt.Nh.Un.XXX_UnionData[:], tmp[pos:pos+16])
2025         pos += 16
2026         return nil
2027 }
2028
2029 // IPPuntRedirectDump represents VPP binary API message 'ip_punt_redirect_dump'.
2030 type IPPuntRedirectDump struct {
2031         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2032         IsIPv6    bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
2033 }
2034
2035 func (m *IPPuntRedirectDump) Reset()                        { *m = IPPuntRedirectDump{} }
2036 func (*IPPuntRedirectDump) GetMessageName() string          { return "ip_punt_redirect_dump" }
2037 func (*IPPuntRedirectDump) GetCrcString() string            { return "2d033de4" }
2038 func (*IPPuntRedirectDump) GetMessageType() api.MessageType { return api.RequestMessage }
2039
2040 func (m *IPPuntRedirectDump) Size() int {
2041         if m == nil {
2042                 return 0
2043         }
2044         var size int
2045         // field[1] m.SwIfIndex
2046         size += 4
2047         // field[1] m.IsIPv6
2048         size += 1
2049         return size
2050 }
2051 func (m *IPPuntRedirectDump) Marshal(b []byte) ([]byte, error) {
2052         o := binary.BigEndian
2053         _ = o
2054         pos := 0
2055         _ = pos
2056         var buf []byte
2057         if b == nil {
2058                 buf = make([]byte, m.Size())
2059         } else {
2060                 buf = b
2061         }
2062         // field[1] m.SwIfIndex
2063         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2064         pos += 4
2065         // field[1] m.IsIPv6
2066         if m.IsIPv6 {
2067                 buf[pos] = 1
2068         }
2069         pos += 1
2070         return buf, nil
2071 }
2072 func (m *IPPuntRedirectDump) Unmarshal(tmp []byte) error {
2073         o := binary.BigEndian
2074         _ = o
2075         pos := 0
2076         _ = pos
2077         // field[1] m.SwIfIndex
2078         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2079         pos += 4
2080         // field[1] m.IsIPv6
2081         m.IsIPv6 = tmp[pos] != 0
2082         pos += 1
2083         return nil
2084 }
2085
2086 // IPPuntRedirectReply represents VPP binary API message 'ip_punt_redirect_reply'.
2087 type IPPuntRedirectReply struct {
2088         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2089 }
2090
2091 func (m *IPPuntRedirectReply) Reset()                        { *m = IPPuntRedirectReply{} }
2092 func (*IPPuntRedirectReply) GetMessageName() string          { return "ip_punt_redirect_reply" }
2093 func (*IPPuntRedirectReply) GetCrcString() string            { return "e8d4e804" }
2094 func (*IPPuntRedirectReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2095
2096 func (m *IPPuntRedirectReply) Size() int {
2097         if m == nil {
2098                 return 0
2099         }
2100         var size int
2101         // field[1] m.Retval
2102         size += 4
2103         return size
2104 }
2105 func (m *IPPuntRedirectReply) Marshal(b []byte) ([]byte, error) {
2106         o := binary.BigEndian
2107         _ = o
2108         pos := 0
2109         _ = pos
2110         var buf []byte
2111         if b == nil {
2112                 buf = make([]byte, m.Size())
2113         } else {
2114                 buf = b
2115         }
2116         // field[1] m.Retval
2117         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2118         pos += 4
2119         return buf, nil
2120 }
2121 func (m *IPPuntRedirectReply) Unmarshal(tmp []byte) error {
2122         o := binary.BigEndian
2123         _ = o
2124         pos := 0
2125         _ = pos
2126         // field[1] m.Retval
2127         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2128         pos += 4
2129         return nil
2130 }
2131
2132 // IPReassemblyEnableDisable represents VPP binary API message 'ip_reassembly_enable_disable'.
2133 type IPReassemblyEnableDisable struct {
2134         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2135         EnableIP4 bool                           `binapi:"bool,name=enable_ip4" json:"enable_ip4,omitempty"`
2136         EnableIP6 bool                           `binapi:"bool,name=enable_ip6" json:"enable_ip6,omitempty"`
2137         Type      IPReassType                    `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
2138 }
2139
2140 func (m *IPReassemblyEnableDisable) Reset()                        { *m = IPReassemblyEnableDisable{} }
2141 func (*IPReassemblyEnableDisable) GetMessageName() string          { return "ip_reassembly_enable_disable" }
2142 func (*IPReassemblyEnableDisable) GetCrcString() string            { return "885c85a6" }
2143 func (*IPReassemblyEnableDisable) GetMessageType() api.MessageType { return api.RequestMessage }
2144
2145 func (m *IPReassemblyEnableDisable) Size() int {
2146         if m == nil {
2147                 return 0
2148         }
2149         var size int
2150         // field[1] m.SwIfIndex
2151         size += 4
2152         // field[1] m.EnableIP4
2153         size += 1
2154         // field[1] m.EnableIP6
2155         size += 1
2156         // field[1] m.Type
2157         size += 4
2158         return size
2159 }
2160 func (m *IPReassemblyEnableDisable) Marshal(b []byte) ([]byte, error) {
2161         o := binary.BigEndian
2162         _ = o
2163         pos := 0
2164         _ = pos
2165         var buf []byte
2166         if b == nil {
2167                 buf = make([]byte, m.Size())
2168         } else {
2169                 buf = b
2170         }
2171         // field[1] m.SwIfIndex
2172         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2173         pos += 4
2174         // field[1] m.EnableIP4
2175         if m.EnableIP4 {
2176                 buf[pos] = 1
2177         }
2178         pos += 1
2179         // field[1] m.EnableIP6
2180         if m.EnableIP6 {
2181                 buf[pos] = 1
2182         }
2183         pos += 1
2184         // field[1] m.Type
2185         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
2186         pos += 4
2187         return buf, nil
2188 }
2189 func (m *IPReassemblyEnableDisable) Unmarshal(tmp []byte) error {
2190         o := binary.BigEndian
2191         _ = o
2192         pos := 0
2193         _ = pos
2194         // field[1] m.SwIfIndex
2195         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2196         pos += 4
2197         // field[1] m.EnableIP4
2198         m.EnableIP4 = tmp[pos] != 0
2199         pos += 1
2200         // field[1] m.EnableIP6
2201         m.EnableIP6 = tmp[pos] != 0
2202         pos += 1
2203         // field[1] m.Type
2204         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
2205         pos += 4
2206         return nil
2207 }
2208
2209 // IPReassemblyEnableDisableReply represents VPP binary API message 'ip_reassembly_enable_disable_reply'.
2210 type IPReassemblyEnableDisableReply struct {
2211         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2212 }
2213
2214 func (m *IPReassemblyEnableDisableReply) Reset() { *m = IPReassemblyEnableDisableReply{} }
2215 func (*IPReassemblyEnableDisableReply) GetMessageName() string {
2216         return "ip_reassembly_enable_disable_reply"
2217 }
2218 func (*IPReassemblyEnableDisableReply) GetCrcString() string            { return "e8d4e804" }
2219 func (*IPReassemblyEnableDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2220
2221 func (m *IPReassemblyEnableDisableReply) Size() int {
2222         if m == nil {
2223                 return 0
2224         }
2225         var size int
2226         // field[1] m.Retval
2227         size += 4
2228         return size
2229 }
2230 func (m *IPReassemblyEnableDisableReply) Marshal(b []byte) ([]byte, error) {
2231         o := binary.BigEndian
2232         _ = o
2233         pos := 0
2234         _ = pos
2235         var buf []byte
2236         if b == nil {
2237                 buf = make([]byte, m.Size())
2238         } else {
2239                 buf = b
2240         }
2241         // field[1] m.Retval
2242         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2243         pos += 4
2244         return buf, nil
2245 }
2246 func (m *IPReassemblyEnableDisableReply) Unmarshal(tmp []byte) error {
2247         o := binary.BigEndian
2248         _ = o
2249         pos := 0
2250         _ = pos
2251         // field[1] m.Retval
2252         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2253         pos += 4
2254         return nil
2255 }
2256
2257 // IPReassemblyGet represents VPP binary API message 'ip_reassembly_get'.
2258 type IPReassemblyGet struct {
2259         IsIP6 bool        `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2260         Type  IPReassType `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
2261 }
2262
2263 func (m *IPReassemblyGet) Reset()                        { *m = IPReassemblyGet{} }
2264 func (*IPReassemblyGet) GetMessageName() string          { return "ip_reassembly_get" }
2265 func (*IPReassemblyGet) GetCrcString() string            { return "ea13ff63" }
2266 func (*IPReassemblyGet) GetMessageType() api.MessageType { return api.RequestMessage }
2267
2268 func (m *IPReassemblyGet) Size() int {
2269         if m == nil {
2270                 return 0
2271         }
2272         var size int
2273         // field[1] m.IsIP6
2274         size += 1
2275         // field[1] m.Type
2276         size += 4
2277         return size
2278 }
2279 func (m *IPReassemblyGet) Marshal(b []byte) ([]byte, error) {
2280         o := binary.BigEndian
2281         _ = o
2282         pos := 0
2283         _ = pos
2284         var buf []byte
2285         if b == nil {
2286                 buf = make([]byte, m.Size())
2287         } else {
2288                 buf = b
2289         }
2290         // field[1] m.IsIP6
2291         if m.IsIP6 {
2292                 buf[pos] = 1
2293         }
2294         pos += 1
2295         // field[1] m.Type
2296         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
2297         pos += 4
2298         return buf, nil
2299 }
2300 func (m *IPReassemblyGet) Unmarshal(tmp []byte) error {
2301         o := binary.BigEndian
2302         _ = o
2303         pos := 0
2304         _ = pos
2305         // field[1] m.IsIP6
2306         m.IsIP6 = tmp[pos] != 0
2307         pos += 1
2308         // field[1] m.Type
2309         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
2310         pos += 4
2311         return nil
2312 }
2313
2314 // IPReassemblyGetReply represents VPP binary API message 'ip_reassembly_get_reply'.
2315 type IPReassemblyGetReply struct {
2316         Retval               int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2317         TimeoutMs            uint32 `binapi:"u32,name=timeout_ms" json:"timeout_ms,omitempty"`
2318         MaxReassemblies      uint32 `binapi:"u32,name=max_reassemblies" json:"max_reassemblies,omitempty"`
2319         MaxReassemblyLength  uint32 `binapi:"u32,name=max_reassembly_length" json:"max_reassembly_length,omitempty"`
2320         ExpireWalkIntervalMs uint32 `binapi:"u32,name=expire_walk_interval_ms" json:"expire_walk_interval_ms,omitempty"`
2321         IsIP6                bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2322 }
2323
2324 func (m *IPReassemblyGetReply) Reset()                        { *m = IPReassemblyGetReply{} }
2325 func (*IPReassemblyGetReply) GetMessageName() string          { return "ip_reassembly_get_reply" }
2326 func (*IPReassemblyGetReply) GetCrcString() string            { return "d5eb8d34" }
2327 func (*IPReassemblyGetReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2328
2329 func (m *IPReassemblyGetReply) Size() int {
2330         if m == nil {
2331                 return 0
2332         }
2333         var size int
2334         // field[1] m.Retval
2335         size += 4
2336         // field[1] m.TimeoutMs
2337         size += 4
2338         // field[1] m.MaxReassemblies
2339         size += 4
2340         // field[1] m.MaxReassemblyLength
2341         size += 4
2342         // field[1] m.ExpireWalkIntervalMs
2343         size += 4
2344         // field[1] m.IsIP6
2345         size += 1
2346         return size
2347 }
2348 func (m *IPReassemblyGetReply) Marshal(b []byte) ([]byte, error) {
2349         o := binary.BigEndian
2350         _ = o
2351         pos := 0
2352         _ = pos
2353         var buf []byte
2354         if b == nil {
2355                 buf = make([]byte, m.Size())
2356         } else {
2357                 buf = b
2358         }
2359         // field[1] m.Retval
2360         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2361         pos += 4
2362         // field[1] m.TimeoutMs
2363         o.PutUint32(buf[pos:pos+4], uint32(m.TimeoutMs))
2364         pos += 4
2365         // field[1] m.MaxReassemblies
2366         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblies))
2367         pos += 4
2368         // field[1] m.MaxReassemblyLength
2369         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblyLength))
2370         pos += 4
2371         // field[1] m.ExpireWalkIntervalMs
2372         o.PutUint32(buf[pos:pos+4], uint32(m.ExpireWalkIntervalMs))
2373         pos += 4
2374         // field[1] m.IsIP6
2375         if m.IsIP6 {
2376                 buf[pos] = 1
2377         }
2378         pos += 1
2379         return buf, nil
2380 }
2381 func (m *IPReassemblyGetReply) Unmarshal(tmp []byte) error {
2382         o := binary.BigEndian
2383         _ = o
2384         pos := 0
2385         _ = pos
2386         // field[1] m.Retval
2387         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2388         pos += 4
2389         // field[1] m.TimeoutMs
2390         m.TimeoutMs = uint32(o.Uint32(tmp[pos : pos+4]))
2391         pos += 4
2392         // field[1] m.MaxReassemblies
2393         m.MaxReassemblies = uint32(o.Uint32(tmp[pos : pos+4]))
2394         pos += 4
2395         // field[1] m.MaxReassemblyLength
2396         m.MaxReassemblyLength = uint32(o.Uint32(tmp[pos : pos+4]))
2397         pos += 4
2398         // field[1] m.ExpireWalkIntervalMs
2399         m.ExpireWalkIntervalMs = uint32(o.Uint32(tmp[pos : pos+4]))
2400         pos += 4
2401         // field[1] m.IsIP6
2402         m.IsIP6 = tmp[pos] != 0
2403         pos += 1
2404         return nil
2405 }
2406
2407 // IPReassemblySet represents VPP binary API message 'ip_reassembly_set'.
2408 type IPReassemblySet struct {
2409         TimeoutMs            uint32      `binapi:"u32,name=timeout_ms" json:"timeout_ms,omitempty"`
2410         MaxReassemblies      uint32      `binapi:"u32,name=max_reassemblies" json:"max_reassemblies,omitempty"`
2411         MaxReassemblyLength  uint32      `binapi:"u32,name=max_reassembly_length" json:"max_reassembly_length,omitempty"`
2412         ExpireWalkIntervalMs uint32      `binapi:"u32,name=expire_walk_interval_ms" json:"expire_walk_interval_ms,omitempty"`
2413         IsIP6                bool        `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2414         Type                 IPReassType `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
2415 }
2416
2417 func (m *IPReassemblySet) Reset()                        { *m = IPReassemblySet{} }
2418 func (*IPReassemblySet) GetMessageName() string          { return "ip_reassembly_set" }
2419 func (*IPReassemblySet) GetCrcString() string            { return "16467d25" }
2420 func (*IPReassemblySet) GetMessageType() api.MessageType { return api.RequestMessage }
2421
2422 func (m *IPReassemblySet) Size() int {
2423         if m == nil {
2424                 return 0
2425         }
2426         var size int
2427         // field[1] m.TimeoutMs
2428         size += 4
2429         // field[1] m.MaxReassemblies
2430         size += 4
2431         // field[1] m.MaxReassemblyLength
2432         size += 4
2433         // field[1] m.ExpireWalkIntervalMs
2434         size += 4
2435         // field[1] m.IsIP6
2436         size += 1
2437         // field[1] m.Type
2438         size += 4
2439         return size
2440 }
2441 func (m *IPReassemblySet) Marshal(b []byte) ([]byte, error) {
2442         o := binary.BigEndian
2443         _ = o
2444         pos := 0
2445         _ = pos
2446         var buf []byte
2447         if b == nil {
2448                 buf = make([]byte, m.Size())
2449         } else {
2450                 buf = b
2451         }
2452         // field[1] m.TimeoutMs
2453         o.PutUint32(buf[pos:pos+4], uint32(m.TimeoutMs))
2454         pos += 4
2455         // field[1] m.MaxReassemblies
2456         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblies))
2457         pos += 4
2458         // field[1] m.MaxReassemblyLength
2459         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblyLength))
2460         pos += 4
2461         // field[1] m.ExpireWalkIntervalMs
2462         o.PutUint32(buf[pos:pos+4], uint32(m.ExpireWalkIntervalMs))
2463         pos += 4
2464         // field[1] m.IsIP6
2465         if m.IsIP6 {
2466                 buf[pos] = 1
2467         }
2468         pos += 1
2469         // field[1] m.Type
2470         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
2471         pos += 4
2472         return buf, nil
2473 }
2474 func (m *IPReassemblySet) Unmarshal(tmp []byte) error {
2475         o := binary.BigEndian
2476         _ = o
2477         pos := 0
2478         _ = pos
2479         // field[1] m.TimeoutMs
2480         m.TimeoutMs = uint32(o.Uint32(tmp[pos : pos+4]))
2481         pos += 4
2482         // field[1] m.MaxReassemblies
2483         m.MaxReassemblies = uint32(o.Uint32(tmp[pos : pos+4]))
2484         pos += 4
2485         // field[1] m.MaxReassemblyLength
2486         m.MaxReassemblyLength = uint32(o.Uint32(tmp[pos : pos+4]))
2487         pos += 4
2488         // field[1] m.ExpireWalkIntervalMs
2489         m.ExpireWalkIntervalMs = uint32(o.Uint32(tmp[pos : pos+4]))
2490         pos += 4
2491         // field[1] m.IsIP6
2492         m.IsIP6 = tmp[pos] != 0
2493         pos += 1
2494         // field[1] m.Type
2495         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
2496         pos += 4
2497         return nil
2498 }
2499
2500 // IPReassemblySetReply represents VPP binary API message 'ip_reassembly_set_reply'.
2501 type IPReassemblySetReply struct {
2502         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2503 }
2504
2505 func (m *IPReassemblySetReply) Reset()                        { *m = IPReassemblySetReply{} }
2506 func (*IPReassemblySetReply) GetMessageName() string          { return "ip_reassembly_set_reply" }
2507 func (*IPReassemblySetReply) GetCrcString() string            { return "e8d4e804" }
2508 func (*IPReassemblySetReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2509
2510 func (m *IPReassemblySetReply) Size() int {
2511         if m == nil {
2512                 return 0
2513         }
2514         var size int
2515         // field[1] m.Retval
2516         size += 4
2517         return size
2518 }
2519 func (m *IPReassemblySetReply) Marshal(b []byte) ([]byte, error) {
2520         o := binary.BigEndian
2521         _ = o
2522         pos := 0
2523         _ = pos
2524         var buf []byte
2525         if b == nil {
2526                 buf = make([]byte, m.Size())
2527         } else {
2528                 buf = b
2529         }
2530         // field[1] m.Retval
2531         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2532         pos += 4
2533         return buf, nil
2534 }
2535 func (m *IPReassemblySetReply) Unmarshal(tmp []byte) error {
2536         o := binary.BigEndian
2537         _ = o
2538         pos := 0
2539         _ = pos
2540         // field[1] m.Retval
2541         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2542         pos += 4
2543         return nil
2544 }
2545
2546 // IPRouteAddDel represents VPP binary API message 'ip_route_add_del'.
2547 type IPRouteAddDel struct {
2548         IsAdd       bool    `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
2549         IsMultipath bool    `binapi:"bool,name=is_multipath" json:"is_multipath,omitempty"`
2550         Route       IPRoute `binapi:"ip_route,name=route" json:"route,omitempty"`
2551 }
2552
2553 func (m *IPRouteAddDel) Reset()                        { *m = IPRouteAddDel{} }
2554 func (*IPRouteAddDel) GetMessageName() string          { return "ip_route_add_del" }
2555 func (*IPRouteAddDel) GetCrcString() string            { return "c1ff832d" }
2556 func (*IPRouteAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
2557
2558 func (m *IPRouteAddDel) Size() int {
2559         if m == nil {
2560                 return 0
2561         }
2562         var size int
2563         // field[1] m.IsAdd
2564         size += 1
2565         // field[1] m.IsMultipath
2566         size += 1
2567         // field[1] m.Route
2568         // field[2] m.Route.TableID
2569         size += 4
2570         // field[2] m.Route.StatsIndex
2571         size += 4
2572         // field[2] m.Route.Prefix
2573         // field[3] m.Route.Prefix.Address
2574         // field[4] m.Route.Prefix.Address.Af
2575         size += 1
2576         // field[4] m.Route.Prefix.Address.Un
2577         size += 16
2578         // field[3] m.Route.Prefix.Len
2579         size += 1
2580         // field[2] m.Route.NPaths
2581         size += 1
2582         // field[2] m.Route.Paths
2583         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
2584                 var s2 fib_types.FibPath
2585                 _ = s2
2586                 if j2 < len(m.Route.Paths) {
2587                         s2 = m.Route.Paths[j2]
2588                 }
2589                 // field[3] s2.SwIfIndex
2590                 size += 4
2591                 // field[3] s2.TableID
2592                 size += 4
2593                 // field[3] s2.RpfID
2594                 size += 4
2595                 // field[3] s2.Weight
2596                 size += 1
2597                 // field[3] s2.Preference
2598                 size += 1
2599                 // field[3] s2.Type
2600                 size += 4
2601                 // field[3] s2.Flags
2602                 size += 4
2603                 // field[3] s2.Proto
2604                 size += 4
2605                 // field[3] s2.Nh
2606                 // field[4] s2.Nh.Address
2607                 size += 16
2608                 // field[4] s2.Nh.ViaLabel
2609                 size += 4
2610                 // field[4] s2.Nh.ObjID
2611                 size += 4
2612                 // field[4] s2.Nh.ClassifyTableIndex
2613                 size += 4
2614                 // field[3] s2.NLabels
2615                 size += 1
2616                 // field[3] s2.LabelStack
2617                 for j3 := 0; j3 < 16; j3++ {
2618                         var s3 fib_types.FibMplsLabel
2619                         _ = s3
2620                         if j3 < len(s2.LabelStack) {
2621                                 s3 = s2.LabelStack[j3]
2622                         }
2623                         // field[4] s3.IsUniform
2624                         size += 1
2625                         // field[4] s3.Label
2626                         size += 4
2627                         // field[4] s3.TTL
2628                         size += 1
2629                         // field[4] s3.Exp
2630                         size += 1
2631                 }
2632         }
2633         return size
2634 }
2635 func (m *IPRouteAddDel) Marshal(b []byte) ([]byte, error) {
2636         o := binary.BigEndian
2637         _ = o
2638         pos := 0
2639         _ = pos
2640         var buf []byte
2641         if b == nil {
2642                 buf = make([]byte, m.Size())
2643         } else {
2644                 buf = b
2645         }
2646         // field[1] m.IsAdd
2647         if m.IsAdd {
2648                 buf[pos] = 1
2649         }
2650         pos += 1
2651         // field[1] m.IsMultipath
2652         if m.IsMultipath {
2653                 buf[pos] = 1
2654         }
2655         pos += 1
2656         // field[1] m.Route
2657         // field[2] m.Route.TableID
2658         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
2659         pos += 4
2660         // field[2] m.Route.StatsIndex
2661         o.PutUint32(buf[pos:pos+4], uint32(m.Route.StatsIndex))
2662         pos += 4
2663         // field[2] m.Route.Prefix
2664         // field[3] m.Route.Prefix.Address
2665         // field[4] m.Route.Prefix.Address.Af
2666         buf[pos] = uint8(m.Route.Prefix.Address.Af)
2667         pos += 1
2668         // field[4] m.Route.Prefix.Address.Un
2669         copy(buf[pos:pos+16], m.Route.Prefix.Address.Un.XXX_UnionData[:])
2670         pos += 16
2671         // field[3] m.Route.Prefix.Len
2672         buf[pos] = uint8(m.Route.Prefix.Len)
2673         pos += 1
2674         // field[2] m.Route.NPaths
2675         buf[pos] = uint8(len(m.Route.Paths))
2676         pos += 1
2677         // field[2] m.Route.Paths
2678         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
2679                 var v2 fib_types.FibPath
2680                 if j2 < len(m.Route.Paths) {
2681                         v2 = m.Route.Paths[j2]
2682                 }
2683                 // field[3] v2.SwIfIndex
2684                 o.PutUint32(buf[pos:pos+4], uint32(v2.SwIfIndex))
2685                 pos += 4
2686                 // field[3] v2.TableID
2687                 o.PutUint32(buf[pos:pos+4], uint32(v2.TableID))
2688                 pos += 4
2689                 // field[3] v2.RpfID
2690                 o.PutUint32(buf[pos:pos+4], uint32(v2.RpfID))
2691                 pos += 4
2692                 // field[3] v2.Weight
2693                 buf[pos] = uint8(v2.Weight)
2694                 pos += 1
2695                 // field[3] v2.Preference
2696                 buf[pos] = uint8(v2.Preference)
2697                 pos += 1
2698                 // field[3] v2.Type
2699                 o.PutUint32(buf[pos:pos+4], uint32(v2.Type))
2700                 pos += 4
2701                 // field[3] v2.Flags
2702                 o.PutUint32(buf[pos:pos+4], uint32(v2.Flags))
2703                 pos += 4
2704                 // field[3] v2.Proto
2705                 o.PutUint32(buf[pos:pos+4], uint32(v2.Proto))
2706                 pos += 4
2707                 // field[3] v2.Nh
2708                 // field[4] v2.Nh.Address
2709                 copy(buf[pos:pos+16], v2.Nh.Address.XXX_UnionData[:])
2710                 pos += 16
2711                 // field[4] v2.Nh.ViaLabel
2712                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ViaLabel))
2713                 pos += 4
2714                 // field[4] v2.Nh.ObjID
2715                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ObjID))
2716                 pos += 4
2717                 // field[4] v2.Nh.ClassifyTableIndex
2718                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ClassifyTableIndex))
2719                 pos += 4
2720                 // field[3] v2.NLabels
2721                 buf[pos] = uint8(v2.NLabels)
2722                 pos += 1
2723                 // field[3] v2.LabelStack
2724                 for j3 := 0; j3 < 16; j3++ {
2725                         var v3 fib_types.FibMplsLabel
2726                         if j3 < len(v2.LabelStack) {
2727                                 v3 = v2.LabelStack[j3]
2728                         }
2729                         // field[4] v3.IsUniform
2730                         buf[pos] = uint8(v3.IsUniform)
2731                         pos += 1
2732                         // field[4] v3.Label
2733                         o.PutUint32(buf[pos:pos+4], uint32(v3.Label))
2734                         pos += 4
2735                         // field[4] v3.TTL
2736                         buf[pos] = uint8(v3.TTL)
2737                         pos += 1
2738                         // field[4] v3.Exp
2739                         buf[pos] = uint8(v3.Exp)
2740                         pos += 1
2741                 }
2742         }
2743         return buf, nil
2744 }
2745 func (m *IPRouteAddDel) Unmarshal(tmp []byte) error {
2746         o := binary.BigEndian
2747         _ = o
2748         pos := 0
2749         _ = pos
2750         // field[1] m.IsAdd
2751         m.IsAdd = tmp[pos] != 0
2752         pos += 1
2753         // field[1] m.IsMultipath
2754         m.IsMultipath = tmp[pos] != 0
2755         pos += 1
2756         // field[1] m.Route
2757         // field[2] m.Route.TableID
2758         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2759         pos += 4
2760         // field[2] m.Route.StatsIndex
2761         m.Route.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2762         pos += 4
2763         // field[2] m.Route.Prefix
2764         // field[3] m.Route.Prefix.Address
2765         // field[4] m.Route.Prefix.Address.Af
2766         m.Route.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
2767         pos += 1
2768         // field[4] m.Route.Prefix.Address.Un
2769         copy(m.Route.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
2770         pos += 16
2771         // field[3] m.Route.Prefix.Len
2772         m.Route.Prefix.Len = uint8(tmp[pos])
2773         pos += 1
2774         // field[2] m.Route.NPaths
2775         m.Route.NPaths = uint8(tmp[pos])
2776         pos += 1
2777         // field[2] m.Route.Paths
2778         m.Route.Paths = make([]fib_types.FibPath, int(m.Route.NPaths))
2779         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
2780                 // field[3] m.Route.Paths[j2].SwIfIndex
2781                 m.Route.Paths[j2].SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2782                 pos += 4
2783                 // field[3] m.Route.Paths[j2].TableID
2784                 m.Route.Paths[j2].TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2785                 pos += 4
2786                 // field[3] m.Route.Paths[j2].RpfID
2787                 m.Route.Paths[j2].RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
2788                 pos += 4
2789                 // field[3] m.Route.Paths[j2].Weight
2790                 m.Route.Paths[j2].Weight = uint8(tmp[pos])
2791                 pos += 1
2792                 // field[3] m.Route.Paths[j2].Preference
2793                 m.Route.Paths[j2].Preference = uint8(tmp[pos])
2794                 pos += 1
2795                 // field[3] m.Route.Paths[j2].Type
2796                 m.Route.Paths[j2].Type = fib_types.FibPathType(o.Uint32(tmp[pos : pos+4]))
2797                 pos += 4
2798                 // field[3] m.Route.Paths[j2].Flags
2799                 m.Route.Paths[j2].Flags = fib_types.FibPathFlags(o.Uint32(tmp[pos : pos+4]))
2800                 pos += 4
2801                 // field[3] m.Route.Paths[j2].Proto
2802                 m.Route.Paths[j2].Proto = fib_types.FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
2803                 pos += 4
2804                 // field[3] m.Route.Paths[j2].Nh
2805                 // field[4] m.Route.Paths[j2].Nh.Address
2806                 copy(m.Route.Paths[j2].Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
2807                 pos += 16
2808                 // field[4] m.Route.Paths[j2].Nh.ViaLabel
2809                 m.Route.Paths[j2].Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
2810                 pos += 4
2811                 // field[4] m.Route.Paths[j2].Nh.ObjID
2812                 m.Route.Paths[j2].Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
2813                 pos += 4
2814                 // field[4] m.Route.Paths[j2].Nh.ClassifyTableIndex
2815                 m.Route.Paths[j2].Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2816                 pos += 4
2817                 // field[3] m.Route.Paths[j2].NLabels
2818                 m.Route.Paths[j2].NLabels = uint8(tmp[pos])
2819                 pos += 1
2820                 // field[3] m.Route.Paths[j2].LabelStack
2821                 for j3 := 0; j3 < 16; j3++ {
2822                         // field[4] m.Route.Paths[j2].LabelStack[j3].IsUniform
2823                         m.Route.Paths[j2].LabelStack[j3].IsUniform = uint8(tmp[pos])
2824                         pos += 1
2825                         // field[4] m.Route.Paths[j2].LabelStack[j3].Label
2826                         m.Route.Paths[j2].LabelStack[j3].Label = uint32(o.Uint32(tmp[pos : pos+4]))
2827                         pos += 4
2828                         // field[4] m.Route.Paths[j2].LabelStack[j3].TTL
2829                         m.Route.Paths[j2].LabelStack[j3].TTL = uint8(tmp[pos])
2830                         pos += 1
2831                         // field[4] m.Route.Paths[j2].LabelStack[j3].Exp
2832                         m.Route.Paths[j2].LabelStack[j3].Exp = uint8(tmp[pos])
2833                         pos += 1
2834                 }
2835         }
2836         return nil
2837 }
2838
2839 // IPRouteAddDelReply represents VPP binary API message 'ip_route_add_del_reply'.
2840 type IPRouteAddDelReply struct {
2841         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2842         StatsIndex uint32 `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
2843 }
2844
2845 func (m *IPRouteAddDelReply) Reset()                        { *m = IPRouteAddDelReply{} }
2846 func (*IPRouteAddDelReply) GetMessageName() string          { return "ip_route_add_del_reply" }
2847 func (*IPRouteAddDelReply) GetCrcString() string            { return "1992deab" }
2848 func (*IPRouteAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2849
2850 func (m *IPRouteAddDelReply) Size() int {
2851         if m == nil {
2852                 return 0
2853         }
2854         var size int
2855         // field[1] m.Retval
2856         size += 4
2857         // field[1] m.StatsIndex
2858         size += 4
2859         return size
2860 }
2861 func (m *IPRouteAddDelReply) Marshal(b []byte) ([]byte, error) {
2862         o := binary.BigEndian
2863         _ = o
2864         pos := 0
2865         _ = pos
2866         var buf []byte
2867         if b == nil {
2868                 buf = make([]byte, m.Size())
2869         } else {
2870                 buf = b
2871         }
2872         // field[1] m.Retval
2873         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2874         pos += 4
2875         // field[1] m.StatsIndex
2876         o.PutUint32(buf[pos:pos+4], uint32(m.StatsIndex))
2877         pos += 4
2878         return buf, nil
2879 }
2880 func (m *IPRouteAddDelReply) Unmarshal(tmp []byte) error {
2881         o := binary.BigEndian
2882         _ = o
2883         pos := 0
2884         _ = pos
2885         // field[1] m.Retval
2886         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2887         pos += 4
2888         // field[1] m.StatsIndex
2889         m.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2890         pos += 4
2891         return nil
2892 }
2893
2894 // IPRouteDetails represents VPP binary API message 'ip_route_details'.
2895 type IPRouteDetails struct {
2896         Route IPRoute `binapi:"ip_route,name=route" json:"route,omitempty"`
2897 }
2898
2899 func (m *IPRouteDetails) Reset()                        { *m = IPRouteDetails{} }
2900 func (*IPRouteDetails) GetMessageName() string          { return "ip_route_details" }
2901 func (*IPRouteDetails) GetCrcString() string            { return "d1ffaae1" }
2902 func (*IPRouteDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
2903
2904 func (m *IPRouteDetails) Size() int {
2905         if m == nil {
2906                 return 0
2907         }
2908         var size int
2909         // field[1] m.Route
2910         // field[2] m.Route.TableID
2911         size += 4
2912         // field[2] m.Route.StatsIndex
2913         size += 4
2914         // field[2] m.Route.Prefix
2915         // field[3] m.Route.Prefix.Address
2916         // field[4] m.Route.Prefix.Address.Af
2917         size += 1
2918         // field[4] m.Route.Prefix.Address.Un
2919         size += 16
2920         // field[3] m.Route.Prefix.Len
2921         size += 1
2922         // field[2] m.Route.NPaths
2923         size += 1
2924         // field[2] m.Route.Paths
2925         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
2926                 var s2 fib_types.FibPath
2927                 _ = s2
2928                 if j2 < len(m.Route.Paths) {
2929                         s2 = m.Route.Paths[j2]
2930                 }
2931                 // field[3] s2.SwIfIndex
2932                 size += 4
2933                 // field[3] s2.TableID
2934                 size += 4
2935                 // field[3] s2.RpfID
2936                 size += 4
2937                 // field[3] s2.Weight
2938                 size += 1
2939                 // field[3] s2.Preference
2940                 size += 1
2941                 // field[3] s2.Type
2942                 size += 4
2943                 // field[3] s2.Flags
2944                 size += 4
2945                 // field[3] s2.Proto
2946                 size += 4
2947                 // field[3] s2.Nh
2948                 // field[4] s2.Nh.Address
2949                 size += 16
2950                 // field[4] s2.Nh.ViaLabel
2951                 size += 4
2952                 // field[4] s2.Nh.ObjID
2953                 size += 4
2954                 // field[4] s2.Nh.ClassifyTableIndex
2955                 size += 4
2956                 // field[3] s2.NLabels
2957                 size += 1
2958                 // field[3] s2.LabelStack
2959                 for j3 := 0; j3 < 16; j3++ {
2960                         var s3 fib_types.FibMplsLabel
2961                         _ = s3
2962                         if j3 < len(s2.LabelStack) {
2963                                 s3 = s2.LabelStack[j3]
2964                         }
2965                         // field[4] s3.IsUniform
2966                         size += 1
2967                         // field[4] s3.Label
2968                         size += 4
2969                         // field[4] s3.TTL
2970                         size += 1
2971                         // field[4] s3.Exp
2972                         size += 1
2973                 }
2974         }
2975         return size
2976 }
2977 func (m *IPRouteDetails) Marshal(b []byte) ([]byte, error) {
2978         o := binary.BigEndian
2979         _ = o
2980         pos := 0
2981         _ = pos
2982         var buf []byte
2983         if b == nil {
2984                 buf = make([]byte, m.Size())
2985         } else {
2986                 buf = b
2987         }
2988         // field[1] m.Route
2989         // field[2] m.Route.TableID
2990         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
2991         pos += 4
2992         // field[2] m.Route.StatsIndex
2993         o.PutUint32(buf[pos:pos+4], uint32(m.Route.StatsIndex))
2994         pos += 4
2995         // field[2] m.Route.Prefix
2996         // field[3] m.Route.Prefix.Address
2997         // field[4] m.Route.Prefix.Address.Af
2998         buf[pos] = uint8(m.Route.Prefix.Address.Af)
2999         pos += 1
3000         // field[4] m.Route.Prefix.Address.Un
3001         copy(buf[pos:pos+16], m.Route.Prefix.Address.Un.XXX_UnionData[:])
3002         pos += 16
3003         // field[3] m.Route.Prefix.Len
3004         buf[pos] = uint8(m.Route.Prefix.Len)
3005         pos += 1
3006         // field[2] m.Route.NPaths
3007         buf[pos] = uint8(len(m.Route.Paths))
3008         pos += 1
3009         // field[2] m.Route.Paths
3010         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3011                 var v2 fib_types.FibPath
3012                 if j2 < len(m.Route.Paths) {
3013                         v2 = m.Route.Paths[j2]
3014                 }
3015                 // field[3] v2.SwIfIndex
3016                 o.PutUint32(buf[pos:pos+4], uint32(v2.SwIfIndex))
3017                 pos += 4
3018                 // field[3] v2.TableID
3019                 o.PutUint32(buf[pos:pos+4], uint32(v2.TableID))
3020                 pos += 4
3021                 // field[3] v2.RpfID
3022                 o.PutUint32(buf[pos:pos+4], uint32(v2.RpfID))
3023                 pos += 4
3024                 // field[3] v2.Weight
3025                 buf[pos] = uint8(v2.Weight)
3026                 pos += 1
3027                 // field[3] v2.Preference
3028                 buf[pos] = uint8(v2.Preference)
3029                 pos += 1
3030                 // field[3] v2.Type
3031                 o.PutUint32(buf[pos:pos+4], uint32(v2.Type))
3032                 pos += 4
3033                 // field[3] v2.Flags
3034                 o.PutUint32(buf[pos:pos+4], uint32(v2.Flags))
3035                 pos += 4
3036                 // field[3] v2.Proto
3037                 o.PutUint32(buf[pos:pos+4], uint32(v2.Proto))
3038                 pos += 4
3039                 // field[3] v2.Nh
3040                 // field[4] v2.Nh.Address
3041                 copy(buf[pos:pos+16], v2.Nh.Address.XXX_UnionData[:])
3042                 pos += 16
3043                 // field[4] v2.Nh.ViaLabel
3044                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ViaLabel))
3045                 pos += 4
3046                 // field[4] v2.Nh.ObjID
3047                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ObjID))
3048                 pos += 4
3049                 // field[4] v2.Nh.ClassifyTableIndex
3050                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ClassifyTableIndex))
3051                 pos += 4
3052                 // field[3] v2.NLabels
3053                 buf[pos] = uint8(v2.NLabels)
3054                 pos += 1
3055                 // field[3] v2.LabelStack
3056                 for j3 := 0; j3 < 16; j3++ {
3057                         var v3 fib_types.FibMplsLabel
3058                         if j3 < len(v2.LabelStack) {
3059                                 v3 = v2.LabelStack[j3]
3060                         }
3061                         // field[4] v3.IsUniform
3062                         buf[pos] = uint8(v3.IsUniform)
3063                         pos += 1
3064                         // field[4] v3.Label
3065                         o.PutUint32(buf[pos:pos+4], uint32(v3.Label))
3066                         pos += 4
3067                         // field[4] v3.TTL
3068                         buf[pos] = uint8(v3.TTL)
3069                         pos += 1
3070                         // field[4] v3.Exp
3071                         buf[pos] = uint8(v3.Exp)
3072                         pos += 1
3073                 }
3074         }
3075         return buf, nil
3076 }
3077 func (m *IPRouteDetails) Unmarshal(tmp []byte) error {
3078         o := binary.BigEndian
3079         _ = o
3080         pos := 0
3081         _ = pos
3082         // field[1] m.Route
3083         // field[2] m.Route.TableID
3084         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3085         pos += 4
3086         // field[2] m.Route.StatsIndex
3087         m.Route.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3088         pos += 4
3089         // field[2] m.Route.Prefix
3090         // field[3] m.Route.Prefix.Address
3091         // field[4] m.Route.Prefix.Address.Af
3092         m.Route.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
3093         pos += 1
3094         // field[4] m.Route.Prefix.Address.Un
3095         copy(m.Route.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3096         pos += 16
3097         // field[3] m.Route.Prefix.Len
3098         m.Route.Prefix.Len = uint8(tmp[pos])
3099         pos += 1
3100         // field[2] m.Route.NPaths
3101         m.Route.NPaths = uint8(tmp[pos])
3102         pos += 1
3103         // field[2] m.Route.Paths
3104         m.Route.Paths = make([]fib_types.FibPath, int(m.Route.NPaths))
3105         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
3106                 // field[3] m.Route.Paths[j2].SwIfIndex
3107                 m.Route.Paths[j2].SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3108                 pos += 4
3109                 // field[3] m.Route.Paths[j2].TableID
3110                 m.Route.Paths[j2].TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3111                 pos += 4
3112                 // field[3] m.Route.Paths[j2].RpfID
3113                 m.Route.Paths[j2].RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
3114                 pos += 4
3115                 // field[3] m.Route.Paths[j2].Weight
3116                 m.Route.Paths[j2].Weight = uint8(tmp[pos])
3117                 pos += 1
3118                 // field[3] m.Route.Paths[j2].Preference
3119                 m.Route.Paths[j2].Preference = uint8(tmp[pos])
3120                 pos += 1
3121                 // field[3] m.Route.Paths[j2].Type
3122                 m.Route.Paths[j2].Type = fib_types.FibPathType(o.Uint32(tmp[pos : pos+4]))
3123                 pos += 4
3124                 // field[3] m.Route.Paths[j2].Flags
3125                 m.Route.Paths[j2].Flags = fib_types.FibPathFlags(o.Uint32(tmp[pos : pos+4]))
3126                 pos += 4
3127                 // field[3] m.Route.Paths[j2].Proto
3128                 m.Route.Paths[j2].Proto = fib_types.FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
3129                 pos += 4
3130                 // field[3] m.Route.Paths[j2].Nh
3131                 // field[4] m.Route.Paths[j2].Nh.Address
3132                 copy(m.Route.Paths[j2].Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
3133                 pos += 16
3134                 // field[4] m.Route.Paths[j2].Nh.ViaLabel
3135                 m.Route.Paths[j2].Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
3136                 pos += 4
3137                 // field[4] m.Route.Paths[j2].Nh.ObjID
3138                 m.Route.Paths[j2].Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
3139                 pos += 4
3140                 // field[4] m.Route.Paths[j2].Nh.ClassifyTableIndex
3141                 m.Route.Paths[j2].Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3142                 pos += 4
3143                 // field[3] m.Route.Paths[j2].NLabels
3144                 m.Route.Paths[j2].NLabels = uint8(tmp[pos])
3145                 pos += 1
3146                 // field[3] m.Route.Paths[j2].LabelStack
3147                 for j3 := 0; j3 < 16; j3++ {
3148                         // field[4] m.Route.Paths[j2].LabelStack[j3].IsUniform
3149                         m.Route.Paths[j2].LabelStack[j3].IsUniform = uint8(tmp[pos])
3150                         pos += 1
3151                         // field[4] m.Route.Paths[j2].LabelStack[j3].Label
3152                         m.Route.Paths[j2].LabelStack[j3].Label = uint32(o.Uint32(tmp[pos : pos+4]))
3153                         pos += 4
3154                         // field[4] m.Route.Paths[j2].LabelStack[j3].TTL
3155                         m.Route.Paths[j2].LabelStack[j3].TTL = uint8(tmp[pos])
3156                         pos += 1
3157                         // field[4] m.Route.Paths[j2].LabelStack[j3].Exp
3158                         m.Route.Paths[j2].LabelStack[j3].Exp = uint8(tmp[pos])
3159                         pos += 1
3160                 }
3161         }
3162         return nil
3163 }
3164
3165 // IPRouteDump represents VPP binary API message 'ip_route_dump'.
3166 type IPRouteDump struct {
3167         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
3168 }
3169
3170 func (m *IPRouteDump) Reset()                        { *m = IPRouteDump{} }
3171 func (*IPRouteDump) GetMessageName() string          { return "ip_route_dump" }
3172 func (*IPRouteDump) GetCrcString() string            { return "b9d2e09e" }
3173 func (*IPRouteDump) GetMessageType() api.MessageType { return api.RequestMessage }
3174
3175 func (m *IPRouteDump) Size() int {
3176         if m == nil {
3177                 return 0
3178         }
3179         var size int
3180         // field[1] m.Table
3181         // field[2] m.Table.TableID
3182         size += 4
3183         // field[2] m.Table.IsIP6
3184         size += 1
3185         // field[2] m.Table.Name
3186         size += 64
3187         return size
3188 }
3189 func (m *IPRouteDump) Marshal(b []byte) ([]byte, error) {
3190         o := binary.BigEndian
3191         _ = o
3192         pos := 0
3193         _ = pos
3194         var buf []byte
3195         if b == nil {
3196                 buf = make([]byte, m.Size())
3197         } else {
3198                 buf = b
3199         }
3200         // field[1] m.Table
3201         // field[2] m.Table.TableID
3202         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
3203         pos += 4
3204         // field[2] m.Table.IsIP6
3205         if m.Table.IsIP6 {
3206                 buf[pos] = 1
3207         }
3208         pos += 1
3209         // field[2] m.Table.Name
3210         copy(buf[pos:pos+64], m.Table.Name)
3211         pos += 64
3212         return buf, nil
3213 }
3214 func (m *IPRouteDump) Unmarshal(tmp []byte) error {
3215         o := binary.BigEndian
3216         _ = o
3217         pos := 0
3218         _ = pos
3219         // field[1] m.Table
3220         // field[2] m.Table.TableID
3221         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3222         pos += 4
3223         // field[2] m.Table.IsIP6
3224         m.Table.IsIP6 = tmp[pos] != 0
3225         pos += 1
3226         // field[2] m.Table.Name
3227         {
3228                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
3229                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
3230                 pos += 64
3231         }
3232         return nil
3233 }
3234
3235 // IPRouteLookup represents VPP binary API message 'ip_route_lookup'.
3236 type IPRouteLookup struct {
3237         TableID uint32           `binapi:"u32,name=table_id" json:"table_id,omitempty"`
3238         Exact   uint8            `binapi:"u8,name=exact" json:"exact,omitempty"`
3239         Prefix  fib_types.Prefix `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
3240 }
3241
3242 func (m *IPRouteLookup) Reset()                        { *m = IPRouteLookup{} }
3243 func (*IPRouteLookup) GetMessageName() string          { return "ip_route_lookup" }
3244 func (*IPRouteLookup) GetCrcString() string            { return "e2986185" }
3245 func (*IPRouteLookup) GetMessageType() api.MessageType { return api.RequestMessage }
3246
3247 func (m *IPRouteLookup) Size() int {
3248         if m == nil {
3249                 return 0
3250         }
3251         var size int
3252         // field[1] m.TableID
3253         size += 4
3254         // field[1] m.Exact
3255         size += 1
3256         // field[1] m.Prefix
3257         // field[2] m.Prefix.Address
3258         // field[3] m.Prefix.Address.Af
3259         size += 1
3260         // field[3] m.Prefix.Address.Un
3261         size += 16
3262         // field[2] m.Prefix.Len
3263         size += 1
3264         return size
3265 }
3266 func (m *IPRouteLookup) Marshal(b []byte) ([]byte, error) {
3267         o := binary.BigEndian
3268         _ = o
3269         pos := 0
3270         _ = pos
3271         var buf []byte
3272         if b == nil {
3273                 buf = make([]byte, m.Size())
3274         } else {
3275                 buf = b
3276         }
3277         // field[1] m.TableID
3278         o.PutUint32(buf[pos:pos+4], uint32(m.TableID))
3279         pos += 4
3280         // field[1] m.Exact
3281         buf[pos] = uint8(m.Exact)
3282         pos += 1
3283         // field[1] m.Prefix
3284         // field[2] m.Prefix.Address
3285         // field[3] m.Prefix.Address.Af
3286         buf[pos] = uint8(m.Prefix.Address.Af)
3287         pos += 1
3288         // field[3] m.Prefix.Address.Un
3289         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
3290         pos += 16
3291         // field[2] m.Prefix.Len
3292         buf[pos] = uint8(m.Prefix.Len)
3293         pos += 1
3294         return buf, nil
3295 }
3296 func (m *IPRouteLookup) Unmarshal(tmp []byte) error {
3297         o := binary.BigEndian
3298         _ = o
3299         pos := 0
3300         _ = pos
3301         // field[1] m.TableID
3302         m.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3303         pos += 4
3304         // field[1] m.Exact
3305         m.Exact = uint8(tmp[pos])
3306         pos += 1
3307         // field[1] m.Prefix
3308         // field[2] m.Prefix.Address
3309         // field[3] m.Prefix.Address.Af
3310         m.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
3311         pos += 1
3312         // field[3] m.Prefix.Address.Un
3313         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3314         pos += 16
3315         // field[2] m.Prefix.Len
3316         m.Prefix.Len = uint8(tmp[pos])
3317         pos += 1
3318         return nil
3319 }
3320
3321 // IPRouteLookupReply represents VPP binary API message 'ip_route_lookup_reply'.
3322 type IPRouteLookupReply struct {
3323         Retval int32   `binapi:"i32,name=retval" json:"retval,omitempty"`
3324         Route  IPRoute `binapi:"ip_route,name=route" json:"route,omitempty"`
3325 }
3326
3327 func (m *IPRouteLookupReply) Reset()                        { *m = IPRouteLookupReply{} }
3328 func (*IPRouteLookupReply) GetMessageName() string          { return "ip_route_lookup_reply" }
3329 func (*IPRouteLookupReply) GetCrcString() string            { return "ae99de8e" }
3330 func (*IPRouteLookupReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3331
3332 func (m *IPRouteLookupReply) Size() int {
3333         if m == nil {
3334                 return 0
3335         }
3336         var size int
3337         // field[1] m.Retval
3338         size += 4
3339         // field[1] m.Route
3340         // field[2] m.Route.TableID
3341         size += 4
3342         // field[2] m.Route.StatsIndex
3343         size += 4
3344         // field[2] m.Route.Prefix
3345         // field[3] m.Route.Prefix.Address
3346         // field[4] m.Route.Prefix.Address.Af
3347         size += 1
3348         // field[4] m.Route.Prefix.Address.Un
3349         size += 16
3350         // field[3] m.Route.Prefix.Len
3351         size += 1
3352         // field[2] m.Route.NPaths
3353         size += 1
3354         // field[2] m.Route.Paths
3355         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3356                 var s2 fib_types.FibPath
3357                 _ = s2
3358                 if j2 < len(m.Route.Paths) {
3359                         s2 = m.Route.Paths[j2]
3360                 }
3361                 // field[3] s2.SwIfIndex
3362                 size += 4
3363                 // field[3] s2.TableID
3364                 size += 4
3365                 // field[3] s2.RpfID
3366                 size += 4
3367                 // field[3] s2.Weight
3368                 size += 1
3369                 // field[3] s2.Preference
3370                 size += 1
3371                 // field[3] s2.Type
3372                 size += 4
3373                 // field[3] s2.Flags
3374                 size += 4
3375                 // field[3] s2.Proto
3376                 size += 4
3377                 // field[3] s2.Nh
3378                 // field[4] s2.Nh.Address
3379                 size += 16
3380                 // field[4] s2.Nh.ViaLabel
3381                 size += 4
3382                 // field[4] s2.Nh.ObjID
3383                 size += 4
3384                 // field[4] s2.Nh.ClassifyTableIndex
3385                 size += 4
3386                 // field[3] s2.NLabels
3387                 size += 1
3388                 // field[3] s2.LabelStack
3389                 for j3 := 0; j3 < 16; j3++ {
3390                         var s3 fib_types.FibMplsLabel
3391                         _ = s3
3392                         if j3 < len(s2.LabelStack) {
3393                                 s3 = s2.LabelStack[j3]
3394                         }
3395                         // field[4] s3.IsUniform
3396                         size += 1
3397                         // field[4] s3.Label
3398                         size += 4
3399                         // field[4] s3.TTL
3400                         size += 1
3401                         // field[4] s3.Exp
3402                         size += 1
3403                 }
3404         }
3405         return size
3406 }
3407 func (m *IPRouteLookupReply) Marshal(b []byte) ([]byte, error) {
3408         o := binary.BigEndian
3409         _ = o
3410         pos := 0
3411         _ = pos
3412         var buf []byte
3413         if b == nil {
3414                 buf = make([]byte, m.Size())
3415         } else {
3416                 buf = b
3417         }
3418         // field[1] m.Retval
3419         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3420         pos += 4
3421         // field[1] m.Route
3422         // field[2] m.Route.TableID
3423         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
3424         pos += 4
3425         // field[2] m.Route.StatsIndex
3426         o.PutUint32(buf[pos:pos+4], uint32(m.Route.StatsIndex))
3427         pos += 4
3428         // field[2] m.Route.Prefix
3429         // field[3] m.Route.Prefix.Address
3430         // field[4] m.Route.Prefix.Address.Af
3431         buf[pos] = uint8(m.Route.Prefix.Address.Af)
3432         pos += 1
3433         // field[4] m.Route.Prefix.Address.Un
3434         copy(buf[pos:pos+16], m.Route.Prefix.Address.Un.XXX_UnionData[:])
3435         pos += 16
3436         // field[3] m.Route.Prefix.Len
3437         buf[pos] = uint8(m.Route.Prefix.Len)
3438         pos += 1
3439         // field[2] m.Route.NPaths
3440         buf[pos] = uint8(len(m.Route.Paths))
3441         pos += 1
3442         // field[2] m.Route.Paths
3443         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3444                 var v2 fib_types.FibPath
3445                 if j2 < len(m.Route.Paths) {
3446                         v2 = m.Route.Paths[j2]
3447                 }
3448                 // field[3] v2.SwIfIndex
3449                 o.PutUint32(buf[pos:pos+4], uint32(v2.SwIfIndex))
3450                 pos += 4
3451                 // field[3] v2.TableID
3452                 o.PutUint32(buf[pos:pos+4], uint32(v2.TableID))
3453                 pos += 4
3454                 // field[3] v2.RpfID
3455                 o.PutUint32(buf[pos:pos+4], uint32(v2.RpfID))
3456                 pos += 4
3457                 // field[3] v2.Weight
3458                 buf[pos] = uint8(v2.Weight)
3459                 pos += 1
3460                 // field[3] v2.Preference
3461                 buf[pos] = uint8(v2.Preference)
3462                 pos += 1
3463                 // field[3] v2.Type
3464                 o.PutUint32(buf[pos:pos+4], uint32(v2.Type))
3465                 pos += 4
3466                 // field[3] v2.Flags
3467                 o.PutUint32(buf[pos:pos+4], uint32(v2.Flags))
3468                 pos += 4
3469                 // field[3] v2.Proto
3470                 o.PutUint32(buf[pos:pos+4], uint32(v2.Proto))
3471                 pos += 4
3472                 // field[3] v2.Nh
3473                 // field[4] v2.Nh.Address
3474                 copy(buf[pos:pos+16], v2.Nh.Address.XXX_UnionData[:])
3475                 pos += 16
3476                 // field[4] v2.Nh.ViaLabel
3477                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ViaLabel))
3478                 pos += 4
3479                 // field[4] v2.Nh.ObjID
3480                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ObjID))
3481                 pos += 4
3482                 // field[4] v2.Nh.ClassifyTableIndex
3483                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ClassifyTableIndex))
3484                 pos += 4
3485                 // field[3] v2.NLabels
3486                 buf[pos] = uint8(v2.NLabels)
3487                 pos += 1
3488                 // field[3] v2.LabelStack
3489                 for j3 := 0; j3 < 16; j3++ {
3490                         var v3 fib_types.FibMplsLabel
3491                         if j3 < len(v2.LabelStack) {
3492                                 v3 = v2.LabelStack[j3]
3493                         }
3494                         // field[4] v3.IsUniform
3495                         buf[pos] = uint8(v3.IsUniform)
3496                         pos += 1
3497                         // field[4] v3.Label
3498                         o.PutUint32(buf[pos:pos+4], uint32(v3.Label))
3499                         pos += 4
3500                         // field[4] v3.TTL
3501                         buf[pos] = uint8(v3.TTL)
3502                         pos += 1
3503                         // field[4] v3.Exp
3504                         buf[pos] = uint8(v3.Exp)
3505                         pos += 1
3506                 }
3507         }
3508         return buf, nil
3509 }
3510 func (m *IPRouteLookupReply) Unmarshal(tmp []byte) error {
3511         o := binary.BigEndian
3512         _ = o
3513         pos := 0
3514         _ = pos
3515         // field[1] m.Retval
3516         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3517         pos += 4
3518         // field[1] m.Route
3519         // field[2] m.Route.TableID
3520         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3521         pos += 4
3522         // field[2] m.Route.StatsIndex
3523         m.Route.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3524         pos += 4
3525         // field[2] m.Route.Prefix
3526         // field[3] m.Route.Prefix.Address
3527         // field[4] m.Route.Prefix.Address.Af
3528         m.Route.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
3529         pos += 1
3530         // field[4] m.Route.Prefix.Address.Un
3531         copy(m.Route.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3532         pos += 16
3533         // field[3] m.Route.Prefix.Len
3534         m.Route.Prefix.Len = uint8(tmp[pos])
3535         pos += 1
3536         // field[2] m.Route.NPaths
3537         m.Route.NPaths = uint8(tmp[pos])
3538         pos += 1
3539         // field[2] m.Route.Paths
3540         m.Route.Paths = make([]fib_types.FibPath, int(m.Route.NPaths))
3541         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
3542                 // field[3] m.Route.Paths[j2].SwIfIndex
3543                 m.Route.Paths[j2].SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3544                 pos += 4
3545                 // field[3] m.Route.Paths[j2].TableID
3546                 m.Route.Paths[j2].TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3547                 pos += 4
3548                 // field[3] m.Route.Paths[j2].RpfID
3549                 m.Route.Paths[j2].RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
3550                 pos += 4
3551                 // field[3] m.Route.Paths[j2].Weight
3552                 m.Route.Paths[j2].Weight = uint8(tmp[pos])
3553                 pos += 1
3554                 // field[3] m.Route.Paths[j2].Preference
3555                 m.Route.Paths[j2].Preference = uint8(tmp[pos])
3556                 pos += 1
3557                 // field[3] m.Route.Paths[j2].Type
3558                 m.Route.Paths[j2].Type = fib_types.FibPathType(o.Uint32(tmp[pos : pos+4]))
3559                 pos += 4
3560                 // field[3] m.Route.Paths[j2].Flags
3561                 m.Route.Paths[j2].Flags = fib_types.FibPathFlags(o.Uint32(tmp[pos : pos+4]))
3562                 pos += 4
3563                 // field[3] m.Route.Paths[j2].Proto
3564                 m.Route.Paths[j2].Proto = fib_types.FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
3565                 pos += 4
3566                 // field[3] m.Route.Paths[j2].Nh
3567                 // field[4] m.Route.Paths[j2].Nh.Address
3568                 copy(m.Route.Paths[j2].Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
3569                 pos += 16
3570                 // field[4] m.Route.Paths[j2].Nh.ViaLabel
3571                 m.Route.Paths[j2].Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
3572                 pos += 4
3573                 // field[4] m.Route.Paths[j2].Nh.ObjID
3574                 m.Route.Paths[j2].Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
3575                 pos += 4
3576                 // field[4] m.Route.Paths[j2].Nh.ClassifyTableIndex
3577                 m.Route.Paths[j2].Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3578                 pos += 4
3579                 // field[3] m.Route.Paths[j2].NLabels
3580                 m.Route.Paths[j2].NLabels = uint8(tmp[pos])
3581                 pos += 1
3582                 // field[3] m.Route.Paths[j2].LabelStack
3583                 for j3 := 0; j3 < 16; j3++ {
3584                         // field[4] m.Route.Paths[j2].LabelStack[j3].IsUniform
3585                         m.Route.Paths[j2].LabelStack[j3].IsUniform = uint8(tmp[pos])
3586                         pos += 1
3587                         // field[4] m.Route.Paths[j2].LabelStack[j3].Label
3588                         m.Route.Paths[j2].LabelStack[j3].Label = uint32(o.Uint32(tmp[pos : pos+4]))
3589                         pos += 4
3590                         // field[4] m.Route.Paths[j2].LabelStack[j3].TTL
3591                         m.Route.Paths[j2].LabelStack[j3].TTL = uint8(tmp[pos])
3592                         pos += 1
3593                         // field[4] m.Route.Paths[j2].LabelStack[j3].Exp
3594                         m.Route.Paths[j2].LabelStack[j3].Exp = uint8(tmp[pos])
3595                         pos += 1
3596                 }
3597         }
3598         return nil
3599 }
3600
3601 // IPSourceAndPortRangeCheckAddDel represents VPP binary API message 'ip_source_and_port_range_check_add_del'.
3602 type IPSourceAndPortRangeCheckAddDel struct {
3603         IsAdd          bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
3604         Prefix         fib_types.Prefix `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
3605         NumberOfRanges uint8            `binapi:"u8,name=number_of_ranges" json:"number_of_ranges,omitempty"`
3606         LowPorts       []uint16         `binapi:"u16[32],name=low_ports" json:"low_ports,omitempty" struc:"[32]uint16"`
3607         HighPorts      []uint16         `binapi:"u16[32],name=high_ports" json:"high_ports,omitempty" struc:"[32]uint16"`
3608         VrfID          uint32           `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
3609 }
3610
3611 func (m *IPSourceAndPortRangeCheckAddDel) Reset() { *m = IPSourceAndPortRangeCheckAddDel{} }
3612 func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
3613         return "ip_source_and_port_range_check_add_del"
3614 }
3615 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string            { return "8bfc76f2" }
3616 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
3617
3618 func (m *IPSourceAndPortRangeCheckAddDel) Size() int {
3619         if m == nil {
3620                 return 0
3621         }
3622         var size int
3623         // field[1] m.IsAdd
3624         size += 1
3625         // field[1] m.Prefix
3626         // field[2] m.Prefix.Address
3627         // field[3] m.Prefix.Address.Af
3628         size += 1
3629         // field[3] m.Prefix.Address.Un
3630         size += 16
3631         // field[2] m.Prefix.Len
3632         size += 1
3633         // field[1] m.NumberOfRanges
3634         size += 1
3635         // field[1] m.LowPorts
3636         size += 64
3637         // field[1] m.HighPorts
3638         size += 64
3639         // field[1] m.VrfID
3640         size += 4
3641         return size
3642 }
3643 func (m *IPSourceAndPortRangeCheckAddDel) Marshal(b []byte) ([]byte, error) {
3644         o := binary.BigEndian
3645         _ = o
3646         pos := 0
3647         _ = pos
3648         var buf []byte
3649         if b == nil {
3650                 buf = make([]byte, m.Size())
3651         } else {
3652                 buf = b
3653         }
3654         // field[1] m.IsAdd
3655         if m.IsAdd {
3656                 buf[pos] = 1
3657         }
3658         pos += 1
3659         // field[1] m.Prefix
3660         // field[2] m.Prefix.Address
3661         // field[3] m.Prefix.Address.Af
3662         buf[pos] = uint8(m.Prefix.Address.Af)
3663         pos += 1
3664         // field[3] m.Prefix.Address.Un
3665         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
3666         pos += 16
3667         // field[2] m.Prefix.Len
3668         buf[pos] = uint8(m.Prefix.Len)
3669         pos += 1
3670         // field[1] m.NumberOfRanges
3671         buf[pos] = uint8(m.NumberOfRanges)
3672         pos += 1
3673         // field[1] m.LowPorts
3674         for i := 0; i < 32; i++ {
3675                 var x uint16
3676                 if i < len(m.LowPorts) {
3677                         x = uint16(m.LowPorts[i])
3678                 }
3679                 o.PutUint16(buf[pos:pos+2], uint16(x))
3680                 pos += 2
3681         }
3682         // field[1] m.HighPorts
3683         for i := 0; i < 32; i++ {
3684                 var x uint16
3685                 if i < len(m.HighPorts) {
3686                         x = uint16(m.HighPorts[i])
3687                 }
3688                 o.PutUint16(buf[pos:pos+2], uint16(x))
3689                 pos += 2
3690         }
3691         // field[1] m.VrfID
3692         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
3693         pos += 4
3694         return buf, nil
3695 }
3696 func (m *IPSourceAndPortRangeCheckAddDel) Unmarshal(tmp []byte) error {
3697         o := binary.BigEndian
3698         _ = o
3699         pos := 0
3700         _ = pos
3701         // field[1] m.IsAdd
3702         m.IsAdd = tmp[pos] != 0
3703         pos += 1
3704         // field[1] m.Prefix
3705         // field[2] m.Prefix.Address
3706         // field[3] m.Prefix.Address.Af
3707         m.Prefix.Address.Af = fib_types.AddressFamily(tmp[pos])
3708         pos += 1
3709         // field[3] m.Prefix.Address.Un
3710         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3711         pos += 16
3712         // field[2] m.Prefix.Len
3713         m.Prefix.Len = uint8(tmp[pos])
3714         pos += 1
3715         // field[1] m.NumberOfRanges
3716         m.NumberOfRanges = uint8(tmp[pos])
3717         pos += 1
3718         // field[1] m.LowPorts
3719         m.LowPorts = make([]uint16, 32)
3720         for i := 0; i < len(m.LowPorts); i++ {
3721                 m.LowPorts[i] = uint16(o.Uint16(tmp[pos : pos+2]))
3722                 pos += 2
3723         }
3724         // field[1] m.HighPorts
3725         m.HighPorts = make([]uint16, 32)
3726         for i := 0; i < len(m.HighPorts); i++ {
3727                 m.HighPorts[i] = uint16(o.Uint16(tmp[pos : pos+2]))
3728                 pos += 2
3729         }
3730         // field[1] m.VrfID
3731         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3732         pos += 4
3733         return nil
3734 }
3735
3736 // IPSourceAndPortRangeCheckAddDelReply represents VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
3737 type IPSourceAndPortRangeCheckAddDelReply struct {
3738         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3739 }
3740
3741 func (m *IPSourceAndPortRangeCheckAddDelReply) Reset() { *m = IPSourceAndPortRangeCheckAddDelReply{} }
3742 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
3743         return "ip_source_and_port_range_check_add_del_reply"
3744 }
3745 func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string { return "e8d4e804" }
3746 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
3747         return api.ReplyMessage
3748 }
3749
3750 func (m *IPSourceAndPortRangeCheckAddDelReply) Size() int {
3751         if m == nil {
3752                 return 0
3753         }
3754         var size int
3755         // field[1] m.Retval
3756         size += 4
3757         return size
3758 }
3759 func (m *IPSourceAndPortRangeCheckAddDelReply) Marshal(b []byte) ([]byte, error) {
3760         o := binary.BigEndian
3761         _ = o
3762         pos := 0
3763         _ = pos
3764         var buf []byte
3765         if b == nil {
3766                 buf = make([]byte, m.Size())
3767         } else {
3768                 buf = b
3769         }
3770         // field[1] m.Retval
3771         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3772         pos += 4
3773         return buf, nil
3774 }
3775 func (m *IPSourceAndPortRangeCheckAddDelReply) Unmarshal(tmp []byte) error {
3776         o := binary.BigEndian
3777         _ = o
3778         pos := 0
3779         _ = pos
3780         // field[1] m.Retval
3781         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3782         pos += 4
3783         return nil
3784 }
3785
3786 // IPSourceAndPortRangeCheckInterfaceAddDel represents VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
3787 type IPSourceAndPortRangeCheckInterfaceAddDel struct {
3788         IsAdd       bool                           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
3789         SwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
3790         TCPInVrfID  uint32                         `binapi:"u32,name=tcp_in_vrf_id" json:"tcp_in_vrf_id,omitempty"`
3791         TCPOutVrfID uint32                         `binapi:"u32,name=tcp_out_vrf_id" json:"tcp_out_vrf_id,omitempty"`
3792         UDPInVrfID  uint32                         `binapi:"u32,name=udp_in_vrf_id" json:"udp_in_vrf_id,omitempty"`
3793         UDPOutVrfID uint32                         `binapi:"u32,name=udp_out_vrf_id" json:"udp_out_vrf_id,omitempty"`
3794 }
3795
3796 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Reset() {
3797         *m = IPSourceAndPortRangeCheckInterfaceAddDel{}
3798 }
3799 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
3800         return "ip_source_and_port_range_check_interface_add_del"
3801 }
3802 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string { return "e1ba8987" }
3803 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
3804         return api.RequestMessage
3805 }
3806
3807 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Size() int {
3808         if m == nil {
3809                 return 0
3810         }
3811         var size int
3812         // field[1] m.IsAdd
3813         size += 1
3814         // field[1] m.SwIfIndex
3815         size += 4
3816         // field[1] m.TCPInVrfID
3817         size += 4
3818         // field[1] m.TCPOutVrfID
3819         size += 4
3820         // field[1] m.UDPInVrfID
3821         size += 4
3822         // field[1] m.UDPOutVrfID
3823         size += 4
3824         return size
3825 }
3826 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
3827         o := binary.BigEndian
3828         _ = o
3829         pos := 0
3830         _ = pos
3831         var buf []byte
3832         if b == nil {
3833                 buf = make([]byte, m.Size())
3834         } else {
3835                 buf = b
3836         }
3837         // field[1] m.IsAdd
3838         if m.IsAdd {
3839                 buf[pos] = 1
3840         }
3841         pos += 1
3842         // field[1] m.SwIfIndex
3843         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
3844         pos += 4
3845         // field[1] m.TCPInVrfID
3846         o.PutUint32(buf[pos:pos+4], uint32(m.TCPInVrfID))
3847         pos += 4
3848         // field[1] m.TCPOutVrfID
3849         o.PutUint32(buf[pos:pos+4], uint32(m.TCPOutVrfID))
3850         pos += 4
3851         // field[1] m.UDPInVrfID
3852         o.PutUint32(buf[pos:pos+4], uint32(m.UDPInVrfID))
3853         pos += 4
3854         // field[1] m.UDPOutVrfID
3855         o.PutUint32(buf[pos:pos+4], uint32(m.UDPOutVrfID))
3856         pos += 4
3857         return buf, nil
3858 }
3859 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Unmarshal(tmp []byte) error {
3860         o := binary.BigEndian
3861         _ = o
3862         pos := 0
3863         _ = pos
3864         // field[1] m.IsAdd
3865         m.IsAdd = tmp[pos] != 0
3866         pos += 1
3867         // field[1] m.SwIfIndex
3868         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3869         pos += 4
3870         // field[1] m.TCPInVrfID
3871         m.TCPInVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3872         pos += 4
3873         // field[1] m.TCPOutVrfID
3874         m.TCPOutVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3875         pos += 4
3876         // field[1] m.UDPInVrfID
3877         m.UDPInVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3878         pos += 4
3879         // field[1] m.UDPOutVrfID
3880         m.UDPOutVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3881         pos += 4
3882         return nil
3883 }
3884
3885 // IPSourceAndPortRangeCheckInterfaceAddDelReply represents VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
3886 type IPSourceAndPortRangeCheckInterfaceAddDelReply struct {
3887         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3888 }
3889
3890 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Reset() {
3891         *m = IPSourceAndPortRangeCheckInterfaceAddDelReply{}
3892 }
3893 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
3894         return "ip_source_and_port_range_check_interface_add_del_reply"
3895 }
3896 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string { return "e8d4e804" }
3897 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
3898         return api.ReplyMessage
3899 }
3900
3901 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Size() int {
3902         if m == nil {
3903                 return 0
3904         }
3905         var size int
3906         // field[1] m.Retval
3907         size += 4
3908         return size
3909 }
3910 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
3911         o := binary.BigEndian
3912         _ = o
3913         pos := 0
3914         _ = pos
3915         var buf []byte
3916         if b == nil {
3917                 buf = make([]byte, m.Size())
3918         } else {
3919                 buf = b
3920         }
3921         // field[1] m.Retval
3922         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3923         pos += 4
3924         return buf, nil
3925 }
3926 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Unmarshal(tmp []byte) error {
3927         o := binary.BigEndian
3928         _ = o
3929         pos := 0
3930         _ = pos
3931         // field[1] m.Retval
3932         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3933         pos += 4
3934         return nil
3935 }
3936
3937 // IPTableAddDel represents VPP binary API message 'ip_table_add_del'.
3938 type IPTableAddDel struct {
3939         IsAdd bool    `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
3940         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
3941 }
3942
3943 func (m *IPTableAddDel) Reset()                        { *m = IPTableAddDel{} }
3944 func (*IPTableAddDel) GetMessageName() string          { return "ip_table_add_del" }
3945 func (*IPTableAddDel) GetCrcString() string            { return "0ffdaec0" }
3946 func (*IPTableAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
3947
3948 func (m *IPTableAddDel) Size() int {
3949         if m == nil {
3950                 return 0
3951         }
3952         var size int
3953         // field[1] m.IsAdd
3954         size += 1
3955         // field[1] m.Table
3956         // field[2] m.Table.TableID
3957         size += 4
3958         // field[2] m.Table.IsIP6
3959         size += 1
3960         // field[2] m.Table.Name
3961         size += 64
3962         return size
3963 }
3964 func (m *IPTableAddDel) Marshal(b []byte) ([]byte, error) {
3965         o := binary.BigEndian
3966         _ = o
3967         pos := 0
3968         _ = pos
3969         var buf []byte
3970         if b == nil {
3971                 buf = make([]byte, m.Size())
3972         } else {
3973                 buf = b
3974         }
3975         // field[1] m.IsAdd
3976         if m.IsAdd {
3977                 buf[pos] = 1
3978         }
3979         pos += 1
3980         // field[1] m.Table
3981         // field[2] m.Table.TableID
3982         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
3983         pos += 4
3984         // field[2] m.Table.IsIP6
3985         if m.Table.IsIP6 {
3986                 buf[pos] = 1
3987         }
3988         pos += 1
3989         // field[2] m.Table.Name
3990         copy(buf[pos:pos+64], m.Table.Name)
3991         pos += 64
3992         return buf, nil
3993 }
3994 func (m *IPTableAddDel) Unmarshal(tmp []byte) error {
3995         o := binary.BigEndian
3996         _ = o
3997         pos := 0
3998         _ = pos
3999         // field[1] m.IsAdd
4000         m.IsAdd = tmp[pos] != 0
4001         pos += 1
4002         // field[1] m.Table
4003         // field[2] m.Table.TableID
4004         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4005         pos += 4
4006         // field[2] m.Table.IsIP6
4007         m.Table.IsIP6 = tmp[pos] != 0
4008         pos += 1
4009         // field[2] m.Table.Name
4010         {
4011                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4012                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4013                 pos += 64
4014         }
4015         return nil
4016 }
4017
4018 // IPTableAddDelReply represents VPP binary API message 'ip_table_add_del_reply'.
4019 type IPTableAddDelReply struct {
4020         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4021 }
4022
4023 func (m *IPTableAddDelReply) Reset()                        { *m = IPTableAddDelReply{} }
4024 func (*IPTableAddDelReply) GetMessageName() string          { return "ip_table_add_del_reply" }
4025 func (*IPTableAddDelReply) GetCrcString() string            { return "e8d4e804" }
4026 func (*IPTableAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4027
4028 func (m *IPTableAddDelReply) Size() int {
4029         if m == nil {
4030                 return 0
4031         }
4032         var size int
4033         // field[1] m.Retval
4034         size += 4
4035         return size
4036 }
4037 func (m *IPTableAddDelReply) Marshal(b []byte) ([]byte, error) {
4038         o := binary.BigEndian
4039         _ = o
4040         pos := 0
4041         _ = pos
4042         var buf []byte
4043         if b == nil {
4044                 buf = make([]byte, m.Size())
4045         } else {
4046                 buf = b
4047         }
4048         // field[1] m.Retval
4049         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4050         pos += 4
4051         return buf, nil
4052 }
4053 func (m *IPTableAddDelReply) Unmarshal(tmp []byte) error {
4054         o := binary.BigEndian
4055         _ = o
4056         pos := 0
4057         _ = pos
4058         // field[1] m.Retval
4059         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4060         pos += 4
4061         return nil
4062 }
4063
4064 // IPTableDetails represents VPP binary API message 'ip_table_details'.
4065 type IPTableDetails struct {
4066         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4067 }
4068
4069 func (m *IPTableDetails) Reset()                        { *m = IPTableDetails{} }
4070 func (*IPTableDetails) GetMessageName() string          { return "ip_table_details" }
4071 func (*IPTableDetails) GetCrcString() string            { return "c79fca0f" }
4072 func (*IPTableDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
4073
4074 func (m *IPTableDetails) Size() int {
4075         if m == nil {
4076                 return 0
4077         }
4078         var size int
4079         // field[1] m.Table
4080         // field[2] m.Table.TableID
4081         size += 4
4082         // field[2] m.Table.IsIP6
4083         size += 1
4084         // field[2] m.Table.Name
4085         size += 64
4086         return size
4087 }
4088 func (m *IPTableDetails) Marshal(b []byte) ([]byte, error) {
4089         o := binary.BigEndian
4090         _ = o
4091         pos := 0
4092         _ = pos
4093         var buf []byte
4094         if b == nil {
4095                 buf = make([]byte, m.Size())
4096         } else {
4097                 buf = b
4098         }
4099         // field[1] m.Table
4100         // field[2] m.Table.TableID
4101         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4102         pos += 4
4103         // field[2] m.Table.IsIP6
4104         if m.Table.IsIP6 {
4105                 buf[pos] = 1
4106         }
4107         pos += 1
4108         // field[2] m.Table.Name
4109         copy(buf[pos:pos+64], m.Table.Name)
4110         pos += 64
4111         return buf, nil
4112 }
4113 func (m *IPTableDetails) Unmarshal(tmp []byte) error {
4114         o := binary.BigEndian
4115         _ = o
4116         pos := 0
4117         _ = pos
4118         // field[1] m.Table
4119         // field[2] m.Table.TableID
4120         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4121         pos += 4
4122         // field[2] m.Table.IsIP6
4123         m.Table.IsIP6 = tmp[pos] != 0
4124         pos += 1
4125         // field[2] m.Table.Name
4126         {
4127                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4128                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4129                 pos += 64
4130         }
4131         return nil
4132 }
4133
4134 // IPTableDump represents VPP binary API message 'ip_table_dump'.
4135 type IPTableDump struct{}
4136
4137 func (m *IPTableDump) Reset()                        { *m = IPTableDump{} }
4138 func (*IPTableDump) GetMessageName() string          { return "ip_table_dump" }
4139 func (*IPTableDump) GetCrcString() string            { return "51077d14" }
4140 func (*IPTableDump) GetMessageType() api.MessageType { return api.RequestMessage }
4141
4142 func (m *IPTableDump) Size() int {
4143         if m == nil {
4144                 return 0
4145         }
4146         var size int
4147         return size
4148 }
4149 func (m *IPTableDump) Marshal(b []byte) ([]byte, error) {
4150         o := binary.BigEndian
4151         _ = o
4152         pos := 0
4153         _ = pos
4154         var buf []byte
4155         if b == nil {
4156                 buf = make([]byte, m.Size())
4157         } else {
4158                 buf = b
4159         }
4160         return buf, nil
4161 }
4162 func (m *IPTableDump) Unmarshal(tmp []byte) error {
4163         o := binary.BigEndian
4164         _ = o
4165         pos := 0
4166         _ = pos
4167         return nil
4168 }
4169
4170 // IPTableFlush represents VPP binary API message 'ip_table_flush'.
4171 type IPTableFlush struct {
4172         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4173 }
4174
4175 func (m *IPTableFlush) Reset()                        { *m = IPTableFlush{} }
4176 func (*IPTableFlush) GetMessageName() string          { return "ip_table_flush" }
4177 func (*IPTableFlush) GetCrcString() string            { return "b9d2e09e" }
4178 func (*IPTableFlush) GetMessageType() api.MessageType { return api.RequestMessage }
4179
4180 func (m *IPTableFlush) Size() int {
4181         if m == nil {
4182                 return 0
4183         }
4184         var size int
4185         // field[1] m.Table
4186         // field[2] m.Table.TableID
4187         size += 4
4188         // field[2] m.Table.IsIP6
4189         size += 1
4190         // field[2] m.Table.Name
4191         size += 64
4192         return size
4193 }
4194 func (m *IPTableFlush) Marshal(b []byte) ([]byte, error) {
4195         o := binary.BigEndian
4196         _ = o
4197         pos := 0
4198         _ = pos
4199         var buf []byte
4200         if b == nil {
4201                 buf = make([]byte, m.Size())
4202         } else {
4203                 buf = b
4204         }
4205         // field[1] m.Table
4206         // field[2] m.Table.TableID
4207         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4208         pos += 4
4209         // field[2] m.Table.IsIP6
4210         if m.Table.IsIP6 {
4211                 buf[pos] = 1
4212         }
4213         pos += 1
4214         // field[2] m.Table.Name
4215         copy(buf[pos:pos+64], m.Table.Name)
4216         pos += 64
4217         return buf, nil
4218 }
4219 func (m *IPTableFlush) Unmarshal(tmp []byte) error {
4220         o := binary.BigEndian
4221         _ = o
4222         pos := 0
4223         _ = pos
4224         // field[1] m.Table
4225         // field[2] m.Table.TableID
4226         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4227         pos += 4
4228         // field[2] m.Table.IsIP6
4229         m.Table.IsIP6 = tmp[pos] != 0
4230         pos += 1
4231         // field[2] m.Table.Name
4232         {
4233                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4234                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4235                 pos += 64
4236         }
4237         return nil
4238 }
4239
4240 // IPTableFlushReply represents VPP binary API message 'ip_table_flush_reply'.
4241 type IPTableFlushReply struct {
4242         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4243 }
4244
4245 func (m *IPTableFlushReply) Reset()                        { *m = IPTableFlushReply{} }
4246 func (*IPTableFlushReply) GetMessageName() string          { return "ip_table_flush_reply" }
4247 func (*IPTableFlushReply) GetCrcString() string            { return "e8d4e804" }
4248 func (*IPTableFlushReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4249
4250 func (m *IPTableFlushReply) Size() int {
4251         if m == nil {
4252                 return 0
4253         }
4254         var size int
4255         // field[1] m.Retval
4256         size += 4
4257         return size
4258 }
4259 func (m *IPTableFlushReply) Marshal(b []byte) ([]byte, error) {
4260         o := binary.BigEndian
4261         _ = o
4262         pos := 0
4263         _ = pos
4264         var buf []byte
4265         if b == nil {
4266                 buf = make([]byte, m.Size())
4267         } else {
4268                 buf = b
4269         }
4270         // field[1] m.Retval
4271         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4272         pos += 4
4273         return buf, nil
4274 }
4275 func (m *IPTableFlushReply) Unmarshal(tmp []byte) error {
4276         o := binary.BigEndian
4277         _ = o
4278         pos := 0
4279         _ = pos
4280         // field[1] m.Retval
4281         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4282         pos += 4
4283         return nil
4284 }
4285
4286 // IPTableReplaceBegin represents VPP binary API message 'ip_table_replace_begin'.
4287 type IPTableReplaceBegin struct {
4288         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4289 }
4290
4291 func (m *IPTableReplaceBegin) Reset()                        { *m = IPTableReplaceBegin{} }
4292 func (*IPTableReplaceBegin) GetMessageName() string          { return "ip_table_replace_begin" }
4293 func (*IPTableReplaceBegin) GetCrcString() string            { return "b9d2e09e" }
4294 func (*IPTableReplaceBegin) GetMessageType() api.MessageType { return api.RequestMessage }
4295
4296 func (m *IPTableReplaceBegin) Size() int {
4297         if m == nil {
4298                 return 0
4299         }
4300         var size int
4301         // field[1] m.Table
4302         // field[2] m.Table.TableID
4303         size += 4
4304         // field[2] m.Table.IsIP6
4305         size += 1
4306         // field[2] m.Table.Name
4307         size += 64
4308         return size
4309 }
4310 func (m *IPTableReplaceBegin) Marshal(b []byte) ([]byte, error) {
4311         o := binary.BigEndian
4312         _ = o
4313         pos := 0
4314         _ = pos
4315         var buf []byte
4316         if b == nil {
4317                 buf = make([]byte, m.Size())
4318         } else {
4319                 buf = b
4320         }
4321         // field[1] m.Table
4322         // field[2] m.Table.TableID
4323         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4324         pos += 4
4325         // field[2] m.Table.IsIP6
4326         if m.Table.IsIP6 {
4327                 buf[pos] = 1
4328         }
4329         pos += 1
4330         // field[2] m.Table.Name
4331         copy(buf[pos:pos+64], m.Table.Name)
4332         pos += 64
4333         return buf, nil
4334 }
4335 func (m *IPTableReplaceBegin) Unmarshal(tmp []byte) error {
4336         o := binary.BigEndian
4337         _ = o
4338         pos := 0
4339         _ = pos
4340         // field[1] m.Table
4341         // field[2] m.Table.TableID
4342         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4343         pos += 4
4344         // field[2] m.Table.IsIP6
4345         m.Table.IsIP6 = tmp[pos] != 0
4346         pos += 1
4347         // field[2] m.Table.Name
4348         {
4349                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4350                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4351                 pos += 64
4352         }
4353         return nil
4354 }
4355
4356 // IPTableReplaceBeginReply represents VPP binary API message 'ip_table_replace_begin_reply'.
4357 type IPTableReplaceBeginReply struct {
4358         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4359 }
4360
4361 func (m *IPTableReplaceBeginReply) Reset()                        { *m = IPTableReplaceBeginReply{} }
4362 func (*IPTableReplaceBeginReply) GetMessageName() string          { return "ip_table_replace_begin_reply" }
4363 func (*IPTableReplaceBeginReply) GetCrcString() string            { return "e8d4e804" }
4364 func (*IPTableReplaceBeginReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4365
4366 func (m *IPTableReplaceBeginReply) Size() int {
4367         if m == nil {
4368                 return 0
4369         }
4370         var size int
4371         // field[1] m.Retval
4372         size += 4
4373         return size
4374 }
4375 func (m *IPTableReplaceBeginReply) Marshal(b []byte) ([]byte, error) {
4376         o := binary.BigEndian
4377         _ = o
4378         pos := 0
4379         _ = pos
4380         var buf []byte
4381         if b == nil {
4382                 buf = make([]byte, m.Size())
4383         } else {
4384                 buf = b
4385         }
4386         // field[1] m.Retval
4387         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4388         pos += 4
4389         return buf, nil
4390 }
4391 func (m *IPTableReplaceBeginReply) Unmarshal(tmp []byte) error {
4392         o := binary.BigEndian
4393         _ = o
4394         pos := 0
4395         _ = pos
4396         // field[1] m.Retval
4397         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4398         pos += 4
4399         return nil
4400 }
4401
4402 // IPTableReplaceEnd represents VPP binary API message 'ip_table_replace_end'.
4403 type IPTableReplaceEnd struct {
4404         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4405 }
4406
4407 func (m *IPTableReplaceEnd) Reset()                        { *m = IPTableReplaceEnd{} }
4408 func (*IPTableReplaceEnd) GetMessageName() string          { return "ip_table_replace_end" }
4409 func (*IPTableReplaceEnd) GetCrcString() string            { return "b9d2e09e" }
4410 func (*IPTableReplaceEnd) GetMessageType() api.MessageType { return api.RequestMessage }
4411
4412 func (m *IPTableReplaceEnd) Size() int {
4413         if m == nil {
4414                 return 0
4415         }
4416         var size int
4417         // field[1] m.Table
4418         // field[2] m.Table.TableID
4419         size += 4
4420         // field[2] m.Table.IsIP6
4421         size += 1
4422         // field[2] m.Table.Name
4423         size += 64
4424         return size
4425 }
4426 func (m *IPTableReplaceEnd) Marshal(b []byte) ([]byte, error) {
4427         o := binary.BigEndian
4428         _ = o
4429         pos := 0
4430         _ = pos
4431         var buf []byte
4432         if b == nil {
4433                 buf = make([]byte, m.Size())
4434         } else {
4435                 buf = b
4436         }
4437         // field[1] m.Table
4438         // field[2] m.Table.TableID
4439         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4440         pos += 4
4441         // field[2] m.Table.IsIP6
4442         if m.Table.IsIP6 {
4443                 buf[pos] = 1
4444         }
4445         pos += 1
4446         // field[2] m.Table.Name
4447         copy(buf[pos:pos+64], m.Table.Name)
4448         pos += 64
4449         return buf, nil
4450 }
4451 func (m *IPTableReplaceEnd) Unmarshal(tmp []byte) error {
4452         o := binary.BigEndian
4453         _ = o
4454         pos := 0
4455         _ = pos
4456         // field[1] m.Table
4457         // field[2] m.Table.TableID
4458         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4459         pos += 4
4460         // field[2] m.Table.IsIP6
4461         m.Table.IsIP6 = tmp[pos] != 0
4462         pos += 1
4463         // field[2] m.Table.Name
4464         {
4465                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4466                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4467                 pos += 64
4468         }
4469         return nil
4470 }
4471
4472 // IPTableReplaceEndReply represents VPP binary API message 'ip_table_replace_end_reply'.
4473 type IPTableReplaceEndReply struct {
4474         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4475 }
4476
4477 func (m *IPTableReplaceEndReply) Reset()                        { *m = IPTableReplaceEndReply{} }
4478 func (*IPTableReplaceEndReply) GetMessageName() string          { return "ip_table_replace_end_reply" }
4479 func (*IPTableReplaceEndReply) GetCrcString() string            { return "e8d4e804" }
4480 func (*IPTableReplaceEndReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4481
4482 func (m *IPTableReplaceEndReply) Size() int {
4483         if m == nil {
4484                 return 0
4485         }
4486         var size int
4487         // field[1] m.Retval
4488         size += 4
4489         return size
4490 }
4491 func (m *IPTableReplaceEndReply) Marshal(b []byte) ([]byte, error) {
4492         o := binary.BigEndian
4493         _ = o
4494         pos := 0
4495         _ = pos
4496         var buf []byte
4497         if b == nil {
4498                 buf = make([]byte, m.Size())
4499         } else {
4500                 buf = b
4501         }
4502         // field[1] m.Retval
4503         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4504         pos += 4
4505         return buf, nil
4506 }
4507 func (m *IPTableReplaceEndReply) Unmarshal(tmp []byte) error {
4508         o := binary.BigEndian
4509         _ = o
4510         pos := 0
4511         _ = pos
4512         // field[1] m.Retval
4513         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4514         pos += 4
4515         return nil
4516 }
4517
4518 // IPUnnumberedDetails represents VPP binary API message 'ip_unnumbered_details'.
4519 type IPUnnumberedDetails struct {
4520         SwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4521         IPSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=ip_sw_if_index" json:"ip_sw_if_index,omitempty"`
4522 }
4523
4524 func (m *IPUnnumberedDetails) Reset()                        { *m = IPUnnumberedDetails{} }
4525 func (*IPUnnumberedDetails) GetMessageName() string          { return "ip_unnumbered_details" }
4526 func (*IPUnnumberedDetails) GetCrcString() string            { return "aa12a483" }
4527 func (*IPUnnumberedDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
4528
4529 func (m *IPUnnumberedDetails) Size() int {
4530         if m == nil {
4531                 return 0
4532         }
4533         var size int
4534         // field[1] m.SwIfIndex
4535         size += 4
4536         // field[1] m.IPSwIfIndex
4537         size += 4
4538         return size
4539 }
4540 func (m *IPUnnumberedDetails) Marshal(b []byte) ([]byte, error) {
4541         o := binary.BigEndian
4542         _ = o
4543         pos := 0
4544         _ = pos
4545         var buf []byte
4546         if b == nil {
4547                 buf = make([]byte, m.Size())
4548         } else {
4549                 buf = b
4550         }
4551         // field[1] m.SwIfIndex
4552         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4553         pos += 4
4554         // field[1] m.IPSwIfIndex
4555         o.PutUint32(buf[pos:pos+4], uint32(m.IPSwIfIndex))
4556         pos += 4
4557         return buf, nil
4558 }
4559 func (m *IPUnnumberedDetails) Unmarshal(tmp []byte) error {
4560         o := binary.BigEndian
4561         _ = o
4562         pos := 0
4563         _ = pos
4564         // field[1] m.SwIfIndex
4565         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4566         pos += 4
4567         // field[1] m.IPSwIfIndex
4568         m.IPSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4569         pos += 4
4570         return nil
4571 }
4572
4573 // IPUnnumberedDump represents VPP binary API message 'ip_unnumbered_dump'.
4574 type IPUnnumberedDump struct {
4575         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index,default=4.294967295e+09" json:"sw_if_index,omitempty"`
4576 }
4577
4578 func (m *IPUnnumberedDump) Reset()                        { *m = IPUnnumberedDump{} }
4579 func (*IPUnnumberedDump) GetMessageName() string          { return "ip_unnumbered_dump" }
4580 func (*IPUnnumberedDump) GetCrcString() string            { return "f9e6675e" }
4581 func (*IPUnnumberedDump) GetMessageType() api.MessageType { return api.RequestMessage }
4582
4583 func (m *IPUnnumberedDump) Size() int {
4584         if m == nil {
4585                 return 0
4586         }
4587         var size int
4588         // field[1] m.SwIfIndex
4589         size += 4
4590         return size
4591 }
4592 func (m *IPUnnumberedDump) Marshal(b []byte) ([]byte, error) {
4593         o := binary.BigEndian
4594         _ = o
4595         pos := 0
4596         _ = pos
4597         var buf []byte
4598         if b == nil {
4599                 buf = make([]byte, m.Size())
4600         } else {
4601                 buf = b
4602         }
4603         // field[1] m.SwIfIndex
4604         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4605         pos += 4
4606         return buf, nil
4607 }
4608 func (m *IPUnnumberedDump) Unmarshal(tmp []byte) error {
4609         o := binary.BigEndian
4610         _ = o
4611         pos := 0
4612         _ = pos
4613         // field[1] m.SwIfIndex
4614         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4615         pos += 4
4616         return nil
4617 }
4618
4619 // MfibSignalDetails represents VPP binary API message 'mfib_signal_details'.
4620 type MfibSignalDetails struct {
4621         SwIfIndex    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4622         TableID      uint32                         `binapi:"u32,name=table_id" json:"table_id,omitempty"`
4623         Prefix       fib_types.Mprefix              `binapi:"mprefix,name=prefix" json:"prefix,omitempty"`
4624         IPPacketLen  uint16                         `binapi:"u16,name=ip_packet_len" json:"ip_packet_len,omitempty"`
4625         IPPacketData []byte                         `binapi:"u8[256],name=ip_packet_data" json:"ip_packet_data,omitempty" struc:"[256]byte"`
4626 }
4627
4628 func (m *MfibSignalDetails) Reset()                        { *m = MfibSignalDetails{} }
4629 func (*MfibSignalDetails) GetMessageName() string          { return "mfib_signal_details" }
4630 func (*MfibSignalDetails) GetCrcString() string            { return "64398a9a" }
4631 func (*MfibSignalDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
4632
4633 func (m *MfibSignalDetails) Size() int {
4634         if m == nil {
4635                 return 0
4636         }
4637         var size int
4638         // field[1] m.SwIfIndex
4639         size += 4
4640         // field[1] m.TableID
4641         size += 4
4642         // field[1] m.Prefix
4643         // field[2] m.Prefix.Af
4644         size += 1
4645         // field[2] m.Prefix.GrpAddressLength
4646         size += 2
4647         // field[2] m.Prefix.GrpAddress
4648         size += 16
4649         // field[2] m.Prefix.SrcAddress
4650         size += 16
4651         // field[1] m.IPPacketLen
4652         size += 2
4653         // field[1] m.IPPacketData
4654         size += 256
4655         return size
4656 }
4657 func (m *MfibSignalDetails) Marshal(b []byte) ([]byte, error) {
4658         o := binary.BigEndian
4659         _ = o
4660         pos := 0
4661         _ = pos
4662         var buf []byte
4663         if b == nil {
4664                 buf = make([]byte, m.Size())
4665         } else {
4666                 buf = b
4667         }
4668         // field[1] m.SwIfIndex
4669         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4670         pos += 4
4671         // field[1] m.TableID
4672         o.PutUint32(buf[pos:pos+4], uint32(m.TableID))
4673         pos += 4
4674         // field[1] m.Prefix
4675         // field[2] m.Prefix.Af
4676         buf[pos] = uint8(m.Prefix.Af)
4677         pos += 1
4678         // field[2] m.Prefix.GrpAddressLength
4679         o.PutUint16(buf[pos:pos+2], uint16(m.Prefix.GrpAddressLength))
4680         pos += 2
4681         // field[2] m.Prefix.GrpAddress
4682         copy(buf[pos:pos+16], m.Prefix.GrpAddress.XXX_UnionData[:])
4683         pos += 16
4684         // field[2] m.Prefix.SrcAddress
4685         copy(buf[pos:pos+16], m.Prefix.SrcAddress.XXX_UnionData[:])
4686         pos += 16
4687         // field[1] m.IPPacketLen
4688         o.PutUint16(buf[pos:pos+2], uint16(m.IPPacketLen))
4689         pos += 2
4690         // field[1] m.IPPacketData
4691         for i := 0; i < 256; i++ {
4692                 var x uint8
4693                 if i < len(m.IPPacketData) {
4694                         x = uint8(m.IPPacketData[i])
4695                 }
4696                 buf[pos] = uint8(x)
4697                 pos += 1
4698         }
4699         return buf, nil
4700 }
4701 func (m *MfibSignalDetails) Unmarshal(tmp []byte) error {
4702         o := binary.BigEndian
4703         _ = o
4704         pos := 0
4705         _ = pos
4706         // field[1] m.SwIfIndex
4707         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4708         pos += 4
4709         // field[1] m.TableID
4710         m.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4711         pos += 4
4712         // field[1] m.Prefix
4713         // field[2] m.Prefix.Af
4714         m.Prefix.Af = fib_types.AddressFamily(tmp[pos])
4715         pos += 1
4716         // field[2] m.Prefix.GrpAddressLength
4717         m.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
4718         pos += 2
4719         // field[2] m.Prefix.GrpAddress
4720         copy(m.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
4721         pos += 16
4722         // field[2] m.Prefix.SrcAddress
4723         copy(m.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
4724         pos += 16
4725         // field[1] m.IPPacketLen
4726         m.IPPacketLen = uint16(o.Uint16(tmp[pos : pos+2]))
4727         pos += 2
4728         // field[1] m.IPPacketData
4729         m.IPPacketData = make([]uint8, 256)
4730         for i := 0; i < len(m.IPPacketData); i++ {
4731                 m.IPPacketData[i] = uint8(tmp[pos])
4732                 pos += 1
4733         }
4734         return nil
4735 }
4736
4737 // MfibSignalDump represents VPP binary API message 'mfib_signal_dump'.
4738 type MfibSignalDump struct{}
4739
4740 func (m *MfibSignalDump) Reset()                        { *m = MfibSignalDump{} }
4741 func (*MfibSignalDump) GetMessageName() string          { return "mfib_signal_dump" }
4742 func (*MfibSignalDump) GetCrcString() string            { return "51077d14" }
4743 func (*MfibSignalDump) GetMessageType() api.MessageType { return api.RequestMessage }
4744
4745 func (m *MfibSignalDump) Size() int {
4746         if m == nil {
4747                 return 0
4748         }
4749         var size int
4750         return size
4751 }
4752 func (m *MfibSignalDump) Marshal(b []byte) ([]byte, error) {
4753         o := binary.BigEndian
4754         _ = o
4755         pos := 0
4756         _ = pos
4757         var buf []byte
4758         if b == nil {
4759                 buf = make([]byte, m.Size())
4760         } else {
4761                 buf = b
4762         }
4763         return buf, nil
4764 }
4765 func (m *MfibSignalDump) Unmarshal(tmp []byte) error {
4766         o := binary.BigEndian
4767         _ = o
4768         pos := 0
4769         _ = pos
4770         return nil
4771 }
4772
4773 // SetIPFlowHash represents VPP binary API message 'set_ip_flow_hash'.
4774 type SetIPFlowHash struct {
4775         VrfID     uint32 `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
4776         IsIPv6    bool   `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
4777         Src       bool   `binapi:"bool,name=src" json:"src,omitempty"`
4778         Dst       bool   `binapi:"bool,name=dst" json:"dst,omitempty"`
4779         Sport     bool   `binapi:"bool,name=sport" json:"sport,omitempty"`
4780         Dport     bool   `binapi:"bool,name=dport" json:"dport,omitempty"`
4781         Proto     bool   `binapi:"bool,name=proto" json:"proto,omitempty"`
4782         Reverse   bool   `binapi:"bool,name=reverse" json:"reverse,omitempty"`
4783         Symmetric bool   `binapi:"bool,name=symmetric" json:"symmetric,omitempty"`
4784 }
4785
4786 func (m *SetIPFlowHash) Reset()                        { *m = SetIPFlowHash{} }
4787 func (*SetIPFlowHash) GetMessageName() string          { return "set_ip_flow_hash" }
4788 func (*SetIPFlowHash) GetCrcString() string            { return "084ee09e" }
4789 func (*SetIPFlowHash) GetMessageType() api.MessageType { return api.RequestMessage }
4790
4791 func (m *SetIPFlowHash) Size() int {
4792         if m == nil {
4793                 return 0
4794         }
4795         var size int
4796         // field[1] m.VrfID
4797         size += 4
4798         // field[1] m.IsIPv6
4799         size += 1
4800         // field[1] m.Src
4801         size += 1
4802         // field[1] m.Dst
4803         size += 1
4804         // field[1] m.Sport
4805         size += 1
4806         // field[1] m.Dport
4807         size += 1
4808         // field[1] m.Proto
4809         size += 1
4810         // field[1] m.Reverse
4811         size += 1
4812         // field[1] m.Symmetric
4813         size += 1
4814         return size
4815 }
4816 func (m *SetIPFlowHash) Marshal(b []byte) ([]byte, error) {
4817         o := binary.BigEndian
4818         _ = o
4819         pos := 0
4820         _ = pos
4821         var buf []byte
4822         if b == nil {
4823                 buf = make([]byte, m.Size())
4824         } else {
4825                 buf = b
4826         }
4827         // field[1] m.VrfID
4828         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
4829         pos += 4
4830         // field[1] m.IsIPv6
4831         if m.IsIPv6 {
4832                 buf[pos] = 1
4833         }
4834         pos += 1
4835         // field[1] m.Src
4836         if m.Src {
4837                 buf[pos] = 1
4838         }
4839         pos += 1
4840         // field[1] m.Dst
4841         if m.Dst {
4842                 buf[pos] = 1
4843         }
4844         pos += 1
4845         // field[1] m.Sport
4846         if m.Sport {
4847                 buf[pos] = 1
4848         }
4849         pos += 1
4850         // field[1] m.Dport
4851         if m.Dport {
4852                 buf[pos] = 1
4853         }
4854         pos += 1
4855         // field[1] m.Proto
4856         if m.Proto {
4857                 buf[pos] = 1
4858         }
4859         pos += 1
4860         // field[1] m.Reverse
4861         if m.Reverse {
4862                 buf[pos] = 1
4863         }
4864         pos += 1
4865         // field[1] m.Symmetric
4866         if m.Symmetric {
4867                 buf[pos] = 1
4868         }
4869         pos += 1
4870         return buf, nil
4871 }
4872 func (m *SetIPFlowHash) Unmarshal(tmp []byte) error {
4873         o := binary.BigEndian
4874         _ = o
4875         pos := 0
4876         _ = pos
4877         // field[1] m.VrfID
4878         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4879         pos += 4
4880         // field[1] m.IsIPv6
4881         m.IsIPv6 = tmp[pos] != 0
4882         pos += 1
4883         // field[1] m.Src
4884         m.Src = tmp[pos] != 0
4885         pos += 1
4886         // field[1] m.Dst
4887         m.Dst = tmp[pos] != 0
4888         pos += 1
4889         // field[1] m.Sport
4890         m.Sport = tmp[pos] != 0
4891         pos += 1
4892         // field[1] m.Dport
4893         m.Dport = tmp[pos] != 0
4894         pos += 1
4895         // field[1] m.Proto
4896         m.Proto = tmp[pos] != 0
4897         pos += 1
4898         // field[1] m.Reverse
4899         m.Reverse = tmp[pos] != 0
4900         pos += 1
4901         // field[1] m.Symmetric
4902         m.Symmetric = tmp[pos] != 0
4903         pos += 1
4904         return nil
4905 }
4906
4907 // SetIPFlowHashReply represents VPP binary API message 'set_ip_flow_hash_reply'.
4908 type SetIPFlowHashReply struct {
4909         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4910 }
4911
4912 func (m *SetIPFlowHashReply) Reset()                        { *m = SetIPFlowHashReply{} }
4913 func (*SetIPFlowHashReply) GetMessageName() string          { return "set_ip_flow_hash_reply" }
4914 func (*SetIPFlowHashReply) GetCrcString() string            { return "e8d4e804" }
4915 func (*SetIPFlowHashReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4916
4917 func (m *SetIPFlowHashReply) Size() int {
4918         if m == nil {
4919                 return 0
4920         }
4921         var size int
4922         // field[1] m.Retval
4923         size += 4
4924         return size
4925 }
4926 func (m *SetIPFlowHashReply) Marshal(b []byte) ([]byte, error) {
4927         o := binary.BigEndian
4928         _ = o
4929         pos := 0
4930         _ = pos
4931         var buf []byte
4932         if b == nil {
4933                 buf = make([]byte, m.Size())
4934         } else {
4935                 buf = b
4936         }
4937         // field[1] m.Retval
4938         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4939         pos += 4
4940         return buf, nil
4941 }
4942 func (m *SetIPFlowHashReply) Unmarshal(tmp []byte) error {
4943         o := binary.BigEndian
4944         _ = o
4945         pos := 0
4946         _ = pos
4947         // field[1] m.Retval
4948         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4949         pos += 4
4950         return nil
4951 }
4952
4953 // SwInterfaceIP6EnableDisable represents VPP binary API message 'sw_interface_ip6_enable_disable'.
4954 type SwInterfaceIP6EnableDisable struct {
4955         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4956         Enable    bool                           `binapi:"bool,name=enable" json:"enable,omitempty"`
4957 }
4958
4959 func (m *SwInterfaceIP6EnableDisable) Reset()                        { *m = SwInterfaceIP6EnableDisable{} }
4960 func (*SwInterfaceIP6EnableDisable) GetMessageName() string          { return "sw_interface_ip6_enable_disable" }
4961 func (*SwInterfaceIP6EnableDisable) GetCrcString() string            { return "ae6cfcfb" }
4962 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType { return api.RequestMessage }
4963
4964 func (m *SwInterfaceIP6EnableDisable) Size() int {
4965         if m == nil {
4966                 return 0
4967         }
4968         var size int
4969         // field[1] m.SwIfIndex
4970         size += 4
4971         // field[1] m.Enable
4972         size += 1
4973         return size
4974 }
4975 func (m *SwInterfaceIP6EnableDisable) Marshal(b []byte) ([]byte, error) {
4976         o := binary.BigEndian
4977         _ = o
4978         pos := 0
4979         _ = pos
4980         var buf []byte
4981         if b == nil {
4982                 buf = make([]byte, m.Size())
4983         } else {
4984                 buf = b
4985         }
4986         // field[1] m.SwIfIndex
4987         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4988         pos += 4
4989         // field[1] m.Enable
4990         if m.Enable {
4991                 buf[pos] = 1
4992         }
4993         pos += 1
4994         return buf, nil
4995 }
4996 func (m *SwInterfaceIP6EnableDisable) Unmarshal(tmp []byte) error {
4997         o := binary.BigEndian
4998         _ = o
4999         pos := 0
5000         _ = pos
5001         // field[1] m.SwIfIndex
5002         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5003         pos += 4
5004         // field[1] m.Enable
5005         m.Enable = tmp[pos] != 0
5006         pos += 1
5007         return nil
5008 }
5009
5010 // SwInterfaceIP6EnableDisableReply represents VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
5011 type SwInterfaceIP6EnableDisableReply struct {
5012         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
5013 }
5014
5015 func (m *SwInterfaceIP6EnableDisableReply) Reset() { *m = SwInterfaceIP6EnableDisableReply{} }
5016 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
5017         return "sw_interface_ip6_enable_disable_reply"
5018 }
5019 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string            { return "e8d4e804" }
5020 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
5021
5022 func (m *SwInterfaceIP6EnableDisableReply) Size() int {
5023         if m == nil {
5024                 return 0
5025         }
5026         var size int
5027         // field[1] m.Retval
5028         size += 4
5029         return size
5030 }
5031 func (m *SwInterfaceIP6EnableDisableReply) Marshal(b []byte) ([]byte, error) {
5032         o := binary.BigEndian
5033         _ = o
5034         pos := 0
5035         _ = pos
5036         var buf []byte
5037         if b == nil {
5038                 buf = make([]byte, m.Size())
5039         } else {
5040                 buf = b
5041         }
5042         // field[1] m.Retval
5043         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
5044         pos += 4
5045         return buf, nil
5046 }
5047 func (m *SwInterfaceIP6EnableDisableReply) Unmarshal(tmp []byte) error {
5048         o := binary.BigEndian
5049         _ = o
5050         pos := 0
5051         _ = pos
5052         // field[1] m.Retval
5053         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
5054         pos += 4
5055         return nil
5056 }
5057
5058 // SwInterfaceIP6SetLinkLocalAddress represents VPP binary API message 'sw_interface_ip6_set_link_local_address'.
5059 type SwInterfaceIP6SetLinkLocalAddress struct {
5060         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
5061         IP        fib_types.IP6Address           `binapi:"ip6_address,name=ip" json:"ip,omitempty"`
5062 }
5063
5064 func (m *SwInterfaceIP6SetLinkLocalAddress) Reset() { *m = SwInterfaceIP6SetLinkLocalAddress{} }
5065 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
5066         return "sw_interface_ip6_set_link_local_address"
5067 }
5068 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string            { return "2931d9fa" }
5069 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType { return api.RequestMessage }
5070
5071 func (m *SwInterfaceIP6SetLinkLocalAddress) Size() int {
5072         if m == nil {
5073                 return 0
5074         }
5075         var size int
5076         // field[1] m.SwIfIndex
5077         size += 4
5078         // field[1] m.IP
5079         size += 16
5080         return size
5081 }
5082 func (m *SwInterfaceIP6SetLinkLocalAddress) Marshal(b []byte) ([]byte, error) {
5083         o := binary.BigEndian
5084         _ = o
5085         pos := 0
5086         _ = pos
5087         var buf []byte
5088         if b == nil {
5089                 buf = make([]byte, m.Size())
5090         } else {
5091                 buf = b
5092         }
5093         // field[1] m.SwIfIndex
5094         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
5095         pos += 4
5096         // field[1] m.IP
5097         for i := 0; i < 16; i++ {
5098                 var x uint8
5099                 if i < len(m.IP) {
5100                         x = uint8(m.IP[i])
5101                 }
5102                 buf[pos] = uint8(x)
5103                 pos += 1
5104         }
5105         return buf, nil
5106 }
5107 func (m *SwInterfaceIP6SetLinkLocalAddress) Unmarshal(tmp []byte) error {
5108         o := binary.BigEndian
5109         _ = o
5110         pos := 0
5111         _ = pos
5112         // field[1] m.SwIfIndex
5113         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5114         pos += 4
5115         // field[1] m.IP
5116         for i := 0; i < len(m.IP); i++ {
5117                 m.IP[i] = uint8(tmp[pos])
5118                 pos += 1
5119         }
5120         return nil
5121 }
5122
5123 // SwInterfaceIP6SetLinkLocalAddressReply represents VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
5124 type SwInterfaceIP6SetLinkLocalAddressReply struct {
5125         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
5126 }
5127
5128 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Reset() {
5129         *m = SwInterfaceIP6SetLinkLocalAddressReply{}
5130 }
5131 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
5132         return "sw_interface_ip6_set_link_local_address_reply"
5133 }
5134 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string { return "e8d4e804" }
5135 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
5136         return api.ReplyMessage
5137 }
5138
5139 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Size() int {
5140         if m == nil {
5141                 return 0
5142         }
5143         var size int
5144         // field[1] m.Retval
5145         size += 4
5146         return size
5147 }
5148 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Marshal(b []byte) ([]byte, error) {
5149         o := binary.BigEndian
5150         _ = o
5151         pos := 0
5152         _ = pos
5153         var buf []byte
5154         if b == nil {
5155                 buf = make([]byte, m.Size())
5156         } else {
5157                 buf = b
5158         }
5159         // field[1] m.Retval
5160         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
5161         pos += 4
5162         return buf, nil
5163 }
5164 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Unmarshal(tmp []byte) error {
5165         o := binary.BigEndian
5166         _ = o
5167         pos := 0
5168         _ = pos
5169         // field[1] m.Retval
5170         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
5171         pos += 4
5172         return nil
5173 }
5174
5175 func init() { file_ip_binapi_init() }
5176 func file_ip_binapi_init() {
5177         api.RegisterMessage((*IoamDisable)(nil), "ip.IoamDisable")
5178         api.RegisterMessage((*IoamDisableReply)(nil), "ip.IoamDisableReply")
5179         api.RegisterMessage((*IoamEnable)(nil), "ip.IoamEnable")
5180         api.RegisterMessage((*IoamEnableReply)(nil), "ip.IoamEnableReply")
5181         api.RegisterMessage((*IPAddressDetails)(nil), "ip.IPAddressDetails")
5182         api.RegisterMessage((*IPAddressDump)(nil), "ip.IPAddressDump")
5183         api.RegisterMessage((*IPContainerProxyAddDel)(nil), "ip.IPContainerProxyAddDel")
5184         api.RegisterMessage((*IPContainerProxyAddDelReply)(nil), "ip.IPContainerProxyAddDelReply")
5185         api.RegisterMessage((*IPContainerProxyDetails)(nil), "ip.IPContainerProxyDetails")
5186         api.RegisterMessage((*IPContainerProxyDump)(nil), "ip.IPContainerProxyDump")
5187         api.RegisterMessage((*IPDetails)(nil), "ip.IPDetails")
5188         api.RegisterMessage((*IPDump)(nil), "ip.IPDump")
5189         api.RegisterMessage((*IPMrouteAddDel)(nil), "ip.IPMrouteAddDel")
5190         api.RegisterMessage((*IPMrouteAddDelReply)(nil), "ip.IPMrouteAddDelReply")
5191         api.RegisterMessage((*IPMrouteDetails)(nil), "ip.IPMrouteDetails")
5192         api.RegisterMessage((*IPMrouteDump)(nil), "ip.IPMrouteDump")
5193         api.RegisterMessage((*IPMtableDetails)(nil), "ip.IPMtableDetails")
5194         api.RegisterMessage((*IPMtableDump)(nil), "ip.IPMtableDump")
5195         api.RegisterMessage((*IPPuntPolice)(nil), "ip.IPPuntPolice")
5196         api.RegisterMessage((*IPPuntPoliceReply)(nil), "ip.IPPuntPoliceReply")
5197         api.RegisterMessage((*IPPuntRedirect)(nil), "ip.IPPuntRedirect")
5198         api.RegisterMessage((*IPPuntRedirectDetails)(nil), "ip.IPPuntRedirectDetails")
5199         api.RegisterMessage((*IPPuntRedirectDump)(nil), "ip.IPPuntRedirectDump")
5200         api.RegisterMessage((*IPPuntRedirectReply)(nil), "ip.IPPuntRedirectReply")
5201         api.RegisterMessage((*IPReassemblyEnableDisable)(nil), "ip.IPReassemblyEnableDisable")
5202         api.RegisterMessage((*IPReassemblyEnableDisableReply)(nil), "ip.IPReassemblyEnableDisableReply")
5203         api.RegisterMessage((*IPReassemblyGet)(nil), "ip.IPReassemblyGet")
5204         api.RegisterMessage((*IPReassemblyGetReply)(nil), "ip.IPReassemblyGetReply")
5205         api.RegisterMessage((*IPReassemblySet)(nil), "ip.IPReassemblySet")
5206         api.RegisterMessage((*IPReassemblySetReply)(nil), "ip.IPReassemblySetReply")
5207         api.RegisterMessage((*IPRouteAddDel)(nil), "ip.IPRouteAddDel")
5208         api.RegisterMessage((*IPRouteAddDelReply)(nil), "ip.IPRouteAddDelReply")
5209         api.RegisterMessage((*IPRouteDetails)(nil), "ip.IPRouteDetails")
5210         api.RegisterMessage((*IPRouteDump)(nil), "ip.IPRouteDump")
5211         api.RegisterMessage((*IPRouteLookup)(nil), "ip.IPRouteLookup")
5212         api.RegisterMessage((*IPRouteLookupReply)(nil), "ip.IPRouteLookupReply")
5213         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDel)(nil), "ip.IPSourceAndPortRangeCheckAddDel")
5214         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckAddDelReply")
5215         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDel)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDel")
5216         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDelReply")
5217         api.RegisterMessage((*IPTableAddDel)(nil), "ip.IPTableAddDel")
5218         api.RegisterMessage((*IPTableAddDelReply)(nil), "ip.IPTableAddDelReply")
5219         api.RegisterMessage((*IPTableDetails)(nil), "ip.IPTableDetails")
5220         api.RegisterMessage((*IPTableDump)(nil), "ip.IPTableDump")
5221         api.RegisterMessage((*IPTableFlush)(nil), "ip.IPTableFlush")
5222         api.RegisterMessage((*IPTableFlushReply)(nil), "ip.IPTableFlushReply")
5223         api.RegisterMessage((*IPTableReplaceBegin)(nil), "ip.IPTableReplaceBegin")
5224         api.RegisterMessage((*IPTableReplaceBeginReply)(nil), "ip.IPTableReplaceBeginReply")
5225         api.RegisterMessage((*IPTableReplaceEnd)(nil), "ip.IPTableReplaceEnd")
5226         api.RegisterMessage((*IPTableReplaceEndReply)(nil), "ip.IPTableReplaceEndReply")
5227         api.RegisterMessage((*IPUnnumberedDetails)(nil), "ip.IPUnnumberedDetails")
5228         api.RegisterMessage((*IPUnnumberedDump)(nil), "ip.IPUnnumberedDump")
5229         api.RegisterMessage((*MfibSignalDetails)(nil), "ip.MfibSignalDetails")
5230         api.RegisterMessage((*MfibSignalDump)(nil), "ip.MfibSignalDump")
5231         api.RegisterMessage((*SetIPFlowHash)(nil), "ip.SetIPFlowHash")
5232         api.RegisterMessage((*SetIPFlowHashReply)(nil), "ip.SetIPFlowHashReply")
5233         api.RegisterMessage((*SwInterfaceIP6EnableDisable)(nil), "ip.SwInterfaceIP6EnableDisable")
5234         api.RegisterMessage((*SwInterfaceIP6EnableDisableReply)(nil), "ip.SwInterfaceIP6EnableDisableReply")
5235         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddress)(nil), "ip.SwInterfaceIP6SetLinkLocalAddress")
5236         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddressReply)(nil), "ip.SwInterfaceIP6SetLinkLocalAddressReply")
5237 }
5238
5239 // Messages returns list of all messages in this module.
5240 func AllMessages() []api.Message {
5241         return []api.Message{
5242                 (*IoamDisable)(nil),
5243                 (*IoamDisableReply)(nil),
5244                 (*IoamEnable)(nil),
5245                 (*IoamEnableReply)(nil),
5246                 (*IPAddressDetails)(nil),
5247                 (*IPAddressDump)(nil),
5248                 (*IPContainerProxyAddDel)(nil),
5249                 (*IPContainerProxyAddDelReply)(nil),
5250                 (*IPContainerProxyDetails)(nil),
5251                 (*IPContainerProxyDump)(nil),
5252                 (*IPDetails)(nil),
5253                 (*IPDump)(nil),
5254                 (*IPMrouteAddDel)(nil),
5255                 (*IPMrouteAddDelReply)(nil),
5256                 (*IPMrouteDetails)(nil),
5257                 (*IPMrouteDump)(nil),
5258                 (*IPMtableDetails)(nil),
5259                 (*IPMtableDump)(nil),
5260                 (*IPPuntPolice)(nil),
5261                 (*IPPuntPoliceReply)(nil),
5262                 (*IPPuntRedirect)(nil),
5263                 (*IPPuntRedirectDetails)(nil),
5264                 (*IPPuntRedirectDump)(nil),
5265                 (*IPPuntRedirectReply)(nil),
5266                 (*IPReassemblyEnableDisable)(nil),
5267                 (*IPReassemblyEnableDisableReply)(nil),
5268                 (*IPReassemblyGet)(nil),
5269                 (*IPReassemblyGetReply)(nil),
5270                 (*IPReassemblySet)(nil),
5271                 (*IPReassemblySetReply)(nil),
5272                 (*IPRouteAddDel)(nil),
5273                 (*IPRouteAddDelReply)(nil),
5274                 (*IPRouteDetails)(nil),
5275                 (*IPRouteDump)(nil),
5276                 (*IPRouteLookup)(nil),
5277                 (*IPRouteLookupReply)(nil),
5278                 (*IPSourceAndPortRangeCheckAddDel)(nil),
5279                 (*IPSourceAndPortRangeCheckAddDelReply)(nil),
5280                 (*IPSourceAndPortRangeCheckInterfaceAddDel)(nil),
5281                 (*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil),
5282                 (*IPTableAddDel)(nil),
5283                 (*IPTableAddDelReply)(nil),
5284                 (*IPTableDetails)(nil),
5285                 (*IPTableDump)(nil),
5286                 (*IPTableFlush)(nil),
5287                 (*IPTableFlushReply)(nil),
5288                 (*IPTableReplaceBegin)(nil),
5289                 (*IPTableReplaceBeginReply)(nil),
5290                 (*IPTableReplaceEnd)(nil),
5291                 (*IPTableReplaceEndReply)(nil),
5292                 (*IPUnnumberedDetails)(nil),
5293                 (*IPUnnumberedDump)(nil),
5294                 (*MfibSignalDetails)(nil),
5295                 (*MfibSignalDump)(nil),
5296                 (*SetIPFlowHash)(nil),
5297                 (*SetIPFlowHashReply)(nil),
5298                 (*SwInterfaceIP6EnableDisable)(nil),
5299                 (*SwInterfaceIP6EnableDisableReply)(nil),
5300                 (*SwInterfaceIP6SetLinkLocalAddress)(nil),
5301                 (*SwInterfaceIP6SetLinkLocalAddressReply)(nil),
5302         }
5303 }
5304
5305 // Reference imports to suppress errors if they are not otherwise used.
5306 var _ = api.RegisterMessage
5307 var _ = codec.DecodeString
5308 var _ = bytes.NewBuffer
5309 var _ = context.Background
5310 var _ = io.Copy
5311 var _ = strconv.Itoa
5312 var _ = strings.Contains
5313 var _ = struc.Pack
5314 var _ = binary.BigEndian
5315 var _ = math.Float32bits
5316 var _ = net.ParseIP
5317 var _ = fmt.Errorf