binapi/wireguard/wireguard.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.6.0-dev
   4 //  VPP:              22.02-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 //  17 messages
  13 //
  14 package wireguard
  15
  16 import (
  17         "strconv"
  18
  19         api "go.fd.io/govpp/api"
  20         interface_types "go.fd.io/govpp/binapi/interface_types"
  21         ip_types "go.fd.io/govpp/binapi/ip_types"
  22         codec "go.fd.io/govpp/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 = 0xb58de7e
  35 )
  36
  37 // WireguardPeerFlags defines enum 'wireguard_peer_flags'.
  38 type WireguardPeerFlags uint8
  39
  40 const (
  41         WIREGUARD_PEER_STATUS_DEAD WireguardPeerFlags = 1
  42         WIREGUARD_PEER_ESTABLISHED WireguardPeerFlags = 2
  43 )
  44
  45 var (
  46         WireguardPeerFlags_name = map[uint8]string{
  47                 1: "WIREGUARD_PEER_STATUS_DEAD",
  48                 2: "WIREGUARD_PEER_ESTABLISHED",
  49         }
  50         WireguardPeerFlags_value = map[string]uint8{
  51                 "WIREGUARD_PEER_STATUS_DEAD": 1,
  52                 "WIREGUARD_PEER_ESTABLISHED": 2,
  53         }
  54 )
  55
  56 func (x WireguardPeerFlags) String() string {
  57         s, ok := WireguardPeerFlags_name[uint8(x)]
  58         if ok {
  59                 return s
  60         }
  61         str := func(n uint8) string {
  62                 s, ok := WireguardPeerFlags_name[uint8(n)]
  63                 if ok {
  64                         return s
  65                 }
  66                 return "WireguardPeerFlags(" + strconv.Itoa(int(n)) + ")"
  67         }
  68         for i := uint8(0); i <= 8; i++ {
  69                 val := uint8(x)
  70                 if val&(1<<i) != 0 {
  71                         if s != "" {
  72                                 s += "|"
  73                         }
  74                         s += str(1 << i)
  75                 }
  76         }
  77         if s == "" {
  78                 return str(uint8(x))
  79         }
  80         return s
  81 }
  82
  83 // WireguardInterface defines type 'wireguard_interface'.
  84 type WireguardInterface struct {
  85         UserInstance uint32                         `binapi:"u32,name=user_instance,default=4294967295" json:"user_instance,omitempty"`
  86         SwIfIndex    interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
  87         PrivateKey   []byte                         `binapi:"u8[32],name=private_key" json:"private_key,omitempty"`
  88         PublicKey    []byte                         `binapi:"u8[32],name=public_key" json:"public_key,omitempty"`
  89         Port         uint16                         `binapi:"u16,name=port" json:"port,omitempty"`
  90         SrcIP        ip_types.Address               `binapi:"address,name=src_ip" json:"src_ip,omitempty"`
  91 }
  92
  93 // WireguardPeer defines type 'wireguard_peer'.
  94 type WireguardPeer struct {
  95         PublicKey           []byte                         `binapi:"u8[32],name=public_key" json:"public_key,omitempty"`
  96         Port                uint16                         `binapi:"u16,name=port" json:"port,omitempty"`
  97         PersistentKeepalive uint16                         `binapi:"u16,name=persistent_keepalive" json:"persistent_keepalive,omitempty"`
  98         TableID             uint32                         `binapi:"u32,name=table_id" json:"table_id,omitempty"`
  99         Endpoint            ip_types.Address               `binapi:"address,name=endpoint" json:"endpoint,omitempty"`
 100         SwIfIndex           interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 101         Flags               WireguardPeerFlags             `binapi:"wireguard_peer_flags,name=flags" json:"flags,omitempty"`
 102         NAllowedIps         uint8                          `binapi:"u8,name=n_allowed_ips" json:"-"`
 103         AllowedIps          []ip_types.Prefix              `binapi:"prefix[n_allowed_ips],name=allowed_ips" json:"allowed_ips,omitempty"`
 104 }
 105
 106 // WantWireguardPeerEvents defines message 'want_wireguard_peer_events'.
 107 // InProgress: the message form may change in the future versions
 108 type WantWireguardPeerEvents struct {
 109         SwIfIndex     interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index,default=4294967295" json:"sw_if_index,omitempty"`
 110         PeerIndex     uint32                         `binapi:"u32,name=peer_index,default=4294967295" json:"peer_index,omitempty"`
 111         EnableDisable uint32                         `binapi:"u32,name=enable_disable" json:"enable_disable,omitempty"`
 112         PID           uint32                         `binapi:"u32,name=pid" json:"pid,omitempty"`
 113 }
 114
 115 func (m *WantWireguardPeerEvents) Reset()               { *m = WantWireguardPeerEvents{} }
 116 func (*WantWireguardPeerEvents) GetMessageName() string { return "want_wireguard_peer_events" }
 117 func (*WantWireguardPeerEvents) GetCrcString() string   { return "3bc666c8" }
 118 func (*WantWireguardPeerEvents) GetMessageType() api.MessageType {
 119         return api.RequestMessage
 120 }
 121
 122 func (m *WantWireguardPeerEvents) Size() (size int) {
 123         if m == nil {
 124                 return 0
 125         }
 126         size += 4 // m.SwIfIndex
 127         size += 4 // m.PeerIndex
 128         size += 4 // m.EnableDisable
 129         size += 4 // m.PID
 130         return size
 131 }
 132 func (m *WantWireguardPeerEvents) Marshal(b []byte) ([]byte, error) {
 133         if b == nil {
 134                 b = make([]byte, m.Size())
 135         }
 136         buf := codec.NewBuffer(b)
 137         buf.EncodeUint32(uint32(m.SwIfIndex))
 138         buf.EncodeUint32(m.PeerIndex)
 139         buf.EncodeUint32(m.EnableDisable)
 140         buf.EncodeUint32(m.PID)
 141         return buf.Bytes(), nil
 142 }
 143 func (m *WantWireguardPeerEvents) Unmarshal(b []byte) error {
 144         buf := codec.NewBuffer(b)
 145         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 146         m.PeerIndex = buf.DecodeUint32()
 147         m.EnableDisable = buf.DecodeUint32()
 148         m.PID = buf.DecodeUint32()
 149         return nil
 150 }
 151
 152 // WantWireguardPeerEventsReply defines message 'want_wireguard_peer_events_reply'.
 153 // InProgress: the message form may change in the future versions
 154 type WantWireguardPeerEventsReply struct {
 155         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 156 }
 157
 158 func (m *WantWireguardPeerEventsReply) Reset() { *m = WantWireguardPeerEventsReply{} }
 159 func (*WantWireguardPeerEventsReply) GetMessageName() string {
 160         return "want_wireguard_peer_events_reply"
 161 }
 162 func (*WantWireguardPeerEventsReply) GetCrcString() string { return "e8d4e804" }
 163 func (*WantWireguardPeerEventsReply) GetMessageType() api.MessageType {
 164         return api.ReplyMessage
 165 }
 166
 167 func (m *WantWireguardPeerEventsReply) Size() (size int) {
 168         if m == nil {
 169                 return 0
 170         }
 171         size += 4 // m.Retval
 172         return size
 173 }
 174 func (m *WantWireguardPeerEventsReply) Marshal(b []byte) ([]byte, error) {
 175         if b == nil {
 176                 b = make([]byte, m.Size())
 177         }
 178         buf := codec.NewBuffer(b)
 179         buf.EncodeInt32(m.Retval)
 180         return buf.Bytes(), nil
 181 }
 182 func (m *WantWireguardPeerEventsReply) Unmarshal(b []byte) error {
 183         buf := codec.NewBuffer(b)
 184         m.Retval = buf.DecodeInt32()
 185         return nil
 186 }
 187
 188 // WgSetAsyncMode defines message 'wg_set_async_mode'.
 189 // InProgress: the message form may change in the future versions
 190 type WgSetAsyncMode struct {
 191         AsyncEnable bool `binapi:"bool,name=async_enable" json:"async_enable,omitempty"`
 192 }
 193
 194 func (m *WgSetAsyncMode) Reset()               { *m = WgSetAsyncMode{} }
 195 func (*WgSetAsyncMode) GetMessageName() string { return "wg_set_async_mode" }
 196 func (*WgSetAsyncMode) GetCrcString() string   { return "a6465f7c" }
 197 func (*WgSetAsyncMode) GetMessageType() api.MessageType {
 198         return api.RequestMessage
 199 }
 200
 201 func (m *WgSetAsyncMode) Size() (size int) {
 202         if m == nil {
 203                 return 0
 204         }
 205         size += 1 // m.AsyncEnable
 206         return size
 207 }
 208 func (m *WgSetAsyncMode) Marshal(b []byte) ([]byte, error) {
 209         if b == nil {
 210                 b = make([]byte, m.Size())
 211         }
 212         buf := codec.NewBuffer(b)
 213         buf.EncodeBool(m.AsyncEnable)
 214         return buf.Bytes(), nil
 215 }
 216 func (m *WgSetAsyncMode) Unmarshal(b []byte) error {
 217         buf := codec.NewBuffer(b)
 218         m.AsyncEnable = buf.DecodeBool()
 219         return nil
 220 }
 221
 222 // WgSetAsyncModeReply defines message 'wg_set_async_mode_reply'.
 223 // InProgress: the message form may change in the future versions
 224 type WgSetAsyncModeReply struct {
 225         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 226 }
 227
 228 func (m *WgSetAsyncModeReply) Reset()               { *m = WgSetAsyncModeReply{} }
 229 func (*WgSetAsyncModeReply) GetMessageName() string { return "wg_set_async_mode_reply" }
 230 func (*WgSetAsyncModeReply) GetCrcString() string   { return "e8d4e804" }
 231 func (*WgSetAsyncModeReply) GetMessageType() api.MessageType {
 232         return api.ReplyMessage
 233 }
 234
 235 func (m *WgSetAsyncModeReply) Size() (size int) {
 236         if m == nil {
 237                 return 0
 238         }
 239         size += 4 // m.Retval
 240         return size
 241 }
 242 func (m *WgSetAsyncModeReply) Marshal(b []byte) ([]byte, error) {
 243         if b == nil {
 244                 b = make([]byte, m.Size())
 245         }
 246         buf := codec.NewBuffer(b)
 247         buf.EncodeInt32(m.Retval)
 248         return buf.Bytes(), nil
 249 }
 250 func (m *WgSetAsyncModeReply) Unmarshal(b []byte) error {
 251         buf := codec.NewBuffer(b)
 252         m.Retval = buf.DecodeInt32()
 253         return nil
 254 }
 255
 256 // WireguardInterfaceCreate defines message 'wireguard_interface_create'.
 257 // InProgress: the message form may change in the future versions
 258 type WireguardInterfaceCreate struct {
 259         Interface   WireguardInterface `binapi:"wireguard_interface,name=interface" json:"interface,omitempty"`
 260         GenerateKey bool               `binapi:"bool,name=generate_key" json:"generate_key,omitempty"`
 261 }
 262
 263 func (m *WireguardInterfaceCreate) Reset()               { *m = WireguardInterfaceCreate{} }
 264 func (*WireguardInterfaceCreate) GetMessageName() string { return "wireguard_interface_create" }
 265 func (*WireguardInterfaceCreate) GetCrcString() string   { return "a530137e" }
 266 func (*WireguardInterfaceCreate) GetMessageType() api.MessageType {
 267         return api.RequestMessage
 268 }
 269
 270 func (m *WireguardInterfaceCreate) Size() (size int) {
 271         if m == nil {
 272                 return 0
 273         }
 274         size += 4      // m.Interface.UserInstance
 275         size += 4      // m.Interface.SwIfIndex
 276         size += 1 * 32 // m.Interface.PrivateKey
 277         size += 1 * 32 // m.Interface.PublicKey
 278         size += 2      // m.Interface.Port
 279         size += 1      // m.Interface.SrcIP.Af
 280         size += 1 * 16 // m.Interface.SrcIP.Un
 281         size += 1      // m.GenerateKey
 282         return size
 283 }
 284 func (m *WireguardInterfaceCreate) Marshal(b []byte) ([]byte, error) {
 285         if b == nil {
 286                 b = make([]byte, m.Size())
 287         }
 288         buf := codec.NewBuffer(b)
 289         buf.EncodeUint32(m.Interface.UserInstance)
 290         buf.EncodeUint32(uint32(m.Interface.SwIfIndex))
 291         buf.EncodeBytes(m.Interface.PrivateKey, 32)
 292         buf.EncodeBytes(m.Interface.PublicKey, 32)
 293         buf.EncodeUint16(m.Interface.Port)
 294         buf.EncodeUint8(uint8(m.Interface.SrcIP.Af))
 295         buf.EncodeBytes(m.Interface.SrcIP.Un.XXX_UnionData[:], 16)
 296         buf.EncodeBool(m.GenerateKey)
 297         return buf.Bytes(), nil
 298 }
 299 func (m *WireguardInterfaceCreate) Unmarshal(b []byte) error {
 300         buf := codec.NewBuffer(b)
 301         m.Interface.UserInstance = buf.DecodeUint32()
 302         m.Interface.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 303         m.Interface.PrivateKey = make([]byte, 32)
 304         copy(m.Interface.PrivateKey, buf.DecodeBytes(len(m.Interface.PrivateKey)))
 305         m.Interface.PublicKey = make([]byte, 32)
 306         copy(m.Interface.PublicKey, buf.DecodeBytes(len(m.Interface.PublicKey)))
 307         m.Interface.Port = buf.DecodeUint16()
 308         m.Interface.SrcIP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 309         copy(m.Interface.SrcIP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 310         m.GenerateKey = buf.DecodeBool()
 311         return nil
 312 }
 313
 314 // WireguardInterfaceCreateReply defines message 'wireguard_interface_create_reply'.
 315 // InProgress: the message form may change in the future versions
 316 type WireguardInterfaceCreateReply struct {
 317         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
 318         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 319 }
 320
 321 func (m *WireguardInterfaceCreateReply) Reset() { *m = WireguardInterfaceCreateReply{} }
 322 func (*WireguardInterfaceCreateReply) GetMessageName() string {
 323         return "wireguard_interface_create_reply"
 324 }
 325 func (*WireguardInterfaceCreateReply) GetCrcString() string { return "5383d31f" }
 326 func (*WireguardInterfaceCreateReply) GetMessageType() api.MessageType {
 327         return api.ReplyMessage
 328 }
 329
 330 func (m *WireguardInterfaceCreateReply) Size() (size int) {
 331         if m == nil {
 332                 return 0
 333         }
 334         size += 4 // m.Retval
 335         size += 4 // m.SwIfIndex
 336         return size
 337 }
 338 func (m *WireguardInterfaceCreateReply) Marshal(b []byte) ([]byte, error) {
 339         if b == nil {
 340                 b = make([]byte, m.Size())
 341         }
 342         buf := codec.NewBuffer(b)
 343         buf.EncodeInt32(m.Retval)
 344         buf.EncodeUint32(uint32(m.SwIfIndex))
 345         return buf.Bytes(), nil
 346 }
 347 func (m *WireguardInterfaceCreateReply) Unmarshal(b []byte) error {
 348         buf := codec.NewBuffer(b)
 349         m.Retval = buf.DecodeInt32()
 350         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 351         return nil
 352 }
 353
 354 // WireguardInterfaceDelete defines message 'wireguard_interface_delete'.
 355 // InProgress: the message form may change in the future versions
 356 type WireguardInterfaceDelete struct {
 357         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 358 }
 359
 360 func (m *WireguardInterfaceDelete) Reset()               { *m = WireguardInterfaceDelete{} }
 361 func (*WireguardInterfaceDelete) GetMessageName() string { return "wireguard_interface_delete" }
 362 func (*WireguardInterfaceDelete) GetCrcString() string   { return "f9e6675e" }
 363 func (*WireguardInterfaceDelete) GetMessageType() api.MessageType {
 364         return api.RequestMessage
 365 }
 366
 367 func (m *WireguardInterfaceDelete) Size() (size int) {
 368         if m == nil {
 369                 return 0
 370         }
 371         size += 4 // m.SwIfIndex
 372         return size
 373 }
 374 func (m *WireguardInterfaceDelete) Marshal(b []byte) ([]byte, error) {
 375         if b == nil {
 376                 b = make([]byte, m.Size())
 377         }
 378         buf := codec.NewBuffer(b)
 379         buf.EncodeUint32(uint32(m.SwIfIndex))
 380         return buf.Bytes(), nil
 381 }
 382 func (m *WireguardInterfaceDelete) Unmarshal(b []byte) error {
 383         buf := codec.NewBuffer(b)
 384         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 385         return nil
 386 }
 387
 388 // WireguardInterfaceDeleteReply defines message 'wireguard_interface_delete_reply'.
 389 // InProgress: the message form may change in the future versions
 390 type WireguardInterfaceDeleteReply struct {
 391         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 392 }
 393
 394 func (m *WireguardInterfaceDeleteReply) Reset() { *m = WireguardInterfaceDeleteReply{} }
 395 func (*WireguardInterfaceDeleteReply) GetMessageName() string {
 396         return "wireguard_interface_delete_reply"
 397 }
 398 func (*WireguardInterfaceDeleteReply) GetCrcString() string { return "e8d4e804" }
 399 func (*WireguardInterfaceDeleteReply) GetMessageType() api.MessageType {
 400         return api.ReplyMessage
 401 }
 402
 403 func (m *WireguardInterfaceDeleteReply) Size() (size int) {
 404         if m == nil {
 405                 return 0
 406         }
 407         size += 4 // m.Retval
 408         return size
 409 }
 410 func (m *WireguardInterfaceDeleteReply) Marshal(b []byte) ([]byte, error) {
 411         if b == nil {
 412                 b = make([]byte, m.Size())
 413         }
 414         buf := codec.NewBuffer(b)
 415         buf.EncodeInt32(m.Retval)
 416         return buf.Bytes(), nil
 417 }
 418 func (m *WireguardInterfaceDeleteReply) Unmarshal(b []byte) error {
 419         buf := codec.NewBuffer(b)
 420         m.Retval = buf.DecodeInt32()
 421         return nil
 422 }
 423
 424 // WireguardInterfaceDetails defines message 'wireguard_interface_details'.
 425 // InProgress: the message form may change in the future versions
 426 type WireguardInterfaceDetails struct {
 427         Interface WireguardInterface `binapi:"wireguard_interface,name=interface" json:"interface,omitempty"`
 428 }
 429
 430 func (m *WireguardInterfaceDetails) Reset()               { *m = WireguardInterfaceDetails{} }
 431 func (*WireguardInterfaceDetails) GetMessageName() string { return "wireguard_interface_details" }
 432 func (*WireguardInterfaceDetails) GetCrcString() string   { return "0dd4865d" }
 433 func (*WireguardInterfaceDetails) GetMessageType() api.MessageType {
 434         return api.ReplyMessage
 435 }
 436
 437 func (m *WireguardInterfaceDetails) Size() (size int) {
 438         if m == nil {
 439                 return 0
 440         }
 441         size += 4      // m.Interface.UserInstance
 442         size += 4      // m.Interface.SwIfIndex
 443         size += 1 * 32 // m.Interface.PrivateKey
 444         size += 1 * 32 // m.Interface.PublicKey
 445         size += 2      // m.Interface.Port
 446         size += 1      // m.Interface.SrcIP.Af
 447         size += 1 * 16 // m.Interface.SrcIP.Un
 448         return size
 449 }
 450 func (m *WireguardInterfaceDetails) Marshal(b []byte) ([]byte, error) {
 451         if b == nil {
 452                 b = make([]byte, m.Size())
 453         }
 454         buf := codec.NewBuffer(b)
 455         buf.EncodeUint32(m.Interface.UserInstance)
 456         buf.EncodeUint32(uint32(m.Interface.SwIfIndex))
 457         buf.EncodeBytes(m.Interface.PrivateKey, 32)
 458         buf.EncodeBytes(m.Interface.PublicKey, 32)
 459         buf.EncodeUint16(m.Interface.Port)
 460         buf.EncodeUint8(uint8(m.Interface.SrcIP.Af))
 461         buf.EncodeBytes(m.Interface.SrcIP.Un.XXX_UnionData[:], 16)
 462         return buf.Bytes(), nil
 463 }
 464 func (m *WireguardInterfaceDetails) Unmarshal(b []byte) error {
 465         buf := codec.NewBuffer(b)
 466         m.Interface.UserInstance = buf.DecodeUint32()
 467         m.Interface.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 468         m.Interface.PrivateKey = make([]byte, 32)
 469         copy(m.Interface.PrivateKey, buf.DecodeBytes(len(m.Interface.PrivateKey)))
 470         m.Interface.PublicKey = make([]byte, 32)
 471         copy(m.Interface.PublicKey, buf.DecodeBytes(len(m.Interface.PublicKey)))
 472         m.Interface.Port = buf.DecodeUint16()
 473         m.Interface.SrcIP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 474         copy(m.Interface.SrcIP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 475         return nil
 476 }
 477
 478 // WireguardInterfaceDump defines message 'wireguard_interface_dump'.
 479 // InProgress: the message form may change in the future versions
 480 type WireguardInterfaceDump struct {
 481         ShowPrivateKey bool                           `binapi:"bool,name=show_private_key" json:"show_private_key,omitempty"`
 482         SwIfIndex      interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 483 }
 484
 485 func (m *WireguardInterfaceDump) Reset()               { *m = WireguardInterfaceDump{} }
 486 func (*WireguardInterfaceDump) GetMessageName() string { return "wireguard_interface_dump" }
 487 func (*WireguardInterfaceDump) GetCrcString() string   { return "2c954158" }
 488 func (*WireguardInterfaceDump) GetMessageType() api.MessageType {
 489         return api.RequestMessage
 490 }
 491
 492 func (m *WireguardInterfaceDump) Size() (size int) {
 493         if m == nil {
 494                 return 0
 495         }
 496         size += 1 // m.ShowPrivateKey
 497         size += 4 // m.SwIfIndex
 498         return size
 499 }
 500 func (m *WireguardInterfaceDump) Marshal(b []byte) ([]byte, error) {
 501         if b == nil {
 502                 b = make([]byte, m.Size())
 503         }
 504         buf := codec.NewBuffer(b)
 505         buf.EncodeBool(m.ShowPrivateKey)
 506         buf.EncodeUint32(uint32(m.SwIfIndex))
 507         return buf.Bytes(), nil
 508 }
 509 func (m *WireguardInterfaceDump) Unmarshal(b []byte) error {
 510         buf := codec.NewBuffer(b)
 511         m.ShowPrivateKey = buf.DecodeBool()
 512         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 513         return nil
 514 }
 515
 516 // WireguardPeerAdd defines message 'wireguard_peer_add'.
 517 // InProgress: the message form may change in the future versions
 518 type WireguardPeerAdd struct {
 519         Peer WireguardPeer `binapi:"wireguard_peer,name=peer" json:"peer,omitempty"`
 520 }
 521
 522 func (m *WireguardPeerAdd) Reset()               { *m = WireguardPeerAdd{} }
 523 func (*WireguardPeerAdd) GetMessageName() string { return "wireguard_peer_add" }
 524 func (*WireguardPeerAdd) GetCrcString() string   { return "aedf8d59" }
 525 func (*WireguardPeerAdd) GetMessageType() api.MessageType {
 526         return api.RequestMessage
 527 }
 528
 529 func (m *WireguardPeerAdd) Size() (size int) {
 530         if m == nil {
 531                 return 0
 532         }
 533         size += 1 * 32 // m.Peer.PublicKey
 534         size += 2      // m.Peer.Port
 535         size += 2      // m.Peer.PersistentKeepalive
 536         size += 4      // m.Peer.TableID
 537         size += 1      // m.Peer.Endpoint.Af
 538         size += 1 * 16 // m.Peer.Endpoint.Un
 539         size += 4      // m.Peer.SwIfIndex
 540         size += 1      // m.Peer.Flags
 541         size += 1      // m.Peer.NAllowedIps
 542         for j2 := 0; j2 < len(m.Peer.AllowedIps); j2++ {
 543                 var s2 ip_types.Prefix
 544                 _ = s2
 545                 if j2 < len(m.Peer.AllowedIps) {
 546                         s2 = m.Peer.AllowedIps[j2]
 547                 }
 548                 size += 1      // s2.Address.Af
 549                 size += 1 * 16 // s2.Address.Un
 550                 size += 1      // s2.Len
 551         }
 552         return size
 553 }
 554 func (m *WireguardPeerAdd) Marshal(b []byte) ([]byte, error) {
 555         if b == nil {
 556                 b = make([]byte, m.Size())
 557         }
 558         buf := codec.NewBuffer(b)
 559         buf.EncodeBytes(m.Peer.PublicKey, 32)
 560         buf.EncodeUint16(m.Peer.Port)
 561         buf.EncodeUint16(m.Peer.PersistentKeepalive)
 562         buf.EncodeUint32(m.Peer.TableID)
 563         buf.EncodeUint8(uint8(m.Peer.Endpoint.Af))
 564         buf.EncodeBytes(m.Peer.Endpoint.Un.XXX_UnionData[:], 16)
 565         buf.EncodeUint32(uint32(m.Peer.SwIfIndex))
 566         buf.EncodeUint8(uint8(m.Peer.Flags))
 567         buf.EncodeUint8(uint8(len(m.Peer.AllowedIps)))
 568         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 569                 var v1 ip_types.Prefix // AllowedIps
 570                 if j1 < len(m.Peer.AllowedIps) {
 571                         v1 = m.Peer.AllowedIps[j1]
 572                 }
 573                 buf.EncodeUint8(uint8(v1.Address.Af))
 574                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
 575                 buf.EncodeUint8(v1.Len)
 576         }
 577         return buf.Bytes(), nil
 578 }
 579 func (m *WireguardPeerAdd) Unmarshal(b []byte) error {
 580         buf := codec.NewBuffer(b)
 581         m.Peer.PublicKey = make([]byte, 32)
 582         copy(m.Peer.PublicKey, buf.DecodeBytes(len(m.Peer.PublicKey)))
 583         m.Peer.Port = buf.DecodeUint16()
 584         m.Peer.PersistentKeepalive = buf.DecodeUint16()
 585         m.Peer.TableID = buf.DecodeUint32()
 586         m.Peer.Endpoint.Af = ip_types.AddressFamily(buf.DecodeUint8())
 587         copy(m.Peer.Endpoint.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 588         m.Peer.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 589         m.Peer.Flags = WireguardPeerFlags(buf.DecodeUint8())
 590         m.Peer.NAllowedIps = buf.DecodeUint8()
 591         m.Peer.AllowedIps = make([]ip_types.Prefix, m.Peer.NAllowedIps)
 592         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 593                 m.Peer.AllowedIps[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
 594                 copy(m.Peer.AllowedIps[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 595                 m.Peer.AllowedIps[j1].Len = buf.DecodeUint8()
 596         }
 597         return nil
 598 }
 599
 600 // WireguardPeerAddReply defines message 'wireguard_peer_add_reply'.
 601 // InProgress: the message form may change in the future versions
 602 type WireguardPeerAddReply struct {
 603         Retval    int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 604         PeerIndex uint32 `binapi:"u32,name=peer_index" json:"peer_index,omitempty"`
 605 }
 606
 607 func (m *WireguardPeerAddReply) Reset()               { *m = WireguardPeerAddReply{} }
 608 func (*WireguardPeerAddReply) GetMessageName() string { return "wireguard_peer_add_reply" }
 609 func (*WireguardPeerAddReply) GetCrcString() string   { return "084a0cd3" }
 610 func (*WireguardPeerAddReply) GetMessageType() api.MessageType {
 611         return api.ReplyMessage
 612 }
 613
 614 func (m *WireguardPeerAddReply) Size() (size int) {
 615         if m == nil {
 616                 return 0
 617         }
 618         size += 4 // m.Retval
 619         size += 4 // m.PeerIndex
 620         return size
 621 }
 622 func (m *WireguardPeerAddReply) Marshal(b []byte) ([]byte, error) {
 623         if b == nil {
 624                 b = make([]byte, m.Size())
 625         }
 626         buf := codec.NewBuffer(b)
 627         buf.EncodeInt32(m.Retval)
 628         buf.EncodeUint32(m.PeerIndex)
 629         return buf.Bytes(), nil
 630 }
 631 func (m *WireguardPeerAddReply) Unmarshal(b []byte) error {
 632         buf := codec.NewBuffer(b)
 633         m.Retval = buf.DecodeInt32()
 634         m.PeerIndex = buf.DecodeUint32()
 635         return nil
 636 }
 637
 638 // WireguardPeerEvent defines message 'wireguard_peer_event'.
 639 // InProgress: the message form may change in the future versions
 640 type WireguardPeerEvent struct {
 641         PID       uint32             `binapi:"u32,name=pid" json:"pid,omitempty"`
 642         PeerIndex uint32             `binapi:"u32,name=peer_index" json:"peer_index,omitempty"`
 643         Flags     WireguardPeerFlags `binapi:"wireguard_peer_flags,name=flags" json:"flags,omitempty"`
 644 }
 645
 646 func (m *WireguardPeerEvent) Reset()               { *m = WireguardPeerEvent{} }
 647 func (*WireguardPeerEvent) GetMessageName() string { return "wireguard_peer_event" }
 648 func (*WireguardPeerEvent) GetCrcString() string   { return "4e1b5d67" }
 649 func (*WireguardPeerEvent) GetMessageType() api.MessageType {
 650         return api.EventMessage
 651 }
 652
 653 func (m *WireguardPeerEvent) Size() (size int) {
 654         if m == nil {
 655                 return 0
 656         }
 657         size += 4 // m.PID
 658         size += 4 // m.PeerIndex
 659         size += 1 // m.Flags
 660         return size
 661 }
 662 func (m *WireguardPeerEvent) Marshal(b []byte) ([]byte, error) {
 663         if b == nil {
 664                 b = make([]byte, m.Size())
 665         }
 666         buf := codec.NewBuffer(b)
 667         buf.EncodeUint32(m.PID)
 668         buf.EncodeUint32(m.PeerIndex)
 669         buf.EncodeUint8(uint8(m.Flags))
 670         return buf.Bytes(), nil
 671 }
 672 func (m *WireguardPeerEvent) Unmarshal(b []byte) error {
 673         buf := codec.NewBuffer(b)
 674         m.PID = buf.DecodeUint32()
 675         m.PeerIndex = buf.DecodeUint32()
 676         m.Flags = WireguardPeerFlags(buf.DecodeUint8())
 677         return nil
 678 }
 679
 680 // WireguardPeerRemove defines message 'wireguard_peer_remove'.
 681 // InProgress: the message form may change in the future versions
 682 type WireguardPeerRemove struct {
 683         PeerIndex uint32 `binapi:"u32,name=peer_index" json:"peer_index,omitempty"`
 684 }
 685
 686 func (m *WireguardPeerRemove) Reset()               { *m = WireguardPeerRemove{} }
 687 func (*WireguardPeerRemove) GetMessageName() string { return "wireguard_peer_remove" }
 688 func (*WireguardPeerRemove) GetCrcString() string   { return "3b74607a" }
 689 func (*WireguardPeerRemove) GetMessageType() api.MessageType {
 690         return api.RequestMessage
 691 }
 692
 693 func (m *WireguardPeerRemove) Size() (size int) {
 694         if m == nil {
 695                 return 0
 696         }
 697         size += 4 // m.PeerIndex
 698         return size
 699 }
 700 func (m *WireguardPeerRemove) Marshal(b []byte) ([]byte, error) {
 701         if b == nil {
 702                 b = make([]byte, m.Size())
 703         }
 704         buf := codec.NewBuffer(b)
 705         buf.EncodeUint32(m.PeerIndex)
 706         return buf.Bytes(), nil
 707 }
 708 func (m *WireguardPeerRemove) Unmarshal(b []byte) error {
 709         buf := codec.NewBuffer(b)
 710         m.PeerIndex = buf.DecodeUint32()
 711         return nil
 712 }
 713
 714 // WireguardPeerRemoveReply defines message 'wireguard_peer_remove_reply'.
 715 // InProgress: the message form may change in the future versions
 716 type WireguardPeerRemoveReply struct {
 717         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 718 }
 719
 720 func (m *WireguardPeerRemoveReply) Reset()               { *m = WireguardPeerRemoveReply{} }
 721 func (*WireguardPeerRemoveReply) GetMessageName() string { return "wireguard_peer_remove_reply" }
 722 func (*WireguardPeerRemoveReply) GetCrcString() string   { return "e8d4e804" }
 723 func (*WireguardPeerRemoveReply) GetMessageType() api.MessageType {
 724         return api.ReplyMessage
 725 }
 726
 727 func (m *WireguardPeerRemoveReply) Size() (size int) {
 728         if m == nil {
 729                 return 0
 730         }
 731         size += 4 // m.Retval
 732         return size
 733 }
 734 func (m *WireguardPeerRemoveReply) Marshal(b []byte) ([]byte, error) {
 735         if b == nil {
 736                 b = make([]byte, m.Size())
 737         }
 738         buf := codec.NewBuffer(b)
 739         buf.EncodeInt32(m.Retval)
 740         return buf.Bytes(), nil
 741 }
 742 func (m *WireguardPeerRemoveReply) Unmarshal(b []byte) error {
 743         buf := codec.NewBuffer(b)
 744         m.Retval = buf.DecodeInt32()
 745         return nil
 746 }
 747
 748 // WireguardPeersDetails defines message 'wireguard_peers_details'.
 749 // InProgress: the message form may change in the future versions
 750 type WireguardPeersDetails struct {
 751         Peer WireguardPeer `binapi:"wireguard_peer,name=peer" json:"peer,omitempty"`
 752 }
 753
 754 func (m *WireguardPeersDetails) Reset()               { *m = WireguardPeersDetails{} }
 755 func (*WireguardPeersDetails) GetMessageName() string { return "wireguard_peers_details" }
 756 func (*WireguardPeersDetails) GetCrcString() string   { return "29269d0e" }
 757 func (*WireguardPeersDetails) GetMessageType() api.MessageType {
 758         return api.ReplyMessage
 759 }
 760
 761 func (m *WireguardPeersDetails) Size() (size int) {
 762         if m == nil {
 763                 return 0
 764         }
 765         size += 1 * 32 // m.Peer.PublicKey
 766         size += 2      // m.Peer.Port
 767         size += 2      // m.Peer.PersistentKeepalive
 768         size += 4      // m.Peer.TableID
 769         size += 1      // m.Peer.Endpoint.Af
 770         size += 1 * 16 // m.Peer.Endpoint.Un
 771         size += 4      // m.Peer.SwIfIndex
 772         size += 1      // m.Peer.Flags
 773         size += 1      // m.Peer.NAllowedIps
 774         for j2 := 0; j2 < len(m.Peer.AllowedIps); j2++ {
 775                 var s2 ip_types.Prefix
 776                 _ = s2
 777                 if j2 < len(m.Peer.AllowedIps) {
 778                         s2 = m.Peer.AllowedIps[j2]
 779                 }
 780                 size += 1      // s2.Address.Af
 781                 size += 1 * 16 // s2.Address.Un
 782                 size += 1      // s2.Len
 783         }
 784         return size
 785 }
 786 func (m *WireguardPeersDetails) Marshal(b []byte) ([]byte, error) {
 787         if b == nil {
 788                 b = make([]byte, m.Size())
 789         }
 790         buf := codec.NewBuffer(b)
 791         buf.EncodeBytes(m.Peer.PublicKey, 32)
 792         buf.EncodeUint16(m.Peer.Port)
 793         buf.EncodeUint16(m.Peer.PersistentKeepalive)
 794         buf.EncodeUint32(m.Peer.TableID)
 795         buf.EncodeUint8(uint8(m.Peer.Endpoint.Af))
 796         buf.EncodeBytes(m.Peer.Endpoint.Un.XXX_UnionData[:], 16)
 797         buf.EncodeUint32(uint32(m.Peer.SwIfIndex))
 798         buf.EncodeUint8(uint8(m.Peer.Flags))
 799         buf.EncodeUint8(uint8(len(m.Peer.AllowedIps)))
 800         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 801                 var v1 ip_types.Prefix // AllowedIps
 802                 if j1 < len(m.Peer.AllowedIps) {
 803                         v1 = m.Peer.AllowedIps[j1]
 804                 }
 805                 buf.EncodeUint8(uint8(v1.Address.Af))
 806                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
 807                 buf.EncodeUint8(v1.Len)
 808         }
 809         return buf.Bytes(), nil
 810 }
 811 func (m *WireguardPeersDetails) Unmarshal(b []byte) error {
 812         buf := codec.NewBuffer(b)
 813         m.Peer.PublicKey = make([]byte, 32)
 814         copy(m.Peer.PublicKey, buf.DecodeBytes(len(m.Peer.PublicKey)))
 815         m.Peer.Port = buf.DecodeUint16()
 816         m.Peer.PersistentKeepalive = buf.DecodeUint16()
 817         m.Peer.TableID = buf.DecodeUint32()
 818         m.Peer.Endpoint.Af = ip_types.AddressFamily(buf.DecodeUint8())
 819         copy(m.Peer.Endpoint.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 820         m.Peer.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 821         m.Peer.Flags = WireguardPeerFlags(buf.DecodeUint8())
 822         m.Peer.NAllowedIps = buf.DecodeUint8()
 823         m.Peer.AllowedIps = make([]ip_types.Prefix, m.Peer.NAllowedIps)
 824         for j1 := 0; j1 < len(m.Peer.AllowedIps); j1++ {
 825                 m.Peer.AllowedIps[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
 826                 copy(m.Peer.AllowedIps[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 827                 m.Peer.AllowedIps[j1].Len = buf.DecodeUint8()
 828         }
 829         return nil
 830 }
 831
 832 // WireguardPeersDump defines message 'wireguard_peers_dump'.
 833 // InProgress: the message form may change in the future versions
 834 type WireguardPeersDump struct {
 835         PeerIndex uint32 `binapi:"u32,name=peer_index,default=4294967295" json:"peer_index,omitempty"`
 836 }
 837
 838 func (m *WireguardPeersDump) Reset()               { *m = WireguardPeersDump{} }
 839 func (*WireguardPeersDump) GetMessageName() string { return "wireguard_peers_dump" }
 840 func (*WireguardPeersDump) GetCrcString() string   { return "3b74607a" }
 841 func (*WireguardPeersDump) GetMessageType() api.MessageType {
 842         return api.RequestMessage
 843 }
 844
 845 func (m *WireguardPeersDump) Size() (size int) {
 846         if m == nil {
 847                 return 0
 848         }
 849         size += 4 // m.PeerIndex
 850         return size
 851 }
 852 func (m *WireguardPeersDump) Marshal(b []byte) ([]byte, error) {
 853         if b == nil {
 854                 b = make([]byte, m.Size())
 855         }
 856         buf := codec.NewBuffer(b)
 857         buf.EncodeUint32(m.PeerIndex)
 858         return buf.Bytes(), nil
 859 }
 860 func (m *WireguardPeersDump) Unmarshal(b []byte) error {
 861         buf := codec.NewBuffer(b)
 862         m.PeerIndex = buf.DecodeUint32()
 863         return nil
 864 }
 865
 866 func init() { file_wireguard_binapi_init() }
 867 func file_wireguard_binapi_init() {
 868         api.RegisterMessage((*WantWireguardPeerEvents)(nil), "want_wireguard_peer_events_3bc666c8")
 869         api.RegisterMessage((*WantWireguardPeerEventsReply)(nil), "want_wireguard_peer_events_reply_e8d4e804")
 870         api.RegisterMessage((*WgSetAsyncMode)(nil), "wg_set_async_mode_a6465f7c")
 871         api.RegisterMessage((*WgSetAsyncModeReply)(nil), "wg_set_async_mode_reply_e8d4e804")
 872         api.RegisterMessage((*WireguardInterfaceCreate)(nil), "wireguard_interface_create_a530137e")
 873         api.RegisterMessage((*WireguardInterfaceCreateReply)(nil), "wireguard_interface_create_reply_5383d31f")
 874         api.RegisterMessage((*WireguardInterfaceDelete)(nil), "wireguard_interface_delete_f9e6675e")
 875         api.RegisterMessage((*WireguardInterfaceDeleteReply)(nil), "wireguard_interface_delete_reply_e8d4e804")
 876         api.RegisterMessage((*WireguardInterfaceDetails)(nil), "wireguard_interface_details_0dd4865d")
 877         api.RegisterMessage((*WireguardInterfaceDump)(nil), "wireguard_interface_dump_2c954158")
 878         api.RegisterMessage((*WireguardPeerAdd)(nil), "wireguard_peer_add_aedf8d59")
 879         api.RegisterMessage((*WireguardPeerAddReply)(nil), "wireguard_peer_add_reply_084a0cd3")
 880         api.RegisterMessage((*WireguardPeerEvent)(nil), "wireguard_peer_event_4e1b5d67")
 881         api.RegisterMessage((*WireguardPeerRemove)(nil), "wireguard_peer_remove_3b74607a")
 882         api.RegisterMessage((*WireguardPeerRemoveReply)(nil), "wireguard_peer_remove_reply_e8d4e804")
 883         api.RegisterMessage((*WireguardPeersDetails)(nil), "wireguard_peers_details_29269d0e")
 884         api.RegisterMessage((*WireguardPeersDump)(nil), "wireguard_peers_dump_3b74607a")
 885 }
 886
 887 // Messages returns list of all messages in this module.
 888 func AllMessages() []api.Message {
 889         return []api.Message{
 890                 (*WantWireguardPeerEvents)(nil),
 891                 (*WantWireguardPeerEventsReply)(nil),
 892                 (*WgSetAsyncMode)(nil),
 893                 (*WgSetAsyncModeReply)(nil),
 894                 (*WireguardInterfaceCreate)(nil),
 895                 (*WireguardInterfaceCreateReply)(nil),
 896                 (*WireguardInterfaceDelete)(nil),
 897                 (*WireguardInterfaceDeleteReply)(nil),
 898                 (*WireguardInterfaceDetails)(nil),
 899                 (*WireguardInterfaceDump)(nil),
 900                 (*WireguardPeerAdd)(nil),
 901                 (*WireguardPeerAddReply)(nil),
 902                 (*WireguardPeerEvent)(nil),
 903                 (*WireguardPeerRemove)(nil),
 904                 (*WireguardPeerRemoveReply)(nil),
 905                 (*WireguardPeersDetails)(nil),
 906                 (*WireguardPeersDump)(nil),
 907         }
 908 }