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