internal/testbinapi/binapi2001/dhcp/dhcp.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.5.0-dev
   4 //  VPP:              20.01
   5 // source: .vppapi/plugins/dhcp.api.json
   6
   7 // Package dhcp contains generated bindings for API file dhcp.api.
   8 //
   9 // Contents:
  10 //   7 aliases
  11 //  13 enums
  12 //  12 structs
  13 //   1 union
  14 //  29 messages
  15 //
  16 package dhcp
  17
  18 import (
  19         "fmt"
  20         "net"
  21         "strconv"
  22         "strings"
  23
  24         api "git.fd.io/govpp.git/api"
  25         codec "git.fd.io/govpp.git/codec"
  26 )
  27
  28 // This is a compile-time assertion to ensure that this generated file
  29 // is compatible with the GoVPP api package it is being compiled against.
  30 // A compilation error at this line likely means your copy of the
  31 // GoVPP api package needs to be updated.
  32 const _ = api.GoVppAPIPackageIsVersion2
  33
  34 const (
  35         APIFile    = "dhcp"
  36         APIVersion = "3.0.1"
  37         VersionCrc = 0x96a5f046
  38 )
  39
  40 // AddressFamily defines enum 'address_family'.
  41 type AddressFamily uint32
  42
  43 const (
  44         ADDRESS_IP4 AddressFamily = 0
  45         ADDRESS_IP6 AddressFamily = 1
  46 )
  47
  48 var (
  49         AddressFamily_name = map[uint32]string{
  50                 0: "ADDRESS_IP4",
  51                 1: "ADDRESS_IP6",
  52         }
  53         AddressFamily_value = map[string]uint32{
  54                 "ADDRESS_IP4": 0,
  55                 "ADDRESS_IP6": 1,
  56         }
  57 )
  58
  59 func (x AddressFamily) String() string {
  60         s, ok := AddressFamily_name[uint32(x)]
  61         if ok {
  62                 return s
  63         }
  64         return "AddressFamily(" + strconv.Itoa(int(x)) + ")"
  65 }
  66
  67 // DHCPClientState defines enum 'dhcp_client_state'.
  68 type DHCPClientState uint32
  69
  70 const (
  71         DHCP_CLIENT_STATE_API_DISCOVER DHCPClientState = 1
  72         DHCP_CLIENT_STATE_API_REQUEST  DHCPClientState = 2
  73         DHCP_CLIENT_STATE_API_BOUND    DHCPClientState = 3
  74 )
  75
  76 var (
  77         DHCPClientState_name = map[uint32]string{
  78                 1: "DHCP_CLIENT_STATE_API_DISCOVER",
  79                 2: "DHCP_CLIENT_STATE_API_REQUEST",
  80                 3: "DHCP_CLIENT_STATE_API_BOUND",
  81         }
  82         DHCPClientState_value = map[string]uint32{
  83                 "DHCP_CLIENT_STATE_API_DISCOVER": 1,
  84                 "DHCP_CLIENT_STATE_API_REQUEST":  2,
  85                 "DHCP_CLIENT_STATE_API_BOUND":    3,
  86         }
  87 )
  88
  89 func (x DHCPClientState) String() string {
  90         s, ok := DHCPClientState_name[uint32(x)]
  91         if ok {
  92                 return s
  93         }
  94         return "DHCPClientState(" + strconv.Itoa(int(x)) + ")"
  95 }
  96
  97 // Dhcpv6MsgType defines enum 'dhcpv6_msg_type'.
  98 type Dhcpv6MsgType uint32
  99
 100 const (
 101         DHCPV6_MSG_API_SOLICIT             Dhcpv6MsgType = 1
 102         DHCPV6_MSG_API_ADVERTISE           Dhcpv6MsgType = 2
 103         DHCPV6_MSG_API_REQUEST             Dhcpv6MsgType = 3
 104         DHCPV6_MSG_API_CONFIRM             Dhcpv6MsgType = 4
 105         DHCPV6_MSG_API_RENEW               Dhcpv6MsgType = 5
 106         DHCPV6_MSG_API_REBIND              Dhcpv6MsgType = 6
 107         DHCPV6_MSG_API_REPLY               Dhcpv6MsgType = 7
 108         DHCPV6_MSG_API_RELEASE             Dhcpv6MsgType = 8
 109         DHCPV6_MSG_API_DECLINE             Dhcpv6MsgType = 9
 110         DHCPV6_MSG_API_RECONFIGURE         Dhcpv6MsgType = 10
 111         DHCPV6_MSG_API_INFORMATION_REQUEST Dhcpv6MsgType = 11
 112         DHCPV6_MSG_API_RELAY_FORW          Dhcpv6MsgType = 12
 113         DHCPV6_MSG_API_RELAY_REPL          Dhcpv6MsgType = 13
 114 )
 115
 116 var (
 117         Dhcpv6MsgType_name = map[uint32]string{
 118                 1:  "DHCPV6_MSG_API_SOLICIT",
 119                 2:  "DHCPV6_MSG_API_ADVERTISE",
 120                 3:  "DHCPV6_MSG_API_REQUEST",
 121                 4:  "DHCPV6_MSG_API_CONFIRM",
 122                 5:  "DHCPV6_MSG_API_RENEW",
 123                 6:  "DHCPV6_MSG_API_REBIND",
 124                 7:  "DHCPV6_MSG_API_REPLY",
 125                 8:  "DHCPV6_MSG_API_RELEASE",
 126                 9:  "DHCPV6_MSG_API_DECLINE",
 127                 10: "DHCPV6_MSG_API_RECONFIGURE",
 128                 11: "DHCPV6_MSG_API_INFORMATION_REQUEST",
 129                 12: "DHCPV6_MSG_API_RELAY_FORW",
 130                 13: "DHCPV6_MSG_API_RELAY_REPL",
 131         }
 132         Dhcpv6MsgType_value = map[string]uint32{
 133                 "DHCPV6_MSG_API_SOLICIT":             1,
 134                 "DHCPV6_MSG_API_ADVERTISE":           2,
 135                 "DHCPV6_MSG_API_REQUEST":             3,
 136                 "DHCPV6_MSG_API_CONFIRM":             4,
 137                 "DHCPV6_MSG_API_RENEW":               5,
 138                 "DHCPV6_MSG_API_REBIND":              6,
 139                 "DHCPV6_MSG_API_REPLY":               7,
 140                 "DHCPV6_MSG_API_RELEASE":             8,
 141                 "DHCPV6_MSG_API_DECLINE":             9,
 142                 "DHCPV6_MSG_API_RECONFIGURE":         10,
 143                 "DHCPV6_MSG_API_INFORMATION_REQUEST": 11,
 144                 "DHCPV6_MSG_API_RELAY_FORW":          12,
 145                 "DHCPV6_MSG_API_RELAY_REPL":          13,
 146         }
 147 )
 148
 149 func (x Dhcpv6MsgType) String() string {
 150         s, ok := Dhcpv6MsgType_name[uint32(x)]
 151         if ok {
 152                 return s
 153         }
 154         return "Dhcpv6MsgType(" + strconv.Itoa(int(x)) + ")"
 155 }
 156
 157 // IfStatusFlags defines enum 'if_status_flags'.
 158 type IfStatusFlags uint32
 159
 160 const (
 161         IF_STATUS_API_FLAG_ADMIN_UP IfStatusFlags = 1
 162         IF_STATUS_API_FLAG_LINK_UP  IfStatusFlags = 2
 163 )
 164
 165 var (
 166         IfStatusFlags_name = map[uint32]string{
 167                 1: "IF_STATUS_API_FLAG_ADMIN_UP",
 168                 2: "IF_STATUS_API_FLAG_LINK_UP",
 169         }
 170         IfStatusFlags_value = map[string]uint32{
 171                 "IF_STATUS_API_FLAG_ADMIN_UP": 1,
 172                 "IF_STATUS_API_FLAG_LINK_UP":  2,
 173         }
 174 )
 175
 176 func (x IfStatusFlags) String() string {
 177         s, ok := IfStatusFlags_name[uint32(x)]
 178         if ok {
 179                 return s
 180         }
 181         str := func(n uint32) string {
 182                 s, ok := IfStatusFlags_name[uint32(n)]
 183                 if ok {
 184                         return s
 185                 }
 186                 return "IfStatusFlags(" + strconv.Itoa(int(n)) + ")"
 187         }
 188         for i := uint32(0); i <= 32; i++ {
 189                 val := uint32(x)
 190                 if val&(1<<i) != 0 {
 191                         if s != "" {
 192                                 s += "|"
 193                         }
 194                         s += str(1 << i)
 195                 }
 196         }
 197         if s == "" {
 198                 return str(uint32(x))
 199         }
 200         return s
 201 }
 202
 203 // IfType defines enum 'if_type'.
 204 type IfType uint32
 205
 206 const (
 207         IF_API_TYPE_HARDWARE IfType = 1
 208         IF_API_TYPE_SUB      IfType = 2
 209         IF_API_TYPE_P2P      IfType = 3
 210         IF_API_TYPE_PIPE     IfType = 4
 211 )
 212
 213 var (
 214         IfType_name = map[uint32]string{
 215                 1: "IF_API_TYPE_HARDWARE",
 216                 2: "IF_API_TYPE_SUB",
 217                 3: "IF_API_TYPE_P2P",
 218                 4: "IF_API_TYPE_PIPE",
 219         }
 220         IfType_value = map[string]uint32{
 221                 "IF_API_TYPE_HARDWARE": 1,
 222                 "IF_API_TYPE_SUB":      2,
 223                 "IF_API_TYPE_P2P":      3,
 224                 "IF_API_TYPE_PIPE":     4,
 225         }
 226 )
 227
 228 func (x IfType) String() string {
 229         s, ok := IfType_name[uint32(x)]
 230         if ok {
 231                 return s
 232         }
 233         return "IfType(" + strconv.Itoa(int(x)) + ")"
 234 }
 235
 236 // IPDscp defines enum 'ip_dscp'.
 237 type IPDscp uint8
 238
 239 const (
 240         IP_API_DSCP_CS0  IPDscp = 0
 241         IP_API_DSCP_CS1  IPDscp = 8
 242         IP_API_DSCP_AF11 IPDscp = 10
 243         IP_API_DSCP_AF12 IPDscp = 12
 244         IP_API_DSCP_AF13 IPDscp = 14
 245         IP_API_DSCP_CS2  IPDscp = 16
 246         IP_API_DSCP_AF21 IPDscp = 18
 247         IP_API_DSCP_AF22 IPDscp = 20
 248         IP_API_DSCP_AF23 IPDscp = 22
 249         IP_API_DSCP_CS3  IPDscp = 24
 250         IP_API_DSCP_AF31 IPDscp = 26
 251         IP_API_DSCP_AF32 IPDscp = 28
 252         IP_API_DSCP_AF33 IPDscp = 30
 253         IP_API_DSCP_CS4  IPDscp = 32
 254         IP_API_DSCP_AF41 IPDscp = 34
 255         IP_API_DSCP_AF42 IPDscp = 36
 256         IP_API_DSCP_AF43 IPDscp = 38
 257         IP_API_DSCP_CS5  IPDscp = 40
 258         IP_API_DSCP_EF   IPDscp = 46
 259         IP_API_DSCP_CS6  IPDscp = 48
 260         IP_API_DSCP_CS7  IPDscp = 50
 261 )
 262
 263 var (
 264         IPDscp_name = map[uint8]string{
 265                 0:  "IP_API_DSCP_CS0",
 266                 8:  "IP_API_DSCP_CS1",
 267                 10: "IP_API_DSCP_AF11",
 268                 12: "IP_API_DSCP_AF12",
 269                 14: "IP_API_DSCP_AF13",
 270                 16: "IP_API_DSCP_CS2",
 271                 18: "IP_API_DSCP_AF21",
 272                 20: "IP_API_DSCP_AF22",
 273                 22: "IP_API_DSCP_AF23",
 274                 24: "IP_API_DSCP_CS3",
 275                 26: "IP_API_DSCP_AF31",
 276                 28: "IP_API_DSCP_AF32",
 277                 30: "IP_API_DSCP_AF33",
 278                 32: "IP_API_DSCP_CS4",
 279                 34: "IP_API_DSCP_AF41",
 280                 36: "IP_API_DSCP_AF42",
 281                 38: "IP_API_DSCP_AF43",
 282                 40: "IP_API_DSCP_CS5",
 283                 46: "IP_API_DSCP_EF",
 284                 48: "IP_API_DSCP_CS6",
 285                 50: "IP_API_DSCP_CS7",
 286         }
 287         IPDscp_value = map[string]uint8{
 288                 "IP_API_DSCP_CS0":  0,
 289                 "IP_API_DSCP_CS1":  8,
 290                 "IP_API_DSCP_AF11": 10,
 291                 "IP_API_DSCP_AF12": 12,
 292                 "IP_API_DSCP_AF13": 14,
 293                 "IP_API_DSCP_CS2":  16,
 294                 "IP_API_DSCP_AF21": 18,
 295                 "IP_API_DSCP_AF22": 20,
 296                 "IP_API_DSCP_AF23": 22,
 297                 "IP_API_DSCP_CS3":  24,
 298                 "IP_API_DSCP_AF31": 26,
 299                 "IP_API_DSCP_AF32": 28,
 300                 "IP_API_DSCP_AF33": 30,
 301                 "IP_API_DSCP_CS4":  32,
 302                 "IP_API_DSCP_AF41": 34,
 303                 "IP_API_DSCP_AF42": 36,
 304                 "IP_API_DSCP_AF43": 38,
 305                 "IP_API_DSCP_CS5":  40,
 306                 "IP_API_DSCP_EF":   46,
 307                 "IP_API_DSCP_CS6":  48,
 308                 "IP_API_DSCP_CS7":  50,
 309         }
 310 )
 311
 312 func (x IPDscp) String() string {
 313         s, ok := IPDscp_name[uint8(x)]
 314         if ok {
 315                 return s
 316         }
 317         return "IPDscp(" + strconv.Itoa(int(x)) + ")"
 318 }
 319
 320 // IPEcn defines enum 'ip_ecn'.
 321 type IPEcn uint8
 322
 323 const (
 324         IP_API_ECN_NONE IPEcn = 0
 325         IP_API_ECN_ECT0 IPEcn = 1
 326         IP_API_ECN_ECT1 IPEcn = 2
 327         IP_API_ECN_CE   IPEcn = 3
 328 )
 329
 330 var (
 331         IPEcn_name = map[uint8]string{
 332                 0: "IP_API_ECN_NONE",
 333                 1: "IP_API_ECN_ECT0",
 334                 2: "IP_API_ECN_ECT1",
 335                 3: "IP_API_ECN_CE",
 336         }
 337         IPEcn_value = map[string]uint8{
 338                 "IP_API_ECN_NONE": 0,
 339                 "IP_API_ECN_ECT0": 1,
 340                 "IP_API_ECN_ECT1": 2,
 341                 "IP_API_ECN_CE":   3,
 342         }
 343 )
 344
 345 func (x IPEcn) String() string {
 346         s, ok := IPEcn_name[uint8(x)]
 347         if ok {
 348                 return s
 349         }
 350         return "IPEcn(" + strconv.Itoa(int(x)) + ")"
 351 }
 352
 353 // IPProto defines enum 'ip_proto'.
 354 type IPProto uint32
 355
 356 const (
 357         IP_API_PROTO_HOPOPT   IPProto = 0
 358         IP_API_PROTO_ICMP     IPProto = 1
 359         IP_API_PROTO_IGMP     IPProto = 2
 360         IP_API_PROTO_TCP      IPProto = 6
 361         IP_API_PROTO_UDP      IPProto = 17
 362         IP_API_PROTO_GRE      IPProto = 47
 363         IP_API_PROTO_AH       IPProto = 50
 364         IP_API_PROTO_ESP      IPProto = 51
 365         IP_API_PROTO_EIGRP    IPProto = 88
 366         IP_API_PROTO_OSPF     IPProto = 89
 367         IP_API_PROTO_SCTP     IPProto = 132
 368         IP_API_PROTO_RESERVED IPProto = 255
 369 )
 370
 371 var (
 372         IPProto_name = map[uint32]string{
 373                 0:   "IP_API_PROTO_HOPOPT",
 374                 1:   "IP_API_PROTO_ICMP",
 375                 2:   "IP_API_PROTO_IGMP",
 376                 6:   "IP_API_PROTO_TCP",
 377                 17:  "IP_API_PROTO_UDP",
 378                 47:  "IP_API_PROTO_GRE",
 379                 50:  "IP_API_PROTO_AH",
 380                 51:  "IP_API_PROTO_ESP",
 381                 88:  "IP_API_PROTO_EIGRP",
 382                 89:  "IP_API_PROTO_OSPF",
 383                 132: "IP_API_PROTO_SCTP",
 384                 255: "IP_API_PROTO_RESERVED",
 385         }
 386         IPProto_value = map[string]uint32{
 387                 "IP_API_PROTO_HOPOPT":   0,
 388                 "IP_API_PROTO_ICMP":     1,
 389                 "IP_API_PROTO_IGMP":     2,
 390                 "IP_API_PROTO_TCP":      6,
 391                 "IP_API_PROTO_UDP":      17,
 392                 "IP_API_PROTO_GRE":      47,
 393                 "IP_API_PROTO_AH":       50,
 394                 "IP_API_PROTO_ESP":      51,
 395                 "IP_API_PROTO_EIGRP":    88,
 396                 "IP_API_PROTO_OSPF":     89,
 397                 "IP_API_PROTO_SCTP":     132,
 398                 "IP_API_PROTO_RESERVED": 255,
 399         }
 400 )
 401
 402 func (x IPProto) String() string {
 403         s, ok := IPProto_name[uint32(x)]
 404         if ok {
 405                 return s
 406         }
 407         return "IPProto(" + strconv.Itoa(int(x)) + ")"
 408 }
 409
 410 // LinkDuplex defines enum 'link_duplex'.
 411 type LinkDuplex uint32
 412
 413 const (
 414         LINK_DUPLEX_API_UNKNOWN LinkDuplex = 0
 415         LINK_DUPLEX_API_HALF    LinkDuplex = 1
 416         LINK_DUPLEX_API_FULL    LinkDuplex = 2
 417 )
 418
 419 var (
 420         LinkDuplex_name = map[uint32]string{
 421                 0: "LINK_DUPLEX_API_UNKNOWN",
 422                 1: "LINK_DUPLEX_API_HALF",
 423                 2: "LINK_DUPLEX_API_FULL",
 424         }
 425         LinkDuplex_value = map[string]uint32{
 426                 "LINK_DUPLEX_API_UNKNOWN": 0,
 427                 "LINK_DUPLEX_API_HALF":    1,
 428                 "LINK_DUPLEX_API_FULL":    2,
 429         }
 430 )
 431
 432 func (x LinkDuplex) String() string {
 433         s, ok := LinkDuplex_name[uint32(x)]
 434         if ok {
 435                 return s
 436         }
 437         return "LinkDuplex(" + strconv.Itoa(int(x)) + ")"
 438 }
 439
 440 // MtuProto defines enum 'mtu_proto'.
 441 type MtuProto uint32
 442
 443 const (
 444         MTU_PROTO_API_L3   MtuProto = 1
 445         MTU_PROTO_API_IP4  MtuProto = 2
 446         MTU_PROTO_API_IP6  MtuProto = 3
 447         MTU_PROTO_API_MPLS MtuProto = 4
 448         MTU_PROTO_API_N    MtuProto = 5
 449 )
 450
 451 var (
 452         MtuProto_name = map[uint32]string{
 453                 1: "MTU_PROTO_API_L3",
 454                 2: "MTU_PROTO_API_IP4",
 455                 3: "MTU_PROTO_API_IP6",
 456                 4: "MTU_PROTO_API_MPLS",
 457                 5: "MTU_PROTO_API_N",
 458         }
 459         MtuProto_value = map[string]uint32{
 460                 "MTU_PROTO_API_L3":   1,
 461                 "MTU_PROTO_API_IP4":  2,
 462                 "MTU_PROTO_API_IP6":  3,
 463                 "MTU_PROTO_API_MPLS": 4,
 464                 "MTU_PROTO_API_N":    5,
 465         }
 466 )
 467
 468 func (x MtuProto) String() string {
 469         s, ok := MtuProto_name[uint32(x)]
 470         if ok {
 471                 return s
 472         }
 473         return "MtuProto(" + strconv.Itoa(int(x)) + ")"
 474 }
 475
 476 // RxMode defines enum 'rx_mode'.
 477 type RxMode uint32
 478
 479 const (
 480         RX_MODE_API_UNKNOWN   RxMode = 0
 481         RX_MODE_API_POLLING   RxMode = 1
 482         RX_MODE_API_INTERRUPT RxMode = 2
 483         RX_MODE_API_ADAPTIVE  RxMode = 3
 484         RX_MODE_API_DEFAULT   RxMode = 4
 485 )
 486
 487 var (
 488         RxMode_name = map[uint32]string{
 489                 0: "RX_MODE_API_UNKNOWN",
 490                 1: "RX_MODE_API_POLLING",
 491                 2: "RX_MODE_API_INTERRUPT",
 492                 3: "RX_MODE_API_ADAPTIVE",
 493                 4: "RX_MODE_API_DEFAULT",
 494         }
 495         RxMode_value = map[string]uint32{
 496                 "RX_MODE_API_UNKNOWN":   0,
 497                 "RX_MODE_API_POLLING":   1,
 498                 "RX_MODE_API_INTERRUPT": 2,
 499                 "RX_MODE_API_ADAPTIVE":  3,
 500                 "RX_MODE_API_DEFAULT":   4,
 501         }
 502 )
 503
 504 func (x RxMode) String() string {
 505         s, ok := RxMode_name[uint32(x)]
 506         if ok {
 507                 return s
 508         }
 509         return "RxMode(" + strconv.Itoa(int(x)) + ")"
 510 }
 511
 512 // SubIfFlags defines enum 'sub_if_flags'.
 513 type SubIfFlags uint32
 514
 515 const (
 516         SUB_IF_API_FLAG_NO_TAGS           SubIfFlags = 1
 517         SUB_IF_API_FLAG_ONE_TAG           SubIfFlags = 2
 518         SUB_IF_API_FLAG_TWO_TAGS          SubIfFlags = 4
 519         SUB_IF_API_FLAG_DOT1AD            SubIfFlags = 8
 520         SUB_IF_API_FLAG_EXACT_MATCH       SubIfFlags = 16
 521         SUB_IF_API_FLAG_DEFAULT           SubIfFlags = 32
 522         SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY SubIfFlags = 64
 523         SUB_IF_API_FLAG_INNER_VLAN_ID_ANY SubIfFlags = 128
 524         SUB_IF_API_FLAG_MASK_VNET         SubIfFlags = 254
 525         SUB_IF_API_FLAG_DOT1AH            SubIfFlags = 256
 526 )
 527
 528 var (
 529         SubIfFlags_name = map[uint32]string{
 530                 1:   "SUB_IF_API_FLAG_NO_TAGS",
 531                 2:   "SUB_IF_API_FLAG_ONE_TAG",
 532                 4:   "SUB_IF_API_FLAG_TWO_TAGS",
 533                 8:   "SUB_IF_API_FLAG_DOT1AD",
 534                 16:  "SUB_IF_API_FLAG_EXACT_MATCH",
 535                 32:  "SUB_IF_API_FLAG_DEFAULT",
 536                 64:  "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY",
 537                 128: "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY",
 538                 254: "SUB_IF_API_FLAG_MASK_VNET",
 539                 256: "SUB_IF_API_FLAG_DOT1AH",
 540         }
 541         SubIfFlags_value = map[string]uint32{
 542                 "SUB_IF_API_FLAG_NO_TAGS":           1,
 543                 "SUB_IF_API_FLAG_ONE_TAG":           2,
 544                 "SUB_IF_API_FLAG_TWO_TAGS":          4,
 545                 "SUB_IF_API_FLAG_DOT1AD":            8,
 546                 "SUB_IF_API_FLAG_EXACT_MATCH":       16,
 547                 "SUB_IF_API_FLAG_DEFAULT":           32,
 548                 "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY": 64,
 549                 "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY": 128,
 550                 "SUB_IF_API_FLAG_MASK_VNET":         254,
 551                 "SUB_IF_API_FLAG_DOT1AH":            256,
 552         }
 553 )
 554
 555 func (x SubIfFlags) String() string {
 556         s, ok := SubIfFlags_name[uint32(x)]
 557         if ok {
 558                 return s
 559         }
 560         str := func(n uint32) string {
 561                 s, ok := SubIfFlags_name[uint32(n)]
 562                 if ok {
 563                         return s
 564                 }
 565                 return "SubIfFlags(" + strconv.Itoa(int(n)) + ")"
 566         }
 567         for i := uint32(0); i <= 32; i++ {
 568                 val := uint32(x)
 569                 if val&(1<<i) != 0 {
 570                         if s != "" {
 571                                 s += "|"
 572                         }
 573                         s += str(1 << i)
 574                 }
 575         }
 576         if s == "" {
 577                 return str(uint32(x))
 578         }
 579         return s
 580 }
 581
 582 // VssType defines enum 'vss_type'.
 583 type VssType uint32
 584
 585 const (
 586         VSS_TYPE_API_ASCII   VssType = 0
 587         VSS_TYPE_API_VPN_ID  VssType = 1
 588         VSS_TYPE_API_INVALID VssType = 123
 589         VSS_TYPE_API_DEFAULT VssType = 255
 590 )
 591
 592 var (
 593         VssType_name = map[uint32]string{
 594                 0:   "VSS_TYPE_API_ASCII",
 595                 1:   "VSS_TYPE_API_VPN_ID",
 596                 123: "VSS_TYPE_API_INVALID",
 597                 255: "VSS_TYPE_API_DEFAULT",
 598         }
 599         VssType_value = map[string]uint32{
 600                 "VSS_TYPE_API_ASCII":   0,
 601                 "VSS_TYPE_API_VPN_ID":  1,
 602                 "VSS_TYPE_API_INVALID": 123,
 603                 "VSS_TYPE_API_DEFAULT": 255,
 604         }
 605 )
 606
 607 func (x VssType) String() string {
 608         s, ok := VssType_name[uint32(x)]
 609         if ok {
 610                 return s
 611         }
 612         return "VssType(" + strconv.Itoa(int(x)) + ")"
 613 }
 614
 615 // AddressWithPrefix defines alias 'address_with_prefix'.
 616 type AddressWithPrefix Prefix
 617
 618 func ParseAddressWithPrefix(s string) (AddressWithPrefix, error) {
 619         prefix, err := ParsePrefix(s)
 620         if err != nil {
 621                 return AddressWithPrefix{}, err
 622         }
 623         return AddressWithPrefix(prefix), nil
 624 }
 625
 626 func (x AddressWithPrefix) String() string {
 627         return Prefix(x).String()
 628 }
 629
 630 func (x *AddressWithPrefix) MarshalText() ([]byte, error) {
 631         return []byte(x.String()), nil
 632 }
 633
 634 func (x *AddressWithPrefix) UnmarshalText(text []byte) error {
 635         prefix, err := ParseAddressWithPrefix(string(text))
 636         if err != nil {
 637                 return err
 638         }
 639         *x = prefix
 640         return nil
 641 }
 642
 643 // InterfaceIndex defines alias 'interface_index'.
 644 type InterfaceIndex uint32
 645
 646 // IP4Address defines alias 'ip4_address'.
 647 type IP4Address [4]uint8
 648
 649 func ParseIP4Address(s string) (IP4Address, error) {
 650         ip := net.ParseIP(s).To4()
 651         if ip == nil {
 652                 return IP4Address{}, fmt.Errorf("invalid IP address: %s", s)
 653         }
 654         var ipaddr IP4Address
 655         copy(ipaddr[:], ip.To4())
 656         return ipaddr, nil
 657 }
 658
 659 func (x IP4Address) ToIP() net.IP {
 660         return net.IP(x[:]).To4()
 661 }
 662
 663 func (x IP4Address) String() string {
 664         return x.ToIP().String()
 665 }
 666
 667 func (x *IP4Address) MarshalText() ([]byte, error) {
 668         return []byte(x.String()), nil
 669 }
 670
 671 func (x *IP4Address) UnmarshalText(text []byte) error {
 672         ipaddr, err := ParseIP4Address(string(text))
 673         if err != nil {
 674                 return err
 675         }
 676         *x = ipaddr
 677         return nil
 678 }
 679
 680 // IP4AddressWithPrefix defines alias 'ip4_address_with_prefix'.
 681 type IP4AddressWithPrefix IP4Prefix
 682
 683 // IP6Address defines alias 'ip6_address'.
 684 type IP6Address [16]uint8
 685
 686 func ParseIP6Address(s string) (IP6Address, error) {
 687         ip := net.ParseIP(s).To16()
 688         if ip == nil {
 689                 return IP6Address{}, fmt.Errorf("invalid IP address: %s", s)
 690         }
 691         var ipaddr IP6Address
 692         copy(ipaddr[:], ip.To16())
 693         return ipaddr, nil
 694 }
 695
 696 func (x IP6Address) ToIP() net.IP {
 697         return net.IP(x[:]).To16()
 698 }
 699
 700 func (x IP6Address) String() string {
 701         return x.ToIP().String()
 702 }
 703
 704 func (x *IP6Address) MarshalText() ([]byte, error) {
 705         return []byte(x.String()), nil
 706 }
 707
 708 func (x *IP6Address) UnmarshalText(text []byte) error {
 709         ipaddr, err := ParseIP6Address(string(text))
 710         if err != nil {
 711                 return err
 712         }
 713         *x = ipaddr
 714         return nil
 715 }
 716
 717 // IP6AddressWithPrefix defines alias 'ip6_address_with_prefix'.
 718 type IP6AddressWithPrefix IP6Prefix
 719
 720 // MacAddress defines alias 'mac_address'.
 721 type MacAddress [6]uint8
 722
 723 func ParseMacAddress(s string) (MacAddress, error) {
 724         var macaddr MacAddress
 725         mac, err := net.ParseMAC(s)
 726         if err != nil {
 727                 return macaddr, err
 728         }
 729         copy(macaddr[:], mac[:])
 730         return macaddr, nil
 731 }
 732
 733 func (x MacAddress) ToMAC() net.HardwareAddr {
 734         return net.HardwareAddr(x[:])
 735 }
 736
 737 func (x MacAddress) String() string {
 738         return x.ToMAC().String()
 739 }
 740
 741 func (x *MacAddress) MarshalText() ([]byte, error) {
 742         return []byte(x.String()), nil
 743 }
 744
 745 func (x *MacAddress) UnmarshalText(text []byte) error {
 746         mac, err := ParseMacAddress(string(text))
 747         if err != nil {
 748                 return err
 749         }
 750         *x = mac
 751         return nil
 752 }
 753
 754 // Address defines type 'address'.
 755 type Address struct {
 756         Af AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 757         Un AddressUnion  `binapi:"address_union,name=un" json:"un,omitempty"`
 758 }
 759
 760 func ParseAddress(s string) (Address, error) {
 761         ip := net.ParseIP(s)
 762         if ip == nil {
 763                 return Address{}, fmt.Errorf("invalid address: %s", s)
 764         }
 765         return AddressFromIP(ip), nil
 766 }
 767
 768 func AddressFromIP(ip net.IP) Address {
 769         var addr Address
 770         if ip.To4() == nil {
 771                 addr.Af = ADDRESS_IP6
 772                 var ip6 IP6Address
 773                 copy(ip6[:], ip.To16())
 774                 addr.Un.SetIP6(ip6)
 775         } else {
 776                 addr.Af = ADDRESS_IP4
 777                 var ip4 IP4Address
 778                 copy(ip4[:], ip.To4())
 779                 addr.Un.SetIP4(ip4)
 780         }
 781         return addr
 782 }
 783
 784 func (x Address) ToIP() net.IP {
 785         if x.Af == ADDRESS_IP6 {
 786                 ip6 := x.Un.GetIP6()
 787                 return net.IP(ip6[:]).To16()
 788         } else {
 789                 ip4 := x.Un.GetIP4()
 790                 return net.IP(ip4[:]).To4()
 791         }
 792 }
 793
 794 func (x Address) String() string {
 795         return x.ToIP().String()
 796 }
 797
 798 func (x *Address) MarshalText() ([]byte, error) {
 799         return []byte(x.String()), nil
 800 }
 801
 802 func (x *Address) UnmarshalText(text []byte) error {
 803         addr, err := ParseAddress(string(text))
 804         if err != nil {
 805                 return err
 806         }
 807         *x = addr
 808         return nil
 809 }
 810
 811 // DHCP6AddressInfo defines type 'dhcp6_address_info'.
 812 type DHCP6AddressInfo struct {
 813         Address       IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 814         ValidTime     uint32     `binapi:"u32,name=valid_time" json:"valid_time,omitempty"`
 815         PreferredTime uint32     `binapi:"u32,name=preferred_time" json:"preferred_time,omitempty"`
 816 }
 817
 818 // DHCP6PdPrefixInfo defines type 'dhcp6_pd_prefix_info'.
 819 type DHCP6PdPrefixInfo struct {
 820         Prefix        IP6Prefix `binapi:"ip6_prefix,name=prefix" json:"prefix,omitempty"`
 821         ValidTime     uint32    `binapi:"u32,name=valid_time" json:"valid_time,omitempty"`
 822         PreferredTime uint32    `binapi:"u32,name=preferred_time" json:"preferred_time,omitempty"`
 823 }
 824
 825 // DHCPClient defines type 'dhcp_client'.
 826 type DHCPClient struct {
 827         SwIfIndex        InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 828         Hostname         string         `binapi:"string[64],name=hostname" json:"hostname,omitempty"`
 829         ID               []byte         `binapi:"u8[64],name=id" json:"id,omitempty"`
 830         WantDHCPEvent    bool           `binapi:"bool,name=want_dhcp_event" json:"want_dhcp_event,omitempty"`
 831         SetBroadcastFlag bool           `binapi:"bool,name=set_broadcast_flag" json:"set_broadcast_flag,omitempty"`
 832         Dscp             IPDscp         `binapi:"ip_dscp,name=dscp" json:"dscp,omitempty"`
 833         PID              uint32         `binapi:"u32,name=pid" json:"pid,omitempty"`
 834 }
 835
 836 // DHCPLease defines type 'dhcp_lease'.
 837 type DHCPLease struct {
 838         SwIfIndex     InterfaceIndex  `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 839         State         DHCPClientState `binapi:"dhcp_client_state,name=state" json:"state,omitempty"`
 840         IsIPv6        bool            `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
 841         Hostname      string          `binapi:"string[64],name=hostname" json:"hostname,omitempty"`
 842         MaskWidth     uint8           `binapi:"u8,name=mask_width" json:"mask_width,omitempty"`
 843         HostAddress   Address         `binapi:"address,name=host_address" json:"host_address,omitempty"`
 844         RouterAddress Address         `binapi:"address,name=router_address" json:"router_address,omitempty"`
 845         HostMac       MacAddress      `binapi:"mac_address,name=host_mac" json:"host_mac,omitempty"`
 846         Count         uint8           `binapi:"u8,name=count" json:"-"`
 847         DomainServer  []DomainServer  `binapi:"domain_server[count],name=domain_server" json:"domain_server,omitempty"`
 848 }
 849
 850 // DHCPServer defines type 'dhcp_server'.
 851 type DHCPServer struct {
 852         ServerVrfID uint32  `binapi:"u32,name=server_vrf_id" json:"server_vrf_id,omitempty"`
 853         DHCPServer  Address `binapi:"address,name=dhcp_server" json:"dhcp_server,omitempty"`
 854 }
 855
 856 // DomainServer defines type 'domain_server'.
 857 type DomainServer struct {
 858         Address Address `binapi:"address,name=address" json:"address,omitempty"`
 859 }
 860
 861 // IP4Prefix defines type 'ip4_prefix'.
 862 type IP4Prefix struct {
 863         Address IP4Address `binapi:"ip4_address,name=address" json:"address,omitempty"`
 864         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 865 }
 866
 867 func ParseIP4Prefix(s string) (prefix IP4Prefix, err error) {
 868         hasPrefix := strings.Contains(s, "/")
 869         if hasPrefix {
 870                 ip, network, err := net.ParseCIDR(s)
 871                 if err != nil {
 872                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 873                 }
 874                 maskSize, _ := network.Mask.Size()
 875                 prefix.Len = byte(maskSize)
 876                 prefix.Address, err = ParseIP4Address(ip.String())
 877                 if err != nil {
 878                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 879                 }
 880         } else {
 881                 ip := net.ParseIP(s)
 882                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 883                 if ip.To4() == nil {
 884                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 885                 }
 886                 prefix.Len = byte(defaultMaskSize)
 887                 prefix.Address, err = ParseIP4Address(ip.String())
 888                 if err != nil {
 889                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 890                 }
 891         }
 892         return prefix, nil
 893 }
 894
 895 func (x IP4Prefix) ToIPNet() *net.IPNet {
 896         mask := net.CIDRMask(int(x.Len), 32)
 897         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 898         return ipnet
 899 }
 900
 901 func (x IP4Prefix) String() string {
 902         ip := x.Address.String()
 903         return ip + "/" + strconv.Itoa(int(x.Len))
 904 }
 905
 906 func (x *IP4Prefix) MarshalText() ([]byte, error) {
 907         return []byte(x.String()), nil
 908 }
 909
 910 func (x *IP4Prefix) UnmarshalText(text []byte) error {
 911         prefix, err := ParseIP4Prefix(string(text))
 912         if err != nil {
 913                 return err
 914         }
 915         *x = prefix
 916         return nil
 917 }
 918
 919 // IP6Prefix defines type 'ip6_prefix'.
 920 type IP6Prefix struct {
 921         Address IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 922         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 923 }
 924
 925 func ParseIP6Prefix(s string) (prefix IP6Prefix, err error) {
 926         hasPrefix := strings.Contains(s, "/")
 927         if hasPrefix {
 928                 ip, network, err := net.ParseCIDR(s)
 929                 if err != nil {
 930                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 931                 }
 932                 maskSize, _ := network.Mask.Size()
 933                 prefix.Len = byte(maskSize)
 934                 prefix.Address, err = ParseIP6Address(ip.String())
 935                 if err != nil {
 936                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 937                 }
 938         } else {
 939                 ip := net.ParseIP(s)
 940                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 941                 if ip.To4() == nil {
 942                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 943                 }
 944                 prefix.Len = byte(defaultMaskSize)
 945                 prefix.Address, err = ParseIP6Address(ip.String())
 946                 if err != nil {
 947                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 948                 }
 949         }
 950         return prefix, nil
 951 }
 952
 953 func (x IP6Prefix) ToIPNet() *net.IPNet {
 954         mask := net.CIDRMask(int(x.Len), 128)
 955         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 956         return ipnet
 957 }
 958
 959 func (x IP6Prefix) String() string {
 960         ip := x.Address.String()
 961         return ip + "/" + strconv.Itoa(int(x.Len))
 962 }
 963
 964 func (x *IP6Prefix) MarshalText() ([]byte, error) {
 965         return []byte(x.String()), nil
 966 }
 967
 968 func (x *IP6Prefix) UnmarshalText(text []byte) error {
 969         prefix, err := ParseIP6Prefix(string(text))
 970         if err != nil {
 971                 return err
 972         }
 973         *x = prefix
 974         return nil
 975 }
 976
 977 // Mprefix defines type 'mprefix'.
 978 type Mprefix struct {
 979         Af               AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 980         GrpAddressLength uint16        `binapi:"u16,name=grp_address_length" json:"grp_address_length,omitempty"`
 981         GrpAddress       AddressUnion  `binapi:"address_union,name=grp_address" json:"grp_address,omitempty"`
 982         SrcAddress       AddressUnion  `binapi:"address_union,name=src_address" json:"src_address,omitempty"`
 983 }
 984
 985 // Prefix defines type 'prefix'.
 986 type Prefix struct {
 987         Address Address `binapi:"address,name=address" json:"address,omitempty"`
 988         Len     uint8   `binapi:"u8,name=len" json:"len,omitempty"`
 989 }
 990
 991 func ParsePrefix(ip string) (prefix Prefix, err error) {
 992         hasPrefix := strings.Contains(ip, "/")
 993         if hasPrefix {
 994                 netIP, network, err := net.ParseCIDR(ip)
 995                 if err != nil {
 996                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 997                 }
 998                 maskSize, _ := network.Mask.Size()
 999                 prefix.Len = byte(maskSize)
1000                 prefix.Address, err = ParseAddress(netIP.String())
1001                 if err != nil {
1002                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
1003                 }
1004         } else {
1005                 netIP := net.ParseIP(ip)
1006                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
1007                 if netIP.To4() == nil {
1008                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
1009                 }
1010                 prefix.Len = byte(defaultMaskSize)
1011                 prefix.Address, err = ParseAddress(netIP.String())
1012                 if err != nil {
1013                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
1014                 }
1015         }
1016         return prefix, nil
1017 }
1018
1019 func (x Prefix) ToIPNet() *net.IPNet {
1020         var mask net.IPMask
1021         if x.Address.Af == ADDRESS_IP4 {
1022                 mask = net.CIDRMask(int(x.Len), 32)
1023         } else {
1024                 mask = net.CIDRMask(int(x.Len), 128)
1025         }
1026         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
1027         return ipnet
1028 }
1029
1030 func (x Prefix) String() string {
1031         ip := x.Address.String()
1032         return ip + "/" + strconv.Itoa(int(x.Len))
1033 }
1034
1035 func (x *Prefix) MarshalText() ([]byte, error) {
1036         return []byte(x.String()), nil
1037 }
1038
1039 func (x *Prefix) UnmarshalText(text []byte) error {
1040         prefix, err := ParsePrefix(string(text))
1041         if err != nil {
1042                 return err
1043         }
1044         *x = prefix
1045         return nil
1046 }
1047
1048 // PrefixMatcher defines type 'prefix_matcher'.
1049 type PrefixMatcher struct {
1050         Le uint8 `binapi:"u8,name=le" json:"le,omitempty"`
1051         Ge uint8 `binapi:"u8,name=ge" json:"ge,omitempty"`
1052 }
1053
1054 // AddressUnion defines union 'address_union'.
1055 type AddressUnion struct {
1056         // AddressUnion can be one of:
1057         // - IP4 *IP4Address
1058         // - IP6 *IP6Address
1059         XXX_UnionData [16]byte
1060 }
1061
1062 func AddressUnionIP4(a IP4Address) (u AddressUnion) {
1063         u.SetIP4(a)
1064         return
1065 }
1066 func (u *AddressUnion) SetIP4(a IP4Address) {
1067         buf := codec.NewBuffer(u.XXX_UnionData[:])
1068         buf.EncodeBytes(a[:], 4)
1069 }
1070 func (u *AddressUnion) GetIP4() (a IP4Address) {
1071         buf := codec.NewBuffer(u.XXX_UnionData[:])
1072         copy(a[:], buf.DecodeBytes(4))
1073         return
1074 }
1075
1076 func AddressUnionIP6(a IP6Address) (u AddressUnion) {
1077         u.SetIP6(a)
1078         return
1079 }
1080 func (u *AddressUnion) SetIP6(a IP6Address) {
1081         buf := codec.NewBuffer(u.XXX_UnionData[:])
1082         buf.EncodeBytes(a[:], 16)
1083 }
1084 func (u *AddressUnion) GetIP6() (a IP6Address) {
1085         buf := codec.NewBuffer(u.XXX_UnionData[:])
1086         copy(a[:], buf.DecodeBytes(16))
1087         return
1088 }
1089
1090 // DHCP6ClientsEnableDisable defines message 'dhcp6_clients_enable_disable'.
1091 type DHCP6ClientsEnableDisable struct {
1092         Enable bool `binapi:"bool,name=enable" json:"enable,omitempty"`
1093 }
1094
1095 func (m *DHCP6ClientsEnableDisable) Reset()               { *m = DHCP6ClientsEnableDisable{} }
1096 func (*DHCP6ClientsEnableDisable) GetMessageName() string { return "dhcp6_clients_enable_disable" }
1097 func (*DHCP6ClientsEnableDisable) GetCrcString() string   { return "b3e225d2" }
1098 func (*DHCP6ClientsEnableDisable) GetMessageType() api.MessageType {
1099         return api.RequestMessage
1100 }
1101
1102 func (m *DHCP6ClientsEnableDisable) Size() (size int) {
1103         if m == nil {
1104                 return 0
1105         }
1106         size += 1 // m.Enable
1107         return size
1108 }
1109 func (m *DHCP6ClientsEnableDisable) Marshal(b []byte) ([]byte, error) {
1110         if b == nil {
1111                 b = make([]byte, m.Size())
1112         }
1113         buf := codec.NewBuffer(b)
1114         buf.EncodeBool(m.Enable)
1115         return buf.Bytes(), nil
1116 }
1117 func (m *DHCP6ClientsEnableDisable) Unmarshal(b []byte) error {
1118         buf := codec.NewBuffer(b)
1119         m.Enable = buf.DecodeBool()
1120         return nil
1121 }
1122
1123 // DHCP6ClientsEnableDisableReply defines message 'dhcp6_clients_enable_disable_reply'.
1124 type DHCP6ClientsEnableDisableReply struct {
1125         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1126 }
1127
1128 func (m *DHCP6ClientsEnableDisableReply) Reset() { *m = DHCP6ClientsEnableDisableReply{} }
1129 func (*DHCP6ClientsEnableDisableReply) GetMessageName() string {
1130         return "dhcp6_clients_enable_disable_reply"
1131 }
1132 func (*DHCP6ClientsEnableDisableReply) GetCrcString() string { return "e8d4e804" }
1133 func (*DHCP6ClientsEnableDisableReply) GetMessageType() api.MessageType {
1134         return api.ReplyMessage
1135 }
1136
1137 func (m *DHCP6ClientsEnableDisableReply) Size() (size int) {
1138         if m == nil {
1139                 return 0
1140         }
1141         size += 4 // m.Retval
1142         return size
1143 }
1144 func (m *DHCP6ClientsEnableDisableReply) Marshal(b []byte) ([]byte, error) {
1145         if b == nil {
1146                 b = make([]byte, m.Size())
1147         }
1148         buf := codec.NewBuffer(b)
1149         buf.EncodeInt32(m.Retval)
1150         return buf.Bytes(), nil
1151 }
1152 func (m *DHCP6ClientsEnableDisableReply) Unmarshal(b []byte) error {
1153         buf := codec.NewBuffer(b)
1154         m.Retval = buf.DecodeInt32()
1155         return nil
1156 }
1157
1158 // DHCP6DuidLlSet defines message 'dhcp6_duid_ll_set'.
1159 type DHCP6DuidLlSet struct {
1160         DuidLl []byte `binapi:"u8[10],name=duid_ll" json:"duid_ll,omitempty"`
1161 }
1162
1163 func (m *DHCP6DuidLlSet) Reset()               { *m = DHCP6DuidLlSet{} }
1164 func (*DHCP6DuidLlSet) GetMessageName() string { return "dhcp6_duid_ll_set" }
1165 func (*DHCP6DuidLlSet) GetCrcString() string   { return "0f6ca323" }
1166 func (*DHCP6DuidLlSet) GetMessageType() api.MessageType {
1167         return api.RequestMessage
1168 }
1169
1170 func (m *DHCP6DuidLlSet) Size() (size int) {
1171         if m == nil {
1172                 return 0
1173         }
1174         size += 1 * 10 // m.DuidLl
1175         return size
1176 }
1177 func (m *DHCP6DuidLlSet) Marshal(b []byte) ([]byte, error) {
1178         if b == nil {
1179                 b = make([]byte, m.Size())
1180         }
1181         buf := codec.NewBuffer(b)
1182         buf.EncodeBytes(m.DuidLl, 10)
1183         return buf.Bytes(), nil
1184 }
1185 func (m *DHCP6DuidLlSet) Unmarshal(b []byte) error {
1186         buf := codec.NewBuffer(b)
1187         m.DuidLl = make([]byte, 10)
1188         copy(m.DuidLl, buf.DecodeBytes(len(m.DuidLl)))
1189         return nil
1190 }
1191
1192 // DHCP6DuidLlSetReply defines message 'dhcp6_duid_ll_set_reply'.
1193 type DHCP6DuidLlSetReply struct {
1194         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1195 }
1196
1197 func (m *DHCP6DuidLlSetReply) Reset()               { *m = DHCP6DuidLlSetReply{} }
1198 func (*DHCP6DuidLlSetReply) GetMessageName() string { return "dhcp6_duid_ll_set_reply" }
1199 func (*DHCP6DuidLlSetReply) GetCrcString() string   { return "e8d4e804" }
1200 func (*DHCP6DuidLlSetReply) GetMessageType() api.MessageType {
1201         return api.ReplyMessage
1202 }
1203
1204 func (m *DHCP6DuidLlSetReply) Size() (size int) {
1205         if m == nil {
1206                 return 0
1207         }
1208         size += 4 // m.Retval
1209         return size
1210 }
1211 func (m *DHCP6DuidLlSetReply) Marshal(b []byte) ([]byte, error) {
1212         if b == nil {
1213                 b = make([]byte, m.Size())
1214         }
1215         buf := codec.NewBuffer(b)
1216         buf.EncodeInt32(m.Retval)
1217         return buf.Bytes(), nil
1218 }
1219 func (m *DHCP6DuidLlSetReply) Unmarshal(b []byte) error {
1220         buf := codec.NewBuffer(b)
1221         m.Retval = buf.DecodeInt32()
1222         return nil
1223 }
1224
1225 // DHCP6PdReplyEvent defines message 'dhcp6_pd_reply_event'.
1226 type DHCP6PdReplyEvent struct {
1227         PID             uint32              `binapi:"u32,name=pid" json:"pid,omitempty"`
1228         SwIfIndex       InterfaceIndex      `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1229         ServerIndex     uint32              `binapi:"u32,name=server_index" json:"server_index,omitempty"`
1230         MsgType         Dhcpv6MsgType       `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
1231         T1              uint32              `binapi:"u32,name=T1" json:"T1,omitempty"`
1232         T2              uint32              `binapi:"u32,name=T2" json:"T2,omitempty"`
1233         InnerStatusCode uint16              `binapi:"u16,name=inner_status_code" json:"inner_status_code,omitempty"`
1234         StatusCode      uint16              `binapi:"u16,name=status_code" json:"status_code,omitempty"`
1235         Preference      uint8               `binapi:"u8,name=preference" json:"preference,omitempty"`
1236         NPrefixes       uint32              `binapi:"u32,name=n_prefixes" json:"-"`
1237         Prefixes        []DHCP6PdPrefixInfo `binapi:"dhcp6_pd_prefix_info[n_prefixes],name=prefixes" json:"prefixes,omitempty"`
1238 }
1239
1240 func (m *DHCP6PdReplyEvent) Reset()               { *m = DHCP6PdReplyEvent{} }
1241 func (*DHCP6PdReplyEvent) GetMessageName() string { return "dhcp6_pd_reply_event" }
1242 func (*DHCP6PdReplyEvent) GetCrcString() string   { return "cb3e462b" }
1243 func (*DHCP6PdReplyEvent) GetMessageType() api.MessageType {
1244         return api.EventMessage
1245 }
1246
1247 func (m *DHCP6PdReplyEvent) Size() (size int) {
1248         if m == nil {
1249                 return 0
1250         }
1251         size += 4 // m.PID
1252         size += 4 // m.SwIfIndex
1253         size += 4 // m.ServerIndex
1254         size += 4 // m.MsgType
1255         size += 4 // m.T1
1256         size += 4 // m.T2
1257         size += 2 // m.InnerStatusCode
1258         size += 2 // m.StatusCode
1259         size += 1 // m.Preference
1260         size += 4 // m.NPrefixes
1261         for j1 := 0; j1 < len(m.Prefixes); j1++ {
1262                 var s1 DHCP6PdPrefixInfo
1263                 _ = s1
1264                 if j1 < len(m.Prefixes) {
1265                         s1 = m.Prefixes[j1]
1266                 }
1267                 size += 1 * 16 // s1.Prefix.Address
1268                 size += 1      // s1.Prefix.Len
1269                 size += 4      // s1.ValidTime
1270                 size += 4      // s1.PreferredTime
1271         }
1272         return size
1273 }
1274 func (m *DHCP6PdReplyEvent) Marshal(b []byte) ([]byte, error) {
1275         if b == nil {
1276                 b = make([]byte, m.Size())
1277         }
1278         buf := codec.NewBuffer(b)
1279         buf.EncodeUint32(m.PID)
1280         buf.EncodeUint32(uint32(m.SwIfIndex))
1281         buf.EncodeUint32(m.ServerIndex)
1282         buf.EncodeUint32(uint32(m.MsgType))
1283         buf.EncodeUint32(m.T1)
1284         buf.EncodeUint32(m.T2)
1285         buf.EncodeUint16(m.InnerStatusCode)
1286         buf.EncodeUint16(m.StatusCode)
1287         buf.EncodeUint8(m.Preference)
1288         buf.EncodeUint32(uint32(len(m.Prefixes)))
1289         for j0 := 0; j0 < len(m.Prefixes); j0++ {
1290                 var v0 DHCP6PdPrefixInfo // Prefixes
1291                 if j0 < len(m.Prefixes) {
1292                         v0 = m.Prefixes[j0]
1293                 }
1294                 buf.EncodeBytes(v0.Prefix.Address[:], 16)
1295                 buf.EncodeUint8(v0.Prefix.Len)
1296                 buf.EncodeUint32(v0.ValidTime)
1297                 buf.EncodeUint32(v0.PreferredTime)
1298         }
1299         return buf.Bytes(), nil
1300 }
1301 func (m *DHCP6PdReplyEvent) Unmarshal(b []byte) error {
1302         buf := codec.NewBuffer(b)
1303         m.PID = buf.DecodeUint32()
1304         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1305         m.ServerIndex = buf.DecodeUint32()
1306         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
1307         m.T1 = buf.DecodeUint32()
1308         m.T2 = buf.DecodeUint32()
1309         m.InnerStatusCode = buf.DecodeUint16()
1310         m.StatusCode = buf.DecodeUint16()
1311         m.Preference = buf.DecodeUint8()
1312         m.NPrefixes = buf.DecodeUint32()
1313         m.Prefixes = make([]DHCP6PdPrefixInfo, m.NPrefixes)
1314         for j0 := 0; j0 < len(m.Prefixes); j0++ {
1315                 copy(m.Prefixes[j0].Prefix.Address[:], buf.DecodeBytes(16))
1316                 m.Prefixes[j0].Prefix.Len = buf.DecodeUint8()
1317                 m.Prefixes[j0].ValidTime = buf.DecodeUint32()
1318                 m.Prefixes[j0].PreferredTime = buf.DecodeUint32()
1319         }
1320         return nil
1321 }
1322
1323 // DHCP6PdSendClientMessage defines message 'dhcp6_pd_send_client_message'.
1324 type DHCP6PdSendClientMessage struct {
1325         SwIfIndex   InterfaceIndex      `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1326         ServerIndex uint32              `binapi:"u32,name=server_index" json:"server_index,omitempty"`
1327         Irt         uint32              `binapi:"u32,name=irt" json:"irt,omitempty"`
1328         Mrt         uint32              `binapi:"u32,name=mrt" json:"mrt,omitempty"`
1329         Mrc         uint32              `binapi:"u32,name=mrc" json:"mrc,omitempty"`
1330         Mrd         uint32              `binapi:"u32,name=mrd" json:"mrd,omitempty"`
1331         Stop        bool                `binapi:"bool,name=stop" json:"stop,omitempty"`
1332         MsgType     Dhcpv6MsgType       `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
1333         T1          uint32              `binapi:"u32,name=T1" json:"T1,omitempty"`
1334         T2          uint32              `binapi:"u32,name=T2" json:"T2,omitempty"`
1335         NPrefixes   uint32              `binapi:"u32,name=n_prefixes" json:"-"`
1336         Prefixes    []DHCP6PdPrefixInfo `binapi:"dhcp6_pd_prefix_info[n_prefixes],name=prefixes" json:"prefixes,omitempty"`
1337 }
1338
1339 func (m *DHCP6PdSendClientMessage) Reset()               { *m = DHCP6PdSendClientMessage{} }
1340 func (*DHCP6PdSendClientMessage) GetMessageName() string { return "dhcp6_pd_send_client_message" }
1341 func (*DHCP6PdSendClientMessage) GetCrcString() string   { return "064badb8" }
1342 func (*DHCP6PdSendClientMessage) GetMessageType() api.MessageType {
1343         return api.RequestMessage
1344 }
1345
1346 func (m *DHCP6PdSendClientMessage) Size() (size int) {
1347         if m == nil {
1348                 return 0
1349         }
1350         size += 4 // m.SwIfIndex
1351         size += 4 // m.ServerIndex
1352         size += 4 // m.Irt
1353         size += 4 // m.Mrt
1354         size += 4 // m.Mrc
1355         size += 4 // m.Mrd
1356         size += 1 // m.Stop
1357         size += 4 // m.MsgType
1358         size += 4 // m.T1
1359         size += 4 // m.T2
1360         size += 4 // m.NPrefixes
1361         for j1 := 0; j1 < len(m.Prefixes); j1++ {
1362                 var s1 DHCP6PdPrefixInfo
1363                 _ = s1
1364                 if j1 < len(m.Prefixes) {
1365                         s1 = m.Prefixes[j1]
1366                 }
1367                 size += 1 * 16 // s1.Prefix.Address
1368                 size += 1      // s1.Prefix.Len
1369                 size += 4      // s1.ValidTime
1370                 size += 4      // s1.PreferredTime
1371         }
1372         return size
1373 }
1374 func (m *DHCP6PdSendClientMessage) Marshal(b []byte) ([]byte, error) {
1375         if b == nil {
1376                 b = make([]byte, m.Size())
1377         }
1378         buf := codec.NewBuffer(b)
1379         buf.EncodeUint32(uint32(m.SwIfIndex))
1380         buf.EncodeUint32(m.ServerIndex)
1381         buf.EncodeUint32(m.Irt)
1382         buf.EncodeUint32(m.Mrt)
1383         buf.EncodeUint32(m.Mrc)
1384         buf.EncodeUint32(m.Mrd)
1385         buf.EncodeBool(m.Stop)
1386         buf.EncodeUint32(uint32(m.MsgType))
1387         buf.EncodeUint32(m.T1)
1388         buf.EncodeUint32(m.T2)
1389         buf.EncodeUint32(uint32(len(m.Prefixes)))
1390         for j0 := 0; j0 < len(m.Prefixes); j0++ {
1391                 var v0 DHCP6PdPrefixInfo // Prefixes
1392                 if j0 < len(m.Prefixes) {
1393                         v0 = m.Prefixes[j0]
1394                 }
1395                 buf.EncodeBytes(v0.Prefix.Address[:], 16)
1396                 buf.EncodeUint8(v0.Prefix.Len)
1397                 buf.EncodeUint32(v0.ValidTime)
1398                 buf.EncodeUint32(v0.PreferredTime)
1399         }
1400         return buf.Bytes(), nil
1401 }
1402 func (m *DHCP6PdSendClientMessage) Unmarshal(b []byte) error {
1403         buf := codec.NewBuffer(b)
1404         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1405         m.ServerIndex = buf.DecodeUint32()
1406         m.Irt = buf.DecodeUint32()
1407         m.Mrt = buf.DecodeUint32()
1408         m.Mrc = buf.DecodeUint32()
1409         m.Mrd = buf.DecodeUint32()
1410         m.Stop = buf.DecodeBool()
1411         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
1412         m.T1 = buf.DecodeUint32()
1413         m.T2 = buf.DecodeUint32()
1414         m.NPrefixes = buf.DecodeUint32()
1415         m.Prefixes = make([]DHCP6PdPrefixInfo, m.NPrefixes)
1416         for j0 := 0; j0 < len(m.Prefixes); j0++ {
1417                 copy(m.Prefixes[j0].Prefix.Address[:], buf.DecodeBytes(16))
1418                 m.Prefixes[j0].Prefix.Len = buf.DecodeUint8()
1419                 m.Prefixes[j0].ValidTime = buf.DecodeUint32()
1420                 m.Prefixes[j0].PreferredTime = buf.DecodeUint32()
1421         }
1422         return nil
1423 }
1424
1425 // DHCP6PdSendClientMessageReply defines message 'dhcp6_pd_send_client_message_reply'.
1426 type DHCP6PdSendClientMessageReply struct {
1427         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1428 }
1429
1430 func (m *DHCP6PdSendClientMessageReply) Reset() { *m = DHCP6PdSendClientMessageReply{} }
1431 func (*DHCP6PdSendClientMessageReply) GetMessageName() string {
1432         return "dhcp6_pd_send_client_message_reply"
1433 }
1434 func (*DHCP6PdSendClientMessageReply) GetCrcString() string { return "e8d4e804" }
1435 func (*DHCP6PdSendClientMessageReply) GetMessageType() api.MessageType {
1436         return api.ReplyMessage
1437 }
1438
1439 func (m *DHCP6PdSendClientMessageReply) Size() (size int) {
1440         if m == nil {
1441                 return 0
1442         }
1443         size += 4 // m.Retval
1444         return size
1445 }
1446 func (m *DHCP6PdSendClientMessageReply) Marshal(b []byte) ([]byte, error) {
1447         if b == nil {
1448                 b = make([]byte, m.Size())
1449         }
1450         buf := codec.NewBuffer(b)
1451         buf.EncodeInt32(m.Retval)
1452         return buf.Bytes(), nil
1453 }
1454 func (m *DHCP6PdSendClientMessageReply) Unmarshal(b []byte) error {
1455         buf := codec.NewBuffer(b)
1456         m.Retval = buf.DecodeInt32()
1457         return nil
1458 }
1459
1460 // DHCP6ReplyEvent defines message 'dhcp6_reply_event'.
1461 type DHCP6ReplyEvent struct {
1462         PID             uint32             `binapi:"u32,name=pid" json:"pid,omitempty"`
1463         SwIfIndex       InterfaceIndex     `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1464         ServerIndex     uint32             `binapi:"u32,name=server_index" json:"server_index,omitempty"`
1465         MsgType         Dhcpv6MsgType      `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
1466         T1              uint32             `binapi:"u32,name=T1" json:"T1,omitempty"`
1467         T2              uint32             `binapi:"u32,name=T2" json:"T2,omitempty"`
1468         InnerStatusCode uint16             `binapi:"u16,name=inner_status_code" json:"inner_status_code,omitempty"`
1469         StatusCode      uint16             `binapi:"u16,name=status_code" json:"status_code,omitempty"`
1470         Preference      uint8              `binapi:"u8,name=preference" json:"preference,omitempty"`
1471         NAddresses      uint32             `binapi:"u32,name=n_addresses" json:"-"`
1472         Addresses       []DHCP6AddressInfo `binapi:"dhcp6_address_info[n_addresses],name=addresses" json:"addresses,omitempty"`
1473 }
1474
1475 func (m *DHCP6ReplyEvent) Reset()               { *m = DHCP6ReplyEvent{} }
1476 func (*DHCP6ReplyEvent) GetMessageName() string { return "dhcp6_reply_event" }
1477 func (*DHCP6ReplyEvent) GetCrcString() string   { return "9f3af9e5" }
1478 func (*DHCP6ReplyEvent) GetMessageType() api.MessageType {
1479         return api.EventMessage
1480 }
1481
1482 func (m *DHCP6ReplyEvent) Size() (size int) {
1483         if m == nil {
1484                 return 0
1485         }
1486         size += 4 // m.PID
1487         size += 4 // m.SwIfIndex
1488         size += 4 // m.ServerIndex
1489         size += 4 // m.MsgType
1490         size += 4 // m.T1
1491         size += 4 // m.T2
1492         size += 2 // m.InnerStatusCode
1493         size += 2 // m.StatusCode
1494         size += 1 // m.Preference
1495         size += 4 // m.NAddresses
1496         for j1 := 0; j1 < len(m.Addresses); j1++ {
1497                 var s1 DHCP6AddressInfo
1498                 _ = s1
1499                 if j1 < len(m.Addresses) {
1500                         s1 = m.Addresses[j1]
1501                 }
1502                 size += 1 * 16 // s1.Address
1503                 size += 4      // s1.ValidTime
1504                 size += 4      // s1.PreferredTime
1505         }
1506         return size
1507 }
1508 func (m *DHCP6ReplyEvent) Marshal(b []byte) ([]byte, error) {
1509         if b == nil {
1510                 b = make([]byte, m.Size())
1511         }
1512         buf := codec.NewBuffer(b)
1513         buf.EncodeUint32(m.PID)
1514         buf.EncodeUint32(uint32(m.SwIfIndex))
1515         buf.EncodeUint32(m.ServerIndex)
1516         buf.EncodeUint32(uint32(m.MsgType))
1517         buf.EncodeUint32(m.T1)
1518         buf.EncodeUint32(m.T2)
1519         buf.EncodeUint16(m.InnerStatusCode)
1520         buf.EncodeUint16(m.StatusCode)
1521         buf.EncodeUint8(m.Preference)
1522         buf.EncodeUint32(uint32(len(m.Addresses)))
1523         for j0 := 0; j0 < len(m.Addresses); j0++ {
1524                 var v0 DHCP6AddressInfo // Addresses
1525                 if j0 < len(m.Addresses) {
1526                         v0 = m.Addresses[j0]
1527                 }
1528                 buf.EncodeBytes(v0.Address[:], 16)
1529                 buf.EncodeUint32(v0.ValidTime)
1530                 buf.EncodeUint32(v0.PreferredTime)
1531         }
1532         return buf.Bytes(), nil
1533 }
1534 func (m *DHCP6ReplyEvent) Unmarshal(b []byte) error {
1535         buf := codec.NewBuffer(b)
1536         m.PID = buf.DecodeUint32()
1537         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1538         m.ServerIndex = buf.DecodeUint32()
1539         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
1540         m.T1 = buf.DecodeUint32()
1541         m.T2 = buf.DecodeUint32()
1542         m.InnerStatusCode = buf.DecodeUint16()
1543         m.StatusCode = buf.DecodeUint16()
1544         m.Preference = buf.DecodeUint8()
1545         m.NAddresses = buf.DecodeUint32()
1546         m.Addresses = make([]DHCP6AddressInfo, m.NAddresses)
1547         for j0 := 0; j0 < len(m.Addresses); j0++ {
1548                 copy(m.Addresses[j0].Address[:], buf.DecodeBytes(16))
1549                 m.Addresses[j0].ValidTime = buf.DecodeUint32()
1550                 m.Addresses[j0].PreferredTime = buf.DecodeUint32()
1551         }
1552         return nil
1553 }
1554
1555 // DHCP6SendClientMessage defines message 'dhcp6_send_client_message'.
1556 type DHCP6SendClientMessage struct {
1557         SwIfIndex   InterfaceIndex     `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1558         ServerIndex uint32             `binapi:"u32,name=server_index" json:"server_index,omitempty"`
1559         Irt         uint32             `binapi:"u32,name=irt" json:"irt,omitempty"`
1560         Mrt         uint32             `binapi:"u32,name=mrt" json:"mrt,omitempty"`
1561         Mrc         uint32             `binapi:"u32,name=mrc" json:"mrc,omitempty"`
1562         Mrd         uint32             `binapi:"u32,name=mrd" json:"mrd,omitempty"`
1563         Stop        bool               `binapi:"bool,name=stop" json:"stop,omitempty"`
1564         MsgType     Dhcpv6MsgType      `binapi:"dhcpv6_msg_type,name=msg_type" json:"msg_type,omitempty"`
1565         T1          uint32             `binapi:"u32,name=T1" json:"T1,omitempty"`
1566         T2          uint32             `binapi:"u32,name=T2" json:"T2,omitempty"`
1567         NAddresses  uint32             `binapi:"u32,name=n_addresses" json:"-"`
1568         Addresses   []DHCP6AddressInfo `binapi:"dhcp6_address_info[n_addresses],name=addresses" json:"addresses,omitempty"`
1569 }
1570
1571 func (m *DHCP6SendClientMessage) Reset()               { *m = DHCP6SendClientMessage{} }
1572 func (*DHCP6SendClientMessage) GetMessageName() string { return "dhcp6_send_client_message" }
1573 func (*DHCP6SendClientMessage) GetCrcString() string   { return "f6f14ef0" }
1574 func (*DHCP6SendClientMessage) GetMessageType() api.MessageType {
1575         return api.RequestMessage
1576 }
1577
1578 func (m *DHCP6SendClientMessage) Size() (size int) {
1579         if m == nil {
1580                 return 0
1581         }
1582         size += 4 // m.SwIfIndex
1583         size += 4 // m.ServerIndex
1584         size += 4 // m.Irt
1585         size += 4 // m.Mrt
1586         size += 4 // m.Mrc
1587         size += 4 // m.Mrd
1588         size += 1 // m.Stop
1589         size += 4 // m.MsgType
1590         size += 4 // m.T1
1591         size += 4 // m.T2
1592         size += 4 // m.NAddresses
1593         for j1 := 0; j1 < len(m.Addresses); j1++ {
1594                 var s1 DHCP6AddressInfo
1595                 _ = s1
1596                 if j1 < len(m.Addresses) {
1597                         s1 = m.Addresses[j1]
1598                 }
1599                 size += 1 * 16 // s1.Address
1600                 size += 4      // s1.ValidTime
1601                 size += 4      // s1.PreferredTime
1602         }
1603         return size
1604 }
1605 func (m *DHCP6SendClientMessage) Marshal(b []byte) ([]byte, error) {
1606         if b == nil {
1607                 b = make([]byte, m.Size())
1608         }
1609         buf := codec.NewBuffer(b)
1610         buf.EncodeUint32(uint32(m.SwIfIndex))
1611         buf.EncodeUint32(m.ServerIndex)
1612         buf.EncodeUint32(m.Irt)
1613         buf.EncodeUint32(m.Mrt)
1614         buf.EncodeUint32(m.Mrc)
1615         buf.EncodeUint32(m.Mrd)
1616         buf.EncodeBool(m.Stop)
1617         buf.EncodeUint32(uint32(m.MsgType))
1618         buf.EncodeUint32(m.T1)
1619         buf.EncodeUint32(m.T2)
1620         buf.EncodeUint32(uint32(len(m.Addresses)))
1621         for j0 := 0; j0 < len(m.Addresses); j0++ {
1622                 var v0 DHCP6AddressInfo // Addresses
1623                 if j0 < len(m.Addresses) {
1624                         v0 = m.Addresses[j0]
1625                 }
1626                 buf.EncodeBytes(v0.Address[:], 16)
1627                 buf.EncodeUint32(v0.ValidTime)
1628                 buf.EncodeUint32(v0.PreferredTime)
1629         }
1630         return buf.Bytes(), nil
1631 }
1632 func (m *DHCP6SendClientMessage) Unmarshal(b []byte) error {
1633         buf := codec.NewBuffer(b)
1634         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1635         m.ServerIndex = buf.DecodeUint32()
1636         m.Irt = buf.DecodeUint32()
1637         m.Mrt = buf.DecodeUint32()
1638         m.Mrc = buf.DecodeUint32()
1639         m.Mrd = buf.DecodeUint32()
1640         m.Stop = buf.DecodeBool()
1641         m.MsgType = Dhcpv6MsgType(buf.DecodeUint32())
1642         m.T1 = buf.DecodeUint32()
1643         m.T2 = buf.DecodeUint32()
1644         m.NAddresses = buf.DecodeUint32()
1645         m.Addresses = make([]DHCP6AddressInfo, m.NAddresses)
1646         for j0 := 0; j0 < len(m.Addresses); j0++ {
1647                 copy(m.Addresses[j0].Address[:], buf.DecodeBytes(16))
1648                 m.Addresses[j0].ValidTime = buf.DecodeUint32()
1649                 m.Addresses[j0].PreferredTime = buf.DecodeUint32()
1650         }
1651         return nil
1652 }
1653
1654 // DHCP6SendClientMessageReply defines message 'dhcp6_send_client_message_reply'.
1655 type DHCP6SendClientMessageReply struct {
1656         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1657 }
1658
1659 func (m *DHCP6SendClientMessageReply) Reset()               { *m = DHCP6SendClientMessageReply{} }
1660 func (*DHCP6SendClientMessageReply) GetMessageName() string { return "dhcp6_send_client_message_reply" }
1661 func (*DHCP6SendClientMessageReply) GetCrcString() string   { return "e8d4e804" }
1662 func (*DHCP6SendClientMessageReply) GetMessageType() api.MessageType {
1663         return api.ReplyMessage
1664 }
1665
1666 func (m *DHCP6SendClientMessageReply) Size() (size int) {
1667         if m == nil {
1668                 return 0
1669         }
1670         size += 4 // m.Retval
1671         return size
1672 }
1673 func (m *DHCP6SendClientMessageReply) Marshal(b []byte) ([]byte, error) {
1674         if b == nil {
1675                 b = make([]byte, m.Size())
1676         }
1677         buf := codec.NewBuffer(b)
1678         buf.EncodeInt32(m.Retval)
1679         return buf.Bytes(), nil
1680 }
1681 func (m *DHCP6SendClientMessageReply) Unmarshal(b []byte) error {
1682         buf := codec.NewBuffer(b)
1683         m.Retval = buf.DecodeInt32()
1684         return nil
1685 }
1686
1687 // DHCPClientConfig defines message 'dhcp_client_config'.
1688 type DHCPClientConfig struct {
1689         IsAdd  bool       `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1690         Client DHCPClient `binapi:"dhcp_client,name=client" json:"client,omitempty"`
1691 }
1692
1693 func (m *DHCPClientConfig) Reset()               { *m = DHCPClientConfig{} }
1694 func (*DHCPClientConfig) GetMessageName() string { return "dhcp_client_config" }
1695 func (*DHCPClientConfig) GetCrcString() string   { return "959b80a3" }
1696 func (*DHCPClientConfig) GetMessageType() api.MessageType {
1697         return api.RequestMessage
1698 }
1699
1700 func (m *DHCPClientConfig) Size() (size int) {
1701         if m == nil {
1702                 return 0
1703         }
1704         size += 1      // m.IsAdd
1705         size += 4      // m.Client.SwIfIndex
1706         size += 64     // m.Client.Hostname
1707         size += 1 * 64 // m.Client.ID
1708         size += 1      // m.Client.WantDHCPEvent
1709         size += 1      // m.Client.SetBroadcastFlag
1710         size += 1      // m.Client.Dscp
1711         size += 4      // m.Client.PID
1712         return size
1713 }
1714 func (m *DHCPClientConfig) Marshal(b []byte) ([]byte, error) {
1715         if b == nil {
1716                 b = make([]byte, m.Size())
1717         }
1718         buf := codec.NewBuffer(b)
1719         buf.EncodeBool(m.IsAdd)
1720         buf.EncodeUint32(uint32(m.Client.SwIfIndex))
1721         buf.EncodeString(m.Client.Hostname, 64)
1722         buf.EncodeBytes(m.Client.ID, 64)
1723         buf.EncodeBool(m.Client.WantDHCPEvent)
1724         buf.EncodeBool(m.Client.SetBroadcastFlag)
1725         buf.EncodeUint8(uint8(m.Client.Dscp))
1726         buf.EncodeUint32(m.Client.PID)
1727         return buf.Bytes(), nil
1728 }
1729 func (m *DHCPClientConfig) Unmarshal(b []byte) error {
1730         buf := codec.NewBuffer(b)
1731         m.IsAdd = buf.DecodeBool()
1732         m.Client.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1733         m.Client.Hostname = buf.DecodeString(64)
1734         m.Client.ID = make([]byte, 64)
1735         copy(m.Client.ID, buf.DecodeBytes(len(m.Client.ID)))
1736         m.Client.WantDHCPEvent = buf.DecodeBool()
1737         m.Client.SetBroadcastFlag = buf.DecodeBool()
1738         m.Client.Dscp = IPDscp(buf.DecodeUint8())
1739         m.Client.PID = buf.DecodeUint32()
1740         return nil
1741 }
1742
1743 // DHCPClientConfigReply defines message 'dhcp_client_config_reply'.
1744 type DHCPClientConfigReply struct {
1745         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1746 }
1747
1748 func (m *DHCPClientConfigReply) Reset()               { *m = DHCPClientConfigReply{} }
1749 func (*DHCPClientConfigReply) GetMessageName() string { return "dhcp_client_config_reply" }
1750 func (*DHCPClientConfigReply) GetCrcString() string   { return "e8d4e804" }
1751 func (*DHCPClientConfigReply) GetMessageType() api.MessageType {
1752         return api.ReplyMessage
1753 }
1754
1755 func (m *DHCPClientConfigReply) Size() (size int) {
1756         if m == nil {
1757                 return 0
1758         }
1759         size += 4 // m.Retval
1760         return size
1761 }
1762 func (m *DHCPClientConfigReply) Marshal(b []byte) ([]byte, error) {
1763         if b == nil {
1764                 b = make([]byte, m.Size())
1765         }
1766         buf := codec.NewBuffer(b)
1767         buf.EncodeInt32(m.Retval)
1768         return buf.Bytes(), nil
1769 }
1770 func (m *DHCPClientConfigReply) Unmarshal(b []byte) error {
1771         buf := codec.NewBuffer(b)
1772         m.Retval = buf.DecodeInt32()
1773         return nil
1774 }
1775
1776 // DHCPClientDetails defines message 'dhcp_client_details'.
1777 type DHCPClientDetails struct {
1778         Client DHCPClient `binapi:"dhcp_client,name=client" json:"client,omitempty"`
1779         Lease  DHCPLease  `binapi:"dhcp_lease,name=lease" json:"lease,omitempty"`
1780 }
1781
1782 func (m *DHCPClientDetails) Reset()               { *m = DHCPClientDetails{} }
1783 func (*DHCPClientDetails) GetMessageName() string { return "dhcp_client_details" }
1784 func (*DHCPClientDetails) GetCrcString() string   { return "acd82f5a" }
1785 func (*DHCPClientDetails) GetMessageType() api.MessageType {
1786         return api.ReplyMessage
1787 }
1788
1789 func (m *DHCPClientDetails) Size() (size int) {
1790         if m == nil {
1791                 return 0
1792         }
1793         size += 4      // m.Client.SwIfIndex
1794         size += 64     // m.Client.Hostname
1795         size += 1 * 64 // m.Client.ID
1796         size += 1      // m.Client.WantDHCPEvent
1797         size += 1      // m.Client.SetBroadcastFlag
1798         size += 1      // m.Client.Dscp
1799         size += 4      // m.Client.PID
1800         size += 4      // m.Lease.SwIfIndex
1801         size += 4      // m.Lease.State
1802         size += 1      // m.Lease.IsIPv6
1803         size += 64     // m.Lease.Hostname
1804         size += 1      // m.Lease.MaskWidth
1805         size += 4      // m.Lease.HostAddress.Af
1806         size += 1 * 16 // m.Lease.HostAddress.Un
1807         size += 4      // m.Lease.RouterAddress.Af
1808         size += 1 * 16 // m.Lease.RouterAddress.Un
1809         size += 1 * 6  // m.Lease.HostMac
1810         size += 1      // m.Lease.Count
1811         for j2 := 0; j2 < len(m.Lease.DomainServer); j2++ {
1812                 var s2 DomainServer
1813                 _ = s2
1814                 if j2 < len(m.Lease.DomainServer) {
1815                         s2 = m.Lease.DomainServer[j2]
1816                 }
1817                 size += 4      // s2.Address.Af
1818                 size += 1 * 16 // s2.Address.Un
1819         }
1820         return size
1821 }
1822 func (m *DHCPClientDetails) Marshal(b []byte) ([]byte, error) {
1823         if b == nil {
1824                 b = make([]byte, m.Size())
1825         }
1826         buf := codec.NewBuffer(b)
1827         buf.EncodeUint32(uint32(m.Client.SwIfIndex))
1828         buf.EncodeString(m.Client.Hostname, 64)
1829         buf.EncodeBytes(m.Client.ID, 64)
1830         buf.EncodeBool(m.Client.WantDHCPEvent)
1831         buf.EncodeBool(m.Client.SetBroadcastFlag)
1832         buf.EncodeUint8(uint8(m.Client.Dscp))
1833         buf.EncodeUint32(m.Client.PID)
1834         buf.EncodeUint32(uint32(m.Lease.SwIfIndex))
1835         buf.EncodeUint32(uint32(m.Lease.State))
1836         buf.EncodeBool(m.Lease.IsIPv6)
1837         buf.EncodeString(m.Lease.Hostname, 64)
1838         buf.EncodeUint8(m.Lease.MaskWidth)
1839         buf.EncodeUint32(uint32(m.Lease.HostAddress.Af))
1840         buf.EncodeBytes(m.Lease.HostAddress.Un.XXX_UnionData[:], 16)
1841         buf.EncodeUint32(uint32(m.Lease.RouterAddress.Af))
1842         buf.EncodeBytes(m.Lease.RouterAddress.Un.XXX_UnionData[:], 16)
1843         buf.EncodeBytes(m.Lease.HostMac[:], 6)
1844         buf.EncodeUint8(uint8(len(m.Lease.DomainServer)))
1845         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1846                 var v1 DomainServer // DomainServer
1847                 if j1 < len(m.Lease.DomainServer) {
1848                         v1 = m.Lease.DomainServer[j1]
1849                 }
1850                 buf.EncodeUint32(uint32(v1.Address.Af))
1851                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
1852         }
1853         return buf.Bytes(), nil
1854 }
1855 func (m *DHCPClientDetails) Unmarshal(b []byte) error {
1856         buf := codec.NewBuffer(b)
1857         m.Client.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1858         m.Client.Hostname = buf.DecodeString(64)
1859         m.Client.ID = make([]byte, 64)
1860         copy(m.Client.ID, buf.DecodeBytes(len(m.Client.ID)))
1861         m.Client.WantDHCPEvent = buf.DecodeBool()
1862         m.Client.SetBroadcastFlag = buf.DecodeBool()
1863         m.Client.Dscp = IPDscp(buf.DecodeUint8())
1864         m.Client.PID = buf.DecodeUint32()
1865         m.Lease.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1866         m.Lease.State = DHCPClientState(buf.DecodeUint32())
1867         m.Lease.IsIPv6 = buf.DecodeBool()
1868         m.Lease.Hostname = buf.DecodeString(64)
1869         m.Lease.MaskWidth = buf.DecodeUint8()
1870         m.Lease.HostAddress.Af = AddressFamily(buf.DecodeUint32())
1871         copy(m.Lease.HostAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1872         m.Lease.RouterAddress.Af = AddressFamily(buf.DecodeUint32())
1873         copy(m.Lease.RouterAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1874         copy(m.Lease.HostMac[:], buf.DecodeBytes(6))
1875         m.Lease.Count = buf.DecodeUint8()
1876         m.Lease.DomainServer = make([]DomainServer, m.Lease.Count)
1877         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1878                 m.Lease.DomainServer[j1].Address.Af = AddressFamily(buf.DecodeUint32())
1879                 copy(m.Lease.DomainServer[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1880         }
1881         return nil
1882 }
1883
1884 // DHCPClientDump defines message 'dhcp_client_dump'.
1885 type DHCPClientDump struct{}
1886
1887 func (m *DHCPClientDump) Reset()               { *m = DHCPClientDump{} }
1888 func (*DHCPClientDump) GetMessageName() string { return "dhcp_client_dump" }
1889 func (*DHCPClientDump) GetCrcString() string   { return "51077d14" }
1890 func (*DHCPClientDump) GetMessageType() api.MessageType {
1891         return api.RequestMessage
1892 }
1893
1894 func (m *DHCPClientDump) Size() (size int) {
1895         if m == nil {
1896                 return 0
1897         }
1898         return size
1899 }
1900 func (m *DHCPClientDump) Marshal(b []byte) ([]byte, error) {
1901         if b == nil {
1902                 b = make([]byte, m.Size())
1903         }
1904         buf := codec.NewBuffer(b)
1905         return buf.Bytes(), nil
1906 }
1907 func (m *DHCPClientDump) Unmarshal(b []byte) error {
1908         return nil
1909 }
1910
1911 // DHCPComplEvent defines message 'dhcp_compl_event'.
1912 type DHCPComplEvent struct {
1913         PID   uint32    `binapi:"u32,name=pid" json:"pid,omitempty"`
1914         Lease DHCPLease `binapi:"dhcp_lease,name=lease" json:"lease,omitempty"`
1915 }
1916
1917 func (m *DHCPComplEvent) Reset()               { *m = DHCPComplEvent{} }
1918 func (*DHCPComplEvent) GetMessageName() string { return "dhcp_compl_event" }
1919 func (*DHCPComplEvent) GetCrcString() string   { return "e908fd1d" }
1920 func (*DHCPComplEvent) GetMessageType() api.MessageType {
1921         return api.EventMessage
1922 }
1923
1924 func (m *DHCPComplEvent) Size() (size int) {
1925         if m == nil {
1926                 return 0
1927         }
1928         size += 4      // m.PID
1929         size += 4      // m.Lease.SwIfIndex
1930         size += 4      // m.Lease.State
1931         size += 1      // m.Lease.IsIPv6
1932         size += 64     // m.Lease.Hostname
1933         size += 1      // m.Lease.MaskWidth
1934         size += 4      // m.Lease.HostAddress.Af
1935         size += 1 * 16 // m.Lease.HostAddress.Un
1936         size += 4      // m.Lease.RouterAddress.Af
1937         size += 1 * 16 // m.Lease.RouterAddress.Un
1938         size += 1 * 6  // m.Lease.HostMac
1939         size += 1      // m.Lease.Count
1940         for j2 := 0; j2 < len(m.Lease.DomainServer); j2++ {
1941                 var s2 DomainServer
1942                 _ = s2
1943                 if j2 < len(m.Lease.DomainServer) {
1944                         s2 = m.Lease.DomainServer[j2]
1945                 }
1946                 size += 4      // s2.Address.Af
1947                 size += 1 * 16 // s2.Address.Un
1948         }
1949         return size
1950 }
1951 func (m *DHCPComplEvent) Marshal(b []byte) ([]byte, error) {
1952         if b == nil {
1953                 b = make([]byte, m.Size())
1954         }
1955         buf := codec.NewBuffer(b)
1956         buf.EncodeUint32(m.PID)
1957         buf.EncodeUint32(uint32(m.Lease.SwIfIndex))
1958         buf.EncodeUint32(uint32(m.Lease.State))
1959         buf.EncodeBool(m.Lease.IsIPv6)
1960         buf.EncodeString(m.Lease.Hostname, 64)
1961         buf.EncodeUint8(m.Lease.MaskWidth)
1962         buf.EncodeUint32(uint32(m.Lease.HostAddress.Af))
1963         buf.EncodeBytes(m.Lease.HostAddress.Un.XXX_UnionData[:], 16)
1964         buf.EncodeUint32(uint32(m.Lease.RouterAddress.Af))
1965         buf.EncodeBytes(m.Lease.RouterAddress.Un.XXX_UnionData[:], 16)
1966         buf.EncodeBytes(m.Lease.HostMac[:], 6)
1967         buf.EncodeUint8(uint8(len(m.Lease.DomainServer)))
1968         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1969                 var v1 DomainServer // DomainServer
1970                 if j1 < len(m.Lease.DomainServer) {
1971                         v1 = m.Lease.DomainServer[j1]
1972                 }
1973                 buf.EncodeUint32(uint32(v1.Address.Af))
1974                 buf.EncodeBytes(v1.Address.Un.XXX_UnionData[:], 16)
1975         }
1976         return buf.Bytes(), nil
1977 }
1978 func (m *DHCPComplEvent) Unmarshal(b []byte) error {
1979         buf := codec.NewBuffer(b)
1980         m.PID = buf.DecodeUint32()
1981         m.Lease.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1982         m.Lease.State = DHCPClientState(buf.DecodeUint32())
1983         m.Lease.IsIPv6 = buf.DecodeBool()
1984         m.Lease.Hostname = buf.DecodeString(64)
1985         m.Lease.MaskWidth = buf.DecodeUint8()
1986         m.Lease.HostAddress.Af = AddressFamily(buf.DecodeUint32())
1987         copy(m.Lease.HostAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1988         m.Lease.RouterAddress.Af = AddressFamily(buf.DecodeUint32())
1989         copy(m.Lease.RouterAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1990         copy(m.Lease.HostMac[:], buf.DecodeBytes(6))
1991         m.Lease.Count = buf.DecodeUint8()
1992         m.Lease.DomainServer = make([]DomainServer, m.Lease.Count)
1993         for j1 := 0; j1 < len(m.Lease.DomainServer); j1++ {
1994                 m.Lease.DomainServer[j1].Address.Af = AddressFamily(buf.DecodeUint32())
1995                 copy(m.Lease.DomainServer[j1].Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1996         }
1997         return nil
1998 }
1999
2000 // DHCPPluginControlPing defines message 'dhcp_plugin_control_ping'.
2001 type DHCPPluginControlPing struct{}
2002
2003 func (m *DHCPPluginControlPing) Reset()               { *m = DHCPPluginControlPing{} }
2004 func (*DHCPPluginControlPing) GetMessageName() string { return "dhcp_plugin_control_ping" }
2005 func (*DHCPPluginControlPing) GetCrcString() string   { return "51077d14" }
2006 func (*DHCPPluginControlPing) GetMessageType() api.MessageType {
2007         return api.RequestMessage
2008 }
2009
2010 func (m *DHCPPluginControlPing) Size() (size int) {
2011         if m == nil {
2012                 return 0
2013         }
2014         return size
2015 }
2016 func (m *DHCPPluginControlPing) Marshal(b []byte) ([]byte, error) {
2017         if b == nil {
2018                 b = make([]byte, m.Size())
2019         }
2020         buf := codec.NewBuffer(b)
2021         return buf.Bytes(), nil
2022 }
2023 func (m *DHCPPluginControlPing) Unmarshal(b []byte) error {
2024         return nil
2025 }
2026
2027 // DHCPPluginControlPingReply defines message 'dhcp_plugin_control_ping_reply'.
2028 type DHCPPluginControlPingReply struct {
2029         Retval      int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2030         ClientIndex uint32 `binapi:"u32,name=client_index" json:"client_index,omitempty"`
2031         VpePID      uint32 `binapi:"u32,name=vpe_pid" json:"vpe_pid,omitempty"`
2032 }
2033
2034 func (m *DHCPPluginControlPingReply) Reset()               { *m = DHCPPluginControlPingReply{} }
2035 func (*DHCPPluginControlPingReply) GetMessageName() string { return "dhcp_plugin_control_ping_reply" }
2036 func (*DHCPPluginControlPingReply) GetCrcString() string   { return "f6b0b8ca" }
2037 func (*DHCPPluginControlPingReply) GetMessageType() api.MessageType {
2038         return api.ReplyMessage
2039 }
2040
2041 func (m *DHCPPluginControlPingReply) Size() (size int) {
2042         if m == nil {
2043                 return 0
2044         }
2045         size += 4 // m.Retval
2046         size += 4 // m.ClientIndex
2047         size += 4 // m.VpePID
2048         return size
2049 }
2050 func (m *DHCPPluginControlPingReply) Marshal(b []byte) ([]byte, error) {
2051         if b == nil {
2052                 b = make([]byte, m.Size())
2053         }
2054         buf := codec.NewBuffer(b)
2055         buf.EncodeInt32(m.Retval)
2056         buf.EncodeUint32(m.ClientIndex)
2057         buf.EncodeUint32(m.VpePID)
2058         return buf.Bytes(), nil
2059 }
2060 func (m *DHCPPluginControlPingReply) Unmarshal(b []byte) error {
2061         buf := codec.NewBuffer(b)
2062         m.Retval = buf.DecodeInt32()
2063         m.ClientIndex = buf.DecodeUint32()
2064         m.VpePID = buf.DecodeUint32()
2065         return nil
2066 }
2067
2068 // DHCPPluginGetVersion defines message 'dhcp_plugin_get_version'.
2069 type DHCPPluginGetVersion struct{}
2070
2071 func (m *DHCPPluginGetVersion) Reset()               { *m = DHCPPluginGetVersion{} }
2072 func (*DHCPPluginGetVersion) GetMessageName() string { return "dhcp_plugin_get_version" }
2073 func (*DHCPPluginGetVersion) GetCrcString() string   { return "51077d14" }
2074 func (*DHCPPluginGetVersion) GetMessageType() api.MessageType {
2075         return api.RequestMessage
2076 }
2077
2078 func (m *DHCPPluginGetVersion) Size() (size int) {
2079         if m == nil {
2080                 return 0
2081         }
2082         return size
2083 }
2084 func (m *DHCPPluginGetVersion) Marshal(b []byte) ([]byte, error) {
2085         if b == nil {
2086                 b = make([]byte, m.Size())
2087         }
2088         buf := codec.NewBuffer(b)
2089         return buf.Bytes(), nil
2090 }
2091 func (m *DHCPPluginGetVersion) Unmarshal(b []byte) error {
2092         return nil
2093 }
2094
2095 // DHCPPluginGetVersionReply defines message 'dhcp_plugin_get_version_reply'.
2096 type DHCPPluginGetVersionReply struct {
2097         Major uint32 `binapi:"u32,name=major" json:"major,omitempty"`
2098         Minor uint32 `binapi:"u32,name=minor" json:"minor,omitempty"`
2099 }
2100
2101 func (m *DHCPPluginGetVersionReply) Reset()               { *m = DHCPPluginGetVersionReply{} }
2102 func (*DHCPPluginGetVersionReply) GetMessageName() string { return "dhcp_plugin_get_version_reply" }
2103 func (*DHCPPluginGetVersionReply) GetCrcString() string   { return "9b32cf86" }
2104 func (*DHCPPluginGetVersionReply) GetMessageType() api.MessageType {
2105         return api.ReplyMessage
2106 }
2107
2108 func (m *DHCPPluginGetVersionReply) Size() (size int) {
2109         if m == nil {
2110                 return 0
2111         }
2112         size += 4 // m.Major
2113         size += 4 // m.Minor
2114         return size
2115 }
2116 func (m *DHCPPluginGetVersionReply) Marshal(b []byte) ([]byte, error) {
2117         if b == nil {
2118                 b = make([]byte, m.Size())
2119         }
2120         buf := codec.NewBuffer(b)
2121         buf.EncodeUint32(m.Major)
2122         buf.EncodeUint32(m.Minor)
2123         return buf.Bytes(), nil
2124 }
2125 func (m *DHCPPluginGetVersionReply) Unmarshal(b []byte) error {
2126         buf := codec.NewBuffer(b)
2127         m.Major = buf.DecodeUint32()
2128         m.Minor = buf.DecodeUint32()
2129         return nil
2130 }
2131
2132 // DHCPProxyConfig defines message 'dhcp_proxy_config'.
2133 type DHCPProxyConfig struct {
2134         RxVrfID        uint32  `binapi:"u32,name=rx_vrf_id" json:"rx_vrf_id,omitempty"`
2135         ServerVrfID    uint32  `binapi:"u32,name=server_vrf_id" json:"server_vrf_id,omitempty"`
2136         IsAdd          bool    `binapi:"bool,name=is_add" json:"is_add,omitempty"`
2137         DHCPServer     Address `binapi:"address,name=dhcp_server" json:"dhcp_server,omitempty"`
2138         DHCPSrcAddress Address `binapi:"address,name=dhcp_src_address" json:"dhcp_src_address,omitempty"`
2139 }
2140
2141 func (m *DHCPProxyConfig) Reset()               { *m = DHCPProxyConfig{} }
2142 func (*DHCPProxyConfig) GetMessageName() string { return "dhcp_proxy_config" }
2143 func (*DHCPProxyConfig) GetCrcString() string   { return "6767230e" }
2144 func (*DHCPProxyConfig) GetMessageType() api.MessageType {
2145         return api.RequestMessage
2146 }
2147
2148 func (m *DHCPProxyConfig) Size() (size int) {
2149         if m == nil {
2150                 return 0
2151         }
2152         size += 4      // m.RxVrfID
2153         size += 4      // m.ServerVrfID
2154         size += 1      // m.IsAdd
2155         size += 4      // m.DHCPServer.Af
2156         size += 1 * 16 // m.DHCPServer.Un
2157         size += 4      // m.DHCPSrcAddress.Af
2158         size += 1 * 16 // m.DHCPSrcAddress.Un
2159         return size
2160 }
2161 func (m *DHCPProxyConfig) Marshal(b []byte) ([]byte, error) {
2162         if b == nil {
2163                 b = make([]byte, m.Size())
2164         }
2165         buf := codec.NewBuffer(b)
2166         buf.EncodeUint32(m.RxVrfID)
2167         buf.EncodeUint32(m.ServerVrfID)
2168         buf.EncodeBool(m.IsAdd)
2169         buf.EncodeUint32(uint32(m.DHCPServer.Af))
2170         buf.EncodeBytes(m.DHCPServer.Un.XXX_UnionData[:], 16)
2171         buf.EncodeUint32(uint32(m.DHCPSrcAddress.Af))
2172         buf.EncodeBytes(m.DHCPSrcAddress.Un.XXX_UnionData[:], 16)
2173         return buf.Bytes(), nil
2174 }
2175 func (m *DHCPProxyConfig) Unmarshal(b []byte) error {
2176         buf := codec.NewBuffer(b)
2177         m.RxVrfID = buf.DecodeUint32()
2178         m.ServerVrfID = buf.DecodeUint32()
2179         m.IsAdd = buf.DecodeBool()
2180         m.DHCPServer.Af = AddressFamily(buf.DecodeUint32())
2181         copy(m.DHCPServer.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2182         m.DHCPSrcAddress.Af = AddressFamily(buf.DecodeUint32())
2183         copy(m.DHCPSrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2184         return nil
2185 }
2186
2187 // DHCPProxyConfigReply defines message 'dhcp_proxy_config_reply'.
2188 type DHCPProxyConfigReply struct {
2189         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2190 }
2191
2192 func (m *DHCPProxyConfigReply) Reset()               { *m = DHCPProxyConfigReply{} }
2193 func (*DHCPProxyConfigReply) GetMessageName() string { return "dhcp_proxy_config_reply" }
2194 func (*DHCPProxyConfigReply) GetCrcString() string   { return "e8d4e804" }
2195 func (*DHCPProxyConfigReply) GetMessageType() api.MessageType {
2196         return api.ReplyMessage
2197 }
2198
2199 func (m *DHCPProxyConfigReply) Size() (size int) {
2200         if m == nil {
2201                 return 0
2202         }
2203         size += 4 // m.Retval
2204         return size
2205 }
2206 func (m *DHCPProxyConfigReply) Marshal(b []byte) ([]byte, error) {
2207         if b == nil {
2208                 b = make([]byte, m.Size())
2209         }
2210         buf := codec.NewBuffer(b)
2211         buf.EncodeInt32(m.Retval)
2212         return buf.Bytes(), nil
2213 }
2214 func (m *DHCPProxyConfigReply) Unmarshal(b []byte) error {
2215         buf := codec.NewBuffer(b)
2216         m.Retval = buf.DecodeInt32()
2217         return nil
2218 }
2219
2220 // DHCPProxyDetails defines message 'dhcp_proxy_details'.
2221 type DHCPProxyDetails struct {
2222         RxVrfID        uint32       `binapi:"u32,name=rx_vrf_id" json:"rx_vrf_id,omitempty"`
2223         VssOui         uint32       `binapi:"u32,name=vss_oui" json:"vss_oui,omitempty"`
2224         VssFibID       uint32       `binapi:"u32,name=vss_fib_id" json:"vss_fib_id,omitempty"`
2225         VssType        VssType      `binapi:"vss_type,name=vss_type" json:"vss_type,omitempty"`
2226         IsIPv6         bool         `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
2227         VssVPNAsciiID  string       `binapi:"string[129],name=vss_vpn_ascii_id" json:"vss_vpn_ascii_id,omitempty"`
2228         DHCPSrcAddress Address      `binapi:"address,name=dhcp_src_address" json:"dhcp_src_address,omitempty"`
2229         Count          uint8        `binapi:"u8,name=count" json:"-"`
2230         Servers        []DHCPServer `binapi:"dhcp_server[count],name=servers" json:"servers,omitempty"`
2231 }
2232
2233 func (m *DHCPProxyDetails) Reset()               { *m = DHCPProxyDetails{} }
2234 func (*DHCPProxyDetails) GetMessageName() string { return "dhcp_proxy_details" }
2235 func (*DHCPProxyDetails) GetCrcString() string   { return "ce16f044" }
2236 func (*DHCPProxyDetails) GetMessageType() api.MessageType {
2237         return api.ReplyMessage
2238 }
2239
2240 func (m *DHCPProxyDetails) Size() (size int) {
2241         if m == nil {
2242                 return 0
2243         }
2244         size += 4      // m.RxVrfID
2245         size += 4      // m.VssOui
2246         size += 4      // m.VssFibID
2247         size += 4      // m.VssType
2248         size += 1      // m.IsIPv6
2249         size += 129    // m.VssVPNAsciiID
2250         size += 4      // m.DHCPSrcAddress.Af
2251         size += 1 * 16 // m.DHCPSrcAddress.Un
2252         size += 1      // m.Count
2253         for j1 := 0; j1 < len(m.Servers); j1++ {
2254                 var s1 DHCPServer
2255                 _ = s1
2256                 if j1 < len(m.Servers) {
2257                         s1 = m.Servers[j1]
2258                 }
2259                 size += 4      // s1.ServerVrfID
2260                 size += 4      // s1.DHCPServer.Af
2261                 size += 1 * 16 // s1.DHCPServer.Un
2262         }
2263         return size
2264 }
2265 func (m *DHCPProxyDetails) Marshal(b []byte) ([]byte, error) {
2266         if b == nil {
2267                 b = make([]byte, m.Size())
2268         }
2269         buf := codec.NewBuffer(b)
2270         buf.EncodeUint32(m.RxVrfID)
2271         buf.EncodeUint32(m.VssOui)
2272         buf.EncodeUint32(m.VssFibID)
2273         buf.EncodeUint32(uint32(m.VssType))
2274         buf.EncodeBool(m.IsIPv6)
2275         buf.EncodeString(m.VssVPNAsciiID, 129)
2276         buf.EncodeUint32(uint32(m.DHCPSrcAddress.Af))
2277         buf.EncodeBytes(m.DHCPSrcAddress.Un.XXX_UnionData[:], 16)
2278         buf.EncodeUint8(uint8(len(m.Servers)))
2279         for j0 := 0; j0 < len(m.Servers); j0++ {
2280                 var v0 DHCPServer // Servers
2281                 if j0 < len(m.Servers) {
2282                         v0 = m.Servers[j0]
2283                 }
2284                 buf.EncodeUint32(v0.ServerVrfID)
2285                 buf.EncodeUint32(uint32(v0.DHCPServer.Af))
2286                 buf.EncodeBytes(v0.DHCPServer.Un.XXX_UnionData[:], 16)
2287         }
2288         return buf.Bytes(), nil
2289 }
2290 func (m *DHCPProxyDetails) Unmarshal(b []byte) error {
2291         buf := codec.NewBuffer(b)
2292         m.RxVrfID = buf.DecodeUint32()
2293         m.VssOui = buf.DecodeUint32()
2294         m.VssFibID = buf.DecodeUint32()
2295         m.VssType = VssType(buf.DecodeUint32())
2296         m.IsIPv6 = buf.DecodeBool()
2297         m.VssVPNAsciiID = buf.DecodeString(129)
2298         m.DHCPSrcAddress.Af = AddressFamily(buf.DecodeUint32())
2299         copy(m.DHCPSrcAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2300         m.Count = buf.DecodeUint8()
2301         m.Servers = make([]DHCPServer, m.Count)
2302         for j0 := 0; j0 < len(m.Servers); j0++ {
2303                 m.Servers[j0].ServerVrfID = buf.DecodeUint32()
2304                 m.Servers[j0].DHCPServer.Af = AddressFamily(buf.DecodeUint32())
2305                 copy(m.Servers[j0].DHCPServer.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2306         }
2307         return nil
2308 }
2309
2310 // DHCPProxyDump defines message 'dhcp_proxy_dump'.
2311 type DHCPProxyDump struct {
2312         IsIP6 bool `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2313 }
2314
2315 func (m *DHCPProxyDump) Reset()               { *m = DHCPProxyDump{} }
2316 func (*DHCPProxyDump) GetMessageName() string { return "dhcp_proxy_dump" }
2317 func (*DHCPProxyDump) GetCrcString() string   { return "5c5b063f" }
2318 func (*DHCPProxyDump) GetMessageType() api.MessageType {
2319         return api.RequestMessage
2320 }
2321
2322 func (m *DHCPProxyDump) Size() (size int) {
2323         if m == nil {
2324                 return 0
2325         }
2326         size += 1 // m.IsIP6
2327         return size
2328 }
2329 func (m *DHCPProxyDump) Marshal(b []byte) ([]byte, error) {
2330         if b == nil {
2331                 b = make([]byte, m.Size())
2332         }
2333         buf := codec.NewBuffer(b)
2334         buf.EncodeBool(m.IsIP6)
2335         return buf.Bytes(), nil
2336 }
2337 func (m *DHCPProxyDump) Unmarshal(b []byte) error {
2338         buf := codec.NewBuffer(b)
2339         m.IsIP6 = buf.DecodeBool()
2340         return nil
2341 }
2342
2343 // DHCPProxySetVss defines message 'dhcp_proxy_set_vss'.
2344 type DHCPProxySetVss struct {
2345         TblID      uint32  `binapi:"u32,name=tbl_id" json:"tbl_id,omitempty"`
2346         VssType    VssType `binapi:"vss_type,name=vss_type" json:"vss_type,omitempty"`
2347         VPNAsciiID string  `binapi:"string[129],name=vpn_ascii_id" json:"vpn_ascii_id,omitempty"`
2348         Oui        uint32  `binapi:"u32,name=oui" json:"oui,omitempty"`
2349         VPNIndex   uint32  `binapi:"u32,name=vpn_index" json:"vpn_index,omitempty"`
2350         IsIPv6     bool    `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
2351         IsAdd      bool    `binapi:"bool,name=is_add" json:"is_add,omitempty"`
2352 }
2353
2354 func (m *DHCPProxySetVss) Reset()               { *m = DHCPProxySetVss{} }
2355 func (*DHCPProxySetVss) GetMessageName() string { return "dhcp_proxy_set_vss" }
2356 func (*DHCPProxySetVss) GetCrcString() string   { return "50537301" }
2357 func (*DHCPProxySetVss) GetMessageType() api.MessageType {
2358         return api.RequestMessage
2359 }
2360
2361 func (m *DHCPProxySetVss) Size() (size int) {
2362         if m == nil {
2363                 return 0
2364         }
2365         size += 4   // m.TblID
2366         size += 4   // m.VssType
2367         size += 129 // m.VPNAsciiID
2368         size += 4   // m.Oui
2369         size += 4   // m.VPNIndex
2370         size += 1   // m.IsIPv6
2371         size += 1   // m.IsAdd
2372         return size
2373 }
2374 func (m *DHCPProxySetVss) Marshal(b []byte) ([]byte, error) {
2375         if b == nil {
2376                 b = make([]byte, m.Size())
2377         }
2378         buf := codec.NewBuffer(b)
2379         buf.EncodeUint32(m.TblID)
2380         buf.EncodeUint32(uint32(m.VssType))
2381         buf.EncodeString(m.VPNAsciiID, 129)
2382         buf.EncodeUint32(m.Oui)
2383         buf.EncodeUint32(m.VPNIndex)
2384         buf.EncodeBool(m.IsIPv6)
2385         buf.EncodeBool(m.IsAdd)
2386         return buf.Bytes(), nil
2387 }
2388 func (m *DHCPProxySetVss) Unmarshal(b []byte) error {
2389         buf := codec.NewBuffer(b)
2390         m.TblID = buf.DecodeUint32()
2391         m.VssType = VssType(buf.DecodeUint32())
2392         m.VPNAsciiID = buf.DecodeString(129)
2393         m.Oui = buf.DecodeUint32()
2394         m.VPNIndex = buf.DecodeUint32()
2395         m.IsIPv6 = buf.DecodeBool()
2396         m.IsAdd = buf.DecodeBool()
2397         return nil
2398 }
2399
2400 // DHCPProxySetVssReply defines message 'dhcp_proxy_set_vss_reply'.
2401 type DHCPProxySetVssReply struct {
2402         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2403 }
2404
2405 func (m *DHCPProxySetVssReply) Reset()               { *m = DHCPProxySetVssReply{} }
2406 func (*DHCPProxySetVssReply) GetMessageName() string { return "dhcp_proxy_set_vss_reply" }
2407 func (*DHCPProxySetVssReply) GetCrcString() string   { return "e8d4e804" }
2408 func (*DHCPProxySetVssReply) GetMessageType() api.MessageType {
2409         return api.ReplyMessage
2410 }
2411
2412 func (m *DHCPProxySetVssReply) Size() (size int) {
2413         if m == nil {
2414                 return 0
2415         }
2416         size += 4 // m.Retval
2417         return size
2418 }
2419 func (m *DHCPProxySetVssReply) Marshal(b []byte) ([]byte, error) {
2420         if b == nil {
2421                 b = make([]byte, m.Size())
2422         }
2423         buf := codec.NewBuffer(b)
2424         buf.EncodeInt32(m.Retval)
2425         return buf.Bytes(), nil
2426 }
2427 func (m *DHCPProxySetVssReply) Unmarshal(b []byte) error {
2428         buf := codec.NewBuffer(b)
2429         m.Retval = buf.DecodeInt32()
2430         return nil
2431 }
2432
2433 // WantDHCP6PdReplyEvents defines message 'want_dhcp6_pd_reply_events'.
2434 type WantDHCP6PdReplyEvents struct {
2435         EnableDisable bool   `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
2436         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
2437 }
2438
2439 func (m *WantDHCP6PdReplyEvents) Reset()               { *m = WantDHCP6PdReplyEvents{} }
2440 func (*WantDHCP6PdReplyEvents) GetMessageName() string { return "want_dhcp6_pd_reply_events" }
2441 func (*WantDHCP6PdReplyEvents) GetCrcString() string   { return "c5e2af94" }
2442 func (*WantDHCP6PdReplyEvents) GetMessageType() api.MessageType {
2443         return api.RequestMessage
2444 }
2445
2446 func (m *WantDHCP6PdReplyEvents) Size() (size int) {
2447         if m == nil {
2448                 return 0
2449         }
2450         size += 1 // m.EnableDisable
2451         size += 4 // m.PID
2452         return size
2453 }
2454 func (m *WantDHCP6PdReplyEvents) Marshal(b []byte) ([]byte, error) {
2455         if b == nil {
2456                 b = make([]byte, m.Size())
2457         }
2458         buf := codec.NewBuffer(b)
2459         buf.EncodeBool(m.EnableDisable)
2460         buf.EncodeUint32(m.PID)
2461         return buf.Bytes(), nil
2462 }
2463 func (m *WantDHCP6PdReplyEvents) Unmarshal(b []byte) error {
2464         buf := codec.NewBuffer(b)
2465         m.EnableDisable = buf.DecodeBool()
2466         m.PID = buf.DecodeUint32()
2467         return nil
2468 }
2469
2470 // WantDHCP6PdReplyEventsReply defines message 'want_dhcp6_pd_reply_events_reply'.
2471 type WantDHCP6PdReplyEventsReply struct {
2472         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2473 }
2474
2475 func (m *WantDHCP6PdReplyEventsReply) Reset() { *m = WantDHCP6PdReplyEventsReply{} }
2476 func (*WantDHCP6PdReplyEventsReply) GetMessageName() string {
2477         return "want_dhcp6_pd_reply_events_reply"
2478 }
2479 func (*WantDHCP6PdReplyEventsReply) GetCrcString() string { return "e8d4e804" }
2480 func (*WantDHCP6PdReplyEventsReply) GetMessageType() api.MessageType {
2481         return api.ReplyMessage
2482 }
2483
2484 func (m *WantDHCP6PdReplyEventsReply) Size() (size int) {
2485         if m == nil {
2486                 return 0
2487         }
2488         size += 4 // m.Retval
2489         return size
2490 }
2491 func (m *WantDHCP6PdReplyEventsReply) Marshal(b []byte) ([]byte, error) {
2492         if b == nil {
2493                 b = make([]byte, m.Size())
2494         }
2495         buf := codec.NewBuffer(b)
2496         buf.EncodeInt32(m.Retval)
2497         return buf.Bytes(), nil
2498 }
2499 func (m *WantDHCP6PdReplyEventsReply) Unmarshal(b []byte) error {
2500         buf := codec.NewBuffer(b)
2501         m.Retval = buf.DecodeInt32()
2502         return nil
2503 }
2504
2505 // WantDHCP6ReplyEvents defines message 'want_dhcp6_reply_events'.
2506 type WantDHCP6ReplyEvents struct {
2507         EnableDisable uint8  `binapi:"u8,name=enable_disable" json:"enable_disable,omitempty"`
2508         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
2509 }
2510
2511 func (m *WantDHCP6ReplyEvents) Reset()               { *m = WantDHCP6ReplyEvents{} }
2512 func (*WantDHCP6ReplyEvents) GetMessageName() string { return "want_dhcp6_reply_events" }
2513 func (*WantDHCP6ReplyEvents) GetCrcString() string   { return "05b454b5" }
2514 func (*WantDHCP6ReplyEvents) GetMessageType() api.MessageType {
2515         return api.RequestMessage
2516 }
2517
2518 func (m *WantDHCP6ReplyEvents) Size() (size int) {
2519         if m == nil {
2520                 return 0
2521         }
2522         size += 1 // m.EnableDisable
2523         size += 4 // m.PID
2524         return size
2525 }
2526 func (m *WantDHCP6ReplyEvents) Marshal(b []byte) ([]byte, error) {
2527         if b == nil {
2528                 b = make([]byte, m.Size())
2529         }
2530         buf := codec.NewBuffer(b)
2531         buf.EncodeUint8(m.EnableDisable)
2532         buf.EncodeUint32(m.PID)
2533         return buf.Bytes(), nil
2534 }
2535 func (m *WantDHCP6ReplyEvents) Unmarshal(b []byte) error {
2536         buf := codec.NewBuffer(b)
2537         m.EnableDisable = buf.DecodeUint8()
2538         m.PID = buf.DecodeUint32()
2539         return nil
2540 }
2541
2542 // WantDHCP6ReplyEventsReply defines message 'want_dhcp6_reply_events_reply'.
2543 type WantDHCP6ReplyEventsReply struct {
2544         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2545 }
2546
2547 func (m *WantDHCP6ReplyEventsReply) Reset()               { *m = WantDHCP6ReplyEventsReply{} }
2548 func (*WantDHCP6ReplyEventsReply) GetMessageName() string { return "want_dhcp6_reply_events_reply" }
2549 func (*WantDHCP6ReplyEventsReply) GetCrcString() string   { return "e8d4e804" }
2550 func (*WantDHCP6ReplyEventsReply) GetMessageType() api.MessageType {
2551         return api.ReplyMessage
2552 }
2553
2554 func (m *WantDHCP6ReplyEventsReply) Size() (size int) {
2555         if m == nil {
2556                 return 0
2557         }
2558         size += 4 // m.Retval
2559         return size
2560 }
2561 func (m *WantDHCP6ReplyEventsReply) Marshal(b []byte) ([]byte, error) {
2562         if b == nil {
2563                 b = make([]byte, m.Size())
2564         }
2565         buf := codec.NewBuffer(b)
2566         buf.EncodeInt32(m.Retval)
2567         return buf.Bytes(), nil
2568 }
2569 func (m *WantDHCP6ReplyEventsReply) Unmarshal(b []byte) error {
2570         buf := codec.NewBuffer(b)
2571         m.Retval = buf.DecodeInt32()
2572         return nil
2573 }
2574
2575 func init() { file_dhcp_binapi_init() }
2576 func file_dhcp_binapi_init() {
2577         api.RegisterMessage((*DHCP6ClientsEnableDisable)(nil), "dhcp6_clients_enable_disable_b3e225d2")
2578         api.RegisterMessage((*DHCP6ClientsEnableDisableReply)(nil), "dhcp6_clients_enable_disable_reply_e8d4e804")
2579         api.RegisterMessage((*DHCP6DuidLlSet)(nil), "dhcp6_duid_ll_set_0f6ca323")
2580         api.RegisterMessage((*DHCP6DuidLlSetReply)(nil), "dhcp6_duid_ll_set_reply_e8d4e804")
2581         api.RegisterMessage((*DHCP6PdReplyEvent)(nil), "dhcp6_pd_reply_event_cb3e462b")
2582         api.RegisterMessage((*DHCP6PdSendClientMessage)(nil), "dhcp6_pd_send_client_message_064badb8")
2583         api.RegisterMessage((*DHCP6PdSendClientMessageReply)(nil), "dhcp6_pd_send_client_message_reply_e8d4e804")
2584         api.RegisterMessage((*DHCP6ReplyEvent)(nil), "dhcp6_reply_event_9f3af9e5")
2585         api.RegisterMessage((*DHCP6SendClientMessage)(nil), "dhcp6_send_client_message_f6f14ef0")
2586         api.RegisterMessage((*DHCP6SendClientMessageReply)(nil), "dhcp6_send_client_message_reply_e8d4e804")
2587         api.RegisterMessage((*DHCPClientConfig)(nil), "dhcp_client_config_959b80a3")
2588         api.RegisterMessage((*DHCPClientConfigReply)(nil), "dhcp_client_config_reply_e8d4e804")
2589         api.RegisterMessage((*DHCPClientDetails)(nil), "dhcp_client_details_acd82f5a")
2590         api.RegisterMessage((*DHCPClientDump)(nil), "dhcp_client_dump_51077d14")
2591         api.RegisterMessage((*DHCPComplEvent)(nil), "dhcp_compl_event_e908fd1d")
2592         api.RegisterMessage((*DHCPPluginControlPing)(nil), "dhcp_plugin_control_ping_51077d14")
2593         api.RegisterMessage((*DHCPPluginControlPingReply)(nil), "dhcp_plugin_control_ping_reply_f6b0b8ca")
2594         api.RegisterMessage((*DHCPPluginGetVersion)(nil), "dhcp_plugin_get_version_51077d14")
2595         api.RegisterMessage((*DHCPPluginGetVersionReply)(nil), "dhcp_plugin_get_version_reply_9b32cf86")
2596         api.RegisterMessage((*DHCPProxyConfig)(nil), "dhcp_proxy_config_6767230e")
2597         api.RegisterMessage((*DHCPProxyConfigReply)(nil), "dhcp_proxy_config_reply_e8d4e804")
2598         api.RegisterMessage((*DHCPProxyDetails)(nil), "dhcp_proxy_details_ce16f044")
2599         api.RegisterMessage((*DHCPProxyDump)(nil), "dhcp_proxy_dump_5c5b063f")
2600         api.RegisterMessage((*DHCPProxySetVss)(nil), "dhcp_proxy_set_vss_50537301")
2601         api.RegisterMessage((*DHCPProxySetVssReply)(nil), "dhcp_proxy_set_vss_reply_e8d4e804")
2602         api.RegisterMessage((*WantDHCP6PdReplyEvents)(nil), "want_dhcp6_pd_reply_events_c5e2af94")
2603         api.RegisterMessage((*WantDHCP6PdReplyEventsReply)(nil), "want_dhcp6_pd_reply_events_reply_e8d4e804")
2604         api.RegisterMessage((*WantDHCP6ReplyEvents)(nil), "want_dhcp6_reply_events_05b454b5")
2605         api.RegisterMessage((*WantDHCP6ReplyEventsReply)(nil), "want_dhcp6_reply_events_reply_e8d4e804")
2606 }
2607
2608 // Messages returns list of all messages in this module.
2609 func AllMessages() []api.Message {
2610         return []api.Message{
2611                 (*DHCP6ClientsEnableDisable)(nil),
2612                 (*DHCP6ClientsEnableDisableReply)(nil),
2613                 (*DHCP6DuidLlSet)(nil),
2614                 (*DHCP6DuidLlSetReply)(nil),
2615                 (*DHCP6PdReplyEvent)(nil),
2616                 (*DHCP6PdSendClientMessage)(nil),
2617                 (*DHCP6PdSendClientMessageReply)(nil),
2618                 (*DHCP6ReplyEvent)(nil),
2619                 (*DHCP6SendClientMessage)(nil),
2620                 (*DHCP6SendClientMessageReply)(nil),
2621                 (*DHCPClientConfig)(nil),
2622                 (*DHCPClientConfigReply)(nil),
2623                 (*DHCPClientDetails)(nil),
2624                 (*DHCPClientDump)(nil),
2625                 (*DHCPComplEvent)(nil),
2626                 (*DHCPPluginControlPing)(nil),
2627                 (*DHCPPluginControlPingReply)(nil),
2628                 (*DHCPPluginGetVersion)(nil),
2629                 (*DHCPPluginGetVersionReply)(nil),
2630                 (*DHCPProxyConfig)(nil),
2631                 (*DHCPProxyConfigReply)(nil),
2632                 (*DHCPProxyDetails)(nil),
2633                 (*DHCPProxyDump)(nil),
2634                 (*DHCPProxySetVss)(nil),
2635                 (*DHCPProxySetVssReply)(nil),
2636                 (*WantDHCP6PdReplyEvents)(nil),
2637                 (*WantDHCP6PdReplyEventsReply)(nil),
2638                 (*WantDHCP6ReplyEvents)(nil),
2639                 (*WantDHCP6ReplyEventsReply)(nil),
2640         }
2641 }