binapi/wireguard/wireguard.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.5.0-dev
   4 //  VPP:              21.06-release
   5 // source: /usr/share/vpp/api/plugins/wireguard.api.json
   6
   7 // Package wireguard contains generated bindings for API file wireguard.api.
   8 //
   9 // Contents:
  10 //   1 enum
  11 //   2 structs
  12 //  12 messages
  13 //
  14 package wireguard
  15
  16 import (
  17         "strconv"
  18
  19         api "git.fd.io/govpp.git/api"
  20         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  21         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  22         codec "git.fd.io/govpp.git/codec"
  23 )
  24
  25 // This is a compile-time assertion to ensure that this generated file
  26 // is compatible with the GoVPP api package it is being compiled against.
  27 // A compilation error at this line likely means your copy of the
  28 // GoVPP api package needs to be updated.
  29 const _ = api.GoVppAPIPackageIsVersion2
  30
  31 const (
  32         APIFile    = "wireguard"
  33         APIVersion = "0.1.0"
  34         VersionCrc = 0x1e1d4252
  35 )
  36
  37 // WireguardPeerFlags defines enum 'wireguard_peer_flags'.
  38 type WireguardPeerFlags uint8
  39
  40 const (
  41         WIREGUARD_PEER_STATUS_DEAD WireguardPeerFlags = 1
  42 )
  43
  44 var (
  45         WireguardPeerFlags_name = map[uint8]string{
  46                 1: "WIREGUARD_PEER_STATUS_DEAD",
  47         }
  48         WireguardPeerFlags_value = map[string]uint8{
  49                 "WIREGUARD_PEER_STATUS_DEAD": 1,
  50         }
  51 )
  52
  53 func (x WireguardPeerFlags) String() string {
  54         s, ok := WireguardPeerFlags_name[uint8(x)]
  55         if ok {
  56                 return s
  57         }
  58         str := func(n uint8) string {
  59                 s, ok := WireguardPeerFlags_name[uint8(n)]
  60                 if ok {
  61                         return s
  62                 }
  63                 return "WireguardPeerFlags(" + strconv.Itoa(int(n)) + ")"
  64         }
  65         for i := uint8(0); i <= 8; i++ {
  66                 val := uint8(x)
  67                 if val&(1<<i) != 0 {
  68                         if s != "" {
  69                                 s += "|"
  70                         }
  71                         s += str(1 << i)
  72                 }
  73         }
  74         if s == "" {
  75                 return str(uint8(x))
  76         }
  77         return s
  78 }
  79
  80 // WireguardInterface defines type 'wireguard_interface'.
  81 type WireguardInterface struct {
  82         UserInstance uint32                         `binapi:"u32,name=user_instance,default=4294967295" json:"user_instance,omitempty"`
  83         SwIfIndex    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
  84         PrivateKey   []byte                         `binapi:"u8[32],name=private_key" json:"private_key,omitempty"`
  85         PublicKey    []byte                         `binapi:"u8[32],name=public_key" json:"public_key,omitempty"`
  86         Port         uint16                         `binapi:"u16,name=port" json:"port,omitempty"`
  87         SrcIP        ip_types.Address               `binapi:"address,name=src_ip" json:"src_ip,omitempty"`
  88 }
  89
  90 // WireguardPeer defines type 'wireguard_peer'.
  91 type WireguardPeer struct {
  92         PublicKey           []byte                         `binapi:"u8[32],name=public_key" json:"public_key,omitempty"`
  93         Port                uint16                         `binapi:"u16,name=port" json:"port,omitempty"`
  94         PersistentKeepalive uint16                         `binapi:"u16,name=persistent_keepalive" json:"persistent_keepalive,omitempty"`
  95         TableID             uint32                         `binapi:"u32,name=table_id" json:"table_id,omitempty"`
  96         Endpoint            ip_types.Address               `binapi:"address,name=endpoint" json:"endpoint,omitempty"`
  97         SwIfIndex           interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
  98         Flags               WireguardPeerFlags             `binapi:"wireguard_peer_flags,name=flags" json:"flags,omitempty"`
  99         NAllowedIps         uint8                          `binapi:"u8,name=n_allowed_ips" json:"-"`
 100         AllowedIps          []ip_types.Prefix              `binapi:"prefix[n_allowed_ips],name=allowed_ips" json:"allowed_ips,omitempty"`
 101 }
 102
 103 // WireguardInterfaceCreate defines message 'wireguard_interface_create'.
 104 // InProgress: the message form may change in the future versions
 105 type WireguardInterfaceCreate struct {
 106         Interface   WireguardInterface `binapi:"wireguard_interface,name=interface" json:"interface,omitempty"`
 107         GenerateKey bool               `binapi:"bool,name=generate_key" json:"generate_key,omitempty"`
 108 }
 109
 110 func (m *WireguardInterfaceCreate) Reset()               { *m = WireguardInterfaceCreate{} }
 111 func (*WireguardInterfaceCreate) GetMessageName() string { return "wireguard_interface_create" }
 112 func (*WireguardInterfaceCreate) GetCrcString() string   { return "a530137e" }
 113 func (*WireguardInterfaceCreate) GetMessageType() api.MessageType {
 114         return api.RequestMessage
 115 }
 116
 117 func (m *WireguardInterfaceCreate) Size() (size int) {
 118         if m == nil {
 119                 return 0
 120         }
 121         size += 4      // m.Interface.UserInstance
 122         size += 4      // m.Interface.SwIfIndex
 123         size += 1 * 32 // m.Interface.PrivateKey
 124         size += 1 * 32 // m.Interface.PublicKey
 125         size += 2      // m.Interface.Port
 126         size += 1      // m.Interface.SrcIP.Af
 127         size += 1 * 16 // m.Interface.SrcIP.Un
 128         size += 1      // m.GenerateKey
 129         return size
 130 }
 131 func (m *WireguardInterfaceCreate) Marshal(b []byte) ([]byte, error) {
 132         if b == nil {
 133                 b = make([]byte, m.Size())
 134         }
 135         buf := codec.NewBuffer(b)
 136         buf.EncodeUint32(m.Interface.UserInstance)
 137         buf.EncodeUint32(uint32(m.Interface.SwIfIndex))
 138         buf.EncodeBytes(m.Interface.PrivateKey, 32)
 139         buf.EncodeBytes(m.Interface.PublicKey, 32)
 140         buf.EncodeUint16(m.Interface.Port)
 141         buf.EncodeUint8(uint8(m.Interface.SrcIP.Af))
 142         buf.EncodeBytes(m.Interface.SrcIP.Un.XXX_UnionData[:], 16)
 143         buf.EncodeBool(m.GenerateKey)
 144         return buf.Bytes(), nil
 145 }
 146 func (m *WireguardInterfaceCreate) Unmarshal(b []byte) error {
 147         buf := codec.NewBuffer(b)
 148         m.Interface.UserInstance = buf.DecodeUint32()
 149         m.Interface.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 150         m.Interface.PrivateKey = make([]byte, 32)
 151         copy(m.Interface.PrivateKey, buf.DecodeBytes(len(m.Interface.PrivateKey)))
 152         m.Interface.PublicKey = make([]byte, 32)
 153         copy(m.Interface.PublicKey, buf.DecodeBytes(len(m.Interface.PublicKey)))
 154         m.Interface.Port = buf.DecodeUint16()
 155         m.Interface.SrcIP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 156         copy(m.Interface.SrcIP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 157         m.GenerateKey = buf.DecodeBool()
 158         return nil
 159 }
 160
 161 // WireguardInterfaceCreateReply defines message 'wireguard_interface_create_reply'.
 162 // InProgress: the message form may change in the future versions
 163 type WireguardInterfaceCreateReply struct {
 164         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 165         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 166 }
 167
 168 func (m *WireguardInterfaceCreateReply) Reset() { *m = WireguardInterfaceCreateReply{} }
 169 func (*WireguardInterfaceCreateReply) GetMessageName() string {
 170         return "wireguard_interface_create_reply"
 171 }
 172 func (*WireguardInterfaceCreateReply) GetCrcString() string { return "5383d31f" }
 173 func (*WireguardInterfaceCreateReply) GetMessageType() api.MessageType {
 174         return api.ReplyMessage
 175 }
 176
 177 func (m *WireguardInterfaceCreateReply) Size() (size int) {
 178         if m == nil {
 179                 return 0
 180         }
 181         size += 4 // m.Retval
 182         size += 4 // m.SwIfIndex
 183         return size
 184 }
 185 func (m *WireguardInterfaceCreateReply) Marshal(b []byte) ([]byte, error) {
 186         if b == nil {
 187                 b = make([]byte, m.Size())
 188         }
 189         buf := codec.NewBuffer(b)
 190         buf.EncodeInt32(m.Retval)
 191         buf.EncodeUint32(uint32(m.SwIfIndex))
 192         return buf.Bytes(), nil
 193 }
 194 func (m *WireguardInterfaceCreateReply) Unmarshal(b []byte) error {
 195         buf := codec.NewBuffer(b)
 196         m.Retval = buf.DecodeInt32()
 197         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 198         return nil
 199 }
 200
 201 // WireguardInterfaceDelete defines message 'wireguard_interface_delete'.
 202 // InProgress: the message form may change in the future versions
 203 type WireguardInterfaceDelete struct {
 204         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 205 }
 206
 207 func (m *WireguardInterfaceDelete) Reset()               { *m = WireguardInterfaceDelete{} }
 208 func (*WireguardInterfaceDelete) GetMessageName() string { return "wireguard_interface_delete" }
 209 func (*WireguardInterfaceDelete) GetCrcString() string   { return "f9e6675e" }
 210 func (*WireguardInterfaceDelete) GetMessageType() api.MessageType {
 211         return api.RequestMessage
 212 }
 213
 214 func (m *WireguardInterfaceDelete) Size() (size int) {
 215         if m == nil {
 216                 return 0
 217         }
 218         size += 4 // m.SwIfIndex
 219         return size
 220 }
 221 func (m *WireguardInterfaceDelete) Marshal(b []byte) ([]byte, error) {
 222         if b == nil {
 223                 b = make([]byte, m.Size())
 224         }
 225         buf := codec.NewBuffer(b)
 226         buf.EncodeUint32(uint32(m.SwIfIndex))
 227         return buf.Bytes(), nil
 228 }
 229 func (m *WireguardInterfaceDelete) Unmarshal(b []byte) error {
 230         buf := codec.NewBuffer(b)
 231         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 232         return nil
 233 }
 234
 235 // WireguardInterfaceDeleteReply defines message 'wireguard_interface_delete_reply'.
 236 // InProgress: the message form may change in the future versions
 237 type WireguardInterfaceDeleteReply struct {
 238         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 239 }
 240
 241 func (m *WireguardInterfaceDeleteReply) Reset() { *m = WireguardInterfaceDeleteReply{} }
 242 func (*WireguardInterfaceDeleteReply) GetMessageName() string {
 243         return "wireguard_interface_delete_reply"
 244 }
 245 func (*WireguardInterfaceDeleteReply) GetCrcString() string { return "e8d4e804" }
 246 func (*WireguardInterfaceDeleteReply) GetMessageType() api.MessageType {
 247         return api.ReplyMessage
 248 }
 249
 250 func (m *WireguardInterfaceDeleteReply) Size() (size int) {
 251         if m == nil {
 252                 return 0
 253         }
 254         size += 4 // m.Retval
 255         return size
 256 }
 257 func (m *WireguardInterfaceDeleteReply) Marshal(b []byte) ([]byte, error) {
 258         if b == nil {
 259                 b = make([]byte, m.Size())
 260         }
 261         buf := codec.NewBuffer(b)
 262         buf.EncodeInt32(m.Retval)
 263         return buf.Bytes(), nil
 264 }
 265 func (m *WireguardInterfaceDeleteReply) Unmarshal(b []byte) error {
 266         buf := codec.NewBuffer(b)
 267         m.Retval = buf.DecodeInt32()
 268         return nil
 269 }
 270
 271 // WireguardInterfaceDetails defines message 'wireguard_interface_details'.
 272 // InProgress: the message form may change in the future versions
 273 type WireguardInterfaceDetails struct {
 274         Interface WireguardInterface `binapi:"wireguard_interface,name=interface" json:"interface,omitempty"`
 275 }
 276
 277 func (m *WireguardInterfaceDetails) Reset()               { *m = WireguardInterfaceDetails{} }
 278 func (*WireguardInterfaceDetails) GetMessageName() string { return "wireguard_interface_details" }
 279 func (*WireguardInterfaceDetails) GetCrcString() string   { return "0dd4865d" }
 280 func (*WireguardInterfaceDetails) GetMessageType() api.MessageType {
 281         return api.ReplyMessage
 282 }
 283
 284 func (m *WireguardInterfaceDetails) Size() (size int) {
 285         if m == nil {
 286                 return 0
 287         }
 288         size += 4      // m.Interface.UserInstance
 289         size += 4      // m.Interface.SwIfIndex
 290         size += 1 * 32 // m.Interface.PrivateKey
 291         size += 1 * 32 // m.Interface.PublicKey
 292         size += 2      // m.Interface.Port
 293         size += 1      // m.Interface.SrcIP.Af
 294         size += 1 * 16 // m.Interface.SrcIP.Un
 295         return size
 296 }
 297 func (m *WireguardInterfaceDetails) Marshal(b []byte) ([]byte, error) {
 298         if b == nil {
 299                 b = make([]byte, m.Size())
 300         }
 301         buf := codec.NewBuffer(b)
 302         buf.EncodeUint32(m.Interface.UserInstance)
 303         buf.EncodeUint32(uint32(m.Interface.SwIfIndex))
 304         buf.EncodeBytes(m.Interface.PrivateKey, 32)
 305         buf.EncodeBytes(m.Interface.PublicKey, 32)
 306         buf.EncodeUint16(m.Interface.Port)
 307         buf.EncodeUint8(uint8(m.Interface.SrcIP.Af))
 308         buf.EncodeBytes(m.Interface.SrcIP.Un.XXX_UnionData[:], 16)
 309         return buf.Bytes(), nil
 310 }
 311 func (m *WireguardInterfaceDetails) Unmarshal(b []byte) error {
 312         buf := codec.NewBuffer(b)
 313         m.Interface.UserInstance = buf.DecodeUint32()
 314         m.Interface.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 315         m.Interface.PrivateKey = make([]byte, 32)
 316         copy(m.Interface.PrivateKey, buf.DecodeBytes(len(m.Interface.PrivateKey)))
 317         m.Interface.PublicKey = make([]byte, 32)
 318         copy(m.Interface.PublicKey, buf.DecodeBytes(len(m.Interface.PublicKey)))
 319         m.Interface.Port = buf.DecodeUint16()
 320         m.Interface.SrcIP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 321         copy(m.Interface.SrcIP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 322         return nil
 323 }
 324
 325 // WireguardInterfaceDump defines message 'wireguard_interface_dump'.
 326 // InProgress: the message form may change in the future versions
 327 type WireguardInterfaceDump struct {
 328         ShowPrivateKey bool                           `binapi:"bool,name=show_private_key" json:"show_private_key,omitempty"`
 329         SwIfIndex      interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 330 }
 331
 332 func (m *WireguardInterfaceDump) Reset()               { *m = WireguardInterfaceDump{} }
 333 func (*WireguardInterfaceDump) GetMessageName() string { return "wireguard_interface_dump" }
 334 func (*WireguardInterfaceDump) GetCrcString() string   { return "2c954158" }
 335 func (*WireguardInterfaceDump) GetMessageType() api.MessageType {
 336         return api.RequestMessage
 337 }
 338
 339 func (m *WireguardInterfaceDump) Size() (size int) {
 340         if m == nil {
 341                 return 0
 342         }
 343         size += 1 // m.ShowPrivateKey
 344         size += 4 // m.SwIfIndex
 345         return size
 346 }
 347 func (m *WireguardInterfaceDump) Marshal(b []byte) ([]byte, error) {
 348         if b == nil {
 349                 b = make([]byte, m.Size())
 350         }
 351         buf := codec.NewBuffer(b)
 352         buf.EncodeBool(m.ShowPrivateKey)
 353         buf.EncodeUint32(uint32(m.SwIfIndex))
 354         return buf.Bytes(), nil
 355 }
 356 func (m *WireguardInterfaceDump) Unmarshal(b []byte) error {
 357         buf := codec.NewBuffer(b)
 358         m.ShowPrivateKey = buf.DecodeBool()
 359         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 360         return nil
 361 }
 362
 363 // WireguardPeerAdd defines message 'wireguard_peer_add'.
 364 // InProgress: the message form may change in the future versions
 365 type WireguardPeerAdd struct {
 366         Peer WireguardPeer `binapi:"wireguard_peer,name=peer" json:"peer,omitempty"`
 367 }
 368
 369 func (m *WireguardPeerAdd) Reset()               { *m = WireguardPeerAdd{} }
 370 func (*WireguardPeerAdd) GetMessageName() string { return "wireguard_peer_add" }
 371 func (*WireguardPeerAdd) GetCrcString() string   { return "ed792326" }
 372 func (*WireguardPeerAdd) GetMessageType() api.MessageType {
 373         return api.RequestMessage
 374 }
 375
 376 func (m *WireguardPeerAdd) Size() (size int) {
 377         if m == nil {
 378                 return 0
 379         }
 380         size += 1 * 32 // m.Peer.PublicKey
 381         size += 2      // m.Peer.Port
 382         size += 2      // m.Peer.PersistentKeepalive
 383         size += 4      // m.Peer.TableID
 384         size += 1      // m.Peer.Endpoint.Af
 385         size += 1 * 16 // m.Peer.Endpoint.Un
 386         size += 4      // m.Peer.SwIfIndex
 387         size += 1      // m.Peer.Flags
 388         size += 1      // m.Peer.NAllowedIps
 389         for j2 := 0; j2 < len(m.Peer.AllowedIps); j2++ {
 390                 var s2 ip_types.Prefix
 391                 _ = s2
 392                 if j2 < len(m.Peer.AllowedIps) {
 393                         s2 = m.Peer.AllowedIps[j2]
 394                 }
 395                 size += 1      // s2.Address.Af
 396                 size += 1 * 16 // s2.Address.Un
 397                 size += 1      // s2.Len
 398         }
 399         return size
 400 }
 401 func (m *WireguardPeerAdd) Marshal(b []byte) ([]byte, error) {
 402         if b == nil {
 403                 b = make([]byte, m.Size())
 404         }
 405         buf := codec.NewBuffer(b)
 406         buf.EncodeBytes(m.Peer.PublicKey, 32)
 407         buf.EncodeUint16(m.Peer.Port)
 408         buf.EncodeUint16(m.Peer.PersistentKeepalive)
 409         buf.EncodeUint32(m.Peer.TableID)
 410         buf.EncodeUint8(uint8(m.Peer.Endpoint.Af))
 411         buf.EncodeBytes(m.Peer.Endpoint.Un.XXX_UnionData[:], 16)
 412         buf.EncodeUint32(uint32(m.Peer.SwIfIndex))
 413         buf.EncodeUint8(uint8(m.Peer.Flags))
 414         buf.EncodeUint8(uint8(len(m.Peer.AllowedIps)))
 415         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 416                 var v1 ip_types.Prefix // AllowedIps
 417                 if j1 < len(m.Peer.AllowedIps) {
 418                         v1 = m.Peer.AllowedIps[j1]
 419                 }
 420                 buf.EncodeUint8(uint8(v1.Address.Af))
 421                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
 422                 buf.EncodeUint8(v1.Len)
 423         }
 424         return buf.Bytes(), nil
 425 }
 426 func (m *WireguardPeerAdd) Unmarshal(b []byte) error {
 427         buf := codec.NewBuffer(b)
 428         m.Peer.PublicKey = make([]byte, 32)
 429         copy(m.Peer.PublicKey, buf.DecodeBytes(len(m.Peer.PublicKey)))
 430         m.Peer.Port = buf.DecodeUint16()
 431         m.Peer.PersistentKeepalive = buf.DecodeUint16()
 432         m.Peer.TableID = buf.DecodeUint32()
 433         m.Peer.Endpoint.Af = ip_types.AddressFamily(buf.DecodeUint8())
 434         copy(m.Peer.Endpoint.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 435         m.Peer.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 436         m.Peer.Flags = WireguardPeerFlags(buf.DecodeUint8())
 437         m.Peer.NAllowedIps = buf.DecodeUint8()
 438         m.Peer.AllowedIps = make([]ip_types.Prefix, m.Peer.NAllowedIps)
 439         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 440                 m.Peer.AllowedIps[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
 441                 copy(m.Peer.AllowedIps[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 442                 m.Peer.AllowedIps[j1].Len = buf.DecodeUint8()
 443         }
 444         return nil
 445 }
 446
 447 // WireguardPeerAddReply defines message 'wireguard_peer_add_reply'.
 448 // InProgress: the message form may change in the future versions
 449 type WireguardPeerAddReply struct {
 450         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 451         PeerIndex uint32 `binapi:"u32,name=peer_index" json:"peer_index,omitempty"`
 452 }
 453
 454 func (m *WireguardPeerAddReply) Reset()               { *m = WireguardPeerAddReply{} }
 455 func (*WireguardPeerAddReply) GetMessageName() string { return "wireguard_peer_add_reply" }
 456 func (*WireguardPeerAddReply) GetCrcString() string   { return "084a0cd3" }
 457 func (*WireguardPeerAddReply) GetMessageType() api.MessageType {
 458         return api.ReplyMessage
 459 }
 460
 461 func (m *WireguardPeerAddReply) Size() (size int) {
 462         if m == nil {
 463                 return 0
 464         }
 465         size += 4 // m.Retval
 466         size += 4 // m.PeerIndex
 467         return size
 468 }
 469 func (m *WireguardPeerAddReply) Marshal(b []byte) ([]byte, error) {
 470         if b == nil {
 471                 b = make([]byte, m.Size())
 472         }
 473         buf := codec.NewBuffer(b)
 474         buf.EncodeInt32(m.Retval)
 475         buf.EncodeUint32(m.PeerIndex)
 476         return buf.Bytes(), nil
 477 }
 478 func (m *WireguardPeerAddReply) Unmarshal(b []byte) error {
 479         buf := codec.NewBuffer(b)
 480         m.Retval = buf.DecodeInt32()
 481         m.PeerIndex = buf.DecodeUint32()
 482         return nil
 483 }
 484
 485 // WireguardPeerRemove defines message 'wireguard_peer_remove'.
 486 // InProgress: the message form may change in the future versions
 487 type WireguardPeerRemove struct {
 488         PeerIndex uint32 `binapi:"u32,name=peer_index" json:"peer_index,omitempty"`
 489 }
 490
 491 func (m *WireguardPeerRemove) Reset()               { *m = WireguardPeerRemove{} }
 492 func (*WireguardPeerRemove) GetMessageName() string { return "wireguard_peer_remove" }
 493 func (*WireguardPeerRemove) GetCrcString() string   { return "3b74607a" }
 494 func (*WireguardPeerRemove) GetMessageType() api.MessageType {
 495         return api.RequestMessage
 496 }
 497
 498 func (m *WireguardPeerRemove) Size() (size int) {
 499         if m == nil {
 500                 return 0
 501         }
 502         size += 4 // m.PeerIndex
 503         return size
 504 }
 505 func (m *WireguardPeerRemove) Marshal(b []byte) ([]byte, error) {
 506         if b == nil {
 507                 b = make([]byte, m.Size())
 508         }
 509         buf := codec.NewBuffer(b)
 510         buf.EncodeUint32(m.PeerIndex)
 511         return buf.Bytes(), nil
 512 }
 513 func (m *WireguardPeerRemove) Unmarshal(b []byte) error {
 514         buf := codec.NewBuffer(b)
 515         m.PeerIndex = buf.DecodeUint32()
 516         return nil
 517 }
 518
 519 // WireguardPeerRemoveReply defines message 'wireguard_peer_remove_reply'.
 520 // InProgress: the message form may change in the future versions
 521 type WireguardPeerRemoveReply struct {
 522         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 523 }
 524
 525 func (m *WireguardPeerRemoveReply) Reset()               { *m = WireguardPeerRemoveReply{} }
 526 func (*WireguardPeerRemoveReply) GetMessageName() string { return "wireguard_peer_remove_reply" }
 527 func (*WireguardPeerRemoveReply) GetCrcString() string   { return "e8d4e804" }
 528 func (*WireguardPeerRemoveReply) GetMessageType() api.MessageType {
 529         return api.ReplyMessage
 530 }
 531
 532 func (m *WireguardPeerRemoveReply) Size() (size int) {
 533         if m == nil {
 534                 return 0
 535         }
 536         size += 4 // m.Retval
 537         return size
 538 }
 539 func (m *WireguardPeerRemoveReply) Marshal(b []byte) ([]byte, error) {
 540         if b == nil {
 541                 b = make([]byte, m.Size())
 542         }
 543         buf := codec.NewBuffer(b)
 544         buf.EncodeInt32(m.Retval)
 545         return buf.Bytes(), nil
 546 }
 547 func (m *WireguardPeerRemoveReply) Unmarshal(b []byte) error {
 548         buf := codec.NewBuffer(b)
 549         m.Retval = buf.DecodeInt32()
 550         return nil
 551 }
 552
 553 // WireguardPeersDetails defines message 'wireguard_peers_details'.
 554 // InProgress: the message form may change in the future versions
 555 type WireguardPeersDetails struct {
 556         Peer WireguardPeer `binapi:"wireguard_peer,name=peer" json:"peer,omitempty"`
 557 }
 558
 559 func (m *WireguardPeersDetails) Reset()               { *m = WireguardPeersDetails{} }
 560 func (*WireguardPeersDetails) GetMessageName() string { return "wireguard_peers_details" }
 561 func (*WireguardPeersDetails) GetCrcString() string   { return "2097f740" }
 562 func (*WireguardPeersDetails) GetMessageType() api.MessageType {
 563         return api.ReplyMessage
 564 }
 565
 566 func (m *WireguardPeersDetails) Size() (size int) {
 567         if m == nil {
 568                 return 0
 569         }
 570         size += 1 * 32 // m.Peer.PublicKey
 571         size += 2      // m.Peer.Port
 572         size += 2      // m.Peer.PersistentKeepalive
 573         size += 4      // m.Peer.TableID
 574         size += 1      // m.Peer.Endpoint.Af
 575         size += 1 * 16 // m.Peer.Endpoint.Un
 576         size += 4      // m.Peer.SwIfIndex
 577         size += 1      // m.Peer.Flags
 578         size += 1      // m.Peer.NAllowedIps
 579         for j2 := 0; j2 < len(m.Peer.AllowedIps); j2++ {
 580                 var s2 ip_types.Prefix
 581                 _ = s2
 582                 if j2 < len(m.Peer.AllowedIps) {
 583                         s2 = m.Peer.AllowedIps[j2]
 584                 }
 585                 size += 1      // s2.Address.Af
 586                 size += 1 * 16 // s2.Address.Un
 587                 size += 1      // s2.Len
 588         }
 589         return size
 590 }
 591 func (m *WireguardPeersDetails) Marshal(b []byte) ([]byte, error) {
 592         if b == nil {
 593                 b = make([]byte, m.Size())
 594         }
 595         buf := codec.NewBuffer(b)
 596         buf.EncodeBytes(m.Peer.PublicKey, 32)
 597         buf.EncodeUint16(m.Peer.Port)
 598         buf.EncodeUint16(m.Peer.PersistentKeepalive)
 599         buf.EncodeUint32(m.Peer.TableID)
 600         buf.EncodeUint8(uint8(m.Peer.Endpoint.Af))
 601         buf.EncodeBytes(m.Peer.Endpoint.Un.XXX_UnionData[:], 16)
 602         buf.EncodeUint32(uint32(m.Peer.SwIfIndex))
 603         buf.EncodeUint8(uint8(m.Peer.Flags))
 604         buf.EncodeUint8(uint8(len(m.Peer.AllowedIps)))
 605         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 606                 var v1 ip_types.Prefix // AllowedIps
 607                 if j1 < len(m.Peer.AllowedIps) {
 608                         v1 = m.Peer.AllowedIps[j1]
 609                 }
 610                 buf.EncodeUint8(uint8(v1.Address.Af))
 611                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
 612                 buf.EncodeUint8(v1.Len)
 613         }
 614         return buf.Bytes(), nil
 615 }
 616 func (m *WireguardPeersDetails) Unmarshal(b []byte) error {
 617         buf := codec.NewBuffer(b)
 618         m.Peer.PublicKey = make([]byte, 32)
 619         copy(m.Peer.PublicKey, buf.DecodeBytes(len(m.Peer.PublicKey)))
 620         m.Peer.Port = buf.DecodeUint16()
 621         m.Peer.PersistentKeepalive = buf.DecodeUint16()
 622         m.Peer.TableID = buf.DecodeUint32()
 623         m.Peer.Endpoint.Af = ip_types.AddressFamily(buf.DecodeUint8())
 624         copy(m.Peer.Endpoint.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 625         m.Peer.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 626         m.Peer.Flags = WireguardPeerFlags(buf.DecodeUint8())
 627         m.Peer.NAllowedIps = buf.DecodeUint8()
 628         m.Peer.AllowedIps = make([]ip_types.Prefix, m.Peer.NAllowedIps)
 629         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 630                 m.Peer.AllowedIps[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
 631                 copy(m.Peer.AllowedIps[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 632                 m.Peer.AllowedIps[j1].Len = buf.DecodeUint8()
 633         }
 634         return nil
 635 }
 636
 637 // WireguardPeersDump defines message 'wireguard_peers_dump'.
 638 // InProgress: the message form may change in the future versions
 639 type WireguardPeersDump struct{}
 640
 641 func (m *WireguardPeersDump) Reset()               { *m = WireguardPeersDump{} }
 642 func (*WireguardPeersDump) GetMessageName() string { return "wireguard_peers_dump" }
 643 func (*WireguardPeersDump) GetCrcString() string   { return "51077d14" }
 644 func (*WireguardPeersDump) GetMessageType() api.MessageType {
 645         return api.RequestMessage
 646 }
 647
 648 func (m *WireguardPeersDump) Size() (size int) {
 649         if m == nil {
 650                 return 0
 651         }
 652         return size
 653 }
 654 func (m *WireguardPeersDump) Marshal(b []byte) ([]byte, error) {
 655         if b == nil {
 656                 b = make([]byte, m.Size())
 657         }
 658         buf := codec.NewBuffer(b)
 659         return buf.Bytes(), nil
 660 }
 661 func (m *WireguardPeersDump) Unmarshal(b []byte) error {
 662         return nil
 663 }
 664
 665 func init() { file_wireguard_binapi_init() }
 666 func file_wireguard_binapi_init() {
 667         api.RegisterMessage((*WireguardInterfaceCreate)(nil), "wireguard_interface_create_a530137e")
 668         api.RegisterMessage((*WireguardInterfaceCreateReply)(nil), "wireguard_interface_create_reply_5383d31f")
 669         api.RegisterMessage((*WireguardInterfaceDelete)(nil), "wireguard_interface_delete_f9e6675e")
 670         api.RegisterMessage((*WireguardInterfaceDeleteReply)(nil), "wireguard_interface_delete_reply_e8d4e804")
 671         api.RegisterMessage((*WireguardInterfaceDetails)(nil), "wireguard_interface_details_0dd4865d")
 672         api.RegisterMessage((*WireguardInterfaceDump)(nil), "wireguard_interface_dump_2c954158")
 673         api.RegisterMessage((*WireguardPeerAdd)(nil), "wireguard_peer_add_ed792326")
 674         api.RegisterMessage((*WireguardPeerAddReply)(nil), "wireguard_peer_add_reply_084a0cd3")
 675         api.RegisterMessage((*WireguardPeerRemove)(nil), "wireguard_peer_remove_3b74607a")
 676         api.RegisterMessage((*WireguardPeerRemoveReply)(nil), "wireguard_peer_remove_reply_e8d4e804")
 677         api.RegisterMessage((*WireguardPeersDetails)(nil), "wireguard_peers_details_2097f740")
 678         api.RegisterMessage((*WireguardPeersDump)(nil), "wireguard_peers_dump_51077d14")
 679 }
 680
 681 // Messages returns list of all messages in this module.
 682 func AllMessages() []api.Message {
 683         return []api.Message{
 684                 (*WireguardInterfaceCreate)(nil),
 685                 (*WireguardInterfaceCreateReply)(nil),
 686                 (*WireguardInterfaceDelete)(nil),
 687                 (*WireguardInterfaceDeleteReply)(nil),
 688                 (*WireguardInterfaceDetails)(nil),
 689                 (*WireguardInterfaceDump)(nil),
 690                 (*WireguardPeerAdd)(nil),
 691                 (*WireguardPeerAddReply)(nil),
 692                 (*WireguardPeerRemove)(nil),
 693                 (*WireguardPeerRemoveReply)(nil),
 694                 (*WireguardPeersDetails)(nil),
 695                 (*WireguardPeersDump)(nil),
 696         }
 697 }