internal/testbinapi/binapi2001/bfd/bfd.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.4.0-dev
   4 //  VPP:              20.01
   5 // source: .vppapi/core/bfd.api.json
   6
   7 // Package bfd contains generated bindings for API file bfd.api.
   8 //
   9 // Contents:
  10 //   6 aliases
  11 //  11 enums
  12 //   6 structs
  13 //   1 union
  14 //  28 messages
  15 //
  16 package bfd
  17
  18 import (
  19         "fmt"
  20         api "git.fd.io/govpp.git/api"
  21         codec "git.fd.io/govpp.git/codec"
  22         "net"
  23         "strconv"
  24         "strings"
  25 )
  26
  27 // This is a compile-time assertion to ensure that this generated file
  28 // is compatible with the GoVPP api package it is being compiled against.
  29 // A compilation error at this line likely means your copy of the
  30 // GoVPP api package needs to be updated.
  31 const _ = api.GoVppAPIPackageIsVersion2
  32
  33 const (
  34         APIFile    = "bfd"
  35         APIVersion = "2.0.0"
  36         VersionCrc = 0xfd792c8c
  37 )
  38
  39 // AddressFamily defines enum 'address_family'.
  40 type AddressFamily uint32
  41
  42 const (
  43         ADDRESS_IP4 AddressFamily = 0
  44         ADDRESS_IP6 AddressFamily = 1
  45 )
  46
  47 var (
  48         AddressFamily_name = map[uint32]string{
  49                 0: "ADDRESS_IP4",
  50                 1: "ADDRESS_IP6",
  51         }
  52         AddressFamily_value = map[string]uint32{
  53                 "ADDRESS_IP4": 0,
  54                 "ADDRESS_IP6": 1,
  55         }
  56 )
  57
  58 func (x AddressFamily) String() string {
  59         s, ok := AddressFamily_name[uint32(x)]
  60         if ok {
  61                 return s
  62         }
  63         return "AddressFamily(" + strconv.Itoa(int(x)) + ")"
  64 }
  65
  66 // BfdState defines enum 'bfd_state'.
  67 type BfdState uint32
  68
  69 const (
  70         BFD_STATE_API_ADMIN_DOWN BfdState = 0
  71         BFD_STATE_API_DOWN       BfdState = 1
  72         BFD_STATE_API_INIT       BfdState = 2
  73         BFD_STATE_API_UP         BfdState = 3
  74 )
  75
  76 var (
  77         BfdState_name = map[uint32]string{
  78                 0: "BFD_STATE_API_ADMIN_DOWN",
  79                 1: "BFD_STATE_API_DOWN",
  80                 2: "BFD_STATE_API_INIT",
  81                 3: "BFD_STATE_API_UP",
  82         }
  83         BfdState_value = map[string]uint32{
  84                 "BFD_STATE_API_ADMIN_DOWN": 0,
  85                 "BFD_STATE_API_DOWN":       1,
  86                 "BFD_STATE_API_INIT":       2,
  87                 "BFD_STATE_API_UP":         3,
  88         }
  89 )
  90
  91 func (x BfdState) String() string {
  92         s, ok := BfdState_name[uint32(x)]
  93         if ok {
  94                 return s
  95         }
  96         return "BfdState(" + strconv.Itoa(int(x)) + ")"
  97 }
  98
  99 // IfStatusFlags defines enum 'if_status_flags'.
 100 type IfStatusFlags uint32
 101
 102 const (
 103         IF_STATUS_API_FLAG_ADMIN_UP IfStatusFlags = 1
 104         IF_STATUS_API_FLAG_LINK_UP  IfStatusFlags = 2
 105 )
 106
 107 var (
 108         IfStatusFlags_name = map[uint32]string{
 109                 1: "IF_STATUS_API_FLAG_ADMIN_UP",
 110                 2: "IF_STATUS_API_FLAG_LINK_UP",
 111         }
 112         IfStatusFlags_value = map[string]uint32{
 113                 "IF_STATUS_API_FLAG_ADMIN_UP": 1,
 114                 "IF_STATUS_API_FLAG_LINK_UP":  2,
 115         }
 116 )
 117
 118 func (x IfStatusFlags) String() string {
 119         s, ok := IfStatusFlags_name[uint32(x)]
 120         if ok {
 121                 return s
 122         }
 123         str := func(n uint32) string {
 124                 s, ok := IfStatusFlags_name[uint32(n)]
 125                 if ok {
 126                         return s
 127                 }
 128                 return "IfStatusFlags(" + strconv.Itoa(int(n)) + ")"
 129         }
 130         for i := uint32(0); i <= 32; i++ {
 131                 val := uint32(x)
 132                 if val&(1<<i) != 0 {
 133                         if s != "" {
 134                                 s += "|"
 135                         }
 136                         s += str(1 << i)
 137                 }
 138         }
 139         if s == "" {
 140                 return str(uint32(x))
 141         }
 142         return s
 143 }
 144
 145 // IfType defines enum 'if_type'.
 146 type IfType uint32
 147
 148 const (
 149         IF_API_TYPE_HARDWARE IfType = 1
 150         IF_API_TYPE_SUB      IfType = 2
 151         IF_API_TYPE_P2P      IfType = 3
 152         IF_API_TYPE_PIPE     IfType = 4
 153 )
 154
 155 var (
 156         IfType_name = map[uint32]string{
 157                 1: "IF_API_TYPE_HARDWARE",
 158                 2: "IF_API_TYPE_SUB",
 159                 3: "IF_API_TYPE_P2P",
 160                 4: "IF_API_TYPE_PIPE",
 161         }
 162         IfType_value = map[string]uint32{
 163                 "IF_API_TYPE_HARDWARE": 1,
 164                 "IF_API_TYPE_SUB":      2,
 165                 "IF_API_TYPE_P2P":      3,
 166                 "IF_API_TYPE_PIPE":     4,
 167         }
 168 )
 169
 170 func (x IfType) String() string {
 171         s, ok := IfType_name[uint32(x)]
 172         if ok {
 173                 return s
 174         }
 175         return "IfType(" + strconv.Itoa(int(x)) + ")"
 176 }
 177
 178 // IPDscp defines enum 'ip_dscp'.
 179 type IPDscp uint8
 180
 181 const (
 182         IP_API_DSCP_CS0  IPDscp = 0
 183         IP_API_DSCP_CS1  IPDscp = 8
 184         IP_API_DSCP_AF11 IPDscp = 10
 185         IP_API_DSCP_AF12 IPDscp = 12
 186         IP_API_DSCP_AF13 IPDscp = 14
 187         IP_API_DSCP_CS2  IPDscp = 16
 188         IP_API_DSCP_AF21 IPDscp = 18
 189         IP_API_DSCP_AF22 IPDscp = 20
 190         IP_API_DSCP_AF23 IPDscp = 22
 191         IP_API_DSCP_CS3  IPDscp = 24
 192         IP_API_DSCP_AF31 IPDscp = 26
 193         IP_API_DSCP_AF32 IPDscp = 28
 194         IP_API_DSCP_AF33 IPDscp = 30
 195         IP_API_DSCP_CS4  IPDscp = 32
 196         IP_API_DSCP_AF41 IPDscp = 34
 197         IP_API_DSCP_AF42 IPDscp = 36
 198         IP_API_DSCP_AF43 IPDscp = 38
 199         IP_API_DSCP_CS5  IPDscp = 40
 200         IP_API_DSCP_EF   IPDscp = 46
 201         IP_API_DSCP_CS6  IPDscp = 48
 202         IP_API_DSCP_CS7  IPDscp = 50
 203 )
 204
 205 var (
 206         IPDscp_name = map[uint8]string{
 207                 0:  "IP_API_DSCP_CS0",
 208                 8:  "IP_API_DSCP_CS1",
 209                 10: "IP_API_DSCP_AF11",
 210                 12: "IP_API_DSCP_AF12",
 211                 14: "IP_API_DSCP_AF13",
 212                 16: "IP_API_DSCP_CS2",
 213                 18: "IP_API_DSCP_AF21",
 214                 20: "IP_API_DSCP_AF22",
 215                 22: "IP_API_DSCP_AF23",
 216                 24: "IP_API_DSCP_CS3",
 217                 26: "IP_API_DSCP_AF31",
 218                 28: "IP_API_DSCP_AF32",
 219                 30: "IP_API_DSCP_AF33",
 220                 32: "IP_API_DSCP_CS4",
 221                 34: "IP_API_DSCP_AF41",
 222                 36: "IP_API_DSCP_AF42",
 223                 38: "IP_API_DSCP_AF43",
 224                 40: "IP_API_DSCP_CS5",
 225                 46: "IP_API_DSCP_EF",
 226                 48: "IP_API_DSCP_CS6",
 227                 50: "IP_API_DSCP_CS7",
 228         }
 229         IPDscp_value = map[string]uint8{
 230                 "IP_API_DSCP_CS0":  0,
 231                 "IP_API_DSCP_CS1":  8,
 232                 "IP_API_DSCP_AF11": 10,
 233                 "IP_API_DSCP_AF12": 12,
 234                 "IP_API_DSCP_AF13": 14,
 235                 "IP_API_DSCP_CS2":  16,
 236                 "IP_API_DSCP_AF21": 18,
 237                 "IP_API_DSCP_AF22": 20,
 238                 "IP_API_DSCP_AF23": 22,
 239                 "IP_API_DSCP_CS3":  24,
 240                 "IP_API_DSCP_AF31": 26,
 241                 "IP_API_DSCP_AF32": 28,
 242                 "IP_API_DSCP_AF33": 30,
 243                 "IP_API_DSCP_CS4":  32,
 244                 "IP_API_DSCP_AF41": 34,
 245                 "IP_API_DSCP_AF42": 36,
 246                 "IP_API_DSCP_AF43": 38,
 247                 "IP_API_DSCP_CS5":  40,
 248                 "IP_API_DSCP_EF":   46,
 249                 "IP_API_DSCP_CS6":  48,
 250                 "IP_API_DSCP_CS7":  50,
 251         }
 252 )
 253
 254 func (x IPDscp) String() string {
 255         s, ok := IPDscp_name[uint8(x)]
 256         if ok {
 257                 return s
 258         }
 259         return "IPDscp(" + strconv.Itoa(int(x)) + ")"
 260 }
 261
 262 // IPEcn defines enum 'ip_ecn'.
 263 type IPEcn uint8
 264
 265 const (
 266         IP_API_ECN_NONE IPEcn = 0
 267         IP_API_ECN_ECT0 IPEcn = 1
 268         IP_API_ECN_ECT1 IPEcn = 2
 269         IP_API_ECN_CE   IPEcn = 3
 270 )
 271
 272 var (
 273         IPEcn_name = map[uint8]string{
 274                 0: "IP_API_ECN_NONE",
 275                 1: "IP_API_ECN_ECT0",
 276                 2: "IP_API_ECN_ECT1",
 277                 3: "IP_API_ECN_CE",
 278         }
 279         IPEcn_value = map[string]uint8{
 280                 "IP_API_ECN_NONE": 0,
 281                 "IP_API_ECN_ECT0": 1,
 282                 "IP_API_ECN_ECT1": 2,
 283                 "IP_API_ECN_CE":   3,
 284         }
 285 )
 286
 287 func (x IPEcn) String() string {
 288         s, ok := IPEcn_name[uint8(x)]
 289         if ok {
 290                 return s
 291         }
 292         return "IPEcn(" + strconv.Itoa(int(x)) + ")"
 293 }
 294
 295 // IPProto defines enum 'ip_proto'.
 296 type IPProto uint32
 297
 298 const (
 299         IP_API_PROTO_HOPOPT   IPProto = 0
 300         IP_API_PROTO_ICMP     IPProto = 1
 301         IP_API_PROTO_IGMP     IPProto = 2
 302         IP_API_PROTO_TCP      IPProto = 6
 303         IP_API_PROTO_UDP      IPProto = 17
 304         IP_API_PROTO_GRE      IPProto = 47
 305         IP_API_PROTO_AH       IPProto = 50
 306         IP_API_PROTO_ESP      IPProto = 51
 307         IP_API_PROTO_EIGRP    IPProto = 88
 308         IP_API_PROTO_OSPF     IPProto = 89
 309         IP_API_PROTO_SCTP     IPProto = 132
 310         IP_API_PROTO_RESERVED IPProto = 255
 311 )
 312
 313 var (
 314         IPProto_name = map[uint32]string{
 315                 0:   "IP_API_PROTO_HOPOPT",
 316                 1:   "IP_API_PROTO_ICMP",
 317                 2:   "IP_API_PROTO_IGMP",
 318                 6:   "IP_API_PROTO_TCP",
 319                 17:  "IP_API_PROTO_UDP",
 320                 47:  "IP_API_PROTO_GRE",
 321                 50:  "IP_API_PROTO_AH",
 322                 51:  "IP_API_PROTO_ESP",
 323                 88:  "IP_API_PROTO_EIGRP",
 324                 89:  "IP_API_PROTO_OSPF",
 325                 132: "IP_API_PROTO_SCTP",
 326                 255: "IP_API_PROTO_RESERVED",
 327         }
 328         IPProto_value = map[string]uint32{
 329                 "IP_API_PROTO_HOPOPT":   0,
 330                 "IP_API_PROTO_ICMP":     1,
 331                 "IP_API_PROTO_IGMP":     2,
 332                 "IP_API_PROTO_TCP":      6,
 333                 "IP_API_PROTO_UDP":      17,
 334                 "IP_API_PROTO_GRE":      47,
 335                 "IP_API_PROTO_AH":       50,
 336                 "IP_API_PROTO_ESP":      51,
 337                 "IP_API_PROTO_EIGRP":    88,
 338                 "IP_API_PROTO_OSPF":     89,
 339                 "IP_API_PROTO_SCTP":     132,
 340                 "IP_API_PROTO_RESERVED": 255,
 341         }
 342 )
 343
 344 func (x IPProto) String() string {
 345         s, ok := IPProto_name[uint32(x)]
 346         if ok {
 347                 return s
 348         }
 349         return "IPProto(" + strconv.Itoa(int(x)) + ")"
 350 }
 351
 352 // LinkDuplex defines enum 'link_duplex'.
 353 type LinkDuplex uint32
 354
 355 const (
 356         LINK_DUPLEX_API_UNKNOWN LinkDuplex = 0
 357         LINK_DUPLEX_API_HALF    LinkDuplex = 1
 358         LINK_DUPLEX_API_FULL    LinkDuplex = 2
 359 )
 360
 361 var (
 362         LinkDuplex_name = map[uint32]string{
 363                 0: "LINK_DUPLEX_API_UNKNOWN",
 364                 1: "LINK_DUPLEX_API_HALF",
 365                 2: "LINK_DUPLEX_API_FULL",
 366         }
 367         LinkDuplex_value = map[string]uint32{
 368                 "LINK_DUPLEX_API_UNKNOWN": 0,
 369                 "LINK_DUPLEX_API_HALF":    1,
 370                 "LINK_DUPLEX_API_FULL":    2,
 371         }
 372 )
 373
 374 func (x LinkDuplex) String() string {
 375         s, ok := LinkDuplex_name[uint32(x)]
 376         if ok {
 377                 return s
 378         }
 379         return "LinkDuplex(" + strconv.Itoa(int(x)) + ")"
 380 }
 381
 382 // MtuProto defines enum 'mtu_proto'.
 383 type MtuProto uint32
 384
 385 const (
 386         MTU_PROTO_API_L3   MtuProto = 1
 387         MTU_PROTO_API_IP4  MtuProto = 2
 388         MTU_PROTO_API_IP6  MtuProto = 3
 389         MTU_PROTO_API_MPLS MtuProto = 4
 390         MTU_PROTO_API_N    MtuProto = 5
 391 )
 392
 393 var (
 394         MtuProto_name = map[uint32]string{
 395                 1: "MTU_PROTO_API_L3",
 396                 2: "MTU_PROTO_API_IP4",
 397                 3: "MTU_PROTO_API_IP6",
 398                 4: "MTU_PROTO_API_MPLS",
 399                 5: "MTU_PROTO_API_N",
 400         }
 401         MtuProto_value = map[string]uint32{
 402                 "MTU_PROTO_API_L3":   1,
 403                 "MTU_PROTO_API_IP4":  2,
 404                 "MTU_PROTO_API_IP6":  3,
 405                 "MTU_PROTO_API_MPLS": 4,
 406                 "MTU_PROTO_API_N":    5,
 407         }
 408 )
 409
 410 func (x MtuProto) String() string {
 411         s, ok := MtuProto_name[uint32(x)]
 412         if ok {
 413                 return s
 414         }
 415         return "MtuProto(" + strconv.Itoa(int(x)) + ")"
 416 }
 417
 418 // RxMode defines enum 'rx_mode'.
 419 type RxMode uint32
 420
 421 const (
 422         RX_MODE_API_UNKNOWN   RxMode = 0
 423         RX_MODE_API_POLLING   RxMode = 1
 424         RX_MODE_API_INTERRUPT RxMode = 2
 425         RX_MODE_API_ADAPTIVE  RxMode = 3
 426         RX_MODE_API_DEFAULT   RxMode = 4
 427 )
 428
 429 var (
 430         RxMode_name = map[uint32]string{
 431                 0: "RX_MODE_API_UNKNOWN",
 432                 1: "RX_MODE_API_POLLING",
 433                 2: "RX_MODE_API_INTERRUPT",
 434                 3: "RX_MODE_API_ADAPTIVE",
 435                 4: "RX_MODE_API_DEFAULT",
 436         }
 437         RxMode_value = map[string]uint32{
 438                 "RX_MODE_API_UNKNOWN":   0,
 439                 "RX_MODE_API_POLLING":   1,
 440                 "RX_MODE_API_INTERRUPT": 2,
 441                 "RX_MODE_API_ADAPTIVE":  3,
 442                 "RX_MODE_API_DEFAULT":   4,
 443         }
 444 )
 445
 446 func (x RxMode) String() string {
 447         s, ok := RxMode_name[uint32(x)]
 448         if ok {
 449                 return s
 450         }
 451         return "RxMode(" + strconv.Itoa(int(x)) + ")"
 452 }
 453
 454 // SubIfFlags defines enum 'sub_if_flags'.
 455 type SubIfFlags uint32
 456
 457 const (
 458         SUB_IF_API_FLAG_NO_TAGS           SubIfFlags = 1
 459         SUB_IF_API_FLAG_ONE_TAG           SubIfFlags = 2
 460         SUB_IF_API_FLAG_TWO_TAGS          SubIfFlags = 4
 461         SUB_IF_API_FLAG_DOT1AD            SubIfFlags = 8
 462         SUB_IF_API_FLAG_EXACT_MATCH       SubIfFlags = 16
 463         SUB_IF_API_FLAG_DEFAULT           SubIfFlags = 32
 464         SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY SubIfFlags = 64
 465         SUB_IF_API_FLAG_INNER_VLAN_ID_ANY SubIfFlags = 128
 466         SUB_IF_API_FLAG_MASK_VNET         SubIfFlags = 254
 467         SUB_IF_API_FLAG_DOT1AH            SubIfFlags = 256
 468 )
 469
 470 var (
 471         SubIfFlags_name = map[uint32]string{
 472                 1:   "SUB_IF_API_FLAG_NO_TAGS",
 473                 2:   "SUB_IF_API_FLAG_ONE_TAG",
 474                 4:   "SUB_IF_API_FLAG_TWO_TAGS",
 475                 8:   "SUB_IF_API_FLAG_DOT1AD",
 476                 16:  "SUB_IF_API_FLAG_EXACT_MATCH",
 477                 32:  "SUB_IF_API_FLAG_DEFAULT",
 478                 64:  "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY",
 479                 128: "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY",
 480                 254: "SUB_IF_API_FLAG_MASK_VNET",
 481                 256: "SUB_IF_API_FLAG_DOT1AH",
 482         }
 483         SubIfFlags_value = map[string]uint32{
 484                 "SUB_IF_API_FLAG_NO_TAGS":           1,
 485                 "SUB_IF_API_FLAG_ONE_TAG":           2,
 486                 "SUB_IF_API_FLAG_TWO_TAGS":          4,
 487                 "SUB_IF_API_FLAG_DOT1AD":            8,
 488                 "SUB_IF_API_FLAG_EXACT_MATCH":       16,
 489                 "SUB_IF_API_FLAG_DEFAULT":           32,
 490                 "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY": 64,
 491                 "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY": 128,
 492                 "SUB_IF_API_FLAG_MASK_VNET":         254,
 493                 "SUB_IF_API_FLAG_DOT1AH":            256,
 494         }
 495 )
 496
 497 func (x SubIfFlags) String() string {
 498         s, ok := SubIfFlags_name[uint32(x)]
 499         if ok {
 500                 return s
 501         }
 502         str := func(n uint32) string {
 503                 s, ok := SubIfFlags_name[uint32(n)]
 504                 if ok {
 505                         return s
 506                 }
 507                 return "SubIfFlags(" + strconv.Itoa(int(n)) + ")"
 508         }
 509         for i := uint32(0); i <= 32; i++ {
 510                 val := uint32(x)
 511                 if val&(1<<i) != 0 {
 512                         if s != "" {
 513                                 s += "|"
 514                         }
 515                         s += str(1 << i)
 516                 }
 517         }
 518         if s == "" {
 519                 return str(uint32(x))
 520         }
 521         return s
 522 }
 523
 524 // AddressWithPrefix defines alias 'address_with_prefix'.
 525 type AddressWithPrefix Prefix
 526
 527 func ParseAddressWithPrefix(s string) (AddressWithPrefix, error) {
 528         prefix, err := ParsePrefix(s)
 529         if err != nil {
 530                 return AddressWithPrefix{}, err
 531         }
 532         return AddressWithPrefix(prefix), nil
 533 }
 534 func (x AddressWithPrefix) String() string {
 535         return Prefix(x).String()
 536 }
 537 func (x *AddressWithPrefix) MarshalText() ([]byte, error) {
 538         return []byte(x.String()), nil
 539 }
 540 func (x *AddressWithPrefix) UnmarshalText(text []byte) error {
 541         prefix, err := ParseAddressWithPrefix(string(text))
 542         if err != nil {
 543                 return err
 544         }
 545         *x = prefix
 546         return nil
 547 }
 548
 549 // InterfaceIndex defines alias 'interface_index'.
 550 type InterfaceIndex uint32
 551
 552 // IP4Address defines alias 'ip4_address'.
 553 type IP4Address [4]uint8
 554
 555 func ParseIP4Address(s string) (IP4Address, error) {
 556         ip := net.ParseIP(s).To4()
 557         if ip == nil {
 558                 return IP4Address{}, fmt.Errorf("invalid IP address: %s", s)
 559         }
 560         var ipaddr IP4Address
 561         copy(ipaddr[:], ip.To4())
 562         return ipaddr, nil
 563 }
 564
 565 func (x IP4Address) ToIP() net.IP {
 566         return net.IP(x[:]).To4()
 567 }
 568 func (x IP4Address) String() string {
 569         return x.ToIP().String()
 570 }
 571 func (x *IP4Address) MarshalText() ([]byte, error) {
 572         return []byte(x.String()), nil
 573 }
 574 func (x *IP4Address) UnmarshalText(text []byte) error {
 575         ipaddr, err := ParseIP4Address(string(text))
 576         if err != nil {
 577                 return err
 578         }
 579         *x = ipaddr
 580         return nil
 581 }
 582
 583 // IP4AddressWithPrefix defines alias 'ip4_address_with_prefix'.
 584 type IP4AddressWithPrefix IP4Prefix
 585
 586 // IP6Address defines alias 'ip6_address'.
 587 type IP6Address [16]uint8
 588
 589 func ParseIP6Address(s string) (IP6Address, error) {
 590         ip := net.ParseIP(s).To16()
 591         if ip == nil {
 592                 return IP6Address{}, fmt.Errorf("invalid IP address: %s", s)
 593         }
 594         var ipaddr IP6Address
 595         copy(ipaddr[:], ip.To16())
 596         return ipaddr, nil
 597 }
 598
 599 func (x IP6Address) ToIP() net.IP {
 600         return net.IP(x[:]).To16()
 601 }
 602 func (x IP6Address) String() string {
 603         return x.ToIP().String()
 604 }
 605 func (x *IP6Address) MarshalText() ([]byte, error) {
 606         return []byte(x.String()), nil
 607 }
 608 func (x *IP6Address) UnmarshalText(text []byte) error {
 609         ipaddr, err := ParseIP6Address(string(text))
 610         if err != nil {
 611                 return err
 612         }
 613         *x = ipaddr
 614         return nil
 615 }
 616
 617 // IP6AddressWithPrefix defines alias 'ip6_address_with_prefix'.
 618 type IP6AddressWithPrefix IP6Prefix
 619
 620 // Address defines type 'address'.
 621 type Address struct {
 622         Af AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 623         Un AddressUnion  `binapi:"address_union,name=un" json:"un,omitempty"`
 624 }
 625
 626 func ParseAddress(s string) (Address, error) {
 627         ip := net.ParseIP(s)
 628         if ip == nil {
 629                 return Address{}, fmt.Errorf("invalid address: %s", s)
 630         }
 631         var addr Address
 632         if ip.To4() == nil {
 633                 addr.Af = ADDRESS_IP6
 634                 var ip6 IP6Address
 635                 copy(ip6[:], ip.To16())
 636                 addr.Un.SetIP6(ip6)
 637         } else {
 638                 addr.Af = ADDRESS_IP4
 639                 var ip4 IP4Address
 640                 copy(ip4[:], ip.To4())
 641                 addr.Un.SetIP4(ip4)
 642         }
 643         return addr, nil
 644 }
 645 func (x Address) ToIP() net.IP {
 646         if x.Af == ADDRESS_IP6 {
 647                 ip6 := x.Un.GetIP6()
 648                 return net.IP(ip6[:]).To16()
 649         } else {
 650                 ip4 := x.Un.GetIP4()
 651                 return net.IP(ip4[:]).To4()
 652         }
 653 }
 654 func (x Address) String() string {
 655         return x.ToIP().String()
 656 }
 657 func (x *Address) MarshalText() ([]byte, error) {
 658         return []byte(x.String()), nil
 659 }
 660 func (x *Address) UnmarshalText(text []byte) error {
 661         addr, err := ParseAddress(string(text))
 662         if err != nil {
 663                 return err
 664         }
 665         *x = addr
 666         return nil
 667 }
 668
 669 // IP4Prefix defines type 'ip4_prefix'.
 670 type IP4Prefix struct {
 671         Address IP4Address `binapi:"ip4_address,name=address" json:"address,omitempty"`
 672         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 673 }
 674
 675 func ParseIP4Prefix(s string) (prefix IP4Prefix, err error) {
 676         hasPrefix := strings.Contains(s, "/")
 677         if hasPrefix {
 678                 ip, network, err := net.ParseCIDR(s)
 679                 if err != nil {
 680                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 681                 }
 682                 maskSize, _ := network.Mask.Size()
 683                 prefix.Len = byte(maskSize)
 684                 prefix.Address, err = ParseIP4Address(ip.String())
 685                 if err != nil {
 686                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 687                 }
 688         } else {
 689                 ip := net.ParseIP(s)
 690                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 691                 if ip.To4() == nil {
 692                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 693                 }
 694                 prefix.Len = byte(defaultMaskSize)
 695                 prefix.Address, err = ParseIP4Address(ip.String())
 696                 if err != nil {
 697                         return IP4Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 698                 }
 699         }
 700         return prefix, nil
 701 }
 702 func (x IP4Prefix) ToIPNet() *net.IPNet {
 703         mask := net.CIDRMask(int(x.Len), 32)
 704         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 705         return ipnet
 706 }
 707 func (x IP4Prefix) String() string {
 708         ip := x.Address.String()
 709         return ip + "/" + strconv.Itoa(int(x.Len))
 710 }
 711 func (x *IP4Prefix) MarshalText() ([]byte, error) {
 712         return []byte(x.String()), nil
 713 }
 714 func (x *IP4Prefix) UnmarshalText(text []byte) error {
 715         prefix, err := ParseIP4Prefix(string(text))
 716         if err != nil {
 717                 return err
 718         }
 719         *x = prefix
 720         return nil
 721 }
 722
 723 // IP6Prefix defines type 'ip6_prefix'.
 724 type IP6Prefix struct {
 725         Address IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 726         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 727 }
 728
 729 func ParseIP6Prefix(s string) (prefix IP6Prefix, err error) {
 730         hasPrefix := strings.Contains(s, "/")
 731         if hasPrefix {
 732                 ip, network, err := net.ParseCIDR(s)
 733                 if err != nil {
 734                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 735                 }
 736                 maskSize, _ := network.Mask.Size()
 737                 prefix.Len = byte(maskSize)
 738                 prefix.Address, err = ParseIP6Address(ip.String())
 739                 if err != nil {
 740                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 741                 }
 742         } else {
 743                 ip := net.ParseIP(s)
 744                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 745                 if ip.To4() == nil {
 746                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 747                 }
 748                 prefix.Len = byte(defaultMaskSize)
 749                 prefix.Address, err = ParseIP6Address(ip.String())
 750                 if err != nil {
 751                         return IP6Prefix{}, fmt.Errorf("invalid IP %s: %s", s, err)
 752                 }
 753         }
 754         return prefix, nil
 755 }
 756 func (x IP6Prefix) ToIPNet() *net.IPNet {
 757         mask := net.CIDRMask(int(x.Len), 128)
 758         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 759         return ipnet
 760 }
 761 func (x IP6Prefix) String() string {
 762         ip := x.Address.String()
 763         return ip + "/" + strconv.Itoa(int(x.Len))
 764 }
 765 func (x *IP6Prefix) MarshalText() ([]byte, error) {
 766         return []byte(x.String()), nil
 767 }
 768 func (x *IP6Prefix) UnmarshalText(text []byte) error {
 769         prefix, err := ParseIP6Prefix(string(text))
 770         if err != nil {
 771                 return err
 772         }
 773         *x = prefix
 774         return nil
 775 }
 776
 777 // Mprefix defines type 'mprefix'.
 778 type Mprefix struct {
 779         Af               AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 780         GrpAddressLength uint16        `binapi:"u16,name=grp_address_length" json:"grp_address_length,omitempty"`
 781         GrpAddress       AddressUnion  `binapi:"address_union,name=grp_address" json:"grp_address,omitempty"`
 782         SrcAddress       AddressUnion  `binapi:"address_union,name=src_address" json:"src_address,omitempty"`
 783 }
 784
 785 // Prefix defines type 'prefix'.
 786 type Prefix struct {
 787         Address Address `binapi:"address,name=address" json:"address,omitempty"`
 788         Len     uint8   `binapi:"u8,name=len" json:"len,omitempty"`
 789 }
 790
 791 func ParsePrefix(ip string) (prefix Prefix, err error) {
 792         hasPrefix := strings.Contains(ip, "/")
 793         if hasPrefix {
 794                 netIP, network, err := net.ParseCIDR(ip)
 795                 if err != nil {
 796                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 797                 }
 798                 maskSize, _ := network.Mask.Size()
 799                 prefix.Len = byte(maskSize)
 800                 prefix.Address, err = ParseAddress(netIP.String())
 801                 if err != nil {
 802                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 803                 }
 804         } else {
 805                 netIP := net.ParseIP(ip)
 806                 defaultMaskSize, _ := net.CIDRMask(32, 32).Size()
 807                 if netIP.To4() == nil {
 808                         defaultMaskSize, _ = net.CIDRMask(128, 128).Size()
 809                 }
 810                 prefix.Len = byte(defaultMaskSize)
 811                 prefix.Address, err = ParseAddress(netIP.String())
 812                 if err != nil {
 813                         return Prefix{}, fmt.Errorf("invalid IP %s: %s", ip, err)
 814                 }
 815         }
 816         return prefix, nil
 817 }
 818 func (x Prefix) ToIPNet() *net.IPNet {
 819         var mask net.IPMask
 820         if x.Address.Af == ADDRESS_IP4 {
 821                 mask = net.CIDRMask(int(x.Len), 32)
 822         } else {
 823                 mask = net.CIDRMask(int(x.Len), 128)
 824         }
 825         ipnet := &net.IPNet{IP: x.Address.ToIP(), Mask: mask}
 826         return ipnet
 827 }
 828 func (x Prefix) String() string {
 829         ip := x.Address.String()
 830         return ip + "/" + strconv.Itoa(int(x.Len))
 831 }
 832 func (x *Prefix) MarshalText() ([]byte, error) {
 833         return []byte(x.String()), nil
 834 }
 835 func (x *Prefix) UnmarshalText(text []byte) error {
 836         prefix, err := ParsePrefix(string(text))
 837         if err != nil {
 838                 return err
 839         }
 840         *x = prefix
 841         return nil
 842 }
 843
 844 // PrefixMatcher defines type 'prefix_matcher'.
 845 type PrefixMatcher struct {
 846         Le uint8 `binapi:"u8,name=le" json:"le,omitempty"`
 847         Ge uint8 `binapi:"u8,name=ge" json:"ge,omitempty"`
 848 }
 849
 850 // AddressUnion defines union 'address_union'.
 851 type AddressUnion struct {
 852         // IP4 *IP4Address
 853         // IP6 *IP6Address
 854         XXX_UnionData [16]byte
 855 }
 856
 857 func AddressUnionIP4(a IP4Address) (u AddressUnion) {
 858         u.SetIP4(a)
 859         return
 860 }
 861 func (u *AddressUnion) SetIP4(a IP4Address) {
 862         buf := codec.NewBuffer(u.XXX_UnionData[:])
 863         buf.EncodeBytes(a[:], 4)
 864 }
 865 func (u *AddressUnion) GetIP4() (a IP4Address) {
 866         buf := codec.NewBuffer(u.XXX_UnionData[:])
 867         copy(a[:], buf.DecodeBytes(4))
 868         return
 869 }
 870
 871 func AddressUnionIP6(a IP6Address) (u AddressUnion) {
 872         u.SetIP6(a)
 873         return
 874 }
 875 func (u *AddressUnion) SetIP6(a IP6Address) {
 876         buf := codec.NewBuffer(u.XXX_UnionData[:])
 877         buf.EncodeBytes(a[:], 16)
 878 }
 879 func (u *AddressUnion) GetIP6() (a IP6Address) {
 880         buf := codec.NewBuffer(u.XXX_UnionData[:])
 881         copy(a[:], buf.DecodeBytes(16))
 882         return
 883 }
 884
 885 // BfdAuthDelKey defines message 'bfd_auth_del_key'.
 886 type BfdAuthDelKey struct {
 887         ConfKeyID uint32 `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
 888 }
 889
 890 func (m *BfdAuthDelKey) Reset()               { *m = BfdAuthDelKey{} }
 891 func (*BfdAuthDelKey) GetMessageName() string { return "bfd_auth_del_key" }
 892 func (*BfdAuthDelKey) GetCrcString() string   { return "65310b22" }
 893 func (*BfdAuthDelKey) GetMessageType() api.MessageType {
 894         return api.RequestMessage
 895 }
 896
 897 func (m *BfdAuthDelKey) Size() (size int) {
 898         if m == nil {
 899                 return 0
 900         }
 901         size += 4 // m.ConfKeyID
 902         return size
 903 }
 904 func (m *BfdAuthDelKey) Marshal(b []byte) ([]byte, error) {
 905         if b == nil {
 906                 b = make([]byte, m.Size())
 907         }
 908         buf := codec.NewBuffer(b)
 909         buf.EncodeUint32(m.ConfKeyID)
 910         return buf.Bytes(), nil
 911 }
 912 func (m *BfdAuthDelKey) Unmarshal(b []byte) error {
 913         buf := codec.NewBuffer(b)
 914         m.ConfKeyID = buf.DecodeUint32()
 915         return nil
 916 }
 917
 918 // BfdAuthDelKeyReply defines message 'bfd_auth_del_key_reply'.
 919 type BfdAuthDelKeyReply struct {
 920         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 921 }
 922
 923 func (m *BfdAuthDelKeyReply) Reset()               { *m = BfdAuthDelKeyReply{} }
 924 func (*BfdAuthDelKeyReply) GetMessageName() string { return "bfd_auth_del_key_reply" }
 925 func (*BfdAuthDelKeyReply) GetCrcString() string   { return "e8d4e804" }
 926 func (*BfdAuthDelKeyReply) GetMessageType() api.MessageType {
 927         return api.ReplyMessage
 928 }
 929
 930 func (m *BfdAuthDelKeyReply) Size() (size int) {
 931         if m == nil {
 932                 return 0
 933         }
 934         size += 4 // m.Retval
 935         return size
 936 }
 937 func (m *BfdAuthDelKeyReply) Marshal(b []byte) ([]byte, error) {
 938         if b == nil {
 939                 b = make([]byte, m.Size())
 940         }
 941         buf := codec.NewBuffer(b)
 942         buf.EncodeInt32(m.Retval)
 943         return buf.Bytes(), nil
 944 }
 945 func (m *BfdAuthDelKeyReply) Unmarshal(b []byte) error {
 946         buf := codec.NewBuffer(b)
 947         m.Retval = buf.DecodeInt32()
 948         return nil
 949 }
 950
 951 // BfdAuthKeysDetails defines message 'bfd_auth_keys_details'.
 952 type BfdAuthKeysDetails struct {
 953         ConfKeyID uint32 `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
 954         UseCount  uint32 `binapi:"u32,name=use_count" json:"use_count,omitempty"`
 955         AuthType  uint8  `binapi:"u8,name=auth_type" json:"auth_type,omitempty"`
 956 }
 957
 958 func (m *BfdAuthKeysDetails) Reset()               { *m = BfdAuthKeysDetails{} }
 959 func (*BfdAuthKeysDetails) GetMessageName() string { return "bfd_auth_keys_details" }
 960 func (*BfdAuthKeysDetails) GetCrcString() string   { return "84130e9f" }
 961 func (*BfdAuthKeysDetails) GetMessageType() api.MessageType {
 962         return api.ReplyMessage
 963 }
 964
 965 func (m *BfdAuthKeysDetails) Size() (size int) {
 966         if m == nil {
 967                 return 0
 968         }
 969         size += 4 // m.ConfKeyID
 970         size += 4 // m.UseCount
 971         size += 1 // m.AuthType
 972         return size
 973 }
 974 func (m *BfdAuthKeysDetails) Marshal(b []byte) ([]byte, error) {
 975         if b == nil {
 976                 b = make([]byte, m.Size())
 977         }
 978         buf := codec.NewBuffer(b)
 979         buf.EncodeUint32(m.ConfKeyID)
 980         buf.EncodeUint32(m.UseCount)
 981         buf.EncodeUint8(m.AuthType)
 982         return buf.Bytes(), nil
 983 }
 984 func (m *BfdAuthKeysDetails) Unmarshal(b []byte) error {
 985         buf := codec.NewBuffer(b)
 986         m.ConfKeyID = buf.DecodeUint32()
 987         m.UseCount = buf.DecodeUint32()
 988         m.AuthType = buf.DecodeUint8()
 989         return nil
 990 }
 991
 992 // BfdAuthKeysDump defines message 'bfd_auth_keys_dump'.
 993 type BfdAuthKeysDump struct{}
 994
 995 func (m *BfdAuthKeysDump) Reset()               { *m = BfdAuthKeysDump{} }
 996 func (*BfdAuthKeysDump) GetMessageName() string { return "bfd_auth_keys_dump" }
 997 func (*BfdAuthKeysDump) GetCrcString() string   { return "51077d14" }
 998 func (*BfdAuthKeysDump) GetMessageType() api.MessageType {
 999         return api.RequestMessage
1000 }
1001
1002 func (m *BfdAuthKeysDump) Size() (size int) {
1003         if m == nil {
1004                 return 0
1005         }
1006         return size
1007 }
1008 func (m *BfdAuthKeysDump) Marshal(b []byte) ([]byte, error) {
1009         if b == nil {
1010                 b = make([]byte, m.Size())
1011         }
1012         buf := codec.NewBuffer(b)
1013         return buf.Bytes(), nil
1014 }
1015 func (m *BfdAuthKeysDump) Unmarshal(b []byte) error {
1016         return nil
1017 }
1018
1019 // BfdAuthSetKey defines message 'bfd_auth_set_key'.
1020 type BfdAuthSetKey struct {
1021         ConfKeyID uint32 `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
1022         KeyLen    uint8  `binapi:"u8,name=key_len" json:"key_len,omitempty"`
1023         AuthType  uint8  `binapi:"u8,name=auth_type" json:"auth_type,omitempty"`
1024         Key       []byte `binapi:"u8[20],name=key" json:"key,omitempty"`
1025 }
1026
1027 func (m *BfdAuthSetKey) Reset()               { *m = BfdAuthSetKey{} }
1028 func (*BfdAuthSetKey) GetMessageName() string { return "bfd_auth_set_key" }
1029 func (*BfdAuthSetKey) GetCrcString() string   { return "690b8877" }
1030 func (*BfdAuthSetKey) GetMessageType() api.MessageType {
1031         return api.RequestMessage
1032 }
1033
1034 func (m *BfdAuthSetKey) Size() (size int) {
1035         if m == nil {
1036                 return 0
1037         }
1038         size += 4      // m.ConfKeyID
1039         size += 1      // m.KeyLen
1040         size += 1      // m.AuthType
1041         size += 1 * 20 // m.Key
1042         return size
1043 }
1044 func (m *BfdAuthSetKey) Marshal(b []byte) ([]byte, error) {
1045         if b == nil {
1046                 b = make([]byte, m.Size())
1047         }
1048         buf := codec.NewBuffer(b)
1049         buf.EncodeUint32(m.ConfKeyID)
1050         buf.EncodeUint8(m.KeyLen)
1051         buf.EncodeUint8(m.AuthType)
1052         buf.EncodeBytes(m.Key, 20)
1053         return buf.Bytes(), nil
1054 }
1055 func (m *BfdAuthSetKey) Unmarshal(b []byte) error {
1056         buf := codec.NewBuffer(b)
1057         m.ConfKeyID = buf.DecodeUint32()
1058         m.KeyLen = buf.DecodeUint8()
1059         m.AuthType = buf.DecodeUint8()
1060         m.Key = make([]byte, 20)
1061         copy(m.Key, buf.DecodeBytes(len(m.Key)))
1062         return nil
1063 }
1064
1065 // BfdAuthSetKeyReply defines message 'bfd_auth_set_key_reply'.
1066 type BfdAuthSetKeyReply struct {
1067         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1068 }
1069
1070 func (m *BfdAuthSetKeyReply) Reset()               { *m = BfdAuthSetKeyReply{} }
1071 func (*BfdAuthSetKeyReply) GetMessageName() string { return "bfd_auth_set_key_reply" }
1072 func (*BfdAuthSetKeyReply) GetCrcString() string   { return "e8d4e804" }
1073 func (*BfdAuthSetKeyReply) GetMessageType() api.MessageType {
1074         return api.ReplyMessage
1075 }
1076
1077 func (m *BfdAuthSetKeyReply) Size() (size int) {
1078         if m == nil {
1079                 return 0
1080         }
1081         size += 4 // m.Retval
1082         return size
1083 }
1084 func (m *BfdAuthSetKeyReply) Marshal(b []byte) ([]byte, error) {
1085         if b == nil {
1086                 b = make([]byte, m.Size())
1087         }
1088         buf := codec.NewBuffer(b)
1089         buf.EncodeInt32(m.Retval)
1090         return buf.Bytes(), nil
1091 }
1092 func (m *BfdAuthSetKeyReply) Unmarshal(b []byte) error {
1093         buf := codec.NewBuffer(b)
1094         m.Retval = buf.DecodeInt32()
1095         return nil
1096 }
1097
1098 // BfdUDPAdd defines message 'bfd_udp_add'.
1099 type BfdUDPAdd struct {
1100         SwIfIndex       InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1101         DesiredMinTx    uint32         `binapi:"u32,name=desired_min_tx" json:"desired_min_tx,omitempty"`
1102         RequiredMinRx   uint32         `binapi:"u32,name=required_min_rx" json:"required_min_rx,omitempty"`
1103         LocalAddr       Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1104         PeerAddr        Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1105         DetectMult      uint8          `binapi:"u8,name=detect_mult" json:"detect_mult,omitempty"`
1106         IsAuthenticated bool           `binapi:"bool,name=is_authenticated" json:"is_authenticated,omitempty"`
1107         BfdKeyID        uint8          `binapi:"u8,name=bfd_key_id" json:"bfd_key_id,omitempty"`
1108         ConfKeyID       uint32         `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
1109 }
1110
1111 func (m *BfdUDPAdd) Reset()               { *m = BfdUDPAdd{} }
1112 func (*BfdUDPAdd) GetMessageName() string { return "bfd_udp_add" }
1113 func (*BfdUDPAdd) GetCrcString() string   { return "7a6d1185" }
1114 func (*BfdUDPAdd) GetMessageType() api.MessageType {
1115         return api.RequestMessage
1116 }
1117
1118 func (m *BfdUDPAdd) Size() (size int) {
1119         if m == nil {
1120                 return 0
1121         }
1122         size += 4      // m.SwIfIndex
1123         size += 4      // m.DesiredMinTx
1124         size += 4      // m.RequiredMinRx
1125         size += 4      // m.LocalAddr.Af
1126         size += 1 * 16 // m.LocalAddr.Un
1127         size += 4      // m.PeerAddr.Af
1128         size += 1 * 16 // m.PeerAddr.Un
1129         size += 1      // m.DetectMult
1130         size += 1      // m.IsAuthenticated
1131         size += 1      // m.BfdKeyID
1132         size += 4      // m.ConfKeyID
1133         return size
1134 }
1135 func (m *BfdUDPAdd) Marshal(b []byte) ([]byte, error) {
1136         if b == nil {
1137                 b = make([]byte, m.Size())
1138         }
1139         buf := codec.NewBuffer(b)
1140         buf.EncodeUint32(uint32(m.SwIfIndex))
1141         buf.EncodeUint32(m.DesiredMinTx)
1142         buf.EncodeUint32(m.RequiredMinRx)
1143         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1144         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1145         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1146         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1147         buf.EncodeUint8(m.DetectMult)
1148         buf.EncodeBool(m.IsAuthenticated)
1149         buf.EncodeUint8(m.BfdKeyID)
1150         buf.EncodeUint32(m.ConfKeyID)
1151         return buf.Bytes(), nil
1152 }
1153 func (m *BfdUDPAdd) Unmarshal(b []byte) error {
1154         buf := codec.NewBuffer(b)
1155         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1156         m.DesiredMinTx = buf.DecodeUint32()
1157         m.RequiredMinRx = buf.DecodeUint32()
1158         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1159         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1160         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1161         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1162         m.DetectMult = buf.DecodeUint8()
1163         m.IsAuthenticated = buf.DecodeBool()
1164         m.BfdKeyID = buf.DecodeUint8()
1165         m.ConfKeyID = buf.DecodeUint32()
1166         return nil
1167 }
1168
1169 // BfdUDPAddReply defines message 'bfd_udp_add_reply'.
1170 type BfdUDPAddReply struct {
1171         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1172 }
1173
1174 func (m *BfdUDPAddReply) Reset()               { *m = BfdUDPAddReply{} }
1175 func (*BfdUDPAddReply) GetMessageName() string { return "bfd_udp_add_reply" }
1176 func (*BfdUDPAddReply) GetCrcString() string   { return "e8d4e804" }
1177 func (*BfdUDPAddReply) GetMessageType() api.MessageType {
1178         return api.ReplyMessage
1179 }
1180
1181 func (m *BfdUDPAddReply) Size() (size int) {
1182         if m == nil {
1183                 return 0
1184         }
1185         size += 4 // m.Retval
1186         return size
1187 }
1188 func (m *BfdUDPAddReply) Marshal(b []byte) ([]byte, error) {
1189         if b == nil {
1190                 b = make([]byte, m.Size())
1191         }
1192         buf := codec.NewBuffer(b)
1193         buf.EncodeInt32(m.Retval)
1194         return buf.Bytes(), nil
1195 }
1196 func (m *BfdUDPAddReply) Unmarshal(b []byte) error {
1197         buf := codec.NewBuffer(b)
1198         m.Retval = buf.DecodeInt32()
1199         return nil
1200 }
1201
1202 // BfdUDPAuthActivate defines message 'bfd_udp_auth_activate'.
1203 type BfdUDPAuthActivate struct {
1204         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1205         LocalAddr Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1206         PeerAddr  Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1207         IsDelayed bool           `binapi:"bool,name=is_delayed" json:"is_delayed,omitempty"`
1208         BfdKeyID  uint8          `binapi:"u8,name=bfd_key_id" json:"bfd_key_id,omitempty"`
1209         ConfKeyID uint32         `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
1210 }
1211
1212 func (m *BfdUDPAuthActivate) Reset()               { *m = BfdUDPAuthActivate{} }
1213 func (*BfdUDPAuthActivate) GetMessageName() string { return "bfd_udp_auth_activate" }
1214 func (*BfdUDPAuthActivate) GetCrcString() string   { return "493ee0ec" }
1215 func (*BfdUDPAuthActivate) GetMessageType() api.MessageType {
1216         return api.RequestMessage
1217 }
1218
1219 func (m *BfdUDPAuthActivate) Size() (size int) {
1220         if m == nil {
1221                 return 0
1222         }
1223         size += 4      // m.SwIfIndex
1224         size += 4      // m.LocalAddr.Af
1225         size += 1 * 16 // m.LocalAddr.Un
1226         size += 4      // m.PeerAddr.Af
1227         size += 1 * 16 // m.PeerAddr.Un
1228         size += 1      // m.IsDelayed
1229         size += 1      // m.BfdKeyID
1230         size += 4      // m.ConfKeyID
1231         return size
1232 }
1233 func (m *BfdUDPAuthActivate) Marshal(b []byte) ([]byte, error) {
1234         if b == nil {
1235                 b = make([]byte, m.Size())
1236         }
1237         buf := codec.NewBuffer(b)
1238         buf.EncodeUint32(uint32(m.SwIfIndex))
1239         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1240         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1241         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1242         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1243         buf.EncodeBool(m.IsDelayed)
1244         buf.EncodeUint8(m.BfdKeyID)
1245         buf.EncodeUint32(m.ConfKeyID)
1246         return buf.Bytes(), nil
1247 }
1248 func (m *BfdUDPAuthActivate) Unmarshal(b []byte) error {
1249         buf := codec.NewBuffer(b)
1250         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1251         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1252         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1253         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1254         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1255         m.IsDelayed = buf.DecodeBool()
1256         m.BfdKeyID = buf.DecodeUint8()
1257         m.ConfKeyID = buf.DecodeUint32()
1258         return nil
1259 }
1260
1261 // BfdUDPAuthActivateReply defines message 'bfd_udp_auth_activate_reply'.
1262 type BfdUDPAuthActivateReply struct {
1263         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1264 }
1265
1266 func (m *BfdUDPAuthActivateReply) Reset()               { *m = BfdUDPAuthActivateReply{} }
1267 func (*BfdUDPAuthActivateReply) GetMessageName() string { return "bfd_udp_auth_activate_reply" }
1268 func (*BfdUDPAuthActivateReply) GetCrcString() string   { return "e8d4e804" }
1269 func (*BfdUDPAuthActivateReply) GetMessageType() api.MessageType {
1270         return api.ReplyMessage
1271 }
1272
1273 func (m *BfdUDPAuthActivateReply) Size() (size int) {
1274         if m == nil {
1275                 return 0
1276         }
1277         size += 4 // m.Retval
1278         return size
1279 }
1280 func (m *BfdUDPAuthActivateReply) Marshal(b []byte) ([]byte, error) {
1281         if b == nil {
1282                 b = make([]byte, m.Size())
1283         }
1284         buf := codec.NewBuffer(b)
1285         buf.EncodeInt32(m.Retval)
1286         return buf.Bytes(), nil
1287 }
1288 func (m *BfdUDPAuthActivateReply) Unmarshal(b []byte) error {
1289         buf := codec.NewBuffer(b)
1290         m.Retval = buf.DecodeInt32()
1291         return nil
1292 }
1293
1294 // BfdUDPAuthDeactivate defines message 'bfd_udp_auth_deactivate'.
1295 type BfdUDPAuthDeactivate struct {
1296         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1297         LocalAddr Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1298         PeerAddr  Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1299         IsDelayed bool           `binapi:"bool,name=is_delayed" json:"is_delayed,omitempty"`
1300 }
1301
1302 func (m *BfdUDPAuthDeactivate) Reset()               { *m = BfdUDPAuthDeactivate{} }
1303 func (*BfdUDPAuthDeactivate) GetMessageName() string { return "bfd_udp_auth_deactivate" }
1304 func (*BfdUDPAuthDeactivate) GetCrcString() string   { return "99978c32" }
1305 func (*BfdUDPAuthDeactivate) GetMessageType() api.MessageType {
1306         return api.RequestMessage
1307 }
1308
1309 func (m *BfdUDPAuthDeactivate) Size() (size int) {
1310         if m == nil {
1311                 return 0
1312         }
1313         size += 4      // m.SwIfIndex
1314         size += 4      // m.LocalAddr.Af
1315         size += 1 * 16 // m.LocalAddr.Un
1316         size += 4      // m.PeerAddr.Af
1317         size += 1 * 16 // m.PeerAddr.Un
1318         size += 1      // m.IsDelayed
1319         return size
1320 }
1321 func (m *BfdUDPAuthDeactivate) Marshal(b []byte) ([]byte, error) {
1322         if b == nil {
1323                 b = make([]byte, m.Size())
1324         }
1325         buf := codec.NewBuffer(b)
1326         buf.EncodeUint32(uint32(m.SwIfIndex))
1327         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1328         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1329         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1330         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1331         buf.EncodeBool(m.IsDelayed)
1332         return buf.Bytes(), nil
1333 }
1334 func (m *BfdUDPAuthDeactivate) Unmarshal(b []byte) error {
1335         buf := codec.NewBuffer(b)
1336         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1337         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1338         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1339         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1340         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1341         m.IsDelayed = buf.DecodeBool()
1342         return nil
1343 }
1344
1345 // BfdUDPAuthDeactivateReply defines message 'bfd_udp_auth_deactivate_reply'.
1346 type BfdUDPAuthDeactivateReply struct {
1347         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1348 }
1349
1350 func (m *BfdUDPAuthDeactivateReply) Reset()               { *m = BfdUDPAuthDeactivateReply{} }
1351 func (*BfdUDPAuthDeactivateReply) GetMessageName() string { return "bfd_udp_auth_deactivate_reply" }
1352 func (*BfdUDPAuthDeactivateReply) GetCrcString() string   { return "e8d4e804" }
1353 func (*BfdUDPAuthDeactivateReply) GetMessageType() api.MessageType {
1354         return api.ReplyMessage
1355 }
1356
1357 func (m *BfdUDPAuthDeactivateReply) Size() (size int) {
1358         if m == nil {
1359                 return 0
1360         }
1361         size += 4 // m.Retval
1362         return size
1363 }
1364 func (m *BfdUDPAuthDeactivateReply) Marshal(b []byte) ([]byte, error) {
1365         if b == nil {
1366                 b = make([]byte, m.Size())
1367         }
1368         buf := codec.NewBuffer(b)
1369         buf.EncodeInt32(m.Retval)
1370         return buf.Bytes(), nil
1371 }
1372 func (m *BfdUDPAuthDeactivateReply) Unmarshal(b []byte) error {
1373         buf := codec.NewBuffer(b)
1374         m.Retval = buf.DecodeInt32()
1375         return nil
1376 }
1377
1378 // BfdUDPDel defines message 'bfd_udp_del'.
1379 type BfdUDPDel struct {
1380         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1381         LocalAddr Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1382         PeerAddr  Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1383 }
1384
1385 func (m *BfdUDPDel) Reset()               { *m = BfdUDPDel{} }
1386 func (*BfdUDPDel) GetMessageName() string { return "bfd_udp_del" }
1387 func (*BfdUDPDel) GetCrcString() string   { return "8096514d" }
1388 func (*BfdUDPDel) GetMessageType() api.MessageType {
1389         return api.RequestMessage
1390 }
1391
1392 func (m *BfdUDPDel) Size() (size int) {
1393         if m == nil {
1394                 return 0
1395         }
1396         size += 4      // m.SwIfIndex
1397         size += 4      // m.LocalAddr.Af
1398         size += 1 * 16 // m.LocalAddr.Un
1399         size += 4      // m.PeerAddr.Af
1400         size += 1 * 16 // m.PeerAddr.Un
1401         return size
1402 }
1403 func (m *BfdUDPDel) Marshal(b []byte) ([]byte, error) {
1404         if b == nil {
1405                 b = make([]byte, m.Size())
1406         }
1407         buf := codec.NewBuffer(b)
1408         buf.EncodeUint32(uint32(m.SwIfIndex))
1409         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1410         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1411         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1412         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1413         return buf.Bytes(), nil
1414 }
1415 func (m *BfdUDPDel) Unmarshal(b []byte) error {
1416         buf := codec.NewBuffer(b)
1417         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1418         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1419         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1420         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1421         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1422         return nil
1423 }
1424
1425 // BfdUDPDelEchoSource defines message 'bfd_udp_del_echo_source'.
1426 type BfdUDPDelEchoSource struct{}
1427
1428 func (m *BfdUDPDelEchoSource) Reset()               { *m = BfdUDPDelEchoSource{} }
1429 func (*BfdUDPDelEchoSource) GetMessageName() string { return "bfd_udp_del_echo_source" }
1430 func (*BfdUDPDelEchoSource) GetCrcString() string   { return "51077d14" }
1431 func (*BfdUDPDelEchoSource) GetMessageType() api.MessageType {
1432         return api.RequestMessage
1433 }
1434
1435 func (m *BfdUDPDelEchoSource) Size() (size int) {
1436         if m == nil {
1437                 return 0
1438         }
1439         return size
1440 }
1441 func (m *BfdUDPDelEchoSource) Marshal(b []byte) ([]byte, error) {
1442         if b == nil {
1443                 b = make([]byte, m.Size())
1444         }
1445         buf := codec.NewBuffer(b)
1446         return buf.Bytes(), nil
1447 }
1448 func (m *BfdUDPDelEchoSource) Unmarshal(b []byte) error {
1449         return nil
1450 }
1451
1452 // BfdUDPDelEchoSourceReply defines message 'bfd_udp_del_echo_source_reply'.
1453 type BfdUDPDelEchoSourceReply struct {
1454         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1455 }
1456
1457 func (m *BfdUDPDelEchoSourceReply) Reset()               { *m = BfdUDPDelEchoSourceReply{} }
1458 func (*BfdUDPDelEchoSourceReply) GetMessageName() string { return "bfd_udp_del_echo_source_reply" }
1459 func (*BfdUDPDelEchoSourceReply) GetCrcString() string   { return "e8d4e804" }
1460 func (*BfdUDPDelEchoSourceReply) GetMessageType() api.MessageType {
1461         return api.ReplyMessage
1462 }
1463
1464 func (m *BfdUDPDelEchoSourceReply) Size() (size int) {
1465         if m == nil {
1466                 return 0
1467         }
1468         size += 4 // m.Retval
1469         return size
1470 }
1471 func (m *BfdUDPDelEchoSourceReply) Marshal(b []byte) ([]byte, error) {
1472         if b == nil {
1473                 b = make([]byte, m.Size())
1474         }
1475         buf := codec.NewBuffer(b)
1476         buf.EncodeInt32(m.Retval)
1477         return buf.Bytes(), nil
1478 }
1479 func (m *BfdUDPDelEchoSourceReply) Unmarshal(b []byte) error {
1480         buf := codec.NewBuffer(b)
1481         m.Retval = buf.DecodeInt32()
1482         return nil
1483 }
1484
1485 // BfdUDPDelReply defines message 'bfd_udp_del_reply'.
1486 type BfdUDPDelReply struct {
1487         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1488 }
1489
1490 func (m *BfdUDPDelReply) Reset()               { *m = BfdUDPDelReply{} }
1491 func (*BfdUDPDelReply) GetMessageName() string { return "bfd_udp_del_reply" }
1492 func (*BfdUDPDelReply) GetCrcString() string   { return "e8d4e804" }
1493 func (*BfdUDPDelReply) GetMessageType() api.MessageType {
1494         return api.ReplyMessage
1495 }
1496
1497 func (m *BfdUDPDelReply) Size() (size int) {
1498         if m == nil {
1499                 return 0
1500         }
1501         size += 4 // m.Retval
1502         return size
1503 }
1504 func (m *BfdUDPDelReply) Marshal(b []byte) ([]byte, error) {
1505         if b == nil {
1506                 b = make([]byte, m.Size())
1507         }
1508         buf := codec.NewBuffer(b)
1509         buf.EncodeInt32(m.Retval)
1510         return buf.Bytes(), nil
1511 }
1512 func (m *BfdUDPDelReply) Unmarshal(b []byte) error {
1513         buf := codec.NewBuffer(b)
1514         m.Retval = buf.DecodeInt32()
1515         return nil
1516 }
1517
1518 // BfdUDPGetEchoSource defines message 'bfd_udp_get_echo_source'.
1519 type BfdUDPGetEchoSource struct{}
1520
1521 func (m *BfdUDPGetEchoSource) Reset()               { *m = BfdUDPGetEchoSource{} }
1522 func (*BfdUDPGetEchoSource) GetMessageName() string { return "bfd_udp_get_echo_source" }
1523 func (*BfdUDPGetEchoSource) GetCrcString() string   { return "51077d14" }
1524 func (*BfdUDPGetEchoSource) GetMessageType() api.MessageType {
1525         return api.RequestMessage
1526 }
1527
1528 func (m *BfdUDPGetEchoSource) Size() (size int) {
1529         if m == nil {
1530                 return 0
1531         }
1532         return size
1533 }
1534 func (m *BfdUDPGetEchoSource) Marshal(b []byte) ([]byte, error) {
1535         if b == nil {
1536                 b = make([]byte, m.Size())
1537         }
1538         buf := codec.NewBuffer(b)
1539         return buf.Bytes(), nil
1540 }
1541 func (m *BfdUDPGetEchoSource) Unmarshal(b []byte) error {
1542         return nil
1543 }
1544
1545 // BfdUDPGetEchoSourceReply defines message 'bfd_udp_get_echo_source_reply'.
1546 type BfdUDPGetEchoSourceReply struct {
1547         Retval        int32          `binapi:"i32,name=retval" json:"retval,omitempty"`
1548         SwIfIndex     InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1549         IsSet         bool           `binapi:"bool,name=is_set" json:"is_set,omitempty"`
1550         HaveUsableIP4 bool           `binapi:"bool,name=have_usable_ip4" json:"have_usable_ip4,omitempty"`
1551         IP4Addr       IP4Address     `binapi:"ip4_address,name=ip4_addr" json:"ip4_addr,omitempty"`
1552         HaveUsableIP6 bool           `binapi:"bool,name=have_usable_ip6" json:"have_usable_ip6,omitempty"`
1553         IP6Addr       IP6Address     `binapi:"ip6_address,name=ip6_addr" json:"ip6_addr,omitempty"`
1554 }
1555
1556 func (m *BfdUDPGetEchoSourceReply) Reset()               { *m = BfdUDPGetEchoSourceReply{} }
1557 func (*BfdUDPGetEchoSourceReply) GetMessageName() string { return "bfd_udp_get_echo_source_reply" }
1558 func (*BfdUDPGetEchoSourceReply) GetCrcString() string   { return "1e00cfce" }
1559 func (*BfdUDPGetEchoSourceReply) GetMessageType() api.MessageType {
1560         return api.ReplyMessage
1561 }
1562
1563 func (m *BfdUDPGetEchoSourceReply) Size() (size int) {
1564         if m == nil {
1565                 return 0
1566         }
1567         size += 4      // m.Retval
1568         size += 4      // m.SwIfIndex
1569         size += 1      // m.IsSet
1570         size += 1      // m.HaveUsableIP4
1571         size += 1 * 4  // m.IP4Addr
1572         size += 1      // m.HaveUsableIP6
1573         size += 1 * 16 // m.IP6Addr
1574         return size
1575 }
1576 func (m *BfdUDPGetEchoSourceReply) Marshal(b []byte) ([]byte, error) {
1577         if b == nil {
1578                 b = make([]byte, m.Size())
1579         }
1580         buf := codec.NewBuffer(b)
1581         buf.EncodeInt32(m.Retval)
1582         buf.EncodeUint32(uint32(m.SwIfIndex))
1583         buf.EncodeBool(m.IsSet)
1584         buf.EncodeBool(m.HaveUsableIP4)
1585         buf.EncodeBytes(m.IP4Addr[:], 4)
1586         buf.EncodeBool(m.HaveUsableIP6)
1587         buf.EncodeBytes(m.IP6Addr[:], 16)
1588         return buf.Bytes(), nil
1589 }
1590 func (m *BfdUDPGetEchoSourceReply) Unmarshal(b []byte) error {
1591         buf := codec.NewBuffer(b)
1592         m.Retval = buf.DecodeInt32()
1593         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1594         m.IsSet = buf.DecodeBool()
1595         m.HaveUsableIP4 = buf.DecodeBool()
1596         copy(m.IP4Addr[:], buf.DecodeBytes(4))
1597         m.HaveUsableIP6 = buf.DecodeBool()
1598         copy(m.IP6Addr[:], buf.DecodeBytes(16))
1599         return nil
1600 }
1601
1602 // BfdUDPMod defines message 'bfd_udp_mod'.
1603 type BfdUDPMod struct {
1604         SwIfIndex     InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1605         DesiredMinTx  uint32         `binapi:"u32,name=desired_min_tx" json:"desired_min_tx,omitempty"`
1606         RequiredMinRx uint32         `binapi:"u32,name=required_min_rx" json:"required_min_rx,omitempty"`
1607         LocalAddr     Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1608         PeerAddr      Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1609         DetectMult    uint8          `binapi:"u8,name=detect_mult" json:"detect_mult,omitempty"`
1610 }
1611
1612 func (m *BfdUDPMod) Reset()               { *m = BfdUDPMod{} }
1613 func (*BfdUDPMod) GetMessageName() string { return "bfd_udp_mod" }
1614 func (*BfdUDPMod) GetCrcString() string   { return "783a3ff6" }
1615 func (*BfdUDPMod) GetMessageType() api.MessageType {
1616         return api.RequestMessage
1617 }
1618
1619 func (m *BfdUDPMod) Size() (size int) {
1620         if m == nil {
1621                 return 0
1622         }
1623         size += 4      // m.SwIfIndex
1624         size += 4      // m.DesiredMinTx
1625         size += 4      // m.RequiredMinRx
1626         size += 4      // m.LocalAddr.Af
1627         size += 1 * 16 // m.LocalAddr.Un
1628         size += 4      // m.PeerAddr.Af
1629         size += 1 * 16 // m.PeerAddr.Un
1630         size += 1      // m.DetectMult
1631         return size
1632 }
1633 func (m *BfdUDPMod) Marshal(b []byte) ([]byte, error) {
1634         if b == nil {
1635                 b = make([]byte, m.Size())
1636         }
1637         buf := codec.NewBuffer(b)
1638         buf.EncodeUint32(uint32(m.SwIfIndex))
1639         buf.EncodeUint32(m.DesiredMinTx)
1640         buf.EncodeUint32(m.RequiredMinRx)
1641         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1642         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1643         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1644         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1645         buf.EncodeUint8(m.DetectMult)
1646         return buf.Bytes(), nil
1647 }
1648 func (m *BfdUDPMod) Unmarshal(b []byte) error {
1649         buf := codec.NewBuffer(b)
1650         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1651         m.DesiredMinTx = buf.DecodeUint32()
1652         m.RequiredMinRx = buf.DecodeUint32()
1653         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1654         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1655         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1656         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1657         m.DetectMult = buf.DecodeUint8()
1658         return nil
1659 }
1660
1661 // BfdUDPModReply defines message 'bfd_udp_mod_reply'.
1662 type BfdUDPModReply struct {
1663         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1664 }
1665
1666 func (m *BfdUDPModReply) Reset()               { *m = BfdUDPModReply{} }
1667 func (*BfdUDPModReply) GetMessageName() string { return "bfd_udp_mod_reply" }
1668 func (*BfdUDPModReply) GetCrcString() string   { return "e8d4e804" }
1669 func (*BfdUDPModReply) GetMessageType() api.MessageType {
1670         return api.ReplyMessage
1671 }
1672
1673 func (m *BfdUDPModReply) Size() (size int) {
1674         if m == nil {
1675                 return 0
1676         }
1677         size += 4 // m.Retval
1678         return size
1679 }
1680 func (m *BfdUDPModReply) Marshal(b []byte) ([]byte, error) {
1681         if b == nil {
1682                 b = make([]byte, m.Size())
1683         }
1684         buf := codec.NewBuffer(b)
1685         buf.EncodeInt32(m.Retval)
1686         return buf.Bytes(), nil
1687 }
1688 func (m *BfdUDPModReply) Unmarshal(b []byte) error {
1689         buf := codec.NewBuffer(b)
1690         m.Retval = buf.DecodeInt32()
1691         return nil
1692 }
1693
1694 // BfdUDPSessionDetails defines message 'bfd_udp_session_details'.
1695 type BfdUDPSessionDetails struct {
1696         SwIfIndex       InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1697         LocalAddr       Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1698         PeerAddr        Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1699         State           BfdState       `binapi:"bfd_state,name=state" json:"state,omitempty"`
1700         IsAuthenticated bool           `binapi:"bool,name=is_authenticated" json:"is_authenticated,omitempty"`
1701         BfdKeyID        uint8          `binapi:"u8,name=bfd_key_id" json:"bfd_key_id,omitempty"`
1702         ConfKeyID       uint32         `binapi:"u32,name=conf_key_id" json:"conf_key_id,omitempty"`
1703         RequiredMinRx   uint32         `binapi:"u32,name=required_min_rx" json:"required_min_rx,omitempty"`
1704         DesiredMinTx    uint32         `binapi:"u32,name=desired_min_tx" json:"desired_min_tx,omitempty"`
1705         DetectMult      uint8          `binapi:"u8,name=detect_mult" json:"detect_mult,omitempty"`
1706 }
1707
1708 func (m *BfdUDPSessionDetails) Reset()               { *m = BfdUDPSessionDetails{} }
1709 func (*BfdUDPSessionDetails) GetMessageName() string { return "bfd_udp_session_details" }
1710 func (*BfdUDPSessionDetails) GetCrcString() string   { return "60653c02" }
1711 func (*BfdUDPSessionDetails) GetMessageType() api.MessageType {
1712         return api.ReplyMessage
1713 }
1714
1715 func (m *BfdUDPSessionDetails) Size() (size int) {
1716         if m == nil {
1717                 return 0
1718         }
1719         size += 4      // m.SwIfIndex
1720         size += 4      // m.LocalAddr.Af
1721         size += 1 * 16 // m.LocalAddr.Un
1722         size += 4      // m.PeerAddr.Af
1723         size += 1 * 16 // m.PeerAddr.Un
1724         size += 4      // m.State
1725         size += 1      // m.IsAuthenticated
1726         size += 1      // m.BfdKeyID
1727         size += 4      // m.ConfKeyID
1728         size += 4      // m.RequiredMinRx
1729         size += 4      // m.DesiredMinTx
1730         size += 1      // m.DetectMult
1731         return size
1732 }
1733 func (m *BfdUDPSessionDetails) Marshal(b []byte) ([]byte, error) {
1734         if b == nil {
1735                 b = make([]byte, m.Size())
1736         }
1737         buf := codec.NewBuffer(b)
1738         buf.EncodeUint32(uint32(m.SwIfIndex))
1739         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1740         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1741         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1742         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1743         buf.EncodeUint32(uint32(m.State))
1744         buf.EncodeBool(m.IsAuthenticated)
1745         buf.EncodeUint8(m.BfdKeyID)
1746         buf.EncodeUint32(m.ConfKeyID)
1747         buf.EncodeUint32(m.RequiredMinRx)
1748         buf.EncodeUint32(m.DesiredMinTx)
1749         buf.EncodeUint8(m.DetectMult)
1750         return buf.Bytes(), nil
1751 }
1752 func (m *BfdUDPSessionDetails) Unmarshal(b []byte) error {
1753         buf := codec.NewBuffer(b)
1754         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1755         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1756         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1757         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1758         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1759         m.State = BfdState(buf.DecodeUint32())
1760         m.IsAuthenticated = buf.DecodeBool()
1761         m.BfdKeyID = buf.DecodeUint8()
1762         m.ConfKeyID = buf.DecodeUint32()
1763         m.RequiredMinRx = buf.DecodeUint32()
1764         m.DesiredMinTx = buf.DecodeUint32()
1765         m.DetectMult = buf.DecodeUint8()
1766         return nil
1767 }
1768
1769 // BfdUDPSessionDump defines message 'bfd_udp_session_dump'.
1770 type BfdUDPSessionDump struct{}
1771
1772 func (m *BfdUDPSessionDump) Reset()               { *m = BfdUDPSessionDump{} }
1773 func (*BfdUDPSessionDump) GetMessageName() string { return "bfd_udp_session_dump" }
1774 func (*BfdUDPSessionDump) GetCrcString() string   { return "51077d14" }
1775 func (*BfdUDPSessionDump) GetMessageType() api.MessageType {
1776         return api.RequestMessage
1777 }
1778
1779 func (m *BfdUDPSessionDump) Size() (size int) {
1780         if m == nil {
1781                 return 0
1782         }
1783         return size
1784 }
1785 func (m *BfdUDPSessionDump) Marshal(b []byte) ([]byte, error) {
1786         if b == nil {
1787                 b = make([]byte, m.Size())
1788         }
1789         buf := codec.NewBuffer(b)
1790         return buf.Bytes(), nil
1791 }
1792 func (m *BfdUDPSessionDump) Unmarshal(b []byte) error {
1793         return nil
1794 }
1795
1796 // BfdUDPSessionSetFlags defines message 'bfd_udp_session_set_flags'.
1797 type BfdUDPSessionSetFlags struct {
1798         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1799         LocalAddr Address        `binapi:"address,name=local_addr" json:"local_addr,omitempty"`
1800         PeerAddr  Address        `binapi:"address,name=peer_addr" json:"peer_addr,omitempty"`
1801         Flags     IfStatusFlags  `binapi:"if_status_flags,name=flags" json:"flags,omitempty"`
1802 }
1803
1804 func (m *BfdUDPSessionSetFlags) Reset()               { *m = BfdUDPSessionSetFlags{} }
1805 func (*BfdUDPSessionSetFlags) GetMessageName() string { return "bfd_udp_session_set_flags" }
1806 func (*BfdUDPSessionSetFlags) GetCrcString() string   { return "cf313851" }
1807 func (*BfdUDPSessionSetFlags) GetMessageType() api.MessageType {
1808         return api.RequestMessage
1809 }
1810
1811 func (m *BfdUDPSessionSetFlags) Size() (size int) {
1812         if m == nil {
1813                 return 0
1814         }
1815         size += 4      // m.SwIfIndex
1816         size += 4      // m.LocalAddr.Af
1817         size += 1 * 16 // m.LocalAddr.Un
1818         size += 4      // m.PeerAddr.Af
1819         size += 1 * 16 // m.PeerAddr.Un
1820         size += 4      // m.Flags
1821         return size
1822 }
1823 func (m *BfdUDPSessionSetFlags) Marshal(b []byte) ([]byte, error) {
1824         if b == nil {
1825                 b = make([]byte, m.Size())
1826         }
1827         buf := codec.NewBuffer(b)
1828         buf.EncodeUint32(uint32(m.SwIfIndex))
1829         buf.EncodeUint32(uint32(m.LocalAddr.Af))
1830         buf.EncodeBytes(m.LocalAddr.Un.XXX_UnionData[:], 16)
1831         buf.EncodeUint32(uint32(m.PeerAddr.Af))
1832         buf.EncodeBytes(m.PeerAddr.Un.XXX_UnionData[:], 16)
1833         buf.EncodeUint32(uint32(m.Flags))
1834         return buf.Bytes(), nil
1835 }
1836 func (m *BfdUDPSessionSetFlags) Unmarshal(b []byte) error {
1837         buf := codec.NewBuffer(b)
1838         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1839         m.LocalAddr.Af = AddressFamily(buf.DecodeUint32())
1840         copy(m.LocalAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1841         m.PeerAddr.Af = AddressFamily(buf.DecodeUint32())
1842         copy(m.PeerAddr.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1843         m.Flags = IfStatusFlags(buf.DecodeUint32())
1844         return nil
1845 }
1846
1847 // BfdUDPSessionSetFlagsReply defines message 'bfd_udp_session_set_flags_reply'.
1848 type BfdUDPSessionSetFlagsReply struct {
1849         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1850 }
1851
1852 func (m *BfdUDPSessionSetFlagsReply) Reset()               { *m = BfdUDPSessionSetFlagsReply{} }
1853 func (*BfdUDPSessionSetFlagsReply) GetMessageName() string { return "bfd_udp_session_set_flags_reply" }
1854 func (*BfdUDPSessionSetFlagsReply) GetCrcString() string   { return "e8d4e804" }
1855 func (*BfdUDPSessionSetFlagsReply) GetMessageType() api.MessageType {
1856         return api.ReplyMessage
1857 }
1858
1859 func (m *BfdUDPSessionSetFlagsReply) Size() (size int) {
1860         if m == nil {
1861                 return 0
1862         }
1863         size += 4 // m.Retval
1864         return size
1865 }
1866 func (m *BfdUDPSessionSetFlagsReply) Marshal(b []byte) ([]byte, error) {
1867         if b == nil {
1868                 b = make([]byte, m.Size())
1869         }
1870         buf := codec.NewBuffer(b)
1871         buf.EncodeInt32(m.Retval)
1872         return buf.Bytes(), nil
1873 }
1874 func (m *BfdUDPSessionSetFlagsReply) Unmarshal(b []byte) error {
1875         buf := codec.NewBuffer(b)
1876         m.Retval = buf.DecodeInt32()
1877         return nil
1878 }
1879
1880 // BfdUDPSetEchoSource defines message 'bfd_udp_set_echo_source'.
1881 type BfdUDPSetEchoSource struct {
1882         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1883 }
1884
1885 func (m *BfdUDPSetEchoSource) Reset()               { *m = BfdUDPSetEchoSource{} }
1886 func (*BfdUDPSetEchoSource) GetMessageName() string { return "bfd_udp_set_echo_source" }
1887 func (*BfdUDPSetEchoSource) GetCrcString() string   { return "f9e6675e" }
1888 func (*BfdUDPSetEchoSource) GetMessageType() api.MessageType {
1889         return api.RequestMessage
1890 }
1891
1892 func (m *BfdUDPSetEchoSource) Size() (size int) {
1893         if m == nil {
1894                 return 0
1895         }
1896         size += 4 // m.SwIfIndex
1897         return size
1898 }
1899 func (m *BfdUDPSetEchoSource) Marshal(b []byte) ([]byte, error) {
1900         if b == nil {
1901                 b = make([]byte, m.Size())
1902         }
1903         buf := codec.NewBuffer(b)
1904         buf.EncodeUint32(uint32(m.SwIfIndex))
1905         return buf.Bytes(), nil
1906 }
1907 func (m *BfdUDPSetEchoSource) Unmarshal(b []byte) error {
1908         buf := codec.NewBuffer(b)
1909         m.SwIfIndex = InterfaceIndex(buf.DecodeUint32())
1910         return nil
1911 }
1912
1913 // BfdUDPSetEchoSourceReply defines message 'bfd_udp_set_echo_source_reply'.
1914 type BfdUDPSetEchoSourceReply struct {
1915         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1916 }
1917
1918 func (m *BfdUDPSetEchoSourceReply) Reset()               { *m = BfdUDPSetEchoSourceReply{} }
1919 func (*BfdUDPSetEchoSourceReply) GetMessageName() string { return "bfd_udp_set_echo_source_reply" }
1920 func (*BfdUDPSetEchoSourceReply) GetCrcString() string   { return "e8d4e804" }
1921 func (*BfdUDPSetEchoSourceReply) GetMessageType() api.MessageType {
1922         return api.ReplyMessage
1923 }
1924
1925 func (m *BfdUDPSetEchoSourceReply) Size() (size int) {
1926         if m == nil {
1927                 return 0
1928         }
1929         size += 4 // m.Retval
1930         return size
1931 }
1932 func (m *BfdUDPSetEchoSourceReply) Marshal(b []byte) ([]byte, error) {
1933         if b == nil {
1934                 b = make([]byte, m.Size())
1935         }
1936         buf := codec.NewBuffer(b)
1937         buf.EncodeInt32(m.Retval)
1938         return buf.Bytes(), nil
1939 }
1940 func (m *BfdUDPSetEchoSourceReply) Unmarshal(b []byte) error {
1941         buf := codec.NewBuffer(b)
1942         m.Retval = buf.DecodeInt32()
1943         return nil
1944 }
1945
1946 // WantBfdEvents defines message 'want_bfd_events'.
1947 type WantBfdEvents struct {
1948         EnableDisable bool   `binapi:"bool,name=enable_disable" json:"enable_disable,omitempty"`
1949         PID           uint32 `binapi:"u32,name=pid" json:"pid,omitempty"`
1950 }
1951
1952 func (m *WantBfdEvents) Reset()               { *m = WantBfdEvents{} }
1953 func (*WantBfdEvents) GetMessageName() string { return "want_bfd_events" }
1954 func (*WantBfdEvents) GetCrcString() string   { return "c5e2af94" }
1955 func (*WantBfdEvents) GetMessageType() api.MessageType {
1956         return api.RequestMessage
1957 }
1958
1959 func (m *WantBfdEvents) Size() (size int) {
1960         if m == nil {
1961                 return 0
1962         }
1963         size += 1 // m.EnableDisable
1964         size += 4 // m.PID
1965         return size
1966 }
1967 func (m *WantBfdEvents) Marshal(b []byte) ([]byte, error) {
1968         if b == nil {
1969                 b = make([]byte, m.Size())
1970         }
1971         buf := codec.NewBuffer(b)
1972         buf.EncodeBool(m.EnableDisable)
1973         buf.EncodeUint32(m.PID)
1974         return buf.Bytes(), nil
1975 }
1976 func (m *WantBfdEvents) Unmarshal(b []byte) error {
1977         buf := codec.NewBuffer(b)
1978         m.EnableDisable = buf.DecodeBool()
1979         m.PID = buf.DecodeUint32()
1980         return nil
1981 }
1982
1983 // WantBfdEventsReply defines message 'want_bfd_events_reply'.
1984 type WantBfdEventsReply struct {
1985         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1986 }
1987
1988 func (m *WantBfdEventsReply) Reset()               { *m = WantBfdEventsReply{} }
1989 func (*WantBfdEventsReply) GetMessageName() string { return "want_bfd_events_reply" }
1990 func (*WantBfdEventsReply) GetCrcString() string   { return "e8d4e804" }
1991 func (*WantBfdEventsReply) GetMessageType() api.MessageType {
1992         return api.ReplyMessage
1993 }
1994
1995 func (m *WantBfdEventsReply) Size() (size int) {
1996         if m == nil {
1997                 return 0
1998         }
1999         size += 4 // m.Retval
2000         return size
2001 }
2002 func (m *WantBfdEventsReply) Marshal(b []byte) ([]byte, error) {
2003         if b == nil {
2004                 b = make([]byte, m.Size())
2005         }
2006         buf := codec.NewBuffer(b)
2007         buf.EncodeInt32(m.Retval)
2008         return buf.Bytes(), nil
2009 }
2010 func (m *WantBfdEventsReply) Unmarshal(b []byte) error {
2011         buf := codec.NewBuffer(b)
2012         m.Retval = buf.DecodeInt32()
2013         return nil
2014 }
2015
2016 func init() { file_bfd_binapi_init() }
2017 func file_bfd_binapi_init() {
2018         api.RegisterMessage((*BfdAuthDelKey)(nil), "bfd_auth_del_key_65310b22")
2019         api.RegisterMessage((*BfdAuthDelKeyReply)(nil), "bfd_auth_del_key_reply_e8d4e804")
2020         api.RegisterMessage((*BfdAuthKeysDetails)(nil), "bfd_auth_keys_details_84130e9f")
2021         api.RegisterMessage((*BfdAuthKeysDump)(nil), "bfd_auth_keys_dump_51077d14")
2022         api.RegisterMessage((*BfdAuthSetKey)(nil), "bfd_auth_set_key_690b8877")
2023         api.RegisterMessage((*BfdAuthSetKeyReply)(nil), "bfd_auth_set_key_reply_e8d4e804")
2024         api.RegisterMessage((*BfdUDPAdd)(nil), "bfd_udp_add_7a6d1185")
2025         api.RegisterMessage((*BfdUDPAddReply)(nil), "bfd_udp_add_reply_e8d4e804")
2026         api.RegisterMessage((*BfdUDPAuthActivate)(nil), "bfd_udp_auth_activate_493ee0ec")
2027         api.RegisterMessage((*BfdUDPAuthActivateReply)(nil), "bfd_udp_auth_activate_reply_e8d4e804")
2028         api.RegisterMessage((*BfdUDPAuthDeactivate)(nil), "bfd_udp_auth_deactivate_99978c32")
2029         api.RegisterMessage((*BfdUDPAuthDeactivateReply)(nil), "bfd_udp_auth_deactivate_reply_e8d4e804")
2030         api.RegisterMessage((*BfdUDPDel)(nil), "bfd_udp_del_8096514d")
2031         api.RegisterMessage((*BfdUDPDelEchoSource)(nil), "bfd_udp_del_echo_source_51077d14")
2032         api.RegisterMessage((*BfdUDPDelEchoSourceReply)(nil), "bfd_udp_del_echo_source_reply_e8d4e804")
2033         api.RegisterMessage((*BfdUDPDelReply)(nil), "bfd_udp_del_reply_e8d4e804")
2034         api.RegisterMessage((*BfdUDPGetEchoSource)(nil), "bfd_udp_get_echo_source_51077d14")
2035         api.RegisterMessage((*BfdUDPGetEchoSourceReply)(nil), "bfd_udp_get_echo_source_reply_1e00cfce")
2036         api.RegisterMessage((*BfdUDPMod)(nil), "bfd_udp_mod_783a3ff6")
2037         api.RegisterMessage((*BfdUDPModReply)(nil), "bfd_udp_mod_reply_e8d4e804")
2038         api.RegisterMessage((*BfdUDPSessionDetails)(nil), "bfd_udp_session_details_60653c02")
2039         api.RegisterMessage((*BfdUDPSessionDump)(nil), "bfd_udp_session_dump_51077d14")
2040         api.RegisterMessage((*BfdUDPSessionSetFlags)(nil), "bfd_udp_session_set_flags_cf313851")
2041         api.RegisterMessage((*BfdUDPSessionSetFlagsReply)(nil), "bfd_udp_session_set_flags_reply_e8d4e804")
2042         api.RegisterMessage((*BfdUDPSetEchoSource)(nil), "bfd_udp_set_echo_source_f9e6675e")
2043         api.RegisterMessage((*BfdUDPSetEchoSourceReply)(nil), "bfd_udp_set_echo_source_reply_e8d4e804")
2044         api.RegisterMessage((*WantBfdEvents)(nil), "want_bfd_events_c5e2af94")
2045         api.RegisterMessage((*WantBfdEventsReply)(nil), "want_bfd_events_reply_e8d4e804")
2046 }
2047
2048 // Messages returns list of all messages in this module.
2049 func AllMessages() []api.Message {
2050         return []api.Message{
2051                 (*BfdAuthDelKey)(nil),
2052                 (*BfdAuthDelKeyReply)(nil),
2053                 (*BfdAuthKeysDetails)(nil),
2054                 (*BfdAuthKeysDump)(nil),
2055                 (*BfdAuthSetKey)(nil),
2056                 (*BfdAuthSetKeyReply)(nil),
2057                 (*BfdUDPAdd)(nil),
2058                 (*BfdUDPAddReply)(nil),
2059                 (*BfdUDPAuthActivate)(nil),
2060                 (*BfdUDPAuthActivateReply)(nil),
2061                 (*BfdUDPAuthDeactivate)(nil),
2062                 (*BfdUDPAuthDeactivateReply)(nil),
2063                 (*BfdUDPDel)(nil),
2064                 (*BfdUDPDelEchoSource)(nil),
2065                 (*BfdUDPDelEchoSourceReply)(nil),
2066                 (*BfdUDPDelReply)(nil),
2067                 (*BfdUDPGetEchoSource)(nil),
2068                 (*BfdUDPGetEchoSourceReply)(nil),
2069                 (*BfdUDPMod)(nil),
2070                 (*BfdUDPModReply)(nil),
2071                 (*BfdUDPSessionDetails)(nil),
2072                 (*BfdUDPSessionDump)(nil),
2073                 (*BfdUDPSessionSetFlags)(nil),
2074                 (*BfdUDPSessionSetFlagsReply)(nil),
2075                 (*BfdUDPSetEchoSource)(nil),
2076                 (*BfdUDPSetEchoSourceReply)(nil),
2077                 (*WantBfdEvents)(nil),
2078                 (*WantBfdEventsReply)(nil),
2079         }
2080 }