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