examples/binapi/acl/acl.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/plugins/acl.api.json
   6
   7 /*
   8 Package acl contains generated code for VPP API file acl.api (2.0.0).
   9
  10 It consists of:
  11           7 aliases
  12          11 enums
  13          38 messages
  14           8 types
  15           1 union
  16 */
  17 package acl
  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 = "acl"
  44         // APIVersion is the API version of this module.
  45         APIVersion = "2.0.0"
  46         // VersionCrc is the CRC of this module.
  47         VersionCrc = 0x68c4cb37
  48 )
  49
  50 // ACLAction represents VPP binary API enum 'acl_action'.
  51 type ACLAction uint8
  52
  53 const (
  54         ACL_ACTION_API_DENY           ACLAction = 0
  55         ACL_ACTION_API_PERMIT         ACLAction = 1
  56         ACL_ACTION_API_PERMIT_REFLECT ACLAction = 2
  57 )
  58
  59 var (
  60         ACLAction_name = map[uint8]string{
  61                 0: "ACL_ACTION_API_DENY",
  62                 1: "ACL_ACTION_API_PERMIT",
  63                 2: "ACL_ACTION_API_PERMIT_REFLECT",
  64         }
  65         ACLAction_value = map[string]uint8{
  66                 "ACL_ACTION_API_DENY":           0,
  67                 "ACL_ACTION_API_PERMIT":         1,
  68                 "ACL_ACTION_API_PERMIT_REFLECT": 2,
  69         }
  70 )
  71
  72 func (x ACLAction) String() string {
  73         s, ok := ACLAction_name[uint8(x)]
  74         if ok {
  75                 return s
  76         }
  77         return "ACLAction(" + strconv.Itoa(int(x)) + ")"
  78 }
  79
  80 type AddressFamily = ip_types.AddressFamily
  81
  82 type IfStatusFlags = interface_types.IfStatusFlags
  83
  84 type IfType = interface_types.IfType
  85
  86 type IPDscp = ip_types.IPDscp
  87
  88 type IPEcn = ip_types.IPEcn
  89
  90 type IPProto = ip_types.IPProto
  91
  92 type LinkDuplex = interface_types.LinkDuplex
  93
  94 type MtuProto = interface_types.MtuProto
  95
  96 type RxMode = interface_types.RxMode
  97
  98 type SubIfFlags = interface_types.SubIfFlags
  99
 100 type AddressWithPrefix = ip_types.AddressWithPrefix
 101
 102 type InterfaceIndex = interface_types.InterfaceIndex
 103
 104 type IP4Address = ip_types.IP4Address
 105
 106 type IP4AddressWithPrefix = ip_types.IP4AddressWithPrefix
 107
 108 type IP6Address = ip_types.IP6Address
 109
 110 type IP6AddressWithPrefix = ip_types.IP6AddressWithPrefix
 111
 112 // MacAddress represents VPP binary API alias 'mac_address'.
 113 type MacAddress [6]uint8
 114
 115 // ACLRule represents VPP binary API type 'acl_rule'.
 116 type ACLRule struct {
 117         IsPermit               ACLAction `binapi:"acl_action,name=is_permit" json:"is_permit,omitempty"`
 118         SrcPrefix              Prefix    `binapi:"prefix,name=src_prefix" json:"src_prefix,omitempty"`
 119         DstPrefix              Prefix    `binapi:"prefix,name=dst_prefix" json:"dst_prefix,omitempty"`
 120         Proto                  IPProto   `binapi:"ip_proto,name=proto" json:"proto,omitempty"`
 121         SrcportOrIcmptypeFirst uint16    `binapi:"u16,name=srcport_or_icmptype_first" json:"srcport_or_icmptype_first,omitempty"`
 122         SrcportOrIcmptypeLast  uint16    `binapi:"u16,name=srcport_or_icmptype_last" json:"srcport_or_icmptype_last,omitempty"`
 123         DstportOrIcmpcodeFirst uint16    `binapi:"u16,name=dstport_or_icmpcode_first" json:"dstport_or_icmpcode_first,omitempty"`
 124         DstportOrIcmpcodeLast  uint16    `binapi:"u16,name=dstport_or_icmpcode_last" json:"dstport_or_icmpcode_last,omitempty"`
 125         TCPFlagsMask           uint8     `binapi:"u8,name=tcp_flags_mask" json:"tcp_flags_mask,omitempty"`
 126         TCPFlagsValue          uint8     `binapi:"u8,name=tcp_flags_value" json:"tcp_flags_value,omitempty"`
 127 }
 128
 129 func (*ACLRule) GetTypeName() string { return "acl_rule" }
 130
 131 type Address = ip_types.Address
 132
 133 type IP4Prefix = ip_types.IP4Prefix
 134
 135 type IP6Prefix = ip_types.IP6Prefix
 136
 137 // MacipACLRule represents VPP binary API type 'macip_acl_rule'.
 138 type MacipACLRule struct {
 139         IsPermit   ACLAction  `binapi:"acl_action,name=is_permit" json:"is_permit,omitempty"`
 140         SrcMac     MacAddress `binapi:"mac_address,name=src_mac" json:"src_mac,omitempty"`
 141         SrcMacMask MacAddress `binapi:"mac_address,name=src_mac_mask" json:"src_mac_mask,omitempty"`
 142         SrcPrefix  Prefix     `binapi:"prefix,name=src_prefix" json:"src_prefix,omitempty"`
 143 }
 144
 145 func (*MacipACLRule) GetTypeName() string { return "macip_acl_rule" }
 146
 147 type Mprefix = ip_types.Mprefix
 148
 149 type Prefix = ip_types.Prefix
 150
 151 type PrefixMatcher = ip_types.PrefixMatcher
 152
 153 type AddressUnion = ip_types.AddressUnion
 154
 155 // ACLAddReplace represents VPP binary API message 'acl_add_replace'.
 156 type ACLAddReplace struct {
 157         ACLIndex uint32    `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 158         Tag      string    `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
 159         Count    uint32    `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=R"`
 160         R        []ACLRule `binapi:"acl_rule[count],name=r" json:"r,omitempty"`
 161 }
 162
 163 func (m *ACLAddReplace) Reset()                        { *m = ACLAddReplace{} }
 164 func (*ACLAddReplace) GetMessageName() string          { return "acl_add_replace" }
 165 func (*ACLAddReplace) GetCrcString() string            { return "1cabdeab" }
 166 func (*ACLAddReplace) GetMessageType() api.MessageType { return api.RequestMessage }
 167
 168 func (m *ACLAddReplace) Size() int {
 169         if m == nil {
 170                 return 0
 171         }
 172         var size int
 173         // field[1] m.ACLIndex
 174         size += 4
 175         // field[1] m.Tag
 176         size += 64
 177         // field[1] m.Count
 178         size += 4
 179         // field[1] m.R
 180         for j1 := 0; j1 < len(m.R); j1++ {
 181                 var s1 ACLRule
 182                 _ = s1
 183                 if j1 < len(m.R) {
 184                         s1 = m.R[j1]
 185                 }
 186                 // field[2] s1.IsPermit
 187                 size += 1
 188                 // field[2] s1.SrcPrefix
 189                 // field[3] s1.SrcPrefix.Address
 190                 // field[4] s1.SrcPrefix.Address.Af
 191                 size += 1
 192                 // field[4] s1.SrcPrefix.Address.Un
 193                 size += 16
 194                 // field[3] s1.SrcPrefix.Len
 195                 size += 1
 196                 // field[2] s1.DstPrefix
 197                 // field[3] s1.DstPrefix.Address
 198                 // field[4] s1.DstPrefix.Address.Af
 199                 size += 1
 200                 // field[4] s1.DstPrefix.Address.Un
 201                 size += 16
 202                 // field[3] s1.DstPrefix.Len
 203                 size += 1
 204                 // field[2] s1.Proto
 205                 size += 1
 206                 // field[2] s1.SrcportOrIcmptypeFirst
 207                 size += 2
 208                 // field[2] s1.SrcportOrIcmptypeLast
 209                 size += 2
 210                 // field[2] s1.DstportOrIcmpcodeFirst
 211                 size += 2
 212                 // field[2] s1.DstportOrIcmpcodeLast
 213                 size += 2
 214                 // field[2] s1.TCPFlagsMask
 215                 size += 1
 216                 // field[2] s1.TCPFlagsValue
 217                 size += 1
 218         }
 219         return size
 220 }
 221 func (m *ACLAddReplace) Marshal(b []byte) ([]byte, error) {
 222         o := binary.BigEndian
 223         _ = o
 224         pos := 0
 225         _ = pos
 226         var buf []byte
 227         if b == nil {
 228                 buf = make([]byte, m.Size())
 229         } else {
 230                 buf = b
 231         }
 232         // field[1] m.ACLIndex
 233         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 234         pos += 4
 235         // field[1] m.Tag
 236         copy(buf[pos:pos+64], m.Tag)
 237         pos += 64
 238         // field[1] m.Count
 239         o.PutUint32(buf[pos:pos+4], uint32(len(m.R)))
 240         pos += 4
 241         // field[1] m.R
 242         for j1 := 0; j1 < len(m.R); j1++ {
 243                 var v1 ACLRule
 244                 if j1 < len(m.R) {
 245                         v1 = m.R[j1]
 246                 }
 247                 // field[2] v1.IsPermit
 248                 buf[pos] = uint8(v1.IsPermit)
 249                 pos += 1
 250                 // field[2] v1.SrcPrefix
 251                 // field[3] v1.SrcPrefix.Address
 252                 // field[4] v1.SrcPrefix.Address.Af
 253                 buf[pos] = uint8(v1.SrcPrefix.Address.Af)
 254                 pos += 1
 255                 // field[4] v1.SrcPrefix.Address.Un
 256                 copy(buf[pos:pos+16], v1.SrcPrefix.Address.Un.XXX_UnionData[:])
 257                 pos += 16
 258                 // field[3] v1.SrcPrefix.Len
 259                 buf[pos] = uint8(v1.SrcPrefix.Len)
 260                 pos += 1
 261                 // field[2] v1.DstPrefix
 262                 // field[3] v1.DstPrefix.Address
 263                 // field[4] v1.DstPrefix.Address.Af
 264                 buf[pos] = uint8(v1.DstPrefix.Address.Af)
 265                 pos += 1
 266                 // field[4] v1.DstPrefix.Address.Un
 267                 copy(buf[pos:pos+16], v1.DstPrefix.Address.Un.XXX_UnionData[:])
 268                 pos += 16
 269                 // field[3] v1.DstPrefix.Len
 270                 buf[pos] = uint8(v1.DstPrefix.Len)
 271                 pos += 1
 272                 // field[2] v1.Proto
 273                 buf[pos] = uint8(v1.Proto)
 274                 pos += 1
 275                 // field[2] v1.SrcportOrIcmptypeFirst
 276                 o.PutUint16(buf[pos:pos+2], uint16(v1.SrcportOrIcmptypeFirst))
 277                 pos += 2
 278                 // field[2] v1.SrcportOrIcmptypeLast
 279                 o.PutUint16(buf[pos:pos+2], uint16(v1.SrcportOrIcmptypeLast))
 280                 pos += 2
 281                 // field[2] v1.DstportOrIcmpcodeFirst
 282                 o.PutUint16(buf[pos:pos+2], uint16(v1.DstportOrIcmpcodeFirst))
 283                 pos += 2
 284                 // field[2] v1.DstportOrIcmpcodeLast
 285                 o.PutUint16(buf[pos:pos+2], uint16(v1.DstportOrIcmpcodeLast))
 286                 pos += 2
 287                 // field[2] v1.TCPFlagsMask
 288                 buf[pos] = uint8(v1.TCPFlagsMask)
 289                 pos += 1
 290                 // field[2] v1.TCPFlagsValue
 291                 buf[pos] = uint8(v1.TCPFlagsValue)
 292                 pos += 1
 293         }
 294         return buf, nil
 295 }
 296 func (m *ACLAddReplace) Unmarshal(tmp []byte) error {
 297         o := binary.BigEndian
 298         _ = o
 299         pos := 0
 300         _ = pos
 301         // field[1] m.ACLIndex
 302         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 303         pos += 4
 304         // field[1] m.Tag
 305         {
 306                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 307                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
 308                 pos += 64
 309         }
 310         // field[1] m.Count
 311         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
 312         pos += 4
 313         // field[1] m.R
 314         m.R = make([]ACLRule, int(m.Count))
 315         for j1 := 0; j1 < int(m.Count); j1++ {
 316                 // field[2] m.R[j1].IsPermit
 317                 m.R[j1].IsPermit = ACLAction(tmp[pos])
 318                 pos += 1
 319                 // field[2] m.R[j1].SrcPrefix
 320                 // field[3] m.R[j1].SrcPrefix.Address
 321                 // field[4] m.R[j1].SrcPrefix.Address.Af
 322                 m.R[j1].SrcPrefix.Address.Af = AddressFamily(tmp[pos])
 323                 pos += 1
 324                 // field[4] m.R[j1].SrcPrefix.Address.Un
 325                 copy(m.R[j1].SrcPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 326                 pos += 16
 327                 // field[3] m.R[j1].SrcPrefix.Len
 328                 m.R[j1].SrcPrefix.Len = uint8(tmp[pos])
 329                 pos += 1
 330                 // field[2] m.R[j1].DstPrefix
 331                 // field[3] m.R[j1].DstPrefix.Address
 332                 // field[4] m.R[j1].DstPrefix.Address.Af
 333                 m.R[j1].DstPrefix.Address.Af = AddressFamily(tmp[pos])
 334                 pos += 1
 335                 // field[4] m.R[j1].DstPrefix.Address.Un
 336                 copy(m.R[j1].DstPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 337                 pos += 16
 338                 // field[3] m.R[j1].DstPrefix.Len
 339                 m.R[j1].DstPrefix.Len = uint8(tmp[pos])
 340                 pos += 1
 341                 // field[2] m.R[j1].Proto
 342                 m.R[j1].Proto = IPProto(tmp[pos])
 343                 pos += 1
 344                 // field[2] m.R[j1].SrcportOrIcmptypeFirst
 345                 m.R[j1].SrcportOrIcmptypeFirst = uint16(o.Uint16(tmp[pos : pos+2]))
 346                 pos += 2
 347                 // field[2] m.R[j1].SrcportOrIcmptypeLast
 348                 m.R[j1].SrcportOrIcmptypeLast = uint16(o.Uint16(tmp[pos : pos+2]))
 349                 pos += 2
 350                 // field[2] m.R[j1].DstportOrIcmpcodeFirst
 351                 m.R[j1].DstportOrIcmpcodeFirst = uint16(o.Uint16(tmp[pos : pos+2]))
 352                 pos += 2
 353                 // field[2] m.R[j1].DstportOrIcmpcodeLast
 354                 m.R[j1].DstportOrIcmpcodeLast = uint16(o.Uint16(tmp[pos : pos+2]))
 355                 pos += 2
 356                 // field[2] m.R[j1].TCPFlagsMask
 357                 m.R[j1].TCPFlagsMask = uint8(tmp[pos])
 358                 pos += 1
 359                 // field[2] m.R[j1].TCPFlagsValue
 360                 m.R[j1].TCPFlagsValue = uint8(tmp[pos])
 361                 pos += 1
 362         }
 363         return nil
 364 }
 365
 366 // ACLAddReplaceReply represents VPP binary API message 'acl_add_replace_reply'.
 367 type ACLAddReplaceReply struct {
 368         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 369         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 370 }
 371
 372 func (m *ACLAddReplaceReply) Reset()                        { *m = ACLAddReplaceReply{} }
 373 func (*ACLAddReplaceReply) GetMessageName() string          { return "acl_add_replace_reply" }
 374 func (*ACLAddReplaceReply) GetCrcString() string            { return "ac407b0c" }
 375 func (*ACLAddReplaceReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 376
 377 func (m *ACLAddReplaceReply) Size() int {
 378         if m == nil {
 379                 return 0
 380         }
 381         var size int
 382         // field[1] m.ACLIndex
 383         size += 4
 384         // field[1] m.Retval
 385         size += 4
 386         return size
 387 }
 388 func (m *ACLAddReplaceReply) Marshal(b []byte) ([]byte, error) {
 389         o := binary.BigEndian
 390         _ = o
 391         pos := 0
 392         _ = pos
 393         var buf []byte
 394         if b == nil {
 395                 buf = make([]byte, m.Size())
 396         } else {
 397                 buf = b
 398         }
 399         // field[1] m.ACLIndex
 400         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 401         pos += 4
 402         // field[1] m.Retval
 403         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 404         pos += 4
 405         return buf, nil
 406 }
 407 func (m *ACLAddReplaceReply) Unmarshal(tmp []byte) error {
 408         o := binary.BigEndian
 409         _ = o
 410         pos := 0
 411         _ = pos
 412         // field[1] m.ACLIndex
 413         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 414         pos += 4
 415         // field[1] m.Retval
 416         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 417         pos += 4
 418         return nil
 419 }
 420
 421 // ACLDel represents VPP binary API message 'acl_del'.
 422 type ACLDel struct {
 423         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 424 }
 425
 426 func (m *ACLDel) Reset()                        { *m = ACLDel{} }
 427 func (*ACLDel) GetMessageName() string          { return "acl_del" }
 428 func (*ACLDel) GetCrcString() string            { return "ef34fea4" }
 429 func (*ACLDel) GetMessageType() api.MessageType { return api.RequestMessage }
 430
 431 func (m *ACLDel) Size() int {
 432         if m == nil {
 433                 return 0
 434         }
 435         var size int
 436         // field[1] m.ACLIndex
 437         size += 4
 438         return size
 439 }
 440 func (m *ACLDel) Marshal(b []byte) ([]byte, error) {
 441         o := binary.BigEndian
 442         _ = o
 443         pos := 0
 444         _ = pos
 445         var buf []byte
 446         if b == nil {
 447                 buf = make([]byte, m.Size())
 448         } else {
 449                 buf = b
 450         }
 451         // field[1] m.ACLIndex
 452         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 453         pos += 4
 454         return buf, nil
 455 }
 456 func (m *ACLDel) Unmarshal(tmp []byte) error {
 457         o := binary.BigEndian
 458         _ = o
 459         pos := 0
 460         _ = pos
 461         // field[1] m.ACLIndex
 462         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 463         pos += 4
 464         return nil
 465 }
 466
 467 // ACLDelReply represents VPP binary API message 'acl_del_reply'.
 468 type ACLDelReply struct {
 469         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 470 }
 471
 472 func (m *ACLDelReply) Reset()                        { *m = ACLDelReply{} }
 473 func (*ACLDelReply) GetMessageName() string          { return "acl_del_reply" }
 474 func (*ACLDelReply) GetCrcString() string            { return "e8d4e804" }
 475 func (*ACLDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 476
 477 func (m *ACLDelReply) Size() int {
 478         if m == nil {
 479                 return 0
 480         }
 481         var size int
 482         // field[1] m.Retval
 483         size += 4
 484         return size
 485 }
 486 func (m *ACLDelReply) Marshal(b []byte) ([]byte, error) {
 487         o := binary.BigEndian
 488         _ = o
 489         pos := 0
 490         _ = pos
 491         var buf []byte
 492         if b == nil {
 493                 buf = make([]byte, m.Size())
 494         } else {
 495                 buf = b
 496         }
 497         // field[1] m.Retval
 498         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 499         pos += 4
 500         return buf, nil
 501 }
 502 func (m *ACLDelReply) Unmarshal(tmp []byte) error {
 503         o := binary.BigEndian
 504         _ = o
 505         pos := 0
 506         _ = pos
 507         // field[1] m.Retval
 508         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 509         pos += 4
 510         return nil
 511 }
 512
 513 // ACLDetails represents VPP binary API message 'acl_details'.
 514 type ACLDetails struct {
 515         ACLIndex uint32    `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 516         Tag      string    `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
 517         Count    uint32    `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=R"`
 518         R        []ACLRule `binapi:"acl_rule[count],name=r" json:"r,omitempty"`
 519 }
 520
 521 func (m *ACLDetails) Reset()                        { *m = ACLDetails{} }
 522 func (*ACLDetails) GetMessageName() string          { return "acl_details" }
 523 func (*ACLDetails) GetCrcString() string            { return "7a97f21c" }
 524 func (*ACLDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 525
 526 func (m *ACLDetails) Size() int {
 527         if m == nil {
 528                 return 0
 529         }
 530         var size int
 531         // field[1] m.ACLIndex
 532         size += 4
 533         // field[1] m.Tag
 534         size += 64
 535         // field[1] m.Count
 536         size += 4
 537         // field[1] m.R
 538         for j1 := 0; j1 < len(m.R); j1++ {
 539                 var s1 ACLRule
 540                 _ = s1
 541                 if j1 < len(m.R) {
 542                         s1 = m.R[j1]
 543                 }
 544                 // field[2] s1.IsPermit
 545                 size += 1
 546                 // field[2] s1.SrcPrefix
 547                 // field[3] s1.SrcPrefix.Address
 548                 // field[4] s1.SrcPrefix.Address.Af
 549                 size += 1
 550                 // field[4] s1.SrcPrefix.Address.Un
 551                 size += 16
 552                 // field[3] s1.SrcPrefix.Len
 553                 size += 1
 554                 // field[2] s1.DstPrefix
 555                 // field[3] s1.DstPrefix.Address
 556                 // field[4] s1.DstPrefix.Address.Af
 557                 size += 1
 558                 // field[4] s1.DstPrefix.Address.Un
 559                 size += 16
 560                 // field[3] s1.DstPrefix.Len
 561                 size += 1
 562                 // field[2] s1.Proto
 563                 size += 1
 564                 // field[2] s1.SrcportOrIcmptypeFirst
 565                 size += 2
 566                 // field[2] s1.SrcportOrIcmptypeLast
 567                 size += 2
 568                 // field[2] s1.DstportOrIcmpcodeFirst
 569                 size += 2
 570                 // field[2] s1.DstportOrIcmpcodeLast
 571                 size += 2
 572                 // field[2] s1.TCPFlagsMask
 573                 size += 1
 574                 // field[2] s1.TCPFlagsValue
 575                 size += 1
 576         }
 577         return size
 578 }
 579 func (m *ACLDetails) Marshal(b []byte) ([]byte, error) {
 580         o := binary.BigEndian
 581         _ = o
 582         pos := 0
 583         _ = pos
 584         var buf []byte
 585         if b == nil {
 586                 buf = make([]byte, m.Size())
 587         } else {
 588                 buf = b
 589         }
 590         // field[1] m.ACLIndex
 591         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 592         pos += 4
 593         // field[1] m.Tag
 594         copy(buf[pos:pos+64], m.Tag)
 595         pos += 64
 596         // field[1] m.Count
 597         o.PutUint32(buf[pos:pos+4], uint32(len(m.R)))
 598         pos += 4
 599         // field[1] m.R
 600         for j1 := 0; j1 < len(m.R); j1++ {
 601                 var v1 ACLRule
 602                 if j1 < len(m.R) {
 603                         v1 = m.R[j1]
 604                 }
 605                 // field[2] v1.IsPermit
 606                 buf[pos] = uint8(v1.IsPermit)
 607                 pos += 1
 608                 // field[2] v1.SrcPrefix
 609                 // field[3] v1.SrcPrefix.Address
 610                 // field[4] v1.SrcPrefix.Address.Af
 611                 buf[pos] = uint8(v1.SrcPrefix.Address.Af)
 612                 pos += 1
 613                 // field[4] v1.SrcPrefix.Address.Un
 614                 copy(buf[pos:pos+16], v1.SrcPrefix.Address.Un.XXX_UnionData[:])
 615                 pos += 16
 616                 // field[3] v1.SrcPrefix.Len
 617                 buf[pos] = uint8(v1.SrcPrefix.Len)
 618                 pos += 1
 619                 // field[2] v1.DstPrefix
 620                 // field[3] v1.DstPrefix.Address
 621                 // field[4] v1.DstPrefix.Address.Af
 622                 buf[pos] = uint8(v1.DstPrefix.Address.Af)
 623                 pos += 1
 624                 // field[4] v1.DstPrefix.Address.Un
 625                 copy(buf[pos:pos+16], v1.DstPrefix.Address.Un.XXX_UnionData[:])
 626                 pos += 16
 627                 // field[3] v1.DstPrefix.Len
 628                 buf[pos] = uint8(v1.DstPrefix.Len)
 629                 pos += 1
 630                 // field[2] v1.Proto
 631                 buf[pos] = uint8(v1.Proto)
 632                 pos += 1
 633                 // field[2] v1.SrcportOrIcmptypeFirst
 634                 o.PutUint16(buf[pos:pos+2], uint16(v1.SrcportOrIcmptypeFirst))
 635                 pos += 2
 636                 // field[2] v1.SrcportOrIcmptypeLast
 637                 o.PutUint16(buf[pos:pos+2], uint16(v1.SrcportOrIcmptypeLast))
 638                 pos += 2
 639                 // field[2] v1.DstportOrIcmpcodeFirst
 640                 o.PutUint16(buf[pos:pos+2], uint16(v1.DstportOrIcmpcodeFirst))
 641                 pos += 2
 642                 // field[2] v1.DstportOrIcmpcodeLast
 643                 o.PutUint16(buf[pos:pos+2], uint16(v1.DstportOrIcmpcodeLast))
 644                 pos += 2
 645                 // field[2] v1.TCPFlagsMask
 646                 buf[pos] = uint8(v1.TCPFlagsMask)
 647                 pos += 1
 648                 // field[2] v1.TCPFlagsValue
 649                 buf[pos] = uint8(v1.TCPFlagsValue)
 650                 pos += 1
 651         }
 652         return buf, nil
 653 }
 654 func (m *ACLDetails) Unmarshal(tmp []byte) error {
 655         o := binary.BigEndian
 656         _ = o
 657         pos := 0
 658         _ = pos
 659         // field[1] m.ACLIndex
 660         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 661         pos += 4
 662         // field[1] m.Tag
 663         {
 664                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 665                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
 666                 pos += 64
 667         }
 668         // field[1] m.Count
 669         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
 670         pos += 4
 671         // field[1] m.R
 672         m.R = make([]ACLRule, int(m.Count))
 673         for j1 := 0; j1 < int(m.Count); j1++ {
 674                 // field[2] m.R[j1].IsPermit
 675                 m.R[j1].IsPermit = ACLAction(tmp[pos])
 676                 pos += 1
 677                 // field[2] m.R[j1].SrcPrefix
 678                 // field[3] m.R[j1].SrcPrefix.Address
 679                 // field[4] m.R[j1].SrcPrefix.Address.Af
 680                 m.R[j1].SrcPrefix.Address.Af = AddressFamily(tmp[pos])
 681                 pos += 1
 682                 // field[4] m.R[j1].SrcPrefix.Address.Un
 683                 copy(m.R[j1].SrcPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 684                 pos += 16
 685                 // field[3] m.R[j1].SrcPrefix.Len
 686                 m.R[j1].SrcPrefix.Len = uint8(tmp[pos])
 687                 pos += 1
 688                 // field[2] m.R[j1].DstPrefix
 689                 // field[3] m.R[j1].DstPrefix.Address
 690                 // field[4] m.R[j1].DstPrefix.Address.Af
 691                 m.R[j1].DstPrefix.Address.Af = AddressFamily(tmp[pos])
 692                 pos += 1
 693                 // field[4] m.R[j1].DstPrefix.Address.Un
 694                 copy(m.R[j1].DstPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
 695                 pos += 16
 696                 // field[3] m.R[j1].DstPrefix.Len
 697                 m.R[j1].DstPrefix.Len = uint8(tmp[pos])
 698                 pos += 1
 699                 // field[2] m.R[j1].Proto
 700                 m.R[j1].Proto = IPProto(tmp[pos])
 701                 pos += 1
 702                 // field[2] m.R[j1].SrcportOrIcmptypeFirst
 703                 m.R[j1].SrcportOrIcmptypeFirst = uint16(o.Uint16(tmp[pos : pos+2]))
 704                 pos += 2
 705                 // field[2] m.R[j1].SrcportOrIcmptypeLast
 706                 m.R[j1].SrcportOrIcmptypeLast = uint16(o.Uint16(tmp[pos : pos+2]))
 707                 pos += 2
 708                 // field[2] m.R[j1].DstportOrIcmpcodeFirst
 709                 m.R[j1].DstportOrIcmpcodeFirst = uint16(o.Uint16(tmp[pos : pos+2]))
 710                 pos += 2
 711                 // field[2] m.R[j1].DstportOrIcmpcodeLast
 712                 m.R[j1].DstportOrIcmpcodeLast = uint16(o.Uint16(tmp[pos : pos+2]))
 713                 pos += 2
 714                 // field[2] m.R[j1].TCPFlagsMask
 715                 m.R[j1].TCPFlagsMask = uint8(tmp[pos])
 716                 pos += 1
 717                 // field[2] m.R[j1].TCPFlagsValue
 718                 m.R[j1].TCPFlagsValue = uint8(tmp[pos])
 719                 pos += 1
 720         }
 721         return nil
 722 }
 723
 724 // ACLDump represents VPP binary API message 'acl_dump'.
 725 type ACLDump struct {
 726         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 727 }
 728
 729 func (m *ACLDump) Reset()                        { *m = ACLDump{} }
 730 func (*ACLDump) GetMessageName() string          { return "acl_dump" }
 731 func (*ACLDump) GetCrcString() string            { return "ef34fea4" }
 732 func (*ACLDump) GetMessageType() api.MessageType { return api.RequestMessage }
 733
 734 func (m *ACLDump) Size() int {
 735         if m == nil {
 736                 return 0
 737         }
 738         var size int
 739         // field[1] m.ACLIndex
 740         size += 4
 741         return size
 742 }
 743 func (m *ACLDump) Marshal(b []byte) ([]byte, error) {
 744         o := binary.BigEndian
 745         _ = o
 746         pos := 0
 747         _ = pos
 748         var buf []byte
 749         if b == nil {
 750                 buf = make([]byte, m.Size())
 751         } else {
 752                 buf = b
 753         }
 754         // field[1] m.ACLIndex
 755         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 756         pos += 4
 757         return buf, nil
 758 }
 759 func (m *ACLDump) Unmarshal(tmp []byte) error {
 760         o := binary.BigEndian
 761         _ = o
 762         pos := 0
 763         _ = pos
 764         // field[1] m.ACLIndex
 765         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 766         pos += 4
 767         return nil
 768 }
 769
 770 // ACLInterfaceAddDel represents VPP binary API message 'acl_interface_add_del'.
 771 type ACLInterfaceAddDel struct {
 772         IsAdd     bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 773         IsInput   bool           `binapi:"bool,name=is_input" json:"is_input,omitempty"`
 774         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 775         ACLIndex  uint32         `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 776 }
 777
 778 func (m *ACLInterfaceAddDel) Reset()                        { *m = ACLInterfaceAddDel{} }
 779 func (*ACLInterfaceAddDel) GetMessageName() string          { return "acl_interface_add_del" }
 780 func (*ACLInterfaceAddDel) GetCrcString() string            { return "4b54bebd" }
 781 func (*ACLInterfaceAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
 782
 783 func (m *ACLInterfaceAddDel) Size() int {
 784         if m == nil {
 785                 return 0
 786         }
 787         var size int
 788         // field[1] m.IsAdd
 789         size += 1
 790         // field[1] m.IsInput
 791         size += 1
 792         // field[1] m.SwIfIndex
 793         size += 4
 794         // field[1] m.ACLIndex
 795         size += 4
 796         return size
 797 }
 798 func (m *ACLInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
 799         o := binary.BigEndian
 800         _ = o
 801         pos := 0
 802         _ = pos
 803         var buf []byte
 804         if b == nil {
 805                 buf = make([]byte, m.Size())
 806         } else {
 807                 buf = b
 808         }
 809         // field[1] m.IsAdd
 810         if m.IsAdd {
 811                 buf[pos] = 1
 812         }
 813         pos += 1
 814         // field[1] m.IsInput
 815         if m.IsInput {
 816                 buf[pos] = 1
 817         }
 818         pos += 1
 819         // field[1] m.SwIfIndex
 820         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 821         pos += 4
 822         // field[1] m.ACLIndex
 823         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
 824         pos += 4
 825         return buf, nil
 826 }
 827 func (m *ACLInterfaceAddDel) Unmarshal(tmp []byte) error {
 828         o := binary.BigEndian
 829         _ = o
 830         pos := 0
 831         _ = pos
 832         // field[1] m.IsAdd
 833         m.IsAdd = tmp[pos] != 0
 834         pos += 1
 835         // field[1] m.IsInput
 836         m.IsInput = tmp[pos] != 0
 837         pos += 1
 838         // field[1] m.SwIfIndex
 839         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 840         pos += 4
 841         // field[1] m.ACLIndex
 842         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
 843         pos += 4
 844         return nil
 845 }
 846
 847 // ACLInterfaceAddDelReply represents VPP binary API message 'acl_interface_add_del_reply'.
 848 type ACLInterfaceAddDelReply struct {
 849         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 850 }
 851
 852 func (m *ACLInterfaceAddDelReply) Reset()                        { *m = ACLInterfaceAddDelReply{} }
 853 func (*ACLInterfaceAddDelReply) GetMessageName() string          { return "acl_interface_add_del_reply" }
 854 func (*ACLInterfaceAddDelReply) GetCrcString() string            { return "e8d4e804" }
 855 func (*ACLInterfaceAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 856
 857 func (m *ACLInterfaceAddDelReply) Size() int {
 858         if m == nil {
 859                 return 0
 860         }
 861         var size int
 862         // field[1] m.Retval
 863         size += 4
 864         return size
 865 }
 866 func (m *ACLInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
 867         o := binary.BigEndian
 868         _ = o
 869         pos := 0
 870         _ = pos
 871         var buf []byte
 872         if b == nil {
 873                 buf = make([]byte, m.Size())
 874         } else {
 875                 buf = b
 876         }
 877         // field[1] m.Retval
 878         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 879         pos += 4
 880         return buf, nil
 881 }
 882 func (m *ACLInterfaceAddDelReply) Unmarshal(tmp []byte) error {
 883         o := binary.BigEndian
 884         _ = o
 885         pos := 0
 886         _ = pos
 887         // field[1] m.Retval
 888         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 889         pos += 4
 890         return nil
 891 }
 892
 893 // ACLInterfaceEtypeWhitelistDetails represents VPP binary API message 'acl_interface_etype_whitelist_details'.
 894 type ACLInterfaceEtypeWhitelistDetails struct {
 895         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 896         Count     uint8          `binapi:"u8,name=count" json:"count,omitempty" struc:"sizeof=Whitelist"`
 897         NInput    uint8          `binapi:"u8,name=n_input" json:"n_input,omitempty"`
 898         Whitelist []uint16       `binapi:"u16[count],name=whitelist" json:"whitelist,omitempty"`
 899 }
 900
 901 func (m *ACLInterfaceEtypeWhitelistDetails) Reset() { *m = ACLInterfaceEtypeWhitelistDetails{} }
 902 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageName() string {
 903         return "acl_interface_etype_whitelist_details"
 904 }
 905 func (*ACLInterfaceEtypeWhitelistDetails) GetCrcString() string            { return "cc2bfded" }
 906 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 907
 908 func (m *ACLInterfaceEtypeWhitelistDetails) Size() int {
 909         if m == nil {
 910                 return 0
 911         }
 912         var size int
 913         // field[1] m.SwIfIndex
 914         size += 4
 915         // field[1] m.Count
 916         size += 1
 917         // field[1] m.NInput
 918         size += 1
 919         // field[1] m.Whitelist
 920         size += 2 * len(m.Whitelist)
 921         return size
 922 }
 923 func (m *ACLInterfaceEtypeWhitelistDetails) Marshal(b []byte) ([]byte, error) {
 924         o := binary.BigEndian
 925         _ = o
 926         pos := 0
 927         _ = pos
 928         var buf []byte
 929         if b == nil {
 930                 buf = make([]byte, m.Size())
 931         } else {
 932                 buf = b
 933         }
 934         // field[1] m.SwIfIndex
 935         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 936         pos += 4
 937         // field[1] m.Count
 938         buf[pos] = uint8(len(m.Whitelist))
 939         pos += 1
 940         // field[1] m.NInput
 941         buf[pos] = uint8(m.NInput)
 942         pos += 1
 943         // field[1] m.Whitelist
 944         for i := 0; i < len(m.Whitelist); i++ {
 945                 var x uint16
 946                 if i < len(m.Whitelist) {
 947                         x = uint16(m.Whitelist[i])
 948                 }
 949                 o.PutUint16(buf[pos:pos+2], uint16(x))
 950                 pos += 2
 951         }
 952         return buf, nil
 953 }
 954 func (m *ACLInterfaceEtypeWhitelistDetails) Unmarshal(tmp []byte) error {
 955         o := binary.BigEndian
 956         _ = o
 957         pos := 0
 958         _ = pos
 959         // field[1] m.SwIfIndex
 960         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 961         pos += 4
 962         // field[1] m.Count
 963         m.Count = uint8(tmp[pos])
 964         pos += 1
 965         // field[1] m.NInput
 966         m.NInput = uint8(tmp[pos])
 967         pos += 1
 968         // field[1] m.Whitelist
 969         m.Whitelist = make([]uint16, m.Count)
 970         for i := 0; i < len(m.Whitelist); i++ {
 971                 m.Whitelist[i] = uint16(o.Uint16(tmp[pos : pos+2]))
 972                 pos += 2
 973         }
 974         return nil
 975 }
 976
 977 // ACLInterfaceEtypeWhitelistDump represents VPP binary API message 'acl_interface_etype_whitelist_dump'.
 978 type ACLInterfaceEtypeWhitelistDump struct {
 979         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 980 }
 981
 982 func (m *ACLInterfaceEtypeWhitelistDump) Reset() { *m = ACLInterfaceEtypeWhitelistDump{} }
 983 func (*ACLInterfaceEtypeWhitelistDump) GetMessageName() string {
 984         return "acl_interface_etype_whitelist_dump"
 985 }
 986 func (*ACLInterfaceEtypeWhitelistDump) GetCrcString() string            { return "f9e6675e" }
 987 func (*ACLInterfaceEtypeWhitelistDump) GetMessageType() api.MessageType { return api.RequestMessage }
 988
 989 func (m *ACLInterfaceEtypeWhitelistDump) Size() int {
 990         if m == nil {
 991                 return 0
 992         }
 993         var size int
 994         // field[1] m.SwIfIndex
 995         size += 4
 996         return size
 997 }
 998 func (m *ACLInterfaceEtypeWhitelistDump) 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         return buf, nil
1013 }
1014 func (m *ACLInterfaceEtypeWhitelistDump) Unmarshal(tmp []byte) error {
1015         o := binary.BigEndian
1016         _ = o
1017         pos := 0
1018         _ = pos
1019         // field[1] m.SwIfIndex
1020         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1021         pos += 4
1022         return nil
1023 }
1024
1025 // ACLInterfaceListDetails represents VPP binary API message 'acl_interface_list_details'.
1026 type ACLInterfaceListDetails struct {
1027         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1028         Count     uint8          `binapi:"u8,name=count" json:"count,omitempty" struc:"sizeof=Acls"`
1029         NInput    uint8          `binapi:"u8,name=n_input" json:"n_input,omitempty"`
1030         Acls      []uint32       `binapi:"u32[count],name=acls" json:"acls,omitempty"`
1031 }
1032
1033 func (m *ACLInterfaceListDetails) Reset()                        { *m = ACLInterfaceListDetails{} }
1034 func (*ACLInterfaceListDetails) GetMessageName() string          { return "acl_interface_list_details" }
1035 func (*ACLInterfaceListDetails) GetCrcString() string            { return "e695d256" }
1036 func (*ACLInterfaceListDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1037
1038 func (m *ACLInterfaceListDetails) Size() int {
1039         if m == nil {
1040                 return 0
1041         }
1042         var size int
1043         // field[1] m.SwIfIndex
1044         size += 4
1045         // field[1] m.Count
1046         size += 1
1047         // field[1] m.NInput
1048         size += 1
1049         // field[1] m.Acls
1050         size += 4 * len(m.Acls)
1051         return size
1052 }
1053 func (m *ACLInterfaceListDetails) Marshal(b []byte) ([]byte, error) {
1054         o := binary.BigEndian
1055         _ = o
1056         pos := 0
1057         _ = pos
1058         var buf []byte
1059         if b == nil {
1060                 buf = make([]byte, m.Size())
1061         } else {
1062                 buf = b
1063         }
1064         // field[1] m.SwIfIndex
1065         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1066         pos += 4
1067         // field[1] m.Count
1068         buf[pos] = uint8(len(m.Acls))
1069         pos += 1
1070         // field[1] m.NInput
1071         buf[pos] = uint8(m.NInput)
1072         pos += 1
1073         // field[1] m.Acls
1074         for i := 0; i < len(m.Acls); i++ {
1075                 var x uint32
1076                 if i < len(m.Acls) {
1077                         x = uint32(m.Acls[i])
1078                 }
1079                 o.PutUint32(buf[pos:pos+4], uint32(x))
1080                 pos += 4
1081         }
1082         return buf, nil
1083 }
1084 func (m *ACLInterfaceListDetails) Unmarshal(tmp []byte) error {
1085         o := binary.BigEndian
1086         _ = o
1087         pos := 0
1088         _ = pos
1089         // field[1] m.SwIfIndex
1090         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1091         pos += 4
1092         // field[1] m.Count
1093         m.Count = uint8(tmp[pos])
1094         pos += 1
1095         // field[1] m.NInput
1096         m.NInput = uint8(tmp[pos])
1097         pos += 1
1098         // field[1] m.Acls
1099         m.Acls = make([]uint32, m.Count)
1100         for i := 0; i < len(m.Acls); i++ {
1101                 m.Acls[i] = uint32(o.Uint32(tmp[pos : pos+4]))
1102                 pos += 4
1103         }
1104         return nil
1105 }
1106
1107 // ACLInterfaceListDump represents VPP binary API message 'acl_interface_list_dump'.
1108 type ACLInterfaceListDump struct {
1109         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index,default=4294967295" json:"sw_if_index,omitempty"`
1110 }
1111
1112 func (m *ACLInterfaceListDump) Reset()                        { *m = ACLInterfaceListDump{} }
1113 func (*ACLInterfaceListDump) GetMessageName() string          { return "acl_interface_list_dump" }
1114 func (*ACLInterfaceListDump) GetCrcString() string            { return "f9e6675e" }
1115 func (*ACLInterfaceListDump) GetMessageType() api.MessageType { return api.RequestMessage }
1116
1117 func (m *ACLInterfaceListDump) Size() int {
1118         if m == nil {
1119                 return 0
1120         }
1121         var size int
1122         // field[1] m.SwIfIndex
1123         size += 4
1124         return size
1125 }
1126 func (m *ACLInterfaceListDump) Marshal(b []byte) ([]byte, error) {
1127         o := binary.BigEndian
1128         _ = o
1129         pos := 0
1130         _ = pos
1131         var buf []byte
1132         if b == nil {
1133                 buf = make([]byte, m.Size())
1134         } else {
1135                 buf = b
1136         }
1137         // field[1] m.SwIfIndex
1138         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1139         pos += 4
1140         return buf, nil
1141 }
1142 func (m *ACLInterfaceListDump) Unmarshal(tmp []byte) error {
1143         o := binary.BigEndian
1144         _ = o
1145         pos := 0
1146         _ = pos
1147         // field[1] m.SwIfIndex
1148         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1149         pos += 4
1150         return nil
1151 }
1152
1153 // ACLInterfaceSetACLList represents VPP binary API message 'acl_interface_set_acl_list'.
1154 type ACLInterfaceSetACLList struct {
1155         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1156         Count     uint8          `binapi:"u8,name=count" json:"count,omitempty" struc:"sizeof=Acls"`
1157         NInput    uint8          `binapi:"u8,name=n_input" json:"n_input,omitempty"`
1158         Acls      []uint32       `binapi:"u32[count],name=acls" json:"acls,omitempty"`
1159 }
1160
1161 func (m *ACLInterfaceSetACLList) Reset()                        { *m = ACLInterfaceSetACLList{} }
1162 func (*ACLInterfaceSetACLList) GetMessageName() string          { return "acl_interface_set_acl_list" }
1163 func (*ACLInterfaceSetACLList) GetCrcString() string            { return "473982bd" }
1164 func (*ACLInterfaceSetACLList) GetMessageType() api.MessageType { return api.RequestMessage }
1165
1166 func (m *ACLInterfaceSetACLList) Size() int {
1167         if m == nil {
1168                 return 0
1169         }
1170         var size int
1171         // field[1] m.SwIfIndex
1172         size += 4
1173         // field[1] m.Count
1174         size += 1
1175         // field[1] m.NInput
1176         size += 1
1177         // field[1] m.Acls
1178         size += 4 * len(m.Acls)
1179         return size
1180 }
1181 func (m *ACLInterfaceSetACLList) Marshal(b []byte) ([]byte, error) {
1182         o := binary.BigEndian
1183         _ = o
1184         pos := 0
1185         _ = pos
1186         var buf []byte
1187         if b == nil {
1188                 buf = make([]byte, m.Size())
1189         } else {
1190                 buf = b
1191         }
1192         // field[1] m.SwIfIndex
1193         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1194         pos += 4
1195         // field[1] m.Count
1196         buf[pos] = uint8(len(m.Acls))
1197         pos += 1
1198         // field[1] m.NInput
1199         buf[pos] = uint8(m.NInput)
1200         pos += 1
1201         // field[1] m.Acls
1202         for i := 0; i < len(m.Acls); i++ {
1203                 var x uint32
1204                 if i < len(m.Acls) {
1205                         x = uint32(m.Acls[i])
1206                 }
1207                 o.PutUint32(buf[pos:pos+4], uint32(x))
1208                 pos += 4
1209         }
1210         return buf, nil
1211 }
1212 func (m *ACLInterfaceSetACLList) Unmarshal(tmp []byte) error {
1213         o := binary.BigEndian
1214         _ = o
1215         pos := 0
1216         _ = pos
1217         // field[1] m.SwIfIndex
1218         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1219         pos += 4
1220         // field[1] m.Count
1221         m.Count = uint8(tmp[pos])
1222         pos += 1
1223         // field[1] m.NInput
1224         m.NInput = uint8(tmp[pos])
1225         pos += 1
1226         // field[1] m.Acls
1227         m.Acls = make([]uint32, m.Count)
1228         for i := 0; i < len(m.Acls); i++ {
1229                 m.Acls[i] = uint32(o.Uint32(tmp[pos : pos+4]))
1230                 pos += 4
1231         }
1232         return nil
1233 }
1234
1235 // ACLInterfaceSetACLListReply represents VPP binary API message 'acl_interface_set_acl_list_reply'.
1236 type ACLInterfaceSetACLListReply struct {
1237         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1238 }
1239
1240 func (m *ACLInterfaceSetACLListReply) Reset() { *m = ACLInterfaceSetACLListReply{} }
1241 func (*ACLInterfaceSetACLListReply) GetMessageName() string {
1242         return "acl_interface_set_acl_list_reply"
1243 }
1244 func (*ACLInterfaceSetACLListReply) GetCrcString() string            { return "e8d4e804" }
1245 func (*ACLInterfaceSetACLListReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1246
1247 func (m *ACLInterfaceSetACLListReply) Size() int {
1248         if m == nil {
1249                 return 0
1250         }
1251         var size int
1252         // field[1] m.Retval
1253         size += 4
1254         return size
1255 }
1256 func (m *ACLInterfaceSetACLListReply) Marshal(b []byte) ([]byte, error) {
1257         o := binary.BigEndian
1258         _ = o
1259         pos := 0
1260         _ = pos
1261         var buf []byte
1262         if b == nil {
1263                 buf = make([]byte, m.Size())
1264         } else {
1265                 buf = b
1266         }
1267         // field[1] m.Retval
1268         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1269         pos += 4
1270         return buf, nil
1271 }
1272 func (m *ACLInterfaceSetACLListReply) Unmarshal(tmp []byte) error {
1273         o := binary.BigEndian
1274         _ = o
1275         pos := 0
1276         _ = pos
1277         // field[1] m.Retval
1278         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1279         pos += 4
1280         return nil
1281 }
1282
1283 // ACLInterfaceSetEtypeWhitelist represents VPP binary API message 'acl_interface_set_etype_whitelist'.
1284 type ACLInterfaceSetEtypeWhitelist struct {
1285         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1286         Count     uint8          `binapi:"u8,name=count" json:"count,omitempty" struc:"sizeof=Whitelist"`
1287         NInput    uint8          `binapi:"u8,name=n_input" json:"n_input,omitempty"`
1288         Whitelist []uint16       `binapi:"u16[count],name=whitelist" json:"whitelist,omitempty"`
1289 }
1290
1291 func (m *ACLInterfaceSetEtypeWhitelist) Reset() { *m = ACLInterfaceSetEtypeWhitelist{} }
1292 func (*ACLInterfaceSetEtypeWhitelist) GetMessageName() string {
1293         return "acl_interface_set_etype_whitelist"
1294 }
1295 func (*ACLInterfaceSetEtypeWhitelist) GetCrcString() string            { return "3f5c2d2d" }
1296 func (*ACLInterfaceSetEtypeWhitelist) GetMessageType() api.MessageType { return api.RequestMessage }
1297
1298 func (m *ACLInterfaceSetEtypeWhitelist) Size() int {
1299         if m == nil {
1300                 return 0
1301         }
1302         var size int
1303         // field[1] m.SwIfIndex
1304         size += 4
1305         // field[1] m.Count
1306         size += 1
1307         // field[1] m.NInput
1308         size += 1
1309         // field[1] m.Whitelist
1310         size += 2 * len(m.Whitelist)
1311         return size
1312 }
1313 func (m *ACLInterfaceSetEtypeWhitelist) Marshal(b []byte) ([]byte, error) {
1314         o := binary.BigEndian
1315         _ = o
1316         pos := 0
1317         _ = pos
1318         var buf []byte
1319         if b == nil {
1320                 buf = make([]byte, m.Size())
1321         } else {
1322                 buf = b
1323         }
1324         // field[1] m.SwIfIndex
1325         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1326         pos += 4
1327         // field[1] m.Count
1328         buf[pos] = uint8(len(m.Whitelist))
1329         pos += 1
1330         // field[1] m.NInput
1331         buf[pos] = uint8(m.NInput)
1332         pos += 1
1333         // field[1] m.Whitelist
1334         for i := 0; i < len(m.Whitelist); i++ {
1335                 var x uint16
1336                 if i < len(m.Whitelist) {
1337                         x = uint16(m.Whitelist[i])
1338                 }
1339                 o.PutUint16(buf[pos:pos+2], uint16(x))
1340                 pos += 2
1341         }
1342         return buf, nil
1343 }
1344 func (m *ACLInterfaceSetEtypeWhitelist) Unmarshal(tmp []byte) error {
1345         o := binary.BigEndian
1346         _ = o
1347         pos := 0
1348         _ = pos
1349         // field[1] m.SwIfIndex
1350         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1351         pos += 4
1352         // field[1] m.Count
1353         m.Count = uint8(tmp[pos])
1354         pos += 1
1355         // field[1] m.NInput
1356         m.NInput = uint8(tmp[pos])
1357         pos += 1
1358         // field[1] m.Whitelist
1359         m.Whitelist = make([]uint16, m.Count)
1360         for i := 0; i < len(m.Whitelist); i++ {
1361                 m.Whitelist[i] = uint16(o.Uint16(tmp[pos : pos+2]))
1362                 pos += 2
1363         }
1364         return nil
1365 }
1366
1367 // ACLInterfaceSetEtypeWhitelistReply represents VPP binary API message 'acl_interface_set_etype_whitelist_reply'.
1368 type ACLInterfaceSetEtypeWhitelistReply struct {
1369         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1370 }
1371
1372 func (m *ACLInterfaceSetEtypeWhitelistReply) Reset() { *m = ACLInterfaceSetEtypeWhitelistReply{} }
1373 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageName() string {
1374         return "acl_interface_set_etype_whitelist_reply"
1375 }
1376 func (*ACLInterfaceSetEtypeWhitelistReply) GetCrcString() string            { return "e8d4e804" }
1377 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1378
1379 func (m *ACLInterfaceSetEtypeWhitelistReply) Size() int {
1380         if m == nil {
1381                 return 0
1382         }
1383         var size int
1384         // field[1] m.Retval
1385         size += 4
1386         return size
1387 }
1388 func (m *ACLInterfaceSetEtypeWhitelistReply) Marshal(b []byte) ([]byte, error) {
1389         o := binary.BigEndian
1390         _ = o
1391         pos := 0
1392         _ = pos
1393         var buf []byte
1394         if b == nil {
1395                 buf = make([]byte, m.Size())
1396         } else {
1397                 buf = b
1398         }
1399         // field[1] m.Retval
1400         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1401         pos += 4
1402         return buf, nil
1403 }
1404 func (m *ACLInterfaceSetEtypeWhitelistReply) Unmarshal(tmp []byte) error {
1405         o := binary.BigEndian
1406         _ = o
1407         pos := 0
1408         _ = pos
1409         // field[1] m.Retval
1410         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1411         pos += 4
1412         return nil
1413 }
1414
1415 // ACLPluginControlPing represents VPP binary API message 'acl_plugin_control_ping'.
1416 type ACLPluginControlPing struct{}
1417
1418 func (m *ACLPluginControlPing) Reset()                        { *m = ACLPluginControlPing{} }
1419 func (*ACLPluginControlPing) GetMessageName() string          { return "acl_plugin_control_ping" }
1420 func (*ACLPluginControlPing) GetCrcString() string            { return "51077d14" }
1421 func (*ACLPluginControlPing) GetMessageType() api.MessageType { return api.RequestMessage }
1422
1423 func (m *ACLPluginControlPing) Size() int {
1424         if m == nil {
1425                 return 0
1426         }
1427         var size int
1428         return size
1429 }
1430 func (m *ACLPluginControlPing) Marshal(b []byte) ([]byte, error) {
1431         o := binary.BigEndian
1432         _ = o
1433         pos := 0
1434         _ = pos
1435         var buf []byte
1436         if b == nil {
1437                 buf = make([]byte, m.Size())
1438         } else {
1439                 buf = b
1440         }
1441         return buf, nil
1442 }
1443 func (m *ACLPluginControlPing) Unmarshal(tmp []byte) error {
1444         o := binary.BigEndian
1445         _ = o
1446         pos := 0
1447         _ = pos
1448         return nil
1449 }
1450
1451 // ACLPluginControlPingReply represents VPP binary API message 'acl_plugin_control_ping_reply'.
1452 type ACLPluginControlPingReply struct {
1453         Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1454         ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
1455         VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
1456 }
1457
1458 func (m *ACLPluginControlPingReply) Reset()                        { *m = ACLPluginControlPingReply{} }
1459 func (*ACLPluginControlPingReply) GetMessageName() string          { return "acl_plugin_control_ping_reply" }
1460 func (*ACLPluginControlPingReply) GetCrcString() string            { return "f6b0b8ca" }
1461 func (*ACLPluginControlPingReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1462
1463 func (m *ACLPluginControlPingReply) Size() int {
1464         if m == nil {
1465                 return 0
1466         }
1467         var size int
1468         // field[1] m.Retval
1469         size += 4
1470         // field[1] m.ClientIndex
1471         size += 4
1472         // field[1] m.VpePID
1473         size += 4
1474         return size
1475 }
1476 func (m *ACLPluginControlPingReply) Marshal(b []byte) ([]byte, error) {
1477         o := binary.BigEndian
1478         _ = o
1479         pos := 0
1480         _ = pos
1481         var buf []byte
1482         if b == nil {
1483                 buf = make([]byte, m.Size())
1484         } else {
1485                 buf = b
1486         }
1487         // field[1] m.Retval
1488         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1489         pos += 4
1490         // field[1] m.ClientIndex
1491         o.PutUint32(buf[pos:pos+4], uint32(m.ClientIndex))
1492         pos += 4
1493         // field[1] m.VpePID
1494         o.PutUint32(buf[pos:pos+4], uint32(m.VpePID))
1495         pos += 4
1496         return buf, nil
1497 }
1498 func (m *ACLPluginControlPingReply) Unmarshal(tmp []byte) error {
1499         o := binary.BigEndian
1500         _ = o
1501         pos := 0
1502         _ = pos
1503         // field[1] m.Retval
1504         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1505         pos += 4
1506         // field[1] m.ClientIndex
1507         m.ClientIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1508         pos += 4
1509         // field[1] m.VpePID
1510         m.VpePID = uint32(o.Uint32(tmp[pos : pos+4]))
1511         pos += 4
1512         return nil
1513 }
1514
1515 // ACLPluginGetConnTableMaxEntries represents VPP binary API message 'acl_plugin_get_conn_table_max_entries'.
1516 type ACLPluginGetConnTableMaxEntries struct{}
1517
1518 func (m *ACLPluginGetConnTableMaxEntries) Reset() { *m = ACLPluginGetConnTableMaxEntries{} }
1519 func (*ACLPluginGetConnTableMaxEntries) GetMessageName() string {
1520         return "acl_plugin_get_conn_table_max_entries"
1521 }
1522 func (*ACLPluginGetConnTableMaxEntries) GetCrcString() string            { return "51077d14" }
1523 func (*ACLPluginGetConnTableMaxEntries) GetMessageType() api.MessageType { return api.RequestMessage }
1524
1525 func (m *ACLPluginGetConnTableMaxEntries) Size() int {
1526         if m == nil {
1527                 return 0
1528         }
1529         var size int
1530         return size
1531 }
1532 func (m *ACLPluginGetConnTableMaxEntries) Marshal(b []byte) ([]byte, error) {
1533         o := binary.BigEndian
1534         _ = o
1535         pos := 0
1536         _ = pos
1537         var buf []byte
1538         if b == nil {
1539                 buf = make([]byte, m.Size())
1540         } else {
1541                 buf = b
1542         }
1543         return buf, nil
1544 }
1545 func (m *ACLPluginGetConnTableMaxEntries) Unmarshal(tmp []byte) error {
1546         o := binary.BigEndian
1547         _ = o
1548         pos := 0
1549         _ = pos
1550         return nil
1551 }
1552
1553 // ACLPluginGetConnTableMaxEntriesReply represents VPP binary API message 'acl_plugin_get_conn_table_max_entries_reply'.
1554 type ACLPluginGetConnTableMaxEntriesReply struct {
1555         ConnTableMaxEntries uint64 `binapi:"u64,name=conn_table_max_entries" json:"conn_table_max_entries,omitempty"`
1556 }
1557
1558 func (m *ACLPluginGetConnTableMaxEntriesReply) Reset() { *m = ACLPluginGetConnTableMaxEntriesReply{} }
1559 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageName() string {
1560         return "acl_plugin_get_conn_table_max_entries_reply"
1561 }
1562 func (*ACLPluginGetConnTableMaxEntriesReply) GetCrcString() string { return "7a096d3d" }
1563 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageType() api.MessageType {
1564         return api.ReplyMessage
1565 }
1566
1567 func (m *ACLPluginGetConnTableMaxEntriesReply) Size() int {
1568         if m == nil {
1569                 return 0
1570         }
1571         var size int
1572         // field[1] m.ConnTableMaxEntries
1573         size += 8
1574         return size
1575 }
1576 func (m *ACLPluginGetConnTableMaxEntriesReply) Marshal(b []byte) ([]byte, error) {
1577         o := binary.BigEndian
1578         _ = o
1579         pos := 0
1580         _ = pos
1581         var buf []byte
1582         if b == nil {
1583                 buf = make([]byte, m.Size())
1584         } else {
1585                 buf = b
1586         }
1587         // field[1] m.ConnTableMaxEntries
1588         o.PutUint64(buf[pos:pos+8], uint64(m.ConnTableMaxEntries))
1589         pos += 8
1590         return buf, nil
1591 }
1592 func (m *ACLPluginGetConnTableMaxEntriesReply) Unmarshal(tmp []byte) error {
1593         o := binary.BigEndian
1594         _ = o
1595         pos := 0
1596         _ = pos
1597         // field[1] m.ConnTableMaxEntries
1598         m.ConnTableMaxEntries = uint64(o.Uint64(tmp[pos : pos+8]))
1599         pos += 8
1600         return nil
1601 }
1602
1603 // ACLPluginGetVersion represents VPP binary API message 'acl_plugin_get_version'.
1604 type ACLPluginGetVersion struct{}
1605
1606 func (m *ACLPluginGetVersion) Reset()                        { *m = ACLPluginGetVersion{} }
1607 func (*ACLPluginGetVersion) GetMessageName() string          { return "acl_plugin_get_version" }
1608 func (*ACLPluginGetVersion) GetCrcString() string            { return "51077d14" }
1609 func (*ACLPluginGetVersion) GetMessageType() api.MessageType { return api.RequestMessage }
1610
1611 func (m *ACLPluginGetVersion) Size() int {
1612         if m == nil {
1613                 return 0
1614         }
1615         var size int
1616         return size
1617 }
1618 func (m *ACLPluginGetVersion) Marshal(b []byte) ([]byte, error) {
1619         o := binary.BigEndian
1620         _ = o
1621         pos := 0
1622         _ = pos
1623         var buf []byte
1624         if b == nil {
1625                 buf = make([]byte, m.Size())
1626         } else {
1627                 buf = b
1628         }
1629         return buf, nil
1630 }
1631 func (m *ACLPluginGetVersion) Unmarshal(tmp []byte) error {
1632         o := binary.BigEndian
1633         _ = o
1634         pos := 0
1635         _ = pos
1636         return nil
1637 }
1638
1639 // ACLPluginGetVersionReply represents VPP binary API message 'acl_plugin_get_version_reply'.
1640 type ACLPluginGetVersionReply struct {
1641         Major uint32 `binapi:"u32,name=major" json:"major,omitempty"`
1642         Minor uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
1643 }
1644
1645 func (m *ACLPluginGetVersionReply) Reset()                        { *m = ACLPluginGetVersionReply{} }
1646 func (*ACLPluginGetVersionReply) GetMessageName() string          { return "acl_plugin_get_version_reply" }
1647 func (*ACLPluginGetVersionReply) GetCrcString() string            { return "9b32cf86" }
1648 func (*ACLPluginGetVersionReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1649
1650 func (m *ACLPluginGetVersionReply) Size() int {
1651         if m == nil {
1652                 return 0
1653         }
1654         var size int
1655         // field[1] m.Major
1656         size += 4
1657         // field[1] m.Minor
1658         size += 4
1659         return size
1660 }
1661 func (m *ACLPluginGetVersionReply) Marshal(b []byte) ([]byte, error) {
1662         o := binary.BigEndian
1663         _ = o
1664         pos := 0
1665         _ = pos
1666         var buf []byte
1667         if b == nil {
1668                 buf = make([]byte, m.Size())
1669         } else {
1670                 buf = b
1671         }
1672         // field[1] m.Major
1673         o.PutUint32(buf[pos:pos+4], uint32(m.Major))
1674         pos += 4
1675         // field[1] m.Minor
1676         o.PutUint32(buf[pos:pos+4], uint32(m.Minor))
1677         pos += 4
1678         return buf, nil
1679 }
1680 func (m *ACLPluginGetVersionReply) Unmarshal(tmp []byte) error {
1681         o := binary.BigEndian
1682         _ = o
1683         pos := 0
1684         _ = pos
1685         // field[1] m.Major
1686         m.Major = uint32(o.Uint32(tmp[pos : pos+4]))
1687         pos += 4
1688         // field[1] m.Minor
1689         m.Minor = uint32(o.Uint32(tmp[pos : pos+4]))
1690         pos += 4
1691         return nil
1692 }
1693
1694 // ACLStatsIntfCountersEnable represents VPP binary API message 'acl_stats_intf_counters_enable'.
1695 type ACLStatsIntfCountersEnable struct {
1696         Enable bool `binapi:"bool,name=enable" json:"enable,omitempty"`
1697 }
1698
1699 func (m *ACLStatsIntfCountersEnable) Reset()                        { *m = ACLStatsIntfCountersEnable{} }
1700 func (*ACLStatsIntfCountersEnable) GetMessageName() string          { return "acl_stats_intf_counters_enable" }
1701 func (*ACLStatsIntfCountersEnable) GetCrcString() string            { return "b3e225d2" }
1702 func (*ACLStatsIntfCountersEnable) GetMessageType() api.MessageType { return api.RequestMessage }
1703
1704 func (m *ACLStatsIntfCountersEnable) Size() int {
1705         if m == nil {
1706                 return 0
1707         }
1708         var size int
1709         // field[1] m.Enable
1710         size += 1
1711         return size
1712 }
1713 func (m *ACLStatsIntfCountersEnable) Marshal(b []byte) ([]byte, error) {
1714         o := binary.BigEndian
1715         _ = o
1716         pos := 0
1717         _ = pos
1718         var buf []byte
1719         if b == nil {
1720                 buf = make([]byte, m.Size())
1721         } else {
1722                 buf = b
1723         }
1724         // field[1] m.Enable
1725         if m.Enable {
1726                 buf[pos] = 1
1727         }
1728         pos += 1
1729         return buf, nil
1730 }
1731 func (m *ACLStatsIntfCountersEnable) Unmarshal(tmp []byte) error {
1732         o := binary.BigEndian
1733         _ = o
1734         pos := 0
1735         _ = pos
1736         // field[1] m.Enable
1737         m.Enable = tmp[pos] != 0
1738         pos += 1
1739         return nil
1740 }
1741
1742 // ACLStatsIntfCountersEnableReply represents VPP binary API message 'acl_stats_intf_counters_enable_reply'.
1743 type ACLStatsIntfCountersEnableReply struct {
1744         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1745 }
1746
1747 func (m *ACLStatsIntfCountersEnableReply) Reset() { *m = ACLStatsIntfCountersEnableReply{} }
1748 func (*ACLStatsIntfCountersEnableReply) GetMessageName() string {
1749         return "acl_stats_intf_counters_enable_reply"
1750 }
1751 func (*ACLStatsIntfCountersEnableReply) GetCrcString() string            { return "e8d4e804" }
1752 func (*ACLStatsIntfCountersEnableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1753
1754 func (m *ACLStatsIntfCountersEnableReply) Size() int {
1755         if m == nil {
1756                 return 0
1757         }
1758         var size int
1759         // field[1] m.Retval
1760         size += 4
1761         return size
1762 }
1763 func (m *ACLStatsIntfCountersEnableReply) Marshal(b []byte) ([]byte, error) {
1764         o := binary.BigEndian
1765         _ = o
1766         pos := 0
1767         _ = pos
1768         var buf []byte
1769         if b == nil {
1770                 buf = make([]byte, m.Size())
1771         } else {
1772                 buf = b
1773         }
1774         // field[1] m.Retval
1775         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1776         pos += 4
1777         return buf, nil
1778 }
1779 func (m *ACLStatsIntfCountersEnableReply) Unmarshal(tmp []byte) error {
1780         o := binary.BigEndian
1781         _ = o
1782         pos := 0
1783         _ = pos
1784         // field[1] m.Retval
1785         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1786         pos += 4
1787         return nil
1788 }
1789
1790 // MacipACLAdd represents VPP binary API message 'macip_acl_add'.
1791 type MacipACLAdd struct {
1792         Tag   string         `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
1793         Count uint32         `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=R"`
1794         R     []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
1795 }
1796
1797 func (m *MacipACLAdd) Reset()                        { *m = MacipACLAdd{} }
1798 func (*MacipACLAdd) GetMessageName() string          { return "macip_acl_add" }
1799 func (*MacipACLAdd) GetCrcString() string            { return "d648fd0a" }
1800 func (*MacipACLAdd) GetMessageType() api.MessageType { return api.RequestMessage }
1801
1802 func (m *MacipACLAdd) Size() int {
1803         if m == nil {
1804                 return 0
1805         }
1806         var size int
1807         // field[1] m.Tag
1808         size += 64
1809         // field[1] m.Count
1810         size += 4
1811         // field[1] m.R
1812         for j1 := 0; j1 < len(m.R); j1++ {
1813                 var s1 MacipACLRule
1814                 _ = s1
1815                 if j1 < len(m.R) {
1816                         s1 = m.R[j1]
1817                 }
1818                 // field[2] s1.IsPermit
1819                 size += 1
1820                 // field[2] s1.SrcMac
1821                 size += 6
1822                 // field[2] s1.SrcMacMask
1823                 size += 6
1824                 // field[2] s1.SrcPrefix
1825                 // field[3] s1.SrcPrefix.Address
1826                 // field[4] s1.SrcPrefix.Address.Af
1827                 size += 1
1828                 // field[4] s1.SrcPrefix.Address.Un
1829                 size += 16
1830                 // field[3] s1.SrcPrefix.Len
1831                 size += 1
1832         }
1833         return size
1834 }
1835 func (m *MacipACLAdd) Marshal(b []byte) ([]byte, error) {
1836         o := binary.BigEndian
1837         _ = o
1838         pos := 0
1839         _ = pos
1840         var buf []byte
1841         if b == nil {
1842                 buf = make([]byte, m.Size())
1843         } else {
1844                 buf = b
1845         }
1846         // field[1] m.Tag
1847         copy(buf[pos:pos+64], m.Tag)
1848         pos += 64
1849         // field[1] m.Count
1850         o.PutUint32(buf[pos:pos+4], uint32(len(m.R)))
1851         pos += 4
1852         // field[1] m.R
1853         for j1 := 0; j1 < len(m.R); j1++ {
1854                 var v1 MacipACLRule
1855                 if j1 < len(m.R) {
1856                         v1 = m.R[j1]
1857                 }
1858                 // field[2] v1.IsPermit
1859                 buf[pos] = uint8(v1.IsPermit)
1860                 pos += 1
1861                 // field[2] v1.SrcMac
1862                 for i := 0; i < 6; i++ {
1863                         var x uint8
1864                         if i < len(v1.SrcMac) {
1865                                 x = uint8(v1.SrcMac[i])
1866                         }
1867                         buf[pos] = uint8(x)
1868                         pos += 1
1869                 }
1870                 // field[2] v1.SrcMacMask
1871                 for i := 0; i < 6; i++ {
1872                         var x uint8
1873                         if i < len(v1.SrcMacMask) {
1874                                 x = uint8(v1.SrcMacMask[i])
1875                         }
1876                         buf[pos] = uint8(x)
1877                         pos += 1
1878                 }
1879                 // field[2] v1.SrcPrefix
1880                 // field[3] v1.SrcPrefix.Address
1881                 // field[4] v1.SrcPrefix.Address.Af
1882                 buf[pos] = uint8(v1.SrcPrefix.Address.Af)
1883                 pos += 1
1884                 // field[4] v1.SrcPrefix.Address.Un
1885                 copy(buf[pos:pos+16], v1.SrcPrefix.Address.Un.XXX_UnionData[:])
1886                 pos += 16
1887                 // field[3] v1.SrcPrefix.Len
1888                 buf[pos] = uint8(v1.SrcPrefix.Len)
1889                 pos += 1
1890         }
1891         return buf, nil
1892 }
1893 func (m *MacipACLAdd) Unmarshal(tmp []byte) error {
1894         o := binary.BigEndian
1895         _ = o
1896         pos := 0
1897         _ = pos
1898         // field[1] m.Tag
1899         {
1900                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
1901                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
1902                 pos += 64
1903         }
1904         // field[1] m.Count
1905         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
1906         pos += 4
1907         // field[1] m.R
1908         m.R = make([]MacipACLRule, int(m.Count))
1909         for j1 := 0; j1 < int(m.Count); j1++ {
1910                 // field[2] m.R[j1].IsPermit
1911                 m.R[j1].IsPermit = ACLAction(tmp[pos])
1912                 pos += 1
1913                 // field[2] m.R[j1].SrcMac
1914                 for i := 0; i < len(m.R[j1].SrcMac); i++ {
1915                         m.R[j1].SrcMac[i] = uint8(tmp[pos])
1916                         pos += 1
1917                 }
1918                 // field[2] m.R[j1].SrcMacMask
1919                 for i := 0; i < len(m.R[j1].SrcMacMask); i++ {
1920                         m.R[j1].SrcMacMask[i] = uint8(tmp[pos])
1921                         pos += 1
1922                 }
1923                 // field[2] m.R[j1].SrcPrefix
1924                 // field[3] m.R[j1].SrcPrefix.Address
1925                 // field[4] m.R[j1].SrcPrefix.Address.Af
1926                 m.R[j1].SrcPrefix.Address.Af = AddressFamily(tmp[pos])
1927                 pos += 1
1928                 // field[4] m.R[j1].SrcPrefix.Address.Un
1929                 copy(m.R[j1].SrcPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
1930                 pos += 16
1931                 // field[3] m.R[j1].SrcPrefix.Len
1932                 m.R[j1].SrcPrefix.Len = uint8(tmp[pos])
1933                 pos += 1
1934         }
1935         return nil
1936 }
1937
1938 // MacipACLAddReplace represents VPP binary API message 'macip_acl_add_replace'.
1939 type MacipACLAddReplace struct {
1940         ACLIndex uint32         `binapi:"u32,name=acl_index,default=4.294967295e+09" json:"acl_index,omitempty"`
1941         Tag      string         `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
1942         Count    uint32         `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=R"`
1943         R        []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
1944 }
1945
1946 func (m *MacipACLAddReplace) Reset()                        { *m = MacipACLAddReplace{} }
1947 func (*MacipACLAddReplace) GetMessageName() string          { return "macip_acl_add_replace" }
1948 func (*MacipACLAddReplace) GetCrcString() string            { return "e34402a7" }
1949 func (*MacipACLAddReplace) GetMessageType() api.MessageType { return api.RequestMessage }
1950
1951 func (m *MacipACLAddReplace) Size() int {
1952         if m == nil {
1953                 return 0
1954         }
1955         var size int
1956         // field[1] m.ACLIndex
1957         size += 4
1958         // field[1] m.Tag
1959         size += 64
1960         // field[1] m.Count
1961         size += 4
1962         // field[1] m.R
1963         for j1 := 0; j1 < len(m.R); j1++ {
1964                 var s1 MacipACLRule
1965                 _ = s1
1966                 if j1 < len(m.R) {
1967                         s1 = m.R[j1]
1968                 }
1969                 // field[2] s1.IsPermit
1970                 size += 1
1971                 // field[2] s1.SrcMac
1972                 size += 6
1973                 // field[2] s1.SrcMacMask
1974                 size += 6
1975                 // field[2] s1.SrcPrefix
1976                 // field[3] s1.SrcPrefix.Address
1977                 // field[4] s1.SrcPrefix.Address.Af
1978                 size += 1
1979                 // field[4] s1.SrcPrefix.Address.Un
1980                 size += 16
1981                 // field[3] s1.SrcPrefix.Len
1982                 size += 1
1983         }
1984         return size
1985 }
1986 func (m *MacipACLAddReplace) Marshal(b []byte) ([]byte, error) {
1987         o := binary.BigEndian
1988         _ = o
1989         pos := 0
1990         _ = pos
1991         var buf []byte
1992         if b == nil {
1993                 buf = make([]byte, m.Size())
1994         } else {
1995                 buf = b
1996         }
1997         // field[1] m.ACLIndex
1998         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
1999         pos += 4
2000         // field[1] m.Tag
2001         copy(buf[pos:pos+64], m.Tag)
2002         pos += 64
2003         // field[1] m.Count
2004         o.PutUint32(buf[pos:pos+4], uint32(len(m.R)))
2005         pos += 4
2006         // field[1] m.R
2007         for j1 := 0; j1 < len(m.R); j1++ {
2008                 var v1 MacipACLRule
2009                 if j1 < len(m.R) {
2010                         v1 = m.R[j1]
2011                 }
2012                 // field[2] v1.IsPermit
2013                 buf[pos] = uint8(v1.IsPermit)
2014                 pos += 1
2015                 // field[2] v1.SrcMac
2016                 for i := 0; i < 6; i++ {
2017                         var x uint8
2018                         if i < len(v1.SrcMac) {
2019                                 x = uint8(v1.SrcMac[i])
2020                         }
2021                         buf[pos] = uint8(x)
2022                         pos += 1
2023                 }
2024                 // field[2] v1.SrcMacMask
2025                 for i := 0; i < 6; i++ {
2026                         var x uint8
2027                         if i < len(v1.SrcMacMask) {
2028                                 x = uint8(v1.SrcMacMask[i])
2029                         }
2030                         buf[pos] = uint8(x)
2031                         pos += 1
2032                 }
2033                 // field[2] v1.SrcPrefix
2034                 // field[3] v1.SrcPrefix.Address
2035                 // field[4] v1.SrcPrefix.Address.Af
2036                 buf[pos] = uint8(v1.SrcPrefix.Address.Af)
2037                 pos += 1
2038                 // field[4] v1.SrcPrefix.Address.Un
2039                 copy(buf[pos:pos+16], v1.SrcPrefix.Address.Un.XXX_UnionData[:])
2040                 pos += 16
2041                 // field[3] v1.SrcPrefix.Len
2042                 buf[pos] = uint8(v1.SrcPrefix.Len)
2043                 pos += 1
2044         }
2045         return buf, nil
2046 }
2047 func (m *MacipACLAddReplace) Unmarshal(tmp []byte) error {
2048         o := binary.BigEndian
2049         _ = o
2050         pos := 0
2051         _ = pos
2052         // field[1] m.ACLIndex
2053         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2054         pos += 4
2055         // field[1] m.Tag
2056         {
2057                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
2058                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
2059                 pos += 64
2060         }
2061         // field[1] m.Count
2062         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
2063         pos += 4
2064         // field[1] m.R
2065         m.R = make([]MacipACLRule, int(m.Count))
2066         for j1 := 0; j1 < int(m.Count); j1++ {
2067                 // field[2] m.R[j1].IsPermit
2068                 m.R[j1].IsPermit = ACLAction(tmp[pos])
2069                 pos += 1
2070                 // field[2] m.R[j1].SrcMac
2071                 for i := 0; i < len(m.R[j1].SrcMac); i++ {
2072                         m.R[j1].SrcMac[i] = uint8(tmp[pos])
2073                         pos += 1
2074                 }
2075                 // field[2] m.R[j1].SrcMacMask
2076                 for i := 0; i < len(m.R[j1].SrcMacMask); i++ {
2077                         m.R[j1].SrcMacMask[i] = uint8(tmp[pos])
2078                         pos += 1
2079                 }
2080                 // field[2] m.R[j1].SrcPrefix
2081                 // field[3] m.R[j1].SrcPrefix.Address
2082                 // field[4] m.R[j1].SrcPrefix.Address.Af
2083                 m.R[j1].SrcPrefix.Address.Af = AddressFamily(tmp[pos])
2084                 pos += 1
2085                 // field[4] m.R[j1].SrcPrefix.Address.Un
2086                 copy(m.R[j1].SrcPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
2087                 pos += 16
2088                 // field[3] m.R[j1].SrcPrefix.Len
2089                 m.R[j1].SrcPrefix.Len = uint8(tmp[pos])
2090                 pos += 1
2091         }
2092         return nil
2093 }
2094
2095 // MacipACLAddReplaceReply represents VPP binary API message 'macip_acl_add_replace_reply'.
2096 type MacipACLAddReplaceReply struct {
2097         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
2098         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2099 }
2100
2101 func (m *MacipACLAddReplaceReply) Reset()                        { *m = MacipACLAddReplaceReply{} }
2102 func (*MacipACLAddReplaceReply) GetMessageName() string          { return "macip_acl_add_replace_reply" }
2103 func (*MacipACLAddReplaceReply) GetCrcString() string            { return "ac407b0c" }
2104 func (*MacipACLAddReplaceReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2105
2106 func (m *MacipACLAddReplaceReply) Size() int {
2107         if m == nil {
2108                 return 0
2109         }
2110         var size int
2111         // field[1] m.ACLIndex
2112         size += 4
2113         // field[1] m.Retval
2114         size += 4
2115         return size
2116 }
2117 func (m *MacipACLAddReplaceReply) Marshal(b []byte) ([]byte, error) {
2118         o := binary.BigEndian
2119         _ = o
2120         pos := 0
2121         _ = pos
2122         var buf []byte
2123         if b == nil {
2124                 buf = make([]byte, m.Size())
2125         } else {
2126                 buf = b
2127         }
2128         // field[1] m.ACLIndex
2129         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2130         pos += 4
2131         // field[1] m.Retval
2132         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2133         pos += 4
2134         return buf, nil
2135 }
2136 func (m *MacipACLAddReplaceReply) Unmarshal(tmp []byte) error {
2137         o := binary.BigEndian
2138         _ = o
2139         pos := 0
2140         _ = pos
2141         // field[1] m.ACLIndex
2142         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2143         pos += 4
2144         // field[1] m.Retval
2145         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2146         pos += 4
2147         return nil
2148 }
2149
2150 // MacipACLAddReply represents VPP binary API message 'macip_acl_add_reply'.
2151 type MacipACLAddReply struct {
2152         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
2153         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2154 }
2155
2156 func (m *MacipACLAddReply) Reset()                        { *m = MacipACLAddReply{} }
2157 func (*MacipACLAddReply) GetMessageName() string          { return "macip_acl_add_reply" }
2158 func (*MacipACLAddReply) GetCrcString() string            { return "ac407b0c" }
2159 func (*MacipACLAddReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2160
2161 func (m *MacipACLAddReply) Size() int {
2162         if m == nil {
2163                 return 0
2164         }
2165         var size int
2166         // field[1] m.ACLIndex
2167         size += 4
2168         // field[1] m.Retval
2169         size += 4
2170         return size
2171 }
2172 func (m *MacipACLAddReply) Marshal(b []byte) ([]byte, error) {
2173         o := binary.BigEndian
2174         _ = o
2175         pos := 0
2176         _ = pos
2177         var buf []byte
2178         if b == nil {
2179                 buf = make([]byte, m.Size())
2180         } else {
2181                 buf = b
2182         }
2183         // field[1] m.ACLIndex
2184         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2185         pos += 4
2186         // field[1] m.Retval
2187         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2188         pos += 4
2189         return buf, nil
2190 }
2191 func (m *MacipACLAddReply) Unmarshal(tmp []byte) error {
2192         o := binary.BigEndian
2193         _ = o
2194         pos := 0
2195         _ = pos
2196         // field[1] m.ACLIndex
2197         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2198         pos += 4
2199         // field[1] m.Retval
2200         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2201         pos += 4
2202         return nil
2203 }
2204
2205 // MacipACLDel represents VPP binary API message 'macip_acl_del'.
2206 type MacipACLDel struct {
2207         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
2208 }
2209
2210 func (m *MacipACLDel) Reset()                        { *m = MacipACLDel{} }
2211 func (*MacipACLDel) GetMessageName() string          { return "macip_acl_del" }
2212 func (*MacipACLDel) GetCrcString() string            { return "ef34fea4" }
2213 func (*MacipACLDel) GetMessageType() api.MessageType { return api.RequestMessage }
2214
2215 func (m *MacipACLDel) Size() int {
2216         if m == nil {
2217                 return 0
2218         }
2219         var size int
2220         // field[1] m.ACLIndex
2221         size += 4
2222         return size
2223 }
2224 func (m *MacipACLDel) Marshal(b []byte) ([]byte, error) {
2225         o := binary.BigEndian
2226         _ = o
2227         pos := 0
2228         _ = pos
2229         var buf []byte
2230         if b == nil {
2231                 buf = make([]byte, m.Size())
2232         } else {
2233                 buf = b
2234         }
2235         // field[1] m.ACLIndex
2236         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2237         pos += 4
2238         return buf, nil
2239 }
2240 func (m *MacipACLDel) Unmarshal(tmp []byte) error {
2241         o := binary.BigEndian
2242         _ = o
2243         pos := 0
2244         _ = pos
2245         // field[1] m.ACLIndex
2246         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2247         pos += 4
2248         return nil
2249 }
2250
2251 // MacipACLDelReply represents VPP binary API message 'macip_acl_del_reply'.
2252 type MacipACLDelReply struct {
2253         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2254 }
2255
2256 func (m *MacipACLDelReply) Reset()                        { *m = MacipACLDelReply{} }
2257 func (*MacipACLDelReply) GetMessageName() string          { return "macip_acl_del_reply" }
2258 func (*MacipACLDelReply) GetCrcString() string            { return "e8d4e804" }
2259 func (*MacipACLDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2260
2261 func (m *MacipACLDelReply) Size() int {
2262         if m == nil {
2263                 return 0
2264         }
2265         var size int
2266         // field[1] m.Retval
2267         size += 4
2268         return size
2269 }
2270 func (m *MacipACLDelReply) Marshal(b []byte) ([]byte, error) {
2271         o := binary.BigEndian
2272         _ = o
2273         pos := 0
2274         _ = pos
2275         var buf []byte
2276         if b == nil {
2277                 buf = make([]byte, m.Size())
2278         } else {
2279                 buf = b
2280         }
2281         // field[1] m.Retval
2282         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2283         pos += 4
2284         return buf, nil
2285 }
2286 func (m *MacipACLDelReply) Unmarshal(tmp []byte) error {
2287         o := binary.BigEndian
2288         _ = o
2289         pos := 0
2290         _ = pos
2291         // field[1] m.Retval
2292         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2293         pos += 4
2294         return nil
2295 }
2296
2297 // MacipACLDetails represents VPP binary API message 'macip_acl_details'.
2298 type MacipACLDetails struct {
2299         ACLIndex uint32         `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
2300         Tag      string         `binapi:"string[64],name=tag" json:"tag,omitempty" struc:"[64]byte"`
2301         Count    uint32         `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=R"`
2302         R        []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
2303 }
2304
2305 func (m *MacipACLDetails) Reset()                        { *m = MacipACLDetails{} }
2306 func (*MacipACLDetails) GetMessageName() string          { return "macip_acl_details" }
2307 func (*MacipACLDetails) GetCrcString() string            { return "57c7482f" }
2308 func (*MacipACLDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
2309
2310 func (m *MacipACLDetails) Size() int {
2311         if m == nil {
2312                 return 0
2313         }
2314         var size int
2315         // field[1] m.ACLIndex
2316         size += 4
2317         // field[1] m.Tag
2318         size += 64
2319         // field[1] m.Count
2320         size += 4
2321         // field[1] m.R
2322         for j1 := 0; j1 < len(m.R); j1++ {
2323                 var s1 MacipACLRule
2324                 _ = s1
2325                 if j1 < len(m.R) {
2326                         s1 = m.R[j1]
2327                 }
2328                 // field[2] s1.IsPermit
2329                 size += 1
2330                 // field[2] s1.SrcMac
2331                 size += 6
2332                 // field[2] s1.SrcMacMask
2333                 size += 6
2334                 // field[2] s1.SrcPrefix
2335                 // field[3] s1.SrcPrefix.Address
2336                 // field[4] s1.SrcPrefix.Address.Af
2337                 size += 1
2338                 // field[4] s1.SrcPrefix.Address.Un
2339                 size += 16
2340                 // field[3] s1.SrcPrefix.Len
2341                 size += 1
2342         }
2343         return size
2344 }
2345 func (m *MacipACLDetails) Marshal(b []byte) ([]byte, error) {
2346         o := binary.BigEndian
2347         _ = o
2348         pos := 0
2349         _ = pos
2350         var buf []byte
2351         if b == nil {
2352                 buf = make([]byte, m.Size())
2353         } else {
2354                 buf = b
2355         }
2356         // field[1] m.ACLIndex
2357         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2358         pos += 4
2359         // field[1] m.Tag
2360         copy(buf[pos:pos+64], m.Tag)
2361         pos += 64
2362         // field[1] m.Count
2363         o.PutUint32(buf[pos:pos+4], uint32(len(m.R)))
2364         pos += 4
2365         // field[1] m.R
2366         for j1 := 0; j1 < len(m.R); j1++ {
2367                 var v1 MacipACLRule
2368                 if j1 < len(m.R) {
2369                         v1 = m.R[j1]
2370                 }
2371                 // field[2] v1.IsPermit
2372                 buf[pos] = uint8(v1.IsPermit)
2373                 pos += 1
2374                 // field[2] v1.SrcMac
2375                 for i := 0; i < 6; i++ {
2376                         var x uint8
2377                         if i < len(v1.SrcMac) {
2378                                 x = uint8(v1.SrcMac[i])
2379                         }
2380                         buf[pos] = uint8(x)
2381                         pos += 1
2382                 }
2383                 // field[2] v1.SrcMacMask
2384                 for i := 0; i < 6; i++ {
2385                         var x uint8
2386                         if i < len(v1.SrcMacMask) {
2387                                 x = uint8(v1.SrcMacMask[i])
2388                         }
2389                         buf[pos] = uint8(x)
2390                         pos += 1
2391                 }
2392                 // field[2] v1.SrcPrefix
2393                 // field[3] v1.SrcPrefix.Address
2394                 // field[4] v1.SrcPrefix.Address.Af
2395                 buf[pos] = uint8(v1.SrcPrefix.Address.Af)
2396                 pos += 1
2397                 // field[4] v1.SrcPrefix.Address.Un
2398                 copy(buf[pos:pos+16], v1.SrcPrefix.Address.Un.XXX_UnionData[:])
2399                 pos += 16
2400                 // field[3] v1.SrcPrefix.Len
2401                 buf[pos] = uint8(v1.SrcPrefix.Len)
2402                 pos += 1
2403         }
2404         return buf, nil
2405 }
2406 func (m *MacipACLDetails) Unmarshal(tmp []byte) error {
2407         o := binary.BigEndian
2408         _ = o
2409         pos := 0
2410         _ = pos
2411         // field[1] m.ACLIndex
2412         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2413         pos += 4
2414         // field[1] m.Tag
2415         {
2416                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
2417                 m.Tag = codec.DecodeString(tmp[pos : pos+nul])
2418                 pos += 64
2419         }
2420         // field[1] m.Count
2421         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
2422         pos += 4
2423         // field[1] m.R
2424         m.R = make([]MacipACLRule, int(m.Count))
2425         for j1 := 0; j1 < int(m.Count); j1++ {
2426                 // field[2] m.R[j1].IsPermit
2427                 m.R[j1].IsPermit = ACLAction(tmp[pos])
2428                 pos += 1
2429                 // field[2] m.R[j1].SrcMac
2430                 for i := 0; i < len(m.R[j1].SrcMac); i++ {
2431                         m.R[j1].SrcMac[i] = uint8(tmp[pos])
2432                         pos += 1
2433                 }
2434                 // field[2] m.R[j1].SrcMacMask
2435                 for i := 0; i < len(m.R[j1].SrcMacMask); i++ {
2436                         m.R[j1].SrcMacMask[i] = uint8(tmp[pos])
2437                         pos += 1
2438                 }
2439                 // field[2] m.R[j1].SrcPrefix
2440                 // field[3] m.R[j1].SrcPrefix.Address
2441                 // field[4] m.R[j1].SrcPrefix.Address.Af
2442                 m.R[j1].SrcPrefix.Address.Af = AddressFamily(tmp[pos])
2443                 pos += 1
2444                 // field[4] m.R[j1].SrcPrefix.Address.Un
2445                 copy(m.R[j1].SrcPrefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
2446                 pos += 16
2447                 // field[3] m.R[j1].SrcPrefix.Len
2448                 m.R[j1].SrcPrefix.Len = uint8(tmp[pos])
2449                 pos += 1
2450         }
2451         return nil
2452 }
2453
2454 // MacipACLDump represents VPP binary API message 'macip_acl_dump'.
2455 type MacipACLDump struct {
2456         ACLIndex uint32 `binapi:"u32,name=acl_index,default=4.294967295e+09" json:"acl_index,omitempty"`
2457 }
2458
2459 func (m *MacipACLDump) Reset()                        { *m = MacipACLDump{} }
2460 func (*MacipACLDump) GetMessageName() string          { return "macip_acl_dump" }
2461 func (*MacipACLDump) GetCrcString() string            { return "ef34fea4" }
2462 func (*MacipACLDump) GetMessageType() api.MessageType { return api.RequestMessage }
2463
2464 func (m *MacipACLDump) Size() int {
2465         if m == nil {
2466                 return 0
2467         }
2468         var size int
2469         // field[1] m.ACLIndex
2470         size += 4
2471         return size
2472 }
2473 func (m *MacipACLDump) Marshal(b []byte) ([]byte, error) {
2474         o := binary.BigEndian
2475         _ = o
2476         pos := 0
2477         _ = pos
2478         var buf []byte
2479         if b == nil {
2480                 buf = make([]byte, m.Size())
2481         } else {
2482                 buf = b
2483         }
2484         // field[1] m.ACLIndex
2485         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2486         pos += 4
2487         return buf, nil
2488 }
2489 func (m *MacipACLDump) Unmarshal(tmp []byte) error {
2490         o := binary.BigEndian
2491         _ = o
2492         pos := 0
2493         _ = pos
2494         // field[1] m.ACLIndex
2495         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2496         pos += 4
2497         return nil
2498 }
2499
2500 // MacipACLInterfaceAddDel represents VPP binary API message 'macip_acl_interface_add_del'.
2501 type MacipACLInterfaceAddDel struct {
2502         IsAdd     bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
2503         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2504         ACLIndex  uint32         `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
2505 }
2506
2507 func (m *MacipACLInterfaceAddDel) Reset()                        { *m = MacipACLInterfaceAddDel{} }
2508 func (*MacipACLInterfaceAddDel) GetMessageName() string          { return "macip_acl_interface_add_del" }
2509 func (*MacipACLInterfaceAddDel) GetCrcString() string            { return "4b8690b1" }
2510 func (*MacipACLInterfaceAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
2511
2512 func (m *MacipACLInterfaceAddDel) Size() int {
2513         if m == nil {
2514                 return 0
2515         }
2516         var size int
2517         // field[1] m.IsAdd
2518         size += 1
2519         // field[1] m.SwIfIndex
2520         size += 4
2521         // field[1] m.ACLIndex
2522         size += 4
2523         return size
2524 }
2525 func (m *MacipACLInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
2526         o := binary.BigEndian
2527         _ = o
2528         pos := 0
2529         _ = pos
2530         var buf []byte
2531         if b == nil {
2532                 buf = make([]byte, m.Size())
2533         } else {
2534                 buf = b
2535         }
2536         // field[1] m.IsAdd
2537         if m.IsAdd {
2538                 buf[pos] = 1
2539         }
2540         pos += 1
2541         // field[1] m.SwIfIndex
2542         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2543         pos += 4
2544         // field[1] m.ACLIndex
2545         o.PutUint32(buf[pos:pos+4], uint32(m.ACLIndex))
2546         pos += 4
2547         return buf, nil
2548 }
2549 func (m *MacipACLInterfaceAddDel) Unmarshal(tmp []byte) error {
2550         o := binary.BigEndian
2551         _ = o
2552         pos := 0
2553         _ = pos
2554         // field[1] m.IsAdd
2555         m.IsAdd = tmp[pos] != 0
2556         pos += 1
2557         // field[1] m.SwIfIndex
2558         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2559         pos += 4
2560         // field[1] m.ACLIndex
2561         m.ACLIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2562         pos += 4
2563         return nil
2564 }
2565
2566 // MacipACLInterfaceAddDelReply represents VPP binary API message 'macip_acl_interface_add_del_reply'.
2567 type MacipACLInterfaceAddDelReply struct {
2568         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2569 }
2570
2571 func (m *MacipACLInterfaceAddDelReply) Reset() { *m = MacipACLInterfaceAddDelReply{} }
2572 func (*MacipACLInterfaceAddDelReply) GetMessageName() string {
2573         return "macip_acl_interface_add_del_reply"
2574 }
2575 func (*MacipACLInterfaceAddDelReply) GetCrcString() string            { return "e8d4e804" }
2576 func (*MacipACLInterfaceAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2577
2578 func (m *MacipACLInterfaceAddDelReply) Size() int {
2579         if m == nil {
2580                 return 0
2581         }
2582         var size int
2583         // field[1] m.Retval
2584         size += 4
2585         return size
2586 }
2587 func (m *MacipACLInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
2588         o := binary.BigEndian
2589         _ = o
2590         pos := 0
2591         _ = pos
2592         var buf []byte
2593         if b == nil {
2594                 buf = make([]byte, m.Size())
2595         } else {
2596                 buf = b
2597         }
2598         // field[1] m.Retval
2599         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2600         pos += 4
2601         return buf, nil
2602 }
2603 func (m *MacipACLInterfaceAddDelReply) Unmarshal(tmp []byte) error {
2604         o := binary.BigEndian
2605         _ = o
2606         pos := 0
2607         _ = pos
2608         // field[1] m.Retval
2609         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2610         pos += 4
2611         return nil
2612 }
2613
2614 // MacipACLInterfaceGet represents VPP binary API message 'macip_acl_interface_get'.
2615 type MacipACLInterfaceGet struct{}
2616
2617 func (m *MacipACLInterfaceGet) Reset()                        { *m = MacipACLInterfaceGet{} }
2618 func (*MacipACLInterfaceGet) GetMessageName() string          { return "macip_acl_interface_get" }
2619 func (*MacipACLInterfaceGet) GetCrcString() string            { return "51077d14" }
2620 func (*MacipACLInterfaceGet) GetMessageType() api.MessageType { return api.RequestMessage }
2621
2622 func (m *MacipACLInterfaceGet) Size() int {
2623         if m == nil {
2624                 return 0
2625         }
2626         var size int
2627         return size
2628 }
2629 func (m *MacipACLInterfaceGet) Marshal(b []byte) ([]byte, error) {
2630         o := binary.BigEndian
2631         _ = o
2632         pos := 0
2633         _ = pos
2634         var buf []byte
2635         if b == nil {
2636                 buf = make([]byte, m.Size())
2637         } else {
2638                 buf = b
2639         }
2640         return buf, nil
2641 }
2642 func (m *MacipACLInterfaceGet) Unmarshal(tmp []byte) error {
2643         o := binary.BigEndian
2644         _ = o
2645         pos := 0
2646         _ = pos
2647         return nil
2648 }
2649
2650 // MacipACLInterfaceGetReply represents VPP binary API message 'macip_acl_interface_get_reply'.
2651 type MacipACLInterfaceGetReply struct {
2652         Count uint32   `binapi:"u32,name=count" json:"count,omitempty" struc:"sizeof=Acls"`
2653         Acls  []uint32 `binapi:"u32[count],name=acls" json:"acls,omitempty"`
2654 }
2655
2656 func (m *MacipACLInterfaceGetReply) Reset()                        { *m = MacipACLInterfaceGetReply{} }
2657 func (*MacipACLInterfaceGetReply) GetMessageName() string          { return "macip_acl_interface_get_reply" }
2658 func (*MacipACLInterfaceGetReply) GetCrcString() string            { return "accf9b05" }
2659 func (*MacipACLInterfaceGetReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2660
2661 func (m *MacipACLInterfaceGetReply) Size() int {
2662         if m == nil {
2663                 return 0
2664         }
2665         var size int
2666         // field[1] m.Count
2667         size += 4
2668         // field[1] m.Acls
2669         size += 4 * len(m.Acls)
2670         return size
2671 }
2672 func (m *MacipACLInterfaceGetReply) Marshal(b []byte) ([]byte, error) {
2673         o := binary.BigEndian
2674         _ = o
2675         pos := 0
2676         _ = pos
2677         var buf []byte
2678         if b == nil {
2679                 buf = make([]byte, m.Size())
2680         } else {
2681                 buf = b
2682         }
2683         // field[1] m.Count
2684         o.PutUint32(buf[pos:pos+4], uint32(len(m.Acls)))
2685         pos += 4
2686         // field[1] m.Acls
2687         for i := 0; i < len(m.Acls); i++ {
2688                 var x uint32
2689                 if i < len(m.Acls) {
2690                         x = uint32(m.Acls[i])
2691                 }
2692                 o.PutUint32(buf[pos:pos+4], uint32(x))
2693                 pos += 4
2694         }
2695         return buf, nil
2696 }
2697 func (m *MacipACLInterfaceGetReply) Unmarshal(tmp []byte) error {
2698         o := binary.BigEndian
2699         _ = o
2700         pos := 0
2701         _ = pos
2702         // field[1] m.Count
2703         m.Count = uint32(o.Uint32(tmp[pos : pos+4]))
2704         pos += 4
2705         // field[1] m.Acls
2706         m.Acls = make([]uint32, m.Count)
2707         for i := 0; i < len(m.Acls); i++ {
2708                 m.Acls[i] = uint32(o.Uint32(tmp[pos : pos+4]))
2709                 pos += 4
2710         }
2711         return nil
2712 }
2713
2714 // MacipACLInterfaceListDetails represents VPP binary API message 'macip_acl_interface_list_details'.
2715 type MacipACLInterfaceListDetails struct {
2716         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2717         Count     uint8          `binapi:"u8,name=count" json:"count,omitempty" struc:"sizeof=Acls"`
2718         Acls      []uint32       `binapi:"u32[count],name=acls" json:"acls,omitempty"`
2719 }
2720
2721 func (m *MacipACLInterfaceListDetails) Reset() { *m = MacipACLInterfaceListDetails{} }
2722 func (*MacipACLInterfaceListDetails) GetMessageName() string {
2723         return "macip_acl_interface_list_details"
2724 }
2725 func (*MacipACLInterfaceListDetails) GetCrcString() string            { return "a0c5d56d" }
2726 func (*MacipACLInterfaceListDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
2727
2728 func (m *MacipACLInterfaceListDetails) Size() int {
2729         if m == nil {
2730                 return 0
2731         }
2732         var size int
2733         // field[1] m.SwIfIndex
2734         size += 4
2735         // field[1] m.Count
2736         size += 1
2737         // field[1] m.Acls
2738         size += 4 * len(m.Acls)
2739         return size
2740 }
2741 func (m *MacipACLInterfaceListDetails) Marshal(b []byte) ([]byte, error) {
2742         o := binary.BigEndian
2743         _ = o
2744         pos := 0
2745         _ = pos
2746         var buf []byte
2747         if b == nil {
2748                 buf = make([]byte, m.Size())
2749         } else {
2750                 buf = b
2751         }
2752         // field[1] m.SwIfIndex
2753         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2754         pos += 4
2755         // field[1] m.Count
2756         buf[pos] = uint8(len(m.Acls))
2757         pos += 1
2758         // field[1] m.Acls
2759         for i := 0; i < len(m.Acls); i++ {
2760                 var x uint32
2761                 if i < len(m.Acls) {
2762                         x = uint32(m.Acls[i])
2763                 }
2764                 o.PutUint32(buf[pos:pos+4], uint32(x))
2765                 pos += 4
2766         }
2767         return buf, nil
2768 }
2769 func (m *MacipACLInterfaceListDetails) Unmarshal(tmp []byte) error {
2770         o := binary.BigEndian
2771         _ = o
2772         pos := 0
2773         _ = pos
2774         // field[1] m.SwIfIndex
2775         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2776         pos += 4
2777         // field[1] m.Count
2778         m.Count = uint8(tmp[pos])
2779         pos += 1
2780         // field[1] m.Acls
2781         m.Acls = make([]uint32, m.Count)
2782         for i := 0; i < len(m.Acls); i++ {
2783                 m.Acls[i] = uint32(o.Uint32(tmp[pos : pos+4]))
2784                 pos += 4
2785         }
2786         return nil
2787 }
2788
2789 // MacipACLInterfaceListDump represents VPP binary API message 'macip_acl_interface_list_dump'.
2790 type MacipACLInterfaceListDump struct {
2791         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2792 }
2793
2794 func (m *MacipACLInterfaceListDump) Reset()                        { *m = MacipACLInterfaceListDump{} }
2795 func (*MacipACLInterfaceListDump) GetMessageName() string          { return "macip_acl_interface_list_dump" }
2796 func (*MacipACLInterfaceListDump) GetCrcString() string            { return "f9e6675e" }
2797 func (*MacipACLInterfaceListDump) GetMessageType() api.MessageType { return api.RequestMessage }
2798
2799 func (m *MacipACLInterfaceListDump) Size() int {
2800         if m == nil {
2801                 return 0
2802         }
2803         var size int
2804         // field[1] m.SwIfIndex
2805         size += 4
2806         return size
2807 }
2808 func (m *MacipACLInterfaceListDump) Marshal(b []byte) ([]byte, error) {
2809         o := binary.BigEndian
2810         _ = o
2811         pos := 0
2812         _ = pos
2813         var buf []byte
2814         if b == nil {
2815                 buf = make([]byte, m.Size())
2816         } else {
2817                 buf = b
2818         }
2819         // field[1] m.SwIfIndex
2820         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2821         pos += 4
2822         return buf, nil
2823 }
2824 func (m *MacipACLInterfaceListDump) Unmarshal(tmp []byte) error {
2825         o := binary.BigEndian
2826         _ = o
2827         pos := 0
2828         _ = pos
2829         // field[1] m.SwIfIndex
2830         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2831         pos += 4
2832         return nil
2833 }
2834
2835 func init() { file_acl_binapi_init() }
2836 func file_acl_binapi_init() {
2837         api.RegisterMessage((*ACLAddReplace)(nil), "acl.ACLAddReplace")
2838         api.RegisterMessage((*ACLAddReplaceReply)(nil), "acl.ACLAddReplaceReply")
2839         api.RegisterMessage((*ACLDel)(nil), "acl.ACLDel")
2840         api.RegisterMessage((*ACLDelReply)(nil), "acl.ACLDelReply")
2841         api.RegisterMessage((*ACLDetails)(nil), "acl.ACLDetails")
2842         api.RegisterMessage((*ACLDump)(nil), "acl.ACLDump")
2843         api.RegisterMessage((*ACLInterfaceAddDel)(nil), "acl.ACLInterfaceAddDel")
2844         api.RegisterMessage((*ACLInterfaceAddDelReply)(nil), "acl.ACLInterfaceAddDelReply")
2845         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDetails)(nil), "acl.ACLInterfaceEtypeWhitelistDetails")
2846         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDump)(nil), "acl.ACLInterfaceEtypeWhitelistDump")
2847         api.RegisterMessage((*ACLInterfaceListDetails)(nil), "acl.ACLInterfaceListDetails")
2848         api.RegisterMessage((*ACLInterfaceListDump)(nil), "acl.ACLInterfaceListDump")
2849         api.RegisterMessage((*ACLInterfaceSetACLList)(nil), "acl.ACLInterfaceSetACLList")
2850         api.RegisterMessage((*ACLInterfaceSetACLListReply)(nil), "acl.ACLInterfaceSetACLListReply")
2851         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelist)(nil), "acl.ACLInterfaceSetEtypeWhitelist")
2852         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelistReply)(nil), "acl.ACLInterfaceSetEtypeWhitelistReply")
2853         api.RegisterMessage((*ACLPluginControlPing)(nil), "acl.ACLPluginControlPing")
2854         api.RegisterMessage((*ACLPluginControlPingReply)(nil), "acl.ACLPluginControlPingReply")
2855         api.RegisterMessage((*ACLPluginGetConnTableMaxEntries)(nil), "acl.ACLPluginGetConnTableMaxEntries")
2856         api.RegisterMessage((*ACLPluginGetConnTableMaxEntriesReply)(nil), "acl.ACLPluginGetConnTableMaxEntriesReply")
2857         api.RegisterMessage((*ACLPluginGetVersion)(nil), "acl.ACLPluginGetVersion")
2858         api.RegisterMessage((*ACLPluginGetVersionReply)(nil), "acl.ACLPluginGetVersionReply")
2859         api.RegisterMessage((*ACLStatsIntfCountersEnable)(nil), "acl.ACLStatsIntfCountersEnable")
2860         api.RegisterMessage((*ACLStatsIntfCountersEnableReply)(nil), "acl.ACLStatsIntfCountersEnableReply")
2861         api.RegisterMessage((*MacipACLAdd)(nil), "acl.MacipACLAdd")
2862         api.RegisterMessage((*MacipACLAddReplace)(nil), "acl.MacipACLAddReplace")
2863         api.RegisterMessage((*MacipACLAddReplaceReply)(nil), "acl.MacipACLAddReplaceReply")
2864         api.RegisterMessage((*MacipACLAddReply)(nil), "acl.MacipACLAddReply")
2865         api.RegisterMessage((*MacipACLDel)(nil), "acl.MacipACLDel")
2866         api.RegisterMessage((*MacipACLDelReply)(nil), "acl.MacipACLDelReply")
2867         api.RegisterMessage((*MacipACLDetails)(nil), "acl.MacipACLDetails")
2868         api.RegisterMessage((*MacipACLDump)(nil), "acl.MacipACLDump")
2869         api.RegisterMessage((*MacipACLInterfaceAddDel)(nil), "acl.MacipACLInterfaceAddDel")
2870         api.RegisterMessage((*MacipACLInterfaceAddDelReply)(nil), "acl.MacipACLInterfaceAddDelReply")
2871         api.RegisterMessage((*MacipACLInterfaceGet)(nil), "acl.MacipACLInterfaceGet")
2872         api.RegisterMessage((*MacipACLInterfaceGetReply)(nil), "acl.MacipACLInterfaceGetReply")
2873         api.RegisterMessage((*MacipACLInterfaceListDetails)(nil), "acl.MacipACLInterfaceListDetails")
2874         api.RegisterMessage((*MacipACLInterfaceListDump)(nil), "acl.MacipACLInterfaceListDump")
2875 }
2876
2877 // Messages returns list of all messages in this module.
2878 func AllMessages() []api.Message {
2879         return []api.Message{
2880                 (*ACLAddReplace)(nil),
2881                 (*ACLAddReplaceReply)(nil),
2882                 (*ACLDel)(nil),
2883                 (*ACLDelReply)(nil),
2884                 (*ACLDetails)(nil),
2885                 (*ACLDump)(nil),
2886                 (*ACLInterfaceAddDel)(nil),
2887                 (*ACLInterfaceAddDelReply)(nil),
2888                 (*ACLInterfaceEtypeWhitelistDetails)(nil),
2889                 (*ACLInterfaceEtypeWhitelistDump)(nil),
2890                 (*ACLInterfaceListDetails)(nil),
2891                 (*ACLInterfaceListDump)(nil),
2892                 (*ACLInterfaceSetACLList)(nil),
2893                 (*ACLInterfaceSetACLListReply)(nil),
2894                 (*ACLInterfaceSetEtypeWhitelist)(nil),
2895                 (*ACLInterfaceSetEtypeWhitelistReply)(nil),
2896                 (*ACLPluginControlPing)(nil),
2897                 (*ACLPluginControlPingReply)(nil),
2898                 (*ACLPluginGetConnTableMaxEntries)(nil),
2899                 (*ACLPluginGetConnTableMaxEntriesReply)(nil),
2900                 (*ACLPluginGetVersion)(nil),
2901                 (*ACLPluginGetVersionReply)(nil),
2902                 (*ACLStatsIntfCountersEnable)(nil),
2903                 (*ACLStatsIntfCountersEnableReply)(nil),
2904                 (*MacipACLAdd)(nil),
2905                 (*MacipACLAddReplace)(nil),
2906                 (*MacipACLAddReplaceReply)(nil),
2907                 (*MacipACLAddReply)(nil),
2908                 (*MacipACLDel)(nil),
2909                 (*MacipACLDelReply)(nil),
2910                 (*MacipACLDetails)(nil),
2911                 (*MacipACLDump)(nil),
2912                 (*MacipACLInterfaceAddDel)(nil),
2913                 (*MacipACLInterfaceAddDelReply)(nil),
2914                 (*MacipACLInterfaceGet)(nil),
2915                 (*MacipACLInterfaceGetReply)(nil),
2916                 (*MacipACLInterfaceListDetails)(nil),
2917                 (*MacipACLInterfaceListDump)(nil),
2918         }
2919 }
2920
2921 // Reference imports to suppress errors if they are not otherwise used.
2922 var _ = api.RegisterMessage
2923 var _ = codec.DecodeString
2924 var _ = bytes.NewBuffer
2925 var _ = context.Background
2926 var _ = io.Copy
2927 var _ = strconv.Itoa
2928 var _ = struc.Pack
2929 var _ = binary.BigEndian
2930 var _ = math.Float32bits