internal/testbinapi/binapi2001/acl/acl.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.5.0-dev
   4 //  VPP:              20.01
   5 // source: .vppapi/plugins/acl.api.json
   6
   7 // Package acl contains generated bindings for API file acl.api.
   8 //
   9 // Contents:
  10 //   2 structs
  11 //  38 messages
  12 //
  13 package acl
  14
  15 import (
  16         api "git.fd.io/govpp.git/api"
  17         codec "git.fd.io/govpp.git/codec"
  18 )
  19
  20 // This is a compile-time assertion to ensure that this generated file
  21 // is compatible with the GoVPP api package it is being compiled against.
  22 // A compilation error at this line likely means your copy of the
  23 // GoVPP api package needs to be updated.
  24 const _ = api.GoVppAPIPackageIsVersion2
  25
  26 const (
  27         APIFile    = "acl"
  28         APIVersion = "1.0.1"
  29         VersionCrc = 0x11c5c1e5
  30 )
  31
  32 // ACLRule defines type 'acl_rule'.
  33 type ACLRule struct {
  34         IsPermit               uint8  `binapi:"u8,name=is_permit" json:"is_permit,omitempty"`
  35         IsIPv6                 uint8  `binapi:"u8,name=is_ipv6" json:"is_ipv6,omitempty"`
  36         SrcIPAddr              []byte `binapi:"u8[16],name=src_ip_addr" json:"src_ip_addr,omitempty"`
  37         SrcIPPrefixLen         uint8  `binapi:"u8,name=src_ip_prefix_len" json:"src_ip_prefix_len,omitempty"`
  38         DstIPAddr              []byte `binapi:"u8[16],name=dst_ip_addr" json:"dst_ip_addr,omitempty"`
  39         DstIPPrefixLen         uint8  `binapi:"u8,name=dst_ip_prefix_len" json:"dst_ip_prefix_len,omitempty"`
  40         Proto                  uint8  `binapi:"u8,name=proto" json:"proto,omitempty"`
  41         SrcportOrIcmptypeFirst uint16 `binapi:"u16,name=srcport_or_icmptype_first" json:"srcport_or_icmptype_first,omitempty"`
  42         SrcportOrIcmptypeLast  uint16 `binapi:"u16,name=srcport_or_icmptype_last" json:"srcport_or_icmptype_last,omitempty"`
  43         DstportOrIcmpcodeFirst uint16 `binapi:"u16,name=dstport_or_icmpcode_first" json:"dstport_or_icmpcode_first,omitempty"`
  44         DstportOrIcmpcodeLast  uint16 `binapi:"u16,name=dstport_or_icmpcode_last" json:"dstport_or_icmpcode_last,omitempty"`
  45         TCPFlagsMask           uint8  `binapi:"u8,name=tcp_flags_mask" json:"tcp_flags_mask,omitempty"`
  46         TCPFlagsValue          uint8  `binapi:"u8,name=tcp_flags_value" json:"tcp_flags_value,omitempty"`
  47 }
  48
  49 // MacipACLRule defines type 'macip_acl_rule'.
  50 type MacipACLRule struct {
  51         IsPermit       uint8  `binapi:"u8,name=is_permit" json:"is_permit,omitempty"`
  52         IsIPv6         uint8  `binapi:"u8,name=is_ipv6" json:"is_ipv6,omitempty"`
  53         SrcMac         []byte `binapi:"u8[6],name=src_mac" json:"src_mac,omitempty"`
  54         SrcMacMask     []byte `binapi:"u8[6],name=src_mac_mask" json:"src_mac_mask,omitempty"`
  55         SrcIPAddr      []byte `binapi:"u8[16],name=src_ip_addr" json:"src_ip_addr,omitempty"`
  56         SrcIPPrefixLen uint8  `binapi:"u8,name=src_ip_prefix_len" json:"src_ip_prefix_len,omitempty"`
  57 }
  58
  59 // ACLAddReplace defines message 'acl_add_replace'.
  60 type ACLAddReplace struct {
  61         ACLIndex uint32    `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
  62         Tag      []byte    `binapi:"u8[64],name=tag" json:"tag,omitempty"`
  63         Count    uint32    `binapi:"u32,name=count" json:"-"`
  64         R        []ACLRule `binapi:"acl_rule[count],name=r" json:"r,omitempty"`
  65 }
  66
  67 func (m *ACLAddReplace) Reset()               { *m = ACLAddReplace{} }
  68 func (*ACLAddReplace) GetMessageName() string { return "acl_add_replace" }
  69 func (*ACLAddReplace) GetCrcString() string   { return "13bc8539" }
  70 func (*ACLAddReplace) GetMessageType() api.MessageType {
  71         return api.RequestMessage
  72 }
  73
  74 func (m *ACLAddReplace) Size() (size int) {
  75         if m == nil {
  76                 return 0
  77         }
  78         size += 4      // m.ACLIndex
  79         size += 1 * 64 // m.Tag
  80         size += 4      // m.Count
  81         for j1 := 0; j1 < len(m.R); j1++ {
  82                 var s1 ACLRule
  83                 _ = s1
  84                 if j1 < len(m.R) {
  85                         s1 = m.R[j1]
  86                 }
  87                 size += 1      // s1.IsPermit
  88                 size += 1      // s1.IsIPv6
  89                 size += 1 * 16 // s1.SrcIPAddr
  90                 size += 1      // s1.SrcIPPrefixLen
  91                 size += 1 * 16 // s1.DstIPAddr
  92                 size += 1      // s1.DstIPPrefixLen
  93                 size += 1      // s1.Proto
  94                 size += 2      // s1.SrcportOrIcmptypeFirst
  95                 size += 2      // s1.SrcportOrIcmptypeLast
  96                 size += 2      // s1.DstportOrIcmpcodeFirst
  97                 size += 2      // s1.DstportOrIcmpcodeLast
  98                 size += 1      // s1.TCPFlagsMask
  99                 size += 1      // s1.TCPFlagsValue
 100         }
 101         return size
 102 }
 103 func (m *ACLAddReplace) Marshal(b []byte) ([]byte, error) {
 104         if b == nil {
 105                 b = make([]byte, m.Size())
 106         }
 107         buf := codec.NewBuffer(b)
 108         buf.EncodeUint32(m.ACLIndex)
 109         buf.EncodeBytes(m.Tag, 64)
 110         buf.EncodeUint32(uint32(len(m.R)))
 111         for j0 := 0; j0 < len(m.R); j0++ {
 112                 var v0 ACLRule // R
 113                 if j0 < len(m.R) {
 114                         v0 = m.R[j0]
 115                 }
 116                 buf.EncodeUint8(v0.IsPermit)
 117                 buf.EncodeUint8(v0.IsIPv6)
 118                 buf.EncodeBytes(v0.SrcIPAddr, 16)
 119                 buf.EncodeUint8(v0.SrcIPPrefixLen)
 120                 buf.EncodeBytes(v0.DstIPAddr, 16)
 121                 buf.EncodeUint8(v0.DstIPPrefixLen)
 122                 buf.EncodeUint8(v0.Proto)
 123                 buf.EncodeUint16(v0.SrcportOrIcmptypeFirst)
 124                 buf.EncodeUint16(v0.SrcportOrIcmptypeLast)
 125                 buf.EncodeUint16(v0.DstportOrIcmpcodeFirst)
 126                 buf.EncodeUint16(v0.DstportOrIcmpcodeLast)
 127                 buf.EncodeUint8(v0.TCPFlagsMask)
 128                 buf.EncodeUint8(v0.TCPFlagsValue)
 129         }
 130         return buf.Bytes(), nil
 131 }
 132 func (m *ACLAddReplace) Unmarshal(b []byte) error {
 133         buf := codec.NewBuffer(b)
 134         m.ACLIndex = buf.DecodeUint32()
 135         m.Tag = make([]byte, 64)
 136         copy(m.Tag, buf.DecodeBytes(len(m.Tag)))
 137         m.Count = buf.DecodeUint32()
 138         m.R = make([]ACLRule, m.Count)
 139         for j0 := 0; j0 < len(m.R); j0++ {
 140                 m.R[j0].IsPermit = buf.DecodeUint8()
 141                 m.R[j0].IsIPv6 = buf.DecodeUint8()
 142                 m.R[j0].SrcIPAddr = make([]byte, 16)
 143                 copy(m.R[j0].SrcIPAddr, buf.DecodeBytes(len(m.R[j0].SrcIPAddr)))
 144                 m.R[j0].SrcIPPrefixLen = buf.DecodeUint8()
 145                 m.R[j0].DstIPAddr = make([]byte, 16)
 146                 copy(m.R[j0].DstIPAddr, buf.DecodeBytes(len(m.R[j0].DstIPAddr)))
 147                 m.R[j0].DstIPPrefixLen = buf.DecodeUint8()
 148                 m.R[j0].Proto = buf.DecodeUint8()
 149                 m.R[j0].SrcportOrIcmptypeFirst = buf.DecodeUint16()
 150                 m.R[j0].SrcportOrIcmptypeLast = buf.DecodeUint16()
 151                 m.R[j0].DstportOrIcmpcodeFirst = buf.DecodeUint16()
 152                 m.R[j0].DstportOrIcmpcodeLast = buf.DecodeUint16()
 153                 m.R[j0].TCPFlagsMask = buf.DecodeUint8()
 154                 m.R[j0].TCPFlagsValue = buf.DecodeUint8()
 155         }
 156         return nil
 157 }
 158
 159 // ACLAddReplaceReply defines message 'acl_add_replace_reply'.
 160 type ACLAddReplaceReply struct {
 161         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 162         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 163 }
 164
 165 func (m *ACLAddReplaceReply) Reset()               { *m = ACLAddReplaceReply{} }
 166 func (*ACLAddReplaceReply) GetMessageName() string { return "acl_add_replace_reply" }
 167 func (*ACLAddReplaceReply) GetCrcString() string   { return "ac407b0c" }
 168 func (*ACLAddReplaceReply) GetMessageType() api.MessageType {
 169         return api.ReplyMessage
 170 }
 171
 172 func (m *ACLAddReplaceReply) Size() (size int) {
 173         if m == nil {
 174                 return 0
 175         }
 176         size += 4 // m.ACLIndex
 177         size += 4 // m.Retval
 178         return size
 179 }
 180 func (m *ACLAddReplaceReply) Marshal(b []byte) ([]byte, error) {
 181         if b == nil {
 182                 b = make([]byte, m.Size())
 183         }
 184         buf := codec.NewBuffer(b)
 185         buf.EncodeUint32(m.ACLIndex)
 186         buf.EncodeInt32(m.Retval)
 187         return buf.Bytes(), nil
 188 }
 189 func (m *ACLAddReplaceReply) Unmarshal(b []byte) error {
 190         buf := codec.NewBuffer(b)
 191         m.ACLIndex = buf.DecodeUint32()
 192         m.Retval = buf.DecodeInt32()
 193         return nil
 194 }
 195
 196 // ACLDel defines message 'acl_del'.
 197 type ACLDel struct {
 198         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 199 }
 200
 201 func (m *ACLDel) Reset()               { *m = ACLDel{} }
 202 func (*ACLDel) GetMessageName() string { return "acl_del" }
 203 func (*ACLDel) GetCrcString() string   { return "ef34fea4" }
 204 func (*ACLDel) GetMessageType() api.MessageType {
 205         return api.RequestMessage
 206 }
 207
 208 func (m *ACLDel) Size() (size int) {
 209         if m == nil {
 210                 return 0
 211         }
 212         size += 4 // m.ACLIndex
 213         return size
 214 }
 215 func (m *ACLDel) Marshal(b []byte) ([]byte, error) {
 216         if b == nil {
 217                 b = make([]byte, m.Size())
 218         }
 219         buf := codec.NewBuffer(b)
 220         buf.EncodeUint32(m.ACLIndex)
 221         return buf.Bytes(), nil
 222 }
 223 func (m *ACLDel) Unmarshal(b []byte) error {
 224         buf := codec.NewBuffer(b)
 225         m.ACLIndex = buf.DecodeUint32()
 226         return nil
 227 }
 228
 229 // ACLDelReply defines message 'acl_del_reply'.
 230 type ACLDelReply struct {
 231         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 232 }
 233
 234 func (m *ACLDelReply) Reset()               { *m = ACLDelReply{} }
 235 func (*ACLDelReply) GetMessageName() string { return "acl_del_reply" }
 236 func (*ACLDelReply) GetCrcString() string   { return "e8d4e804" }
 237 func (*ACLDelReply) GetMessageType() api.MessageType {
 238         return api.ReplyMessage
 239 }
 240
 241 func (m *ACLDelReply) Size() (size int) {
 242         if m == nil {
 243                 return 0
 244         }
 245         size += 4 // m.Retval
 246         return size
 247 }
 248 func (m *ACLDelReply) Marshal(b []byte) ([]byte, error) {
 249         if b == nil {
 250                 b = make([]byte, m.Size())
 251         }
 252         buf := codec.NewBuffer(b)
 253         buf.EncodeInt32(m.Retval)
 254         return buf.Bytes(), nil
 255 }
 256 func (m *ACLDelReply) Unmarshal(b []byte) error {
 257         buf := codec.NewBuffer(b)
 258         m.Retval = buf.DecodeInt32()
 259         return nil
 260 }
 261
 262 // ACLDetails defines message 'acl_details'.
 263 type ACLDetails struct {
 264         ACLIndex uint32    `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 265         Tag      []byte    `binapi:"u8[64],name=tag" json:"tag,omitempty"`
 266         Count    uint32    `binapi:"u32,name=count" json:"-"`
 267         R        []ACLRule `binapi:"acl_rule[count],name=r" json:"r,omitempty"`
 268 }
 269
 270 func (m *ACLDetails) Reset()               { *m = ACLDetails{} }
 271 func (*ACLDetails) GetMessageName() string { return "acl_details" }
 272 func (*ACLDetails) GetCrcString() string   { return "f89d7a88" }
 273 func (*ACLDetails) GetMessageType() api.MessageType {
 274         return api.ReplyMessage
 275 }
 276
 277 func (m *ACLDetails) Size() (size int) {
 278         if m == nil {
 279                 return 0
 280         }
 281         size += 4      // m.ACLIndex
 282         size += 1 * 64 // m.Tag
 283         size += 4      // m.Count
 284         for j1 := 0; j1 < len(m.R); j1++ {
 285                 var s1 ACLRule
 286                 _ = s1
 287                 if j1 < len(m.R) {
 288                         s1 = m.R[j1]
 289                 }
 290                 size += 1      // s1.IsPermit
 291                 size += 1      // s1.IsIPv6
 292                 size += 1 * 16 // s1.SrcIPAddr
 293                 size += 1      // s1.SrcIPPrefixLen
 294                 size += 1 * 16 // s1.DstIPAddr
 295                 size += 1      // s1.DstIPPrefixLen
 296                 size += 1      // s1.Proto
 297                 size += 2      // s1.SrcportOrIcmptypeFirst
 298                 size += 2      // s1.SrcportOrIcmptypeLast
 299                 size += 2      // s1.DstportOrIcmpcodeFirst
 300                 size += 2      // s1.DstportOrIcmpcodeLast
 301                 size += 1      // s1.TCPFlagsMask
 302                 size += 1      // s1.TCPFlagsValue
 303         }
 304         return size
 305 }
 306 func (m *ACLDetails) Marshal(b []byte) ([]byte, error) {
 307         if b == nil {
 308                 b = make([]byte, m.Size())
 309         }
 310         buf := codec.NewBuffer(b)
 311         buf.EncodeUint32(m.ACLIndex)
 312         buf.EncodeBytes(m.Tag, 64)
 313         buf.EncodeUint32(uint32(len(m.R)))
 314         for j0 := 0; j0 < len(m.R); j0++ {
 315                 var v0 ACLRule // R
 316                 if j0 < len(m.R) {
 317                         v0 = m.R[j0]
 318                 }
 319                 buf.EncodeUint8(v0.IsPermit)
 320                 buf.EncodeUint8(v0.IsIPv6)
 321                 buf.EncodeBytes(v0.SrcIPAddr, 16)
 322                 buf.EncodeUint8(v0.SrcIPPrefixLen)
 323                 buf.EncodeBytes(v0.DstIPAddr, 16)
 324                 buf.EncodeUint8(v0.DstIPPrefixLen)
 325                 buf.EncodeUint8(v0.Proto)
 326                 buf.EncodeUint16(v0.SrcportOrIcmptypeFirst)
 327                 buf.EncodeUint16(v0.SrcportOrIcmptypeLast)
 328                 buf.EncodeUint16(v0.DstportOrIcmpcodeFirst)
 329                 buf.EncodeUint16(v0.DstportOrIcmpcodeLast)
 330                 buf.EncodeUint8(v0.TCPFlagsMask)
 331                 buf.EncodeUint8(v0.TCPFlagsValue)
 332         }
 333         return buf.Bytes(), nil
 334 }
 335 func (m *ACLDetails) Unmarshal(b []byte) error {
 336         buf := codec.NewBuffer(b)
 337         m.ACLIndex = buf.DecodeUint32()
 338         m.Tag = make([]byte, 64)
 339         copy(m.Tag, buf.DecodeBytes(len(m.Tag)))
 340         m.Count = buf.DecodeUint32()
 341         m.R = make([]ACLRule, m.Count)
 342         for j0 := 0; j0 < len(m.R); j0++ {
 343                 m.R[j0].IsPermit = buf.DecodeUint8()
 344                 m.R[j0].IsIPv6 = buf.DecodeUint8()
 345                 m.R[j0].SrcIPAddr = make([]byte, 16)
 346                 copy(m.R[j0].SrcIPAddr, buf.DecodeBytes(len(m.R[j0].SrcIPAddr)))
 347                 m.R[j0].SrcIPPrefixLen = buf.DecodeUint8()
 348                 m.R[j0].DstIPAddr = make([]byte, 16)
 349                 copy(m.R[j0].DstIPAddr, buf.DecodeBytes(len(m.R[j0].DstIPAddr)))
 350                 m.R[j0].DstIPPrefixLen = buf.DecodeUint8()
 351                 m.R[j0].Proto = buf.DecodeUint8()
 352                 m.R[j0].SrcportOrIcmptypeFirst = buf.DecodeUint16()
 353                 m.R[j0].SrcportOrIcmptypeLast = buf.DecodeUint16()
 354                 m.R[j0].DstportOrIcmpcodeFirst = buf.DecodeUint16()
 355                 m.R[j0].DstportOrIcmpcodeLast = buf.DecodeUint16()
 356                 m.R[j0].TCPFlagsMask = buf.DecodeUint8()
 357                 m.R[j0].TCPFlagsValue = buf.DecodeUint8()
 358         }
 359         return nil
 360 }
 361
 362 // ACLDump defines message 'acl_dump'.
 363 type ACLDump struct {
 364         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 365 }
 366
 367 func (m *ACLDump) Reset()               { *m = ACLDump{} }
 368 func (*ACLDump) GetMessageName() string { return "acl_dump" }
 369 func (*ACLDump) GetCrcString() string   { return "ef34fea4" }
 370 func (*ACLDump) GetMessageType() api.MessageType {
 371         return api.RequestMessage
 372 }
 373
 374 func (m *ACLDump) Size() (size int) {
 375         if m == nil {
 376                 return 0
 377         }
 378         size += 4 // m.ACLIndex
 379         return size
 380 }
 381 func (m *ACLDump) Marshal(b []byte) ([]byte, error) {
 382         if b == nil {
 383                 b = make([]byte, m.Size())
 384         }
 385         buf := codec.NewBuffer(b)
 386         buf.EncodeUint32(m.ACLIndex)
 387         return buf.Bytes(), nil
 388 }
 389 func (m *ACLDump) Unmarshal(b []byte) error {
 390         buf := codec.NewBuffer(b)
 391         m.ACLIndex = buf.DecodeUint32()
 392         return nil
 393 }
 394
 395 // ACLInterfaceAddDel defines message 'acl_interface_add_del'.
 396 type ACLInterfaceAddDel struct {
 397         IsAdd     uint8  `binapi:"u8,name=is_add" json:"is_add,omitempty"`
 398         IsInput   uint8  `binapi:"u8,name=is_input" json:"is_input,omitempty"`
 399         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 400         ACLIndex  uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 401 }
 402
 403 func (m *ACLInterfaceAddDel) Reset()               { *m = ACLInterfaceAddDel{} }
 404 func (*ACLInterfaceAddDel) GetMessageName() string { return "acl_interface_add_del" }
 405 func (*ACLInterfaceAddDel) GetCrcString() string   { return "0b2aedd1" }
 406 func (*ACLInterfaceAddDel) GetMessageType() api.MessageType {
 407         return api.RequestMessage
 408 }
 409
 410 func (m *ACLInterfaceAddDel) Size() (size int) {
 411         if m == nil {
 412                 return 0
 413         }
 414         size += 1 // m.IsAdd
 415         size += 1 // m.IsInput
 416         size += 4 // m.SwIfIndex
 417         size += 4 // m.ACLIndex
 418         return size
 419 }
 420 func (m *ACLInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
 421         if b == nil {
 422                 b = make([]byte, m.Size())
 423         }
 424         buf := codec.NewBuffer(b)
 425         buf.EncodeUint8(m.IsAdd)
 426         buf.EncodeUint8(m.IsInput)
 427         buf.EncodeUint32(m.SwIfIndex)
 428         buf.EncodeUint32(m.ACLIndex)
 429         return buf.Bytes(), nil
 430 }
 431 func (m *ACLInterfaceAddDel) Unmarshal(b []byte) error {
 432         buf := codec.NewBuffer(b)
 433         m.IsAdd = buf.DecodeUint8()
 434         m.IsInput = buf.DecodeUint8()
 435         m.SwIfIndex = buf.DecodeUint32()
 436         m.ACLIndex = buf.DecodeUint32()
 437         return nil
 438 }
 439
 440 // ACLInterfaceAddDelReply defines message 'acl_interface_add_del_reply'.
 441 type ACLInterfaceAddDelReply struct {
 442         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 443 }
 444
 445 func (m *ACLInterfaceAddDelReply) Reset()               { *m = ACLInterfaceAddDelReply{} }
 446 func (*ACLInterfaceAddDelReply) GetMessageName() string { return "acl_interface_add_del_reply" }
 447 func (*ACLInterfaceAddDelReply) GetCrcString() string   { return "e8d4e804" }
 448 func (*ACLInterfaceAddDelReply) GetMessageType() api.MessageType {
 449         return api.ReplyMessage
 450 }
 451
 452 func (m *ACLInterfaceAddDelReply) Size() (size int) {
 453         if m == nil {
 454                 return 0
 455         }
 456         size += 4 // m.Retval
 457         return size
 458 }
 459 func (m *ACLInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
 460         if b == nil {
 461                 b = make([]byte, m.Size())
 462         }
 463         buf := codec.NewBuffer(b)
 464         buf.EncodeInt32(m.Retval)
 465         return buf.Bytes(), nil
 466 }
 467 func (m *ACLInterfaceAddDelReply) Unmarshal(b []byte) error {
 468         buf := codec.NewBuffer(b)
 469         m.Retval = buf.DecodeInt32()
 470         return nil
 471 }
 472
 473 // ACLInterfaceEtypeWhitelistDetails defines message 'acl_interface_etype_whitelist_details'.
 474 type ACLInterfaceEtypeWhitelistDetails struct {
 475         SwIfIndex uint32   `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 476         Count     uint8    `binapi:"u8,name=count" json:"-"`
 477         NInput    uint8    `binapi:"u8,name=n_input" json:"n_input,omitempty"`
 478         Whitelist []uint16 `binapi:"u16[count],name=whitelist" json:"whitelist,omitempty"`
 479 }
 480
 481 func (m *ACLInterfaceEtypeWhitelistDetails) Reset() { *m = ACLInterfaceEtypeWhitelistDetails{} }
 482 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageName() string {
 483         return "acl_interface_etype_whitelist_details"
 484 }
 485 func (*ACLInterfaceEtypeWhitelistDetails) GetCrcString() string { return "6a5d4e81" }
 486 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageType() api.MessageType {
 487         return api.ReplyMessage
 488 }
 489
 490 func (m *ACLInterfaceEtypeWhitelistDetails) Size() (size int) {
 491         if m == nil {
 492                 return 0
 493         }
 494         size += 4                    // m.SwIfIndex
 495         size += 1                    // m.Count
 496         size += 1                    // m.NInput
 497         size += 2 * len(m.Whitelist) // m.Whitelist
 498         return size
 499 }
 500 func (m *ACLInterfaceEtypeWhitelistDetails) Marshal(b []byte) ([]byte, error) {
 501         if b == nil {
 502                 b = make([]byte, m.Size())
 503         }
 504         buf := codec.NewBuffer(b)
 505         buf.EncodeUint32(m.SwIfIndex)
 506         buf.EncodeUint8(uint8(len(m.Whitelist)))
 507         buf.EncodeUint8(m.NInput)
 508         for i := 0; i < len(m.Whitelist); i++ {
 509                 var x uint16
 510                 if i < len(m.Whitelist) {
 511                         x = uint16(m.Whitelist[i])
 512                 }
 513                 buf.EncodeUint16(x)
 514         }
 515         return buf.Bytes(), nil
 516 }
 517 func (m *ACLInterfaceEtypeWhitelistDetails) Unmarshal(b []byte) error {
 518         buf := codec.NewBuffer(b)
 519         m.SwIfIndex = buf.DecodeUint32()
 520         m.Count = buf.DecodeUint8()
 521         m.NInput = buf.DecodeUint8()
 522         m.Whitelist = make([]uint16, m.Count)
 523         for i := 0; i < len(m.Whitelist); i++ {
 524                 m.Whitelist[i] = buf.DecodeUint16()
 525         }
 526         return nil
 527 }
 528
 529 // ACLInterfaceEtypeWhitelistDump defines message 'acl_interface_etype_whitelist_dump'.
 530 type ACLInterfaceEtypeWhitelistDump struct {
 531         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 532 }
 533
 534 func (m *ACLInterfaceEtypeWhitelistDump) Reset() { *m = ACLInterfaceEtypeWhitelistDump{} }
 535 func (*ACLInterfaceEtypeWhitelistDump) GetMessageName() string {
 536         return "acl_interface_etype_whitelist_dump"
 537 }
 538 func (*ACLInterfaceEtypeWhitelistDump) GetCrcString() string { return "529cb13f" }
 539 func (*ACLInterfaceEtypeWhitelistDump) GetMessageType() api.MessageType {
 540         return api.RequestMessage
 541 }
 542
 543 func (m *ACLInterfaceEtypeWhitelistDump) Size() (size int) {
 544         if m == nil {
 545                 return 0
 546         }
 547         size += 4 // m.SwIfIndex
 548         return size
 549 }
 550 func (m *ACLInterfaceEtypeWhitelistDump) Marshal(b []byte) ([]byte, error) {
 551         if b == nil {
 552                 b = make([]byte, m.Size())
 553         }
 554         buf := codec.NewBuffer(b)
 555         buf.EncodeUint32(m.SwIfIndex)
 556         return buf.Bytes(), nil
 557 }
 558 func (m *ACLInterfaceEtypeWhitelistDump) Unmarshal(b []byte) error {
 559         buf := codec.NewBuffer(b)
 560         m.SwIfIndex = buf.DecodeUint32()
 561         return nil
 562 }
 563
 564 // ACLInterfaceListDetails defines message 'acl_interface_list_details'.
 565 type ACLInterfaceListDetails struct {
 566         SwIfIndex uint32   `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 567         Count     uint8    `binapi:"u8,name=count" json:"-"`
 568         NInput    uint8    `binapi:"u8,name=n_input" json:"n_input,omitempty"`
 569         Acls      []uint32 `binapi:"u32[count],name=acls" json:"acls,omitempty"`
 570 }
 571
 572 func (m *ACLInterfaceListDetails) Reset()               { *m = ACLInterfaceListDetails{} }
 573 func (*ACLInterfaceListDetails) GetMessageName() string { return "acl_interface_list_details" }
 574 func (*ACLInterfaceListDetails) GetCrcString() string   { return "d5e80809" }
 575 func (*ACLInterfaceListDetails) GetMessageType() api.MessageType {
 576         return api.ReplyMessage
 577 }
 578
 579 func (m *ACLInterfaceListDetails) Size() (size int) {
 580         if m == nil {
 581                 return 0
 582         }
 583         size += 4               // m.SwIfIndex
 584         size += 1               // m.Count
 585         size += 1               // m.NInput
 586         size += 4 * len(m.Acls) // m.Acls
 587         return size
 588 }
 589 func (m *ACLInterfaceListDetails) Marshal(b []byte) ([]byte, error) {
 590         if b == nil {
 591                 b = make([]byte, m.Size())
 592         }
 593         buf := codec.NewBuffer(b)
 594         buf.EncodeUint32(m.SwIfIndex)
 595         buf.EncodeUint8(uint8(len(m.Acls)))
 596         buf.EncodeUint8(m.NInput)
 597         for i := 0; i < len(m.Acls); i++ {
 598                 var x uint32
 599                 if i < len(m.Acls) {
 600                         x = uint32(m.Acls[i])
 601                 }
 602                 buf.EncodeUint32(x)
 603         }
 604         return buf.Bytes(), nil
 605 }
 606 func (m *ACLInterfaceListDetails) Unmarshal(b []byte) error {
 607         buf := codec.NewBuffer(b)
 608         m.SwIfIndex = buf.DecodeUint32()
 609         m.Count = buf.DecodeUint8()
 610         m.NInput = buf.DecodeUint8()
 611         m.Acls = make([]uint32, m.Count)
 612         for i := 0; i < len(m.Acls); i++ {
 613                 m.Acls[i] = buf.DecodeUint32()
 614         }
 615         return nil
 616 }
 617
 618 // ACLInterfaceListDump defines message 'acl_interface_list_dump'.
 619 type ACLInterfaceListDump struct {
 620         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 621 }
 622
 623 func (m *ACLInterfaceListDump) Reset()               { *m = ACLInterfaceListDump{} }
 624 func (*ACLInterfaceListDump) GetMessageName() string { return "acl_interface_list_dump" }
 625 func (*ACLInterfaceListDump) GetCrcString() string   { return "529cb13f" }
 626 func (*ACLInterfaceListDump) GetMessageType() api.MessageType {
 627         return api.RequestMessage
 628 }
 629
 630 func (m *ACLInterfaceListDump) Size() (size int) {
 631         if m == nil {
 632                 return 0
 633         }
 634         size += 4 // m.SwIfIndex
 635         return size
 636 }
 637 func (m *ACLInterfaceListDump) Marshal(b []byte) ([]byte, error) {
 638         if b == nil {
 639                 b = make([]byte, m.Size())
 640         }
 641         buf := codec.NewBuffer(b)
 642         buf.EncodeUint32(m.SwIfIndex)
 643         return buf.Bytes(), nil
 644 }
 645 func (m *ACLInterfaceListDump) Unmarshal(b []byte) error {
 646         buf := codec.NewBuffer(b)
 647         m.SwIfIndex = buf.DecodeUint32()
 648         return nil
 649 }
 650
 651 // ACLInterfaceSetACLList defines message 'acl_interface_set_acl_list'.
 652 type ACLInterfaceSetACLList struct {
 653         SwIfIndex uint32   `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 654         Count     uint8    `binapi:"u8,name=count" json:"-"`
 655         NInput    uint8    `binapi:"u8,name=n_input" json:"n_input,omitempty"`
 656         Acls      []uint32 `binapi:"u32[count],name=acls" json:"acls,omitempty"`
 657 }
 658
 659 func (m *ACLInterfaceSetACLList) Reset()               { *m = ACLInterfaceSetACLList{} }
 660 func (*ACLInterfaceSetACLList) GetMessageName() string { return "acl_interface_set_acl_list" }
 661 func (*ACLInterfaceSetACLList) GetCrcString() string   { return "8baece38" }
 662 func (*ACLInterfaceSetACLList) GetMessageType() api.MessageType {
 663         return api.RequestMessage
 664 }
 665
 666 func (m *ACLInterfaceSetACLList) Size() (size int) {
 667         if m == nil {
 668                 return 0
 669         }
 670         size += 4               // m.SwIfIndex
 671         size += 1               // m.Count
 672         size += 1               // m.NInput
 673         size += 4 * len(m.Acls) // m.Acls
 674         return size
 675 }
 676 func (m *ACLInterfaceSetACLList) Marshal(b []byte) ([]byte, error) {
 677         if b == nil {
 678                 b = make([]byte, m.Size())
 679         }
 680         buf := codec.NewBuffer(b)
 681         buf.EncodeUint32(m.SwIfIndex)
 682         buf.EncodeUint8(uint8(len(m.Acls)))
 683         buf.EncodeUint8(m.NInput)
 684         for i := 0; i < len(m.Acls); i++ {
 685                 var x uint32
 686                 if i < len(m.Acls) {
 687                         x = uint32(m.Acls[i])
 688                 }
 689                 buf.EncodeUint32(x)
 690         }
 691         return buf.Bytes(), nil
 692 }
 693 func (m *ACLInterfaceSetACLList) Unmarshal(b []byte) error {
 694         buf := codec.NewBuffer(b)
 695         m.SwIfIndex = buf.DecodeUint32()
 696         m.Count = buf.DecodeUint8()
 697         m.NInput = buf.DecodeUint8()
 698         m.Acls = make([]uint32, m.Count)
 699         for i := 0; i < len(m.Acls); i++ {
 700                 m.Acls[i] = buf.DecodeUint32()
 701         }
 702         return nil
 703 }
 704
 705 // ACLInterfaceSetACLListReply defines message 'acl_interface_set_acl_list_reply'.
 706 type ACLInterfaceSetACLListReply struct {
 707         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 708 }
 709
 710 func (m *ACLInterfaceSetACLListReply) Reset() { *m = ACLInterfaceSetACLListReply{} }
 711 func (*ACLInterfaceSetACLListReply) GetMessageName() string {
 712         return "acl_interface_set_acl_list_reply"
 713 }
 714 func (*ACLInterfaceSetACLListReply) GetCrcString() string { return "e8d4e804" }
 715 func (*ACLInterfaceSetACLListReply) GetMessageType() api.MessageType {
 716         return api.ReplyMessage
 717 }
 718
 719 func (m *ACLInterfaceSetACLListReply) Size() (size int) {
 720         if m == nil {
 721                 return 0
 722         }
 723         size += 4 // m.Retval
 724         return size
 725 }
 726 func (m *ACLInterfaceSetACLListReply) Marshal(b []byte) ([]byte, error) {
 727         if b == nil {
 728                 b = make([]byte, m.Size())
 729         }
 730         buf := codec.NewBuffer(b)
 731         buf.EncodeInt32(m.Retval)
 732         return buf.Bytes(), nil
 733 }
 734 func (m *ACLInterfaceSetACLListReply) Unmarshal(b []byte) error {
 735         buf := codec.NewBuffer(b)
 736         m.Retval = buf.DecodeInt32()
 737         return nil
 738 }
 739
 740 // ACLInterfaceSetEtypeWhitelist defines message 'acl_interface_set_etype_whitelist'.
 741 type ACLInterfaceSetEtypeWhitelist struct {
 742         SwIfIndex uint32   `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 743         Count     uint8    `binapi:"u8,name=count" json:"-"`
 744         NInput    uint8    `binapi:"u8,name=n_input" json:"n_input,omitempty"`
 745         Whitelist []uint16 `binapi:"u16[count],name=whitelist" json:"whitelist,omitempty"`
 746 }
 747
 748 func (m *ACLInterfaceSetEtypeWhitelist) Reset() { *m = ACLInterfaceSetEtypeWhitelist{} }
 749 func (*ACLInterfaceSetEtypeWhitelist) GetMessageName() string {
 750         return "acl_interface_set_etype_whitelist"
 751 }
 752 func (*ACLInterfaceSetEtypeWhitelist) GetCrcString() string { return "f515efc5" }
 753 func (*ACLInterfaceSetEtypeWhitelist) GetMessageType() api.MessageType {
 754         return api.RequestMessage
 755 }
 756
 757 func (m *ACLInterfaceSetEtypeWhitelist) Size() (size int) {
 758         if m == nil {
 759                 return 0
 760         }
 761         size += 4                    // m.SwIfIndex
 762         size += 1                    // m.Count
 763         size += 1                    // m.NInput
 764         size += 2 * len(m.Whitelist) // m.Whitelist
 765         return size
 766 }
 767 func (m *ACLInterfaceSetEtypeWhitelist) Marshal(b []byte) ([]byte, error) {
 768         if b == nil {
 769                 b = make([]byte, m.Size())
 770         }
 771         buf := codec.NewBuffer(b)
 772         buf.EncodeUint32(m.SwIfIndex)
 773         buf.EncodeUint8(uint8(len(m.Whitelist)))
 774         buf.EncodeUint8(m.NInput)
 775         for i := 0; i < len(m.Whitelist); i++ {
 776                 var x uint16
 777                 if i < len(m.Whitelist) {
 778                         x = uint16(m.Whitelist[i])
 779                 }
 780                 buf.EncodeUint16(x)
 781         }
 782         return buf.Bytes(), nil
 783 }
 784 func (m *ACLInterfaceSetEtypeWhitelist) Unmarshal(b []byte) error {
 785         buf := codec.NewBuffer(b)
 786         m.SwIfIndex = buf.DecodeUint32()
 787         m.Count = buf.DecodeUint8()
 788         m.NInput = buf.DecodeUint8()
 789         m.Whitelist = make([]uint16, m.Count)
 790         for i := 0; i < len(m.Whitelist); i++ {
 791                 m.Whitelist[i] = buf.DecodeUint16()
 792         }
 793         return nil
 794 }
 795
 796 // ACLInterfaceSetEtypeWhitelistReply defines message 'acl_interface_set_etype_whitelist_reply'.
 797 type ACLInterfaceSetEtypeWhitelistReply struct {
 798         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 799 }
 800
 801 func (m *ACLInterfaceSetEtypeWhitelistReply) Reset() { *m = ACLInterfaceSetEtypeWhitelistReply{} }
 802 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageName() string {
 803         return "acl_interface_set_etype_whitelist_reply"
 804 }
 805 func (*ACLInterfaceSetEtypeWhitelistReply) GetCrcString() string { return "e8d4e804" }
 806 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageType() api.MessageType {
 807         return api.ReplyMessage
 808 }
 809
 810 func (m *ACLInterfaceSetEtypeWhitelistReply) Size() (size int) {
 811         if m == nil {
 812                 return 0
 813         }
 814         size += 4 // m.Retval
 815         return size
 816 }
 817 func (m *ACLInterfaceSetEtypeWhitelistReply) Marshal(b []byte) ([]byte, error) {
 818         if b == nil {
 819                 b = make([]byte, m.Size())
 820         }
 821         buf := codec.NewBuffer(b)
 822         buf.EncodeInt32(m.Retval)
 823         return buf.Bytes(), nil
 824 }
 825 func (m *ACLInterfaceSetEtypeWhitelistReply) Unmarshal(b []byte) error {
 826         buf := codec.NewBuffer(b)
 827         m.Retval = buf.DecodeInt32()
 828         return nil
 829 }
 830
 831 // ACLPluginControlPing defines message 'acl_plugin_control_ping'.
 832 type ACLPluginControlPing struct{}
 833
 834 func (m *ACLPluginControlPing) Reset()               { *m = ACLPluginControlPing{} }
 835 func (*ACLPluginControlPing) GetMessageName() string { return "acl_plugin_control_ping" }
 836 func (*ACLPluginControlPing) GetCrcString() string   { return "51077d14" }
 837 func (*ACLPluginControlPing) GetMessageType() api.MessageType {
 838         return api.RequestMessage
 839 }
 840
 841 func (m *ACLPluginControlPing) Size() (size int) {
 842         if m == nil {
 843                 return 0
 844         }
 845         return size
 846 }
 847 func (m *ACLPluginControlPing) Marshal(b []byte) ([]byte, error) {
 848         if b == nil {
 849                 b = make([]byte, m.Size())
 850         }
 851         buf := codec.NewBuffer(b)
 852         return buf.Bytes(), nil
 853 }
 854 func (m *ACLPluginControlPing) Unmarshal(b []byte) error {
 855         return nil
 856 }
 857
 858 // ACLPluginControlPingReply defines message 'acl_plugin_control_ping_reply'.
 859 type ACLPluginControlPingReply struct {
 860         Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 861         ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
 862         VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
 863 }
 864
 865 func (m *ACLPluginControlPingReply) Reset()               { *m = ACLPluginControlPingReply{} }
 866 func (*ACLPluginControlPingReply) GetMessageName() string { return "acl_plugin_control_ping_reply" }
 867 func (*ACLPluginControlPingReply) GetCrcString() string   { return "f6b0b8ca" }
 868 func (*ACLPluginControlPingReply) GetMessageType() api.MessageType {
 869         return api.ReplyMessage
 870 }
 871
 872 func (m *ACLPluginControlPingReply) Size() (size int) {
 873         if m == nil {
 874                 return 0
 875         }
 876         size += 4 // m.Retval
 877         size += 4 // m.ClientIndex
 878         size += 4 // m.VpePID
 879         return size
 880 }
 881 func (m *ACLPluginControlPingReply) Marshal(b []byte) ([]byte, error) {
 882         if b == nil {
 883                 b = make([]byte, m.Size())
 884         }
 885         buf := codec.NewBuffer(b)
 886         buf.EncodeInt32(m.Retval)
 887         buf.EncodeUint32(m.ClientIndex)
 888         buf.EncodeUint32(m.VpePID)
 889         return buf.Bytes(), nil
 890 }
 891 func (m *ACLPluginControlPingReply) Unmarshal(b []byte) error {
 892         buf := codec.NewBuffer(b)
 893         m.Retval = buf.DecodeInt32()
 894         m.ClientIndex = buf.DecodeUint32()
 895         m.VpePID = buf.DecodeUint32()
 896         return nil
 897 }
 898
 899 // ACLPluginGetConnTableMaxEntries defines message 'acl_plugin_get_conn_table_max_entries'.
 900 type ACLPluginGetConnTableMaxEntries struct{}
 901
 902 func (m *ACLPluginGetConnTableMaxEntries) Reset() { *m = ACLPluginGetConnTableMaxEntries{} }
 903 func (*ACLPluginGetConnTableMaxEntries) GetMessageName() string {
 904         return "acl_plugin_get_conn_table_max_entries"
 905 }
 906 func (*ACLPluginGetConnTableMaxEntries) GetCrcString() string { return "51077d14" }
 907 func (*ACLPluginGetConnTableMaxEntries) GetMessageType() api.MessageType {
 908         return api.RequestMessage
 909 }
 910
 911 func (m *ACLPluginGetConnTableMaxEntries) Size() (size int) {
 912         if m == nil {
 913                 return 0
 914         }
 915         return size
 916 }
 917 func (m *ACLPluginGetConnTableMaxEntries) Marshal(b []byte) ([]byte, error) {
 918         if b == nil {
 919                 b = make([]byte, m.Size())
 920         }
 921         buf := codec.NewBuffer(b)
 922         return buf.Bytes(), nil
 923 }
 924 func (m *ACLPluginGetConnTableMaxEntries) Unmarshal(b []byte) error {
 925         return nil
 926 }
 927
 928 // ACLPluginGetConnTableMaxEntriesReply defines message 'acl_plugin_get_conn_table_max_entries_reply'.
 929 type ACLPluginGetConnTableMaxEntriesReply struct {
 930         ConnTableMaxEntries uint64 `binapi:"u64,name=conn_table_max_entries" json:"conn_table_max_entries,omitempty"`
 931 }
 932
 933 func (m *ACLPluginGetConnTableMaxEntriesReply) Reset() { *m = ACLPluginGetConnTableMaxEntriesReply{} }
 934 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageName() string {
 935         return "acl_plugin_get_conn_table_max_entries_reply"
 936 }
 937 func (*ACLPluginGetConnTableMaxEntriesReply) GetCrcString() string { return "7a096d3d" }
 938 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageType() api.MessageType {
 939         return api.ReplyMessage
 940 }
 941
 942 func (m *ACLPluginGetConnTableMaxEntriesReply) Size() (size int) {
 943         if m == nil {
 944                 return 0
 945         }
 946         size += 8 // m.ConnTableMaxEntries
 947         return size
 948 }
 949 func (m *ACLPluginGetConnTableMaxEntriesReply) Marshal(b []byte) ([]byte, error) {
 950         if b == nil {
 951                 b = make([]byte, m.Size())
 952         }
 953         buf := codec.NewBuffer(b)
 954         buf.EncodeUint64(m.ConnTableMaxEntries)
 955         return buf.Bytes(), nil
 956 }
 957 func (m *ACLPluginGetConnTableMaxEntriesReply) Unmarshal(b []byte) error {
 958         buf := codec.NewBuffer(b)
 959         m.ConnTableMaxEntries = buf.DecodeUint64()
 960         return nil
 961 }
 962
 963 // ACLPluginGetVersion defines message 'acl_plugin_get_version'.
 964 type ACLPluginGetVersion struct{}
 965
 966 func (m *ACLPluginGetVersion) Reset()               { *m = ACLPluginGetVersion{} }
 967 func (*ACLPluginGetVersion) GetMessageName() string { return "acl_plugin_get_version" }
 968 func (*ACLPluginGetVersion) GetCrcString() string   { return "51077d14" }
 969 func (*ACLPluginGetVersion) GetMessageType() api.MessageType {
 970         return api.RequestMessage
 971 }
 972
 973 func (m *ACLPluginGetVersion) Size() (size int) {
 974         if m == nil {
 975                 return 0
 976         }
 977         return size
 978 }
 979 func (m *ACLPluginGetVersion) Marshal(b []byte) ([]byte, error) {
 980         if b == nil {
 981                 b = make([]byte, m.Size())
 982         }
 983         buf := codec.NewBuffer(b)
 984         return buf.Bytes(), nil
 985 }
 986 func (m *ACLPluginGetVersion) Unmarshal(b []byte) error {
 987         return nil
 988 }
 989
 990 // ACLPluginGetVersionReply defines message 'acl_plugin_get_version_reply'.
 991 type ACLPluginGetVersionReply struct {
 992         Major uint32 `binapi:"u32,name=major" json:"major,omitempty"`
 993         Minor uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
 994 }
 995
 996 func (m *ACLPluginGetVersionReply) Reset()               { *m = ACLPluginGetVersionReply{} }
 997 func (*ACLPluginGetVersionReply) GetMessageName() string { return "acl_plugin_get_version_reply" }
 998 func (*ACLPluginGetVersionReply) GetCrcString() string   { return "9b32cf86" }
 999 func (*ACLPluginGetVersionReply) GetMessageType() api.MessageType {
1000         return api.ReplyMessage
1001 }
1002
1003 func (m *ACLPluginGetVersionReply) Size() (size int) {
1004         if m == nil {
1005                 return 0
1006         }
1007         size += 4 // m.Major
1008         size += 4 // m.Minor
1009         return size
1010 }
1011 func (m *ACLPluginGetVersionReply) Marshal(b []byte) ([]byte, error) {
1012         if b == nil {
1013                 b = make([]byte, m.Size())
1014         }
1015         buf := codec.NewBuffer(b)
1016         buf.EncodeUint32(m.Major)
1017         buf.EncodeUint32(m.Minor)
1018         return buf.Bytes(), nil
1019 }
1020 func (m *ACLPluginGetVersionReply) Unmarshal(b []byte) error {
1021         buf := codec.NewBuffer(b)
1022         m.Major = buf.DecodeUint32()
1023         m.Minor = buf.DecodeUint32()
1024         return nil
1025 }
1026
1027 // ACLStatsIntfCountersEnable defines message 'acl_stats_intf_counters_enable'.
1028 type ACLStatsIntfCountersEnable struct {
1029         Enable bool `binapi:"bool,name=enable" json:"enable,omitempty"`
1030 }
1031
1032 func (m *ACLStatsIntfCountersEnable) Reset()               { *m = ACLStatsIntfCountersEnable{} }
1033 func (*ACLStatsIntfCountersEnable) GetMessageName() string { return "acl_stats_intf_counters_enable" }
1034 func (*ACLStatsIntfCountersEnable) GetCrcString() string   { return "b3e225d2" }
1035 func (*ACLStatsIntfCountersEnable) GetMessageType() api.MessageType {
1036         return api.RequestMessage
1037 }
1038
1039 func (m *ACLStatsIntfCountersEnable) Size() (size int) {
1040         if m == nil {
1041                 return 0
1042         }
1043         size += 1 // m.Enable
1044         return size
1045 }
1046 func (m *ACLStatsIntfCountersEnable) Marshal(b []byte) ([]byte, error) {
1047         if b == nil {
1048                 b = make([]byte, m.Size())
1049         }
1050         buf := codec.NewBuffer(b)
1051         buf.EncodeBool(m.Enable)
1052         return buf.Bytes(), nil
1053 }
1054 func (m *ACLStatsIntfCountersEnable) Unmarshal(b []byte) error {
1055         buf := codec.NewBuffer(b)
1056         m.Enable = buf.DecodeBool()
1057         return nil
1058 }
1059
1060 // ACLStatsIntfCountersEnableReply defines message 'acl_stats_intf_counters_enable_reply'.
1061 type ACLStatsIntfCountersEnableReply struct {
1062         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1063 }
1064
1065 func (m *ACLStatsIntfCountersEnableReply) Reset() { *m = ACLStatsIntfCountersEnableReply{} }
1066 func (*ACLStatsIntfCountersEnableReply) GetMessageName() string {
1067         return "acl_stats_intf_counters_enable_reply"
1068 }
1069 func (*ACLStatsIntfCountersEnableReply) GetCrcString() string { return "e8d4e804" }
1070 func (*ACLStatsIntfCountersEnableReply) GetMessageType() api.MessageType {
1071         return api.ReplyMessage
1072 }
1073
1074 func (m *ACLStatsIntfCountersEnableReply) Size() (size int) {
1075         if m == nil {
1076                 return 0
1077         }
1078         size += 4 // m.Retval
1079         return size
1080 }
1081 func (m *ACLStatsIntfCountersEnableReply) Marshal(b []byte) ([]byte, error) {
1082         if b == nil {
1083                 b = make([]byte, m.Size())
1084         }
1085         buf := codec.NewBuffer(b)
1086         buf.EncodeInt32(m.Retval)
1087         return buf.Bytes(), nil
1088 }
1089 func (m *ACLStatsIntfCountersEnableReply) Unmarshal(b []byte) error {
1090         buf := codec.NewBuffer(b)
1091         m.Retval = buf.DecodeInt32()
1092         return nil
1093 }
1094
1095 // MacipACLAdd defines message 'macip_acl_add'.
1096 type MacipACLAdd struct {
1097         Tag   []byte         `binapi:"u8[64],name=tag" json:"tag,omitempty"`
1098         Count uint32         `binapi:"u32,name=count" json:"-"`
1099         R     []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
1100 }
1101
1102 func (m *MacipACLAdd) Reset()               { *m = MacipACLAdd{} }
1103 func (*MacipACLAdd) GetMessageName() string { return "macip_acl_add" }
1104 func (*MacipACLAdd) GetCrcString() string   { return "0c680ca5" }
1105 func (*MacipACLAdd) GetMessageType() api.MessageType {
1106         return api.RequestMessage
1107 }
1108
1109 func (m *MacipACLAdd) Size() (size int) {
1110         if m == nil {
1111                 return 0
1112         }
1113         size += 1 * 64 // m.Tag
1114         size += 4      // m.Count
1115         for j1 := 0; j1 < len(m.R); j1++ {
1116                 var s1 MacipACLRule
1117                 _ = s1
1118                 if j1 < len(m.R) {
1119                         s1 = m.R[j1]
1120                 }
1121                 size += 1      // s1.IsPermit
1122                 size += 1      // s1.IsIPv6
1123                 size += 1 * 6  // s1.SrcMac
1124                 size += 1 * 6  // s1.SrcMacMask
1125                 size += 1 * 16 // s1.SrcIPAddr
1126                 size += 1      // s1.SrcIPPrefixLen
1127         }
1128         return size
1129 }
1130 func (m *MacipACLAdd) Marshal(b []byte) ([]byte, error) {
1131         if b == nil {
1132                 b = make([]byte, m.Size())
1133         }
1134         buf := codec.NewBuffer(b)
1135         buf.EncodeBytes(m.Tag, 64)
1136         buf.EncodeUint32(uint32(len(m.R)))
1137         for j0 := 0; j0 < len(m.R); j0++ {
1138                 var v0 MacipACLRule // R
1139                 if j0 < len(m.R) {
1140                         v0 = m.R[j0]
1141                 }
1142                 buf.EncodeUint8(v0.IsPermit)
1143                 buf.EncodeUint8(v0.IsIPv6)
1144                 buf.EncodeBytes(v0.SrcMac, 6)
1145                 buf.EncodeBytes(v0.SrcMacMask, 6)
1146                 buf.EncodeBytes(v0.SrcIPAddr, 16)
1147                 buf.EncodeUint8(v0.SrcIPPrefixLen)
1148         }
1149         return buf.Bytes(), nil
1150 }
1151 func (m *MacipACLAdd) Unmarshal(b []byte) error {
1152         buf := codec.NewBuffer(b)
1153         m.Tag = make([]byte, 64)
1154         copy(m.Tag, buf.DecodeBytes(len(m.Tag)))
1155         m.Count = buf.DecodeUint32()
1156         m.R = make([]MacipACLRule, m.Count)
1157         for j0 := 0; j0 < len(m.R); j0++ {
1158                 m.R[j0].IsPermit = buf.DecodeUint8()
1159                 m.R[j0].IsIPv6 = buf.DecodeUint8()
1160                 m.R[j0].SrcMac = make([]byte, 6)
1161                 copy(m.R[j0].SrcMac, buf.DecodeBytes(len(m.R[j0].SrcMac)))
1162                 m.R[j0].SrcMacMask = make([]byte, 6)
1163                 copy(m.R[j0].SrcMacMask, buf.DecodeBytes(len(m.R[j0].SrcMacMask)))
1164                 m.R[j0].SrcIPAddr = make([]byte, 16)
1165                 copy(m.R[j0].SrcIPAddr, buf.DecodeBytes(len(m.R[j0].SrcIPAddr)))
1166                 m.R[j0].SrcIPPrefixLen = buf.DecodeUint8()
1167         }
1168         return nil
1169 }
1170
1171 // MacipACLAddReplace defines message 'macip_acl_add_replace'.
1172 type MacipACLAddReplace struct {
1173         ACLIndex uint32         `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1174         Tag      []byte         `binapi:"u8[64],name=tag" json:"tag,omitempty"`
1175         Count    uint32         `binapi:"u32,name=count" json:"-"`
1176         R        []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
1177 }
1178
1179 func (m *MacipACLAddReplace) Reset()               { *m = MacipACLAddReplace{} }
1180 func (*MacipACLAddReplace) GetMessageName() string { return "macip_acl_add_replace" }
1181 func (*MacipACLAddReplace) GetCrcString() string   { return "d3d313e7" }
1182 func (*MacipACLAddReplace) GetMessageType() api.MessageType {
1183         return api.RequestMessage
1184 }
1185
1186 func (m *MacipACLAddReplace) Size() (size int) {
1187         if m == nil {
1188                 return 0
1189         }
1190         size += 4      // m.ACLIndex
1191         size += 1 * 64 // m.Tag
1192         size += 4      // m.Count
1193         for j1 := 0; j1 < len(m.R); j1++ {
1194                 var s1 MacipACLRule
1195                 _ = s1
1196                 if j1 < len(m.R) {
1197                         s1 = m.R[j1]
1198                 }
1199                 size += 1      // s1.IsPermit
1200                 size += 1      // s1.IsIPv6
1201                 size += 1 * 6  // s1.SrcMac
1202                 size += 1 * 6  // s1.SrcMacMask
1203                 size += 1 * 16 // s1.SrcIPAddr
1204                 size += 1      // s1.SrcIPPrefixLen
1205         }
1206         return size
1207 }
1208 func (m *MacipACLAddReplace) Marshal(b []byte) ([]byte, error) {
1209         if b == nil {
1210                 b = make([]byte, m.Size())
1211         }
1212         buf := codec.NewBuffer(b)
1213         buf.EncodeUint32(m.ACLIndex)
1214         buf.EncodeBytes(m.Tag, 64)
1215         buf.EncodeUint32(uint32(len(m.R)))
1216         for j0 := 0; j0 < len(m.R); j0++ {
1217                 var v0 MacipACLRule // R
1218                 if j0 < len(m.R) {
1219                         v0 = m.R[j0]
1220                 }
1221                 buf.EncodeUint8(v0.IsPermit)
1222                 buf.EncodeUint8(v0.IsIPv6)
1223                 buf.EncodeBytes(v0.SrcMac, 6)
1224                 buf.EncodeBytes(v0.SrcMacMask, 6)
1225                 buf.EncodeBytes(v0.SrcIPAddr, 16)
1226                 buf.EncodeUint8(v0.SrcIPPrefixLen)
1227         }
1228         return buf.Bytes(), nil
1229 }
1230 func (m *MacipACLAddReplace) Unmarshal(b []byte) error {
1231         buf := codec.NewBuffer(b)
1232         m.ACLIndex = buf.DecodeUint32()
1233         m.Tag = make([]byte, 64)
1234         copy(m.Tag, buf.DecodeBytes(len(m.Tag)))
1235         m.Count = buf.DecodeUint32()
1236         m.R = make([]MacipACLRule, m.Count)
1237         for j0 := 0; j0 < len(m.R); j0++ {
1238                 m.R[j0].IsPermit = buf.DecodeUint8()
1239                 m.R[j0].IsIPv6 = buf.DecodeUint8()
1240                 m.R[j0].SrcMac = make([]byte, 6)
1241                 copy(m.R[j0].SrcMac, buf.DecodeBytes(len(m.R[j0].SrcMac)))
1242                 m.R[j0].SrcMacMask = make([]byte, 6)
1243                 copy(m.R[j0].SrcMacMask, buf.DecodeBytes(len(m.R[j0].SrcMacMask)))
1244                 m.R[j0].SrcIPAddr = make([]byte, 16)
1245                 copy(m.R[j0].SrcIPAddr, buf.DecodeBytes(len(m.R[j0].SrcIPAddr)))
1246                 m.R[j0].SrcIPPrefixLen = buf.DecodeUint8()
1247         }
1248         return nil
1249 }
1250
1251 // MacipACLAddReplaceReply defines message 'macip_acl_add_replace_reply'.
1252 type MacipACLAddReplaceReply struct {
1253         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1254         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1255 }
1256
1257 func (m *MacipACLAddReplaceReply) Reset()               { *m = MacipACLAddReplaceReply{} }
1258 func (*MacipACLAddReplaceReply) GetMessageName() string { return "macip_acl_add_replace_reply" }
1259 func (*MacipACLAddReplaceReply) GetCrcString() string   { return "ac407b0c" }
1260 func (*MacipACLAddReplaceReply) GetMessageType() api.MessageType {
1261         return api.ReplyMessage
1262 }
1263
1264 func (m *MacipACLAddReplaceReply) Size() (size int) {
1265         if m == nil {
1266                 return 0
1267         }
1268         size += 4 // m.ACLIndex
1269         size += 4 // m.Retval
1270         return size
1271 }
1272 func (m *MacipACLAddReplaceReply) Marshal(b []byte) ([]byte, error) {
1273         if b == nil {
1274                 b = make([]byte, m.Size())
1275         }
1276         buf := codec.NewBuffer(b)
1277         buf.EncodeUint32(m.ACLIndex)
1278         buf.EncodeInt32(m.Retval)
1279         return buf.Bytes(), nil
1280 }
1281 func (m *MacipACLAddReplaceReply) Unmarshal(b []byte) error {
1282         buf := codec.NewBuffer(b)
1283         m.ACLIndex = buf.DecodeUint32()
1284         m.Retval = buf.DecodeInt32()
1285         return nil
1286 }
1287
1288 // MacipACLAddReply defines message 'macip_acl_add_reply'.
1289 type MacipACLAddReply struct {
1290         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1291         Retval   int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1292 }
1293
1294 func (m *MacipACLAddReply) Reset()               { *m = MacipACLAddReply{} }
1295 func (*MacipACLAddReply) GetMessageName() string { return "macip_acl_add_reply" }
1296 func (*MacipACLAddReply) GetCrcString() string   { return "ac407b0c" }
1297 func (*MacipACLAddReply) GetMessageType() api.MessageType {
1298         return api.ReplyMessage
1299 }
1300
1301 func (m *MacipACLAddReply) Size() (size int) {
1302         if m == nil {
1303                 return 0
1304         }
1305         size += 4 // m.ACLIndex
1306         size += 4 // m.Retval
1307         return size
1308 }
1309 func (m *MacipACLAddReply) Marshal(b []byte) ([]byte, error) {
1310         if b == nil {
1311                 b = make([]byte, m.Size())
1312         }
1313         buf := codec.NewBuffer(b)
1314         buf.EncodeUint32(m.ACLIndex)
1315         buf.EncodeInt32(m.Retval)
1316         return buf.Bytes(), nil
1317 }
1318 func (m *MacipACLAddReply) Unmarshal(b []byte) error {
1319         buf := codec.NewBuffer(b)
1320         m.ACLIndex = buf.DecodeUint32()
1321         m.Retval = buf.DecodeInt32()
1322         return nil
1323 }
1324
1325 // MacipACLDel defines message 'macip_acl_del'.
1326 type MacipACLDel struct {
1327         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1328 }
1329
1330 func (m *MacipACLDel) Reset()               { *m = MacipACLDel{} }
1331 func (*MacipACLDel) GetMessageName() string { return "macip_acl_del" }
1332 func (*MacipACLDel) GetCrcString() string   { return "ef34fea4" }
1333 func (*MacipACLDel) GetMessageType() api.MessageType {
1334         return api.RequestMessage
1335 }
1336
1337 func (m *MacipACLDel) Size() (size int) {
1338         if m == nil {
1339                 return 0
1340         }
1341         size += 4 // m.ACLIndex
1342         return size
1343 }
1344 func (m *MacipACLDel) Marshal(b []byte) ([]byte, error) {
1345         if b == nil {
1346                 b = make([]byte, m.Size())
1347         }
1348         buf := codec.NewBuffer(b)
1349         buf.EncodeUint32(m.ACLIndex)
1350         return buf.Bytes(), nil
1351 }
1352 func (m *MacipACLDel) Unmarshal(b []byte) error {
1353         buf := codec.NewBuffer(b)
1354         m.ACLIndex = buf.DecodeUint32()
1355         return nil
1356 }
1357
1358 // MacipACLDelReply defines message 'macip_acl_del_reply'.
1359 type MacipACLDelReply struct {
1360         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1361 }
1362
1363 func (m *MacipACLDelReply) Reset()               { *m = MacipACLDelReply{} }
1364 func (*MacipACLDelReply) GetMessageName() string { return "macip_acl_del_reply" }
1365 func (*MacipACLDelReply) GetCrcString() string   { return "e8d4e804" }
1366 func (*MacipACLDelReply) GetMessageType() api.MessageType {
1367         return api.ReplyMessage
1368 }
1369
1370 func (m *MacipACLDelReply) Size() (size int) {
1371         if m == nil {
1372                 return 0
1373         }
1374         size += 4 // m.Retval
1375         return size
1376 }
1377 func (m *MacipACLDelReply) Marshal(b []byte) ([]byte, error) {
1378         if b == nil {
1379                 b = make([]byte, m.Size())
1380         }
1381         buf := codec.NewBuffer(b)
1382         buf.EncodeInt32(m.Retval)
1383         return buf.Bytes(), nil
1384 }
1385 func (m *MacipACLDelReply) Unmarshal(b []byte) error {
1386         buf := codec.NewBuffer(b)
1387         m.Retval = buf.DecodeInt32()
1388         return nil
1389 }
1390
1391 // MacipACLDetails defines message 'macip_acl_details'.
1392 type MacipACLDetails struct {
1393         ACLIndex uint32         `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1394         Tag      []byte         `binapi:"u8[64],name=tag" json:"tag,omitempty"`
1395         Count    uint32         `binapi:"u32,name=count" json:"-"`
1396         R        []MacipACLRule `binapi:"macip_acl_rule[count],name=r" json:"r,omitempty"`
1397 }
1398
1399 func (m *MacipACLDetails) Reset()               { *m = MacipACLDetails{} }
1400 func (*MacipACLDetails) GetMessageName() string { return "macip_acl_details" }
1401 func (*MacipACLDetails) GetCrcString() string   { return "e164e69a" }
1402 func (*MacipACLDetails) GetMessageType() api.MessageType {
1403         return api.ReplyMessage
1404 }
1405
1406 func (m *MacipACLDetails) Size() (size int) {
1407         if m == nil {
1408                 return 0
1409         }
1410         size += 4      // m.ACLIndex
1411         size += 1 * 64 // m.Tag
1412         size += 4      // m.Count
1413         for j1 := 0; j1 < len(m.R); j1++ {
1414                 var s1 MacipACLRule
1415                 _ = s1
1416                 if j1 < len(m.R) {
1417                         s1 = m.R[j1]
1418                 }
1419                 size += 1      // s1.IsPermit
1420                 size += 1      // s1.IsIPv6
1421                 size += 1 * 6  // s1.SrcMac
1422                 size += 1 * 6  // s1.SrcMacMask
1423                 size += 1 * 16 // s1.SrcIPAddr
1424                 size += 1      // s1.SrcIPPrefixLen
1425         }
1426         return size
1427 }
1428 func (m *MacipACLDetails) Marshal(b []byte) ([]byte, error) {
1429         if b == nil {
1430                 b = make([]byte, m.Size())
1431         }
1432         buf := codec.NewBuffer(b)
1433         buf.EncodeUint32(m.ACLIndex)
1434         buf.EncodeBytes(m.Tag, 64)
1435         buf.EncodeUint32(uint32(len(m.R)))
1436         for j0 := 0; j0 < len(m.R); j0++ {
1437                 var v0 MacipACLRule // R
1438                 if j0 < len(m.R) {
1439                         v0 = m.R[j0]
1440                 }
1441                 buf.EncodeUint8(v0.IsPermit)
1442                 buf.EncodeUint8(v0.IsIPv6)
1443                 buf.EncodeBytes(v0.SrcMac, 6)
1444                 buf.EncodeBytes(v0.SrcMacMask, 6)
1445                 buf.EncodeBytes(v0.SrcIPAddr, 16)
1446                 buf.EncodeUint8(v0.SrcIPPrefixLen)
1447         }
1448         return buf.Bytes(), nil
1449 }
1450 func (m *MacipACLDetails) Unmarshal(b []byte) error {
1451         buf := codec.NewBuffer(b)
1452         m.ACLIndex = buf.DecodeUint32()
1453         m.Tag = make([]byte, 64)
1454         copy(m.Tag, buf.DecodeBytes(len(m.Tag)))
1455         m.Count = buf.DecodeUint32()
1456         m.R = make([]MacipACLRule, m.Count)
1457         for j0 := 0; j0 < len(m.R); j0++ {
1458                 m.R[j0].IsPermit = buf.DecodeUint8()
1459                 m.R[j0].IsIPv6 = buf.DecodeUint8()
1460                 m.R[j0].SrcMac = make([]byte, 6)
1461                 copy(m.R[j0].SrcMac, buf.DecodeBytes(len(m.R[j0].SrcMac)))
1462                 m.R[j0].SrcMacMask = make([]byte, 6)
1463                 copy(m.R[j0].SrcMacMask, buf.DecodeBytes(len(m.R[j0].SrcMacMask)))
1464                 m.R[j0].SrcIPAddr = make([]byte, 16)
1465                 copy(m.R[j0].SrcIPAddr, buf.DecodeBytes(len(m.R[j0].SrcIPAddr)))
1466                 m.R[j0].SrcIPPrefixLen = buf.DecodeUint8()
1467         }
1468         return nil
1469 }
1470
1471 // MacipACLDump defines message 'macip_acl_dump'.
1472 type MacipACLDump struct {
1473         ACLIndex uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1474 }
1475
1476 func (m *MacipACLDump) Reset()               { *m = MacipACLDump{} }
1477 func (*MacipACLDump) GetMessageName() string { return "macip_acl_dump" }
1478 func (*MacipACLDump) GetCrcString() string   { return "ef34fea4" }
1479 func (*MacipACLDump) GetMessageType() api.MessageType {
1480         return api.RequestMessage
1481 }
1482
1483 func (m *MacipACLDump) Size() (size int) {
1484         if m == nil {
1485                 return 0
1486         }
1487         size += 4 // m.ACLIndex
1488         return size
1489 }
1490 func (m *MacipACLDump) Marshal(b []byte) ([]byte, error) {
1491         if b == nil {
1492                 b = make([]byte, m.Size())
1493         }
1494         buf := codec.NewBuffer(b)
1495         buf.EncodeUint32(m.ACLIndex)
1496         return buf.Bytes(), nil
1497 }
1498 func (m *MacipACLDump) Unmarshal(b []byte) error {
1499         buf := codec.NewBuffer(b)
1500         m.ACLIndex = buf.DecodeUint32()
1501         return nil
1502 }
1503
1504 // MacipACLInterfaceAddDel defines message 'macip_acl_interface_add_del'.
1505 type MacipACLInterfaceAddDel struct {
1506         IsAdd     uint8  `binapi:"u8,name=is_add" json:"is_add,omitempty"`
1507         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
1508         ACLIndex  uint32 `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
1509 }
1510
1511 func (m *MacipACLInterfaceAddDel) Reset()               { *m = MacipACLInterfaceAddDel{} }
1512 func (*MacipACLInterfaceAddDel) GetMessageName() string { return "macip_acl_interface_add_del" }
1513 func (*MacipACLInterfaceAddDel) GetCrcString() string   { return "6a6be97c" }
1514 func (*MacipACLInterfaceAddDel) GetMessageType() api.MessageType {
1515         return api.RequestMessage
1516 }
1517
1518 func (m *MacipACLInterfaceAddDel) Size() (size int) {
1519         if m == nil {
1520                 return 0
1521         }
1522         size += 1 // m.IsAdd
1523         size += 4 // m.SwIfIndex
1524         size += 4 // m.ACLIndex
1525         return size
1526 }
1527 func (m *MacipACLInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
1528         if b == nil {
1529                 b = make([]byte, m.Size())
1530         }
1531         buf := codec.NewBuffer(b)
1532         buf.EncodeUint8(m.IsAdd)
1533         buf.EncodeUint32(m.SwIfIndex)
1534         buf.EncodeUint32(m.ACLIndex)
1535         return buf.Bytes(), nil
1536 }
1537 func (m *MacipACLInterfaceAddDel) Unmarshal(b []byte) error {
1538         buf := codec.NewBuffer(b)
1539         m.IsAdd = buf.DecodeUint8()
1540         m.SwIfIndex = buf.DecodeUint32()
1541         m.ACLIndex = buf.DecodeUint32()
1542         return nil
1543 }
1544
1545 // MacipACLInterfaceAddDelReply defines message 'macip_acl_interface_add_del_reply'.
1546 type MacipACLInterfaceAddDelReply struct {
1547         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1548 }
1549
1550 func (m *MacipACLInterfaceAddDelReply) Reset() { *m = MacipACLInterfaceAddDelReply{} }
1551 func (*MacipACLInterfaceAddDelReply) GetMessageName() string {
1552         return "macip_acl_interface_add_del_reply"
1553 }
1554 func (*MacipACLInterfaceAddDelReply) GetCrcString() string { return "e8d4e804" }
1555 func (*MacipACLInterfaceAddDelReply) GetMessageType() api.MessageType {
1556         return api.ReplyMessage
1557 }
1558
1559 func (m *MacipACLInterfaceAddDelReply) Size() (size int) {
1560         if m == nil {
1561                 return 0
1562         }
1563         size += 4 // m.Retval
1564         return size
1565 }
1566 func (m *MacipACLInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
1567         if b == nil {
1568                 b = make([]byte, m.Size())
1569         }
1570         buf := codec.NewBuffer(b)
1571         buf.EncodeInt32(m.Retval)
1572         return buf.Bytes(), nil
1573 }
1574 func (m *MacipACLInterfaceAddDelReply) Unmarshal(b []byte) error {
1575         buf := codec.NewBuffer(b)
1576         m.Retval = buf.DecodeInt32()
1577         return nil
1578 }
1579
1580 // MacipACLInterfaceGet defines message 'macip_acl_interface_get'.
1581 type MacipACLInterfaceGet struct{}
1582
1583 func (m *MacipACLInterfaceGet) Reset()               { *m = MacipACLInterfaceGet{} }
1584 func (*MacipACLInterfaceGet) GetMessageName() string { return "macip_acl_interface_get" }
1585 func (*MacipACLInterfaceGet) GetCrcString() string   { return "51077d14" }
1586 func (*MacipACLInterfaceGet) GetMessageType() api.MessageType {
1587         return api.RequestMessage
1588 }
1589
1590 func (m *MacipACLInterfaceGet) Size() (size int) {
1591         if m == nil {
1592                 return 0
1593         }
1594         return size
1595 }
1596 func (m *MacipACLInterfaceGet) Marshal(b []byte) ([]byte, error) {
1597         if b == nil {
1598                 b = make([]byte, m.Size())
1599         }
1600         buf := codec.NewBuffer(b)
1601         return buf.Bytes(), nil
1602 }
1603 func (m *MacipACLInterfaceGet) Unmarshal(b []byte) error {
1604         return nil
1605 }
1606
1607 // MacipACLInterfaceGetReply defines message 'macip_acl_interface_get_reply'.
1608 type MacipACLInterfaceGetReply struct {
1609         Count uint32   `binapi:"u32,name=count" json:"-"`
1610         Acls  []uint32 `binapi:"u32[count],name=acls" json:"acls,omitempty"`
1611 }
1612
1613 func (m *MacipACLInterfaceGetReply) Reset()               { *m = MacipACLInterfaceGetReply{} }
1614 func (*MacipACLInterfaceGetReply) GetMessageName() string { return "macip_acl_interface_get_reply" }
1615 func (*MacipACLInterfaceGetReply) GetCrcString() string   { return "accf9b05" }
1616 func (*MacipACLInterfaceGetReply) GetMessageType() api.MessageType {
1617         return api.ReplyMessage
1618 }
1619
1620 func (m *MacipACLInterfaceGetReply) Size() (size int) {
1621         if m == nil {
1622                 return 0
1623         }
1624         size += 4               // m.Count
1625         size += 4 * len(m.Acls) // m.Acls
1626         return size
1627 }
1628 func (m *MacipACLInterfaceGetReply) Marshal(b []byte) ([]byte, error) {
1629         if b == nil {
1630                 b = make([]byte, m.Size())
1631         }
1632         buf := codec.NewBuffer(b)
1633         buf.EncodeUint32(uint32(len(m.Acls)))
1634         for i := 0; i < len(m.Acls); i++ {
1635                 var x uint32
1636                 if i < len(m.Acls) {
1637                         x = uint32(m.Acls[i])
1638                 }
1639                 buf.EncodeUint32(x)
1640         }
1641         return buf.Bytes(), nil
1642 }
1643 func (m *MacipACLInterfaceGetReply) Unmarshal(b []byte) error {
1644         buf := codec.NewBuffer(b)
1645         m.Count = buf.DecodeUint32()
1646         m.Acls = make([]uint32, m.Count)
1647         for i := 0; i < len(m.Acls); i++ {
1648                 m.Acls[i] = buf.DecodeUint32()
1649         }
1650         return nil
1651 }
1652
1653 // MacipACLInterfaceListDetails defines message 'macip_acl_interface_list_details'.
1654 type MacipACLInterfaceListDetails struct {
1655         SwIfIndex uint32   `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
1656         Count     uint8    `binapi:"u8,name=count" json:"-"`
1657         Acls      []uint32 `binapi:"u32[count],name=acls" json:"acls,omitempty"`
1658 }
1659
1660 func (m *MacipACLInterfaceListDetails) Reset() { *m = MacipACLInterfaceListDetails{} }
1661 func (*MacipACLInterfaceListDetails) GetMessageName() string {
1662         return "macip_acl_interface_list_details"
1663 }
1664 func (*MacipACLInterfaceListDetails) GetCrcString() string { return "29783fa0" }
1665 func (*MacipACLInterfaceListDetails) GetMessageType() api.MessageType {
1666         return api.ReplyMessage
1667 }
1668
1669 func (m *MacipACLInterfaceListDetails) Size() (size int) {
1670         if m == nil {
1671                 return 0
1672         }
1673         size += 4               // m.SwIfIndex
1674         size += 1               // m.Count
1675         size += 4 * len(m.Acls) // m.Acls
1676         return size
1677 }
1678 func (m *MacipACLInterfaceListDetails) Marshal(b []byte) ([]byte, error) {
1679         if b == nil {
1680                 b = make([]byte, m.Size())
1681         }
1682         buf := codec.NewBuffer(b)
1683         buf.EncodeUint32(m.SwIfIndex)
1684         buf.EncodeUint8(uint8(len(m.Acls)))
1685         for i := 0; i < len(m.Acls); i++ {
1686                 var x uint32
1687                 if i < len(m.Acls) {
1688                         x = uint32(m.Acls[i])
1689                 }
1690                 buf.EncodeUint32(x)
1691         }
1692         return buf.Bytes(), nil
1693 }
1694 func (m *MacipACLInterfaceListDetails) Unmarshal(b []byte) error {
1695         buf := codec.NewBuffer(b)
1696         m.SwIfIndex = buf.DecodeUint32()
1697         m.Count = buf.DecodeUint8()
1698         m.Acls = make([]uint32, m.Count)
1699         for i := 0; i < len(m.Acls); i++ {
1700                 m.Acls[i] = buf.DecodeUint32()
1701         }
1702         return nil
1703 }
1704
1705 // MacipACLInterfaceListDump defines message 'macip_acl_interface_list_dump'.
1706 type MacipACLInterfaceListDump struct {
1707         SwIfIndex uint32 `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
1708 }
1709
1710 func (m *MacipACLInterfaceListDump) Reset()               { *m = MacipACLInterfaceListDump{} }
1711 func (*MacipACLInterfaceListDump) GetMessageName() string { return "macip_acl_interface_list_dump" }
1712 func (*MacipACLInterfaceListDump) GetCrcString() string   { return "529cb13f" }
1713 func (*MacipACLInterfaceListDump) GetMessageType() api.MessageType {
1714         return api.RequestMessage
1715 }
1716
1717 func (m *MacipACLInterfaceListDump) Size() (size int) {
1718         if m == nil {
1719                 return 0
1720         }
1721         size += 4 // m.SwIfIndex
1722         return size
1723 }
1724 func (m *MacipACLInterfaceListDump) Marshal(b []byte) ([]byte, error) {
1725         if b == nil {
1726                 b = make([]byte, m.Size())
1727         }
1728         buf := codec.NewBuffer(b)
1729         buf.EncodeUint32(m.SwIfIndex)
1730         return buf.Bytes(), nil
1731 }
1732 func (m *MacipACLInterfaceListDump) Unmarshal(b []byte) error {
1733         buf := codec.NewBuffer(b)
1734         m.SwIfIndex = buf.DecodeUint32()
1735         return nil
1736 }
1737
1738 func init() { file_acl_binapi_init() }
1739 func file_acl_binapi_init() {
1740         api.RegisterMessage((*ACLAddReplace)(nil), "acl_add_replace_13bc8539")
1741         api.RegisterMessage((*ACLAddReplaceReply)(nil), "acl_add_replace_reply_ac407b0c")
1742         api.RegisterMessage((*ACLDel)(nil), "acl_del_ef34fea4")
1743         api.RegisterMessage((*ACLDelReply)(nil), "acl_del_reply_e8d4e804")
1744         api.RegisterMessage((*ACLDetails)(nil), "acl_details_f89d7a88")
1745         api.RegisterMessage((*ACLDump)(nil), "acl_dump_ef34fea4")
1746         api.RegisterMessage((*ACLInterfaceAddDel)(nil), "acl_interface_add_del_0b2aedd1")
1747         api.RegisterMessage((*ACLInterfaceAddDelReply)(nil), "acl_interface_add_del_reply_e8d4e804")
1748         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDetails)(nil), "acl_interface_etype_whitelist_details_6a5d4e81")
1749         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDump)(nil), "acl_interface_etype_whitelist_dump_529cb13f")
1750         api.RegisterMessage((*ACLInterfaceListDetails)(nil), "acl_interface_list_details_d5e80809")
1751         api.RegisterMessage((*ACLInterfaceListDump)(nil), "acl_interface_list_dump_529cb13f")
1752         api.RegisterMessage((*ACLInterfaceSetACLList)(nil), "acl_interface_set_acl_list_8baece38")
1753         api.RegisterMessage((*ACLInterfaceSetACLListReply)(nil), "acl_interface_set_acl_list_reply_e8d4e804")
1754         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelist)(nil), "acl_interface_set_etype_whitelist_f515efc5")
1755         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelistReply)(nil), "acl_interface_set_etype_whitelist_reply_e8d4e804")
1756         api.RegisterMessage((*ACLPluginControlPing)(nil), "acl_plugin_control_ping_51077d14")
1757         api.RegisterMessage((*ACLPluginControlPingReply)(nil), "acl_plugin_control_ping_reply_f6b0b8ca")
1758         api.RegisterMessage((*ACLPluginGetConnTableMaxEntries)(nil), "acl_plugin_get_conn_table_max_entries_51077d14")
1759         api.RegisterMessage((*ACLPluginGetConnTableMaxEntriesReply)(nil), "acl_plugin_get_conn_table_max_entries_reply_7a096d3d")
1760         api.RegisterMessage((*ACLPluginGetVersion)(nil), "acl_plugin_get_version_51077d14")
1761         api.RegisterMessage((*ACLPluginGetVersionReply)(nil), "acl_plugin_get_version_reply_9b32cf86")
1762         api.RegisterMessage((*ACLStatsIntfCountersEnable)(nil), "acl_stats_intf_counters_enable_b3e225d2")
1763         api.RegisterMessage((*ACLStatsIntfCountersEnableReply)(nil), "acl_stats_intf_counters_enable_reply_e8d4e804")
1764         api.RegisterMessage((*MacipACLAdd)(nil), "macip_acl_add_0c680ca5")
1765         api.RegisterMessage((*MacipACLAddReplace)(nil), "macip_acl_add_replace_d3d313e7")
1766         api.RegisterMessage((*MacipACLAddReplaceReply)(nil), "macip_acl_add_replace_reply_ac407b0c")
1767         api.RegisterMessage((*MacipACLAddReply)(nil), "macip_acl_add_reply_ac407b0c")
1768         api.RegisterMessage((*MacipACLDel)(nil), "macip_acl_del_ef34fea4")
1769         api.RegisterMessage((*MacipACLDelReply)(nil), "macip_acl_del_reply_e8d4e804")
1770         api.RegisterMessage((*MacipACLDetails)(nil), "macip_acl_details_e164e69a")
1771         api.RegisterMessage((*MacipACLDump)(nil), "macip_acl_dump_ef34fea4")
1772         api.RegisterMessage((*MacipACLInterfaceAddDel)(nil), "macip_acl_interface_add_del_6a6be97c")
1773         api.RegisterMessage((*MacipACLInterfaceAddDelReply)(nil), "macip_acl_interface_add_del_reply_e8d4e804")
1774         api.RegisterMessage((*MacipACLInterfaceGet)(nil), "macip_acl_interface_get_51077d14")
1775         api.RegisterMessage((*MacipACLInterfaceGetReply)(nil), "macip_acl_interface_get_reply_accf9b05")
1776         api.RegisterMessage((*MacipACLInterfaceListDetails)(nil), "macip_acl_interface_list_details_29783fa0")
1777         api.RegisterMessage((*MacipACLInterfaceListDump)(nil), "macip_acl_interface_list_dump_529cb13f")
1778 }
1779
1780 // Messages returns list of all messages in this module.
1781 func AllMessages() []api.Message {
1782         return []api.Message{
1783                 (*ACLAddReplace)(nil),
1784                 (*ACLAddReplaceReply)(nil),
1785                 (*ACLDel)(nil),
1786                 (*ACLDelReply)(nil),
1787                 (*ACLDetails)(nil),
1788                 (*ACLDump)(nil),
1789                 (*ACLInterfaceAddDel)(nil),
1790                 (*ACLInterfaceAddDelReply)(nil),
1791                 (*ACLInterfaceEtypeWhitelistDetails)(nil),
1792                 (*ACLInterfaceEtypeWhitelistDump)(nil),
1793                 (*ACLInterfaceListDetails)(nil),
1794                 (*ACLInterfaceListDump)(nil),
1795                 (*ACLInterfaceSetACLList)(nil),
1796                 (*ACLInterfaceSetACLListReply)(nil),
1797                 (*ACLInterfaceSetEtypeWhitelist)(nil),
1798                 (*ACLInterfaceSetEtypeWhitelistReply)(nil),
1799                 (*ACLPluginControlPing)(nil),
1800                 (*ACLPluginControlPingReply)(nil),
1801                 (*ACLPluginGetConnTableMaxEntries)(nil),
1802                 (*ACLPluginGetConnTableMaxEntriesReply)(nil),
1803                 (*ACLPluginGetVersion)(nil),
1804                 (*ACLPluginGetVersionReply)(nil),
1805                 (*ACLStatsIntfCountersEnable)(nil),
1806                 (*ACLStatsIntfCountersEnableReply)(nil),
1807                 (*MacipACLAdd)(nil),
1808                 (*MacipACLAddReplace)(nil),
1809                 (*MacipACLAddReplaceReply)(nil),
1810                 (*MacipACLAddReply)(nil),
1811                 (*MacipACLDel)(nil),
1812                 (*MacipACLDelReply)(nil),
1813                 (*MacipACLDetails)(nil),
1814                 (*MacipACLDump)(nil),
1815                 (*MacipACLInterfaceAddDel)(nil),
1816                 (*MacipACLInterfaceAddDelReply)(nil),
1817                 (*MacipACLInterfaceGet)(nil),
1818                 (*MacipACLInterfaceGetReply)(nil),
1819                 (*MacipACLInterfaceListDetails)(nil),
1820                 (*MacipACLInterfaceListDump)(nil),
1821         }
1822 }