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