examples/binapi/memif/memif.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/memif.api.json
   6
   7 /*
   8 Package memif contains generated code for VPP API file memif.api (3.0.0).
   9
  10 It consists of:
  11           2 aliases
  12           8 enums
  13          10 messages
  14 */
  15 package memif
  16
  17 import (
  18         "bytes"
  19         "context"
  20         "encoding/binary"
  21         "fmt"
  22         "io"
  23         "math"
  24         "net"
  25         "strconv"
  26         "strings"
  27
  28         api "git.fd.io/govpp.git/api"
  29         codec "git.fd.io/govpp.git/codec"
  30         struc "github.com/lunixbochs/struc"
  31
  32         interface_types "git.fd.io/govpp.git/examples/binapi/interface_types"
  33 )
  34
  35 // This is a compile-time assertion to ensure that this generated file
  36 // is compatible with the GoVPP api package it is being compiled against.
  37 // A compilation error at this line likely means your copy of the
  38 // GoVPP api package needs to be updated.
  39 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  40
  41 const (
  42         // ModuleName is the name of this module.
  43         ModuleName = "memif"
  44         // APIVersion is the API version of this module.
  45         APIVersion = "3.0.0"
  46         // VersionCrc is the CRC of this module.
  47         VersionCrc = 0x1a1c95b8
  48 )
  49
  50 // MemifMode represents VPP binary API enum 'memif_mode'.
  51 type MemifMode uint32
  52
  53 const (
  54         MEMIF_MODE_API_ETHERNET    MemifMode = 0
  55         MEMIF_MODE_API_IP          MemifMode = 1
  56         MEMIF_MODE_API_PUNT_INJECT MemifMode = 2
  57 )
  58
  59 var (
  60         MemifMode_name = map[uint32]string{
  61                 0: "MEMIF_MODE_API_ETHERNET",
  62                 1: "MEMIF_MODE_API_IP",
  63                 2: "MEMIF_MODE_API_PUNT_INJECT",
  64         }
  65         MemifMode_value = map[string]uint32{
  66                 "MEMIF_MODE_API_ETHERNET":    0,
  67                 "MEMIF_MODE_API_IP":          1,
  68                 "MEMIF_MODE_API_PUNT_INJECT": 2,
  69         }
  70 )
  71
  72 func (x MemifMode) String() string {
  73         s, ok := MemifMode_name[uint32(x)]
  74         if ok {
  75                 return s
  76         }
  77         return "MemifMode(" + strconv.Itoa(int(x)) + ")"
  78 }
  79
  80 // MemifRole represents VPP binary API enum 'memif_role'.
  81 type MemifRole uint32
  82
  83 const (
  84         MEMIF_ROLE_API_MASTER MemifRole = 0
  85         MEMIF_ROLE_API_SLAVE  MemifRole = 1
  86 )
  87
  88 var (
  89         MemifRole_name = map[uint32]string{
  90                 0: "MEMIF_ROLE_API_MASTER",
  91                 1: "MEMIF_ROLE_API_SLAVE",
  92         }
  93         MemifRole_value = map[string]uint32{
  94                 "MEMIF_ROLE_API_MASTER": 0,
  95                 "MEMIF_ROLE_API_SLAVE":  1,
  96         }
  97 )
  98
  99 func (x MemifRole) String() string {
 100         s, ok := MemifRole_name[uint32(x)]
 101         if ok {
 102                 return s
 103         }
 104         return "MemifRole(" + strconv.Itoa(int(x)) + ")"
 105 }
 106
 107 // MacAddress represents VPP binary API alias 'mac_address'.
 108 type MacAddress [6]uint8
 109
 110 func ParseMAC(mac string) (parsed MacAddress, err error) {
 111         var hw net.HardwareAddr
 112         if hw, err = net.ParseMAC(mac); err != nil {
 113                 return
 114         }
 115         copy(parsed[:], hw[:])
 116         return
 117 }
 118
 119 func (m *MacAddress) ToString() string {
 120         return net.HardwareAddr(m[:]).String()
 121 }
 122
 123 // MemifCreate represents VPP binary API message 'memif_create'.
 124 type MemifCreate struct {
 125         Role       MemifRole  `binapi:"memif_role,name=role" json:"role,omitempty"`
 126         Mode       MemifMode  `binapi:"memif_mode,name=mode" json:"mode,omitempty"`
 127         RxQueues   uint8      `binapi:"u8,name=rx_queues" json:"rx_queues,omitempty"`
 128         TxQueues   uint8      `binapi:"u8,name=tx_queues" json:"tx_queues,omitempty"`
 129         ID         uint32     `binapi:"u32,name=id" json:"id,omitempty"`
 130         SocketID   uint32     `binapi:"u32,name=socket_id" json:"socket_id,omitempty"`
 131         RingSize   uint32     `binapi:"u32,name=ring_size" json:"ring_size,omitempty"`
 132         BufferSize uint16     `binapi:"u16,name=buffer_size" json:"buffer_size,omitempty"`
 133         NoZeroCopy bool       `binapi:"bool,name=no_zero_copy" json:"no_zero_copy,omitempty"`
 134         HwAddr     MacAddress `binapi:"mac_address,name=hw_addr" json:"hw_addr,omitempty"`
 135         Secret     string     `binapi:"string[24],name=secret" json:"secret,omitempty" struc:"[24]byte"`
 136 }
 137
 138 func (m *MemifCreate) Reset()                        { *m = MemifCreate{} }
 139 func (*MemifCreate) GetMessageName() string          { return "memif_create" }
 140 func (*MemifCreate) GetCrcString() string            { return "b1b25061" }
 141 func (*MemifCreate) GetMessageType() api.MessageType { return api.RequestMessage }
 142
 143 func (m *MemifCreate) Size() int {
 144         if m == nil {
 145                 return 0
 146         }
 147         var size int
 148         // field[1] m.Role
 149         size += 4
 150         // field[1] m.Mode
 151         size += 4
 152         // field[1] m.RxQueues
 153         size += 1
 154         // field[1] m.TxQueues
 155         size += 1
 156         // field[1] m.ID
 157         size += 4
 158         // field[1] m.SocketID
 159         size += 4
 160         // field[1] m.RingSize
 161         size += 4
 162         // field[1] m.BufferSize
 163         size += 2
 164         // field[1] m.NoZeroCopy
 165         size += 1
 166         // field[1] m.HwAddr
 167         size += 6
 168         // field[1] m.Secret
 169         size += 24
 170         return size
 171 }
 172 func (m *MemifCreate) Marshal(b []byte) ([]byte, error) {
 173         o := binary.BigEndian
 174         _ = o
 175         pos := 0
 176         _ = pos
 177         var buf []byte
 178         if b == nil {
 179                 buf = make([]byte, m.Size())
 180         } else {
 181                 buf = b
 182         }
 183         // field[1] m.Role
 184         o.PutUint32(buf[pos:pos+4], uint32(m.Role))
 185         pos += 4
 186         // field[1] m.Mode
 187         o.PutUint32(buf[pos:pos+4], uint32(m.Mode))
 188         pos += 4
 189         // field[1] m.RxQueues
 190         buf[pos] = uint8(m.RxQueues)
 191         pos += 1
 192         // field[1] m.TxQueues
 193         buf[pos] = uint8(m.TxQueues)
 194         pos += 1
 195         // field[1] m.ID
 196         o.PutUint32(buf[pos:pos+4], uint32(m.ID))
 197         pos += 4
 198         // field[1] m.SocketID
 199         o.PutUint32(buf[pos:pos+4], uint32(m.SocketID))
 200         pos += 4
 201         // field[1] m.RingSize
 202         o.PutUint32(buf[pos:pos+4], uint32(m.RingSize))
 203         pos += 4
 204         // field[1] m.BufferSize
 205         o.PutUint16(buf[pos:pos+2], uint16(m.BufferSize))
 206         pos += 2
 207         // field[1] m.NoZeroCopy
 208         if m.NoZeroCopy {
 209                 buf[pos] = 1
 210         }
 211         pos += 1
 212         // field[1] m.HwAddr
 213         for i := 0; i < 6; i++ {
 214                 var x uint8
 215                 if i < len(m.HwAddr) {
 216                         x = uint8(m.HwAddr[i])
 217                 }
 218                 buf[pos] = uint8(x)
 219                 pos += 1
 220         }
 221         // field[1] m.Secret
 222         copy(buf[pos:pos+24], m.Secret)
 223         pos += 24
 224         return buf, nil
 225 }
 226 func (m *MemifCreate) Unmarshal(tmp []byte) error {
 227         o := binary.BigEndian
 228         _ = o
 229         pos := 0
 230         _ = pos
 231         // field[1] m.Role
 232         m.Role = MemifRole(o.Uint32(tmp[pos : pos+4]))
 233         pos += 4
 234         // field[1] m.Mode
 235         m.Mode = MemifMode(o.Uint32(tmp[pos : pos+4]))
 236         pos += 4
 237         // field[1] m.RxQueues
 238         m.RxQueues = uint8(tmp[pos])
 239         pos += 1
 240         // field[1] m.TxQueues
 241         m.TxQueues = uint8(tmp[pos])
 242         pos += 1
 243         // field[1] m.ID
 244         m.ID = uint32(o.Uint32(tmp[pos : pos+4]))
 245         pos += 4
 246         // field[1] m.SocketID
 247         m.SocketID = uint32(o.Uint32(tmp[pos : pos+4]))
 248         pos += 4
 249         // field[1] m.RingSize
 250         m.RingSize = uint32(o.Uint32(tmp[pos : pos+4]))
 251         pos += 4
 252         // field[1] m.BufferSize
 253         m.BufferSize = uint16(o.Uint16(tmp[pos : pos+2]))
 254         pos += 2
 255         // field[1] m.NoZeroCopy
 256         m.NoZeroCopy = tmp[pos] != 0
 257         pos += 1
 258         // field[1] m.HwAddr
 259         for i := 0; i < len(m.HwAddr); i++ {
 260                 m.HwAddr[i] = uint8(tmp[pos])
 261                 pos += 1
 262         }
 263         // field[1] m.Secret
 264         {
 265                 nul := bytes.Index(tmp[pos:pos+24], []byte{0x00})
 266                 m.Secret = codec.DecodeString(tmp[pos : pos+nul])
 267                 pos += 24
 268         }
 269         return nil
 270 }
 271
 272 // MemifCreateReply represents VPP binary API message 'memif_create_reply'.
 273 type MemifCreateReply struct {
 274         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 275         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 276 }
 277
 278 func (m *MemifCreateReply) Reset()                        { *m = MemifCreateReply{} }
 279 func (*MemifCreateReply) GetMessageName() string          { return "memif_create_reply" }
 280 func (*MemifCreateReply) GetCrcString() string            { return "5383d31f" }
 281 func (*MemifCreateReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 282
 283 func (m *MemifCreateReply) Size() int {
 284         if m == nil {
 285                 return 0
 286         }
 287         var size int
 288         // field[1] m.Retval
 289         size += 4
 290         // field[1] m.SwIfIndex
 291         size += 4
 292         return size
 293 }
 294 func (m *MemifCreateReply) Marshal(b []byte) ([]byte, error) {
 295         o := binary.BigEndian
 296         _ = o
 297         pos := 0
 298         _ = pos
 299         var buf []byte
 300         if b == nil {
 301                 buf = make([]byte, m.Size())
 302         } else {
 303                 buf = b
 304         }
 305         // field[1] m.Retval
 306         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 307         pos += 4
 308         // field[1] m.SwIfIndex
 309         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 310         pos += 4
 311         return buf, nil
 312 }
 313 func (m *MemifCreateReply) Unmarshal(tmp []byte) error {
 314         o := binary.BigEndian
 315         _ = o
 316         pos := 0
 317         _ = pos
 318         // field[1] m.Retval
 319         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 320         pos += 4
 321         // field[1] m.SwIfIndex
 322         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 323         pos += 4
 324         return nil
 325 }
 326
 327 // MemifDelete represents VPP binary API message 'memif_delete'.
 328 type MemifDelete struct {
 329         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 330 }
 331
 332 func (m *MemifDelete) Reset()                        { *m = MemifDelete{} }
 333 func (*MemifDelete) GetMessageName() string          { return "memif_delete" }
 334 func (*MemifDelete) GetCrcString() string            { return "f9e6675e" }
 335 func (*MemifDelete) GetMessageType() api.MessageType { return api.RequestMessage }
 336
 337 func (m *MemifDelete) Size() int {
 338         if m == nil {
 339                 return 0
 340         }
 341         var size int
 342         // field[1] m.SwIfIndex
 343         size += 4
 344         return size
 345 }
 346 func (m *MemifDelete) Marshal(b []byte) ([]byte, error) {
 347         o := binary.BigEndian
 348         _ = o
 349         pos := 0
 350         _ = pos
 351         var buf []byte
 352         if b == nil {
 353                 buf = make([]byte, m.Size())
 354         } else {
 355                 buf = b
 356         }
 357         // field[1] m.SwIfIndex
 358         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 359         pos += 4
 360         return buf, nil
 361 }
 362 func (m *MemifDelete) Unmarshal(tmp []byte) error {
 363         o := binary.BigEndian
 364         _ = o
 365         pos := 0
 366         _ = pos
 367         // field[1] m.SwIfIndex
 368         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 369         pos += 4
 370         return nil
 371 }
 372
 373 // MemifDeleteReply represents VPP binary API message 'memif_delete_reply'.
 374 type MemifDeleteReply struct {
 375         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 376 }
 377
 378 func (m *MemifDeleteReply) Reset()                        { *m = MemifDeleteReply{} }
 379 func (*MemifDeleteReply) GetMessageName() string          { return "memif_delete_reply" }
 380 func (*MemifDeleteReply) GetCrcString() string            { return "e8d4e804" }
 381 func (*MemifDeleteReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 382
 383 func (m *MemifDeleteReply) Size() int {
 384         if m == nil {
 385                 return 0
 386         }
 387         var size int
 388         // field[1] m.Retval
 389         size += 4
 390         return size
 391 }
 392 func (m *MemifDeleteReply) Marshal(b []byte) ([]byte, error) {
 393         o := binary.BigEndian
 394         _ = o
 395         pos := 0
 396         _ = pos
 397         var buf []byte
 398         if b == nil {
 399                 buf = make([]byte, m.Size())
 400         } else {
 401                 buf = b
 402         }
 403         // field[1] m.Retval
 404         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 405         pos += 4
 406         return buf, nil
 407 }
 408 func (m *MemifDeleteReply) Unmarshal(tmp []byte) error {
 409         o := binary.BigEndian
 410         _ = o
 411         pos := 0
 412         _ = pos
 413         // field[1] m.Retval
 414         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 415         pos += 4
 416         return nil
 417 }
 418
 419 // MemifDetails represents VPP binary API message 'memif_details'.
 420 type MemifDetails struct {
 421         SwIfIndex  interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 422         HwAddr     MacAddress                     `binapi:"mac_address,name=hw_addr" json:"hw_addr,omitempty"`
 423         ID         uint32                         `binapi:"u32,name=id" json:"id,omitempty"`
 424         Role       MemifRole                      `binapi:"memif_role,name=role" json:"role,omitempty"`
 425         Mode       MemifMode                      `binapi:"memif_mode,name=mode" json:"mode,omitempty"`
 426         ZeroCopy   bool                           `binapi:"bool,name=zero_copy" json:"zero_copy,omitempty"`
 427         SocketID   uint32                         `binapi:"u32,name=socket_id" json:"socket_id,omitempty"`
 428         RingSize   uint32                         `binapi:"u32,name=ring_size" json:"ring_size,omitempty"`
 429         BufferSize uint16                         `binapi:"u16,name=buffer_size" json:"buffer_size,omitempty"`
 430         Flags      interface_types.IfStatusFlags  `binapi:"if_status_flags,name=flags" json:"flags,omitempty"`
 431         IfName     string                         `binapi:"string[64],name=if_name" json:"if_name,omitempty" struc:"[64]byte"`
 432 }
 433
 434 func (m *MemifDetails) Reset()                        { *m = MemifDetails{} }
 435 func (*MemifDetails) GetMessageName() string          { return "memif_details" }
 436 func (*MemifDetails) GetCrcString() string            { return "d0382c4c" }
 437 func (*MemifDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 438
 439 func (m *MemifDetails) Size() int {
 440         if m == nil {
 441                 return 0
 442         }
 443         var size int
 444         // field[1] m.SwIfIndex
 445         size += 4
 446         // field[1] m.HwAddr
 447         size += 6
 448         // field[1] m.ID
 449         size += 4
 450         // field[1] m.Role
 451         size += 4
 452         // field[1] m.Mode
 453         size += 4
 454         // field[1] m.ZeroCopy
 455         size += 1
 456         // field[1] m.SocketID
 457         size += 4
 458         // field[1] m.RingSize
 459         size += 4
 460         // field[1] m.BufferSize
 461         size += 2
 462         // field[1] m.Flags
 463         size += 4
 464         // field[1] m.IfName
 465         size += 64
 466         return size
 467 }
 468 func (m *MemifDetails) Marshal(b []byte) ([]byte, error) {
 469         o := binary.BigEndian
 470         _ = o
 471         pos := 0
 472         _ = pos
 473         var buf []byte
 474         if b == nil {
 475                 buf = make([]byte, m.Size())
 476         } else {
 477                 buf = b
 478         }
 479         // field[1] m.SwIfIndex
 480         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
 481         pos += 4
 482         // field[1] m.HwAddr
 483         for i := 0; i < 6; i++ {
 484                 var x uint8
 485                 if i < len(m.HwAddr) {
 486                         x = uint8(m.HwAddr[i])
 487                 }
 488                 buf[pos] = uint8(x)
 489                 pos += 1
 490         }
 491         // field[1] m.ID
 492         o.PutUint32(buf[pos:pos+4], uint32(m.ID))
 493         pos += 4
 494         // field[1] m.Role
 495         o.PutUint32(buf[pos:pos+4], uint32(m.Role))
 496         pos += 4
 497         // field[1] m.Mode
 498         o.PutUint32(buf[pos:pos+4], uint32(m.Mode))
 499         pos += 4
 500         // field[1] m.ZeroCopy
 501         if m.ZeroCopy {
 502                 buf[pos] = 1
 503         }
 504         pos += 1
 505         // field[1] m.SocketID
 506         o.PutUint32(buf[pos:pos+4], uint32(m.SocketID))
 507         pos += 4
 508         // field[1] m.RingSize
 509         o.PutUint32(buf[pos:pos+4], uint32(m.RingSize))
 510         pos += 4
 511         // field[1] m.BufferSize
 512         o.PutUint16(buf[pos:pos+2], uint16(m.BufferSize))
 513         pos += 2
 514         // field[1] m.Flags
 515         o.PutUint32(buf[pos:pos+4], uint32(m.Flags))
 516         pos += 4
 517         // field[1] m.IfName
 518         copy(buf[pos:pos+64], m.IfName)
 519         pos += 64
 520         return buf, nil
 521 }
 522 func (m *MemifDetails) Unmarshal(tmp []byte) error {
 523         o := binary.BigEndian
 524         _ = o
 525         pos := 0
 526         _ = pos
 527         // field[1] m.SwIfIndex
 528         m.SwIfIndex = interface_types.InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
 529         pos += 4
 530         // field[1] m.HwAddr
 531         for i := 0; i < len(m.HwAddr); i++ {
 532                 m.HwAddr[i] = uint8(tmp[pos])
 533                 pos += 1
 534         }
 535         // field[1] m.ID
 536         m.ID = uint32(o.Uint32(tmp[pos : pos+4]))
 537         pos += 4
 538         // field[1] m.Role
 539         m.Role = MemifRole(o.Uint32(tmp[pos : pos+4]))
 540         pos += 4
 541         // field[1] m.Mode
 542         m.Mode = MemifMode(o.Uint32(tmp[pos : pos+4]))
 543         pos += 4
 544         // field[1] m.ZeroCopy
 545         m.ZeroCopy = tmp[pos] != 0
 546         pos += 1
 547         // field[1] m.SocketID
 548         m.SocketID = uint32(o.Uint32(tmp[pos : pos+4]))
 549         pos += 4
 550         // field[1] m.RingSize
 551         m.RingSize = uint32(o.Uint32(tmp[pos : pos+4]))
 552         pos += 4
 553         // field[1] m.BufferSize
 554         m.BufferSize = uint16(o.Uint16(tmp[pos : pos+2]))
 555         pos += 2
 556         // field[1] m.Flags
 557         m.Flags = interface_types.IfStatusFlags(o.Uint32(tmp[pos : pos+4]))
 558         pos += 4
 559         // field[1] m.IfName
 560         {
 561                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
 562                 m.IfName = codec.DecodeString(tmp[pos : pos+nul])
 563                 pos += 64
 564         }
 565         return nil
 566 }
 567
 568 // MemifDump represents VPP binary API message 'memif_dump'.
 569 type MemifDump struct{}
 570
 571 func (m *MemifDump) Reset()                        { *m = MemifDump{} }
 572 func (*MemifDump) GetMessageName() string          { return "memif_dump" }
 573 func (*MemifDump) GetCrcString() string            { return "51077d14" }
 574 func (*MemifDump) GetMessageType() api.MessageType { return api.RequestMessage }
 575
 576 func (m *MemifDump) Size() int {
 577         if m == nil {
 578                 return 0
 579         }
 580         var size int
 581         return size
 582 }
 583 func (m *MemifDump) Marshal(b []byte) ([]byte, error) {
 584         o := binary.BigEndian
 585         _ = o
 586         pos := 0
 587         _ = pos
 588         var buf []byte
 589         if b == nil {
 590                 buf = make([]byte, m.Size())
 591         } else {
 592                 buf = b
 593         }
 594         return buf, nil
 595 }
 596 func (m *MemifDump) Unmarshal(tmp []byte) error {
 597         o := binary.BigEndian
 598         _ = o
 599         pos := 0
 600         _ = pos
 601         return nil
 602 }
 603
 604 // MemifSocketFilenameAddDel represents VPP binary API message 'memif_socket_filename_add_del'.
 605 type MemifSocketFilenameAddDel struct {
 606         IsAdd          bool   `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 607         SocketID       uint32 `binapi:"u32,name=socket_id" json:"socket_id,omitempty"`
 608         SocketFilename string `binapi:"string[108],name=socket_filename" json:"socket_filename,omitempty" struc:"[108]byte"`
 609 }
 610
 611 func (m *MemifSocketFilenameAddDel) Reset()                        { *m = MemifSocketFilenameAddDel{} }
 612 func (*MemifSocketFilenameAddDel) GetMessageName() string          { return "memif_socket_filename_add_del" }
 613 func (*MemifSocketFilenameAddDel) GetCrcString() string            { return "a2ce1a10" }
 614 func (*MemifSocketFilenameAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
 615
 616 func (m *MemifSocketFilenameAddDel) Size() int {
 617         if m == nil {
 618                 return 0
 619         }
 620         var size int
 621         // field[1] m.IsAdd
 622         size += 1
 623         // field[1] m.SocketID
 624         size += 4
 625         // field[1] m.SocketFilename
 626         size += 108
 627         return size
 628 }
 629 func (m *MemifSocketFilenameAddDel) Marshal(b []byte) ([]byte, error) {
 630         o := binary.BigEndian
 631         _ = o
 632         pos := 0
 633         _ = pos
 634         var buf []byte
 635         if b == nil {
 636                 buf = make([]byte, m.Size())
 637         } else {
 638                 buf = b
 639         }
 640         // field[1] m.IsAdd
 641         if m.IsAdd {
 642                 buf[pos] = 1
 643         }
 644         pos += 1
 645         // field[1] m.SocketID
 646         o.PutUint32(buf[pos:pos+4], uint32(m.SocketID))
 647         pos += 4
 648         // field[1] m.SocketFilename
 649         copy(buf[pos:pos+108], m.SocketFilename)
 650         pos += 108
 651         return buf, nil
 652 }
 653 func (m *MemifSocketFilenameAddDel) Unmarshal(tmp []byte) error {
 654         o := binary.BigEndian
 655         _ = o
 656         pos := 0
 657         _ = pos
 658         // field[1] m.IsAdd
 659         m.IsAdd = tmp[pos] != 0
 660         pos += 1
 661         // field[1] m.SocketID
 662         m.SocketID = uint32(o.Uint32(tmp[pos : pos+4]))
 663         pos += 4
 664         // field[1] m.SocketFilename
 665         {
 666                 nul := bytes.Index(tmp[pos:pos+108], []byte{0x00})
 667                 m.SocketFilename = codec.DecodeString(tmp[pos : pos+nul])
 668                 pos += 108
 669         }
 670         return nil
 671 }
 672
 673 // MemifSocketFilenameAddDelReply represents VPP binary API message 'memif_socket_filename_add_del_reply'.
 674 type MemifSocketFilenameAddDelReply struct {
 675         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 676 }
 677
 678 func (m *MemifSocketFilenameAddDelReply) Reset() { *m = MemifSocketFilenameAddDelReply{} }
 679 func (*MemifSocketFilenameAddDelReply) GetMessageName() string {
 680         return "memif_socket_filename_add_del_reply"
 681 }
 682 func (*MemifSocketFilenameAddDelReply) GetCrcString() string            { return "e8d4e804" }
 683 func (*MemifSocketFilenameAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 684
 685 func (m *MemifSocketFilenameAddDelReply) Size() int {
 686         if m == nil {
 687                 return 0
 688         }
 689         var size int
 690         // field[1] m.Retval
 691         size += 4
 692         return size
 693 }
 694 func (m *MemifSocketFilenameAddDelReply) Marshal(b []byte) ([]byte, error) {
 695         o := binary.BigEndian
 696         _ = o
 697         pos := 0
 698         _ = pos
 699         var buf []byte
 700         if b == nil {
 701                 buf = make([]byte, m.Size())
 702         } else {
 703                 buf = b
 704         }
 705         // field[1] m.Retval
 706         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 707         pos += 4
 708         return buf, nil
 709 }
 710 func (m *MemifSocketFilenameAddDelReply) Unmarshal(tmp []byte) error {
 711         o := binary.BigEndian
 712         _ = o
 713         pos := 0
 714         _ = pos
 715         // field[1] m.Retval
 716         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 717         pos += 4
 718         return nil
 719 }
 720
 721 // MemifSocketFilenameDetails represents VPP binary API message 'memif_socket_filename_details'.
 722 type MemifSocketFilenameDetails struct {
 723         SocketID       uint32 `binapi:"u32,name=socket_id" json:"socket_id,omitempty"`
 724         SocketFilename string `binapi:"string[108],name=socket_filename" json:"socket_filename,omitempty" struc:"[108]byte"`
 725 }
 726
 727 func (m *MemifSocketFilenameDetails) Reset()                        { *m = MemifSocketFilenameDetails{} }
 728 func (*MemifSocketFilenameDetails) GetMessageName() string          { return "memif_socket_filename_details" }
 729 func (*MemifSocketFilenameDetails) GetCrcString() string            { return "7ff326f7" }
 730 func (*MemifSocketFilenameDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
 731
 732 func (m *MemifSocketFilenameDetails) Size() int {
 733         if m == nil {
 734                 return 0
 735         }
 736         var size int
 737         // field[1] m.SocketID
 738         size += 4
 739         // field[1] m.SocketFilename
 740         size += 108
 741         return size
 742 }
 743 func (m *MemifSocketFilenameDetails) Marshal(b []byte) ([]byte, error) {
 744         o := binary.BigEndian
 745         _ = o
 746         pos := 0
 747         _ = pos
 748         var buf []byte
 749         if b == nil {
 750                 buf = make([]byte, m.Size())
 751         } else {
 752                 buf = b
 753         }
 754         // field[1] m.SocketID
 755         o.PutUint32(buf[pos:pos+4], uint32(m.SocketID))
 756         pos += 4
 757         // field[1] m.SocketFilename
 758         copy(buf[pos:pos+108], m.SocketFilename)
 759         pos += 108
 760         return buf, nil
 761 }
 762 func (m *MemifSocketFilenameDetails) Unmarshal(tmp []byte) error {
 763         o := binary.BigEndian
 764         _ = o
 765         pos := 0
 766         _ = pos
 767         // field[1] m.SocketID
 768         m.SocketID = uint32(o.Uint32(tmp[pos : pos+4]))
 769         pos += 4
 770         // field[1] m.SocketFilename
 771         {
 772                 nul := bytes.Index(tmp[pos:pos+108], []byte{0x00})
 773                 m.SocketFilename = codec.DecodeString(tmp[pos : pos+nul])
 774                 pos += 108
 775         }
 776         return nil
 777 }
 778
 779 // MemifSocketFilenameDump represents VPP binary API message 'memif_socket_filename_dump'.
 780 type MemifSocketFilenameDump struct{}
 781
 782 func (m *MemifSocketFilenameDump) Reset()                        { *m = MemifSocketFilenameDump{} }
 783 func (*MemifSocketFilenameDump) GetMessageName() string          { return "memif_socket_filename_dump" }
 784 func (*MemifSocketFilenameDump) GetCrcString() string            { return "51077d14" }
 785 func (*MemifSocketFilenameDump) GetMessageType() api.MessageType { return api.RequestMessage }
 786
 787 func (m *MemifSocketFilenameDump) Size() int {
 788         if m == nil {
 789                 return 0
 790         }
 791         var size int
 792         return size
 793 }
 794 func (m *MemifSocketFilenameDump) Marshal(b []byte) ([]byte, error) {
 795         o := binary.BigEndian
 796         _ = o
 797         pos := 0
 798         _ = pos
 799         var buf []byte
 800         if b == nil {
 801                 buf = make([]byte, m.Size())
 802         } else {
 803                 buf = b
 804         }
 805         return buf, nil
 806 }
 807 func (m *MemifSocketFilenameDump) Unmarshal(tmp []byte) error {
 808         o := binary.BigEndian
 809         _ = o
 810         pos := 0
 811         _ = pos
 812         return nil
 813 }
 814
 815 func init() { file_memif_binapi_init() }
 816 func file_memif_binapi_init() {
 817         api.RegisterMessage((*MemifCreate)(nil), "memif.MemifCreate")
 818         api.RegisterMessage((*MemifCreateReply)(nil), "memif.MemifCreateReply")
 819         api.RegisterMessage((*MemifDelete)(nil), "memif.MemifDelete")
 820         api.RegisterMessage((*MemifDeleteReply)(nil), "memif.MemifDeleteReply")
 821         api.RegisterMessage((*MemifDetails)(nil), "memif.MemifDetails")
 822         api.RegisterMessage((*MemifDump)(nil), "memif.MemifDump")
 823         api.RegisterMessage((*MemifSocketFilenameAddDel)(nil), "memif.MemifSocketFilenameAddDel")
 824         api.RegisterMessage((*MemifSocketFilenameAddDelReply)(nil), "memif.MemifSocketFilenameAddDelReply")
 825         api.RegisterMessage((*MemifSocketFilenameDetails)(nil), "memif.MemifSocketFilenameDetails")
 826         api.RegisterMessage((*MemifSocketFilenameDump)(nil), "memif.MemifSocketFilenameDump")
 827 }
 828
 829 // Messages returns list of all messages in this module.
 830 func AllMessages() []api.Message {
 831         return []api.Message{
 832                 (*MemifCreate)(nil),
 833                 (*MemifCreateReply)(nil),
 834                 (*MemifDelete)(nil),
 835                 (*MemifDeleteReply)(nil),
 836                 (*MemifDetails)(nil),
 837                 (*MemifDump)(nil),
 838                 (*MemifSocketFilenameAddDel)(nil),
 839                 (*MemifSocketFilenameAddDelReply)(nil),
 840                 (*MemifSocketFilenameDetails)(nil),
 841                 (*MemifSocketFilenameDump)(nil),
 842         }
 843 }
 844
 845 // Reference imports to suppress errors if they are not otherwise used.
 846 var _ = api.RegisterMessage
 847 var _ = codec.DecodeString
 848 var _ = bytes.NewBuffer
 849 var _ = context.Background
 850 var _ = io.Copy
 851 var _ = strconv.Itoa
 852 var _ = strings.Contains
 853 var _ = struc.Pack
 854 var _ = binary.BigEndian
 855 var _ = math.Float32bits
 856 var _ = net.ParseIP
 857 var _ = fmt.Errorf