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