binapi/dhcp/dhcp.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/dhcp.api.json
   6
   7 // Package dhcp contains generated bindings for API file dhcp.api.
   8 //
   9 // Contents:
  10 //   3 enums
  11 //   6 structs
  12 //  29 messages
  13 //
  14 package dhcp
  15
  16 import (
  17         api "git.fd.io/govpp.git/api"
  18         ethernet_types "git.fd.io/govpp.git/binapi/ethernet_types"
  19         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  20         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  21         codec "git.fd.io/govpp.git/codec"
  22         "strconv"
  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    = "dhcp"
  33         APIVersion = "3.0.1"
  34         VersionCrc = 0x96274cae
  35 )
  36
  37 // DHCPClientState defines enum 'dhcp_client_state'.
  38 type DHCPClientState uint32
  39
  40 const (
  41         DHCP_CLIENT_STATE_API_DISCOVER DHCPClientState = 1
  42         DHCP_CLIENT_STATE_API_REQUEST  DHCPClientState = 2
  43         DHCP_CLIENT_STATE_API_BOUND    DHCPClientState = 3
  44 )
  45
  46 var (
  47         DHCPClientState_name = map[uint32]string{
  48                 1: "DHCP_CLIENT_STATE_API_DISCOVER",
  49                 2: "DHCP_CLIENT_STATE_API_REQUEST",
  50                 3: "DHCP_CLIENT_STATE_API_BOUND",
  51         }
  52         DHCPClientState_value = map[string]uint32{
  53                 "DHCP_CLIENT_STATE_API_DISCOVER": 1,
  54                 "DHCP_CLIENT_STATE_API_REQUEST":  2,
  55                 "DHCP_CLIENT_STATE_API_BOUND":    3,
  56         }
  57 )
  58
  59 func (x DHCPClientState) String() string {
  60         s, ok := DHCPClientState_name[uint32(x)]
  61         if ok {
  62                 return s
  63         }
  64         return "DHCPClientState(" + strconv.Itoa(int(x)) + ")"
  65 }
  66
  67 // Dhcpv6MsgType defines enum 'dhcpv6_msg_type'.
  68 type Dhcpv6MsgType uint32
  69
  70 const (
  71         DHCPV6_MSG_API_SOLICIT             Dhcpv6MsgType = 1
  72         DHCPV6_MSG_API_ADVERTISE           Dhcpv6MsgType = 2
  73         DHCPV6_MSG_API_REQUEST             Dhcpv6MsgType = 3
  74         DHCPV6_MSG_API_CONFIRM             Dhcpv6MsgType = 4
  75         DHCPV6_MSG_API_RENEW               Dhcpv6MsgType = 5
  76         DHCPV6_MSG_API_REBIND              Dhcpv6MsgType = 6
  77         DHCPV6_MSG_API_REPLY               Dhcpv6MsgType = 7
  78         DHCPV6_MSG_API_RELEASE             Dhcpv6MsgType = 8
  79         DHCPV6_MSG_API_DECLINE             Dhcpv6MsgType = 9
  80         DHCPV6_MSG_API_RECONFIGURE         Dhcpv6MsgType = 10
  81         DHCPV6_MSG_API_INFORMATION_REQUEST Dhcpv6MsgType = 11
  82         DHCPV6_MSG_API_RELAY_FORW          Dhcpv6MsgType = 12
  83         DHCPV6_MSG_API_RELAY_REPL          Dhcpv6MsgType = 13
  84 )
  85
  86 var (
  87         Dhcpv6MsgType_name = map[uint32]string{
  88                 1:  "DHCPV6_MSG_API_SOLICIT",
  89                 2:  "DHCPV6_MSG_API_ADVERTISE",
  90                 3:  "DHCPV6_MSG_API_REQUEST",
  91                 4:  "DHCPV6_MSG_API_CONFIRM",
  92                 5:  "DHCPV6_MSG_API_RENEW",
  93                 6:  "DHCPV6_MSG_API_REBIND",
  94                 7:  "DHCPV6_MSG_API_REPLY",
  95                 8:  "DHCPV6_MSG_API_RELEASE",
  96                 9:  "DHCPV6_MSG_API_DECLINE",
  97                 10: "DHCPV6_MSG_API_RECONFIGURE",
  98                 11: "DHCPV6_MSG_API_INFORMATION_REQUEST",
  99                 12: "DHCPV6_MSG_API_RELAY_FORW",
 100                 13: "DHCPV6_MSG_API_RELAY_REPL",
 101         }
 102         Dhcpv6MsgType_value = map[string]uint32{
 103                 "DHCPV6_MSG_API_SOLICIT":             1,
 104                 "DHCPV6_MSG_API_ADVERTISE":           2,
 105                 "DHCPV6_MSG_API_REQUEST":             3,
 106                 "DHCPV6_MSG_API_CONFIRM":             4,
 107                 "DHCPV6_MSG_API_RENEW":               5,
 108                 "DHCPV6_MSG_API_REBIND":              6,
 109                 "DHCPV6_MSG_API_REPLY":               7,
 110                 "DHCPV6_MSG_API_RELEASE":             8,
 111                 "DHCPV6_MSG_API_DECLINE":             9,
 112                 "DHCPV6_MSG_API_RECONFIGURE":         10,
 113                 "DHCPV6_MSG_API_INFORMATION_REQUEST": 11,
 114                 "DHCPV6_MSG_API_RELAY_FORW":          12,
 115                 "DHCPV6_MSG_API_RELAY_REPL":          13,
 116         }
 117 )
 118
 119 func (x Dhcpv6MsgType) String() string {
 120         s, ok := Dhcpv6MsgType_name[uint32(x)]
 121         if ok {
 122                 return s
 123         }
 124         return "Dhcpv6MsgType(" + strconv.Itoa(int(x)) + ")"
 125 }
 126
 127 // VssType defines enum 'vss_type'.
 128 type VssType uint32
 129
 130 const (
 131         VSS_TYPE_API_ASCII   VssType = 0
 132         VSS_TYPE_API_VPN_ID  VssType = 1
 133         VSS_TYPE_API_INVALID VssType = 123
 134         VSS_TYPE_API_DEFAULT VssType = 255
 135 )
 136
 137 var (
 138         VssType_name = map[uint32]string{
 139                 0:   "VSS_TYPE_API_ASCII",
 140                 1:   "VSS_TYPE_API_VPN_ID",
 141                 123: "VSS_TYPE_API_INVALID",
 142                 255: "VSS_TYPE_API_DEFAULT",
 143         }
 144         VssType_value = map[string]uint32{
 145                 "VSS_TYPE_API_ASCII":   0,
 146                 "VSS_TYPE_API_VPN_ID":  1,
 147                 "VSS_TYPE_API_INVALID": 123,
 148                 "VSS_TYPE_API_DEFAULT": 255,
 149         }
 150 )
 151
 152 func (x VssType) String() string {
 153         s, ok := VssType_name[uint32(x)]
 154         if ok {
 155                 return s
 156         }
 157         return "VssType(" + strconv.Itoa(int(x)) + ")"
 158 }
 159
 160 // DHCP6AddressInfo defines type 'dhcp6_address_info'.
 161 type DHCP6AddressInfo struct {
 162         Address       ip_types.IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 163         ValidTime     uint32              `binapi:"u32,name=valid_time" json:"valid_time,omitempty"`
 164         PreferredTime uint32              `binapi:"u32,name=preferred_time" json:"preferred_time,omitempty"`
 165 }
 166
 167 // DHCP6PdPrefixInfo defines type 'dhcp6_pd_prefix_info'.
 168 type DHCP6PdPrefixInfo struct {
 169         Prefix        ip_types.IP6Prefix `binapi:"ip6_prefix,name=prefix" json:"prefix,omitempty"`
 170         ValidTime     uint32             `binapi:"u32,name=valid_time" json:"valid_time,omitempty"`
 171         PreferredTime uint32             `binapi:"u32,name=preferred_time" json:"preferred_time,omitempty"`
 172 }
 173
 174 // DHCPClient defines type 'dhcp_client'.
 175 type DHCPClient struct {
 176         SwIfIndex        interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 177         Hostname         string                         `binapi:"string[64],name=hostname" json:"hostname,omitempty"`
 178         ID               []byte                         `binapi:"u8[64],name=id" json:"id,omitempty"`
 179         WantDHCPEvent    bool                           `binapi:"bool,name=want_dhcp_event" json:"want_dhcp_event,omitempty"`
 180         SetBroadcastFlag bool                           `binapi:"bool,name=set_broadcast_flag" json:"set_broadcast_flag,omitempty"`
 181         Dscp             ip_types.IPDscp                `binapi:"ip_dscp,name=dscp" json:"dscp,omitempty"`
 182         PID              uint32                         `binapi:"u32,name=pid" json:"pid,omitempty"`
 183 }
 184
 185 // DHCPLease defines type 'dhcp_lease'.
 186 type DHCPLease struct {
 187         SwIfIndex     interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 188         State         DHCPClientState                `binapi:"dhcp_client_state,name=state" json:"state,omitempty"`
 189         IsIPv6        bool                           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
 190         Hostname      string                         `binapi:"string[64],name=hostname" json:"hostname,omitempty"`
 191         MaskWidth     uint8                          `binapi:"u8,name=mask_width" json:"mask_width,omitempty"`
 192         HostAddress   ip_types.Address               `binapi:"address,name=host_address" json:"host_address,omitempty"`
 193         RouterAddress ip_types.Address               `binapi:"address,name=router_address" json:"router_address,omitempty"`
 194         HostMac       ethernet_types.MacAddress      `binapi:"mac_address,name=host_mac" json:"host_mac,omitempty"`
 195         Count         uint8                          `binapi:"u8,name=count" json:"-"`
 196         DomainServer  []DomainServer                 `binapi:"domain_server[count],name=domain_server" json:"domain_server,omitempty"`
 197 }
 198
 199 // DHCPServer defines type 'dhcp_server'.
 200 type DHCPServer struct {
 201         ServerVrfID uint32           `binapi:"u32,name=server_vrf_id" json:"server_vrf_id,omitempty"`
 202         DHCPServer  ip_types.Address `binapi:"address,name=dhcp_server" json:"dhcp_server,omitempty"`
 203 }
 204
 205 // DomainServer defines type 'domain_server'.
 206 type DomainServer struct {
 207         Address ip_types.Address `binapi:"address,name=address" json:"address,omitempty"`
 208 }
 209
 210 // DHCP6ClientsEnableDisable defines message 'dhcp6_clients_enable_disable'.
 211 type DHCP6ClientsEnableDisable struct {
 212         Enable bool `binapi:"bool,name=enable" json:"enable,omitempty"`
 213 }
 214
 215 func (m *DHCP6ClientsEnableDisable) Reset()               { *m = DHCP6ClientsEnableDisable{} }
 216 func (*DHCP6ClientsEnableDisable) GetMessageName() string { return "dhcp6_clients_enable_disable" }
 217 func (*DHCP6ClientsEnableDisable) GetCrcString() string   { return "b3e225d2" }
 218 func (*DHCP6ClientsEnableDisable) GetMessageType() api.MessageType {
 219         return api.RequestMessage
 220 }
 221
 222 func (m *DHCP6ClientsEnableDisable) Size() int {
 223         if m == nil {
 224                 return 0
 225         }
 226         var size int
 227         size += 1 // m.Enable
 228         return size
 229 }
 230 func (m *DHCP6ClientsEnableDisable) Marshal(b []byte) ([]byte, error) {
 231         var buf *codec.Buffer
 232         if b == nil {
 233                 buf = codec.NewBuffer(make([]byte, m.Size()))
 234         } else {
 235                 buf = codec.NewBuffer(b)
 236         }
 237         buf.EncodeBool(m.Enable)
 238         return buf.Bytes(), nil
 239 }
 240 func (m *DHCP6ClientsEnableDisable) Unmarshal(b []byte) error {
 241         buf := codec.NewBuffer(b)
 242         m.Enable = buf.DecodeBool()
 243         return nil
 244 }
 245
 246 // DHCP6ClientsEnableDisableReply defines message 'dhcp6_clients_enable_disable_reply'.
 247 type DHCP6ClientsEnableDisableReply struct {
 248         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 249 }
 250
 251 func (m *DHCP6ClientsEnableDisableReply) Reset() { *m = DHCP6ClientsEnableDisableReply{} }
 252 func (*DHCP6ClientsEnableDisableReply) GetMessageName() string {
 253         return "dhcp6_clients_enable_disable_reply"
 254 }
 255 func (*DHCP6ClientsEnableDisableReply) GetCrcString() string { return "e8d4e804" }
 256 func (*DHCP6ClientsEnableDisableReply) GetMessageType() api.MessageType {
 257         return api.ReplyMessage
 258 }
 259
 260 func (m *DHCP6ClientsEnableDisableReply) Size() int {
 261         if m == nil {
 262                 return 0
 263         }
 264         var size int
 265         size += 4 // m.Retval
 266         return size
 267 }
 268 func (m *DHCP6ClientsEnableDisableReply) Marshal(b []byte) ([]byte, error) {
 269         var buf *codec.Buffer
 270         if b == nil {
 271                 buf = codec.NewBuffer(make([]byte, m.Size()))
 272         } else {
 273                 buf = codec.NewBuffer(b)
 274         }
 275         buf.EncodeUint32(uint32(m.Retval))
 276         return buf.Bytes(), nil
 277 }
 278 func (m *DHCP6ClientsEnableDisableReply) Unmarshal(b []byte) error {
 279         buf := codec.NewBuffer(b)
 280         m.Retval = int32(buf.DecodeUint32())
 281         return nil
 282 }
 283
 284 // DHCP6DuidLlSet defines message 'dhcp6_duid_ll_set'.
 285 type DHCP6DuidLlSet struct {
 286         DuidLl []byte `binapi:"u8[10],name=duid_ll" json:"duid_ll,omitempty"`
 287 }
 288
 289 func (m *DHCP6DuidLlSet) Reset()               { *m = DHCP6DuidLlSet{} }
 290 func (*DHCP6DuidLlSet) GetMessageName() string { return "dhcp6_duid_ll_set" }
 291 func (*DHCP6DuidLlSet) GetCrcString() string   { return "0f6ca323" }
 292 func (*DHCP6DuidLlSet) GetMessageType() api.MessageType {
 293         return api.RequestMessage
 294 }
 295
 296 func (m *DHCP6DuidLlSet) Size() int {
 297         if m == nil {
 298                 return 0
 299         }
 300         var size int
 301         size += 1 * 10 // m.DuidLl
 302         return size
 303 }
 304 func (m *DHCP6DuidLlSet) Marshal(b []byte) ([]byte, error) {
 305         var buf *codec.Buffer
 306         if b == nil {
 307                 buf = codec.NewBuffer(make([]byte, m.Size()))
 308         } else {
 309                 buf = codec.NewBuffer(b)
 310         }
 311         buf.EncodeBytes(m.DuidLl[:], 10)
 312         return buf.Bytes(), nil
 313 }
 314 func (m *DHCP6DuidLlSet) Unmarshal(b []byte) error {
 315         buf := codec.NewBuffer(b)
 316         copy(m.DuidLl[:], buf.DecodeBytes(10))
 317         return nil
 318 }
 319
 320 // DHCP6DuidLlSetReply defines message 'dhcp6_duid_ll_set_reply'.
 321 type DHCP6DuidLlSetReply struct {
 322         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 323 }
 324
 325 func (m *DHCP6DuidLlSetReply) Reset()               { *m = DHCP6DuidLlSetReply{} }
 326 func (*DHCP6DuidLlSetReply) GetMessageName() string { return "dhcp6_duid_ll_set_reply" }
 327 func (*DHCP6DuidLlSetReply) GetCrcString() string   { return "e8d4e804" }
 328 func (*DHCP6DuidLlSetReply) GetMessageType() api.MessageType {
 329         return api.ReplyMessage
 330 }
 331
 332 func (m *DHCP6DuidLlSetReply) Size() int {
 333         if m == nil {
 334                 return 0
 335         }
 336         var size int
 337         size += 4 // m.Retval
 338         return size
 339 }
 340 func (m *DHCP6DuidLlSetReply) Marshal(b []byte) ([]byte, error) {
 341         var buf *codec.Buffer
 342         if b == nil {
 343                 buf = codec.NewBuffer(make([]byte, m.Size()))
 344         } else {
 345                 buf = codec.NewBuffer(b)
 346         }
 347         buf.EncodeUint32(uint32(m.Retval))
 348         return buf.Bytes(), nil
 349 }
 350 func (m *DHCP6DuidLlSetReply) Unmarshal(b []byte) error {
 351         buf := codec.NewBuffer(b)
 352         m.Retval = int32(buf.DecodeUint32())
 353         return nil
 354 }
 355
 356 // DHCP6PdReplyEvent defines message 'dhcp6_pd_reply_event'.
 357 type DHCP6PdReplyEvent struct {
 358         PID             uint32                         `binapi:"u32,name=pid" json:"pid,omitempty"`
 359         SwIfIndex       interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 360         ServerIndex     uint32                         `binapi:"u32,name=server_index" json:"server_index,omitempty"`
 361         MsgType         Dhcpv6MsgType                  `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
 362         T1              uint32                         `binapi:"u32,name=T1" json:"T1,omitempty"`
 363         T2              uint32                         `binapi:"u32,name=T2" json:"T2,omitempty"`
 364         InnerStatusCode uint16                         `binapi:"u16,name=inner_status_code" json:"inner_status_code,omitempty"`
 365         StatusCode      uint16                         `binapi:"u16,name=status_code" json:"status_code,omitempty"`
 366         Preference      uint8                          `binapi:"u8,name=preference" json:"preference,omitempty"`
 367         NPrefixes       uint32                         `binapi:"u32,name=n_prefixes" json:"-"`
 368         Prefixes        []DHCP6PdPrefixInfo            `binapi:"dhcp6_pd_prefix_info[n_prefixes],name=prefixes" json:"prefixes,omitempty"`
 369 }
 370
 371 func (m *DHCP6PdReplyEvent) Reset()               { *m = DHCP6PdReplyEvent{} }
 372 func (*DHCP6PdReplyEvent) GetMessageName() string { return "dhcp6_pd_reply_event" }
 373 func (*DHCP6PdReplyEvent) GetCrcString() string   { return "cb3e462b" }
 374 func (*DHCP6PdReplyEvent) GetMessageType() api.MessageType {
 375         return api.EventMessage
 376 }
 377
 378 func (m *DHCP6PdReplyEvent) Size() int {
 379         if m == nil {
 380                 return 0
 381         }
 382         var size int
 383         size += 4 // m.PID
 384         size += 4 // m.SwIfIndex
 385         size += 4 // m.ServerIndex
 386         size += 4 // m.MsgType
 387         size += 4 // m.T1
 388         size += 4 // m.T2
 389         size += 2 // m.InnerStatusCode
 390         size += 2 // m.StatusCode
 391         size += 1 // m.Preference
 392         size += 4 // m.NPrefixes
 393         for j1 := 0; j1 < len(m.Prefixes); j1++ {
 394                 var s1 DHCP6PdPrefixInfo
 395                 _ = s1
 396                 if j1 < len(m.Prefixes) {
 397                         s1 = m.Prefixes[j1]
 398                 }
 399                 size += 1 * 16 // s1.Prefix.Address
 400                 size += 1      // s1.Prefix.Len
 401                 size += 4      // s1.ValidTime
 402                 size += 4      // s1.PreferredTime
 403         }
 404         return size
 405 }
 406 func (m *DHCP6PdReplyEvent) Marshal(b []byte) ([]byte, error) {
 407         var buf *codec.Buffer
 408         if b == nil {
 409                 buf = codec.NewBuffer(make([]byte, m.Size()))
 410         } else {
 411                 buf = codec.NewBuffer(b)
 412         }
 413         buf.EncodeUint32(uint32(m.PID))
 414         buf.EncodeUint32(uint32(m.SwIfIndex))
 415         buf.EncodeUint32(uint32(m.ServerIndex))
 416         buf.EncodeUint32(uint32(m.MsgType))
 417         buf.EncodeUint32(uint32(m.T1))
 418         buf.EncodeUint32(uint32(m.T2))
 419         buf.EncodeUint16(uint16(m.InnerStatusCode))
 420         buf.EncodeUint16(uint16(m.StatusCode))
 421         buf.EncodeUint8(uint8(m.Preference))
 422         buf.EncodeUint32(uint32(len(m.Prefixes)))
 423         for j0 := 0; j0 < len(m.Prefixes); j0++ {
 424                 var v0 DHCP6PdPrefixInfo
 425                 if j0 < len(m.Prefixes) {
 426                         v0 = m.Prefixes[j0]
 427                 }
 428                 buf.EncodeBytes(v0.Prefix.Address[:], 16)
 429                 buf.EncodeUint8(uint8(v0.Prefix.Len))
 430                 buf.EncodeUint32(uint32(v0.ValidTime))
 431                 buf.EncodeUint32(uint32(v0.PreferredTime))
 432         }
 433         return buf.Bytes(), nil
 434 }
 435 func (m *DHCP6PdReplyEvent) Unmarshal(b []byte) error {
 436         buf := codec.NewBuffer(b)
 437         m.PID = buf.DecodeUint32()
 438         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 439         m.ServerIndex = buf.DecodeUint32()
 440         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
 441         m.T1 = buf.DecodeUint32()
 442         m.T2 = buf.DecodeUint32()
 443         m.InnerStatusCode = buf.DecodeUint16()
 444         m.StatusCode = buf.DecodeUint16()
 445         m.Preference = buf.DecodeUint8()
 446         m.NPrefixes = buf.DecodeUint32()
 447         m.Prefixes = make([]DHCP6PdPrefixInfo, int(m.NPrefixes))
 448         for j0 := 0; j0 < len(m.Prefixes); j0++ {
 449                 copy(m.Prefixes[j0].Prefix.Address[:], buf.DecodeBytes(16))
 450                 m.Prefixes[j0].Prefix.Len = buf.DecodeUint8()
 451                 m.Prefixes[j0].ValidTime = buf.DecodeUint32()
 452                 m.Prefixes[j0].PreferredTime = buf.DecodeUint32()
 453         }
 454         return nil
 455 }
 456
 457 // DHCP6PdSendClientMessage defines message 'dhcp6_pd_send_client_message'.
 458 type DHCP6PdSendClientMessage struct {
 459         SwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 460         ServerIndex uint32                         `binapi:"u32,name=server_index" json:"server_index,omitempty"`
 461         Irt         uint32                         `binapi:"u32,name=irt" json:"irt,omitempty"`
 462         Mrt         uint32                         `binapi:"u32,name=mrt" json:"mrt,omitempty"`
 463         Mrc         uint32                         `binapi:"u32,name=mrc" json:"mrc,omitempty"`
 464         Mrd         uint32                         `binapi:"u32,name=mrd" json:"mrd,omitempty"`
 465         Stop        bool                           `binapi:"bool,name=stop" json:"stop,omitempty"`
 466         MsgType     Dhcpv6MsgType                  `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
 467         T1          uint32                         `binapi:"u32,name=T1" json:"T1,omitempty"`
 468         T2          uint32                         `binapi:"u32,name=T2" json:"T2,omitempty"`
 469         NPrefixes   uint32                         `binapi:"u32,name=n_prefixes" json:"-"`
 470         Prefixes    []DHCP6PdPrefixInfo            `binapi:"dhcp6_pd_prefix_info[n_prefixes],name=prefixes" json:"prefixes,omitempty"`
 471 }
 472
 473 func (m *DHCP6PdSendClientMessage) Reset()               { *m = DHCP6PdSendClientMessage{} }
 474 func (*DHCP6PdSendClientMessage) GetMessageName() string { return "dhcp6_pd_send_client_message" }
 475 func (*DHCP6PdSendClientMessage) GetCrcString() string   { return "064badb8" }
 476 func (*DHCP6PdSendClientMessage) GetMessageType() api.MessageType {
 477         return api.RequestMessage
 478 }
 479
 480 func (m *DHCP6PdSendClientMessage) Size() int {
 481         if m == nil {
 482                 return 0
 483         }
 484         var size int
 485         size += 4 // m.SwIfIndex
 486         size += 4 // m.ServerIndex
 487         size += 4 // m.Irt
 488         size += 4 // m.Mrt
 489         size += 4 // m.Mrc
 490         size += 4 // m.Mrd
 491         size += 1 // m.Stop
 492         size += 4 // m.MsgType
 493         size += 4 // m.T1
 494         size += 4 // m.T2
 495         size += 4 // m.NPrefixes
 496         for j1 := 0; j1 < len(m.Prefixes); j1++ {
 497                 var s1 DHCP6PdPrefixInfo
 498                 _ = s1
 499                 if j1 < len(m.Prefixes) {
 500                         s1 = m.Prefixes[j1]
 501                 }
 502                 size += 1 * 16 // s1.Prefix.Address
 503                 size += 1      // s1.Prefix.Len
 504                 size += 4      // s1.ValidTime
 505                 size += 4      // s1.PreferredTime
 506         }
 507         return size
 508 }
 509 func (m *DHCP6PdSendClientMessage) Marshal(b []byte) ([]byte, error) {
 510         var buf *codec.Buffer
 511         if b == nil {
 512                 buf = codec.NewBuffer(make([]byte, m.Size()))
 513         } else {
 514                 buf = codec.NewBuffer(b)
 515         }
 516         buf.EncodeUint32(uint32(m.SwIfIndex))
 517         buf.EncodeUint32(uint32(m.ServerIndex))
 518         buf.EncodeUint32(uint32(m.Irt))
 519         buf.EncodeUint32(uint32(m.Mrt))
 520         buf.EncodeUint32(uint32(m.Mrc))
 521         buf.EncodeUint32(uint32(m.Mrd))
 522         buf.EncodeBool(m.Stop)
 523         buf.EncodeUint32(uint32(m.MsgType))
 524         buf.EncodeUint32(uint32(m.T1))
 525         buf.EncodeUint32(uint32(m.T2))
 526         buf.EncodeUint32(uint32(len(m.Prefixes)))
 527         for j0 := 0; j0 < len(m.Prefixes); j0++ {
 528                 var v0 DHCP6PdPrefixInfo
 529                 if j0 < len(m.Prefixes) {
 530                         v0 = m.Prefixes[j0]
 531                 }
 532                 buf.EncodeBytes(v0.Prefix.Address[:], 16)
 533                 buf.EncodeUint8(uint8(v0.Prefix.Len))
 534                 buf.EncodeUint32(uint32(v0.ValidTime))
 535                 buf.EncodeUint32(uint32(v0.PreferredTime))
 536         }
 537         return buf.Bytes(), nil
 538 }
 539 func (m *DHCP6PdSendClientMessage) Unmarshal(b []byte) error {
 540         buf := codec.NewBuffer(b)
 541         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 542         m.ServerIndex = buf.DecodeUint32()
 543         m.Irt = buf.DecodeUint32()
 544         m.Mrt = buf.DecodeUint32()
 545         m.Mrc = buf.DecodeUint32()
 546         m.Mrd = buf.DecodeUint32()
 547         m.Stop = buf.DecodeBool()
 548         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
 549         m.T1 = buf.DecodeUint32()
 550         m.T2 = buf.DecodeUint32()
 551         m.NPrefixes = buf.DecodeUint32()
 552         m.Prefixes = make([]DHCP6PdPrefixInfo, int(m.NPrefixes))
 553         for j0 := 0; j0 < len(m.Prefixes); j0++ {
 554                 copy(m.Prefixes[j0].Prefix.Address[:], buf.DecodeBytes(16))
 555                 m.Prefixes[j0].Prefix.Len = buf.DecodeUint8()
 556                 m.Prefixes[j0].ValidTime = buf.DecodeUint32()
 557                 m.Prefixes[j0].PreferredTime = buf.DecodeUint32()
 558         }
 559         return nil
 560 }
 561
 562 // DHCP6PdSendClientMessageReply defines message 'dhcp6_pd_send_client_message_reply'.
 563 type DHCP6PdSendClientMessageReply struct {
 564         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 565 }
 566
 567 func (m *DHCP6PdSendClientMessageReply) Reset() { *m = DHCP6PdSendClientMessageReply{} }
 568 func (*DHCP6PdSendClientMessageReply) GetMessageName() string {
 569         return "dhcp6_pd_send_client_message_reply"
 570 }
 571 func (*DHCP6PdSendClientMessageReply) GetCrcString() string { return "e8d4e804" }
 572 func (*DHCP6PdSendClientMessageReply) GetMessageType() api.MessageType {
 573         return api.ReplyMessage
 574 }
 575
 576 func (m *DHCP6PdSendClientMessageReply) Size() int {
 577         if m == nil {
 578                 return 0
 579         }
 580         var size int
 581         size += 4 // m.Retval
 582         return size
 583 }
 584 func (m *DHCP6PdSendClientMessageReply) Marshal(b []byte) ([]byte, error) {
 585         var buf *codec.Buffer
 586         if b == nil {
 587                 buf = codec.NewBuffer(make([]byte, m.Size()))
 588         } else {
 589                 buf = codec.NewBuffer(b)
 590         }
 591         buf.EncodeUint32(uint32(m.Retval))
 592         return buf.Bytes(), nil
 593 }
 594 func (m *DHCP6PdSendClientMessageReply) Unmarshal(b []byte) error {
 595         buf := codec.NewBuffer(b)
 596         m.Retval = int32(buf.DecodeUint32())
 597         return nil
 598 }
 599
 600 // DHCP6ReplyEvent defines message 'dhcp6_reply_event'.
 601 type DHCP6ReplyEvent struct {
 602         PID             uint32                         `binapi:"u32,name=pid" json:"pid,omitempty"`
 603         SwIfIndex       interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 604         ServerIndex     uint32                         `binapi:"u32,name=server_index" json:"server_index,omitempty"`
 605         MsgType         Dhcpv6MsgType                  `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
 606         T1              uint32                         `binapi:"u32,name=T1" json:"T1,omitempty"`
 607         T2              uint32                         `binapi:"u32,name=T2" json:"T2,omitempty"`
 608         InnerStatusCode uint16                         `binapi:"u16,name=inner_status_code" json:"inner_status_code,omitempty"`
 609         StatusCode      uint16                         `binapi:"u16,name=status_code" json:"status_code,omitempty"`
 610         Preference      uint8                          `binapi:"u8,name=preference" json:"preference,omitempty"`
 611         NAddresses      uint32                         `binapi:"u32,name=n_addresses" json:"-"`
 612         Addresses       []DHCP6AddressInfo             `binapi:"dhcp6_address_info[n_addresses],name=addresses" json:"addresses,omitempty"`
 613 }
 614
 615 func (m *DHCP6ReplyEvent) Reset()               { *m = DHCP6ReplyEvent{} }
 616 func (*DHCP6ReplyEvent) GetMessageName() string { return "dhcp6_reply_event" }
 617 func (*DHCP6ReplyEvent) GetCrcString() string   { return "9f3af9e5" }
 618 func (*DHCP6ReplyEvent) GetMessageType() api.MessageType {
 619         return api.EventMessage
 620 }
 621
 622 func (m *DHCP6ReplyEvent) Size() int {
 623         if m == nil {
 624                 return 0
 625         }
 626         var size int
 627         size += 4 // m.PID
 628         size += 4 // m.SwIfIndex
 629         size += 4 // m.ServerIndex
 630         size += 4 // m.MsgType
 631         size += 4 // m.T1
 632         size += 4 // m.T2
 633         size += 2 // m.InnerStatusCode
 634         size += 2 // m.StatusCode
 635         size += 1 // m.Preference
 636         size += 4 // m.NAddresses
 637         for j1 := 0; j1 < len(m.Addresses); j1++ {
 638                 var s1 DHCP6AddressInfo
 639                 _ = s1
 640                 if j1 < len(m.Addresses) {
 641                         s1 = m.Addresses[j1]
 642                 }
 643                 size += 1 * 16 // s1.Address
 644                 size += 4      // s1.ValidTime
 645                 size += 4      // s1.PreferredTime
 646         }
 647         return size
 648 }
 649 func (m *DHCP6ReplyEvent) Marshal(b []byte) ([]byte, error) {
 650         var buf *codec.Buffer
 651         if b == nil {
 652                 buf = codec.NewBuffer(make([]byte, m.Size()))
 653         } else {
 654                 buf = codec.NewBuffer(b)
 655         }
 656         buf.EncodeUint32(uint32(m.PID))
 657         buf.EncodeUint32(uint32(m.SwIfIndex))
 658         buf.EncodeUint32(uint32(m.ServerIndex))
 659         buf.EncodeUint32(uint32(m.MsgType))
 660         buf.EncodeUint32(uint32(m.T1))
 661         buf.EncodeUint32(uint32(m.T2))
 662         buf.EncodeUint16(uint16(m.InnerStatusCode))
 663         buf.EncodeUint16(uint16(m.StatusCode))
 664         buf.EncodeUint8(uint8(m.Preference))
 665         buf.EncodeUint32(uint32(len(m.Addresses)))
 666         for j0 := 0; j0 < len(m.Addresses); j0++ {
 667                 var v0 DHCP6AddressInfo
 668                 if j0 < len(m.Addresses) {
 669                         v0 = m.Addresses[j0]
 670                 }
 671                 buf.EncodeBytes(v0.Address[:], 16)
 672                 buf.EncodeUint32(uint32(v0.ValidTime))
 673                 buf.EncodeUint32(uint32(v0.PreferredTime))
 674         }
 675         return buf.Bytes(), nil
 676 }
 677 func (m *DHCP6ReplyEvent) Unmarshal(b []byte) error {
 678         buf := codec.NewBuffer(b)
 679         m.PID = buf.DecodeUint32()
 680         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 681         m.ServerIndex = buf.DecodeUint32()
 682         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
 683         m.T1 = buf.DecodeUint32()
 684         m.T2 = buf.DecodeUint32()
 685         m.InnerStatusCode = buf.DecodeUint16()
 686         m.StatusCode = buf.DecodeUint16()
 687         m.Preference = buf.DecodeUint8()
 688         m.NAddresses = buf.DecodeUint32()
 689         m.Addresses = make([]DHCP6AddressInfo, int(m.NAddresses))
 690         for j0 := 0; j0 < len(m.Addresses); j0++ {
 691                 copy(m.Addresses[j0].Address[:], buf.DecodeBytes(16))
 692                 m.Addresses[j0].ValidTime = buf.DecodeUint32()
 693                 m.Addresses[j0].PreferredTime = buf.DecodeUint32()
 694         }
 695         return nil
 696 }
 697
 698 // DHCP6SendClientMessage defines message 'dhcp6_send_client_message'.
 699 type DHCP6SendClientMessage struct {
 700         SwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 701         ServerIndex uint32                         `binapi:"u32,name=server_index" json:"server_index,omitempty"`
 702         Irt         uint32                         `binapi:"u32,name=irt" json:"irt,omitempty"`
 703         Mrt         uint32                         `binapi:"u32,name=mrt" json:"mrt,omitempty"`
 704         Mrc         uint32                         `binapi:"u32,name=mrc" json:"mrc,omitempty"`
 705         Mrd         uint32                         `binapi:"u32,name=mrd" json:"mrd,omitempty"`
 706         Stop        bool                           `binapi:"bool,name=stop" json:"stop,omitempty"`
 707         MsgType     Dhcpv6MsgType                  `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
 708         T1          uint32                         `binapi:"u32,name=T1" json:"T1,omitempty"`
 709         T2          uint32                         `binapi:"u32,name=T2" json:"T2,omitempty"`
 710         NAddresses  uint32                         `binapi:"u32,name=n_addresses" json:"-"`
 711         Addresses   []DHCP6AddressInfo             `binapi:"dhcp6_address_info[n_addresses],name=addresses" json:"addresses,omitempty"`
 712 }
 713
 714 func (m *DHCP6SendClientMessage) Reset()               { *m = DHCP6SendClientMessage{} }
 715 func (*DHCP6SendClientMessage) GetMessageName() string { return "dhcp6_send_client_message" }
 716 func (*DHCP6SendClientMessage) GetCrcString() string   { return "f6f14ef0" }
 717 func (*DHCP6SendClientMessage) GetMessageType() api.MessageType {
 718         return api.RequestMessage
 719 }
 720
 721 func (m *DHCP6SendClientMessage) Size() int {
 722         if m == nil {
 723                 return 0
 724         }
 725         var size int
 726         size += 4 // m.SwIfIndex
 727         size += 4 // m.ServerIndex
 728         size += 4 // m.Irt
 729         size += 4 // m.Mrt
 730         size += 4 // m.Mrc
 731         size += 4 // m.Mrd
 732         size += 1 // m.Stop
 733         size += 4 // m.MsgType
 734         size += 4 // m.T1
 735         size += 4 // m.T2
 736         size += 4 // m.NAddresses
 737         for j1 := 0; j1 < len(m.Addresses); j1++ {
 738                 var s1 DHCP6AddressInfo
 739                 _ = s1
 740                 if j1 < len(m.Addresses) {
 741                         s1 = m.Addresses[j1]
 742                 }
 743                 size += 1 * 16 // s1.Address
 744                 size += 4      // s1.ValidTime
 745                 size += 4      // s1.PreferredTime
 746         }
 747         return size
 748 }
 749 func (m *DHCP6SendClientMessage) Marshal(b []byte) ([]byte, error) {
 750         var buf *codec.Buffer
 751         if b == nil {
 752                 buf = codec.NewBuffer(make([]byte, m.Size()))
 753         } else {
 754                 buf = codec.NewBuffer(b)
 755         }
 756         buf.EncodeUint32(uint32(m.SwIfIndex))
 757         buf.EncodeUint32(uint32(m.ServerIndex))
 758         buf.EncodeUint32(uint32(m.Irt))
 759         buf.EncodeUint32(uint32(m.Mrt))
 760         buf.EncodeUint32(uint32(m.Mrc))
 761         buf.EncodeUint32(uint32(m.Mrd))
 762         buf.EncodeBool(m.Stop)
 763         buf.EncodeUint32(uint32(m.MsgType))
 764         buf.EncodeUint32(uint32(m.T1))
 765         buf.EncodeUint32(uint32(m.T2))
 766         buf.EncodeUint32(uint32(len(m.Addresses)))
 767         for j0 := 0; j0 < len(m.Addresses); j0++ {
 768                 var v0 DHCP6AddressInfo
 769                 if j0 < len(m.Addresses) {
 770                         v0 = m.Addresses[j0]
 771                 }
 772                 buf.EncodeBytes(v0.Address[:], 16)
 773                 buf.EncodeUint32(uint32(v0.ValidTime))
 774                 buf.EncodeUint32(uint32(v0.PreferredTime))
 775         }
 776         return buf.Bytes(), nil
 777 }
 778 func (m *DHCP6SendClientMessage) Unmarshal(b []byte) error {
 779         buf := codec.NewBuffer(b)
 780         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 781         m.ServerIndex = buf.DecodeUint32()
 782         m.Irt = buf.DecodeUint32()
 783         m.Mrt = buf.DecodeUint32()
 784         m.Mrc = buf.DecodeUint32()
 785         m.Mrd = buf.DecodeUint32()
 786         m.Stop = buf.DecodeBool()
 787         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
 788         m.T1 = buf.DecodeUint32()
 789         m.T2 = buf.DecodeUint32()
 790         m.NAddresses = buf.DecodeUint32()
 791         m.Addresses = make([]DHCP6AddressInfo, int(m.NAddresses))
 792         for j0 := 0; j0 < len(m.Addresses); j0++ {
 793                 copy(m.Addresses[j0].Address[:], buf.DecodeBytes(16))
 794                 m.Addresses[j0].ValidTime = buf.DecodeUint32()
 795                 m.Addresses[j0].PreferredTime = buf.DecodeUint32()
 796         }
 797         return nil
 798 }
 799
 800 // DHCP6SendClientMessageReply defines message 'dhcp6_send_client_message_reply'.
 801 type DHCP6SendClientMessageReply struct {
 802         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 803 }
 804
 805 func (m *DHCP6SendClientMessageReply) Reset()               { *m = DHCP6SendClientMessageReply{} }
 806 func (*DHCP6SendClientMessageReply) GetMessageName() string { return "dhcp6_send_client_message_reply" }
 807 func (*DHCP6SendClientMessageReply) GetCrcString() string   { return "e8d4e804" }
 808 func (*DHCP6SendClientMessageReply) GetMessageType() api.MessageType {
 809         return api.ReplyMessage
 810 }
 811
 812 func (m *DHCP6SendClientMessageReply) Size() int {
 813         if m == nil {
 814                 return 0
 815         }
 816         var size int
 817         size += 4 // m.Retval
 818         return size
 819 }
 820 func (m *DHCP6SendClientMessageReply) Marshal(b []byte) ([]byte, error) {
 821         var buf *codec.Buffer
 822         if b == nil {
 823                 buf = codec.NewBuffer(make([]byte, m.Size()))
 824         } else {
 825                 buf = codec.NewBuffer(b)
 826         }
 827         buf.EncodeUint32(uint32(m.Retval))
 828         return buf.Bytes(), nil
 829 }
 830 func (m *DHCP6SendClientMessageReply) Unmarshal(b []byte) error {
 831         buf := codec.NewBuffer(b)
 832         m.Retval = int32(buf.DecodeUint32())
 833         return nil
 834 }
 835
 836 // DHCPClientConfig defines message 'dhcp_client_config'.
 837 type DHCPClientConfig struct {
 838         IsAdd  bool       `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 839         Client DHCPClient `binapi:"dhcp_client,name=client" json:"client,omitempty"`
 840 }
 841
 842 func (m *DHCPClientConfig) Reset()               { *m = DHCPClientConfig{} }
 843 func (*DHCPClientConfig) GetMessageName() string { return "dhcp_client_config" }
 844 func (*DHCPClientConfig) GetCrcString() string   { return "959b80a3" }
 845 func (*DHCPClientConfig) GetMessageType() api.MessageType {
 846         return api.RequestMessage
 847 }
 848
 849 func (m *DHCPClientConfig) Size() int {
 850         if m == nil {
 851                 return 0
 852         }
 853         var size int
 854         size += 1      // m.IsAdd
 855         size += 4      // m.Client.SwIfIndex
 856         size += 64     // m.Client.Hostname
 857         size += 1 * 64 // m.Client.ID
 858         size += 1      // m.Client.WantDHCPEvent
 859         size += 1      // m.Client.SetBroadcastFlag
 860         size += 1      // m.Client.Dscp
 861         size += 4      // m.Client.PID
 862         return size
 863 }
 864 func (m *DHCPClientConfig) Marshal(b []byte) ([]byte, error) {
 865         var buf *codec.Buffer
 866         if b == nil {
 867                 buf = codec.NewBuffer(make([]byte, m.Size()))
 868         } else {
 869                 buf = codec.NewBuffer(b)
 870         }
 871         buf.EncodeBool(m.IsAdd)
 872         buf.EncodeUint32(uint32(m.Client.SwIfIndex))
 873         buf.EncodeString(m.Client.Hostname, 64)
 874         buf.EncodeBytes(m.Client.ID[:], 64)
 875         buf.EncodeBool(m.Client.WantDHCPEvent)
 876         buf.EncodeBool(m.Client.SetBroadcastFlag)
 877         buf.EncodeUint8(uint8(m.Client.Dscp))
 878         buf.EncodeUint32(uint32(m.Client.PID))
 879         return buf.Bytes(), nil
 880 }
 881 func (m *DHCPClientConfig) Unmarshal(b []byte) error {
 882         buf := codec.NewBuffer(b)
 883         m.IsAdd = buf.DecodeBool()
 884         m.Client.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 885         m.Client.Hostname = buf.DecodeString(64)
 886         copy(m.Client.ID[:], buf.DecodeBytes(64))
 887         m.Client.WantDHCPEvent = buf.DecodeBool()
 888         m.Client.SetBroadcastFlag = buf.DecodeBool()
 889         m.Client.Dscp = ip_types.IPDscp(buf.DecodeUint8())
 890         m.Client.PID = buf.DecodeUint32()
 891         return nil
 892 }
 893
 894 // DHCPClientConfigReply defines message 'dhcp_client_config_reply'.
 895 type DHCPClientConfigReply struct {
 896         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 897 }
 898
 899 func (m *DHCPClientConfigReply) Reset()               { *m = DHCPClientConfigReply{} }
 900 func (*DHCPClientConfigReply) GetMessageName() string { return "dhcp_client_config_reply" }
 901 func (*DHCPClientConfigReply) GetCrcString() string   { return "e8d4e804" }
 902 func (*DHCPClientConfigReply) GetMessageType() api.MessageType {
 903         return api.ReplyMessage
 904 }
 905
 906 func (m *DHCPClientConfigReply) Size() int {
 907         if m == nil {
 908                 return 0
 909         }
 910         var size int
 911         size += 4 // m.Retval
 912         return size
 913 }
 914 func (m *DHCPClientConfigReply) Marshal(b []byte) ([]byte, error) {
 915         var buf *codec.Buffer
 916         if b == nil {
 917                 buf = codec.NewBuffer(make([]byte, m.Size()))
 918         } else {
 919                 buf = codec.NewBuffer(b)
 920         }
 921         buf.EncodeUint32(uint32(m.Retval))
 922         return buf.Bytes(), nil
 923 }
 924 func (m *DHCPClientConfigReply) Unmarshal(b []byte) error {
 925         buf := codec.NewBuffer(b)
 926         m.Retval = int32(buf.DecodeUint32())
 927         return nil
 928 }
 929
 930 // DHCPClientDetails defines message 'dhcp_client_details'.
 931 type DHCPClientDetails struct {
 932         Client DHCPClient `binapi:"dhcp_client,name=client" json:"client,omitempty"`
 933         Lease  DHCPLease  `binapi:"dhcp_lease,name=lease" json:"lease,omitempty"`
 934 }
 935
 936 func (m *DHCPClientDetails) Reset()               { *m = DHCPClientDetails{} }
 937 func (*DHCPClientDetails) GetMessageName() string { return "dhcp_client_details" }
 938 func (*DHCPClientDetails) GetCrcString() string   { return "acd82f5a" }
 939 func (*DHCPClientDetails) GetMessageType() api.MessageType {
 940         return api.ReplyMessage
 941 }
 942
 943 func (m *DHCPClientDetails) Size() int {
 944         if m == nil {
 945                 return 0
 946         }
 947         var size int
 948         size += 4      // m.Client.SwIfIndex
 949         size += 64     // m.Client.Hostname
 950         size += 1 * 64 // m.Client.ID
 951         size += 1      // m.Client.WantDHCPEvent
 952         size += 1      // m.Client.SetBroadcastFlag
 953         size += 1      // m.Client.Dscp
 954         size += 4      // m.Client.PID
 955         size += 4      // m.Lease.SwIfIndex
 956         size += 4      // m.Lease.State
 957         size += 1      // m.Lease.IsIPv6
 958         size += 64     // m.Lease.Hostname
 959         size += 1      // m.Lease.MaskWidth
 960         size += 1      // m.Lease.HostAddress.Af
 961         size += 1 * 16 // m.Lease.HostAddress.Un
 962         size += 1      // m.Lease.RouterAddress.Af
 963         size += 1 * 16 // m.Lease.RouterAddress.Un
 964         size += 1 * 6  // m.Lease.HostMac
 965         size += 1      // m.Lease.Count
 966         for j2 := 0; j2 < len(m.Lease.DomainServer); j2++ {
 967                 var s2 DomainServer
 968                 _ = s2
 969                 if j2 < len(m.Lease.DomainServer) {
 970                         s2 = m.Lease.DomainServer[j2]
 971                 }
 972                 size += 1      // s2.Address.Af
 973                 size += 1 * 16 // s2.Address.Un
 974         }
 975         return size
 976 }
 977 func (m *DHCPClientDetails) Marshal(b []byte) ([]byte, error) {
 978         var buf *codec.Buffer
 979         if b == nil {
 980                 buf = codec.NewBuffer(make([]byte, m.Size()))
 981         } else {
 982                 buf = codec.NewBuffer(b)
 983         }
 984         buf.EncodeUint32(uint32(m.Client.SwIfIndex))
 985         buf.EncodeString(m.Client.Hostname, 64)
 986         buf.EncodeBytes(m.Client.ID[:], 64)
 987         buf.EncodeBool(m.Client.WantDHCPEvent)
 988         buf.EncodeBool(m.Client.SetBroadcastFlag)
 989         buf.EncodeUint8(uint8(m.Client.Dscp))
 990         buf.EncodeUint32(uint32(m.Client.PID))
 991         buf.EncodeUint32(uint32(m.Lease.SwIfIndex))
 992         buf.EncodeUint32(uint32(m.Lease.State))
 993         buf.EncodeBool(m.Lease.IsIPv6)
 994         buf.EncodeString(m.Lease.Hostname, 64)
 995         buf.EncodeUint8(uint8(m.Lease.MaskWidth))
 996         buf.EncodeUint8(uint8(m.Lease.HostAddress.Af))
 997         buf.EncodeBytes(m.Lease.HostAddress.Un.XXX_UnionData[:], 0)
 998         buf.EncodeUint8(uint8(m.Lease.RouterAddress.Af))
 999         buf.EncodeBytes(m.Lease.RouterAddress.Un.XXX_UnionData[:], 0)
1000         buf.EncodeBytes(m.Lease.HostMac[:], 6)
1001         buf.EncodeUint8(uint8(len(m.Lease.DomainServer)))
1002         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1003                 var v1 DomainServer
1004                 if j1 < len(m.Lease.DomainServer) {
1005                         v1 = m.Lease.DomainServer[j1]
1006                 }
1007                 buf.EncodeUint8(uint8(v1.Address.Af))
1008                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 0)
1009         }
1010         return buf.Bytes(), nil
1011 }
1012 func (m *DHCPClientDetails) Unmarshal(b []byte) error {
1013         buf := codec.NewBuffer(b)
1014         m.Client.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1015         m.Client.Hostname = buf.DecodeString(64)
1016         copy(m.Client.ID[:], buf.DecodeBytes(64))
1017         m.Client.WantDHCPEvent = buf.DecodeBool()
1018         m.Client.SetBroadcastFlag = buf.DecodeBool()
1019         m.Client.Dscp = ip_types.IPDscp(buf.DecodeUint8())
1020         m.Client.PID = buf.DecodeUint32()
1021         m.Lease.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1022         m.Lease.State = DHCPClientState(buf.DecodeUint32())
1023         m.Lease.IsIPv6 = buf.DecodeBool()
1024         m.Lease.Hostname = buf.DecodeString(64)
1025         m.Lease.MaskWidth = buf.DecodeUint8()
1026         m.Lease.HostAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1027         copy(m.Lease.HostAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1028         m.Lease.RouterAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1029         copy(m.Lease.RouterAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1030         copy(m.Lease.HostMac[:], buf.DecodeBytes(6))
1031         m.Lease.Count = buf.DecodeUint8()
1032         m.Lease.DomainServer = make([]DomainServer, int(m.Lease.Count))
1033         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1034                 m.Lease.DomainServer[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
1035                 copy(m.Lease.DomainServer[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1036         }
1037         return nil
1038 }
1039
1040 // DHCPClientDump defines message 'dhcp_client_dump'.
1041 type DHCPClientDump struct{}
1042
1043 func (m *DHCPClientDump) Reset()               { *m = DHCPClientDump{} }
1044 func (*DHCPClientDump) GetMessageName() string { return "dhcp_client_dump" }
1045 func (*DHCPClientDump) GetCrcString() string   { return "51077d14" }
1046 func (*DHCPClientDump) GetMessageType() api.MessageType {
1047         return api.RequestMessage
1048 }
1049
1050 func (m *DHCPClientDump) Size() int {
1051         if m == nil {
1052                 return 0
1053         }
1054         var size int
1055         return size
1056 }
1057 func (m *DHCPClientDump) Marshal(b []byte) ([]byte, error) {
1058         var buf *codec.Buffer
1059         if b == nil {
1060                 buf = codec.NewBuffer(make([]byte, m.Size()))
1061         } else {
1062                 buf = codec.NewBuffer(b)
1063         }
1064         return buf.Bytes(), nil
1065 }
1066 func (m *DHCPClientDump) Unmarshal(b []byte) error {
1067         return nil
1068 }
1069
1070 // DHCPComplEvent defines message 'dhcp_compl_event'.
1071 type DHCPComplEvent struct {
1072         PID   uint32    `binapi:"u32,name=pid" json:"pid,omitempty"`
1073         Lease DHCPLease `binapi:"dhcp_lease,name=lease" json:"lease,omitempty"`
1074 }
1075
1076 func (m *DHCPComplEvent) Reset()               { *m = DHCPComplEvent{} }
1077 func (*DHCPComplEvent) GetMessageName() string { return "dhcp_compl_event" }
1078 func (*DHCPComplEvent) GetCrcString() string   { return "e908fd1d" }
1079 func (*DHCPComplEvent) GetMessageType() api.MessageType {
1080         return api.EventMessage
1081 }
1082
1083 func (m *DHCPComplEvent) Size() int {
1084         if m == nil {
1085                 return 0
1086         }
1087         var size int
1088         size += 4      // m.PID
1089         size += 4      // m.Lease.SwIfIndex
1090         size += 4      // m.Lease.State
1091         size += 1      // m.Lease.IsIPv6
1092         size += 64     // m.Lease.Hostname
1093         size += 1      // m.Lease.MaskWidth
1094         size += 1      // m.Lease.HostAddress.Af
1095         size += 1 * 16 // m.Lease.HostAddress.Un
1096         size += 1      // m.Lease.RouterAddress.Af
1097         size += 1 * 16 // m.Lease.RouterAddress.Un
1098         size += 1 * 6  // m.Lease.HostMac
1099         size += 1      // m.Lease.Count
1100         for j2 := 0; j2 < len(m.Lease.DomainServer); j2++ {
1101                 var s2 DomainServer
1102                 _ = s2
1103                 if j2 < len(m.Lease.DomainServer) {
1104                         s2 = m.Lease.DomainServer[j2]
1105                 }
1106                 size += 1      // s2.Address.Af
1107                 size += 1 * 16 // s2.Address.Un
1108         }
1109         return size
1110 }
1111 func (m *DHCPComplEvent) Marshal(b []byte) ([]byte, error) {
1112         var buf *codec.Buffer
1113         if b == nil {
1114                 buf = codec.NewBuffer(make([]byte, m.Size()))
1115         } else {
1116                 buf = codec.NewBuffer(b)
1117         }
1118         buf.EncodeUint32(uint32(m.PID))
1119         buf.EncodeUint32(uint32(m.Lease.SwIfIndex))
1120         buf.EncodeUint32(uint32(m.Lease.State))
1121         buf.EncodeBool(m.Lease.IsIPv6)
1122         buf.EncodeString(m.Lease.Hostname, 64)
1123         buf.EncodeUint8(uint8(m.Lease.MaskWidth))
1124         buf.EncodeUint8(uint8(m.Lease.HostAddress.Af))
1125         buf.EncodeBytes(m.Lease.HostAddress.Un.XXX_UnionData[:], 0)
1126         buf.EncodeUint8(uint8(m.Lease.RouterAddress.Af))
1127         buf.EncodeBytes(m.Lease.RouterAddress.Un.XXX_UnionData[:], 0)
1128         buf.EncodeBytes(m.Lease.HostMac[:], 6)
1129         buf.EncodeUint8(uint8(len(m.Lease.DomainServer)))
1130         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1131                 var v1 DomainServer
1132                 if j1 < len(m.Lease.DomainServer) {
1133                         v1 = m.Lease.DomainServer[j1]
1134                 }
1135                 buf.EncodeUint8(uint8(v1.Address.Af))
1136                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 0)
1137         }
1138         return buf.Bytes(), nil
1139 }
1140 func (m *DHCPComplEvent) Unmarshal(b []byte) error {
1141         buf := codec.NewBuffer(b)
1142         m.PID = buf.DecodeUint32()
1143         m.Lease.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1144         m.Lease.State = DHCPClientState(buf.DecodeUint32())
1145         m.Lease.IsIPv6 = buf.DecodeBool()
1146         m.Lease.Hostname = buf.DecodeString(64)
1147         m.Lease.MaskWidth = buf.DecodeUint8()
1148         m.Lease.HostAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1149         copy(m.Lease.HostAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1150         m.Lease.RouterAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1151         copy(m.Lease.RouterAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1152         copy(m.Lease.HostMac[:], buf.DecodeBytes(6))
1153         m.Lease.Count = buf.DecodeUint8()
1154         m.Lease.DomainServer = make([]DomainServer, int(m.Lease.Count))
1155         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1156                 m.Lease.DomainServer[j1].Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
1157                 copy(m.Lease.DomainServer[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1158         }
1159         return nil
1160 }
1161
1162 // DHCPPluginControlPing defines message 'dhcp_plugin_control_ping'.
1163 type DHCPPluginControlPing struct{}
1164
1165 func (m *DHCPPluginControlPing) Reset()               { *m = DHCPPluginControlPing{} }
1166 func (*DHCPPluginControlPing) GetMessageName() string { return "dhcp_plugin_control_ping" }
1167 func (*DHCPPluginControlPing) GetCrcString() string   { return "51077d14" }
1168 func (*DHCPPluginControlPing) GetMessageType() api.MessageType {
1169         return api.RequestMessage
1170 }
1171
1172 func (m *DHCPPluginControlPing) Size() int {
1173         if m == nil {
1174                 return 0
1175         }
1176         var size int
1177         return size
1178 }
1179 func (m *DHCPPluginControlPing) Marshal(b []byte) ([]byte, error) {
1180         var buf *codec.Buffer
1181         if b == nil {
1182                 buf = codec.NewBuffer(make([]byte, m.Size()))
1183         } else {
1184                 buf = codec.NewBuffer(b)
1185         }
1186         return buf.Bytes(), nil
1187 }
1188 func (m *DHCPPluginControlPing) Unmarshal(b []byte) error {
1189         return nil
1190 }
1191
1192 // DHCPPluginControlPingReply defines message 'dhcp_plugin_control_ping_reply'.
1193 type DHCPPluginControlPingReply struct {
1194         Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1195         ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
1196         VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
1197 }
1198
1199 func (m *DHCPPluginControlPingReply) Reset()               { *m = DHCPPluginControlPingReply{} }
1200 func (*DHCPPluginControlPingReply) GetMessageName() string { return "dhcp_plugin_control_ping_reply" }
1201 func (*DHCPPluginControlPingReply) GetCrcString() string   { return "f6b0b8ca" }
1202 func (*DHCPPluginControlPingReply) GetMessageType() api.MessageType {
1203         return api.ReplyMessage
1204 }
1205
1206 func (m *DHCPPluginControlPingReply) Size() int {
1207         if m == nil {
1208                 return 0
1209         }
1210         var size int
1211         size += 4 // m.Retval
1212         size += 4 // m.ClientIndex
1213         size += 4 // m.VpePID
1214         return size
1215 }
1216 func (m *DHCPPluginControlPingReply) Marshal(b []byte) ([]byte, error) {
1217         var buf *codec.Buffer
1218         if b == nil {
1219                 buf = codec.NewBuffer(make([]byte, m.Size()))
1220         } else {
1221                 buf = codec.NewBuffer(b)
1222         }
1223         buf.EncodeUint32(uint32(m.Retval))
1224         buf.EncodeUint32(uint32(m.ClientIndex))
1225         buf.EncodeUint32(uint32(m.VpePID))
1226         return buf.Bytes(), nil
1227 }
1228 func (m *DHCPPluginControlPingReply) Unmarshal(b []byte) error {
1229         buf := codec.NewBuffer(b)
1230         m.Retval = int32(buf.DecodeUint32())
1231         m.ClientIndex = buf.DecodeUint32()
1232         m.VpePID = buf.DecodeUint32()
1233         return nil
1234 }
1235
1236 // DHCPPluginGetVersion defines message 'dhcp_plugin_get_version'.
1237 type DHCPPluginGetVersion struct{}
1238
1239 func (m *DHCPPluginGetVersion) Reset()               { *m = DHCPPluginGetVersion{} }
1240 func (*DHCPPluginGetVersion) GetMessageName() string { return "dhcp_plugin_get_version" }
1241 func (*DHCPPluginGetVersion) GetCrcString() string   { return "51077d14" }
1242 func (*DHCPPluginGetVersion) GetMessageType() api.MessageType {
1243         return api.RequestMessage
1244 }
1245
1246 func (m *DHCPPluginGetVersion) Size() int {
1247         if m == nil {
1248                 return 0
1249         }
1250         var size int
1251         return size
1252 }
1253 func (m *DHCPPluginGetVersion) Marshal(b []byte) ([]byte, error) {
1254         var buf *codec.Buffer
1255         if b == nil {
1256                 buf = codec.NewBuffer(make([]byte, m.Size()))
1257         } else {
1258                 buf = codec.NewBuffer(b)
1259         }
1260         return buf.Bytes(), nil
1261 }
1262 func (m *DHCPPluginGetVersion) Unmarshal(b []byte) error {
1263         return nil
1264 }
1265
1266 // DHCPPluginGetVersionReply defines message 'dhcp_plugin_get_version_reply'.
1267 type DHCPPluginGetVersionReply struct {
1268         Major uint32 `binapi:"u32,name=major" json:"major,omitempty"`
1269         Minor uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
1270 }
1271
1272 func (m *DHCPPluginGetVersionReply) Reset()               { *m = DHCPPluginGetVersionReply{} }
1273 func (*DHCPPluginGetVersionReply) GetMessageName() string { return "dhcp_plugin_get_version_reply" }
1274 func (*DHCPPluginGetVersionReply) GetCrcString() string   { return "9b32cf86" }
1275 func (*DHCPPluginGetVersionReply) GetMessageType() api.MessageType {
1276         return api.ReplyMessage
1277 }
1278
1279 func (m *DHCPPluginGetVersionReply) Size() int {
1280         if m == nil {
1281                 return 0
1282         }
1283         var size int
1284         size += 4 // m.Major
1285         size += 4 // m.Minor
1286         return size
1287 }
1288 func (m *DHCPPluginGetVersionReply) Marshal(b []byte) ([]byte, error) {
1289         var buf *codec.Buffer
1290         if b == nil {
1291                 buf = codec.NewBuffer(make([]byte, m.Size()))
1292         } else {
1293                 buf = codec.NewBuffer(b)
1294         }
1295         buf.EncodeUint32(uint32(m.Major))
1296         buf.EncodeUint32(uint32(m.Minor))
1297         return buf.Bytes(), nil
1298 }
1299 func (m *DHCPPluginGetVersionReply) Unmarshal(b []byte) error {
1300         buf := codec.NewBuffer(b)
1301         m.Major = buf.DecodeUint32()
1302         m.Minor = buf.DecodeUint32()
1303         return nil
1304 }
1305
1306 // DHCPProxyConfig defines message 'dhcp_proxy_config'.
1307 type DHCPProxyConfig struct {
1308         RxVrfID        uint32           `binapi:"u32,name=rx_vrf_id" json:"rx_vrf_id,omitempty"`
1309         ServerVrfID    uint32           `binapi:"u32,name=server_vrf_id" json:"server_vrf_id,omitempty"`
1310         IsAdd          bool             `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1311         DHCPServer     ip_types.Address `binapi:"address,name=dhcp_server" json:"dhcp_server,omitempty"`
1312         DHCPSrcAddress ip_types.Address `binapi:"address,name=dhcp_src_address" json:"dhcp_src_address,omitempty"`
1313 }
1314
1315 func (m *DHCPProxyConfig) Reset()               { *m = DHCPProxyConfig{} }
1316 func (*DHCPProxyConfig) GetMessageName() string { return "dhcp_proxy_config" }
1317 func (*DHCPProxyConfig) GetCrcString() string   { return "6767230e" }
1318 func (*DHCPProxyConfig) GetMessageType() api.MessageType {
1319         return api.RequestMessage
1320 }
1321
1322 func (m *DHCPProxyConfig) Size() int {
1323         if m == nil {
1324                 return 0
1325         }
1326         var size int
1327         size += 4      // m.RxVrfID
1328         size += 4      // m.ServerVrfID
1329         size += 1      // m.IsAdd
1330         size += 1      // m.DHCPServer.Af
1331         size += 1 * 16 // m.DHCPServer.Un
1332         size += 1      // m.DHCPSrcAddress.Af
1333         size += 1 * 16 // m.DHCPSrcAddress.Un
1334         return size
1335 }
1336 func (m *DHCPProxyConfig) Marshal(b []byte) ([]byte, error) {
1337         var buf *codec.Buffer
1338         if b == nil {
1339                 buf = codec.NewBuffer(make([]byte, m.Size()))
1340         } else {
1341                 buf = codec.NewBuffer(b)
1342         }
1343         buf.EncodeUint32(uint32(m.RxVrfID))
1344         buf.EncodeUint32(uint32(m.ServerVrfID))
1345         buf.EncodeBool(m.IsAdd)
1346         buf.EncodeUint8(uint8(m.DHCPServer.Af))
1347         buf.EncodeBytes(m.DHCPServer.Un.XXX_UnionData[:], 0)
1348         buf.EncodeUint8(uint8(m.DHCPSrcAddress.Af))
1349         buf.EncodeBytes(m.DHCPSrcAddress.Un.XXX_UnionData[:], 0)
1350         return buf.Bytes(), nil
1351 }
1352 func (m *DHCPProxyConfig) Unmarshal(b []byte) error {
1353         buf := codec.NewBuffer(b)
1354         m.RxVrfID = buf.DecodeUint32()
1355         m.ServerVrfID = buf.DecodeUint32()
1356         m.IsAdd = buf.DecodeBool()
1357         m.DHCPServer.Af = ip_types.AddressFamily(buf.DecodeUint8())
1358         copy(m.DHCPServer.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1359         m.DHCPSrcAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1360         copy(m.DHCPSrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1361         return nil
1362 }
1363
1364 // DHCPProxyConfigReply defines message 'dhcp_proxy_config_reply'.
1365 type DHCPProxyConfigReply struct {
1366         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1367 }
1368
1369 func (m *DHCPProxyConfigReply) Reset()               { *m = DHCPProxyConfigReply{} }
1370 func (*DHCPProxyConfigReply) GetMessageName() string { return "dhcp_proxy_config_reply" }
1371 func (*DHCPProxyConfigReply) GetCrcString() string   { return "e8d4e804" }
1372 func (*DHCPProxyConfigReply) GetMessageType() api.MessageType {
1373         return api.ReplyMessage
1374 }
1375
1376 func (m *DHCPProxyConfigReply) Size() int {
1377         if m == nil {
1378                 return 0
1379         }
1380         var size int
1381         size += 4 // m.Retval
1382         return size
1383 }
1384 func (m *DHCPProxyConfigReply) Marshal(b []byte) ([]byte, error) {
1385         var buf *codec.Buffer
1386         if b == nil {
1387                 buf = codec.NewBuffer(make([]byte, m.Size()))
1388         } else {
1389                 buf = codec.NewBuffer(b)
1390         }
1391         buf.EncodeUint32(uint32(m.Retval))
1392         return buf.Bytes(), nil
1393 }
1394 func (m *DHCPProxyConfigReply) Unmarshal(b []byte) error {
1395         buf := codec.NewBuffer(b)
1396         m.Retval = int32(buf.DecodeUint32())
1397         return nil
1398 }
1399
1400 // DHCPProxyDetails defines message 'dhcp_proxy_details'.
1401 type DHCPProxyDetails struct {
1402         RxVrfID        uint32           `binapi:"u32,name=rx_vrf_id" json:"rx_vrf_id,omitempty"`
1403         VssOui         uint32           `binapi:"u32,name=vss_oui" json:"vss_oui,omitempty"`
1404         VssFibID       uint32           `binapi:"u32,name=vss_fib_id" json:"vss_fib_id,omitempty"`
1405         VssType        VssType          `binapi:"vss_type,name=vss_type" json:"vss_type,omitempty"`
1406         IsIPv6         bool             `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
1407         VssVPNAsciiID  string           `binapi:"string[129],name=vss_vpn_ascii_id" json:"vss_vpn_ascii_id,omitempty"`
1408         DHCPSrcAddress ip_types.Address `binapi:"address,name=dhcp_src_address" json:"dhcp_src_address,omitempty"`
1409         Count          uint8            `binapi:"u8,name=count" json:"-"`
1410         Servers        []DHCPServer     `binapi:"dhcp_server[count],name=servers" json:"servers,omitempty"`
1411 }
1412
1413 func (m *DHCPProxyDetails) Reset()               { *m = DHCPProxyDetails{} }
1414 func (*DHCPProxyDetails) GetMessageName() string { return "dhcp_proxy_details" }
1415 func (*DHCPProxyDetails) GetCrcString() string   { return "ce16f044" }
1416 func (*DHCPProxyDetails) GetMessageType() api.MessageType {
1417         return api.ReplyMessage
1418 }
1419
1420 func (m *DHCPProxyDetails) Size() int {
1421         if m == nil {
1422                 return 0
1423         }
1424         var size int
1425         size += 4      // m.RxVrfID
1426         size += 4      // m.VssOui
1427         size += 4      // m.VssFibID
1428         size += 4      // m.VssType
1429         size += 1      // m.IsIPv6
1430         size += 129    // m.VssVPNAsciiID
1431         size += 1      // m.DHCPSrcAddress.Af
1432         size += 1 * 16 // m.DHCPSrcAddress.Un
1433         size += 1      // m.Count
1434         for j1 := 0; j1 < len(m.Servers); j1++ {
1435                 var s1 DHCPServer
1436                 _ = s1
1437                 if j1 < len(m.Servers) {
1438                         s1 = m.Servers[j1]
1439                 }
1440                 size += 4      // s1.ServerVrfID
1441                 size += 1      // s1.DHCPServer.Af
1442                 size += 1 * 16 // s1.DHCPServer.Un
1443         }
1444         return size
1445 }
1446 func (m *DHCPProxyDetails) Marshal(b []byte) ([]byte, error) {
1447         var buf *codec.Buffer
1448         if b == nil {
1449                 buf = codec.NewBuffer(make([]byte, m.Size()))
1450         } else {
1451                 buf = codec.NewBuffer(b)
1452         }
1453         buf.EncodeUint32(uint32(m.RxVrfID))
1454         buf.EncodeUint32(uint32(m.VssOui))
1455         buf.EncodeUint32(uint32(m.VssFibID))
1456         buf.EncodeUint32(uint32(m.VssType))
1457         buf.EncodeBool(m.IsIPv6)
1458         buf.EncodeString(m.VssVPNAsciiID, 129)
1459         buf.EncodeUint8(uint8(m.DHCPSrcAddress.Af))
1460         buf.EncodeBytes(m.DHCPSrcAddress.Un.XXX_UnionData[:], 0)
1461         buf.EncodeUint8(uint8(len(m.Servers)))
1462         for j0 := 0; j0 < len(m.Servers); j0++ {
1463                 var v0 DHCPServer
1464                 if j0 < len(m.Servers) {
1465                         v0 = m.Servers[j0]
1466                 }
1467                 buf.EncodeUint32(uint32(v0.ServerVrfID))
1468                 buf.EncodeUint8(uint8(v0.DHCPServer.Af))
1469                 buf.EncodeBytes(v0.DHCPServer.Un.XXX_UnionData[:], 0)
1470         }
1471         return buf.Bytes(), nil
1472 }
1473 func (m *DHCPProxyDetails) Unmarshal(b []byte) error {
1474         buf := codec.NewBuffer(b)
1475         m.RxVrfID = buf.DecodeUint32()
1476         m.VssOui = buf.DecodeUint32()
1477         m.VssFibID = buf.DecodeUint32()
1478         m.VssType = VssType(buf.DecodeUint32())
1479         m.IsIPv6 = buf.DecodeBool()
1480         m.VssVPNAsciiID = buf.DecodeString(129)
1481         m.DHCPSrcAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1482         copy(m.DHCPSrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1483         m.Count = buf.DecodeUint8()
1484         m.Servers = make([]DHCPServer, int(m.Count))
1485         for j0 := 0; j0 < len(m.Servers); j0++ {
1486                 m.Servers[j0].ServerVrfID = buf.DecodeUint32()
1487                 m.Servers[j0].DHCPServer.Af = ip_types.AddressFamily(buf.DecodeUint8())
1488                 copy(m.Servers[j0].DHCPServer.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1489         }
1490         return nil
1491 }
1492
1493 // DHCPProxyDump defines message 'dhcp_proxy_dump'.
1494 type DHCPProxyDump struct {
1495         IsIP6 bool `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
1496 }
1497
1498 func (m *DHCPProxyDump) Reset()               { *m = DHCPProxyDump{} }
1499 func (*DHCPProxyDump) GetMessageName() string { return "dhcp_proxy_dump" }
1500 func (*DHCPProxyDump) GetCrcString() string   { return "5c5b063f" }
1501 func (*DHCPProxyDump) GetMessageType() api.MessageType {
1502         return api.RequestMessage
1503 }
1504
1505 func (m *DHCPProxyDump) Size() int {
1506         if m == nil {
1507                 return 0
1508         }
1509         var size int
1510         size += 1 // m.IsIP6
1511         return size
1512 }
1513 func (m *DHCPProxyDump) Marshal(b []byte) ([]byte, error) {
1514         var buf *codec.Buffer
1515         if b == nil {
1516                 buf = codec.NewBuffer(make([]byte, m.Size()))
1517         } else {
1518                 buf = codec.NewBuffer(b)
1519         }
1520         buf.EncodeBool(m.IsIP6)
1521         return buf.Bytes(), nil
1522 }
1523 func (m *DHCPProxyDump) Unmarshal(b []byte) error {
1524         buf := codec.NewBuffer(b)
1525         m.IsIP6 = buf.DecodeBool()
1526         return nil
1527 }
1528
1529 // DHCPProxySetVss defines message 'dhcp_proxy_set_vss'.
1530 type DHCPProxySetVss struct {
1531         TblID      uint32  `binapi:"u32,name=tbl_id" json:"tbl_id,omitempty"`
1532         VssType    VssType `binapi:"vss_type,name=vss_type" json:"vss_type,omitempty"`
1533         VPNAsciiID string  `binapi:"string[129],name=vpn_ascii_id" json:"vpn_ascii_id,omitempty"`
1534         Oui        uint32  `binapi:"u32,name=oui" json:"oui,omitempty"`
1535         VPNIndex   uint32  `binapi:"u32,name=vpn_index" json:"vpn_index,omitempty"`
1536         IsIPv6     bool    `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
1537         IsAdd      bool    `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1538 }
1539
1540 func (m *DHCPProxySetVss) Reset()               { *m = DHCPProxySetVss{} }
1541 func (*DHCPProxySetVss) GetMessageName() string { return "dhcp_proxy_set_vss" }
1542 func (*DHCPProxySetVss) GetCrcString() string   { return "50537301" }
1543 func (*DHCPProxySetVss) GetMessageType() api.MessageType {
1544         return api.RequestMessage
1545 }
1546
1547 func (m *DHCPProxySetVss) Size() int {
1548         if m == nil {
1549                 return 0
1550         }
1551         var size int
1552         size += 4   // m.TblID
1553         size += 4   // m.VssType
1554         size += 129 // m.VPNAsciiID
1555         size += 4   // m.Oui
1556         size += 4   // m.VPNIndex
1557         size += 1   // m.IsIPv6
1558         size += 1   // m.IsAdd
1559         return size
1560 }
1561 func (m *DHCPProxySetVss) Marshal(b []byte) ([]byte, error) {
1562         var buf *codec.Buffer
1563         if b == nil {
1564                 buf = codec.NewBuffer(make([]byte, m.Size()))
1565         } else {
1566                 buf = codec.NewBuffer(b)
1567         }
1568         buf.EncodeUint32(uint32(m.TblID))
1569         buf.EncodeUint32(uint32(m.VssType))
1570         buf.EncodeString(m.VPNAsciiID, 129)
1571         buf.EncodeUint32(uint32(m.Oui))
1572         buf.EncodeUint32(uint32(m.VPNIndex))
1573         buf.EncodeBool(m.IsIPv6)
1574         buf.EncodeBool(m.IsAdd)
1575         return buf.Bytes(), nil
1576 }
1577 func (m *DHCPProxySetVss) Unmarshal(b []byte) error {
1578         buf := codec.NewBuffer(b)
1579         m.TblID = buf.DecodeUint32()
1580         m.VssType = VssType(buf.DecodeUint32())
1581         m.VPNAsciiID = buf.DecodeString(129)
1582         m.Oui = buf.DecodeUint32()
1583         m.VPNIndex = buf.DecodeUint32()
1584         m.IsIPv6 = buf.DecodeBool()
1585         m.IsAdd = buf.DecodeBool()
1586         return nil
1587 }
1588
1589 // DHCPProxySetVssReply defines message 'dhcp_proxy_set_vss_reply'.
1590 type DHCPProxySetVssReply struct {
1591         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1592 }
1593
1594 func (m *DHCPProxySetVssReply) Reset()               { *m = DHCPProxySetVssReply{} }
1595 func (*DHCPProxySetVssReply) GetMessageName() string { return "dhcp_proxy_set_vss_reply" }
1596 func (*DHCPProxySetVssReply) GetCrcString() string   { return "e8d4e804" }
1597 func (*DHCPProxySetVssReply) GetMessageType() api.MessageType {
1598         return api.ReplyMessage
1599 }
1600
1601 func (m *DHCPProxySetVssReply) Size() int {
1602         if m == nil {
1603                 return 0
1604         }
1605         var size int
1606         size += 4 // m.Retval
1607         return size
1608 }
1609 func (m *DHCPProxySetVssReply) Marshal(b []byte) ([]byte, error) {
1610         var buf *codec.Buffer
1611         if b == nil {
1612                 buf = codec.NewBuffer(make([]byte, m.Size()))
1613         } else {
1614                 buf = codec.NewBuffer(b)
1615         }
1616         buf.EncodeUint32(uint32(m.Retval))
1617         return buf.Bytes(), nil
1618 }
1619 func (m *DHCPProxySetVssReply) Unmarshal(b []byte) error {
1620         buf := codec.NewBuffer(b)
1621         m.Retval = int32(buf.DecodeUint32())
1622         return nil
1623 }
1624
1625 // WantDHCP6PdReplyEvents defines message 'want_dhcp6_pd_reply_events'.
1626 type WantDHCP6PdReplyEvents struct {
1627         EnableDisable bool   `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
1628         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
1629 }
1630
1631 func (m *WantDHCP6PdReplyEvents) Reset()               { *m = WantDHCP6PdReplyEvents{} }
1632 func (*WantDHCP6PdReplyEvents) GetMessageName() string { return "want_dhcp6_pd_reply_events" }
1633 func (*WantDHCP6PdReplyEvents) GetCrcString() string   { return "c5e2af94" }
1634 func (*WantDHCP6PdReplyEvents) GetMessageType() api.MessageType {
1635         return api.RequestMessage
1636 }
1637
1638 func (m *WantDHCP6PdReplyEvents) Size() int {
1639         if m == nil {
1640                 return 0
1641         }
1642         var size int
1643         size += 1 // m.EnableDisable
1644         size += 4 // m.PID
1645         return size
1646 }
1647 func (m *WantDHCP6PdReplyEvents) Marshal(b []byte) ([]byte, error) {
1648         var buf *codec.Buffer
1649         if b == nil {
1650                 buf = codec.NewBuffer(make([]byte, m.Size()))
1651         } else {
1652                 buf = codec.NewBuffer(b)
1653         }
1654         buf.EncodeBool(m.EnableDisable)
1655         buf.EncodeUint32(uint32(m.PID))
1656         return buf.Bytes(), nil
1657 }
1658 func (m *WantDHCP6PdReplyEvents) Unmarshal(b []byte) error {
1659         buf := codec.NewBuffer(b)
1660         m.EnableDisable = buf.DecodeBool()
1661         m.PID = buf.DecodeUint32()
1662         return nil
1663 }
1664
1665 // WantDHCP6PdReplyEventsReply defines message 'want_dhcp6_pd_reply_events_reply'.
1666 type WantDHCP6PdReplyEventsReply struct {
1667         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1668 }
1669
1670 func (m *WantDHCP6PdReplyEventsReply) Reset() { *m = WantDHCP6PdReplyEventsReply{} }
1671 func (*WantDHCP6PdReplyEventsReply) GetMessageName() string {
1672         return "want_dhcp6_pd_reply_events_reply"
1673 }
1674 func (*WantDHCP6PdReplyEventsReply) GetCrcString() string { return "e8d4e804" }
1675 func (*WantDHCP6PdReplyEventsReply) GetMessageType() api.MessageType {
1676         return api.ReplyMessage
1677 }
1678
1679 func (m *WantDHCP6PdReplyEventsReply) Size() int {
1680         if m == nil {
1681                 return 0
1682         }
1683         var size int
1684         size += 4 // m.Retval
1685         return size
1686 }
1687 func (m *WantDHCP6PdReplyEventsReply) Marshal(b []byte) ([]byte, error) {
1688         var buf *codec.Buffer
1689         if b == nil {
1690                 buf = codec.NewBuffer(make([]byte, m.Size()))
1691         } else {
1692                 buf = codec.NewBuffer(b)
1693         }
1694         buf.EncodeUint32(uint32(m.Retval))
1695         return buf.Bytes(), nil
1696 }
1697 func (m *WantDHCP6PdReplyEventsReply) Unmarshal(b []byte) error {
1698         buf := codec.NewBuffer(b)
1699         m.Retval = int32(buf.DecodeUint32())
1700         return nil
1701 }
1702
1703 // WantDHCP6ReplyEvents defines message 'want_dhcp6_reply_events'.
1704 type WantDHCP6ReplyEvents struct {
1705         EnableDisable uint8  `binapi:"u8,name=enable_disable" json:"enable_disable,omitempty"`
1706         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
1707 }
1708
1709 func (m *WantDHCP6ReplyEvents) Reset()               { *m = WantDHCP6ReplyEvents{} }
1710 func (*WantDHCP6ReplyEvents) GetMessageName() string { return "want_dhcp6_reply_events" }
1711 func (*WantDHCP6ReplyEvents) GetCrcString() string   { return "05b454b5" }
1712 func (*WantDHCP6ReplyEvents) GetMessageType() api.MessageType {
1713         return api.RequestMessage
1714 }
1715
1716 func (m *WantDHCP6ReplyEvents) Size() int {
1717         if m == nil {
1718                 return 0
1719         }
1720         var size int
1721         size += 1 // m.EnableDisable
1722         size += 4 // m.PID
1723         return size
1724 }
1725 func (m *WantDHCP6ReplyEvents) Marshal(b []byte) ([]byte, error) {
1726         var buf *codec.Buffer
1727         if b == nil {
1728                 buf = codec.NewBuffer(make([]byte, m.Size()))
1729         } else {
1730                 buf = codec.NewBuffer(b)
1731         }
1732         buf.EncodeUint8(uint8(m.EnableDisable))
1733         buf.EncodeUint32(uint32(m.PID))
1734         return buf.Bytes(), nil
1735 }
1736 func (m *WantDHCP6ReplyEvents) Unmarshal(b []byte) error {
1737         buf := codec.NewBuffer(b)
1738         m.EnableDisable = buf.DecodeUint8()
1739         m.PID = buf.DecodeUint32()
1740         return nil
1741 }
1742
1743 // WantDHCP6ReplyEventsReply defines message 'want_dhcp6_reply_events_reply'.
1744 type WantDHCP6ReplyEventsReply struct {
1745         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1746 }
1747
1748 func (m *WantDHCP6ReplyEventsReply) Reset()               { *m = WantDHCP6ReplyEventsReply{} }
1749 func (*WantDHCP6ReplyEventsReply) GetMessageName() string { return "want_dhcp6_reply_events_reply" }
1750 func (*WantDHCP6ReplyEventsReply) GetCrcString() string   { return "e8d4e804" }
1751 func (*WantDHCP6ReplyEventsReply) GetMessageType() api.MessageType {
1752         return api.ReplyMessage
1753 }
1754
1755 func (m *WantDHCP6ReplyEventsReply) Size() int {
1756         if m == nil {
1757                 return 0
1758         }
1759         var size int
1760         size += 4 // m.Retval
1761         return size
1762 }
1763 func (m *WantDHCP6ReplyEventsReply) Marshal(b []byte) ([]byte, error) {
1764         var buf *codec.Buffer
1765         if b == nil {
1766                 buf = codec.NewBuffer(make([]byte, m.Size()))
1767         } else {
1768                 buf = codec.NewBuffer(b)
1769         }
1770         buf.EncodeUint32(uint32(m.Retval))
1771         return buf.Bytes(), nil
1772 }
1773 func (m *WantDHCP6ReplyEventsReply) Unmarshal(b []byte) error {
1774         buf := codec.NewBuffer(b)
1775         m.Retval = int32(buf.DecodeUint32())
1776         return nil
1777 }
1778
1779 func init() { file_dhcp_binapi_init() }
1780 func file_dhcp_binapi_init() {
1781         api.RegisterMessage((*DHCP6ClientsEnableDisable)(nil), "dhcp6_clients_enable_disable_b3e225d2")
1782         api.RegisterMessage((*DHCP6ClientsEnableDisableReply)(nil), "dhcp6_clients_enable_disable_reply_e8d4e804")
1783         api.RegisterMessage((*DHCP6DuidLlSet)(nil), "dhcp6_duid_ll_set_0f6ca323")
1784         api.RegisterMessage((*DHCP6DuidLlSetReply)(nil), "dhcp6_duid_ll_set_reply_e8d4e804")
1785         api.RegisterMessage((*DHCP6PdReplyEvent)(nil), "dhcp6_pd_reply_event_cb3e462b")
1786         api.RegisterMessage((*DHCP6PdSendClientMessage)(nil), "dhcp6_pd_send_client_message_064badb8")
1787         api.RegisterMessage((*DHCP6PdSendClientMessageReply)(nil), "dhcp6_pd_send_client_message_reply_e8d4e804")
1788         api.RegisterMessage((*DHCP6ReplyEvent)(nil), "dhcp6_reply_event_9f3af9e5")
1789         api.RegisterMessage((*DHCP6SendClientMessage)(nil), "dhcp6_send_client_message_f6f14ef0")
1790         api.RegisterMessage((*DHCP6SendClientMessageReply)(nil), "dhcp6_send_client_message_reply_e8d4e804")
1791         api.RegisterMessage((*DHCPClientConfig)(nil), "dhcp_client_config_959b80a3")
1792         api.RegisterMessage((*DHCPClientConfigReply)(nil), "dhcp_client_config_reply_e8d4e804")
1793         api.RegisterMessage((*DHCPClientDetails)(nil), "dhcp_client_details_acd82f5a")
1794         api.RegisterMessage((*DHCPClientDump)(nil), "dhcp_client_dump_51077d14")
1795         api.RegisterMessage((*DHCPComplEvent)(nil), "dhcp_compl_event_e908fd1d")
1796         api.RegisterMessage((*DHCPPluginControlPing)(nil), "dhcp_plugin_control_ping_51077d14")
1797         api.RegisterMessage((*DHCPPluginControlPingReply)(nil), "dhcp_plugin_control_ping_reply_f6b0b8ca")
1798         api.RegisterMessage((*DHCPPluginGetVersion)(nil), "dhcp_plugin_get_version_51077d14")
1799         api.RegisterMessage((*DHCPPluginGetVersionReply)(nil), "dhcp_plugin_get_version_reply_9b32cf86")
1800         api.RegisterMessage((*DHCPProxyConfig)(nil), "dhcp_proxy_config_6767230e")
1801         api.RegisterMessage((*DHCPProxyConfigReply)(nil), "dhcp_proxy_config_reply_e8d4e804")
1802         api.RegisterMessage((*DHCPProxyDetails)(nil), "dhcp_proxy_details_ce16f044")
1803         api.RegisterMessage((*DHCPProxyDump)(nil), "dhcp_proxy_dump_5c5b063f")
1804         api.RegisterMessage((*DHCPProxySetVss)(nil), "dhcp_proxy_set_vss_50537301")
1805         api.RegisterMessage((*DHCPProxySetVssReply)(nil), "dhcp_proxy_set_vss_reply_e8d4e804")
1806         api.RegisterMessage((*WantDHCP6PdReplyEvents)(nil), "want_dhcp6_pd_reply_events_c5e2af94")
1807         api.RegisterMessage((*WantDHCP6PdReplyEventsReply)(nil), "want_dhcp6_pd_reply_events_reply_e8d4e804")
1808         api.RegisterMessage((*WantDHCP6ReplyEvents)(nil), "want_dhcp6_reply_events_05b454b5")
1809         api.RegisterMessage((*WantDHCP6ReplyEventsReply)(nil), "want_dhcp6_reply_events_reply_e8d4e804")
1810 }
1811
1812 // Messages returns list of all messages in this module.
1813 func AllMessages() []api.Message {
1814         return []api.Message{
1815                 (*DHCP6ClientsEnableDisable)(nil),
1816                 (*DHCP6ClientsEnableDisableReply)(nil),
1817                 (*DHCP6DuidLlSet)(nil),
1818                 (*DHCP6DuidLlSetReply)(nil),
1819                 (*DHCP6PdReplyEvent)(nil),
1820                 (*DHCP6PdSendClientMessage)(nil),
1821                 (*DHCP6PdSendClientMessageReply)(nil),
1822                 (*DHCP6ReplyEvent)(nil),
1823                 (*DHCP6SendClientMessage)(nil),
1824                 (*DHCP6SendClientMessageReply)(nil),
1825                 (*DHCPClientConfig)(nil),
1826                 (*DHCPClientConfigReply)(nil),
1827                 (*DHCPClientDetails)(nil),
1828                 (*DHCPClientDump)(nil),
1829                 (*DHCPComplEvent)(nil),
1830                 (*DHCPPluginControlPing)(nil),
1831                 (*DHCPPluginControlPingReply)(nil),
1832                 (*DHCPPluginGetVersion)(nil),
1833                 (*DHCPPluginGetVersionReply)(nil),
1834                 (*DHCPProxyConfig)(nil),
1835                 (*DHCPProxyConfigReply)(nil),
1836                 (*DHCPProxyDetails)(nil),
1837                 (*DHCPProxyDump)(nil),
1838                 (*DHCPProxySetVss)(nil),
1839                 (*DHCPProxySetVssReply)(nil),
1840                 (*WantDHCP6PdReplyEvents)(nil),
1841                 (*WantDHCP6PdReplyEventsReply)(nil),
1842                 (*WantDHCP6ReplyEvents)(nil),
1843                 (*WantDHCP6ReplyEventsReply)(nil),
1844         }
1845 }