examples/binapi/interfaces/interfaces.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/interface.api.json
   6
   7 /*
   8 Package interfaces contains generated code for VPP API file interface.api (3.2.2).
   9
  10 It consists of:
  11           7 aliases
  12          10 enums
  13          57 messages
  14           6 types
  15           1 union
  16 */
  17 package interfaces
  18
  19 import (
  20         "bytes"
  21         "context"
  22         "encoding/binary"
  23         "fmt"
  24         "io"
  25         "math"
  26         "net"
  27         "strconv"
  28         "strings"
  29
  30         api "git.fd.io/govpp.git/api"
  31         codec "git.fd.io/govpp.git/codec"
  32         struc "github.com/lunixbochs/struc"
  33
  34         interface_types "git.fd.io/govpp.git/examples/binapi/interface_types"
  35         ip_types "git.fd.io/govpp.git/examples/binapi/ip_types"
  36 )
  37
  38 // This is a compile-time assertion to ensure that this generated file
  39 // is compatible with the GoVPP api package it is being compiled against.
  40 // A compilation error at this line likely means your copy of the
  41 // GoVPP api package needs to be updated.
  42 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  43
  44 const (
  45         // ModuleName is the name of this module.
  46         ModuleName = "interface"
  47         // APIVersion is the API version of this module.
  48         APIVersion = "3.2.2"
  49         // VersionCrc is the CRC of this module.
  50         VersionCrc = 0x58d4cf5a
  51 )
  52
  53 // MacAddress represents VPP binary API alias 'mac_address'.
  54 type MacAddress [6]uint8
  55
  56 func ParseMAC(mac string) (parsed MacAddress, err error) {
  57         var hw net.HardwareAddr
  58         if hw, err = net.ParseMAC(mac); err != nil {
  59                 return
  60         }
  61         copy(parsed[:], hw[:])
  62         return
  63 }
  64
  65 func (m *MacAddress) ToString() string {
  66         return net.HardwareAddr(m[:]).String()
  67 }
  68
  69 // CollectDetailedInterfaceStats represents VPP binary API message 'collect_detailed_interface_stats'.
  70 type CollectDetailedInterfaceStats struct {
  71         SwIfIndex     interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
  72         EnableDisable bool                           `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
  73 }
  74
  75 func (m *CollectDetailedInterfaceStats) Reset() { *m = CollectDetailedInterfaceStats{} }
  76 func (*CollectDetailedInterfaceStats) GetMessageName() string {
  77         return "collect_detailed_interface_stats"
  78 }
  79 func (*CollectDetailedInterfaceStats) GetCrcString() string            { return "5501adee" }
  80 func (*CollectDetailedInterfaceStats) GetMessageType() api.MessageType { return api.RequestMessage }
  81
  82 func (m *CollectDetailedInterfaceStats) Size() int {
  83         if m == nil {
  84                 return 0
  85         }
  86         var size int
  87         // field[1] m.SwIfIndex
  88         size += 4
  89         // field[1] m.EnableDisable
  90         size += 1
  91         return size
  92 }
  93 func (m *CollectDetailedInterfaceStats) Marshal(b []byte) ([]byte, error) {
  94         o := binary.BigEndian
  95         _ = o
  96         pos := 0
  97         _ = pos
  98         var buf []byte
  99         if b == nil {
 100                 buf = make([]byte, m.Size())
 101         } else {
 102                 buf = b
 103         }
 104         // field[1] m.SwIfIndex
 105         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 106         pos += 4
 107         // field[1] m.EnableDisable
 108         if m.EnableDisable {
 109                 buf[pos] = 1
 110         }
 111         pos += 1
 112         return buf, nil
 113 }
 114 func (m *CollectDetailedInterfaceStats) Unmarshal(tmp []byte) error {
 115         o := binary.BigEndian
 116         _ = o
 117         pos := 0
 118         _ = pos
 119         // field[1] m.SwIfIndex
 120         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 121         pos += 4
 122         // field[1] m.EnableDisable
 123         m.EnableDisable = tmp[pos] != 0
 124         pos += 1
 125         return nil
 126 }
 127
 128 // CollectDetailedInterfaceStatsReply represents VPP binary API message 'collect_detailed_interface_stats_reply'.
 129 type CollectDetailedInterfaceStatsReply struct {
 130         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 131 }
 132
 133 func (m *CollectDetailedInterfaceStatsReply) Reset() { *m = CollectDetailedInterfaceStatsReply{} }
 134 func (*CollectDetailedInterfaceStatsReply) GetMessageName() string {
 135         return "collect_detailed_interface_stats_reply"
 136 }
 137 func (*CollectDetailedInterfaceStatsReply) GetCrcString() string            { return "e8d4e804" }
 138 func (*CollectDetailedInterfaceStatsReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 139
 140 func (m *CollectDetailedInterfaceStatsReply) Size() int {
 141         if m == nil {
 142                 return 0
 143         }
 144         var size int
 145         // field[1] m.Retval
 146         size += 4
 147         return size
 148 }
 149 func (m *CollectDetailedInterfaceStatsReply) Marshal(b []byte) ([]byte, error) {
 150         o := binary.BigEndian
 151         _ = o
 152         pos := 0
 153         _ = pos
 154         var buf []byte
 155         if b == nil {
 156                 buf = make([]byte, m.Size())
 157         } else {
 158                 buf = b
 159         }
 160         // field[1] m.Retval
 161         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 162         pos += 4
 163         return buf, nil
 164 }
 165 func (m *CollectDetailedInterfaceStatsReply) Unmarshal(tmp []byte) error {
 166         o := binary.BigEndian
 167         _ = o
 168         pos := 0
 169         _ = pos
 170         // field[1] m.Retval
 171         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 172         pos += 4
 173         return nil
 174 }
 175
 176 // CreateLoopback represents VPP binary API message 'create_loopback'.
 177 type CreateLoopback struct {
 178         MacAddress MacAddress `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
 179 }
 180
 181 func (m *CreateLoopback) Reset()                        { *m = CreateLoopback{} }
 182 func (*CreateLoopback) GetMessageName() string          { return "create_loopback" }
 183 func (*CreateLoopback) GetCrcString() string            { return "42bb5d22" }
 184 func (*CreateLoopback) GetMessageType() api.MessageType { return api.RequestMessage }
 185
 186 func (m *CreateLoopback) Size() int {
 187         if m == nil {
 188                 return 0
 189         }
 190         var size int
 191         // field[1] m.MacAddress
 192         size += 6
 193         return size
 194 }
 195 func (m *CreateLoopback) Marshal(b []byte) ([]byte, error) {
 196         o := binary.BigEndian
 197         _ = o
 198         pos := 0
 199         _ = pos
 200         var buf []byte
 201         if b == nil {
 202                 buf = make([]byte, m.Size())
 203         } else {
 204                 buf = b
 205         }
 206         // field[1] m.MacAddress
 207         for i := 0; i < 6; i++ {
 208                 var x uint8
 209                 if i < len(m.MacAddress) {
 210                         x = uint8(m.MacAddress[i])
 211                 }
 212                 buf[pos] = uint8(x)
 213                 pos += 1
 214         }
 215         return buf, nil
 216 }
 217 func (m *CreateLoopback) Unmarshal(tmp []byte) error {
 218         o := binary.BigEndian
 219         _ = o
 220         pos := 0
 221         _ = pos
 222         // field[1] m.MacAddress
 223         for i := 0; i < len(m.MacAddress); i++ {
 224                 m.MacAddress[i] = uint8(tmp[pos])
 225                 pos += 1
 226         }
 227         return nil
 228 }
 229
 230 // CreateLoopbackInstance represents VPP binary API message 'create_loopback_instance'.
 231 type CreateLoopbackInstance struct {
 232         MacAddress   MacAddress `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
 233         IsSpecified  bool       `binapi:"bool,name=is_specified" json:"is_specified,omitempty"`
 234         UserInstance uint32     `binapi:"u32,name=user_instance" json:"user_instance,omitempty"`
 235 }
 236
 237 func (m *CreateLoopbackInstance) Reset()                        { *m = CreateLoopbackInstance{} }
 238 func (*CreateLoopbackInstance) GetMessageName() string          { return "create_loopback_instance" }
 239 func (*CreateLoopbackInstance) GetCrcString() string            { return "d36a3ee2" }
 240 func (*CreateLoopbackInstance) GetMessageType() api.MessageType { return api.RequestMessage }
 241
 242 func (m *CreateLoopbackInstance) Size() int {
 243         if m == nil {
 244                 return 0
 245         }
 246         var size int
 247         // field[1] m.MacAddress
 248         size += 6
 249         // field[1] m.IsSpecified
 250         size += 1
 251         // field[1] m.UserInstance
 252         size += 4
 253         return size
 254 }
 255 func (m *CreateLoopbackInstance) Marshal(b []byte) ([]byte, error) {
 256         o := binary.BigEndian
 257         _ = o
 258         pos := 0
 259         _ = pos
 260         var buf []byte
 261         if b == nil {
 262                 buf = make([]byte, m.Size())
 263         } else {
 264                 buf = b
 265         }
 266         // field[1] m.MacAddress
 267         for i := 0; i < 6; i++ {
 268                 var x uint8
 269                 if i < len(m.MacAddress) {
 270                         x = uint8(m.MacAddress[i])
 271                 }
 272                 buf[pos] = uint8(x)
 273                 pos += 1
 274         }
 275         // field[1] m.IsSpecified
 276         if m.IsSpecified {
 277                 buf[pos] = 1
 278         }
 279         pos += 1
 280         // field[1] m.UserInstance
 281         o.PutUint32(buf[pos:pos+4], uint32(m.UserInstance))
 282         pos += 4
 283         return buf, nil
 284 }
 285 func (m *CreateLoopbackInstance) Unmarshal(tmp []byte) error {
 286         o := binary.BigEndian
 287         _ = o
 288         pos := 0
 289         _ = pos
 290         // field[1] m.MacAddress
 291         for i := 0; i < len(m.MacAddress); i++ {
 292                 m.MacAddress[i] = uint8(tmp[pos])
 293                 pos += 1
 294         }
 295         // field[1] m.IsSpecified
 296         m.IsSpecified = tmp[pos] != 0
 297         pos += 1
 298         // field[1] m.UserInstance
 299         m.UserInstance = uint32(o.Uint32(tmp[pos : pos+4]))
 300         pos += 4
 301         return nil
 302 }
 303
 304 // CreateLoopbackInstanceReply represents VPP binary API message 'create_loopback_instance_reply'.
 305 type CreateLoopbackInstanceReply struct {
 306         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 307         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 308 }
 309
 310 func (m *CreateLoopbackInstanceReply) Reset()                        { *m = CreateLoopbackInstanceReply{} }
 311 func (*CreateLoopbackInstanceReply) GetMessageName() string          { return "create_loopback_instance_reply" }
 312 func (*CreateLoopbackInstanceReply) GetCrcString() string            { return "5383d31f" }
 313 func (*CreateLoopbackInstanceReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 314
 315 func (m *CreateLoopbackInstanceReply) Size() int {
 316         if m == nil {
 317                 return 0
 318         }
 319         var size int
 320         // field[1] m.Retval
 321         size += 4
 322         // field[1] m.SwIfIndex
 323         size += 4
 324         return size
 325 }
 326 func (m *CreateLoopbackInstanceReply) Marshal(b []byte) ([]byte, error) {
 327         o := binary.BigEndian
 328         _ = o
 329         pos := 0
 330         _ = pos
 331         var buf []byte
 332         if b == nil {
 333                 buf = make([]byte, m.Size())
 334         } else {
 335                 buf = b
 336         }
 337         // field[1] m.Retval
 338         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 339         pos += 4
 340         // field[1] m.SwIfIndex
 341         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 342         pos += 4
 343         return buf, nil
 344 }
 345 func (m *CreateLoopbackInstanceReply) Unmarshal(tmp []byte) error {
 346         o := binary.BigEndian
 347         _ = o
 348         pos := 0
 349         _ = pos
 350         // field[1] m.Retval
 351         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 352         pos += 4
 353         // field[1] m.SwIfIndex
 354         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 355         pos += 4
 356         return nil
 357 }
 358
 359 // CreateLoopbackReply represents VPP binary API message 'create_loopback_reply'.
 360 type CreateLoopbackReply struct {
 361         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 362         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 363 }
 364
 365 func (m *CreateLoopbackReply) Reset()                        { *m = CreateLoopbackReply{} }
 366 func (*CreateLoopbackReply) GetMessageName() string          { return "create_loopback_reply" }
 367 func (*CreateLoopbackReply) GetCrcString() string            { return "5383d31f" }
 368 func (*CreateLoopbackReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 369
 370 func (m *CreateLoopbackReply) Size() int {
 371         if m == nil {
 372                 return 0
 373         }
 374         var size int
 375         // field[1] m.Retval
 376         size += 4
 377         // field[1] m.SwIfIndex
 378         size += 4
 379         return size
 380 }
 381 func (m *CreateLoopbackReply) Marshal(b []byte) ([]byte, error) {
 382         o := binary.BigEndian
 383         _ = o
 384         pos := 0
 385         _ = pos
 386         var buf []byte
 387         if b == nil {
 388                 buf = make([]byte, m.Size())
 389         } else {
 390                 buf = b
 391         }
 392         // field[1] m.Retval
 393         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 394         pos += 4
 395         // field[1] m.SwIfIndex
 396         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 397         pos += 4
 398         return buf, nil
 399 }
 400 func (m *CreateLoopbackReply) Unmarshal(tmp []byte) error {
 401         o := binary.BigEndian
 402         _ = o
 403         pos := 0
 404         _ = pos
 405         // field[1] m.Retval
 406         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 407         pos += 4
 408         // field[1] m.SwIfIndex
 409         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 410         pos += 4
 411         return nil
 412 }
 413
 414 // CreateSubif represents VPP binary API message 'create_subif'.
 415 type CreateSubif struct {
 416         SwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 417         SubID       uint32                         `binapi:"u32,name=sub_id" json:"sub_id,omitempty"`
 418         SubIfFlags  interface_types.SubIfFlags     `binapi:"sub_if_flags,name=sub_if_flags" json:"sub_if_flags,omitempty"`
 419         OuterVlanID uint16                         `binapi:"u16,name=outer_vlan_id" json:"outer_vlan_id,omitempty"`
 420         InnerVlanID uint16                         `binapi:"u16,name=inner_vlan_id" json:"inner_vlan_id,omitempty"`
 421 }
 422
 423 func (m *CreateSubif) Reset()                        { *m = CreateSubif{} }
 424 func (*CreateSubif) GetMessageName() string          { return "create_subif" }
 425 func (*CreateSubif) GetCrcString() string            { return "cb371063" }
 426 func (*CreateSubif) GetMessageType() api.MessageType { return api.RequestMessage }
 427
 428 func (m *CreateSubif) Size() int {
 429         if m == nil {
 430                 return 0
 431         }
 432         var size int
 433         // field[1] m.SwIfIndex
 434         size += 4
 435         // field[1] m.SubID
 436         size += 4
 437         // field[1] m.SubIfFlags
 438         size += 4
 439         // field[1] m.OuterVlanID
 440         size += 2
 441         // field[1] m.InnerVlanID
 442         size += 2
 443         return size
 444 }
 445 func (m *CreateSubif) Marshal(b []byte) ([]byte, error) {
 446         o := binary.BigEndian
 447         _ = o
 448         pos := 0
 449         _ = pos
 450         var buf []byte
 451         if b == nil {
 452                 buf = make([]byte, m.Size())
 453         } else {
 454                 buf = b
 455         }
 456         // field[1] m.SwIfIndex
 457         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 458         pos += 4
 459         // field[1] m.SubID
 460         o.PutUint32(buf[pos:pos+4], uint32(m.SubID))
 461         pos += 4
 462         // field[1] m.SubIfFlags
 463         o.PutUint32(buf[pos:pos+4], uint32(m.SubIfFlags))
 464         pos += 4
 465         // field[1] m.OuterVlanID
 466         o.PutUint16(buf[pos:pos+2], uint16(m.OuterVlanID))
 467         pos += 2
 468         // field[1] m.InnerVlanID
 469         o.PutUint16(buf[pos:pos+2], uint16(m.InnerVlanID))
 470         pos += 2
 471         return buf, nil
 472 }
 473 func (m *CreateSubif) Unmarshal(tmp []byte) error {
 474         o := binary.BigEndian
 475         _ = o
 476         pos := 0
 477         _ = pos
 478         // field[1] m.SwIfIndex
 479         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 480         pos += 4
 481         // field[1] m.SubID
 482         m.SubID = uint32(o.Uint32(tmp[pos : pos+4]))
 483         pos += 4
 484         // field[1] m.SubIfFlags
 485         m.SubIfFlags = interface_types.SubIfFlags(o.Uint32(tmp[pos : pos+4]))
 486         pos += 4
 487         // field[1] m.OuterVlanID
 488         m.OuterVlanID = uint16(o.Uint16(tmp[pos : pos+2]))
 489         pos += 2
 490         // field[1] m.InnerVlanID
 491         m.InnerVlanID = uint16(o.Uint16(tmp[pos : pos+2]))
 492         pos += 2
 493         return nil
 494 }
 495
 496 // CreateSubifReply represents VPP binary API message 'create_subif_reply'.
 497 type CreateSubifReply struct {
 498         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 499         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 500 }
 501
 502 func (m *CreateSubifReply) Reset()                        { *m = CreateSubifReply{} }
 503 func (*CreateSubifReply) GetMessageName() string          { return "create_subif_reply" }
 504 func (*CreateSubifReply) GetCrcString() string            { return "5383d31f" }
 505 func (*CreateSubifReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 506
 507 func (m *CreateSubifReply) Size() int {
 508         if m == nil {
 509                 return 0
 510         }
 511         var size int
 512         // field[1] m.Retval
 513         size += 4
 514         // field[1] m.SwIfIndex
 515         size += 4
 516         return size
 517 }
 518 func (m *CreateSubifReply) Marshal(b []byte) ([]byte, error) {
 519         o := binary.BigEndian
 520         _ = o
 521         pos := 0
 522         _ = pos
 523         var buf []byte
 524         if b == nil {
 525                 buf = make([]byte, m.Size())
 526         } else {
 527                 buf = b
 528         }
 529         // field[1] m.Retval
 530         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 531         pos += 4
 532         // field[1] m.SwIfIndex
 533         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 534         pos += 4
 535         return buf, nil
 536 }
 537 func (m *CreateSubifReply) Unmarshal(tmp []byte) error {
 538         o := binary.BigEndian
 539         _ = o
 540         pos := 0
 541         _ = pos
 542         // field[1] m.Retval
 543         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 544         pos += 4
 545         // field[1] m.SwIfIndex
 546         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 547         pos += 4
 548         return nil
 549 }
 550
 551 // CreateVlanSubif represents VPP binary API message 'create_vlan_subif'.
 552 type CreateVlanSubif struct {
 553         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 554         VlanID    uint32                         `binapi:"u32,name=vlan_id" json:"vlan_id,omitempty"`
 555 }
 556
 557 func (m *CreateVlanSubif) Reset()                        { *m = CreateVlanSubif{} }
 558 func (*CreateVlanSubif) GetMessageName() string          { return "create_vlan_subif" }
 559 func (*CreateVlanSubif) GetCrcString() string            { return "af34ac8b" }
 560 func (*CreateVlanSubif) GetMessageType() api.MessageType { return api.RequestMessage }
 561
 562 func (m *CreateVlanSubif) Size() int {
 563         if m == nil {
 564                 return 0
 565         }
 566         var size int
 567         // field[1] m.SwIfIndex
 568         size += 4
 569         // field[1] m.VlanID
 570         size += 4
 571         return size
 572 }
 573 func (m *CreateVlanSubif) Marshal(b []byte) ([]byte, error) {
 574         o := binary.BigEndian
 575         _ = o
 576         pos := 0
 577         _ = pos
 578         var buf []byte
 579         if b == nil {
 580                 buf = make([]byte, m.Size())
 581         } else {
 582                 buf = b
 583         }
 584         // field[1] m.SwIfIndex
 585         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 586         pos += 4
 587         // field[1] m.VlanID
 588         o.PutUint32(buf[pos:pos+4], uint32(m.VlanID))
 589         pos += 4
 590         return buf, nil
 591 }
 592 func (m *CreateVlanSubif) Unmarshal(tmp []byte) error {
 593         o := binary.BigEndian
 594         _ = o
 595         pos := 0
 596         _ = pos
 597         // field[1] m.SwIfIndex
 598         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 599         pos += 4
 600         // field[1] m.VlanID
 601         m.VlanID = uint32(o.Uint32(tmp[pos : pos+4]))
 602         pos += 4
 603         return nil
 604 }
 605
 606 // CreateVlanSubifReply represents VPP binary API message 'create_vlan_subif_reply'.
 607 type CreateVlanSubifReply struct {
 608         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 609         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 610 }
 611
 612 func (m *CreateVlanSubifReply) Reset()                        { *m = CreateVlanSubifReply{} }
 613 func (*CreateVlanSubifReply) GetMessageName() string          { return "create_vlan_subif_reply" }
 614 func (*CreateVlanSubifReply) GetCrcString() string            { return "5383d31f" }
 615 func (*CreateVlanSubifReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 616
 617 func (m *CreateVlanSubifReply) Size() int {
 618         if m == nil {
 619                 return 0
 620         }
 621         var size int
 622         // field[1] m.Retval
 623         size += 4
 624         // field[1] m.SwIfIndex
 625         size += 4
 626         return size
 627 }
 628 func (m *CreateVlanSubifReply) 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.Retval
 640         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 641         pos += 4
 642         // field[1] m.SwIfIndex
 643         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 644         pos += 4
 645         return buf, nil
 646 }
 647 func (m *CreateVlanSubifReply) Unmarshal(tmp []byte) error {
 648         o := binary.BigEndian
 649         _ = o
 650         pos := 0
 651         _ = pos
 652         // field[1] m.Retval
 653         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 654         pos += 4
 655         // field[1] m.SwIfIndex
 656         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 657         pos += 4
 658         return nil
 659 }
 660
 661 // DeleteLoopback represents VPP binary API message 'delete_loopback'.
 662 type DeleteLoopback struct {
 663         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 664 }
 665
 666 func (m *DeleteLoopback) Reset()                        { *m = DeleteLoopback{} }
 667 func (*DeleteLoopback) GetMessageName() string          { return "delete_loopback" }
 668 func (*DeleteLoopback) GetCrcString() string            { return "f9e6675e" }
 669 func (*DeleteLoopback) GetMessageType() api.MessageType { return api.RequestMessage }
 670
 671 func (m *DeleteLoopback) Size() int {
 672         if m == nil {
 673                 return 0
 674         }
 675         var size int
 676         // field[1] m.SwIfIndex
 677         size += 4
 678         return size
 679 }
 680 func (m *DeleteLoopback) Marshal(b []byte) ([]byte, error) {
 681         o := binary.BigEndian
 682         _ = o
 683         pos := 0
 684         _ = pos
 685         var buf []byte
 686         if b == nil {
 687                 buf = make([]byte, m.Size())
 688         } else {
 689                 buf = b
 690         }
 691         // field[1] m.SwIfIndex
 692         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 693         pos += 4
 694         return buf, nil
 695 }
 696 func (m *DeleteLoopback) Unmarshal(tmp []byte) error {
 697         o := binary.BigEndian
 698         _ = o
 699         pos := 0
 700         _ = pos
 701         // field[1] m.SwIfIndex
 702         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 703         pos += 4
 704         return nil
 705 }
 706
 707 // DeleteLoopbackReply represents VPP binary API message 'delete_loopback_reply'.
 708 type DeleteLoopbackReply struct {
 709         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 710 }
 711
 712 func (m *DeleteLoopbackReply) Reset()                        { *m = DeleteLoopbackReply{} }
 713 func (*DeleteLoopbackReply) GetMessageName() string          { return "delete_loopback_reply" }
 714 func (*DeleteLoopbackReply) GetCrcString() string            { return "e8d4e804" }
 715 func (*DeleteLoopbackReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 716
 717 func (m *DeleteLoopbackReply) Size() int {
 718         if m == nil {
 719                 return 0
 720         }
 721         var size int
 722         // field[1] m.Retval
 723         size += 4
 724         return size
 725 }
 726 func (m *DeleteLoopbackReply) Marshal(b []byte) ([]byte, error) {
 727         o := binary.BigEndian
 728         _ = o
 729         pos := 0
 730         _ = pos
 731         var buf []byte
 732         if b == nil {
 733                 buf = make([]byte, m.Size())
 734         } else {
 735                 buf = b
 736         }
 737         // field[1] m.Retval
 738         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 739         pos += 4
 740         return buf, nil
 741 }
 742 func (m *DeleteLoopbackReply) Unmarshal(tmp []byte) error {
 743         o := binary.BigEndian
 744         _ = o
 745         pos := 0
 746         _ = pos
 747         // field[1] m.Retval
 748         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 749         pos += 4
 750         return nil
 751 }
 752
 753 // DeleteSubif represents VPP binary API message 'delete_subif'.
 754 type DeleteSubif struct {
 755         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 756 }
 757
 758 func (m *DeleteSubif) Reset()                        { *m = DeleteSubif{} }
 759 func (*DeleteSubif) GetMessageName() string          { return "delete_subif" }
 760 func (*DeleteSubif) GetCrcString() string            { return "f9e6675e" }
 761 func (*DeleteSubif) GetMessageType() api.MessageType { return api.RequestMessage }
 762
 763 func (m *DeleteSubif) Size() int {
 764         if m == nil {
 765                 return 0
 766         }
 767         var size int
 768         // field[1] m.SwIfIndex
 769         size += 4
 770         return size
 771 }
 772 func (m *DeleteSubif) Marshal(b []byte) ([]byte, error) {
 773         o := binary.BigEndian
 774         _ = o
 775         pos := 0
 776         _ = pos
 777         var buf []byte
 778         if b == nil {
 779                 buf = make([]byte, m.Size())
 780         } else {
 781                 buf = b
 782         }
 783         // field[1] m.SwIfIndex
 784         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 785         pos += 4
 786         return buf, nil
 787 }
 788 func (m *DeleteSubif) Unmarshal(tmp []byte) error {
 789         o := binary.BigEndian
 790         _ = o
 791         pos := 0
 792         _ = pos
 793         // field[1] m.SwIfIndex
 794         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 795         pos += 4
 796         return nil
 797 }
 798
 799 // DeleteSubifReply represents VPP binary API message 'delete_subif_reply'.
 800 type DeleteSubifReply struct {
 801         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 802 }
 803
 804 func (m *DeleteSubifReply) Reset()                        { *m = DeleteSubifReply{} }
 805 func (*DeleteSubifReply) GetMessageName() string          { return "delete_subif_reply" }
 806 func (*DeleteSubifReply) GetCrcString() string            { return "e8d4e804" }
 807 func (*DeleteSubifReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 808
 809 func (m *DeleteSubifReply) Size() int {
 810         if m == nil {
 811                 return 0
 812         }
 813         var size int
 814         // field[1] m.Retval
 815         size += 4
 816         return size
 817 }
 818 func (m *DeleteSubifReply) Marshal(b []byte) ([]byte, error) {
 819         o := binary.BigEndian
 820         _ = o
 821         pos := 0
 822         _ = pos
 823         var buf []byte
 824         if b == nil {
 825                 buf = make([]byte, m.Size())
 826         } else {
 827                 buf = b
 828         }
 829         // field[1] m.Retval
 830         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 831         pos += 4
 832         return buf, nil
 833 }
 834 func (m *DeleteSubifReply) Unmarshal(tmp []byte) error {
 835         o := binary.BigEndian
 836         _ = o
 837         pos := 0
 838         _ = pos
 839         // field[1] m.Retval
 840         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 841         pos += 4
 842         return nil
 843 }
 844
 845 // HwInterfaceSetMtu represents VPP binary API message 'hw_interface_set_mtu'.
 846 type HwInterfaceSetMtu struct {
 847         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 848         Mtu       uint16                         `binapi:"u16,name=mtu" json:"mtu,omitempty"`
 849 }
 850
 851 func (m *HwInterfaceSetMtu) Reset()                        { *m = HwInterfaceSetMtu{} }
 852 func (*HwInterfaceSetMtu) GetMessageName() string          { return "hw_interface_set_mtu" }
 853 func (*HwInterfaceSetMtu) GetCrcString() string            { return "e6746899" }
 854 func (*HwInterfaceSetMtu) GetMessageType() api.MessageType { return api.RequestMessage }
 855
 856 func (m *HwInterfaceSetMtu) Size() int {
 857         if m == nil {
 858                 return 0
 859         }
 860         var size int
 861         // field[1] m.SwIfIndex
 862         size += 4
 863         // field[1] m.Mtu
 864         size += 2
 865         return size
 866 }
 867 func (m *HwInterfaceSetMtu) Marshal(b []byte) ([]byte, error) {
 868         o := binary.BigEndian
 869         _ = o
 870         pos := 0
 871         _ = pos
 872         var buf []byte
 873         if b == nil {
 874                 buf = make([]byte, m.Size())
 875         } else {
 876                 buf = b
 877         }
 878         // field[1] m.SwIfIndex
 879         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 880         pos += 4
 881         // field[1] m.Mtu
 882         o.PutUint16(buf[pos:pos+2], uint16(m.Mtu))
 883         pos += 2
 884         return buf, nil
 885 }
 886 func (m *HwInterfaceSetMtu) Unmarshal(tmp []byte) error {
 887         o := binary.BigEndian
 888         _ = o
 889         pos := 0
 890         _ = pos
 891         // field[1] m.SwIfIndex
 892         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 893         pos += 4
 894         // field[1] m.Mtu
 895         m.Mtu = uint16(o.Uint16(tmp[pos : pos+2]))
 896         pos += 2
 897         return nil
 898 }
 899
 900 // HwInterfaceSetMtuReply represents VPP binary API message 'hw_interface_set_mtu_reply'.
 901 type HwInterfaceSetMtuReply struct {
 902         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 903 }
 904
 905 func (m *HwInterfaceSetMtuReply) Reset()                        { *m = HwInterfaceSetMtuReply{} }
 906 func (*HwInterfaceSetMtuReply) GetMessageName() string          { return "hw_interface_set_mtu_reply" }
 907 func (*HwInterfaceSetMtuReply) GetCrcString() string            { return "e8d4e804" }
 908 func (*HwInterfaceSetMtuReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 909
 910 func (m *HwInterfaceSetMtuReply) Size() int {
 911         if m == nil {
 912                 return 0
 913         }
 914         var size int
 915         // field[1] m.Retval
 916         size += 4
 917         return size
 918 }
 919 func (m *HwInterfaceSetMtuReply) Marshal(b []byte) ([]byte, error) {
 920         o := binary.BigEndian
 921         _ = o
 922         pos := 0
 923         _ = pos
 924         var buf []byte
 925         if b == nil {
 926                 buf = make([]byte, m.Size())
 927         } else {
 928                 buf = b
 929         }
 930         // field[1] m.Retval
 931         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 932         pos += 4
 933         return buf, nil
 934 }
 935 func (m *HwInterfaceSetMtuReply) Unmarshal(tmp []byte) error {
 936         o := binary.BigEndian
 937         _ = o
 938         pos := 0
 939         _ = pos
 940         // field[1] m.Retval
 941         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 942         pos += 4
 943         return nil
 944 }
 945
 946 // InterfaceNameRenumber represents VPP binary API message 'interface_name_renumber'.
 947 type InterfaceNameRenumber struct {
 948         SwIfIndex          interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 949         NewShowDevInstance uint32                         `binapi:"u32,name=new_show_dev_instance" json:"new_show_dev_instance,omitempty"`
 950 }
 951
 952 func (m *InterfaceNameRenumber) Reset()                        { *m = InterfaceNameRenumber{} }
 953 func (*InterfaceNameRenumber) GetMessageName() string          { return "interface_name_renumber" }
 954 func (*InterfaceNameRenumber) GetCrcString() string            { return "2b8858b8" }
 955 func (*InterfaceNameRenumber) GetMessageType() api.MessageType { return api.RequestMessage }
 956
 957 func (m *InterfaceNameRenumber) Size() int {
 958         if m == nil {
 959                 return 0
 960         }
 961         var size int
 962         // field[1] m.SwIfIndex
 963         size += 4
 964         // field[1] m.NewShowDevInstance
 965         size += 4
 966         return size
 967 }
 968 func (m *InterfaceNameRenumber) Marshal(b []byte) ([]byte, error) {
 969         o := binary.BigEndian
 970         _ = o
 971         pos := 0
 972         _ = pos
 973         var buf []byte
 974         if b == nil {
 975                 buf = make([]byte, m.Size())
 976         } else {
 977                 buf = b
 978         }
 979         // field[1] m.SwIfIndex
 980         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 981         pos += 4
 982         // field[1] m.NewShowDevInstance
 983         o.PutUint32(buf[pos:pos+4], uint32(m.NewShowDevInstance))
 984         pos += 4
 985         return buf, nil
 986 }
 987 func (m *InterfaceNameRenumber) Unmarshal(tmp []byte) error {
 988         o := binary.BigEndian
 989         _ = o
 990         pos := 0
 991         _ = pos
 992         // field[1] m.SwIfIndex
 993         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 994         pos += 4
 995         // field[1] m.NewShowDevInstance
 996         m.NewShowDevInstance = uint32(o.Uint32(tmp[pos : pos+4]))
 997         pos += 4
 998         return nil
 999 }
1000
1001 // InterfaceNameRenumberReply represents VPP binary API message 'interface_name_renumber_reply'.
1002 type InterfaceNameRenumberReply struct {
1003         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1004 }
1005
1006 func (m *InterfaceNameRenumberReply) Reset()                        { *m = InterfaceNameRenumberReply{} }
1007 func (*InterfaceNameRenumberReply) GetMessageName() string          { return "interface_name_renumber_reply" }
1008 func (*InterfaceNameRenumberReply) GetCrcString() string            { return "e8d4e804" }
1009 func (*InterfaceNameRenumberReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1010
1011 func (m *InterfaceNameRenumberReply) Size() int {
1012         if m == nil {
1013                 return 0
1014         }
1015         var size int
1016         // field[1] m.Retval
1017         size += 4
1018         return size
1019 }
1020 func (m *InterfaceNameRenumberReply) Marshal(b []byte) ([]byte, error) {
1021         o := binary.BigEndian
1022         _ = o
1023         pos := 0
1024         _ = pos
1025         var buf []byte
1026         if b == nil {
1027                 buf = make([]byte, m.Size())
1028         } else {
1029                 buf = b
1030         }
1031         // field[1] m.Retval
1032         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1033         pos += 4
1034         return buf, nil
1035 }
1036 func (m *InterfaceNameRenumberReply) Unmarshal(tmp []byte) error {
1037         o := binary.BigEndian
1038         _ = o
1039         pos := 0
1040         _ = pos
1041         // field[1] m.Retval
1042         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1043         pos += 4
1044         return nil
1045 }
1046
1047 // SwInterfaceAddDelAddress represents VPP binary API message 'sw_interface_add_del_address'.
1048 type SwInterfaceAddDelAddress struct {
1049         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1050         IsAdd     bool                           `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1051         DelAll    bool                           `binapi:"bool,name=del_all" json:"del_all,omitempty"`
1052         Prefix    ip_types.AddressWithPrefix     `binapi:"address_with_prefix,name=prefix" json:"prefix,omitempty"`
1053 }
1054
1055 func (m *SwInterfaceAddDelAddress) Reset()                        { *m = SwInterfaceAddDelAddress{} }
1056 func (*SwInterfaceAddDelAddress) GetMessageName() string          { return "sw_interface_add_del_address" }
1057 func (*SwInterfaceAddDelAddress) GetCrcString() string            { return "5803d5c4" }
1058 func (*SwInterfaceAddDelAddress) GetMessageType() api.MessageType { return api.RequestMessage }
1059
1060 func (m *SwInterfaceAddDelAddress) Size() int {
1061         if m == nil {
1062                 return 0
1063         }
1064         var size int
1065         // field[1] m.SwIfIndex
1066         size += 4
1067         // field[1] m.IsAdd
1068         size += 1
1069         // field[1] m.DelAll
1070         size += 1
1071         // field[1] m.Prefix
1072         // field[2] m.Prefix.Address
1073         // field[3] m.Prefix.Address.Af
1074         size += 1
1075         // field[3] m.Prefix.Address.Un
1076         size += 16
1077         // field[2] m.Prefix.Len
1078         size += 1
1079         return size
1080 }
1081 func (m *SwInterfaceAddDelAddress) Marshal(b []byte) ([]byte, error) {
1082         o := binary.BigEndian
1083         _ = o
1084         pos := 0
1085         _ = pos
1086         var buf []byte
1087         if b == nil {
1088                 buf = make([]byte, m.Size())
1089         } else {
1090                 buf = b
1091         }
1092         // field[1] m.SwIfIndex
1093         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1094         pos += 4
1095         // field[1] m.IsAdd
1096         if m.IsAdd {
1097                 buf[pos] = 1
1098         }
1099         pos += 1
1100         // field[1] m.DelAll
1101         if m.DelAll {
1102                 buf[pos] = 1
1103         }
1104         pos += 1
1105         // field[1] m.Prefix
1106         // field[2] m.Prefix.Address
1107         // field[3] m.Prefix.Address.Af
1108         buf[pos] = uint8(m.Prefix.Address.Af)
1109         pos += 1
1110         // field[3] m.Prefix.Address.Un
1111         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
1112         pos += 16
1113         // field[2] m.Prefix.Len
1114         buf[pos] = uint8(m.Prefix.Len)
1115         pos += 1
1116         return buf, nil
1117 }
1118 func (m *SwInterfaceAddDelAddress) Unmarshal(tmp []byte) error {
1119         o := binary.BigEndian
1120         _ = o
1121         pos := 0
1122         _ = pos
1123         // field[1] m.SwIfIndex
1124         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1125         pos += 4
1126         // field[1] m.IsAdd
1127         m.IsAdd = tmp[pos] != 0
1128         pos += 1
1129         // field[1] m.DelAll
1130         m.DelAll = tmp[pos] != 0
1131         pos += 1
1132         // field[1] m.Prefix
1133         // field[2] m.Prefix.Address
1134         // field[3] m.Prefix.Address.Af
1135         m.Prefix.Address.Af = ip_types.AddressFamily(tmp[pos])
1136         pos += 1
1137         // field[3] m.Prefix.Address.Un
1138         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
1139         pos += 16
1140         // field[2] m.Prefix.Len
1141         m.Prefix.Len = uint8(tmp[pos])
1142         pos += 1
1143         return nil
1144 }
1145
1146 // SwInterfaceAddDelAddressReply represents VPP binary API message 'sw_interface_add_del_address_reply'.
1147 type SwInterfaceAddDelAddressReply struct {
1148         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1149 }
1150
1151 func (m *SwInterfaceAddDelAddressReply) Reset() { *m = SwInterfaceAddDelAddressReply{} }
1152 func (*SwInterfaceAddDelAddressReply) GetMessageName() string {
1153         return "sw_interface_add_del_address_reply"
1154 }
1155 func (*SwInterfaceAddDelAddressReply) GetCrcString() string            { return "e8d4e804" }
1156 func (*SwInterfaceAddDelAddressReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1157
1158 func (m *SwInterfaceAddDelAddressReply) Size() int {
1159         if m == nil {
1160                 return 0
1161         }
1162         var size int
1163         // field[1] m.Retval
1164         size += 4
1165         return size
1166 }
1167 func (m *SwInterfaceAddDelAddressReply) Marshal(b []byte) ([]byte, error) {
1168         o := binary.BigEndian
1169         _ = o
1170         pos := 0
1171         _ = pos
1172         var buf []byte
1173         if b == nil {
1174                 buf = make([]byte, m.Size())
1175         } else {
1176                 buf = b
1177         }
1178         // field[1] m.Retval
1179         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1180         pos += 4
1181         return buf, nil
1182 }
1183 func (m *SwInterfaceAddDelAddressReply) Unmarshal(tmp []byte) error {
1184         o := binary.BigEndian
1185         _ = o
1186         pos := 0
1187         _ = pos
1188         // field[1] m.Retval
1189         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1190         pos += 4
1191         return nil
1192 }
1193
1194 // SwInterfaceAddDelMacAddress represents VPP binary API message 'sw_interface_add_del_mac_address'.
1195 type SwInterfaceAddDelMacAddress struct {
1196         SwIfIndex uint32     `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
1197         Addr      MacAddress `binapi:"mac_address,name=addr" json:"addr,omitempty"`
1198         IsAdd     uint8      `binapi:"u8,name=is_add" json:"is_add,omitempty"`
1199 }
1200
1201 func (m *SwInterfaceAddDelMacAddress) Reset() { *m = SwInterfaceAddDelMacAddress{} }
1202 func (*SwInterfaceAddDelMacAddress) GetMessageName() string {
1203         return "sw_interface_add_del_mac_address"
1204 }
1205 func (*SwInterfaceAddDelMacAddress) GetCrcString() string            { return "638bb9f4" }
1206 func (*SwInterfaceAddDelMacAddress) GetMessageType() api.MessageType { return api.RequestMessage }
1207
1208 func (m *SwInterfaceAddDelMacAddress) Size() int {
1209         if m == nil {
1210                 return 0
1211         }
1212         var size int
1213         // field[1] m.SwIfIndex
1214         size += 4
1215         // field[1] m.Addr
1216         size += 6
1217         // field[1] m.IsAdd
1218         size += 1
1219         return size
1220 }
1221 func (m *SwInterfaceAddDelMacAddress) Marshal(b []byte) ([]byte, error) {
1222         o := binary.BigEndian
1223         _ = o
1224         pos := 0
1225         _ = pos
1226         var buf []byte
1227         if b == nil {
1228                 buf = make([]byte, m.Size())
1229         } else {
1230                 buf = b
1231         }
1232         // field[1] m.SwIfIndex
1233         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1234         pos += 4
1235         // field[1] m.Addr
1236         for i := 0; i < 6; i++ {
1237                 var x uint8
1238                 if i < len(m.Addr) {
1239                         x = uint8(m.Addr[i])
1240                 }
1241                 buf[pos] = uint8(x)
1242                 pos += 1
1243         }
1244         // field[1] m.IsAdd
1245         buf[pos] = uint8(m.IsAdd)
1246         pos += 1
1247         return buf, nil
1248 }
1249 func (m *SwInterfaceAddDelMacAddress) Unmarshal(tmp []byte) error {
1250         o := binary.BigEndian
1251         _ = o
1252         pos := 0
1253         _ = pos
1254         // field[1] m.SwIfIndex
1255         m.SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1256         pos += 4
1257         // field[1] m.Addr
1258         for i := 0; i < len(m.Addr); i++ {
1259                 m.Addr[i] = uint8(tmp[pos])
1260                 pos += 1
1261         }
1262         // field[1] m.IsAdd
1263         m.IsAdd = uint8(tmp[pos])
1264         pos += 1
1265         return nil
1266 }
1267
1268 // SwInterfaceAddDelMacAddressReply represents VPP binary API message 'sw_interface_add_del_mac_address_reply'.
1269 type SwInterfaceAddDelMacAddressReply struct {
1270         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1271 }
1272
1273 func (m *SwInterfaceAddDelMacAddressReply) Reset() { *m = SwInterfaceAddDelMacAddressReply{} }
1274 func (*SwInterfaceAddDelMacAddressReply) GetMessageName() string {
1275         return "sw_interface_add_del_mac_address_reply"
1276 }
1277 func (*SwInterfaceAddDelMacAddressReply) GetCrcString() string            { return "e8d4e804" }
1278 func (*SwInterfaceAddDelMacAddressReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1279
1280 func (m *SwInterfaceAddDelMacAddressReply) Size() int {
1281         if m == nil {
1282                 return 0
1283         }
1284         var size int
1285         // field[1] m.Retval
1286         size += 4
1287         return size
1288 }
1289 func (m *SwInterfaceAddDelMacAddressReply) Marshal(b []byte) ([]byte, error) {
1290         o := binary.BigEndian
1291         _ = o
1292         pos := 0
1293         _ = pos
1294         var buf []byte
1295         if b == nil {
1296                 buf = make([]byte, m.Size())
1297         } else {
1298                 buf = b
1299         }
1300         // field[1] m.Retval
1301         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1302         pos += 4
1303         return buf, nil
1304 }
1305 func (m *SwInterfaceAddDelMacAddressReply) Unmarshal(tmp []byte) error {
1306         o := binary.BigEndian
1307         _ = o
1308         pos := 0
1309         _ = pos
1310         // field[1] m.Retval
1311         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1312         pos += 4
1313         return nil
1314 }
1315
1316 // SwInterfaceAddressReplaceBegin represents VPP binary API message 'sw_interface_address_replace_begin'.
1317 type SwInterfaceAddressReplaceBegin struct{}
1318
1319 func (m *SwInterfaceAddressReplaceBegin) Reset() { *m = SwInterfaceAddressReplaceBegin{} }
1320 func (*SwInterfaceAddressReplaceBegin) GetMessageName() string {
1321         return "sw_interface_address_replace_begin"
1322 }
1323 func (*SwInterfaceAddressReplaceBegin) GetCrcString() string            { return "51077d14" }
1324 func (*SwInterfaceAddressReplaceBegin) GetMessageType() api.MessageType { return api.RequestMessage }
1325
1326 func (m *SwInterfaceAddressReplaceBegin) Size() int {
1327         if m == nil {
1328                 return 0
1329         }
1330         var size int
1331         return size
1332 }
1333 func (m *SwInterfaceAddressReplaceBegin) Marshal(b []byte) ([]byte, error) {
1334         o := binary.BigEndian
1335         _ = o
1336         pos := 0
1337         _ = pos
1338         var buf []byte
1339         if b == nil {
1340                 buf = make([]byte, m.Size())
1341         } else {
1342                 buf = b
1343         }
1344         return buf, nil
1345 }
1346 func (m *SwInterfaceAddressReplaceBegin) Unmarshal(tmp []byte) error {
1347         o := binary.BigEndian
1348         _ = o
1349         pos := 0
1350         _ = pos
1351         return nil
1352 }
1353
1354 // SwInterfaceAddressReplaceBeginReply represents VPP binary API message 'sw_interface_address_replace_begin_reply'.
1355 type SwInterfaceAddressReplaceBeginReply struct {
1356         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1357 }
1358
1359 func (m *SwInterfaceAddressReplaceBeginReply) Reset() { *m = SwInterfaceAddressReplaceBeginReply{} }
1360 func (*SwInterfaceAddressReplaceBeginReply) GetMessageName() string {
1361         return "sw_interface_address_replace_begin_reply"
1362 }
1363 func (*SwInterfaceAddressReplaceBeginReply) GetCrcString() string            { return "e8d4e804" }
1364 func (*SwInterfaceAddressReplaceBeginReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1365
1366 func (m *SwInterfaceAddressReplaceBeginReply) Size() int {
1367         if m == nil {
1368                 return 0
1369         }
1370         var size int
1371         // field[1] m.Retval
1372         size += 4
1373         return size
1374 }
1375 func (m *SwInterfaceAddressReplaceBeginReply) Marshal(b []byte) ([]byte, error) {
1376         o := binary.BigEndian
1377         _ = o
1378         pos := 0
1379         _ = pos
1380         var buf []byte
1381         if b == nil {
1382                 buf = make([]byte, m.Size())
1383         } else {
1384                 buf = b
1385         }
1386         // field[1] m.Retval
1387         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1388         pos += 4
1389         return buf, nil
1390 }
1391 func (m *SwInterfaceAddressReplaceBeginReply) Unmarshal(tmp []byte) error {
1392         o := binary.BigEndian
1393         _ = o
1394         pos := 0
1395         _ = pos
1396         // field[1] m.Retval
1397         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1398         pos += 4
1399         return nil
1400 }
1401
1402 // SwInterfaceAddressReplaceEnd represents VPP binary API message 'sw_interface_address_replace_end'.
1403 type SwInterfaceAddressReplaceEnd struct{}
1404
1405 func (m *SwInterfaceAddressReplaceEnd) Reset() { *m = SwInterfaceAddressReplaceEnd{} }
1406 func (*SwInterfaceAddressReplaceEnd) GetMessageName() string {
1407         return "sw_interface_address_replace_end"
1408 }
1409 func (*SwInterfaceAddressReplaceEnd) GetCrcString() string            { return "51077d14" }
1410 func (*SwInterfaceAddressReplaceEnd) GetMessageType() api.MessageType { return api.RequestMessage }
1411
1412 func (m *SwInterfaceAddressReplaceEnd) Size() int {
1413         if m == nil {
1414                 return 0
1415         }
1416         var size int
1417         return size
1418 }
1419 func (m *SwInterfaceAddressReplaceEnd) Marshal(b []byte) ([]byte, error) {
1420         o := binary.BigEndian
1421         _ = o
1422         pos := 0
1423         _ = pos
1424         var buf []byte
1425         if b == nil {
1426                 buf = make([]byte, m.Size())
1427         } else {
1428                 buf = b
1429         }
1430         return buf, nil
1431 }
1432 func (m *SwInterfaceAddressReplaceEnd) Unmarshal(tmp []byte) error {
1433         o := binary.BigEndian
1434         _ = o
1435         pos := 0
1436         _ = pos
1437         return nil
1438 }
1439
1440 // SwInterfaceAddressReplaceEndReply represents VPP binary API message 'sw_interface_address_replace_end_reply'.
1441 type SwInterfaceAddressReplaceEndReply struct {
1442         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1443 }
1444
1445 func (m *SwInterfaceAddressReplaceEndReply) Reset() { *m = SwInterfaceAddressReplaceEndReply{} }
1446 func (*SwInterfaceAddressReplaceEndReply) GetMessageName() string {
1447         return "sw_interface_address_replace_end_reply"
1448 }
1449 func (*SwInterfaceAddressReplaceEndReply) GetCrcString() string            { return "e8d4e804" }
1450 func (*SwInterfaceAddressReplaceEndReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1451
1452 func (m *SwInterfaceAddressReplaceEndReply) Size() int {
1453         if m == nil {
1454                 return 0
1455         }
1456         var size int
1457         // field[1] m.Retval
1458         size += 4
1459         return size
1460 }
1461 func (m *SwInterfaceAddressReplaceEndReply) Marshal(b []byte) ([]byte, error) {
1462         o := binary.BigEndian
1463         _ = o
1464         pos := 0
1465         _ = pos
1466         var buf []byte
1467         if b == nil {
1468                 buf = make([]byte, m.Size())
1469         } else {
1470                 buf = b
1471         }
1472         // field[1] m.Retval
1473         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1474         pos += 4
1475         return buf, nil
1476 }
1477 func (m *SwInterfaceAddressReplaceEndReply) Unmarshal(tmp []byte) error {
1478         o := binary.BigEndian
1479         _ = o
1480         pos := 0
1481         _ = pos
1482         // field[1] m.Retval
1483         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1484         pos += 4
1485         return nil
1486 }
1487
1488 // SwInterfaceClearStats represents VPP binary API message 'sw_interface_clear_stats'.
1489 type SwInterfaceClearStats struct {
1490         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1491 }
1492
1493 func (m *SwInterfaceClearStats) Reset()                        { *m = SwInterfaceClearStats{} }
1494 func (*SwInterfaceClearStats) GetMessageName() string          { return "sw_interface_clear_stats" }
1495 func (*SwInterfaceClearStats) GetCrcString() string            { return "f9e6675e" }
1496 func (*SwInterfaceClearStats) GetMessageType() api.MessageType { return api.RequestMessage }
1497
1498 func (m *SwInterfaceClearStats) Size() int {
1499         if m == nil {
1500                 return 0
1501         }
1502         var size int
1503         // field[1] m.SwIfIndex
1504         size += 4
1505         return size
1506 }
1507 func (m *SwInterfaceClearStats) Marshal(b []byte) ([]byte, error) {
1508         o := binary.BigEndian
1509         _ = o
1510         pos := 0
1511         _ = pos
1512         var buf []byte
1513         if b == nil {
1514                 buf = make([]byte, m.Size())
1515         } else {
1516                 buf = b
1517         }
1518         // field[1] m.SwIfIndex
1519         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1520         pos += 4
1521         return buf, nil
1522 }
1523 func (m *SwInterfaceClearStats) Unmarshal(tmp []byte) error {
1524         o := binary.BigEndian
1525         _ = o
1526         pos := 0
1527         _ = pos
1528         // field[1] m.SwIfIndex
1529         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1530         pos += 4
1531         return nil
1532 }
1533
1534 // SwInterfaceClearStatsReply represents VPP binary API message 'sw_interface_clear_stats_reply'.
1535 type SwInterfaceClearStatsReply struct {
1536         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1537 }
1538
1539 func (m *SwInterfaceClearStatsReply) Reset()                        { *m = SwInterfaceClearStatsReply{} }
1540 func (*SwInterfaceClearStatsReply) GetMessageName() string          { return "sw_interface_clear_stats_reply" }
1541 func (*SwInterfaceClearStatsReply) GetCrcString() string            { return "e8d4e804" }
1542 func (*SwInterfaceClearStatsReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1543
1544 func (m *SwInterfaceClearStatsReply) Size() int {
1545         if m == nil {
1546                 return 0
1547         }
1548         var size int
1549         // field[1] m.Retval
1550         size += 4
1551         return size
1552 }
1553 func (m *SwInterfaceClearStatsReply) Marshal(b []byte) ([]byte, error) {
1554         o := binary.BigEndian
1555         _ = o
1556         pos := 0
1557         _ = pos
1558         var buf []byte
1559         if b == nil {
1560                 buf = make([]byte, m.Size())
1561         } else {
1562                 buf = b
1563         }
1564         // field[1] m.Retval
1565         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1566         pos += 4
1567         return buf, nil
1568 }
1569 func (m *SwInterfaceClearStatsReply) Unmarshal(tmp []byte) error {
1570         o := binary.BigEndian
1571         _ = o
1572         pos := 0
1573         _ = pos
1574         // field[1] m.Retval
1575         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1576         pos += 4
1577         return nil
1578 }
1579
1580 // SwInterfaceDetails represents VPP binary API message 'sw_interface_details'.
1581 type SwInterfaceDetails struct {
1582         SwIfIndex        interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1583         SupSwIfIndex     uint32                         `binapi:"u32,name=sup_sw_if_index" json:"sup_sw_if_index,omitempty"`
1584         L2Address        MacAddress                     `binapi:"mac_address,name=l2_address" json:"l2_address,omitempty"`
1585         Flags            interface_types.IfStatusFlags  `binapi:"if_status_flags,name=flags" json:"flags,omitempty"`
1586         Type             interface_types.IfType         `binapi:"if_type,name=type" json:"type,omitempty"`
1587         LinkDuplex       interface_types.LinkDuplex     `binapi:"link_duplex,name=link_duplex" json:"link_duplex,omitempty"`
1588         LinkSpeed        uint32                         `binapi:"u32,name=link_speed" json:"link_speed,omitempty"`
1589         LinkMtu          uint16                         `binapi:"u16,name=link_mtu" json:"link_mtu,omitempty"`
1590         Mtu              []uint32                       `binapi:"u32[4],name=mtu" json:"mtu,omitempty" struc:"[4]uint32"`
1591         SubID            uint32                         `binapi:"u32,name=sub_id" json:"sub_id,omitempty"`
1592         SubNumberOfTags  uint8                          `binapi:"u8,name=sub_number_of_tags" json:"sub_number_of_tags,omitempty"`
1593         SubOuterVlanID   uint16                         `binapi:"u16,name=sub_outer_vlan_id" json:"sub_outer_vlan_id,omitempty"`
1594         SubInnerVlanID   uint16                         `binapi:"u16,name=sub_inner_vlan_id" json:"sub_inner_vlan_id,omitempty"`
1595         SubIfFlags       interface_types.SubIfFlags     `binapi:"sub_if_flags,name=sub_if_flags" json:"sub_if_flags,omitempty"`
1596         VtrOp            uint32                         `binapi:"u32,name=vtr_op" json:"vtr_op,omitempty"`
1597         VtrPushDot1q     uint32                         `binapi:"u32,name=vtr_push_dot1q" json:"vtr_push_dot1q,omitempty"`
1598         VtrTag1          uint32                         `binapi:"u32,name=vtr_tag1" json:"vtr_tag1,omitempty"`
1599         VtrTag2          uint32                         `binapi:"u32,name=vtr_tag2" json:"vtr_tag2,omitempty"`
1600         OuterTag         uint16                         `binapi:"u16,name=outer_tag" json:"outer_tag,omitempty"`
1601         BDmac            MacAddress                     `binapi:"mac_address,name=b_dmac" json:"b_dmac,omitempty"`
1602         BSmac            MacAddress                     `binapi:"mac_address,name=b_smac" json:"b_smac,omitempty"`
1603         BVlanid          uint16                         `binapi:"u16,name=b_vlanid" json:"b_vlanid,omitempty"`
1604         ISid             uint32                         `binapi:"u32,name=i_sid" json:"i_sid,omitempty"`
1605         InterfaceName    string                         `binapi:"string[64],name=interface_name" json:"interface_name,omitempty" struc:"[64]byte"`
1606         InterfaceDevType string                         `binapi:"string[64],name=interface_dev_type" json:"interface_dev_type,omitempty" struc:"[64]byte"`
1607         Tag              string                         `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
1608 }
1609
1610 func (m *SwInterfaceDetails) Reset()                        { *m = SwInterfaceDetails{} }
1611 func (*SwInterfaceDetails) GetMessageName() string          { return "sw_interface_details" }
1612 func (*SwInterfaceDetails) GetCrcString() string            { return "17b69fa2" }
1613 func (*SwInterfaceDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1614
1615 func (m *SwInterfaceDetails) Size() int {
1616         if m == nil {
1617                 return 0
1618         }
1619         var size int
1620         // field[1] m.SwIfIndex
1621         size += 4
1622         // field[1] m.SupSwIfIndex
1623         size += 4
1624         // field[1] m.L2Address
1625         size += 6
1626         // field[1] m.Flags
1627         size += 4
1628         // field[1] m.Type
1629         size += 4
1630         // field[1] m.LinkDuplex
1631         size += 4
1632         // field[1] m.LinkSpeed
1633         size += 4
1634         // field[1] m.LinkMtu
1635         size += 2
1636         // field[1] m.Mtu
1637         size += 16
1638         // field[1] m.SubID
1639         size += 4
1640         // field[1] m.SubNumberOfTags
1641         size += 1
1642         // field[1] m.SubOuterVlanID
1643         size += 2
1644         // field[1] m.SubInnerVlanID
1645         size += 2
1646         // field[1] m.SubIfFlags
1647         size += 4
1648         // field[1] m.VtrOp
1649         size += 4
1650         // field[1] m.VtrPushDot1q
1651         size += 4
1652         // field[1] m.VtrTag1
1653         size += 4
1654         // field[1] m.VtrTag2
1655         size += 4
1656         // field[1] m.OuterTag
1657         size += 2
1658         // field[1] m.BDmac
1659         size += 6
1660         // field[1] m.BSmac
1661         size += 6
1662         // field[1] m.BVlanid
1663         size += 2
1664         // field[1] m.ISid
1665         size += 4
1666         // field[1] m.InterfaceName
1667         size += 64
1668         // field[1] m.InterfaceDevType
1669         size += 64
1670         // field[1] m.Tag
1671         size += 64
1672         return size
1673 }
1674 func (m *SwInterfaceDetails) Marshal(b []byte) ([]byte, error) {
1675         o := binary.BigEndian
1676         _ = o
1677         pos := 0
1678         _ = pos
1679         var buf []byte
1680         if b == nil {
1681                 buf = make([]byte, m.Size())
1682         } else {
1683                 buf = b
1684         }
1685         // field[1] m.SwIfIndex
1686         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1687         pos += 4
1688         // field[1] m.SupSwIfIndex
1689         o.PutUint32(buf[pos:pos+4], uint32(m.SupSwIfIndex))
1690         pos += 4
1691         // field[1] m.L2Address
1692         for i := 0; i < 6; i++ {
1693                 var x uint8
1694                 if i < len(m.L2Address) {
1695                         x = uint8(m.L2Address[i])
1696                 }
1697                 buf[pos] = uint8(x)
1698                 pos += 1
1699         }
1700         // field[1] m.Flags
1701         o.PutUint32(buf[pos:pos+4], uint32(m.Flags))
1702         pos += 4
1703         // field[1] m.Type
1704         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
1705         pos += 4
1706         // field[1] m.LinkDuplex
1707         o.PutUint32(buf[pos:pos+4], uint32(m.LinkDuplex))
1708         pos += 4
1709         // field[1] m.LinkSpeed
1710         o.PutUint32(buf[pos:pos+4], uint32(m.LinkSpeed))
1711         pos += 4
1712         // field[1] m.LinkMtu
1713         o.PutUint16(buf[pos:pos+2], uint16(m.LinkMtu))
1714         pos += 2
1715         // field[1] m.Mtu
1716         for i := 0; i < 4; i++ {
1717                 var x uint32
1718                 if i < len(m.Mtu) {
1719                         x = uint32(m.Mtu[i])
1720                 }
1721                 o.PutUint32(buf[pos:pos+4], uint32(x))
1722                 pos += 4
1723         }
1724         // field[1] m.SubID
1725         o.PutUint32(buf[pos:pos+4], uint32(m.SubID))
1726         pos += 4
1727         // field[1] m.SubNumberOfTags
1728         buf[pos] = uint8(m.SubNumberOfTags)
1729         pos += 1
1730         // field[1] m.SubOuterVlanID
1731         o.PutUint16(buf[pos:pos+2], uint16(m.SubOuterVlanID))
1732         pos += 2
1733         // field[1] m.SubInnerVlanID
1734         o.PutUint16(buf[pos:pos+2], uint16(m.SubInnerVlanID))
1735         pos += 2
1736         // field[1] m.SubIfFlags
1737         o.PutUint32(buf[pos:pos+4], uint32(m.SubIfFlags))
1738         pos += 4
1739         // field[1] m.VtrOp
1740         o.PutUint32(buf[pos:pos+4], uint32(m.VtrOp))
1741         pos += 4
1742         // field[1] m.VtrPushDot1q
1743         o.PutUint32(buf[pos:pos+4], uint32(m.VtrPushDot1q))
1744         pos += 4
1745         // field[1] m.VtrTag1
1746         o.PutUint32(buf[pos:pos+4], uint32(m.VtrTag1))
1747         pos += 4
1748         // field[1] m.VtrTag2
1749         o.PutUint32(buf[pos:pos+4], uint32(m.VtrTag2))
1750         pos += 4
1751         // field[1] m.OuterTag
1752         o.PutUint16(buf[pos:pos+2], uint16(m.OuterTag))
1753         pos += 2
1754         // field[1] m.BDmac
1755         for i := 0; i < 6; i++ {
1756                 var x uint8
1757                 if i < len(m.BDmac) {
1758                         x = uint8(m.BDmac[i])
1759                 }
1760                 buf[pos] = uint8(x)
1761                 pos += 1
1762         }
1763         // field[1] m.BSmac
1764         for i := 0; i < 6; i++ {
1765                 var x uint8
1766                 if i < len(m.BSmac) {
1767                         x = uint8(m.BSmac[i])
1768                 }
1769                 buf[pos] = uint8(x)
1770                 pos += 1
1771         }
1772         // field[1] m.BVlanid
1773         o.PutUint16(buf[pos:pos+2], uint16(m.BVlanid))
1774         pos += 2
1775         // field[1] m.ISid
1776         o.PutUint32(buf[pos:pos+4], uint32(m.ISid))
1777         pos += 4
1778         // field[1] m.InterfaceName
1779         copy(buf[pos:pos+64], m.InterfaceName)
1780         pos += 64
1781         // field[1] m.InterfaceDevType
1782         copy(buf[pos:pos+64], m.InterfaceDevType)
1783         pos += 64
1784         // field[1] m.Tag
1785         copy(buf[pos:pos+64], m.Tag)
1786         pos += 64
1787         return buf, nil
1788 }
1789 func (m *SwInterfaceDetails) Unmarshal(tmp []byte) error {
1790         o := binary.BigEndian
1791         _ = o
1792         pos := 0
1793         _ = pos
1794         // field[1] m.SwIfIndex
1795         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1796         pos += 4
1797         // field[1] m.SupSwIfIndex
1798         m.SupSwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1799         pos += 4
1800         // field[1] m.L2Address
1801         for i := 0; i < len(m.L2Address); i++ {
1802                 m.L2Address[i] = uint8(tmp[pos])
1803                 pos += 1
1804         }
1805         // field[1] m.Flags
1806         m.Flags = interface_types.IfStatusFlags(o.Uint32(tmp[pos : pos+4]))
1807         pos += 4
1808         // field[1] m.Type
1809         m.Type = interface_types.IfType(o.Uint32(tmp[pos : pos+4]))
1810         pos += 4
1811         // field[1] m.LinkDuplex
1812         m.LinkDuplex = interface_types.LinkDuplex(o.Uint32(tmp[pos : pos+4]))
1813         pos += 4
1814         // field[1] m.LinkSpeed
1815         m.LinkSpeed = uint32(o.Uint32(tmp[pos : pos+4]))
1816         pos += 4
1817         // field[1] m.LinkMtu
1818         m.LinkMtu = uint16(o.Uint16(tmp[pos : pos+2]))
1819         pos += 2
1820         // field[1] m.Mtu
1821         m.Mtu = make([]uint32, 4)
1822         for i := 0; i < len(m.Mtu); i++ {
1823                 m.Mtu[i] = uint32(o.Uint32(tmp[pos : pos+4]))
1824                 pos += 4
1825         }
1826         // field[1] m.SubID
1827         m.SubID = uint32(o.Uint32(tmp[pos : pos+4]))
1828         pos += 4
1829         // field[1] m.SubNumberOfTags
1830         m.SubNumberOfTags = uint8(tmp[pos])
1831         pos += 1
1832         // field[1] m.SubOuterVlanID
1833         m.SubOuterVlanID = uint16(o.Uint16(tmp[pos : pos+2]))
1834         pos += 2
1835         // field[1] m.SubInnerVlanID
1836         m.SubInnerVlanID = uint16(o.Uint16(tmp[pos : pos+2]))
1837         pos += 2
1838         // field[1] m.SubIfFlags
1839         m.SubIfFlags = interface_types.SubIfFlags(o.Uint32(tmp[pos : pos+4]))
1840         pos += 4
1841         // field[1] m.VtrOp
1842         m.VtrOp = uint32(o.Uint32(tmp[pos : pos+4]))
1843         pos += 4
1844         // field[1] m.VtrPushDot1q
1845         m.VtrPushDot1q = uint32(o.Uint32(tmp[pos : pos+4]))
1846         pos += 4
1847         // field[1] m.VtrTag1
1848         m.VtrTag1 = uint32(o.Uint32(tmp[pos : pos+4]))
1849         pos += 4
1850         // field[1] m.VtrTag2
1851         m.VtrTag2 = uint32(o.Uint32(tmp[pos : pos+4]))
1852         pos += 4
1853         // field[1] m.OuterTag
1854         m.OuterTag = uint16(o.Uint16(tmp[pos : pos+2]))
1855         pos += 2
1856         // field[1] m.BDmac
1857         for i := 0; i < len(m.BDmac); i++ {
1858                 m.BDmac[i] = uint8(tmp[pos])
1859                 pos += 1
1860         }
1861         // field[1] m.BSmac
1862         for i := 0; i < len(m.BSmac); i++ {
1863                 m.BSmac[i] = uint8(tmp[pos])
1864                 pos += 1
1865         }
1866         // field[1] m.BVlanid
1867         m.BVlanid = uint16(o.Uint16(tmp[pos : pos+2]))
1868         pos += 2
1869         // field[1] m.ISid
1870         m.ISid = uint32(o.Uint32(tmp[pos : pos+4]))
1871         pos += 4
1872         // field[1] m.InterfaceName
1873         {
1874                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1875                 m.InterfaceName = codec.DecodeString(tmp[pos : pos+nul])
1876                 pos += 64
1877         }
1878         // field[1] m.InterfaceDevType
1879         {
1880                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1881                 m.InterfaceDevType = codec.DecodeString(tmp[pos : pos+nul])
1882                 pos += 64
1883         }
1884         // field[1] m.Tag
1885         {
1886                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1887                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
1888                 pos += 64
1889         }
1890         return nil
1891 }
1892
1893 // SwInterfaceDump represents VPP binary API message 'sw_interface_dump'.
1894 type SwInterfaceDump struct {
1895         SwIfIndex         interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index,default=4.294967295e+09" json:"sw_if_index,omitempty"`
1896         NameFilterValid   bool                           `binapi:"bool,name=name_filter_valid" json:"name_filter_valid,omitempty"`
1897         XXX_NameFilterLen uint32                         `struc:"sizeof=NameFilter"`
1898         NameFilter        string                         `json:"name_filter,omitempty"`
1899 }
1900
1901 func (m *SwInterfaceDump) Reset()                        { *m = SwInterfaceDump{} }
1902 func (*SwInterfaceDump) GetMessageName() string          { return "sw_interface_dump" }
1903 func (*SwInterfaceDump) GetCrcString() string            { return "aa610c27" }
1904 func (*SwInterfaceDump) GetMessageType() api.MessageType { return api.RequestMessage }
1905
1906 func (m *SwInterfaceDump) Size() int {
1907         if m == nil {
1908                 return 0
1909         }
1910         var size int
1911         // field[1] m.SwIfIndex
1912         size += 4
1913         // field[1] m.NameFilterValid
1914         size += 1
1915         // field[1] m.NameFilter
1916         size += 4 + len(m.NameFilter)
1917         return size
1918 }
1919 func (m *SwInterfaceDump) Marshal(b []byte) ([]byte, error) {
1920         o := binary.BigEndian
1921         _ = o
1922         pos := 0
1923         _ = pos
1924         var buf []byte
1925         if b == nil {
1926                 buf = make([]byte, m.Size())
1927         } else {
1928                 buf = b
1929         }
1930         // field[1] m.SwIfIndex
1931         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1932         pos += 4
1933         // field[1] m.NameFilterValid
1934         if m.NameFilterValid {
1935                 buf[pos] = 1
1936         }
1937         pos += 1
1938         // field[1] m.NameFilter
1939         o.PutUint32(buf[pos:pos+4], uint32(len(m.NameFilter)))
1940         pos += 4
1941         copy(buf[pos:pos+len(m.NameFilter)], m.NameFilter[:])
1942         pos += len(m.NameFilter)
1943         return buf, nil
1944 }
1945 func (m *SwInterfaceDump) Unmarshal(tmp []byte) error {
1946         o := binary.BigEndian
1947         _ = o
1948         pos := 0
1949         _ = pos
1950         // field[1] m.SwIfIndex
1951         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1952         pos += 4
1953         // field[1] m.NameFilterValid
1954         m.NameFilterValid = tmp[pos] != 0
1955         pos += 1
1956         // field[1] m.NameFilter
1957         {
1958                 siz := o.Uint32(tmp[pos : pos+4])
1959                 pos += 4
1960                 m.NameFilter = codec.DecodeString(tmp[pos : pos+int(siz)])
1961                 pos += len(m.NameFilter)
1962         }
1963         return nil
1964 }
1965
1966 // SwInterfaceEvent represents VPP binary API message 'sw_interface_event'.
1967 type SwInterfaceEvent struct {
1968         PID       uint32                         `binapi:"u32,name=pid" json:"pid,omitempty"`
1969         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1970         Flags     interface_types.IfStatusFlags  `binapi:"if_status_flags,name=flags" json:"flags,omitempty"`
1971         Deleted   bool                           `binapi:"bool,name=deleted" json:"deleted,omitempty"`
1972 }
1973
1974 func (m *SwInterfaceEvent) Reset()                        { *m = SwInterfaceEvent{} }
1975 func (*SwInterfaceEvent) GetMessageName() string          { return "sw_interface_event" }
1976 func (*SwInterfaceEvent) GetCrcString() string            { return "f709f78d" }
1977 func (*SwInterfaceEvent) GetMessageType() api.MessageType { return api.EventMessage }
1978
1979 func (m *SwInterfaceEvent) Size() int {
1980         if m == nil {
1981                 return 0
1982         }
1983         var size int
1984         // field[1] m.PID
1985         size += 4
1986         // field[1] m.SwIfIndex
1987         size += 4
1988         // field[1] m.Flags
1989         size += 4
1990         // field[1] m.Deleted
1991         size += 1
1992         return size
1993 }
1994 func (m *SwInterfaceEvent) Marshal(b []byte) ([]byte, error) {
1995         o := binary.BigEndian
1996         _ = o
1997         pos := 0
1998         _ = pos
1999         var buf []byte
2000         if b == nil {
2001                 buf = make([]byte, m.Size())
2002         } else {
2003                 buf = b
2004         }
2005         // field[1] m.PID
2006         o.PutUint32(buf[pos:pos+4], uint32(m.PID))
2007         pos += 4
2008         // field[1] m.SwIfIndex
2009         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2010         pos += 4
2011         // field[1] m.Flags
2012         o.PutUint32(buf[pos:pos+4], uint32(m.Flags))
2013         pos += 4
2014         // field[1] m.Deleted
2015         if m.Deleted {
2016                 buf[pos] = 1
2017         }
2018         pos += 1
2019         return buf, nil
2020 }
2021 func (m *SwInterfaceEvent) Unmarshal(tmp []byte) error {
2022         o := binary.BigEndian
2023         _ = o
2024         pos := 0
2025         _ = pos
2026         // field[1] m.PID
2027         m.PID = uint32(o.Uint32(tmp[pos : pos+4]))
2028         pos += 4
2029         // field[1] m.SwIfIndex
2030         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2031         pos += 4
2032         // field[1] m.Flags
2033         m.Flags = interface_types.IfStatusFlags(o.Uint32(tmp[pos : pos+4]))
2034         pos += 4
2035         // field[1] m.Deleted
2036         m.Deleted = tmp[pos] != 0
2037         pos += 1
2038         return nil
2039 }
2040
2041 // SwInterfaceGetMacAddress represents VPP binary API message 'sw_interface_get_mac_address'.
2042 type SwInterfaceGetMacAddress struct {
2043         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2044 }
2045
2046 func (m *SwInterfaceGetMacAddress) Reset()                        { *m = SwInterfaceGetMacAddress{} }
2047 func (*SwInterfaceGetMacAddress) GetMessageName() string          { return "sw_interface_get_mac_address" }
2048 func (*SwInterfaceGetMacAddress) GetCrcString() string            { return "f9e6675e" }
2049 func (*SwInterfaceGetMacAddress) GetMessageType() api.MessageType { return api.RequestMessage }
2050
2051 func (m *SwInterfaceGetMacAddress) Size() int {
2052         if m == nil {
2053                 return 0
2054         }
2055         var size int
2056         // field[1] m.SwIfIndex
2057         size += 4
2058         return size
2059 }
2060 func (m *SwInterfaceGetMacAddress) Marshal(b []byte) ([]byte, error) {
2061         o := binary.BigEndian
2062         _ = o
2063         pos := 0
2064         _ = pos
2065         var buf []byte
2066         if b == nil {
2067                 buf = make([]byte, m.Size())
2068         } else {
2069                 buf = b
2070         }
2071         // field[1] m.SwIfIndex
2072         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2073         pos += 4
2074         return buf, nil
2075 }
2076 func (m *SwInterfaceGetMacAddress) Unmarshal(tmp []byte) error {
2077         o := binary.BigEndian
2078         _ = o
2079         pos := 0
2080         _ = pos
2081         // field[1] m.SwIfIndex
2082         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2083         pos += 4
2084         return nil
2085 }
2086
2087 // SwInterfaceGetMacAddressReply represents VPP binary API message 'sw_interface_get_mac_address_reply'.
2088 type SwInterfaceGetMacAddressReply struct {
2089         Retval     int32      `binapi:"i32,name=retval" json:"retval,omitempty"`
2090         MacAddress MacAddress `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
2091 }
2092
2093 func (m *SwInterfaceGetMacAddressReply) Reset() { *m = SwInterfaceGetMacAddressReply{} }
2094 func (*SwInterfaceGetMacAddressReply) GetMessageName() string {
2095         return "sw_interface_get_mac_address_reply"
2096 }
2097 func (*SwInterfaceGetMacAddressReply) GetCrcString() string            { return "40ef2c08" }
2098 func (*SwInterfaceGetMacAddressReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2099
2100 func (m *SwInterfaceGetMacAddressReply) Size() int {
2101         if m == nil {
2102                 return 0
2103         }
2104         var size int
2105         // field[1] m.Retval
2106         size += 4
2107         // field[1] m.MacAddress
2108         size += 6
2109         return size
2110 }
2111 func (m *SwInterfaceGetMacAddressReply) Marshal(b []byte) ([]byte, error) {
2112         o := binary.BigEndian
2113         _ = o
2114         pos := 0
2115         _ = pos
2116         var buf []byte
2117         if b == nil {
2118                 buf = make([]byte, m.Size())
2119         } else {
2120                 buf = b
2121         }
2122         // field[1] m.Retval
2123         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2124         pos += 4
2125         // field[1] m.MacAddress
2126         for i := 0; i < 6; i++ {
2127                 var x uint8
2128                 if i < len(m.MacAddress) {
2129                         x = uint8(m.MacAddress[i])
2130                 }
2131                 buf[pos] = uint8(x)
2132                 pos += 1
2133         }
2134         return buf, nil
2135 }
2136 func (m *SwInterfaceGetMacAddressReply) Unmarshal(tmp []byte) error {
2137         o := binary.BigEndian
2138         _ = o
2139         pos := 0
2140         _ = pos
2141         // field[1] m.Retval
2142         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2143         pos += 4
2144         // field[1] m.MacAddress
2145         for i := 0; i < len(m.MacAddress); i++ {
2146                 m.MacAddress[i] = uint8(tmp[pos])
2147                 pos += 1
2148         }
2149         return nil
2150 }
2151
2152 // SwInterfaceGetTable represents VPP binary API message 'sw_interface_get_table'.
2153 type SwInterfaceGetTable struct {
2154         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2155         IsIPv6    bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
2156 }
2157
2158 func (m *SwInterfaceGetTable) Reset()                        { *m = SwInterfaceGetTable{} }
2159 func (*SwInterfaceGetTable) GetMessageName() string          { return "sw_interface_get_table" }
2160 func (*SwInterfaceGetTable) GetCrcString() string            { return "2d033de4" }
2161 func (*SwInterfaceGetTable) GetMessageType() api.MessageType { return api.RequestMessage }
2162
2163 func (m *SwInterfaceGetTable) Size() int {
2164         if m == nil {
2165                 return 0
2166         }
2167         var size int
2168         // field[1] m.SwIfIndex
2169         size += 4
2170         // field[1] m.IsIPv6
2171         size += 1
2172         return size
2173 }
2174 func (m *SwInterfaceGetTable) Marshal(b []byte) ([]byte, error) {
2175         o := binary.BigEndian
2176         _ = o
2177         pos := 0
2178         _ = pos
2179         var buf []byte
2180         if b == nil {
2181                 buf = make([]byte, m.Size())
2182         } else {
2183                 buf = b
2184         }
2185         // field[1] m.SwIfIndex
2186         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2187         pos += 4
2188         // field[1] m.IsIPv6
2189         if m.IsIPv6 {
2190                 buf[pos] = 1
2191         }
2192         pos += 1
2193         return buf, nil
2194 }
2195 func (m *SwInterfaceGetTable) Unmarshal(tmp []byte) error {
2196         o := binary.BigEndian
2197         _ = o
2198         pos := 0
2199         _ = pos
2200         // field[1] m.SwIfIndex
2201         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2202         pos += 4
2203         // field[1] m.IsIPv6
2204         m.IsIPv6 = tmp[pos] != 0
2205         pos += 1
2206         return nil
2207 }
2208
2209 // SwInterfaceGetTableReply represents VPP binary API message 'sw_interface_get_table_reply'.
2210 type SwInterfaceGetTableReply struct {
2211         Retval int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2212         VrfID  uint32 `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
2213 }
2214
2215 func (m *SwInterfaceGetTableReply) Reset()                        { *m = SwInterfaceGetTableReply{} }
2216 func (*SwInterfaceGetTableReply) GetMessageName() string          { return "sw_interface_get_table_reply" }
2217 func (*SwInterfaceGetTableReply) GetCrcString() string            { return "a6eb0109" }
2218 func (*SwInterfaceGetTableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2219
2220 func (m *SwInterfaceGetTableReply) Size() int {
2221         if m == nil {
2222                 return 0
2223         }
2224         var size int
2225         // field[1] m.Retval
2226         size += 4
2227         // field[1] m.VrfID
2228         size += 4
2229         return size
2230 }
2231 func (m *SwInterfaceGetTableReply) Marshal(b []byte) ([]byte, error) {
2232         o := binary.BigEndian
2233         _ = o
2234         pos := 0
2235         _ = pos
2236         var buf []byte
2237         if b == nil {
2238                 buf = make([]byte, m.Size())
2239         } else {
2240                 buf = b
2241         }
2242         // field[1] m.Retval
2243         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2244         pos += 4
2245         // field[1] m.VrfID
2246         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
2247         pos += 4
2248         return buf, nil
2249 }
2250 func (m *SwInterfaceGetTableReply) Unmarshal(tmp []byte) error {
2251         o := binary.BigEndian
2252         _ = o
2253         pos := 0
2254         _ = pos
2255         // field[1] m.Retval
2256         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2257         pos += 4
2258         // field[1] m.VrfID
2259         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
2260         pos += 4
2261         return nil
2262 }
2263
2264 // SwInterfaceRxPlacementDetails represents VPP binary API message 'sw_interface_rx_placement_details'.
2265 type SwInterfaceRxPlacementDetails struct {
2266         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2267         QueueID   uint32                         `binapi:"u32,name=queue_id" json:"queue_id,omitempty"`
2268         WorkerID  uint32                         `binapi:"u32,name=worker_id" json:"worker_id,omitempty"`
2269         Mode      interface_types.RxMode         `binapi:"rx_mode,name=mode" json:"mode,omitempty"`
2270 }
2271
2272 func (m *SwInterfaceRxPlacementDetails) Reset() { *m = SwInterfaceRxPlacementDetails{} }
2273 func (*SwInterfaceRxPlacementDetails) GetMessageName() string {
2274         return "sw_interface_rx_placement_details"
2275 }
2276 func (*SwInterfaceRxPlacementDetails) GetCrcString() string            { return "f6d7d024" }
2277 func (*SwInterfaceRxPlacementDetails) GetMessageType() api.MessageType { return api.RequestMessage }
2278
2279 func (m *SwInterfaceRxPlacementDetails) Size() int {
2280         if m == nil {
2281                 return 0
2282         }
2283         var size int
2284         // field[1] m.SwIfIndex
2285         size += 4
2286         // field[1] m.QueueID
2287         size += 4
2288         // field[1] m.WorkerID
2289         size += 4
2290         // field[1] m.Mode
2291         size += 4
2292         return size
2293 }
2294 func (m *SwInterfaceRxPlacementDetails) Marshal(b []byte) ([]byte, error) {
2295         o := binary.BigEndian
2296         _ = o
2297         pos := 0
2298         _ = pos
2299         var buf []byte
2300         if b == nil {
2301                 buf = make([]byte, m.Size())
2302         } else {
2303                 buf = b
2304         }
2305         // field[1] m.SwIfIndex
2306         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2307         pos += 4
2308         // field[1] m.QueueID
2309         o.PutUint32(buf[pos:pos+4], uint32(m.QueueID))
2310         pos += 4
2311         // field[1] m.WorkerID
2312         o.PutUint32(buf[pos:pos+4], uint32(m.WorkerID))
2313         pos += 4
2314         // field[1] m.Mode
2315         o.PutUint32(buf[pos:pos+4], uint32(m.Mode))
2316         pos += 4
2317         return buf, nil
2318 }
2319 func (m *SwInterfaceRxPlacementDetails) Unmarshal(tmp []byte) error {
2320         o := binary.BigEndian
2321         _ = o
2322         pos := 0
2323         _ = pos
2324         // field[1] m.SwIfIndex
2325         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2326         pos += 4
2327         // field[1] m.QueueID
2328         m.QueueID = uint32(o.Uint32(tmp[pos : pos+4]))
2329         pos += 4
2330         // field[1] m.WorkerID
2331         m.WorkerID = uint32(o.Uint32(tmp[pos : pos+4]))
2332         pos += 4
2333         // field[1] m.Mode
2334         m.Mode = interface_types.RxMode(o.Uint32(tmp[pos : pos+4]))
2335         pos += 4
2336         return nil
2337 }
2338
2339 // SwInterfaceRxPlacementDump represents VPP binary API message 'sw_interface_rx_placement_dump'.
2340 type SwInterfaceRxPlacementDump struct {
2341         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2342 }
2343
2344 func (m *SwInterfaceRxPlacementDump) Reset()                        { *m = SwInterfaceRxPlacementDump{} }
2345 func (*SwInterfaceRxPlacementDump) GetMessageName() string          { return "sw_interface_rx_placement_dump" }
2346 func (*SwInterfaceRxPlacementDump) GetCrcString() string            { return "f9e6675e" }
2347 func (*SwInterfaceRxPlacementDump) GetMessageType() api.MessageType { return api.RequestMessage }
2348
2349 func (m *SwInterfaceRxPlacementDump) Size() int {
2350         if m == nil {
2351                 return 0
2352         }
2353         var size int
2354         // field[1] m.SwIfIndex
2355         size += 4
2356         return size
2357 }
2358 func (m *SwInterfaceRxPlacementDump) Marshal(b []byte) ([]byte, error) {
2359         o := binary.BigEndian
2360         _ = o
2361         pos := 0
2362         _ = pos
2363         var buf []byte
2364         if b == nil {
2365                 buf = make([]byte, m.Size())
2366         } else {
2367                 buf = b
2368         }
2369         // field[1] m.SwIfIndex
2370         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2371         pos += 4
2372         return buf, nil
2373 }
2374 func (m *SwInterfaceRxPlacementDump) Unmarshal(tmp []byte) error {
2375         o := binary.BigEndian
2376         _ = o
2377         pos := 0
2378         _ = pos
2379         // field[1] m.SwIfIndex
2380         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2381         pos += 4
2382         return nil
2383 }
2384
2385 // SwInterfaceSetFlags represents VPP binary API message 'sw_interface_set_flags'.
2386 type SwInterfaceSetFlags struct {
2387         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2388         Flags     interface_types.IfStatusFlags  `binapi:"if_status_flags,name=flags" json:"flags,omitempty"`
2389 }
2390
2391 func (m *SwInterfaceSetFlags) Reset()                        { *m = SwInterfaceSetFlags{} }
2392 func (*SwInterfaceSetFlags) GetMessageName() string          { return "sw_interface_set_flags" }
2393 func (*SwInterfaceSetFlags) GetCrcString() string            { return "6a2b491a" }
2394 func (*SwInterfaceSetFlags) GetMessageType() api.MessageType { return api.RequestMessage }
2395
2396 func (m *SwInterfaceSetFlags) Size() int {
2397         if m == nil {
2398                 return 0
2399         }
2400         var size int
2401         // field[1] m.SwIfIndex
2402         size += 4
2403         // field[1] m.Flags
2404         size += 4
2405         return size
2406 }
2407 func (m *SwInterfaceSetFlags) Marshal(b []byte) ([]byte, error) {
2408         o := binary.BigEndian
2409         _ = o
2410         pos := 0
2411         _ = pos
2412         var buf []byte
2413         if b == nil {
2414                 buf = make([]byte, m.Size())
2415         } else {
2416                 buf = b
2417         }
2418         // field[1] m.SwIfIndex
2419         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2420         pos += 4
2421         // field[1] m.Flags
2422         o.PutUint32(buf[pos:pos+4], uint32(m.Flags))
2423         pos += 4
2424         return buf, nil
2425 }
2426 func (m *SwInterfaceSetFlags) Unmarshal(tmp []byte) error {
2427         o := binary.BigEndian
2428         _ = o
2429         pos := 0
2430         _ = pos
2431         // field[1] m.SwIfIndex
2432         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2433         pos += 4
2434         // field[1] m.Flags
2435         m.Flags = interface_types.IfStatusFlags(o.Uint32(tmp[pos : pos+4]))
2436         pos += 4
2437         return nil
2438 }
2439
2440 // SwInterfaceSetFlagsReply represents VPP binary API message 'sw_interface_set_flags_reply'.
2441 type SwInterfaceSetFlagsReply struct {
2442         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2443 }
2444
2445 func (m *SwInterfaceSetFlagsReply) Reset()                        { *m = SwInterfaceSetFlagsReply{} }
2446 func (*SwInterfaceSetFlagsReply) GetMessageName() string          { return "sw_interface_set_flags_reply" }
2447 func (*SwInterfaceSetFlagsReply) GetCrcString() string            { return "e8d4e804" }
2448 func (*SwInterfaceSetFlagsReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2449
2450 func (m *SwInterfaceSetFlagsReply) Size() int {
2451         if m == nil {
2452                 return 0
2453         }
2454         var size int
2455         // field[1] m.Retval
2456         size += 4
2457         return size
2458 }
2459 func (m *SwInterfaceSetFlagsReply) Marshal(b []byte) ([]byte, error) {
2460         o := binary.BigEndian
2461         _ = o
2462         pos := 0
2463         _ = pos
2464         var buf []byte
2465         if b == nil {
2466                 buf = make([]byte, m.Size())
2467         } else {
2468                 buf = b
2469         }
2470         // field[1] m.Retval
2471         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2472         pos += 4
2473         return buf, nil
2474 }
2475 func (m *SwInterfaceSetFlagsReply) Unmarshal(tmp []byte) error {
2476         o := binary.BigEndian
2477         _ = o
2478         pos := 0
2479         _ = pos
2480         // field[1] m.Retval
2481         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2482         pos += 4
2483         return nil
2484 }
2485
2486 // SwInterfaceSetIPDirectedBroadcast represents VPP binary API message 'sw_interface_set_ip_directed_broadcast'.
2487 type SwInterfaceSetIPDirectedBroadcast struct {
2488         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2489         Enable    bool                           `binapi:"bool,name=enable" json:"enable,omitempty"`
2490 }
2491
2492 func (m *SwInterfaceSetIPDirectedBroadcast) Reset() { *m = SwInterfaceSetIPDirectedBroadcast{} }
2493 func (*SwInterfaceSetIPDirectedBroadcast) GetMessageName() string {
2494         return "sw_interface_set_ip_directed_broadcast"
2495 }
2496 func (*SwInterfaceSetIPDirectedBroadcast) GetCrcString() string            { return "ae6cfcfb" }
2497 func (*SwInterfaceSetIPDirectedBroadcast) GetMessageType() api.MessageType { return api.RequestMessage }
2498
2499 func (m *SwInterfaceSetIPDirectedBroadcast) Size() int {
2500         if m == nil {
2501                 return 0
2502         }
2503         var size int
2504         // field[1] m.SwIfIndex
2505         size += 4
2506         // field[1] m.Enable
2507         size += 1
2508         return size
2509 }
2510 func (m *SwInterfaceSetIPDirectedBroadcast) Marshal(b []byte) ([]byte, error) {
2511         o := binary.BigEndian
2512         _ = o
2513         pos := 0
2514         _ = pos
2515         var buf []byte
2516         if b == nil {
2517                 buf = make([]byte, m.Size())
2518         } else {
2519                 buf = b
2520         }
2521         // field[1] m.SwIfIndex
2522         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2523         pos += 4
2524         // field[1] m.Enable
2525         if m.Enable {
2526                 buf[pos] = 1
2527         }
2528         pos += 1
2529         return buf, nil
2530 }
2531 func (m *SwInterfaceSetIPDirectedBroadcast) Unmarshal(tmp []byte) error {
2532         o := binary.BigEndian
2533         _ = o
2534         pos := 0
2535         _ = pos
2536         // field[1] m.SwIfIndex
2537         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2538         pos += 4
2539         // field[1] m.Enable
2540         m.Enable = tmp[pos] != 0
2541         pos += 1
2542         return nil
2543 }
2544
2545 // SwInterfaceSetIPDirectedBroadcastReply represents VPP binary API message 'sw_interface_set_ip_directed_broadcast_reply'.
2546 type SwInterfaceSetIPDirectedBroadcastReply struct {
2547         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2548 }
2549
2550 func (m *SwInterfaceSetIPDirectedBroadcastReply) Reset() {
2551         *m = SwInterfaceSetIPDirectedBroadcastReply{}
2552 }
2553 func (*SwInterfaceSetIPDirectedBroadcastReply) GetMessageName() string {
2554         return "sw_interface_set_ip_directed_broadcast_reply"
2555 }
2556 func (*SwInterfaceSetIPDirectedBroadcastReply) GetCrcString() string { return "e8d4e804" }
2557 func (*SwInterfaceSetIPDirectedBroadcastReply) GetMessageType() api.MessageType {
2558         return api.ReplyMessage
2559 }
2560
2561 func (m *SwInterfaceSetIPDirectedBroadcastReply) Size() int {
2562         if m == nil {
2563                 return 0
2564         }
2565         var size int
2566         // field[1] m.Retval
2567         size += 4
2568         return size
2569 }
2570 func (m *SwInterfaceSetIPDirectedBroadcastReply) Marshal(b []byte) ([]byte, error) {
2571         o := binary.BigEndian
2572         _ = o
2573         pos := 0
2574         _ = pos
2575         var buf []byte
2576         if b == nil {
2577                 buf = make([]byte, m.Size())
2578         } else {
2579                 buf = b
2580         }
2581         // field[1] m.Retval
2582         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2583         pos += 4
2584         return buf, nil
2585 }
2586 func (m *SwInterfaceSetIPDirectedBroadcastReply) Unmarshal(tmp []byte) error {
2587         o := binary.BigEndian
2588         _ = o
2589         pos := 0
2590         _ = pos
2591         // field[1] m.Retval
2592         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2593         pos += 4
2594         return nil
2595 }
2596
2597 // SwInterfaceSetMacAddress represents VPP binary API message 'sw_interface_set_mac_address'.
2598 type SwInterfaceSetMacAddress struct {
2599         SwIfIndex  interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2600         MacAddress MacAddress                     `binapi:"mac_address,name=mac_address" json:"mac_address,omitempty"`
2601 }
2602
2603 func (m *SwInterfaceSetMacAddress) Reset()                        { *m = SwInterfaceSetMacAddress{} }
2604 func (*SwInterfaceSetMacAddress) GetMessageName() string          { return "sw_interface_set_mac_address" }
2605 func (*SwInterfaceSetMacAddress) GetCrcString() string            { return "6aca746a" }
2606 func (*SwInterfaceSetMacAddress) GetMessageType() api.MessageType { return api.RequestMessage }
2607
2608 func (m *SwInterfaceSetMacAddress) Size() int {
2609         if m == nil {
2610                 return 0
2611         }
2612         var size int
2613         // field[1] m.SwIfIndex
2614         size += 4
2615         // field[1] m.MacAddress
2616         size += 6
2617         return size
2618 }
2619 func (m *SwInterfaceSetMacAddress) Marshal(b []byte) ([]byte, error) {
2620         o := binary.BigEndian
2621         _ = o
2622         pos := 0
2623         _ = pos
2624         var buf []byte
2625         if b == nil {
2626                 buf = make([]byte, m.Size())
2627         } else {
2628                 buf = b
2629         }
2630         // field[1] m.SwIfIndex
2631         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2632         pos += 4
2633         // field[1] m.MacAddress
2634         for i := 0; i < 6; i++ {
2635                 var x uint8
2636                 if i < len(m.MacAddress) {
2637                         x = uint8(m.MacAddress[i])
2638                 }
2639                 buf[pos] = uint8(x)
2640                 pos += 1
2641         }
2642         return buf, nil
2643 }
2644 func (m *SwInterfaceSetMacAddress) Unmarshal(tmp []byte) error {
2645         o := binary.BigEndian
2646         _ = o
2647         pos := 0
2648         _ = pos
2649         // field[1] m.SwIfIndex
2650         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2651         pos += 4
2652         // field[1] m.MacAddress
2653         for i := 0; i < len(m.MacAddress); i++ {
2654                 m.MacAddress[i] = uint8(tmp[pos])
2655                 pos += 1
2656         }
2657         return nil
2658 }
2659
2660 // SwInterfaceSetMacAddressReply represents VPP binary API message 'sw_interface_set_mac_address_reply'.
2661 type SwInterfaceSetMacAddressReply struct {
2662         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2663 }
2664
2665 func (m *SwInterfaceSetMacAddressReply) Reset() { *m = SwInterfaceSetMacAddressReply{} }
2666 func (*SwInterfaceSetMacAddressReply) GetMessageName() string {
2667         return "sw_interface_set_mac_address_reply"
2668 }
2669 func (*SwInterfaceSetMacAddressReply) GetCrcString() string            { return "e8d4e804" }
2670 func (*SwInterfaceSetMacAddressReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2671
2672 func (m *SwInterfaceSetMacAddressReply) Size() int {
2673         if m == nil {
2674                 return 0
2675         }
2676         var size int
2677         // field[1] m.Retval
2678         size += 4
2679         return size
2680 }
2681 func (m *SwInterfaceSetMacAddressReply) Marshal(b []byte) ([]byte, error) {
2682         o := binary.BigEndian
2683         _ = o
2684         pos := 0
2685         _ = pos
2686         var buf []byte
2687         if b == nil {
2688                 buf = make([]byte, m.Size())
2689         } else {
2690                 buf = b
2691         }
2692         // field[1] m.Retval
2693         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2694         pos += 4
2695         return buf, nil
2696 }
2697 func (m *SwInterfaceSetMacAddressReply) Unmarshal(tmp []byte) error {
2698         o := binary.BigEndian
2699         _ = o
2700         pos := 0
2701         _ = pos
2702         // field[1] m.Retval
2703         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2704         pos += 4
2705         return nil
2706 }
2707
2708 // SwInterfaceSetMtu represents VPP binary API message 'sw_interface_set_mtu'.
2709 type SwInterfaceSetMtu struct {
2710         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2711         Mtu       []uint32                       `binapi:"u32[4],name=mtu" json:"mtu,omitempty" struc:"[4]uint32"`
2712 }
2713
2714 func (m *SwInterfaceSetMtu) Reset()                        { *m = SwInterfaceSetMtu{} }
2715 func (*SwInterfaceSetMtu) GetMessageName() string          { return "sw_interface_set_mtu" }
2716 func (*SwInterfaceSetMtu) GetCrcString() string            { return "5cbe85e5" }
2717 func (*SwInterfaceSetMtu) GetMessageType() api.MessageType { return api.RequestMessage }
2718
2719 func (m *SwInterfaceSetMtu) Size() int {
2720         if m == nil {
2721                 return 0
2722         }
2723         var size int
2724         // field[1] m.SwIfIndex
2725         size += 4
2726         // field[1] m.Mtu
2727         size += 16
2728         return size
2729 }
2730 func (m *SwInterfaceSetMtu) Marshal(b []byte) ([]byte, error) {
2731         o := binary.BigEndian
2732         _ = o
2733         pos := 0
2734         _ = pos
2735         var buf []byte
2736         if b == nil {
2737                 buf = make([]byte, m.Size())
2738         } else {
2739                 buf = b
2740         }
2741         // field[1] m.SwIfIndex
2742         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2743         pos += 4
2744         // field[1] m.Mtu
2745         for i := 0; i < 4; i++ {
2746                 var x uint32
2747                 if i < len(m.Mtu) {
2748                         x = uint32(m.Mtu[i])
2749                 }
2750                 o.PutUint32(buf[pos:pos+4], uint32(x))
2751                 pos += 4
2752         }
2753         return buf, nil
2754 }
2755 func (m *SwInterfaceSetMtu) Unmarshal(tmp []byte) error {
2756         o := binary.BigEndian
2757         _ = o
2758         pos := 0
2759         _ = pos
2760         // field[1] m.SwIfIndex
2761         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2762         pos += 4
2763         // field[1] m.Mtu
2764         m.Mtu = make([]uint32, 4)
2765         for i := 0; i < len(m.Mtu); i++ {
2766                 m.Mtu[i] = uint32(o.Uint32(tmp[pos : pos+4]))
2767                 pos += 4
2768         }
2769         return nil
2770 }
2771
2772 // SwInterfaceSetMtuReply represents VPP binary API message 'sw_interface_set_mtu_reply'.
2773 type SwInterfaceSetMtuReply struct {
2774         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2775 }
2776
2777 func (m *SwInterfaceSetMtuReply) Reset()                        { *m = SwInterfaceSetMtuReply{} }
2778 func (*SwInterfaceSetMtuReply) GetMessageName() string          { return "sw_interface_set_mtu_reply" }
2779 func (*SwInterfaceSetMtuReply) GetCrcString() string            { return "e8d4e804" }
2780 func (*SwInterfaceSetMtuReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2781
2782 func (m *SwInterfaceSetMtuReply) Size() int {
2783         if m == nil {
2784                 return 0
2785         }
2786         var size int
2787         // field[1] m.Retval
2788         size += 4
2789         return size
2790 }
2791 func (m *SwInterfaceSetMtuReply) Marshal(b []byte) ([]byte, error) {
2792         o := binary.BigEndian
2793         _ = o
2794         pos := 0
2795         _ = pos
2796         var buf []byte
2797         if b == nil {
2798                 buf = make([]byte, m.Size())
2799         } else {
2800                 buf = b
2801         }
2802         // field[1] m.Retval
2803         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2804         pos += 4
2805         return buf, nil
2806 }
2807 func (m *SwInterfaceSetMtuReply) Unmarshal(tmp []byte) error {
2808         o := binary.BigEndian
2809         _ = o
2810         pos := 0
2811         _ = pos
2812         // field[1] m.Retval
2813         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2814         pos += 4
2815         return nil
2816 }
2817
2818 // SwInterfaceSetRxMode represents VPP binary API message 'sw_interface_set_rx_mode'.
2819 type SwInterfaceSetRxMode struct {
2820         SwIfIndex    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2821         QueueIDValid bool                           `binapi:"bool,name=queue_id_valid" json:"queue_id_valid,omitempty"`
2822         QueueID      uint32                         `binapi:"u32,name=queue_id" json:"queue_id,omitempty"`
2823         Mode         interface_types.RxMode         `binapi:"rx_mode,name=mode" json:"mode,omitempty"`
2824 }
2825
2826 func (m *SwInterfaceSetRxMode) Reset()                        { *m = SwInterfaceSetRxMode{} }
2827 func (*SwInterfaceSetRxMode) GetMessageName() string          { return "sw_interface_set_rx_mode" }
2828 func (*SwInterfaceSetRxMode) GetCrcString() string            { return "780f5cee" }
2829 func (*SwInterfaceSetRxMode) GetMessageType() api.MessageType { return api.RequestMessage }
2830
2831 func (m *SwInterfaceSetRxMode) Size() int {
2832         if m == nil {
2833                 return 0
2834         }
2835         var size int
2836         // field[1] m.SwIfIndex
2837         size += 4
2838         // field[1] m.QueueIDValid
2839         size += 1
2840         // field[1] m.QueueID
2841         size += 4
2842         // field[1] m.Mode
2843         size += 4
2844         return size
2845 }
2846 func (m *SwInterfaceSetRxMode) Marshal(b []byte) ([]byte, error) {
2847         o := binary.BigEndian
2848         _ = o
2849         pos := 0
2850         _ = pos
2851         var buf []byte
2852         if b == nil {
2853                 buf = make([]byte, m.Size())
2854         } else {
2855                 buf = b
2856         }
2857         // field[1] m.SwIfIndex
2858         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2859         pos += 4
2860         // field[1] m.QueueIDValid
2861         if m.QueueIDValid {
2862                 buf[pos] = 1
2863         }
2864         pos += 1
2865         // field[1] m.QueueID
2866         o.PutUint32(buf[pos:pos+4], uint32(m.QueueID))
2867         pos += 4
2868         // field[1] m.Mode
2869         o.PutUint32(buf[pos:pos+4], uint32(m.Mode))
2870         pos += 4
2871         return buf, nil
2872 }
2873 func (m *SwInterfaceSetRxMode) Unmarshal(tmp []byte) error {
2874         o := binary.BigEndian
2875         _ = o
2876         pos := 0
2877         _ = pos
2878         // field[1] m.SwIfIndex
2879         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2880         pos += 4
2881         // field[1] m.QueueIDValid
2882         m.QueueIDValid = tmp[pos] != 0
2883         pos += 1
2884         // field[1] m.QueueID
2885         m.QueueID = uint32(o.Uint32(tmp[pos : pos+4]))
2886         pos += 4
2887         // field[1] m.Mode
2888         m.Mode = interface_types.RxMode(o.Uint32(tmp[pos : pos+4]))
2889         pos += 4
2890         return nil
2891 }
2892
2893 // SwInterfaceSetRxModeReply represents VPP binary API message 'sw_interface_set_rx_mode_reply'.
2894 type SwInterfaceSetRxModeReply struct {
2895         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2896 }
2897
2898 func (m *SwInterfaceSetRxModeReply) Reset()                        { *m = SwInterfaceSetRxModeReply{} }
2899 func (*SwInterfaceSetRxModeReply) GetMessageName() string          { return "sw_interface_set_rx_mode_reply" }
2900 func (*SwInterfaceSetRxModeReply) GetCrcString() string            { return "e8d4e804" }
2901 func (*SwInterfaceSetRxModeReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2902
2903 func (m *SwInterfaceSetRxModeReply) Size() int {
2904         if m == nil {
2905                 return 0
2906         }
2907         var size int
2908         // field[1] m.Retval
2909         size += 4
2910         return size
2911 }
2912 func (m *SwInterfaceSetRxModeReply) Marshal(b []byte) ([]byte, error) {
2913         o := binary.BigEndian
2914         _ = o
2915         pos := 0
2916         _ = pos
2917         var buf []byte
2918         if b == nil {
2919                 buf = make([]byte, m.Size())
2920         } else {
2921                 buf = b
2922         }
2923         // field[1] m.Retval
2924         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2925         pos += 4
2926         return buf, nil
2927 }
2928 func (m *SwInterfaceSetRxModeReply) Unmarshal(tmp []byte) error {
2929         o := binary.BigEndian
2930         _ = o
2931         pos := 0
2932         _ = pos
2933         // field[1] m.Retval
2934         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2935         pos += 4
2936         return nil
2937 }
2938
2939 // SwInterfaceSetRxPlacement represents VPP binary API message 'sw_interface_set_rx_placement'.
2940 type SwInterfaceSetRxPlacement struct {
2941         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2942         QueueID   uint32                         `binapi:"u32,name=queue_id" json:"queue_id,omitempty"`
2943         WorkerID  uint32                         `binapi:"u32,name=worker_id" json:"worker_id,omitempty"`
2944         IsMain    bool                           `binapi:"bool,name=is_main" json:"is_main,omitempty"`
2945 }
2946
2947 func (m *SwInterfaceSetRxPlacement) Reset()                        { *m = SwInterfaceSetRxPlacement{} }
2948 func (*SwInterfaceSetRxPlacement) GetMessageName() string          { return "sw_interface_set_rx_placement" }
2949 func (*SwInterfaceSetRxPlacement) GetCrcString() string            { return "db65f3c9" }
2950 func (*SwInterfaceSetRxPlacement) GetMessageType() api.MessageType { return api.RequestMessage }
2951
2952 func (m *SwInterfaceSetRxPlacement) Size() int {
2953         if m == nil {
2954                 return 0
2955         }
2956         var size int
2957         // field[1] m.SwIfIndex
2958         size += 4
2959         // field[1] m.QueueID
2960         size += 4
2961         // field[1] m.WorkerID
2962         size += 4
2963         // field[1] m.IsMain
2964         size += 1
2965         return size
2966 }
2967 func (m *SwInterfaceSetRxPlacement) Marshal(b []byte) ([]byte, error) {
2968         o := binary.BigEndian
2969         _ = o
2970         pos := 0
2971         _ = pos
2972         var buf []byte
2973         if b == nil {
2974                 buf = make([]byte, m.Size())
2975         } else {
2976                 buf = b
2977         }
2978         // field[1] m.SwIfIndex
2979         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2980         pos += 4
2981         // field[1] m.QueueID
2982         o.PutUint32(buf[pos:pos+4], uint32(m.QueueID))
2983         pos += 4
2984         // field[1] m.WorkerID
2985         o.PutUint32(buf[pos:pos+4], uint32(m.WorkerID))
2986         pos += 4
2987         // field[1] m.IsMain
2988         if m.IsMain {
2989                 buf[pos] = 1
2990         }
2991         pos += 1
2992         return buf, nil
2993 }
2994 func (m *SwInterfaceSetRxPlacement) Unmarshal(tmp []byte) error {
2995         o := binary.BigEndian
2996         _ = o
2997         pos := 0
2998         _ = pos
2999         // field[1] m.SwIfIndex
3000         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3001         pos += 4
3002         // field[1] m.QueueID
3003         m.QueueID = uint32(o.Uint32(tmp[pos : pos+4]))
3004         pos += 4
3005         // field[1] m.WorkerID
3006         m.WorkerID = uint32(o.Uint32(tmp[pos : pos+4]))
3007         pos += 4
3008         // field[1] m.IsMain
3009         m.IsMain = tmp[pos] != 0
3010         pos += 1
3011         return nil
3012 }
3013
3014 // SwInterfaceSetRxPlacementReply represents VPP binary API message 'sw_interface_set_rx_placement_reply'.
3015 type SwInterfaceSetRxPlacementReply struct {
3016         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3017 }
3018
3019 func (m *SwInterfaceSetRxPlacementReply) Reset() { *m = SwInterfaceSetRxPlacementReply{} }
3020 func (*SwInterfaceSetRxPlacementReply) GetMessageName() string {
3021         return "sw_interface_set_rx_placement_reply"
3022 }
3023 func (*SwInterfaceSetRxPlacementReply) GetCrcString() string            { return "e8d4e804" }
3024 func (*SwInterfaceSetRxPlacementReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3025
3026 func (m *SwInterfaceSetRxPlacementReply) Size() int {
3027         if m == nil {
3028                 return 0
3029         }
3030         var size int
3031         // field[1] m.Retval
3032         size += 4
3033         return size
3034 }
3035 func (m *SwInterfaceSetRxPlacementReply) Marshal(b []byte) ([]byte, error) {
3036         o := binary.BigEndian
3037         _ = o
3038         pos := 0
3039         _ = pos
3040         var buf []byte
3041         if b == nil {
3042                 buf = make([]byte, m.Size())
3043         } else {
3044                 buf = b
3045         }
3046         // field[1] m.Retval
3047         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3048         pos += 4
3049         return buf, nil
3050 }
3051 func (m *SwInterfaceSetRxPlacementReply) Unmarshal(tmp []byte) error {
3052         o := binary.BigEndian
3053         _ = o
3054         pos := 0
3055         _ = pos
3056         // field[1] m.Retval
3057         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3058         pos += 4
3059         return nil
3060 }
3061
3062 // SwInterfaceSetTable represents VPP binary API message 'sw_interface_set_table'.
3063 type SwInterfaceSetTable struct {
3064         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
3065         IsIPv6    bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
3066         VrfID     uint32                         `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
3067 }
3068
3069 func (m *SwInterfaceSetTable) Reset()                        { *m = SwInterfaceSetTable{} }
3070 func (*SwInterfaceSetTable) GetMessageName() string          { return "sw_interface_set_table" }
3071 func (*SwInterfaceSetTable) GetCrcString() string            { return "df42a577" }
3072 func (*SwInterfaceSetTable) GetMessageType() api.MessageType { return api.RequestMessage }
3073
3074 func (m *SwInterfaceSetTable) Size() int {
3075         if m == nil {
3076                 return 0
3077         }
3078         var size int
3079         // field[1] m.SwIfIndex
3080         size += 4
3081         // field[1] m.IsIPv6
3082         size += 1
3083         // field[1] m.VrfID
3084         size += 4
3085         return size
3086 }
3087 func (m *SwInterfaceSetTable) Marshal(b []byte) ([]byte, error) {
3088         o := binary.BigEndian
3089         _ = o
3090         pos := 0
3091         _ = pos
3092         var buf []byte
3093         if b == nil {
3094                 buf = make([]byte, m.Size())
3095         } else {
3096                 buf = b
3097         }
3098         // field[1] m.SwIfIndex
3099         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
3100         pos += 4
3101         // field[1] m.IsIPv6
3102         if m.IsIPv6 {
3103                 buf[pos] = 1
3104         }
3105         pos += 1
3106         // field[1] m.VrfID
3107         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
3108         pos += 4
3109         return buf, nil
3110 }
3111 func (m *SwInterfaceSetTable) Unmarshal(tmp []byte) error {
3112         o := binary.BigEndian
3113         _ = o
3114         pos := 0
3115         _ = pos
3116         // field[1] m.SwIfIndex
3117         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3118         pos += 4
3119         // field[1] m.IsIPv6
3120         m.IsIPv6 = tmp[pos] != 0
3121         pos += 1
3122         // field[1] m.VrfID
3123         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
3124         pos += 4
3125         return nil
3126 }
3127
3128 // SwInterfaceSetTableReply represents VPP binary API message 'sw_interface_set_table_reply'.
3129 type SwInterfaceSetTableReply struct {
3130         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3131 }
3132
3133 func (m *SwInterfaceSetTableReply) Reset()                        { *m = SwInterfaceSetTableReply{} }
3134 func (*SwInterfaceSetTableReply) GetMessageName() string          { return "sw_interface_set_table_reply" }
3135 func (*SwInterfaceSetTableReply) GetCrcString() string            { return "e8d4e804" }
3136 func (*SwInterfaceSetTableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3137
3138 func (m *SwInterfaceSetTableReply) Size() int {
3139         if m == nil {
3140                 return 0
3141         }
3142         var size int
3143         // field[1] m.Retval
3144         size += 4
3145         return size
3146 }
3147 func (m *SwInterfaceSetTableReply) Marshal(b []byte) ([]byte, error) {
3148         o := binary.BigEndian
3149         _ = o
3150         pos := 0
3151         _ = pos
3152         var buf []byte
3153         if b == nil {
3154                 buf = make([]byte, m.Size())
3155         } else {
3156                 buf = b
3157         }
3158         // field[1] m.Retval
3159         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3160         pos += 4
3161         return buf, nil
3162 }
3163 func (m *SwInterfaceSetTableReply) Unmarshal(tmp []byte) error {
3164         o := binary.BigEndian
3165         _ = o
3166         pos := 0
3167         _ = pos
3168         // field[1] m.Retval
3169         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3170         pos += 4
3171         return nil
3172 }
3173
3174 // SwInterfaceSetUnnumbered represents VPP binary API message 'sw_interface_set_unnumbered'.
3175 type SwInterfaceSetUnnumbered struct {
3176         SwIfIndex           interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
3177         UnnumberedSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=unnumbered_sw_if_index" json:"unnumbered_sw_if_index,omitempty"`
3178         IsAdd               bool                           `binapi:"bool,name=is_add" json:"is_add,omitempty"`
3179 }
3180
3181 func (m *SwInterfaceSetUnnumbered) Reset()                        { *m = SwInterfaceSetUnnumbered{} }
3182 func (*SwInterfaceSetUnnumbered) GetMessageName() string          { return "sw_interface_set_unnumbered" }
3183 func (*SwInterfaceSetUnnumbered) GetCrcString() string            { return "938ef33b" }
3184 func (*SwInterfaceSetUnnumbered) GetMessageType() api.MessageType { return api.RequestMessage }
3185
3186 func (m *SwInterfaceSetUnnumbered) Size() int {
3187         if m == nil {
3188                 return 0
3189         }
3190         var size int
3191         // field[1] m.SwIfIndex
3192         size += 4
3193         // field[1] m.UnnumberedSwIfIndex
3194         size += 4
3195         // field[1] m.IsAdd
3196         size += 1
3197         return size
3198 }
3199 func (m *SwInterfaceSetUnnumbered) Marshal(b []byte) ([]byte, error) {
3200         o := binary.BigEndian
3201         _ = o
3202         pos := 0
3203         _ = pos
3204         var buf []byte
3205         if b == nil {
3206                 buf = make([]byte, m.Size())
3207         } else {
3208                 buf = b
3209         }
3210         // field[1] m.SwIfIndex
3211         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
3212         pos += 4
3213         // field[1] m.UnnumberedSwIfIndex
3214         o.PutUint32(buf[pos:pos+4], uint32(m.UnnumberedSwIfIndex))
3215         pos += 4
3216         // field[1] m.IsAdd
3217         if m.IsAdd {
3218                 buf[pos] = 1
3219         }
3220         pos += 1
3221         return buf, nil
3222 }
3223 func (m *SwInterfaceSetUnnumbered) Unmarshal(tmp []byte) error {
3224         o := binary.BigEndian
3225         _ = o
3226         pos := 0
3227         _ = pos
3228         // field[1] m.SwIfIndex
3229         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3230         pos += 4
3231         // field[1] m.UnnumberedSwIfIndex
3232         m.UnnumberedSwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3233         pos += 4
3234         // field[1] m.IsAdd
3235         m.IsAdd = tmp[pos] != 0
3236         pos += 1
3237         return nil
3238 }
3239
3240 // SwInterfaceSetUnnumberedReply represents VPP binary API message 'sw_interface_set_unnumbered_reply'.
3241 type SwInterfaceSetUnnumberedReply struct {
3242         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3243 }
3244
3245 func (m *SwInterfaceSetUnnumberedReply) Reset() { *m = SwInterfaceSetUnnumberedReply{} }
3246 func (*SwInterfaceSetUnnumberedReply) GetMessageName() string {
3247         return "sw_interface_set_unnumbered_reply"
3248 }
3249 func (*SwInterfaceSetUnnumberedReply) GetCrcString() string            { return "e8d4e804" }
3250 func (*SwInterfaceSetUnnumberedReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3251
3252 func (m *SwInterfaceSetUnnumberedReply) Size() int {
3253         if m == nil {
3254                 return 0
3255         }
3256         var size int
3257         // field[1] m.Retval
3258         size += 4
3259         return size
3260 }
3261 func (m *SwInterfaceSetUnnumberedReply) Marshal(b []byte) ([]byte, error) {
3262         o := binary.BigEndian
3263         _ = o
3264         pos := 0
3265         _ = pos
3266         var buf []byte
3267         if b == nil {
3268                 buf = make([]byte, m.Size())
3269         } else {
3270                 buf = b
3271         }
3272         // field[1] m.Retval
3273         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3274         pos += 4
3275         return buf, nil
3276 }
3277 func (m *SwInterfaceSetUnnumberedReply) Unmarshal(tmp []byte) error {
3278         o := binary.BigEndian
3279         _ = o
3280         pos := 0
3281         _ = pos
3282         // field[1] m.Retval
3283         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3284         pos += 4
3285         return nil
3286 }
3287
3288 // SwInterfaceTagAddDel represents VPP binary API message 'sw_interface_tag_add_del'.
3289 type SwInterfaceTagAddDel struct {
3290         IsAdd     bool                           `binapi:"bool,name=is_add" json:"is_add,omitempty"`
3291         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
3292         Tag       string                         `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
3293 }
3294
3295 func (m *SwInterfaceTagAddDel) Reset()                        { *m = SwInterfaceTagAddDel{} }
3296 func (*SwInterfaceTagAddDel) GetMessageName() string          { return "sw_interface_tag_add_del" }
3297 func (*SwInterfaceTagAddDel) GetCrcString() string            { return "426f8bc1" }
3298 func (*SwInterfaceTagAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
3299
3300 func (m *SwInterfaceTagAddDel) Size() int {
3301         if m == nil {
3302                 return 0
3303         }
3304         var size int
3305         // field[1] m.IsAdd
3306         size += 1
3307         // field[1] m.SwIfIndex
3308         size += 4
3309         // field[1] m.Tag
3310         size += 64
3311         return size
3312 }
3313 func (m *SwInterfaceTagAddDel) Marshal(b []byte) ([]byte, error) {
3314         o := binary.BigEndian
3315         _ = o
3316         pos := 0
3317         _ = pos
3318         var buf []byte
3319         if b == nil {
3320                 buf = make([]byte, m.Size())
3321         } else {
3322                 buf = b
3323         }
3324         // field[1] m.IsAdd
3325         if m.IsAdd {
3326                 buf[pos] = 1
3327         }
3328         pos += 1
3329         // field[1] m.SwIfIndex
3330         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
3331         pos += 4
3332         // field[1] m.Tag
3333         copy(buf[pos:pos+64], m.Tag)
3334         pos += 64
3335         return buf, nil
3336 }
3337 func (m *SwInterfaceTagAddDel) Unmarshal(tmp []byte) error {
3338         o := binary.BigEndian
3339         _ = o
3340         pos := 0
3341         _ = pos
3342         // field[1] m.IsAdd
3343         m.IsAdd = tmp[pos] != 0
3344         pos += 1
3345         // field[1] m.SwIfIndex
3346         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
3347         pos += 4
3348         // field[1] m.Tag
3349         {
3350                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
3351                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
3352                 pos += 64
3353         }
3354         return nil
3355 }
3356
3357 // SwInterfaceTagAddDelReply represents VPP binary API message 'sw_interface_tag_add_del_reply'.
3358 type SwInterfaceTagAddDelReply struct {
3359         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3360 }
3361
3362 func (m *SwInterfaceTagAddDelReply) Reset()                        { *m = SwInterfaceTagAddDelReply{} }
3363 func (*SwInterfaceTagAddDelReply) GetMessageName() string          { return "sw_interface_tag_add_del_reply" }
3364 func (*SwInterfaceTagAddDelReply) GetCrcString() string            { return "e8d4e804" }
3365 func (*SwInterfaceTagAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3366
3367 func (m *SwInterfaceTagAddDelReply) Size() int {
3368         if m == nil {
3369                 return 0
3370         }
3371         var size int
3372         // field[1] m.Retval
3373         size += 4
3374         return size
3375 }
3376 func (m *SwInterfaceTagAddDelReply) Marshal(b []byte) ([]byte, error) {
3377         o := binary.BigEndian
3378         _ = o
3379         pos := 0
3380         _ = pos
3381         var buf []byte
3382         if b == nil {
3383                 buf = make([]byte, m.Size())
3384         } else {
3385                 buf = b
3386         }
3387         // field[1] m.Retval
3388         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3389         pos += 4
3390         return buf, nil
3391 }
3392 func (m *SwInterfaceTagAddDelReply) Unmarshal(tmp []byte) error {
3393         o := binary.BigEndian
3394         _ = o
3395         pos := 0
3396         _ = pos
3397         // field[1] m.Retval
3398         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3399         pos += 4
3400         return nil
3401 }
3402
3403 // WantInterfaceEvents represents VPP binary API message 'want_interface_events'.
3404 type WantInterfaceEvents struct {
3405         EnableDisable uint32 `binapi:"u32,name=enable_disable" json:"enable_disable,omitempty"`
3406         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
3407 }
3408
3409 func (m *WantInterfaceEvents) Reset()                        { *m = WantInterfaceEvents{} }
3410 func (*WantInterfaceEvents) GetMessageName() string          { return "want_interface_events" }
3411 func (*WantInterfaceEvents) GetCrcString() string            { return "476f5a08" }
3412 func (*WantInterfaceEvents) GetMessageType() api.MessageType { return api.RequestMessage }
3413
3414 func (m *WantInterfaceEvents) Size() int {
3415         if m == nil {
3416                 return 0
3417         }
3418         var size int
3419         // field[1] m.EnableDisable
3420         size += 4
3421         // field[1] m.PID
3422         size += 4
3423         return size
3424 }
3425 func (m *WantInterfaceEvents) Marshal(b []byte) ([]byte, error) {
3426         o := binary.BigEndian
3427         _ = o
3428         pos := 0
3429         _ = pos
3430         var buf []byte
3431         if b == nil {
3432                 buf = make([]byte, m.Size())
3433         } else {
3434                 buf = b
3435         }
3436         // field[1] m.EnableDisable
3437         o.PutUint32(buf[pos:pos+4], uint32(m.EnableDisable))
3438         pos += 4
3439         // field[1] m.PID
3440         o.PutUint32(buf[pos:pos+4], uint32(m.PID))
3441         pos += 4
3442         return buf, nil
3443 }
3444 func (m *WantInterfaceEvents) Unmarshal(tmp []byte) error {
3445         o := binary.BigEndian
3446         _ = o
3447         pos := 0
3448         _ = pos
3449         // field[1] m.EnableDisable
3450         m.EnableDisable = uint32(o.Uint32(tmp[pos : pos+4]))
3451         pos += 4
3452         // field[1] m.PID
3453         m.PID = uint32(o.Uint32(tmp[pos : pos+4]))
3454         pos += 4
3455         return nil
3456 }
3457
3458 // WantInterfaceEventsReply represents VPP binary API message 'want_interface_events_reply'.
3459 type WantInterfaceEventsReply struct {
3460         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3461 }
3462
3463 func (m *WantInterfaceEventsReply) Reset()                        { *m = WantInterfaceEventsReply{} }
3464 func (*WantInterfaceEventsReply) GetMessageName() string          { return "want_interface_events_reply" }
3465 func (*WantInterfaceEventsReply) GetCrcString() string            { return "e8d4e804" }
3466 func (*WantInterfaceEventsReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3467
3468 func (m *WantInterfaceEventsReply) Size() int {
3469         if m == nil {
3470                 return 0
3471         }
3472         var size int
3473         // field[1] m.Retval
3474         size += 4
3475         return size
3476 }
3477 func (m *WantInterfaceEventsReply) Marshal(b []byte) ([]byte, error) {
3478         o := binary.BigEndian
3479         _ = o
3480         pos := 0
3481         _ = pos
3482         var buf []byte
3483         if b == nil {
3484                 buf = make([]byte, m.Size())
3485         } else {
3486                 buf = b
3487         }
3488         // field[1] m.Retval
3489         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3490         pos += 4
3491         return buf, nil
3492 }
3493 func (m *WantInterfaceEventsReply) Unmarshal(tmp []byte) error {
3494         o := binary.BigEndian
3495         _ = o
3496         pos := 0
3497         _ = pos
3498         // field[1] m.Retval
3499         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3500         pos += 4
3501         return nil
3502 }
3503
3504 func init() { file_interfaces_binapi_init() }
3505 func file_interfaces_binapi_init() {
3506         api.RegisterMessage((*CollectDetailedInterfaceStats)(nil), "interface.CollectDetailedInterfaceStats")
3507         api.RegisterMessage((*CollectDetailedInterfaceStatsReply)(nil), "interface.CollectDetailedInterfaceStatsReply")
3508         api.RegisterMessage((*CreateLoopback)(nil), "interface.CreateLoopback")
3509         api.RegisterMessage((*CreateLoopbackInstance)(nil), "interface.CreateLoopbackInstance")
3510         api.RegisterMessage((*CreateLoopbackInstanceReply)(nil), "interface.CreateLoopbackInstanceReply")
3511         api.RegisterMessage((*CreateLoopbackReply)(nil), "interface.CreateLoopbackReply")
3512         api.RegisterMessage((*CreateSubif)(nil), "interface.CreateSubif")
3513         api.RegisterMessage((*CreateSubifReply)(nil), "interface.CreateSubifReply")
3514         api.RegisterMessage((*CreateVlanSubif)(nil), "interface.CreateVlanSubif")
3515         api.RegisterMessage((*CreateVlanSubifReply)(nil), "interface.CreateVlanSubifReply")
3516         api.RegisterMessage((*DeleteLoopback)(nil), "interface.DeleteLoopback")
3517         api.RegisterMessage((*DeleteLoopbackReply)(nil), "interface.DeleteLoopbackReply")
3518         api.RegisterMessage((*DeleteSubif)(nil), "interface.DeleteSubif")
3519         api.RegisterMessage((*DeleteSubifReply)(nil), "interface.DeleteSubifReply")
3520         api.RegisterMessage((*HwInterfaceSetMtu)(nil), "interface.HwInterfaceSetMtu")
3521         api.RegisterMessage((*HwInterfaceSetMtuReply)(nil), "interface.HwInterfaceSetMtuReply")
3522         api.RegisterMessage((*InterfaceNameRenumber)(nil), "interface.InterfaceNameRenumber")
3523         api.RegisterMessage((*InterfaceNameRenumberReply)(nil), "interface.InterfaceNameRenumberReply")
3524         api.RegisterMessage((*SwInterfaceAddDelAddress)(nil), "interface.SwInterfaceAddDelAddress")
3525         api.RegisterMessage((*SwInterfaceAddDelAddressReply)(nil), "interface.SwInterfaceAddDelAddressReply")
3526         api.RegisterMessage((*SwInterfaceAddDelMacAddress)(nil), "interface.SwInterfaceAddDelMacAddress")
3527         api.RegisterMessage((*SwInterfaceAddDelMacAddressReply)(nil), "interface.SwInterfaceAddDelMacAddressReply")
3528         api.RegisterMessage((*SwInterfaceAddressReplaceBegin)(nil), "interface.SwInterfaceAddressReplaceBegin")
3529         api.RegisterMessage((*SwInterfaceAddressReplaceBeginReply)(nil), "interface.SwInterfaceAddressReplaceBeginReply")
3530         api.RegisterMessage((*SwInterfaceAddressReplaceEnd)(nil), "interface.SwInterfaceAddressReplaceEnd")
3531         api.RegisterMessage((*SwInterfaceAddressReplaceEndReply)(nil), "interface.SwInterfaceAddressReplaceEndReply")
3532         api.RegisterMessage((*SwInterfaceClearStats)(nil), "interface.SwInterfaceClearStats")
3533         api.RegisterMessage((*SwInterfaceClearStatsReply)(nil), "interface.SwInterfaceClearStatsReply")
3534         api.RegisterMessage((*SwInterfaceDetails)(nil), "interface.SwInterfaceDetails")
3535         api.RegisterMessage((*SwInterfaceDump)(nil), "interface.SwInterfaceDump")
3536         api.RegisterMessage((*SwInterfaceEvent)(nil), "interface.SwInterfaceEvent")
3537         api.RegisterMessage((*SwInterfaceGetMacAddress)(nil), "interface.SwInterfaceGetMacAddress")
3538         api.RegisterMessage((*SwInterfaceGetMacAddressReply)(nil), "interface.SwInterfaceGetMacAddressReply")
3539         api.RegisterMessage((*SwInterfaceGetTable)(nil), "interface.SwInterfaceGetTable")
3540         api.RegisterMessage((*SwInterfaceGetTableReply)(nil), "interface.SwInterfaceGetTableReply")
3541         api.RegisterMessage((*SwInterfaceRxPlacementDetails)(nil), "interface.SwInterfaceRxPlacementDetails")
3542         api.RegisterMessage((*SwInterfaceRxPlacementDump)(nil), "interface.SwInterfaceRxPlacementDump")
3543         api.RegisterMessage((*SwInterfaceSetFlags)(nil), "interface.SwInterfaceSetFlags")
3544         api.RegisterMessage((*SwInterfaceSetFlagsReply)(nil), "interface.SwInterfaceSetFlagsReply")
3545         api.RegisterMessage((*SwInterfaceSetIPDirectedBroadcast)(nil), "interface.SwInterfaceSetIPDirectedBroadcast")
3546         api.RegisterMessage((*SwInterfaceSetIPDirectedBroadcastReply)(nil), "interface.SwInterfaceSetIPDirectedBroadcastReply")
3547         api.RegisterMessage((*SwInterfaceSetMacAddress)(nil), "interface.SwInterfaceSetMacAddress")
3548         api.RegisterMessage((*SwInterfaceSetMacAddressReply)(nil), "interface.SwInterfaceSetMacAddressReply")
3549         api.RegisterMessage((*SwInterfaceSetMtu)(nil), "interface.SwInterfaceSetMtu")
3550         api.RegisterMessage((*SwInterfaceSetMtuReply)(nil), "interface.SwInterfaceSetMtuReply")
3551         api.RegisterMessage((*SwInterfaceSetRxMode)(nil), "interface.SwInterfaceSetRxMode")
3552         api.RegisterMessage((*SwInterfaceSetRxModeReply)(nil), "interface.SwInterfaceSetRxModeReply")
3553         api.RegisterMessage((*SwInterfaceSetRxPlacement)(nil), "interface.SwInterfaceSetRxPlacement")
3554         api.RegisterMessage((*SwInterfaceSetRxPlacementReply)(nil), "interface.SwInterfaceSetRxPlacementReply")
3555         api.RegisterMessage((*SwInterfaceSetTable)(nil), "interface.SwInterfaceSetTable")
3556         api.RegisterMessage((*SwInterfaceSetTableReply)(nil), "interface.SwInterfaceSetTableReply")
3557         api.RegisterMessage((*SwInterfaceSetUnnumbered)(nil), "interface.SwInterfaceSetUnnumbered")
3558         api.RegisterMessage((*SwInterfaceSetUnnumberedReply)(nil), "interface.SwInterfaceSetUnnumberedReply")
3559         api.RegisterMessage((*SwInterfaceTagAddDel)(nil), "interface.SwInterfaceTagAddDel")
3560         api.RegisterMessage((*SwInterfaceTagAddDelReply)(nil), "interface.SwInterfaceTagAddDelReply")
3561         api.RegisterMessage((*WantInterfaceEvents)(nil), "interface.WantInterfaceEvents")
3562         api.RegisterMessage((*WantInterfaceEventsReply)(nil), "interface.WantInterfaceEventsReply")
3563 }
3564
3565 // Messages returns list of all messages in this module.
3566 func AllMessages() []api.Message {
3567         return []api.Message{
3568                 (*CollectDetailedInterfaceStats)(nil),
3569                 (*CollectDetailedInterfaceStatsReply)(nil),
3570                 (*CreateLoopback)(nil),
3571                 (*CreateLoopbackInstance)(nil),
3572                 (*CreateLoopbackInstanceReply)(nil),
3573                 (*CreateLoopbackReply)(nil),
3574                 (*CreateSubif)(nil),
3575                 (*CreateSubifReply)(nil),
3576                 (*CreateVlanSubif)(nil),
3577                 (*CreateVlanSubifReply)(nil),
3578                 (*DeleteLoopback)(nil),
3579                 (*DeleteLoopbackReply)(nil),
3580                 (*DeleteSubif)(nil),
3581                 (*DeleteSubifReply)(nil),
3582                 (*HwInterfaceSetMtu)(nil),
3583                 (*HwInterfaceSetMtuReply)(nil),
3584                 (*InterfaceNameRenumber)(nil),
3585                 (*InterfaceNameRenumberReply)(nil),
3586                 (*SwInterfaceAddDelAddress)(nil),
3587                 (*SwInterfaceAddDelAddressReply)(nil),
3588                 (*SwInterfaceAddDelMacAddress)(nil),
3589                 (*SwInterfaceAddDelMacAddressReply)(nil),
3590                 (*SwInterfaceAddressReplaceBegin)(nil),
3591                 (*SwInterfaceAddressReplaceBeginReply)(nil),
3592                 (*SwInterfaceAddressReplaceEnd)(nil),
3593                 (*SwInterfaceAddressReplaceEndReply)(nil),
3594                 (*SwInterfaceClearStats)(nil),
3595                 (*SwInterfaceClearStatsReply)(nil),
3596                 (*SwInterfaceDetails)(nil),
3597                 (*SwInterfaceDump)(nil),
3598                 (*SwInterfaceEvent)(nil),
3599                 (*SwInterfaceGetMacAddress)(nil),
3600                 (*SwInterfaceGetMacAddressReply)(nil),
3601                 (*SwInterfaceGetTable)(nil),
3602                 (*SwInterfaceGetTableReply)(nil),
3603                 (*SwInterfaceRxPlacementDetails)(nil),
3604                 (*SwInterfaceRxPlacementDump)(nil),
3605                 (*SwInterfaceSetFlags)(nil),
3606                 (*SwInterfaceSetFlagsReply)(nil),
3607                 (*SwInterfaceSetIPDirectedBroadcast)(nil),
3608                 (*SwInterfaceSetIPDirectedBroadcastReply)(nil),
3609                 (*SwInterfaceSetMacAddress)(nil),
3610                 (*SwInterfaceSetMacAddressReply)(nil),
3611                 (*SwInterfaceSetMtu)(nil),
3612                 (*SwInterfaceSetMtuReply)(nil),
3613                 (*SwInterfaceSetRxMode)(nil),
3614                 (*SwInterfaceSetRxModeReply)(nil),
3615                 (*SwInterfaceSetRxPlacement)(nil),
3616                 (*SwInterfaceSetRxPlacementReply)(nil),
3617                 (*SwInterfaceSetTable)(nil),
3618                 (*SwInterfaceSetTableReply)(nil),
3619                 (*SwInterfaceSetUnnumbered)(nil),
3620                 (*SwInterfaceSetUnnumberedReply)(nil),
3621                 (*SwInterfaceTagAddDel)(nil),
3622                 (*SwInterfaceTagAddDelReply)(nil),
3623                 (*WantInterfaceEvents)(nil),
3624                 (*WantInterfaceEventsReply)(nil),
3625         }
3626 }
3627
3628 // Reference imports to suppress errors if they are not otherwise used.
3629 var _ = api.RegisterMessage
3630 var _ = codec.DecodeString
3631 var _ = bytes.NewBuffer
3632 var _ = context.Background
3633 var _ = io.Copy
3634 var _ = strconv.Itoa
3635 var _ = strings.Contains
3636 var _ = struc.Pack
3637 var _ = binary.BigEndian
3638 var _ = math.Float32bits
3639 var _ = net.ParseIP
3640 var _ = fmt.Errorf