examples/binapi/ip/ip.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.4.0-alpha-1-g435c3f4-dirty
   4 //  VPP:              20.01-45~g7a071e370~b63
   5 // source: /usr/share/vpp/api/core/ip.api.json
   6
   7 /*
   8 Package ip contains generated code for VPP binary API defined by ip.api (version 3.0.1).
   9
  10 It consists of:
  11           7 aliases
  12          15 enums
  13          60 messages
  14          14 types
  15           1 union
  16 */
  17 package ip
  18
  19 import (
  20         "bytes"
  21         "context"
  22         "encoding/binary"
  23         "io"
  24         "math"
  25         "strconv"
  26
  27         api "git.fd.io/govpp.git/api"
  28         codec "git.fd.io/govpp.git/codec"
  29         struc "github.com/lunixbochs/struc"
  30 )
  31
  32 // This is a compile-time assertion to ensure that this generated file
  33 // is compatible with the GoVPP api package it is being compiled against.
  34 // A compilation error at this line likely means your copy of the
  35 // GoVPP api package needs to be updated.
  36 const _ = api.GoVppAPIPackageIsVersion2 // please upgrade the GoVPP api package
  37
  38 const (
  39         // ModuleName is the name of this module.
  40         ModuleName = "ip"
  41         // APIVersion is the API version of this module.
  42         APIVersion = "3.0.1"
  43         // VersionCrc is the CRC of this module.
  44         VersionCrc = 0xfc3fea46
  45 )
  46
  47 // AddressFamily represents VPP binary API enum 'address_family'.
  48 type AddressFamily uint32
  49
  50 const (
  51         ADDRESS_IP4 AddressFamily = 0
  52         ADDRESS_IP6 AddressFamily = 1
  53 )
  54
  55 var (
  56         AddressFamily_name = map[uint32]string{
  57                 0: "ADDRESS_IP4",
  58                 1: "ADDRESS_IP6",
  59         }
  60         AddressFamily_value = map[string]uint32{
  61                 "ADDRESS_IP4": 0,
  62                 "ADDRESS_IP6": 1,
  63         }
  64 )
  65
  66 func (x AddressFamily) String() string {
  67         s, ok := AddressFamily_name[uint32(x)]
  68         if ok {
  69                 return s
  70         }
  71         return "AddressFamily(" + strconv.Itoa(int(x)) + ")"
  72 }
  73
  74 // FibPathFlags represents VPP binary API enum 'fib_path_flags'.
  75 type FibPathFlags uint32
  76
  77 const (
  78         FIB_API_PATH_FLAG_NONE                 FibPathFlags = 0
  79         FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED FibPathFlags = 1
  80         FIB_API_PATH_FLAG_RESOLVE_VIA_HOST     FibPathFlags = 2
  81         FIB_API_PATH_FLAG_POP_PW_CW            FibPathFlags = 4
  82 )
  83
  84 var (
  85         FibPathFlags_name = map[uint32]string{
  86                 0: "FIB_API_PATH_FLAG_NONE",
  87                 1: "FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED",
  88                 2: "FIB_API_PATH_FLAG_RESOLVE_VIA_HOST",
  89                 4: "FIB_API_PATH_FLAG_POP_PW_CW",
  90         }
  91         FibPathFlags_value = map[string]uint32{
  92                 "FIB_API_PATH_FLAG_NONE":                 0,
  93                 "FIB_API_PATH_FLAG_RESOLVE_VIA_ATTACHED": 1,
  94                 "FIB_API_PATH_FLAG_RESOLVE_VIA_HOST":     2,
  95                 "FIB_API_PATH_FLAG_POP_PW_CW":            4,
  96         }
  97 )
  98
  99 func (x FibPathFlags) String() string {
 100         s, ok := FibPathFlags_name[uint32(x)]
 101         if ok {
 102                 return s
 103         }
 104         return "FibPathFlags(" + strconv.Itoa(int(x)) + ")"
 105 }
 106
 107 // FibPathNhProto represents VPP binary API enum 'fib_path_nh_proto'.
 108 type FibPathNhProto uint32
 109
 110 const (
 111         FIB_API_PATH_NH_PROTO_IP4      FibPathNhProto = 0
 112         FIB_API_PATH_NH_PROTO_IP6      FibPathNhProto = 1
 113         FIB_API_PATH_NH_PROTO_MPLS     FibPathNhProto = 2
 114         FIB_API_PATH_NH_PROTO_ETHERNET FibPathNhProto = 3
 115         FIB_API_PATH_NH_PROTO_BIER     FibPathNhProto = 4
 116 )
 117
 118 var (
 119         FibPathNhProto_name = map[uint32]string{
 120                 0: "FIB_API_PATH_NH_PROTO_IP4",
 121                 1: "FIB_API_PATH_NH_PROTO_IP6",
 122                 2: "FIB_API_PATH_NH_PROTO_MPLS",
 123                 3: "FIB_API_PATH_NH_PROTO_ETHERNET",
 124                 4: "FIB_API_PATH_NH_PROTO_BIER",
 125         }
 126         FibPathNhProto_value = map[string]uint32{
 127                 "FIB_API_PATH_NH_PROTO_IP4":      0,
 128                 "FIB_API_PATH_NH_PROTO_IP6":      1,
 129                 "FIB_API_PATH_NH_PROTO_MPLS":     2,
 130                 "FIB_API_PATH_NH_PROTO_ETHERNET": 3,
 131                 "FIB_API_PATH_NH_PROTO_BIER":     4,
 132         }
 133 )
 134
 135 func (x FibPathNhProto) String() string {
 136         s, ok := FibPathNhProto_name[uint32(x)]
 137         if ok {
 138                 return s
 139         }
 140         return "FibPathNhProto(" + strconv.Itoa(int(x)) + ")"
 141 }
 142
 143 // FibPathType represents VPP binary API enum 'fib_path_type'.
 144 type FibPathType uint32
 145
 146 const (
 147         FIB_API_PATH_TYPE_NORMAL        FibPathType = 0
 148         FIB_API_PATH_TYPE_LOCAL         FibPathType = 1
 149         FIB_API_PATH_TYPE_DROP          FibPathType = 2
 150         FIB_API_PATH_TYPE_UDP_ENCAP     FibPathType = 3
 151         FIB_API_PATH_TYPE_BIER_IMP      FibPathType = 4
 152         FIB_API_PATH_TYPE_ICMP_UNREACH  FibPathType = 5
 153         FIB_API_PATH_TYPE_ICMP_PROHIBIT FibPathType = 6
 154         FIB_API_PATH_TYPE_SOURCE_LOOKUP FibPathType = 7
 155         FIB_API_PATH_TYPE_DVR           FibPathType = 8
 156         FIB_API_PATH_TYPE_INTERFACE_RX  FibPathType = 9
 157         FIB_API_PATH_TYPE_CLASSIFY      FibPathType = 10
 158 )
 159
 160 var (
 161         FibPathType_name = map[uint32]string{
 162                 0:  "FIB_API_PATH_TYPE_NORMAL",
 163                 1:  "FIB_API_PATH_TYPE_LOCAL",
 164                 2:  "FIB_API_PATH_TYPE_DROP",
 165                 3:  "FIB_API_PATH_TYPE_UDP_ENCAP",
 166                 4:  "FIB_API_PATH_TYPE_BIER_IMP",
 167                 5:  "FIB_API_PATH_TYPE_ICMP_UNREACH",
 168                 6:  "FIB_API_PATH_TYPE_ICMP_PROHIBIT",
 169                 7:  "FIB_API_PATH_TYPE_SOURCE_LOOKUP",
 170                 8:  "FIB_API_PATH_TYPE_DVR",
 171                 9:  "FIB_API_PATH_TYPE_INTERFACE_RX",
 172                 10: "FIB_API_PATH_TYPE_CLASSIFY",
 173         }
 174         FibPathType_value = map[string]uint32{
 175                 "FIB_API_PATH_TYPE_NORMAL":        0,
 176                 "FIB_API_PATH_TYPE_LOCAL":         1,
 177                 "FIB_API_PATH_TYPE_DROP":          2,
 178                 "FIB_API_PATH_TYPE_UDP_ENCAP":     3,
 179                 "FIB_API_PATH_TYPE_BIER_IMP":      4,
 180                 "FIB_API_PATH_TYPE_ICMP_UNREACH":  5,
 181                 "FIB_API_PATH_TYPE_ICMP_PROHIBIT": 6,
 182                 "FIB_API_PATH_TYPE_SOURCE_LOOKUP": 7,
 183                 "FIB_API_PATH_TYPE_DVR":           8,
 184                 "FIB_API_PATH_TYPE_INTERFACE_RX":  9,
 185                 "FIB_API_PATH_TYPE_CLASSIFY":      10,
 186         }
 187 )
 188
 189 func (x FibPathType) String() string {
 190         s, ok := FibPathType_name[uint32(x)]
 191         if ok {
 192                 return s
 193         }
 194         return "FibPathType(" + strconv.Itoa(int(x)) + ")"
 195 }
 196
 197 // IfStatusFlags represents VPP binary API enum 'if_status_flags'.
 198 type IfStatusFlags uint32
 199
 200 const (
 201         IF_STATUS_API_FLAG_ADMIN_UP IfStatusFlags = 1
 202         IF_STATUS_API_FLAG_LINK_UP  IfStatusFlags = 2
 203 )
 204
 205 var (
 206         IfStatusFlags_name = map[uint32]string{
 207                 1: "IF_STATUS_API_FLAG_ADMIN_UP",
 208                 2: "IF_STATUS_API_FLAG_LINK_UP",
 209         }
 210         IfStatusFlags_value = map[string]uint32{
 211                 "IF_STATUS_API_FLAG_ADMIN_UP": 1,
 212                 "IF_STATUS_API_FLAG_LINK_UP":  2,
 213         }
 214 )
 215
 216 func (x IfStatusFlags) String() string {
 217         s, ok := IfStatusFlags_name[uint32(x)]
 218         if ok {
 219                 return s
 220         }
 221         return "IfStatusFlags(" + strconv.Itoa(int(x)) + ")"
 222 }
 223
 224 // IfType represents VPP binary API enum 'if_type'.
 225 type IfType uint32
 226
 227 const (
 228         IF_API_TYPE_HARDWARE IfType = 1
 229         IF_API_TYPE_SUB      IfType = 2
 230         IF_API_TYPE_P2P      IfType = 3
 231         IF_API_TYPE_PIPE     IfType = 4
 232 )
 233
 234 var (
 235         IfType_name = map[uint32]string{
 236                 1: "IF_API_TYPE_HARDWARE",
 237                 2: "IF_API_TYPE_SUB",
 238                 3: "IF_API_TYPE_P2P",
 239                 4: "IF_API_TYPE_PIPE",
 240         }
 241         IfType_value = map[string]uint32{
 242                 "IF_API_TYPE_HARDWARE": 1,
 243                 "IF_API_TYPE_SUB":      2,
 244                 "IF_API_TYPE_P2P":      3,
 245                 "IF_API_TYPE_PIPE":     4,
 246         }
 247 )
 248
 249 func (x IfType) String() string {
 250         s, ok := IfType_name[uint32(x)]
 251         if ok {
 252                 return s
 253         }
 254         return "IfType(" + strconv.Itoa(int(x)) + ")"
 255 }
 256
 257 // IPDscp represents VPP binary API enum 'ip_dscp'.
 258 type IPDscp uint8
 259
 260 const (
 261         IP_API_DSCP_CS0  IPDscp = 0
 262         IP_API_DSCP_CS1  IPDscp = 8
 263         IP_API_DSCP_AF11 IPDscp = 10
 264         IP_API_DSCP_AF12 IPDscp = 12
 265         IP_API_DSCP_AF13 IPDscp = 14
 266         IP_API_DSCP_CS2  IPDscp = 16
 267         IP_API_DSCP_AF21 IPDscp = 18
 268         IP_API_DSCP_AF22 IPDscp = 20
 269         IP_API_DSCP_AF23 IPDscp = 22
 270         IP_API_DSCP_CS3  IPDscp = 24
 271         IP_API_DSCP_AF31 IPDscp = 26
 272         IP_API_DSCP_AF32 IPDscp = 28
 273         IP_API_DSCP_AF33 IPDscp = 30
 274         IP_API_DSCP_CS4  IPDscp = 32
 275         IP_API_DSCP_AF41 IPDscp = 34
 276         IP_API_DSCP_AF42 IPDscp = 36
 277         IP_API_DSCP_AF43 IPDscp = 38
 278         IP_API_DSCP_CS5  IPDscp = 40
 279         IP_API_DSCP_EF   IPDscp = 46
 280         IP_API_DSCP_CS6  IPDscp = 48
 281         IP_API_DSCP_CS7  IPDscp = 50
 282 )
 283
 284 var (
 285         IPDscp_name = map[uint8]string{
 286                 0:  "IP_API_DSCP_CS0",
 287                 8:  "IP_API_DSCP_CS1",
 288                 10: "IP_API_DSCP_AF11",
 289                 12: "IP_API_DSCP_AF12",
 290                 14: "IP_API_DSCP_AF13",
 291                 16: "IP_API_DSCP_CS2",
 292                 18: "IP_API_DSCP_AF21",
 293                 20: "IP_API_DSCP_AF22",
 294                 22: "IP_API_DSCP_AF23",
 295                 24: "IP_API_DSCP_CS3",
 296                 26: "IP_API_DSCP_AF31",
 297                 28: "IP_API_DSCP_AF32",
 298                 30: "IP_API_DSCP_AF33",
 299                 32: "IP_API_DSCP_CS4",
 300                 34: "IP_API_DSCP_AF41",
 301                 36: "IP_API_DSCP_AF42",
 302                 38: "IP_API_DSCP_AF43",
 303                 40: "IP_API_DSCP_CS5",
 304                 46: "IP_API_DSCP_EF",
 305                 48: "IP_API_DSCP_CS6",
 306                 50: "IP_API_DSCP_CS7",
 307         }
 308         IPDscp_value = map[string]uint8{
 309                 "IP_API_DSCP_CS0":  0,
 310                 "IP_API_DSCP_CS1":  8,
 311                 "IP_API_DSCP_AF11": 10,
 312                 "IP_API_DSCP_AF12": 12,
 313                 "IP_API_DSCP_AF13": 14,
 314                 "IP_API_DSCP_CS2":  16,
 315                 "IP_API_DSCP_AF21": 18,
 316                 "IP_API_DSCP_AF22": 20,
 317                 "IP_API_DSCP_AF23": 22,
 318                 "IP_API_DSCP_CS3":  24,
 319                 "IP_API_DSCP_AF31": 26,
 320                 "IP_API_DSCP_AF32": 28,
 321                 "IP_API_DSCP_AF33": 30,
 322                 "IP_API_DSCP_CS4":  32,
 323                 "IP_API_DSCP_AF41": 34,
 324                 "IP_API_DSCP_AF42": 36,
 325                 "IP_API_DSCP_AF43": 38,
 326                 "IP_API_DSCP_CS5":  40,
 327                 "IP_API_DSCP_EF":   46,
 328                 "IP_API_DSCP_CS6":  48,
 329                 "IP_API_DSCP_CS7":  50,
 330         }
 331 )
 332
 333 func (x IPDscp) String() string {
 334         s, ok := IPDscp_name[uint8(x)]
 335         if ok {
 336                 return s
 337         }
 338         return "IPDscp(" + strconv.Itoa(int(x)) + ")"
 339 }
 340
 341 // IPEcn represents VPP binary API enum 'ip_ecn'.
 342 type IPEcn uint8
 343
 344 const (
 345         IP_API_ECN_NONE IPEcn = 0
 346         IP_API_ECN_ECT0 IPEcn = 1
 347         IP_API_ECN_ECT1 IPEcn = 2
 348         IP_API_ECN_CE   IPEcn = 3
 349 )
 350
 351 var (
 352         IPEcn_name = map[uint8]string{
 353                 0: "IP_API_ECN_NONE",
 354                 1: "IP_API_ECN_ECT0",
 355                 2: "IP_API_ECN_ECT1",
 356                 3: "IP_API_ECN_CE",
 357         }
 358         IPEcn_value = map[string]uint8{
 359                 "IP_API_ECN_NONE": 0,
 360                 "IP_API_ECN_ECT0": 1,
 361                 "IP_API_ECN_ECT1": 2,
 362                 "IP_API_ECN_CE":   3,
 363         }
 364 )
 365
 366 func (x IPEcn) String() string {
 367         s, ok := IPEcn_name[uint8(x)]
 368         if ok {
 369                 return s
 370         }
 371         return "IPEcn(" + strconv.Itoa(int(x)) + ")"
 372 }
 373
 374 // IPProto represents VPP binary API enum 'ip_proto'.
 375 type IPProto uint32
 376
 377 const (
 378         IP_API_PROTO_HOPOPT   IPProto = 0
 379         IP_API_PROTO_ICMP     IPProto = 1
 380         IP_API_PROTO_IGMP     IPProto = 2
 381         IP_API_PROTO_TCP      IPProto = 6
 382         IP_API_PROTO_UDP      IPProto = 17
 383         IP_API_PROTO_GRE      IPProto = 47
 384         IP_API_PROTO_AH       IPProto = 50
 385         IP_API_PROTO_ESP      IPProto = 51
 386         IP_API_PROTO_EIGRP    IPProto = 88
 387         IP_API_PROTO_OSPF     IPProto = 89
 388         IP_API_PROTO_SCTP     IPProto = 132
 389         IP_API_PROTO_RESERVED IPProto = 255
 390 )
 391
 392 var (
 393         IPProto_name = map[uint32]string{
 394                 0:   "IP_API_PROTO_HOPOPT",
 395                 1:   "IP_API_PROTO_ICMP",
 396                 2:   "IP_API_PROTO_IGMP",
 397                 6:   "IP_API_PROTO_TCP",
 398                 17:  "IP_API_PROTO_UDP",
 399                 47:  "IP_API_PROTO_GRE",
 400                 50:  "IP_API_PROTO_AH",
 401                 51:  "IP_API_PROTO_ESP",
 402                 88:  "IP_API_PROTO_EIGRP",
 403                 89:  "IP_API_PROTO_OSPF",
 404                 132: "IP_API_PROTO_SCTP",
 405                 255: "IP_API_PROTO_RESERVED",
 406         }
 407         IPProto_value = map[string]uint32{
 408                 "IP_API_PROTO_HOPOPT":   0,
 409                 "IP_API_PROTO_ICMP":     1,
 410                 "IP_API_PROTO_IGMP":     2,
 411                 "IP_API_PROTO_TCP":      6,
 412                 "IP_API_PROTO_UDP":      17,
 413                 "IP_API_PROTO_GRE":      47,
 414                 "IP_API_PROTO_AH":       50,
 415                 "IP_API_PROTO_ESP":      51,
 416                 "IP_API_PROTO_EIGRP":    88,
 417                 "IP_API_PROTO_OSPF":     89,
 418                 "IP_API_PROTO_SCTP":     132,
 419                 "IP_API_PROTO_RESERVED": 255,
 420         }
 421 )
 422
 423 func (x IPProto) String() string {
 424         s, ok := IPProto_name[uint32(x)]
 425         if ok {
 426                 return s
 427         }
 428         return "IPProto(" + strconv.Itoa(int(x)) + ")"
 429 }
 430
 431 // IPReassType represents VPP binary API enum 'ip_reass_type'.
 432 type IPReassType uint32
 433
 434 const (
 435         IP_REASS_TYPE_FULL            IPReassType = 0
 436         IP_REASS_TYPE_SHALLOW_VIRTUAL IPReassType = 1
 437 )
 438
 439 var (
 440         IPReassType_name = map[uint32]string{
 441                 0: "IP_REASS_TYPE_FULL",
 442                 1: "IP_REASS_TYPE_SHALLOW_VIRTUAL",
 443         }
 444         IPReassType_value = map[string]uint32{
 445                 "IP_REASS_TYPE_FULL":            0,
 446                 "IP_REASS_TYPE_SHALLOW_VIRTUAL": 1,
 447         }
 448 )
 449
 450 func (x IPReassType) String() string {
 451         s, ok := IPReassType_name[uint32(x)]
 452         if ok {
 453                 return s
 454         }
 455         return "IPReassType(" + strconv.Itoa(int(x)) + ")"
 456 }
 457
 458 // LinkDuplex represents VPP binary API enum 'link_duplex'.
 459 type LinkDuplex uint32
 460
 461 const (
 462         LINK_DUPLEX_API_UNKNOWN LinkDuplex = 0
 463         LINK_DUPLEX_API_HALF    LinkDuplex = 1
 464         LINK_DUPLEX_API_FULL    LinkDuplex = 2
 465 )
 466
 467 var (
 468         LinkDuplex_name = map[uint32]string{
 469                 0: "LINK_DUPLEX_API_UNKNOWN",
 470                 1: "LINK_DUPLEX_API_HALF",
 471                 2: "LINK_DUPLEX_API_FULL",
 472         }
 473         LinkDuplex_value = map[string]uint32{
 474                 "LINK_DUPLEX_API_UNKNOWN": 0,
 475                 "LINK_DUPLEX_API_HALF":    1,
 476                 "LINK_DUPLEX_API_FULL":    2,
 477         }
 478 )
 479
 480 func (x LinkDuplex) String() string {
 481         s, ok := LinkDuplex_name[uint32(x)]
 482         if ok {
 483                 return s
 484         }
 485         return "LinkDuplex(" + strconv.Itoa(int(x)) + ")"
 486 }
 487
 488 // MfibItfFlags represents VPP binary API enum 'mfib_itf_flags'.
 489 type MfibItfFlags uint32
 490
 491 const (
 492         MFIB_API_ITF_FLAG_NONE           MfibItfFlags = 0
 493         MFIB_API_ITF_FLAG_NEGATE_SIGNAL  MfibItfFlags = 1
 494         MFIB_API_ITF_FLAG_ACCEPT         MfibItfFlags = 2
 495         MFIB_API_ITF_FLAG_FORWARD        MfibItfFlags = 4
 496         MFIB_API_ITF_FLAG_SIGNAL_PRESENT MfibItfFlags = 8
 497         MFIB_API_ITF_FLAG_DONT_PRESERVE  MfibItfFlags = 16
 498 )
 499
 500 var (
 501         MfibItfFlags_name = map[uint32]string{
 502                 0:  "MFIB_API_ITF_FLAG_NONE",
 503                 1:  "MFIB_API_ITF_FLAG_NEGATE_SIGNAL",
 504                 2:  "MFIB_API_ITF_FLAG_ACCEPT",
 505                 4:  "MFIB_API_ITF_FLAG_FORWARD",
 506                 8:  "MFIB_API_ITF_FLAG_SIGNAL_PRESENT",
 507                 16: "MFIB_API_ITF_FLAG_DONT_PRESERVE",
 508         }
 509         MfibItfFlags_value = map[string]uint32{
 510                 "MFIB_API_ITF_FLAG_NONE":           0,
 511                 "MFIB_API_ITF_FLAG_NEGATE_SIGNAL":  1,
 512                 "MFIB_API_ITF_FLAG_ACCEPT":         2,
 513                 "MFIB_API_ITF_FLAG_FORWARD":        4,
 514                 "MFIB_API_ITF_FLAG_SIGNAL_PRESENT": 8,
 515                 "MFIB_API_ITF_FLAG_DONT_PRESERVE":  16,
 516         }
 517 )
 518
 519 func (x MfibItfFlags) String() string {
 520         s, ok := MfibItfFlags_name[uint32(x)]
 521         if ok {
 522                 return s
 523         }
 524         return "MfibItfFlags(" + strconv.Itoa(int(x)) + ")"
 525 }
 526
 527 // MtuProto represents VPP binary API enum 'mtu_proto'.
 528 type MtuProto uint32
 529
 530 const (
 531         MTU_PROTO_API_L3   MtuProto = 1
 532         MTU_PROTO_API_IP4  MtuProto = 2
 533         MTU_PROTO_API_IP6  MtuProto = 3
 534         MTU_PROTO_API_MPLS MtuProto = 4
 535         MTU_PROTO_API_N    MtuProto = 5
 536 )
 537
 538 var (
 539         MtuProto_name = map[uint32]string{
 540                 1: "MTU_PROTO_API_L3",
 541                 2: "MTU_PROTO_API_IP4",
 542                 3: "MTU_PROTO_API_IP6",
 543                 4: "MTU_PROTO_API_MPLS",
 544                 5: "MTU_PROTO_API_N",
 545         }
 546         MtuProto_value = map[string]uint32{
 547                 "MTU_PROTO_API_L3":   1,
 548                 "MTU_PROTO_API_IP4":  2,
 549                 "MTU_PROTO_API_IP6":  3,
 550                 "MTU_PROTO_API_MPLS": 4,
 551                 "MTU_PROTO_API_N":    5,
 552         }
 553 )
 554
 555 func (x MtuProto) String() string {
 556         s, ok := MtuProto_name[uint32(x)]
 557         if ok {
 558                 return s
 559         }
 560         return "MtuProto(" + strconv.Itoa(int(x)) + ")"
 561 }
 562
 563 // RxMode represents VPP binary API enum 'rx_mode'.
 564 type RxMode uint32
 565
 566 const (
 567         RX_MODE_API_UNKNOWN   RxMode = 0
 568         RX_MODE_API_POLLING   RxMode = 1
 569         RX_MODE_API_INTERRUPT RxMode = 2
 570         RX_MODE_API_ADAPTIVE  RxMode = 3
 571         RX_MODE_API_DEFAULT   RxMode = 4
 572 )
 573
 574 var (
 575         RxMode_name = map[uint32]string{
 576                 0: "RX_MODE_API_UNKNOWN",
 577                 1: "RX_MODE_API_POLLING",
 578                 2: "RX_MODE_API_INTERRUPT",
 579                 3: "RX_MODE_API_ADAPTIVE",
 580                 4: "RX_MODE_API_DEFAULT",
 581         }
 582         RxMode_value = map[string]uint32{
 583                 "RX_MODE_API_UNKNOWN":   0,
 584                 "RX_MODE_API_POLLING":   1,
 585                 "RX_MODE_API_INTERRUPT": 2,
 586                 "RX_MODE_API_ADAPTIVE":  3,
 587                 "RX_MODE_API_DEFAULT":   4,
 588         }
 589 )
 590
 591 func (x RxMode) String() string {
 592         s, ok := RxMode_name[uint32(x)]
 593         if ok {
 594                 return s
 595         }
 596         return "RxMode(" + strconv.Itoa(int(x)) + ")"
 597 }
 598
 599 // SubIfFlags represents VPP binary API enum 'sub_if_flags'.
 600 type SubIfFlags uint32
 601
 602 const (
 603         SUB_IF_API_FLAG_NO_TAGS           SubIfFlags = 1
 604         SUB_IF_API_FLAG_ONE_TAG           SubIfFlags = 2
 605         SUB_IF_API_FLAG_TWO_TAGS          SubIfFlags = 4
 606         SUB_IF_API_FLAG_DOT1AD            SubIfFlags = 8
 607         SUB_IF_API_FLAG_EXACT_MATCH       SubIfFlags = 16
 608         SUB_IF_API_FLAG_DEFAULT           SubIfFlags = 32
 609         SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY SubIfFlags = 64
 610         SUB_IF_API_FLAG_INNER_VLAN_ID_ANY SubIfFlags = 128
 611         SUB_IF_API_FLAG_MASK_VNET         SubIfFlags = 254
 612         SUB_IF_API_FLAG_DOT1AH            SubIfFlags = 256
 613 )
 614
 615 var (
 616         SubIfFlags_name = map[uint32]string{
 617                 1:   "SUB_IF_API_FLAG_NO_TAGS",
 618                 2:   "SUB_IF_API_FLAG_ONE_TAG",
 619                 4:   "SUB_IF_API_FLAG_TWO_TAGS",
 620                 8:   "SUB_IF_API_FLAG_DOT1AD",
 621                 16:  "SUB_IF_API_FLAG_EXACT_MATCH",
 622                 32:  "SUB_IF_API_FLAG_DEFAULT",
 623                 64:  "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY",
 624                 128: "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY",
 625                 254: "SUB_IF_API_FLAG_MASK_VNET",
 626                 256: "SUB_IF_API_FLAG_DOT1AH",
 627         }
 628         SubIfFlags_value = map[string]uint32{
 629                 "SUB_IF_API_FLAG_NO_TAGS":           1,
 630                 "SUB_IF_API_FLAG_ONE_TAG":           2,
 631                 "SUB_IF_API_FLAG_TWO_TAGS":          4,
 632                 "SUB_IF_API_FLAG_DOT1AD":            8,
 633                 "SUB_IF_API_FLAG_EXACT_MATCH":       16,
 634                 "SUB_IF_API_FLAG_DEFAULT":           32,
 635                 "SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY": 64,
 636                 "SUB_IF_API_FLAG_INNER_VLAN_ID_ANY": 128,
 637                 "SUB_IF_API_FLAG_MASK_VNET":         254,
 638                 "SUB_IF_API_FLAG_DOT1AH":            256,
 639         }
 640 )
 641
 642 func (x SubIfFlags) String() string {
 643         s, ok := SubIfFlags_name[uint32(x)]
 644         if ok {
 645                 return s
 646         }
 647         return "SubIfFlags(" + strconv.Itoa(int(x)) + ")"
 648 }
 649
 650 // AddressWithPrefix represents VPP binary API alias 'address_with_prefix'.
 651 type AddressWithPrefix Prefix
 652
 653 // InterfaceIndex represents VPP binary API alias 'interface_index'.
 654 type InterfaceIndex uint32
 655
 656 // IP4Address represents VPP binary API alias 'ip4_address'.
 657 type IP4Address [4]uint8
 658
 659 // IP4AddressWithPrefix represents VPP binary API alias 'ip4_address_with_prefix'.
 660 type IP4AddressWithPrefix IP4Prefix
 661
 662 // IP6Address represents VPP binary API alias 'ip6_address'.
 663 type IP6Address [16]uint8
 664
 665 // IP6AddressWithPrefix represents VPP binary API alias 'ip6_address_with_prefix'.
 666 type IP6AddressWithPrefix IP6Prefix
 667
 668 // MacAddress represents VPP binary API alias 'mac_address'.
 669 type MacAddress [6]uint8
 670
 671 // Address represents VPP binary API type 'address'.
 672 type Address struct {
 673         Af AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 674         Un AddressUnion  `binapi:"address_union,name=un" json:"un,omitempty"`
 675 }
 676
 677 func (*Address) GetTypeName() string { return "address" }
 678
 679 // FibMplsLabel represents VPP binary API type 'fib_mpls_label'.
 680 type FibMplsLabel struct {
 681         IsUniform uint8  `binapi:"u8,name=is_uniform" json:"is_uniform,omitempty"`
 682         Label     uint32 `binapi:"u32,name=label" json:"label,omitempty"`
 683         TTL       uint8  `binapi:"u8,name=ttl" json:"ttl,omitempty"`
 684         Exp       uint8  `binapi:"u8,name=exp" json:"exp,omitempty"`
 685 }
 686
 687 func (*FibMplsLabel) GetTypeName() string { return "fib_mpls_label" }
 688
 689 // FibPath represents VPP binary API type 'fib_path'.
 690 type FibPath struct {
 691         SwIfIndex  uint32           `binapi:"u32,name=sw_if_index" json:"sw_if_index,omitempty"`
 692         TableID    uint32           `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 693         RpfID      uint32           `binapi:"u32,name=rpf_id" json:"rpf_id,omitempty"`
 694         Weight     uint8            `binapi:"u8,name=weight" json:"weight,omitempty"`
 695         Preference uint8            `binapi:"u8,name=preference" json:"preference,omitempty"`
 696         Type       FibPathType      `binapi:"fib_path_type,name=type" json:"type,omitempty"`
 697         Flags      FibPathFlags     `binapi:"fib_path_flags,name=flags" json:"flags,omitempty"`
 698         Proto      FibPathNhProto   `binapi:"fib_path_nh_proto,name=proto" json:"proto,omitempty"`
 699         Nh         FibPathNh        `binapi:"fib_path_nh,name=nh" json:"nh,omitempty"`
 700         NLabels    uint8            `binapi:"u8,name=n_labels" json:"n_labels,omitempty"`
 701         LabelStack [16]FibMplsLabel `binapi:"fib_mpls_label[16],name=label_stack" json:"label_stack,omitempty" struc:"[16]FibMplsLabel"`
 702 }
 703
 704 func (*FibPath) GetTypeName() string { return "fib_path" }
 705
 706 // FibPathNh represents VPP binary API type 'fib_path_nh'.
 707 type FibPathNh struct {
 708         Address            AddressUnion `binapi:"address_union,name=address" json:"address,omitempty"`
 709         ViaLabel           uint32       `binapi:"u32,name=via_label" json:"via_label,omitempty"`
 710         ObjID              uint32       `binapi:"u32,name=obj_id" json:"obj_id,omitempty"`
 711         ClassifyTableIndex uint32       `binapi:"u32,name=classify_table_index" json:"classify_table_index,omitempty"`
 712 }
 713
 714 func (*FibPathNh) GetTypeName() string { return "fib_path_nh" }
 715
 716 // IP4Prefix represents VPP binary API type 'ip4_prefix'.
 717 type IP4Prefix struct {
 718         Address IP4Address `binapi:"ip4_address,name=address" json:"address,omitempty"`
 719         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 720 }
 721
 722 func (*IP4Prefix) GetTypeName() string { return "ip4_prefix" }
 723
 724 // IP6Prefix represents VPP binary API type 'ip6_prefix'.
 725 type IP6Prefix struct {
 726         Address IP6Address `binapi:"ip6_address,name=address" json:"address,omitempty"`
 727         Len     uint8      `binapi:"u8,name=len" json:"len,omitempty"`
 728 }
 729
 730 func (*IP6Prefix) GetTypeName() string { return "ip6_prefix" }
 731
 732 // IPMroute represents VPP binary API type 'ip_mroute'.
 733 type IPMroute struct {
 734         TableID    uint32     `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 735         EntryFlags uint32     `binapi:"u32,name=entry_flags" json:"entry_flags,omitempty"`
 736         RpfID      uint32     `binapi:"u32,name=rpf_id" json:"rpf_id,omitempty"`
 737         Prefix     Mprefix    `binapi:"mprefix,name=prefix" json:"prefix,omitempty"`
 738         NPaths     uint8      `binapi:"u8,name=n_paths" json:"n_paths,omitempty" struc:"sizeof=Paths"`
 739         Paths      []MfibPath `binapi:"mfib_path[n_paths],name=paths" json:"paths,omitempty"`
 740 }
 741
 742 func (*IPMroute) GetTypeName() string { return "ip_mroute" }
 743
 744 // IPRoute represents VPP binary API type 'ip_route'.
 745 type IPRoute struct {
 746         TableID    uint32    `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 747         StatsIndex uint32    `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
 748         Prefix     Prefix    `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
 749         NPaths     uint8     `binapi:"u8,name=n_paths" json:"n_paths,omitempty" struc:"sizeof=Paths"`
 750         Paths      []FibPath `binapi:"fib_path[n_paths],name=paths" json:"paths,omitempty"`
 751 }
 752
 753 func (*IPRoute) GetTypeName() string { return "ip_route" }
 754
 755 // IPTable represents VPP binary API type 'ip_table'.
 756 type IPTable struct {
 757         TableID uint32 `binapi:"u32,name=table_id" json:"table_id,omitempty"`
 758         IsIP6   bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
 759         Name    string `binapi:"string[64],name=name" json:"name,omitempty" struc:"[64]byte"`
 760 }
 761
 762 func (*IPTable) GetTypeName() string { return "ip_table" }
 763
 764 // MfibPath represents VPP binary API type 'mfib_path'.
 765 type MfibPath struct {
 766         ItfFlags MfibItfFlags `binapi:"mfib_itf_flags,name=itf_flags" json:"itf_flags,omitempty"`
 767         Path     FibPath      `binapi:"fib_path,name=path" json:"path,omitempty"`
 768 }
 769
 770 func (*MfibPath) GetTypeName() string { return "mfib_path" }
 771
 772 // Mprefix represents VPP binary API type 'mprefix'.
 773 type Mprefix struct {
 774         Af               AddressFamily `binapi:"address_family,name=af" json:"af,omitempty"`
 775         GrpAddressLength uint16        `binapi:"u16,name=grp_address_length" json:"grp_address_length,omitempty"`
 776         GrpAddress       AddressUnion  `binapi:"address_union,name=grp_address" json:"grp_address,omitempty"`
 777         SrcAddress       AddressUnion  `binapi:"address_union,name=src_address" json:"src_address,omitempty"`
 778 }
 779
 780 func (*Mprefix) GetTypeName() string { return "mprefix" }
 781
 782 // Prefix represents VPP binary API type 'prefix'.
 783 type Prefix struct {
 784         Address Address `binapi:"address,name=address" json:"address,omitempty"`
 785         Len     uint8   `binapi:"u8,name=len" json:"len,omitempty"`
 786 }
 787
 788 func (*Prefix) GetTypeName() string { return "prefix" }
 789
 790 // PrefixMatcher represents VPP binary API type 'prefix_matcher'.
 791 type PrefixMatcher struct {
 792         Le uint8 `binapi:"u8,name=le" json:"le,omitempty"`
 793         Ge uint8 `binapi:"u8,name=ge" json:"ge,omitempty"`
 794 }
 795
 796 func (*PrefixMatcher) GetTypeName() string { return "prefix_matcher" }
 797
 798 // PuntRedirect represents VPP binary API type 'punt_redirect'.
 799 type PuntRedirect struct {
 800         RxSwIfIndex InterfaceIndex `binapi:"interface_index,name=rx_sw_if_index" json:"rx_sw_if_index,omitempty"`
 801         TxSwIfIndex InterfaceIndex `binapi:"interface_index,name=tx_sw_if_index" json:"tx_sw_if_index,omitempty"`
 802         Nh          Address        `binapi:"address,name=nh" json:"nh,omitempty"`
 803 }
 804
 805 func (*PuntRedirect) GetTypeName() string { return "punt_redirect" }
 806
 807 // AddressUnion represents VPP binary API union 'address_union'.
 808 type AddressUnion struct {
 809         XXX_UnionData [16]byte
 810 }
 811
 812 func (*AddressUnion) GetTypeName() string { return "address_union" }
 813
 814 func AddressUnionIP4(a IP4Address) (u AddressUnion) {
 815         u.SetIP4(a)
 816         return
 817 }
 818 func (u *AddressUnion) SetIP4(a IP4Address) {
 819         var b = new(bytes.Buffer)
 820         if err := struc.Pack(b, &a); err != nil {
 821                 return
 822         }
 823         copy(u.XXX_UnionData[:], b.Bytes())
 824 }
 825 func (u *AddressUnion) GetIP4() (a IP4Address) {
 826         var b = bytes.NewReader(u.XXX_UnionData[:])
 827         struc.Unpack(b, &a)
 828         return
 829 }
 830
 831 func AddressUnionIP6(a IP6Address) (u AddressUnion) {
 832         u.SetIP6(a)
 833         return
 834 }
 835 func (u *AddressUnion) SetIP6(a IP6Address) {
 836         var b = new(bytes.Buffer)
 837         if err := struc.Pack(b, &a); err != nil {
 838                 return
 839         }
 840         copy(u.XXX_UnionData[:], b.Bytes())
 841 }
 842 func (u *AddressUnion) GetIP6() (a IP6Address) {
 843         var b = bytes.NewReader(u.XXX_UnionData[:])
 844         struc.Unpack(b, &a)
 845         return
 846 }
 847
 848 // IoamDisable represents VPP binary API message 'ioam_disable'.
 849 type IoamDisable struct {
 850         ID uint16 `binapi:"u16,name=id" json:"id,omitempty"`
 851 }
 852
 853 func (m *IoamDisable) Reset()                        { *m = IoamDisable{} }
 854 func (*IoamDisable) GetMessageName() string          { return "ioam_disable" }
 855 func (*IoamDisable) GetCrcString() string            { return "6b16a45e" }
 856 func (*IoamDisable) GetMessageType() api.MessageType { return api.RequestMessage }
 857
 858 func (m *IoamDisable) Size() int {
 859         if m == nil {
 860                 return 0
 861         }
 862         var size int
 863         // field[1] m.ID
 864         size += 2
 865         return size
 866 }
 867 func (m *IoamDisable) Marshal(b []byte) ([]byte, error) {
 868         o := binary.BigEndian
 869         _ = o
 870         pos := 0
 871         _ = pos
 872         var buf []byte
 873         if b == nil {
 874                 buf = make([]byte, m.Size())
 875         } else {
 876                 buf = b
 877         }
 878         // field[1] m.ID
 879         o.PutUint16(buf[pos:pos+2], uint16(m.ID))
 880         pos += 2
 881         return buf, nil
 882 }
 883 func (m *IoamDisable) Unmarshal(tmp []byte) error {
 884         o := binary.BigEndian
 885         _ = o
 886         pos := 0
 887         _ = pos
 888         // field[1] m.ID
 889         m.ID = uint16(o.Uint16(tmp[pos : pos+2]))
 890         pos += 2
 891         return nil
 892 }
 893
 894 // IoamDisableReply represents VPP binary API message 'ioam_disable_reply'.
 895 type IoamDisableReply struct {
 896         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 897 }
 898
 899 func (m *IoamDisableReply) Reset()                        { *m = IoamDisableReply{} }
 900 func (*IoamDisableReply) GetMessageName() string          { return "ioam_disable_reply" }
 901 func (*IoamDisableReply) GetCrcString() string            { return "e8d4e804" }
 902 func (*IoamDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
 903
 904 func (m *IoamDisableReply) Size() int {
 905         if m == nil {
 906                 return 0
 907         }
 908         var size int
 909         // field[1] m.Retval
 910         size += 4
 911         return size
 912 }
 913 func (m *IoamDisableReply) Marshal(b []byte) ([]byte, error) {
 914         o := binary.BigEndian
 915         _ = o
 916         pos := 0
 917         _ = pos
 918         var buf []byte
 919         if b == nil {
 920                 buf = make([]byte, m.Size())
 921         } else {
 922                 buf = b
 923         }
 924         // field[1] m.Retval
 925         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
 926         pos += 4
 927         return buf, nil
 928 }
 929 func (m *IoamDisableReply) Unmarshal(tmp []byte) error {
 930         o := binary.BigEndian
 931         _ = o
 932         pos := 0
 933         _ = pos
 934         // field[1] m.Retval
 935         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
 936         pos += 4
 937         return nil
 938 }
 939
 940 // IoamEnable represents VPP binary API message 'ioam_enable'.
 941 type IoamEnable struct {
 942         ID          uint16 `binapi:"u16,name=id" json:"id,omitempty"`
 943         Seqno       bool   `binapi:"bool,name=seqno" json:"seqno,omitempty"`
 944         Analyse     bool   `binapi:"bool,name=analyse" json:"analyse,omitempty"`
 945         PotEnable   bool   `binapi:"bool,name=pot_enable" json:"pot_enable,omitempty"`
 946         TraceEnable bool   `binapi:"bool,name=trace_enable" json:"trace_enable,omitempty"`
 947         NodeID      uint32 `binapi:"u32,name=node_id" json:"node_id,omitempty"`
 948 }
 949
 950 func (m *IoamEnable) Reset()                        { *m = IoamEnable{} }
 951 func (*IoamEnable) GetMessageName() string          { return "ioam_enable" }
 952 func (*IoamEnable) GetCrcString() string            { return "51ccd868" }
 953 func (*IoamEnable) GetMessageType() api.MessageType { return api.RequestMessage }
 954
 955 func (m *IoamEnable) Size() int {
 956         if m == nil {
 957                 return 0
 958         }
 959         var size int
 960         // field[1] m.ID
 961         size += 2
 962         // field[1] m.Seqno
 963         size += 1
 964         // field[1] m.Analyse
 965         size += 1
 966         // field[1] m.PotEnable
 967         size += 1
 968         // field[1] m.TraceEnable
 969         size += 1
 970         // field[1] m.NodeID
 971         size += 4
 972         return size
 973 }
 974 func (m *IoamEnable) Marshal(b []byte) ([]byte, error) {
 975         o := binary.BigEndian
 976         _ = o
 977         pos := 0
 978         _ = pos
 979         var buf []byte
 980         if b == nil {
 981                 buf = make([]byte, m.Size())
 982         } else {
 983                 buf = b
 984         }
 985         // field[1] m.ID
 986         o.PutUint16(buf[pos:pos+2], uint16(m.ID))
 987         pos += 2
 988         // field[1] m.Seqno
 989         if m.Seqno {
 990                 buf[pos] = 1
 991         }
 992         pos += 1
 993         // field[1] m.Analyse
 994         if m.Analyse {
 995                 buf[pos] = 1
 996         }
 997         pos += 1
 998         // field[1] m.PotEnable
 999         if m.PotEnable {
1000                 buf[pos] = 1
1001         }
1002         pos += 1
1003         // field[1] m.TraceEnable
1004         if m.TraceEnable {
1005                 buf[pos] = 1
1006         }
1007         pos += 1
1008         // field[1] m.NodeID
1009         o.PutUint32(buf[pos:pos+4], uint32(m.NodeID))
1010         pos += 4
1011         return buf, nil
1012 }
1013 func (m *IoamEnable) Unmarshal(tmp []byte) error {
1014         o := binary.BigEndian
1015         _ = o
1016         pos := 0
1017         _ = pos
1018         // field[1] m.ID
1019         m.ID = uint16(o.Uint16(tmp[pos : pos+2]))
1020         pos += 2
1021         // field[1] m.Seqno
1022         m.Seqno = tmp[pos] != 0
1023         pos += 1
1024         // field[1] m.Analyse
1025         m.Analyse = tmp[pos] != 0
1026         pos += 1
1027         // field[1] m.PotEnable
1028         m.PotEnable = tmp[pos] != 0
1029         pos += 1
1030         // field[1] m.TraceEnable
1031         m.TraceEnable = tmp[pos] != 0
1032         pos += 1
1033         // field[1] m.NodeID
1034         m.NodeID = uint32(o.Uint32(tmp[pos : pos+4]))
1035         pos += 4
1036         return nil
1037 }
1038
1039 // IoamEnableReply represents VPP binary API message 'ioam_enable_reply'.
1040 type IoamEnableReply struct {
1041         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1042 }
1043
1044 func (m *IoamEnableReply) Reset()                        { *m = IoamEnableReply{} }
1045 func (*IoamEnableReply) GetMessageName() string          { return "ioam_enable_reply" }
1046 func (*IoamEnableReply) GetCrcString() string            { return "e8d4e804" }
1047 func (*IoamEnableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1048
1049 func (m *IoamEnableReply) Size() int {
1050         if m == nil {
1051                 return 0
1052         }
1053         var size int
1054         // field[1] m.Retval
1055         size += 4
1056         return size
1057 }
1058 func (m *IoamEnableReply) Marshal(b []byte) ([]byte, error) {
1059         o := binary.BigEndian
1060         _ = o
1061         pos := 0
1062         _ = pos
1063         var buf []byte
1064         if b == nil {
1065                 buf = make([]byte, m.Size())
1066         } else {
1067                 buf = b
1068         }
1069         // field[1] m.Retval
1070         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1071         pos += 4
1072         return buf, nil
1073 }
1074 func (m *IoamEnableReply) Unmarshal(tmp []byte) error {
1075         o := binary.BigEndian
1076         _ = o
1077         pos := 0
1078         _ = pos
1079         // field[1] m.Retval
1080         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1081         pos += 4
1082         return nil
1083 }
1084
1085 // IPAddressDetails represents VPP binary API message 'ip_address_details'.
1086 type IPAddressDetails struct {
1087         SwIfIndex InterfaceIndex    `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1088         Prefix    AddressWithPrefix `binapi:"address_with_prefix,name=prefix" json:"prefix,omitempty"`
1089 }
1090
1091 func (m *IPAddressDetails) Reset()                        { *m = IPAddressDetails{} }
1092 func (*IPAddressDetails) GetMessageName() string          { return "ip_address_details" }
1093 func (*IPAddressDetails) GetCrcString() string            { return "b1199745" }
1094 func (*IPAddressDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1095
1096 func (m *IPAddressDetails) Size() int {
1097         if m == nil {
1098                 return 0
1099         }
1100         var size int
1101         // field[1] m.SwIfIndex
1102         size += 4
1103         // field[1] m.Prefix
1104         // field[2] m.Prefix.Address
1105         // field[3] m.Prefix.Address.Af
1106         size += 4
1107         // field[3] m.Prefix.Address.Un
1108         size += 16
1109         // field[2] m.Prefix.Len
1110         size += 1
1111         return size
1112 }
1113 func (m *IPAddressDetails) Marshal(b []byte) ([]byte, error) {
1114         o := binary.BigEndian
1115         _ = o
1116         pos := 0
1117         _ = pos
1118         var buf []byte
1119         if b == nil {
1120                 buf = make([]byte, m.Size())
1121         } else {
1122                 buf = b
1123         }
1124         // field[1] m.SwIfIndex
1125         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1126         pos += 4
1127         // field[1] m.Prefix
1128         // field[2] m.Prefix.Address
1129         // field[3] m.Prefix.Address.Af
1130         o.PutUint32(buf[pos:pos+4], uint32(m.Prefix.Address.Af))
1131         pos += 4
1132         // field[3] m.Prefix.Address.Un
1133         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
1134         pos += 16
1135         // field[2] m.Prefix.Len
1136         buf[pos] = uint8(m.Prefix.Len)
1137         pos += 1
1138         return buf, nil
1139 }
1140 func (m *IPAddressDetails) Unmarshal(tmp []byte) error {
1141         o := binary.BigEndian
1142         _ = o
1143         pos := 0
1144         _ = pos
1145         // field[1] m.SwIfIndex
1146         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1147         pos += 4
1148         // field[1] m.Prefix
1149         // field[2] m.Prefix.Address
1150         // field[3] m.Prefix.Address.Af
1151         m.Prefix.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
1152         pos += 4
1153         // field[3] m.Prefix.Address.Un
1154         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
1155         pos += 16
1156         // field[2] m.Prefix.Len
1157         m.Prefix.Len = uint8(tmp[pos])
1158         pos += 1
1159         return nil
1160 }
1161
1162 // IPAddressDump represents VPP binary API message 'ip_address_dump'.
1163 type IPAddressDump struct {
1164         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1165         IsIPv6    bool           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
1166 }
1167
1168 func (m *IPAddressDump) Reset()                        { *m = IPAddressDump{} }
1169 func (*IPAddressDump) GetMessageName() string          { return "ip_address_dump" }
1170 func (*IPAddressDump) GetCrcString() string            { return "2d033de4" }
1171 func (*IPAddressDump) GetMessageType() api.MessageType { return api.RequestMessage }
1172
1173 func (m *IPAddressDump) Size() int {
1174         if m == nil {
1175                 return 0
1176         }
1177         var size int
1178         // field[1] m.SwIfIndex
1179         size += 4
1180         // field[1] m.IsIPv6
1181         size += 1
1182         return size
1183 }
1184 func (m *IPAddressDump) Marshal(b []byte) ([]byte, error) {
1185         o := binary.BigEndian
1186         _ = o
1187         pos := 0
1188         _ = pos
1189         var buf []byte
1190         if b == nil {
1191                 buf = make([]byte, m.Size())
1192         } else {
1193                 buf = b
1194         }
1195         // field[1] m.SwIfIndex
1196         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1197         pos += 4
1198         // field[1] m.IsIPv6
1199         if m.IsIPv6 {
1200                 buf[pos] = 1
1201         }
1202         pos += 1
1203         return buf, nil
1204 }
1205 func (m *IPAddressDump) Unmarshal(tmp []byte) error {
1206         o := binary.BigEndian
1207         _ = o
1208         pos := 0
1209         _ = pos
1210         // field[1] m.SwIfIndex
1211         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1212         pos += 4
1213         // field[1] m.IsIPv6
1214         m.IsIPv6 = tmp[pos] != 0
1215         pos += 1
1216         return nil
1217 }
1218
1219 // IPContainerProxyAddDel represents VPP binary API message 'ip_container_proxy_add_del'.
1220 type IPContainerProxyAddDel struct {
1221         Pfx       Prefix         `binapi:"prefix,name=pfx" json:"pfx,omitempty"`
1222         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1223         IsAdd     bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1224 }
1225
1226 func (m *IPContainerProxyAddDel) Reset()                        { *m = IPContainerProxyAddDel{} }
1227 func (*IPContainerProxyAddDel) GetMessageName() string          { return "ip_container_proxy_add_del" }
1228 func (*IPContainerProxyAddDel) GetCrcString() string            { return "91189f40" }
1229 func (*IPContainerProxyAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
1230
1231 func (m *IPContainerProxyAddDel) Size() int {
1232         if m == nil {
1233                 return 0
1234         }
1235         var size int
1236         // field[1] m.Pfx
1237         // field[2] m.Pfx.Address
1238         // field[3] m.Pfx.Address.Af
1239         size += 4
1240         // field[3] m.Pfx.Address.Un
1241         size += 16
1242         // field[2] m.Pfx.Len
1243         size += 1
1244         // field[1] m.SwIfIndex
1245         size += 4
1246         // field[1] m.IsAdd
1247         size += 1
1248         return size
1249 }
1250 func (m *IPContainerProxyAddDel) Marshal(b []byte) ([]byte, error) {
1251         o := binary.BigEndian
1252         _ = o
1253         pos := 0
1254         _ = pos
1255         var buf []byte
1256         if b == nil {
1257                 buf = make([]byte, m.Size())
1258         } else {
1259                 buf = b
1260         }
1261         // field[1] m.Pfx
1262         // field[2] m.Pfx.Address
1263         // field[3] m.Pfx.Address.Af
1264         o.PutUint32(buf[pos:pos+4], uint32(m.Pfx.Address.Af))
1265         pos += 4
1266         // field[3] m.Pfx.Address.Un
1267         copy(buf[pos:pos+16], m.Pfx.Address.Un.XXX_UnionData[:])
1268         pos += 16
1269         // field[2] m.Pfx.Len
1270         buf[pos] = uint8(m.Pfx.Len)
1271         pos += 1
1272         // field[1] m.SwIfIndex
1273         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1274         pos += 4
1275         // field[1] m.IsAdd
1276         if m.IsAdd {
1277                 buf[pos] = 1
1278         }
1279         pos += 1
1280         return buf, nil
1281 }
1282 func (m *IPContainerProxyAddDel) Unmarshal(tmp []byte) error {
1283         o := binary.BigEndian
1284         _ = o
1285         pos := 0
1286         _ = pos
1287         // field[1] m.Pfx
1288         // field[2] m.Pfx.Address
1289         // field[3] m.Pfx.Address.Af
1290         m.Pfx.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
1291         pos += 4
1292         // field[3] m.Pfx.Address.Un
1293         copy(m.Pfx.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
1294         pos += 16
1295         // field[2] m.Pfx.Len
1296         m.Pfx.Len = uint8(tmp[pos])
1297         pos += 1
1298         // field[1] m.SwIfIndex
1299         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1300         pos += 4
1301         // field[1] m.IsAdd
1302         m.IsAdd = tmp[pos] != 0
1303         pos += 1
1304         return nil
1305 }
1306
1307 // IPContainerProxyAddDelReply represents VPP binary API message 'ip_container_proxy_add_del_reply'.
1308 type IPContainerProxyAddDelReply struct {
1309         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1310 }
1311
1312 func (m *IPContainerProxyAddDelReply) Reset() { *m = IPContainerProxyAddDelReply{} }
1313 func (*IPContainerProxyAddDelReply) GetMessageName() string {
1314         return "ip_container_proxy_add_del_reply"
1315 }
1316 func (*IPContainerProxyAddDelReply) GetCrcString() string            { return "e8d4e804" }
1317 func (*IPContainerProxyAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1318
1319 func (m *IPContainerProxyAddDelReply) Size() int {
1320         if m == nil {
1321                 return 0
1322         }
1323         var size int
1324         // field[1] m.Retval
1325         size += 4
1326         return size
1327 }
1328 func (m *IPContainerProxyAddDelReply) Marshal(b []byte) ([]byte, error) {
1329         o := binary.BigEndian
1330         _ = o
1331         pos := 0
1332         _ = pos
1333         var buf []byte
1334         if b == nil {
1335                 buf = make([]byte, m.Size())
1336         } else {
1337                 buf = b
1338         }
1339         // field[1] m.Retval
1340         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1341         pos += 4
1342         return buf, nil
1343 }
1344 func (m *IPContainerProxyAddDelReply) Unmarshal(tmp []byte) error {
1345         o := binary.BigEndian
1346         _ = o
1347         pos := 0
1348         _ = pos
1349         // field[1] m.Retval
1350         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1351         pos += 4
1352         return nil
1353 }
1354
1355 // IPContainerProxyDetails represents VPP binary API message 'ip_container_proxy_details'.
1356 type IPContainerProxyDetails struct {
1357         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1358         Prefix    Prefix         `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
1359 }
1360
1361 func (m *IPContainerProxyDetails) Reset()                        { *m = IPContainerProxyDetails{} }
1362 func (*IPContainerProxyDetails) GetMessageName() string          { return "ip_container_proxy_details" }
1363 func (*IPContainerProxyDetails) GetCrcString() string            { return "0ee460e8" }
1364 func (*IPContainerProxyDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1365
1366 func (m *IPContainerProxyDetails) Size() int {
1367         if m == nil {
1368                 return 0
1369         }
1370         var size int
1371         // field[1] m.SwIfIndex
1372         size += 4
1373         // field[1] m.Prefix
1374         // field[2] m.Prefix.Address
1375         // field[3] m.Prefix.Address.Af
1376         size += 4
1377         // field[3] m.Prefix.Address.Un
1378         size += 16
1379         // field[2] m.Prefix.Len
1380         size += 1
1381         return size
1382 }
1383 func (m *IPContainerProxyDetails) Marshal(b []byte) ([]byte, error) {
1384         o := binary.BigEndian
1385         _ = o
1386         pos := 0
1387         _ = pos
1388         var buf []byte
1389         if b == nil {
1390                 buf = make([]byte, m.Size())
1391         } else {
1392                 buf = b
1393         }
1394         // field[1] m.SwIfIndex
1395         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1396         pos += 4
1397         // field[1] m.Prefix
1398         // field[2] m.Prefix.Address
1399         // field[3] m.Prefix.Address.Af
1400         o.PutUint32(buf[pos:pos+4], uint32(m.Prefix.Address.Af))
1401         pos += 4
1402         // field[3] m.Prefix.Address.Un
1403         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
1404         pos += 16
1405         // field[2] m.Prefix.Len
1406         buf[pos] = uint8(m.Prefix.Len)
1407         pos += 1
1408         return buf, nil
1409 }
1410 func (m *IPContainerProxyDetails) Unmarshal(tmp []byte) error {
1411         o := binary.BigEndian
1412         _ = o
1413         pos := 0
1414         _ = pos
1415         // field[1] m.SwIfIndex
1416         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1417         pos += 4
1418         // field[1] m.Prefix
1419         // field[2] m.Prefix.Address
1420         // field[3] m.Prefix.Address.Af
1421         m.Prefix.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
1422         pos += 4
1423         // field[3] m.Prefix.Address.Un
1424         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
1425         pos += 16
1426         // field[2] m.Prefix.Len
1427         m.Prefix.Len = uint8(tmp[pos])
1428         pos += 1
1429         return nil
1430 }
1431
1432 // IPContainerProxyDump represents VPP binary API message 'ip_container_proxy_dump'.
1433 type IPContainerProxyDump struct{}
1434
1435 func (m *IPContainerProxyDump) Reset()                        { *m = IPContainerProxyDump{} }
1436 func (*IPContainerProxyDump) GetMessageName() string          { return "ip_container_proxy_dump" }
1437 func (*IPContainerProxyDump) GetCrcString() string            { return "51077d14" }
1438 func (*IPContainerProxyDump) GetMessageType() api.MessageType { return api.RequestMessage }
1439
1440 func (m *IPContainerProxyDump) Size() int {
1441         if m == nil {
1442                 return 0
1443         }
1444         var size int
1445         return size
1446 }
1447 func (m *IPContainerProxyDump) Marshal(b []byte) ([]byte, error) {
1448         o := binary.BigEndian
1449         _ = o
1450         pos := 0
1451         _ = pos
1452         var buf []byte
1453         if b == nil {
1454                 buf = make([]byte, m.Size())
1455         } else {
1456                 buf = b
1457         }
1458         return buf, nil
1459 }
1460 func (m *IPContainerProxyDump) Unmarshal(tmp []byte) error {
1461         o := binary.BigEndian
1462         _ = o
1463         pos := 0
1464         _ = pos
1465         return nil
1466 }
1467
1468 // IPDetails represents VPP binary API message 'ip_details'.
1469 type IPDetails struct {
1470         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1471         IsIPv6    bool           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
1472 }
1473
1474 func (m *IPDetails) Reset()                        { *m = IPDetails{} }
1475 func (*IPDetails) GetMessageName() string          { return "ip_details" }
1476 func (*IPDetails) GetCrcString() string            { return "eb152d07" }
1477 func (*IPDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1478
1479 func (m *IPDetails) Size() int {
1480         if m == nil {
1481                 return 0
1482         }
1483         var size int
1484         // field[1] m.SwIfIndex
1485         size += 4
1486         // field[1] m.IsIPv6
1487         size += 1
1488         return size
1489 }
1490 func (m *IPDetails) Marshal(b []byte) ([]byte, error) {
1491         o := binary.BigEndian
1492         _ = o
1493         pos := 0
1494         _ = pos
1495         var buf []byte
1496         if b == nil {
1497                 buf = make([]byte, m.Size())
1498         } else {
1499                 buf = b
1500         }
1501         // field[1] m.SwIfIndex
1502         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
1503         pos += 4
1504         // field[1] m.IsIPv6
1505         if m.IsIPv6 {
1506                 buf[pos] = 1
1507         }
1508         pos += 1
1509         return buf, nil
1510 }
1511 func (m *IPDetails) Unmarshal(tmp []byte) error {
1512         o := binary.BigEndian
1513         _ = o
1514         pos := 0
1515         _ = pos
1516         // field[1] m.SwIfIndex
1517         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
1518         pos += 4
1519         // field[1] m.IsIPv6
1520         m.IsIPv6 = tmp[pos] != 0
1521         pos += 1
1522         return nil
1523 }
1524
1525 // IPDump represents VPP binary API message 'ip_dump'.
1526 type IPDump struct {
1527         IsIPv6 bool `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
1528 }
1529
1530 func (m *IPDump) Reset()                        { *m = IPDump{} }
1531 func (*IPDump) GetMessageName() string          { return "ip_dump" }
1532 func (*IPDump) GetCrcString() string            { return "98d231ca" }
1533 func (*IPDump) GetMessageType() api.MessageType { return api.RequestMessage }
1534
1535 func (m *IPDump) Size() int {
1536         if m == nil {
1537                 return 0
1538         }
1539         var size int
1540         // field[1] m.IsIPv6
1541         size += 1
1542         return size
1543 }
1544 func (m *IPDump) Marshal(b []byte) ([]byte, error) {
1545         o := binary.BigEndian
1546         _ = o
1547         pos := 0
1548         _ = pos
1549         var buf []byte
1550         if b == nil {
1551                 buf = make([]byte, m.Size())
1552         } else {
1553                 buf = b
1554         }
1555         // field[1] m.IsIPv6
1556         if m.IsIPv6 {
1557                 buf[pos] = 1
1558         }
1559         pos += 1
1560         return buf, nil
1561 }
1562 func (m *IPDump) Unmarshal(tmp []byte) error {
1563         o := binary.BigEndian
1564         _ = o
1565         pos := 0
1566         _ = pos
1567         // field[1] m.IsIPv6
1568         m.IsIPv6 = tmp[pos] != 0
1569         pos += 1
1570         return nil
1571 }
1572
1573 // IPMrouteAddDel represents VPP binary API message 'ip_mroute_add_del'.
1574 type IPMrouteAddDel struct {
1575         IsAdd       bool     `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1576         IsMultipath bool     `binapi:"bool,name=is_multipath" json:"is_multipath,omitempty"`
1577         Route       IPMroute `binapi:"ip_mroute,name=route" json:"route,omitempty"`
1578 }
1579
1580 func (m *IPMrouteAddDel) Reset()                        { *m = IPMrouteAddDel{} }
1581 func (*IPMrouteAddDel) GetMessageName() string          { return "ip_mroute_add_del" }
1582 func (*IPMrouteAddDel) GetCrcString() string            { return "f6627d17" }
1583 func (*IPMrouteAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
1584
1585 func (m *IPMrouteAddDel) Size() int {
1586         if m == nil {
1587                 return 0
1588         }
1589         var size int
1590         // field[1] m.IsAdd
1591         size += 1
1592         // field[1] m.IsMultipath
1593         size += 1
1594         // field[1] m.Route
1595         // field[2] m.Route.TableID
1596         size += 4
1597         // field[2] m.Route.EntryFlags
1598         size += 4
1599         // field[2] m.Route.RpfID
1600         size += 4
1601         // field[2] m.Route.Prefix
1602         // field[3] m.Route.Prefix.Af
1603         size += 4
1604         // field[3] m.Route.Prefix.GrpAddressLength
1605         size += 2
1606         // field[3] m.Route.Prefix.GrpAddress
1607         size += 16
1608         // field[3] m.Route.Prefix.SrcAddress
1609         size += 16
1610         // field[2] m.Route.NPaths
1611         size += 1
1612         // field[2] m.Route.Paths
1613         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1614                 var s2 MfibPath
1615                 _ = s2
1616                 if j2 < len(m.Route.Paths) {
1617                         s2 = m.Route.Paths[j2]
1618                 }
1619                 // field[3] s2.ItfFlags
1620                 size += 4
1621                 // field[3] s2.Path
1622                 // field[4] s2.Path.SwIfIndex
1623                 size += 4
1624                 // field[4] s2.Path.TableID
1625                 size += 4
1626                 // field[4] s2.Path.RpfID
1627                 size += 4
1628                 // field[4] s2.Path.Weight
1629                 size += 1
1630                 // field[4] s2.Path.Preference
1631                 size += 1
1632                 // field[4] s2.Path.Type
1633                 size += 4
1634                 // field[4] s2.Path.Flags
1635                 size += 4
1636                 // field[4] s2.Path.Proto
1637                 size += 4
1638                 // field[4] s2.Path.Nh
1639                 // field[5] s2.Path.Nh.Address
1640                 size += 16
1641                 // field[5] s2.Path.Nh.ViaLabel
1642                 size += 4
1643                 // field[5] s2.Path.Nh.ObjID
1644                 size += 4
1645                 // field[5] s2.Path.Nh.ClassifyTableIndex
1646                 size += 4
1647                 // field[4] s2.Path.NLabels
1648                 size += 1
1649                 // field[4] s2.Path.LabelStack
1650                 for j4 := 0; j4 < 16; j4++ {
1651                         var s4 FibMplsLabel
1652                         _ = s4
1653                         if j4 < len(s2.Path.LabelStack) {
1654                                 s4 = s2.Path.LabelStack[j4]
1655                         }
1656                         // field[5] s4.IsUniform
1657                         size += 1
1658                         // field[5] s4.Label
1659                         size += 4
1660                         // field[5] s4.TTL
1661                         size += 1
1662                         // field[5] s4.Exp
1663                         size += 1
1664                 }
1665         }
1666         return size
1667 }
1668 func (m *IPMrouteAddDel) Marshal(b []byte) ([]byte, error) {
1669         o := binary.BigEndian
1670         _ = o
1671         pos := 0
1672         _ = pos
1673         var buf []byte
1674         if b == nil {
1675                 buf = make([]byte, m.Size())
1676         } else {
1677                 buf = b
1678         }
1679         // field[1] m.IsAdd
1680         if m.IsAdd {
1681                 buf[pos] = 1
1682         }
1683         pos += 1
1684         // field[1] m.IsMultipath
1685         if m.IsMultipath {
1686                 buf[pos] = 1
1687         }
1688         pos += 1
1689         // field[1] m.Route
1690         // field[2] m.Route.TableID
1691         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
1692         pos += 4
1693         // field[2] m.Route.EntryFlags
1694         o.PutUint32(buf[pos:pos+4], uint32(m.Route.EntryFlags))
1695         pos += 4
1696         // field[2] m.Route.RpfID
1697         o.PutUint32(buf[pos:pos+4], uint32(m.Route.RpfID))
1698         pos += 4
1699         // field[2] m.Route.Prefix
1700         // field[3] m.Route.Prefix.Af
1701         o.PutUint32(buf[pos:pos+4], uint32(m.Route.Prefix.Af))
1702         pos += 4
1703         // field[3] m.Route.Prefix.GrpAddressLength
1704         o.PutUint16(buf[pos:pos+2], uint16(m.Route.Prefix.GrpAddressLength))
1705         pos += 2
1706         // field[3] m.Route.Prefix.GrpAddress
1707         copy(buf[pos:pos+16], m.Route.Prefix.GrpAddress.XXX_UnionData[:])
1708         pos += 16
1709         // field[3] m.Route.Prefix.SrcAddress
1710         copy(buf[pos:pos+16], m.Route.Prefix.SrcAddress.XXX_UnionData[:])
1711         pos += 16
1712         // field[2] m.Route.NPaths
1713         buf[pos] = uint8(len(m.Route.Paths))
1714         pos += 1
1715         // field[2] m.Route.Paths
1716         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1717                 var v2 MfibPath
1718                 if j2 < len(m.Route.Paths) {
1719                         v2 = m.Route.Paths[j2]
1720                 }
1721                 // field[3] v2.ItfFlags
1722                 o.PutUint32(buf[pos:pos+4], uint32(v2.ItfFlags))
1723                 pos += 4
1724                 // field[3] v2.Path
1725                 // field[4] v2.Path.SwIfIndex
1726                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.SwIfIndex))
1727                 pos += 4
1728                 // field[4] v2.Path.TableID
1729                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.TableID))
1730                 pos += 4
1731                 // field[4] v2.Path.RpfID
1732                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.RpfID))
1733                 pos += 4
1734                 // field[4] v2.Path.Weight
1735                 buf[pos] = uint8(v2.Path.Weight)
1736                 pos += 1
1737                 // field[4] v2.Path.Preference
1738                 buf[pos] = uint8(v2.Path.Preference)
1739                 pos += 1
1740                 // field[4] v2.Path.Type
1741                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Type))
1742                 pos += 4
1743                 // field[4] v2.Path.Flags
1744                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Flags))
1745                 pos += 4
1746                 // field[4] v2.Path.Proto
1747                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Proto))
1748                 pos += 4
1749                 // field[4] v2.Path.Nh
1750                 // field[5] v2.Path.Nh.Address
1751                 copy(buf[pos:pos+16], v2.Path.Nh.Address.XXX_UnionData[:])
1752                 pos += 16
1753                 // field[5] v2.Path.Nh.ViaLabel
1754                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ViaLabel))
1755                 pos += 4
1756                 // field[5] v2.Path.Nh.ObjID
1757                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ObjID))
1758                 pos += 4
1759                 // field[5] v2.Path.Nh.ClassifyTableIndex
1760                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ClassifyTableIndex))
1761                 pos += 4
1762                 // field[4] v2.Path.NLabels
1763                 buf[pos] = uint8(v2.Path.NLabels)
1764                 pos += 1
1765                 // field[4] v2.Path.LabelStack
1766                 for j4 := 0; j4 < 16; j4++ {
1767                         var v4 FibMplsLabel
1768                         if j4 < len(v2.Path.LabelStack) {
1769                                 v4 = v2.Path.LabelStack[j4]
1770                         }
1771                         // field[5] v4.IsUniform
1772                         buf[pos] = uint8(v4.IsUniform)
1773                         pos += 1
1774                         // field[5] v4.Label
1775                         o.PutUint32(buf[pos:pos+4], uint32(v4.Label))
1776                         pos += 4
1777                         // field[5] v4.TTL
1778                         buf[pos] = uint8(v4.TTL)
1779                         pos += 1
1780                         // field[5] v4.Exp
1781                         buf[pos] = uint8(v4.Exp)
1782                         pos += 1
1783                 }
1784         }
1785         return buf, nil
1786 }
1787 func (m *IPMrouteAddDel) Unmarshal(tmp []byte) error {
1788         o := binary.BigEndian
1789         _ = o
1790         pos := 0
1791         _ = pos
1792         // field[1] m.IsAdd
1793         m.IsAdd = tmp[pos] != 0
1794         pos += 1
1795         // field[1] m.IsMultipath
1796         m.IsMultipath = tmp[pos] != 0
1797         pos += 1
1798         // field[1] m.Route
1799         // field[2] m.Route.TableID
1800         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1801         pos += 4
1802         // field[2] m.Route.EntryFlags
1803         m.Route.EntryFlags = uint32(o.Uint32(tmp[pos : pos+4]))
1804         pos += 4
1805         // field[2] m.Route.RpfID
1806         m.Route.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1807         pos += 4
1808         // field[2] m.Route.Prefix
1809         // field[3] m.Route.Prefix.Af
1810         m.Route.Prefix.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
1811         pos += 4
1812         // field[3] m.Route.Prefix.GrpAddressLength
1813         m.Route.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
1814         pos += 2
1815         // field[3] m.Route.Prefix.GrpAddress
1816         copy(m.Route.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
1817         pos += 16
1818         // field[3] m.Route.Prefix.SrcAddress
1819         copy(m.Route.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
1820         pos += 16
1821         // field[2] m.Route.NPaths
1822         m.Route.NPaths = uint8(tmp[pos])
1823         pos += 1
1824         // field[2] m.Route.Paths
1825         m.Route.Paths = make([]MfibPath, int(m.Route.NPaths))
1826         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
1827                 // field[3] m.Route.Paths[j2].ItfFlags
1828                 m.Route.Paths[j2].ItfFlags = MfibItfFlags(o.Uint32(tmp[pos : pos+4]))
1829                 pos += 4
1830                 // field[3] m.Route.Paths[j2].Path
1831                 // field[4] m.Route.Paths[j2].Path.SwIfIndex
1832                 m.Route.Paths[j2].Path.SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1833                 pos += 4
1834                 // field[4] m.Route.Paths[j2].Path.TableID
1835                 m.Route.Paths[j2].Path.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
1836                 pos += 4
1837                 // field[4] m.Route.Paths[j2].Path.RpfID
1838                 m.Route.Paths[j2].Path.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
1839                 pos += 4
1840                 // field[4] m.Route.Paths[j2].Path.Weight
1841                 m.Route.Paths[j2].Path.Weight = uint8(tmp[pos])
1842                 pos += 1
1843                 // field[4] m.Route.Paths[j2].Path.Preference
1844                 m.Route.Paths[j2].Path.Preference = uint8(tmp[pos])
1845                 pos += 1
1846                 // field[4] m.Route.Paths[j2].Path.Type
1847                 m.Route.Paths[j2].Path.Type = FibPathType(o.Uint32(tmp[pos : pos+4]))
1848                 pos += 4
1849                 // field[4] m.Route.Paths[j2].Path.Flags
1850                 m.Route.Paths[j2].Path.Flags = FibPathFlags(o.Uint32(tmp[pos : pos+4]))
1851                 pos += 4
1852                 // field[4] m.Route.Paths[j2].Path.Proto
1853                 m.Route.Paths[j2].Path.Proto = FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
1854                 pos += 4
1855                 // field[4] m.Route.Paths[j2].Path.Nh
1856                 // field[5] m.Route.Paths[j2].Path.Nh.Address
1857                 copy(m.Route.Paths[j2].Path.Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
1858                 pos += 16
1859                 // field[5] m.Route.Paths[j2].Path.Nh.ViaLabel
1860                 m.Route.Paths[j2].Path.Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
1861                 pos += 4
1862                 // field[5] m.Route.Paths[j2].Path.Nh.ObjID
1863                 m.Route.Paths[j2].Path.Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
1864                 pos += 4
1865                 // field[5] m.Route.Paths[j2].Path.Nh.ClassifyTableIndex
1866                 m.Route.Paths[j2].Path.Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1867                 pos += 4
1868                 // field[4] m.Route.Paths[j2].Path.NLabels
1869                 m.Route.Paths[j2].Path.NLabels = uint8(tmp[pos])
1870                 pos += 1
1871                 // field[4] m.Route.Paths[j2].Path.LabelStack
1872                 for j4 := 0; j4 < 16; j4++ {
1873                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].IsUniform
1874                         m.Route.Paths[j2].Path.LabelStack[j4].IsUniform = uint8(tmp[pos])
1875                         pos += 1
1876                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Label
1877                         m.Route.Paths[j2].Path.LabelStack[j4].Label = uint32(o.Uint32(tmp[pos : pos+4]))
1878                         pos += 4
1879                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].TTL
1880                         m.Route.Paths[j2].Path.LabelStack[j4].TTL = uint8(tmp[pos])
1881                         pos += 1
1882                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Exp
1883                         m.Route.Paths[j2].Path.LabelStack[j4].Exp = uint8(tmp[pos])
1884                         pos += 1
1885                 }
1886         }
1887         return nil
1888 }
1889
1890 // IPMrouteAddDelReply represents VPP binary API message 'ip_mroute_add_del_reply'.
1891 type IPMrouteAddDelReply struct {
1892         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1893         StatsIndex uint32 `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
1894 }
1895
1896 func (m *IPMrouteAddDelReply) Reset()                        { *m = IPMrouteAddDelReply{} }
1897 func (*IPMrouteAddDelReply) GetMessageName() string          { return "ip_mroute_add_del_reply" }
1898 func (*IPMrouteAddDelReply) GetCrcString() string            { return "1992deab" }
1899 func (*IPMrouteAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
1900
1901 func (m *IPMrouteAddDelReply) Size() int {
1902         if m == nil {
1903                 return 0
1904         }
1905         var size int
1906         // field[1] m.Retval
1907         size += 4
1908         // field[1] m.StatsIndex
1909         size += 4
1910         return size
1911 }
1912 func (m *IPMrouteAddDelReply) Marshal(b []byte) ([]byte, error) {
1913         o := binary.BigEndian
1914         _ = o
1915         pos := 0
1916         _ = pos
1917         var buf []byte
1918         if b == nil {
1919                 buf = make([]byte, m.Size())
1920         } else {
1921                 buf = b
1922         }
1923         // field[1] m.Retval
1924         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
1925         pos += 4
1926         // field[1] m.StatsIndex
1927         o.PutUint32(buf[pos:pos+4], uint32(m.StatsIndex))
1928         pos += 4
1929         return buf, nil
1930 }
1931 func (m *IPMrouteAddDelReply) Unmarshal(tmp []byte) error {
1932         o := binary.BigEndian
1933         _ = o
1934         pos := 0
1935         _ = pos
1936         // field[1] m.Retval
1937         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
1938         pos += 4
1939         // field[1] m.StatsIndex
1940         m.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
1941         pos += 4
1942         return nil
1943 }
1944
1945 // IPMrouteDetails represents VPP binary API message 'ip_mroute_details'.
1946 type IPMrouteDetails struct {
1947         Route IPMroute `binapi:"ip_mroute,name=route" json:"route,omitempty"`
1948 }
1949
1950 func (m *IPMrouteDetails) Reset()                        { *m = IPMrouteDetails{} }
1951 func (*IPMrouteDetails) GetMessageName() string          { return "ip_mroute_details" }
1952 func (*IPMrouteDetails) GetCrcString() string            { return "c1cb4b44" }
1953 func (*IPMrouteDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
1954
1955 func (m *IPMrouteDetails) Size() int {
1956         if m == nil {
1957                 return 0
1958         }
1959         var size int
1960         // field[1] m.Route
1961         // field[2] m.Route.TableID
1962         size += 4
1963         // field[2] m.Route.EntryFlags
1964         size += 4
1965         // field[2] m.Route.RpfID
1966         size += 4
1967         // field[2] m.Route.Prefix
1968         // field[3] m.Route.Prefix.Af
1969         size += 4
1970         // field[3] m.Route.Prefix.GrpAddressLength
1971         size += 2
1972         // field[3] m.Route.Prefix.GrpAddress
1973         size += 16
1974         // field[3] m.Route.Prefix.SrcAddress
1975         size += 16
1976         // field[2] m.Route.NPaths
1977         size += 1
1978         // field[2] m.Route.Paths
1979         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
1980                 var s2 MfibPath
1981                 _ = s2
1982                 if j2 < len(m.Route.Paths) {
1983                         s2 = m.Route.Paths[j2]
1984                 }
1985                 // field[3] s2.ItfFlags
1986                 size += 4
1987                 // field[3] s2.Path
1988                 // field[4] s2.Path.SwIfIndex
1989                 size += 4
1990                 // field[4] s2.Path.TableID
1991                 size += 4
1992                 // field[4] s2.Path.RpfID
1993                 size += 4
1994                 // field[4] s2.Path.Weight
1995                 size += 1
1996                 // field[4] s2.Path.Preference
1997                 size += 1
1998                 // field[4] s2.Path.Type
1999                 size += 4
2000                 // field[4] s2.Path.Flags
2001                 size += 4
2002                 // field[4] s2.Path.Proto
2003                 size += 4
2004                 // field[4] s2.Path.Nh
2005                 // field[5] s2.Path.Nh.Address
2006                 size += 16
2007                 // field[5] s2.Path.Nh.ViaLabel
2008                 size += 4
2009                 // field[5] s2.Path.Nh.ObjID
2010                 size += 4
2011                 // field[5] s2.Path.Nh.ClassifyTableIndex
2012                 size += 4
2013                 // field[4] s2.Path.NLabels
2014                 size += 1
2015                 // field[4] s2.Path.LabelStack
2016                 for j4 := 0; j4 < 16; j4++ {
2017                         var s4 FibMplsLabel
2018                         _ = s4
2019                         if j4 < len(s2.Path.LabelStack) {
2020                                 s4 = s2.Path.LabelStack[j4]
2021                         }
2022                         // field[5] s4.IsUniform
2023                         size += 1
2024                         // field[5] s4.Label
2025                         size += 4
2026                         // field[5] s4.TTL
2027                         size += 1
2028                         // field[5] s4.Exp
2029                         size += 1
2030                 }
2031         }
2032         return size
2033 }
2034 func (m *IPMrouteDetails) Marshal(b []byte) ([]byte, error) {
2035         o := binary.BigEndian
2036         _ = o
2037         pos := 0
2038         _ = pos
2039         var buf []byte
2040         if b == nil {
2041                 buf = make([]byte, m.Size())
2042         } else {
2043                 buf = b
2044         }
2045         // field[1] m.Route
2046         // field[2] m.Route.TableID
2047         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
2048         pos += 4
2049         // field[2] m.Route.EntryFlags
2050         o.PutUint32(buf[pos:pos+4], uint32(m.Route.EntryFlags))
2051         pos += 4
2052         // field[2] m.Route.RpfID
2053         o.PutUint32(buf[pos:pos+4], uint32(m.Route.RpfID))
2054         pos += 4
2055         // field[2] m.Route.Prefix
2056         // field[3] m.Route.Prefix.Af
2057         o.PutUint32(buf[pos:pos+4], uint32(m.Route.Prefix.Af))
2058         pos += 4
2059         // field[3] m.Route.Prefix.GrpAddressLength
2060         o.PutUint16(buf[pos:pos+2], uint16(m.Route.Prefix.GrpAddressLength))
2061         pos += 2
2062         // field[3] m.Route.Prefix.GrpAddress
2063         copy(buf[pos:pos+16], m.Route.Prefix.GrpAddress.XXX_UnionData[:])
2064         pos += 16
2065         // field[3] m.Route.Prefix.SrcAddress
2066         copy(buf[pos:pos+16], m.Route.Prefix.SrcAddress.XXX_UnionData[:])
2067         pos += 16
2068         // field[2] m.Route.NPaths
2069         buf[pos] = uint8(len(m.Route.Paths))
2070         pos += 1
2071         // field[2] m.Route.Paths
2072         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
2073                 var v2 MfibPath
2074                 if j2 < len(m.Route.Paths) {
2075                         v2 = m.Route.Paths[j2]
2076                 }
2077                 // field[3] v2.ItfFlags
2078                 o.PutUint32(buf[pos:pos+4], uint32(v2.ItfFlags))
2079                 pos += 4
2080                 // field[3] v2.Path
2081                 // field[4] v2.Path.SwIfIndex
2082                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.SwIfIndex))
2083                 pos += 4
2084                 // field[4] v2.Path.TableID
2085                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.TableID))
2086                 pos += 4
2087                 // field[4] v2.Path.RpfID
2088                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.RpfID))
2089                 pos += 4
2090                 // field[4] v2.Path.Weight
2091                 buf[pos] = uint8(v2.Path.Weight)
2092                 pos += 1
2093                 // field[4] v2.Path.Preference
2094                 buf[pos] = uint8(v2.Path.Preference)
2095                 pos += 1
2096                 // field[4] v2.Path.Type
2097                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Type))
2098                 pos += 4
2099                 // field[4] v2.Path.Flags
2100                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Flags))
2101                 pos += 4
2102                 // field[4] v2.Path.Proto
2103                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Proto))
2104                 pos += 4
2105                 // field[4] v2.Path.Nh
2106                 // field[5] v2.Path.Nh.Address
2107                 copy(buf[pos:pos+16], v2.Path.Nh.Address.XXX_UnionData[:])
2108                 pos += 16
2109                 // field[5] v2.Path.Nh.ViaLabel
2110                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ViaLabel))
2111                 pos += 4
2112                 // field[5] v2.Path.Nh.ObjID
2113                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ObjID))
2114                 pos += 4
2115                 // field[5] v2.Path.Nh.ClassifyTableIndex
2116                 o.PutUint32(buf[pos:pos+4], uint32(v2.Path.Nh.ClassifyTableIndex))
2117                 pos += 4
2118                 // field[4] v2.Path.NLabels
2119                 buf[pos] = uint8(v2.Path.NLabels)
2120                 pos += 1
2121                 // field[4] v2.Path.LabelStack
2122                 for j4 := 0; j4 < 16; j4++ {
2123                         var v4 FibMplsLabel
2124                         if j4 < len(v2.Path.LabelStack) {
2125                                 v4 = v2.Path.LabelStack[j4]
2126                         }
2127                         // field[5] v4.IsUniform
2128                         buf[pos] = uint8(v4.IsUniform)
2129                         pos += 1
2130                         // field[5] v4.Label
2131                         o.PutUint32(buf[pos:pos+4], uint32(v4.Label))
2132                         pos += 4
2133                         // field[5] v4.TTL
2134                         buf[pos] = uint8(v4.TTL)
2135                         pos += 1
2136                         // field[5] v4.Exp
2137                         buf[pos] = uint8(v4.Exp)
2138                         pos += 1
2139                 }
2140         }
2141         return buf, nil
2142 }
2143 func (m *IPMrouteDetails) Unmarshal(tmp []byte) error {
2144         o := binary.BigEndian
2145         _ = o
2146         pos := 0
2147         _ = pos
2148         // field[1] m.Route
2149         // field[2] m.Route.TableID
2150         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2151         pos += 4
2152         // field[2] m.Route.EntryFlags
2153         m.Route.EntryFlags = uint32(o.Uint32(tmp[pos : pos+4]))
2154         pos += 4
2155         // field[2] m.Route.RpfID
2156         m.Route.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
2157         pos += 4
2158         // field[2] m.Route.Prefix
2159         // field[3] m.Route.Prefix.Af
2160         m.Route.Prefix.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
2161         pos += 4
2162         // field[3] m.Route.Prefix.GrpAddressLength
2163         m.Route.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
2164         pos += 2
2165         // field[3] m.Route.Prefix.GrpAddress
2166         copy(m.Route.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
2167         pos += 16
2168         // field[3] m.Route.Prefix.SrcAddress
2169         copy(m.Route.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
2170         pos += 16
2171         // field[2] m.Route.NPaths
2172         m.Route.NPaths = uint8(tmp[pos])
2173         pos += 1
2174         // field[2] m.Route.Paths
2175         m.Route.Paths = make([]MfibPath, int(m.Route.NPaths))
2176         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
2177                 // field[3] m.Route.Paths[j2].ItfFlags
2178                 m.Route.Paths[j2].ItfFlags = MfibItfFlags(o.Uint32(tmp[pos : pos+4]))
2179                 pos += 4
2180                 // field[3] m.Route.Paths[j2].Path
2181                 // field[4] m.Route.Paths[j2].Path.SwIfIndex
2182                 m.Route.Paths[j2].Path.SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2183                 pos += 4
2184                 // field[4] m.Route.Paths[j2].Path.TableID
2185                 m.Route.Paths[j2].Path.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2186                 pos += 4
2187                 // field[4] m.Route.Paths[j2].Path.RpfID
2188                 m.Route.Paths[j2].Path.RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
2189                 pos += 4
2190                 // field[4] m.Route.Paths[j2].Path.Weight
2191                 m.Route.Paths[j2].Path.Weight = uint8(tmp[pos])
2192                 pos += 1
2193                 // field[4] m.Route.Paths[j2].Path.Preference
2194                 m.Route.Paths[j2].Path.Preference = uint8(tmp[pos])
2195                 pos += 1
2196                 // field[4] m.Route.Paths[j2].Path.Type
2197                 m.Route.Paths[j2].Path.Type = FibPathType(o.Uint32(tmp[pos : pos+4]))
2198                 pos += 4
2199                 // field[4] m.Route.Paths[j2].Path.Flags
2200                 m.Route.Paths[j2].Path.Flags = FibPathFlags(o.Uint32(tmp[pos : pos+4]))
2201                 pos += 4
2202                 // field[4] m.Route.Paths[j2].Path.Proto
2203                 m.Route.Paths[j2].Path.Proto = FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
2204                 pos += 4
2205                 // field[4] m.Route.Paths[j2].Path.Nh
2206                 // field[5] m.Route.Paths[j2].Path.Nh.Address
2207                 copy(m.Route.Paths[j2].Path.Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
2208                 pos += 16
2209                 // field[5] m.Route.Paths[j2].Path.Nh.ViaLabel
2210                 m.Route.Paths[j2].Path.Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
2211                 pos += 4
2212                 // field[5] m.Route.Paths[j2].Path.Nh.ObjID
2213                 m.Route.Paths[j2].Path.Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
2214                 pos += 4
2215                 // field[5] m.Route.Paths[j2].Path.Nh.ClassifyTableIndex
2216                 m.Route.Paths[j2].Path.Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2217                 pos += 4
2218                 // field[4] m.Route.Paths[j2].Path.NLabels
2219                 m.Route.Paths[j2].Path.NLabels = uint8(tmp[pos])
2220                 pos += 1
2221                 // field[4] m.Route.Paths[j2].Path.LabelStack
2222                 for j4 := 0; j4 < 16; j4++ {
2223                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].IsUniform
2224                         m.Route.Paths[j2].Path.LabelStack[j4].IsUniform = uint8(tmp[pos])
2225                         pos += 1
2226                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Label
2227                         m.Route.Paths[j2].Path.LabelStack[j4].Label = uint32(o.Uint32(tmp[pos : pos+4]))
2228                         pos += 4
2229                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].TTL
2230                         m.Route.Paths[j2].Path.LabelStack[j4].TTL = uint8(tmp[pos])
2231                         pos += 1
2232                         // field[5] m.Route.Paths[j2].Path.LabelStack[j4].Exp
2233                         m.Route.Paths[j2].Path.LabelStack[j4].Exp = uint8(tmp[pos])
2234                         pos += 1
2235                 }
2236         }
2237         return nil
2238 }
2239
2240 // IPMrouteDump represents VPP binary API message 'ip_mroute_dump'.
2241 type IPMrouteDump struct {
2242         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
2243 }
2244
2245 func (m *IPMrouteDump) Reset()                        { *m = IPMrouteDump{} }
2246 func (*IPMrouteDump) GetMessageName() string          { return "ip_mroute_dump" }
2247 func (*IPMrouteDump) GetCrcString() string            { return "b9d2e09e" }
2248 func (*IPMrouteDump) GetMessageType() api.MessageType { return api.RequestMessage }
2249
2250 func (m *IPMrouteDump) Size() int {
2251         if m == nil {
2252                 return 0
2253         }
2254         var size int
2255         // field[1] m.Table
2256         // field[2] m.Table.TableID
2257         size += 4
2258         // field[2] m.Table.IsIP6
2259         size += 1
2260         // field[2] m.Table.Name
2261         size += 64
2262         return size
2263 }
2264 func (m *IPMrouteDump) Marshal(b []byte) ([]byte, error) {
2265         o := binary.BigEndian
2266         _ = o
2267         pos := 0
2268         _ = pos
2269         var buf []byte
2270         if b == nil {
2271                 buf = make([]byte, m.Size())
2272         } else {
2273                 buf = b
2274         }
2275         // field[1] m.Table
2276         // field[2] m.Table.TableID
2277         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
2278         pos += 4
2279         // field[2] m.Table.IsIP6
2280         if m.Table.IsIP6 {
2281                 buf[pos] = 1
2282         }
2283         pos += 1
2284         // field[2] m.Table.Name
2285         copy(buf[pos:pos+64], m.Table.Name)
2286         pos += 64
2287         return buf, nil
2288 }
2289 func (m *IPMrouteDump) Unmarshal(tmp []byte) error {
2290         o := binary.BigEndian
2291         _ = o
2292         pos := 0
2293         _ = pos
2294         // field[1] m.Table
2295         // field[2] m.Table.TableID
2296         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2297         pos += 4
2298         // field[2] m.Table.IsIP6
2299         m.Table.IsIP6 = tmp[pos] != 0
2300         pos += 1
2301         // field[2] m.Table.Name
2302         {
2303                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
2304                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
2305                 pos += 64
2306         }
2307         return nil
2308 }
2309
2310 // IPMtableDetails represents VPP binary API message 'ip_mtable_details'.
2311 type IPMtableDetails struct {
2312         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
2313 }
2314
2315 func (m *IPMtableDetails) Reset()                        { *m = IPMtableDetails{} }
2316 func (*IPMtableDetails) GetMessageName() string          { return "ip_mtable_details" }
2317 func (*IPMtableDetails) GetCrcString() string            { return "b9d2e09e" }
2318 func (*IPMtableDetails) GetMessageType() api.MessageType { return api.RequestMessage }
2319
2320 func (m *IPMtableDetails) Size() int {
2321         if m == nil {
2322                 return 0
2323         }
2324         var size int
2325         // field[1] m.Table
2326         // field[2] m.Table.TableID
2327         size += 4
2328         // field[2] m.Table.IsIP6
2329         size += 1
2330         // field[2] m.Table.Name
2331         size += 64
2332         return size
2333 }
2334 func (m *IPMtableDetails) Marshal(b []byte) ([]byte, error) {
2335         o := binary.BigEndian
2336         _ = o
2337         pos := 0
2338         _ = pos
2339         var buf []byte
2340         if b == nil {
2341                 buf = make([]byte, m.Size())
2342         } else {
2343                 buf = b
2344         }
2345         // field[1] m.Table
2346         // field[2] m.Table.TableID
2347         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
2348         pos += 4
2349         // field[2] m.Table.IsIP6
2350         if m.Table.IsIP6 {
2351                 buf[pos] = 1
2352         }
2353         pos += 1
2354         // field[2] m.Table.Name
2355         copy(buf[pos:pos+64], m.Table.Name)
2356         pos += 64
2357         return buf, nil
2358 }
2359 func (m *IPMtableDetails) Unmarshal(tmp []byte) error {
2360         o := binary.BigEndian
2361         _ = o
2362         pos := 0
2363         _ = pos
2364         // field[1] m.Table
2365         // field[2] m.Table.TableID
2366         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
2367         pos += 4
2368         // field[2] m.Table.IsIP6
2369         m.Table.IsIP6 = tmp[pos] != 0
2370         pos += 1
2371         // field[2] m.Table.Name
2372         {
2373                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
2374                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
2375                 pos += 64
2376         }
2377         return nil
2378 }
2379
2380 // IPMtableDump represents VPP binary API message 'ip_mtable_dump'.
2381 type IPMtableDump struct{}
2382
2383 func (m *IPMtableDump) Reset()                        { *m = IPMtableDump{} }
2384 func (*IPMtableDump) GetMessageName() string          { return "ip_mtable_dump" }
2385 func (*IPMtableDump) GetCrcString() string            { return "51077d14" }
2386 func (*IPMtableDump) GetMessageType() api.MessageType { return api.RequestMessage }
2387
2388 func (m *IPMtableDump) Size() int {
2389         if m == nil {
2390                 return 0
2391         }
2392         var size int
2393         return size
2394 }
2395 func (m *IPMtableDump) Marshal(b []byte) ([]byte, error) {
2396         o := binary.BigEndian
2397         _ = o
2398         pos := 0
2399         _ = pos
2400         var buf []byte
2401         if b == nil {
2402                 buf = make([]byte, m.Size())
2403         } else {
2404                 buf = b
2405         }
2406         return buf, nil
2407 }
2408 func (m *IPMtableDump) Unmarshal(tmp []byte) error {
2409         o := binary.BigEndian
2410         _ = o
2411         pos := 0
2412         _ = pos
2413         return nil
2414 }
2415
2416 // IPPuntPolice represents VPP binary API message 'ip_punt_police'.
2417 type IPPuntPolice struct {
2418         PolicerIndex uint32 `binapi:"u32,name=policer_index" json:"policer_index,omitempty"`
2419         IsAdd        bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
2420         IsIP6        bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2421 }
2422
2423 func (m *IPPuntPolice) Reset()                        { *m = IPPuntPolice{} }
2424 func (*IPPuntPolice) GetMessageName() string          { return "ip_punt_police" }
2425 func (*IPPuntPolice) GetCrcString() string            { return "db867cea" }
2426 func (*IPPuntPolice) GetMessageType() api.MessageType { return api.RequestMessage }
2427
2428 func (m *IPPuntPolice) Size() int {
2429         if m == nil {
2430                 return 0
2431         }
2432         var size int
2433         // field[1] m.PolicerIndex
2434         size += 4
2435         // field[1] m.IsAdd
2436         size += 1
2437         // field[1] m.IsIP6
2438         size += 1
2439         return size
2440 }
2441 func (m *IPPuntPolice) Marshal(b []byte) ([]byte, error) {
2442         o := binary.BigEndian
2443         _ = o
2444         pos := 0
2445         _ = pos
2446         var buf []byte
2447         if b == nil {
2448                 buf = make([]byte, m.Size())
2449         } else {
2450                 buf = b
2451         }
2452         // field[1] m.PolicerIndex
2453         o.PutUint32(buf[pos:pos+4], uint32(m.PolicerIndex))
2454         pos += 4
2455         // field[1] m.IsAdd
2456         if m.IsAdd {
2457                 buf[pos] = 1
2458         }
2459         pos += 1
2460         // field[1] m.IsIP6
2461         if m.IsIP6 {
2462                 buf[pos] = 1
2463         }
2464         pos += 1
2465         return buf, nil
2466 }
2467 func (m *IPPuntPolice) Unmarshal(tmp []byte) error {
2468         o := binary.BigEndian
2469         _ = o
2470         pos := 0
2471         _ = pos
2472         // field[1] m.PolicerIndex
2473         m.PolicerIndex = uint32(o.Uint32(tmp[pos : pos+4]))
2474         pos += 4
2475         // field[1] m.IsAdd
2476         m.IsAdd = tmp[pos] != 0
2477         pos += 1
2478         // field[1] m.IsIP6
2479         m.IsIP6 = tmp[pos] != 0
2480         pos += 1
2481         return nil
2482 }
2483
2484 // IPPuntPoliceReply represents VPP binary API message 'ip_punt_police_reply'.
2485 type IPPuntPoliceReply struct {
2486         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2487 }
2488
2489 func (m *IPPuntPoliceReply) Reset()                        { *m = IPPuntPoliceReply{} }
2490 func (*IPPuntPoliceReply) GetMessageName() string          { return "ip_punt_police_reply" }
2491 func (*IPPuntPoliceReply) GetCrcString() string            { return "e8d4e804" }
2492 func (*IPPuntPoliceReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2493
2494 func (m *IPPuntPoliceReply) Size() int {
2495         if m == nil {
2496                 return 0
2497         }
2498         var size int
2499         // field[1] m.Retval
2500         size += 4
2501         return size
2502 }
2503 func (m *IPPuntPoliceReply) Marshal(b []byte) ([]byte, error) {
2504         o := binary.BigEndian
2505         _ = o
2506         pos := 0
2507         _ = pos
2508         var buf []byte
2509         if b == nil {
2510                 buf = make([]byte, m.Size())
2511         } else {
2512                 buf = b
2513         }
2514         // field[1] m.Retval
2515         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2516         pos += 4
2517         return buf, nil
2518 }
2519 func (m *IPPuntPoliceReply) Unmarshal(tmp []byte) error {
2520         o := binary.BigEndian
2521         _ = o
2522         pos := 0
2523         _ = pos
2524         // field[1] m.Retval
2525         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2526         pos += 4
2527         return nil
2528 }
2529
2530 // IPPuntRedirect represents VPP binary API message 'ip_punt_redirect'.
2531 type IPPuntRedirect struct {
2532         Punt  PuntRedirect `binapi:"punt_redirect,name=punt" json:"punt,omitempty"`
2533         IsAdd bool         `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
2534 }
2535
2536 func (m *IPPuntRedirect) Reset()                        { *m = IPPuntRedirect{} }
2537 func (*IPPuntRedirect) GetMessageName() string          { return "ip_punt_redirect" }
2538 func (*IPPuntRedirect) GetCrcString() string            { return "a9a5592c" }
2539 func (*IPPuntRedirect) GetMessageType() api.MessageType { return api.RequestMessage }
2540
2541 func (m *IPPuntRedirect) Size() int {
2542         if m == nil {
2543                 return 0
2544         }
2545         var size int
2546         // field[1] m.Punt
2547         // field[2] m.Punt.RxSwIfIndex
2548         size += 4
2549         // field[2] m.Punt.TxSwIfIndex
2550         size += 4
2551         // field[2] m.Punt.Nh
2552         // field[3] m.Punt.Nh.Af
2553         size += 4
2554         // field[3] m.Punt.Nh.Un
2555         size += 16
2556         // field[1] m.IsAdd
2557         size += 1
2558         return size
2559 }
2560 func (m *IPPuntRedirect) Marshal(b []byte) ([]byte, error) {
2561         o := binary.BigEndian
2562         _ = o
2563         pos := 0
2564         _ = pos
2565         var buf []byte
2566         if b == nil {
2567                 buf = make([]byte, m.Size())
2568         } else {
2569                 buf = b
2570         }
2571         // field[1] m.Punt
2572         // field[2] m.Punt.RxSwIfIndex
2573         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.RxSwIfIndex))
2574         pos += 4
2575         // field[2] m.Punt.TxSwIfIndex
2576         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.TxSwIfIndex))
2577         pos += 4
2578         // field[2] m.Punt.Nh
2579         // field[3] m.Punt.Nh.Af
2580         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.Nh.Af))
2581         pos += 4
2582         // field[3] m.Punt.Nh.Un
2583         copy(buf[pos:pos+16], m.Punt.Nh.Un.XXX_UnionData[:])
2584         pos += 16
2585         // field[1] m.IsAdd
2586         if m.IsAdd {
2587                 buf[pos] = 1
2588         }
2589         pos += 1
2590         return buf, nil
2591 }
2592 func (m *IPPuntRedirect) Unmarshal(tmp []byte) error {
2593         o := binary.BigEndian
2594         _ = o
2595         pos := 0
2596         _ = pos
2597         // field[1] m.Punt
2598         // field[2] m.Punt.RxSwIfIndex
2599         m.Punt.RxSwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2600         pos += 4
2601         // field[2] m.Punt.TxSwIfIndex
2602         m.Punt.TxSwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2603         pos += 4
2604         // field[2] m.Punt.Nh
2605         // field[3] m.Punt.Nh.Af
2606         m.Punt.Nh.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
2607         pos += 4
2608         // field[3] m.Punt.Nh.Un
2609         copy(m.Punt.Nh.Un.XXX_UnionData[:], tmp[pos:pos+16])
2610         pos += 16
2611         // field[1] m.IsAdd
2612         m.IsAdd = tmp[pos] != 0
2613         pos += 1
2614         return nil
2615 }
2616
2617 // IPPuntRedirectDetails represents VPP binary API message 'ip_punt_redirect_details'.
2618 type IPPuntRedirectDetails struct {
2619         Punt PuntRedirect `binapi:"punt_redirect,name=punt" json:"punt,omitempty"`
2620 }
2621
2622 func (m *IPPuntRedirectDetails) Reset()                        { *m = IPPuntRedirectDetails{} }
2623 func (*IPPuntRedirectDetails) GetMessageName() string          { return "ip_punt_redirect_details" }
2624 func (*IPPuntRedirectDetails) GetCrcString() string            { return "3924f5d3" }
2625 func (*IPPuntRedirectDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
2626
2627 func (m *IPPuntRedirectDetails) Size() int {
2628         if m == nil {
2629                 return 0
2630         }
2631         var size int
2632         // field[1] m.Punt
2633         // field[2] m.Punt.RxSwIfIndex
2634         size += 4
2635         // field[2] m.Punt.TxSwIfIndex
2636         size += 4
2637         // field[2] m.Punt.Nh
2638         // field[3] m.Punt.Nh.Af
2639         size += 4
2640         // field[3] m.Punt.Nh.Un
2641         size += 16
2642         return size
2643 }
2644 func (m *IPPuntRedirectDetails) Marshal(b []byte) ([]byte, error) {
2645         o := binary.BigEndian
2646         _ = o
2647         pos := 0
2648         _ = pos
2649         var buf []byte
2650         if b == nil {
2651                 buf = make([]byte, m.Size())
2652         } else {
2653                 buf = b
2654         }
2655         // field[1] m.Punt
2656         // field[2] m.Punt.RxSwIfIndex
2657         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.RxSwIfIndex))
2658         pos += 4
2659         // field[2] m.Punt.TxSwIfIndex
2660         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.TxSwIfIndex))
2661         pos += 4
2662         // field[2] m.Punt.Nh
2663         // field[3] m.Punt.Nh.Af
2664         o.PutUint32(buf[pos:pos+4], uint32(m.Punt.Nh.Af))
2665         pos += 4
2666         // field[3] m.Punt.Nh.Un
2667         copy(buf[pos:pos+16], m.Punt.Nh.Un.XXX_UnionData[:])
2668         pos += 16
2669         return buf, nil
2670 }
2671 func (m *IPPuntRedirectDetails) Unmarshal(tmp []byte) error {
2672         o := binary.BigEndian
2673         _ = o
2674         pos := 0
2675         _ = pos
2676         // field[1] m.Punt
2677         // field[2] m.Punt.RxSwIfIndex
2678         m.Punt.RxSwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2679         pos += 4
2680         // field[2] m.Punt.TxSwIfIndex
2681         m.Punt.TxSwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2682         pos += 4
2683         // field[2] m.Punt.Nh
2684         // field[3] m.Punt.Nh.Af
2685         m.Punt.Nh.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
2686         pos += 4
2687         // field[3] m.Punt.Nh.Un
2688         copy(m.Punt.Nh.Un.XXX_UnionData[:], tmp[pos:pos+16])
2689         pos += 16
2690         return nil
2691 }
2692
2693 // IPPuntRedirectDump represents VPP binary API message 'ip_punt_redirect_dump'.
2694 type IPPuntRedirectDump struct {
2695         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2696         IsIPv6    bool           `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
2697 }
2698
2699 func (m *IPPuntRedirectDump) Reset()                        { *m = IPPuntRedirectDump{} }
2700 func (*IPPuntRedirectDump) GetMessageName() string          { return "ip_punt_redirect_dump" }
2701 func (*IPPuntRedirectDump) GetCrcString() string            { return "2d033de4" }
2702 func (*IPPuntRedirectDump) GetMessageType() api.MessageType { return api.RequestMessage }
2703
2704 func (m *IPPuntRedirectDump) Size() int {
2705         if m == nil {
2706                 return 0
2707         }
2708         var size int
2709         // field[1] m.SwIfIndex
2710         size += 4
2711         // field[1] m.IsIPv6
2712         size += 1
2713         return size
2714 }
2715 func (m *IPPuntRedirectDump) Marshal(b []byte) ([]byte, error) {
2716         o := binary.BigEndian
2717         _ = o
2718         pos := 0
2719         _ = pos
2720         var buf []byte
2721         if b == nil {
2722                 buf = make([]byte, m.Size())
2723         } else {
2724                 buf = b
2725         }
2726         // field[1] m.SwIfIndex
2727         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2728         pos += 4
2729         // field[1] m.IsIPv6
2730         if m.IsIPv6 {
2731                 buf[pos] = 1
2732         }
2733         pos += 1
2734         return buf, nil
2735 }
2736 func (m *IPPuntRedirectDump) Unmarshal(tmp []byte) error {
2737         o := binary.BigEndian
2738         _ = o
2739         pos := 0
2740         _ = pos
2741         // field[1] m.SwIfIndex
2742         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2743         pos += 4
2744         // field[1] m.IsIPv6
2745         m.IsIPv6 = tmp[pos] != 0
2746         pos += 1
2747         return nil
2748 }
2749
2750 // IPPuntRedirectReply represents VPP binary API message 'ip_punt_redirect_reply'.
2751 type IPPuntRedirectReply struct {
2752         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2753 }
2754
2755 func (m *IPPuntRedirectReply) Reset()                        { *m = IPPuntRedirectReply{} }
2756 func (*IPPuntRedirectReply) GetMessageName() string          { return "ip_punt_redirect_reply" }
2757 func (*IPPuntRedirectReply) GetCrcString() string            { return "e8d4e804" }
2758 func (*IPPuntRedirectReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2759
2760 func (m *IPPuntRedirectReply) Size() int {
2761         if m == nil {
2762                 return 0
2763         }
2764         var size int
2765         // field[1] m.Retval
2766         size += 4
2767         return size
2768 }
2769 func (m *IPPuntRedirectReply) Marshal(b []byte) ([]byte, error) {
2770         o := binary.BigEndian
2771         _ = o
2772         pos := 0
2773         _ = pos
2774         var buf []byte
2775         if b == nil {
2776                 buf = make([]byte, m.Size())
2777         } else {
2778                 buf = b
2779         }
2780         // field[1] m.Retval
2781         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2782         pos += 4
2783         return buf, nil
2784 }
2785 func (m *IPPuntRedirectReply) Unmarshal(tmp []byte) error {
2786         o := binary.BigEndian
2787         _ = o
2788         pos := 0
2789         _ = pos
2790         // field[1] m.Retval
2791         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2792         pos += 4
2793         return nil
2794 }
2795
2796 // IPReassemblyEnableDisable represents VPP binary API message 'ip_reassembly_enable_disable'.
2797 type IPReassemblyEnableDisable struct {
2798         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2799         EnableIP4 bool           `binapi:"bool,name=enable_ip4" json:"enable_ip4,omitempty"`
2800         EnableIP6 bool           `binapi:"bool,name=enable_ip6" json:"enable_ip6,omitempty"`
2801         Type      IPReassType    `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
2802 }
2803
2804 func (m *IPReassemblyEnableDisable) Reset()                        { *m = IPReassemblyEnableDisable{} }
2805 func (*IPReassemblyEnableDisable) GetMessageName() string          { return "ip_reassembly_enable_disable" }
2806 func (*IPReassemblyEnableDisable) GetCrcString() string            { return "885c85a6" }
2807 func (*IPReassemblyEnableDisable) GetMessageType() api.MessageType { return api.RequestMessage }
2808
2809 func (m *IPReassemblyEnableDisable) Size() int {
2810         if m == nil {
2811                 return 0
2812         }
2813         var size int
2814         // field[1] m.SwIfIndex
2815         size += 4
2816         // field[1] m.EnableIP4
2817         size += 1
2818         // field[1] m.EnableIP6
2819         size += 1
2820         // field[1] m.Type
2821         size += 4
2822         return size
2823 }
2824 func (m *IPReassemblyEnableDisable) Marshal(b []byte) ([]byte, error) {
2825         o := binary.BigEndian
2826         _ = o
2827         pos := 0
2828         _ = pos
2829         var buf []byte
2830         if b == nil {
2831                 buf = make([]byte, m.Size())
2832         } else {
2833                 buf = b
2834         }
2835         // field[1] m.SwIfIndex
2836         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
2837         pos += 4
2838         // field[1] m.EnableIP4
2839         if m.EnableIP4 {
2840                 buf[pos] = 1
2841         }
2842         pos += 1
2843         // field[1] m.EnableIP6
2844         if m.EnableIP6 {
2845                 buf[pos] = 1
2846         }
2847         pos += 1
2848         // field[1] m.Type
2849         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
2850         pos += 4
2851         return buf, nil
2852 }
2853 func (m *IPReassemblyEnableDisable) Unmarshal(tmp []byte) error {
2854         o := binary.BigEndian
2855         _ = o
2856         pos := 0
2857         _ = pos
2858         // field[1] m.SwIfIndex
2859         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
2860         pos += 4
2861         // field[1] m.EnableIP4
2862         m.EnableIP4 = tmp[pos] != 0
2863         pos += 1
2864         // field[1] m.EnableIP6
2865         m.EnableIP6 = tmp[pos] != 0
2866         pos += 1
2867         // field[1] m.Type
2868         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
2869         pos += 4
2870         return nil
2871 }
2872
2873 // IPReassemblyEnableDisableReply represents VPP binary API message 'ip_reassembly_enable_disable_reply'.
2874 type IPReassemblyEnableDisableReply struct {
2875         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2876 }
2877
2878 func (m *IPReassemblyEnableDisableReply) Reset() { *m = IPReassemblyEnableDisableReply{} }
2879 func (*IPReassemblyEnableDisableReply) GetMessageName() string {
2880         return "ip_reassembly_enable_disable_reply"
2881 }
2882 func (*IPReassemblyEnableDisableReply) GetCrcString() string            { return "e8d4e804" }
2883 func (*IPReassemblyEnableDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2884
2885 func (m *IPReassemblyEnableDisableReply) Size() int {
2886         if m == nil {
2887                 return 0
2888         }
2889         var size int
2890         // field[1] m.Retval
2891         size += 4
2892         return size
2893 }
2894 func (m *IPReassemblyEnableDisableReply) Marshal(b []byte) ([]byte, error) {
2895         o := binary.BigEndian
2896         _ = o
2897         pos := 0
2898         _ = pos
2899         var buf []byte
2900         if b == nil {
2901                 buf = make([]byte, m.Size())
2902         } else {
2903                 buf = b
2904         }
2905         // field[1] m.Retval
2906         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
2907         pos += 4
2908         return buf, nil
2909 }
2910 func (m *IPReassemblyEnableDisableReply) Unmarshal(tmp []byte) error {
2911         o := binary.BigEndian
2912         _ = o
2913         pos := 0
2914         _ = pos
2915         // field[1] m.Retval
2916         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
2917         pos += 4
2918         return nil
2919 }
2920
2921 // IPReassemblyGet represents VPP binary API message 'ip_reassembly_get'.
2922 type IPReassemblyGet struct {
2923         IsIP6 bool        `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2924         Type  IPReassType `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
2925 }
2926
2927 func (m *IPReassemblyGet) Reset()                        { *m = IPReassemblyGet{} }
2928 func (*IPReassemblyGet) GetMessageName() string          { return "ip_reassembly_get" }
2929 func (*IPReassemblyGet) GetCrcString() string            { return "ea13ff63" }
2930 func (*IPReassemblyGet) GetMessageType() api.MessageType { return api.RequestMessage }
2931
2932 func (m *IPReassemblyGet) Size() int {
2933         if m == nil {
2934                 return 0
2935         }
2936         var size int
2937         // field[1] m.IsIP6
2938         size += 1
2939         // field[1] m.Type
2940         size += 4
2941         return size
2942 }
2943 func (m *IPReassemblyGet) Marshal(b []byte) ([]byte, error) {
2944         o := binary.BigEndian
2945         _ = o
2946         pos := 0
2947         _ = pos
2948         var buf []byte
2949         if b == nil {
2950                 buf = make([]byte, m.Size())
2951         } else {
2952                 buf = b
2953         }
2954         // field[1] m.IsIP6
2955         if m.IsIP6 {
2956                 buf[pos] = 1
2957         }
2958         pos += 1
2959         // field[1] m.Type
2960         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
2961         pos += 4
2962         return buf, nil
2963 }
2964 func (m *IPReassemblyGet) Unmarshal(tmp []byte) error {
2965         o := binary.BigEndian
2966         _ = o
2967         pos := 0
2968         _ = pos
2969         // field[1] m.IsIP6
2970         m.IsIP6 = tmp[pos] != 0
2971         pos += 1
2972         // field[1] m.Type
2973         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
2974         pos += 4
2975         return nil
2976 }
2977
2978 // IPReassemblyGetReply represents VPP binary API message 'ip_reassembly_get_reply'.
2979 type IPReassemblyGetReply struct {
2980         Retval               int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2981         TimeoutMs            uint32 `binapi:"u32,name=timeout_ms" json:"timeout_ms,omitempty"`
2982         MaxReassemblies      uint32 `binapi:"u32,name=max_reassemblies" json:"max_reassemblies,omitempty"`
2983         MaxReassemblyLength  uint32 `binapi:"u32,name=max_reassembly_length" json:"max_reassembly_length,omitempty"`
2984         ExpireWalkIntervalMs uint32 `binapi:"u32,name=expire_walk_interval_ms" json:"expire_walk_interval_ms,omitempty"`
2985         IsIP6                bool   `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
2986 }
2987
2988 func (m *IPReassemblyGetReply) Reset()                        { *m = IPReassemblyGetReply{} }
2989 func (*IPReassemblyGetReply) GetMessageName() string          { return "ip_reassembly_get_reply" }
2990 func (*IPReassemblyGetReply) GetCrcString() string            { return "d5eb8d34" }
2991 func (*IPReassemblyGetReply) GetMessageType() api.MessageType { return api.ReplyMessage }
2992
2993 func (m *IPReassemblyGetReply) Size() int {
2994         if m == nil {
2995                 return 0
2996         }
2997         var size int
2998         // field[1] m.Retval
2999         size += 4
3000         // field[1] m.TimeoutMs
3001         size += 4
3002         // field[1] m.MaxReassemblies
3003         size += 4
3004         // field[1] m.MaxReassemblyLength
3005         size += 4
3006         // field[1] m.ExpireWalkIntervalMs
3007         size += 4
3008         // field[1] m.IsIP6
3009         size += 1
3010         return size
3011 }
3012 func (m *IPReassemblyGetReply) Marshal(b []byte) ([]byte, error) {
3013         o := binary.BigEndian
3014         _ = o
3015         pos := 0
3016         _ = pos
3017         var buf []byte
3018         if b == nil {
3019                 buf = make([]byte, m.Size())
3020         } else {
3021                 buf = b
3022         }
3023         // field[1] m.Retval
3024         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3025         pos += 4
3026         // field[1] m.TimeoutMs
3027         o.PutUint32(buf[pos:pos+4], uint32(m.TimeoutMs))
3028         pos += 4
3029         // field[1] m.MaxReassemblies
3030         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblies))
3031         pos += 4
3032         // field[1] m.MaxReassemblyLength
3033         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblyLength))
3034         pos += 4
3035         // field[1] m.ExpireWalkIntervalMs
3036         o.PutUint32(buf[pos:pos+4], uint32(m.ExpireWalkIntervalMs))
3037         pos += 4
3038         // field[1] m.IsIP6
3039         if m.IsIP6 {
3040                 buf[pos] = 1
3041         }
3042         pos += 1
3043         return buf, nil
3044 }
3045 func (m *IPReassemblyGetReply) Unmarshal(tmp []byte) error {
3046         o := binary.BigEndian
3047         _ = o
3048         pos := 0
3049         _ = pos
3050         // field[1] m.Retval
3051         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3052         pos += 4
3053         // field[1] m.TimeoutMs
3054         m.TimeoutMs = uint32(o.Uint32(tmp[pos : pos+4]))
3055         pos += 4
3056         // field[1] m.MaxReassemblies
3057         m.MaxReassemblies = uint32(o.Uint32(tmp[pos : pos+4]))
3058         pos += 4
3059         // field[1] m.MaxReassemblyLength
3060         m.MaxReassemblyLength = uint32(o.Uint32(tmp[pos : pos+4]))
3061         pos += 4
3062         // field[1] m.ExpireWalkIntervalMs
3063         m.ExpireWalkIntervalMs = uint32(o.Uint32(tmp[pos : pos+4]))
3064         pos += 4
3065         // field[1] m.IsIP6
3066         m.IsIP6 = tmp[pos] != 0
3067         pos += 1
3068         return nil
3069 }
3070
3071 // IPReassemblySet represents VPP binary API message 'ip_reassembly_set'.
3072 type IPReassemblySet struct {
3073         TimeoutMs            uint32      `binapi:"u32,name=timeout_ms" json:"timeout_ms,omitempty"`
3074         MaxReassemblies      uint32      `binapi:"u32,name=max_reassemblies" json:"max_reassemblies,omitempty"`
3075         MaxReassemblyLength  uint32      `binapi:"u32,name=max_reassembly_length" json:"max_reassembly_length,omitempty"`
3076         ExpireWalkIntervalMs uint32      `binapi:"u32,name=expire_walk_interval_ms" json:"expire_walk_interval_ms,omitempty"`
3077         IsIP6                bool        `binapi:"bool,name=is_ip6" json:"is_ip6,omitempty"`
3078         Type                 IPReassType `binapi:"ip_reass_type,name=type" json:"type,omitempty"`
3079 }
3080
3081 func (m *IPReassemblySet) Reset()                        { *m = IPReassemblySet{} }
3082 func (*IPReassemblySet) GetMessageName() string          { return "ip_reassembly_set" }
3083 func (*IPReassemblySet) GetCrcString() string            { return "16467d25" }
3084 func (*IPReassemblySet) GetMessageType() api.MessageType { return api.RequestMessage }
3085
3086 func (m *IPReassemblySet) Size() int {
3087         if m == nil {
3088                 return 0
3089         }
3090         var size int
3091         // field[1] m.TimeoutMs
3092         size += 4
3093         // field[1] m.MaxReassemblies
3094         size += 4
3095         // field[1] m.MaxReassemblyLength
3096         size += 4
3097         // field[1] m.ExpireWalkIntervalMs
3098         size += 4
3099         // field[1] m.IsIP6
3100         size += 1
3101         // field[1] m.Type
3102         size += 4
3103         return size
3104 }
3105 func (m *IPReassemblySet) Marshal(b []byte) ([]byte, error) {
3106         o := binary.BigEndian
3107         _ = o
3108         pos := 0
3109         _ = pos
3110         var buf []byte
3111         if b == nil {
3112                 buf = make([]byte, m.Size())
3113         } else {
3114                 buf = b
3115         }
3116         // field[1] m.TimeoutMs
3117         o.PutUint32(buf[pos:pos+4], uint32(m.TimeoutMs))
3118         pos += 4
3119         // field[1] m.MaxReassemblies
3120         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblies))
3121         pos += 4
3122         // field[1] m.MaxReassemblyLength
3123         o.PutUint32(buf[pos:pos+4], uint32(m.MaxReassemblyLength))
3124         pos += 4
3125         // field[1] m.ExpireWalkIntervalMs
3126         o.PutUint32(buf[pos:pos+4], uint32(m.ExpireWalkIntervalMs))
3127         pos += 4
3128         // field[1] m.IsIP6
3129         if m.IsIP6 {
3130                 buf[pos] = 1
3131         }
3132         pos += 1
3133         // field[1] m.Type
3134         o.PutUint32(buf[pos:pos+4], uint32(m.Type))
3135         pos += 4
3136         return buf, nil
3137 }
3138 func (m *IPReassemblySet) Unmarshal(tmp []byte) error {
3139         o := binary.BigEndian
3140         _ = o
3141         pos := 0
3142         _ = pos
3143         // field[1] m.TimeoutMs
3144         m.TimeoutMs = uint32(o.Uint32(tmp[pos : pos+4]))
3145         pos += 4
3146         // field[1] m.MaxReassemblies
3147         m.MaxReassemblies = uint32(o.Uint32(tmp[pos : pos+4]))
3148         pos += 4
3149         // field[1] m.MaxReassemblyLength
3150         m.MaxReassemblyLength = uint32(o.Uint32(tmp[pos : pos+4]))
3151         pos += 4
3152         // field[1] m.ExpireWalkIntervalMs
3153         m.ExpireWalkIntervalMs = uint32(o.Uint32(tmp[pos : pos+4]))
3154         pos += 4
3155         // field[1] m.IsIP6
3156         m.IsIP6 = tmp[pos] != 0
3157         pos += 1
3158         // field[1] m.Type
3159         m.Type = IPReassType(o.Uint32(tmp[pos : pos+4]))
3160         pos += 4
3161         return nil
3162 }
3163
3164 // IPReassemblySetReply represents VPP binary API message 'ip_reassembly_set_reply'.
3165 type IPReassemblySetReply struct {
3166         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
3167 }
3168
3169 func (m *IPReassemblySetReply) Reset()                        { *m = IPReassemblySetReply{} }
3170 func (*IPReassemblySetReply) GetMessageName() string          { return "ip_reassembly_set_reply" }
3171 func (*IPReassemblySetReply) GetCrcString() string            { return "e8d4e804" }
3172 func (*IPReassemblySetReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3173
3174 func (m *IPReassemblySetReply) Size() int {
3175         if m == nil {
3176                 return 0
3177         }
3178         var size int
3179         // field[1] m.Retval
3180         size += 4
3181         return size
3182 }
3183 func (m *IPReassemblySetReply) Marshal(b []byte) ([]byte, error) {
3184         o := binary.BigEndian
3185         _ = o
3186         pos := 0
3187         _ = pos
3188         var buf []byte
3189         if b == nil {
3190                 buf = make([]byte, m.Size())
3191         } else {
3192                 buf = b
3193         }
3194         // field[1] m.Retval
3195         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3196         pos += 4
3197         return buf, nil
3198 }
3199 func (m *IPReassemblySetReply) Unmarshal(tmp []byte) error {
3200         o := binary.BigEndian
3201         _ = o
3202         pos := 0
3203         _ = pos
3204         // field[1] m.Retval
3205         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3206         pos += 4
3207         return nil
3208 }
3209
3210 // IPRouteAddDel represents VPP binary API message 'ip_route_add_del'.
3211 type IPRouteAddDel struct {
3212         IsAdd       bool    `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
3213         IsMultipath bool    `binapi:"bool,name=is_multipath" json:"is_multipath,omitempty"`
3214         Route       IPRoute `binapi:"ip_route,name=route" json:"route,omitempty"`
3215 }
3216
3217 func (m *IPRouteAddDel) Reset()                        { *m = IPRouteAddDel{} }
3218 func (*IPRouteAddDel) GetMessageName() string          { return "ip_route_add_del" }
3219 func (*IPRouteAddDel) GetCrcString() string            { return "c1ff832d" }
3220 func (*IPRouteAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
3221
3222 func (m *IPRouteAddDel) Size() int {
3223         if m == nil {
3224                 return 0
3225         }
3226         var size int
3227         // field[1] m.IsAdd
3228         size += 1
3229         // field[1] m.IsMultipath
3230         size += 1
3231         // field[1] m.Route
3232         // field[2] m.Route.TableID
3233         size += 4
3234         // field[2] m.Route.StatsIndex
3235         size += 4
3236         // field[2] m.Route.Prefix
3237         // field[3] m.Route.Prefix.Address
3238         // field[4] m.Route.Prefix.Address.Af
3239         size += 4
3240         // field[4] m.Route.Prefix.Address.Un
3241         size += 16
3242         // field[3] m.Route.Prefix.Len
3243         size += 1
3244         // field[2] m.Route.NPaths
3245         size += 1
3246         // field[2] m.Route.Paths
3247         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3248                 var s2 FibPath
3249                 _ = s2
3250                 if j2 < len(m.Route.Paths) {
3251                         s2 = m.Route.Paths[j2]
3252                 }
3253                 // field[3] s2.SwIfIndex
3254                 size += 4
3255                 // field[3] s2.TableID
3256                 size += 4
3257                 // field[3] s2.RpfID
3258                 size += 4
3259                 // field[3] s2.Weight
3260                 size += 1
3261                 // field[3] s2.Preference
3262                 size += 1
3263                 // field[3] s2.Type
3264                 size += 4
3265                 // field[3] s2.Flags
3266                 size += 4
3267                 // field[3] s2.Proto
3268                 size += 4
3269                 // field[3] s2.Nh
3270                 // field[4] s2.Nh.Address
3271                 size += 16
3272                 // field[4] s2.Nh.ViaLabel
3273                 size += 4
3274                 // field[4] s2.Nh.ObjID
3275                 size += 4
3276                 // field[4] s2.Nh.ClassifyTableIndex
3277                 size += 4
3278                 // field[3] s2.NLabels
3279                 size += 1
3280                 // field[3] s2.LabelStack
3281                 for j3 := 0; j3 < 16; j3++ {
3282                         var s3 FibMplsLabel
3283                         _ = s3
3284                         if j3 < len(s2.LabelStack) {
3285                                 s3 = s2.LabelStack[j3]
3286                         }
3287                         // field[4] s3.IsUniform
3288                         size += 1
3289                         // field[4] s3.Label
3290                         size += 4
3291                         // field[4] s3.TTL
3292                         size += 1
3293                         // field[4] s3.Exp
3294                         size += 1
3295                 }
3296         }
3297         return size
3298 }
3299 func (m *IPRouteAddDel) Marshal(b []byte) ([]byte, error) {
3300         o := binary.BigEndian
3301         _ = o
3302         pos := 0
3303         _ = pos
3304         var buf []byte
3305         if b == nil {
3306                 buf = make([]byte, m.Size())
3307         } else {
3308                 buf = b
3309         }
3310         // field[1] m.IsAdd
3311         if m.IsAdd {
3312                 buf[pos] = 1
3313         }
3314         pos += 1
3315         // field[1] m.IsMultipath
3316         if m.IsMultipath {
3317                 buf[pos] = 1
3318         }
3319         pos += 1
3320         // field[1] m.Route
3321         // field[2] m.Route.TableID
3322         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
3323         pos += 4
3324         // field[2] m.Route.StatsIndex
3325         o.PutUint32(buf[pos:pos+4], uint32(m.Route.StatsIndex))
3326         pos += 4
3327         // field[2] m.Route.Prefix
3328         // field[3] m.Route.Prefix.Address
3329         // field[4] m.Route.Prefix.Address.Af
3330         o.PutUint32(buf[pos:pos+4], uint32(m.Route.Prefix.Address.Af))
3331         pos += 4
3332         // field[4] m.Route.Prefix.Address.Un
3333         copy(buf[pos:pos+16], m.Route.Prefix.Address.Un.XXX_UnionData[:])
3334         pos += 16
3335         // field[3] m.Route.Prefix.Len
3336         buf[pos] = uint8(m.Route.Prefix.Len)
3337         pos += 1
3338         // field[2] m.Route.NPaths
3339         buf[pos] = uint8(len(m.Route.Paths))
3340         pos += 1
3341         // field[2] m.Route.Paths
3342         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3343                 var v2 FibPath
3344                 if j2 < len(m.Route.Paths) {
3345                         v2 = m.Route.Paths[j2]
3346                 }
3347                 // field[3] v2.SwIfIndex
3348                 o.PutUint32(buf[pos:pos+4], uint32(v2.SwIfIndex))
3349                 pos += 4
3350                 // field[3] v2.TableID
3351                 o.PutUint32(buf[pos:pos+4], uint32(v2.TableID))
3352                 pos += 4
3353                 // field[3] v2.RpfID
3354                 o.PutUint32(buf[pos:pos+4], uint32(v2.RpfID))
3355                 pos += 4
3356                 // field[3] v2.Weight
3357                 buf[pos] = uint8(v2.Weight)
3358                 pos += 1
3359                 // field[3] v2.Preference
3360                 buf[pos] = uint8(v2.Preference)
3361                 pos += 1
3362                 // field[3] v2.Type
3363                 o.PutUint32(buf[pos:pos+4], uint32(v2.Type))
3364                 pos += 4
3365                 // field[3] v2.Flags
3366                 o.PutUint32(buf[pos:pos+4], uint32(v2.Flags))
3367                 pos += 4
3368                 // field[3] v2.Proto
3369                 o.PutUint32(buf[pos:pos+4], uint32(v2.Proto))
3370                 pos += 4
3371                 // field[3] v2.Nh
3372                 // field[4] v2.Nh.Address
3373                 copy(buf[pos:pos+16], v2.Nh.Address.XXX_UnionData[:])
3374                 pos += 16
3375                 // field[4] v2.Nh.ViaLabel
3376                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ViaLabel))
3377                 pos += 4
3378                 // field[4] v2.Nh.ObjID
3379                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ObjID))
3380                 pos += 4
3381                 // field[4] v2.Nh.ClassifyTableIndex
3382                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ClassifyTableIndex))
3383                 pos += 4
3384                 // field[3] v2.NLabels
3385                 buf[pos] = uint8(v2.NLabels)
3386                 pos += 1
3387                 // field[3] v2.LabelStack
3388                 for j3 := 0; j3 < 16; j3++ {
3389                         var v3 FibMplsLabel
3390                         if j3 < len(v2.LabelStack) {
3391                                 v3 = v2.LabelStack[j3]
3392                         }
3393                         // field[4] v3.IsUniform
3394                         buf[pos] = uint8(v3.IsUniform)
3395                         pos += 1
3396                         // field[4] v3.Label
3397                         o.PutUint32(buf[pos:pos+4], uint32(v3.Label))
3398                         pos += 4
3399                         // field[4] v3.TTL
3400                         buf[pos] = uint8(v3.TTL)
3401                         pos += 1
3402                         // field[4] v3.Exp
3403                         buf[pos] = uint8(v3.Exp)
3404                         pos += 1
3405                 }
3406         }
3407         return buf, nil
3408 }
3409 func (m *IPRouteAddDel) Unmarshal(tmp []byte) error {
3410         o := binary.BigEndian
3411         _ = o
3412         pos := 0
3413         _ = pos
3414         // field[1] m.IsAdd
3415         m.IsAdd = tmp[pos] != 0
3416         pos += 1
3417         // field[1] m.IsMultipath
3418         m.IsMultipath = tmp[pos] != 0
3419         pos += 1
3420         // field[1] m.Route
3421         // field[2] m.Route.TableID
3422         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3423         pos += 4
3424         // field[2] m.Route.StatsIndex
3425         m.Route.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3426         pos += 4
3427         // field[2] m.Route.Prefix
3428         // field[3] m.Route.Prefix.Address
3429         // field[4] m.Route.Prefix.Address.Af
3430         m.Route.Prefix.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
3431         pos += 4
3432         // field[4] m.Route.Prefix.Address.Un
3433         copy(m.Route.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3434         pos += 16
3435         // field[3] m.Route.Prefix.Len
3436         m.Route.Prefix.Len = uint8(tmp[pos])
3437         pos += 1
3438         // field[2] m.Route.NPaths
3439         m.Route.NPaths = uint8(tmp[pos])
3440         pos += 1
3441         // field[2] m.Route.Paths
3442         m.Route.Paths = make([]FibPath, int(m.Route.NPaths))
3443         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
3444                 // field[3] m.Route.Paths[j2].SwIfIndex
3445                 m.Route.Paths[j2].SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3446                 pos += 4
3447                 // field[3] m.Route.Paths[j2].TableID
3448                 m.Route.Paths[j2].TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3449                 pos += 4
3450                 // field[3] m.Route.Paths[j2].RpfID
3451                 m.Route.Paths[j2].RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
3452                 pos += 4
3453                 // field[3] m.Route.Paths[j2].Weight
3454                 m.Route.Paths[j2].Weight = uint8(tmp[pos])
3455                 pos += 1
3456                 // field[3] m.Route.Paths[j2].Preference
3457                 m.Route.Paths[j2].Preference = uint8(tmp[pos])
3458                 pos += 1
3459                 // field[3] m.Route.Paths[j2].Type
3460                 m.Route.Paths[j2].Type = FibPathType(o.Uint32(tmp[pos : pos+4]))
3461                 pos += 4
3462                 // field[3] m.Route.Paths[j2].Flags
3463                 m.Route.Paths[j2].Flags = FibPathFlags(o.Uint32(tmp[pos : pos+4]))
3464                 pos += 4
3465                 // field[3] m.Route.Paths[j2].Proto
3466                 m.Route.Paths[j2].Proto = FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
3467                 pos += 4
3468                 // field[3] m.Route.Paths[j2].Nh
3469                 // field[4] m.Route.Paths[j2].Nh.Address
3470                 copy(m.Route.Paths[j2].Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
3471                 pos += 16
3472                 // field[4] m.Route.Paths[j2].Nh.ViaLabel
3473                 m.Route.Paths[j2].Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
3474                 pos += 4
3475                 // field[4] m.Route.Paths[j2].Nh.ObjID
3476                 m.Route.Paths[j2].Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
3477                 pos += 4
3478                 // field[4] m.Route.Paths[j2].Nh.ClassifyTableIndex
3479                 m.Route.Paths[j2].Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3480                 pos += 4
3481                 // field[3] m.Route.Paths[j2].NLabels
3482                 m.Route.Paths[j2].NLabels = uint8(tmp[pos])
3483                 pos += 1
3484                 // field[3] m.Route.Paths[j2].LabelStack
3485                 for j3 := 0; j3 < 16; j3++ {
3486                         // field[4] m.Route.Paths[j2].LabelStack[j3].IsUniform
3487                         m.Route.Paths[j2].LabelStack[j3].IsUniform = uint8(tmp[pos])
3488                         pos += 1
3489                         // field[4] m.Route.Paths[j2].LabelStack[j3].Label
3490                         m.Route.Paths[j2].LabelStack[j3].Label = uint32(o.Uint32(tmp[pos : pos+4]))
3491                         pos += 4
3492                         // field[4] m.Route.Paths[j2].LabelStack[j3].TTL
3493                         m.Route.Paths[j2].LabelStack[j3].TTL = uint8(tmp[pos])
3494                         pos += 1
3495                         // field[4] m.Route.Paths[j2].LabelStack[j3].Exp
3496                         m.Route.Paths[j2].LabelStack[j3].Exp = uint8(tmp[pos])
3497                         pos += 1
3498                 }
3499         }
3500         return nil
3501 }
3502
3503 // IPRouteAddDelReply represents VPP binary API message 'ip_route_add_del_reply'.
3504 type IPRouteAddDelReply struct {
3505         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
3506         StatsIndex uint32 `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
3507 }
3508
3509 func (m *IPRouteAddDelReply) Reset()                        { *m = IPRouteAddDelReply{} }
3510 func (*IPRouteAddDelReply) GetMessageName() string          { return "ip_route_add_del_reply" }
3511 func (*IPRouteAddDelReply) GetCrcString() string            { return "1992deab" }
3512 func (*IPRouteAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
3513
3514 func (m *IPRouteAddDelReply) Size() int {
3515         if m == nil {
3516                 return 0
3517         }
3518         var size int
3519         // field[1] m.Retval
3520         size += 4
3521         // field[1] m.StatsIndex
3522         size += 4
3523         return size
3524 }
3525 func (m *IPRouteAddDelReply) Marshal(b []byte) ([]byte, error) {
3526         o := binary.BigEndian
3527         _ = o
3528         pos := 0
3529         _ = pos
3530         var buf []byte
3531         if b == nil {
3532                 buf = make([]byte, m.Size())
3533         } else {
3534                 buf = b
3535         }
3536         // field[1] m.Retval
3537         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
3538         pos += 4
3539         // field[1] m.StatsIndex
3540         o.PutUint32(buf[pos:pos+4], uint32(m.StatsIndex))
3541         pos += 4
3542         return buf, nil
3543 }
3544 func (m *IPRouteAddDelReply) Unmarshal(tmp []byte) error {
3545         o := binary.BigEndian
3546         _ = o
3547         pos := 0
3548         _ = pos
3549         // field[1] m.Retval
3550         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
3551         pos += 4
3552         // field[1] m.StatsIndex
3553         m.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3554         pos += 4
3555         return nil
3556 }
3557
3558 // IPRouteDetails represents VPP binary API message 'ip_route_details'.
3559 type IPRouteDetails struct {
3560         Route IPRoute `binapi:"ip_route,name=route" json:"route,omitempty"`
3561 }
3562
3563 func (m *IPRouteDetails) Reset()                        { *m = IPRouteDetails{} }
3564 func (*IPRouteDetails) GetMessageName() string          { return "ip_route_details" }
3565 func (*IPRouteDetails) GetCrcString() string            { return "d1ffaae1" }
3566 func (*IPRouteDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
3567
3568 func (m *IPRouteDetails) Size() int {
3569         if m == nil {
3570                 return 0
3571         }
3572         var size int
3573         // field[1] m.Route
3574         // field[2] m.Route.TableID
3575         size += 4
3576         // field[2] m.Route.StatsIndex
3577         size += 4
3578         // field[2] m.Route.Prefix
3579         // field[3] m.Route.Prefix.Address
3580         // field[4] m.Route.Prefix.Address.Af
3581         size += 4
3582         // field[4] m.Route.Prefix.Address.Un
3583         size += 16
3584         // field[3] m.Route.Prefix.Len
3585         size += 1
3586         // field[2] m.Route.NPaths
3587         size += 1
3588         // field[2] m.Route.Paths
3589         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3590                 var s2 FibPath
3591                 _ = s2
3592                 if j2 < len(m.Route.Paths) {
3593                         s2 = m.Route.Paths[j2]
3594                 }
3595                 // field[3] s2.SwIfIndex
3596                 size += 4
3597                 // field[3] s2.TableID
3598                 size += 4
3599                 // field[3] s2.RpfID
3600                 size += 4
3601                 // field[3] s2.Weight
3602                 size += 1
3603                 // field[3] s2.Preference
3604                 size += 1
3605                 // field[3] s2.Type
3606                 size += 4
3607                 // field[3] s2.Flags
3608                 size += 4
3609                 // field[3] s2.Proto
3610                 size += 4
3611                 // field[3] s2.Nh
3612                 // field[4] s2.Nh.Address
3613                 size += 16
3614                 // field[4] s2.Nh.ViaLabel
3615                 size += 4
3616                 // field[4] s2.Nh.ObjID
3617                 size += 4
3618                 // field[4] s2.Nh.ClassifyTableIndex
3619                 size += 4
3620                 // field[3] s2.NLabels
3621                 size += 1
3622                 // field[3] s2.LabelStack
3623                 for j3 := 0; j3 < 16; j3++ {
3624                         var s3 FibMplsLabel
3625                         _ = s3
3626                         if j3 < len(s2.LabelStack) {
3627                                 s3 = s2.LabelStack[j3]
3628                         }
3629                         // field[4] s3.IsUniform
3630                         size += 1
3631                         // field[4] s3.Label
3632                         size += 4
3633                         // field[4] s3.TTL
3634                         size += 1
3635                         // field[4] s3.Exp
3636                         size += 1
3637                 }
3638         }
3639         return size
3640 }
3641 func (m *IPRouteDetails) Marshal(b []byte) ([]byte, error) {
3642         o := binary.BigEndian
3643         _ = o
3644         pos := 0
3645         _ = pos
3646         var buf []byte
3647         if b == nil {
3648                 buf = make([]byte, m.Size())
3649         } else {
3650                 buf = b
3651         }
3652         // field[1] m.Route
3653         // field[2] m.Route.TableID
3654         o.PutUint32(buf[pos:pos+4], uint32(m.Route.TableID))
3655         pos += 4
3656         // field[2] m.Route.StatsIndex
3657         o.PutUint32(buf[pos:pos+4], uint32(m.Route.StatsIndex))
3658         pos += 4
3659         // field[2] m.Route.Prefix
3660         // field[3] m.Route.Prefix.Address
3661         // field[4] m.Route.Prefix.Address.Af
3662         o.PutUint32(buf[pos:pos+4], uint32(m.Route.Prefix.Address.Af))
3663         pos += 4
3664         // field[4] m.Route.Prefix.Address.Un
3665         copy(buf[pos:pos+16], m.Route.Prefix.Address.Un.XXX_UnionData[:])
3666         pos += 16
3667         // field[3] m.Route.Prefix.Len
3668         buf[pos] = uint8(m.Route.Prefix.Len)
3669         pos += 1
3670         // field[2] m.Route.NPaths
3671         buf[pos] = uint8(len(m.Route.Paths))
3672         pos += 1
3673         // field[2] m.Route.Paths
3674         for j2 := 0; j2 < len(m.Route.Paths); j2++ {
3675                 var v2 FibPath
3676                 if j2 < len(m.Route.Paths) {
3677                         v2 = m.Route.Paths[j2]
3678                 }
3679                 // field[3] v2.SwIfIndex
3680                 o.PutUint32(buf[pos:pos+4], uint32(v2.SwIfIndex))
3681                 pos += 4
3682                 // field[3] v2.TableID
3683                 o.PutUint32(buf[pos:pos+4], uint32(v2.TableID))
3684                 pos += 4
3685                 // field[3] v2.RpfID
3686                 o.PutUint32(buf[pos:pos+4], uint32(v2.RpfID))
3687                 pos += 4
3688                 // field[3] v2.Weight
3689                 buf[pos] = uint8(v2.Weight)
3690                 pos += 1
3691                 // field[3] v2.Preference
3692                 buf[pos] = uint8(v2.Preference)
3693                 pos += 1
3694                 // field[3] v2.Type
3695                 o.PutUint32(buf[pos:pos+4], uint32(v2.Type))
3696                 pos += 4
3697                 // field[3] v2.Flags
3698                 o.PutUint32(buf[pos:pos+4], uint32(v2.Flags))
3699                 pos += 4
3700                 // field[3] v2.Proto
3701                 o.PutUint32(buf[pos:pos+4], uint32(v2.Proto))
3702                 pos += 4
3703                 // field[3] v2.Nh
3704                 // field[4] v2.Nh.Address
3705                 copy(buf[pos:pos+16], v2.Nh.Address.XXX_UnionData[:])
3706                 pos += 16
3707                 // field[4] v2.Nh.ViaLabel
3708                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ViaLabel))
3709                 pos += 4
3710                 // field[4] v2.Nh.ObjID
3711                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ObjID))
3712                 pos += 4
3713                 // field[4] v2.Nh.ClassifyTableIndex
3714                 o.PutUint32(buf[pos:pos+4], uint32(v2.Nh.ClassifyTableIndex))
3715                 pos += 4
3716                 // field[3] v2.NLabels
3717                 buf[pos] = uint8(v2.NLabels)
3718                 pos += 1
3719                 // field[3] v2.LabelStack
3720                 for j3 := 0; j3 < 16; j3++ {
3721                         var v3 FibMplsLabel
3722                         if j3 < len(v2.LabelStack) {
3723                                 v3 = v2.LabelStack[j3]
3724                         }
3725                         // field[4] v3.IsUniform
3726                         buf[pos] = uint8(v3.IsUniform)
3727                         pos += 1
3728                         // field[4] v3.Label
3729                         o.PutUint32(buf[pos:pos+4], uint32(v3.Label))
3730                         pos += 4
3731                         // field[4] v3.TTL
3732                         buf[pos] = uint8(v3.TTL)
3733                         pos += 1
3734                         // field[4] v3.Exp
3735                         buf[pos] = uint8(v3.Exp)
3736                         pos += 1
3737                 }
3738         }
3739         return buf, nil
3740 }
3741 func (m *IPRouteDetails) Unmarshal(tmp []byte) error {
3742         o := binary.BigEndian
3743         _ = o
3744         pos := 0
3745         _ = pos
3746         // field[1] m.Route
3747         // field[2] m.Route.TableID
3748         m.Route.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3749         pos += 4
3750         // field[2] m.Route.StatsIndex
3751         m.Route.StatsIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3752         pos += 4
3753         // field[2] m.Route.Prefix
3754         // field[3] m.Route.Prefix.Address
3755         // field[4] m.Route.Prefix.Address.Af
3756         m.Route.Prefix.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
3757         pos += 4
3758         // field[4] m.Route.Prefix.Address.Un
3759         copy(m.Route.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
3760         pos += 16
3761         // field[3] m.Route.Prefix.Len
3762         m.Route.Prefix.Len = uint8(tmp[pos])
3763         pos += 1
3764         // field[2] m.Route.NPaths
3765         m.Route.NPaths = uint8(tmp[pos])
3766         pos += 1
3767         // field[2] m.Route.Paths
3768         m.Route.Paths = make([]FibPath, int(m.Route.NPaths))
3769         for j2 := 0; j2 < int(m.Route.NPaths); j2++ {
3770                 // field[3] m.Route.Paths[j2].SwIfIndex
3771                 m.Route.Paths[j2].SwIfIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3772                 pos += 4
3773                 // field[3] m.Route.Paths[j2].TableID
3774                 m.Route.Paths[j2].TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3775                 pos += 4
3776                 // field[3] m.Route.Paths[j2].RpfID
3777                 m.Route.Paths[j2].RpfID = uint32(o.Uint32(tmp[pos : pos+4]))
3778                 pos += 4
3779                 // field[3] m.Route.Paths[j2].Weight
3780                 m.Route.Paths[j2].Weight = uint8(tmp[pos])
3781                 pos += 1
3782                 // field[3] m.Route.Paths[j2].Preference
3783                 m.Route.Paths[j2].Preference = uint8(tmp[pos])
3784                 pos += 1
3785                 // field[3] m.Route.Paths[j2].Type
3786                 m.Route.Paths[j2].Type = FibPathType(o.Uint32(tmp[pos : pos+4]))
3787                 pos += 4
3788                 // field[3] m.Route.Paths[j2].Flags
3789                 m.Route.Paths[j2].Flags = FibPathFlags(o.Uint32(tmp[pos : pos+4]))
3790                 pos += 4
3791                 // field[3] m.Route.Paths[j2].Proto
3792                 m.Route.Paths[j2].Proto = FibPathNhProto(o.Uint32(tmp[pos : pos+4]))
3793                 pos += 4
3794                 // field[3] m.Route.Paths[j2].Nh
3795                 // field[4] m.Route.Paths[j2].Nh.Address
3796                 copy(m.Route.Paths[j2].Nh.Address.XXX_UnionData[:], tmp[pos:pos+16])
3797                 pos += 16
3798                 // field[4] m.Route.Paths[j2].Nh.ViaLabel
3799                 m.Route.Paths[j2].Nh.ViaLabel = uint32(o.Uint32(tmp[pos : pos+4]))
3800                 pos += 4
3801                 // field[4] m.Route.Paths[j2].Nh.ObjID
3802                 m.Route.Paths[j2].Nh.ObjID = uint32(o.Uint32(tmp[pos : pos+4]))
3803                 pos += 4
3804                 // field[4] m.Route.Paths[j2].Nh.ClassifyTableIndex
3805                 m.Route.Paths[j2].Nh.ClassifyTableIndex = uint32(o.Uint32(tmp[pos : pos+4]))
3806                 pos += 4
3807                 // field[3] m.Route.Paths[j2].NLabels
3808                 m.Route.Paths[j2].NLabels = uint8(tmp[pos])
3809                 pos += 1
3810                 // field[3] m.Route.Paths[j2].LabelStack
3811                 for j3 := 0; j3 < 16; j3++ {
3812                         // field[4] m.Route.Paths[j2].LabelStack[j3].IsUniform
3813                         m.Route.Paths[j2].LabelStack[j3].IsUniform = uint8(tmp[pos])
3814                         pos += 1
3815                         // field[4] m.Route.Paths[j2].LabelStack[j3].Label
3816                         m.Route.Paths[j2].LabelStack[j3].Label = uint32(o.Uint32(tmp[pos : pos+4]))
3817                         pos += 4
3818                         // field[4] m.Route.Paths[j2].LabelStack[j3].TTL
3819                         m.Route.Paths[j2].LabelStack[j3].TTL = uint8(tmp[pos])
3820                         pos += 1
3821                         // field[4] m.Route.Paths[j2].LabelStack[j3].Exp
3822                         m.Route.Paths[j2].LabelStack[j3].Exp = uint8(tmp[pos])
3823                         pos += 1
3824                 }
3825         }
3826         return nil
3827 }
3828
3829 // IPRouteDump represents VPP binary API message 'ip_route_dump'.
3830 type IPRouteDump struct {
3831         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
3832 }
3833
3834 func (m *IPRouteDump) Reset()                        { *m = IPRouteDump{} }
3835 func (*IPRouteDump) GetMessageName() string          { return "ip_route_dump" }
3836 func (*IPRouteDump) GetCrcString() string            { return "b9d2e09e" }
3837 func (*IPRouteDump) GetMessageType() api.MessageType { return api.RequestMessage }
3838
3839 func (m *IPRouteDump) Size() int {
3840         if m == nil {
3841                 return 0
3842         }
3843         var size int
3844         // field[1] m.Table
3845         // field[2] m.Table.TableID
3846         size += 4
3847         // field[2] m.Table.IsIP6
3848         size += 1
3849         // field[2] m.Table.Name
3850         size += 64
3851         return size
3852 }
3853 func (m *IPRouteDump) Marshal(b []byte) ([]byte, error) {
3854         o := binary.BigEndian
3855         _ = o
3856         pos := 0
3857         _ = pos
3858         var buf []byte
3859         if b == nil {
3860                 buf = make([]byte, m.Size())
3861         } else {
3862                 buf = b
3863         }
3864         // field[1] m.Table
3865         // field[2] m.Table.TableID
3866         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
3867         pos += 4
3868         // field[2] m.Table.IsIP6
3869         if m.Table.IsIP6 {
3870                 buf[pos] = 1
3871         }
3872         pos += 1
3873         // field[2] m.Table.Name
3874         copy(buf[pos:pos+64], m.Table.Name)
3875         pos += 64
3876         return buf, nil
3877 }
3878 func (m *IPRouteDump) Unmarshal(tmp []byte) error {
3879         o := binary.BigEndian
3880         _ = o
3881         pos := 0
3882         _ = pos
3883         // field[1] m.Table
3884         // field[2] m.Table.TableID
3885         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
3886         pos += 4
3887         // field[2] m.Table.IsIP6
3888         m.Table.IsIP6 = tmp[pos] != 0
3889         pos += 1
3890         // field[2] m.Table.Name
3891         {
3892                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
3893                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
3894                 pos += 64
3895         }
3896         return nil
3897 }
3898
3899 // IPSourceAndPortRangeCheckAddDel represents VPP binary API message 'ip_source_and_port_range_check_add_del'.
3900 type IPSourceAndPortRangeCheckAddDel struct {
3901         IsAdd          bool     `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
3902         Prefix         Prefix   `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
3903         NumberOfRanges uint8    `binapi:"u8,name=number_of_ranges" json:"number_of_ranges,omitempty"`
3904         LowPorts       []uint16 `binapi:"u16[32],name=low_ports" json:"low_ports,omitempty" struc:"[32]uint16"`
3905         HighPorts      []uint16 `binapi:"u16[32],name=high_ports" json:"high_ports,omitempty" struc:"[32]uint16"`
3906         VrfID          uint32   `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
3907 }
3908
3909 func (m *IPSourceAndPortRangeCheckAddDel) Reset() { *m = IPSourceAndPortRangeCheckAddDel{} }
3910 func (*IPSourceAndPortRangeCheckAddDel) GetMessageName() string {
3911         return "ip_source_and_port_range_check_add_del"
3912 }
3913 func (*IPSourceAndPortRangeCheckAddDel) GetCrcString() string            { return "8bfc76f2" }
3914 func (*IPSourceAndPortRangeCheckAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
3915
3916 func (m *IPSourceAndPortRangeCheckAddDel) Size() int {
3917         if m == nil {
3918                 return 0
3919         }
3920         var size int
3921         // field[1] m.IsAdd
3922         size += 1
3923         // field[1] m.Prefix
3924         // field[2] m.Prefix.Address
3925         // field[3] m.Prefix.Address.Af
3926         size += 4
3927         // field[3] m.Prefix.Address.Un
3928         size += 16
3929         // field[2] m.Prefix.Len
3930         size += 1
3931         // field[1] m.NumberOfRanges
3932         size += 1
3933         // field[1] m.LowPorts
3934         size += 64
3935         // field[1] m.HighPorts
3936         size += 64
3937         // field[1] m.VrfID
3938         size += 4
3939         return size
3940 }
3941 func (m *IPSourceAndPortRangeCheckAddDel) Marshal(b []byte) ([]byte, error) {
3942         o := binary.BigEndian
3943         _ = o
3944         pos := 0
3945         _ = pos
3946         var buf []byte
3947         if b == nil {
3948                 buf = make([]byte, m.Size())
3949         } else {
3950                 buf = b
3951         }
3952         // field[1] m.IsAdd
3953         if m.IsAdd {
3954                 buf[pos] = 1
3955         }
3956         pos += 1
3957         // field[1] m.Prefix
3958         // field[2] m.Prefix.Address
3959         // field[3] m.Prefix.Address.Af
3960         o.PutUint32(buf[pos:pos+4], uint32(m.Prefix.Address.Af))
3961         pos += 4
3962         // field[3] m.Prefix.Address.Un
3963         copy(buf[pos:pos+16], m.Prefix.Address.Un.XXX_UnionData[:])
3964         pos += 16
3965         // field[2] m.Prefix.Len
3966         buf[pos] = uint8(m.Prefix.Len)
3967         pos += 1
3968         // field[1] m.NumberOfRanges
3969         buf[pos] = uint8(m.NumberOfRanges)
3970         pos += 1
3971         // field[1] m.LowPorts
3972         for i := 0; i < 32; i++ {
3973                 var x uint16
3974                 if i < len(m.LowPorts) {
3975                         x = uint16(m.LowPorts[i])
3976                 }
3977                 o.PutUint16(buf[pos:pos+2], uint16(x))
3978                 pos += 2
3979         }
3980         // field[1] m.HighPorts
3981         for i := 0; i < 32; i++ {
3982                 var x uint16
3983                 if i < len(m.HighPorts) {
3984                         x = uint16(m.HighPorts[i])
3985                 }
3986                 o.PutUint16(buf[pos:pos+2], uint16(x))
3987                 pos += 2
3988         }
3989         // field[1] m.VrfID
3990         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
3991         pos += 4
3992         return buf, nil
3993 }
3994 func (m *IPSourceAndPortRangeCheckAddDel) Unmarshal(tmp []byte) error {
3995         o := binary.BigEndian
3996         _ = o
3997         pos := 0
3998         _ = pos
3999         // field[1] m.IsAdd
4000         m.IsAdd = tmp[pos] != 0
4001         pos += 1
4002         // field[1] m.Prefix
4003         // field[2] m.Prefix.Address
4004         // field[3] m.Prefix.Address.Af
4005         m.Prefix.Address.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
4006         pos += 4
4007         // field[3] m.Prefix.Address.Un
4008         copy(m.Prefix.Address.Un.XXX_UnionData[:], tmp[pos:pos+16])
4009         pos += 16
4010         // field[2] m.Prefix.Len
4011         m.Prefix.Len = uint8(tmp[pos])
4012         pos += 1
4013         // field[1] m.NumberOfRanges
4014         m.NumberOfRanges = uint8(tmp[pos])
4015         pos += 1
4016         // field[1] m.LowPorts
4017         m.LowPorts = make([]uint16, 32)
4018         for i := 0; i < len(m.LowPorts); i++ {
4019                 m.LowPorts[i] = uint16(o.Uint16(tmp[pos : pos+2]))
4020                 pos += 2
4021         }
4022         // field[1] m.HighPorts
4023         m.HighPorts = make([]uint16, 32)
4024         for i := 0; i < len(m.HighPorts); i++ {
4025                 m.HighPorts[i] = uint16(o.Uint16(tmp[pos : pos+2]))
4026                 pos += 2
4027         }
4028         // field[1] m.VrfID
4029         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4030         pos += 4
4031         return nil
4032 }
4033
4034 // IPSourceAndPortRangeCheckAddDelReply represents VPP binary API message 'ip_source_and_port_range_check_add_del_reply'.
4035 type IPSourceAndPortRangeCheckAddDelReply struct {
4036         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4037 }
4038
4039 func (m *IPSourceAndPortRangeCheckAddDelReply) Reset() { *m = IPSourceAndPortRangeCheckAddDelReply{} }
4040 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageName() string {
4041         return "ip_source_and_port_range_check_add_del_reply"
4042 }
4043 func (*IPSourceAndPortRangeCheckAddDelReply) GetCrcString() string { return "e8d4e804" }
4044 func (*IPSourceAndPortRangeCheckAddDelReply) GetMessageType() api.MessageType {
4045         return api.ReplyMessage
4046 }
4047
4048 func (m *IPSourceAndPortRangeCheckAddDelReply) Size() int {
4049         if m == nil {
4050                 return 0
4051         }
4052         var size int
4053         // field[1] m.Retval
4054         size += 4
4055         return size
4056 }
4057 func (m *IPSourceAndPortRangeCheckAddDelReply) Marshal(b []byte) ([]byte, error) {
4058         o := binary.BigEndian
4059         _ = o
4060         pos := 0
4061         _ = pos
4062         var buf []byte
4063         if b == nil {
4064                 buf = make([]byte, m.Size())
4065         } else {
4066                 buf = b
4067         }
4068         // field[1] m.Retval
4069         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4070         pos += 4
4071         return buf, nil
4072 }
4073 func (m *IPSourceAndPortRangeCheckAddDelReply) Unmarshal(tmp []byte) error {
4074         o := binary.BigEndian
4075         _ = o
4076         pos := 0
4077         _ = pos
4078         // field[1] m.Retval
4079         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4080         pos += 4
4081         return nil
4082 }
4083
4084 // IPSourceAndPortRangeCheckInterfaceAddDel represents VPP binary API message 'ip_source_and_port_range_check_interface_add_del'.
4085 type IPSourceAndPortRangeCheckInterfaceAddDel struct {
4086         IsAdd       bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
4087         SwIfIndex   InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4088         TCPInVrfID  uint32         `binapi:"u32,name=tcp_in_vrf_id" json:"tcp_in_vrf_id,omitempty"`
4089         TCPOutVrfID uint32         `binapi:"u32,name=tcp_out_vrf_id" json:"tcp_out_vrf_id,omitempty"`
4090         UDPInVrfID  uint32         `binapi:"u32,name=udp_in_vrf_id" json:"udp_in_vrf_id,omitempty"`
4091         UDPOutVrfID uint32         `binapi:"u32,name=udp_out_vrf_id" json:"udp_out_vrf_id,omitempty"`
4092 }
4093
4094 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Reset() {
4095         *m = IPSourceAndPortRangeCheckInterfaceAddDel{}
4096 }
4097 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageName() string {
4098         return "ip_source_and_port_range_check_interface_add_del"
4099 }
4100 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetCrcString() string { return "e1ba8987" }
4101 func (*IPSourceAndPortRangeCheckInterfaceAddDel) GetMessageType() api.MessageType {
4102         return api.RequestMessage
4103 }
4104
4105 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Size() int {
4106         if m == nil {
4107                 return 0
4108         }
4109         var size int
4110         // field[1] m.IsAdd
4111         size += 1
4112         // field[1] m.SwIfIndex
4113         size += 4
4114         // field[1] m.TCPInVrfID
4115         size += 4
4116         // field[1] m.TCPOutVrfID
4117         size += 4
4118         // field[1] m.UDPInVrfID
4119         size += 4
4120         // field[1] m.UDPOutVrfID
4121         size += 4
4122         return size
4123 }
4124 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
4125         o := binary.BigEndian
4126         _ = o
4127         pos := 0
4128         _ = pos
4129         var buf []byte
4130         if b == nil {
4131                 buf = make([]byte, m.Size())
4132         } else {
4133                 buf = b
4134         }
4135         // field[1] m.IsAdd
4136         if m.IsAdd {
4137                 buf[pos] = 1
4138         }
4139         pos += 1
4140         // field[1] m.SwIfIndex
4141         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4142         pos += 4
4143         // field[1] m.TCPInVrfID
4144         o.PutUint32(buf[pos:pos+4], uint32(m.TCPInVrfID))
4145         pos += 4
4146         // field[1] m.TCPOutVrfID
4147         o.PutUint32(buf[pos:pos+4], uint32(m.TCPOutVrfID))
4148         pos += 4
4149         // field[1] m.UDPInVrfID
4150         o.PutUint32(buf[pos:pos+4], uint32(m.UDPInVrfID))
4151         pos += 4
4152         // field[1] m.UDPOutVrfID
4153         o.PutUint32(buf[pos:pos+4], uint32(m.UDPOutVrfID))
4154         pos += 4
4155         return buf, nil
4156 }
4157 func (m *IPSourceAndPortRangeCheckInterfaceAddDel) Unmarshal(tmp []byte) error {
4158         o := binary.BigEndian
4159         _ = o
4160         pos := 0
4161         _ = pos
4162         // field[1] m.IsAdd
4163         m.IsAdd = tmp[pos] != 0
4164         pos += 1
4165         // field[1] m.SwIfIndex
4166         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4167         pos += 4
4168         // field[1] m.TCPInVrfID
4169         m.TCPInVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4170         pos += 4
4171         // field[1] m.TCPOutVrfID
4172         m.TCPOutVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4173         pos += 4
4174         // field[1] m.UDPInVrfID
4175         m.UDPInVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4176         pos += 4
4177         // field[1] m.UDPOutVrfID
4178         m.UDPOutVrfID = uint32(o.Uint32(tmp[pos : pos+4]))
4179         pos += 4
4180         return nil
4181 }
4182
4183 // IPSourceAndPortRangeCheckInterfaceAddDelReply represents VPP binary API message 'ip_source_and_port_range_check_interface_add_del_reply'.
4184 type IPSourceAndPortRangeCheckInterfaceAddDelReply struct {
4185         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4186 }
4187
4188 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Reset() {
4189         *m = IPSourceAndPortRangeCheckInterfaceAddDelReply{}
4190 }
4191 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageName() string {
4192         return "ip_source_and_port_range_check_interface_add_del_reply"
4193 }
4194 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetCrcString() string { return "e8d4e804" }
4195 func (*IPSourceAndPortRangeCheckInterfaceAddDelReply) GetMessageType() api.MessageType {
4196         return api.ReplyMessage
4197 }
4198
4199 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Size() int {
4200         if m == nil {
4201                 return 0
4202         }
4203         var size int
4204         // field[1] m.Retval
4205         size += 4
4206         return size
4207 }
4208 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
4209         o := binary.BigEndian
4210         _ = o
4211         pos := 0
4212         _ = pos
4213         var buf []byte
4214         if b == nil {
4215                 buf = make([]byte, m.Size())
4216         } else {
4217                 buf = b
4218         }
4219         // field[1] m.Retval
4220         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4221         pos += 4
4222         return buf, nil
4223 }
4224 func (m *IPSourceAndPortRangeCheckInterfaceAddDelReply) Unmarshal(tmp []byte) error {
4225         o := binary.BigEndian
4226         _ = o
4227         pos := 0
4228         _ = pos
4229         // field[1] m.Retval
4230         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4231         pos += 4
4232         return nil
4233 }
4234
4235 // IPSourceCheckInterfaceAddDel represents VPP binary API message 'ip_source_check_interface_add_del'.
4236 type IPSourceCheckInterfaceAddDel struct {
4237         IsAdd     bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
4238         Loose     bool           `binapi:"bool,name=loose" json:"loose,omitempty"`
4239         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4240 }
4241
4242 func (m *IPSourceCheckInterfaceAddDel) Reset() { *m = IPSourceCheckInterfaceAddDel{} }
4243 func (*IPSourceCheckInterfaceAddDel) GetMessageName() string {
4244         return "ip_source_check_interface_add_del"
4245 }
4246 func (*IPSourceCheckInterfaceAddDel) GetCrcString() string            { return "6612356b" }
4247 func (*IPSourceCheckInterfaceAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
4248
4249 func (m *IPSourceCheckInterfaceAddDel) Size() int {
4250         if m == nil {
4251                 return 0
4252         }
4253         var size int
4254         // field[1] m.IsAdd
4255         size += 1
4256         // field[1] m.Loose
4257         size += 1
4258         // field[1] m.SwIfIndex
4259         size += 4
4260         return size
4261 }
4262 func (m *IPSourceCheckInterfaceAddDel) Marshal(b []byte) ([]byte, error) {
4263         o := binary.BigEndian
4264         _ = o
4265         pos := 0
4266         _ = pos
4267         var buf []byte
4268         if b == nil {
4269                 buf = make([]byte, m.Size())
4270         } else {
4271                 buf = b
4272         }
4273         // field[1] m.IsAdd
4274         if m.IsAdd {
4275                 buf[pos] = 1
4276         }
4277         pos += 1
4278         // field[1] m.Loose
4279         if m.Loose {
4280                 buf[pos] = 1
4281         }
4282         pos += 1
4283         // field[1] m.SwIfIndex
4284         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4285         pos += 4
4286         return buf, nil
4287 }
4288 func (m *IPSourceCheckInterfaceAddDel) Unmarshal(tmp []byte) error {
4289         o := binary.BigEndian
4290         _ = o
4291         pos := 0
4292         _ = pos
4293         // field[1] m.IsAdd
4294         m.IsAdd = tmp[pos] != 0
4295         pos += 1
4296         // field[1] m.Loose
4297         m.Loose = tmp[pos] != 0
4298         pos += 1
4299         // field[1] m.SwIfIndex
4300         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4301         pos += 4
4302         return nil
4303 }
4304
4305 // IPSourceCheckInterfaceAddDelReply represents VPP binary API message 'ip_source_check_interface_add_del_reply'.
4306 type IPSourceCheckInterfaceAddDelReply struct {
4307         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4308 }
4309
4310 func (m *IPSourceCheckInterfaceAddDelReply) Reset() { *m = IPSourceCheckInterfaceAddDelReply{} }
4311 func (*IPSourceCheckInterfaceAddDelReply) GetMessageName() string {
4312         return "ip_source_check_interface_add_del_reply"
4313 }
4314 func (*IPSourceCheckInterfaceAddDelReply) GetCrcString() string            { return "e8d4e804" }
4315 func (*IPSourceCheckInterfaceAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4316
4317 func (m *IPSourceCheckInterfaceAddDelReply) Size() int {
4318         if m == nil {
4319                 return 0
4320         }
4321         var size int
4322         // field[1] m.Retval
4323         size += 4
4324         return size
4325 }
4326 func (m *IPSourceCheckInterfaceAddDelReply) Marshal(b []byte) ([]byte, error) {
4327         o := binary.BigEndian
4328         _ = o
4329         pos := 0
4330         _ = pos
4331         var buf []byte
4332         if b == nil {
4333                 buf = make([]byte, m.Size())
4334         } else {
4335                 buf = b
4336         }
4337         // field[1] m.Retval
4338         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4339         pos += 4
4340         return buf, nil
4341 }
4342 func (m *IPSourceCheckInterfaceAddDelReply) Unmarshal(tmp []byte) error {
4343         o := binary.BigEndian
4344         _ = o
4345         pos := 0
4346         _ = pos
4347         // field[1] m.Retval
4348         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4349         pos += 4
4350         return nil
4351 }
4352
4353 // IPTableAddDel represents VPP binary API message 'ip_table_add_del'.
4354 type IPTableAddDel struct {
4355         IsAdd bool    `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
4356         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4357 }
4358
4359 func (m *IPTableAddDel) Reset()                        { *m = IPTableAddDel{} }
4360 func (*IPTableAddDel) GetMessageName() string          { return "ip_table_add_del" }
4361 func (*IPTableAddDel) GetCrcString() string            { return "0ffdaec0" }
4362 func (*IPTableAddDel) GetMessageType() api.MessageType { return api.RequestMessage }
4363
4364 func (m *IPTableAddDel) Size() int {
4365         if m == nil {
4366                 return 0
4367         }
4368         var size int
4369         // field[1] m.IsAdd
4370         size += 1
4371         // field[1] m.Table
4372         // field[2] m.Table.TableID
4373         size += 4
4374         // field[2] m.Table.IsIP6
4375         size += 1
4376         // field[2] m.Table.Name
4377         size += 64
4378         return size
4379 }
4380 func (m *IPTableAddDel) Marshal(b []byte) ([]byte, error) {
4381         o := binary.BigEndian
4382         _ = o
4383         pos := 0
4384         _ = pos
4385         var buf []byte
4386         if b == nil {
4387                 buf = make([]byte, m.Size())
4388         } else {
4389                 buf = b
4390         }
4391         // field[1] m.IsAdd
4392         if m.IsAdd {
4393                 buf[pos] = 1
4394         }
4395         pos += 1
4396         // field[1] m.Table
4397         // field[2] m.Table.TableID
4398         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4399         pos += 4
4400         // field[2] m.Table.IsIP6
4401         if m.Table.IsIP6 {
4402                 buf[pos] = 1
4403         }
4404         pos += 1
4405         // field[2] m.Table.Name
4406         copy(buf[pos:pos+64], m.Table.Name)
4407         pos += 64
4408         return buf, nil
4409 }
4410 func (m *IPTableAddDel) Unmarshal(tmp []byte) error {
4411         o := binary.BigEndian
4412         _ = o
4413         pos := 0
4414         _ = pos
4415         // field[1] m.IsAdd
4416         m.IsAdd = tmp[pos] != 0
4417         pos += 1
4418         // field[1] m.Table
4419         // field[2] m.Table.TableID
4420         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4421         pos += 4
4422         // field[2] m.Table.IsIP6
4423         m.Table.IsIP6 = tmp[pos] != 0
4424         pos += 1
4425         // field[2] m.Table.Name
4426         {
4427                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4428                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4429                 pos += 64
4430         }
4431         return nil
4432 }
4433
4434 // IPTableAddDelReply represents VPP binary API message 'ip_table_add_del_reply'.
4435 type IPTableAddDelReply struct {
4436         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4437 }
4438
4439 func (m *IPTableAddDelReply) Reset()                        { *m = IPTableAddDelReply{} }
4440 func (*IPTableAddDelReply) GetMessageName() string          { return "ip_table_add_del_reply" }
4441 func (*IPTableAddDelReply) GetCrcString() string            { return "e8d4e804" }
4442 func (*IPTableAddDelReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4443
4444 func (m *IPTableAddDelReply) Size() int {
4445         if m == nil {
4446                 return 0
4447         }
4448         var size int
4449         // field[1] m.Retval
4450         size += 4
4451         return size
4452 }
4453 func (m *IPTableAddDelReply) Marshal(b []byte) ([]byte, error) {
4454         o := binary.BigEndian
4455         _ = o
4456         pos := 0
4457         _ = pos
4458         var buf []byte
4459         if b == nil {
4460                 buf = make([]byte, m.Size())
4461         } else {
4462                 buf = b
4463         }
4464         // field[1] m.Retval
4465         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4466         pos += 4
4467         return buf, nil
4468 }
4469 func (m *IPTableAddDelReply) Unmarshal(tmp []byte) error {
4470         o := binary.BigEndian
4471         _ = o
4472         pos := 0
4473         _ = pos
4474         // field[1] m.Retval
4475         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4476         pos += 4
4477         return nil
4478 }
4479
4480 // IPTableDetails represents VPP binary API message 'ip_table_details'.
4481 type IPTableDetails struct {
4482         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4483 }
4484
4485 func (m *IPTableDetails) Reset()                        { *m = IPTableDetails{} }
4486 func (*IPTableDetails) GetMessageName() string          { return "ip_table_details" }
4487 func (*IPTableDetails) GetCrcString() string            { return "c79fca0f" }
4488 func (*IPTableDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
4489
4490 func (m *IPTableDetails) Size() int {
4491         if m == nil {
4492                 return 0
4493         }
4494         var size int
4495         // field[1] m.Table
4496         // field[2] m.Table.TableID
4497         size += 4
4498         // field[2] m.Table.IsIP6
4499         size += 1
4500         // field[2] m.Table.Name
4501         size += 64
4502         return size
4503 }
4504 func (m *IPTableDetails) Marshal(b []byte) ([]byte, error) {
4505         o := binary.BigEndian
4506         _ = o
4507         pos := 0
4508         _ = pos
4509         var buf []byte
4510         if b == nil {
4511                 buf = make([]byte, m.Size())
4512         } else {
4513                 buf = b
4514         }
4515         // field[1] m.Table
4516         // field[2] m.Table.TableID
4517         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4518         pos += 4
4519         // field[2] m.Table.IsIP6
4520         if m.Table.IsIP6 {
4521                 buf[pos] = 1
4522         }
4523         pos += 1
4524         // field[2] m.Table.Name
4525         copy(buf[pos:pos+64], m.Table.Name)
4526         pos += 64
4527         return buf, nil
4528 }
4529 func (m *IPTableDetails) Unmarshal(tmp []byte) error {
4530         o := binary.BigEndian
4531         _ = o
4532         pos := 0
4533         _ = pos
4534         // field[1] m.Table
4535         // field[2] m.Table.TableID
4536         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4537         pos += 4
4538         // field[2] m.Table.IsIP6
4539         m.Table.IsIP6 = tmp[pos] != 0
4540         pos += 1
4541         // field[2] m.Table.Name
4542         {
4543                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4544                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4545                 pos += 64
4546         }
4547         return nil
4548 }
4549
4550 // IPTableDump represents VPP binary API message 'ip_table_dump'.
4551 type IPTableDump struct{}
4552
4553 func (m *IPTableDump) Reset()                        { *m = IPTableDump{} }
4554 func (*IPTableDump) GetMessageName() string          { return "ip_table_dump" }
4555 func (*IPTableDump) GetCrcString() string            { return "51077d14" }
4556 func (*IPTableDump) GetMessageType() api.MessageType { return api.RequestMessage }
4557
4558 func (m *IPTableDump) Size() int {
4559         if m == nil {
4560                 return 0
4561         }
4562         var size int
4563         return size
4564 }
4565 func (m *IPTableDump) Marshal(b []byte) ([]byte, error) {
4566         o := binary.BigEndian
4567         _ = o
4568         pos := 0
4569         _ = pos
4570         var buf []byte
4571         if b == nil {
4572                 buf = make([]byte, m.Size())
4573         } else {
4574                 buf = b
4575         }
4576         return buf, nil
4577 }
4578 func (m *IPTableDump) Unmarshal(tmp []byte) error {
4579         o := binary.BigEndian
4580         _ = o
4581         pos := 0
4582         _ = pos
4583         return nil
4584 }
4585
4586 // IPTableFlush represents VPP binary API message 'ip_table_flush'.
4587 type IPTableFlush struct {
4588         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4589 }
4590
4591 func (m *IPTableFlush) Reset()                        { *m = IPTableFlush{} }
4592 func (*IPTableFlush) GetMessageName() string          { return "ip_table_flush" }
4593 func (*IPTableFlush) GetCrcString() string            { return "b9d2e09e" }
4594 func (*IPTableFlush) GetMessageType() api.MessageType { return api.RequestMessage }
4595
4596 func (m *IPTableFlush) Size() int {
4597         if m == nil {
4598                 return 0
4599         }
4600         var size int
4601         // field[1] m.Table
4602         // field[2] m.Table.TableID
4603         size += 4
4604         // field[2] m.Table.IsIP6
4605         size += 1
4606         // field[2] m.Table.Name
4607         size += 64
4608         return size
4609 }
4610 func (m *IPTableFlush) Marshal(b []byte) ([]byte, error) {
4611         o := binary.BigEndian
4612         _ = o
4613         pos := 0
4614         _ = pos
4615         var buf []byte
4616         if b == nil {
4617                 buf = make([]byte, m.Size())
4618         } else {
4619                 buf = b
4620         }
4621         // field[1] m.Table
4622         // field[2] m.Table.TableID
4623         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4624         pos += 4
4625         // field[2] m.Table.IsIP6
4626         if m.Table.IsIP6 {
4627                 buf[pos] = 1
4628         }
4629         pos += 1
4630         // field[2] m.Table.Name
4631         copy(buf[pos:pos+64], m.Table.Name)
4632         pos += 64
4633         return buf, nil
4634 }
4635 func (m *IPTableFlush) Unmarshal(tmp []byte) error {
4636         o := binary.BigEndian
4637         _ = o
4638         pos := 0
4639         _ = pos
4640         // field[1] m.Table
4641         // field[2] m.Table.TableID
4642         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4643         pos += 4
4644         // field[2] m.Table.IsIP6
4645         m.Table.IsIP6 = tmp[pos] != 0
4646         pos += 1
4647         // field[2] m.Table.Name
4648         {
4649                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4650                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4651                 pos += 64
4652         }
4653         return nil
4654 }
4655
4656 // IPTableFlushReply represents VPP binary API message 'ip_table_flush_reply'.
4657 type IPTableFlushReply struct {
4658         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4659 }
4660
4661 func (m *IPTableFlushReply) Reset()                        { *m = IPTableFlushReply{} }
4662 func (*IPTableFlushReply) GetMessageName() string          { return "ip_table_flush_reply" }
4663 func (*IPTableFlushReply) GetCrcString() string            { return "e8d4e804" }
4664 func (*IPTableFlushReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4665
4666 func (m *IPTableFlushReply) Size() int {
4667         if m == nil {
4668                 return 0
4669         }
4670         var size int
4671         // field[1] m.Retval
4672         size += 4
4673         return size
4674 }
4675 func (m *IPTableFlushReply) Marshal(b []byte) ([]byte, error) {
4676         o := binary.BigEndian
4677         _ = o
4678         pos := 0
4679         _ = pos
4680         var buf []byte
4681         if b == nil {
4682                 buf = make([]byte, m.Size())
4683         } else {
4684                 buf = b
4685         }
4686         // field[1] m.Retval
4687         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4688         pos += 4
4689         return buf, nil
4690 }
4691 func (m *IPTableFlushReply) Unmarshal(tmp []byte) error {
4692         o := binary.BigEndian
4693         _ = o
4694         pos := 0
4695         _ = pos
4696         // field[1] m.Retval
4697         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4698         pos += 4
4699         return nil
4700 }
4701
4702 // IPTableReplaceBegin represents VPP binary API message 'ip_table_replace_begin'.
4703 type IPTableReplaceBegin struct {
4704         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4705 }
4706
4707 func (m *IPTableReplaceBegin) Reset()                        { *m = IPTableReplaceBegin{} }
4708 func (*IPTableReplaceBegin) GetMessageName() string          { return "ip_table_replace_begin" }
4709 func (*IPTableReplaceBegin) GetCrcString() string            { return "b9d2e09e" }
4710 func (*IPTableReplaceBegin) GetMessageType() api.MessageType { return api.RequestMessage }
4711
4712 func (m *IPTableReplaceBegin) Size() int {
4713         if m == nil {
4714                 return 0
4715         }
4716         var size int
4717         // field[1] m.Table
4718         // field[2] m.Table.TableID
4719         size += 4
4720         // field[2] m.Table.IsIP6
4721         size += 1
4722         // field[2] m.Table.Name
4723         size += 64
4724         return size
4725 }
4726 func (m *IPTableReplaceBegin) Marshal(b []byte) ([]byte, error) {
4727         o := binary.BigEndian
4728         _ = o
4729         pos := 0
4730         _ = pos
4731         var buf []byte
4732         if b == nil {
4733                 buf = make([]byte, m.Size())
4734         } else {
4735                 buf = b
4736         }
4737         // field[1] m.Table
4738         // field[2] m.Table.TableID
4739         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4740         pos += 4
4741         // field[2] m.Table.IsIP6
4742         if m.Table.IsIP6 {
4743                 buf[pos] = 1
4744         }
4745         pos += 1
4746         // field[2] m.Table.Name
4747         copy(buf[pos:pos+64], m.Table.Name)
4748         pos += 64
4749         return buf, nil
4750 }
4751 func (m *IPTableReplaceBegin) Unmarshal(tmp []byte) error {
4752         o := binary.BigEndian
4753         _ = o
4754         pos := 0
4755         _ = pos
4756         // field[1] m.Table
4757         // field[2] m.Table.TableID
4758         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4759         pos += 4
4760         // field[2] m.Table.IsIP6
4761         m.Table.IsIP6 = tmp[pos] != 0
4762         pos += 1
4763         // field[2] m.Table.Name
4764         {
4765                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4766                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4767                 pos += 64
4768         }
4769         return nil
4770 }
4771
4772 // IPTableReplaceBeginReply represents VPP binary API message 'ip_table_replace_begin_reply'.
4773 type IPTableReplaceBeginReply struct {
4774         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4775 }
4776
4777 func (m *IPTableReplaceBeginReply) Reset()                        { *m = IPTableReplaceBeginReply{} }
4778 func (*IPTableReplaceBeginReply) GetMessageName() string          { return "ip_table_replace_begin_reply" }
4779 func (*IPTableReplaceBeginReply) GetCrcString() string            { return "e8d4e804" }
4780 func (*IPTableReplaceBeginReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4781
4782 func (m *IPTableReplaceBeginReply) Size() int {
4783         if m == nil {
4784                 return 0
4785         }
4786         var size int
4787         // field[1] m.Retval
4788         size += 4
4789         return size
4790 }
4791 func (m *IPTableReplaceBeginReply) Marshal(b []byte) ([]byte, error) {
4792         o := binary.BigEndian
4793         _ = o
4794         pos := 0
4795         _ = pos
4796         var buf []byte
4797         if b == nil {
4798                 buf = make([]byte, m.Size())
4799         } else {
4800                 buf = b
4801         }
4802         // field[1] m.Retval
4803         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4804         pos += 4
4805         return buf, nil
4806 }
4807 func (m *IPTableReplaceBeginReply) Unmarshal(tmp []byte) error {
4808         o := binary.BigEndian
4809         _ = o
4810         pos := 0
4811         _ = pos
4812         // field[1] m.Retval
4813         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4814         pos += 4
4815         return nil
4816 }
4817
4818 // IPTableReplaceEnd represents VPP binary API message 'ip_table_replace_end'.
4819 type IPTableReplaceEnd struct {
4820         Table IPTable `binapi:"ip_table,name=table" json:"table,omitempty"`
4821 }
4822
4823 func (m *IPTableReplaceEnd) Reset()                        { *m = IPTableReplaceEnd{} }
4824 func (*IPTableReplaceEnd) GetMessageName() string          { return "ip_table_replace_end" }
4825 func (*IPTableReplaceEnd) GetCrcString() string            { return "b9d2e09e" }
4826 func (*IPTableReplaceEnd) GetMessageType() api.MessageType { return api.RequestMessage }
4827
4828 func (m *IPTableReplaceEnd) Size() int {
4829         if m == nil {
4830                 return 0
4831         }
4832         var size int
4833         // field[1] m.Table
4834         // field[2] m.Table.TableID
4835         size += 4
4836         // field[2] m.Table.IsIP6
4837         size += 1
4838         // field[2] m.Table.Name
4839         size += 64
4840         return size
4841 }
4842 func (m *IPTableReplaceEnd) Marshal(b []byte) ([]byte, error) {
4843         o := binary.BigEndian
4844         _ = o
4845         pos := 0
4846         _ = pos
4847         var buf []byte
4848         if b == nil {
4849                 buf = make([]byte, m.Size())
4850         } else {
4851                 buf = b
4852         }
4853         // field[1] m.Table
4854         // field[2] m.Table.TableID
4855         o.PutUint32(buf[pos:pos+4], uint32(m.Table.TableID))
4856         pos += 4
4857         // field[2] m.Table.IsIP6
4858         if m.Table.IsIP6 {
4859                 buf[pos] = 1
4860         }
4861         pos += 1
4862         // field[2] m.Table.Name
4863         copy(buf[pos:pos+64], m.Table.Name)
4864         pos += 64
4865         return buf, nil
4866 }
4867 func (m *IPTableReplaceEnd) Unmarshal(tmp []byte) error {
4868         o := binary.BigEndian
4869         _ = o
4870         pos := 0
4871         _ = pos
4872         // field[1] m.Table
4873         // field[2] m.Table.TableID
4874         m.Table.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
4875         pos += 4
4876         // field[2] m.Table.IsIP6
4877         m.Table.IsIP6 = tmp[pos] != 0
4878         pos += 1
4879         // field[2] m.Table.Name
4880         {
4881                 nul := bytes.Index(tmp[pos:pos+64], []byte{0x00})
4882                 m.Table.Name = codec.DecodeString(tmp[pos : pos+nul])
4883                 pos += 64
4884         }
4885         return nil
4886 }
4887
4888 // IPTableReplaceEndReply represents VPP binary API message 'ip_table_replace_end_reply'.
4889 type IPTableReplaceEndReply struct {
4890         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
4891 }
4892
4893 func (m *IPTableReplaceEndReply) Reset()                        { *m = IPTableReplaceEndReply{} }
4894 func (*IPTableReplaceEndReply) GetMessageName() string          { return "ip_table_replace_end_reply" }
4895 func (*IPTableReplaceEndReply) GetCrcString() string            { return "e8d4e804" }
4896 func (*IPTableReplaceEndReply) GetMessageType() api.MessageType { return api.ReplyMessage }
4897
4898 func (m *IPTableReplaceEndReply) Size() int {
4899         if m == nil {
4900                 return 0
4901         }
4902         var size int
4903         // field[1] m.Retval
4904         size += 4
4905         return size
4906 }
4907 func (m *IPTableReplaceEndReply) Marshal(b []byte) ([]byte, error) {
4908         o := binary.BigEndian
4909         _ = o
4910         pos := 0
4911         _ = pos
4912         var buf []byte
4913         if b == nil {
4914                 buf = make([]byte, m.Size())
4915         } else {
4916                 buf = b
4917         }
4918         // field[1] m.Retval
4919         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
4920         pos += 4
4921         return buf, nil
4922 }
4923 func (m *IPTableReplaceEndReply) Unmarshal(tmp []byte) error {
4924         o := binary.BigEndian
4925         _ = o
4926         pos := 0
4927         _ = pos
4928         // field[1] m.Retval
4929         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
4930         pos += 4
4931         return nil
4932 }
4933
4934 // IPUnnumberedDetails represents VPP binary API message 'ip_unnumbered_details'.
4935 type IPUnnumberedDetails struct {
4936         SwIfIndex   InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4937         IPSwIfIndex InterfaceIndex `binapi:"interface_index,name=ip_sw_if_index" json:"ip_sw_if_index,omitempty"`
4938 }
4939
4940 func (m *IPUnnumberedDetails) Reset()                        { *m = IPUnnumberedDetails{} }
4941 func (*IPUnnumberedDetails) GetMessageName() string          { return "ip_unnumbered_details" }
4942 func (*IPUnnumberedDetails) GetCrcString() string            { return "aa12a483" }
4943 func (*IPUnnumberedDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
4944
4945 func (m *IPUnnumberedDetails) Size() int {
4946         if m == nil {
4947                 return 0
4948         }
4949         var size int
4950         // field[1] m.SwIfIndex
4951         size += 4
4952         // field[1] m.IPSwIfIndex
4953         size += 4
4954         return size
4955 }
4956 func (m *IPUnnumberedDetails) Marshal(b []byte) ([]byte, error) {
4957         o := binary.BigEndian
4958         _ = o
4959         pos := 0
4960         _ = pos
4961         var buf []byte
4962         if b == nil {
4963                 buf = make([]byte, m.Size())
4964         } else {
4965                 buf = b
4966         }
4967         // field[1] m.SwIfIndex
4968         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
4969         pos += 4
4970         // field[1] m.IPSwIfIndex
4971         o.PutUint32(buf[pos:pos+4], uint32(m.IPSwIfIndex))
4972         pos += 4
4973         return buf, nil
4974 }
4975 func (m *IPUnnumberedDetails) Unmarshal(tmp []byte) error {
4976         o := binary.BigEndian
4977         _ = o
4978         pos := 0
4979         _ = pos
4980         // field[1] m.SwIfIndex
4981         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4982         pos += 4
4983         // field[1] m.IPSwIfIndex
4984         m.IPSwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
4985         pos += 4
4986         return nil
4987 }
4988
4989 // IPUnnumberedDump represents VPP binary API message 'ip_unnumbered_dump'.
4990 type IPUnnumberedDump struct {
4991         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
4992 }
4993
4994 func (m *IPUnnumberedDump) Reset()                        { *m = IPUnnumberedDump{} }
4995 func (*IPUnnumberedDump) GetMessageName() string          { return "ip_unnumbered_dump" }
4996 func (*IPUnnumberedDump) GetCrcString() string            { return "f9e6675e" }
4997 func (*IPUnnumberedDump) GetMessageType() api.MessageType { return api.RequestMessage }
4998
4999 func (m *IPUnnumberedDump) Size() int {
5000         if m == nil {
5001                 return 0
5002         }
5003         var size int
5004         // field[1] m.SwIfIndex
5005         size += 4
5006         return size
5007 }
5008 func (m *IPUnnumberedDump) Marshal(b []byte) ([]byte, error) {
5009         o := binary.BigEndian
5010         _ = o
5011         pos := 0
5012         _ = pos
5013         var buf []byte
5014         if b == nil {
5015                 buf = make([]byte, m.Size())
5016         } else {
5017                 buf = b
5018         }
5019         // field[1] m.SwIfIndex
5020         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
5021         pos += 4
5022         return buf, nil
5023 }
5024 func (m *IPUnnumberedDump) Unmarshal(tmp []byte) error {
5025         o := binary.BigEndian
5026         _ = o
5027         pos := 0
5028         _ = pos
5029         // field[1] m.SwIfIndex
5030         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5031         pos += 4
5032         return nil
5033 }
5034
5035 // MfibSignalDetails represents VPP binary API message 'mfib_signal_details'.
5036 type MfibSignalDetails struct {
5037         SwIfIndex    InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
5038         TableID      uint32         `binapi:"u32,name=table_id" json:"table_id,omitempty"`
5039         Prefix       Mprefix        `binapi:"mprefix,name=prefix" json:"prefix,omitempty"`
5040         IPPacketLen  uint16         `binapi:"u16,name=ip_packet_len" json:"ip_packet_len,omitempty"`
5041         IPPacketData []byte         `binapi:"u8[256],name=ip_packet_data" json:"ip_packet_data,omitempty" struc:"[256]byte"`
5042 }
5043
5044 func (m *MfibSignalDetails) Reset()                        { *m = MfibSignalDetails{} }
5045 func (*MfibSignalDetails) GetMessageName() string          { return "mfib_signal_details" }
5046 func (*MfibSignalDetails) GetCrcString() string            { return "64398a9a" }
5047 func (*MfibSignalDetails) GetMessageType() api.MessageType { return api.ReplyMessage }
5048
5049 func (m *MfibSignalDetails) Size() int {
5050         if m == nil {
5051                 return 0
5052         }
5053         var size int
5054         // field[1] m.SwIfIndex
5055         size += 4
5056         // field[1] m.TableID
5057         size += 4
5058         // field[1] m.Prefix
5059         // field[2] m.Prefix.Af
5060         size += 4
5061         // field[2] m.Prefix.GrpAddressLength
5062         size += 2
5063         // field[2] m.Prefix.GrpAddress
5064         size += 16
5065         // field[2] m.Prefix.SrcAddress
5066         size += 16
5067         // field[1] m.IPPacketLen
5068         size += 2
5069         // field[1] m.IPPacketData
5070         size += 256
5071         return size
5072 }
5073 func (m *MfibSignalDetails) Marshal(b []byte) ([]byte, error) {
5074         o := binary.BigEndian
5075         _ = o
5076         pos := 0
5077         _ = pos
5078         var buf []byte
5079         if b == nil {
5080                 buf = make([]byte, m.Size())
5081         } else {
5082                 buf = b
5083         }
5084         // field[1] m.SwIfIndex
5085         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
5086         pos += 4
5087         // field[1] m.TableID
5088         o.PutUint32(buf[pos:pos+4], uint32(m.TableID))
5089         pos += 4
5090         // field[1] m.Prefix
5091         // field[2] m.Prefix.Af
5092         o.PutUint32(buf[pos:pos+4], uint32(m.Prefix.Af))
5093         pos += 4
5094         // field[2] m.Prefix.GrpAddressLength
5095         o.PutUint16(buf[pos:pos+2], uint16(m.Prefix.GrpAddressLength))
5096         pos += 2
5097         // field[2] m.Prefix.GrpAddress
5098         copy(buf[pos:pos+16], m.Prefix.GrpAddress.XXX_UnionData[:])
5099         pos += 16
5100         // field[2] m.Prefix.SrcAddress
5101         copy(buf[pos:pos+16], m.Prefix.SrcAddress.XXX_UnionData[:])
5102         pos += 16
5103         // field[1] m.IPPacketLen
5104         o.PutUint16(buf[pos:pos+2], uint16(m.IPPacketLen))
5105         pos += 2
5106         // field[1] m.IPPacketData
5107         for i := 0; i < 256; i++ {
5108                 var x uint8
5109                 if i < len(m.IPPacketData) {
5110                         x = uint8(m.IPPacketData[i])
5111                 }
5112                 buf[pos] = uint8(x)
5113                 pos += 1
5114         }
5115         return buf, nil
5116 }
5117 func (m *MfibSignalDetails) Unmarshal(tmp []byte) error {
5118         o := binary.BigEndian
5119         _ = o
5120         pos := 0
5121         _ = pos
5122         // field[1] m.SwIfIndex
5123         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5124         pos += 4
5125         // field[1] m.TableID
5126         m.TableID = uint32(o.Uint32(tmp[pos : pos+4]))
5127         pos += 4
5128         // field[1] m.Prefix
5129         // field[2] m.Prefix.Af
5130         m.Prefix.Af = AddressFamily(o.Uint32(tmp[pos : pos+4]))
5131         pos += 4
5132         // field[2] m.Prefix.GrpAddressLength
5133         m.Prefix.GrpAddressLength = uint16(o.Uint16(tmp[pos : pos+2]))
5134         pos += 2
5135         // field[2] m.Prefix.GrpAddress
5136         copy(m.Prefix.GrpAddress.XXX_UnionData[:], tmp[pos:pos+16])
5137         pos += 16
5138         // field[2] m.Prefix.SrcAddress
5139         copy(m.Prefix.SrcAddress.XXX_UnionData[:], tmp[pos:pos+16])
5140         pos += 16
5141         // field[1] m.IPPacketLen
5142         m.IPPacketLen = uint16(o.Uint16(tmp[pos : pos+2]))
5143         pos += 2
5144         // field[1] m.IPPacketData
5145         m.IPPacketData = make([]uint8, 256)
5146         for i := 0; i < len(m.IPPacketData); i++ {
5147                 m.IPPacketData[i] = uint8(tmp[pos])
5148                 pos += 1
5149         }
5150         return nil
5151 }
5152
5153 // MfibSignalDump represents VPP binary API message 'mfib_signal_dump'.
5154 type MfibSignalDump struct{}
5155
5156 func (m *MfibSignalDump) Reset()                        { *m = MfibSignalDump{} }
5157 func (*MfibSignalDump) GetMessageName() string          { return "mfib_signal_dump" }
5158 func (*MfibSignalDump) GetCrcString() string            { return "51077d14" }
5159 func (*MfibSignalDump) GetMessageType() api.MessageType { return api.RequestMessage }
5160
5161 func (m *MfibSignalDump) Size() int {
5162         if m == nil {
5163                 return 0
5164         }
5165         var size int
5166         return size
5167 }
5168 func (m *MfibSignalDump) Marshal(b []byte) ([]byte, error) {
5169         o := binary.BigEndian
5170         _ = o
5171         pos := 0
5172         _ = pos
5173         var buf []byte
5174         if b == nil {
5175                 buf = make([]byte, m.Size())
5176         } else {
5177                 buf = b
5178         }
5179         return buf, nil
5180 }
5181 func (m *MfibSignalDump) Unmarshal(tmp []byte) error {
5182         o := binary.BigEndian
5183         _ = o
5184         pos := 0
5185         _ = pos
5186         return nil
5187 }
5188
5189 // SetIPFlowHash represents VPP binary API message 'set_ip_flow_hash'.
5190 type SetIPFlowHash struct {
5191         VrfID     uint32 `binapi:"u32,name=vrf_id" json:"vrf_id,omitempty"`
5192         IsIPv6    bool   `binapi:"bool,name=is_ipv6" json:"is_ipv6,omitempty"`
5193         Src       bool   `binapi:"bool,name=src" json:"src,omitempty"`
5194         Dst       bool   `binapi:"bool,name=dst" json:"dst,omitempty"`
5195         Sport     bool   `binapi:"bool,name=sport" json:"sport,omitempty"`
5196         Dport     bool   `binapi:"bool,name=dport" json:"dport,omitempty"`
5197         Proto     bool   `binapi:"bool,name=proto" json:"proto,omitempty"`
5198         Reverse   bool   `binapi:"bool,name=reverse" json:"reverse,omitempty"`
5199         Symmetric bool   `binapi:"bool,name=symmetric" json:"symmetric,omitempty"`
5200 }
5201
5202 func (m *SetIPFlowHash) Reset()                        { *m = SetIPFlowHash{} }
5203 func (*SetIPFlowHash) GetMessageName() string          { return "set_ip_flow_hash" }
5204 func (*SetIPFlowHash) GetCrcString() string            { return "084ee09e" }
5205 func (*SetIPFlowHash) GetMessageType() api.MessageType { return api.RequestMessage }
5206
5207 func (m *SetIPFlowHash) Size() int {
5208         if m == nil {
5209                 return 0
5210         }
5211         var size int
5212         // field[1] m.VrfID
5213         size += 4
5214         // field[1] m.IsIPv6
5215         size += 1
5216         // field[1] m.Src
5217         size += 1
5218         // field[1] m.Dst
5219         size += 1
5220         // field[1] m.Sport
5221         size += 1
5222         // field[1] m.Dport
5223         size += 1
5224         // field[1] m.Proto
5225         size += 1
5226         // field[1] m.Reverse
5227         size += 1
5228         // field[1] m.Symmetric
5229         size += 1
5230         return size
5231 }
5232 func (m *SetIPFlowHash) Marshal(b []byte) ([]byte, error) {
5233         o := binary.BigEndian
5234         _ = o
5235         pos := 0
5236         _ = pos
5237         var buf []byte
5238         if b == nil {
5239                 buf = make([]byte, m.Size())
5240         } else {
5241                 buf = b
5242         }
5243         // field[1] m.VrfID
5244         o.PutUint32(buf[pos:pos+4], uint32(m.VrfID))
5245         pos += 4
5246         // field[1] m.IsIPv6
5247         if m.IsIPv6 {
5248                 buf[pos] = 1
5249         }
5250         pos += 1
5251         // field[1] m.Src
5252         if m.Src {
5253                 buf[pos] = 1
5254         }
5255         pos += 1
5256         // field[1] m.Dst
5257         if m.Dst {
5258                 buf[pos] = 1
5259         }
5260         pos += 1
5261         // field[1] m.Sport
5262         if m.Sport {
5263                 buf[pos] = 1
5264         }
5265         pos += 1
5266         // field[1] m.Dport
5267         if m.Dport {
5268                 buf[pos] = 1
5269         }
5270         pos += 1
5271         // field[1] m.Proto
5272         if m.Proto {
5273                 buf[pos] = 1
5274         }
5275         pos += 1
5276         // field[1] m.Reverse
5277         if m.Reverse {
5278                 buf[pos] = 1
5279         }
5280         pos += 1
5281         // field[1] m.Symmetric
5282         if m.Symmetric {
5283                 buf[pos] = 1
5284         }
5285         pos += 1
5286         return buf, nil
5287 }
5288 func (m *SetIPFlowHash) Unmarshal(tmp []byte) error {
5289         o := binary.BigEndian
5290         _ = o
5291         pos := 0
5292         _ = pos
5293         // field[1] m.VrfID
5294         m.VrfID = uint32(o.Uint32(tmp[pos : pos+4]))
5295         pos += 4
5296         // field[1] m.IsIPv6
5297         m.IsIPv6 = tmp[pos] != 0
5298         pos += 1
5299         // field[1] m.Src
5300         m.Src = tmp[pos] != 0
5301         pos += 1
5302         // field[1] m.Dst
5303         m.Dst = tmp[pos] != 0
5304         pos += 1
5305         // field[1] m.Sport
5306         m.Sport = tmp[pos] != 0
5307         pos += 1
5308         // field[1] m.Dport
5309         m.Dport = tmp[pos] != 0
5310         pos += 1
5311         // field[1] m.Proto
5312         m.Proto = tmp[pos] != 0
5313         pos += 1
5314         // field[1] m.Reverse
5315         m.Reverse = tmp[pos] != 0
5316         pos += 1
5317         // field[1] m.Symmetric
5318         m.Symmetric = tmp[pos] != 0
5319         pos += 1
5320         return nil
5321 }
5322
5323 // SetIPFlowHashReply represents VPP binary API message 'set_ip_flow_hash_reply'.
5324 type SetIPFlowHashReply struct {
5325         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
5326 }
5327
5328 func (m *SetIPFlowHashReply) Reset()                        { *m = SetIPFlowHashReply{} }
5329 func (*SetIPFlowHashReply) GetMessageName() string          { return "set_ip_flow_hash_reply" }
5330 func (*SetIPFlowHashReply) GetCrcString() string            { return "e8d4e804" }
5331 func (*SetIPFlowHashReply) GetMessageType() api.MessageType { return api.ReplyMessage }
5332
5333 func (m *SetIPFlowHashReply) Size() int {
5334         if m == nil {
5335                 return 0
5336         }
5337         var size int
5338         // field[1] m.Retval
5339         size += 4
5340         return size
5341 }
5342 func (m *SetIPFlowHashReply) Marshal(b []byte) ([]byte, error) {
5343         o := binary.BigEndian
5344         _ = o
5345         pos := 0
5346         _ = pos
5347         var buf []byte
5348         if b == nil {
5349                 buf = make([]byte, m.Size())
5350         } else {
5351                 buf = b
5352         }
5353         // field[1] m.Retval
5354         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
5355         pos += 4
5356         return buf, nil
5357 }
5358 func (m *SetIPFlowHashReply) Unmarshal(tmp []byte) error {
5359         o := binary.BigEndian
5360         _ = o
5361         pos := 0
5362         _ = pos
5363         // field[1] m.Retval
5364         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
5365         pos += 4
5366         return nil
5367 }
5368
5369 // SwInterfaceIP6EnableDisable represents VPP binary API message 'sw_interface_ip6_enable_disable'.
5370 type SwInterfaceIP6EnableDisable struct {
5371         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
5372         Enable    bool           `binapi:"bool,name=enable" json:"enable,omitempty"`
5373 }
5374
5375 func (m *SwInterfaceIP6EnableDisable) Reset()                        { *m = SwInterfaceIP6EnableDisable{} }
5376 func (*SwInterfaceIP6EnableDisable) GetMessageName() string          { return "sw_interface_ip6_enable_disable" }
5377 func (*SwInterfaceIP6EnableDisable) GetCrcString() string            { return "ae6cfcfb" }
5378 func (*SwInterfaceIP6EnableDisable) GetMessageType() api.MessageType { return api.RequestMessage }
5379
5380 func (m *SwInterfaceIP6EnableDisable) Size() int {
5381         if m == nil {
5382                 return 0
5383         }
5384         var size int
5385         // field[1] m.SwIfIndex
5386         size += 4
5387         // field[1] m.Enable
5388         size += 1
5389         return size
5390 }
5391 func (m *SwInterfaceIP6EnableDisable) Marshal(b []byte) ([]byte, error) {
5392         o := binary.BigEndian
5393         _ = o
5394         pos := 0
5395         _ = pos
5396         var buf []byte
5397         if b == nil {
5398                 buf = make([]byte, m.Size())
5399         } else {
5400                 buf = b
5401         }
5402         // field[1] m.SwIfIndex
5403         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
5404         pos += 4
5405         // field[1] m.Enable
5406         if m.Enable {
5407                 buf[pos] = 1
5408         }
5409         pos += 1
5410         return buf, nil
5411 }
5412 func (m *SwInterfaceIP6EnableDisable) Unmarshal(tmp []byte) error {
5413         o := binary.BigEndian
5414         _ = o
5415         pos := 0
5416         _ = pos
5417         // field[1] m.SwIfIndex
5418         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5419         pos += 4
5420         // field[1] m.Enable
5421         m.Enable = tmp[pos] != 0
5422         pos += 1
5423         return nil
5424 }
5425
5426 // SwInterfaceIP6EnableDisableReply represents VPP binary API message 'sw_interface_ip6_enable_disable_reply'.
5427 type SwInterfaceIP6EnableDisableReply struct {
5428         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
5429 }
5430
5431 func (m *SwInterfaceIP6EnableDisableReply) Reset() { *m = SwInterfaceIP6EnableDisableReply{} }
5432 func (*SwInterfaceIP6EnableDisableReply) GetMessageName() string {
5433         return "sw_interface_ip6_enable_disable_reply"
5434 }
5435 func (*SwInterfaceIP6EnableDisableReply) GetCrcString() string            { return "e8d4e804" }
5436 func (*SwInterfaceIP6EnableDisableReply) GetMessageType() api.MessageType { return api.ReplyMessage }
5437
5438 func (m *SwInterfaceIP6EnableDisableReply) Size() int {
5439         if m == nil {
5440                 return 0
5441         }
5442         var size int
5443         // field[1] m.Retval
5444         size += 4
5445         return size
5446 }
5447 func (m *SwInterfaceIP6EnableDisableReply) Marshal(b []byte) ([]byte, error) {
5448         o := binary.BigEndian
5449         _ = o
5450         pos := 0
5451         _ = pos
5452         var buf []byte
5453         if b == nil {
5454                 buf = make([]byte, m.Size())
5455         } else {
5456                 buf = b
5457         }
5458         // field[1] m.Retval
5459         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
5460         pos += 4
5461         return buf, nil
5462 }
5463 func (m *SwInterfaceIP6EnableDisableReply) Unmarshal(tmp []byte) error {
5464         o := binary.BigEndian
5465         _ = o
5466         pos := 0
5467         _ = pos
5468         // field[1] m.Retval
5469         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
5470         pos += 4
5471         return nil
5472 }
5473
5474 // SwInterfaceIP6SetLinkLocalAddress represents VPP binary API message 'sw_interface_ip6_set_link_local_address'.
5475 type SwInterfaceIP6SetLinkLocalAddress struct {
5476         SwIfIndex InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
5477         IP        IP6Address     `binapi:"ip6_address,name=ip" json:"ip,omitempty"`
5478 }
5479
5480 func (m *SwInterfaceIP6SetLinkLocalAddress) Reset() { *m = SwInterfaceIP6SetLinkLocalAddress{} }
5481 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageName() string {
5482         return "sw_interface_ip6_set_link_local_address"
5483 }
5484 func (*SwInterfaceIP6SetLinkLocalAddress) GetCrcString() string            { return "2931d9fa" }
5485 func (*SwInterfaceIP6SetLinkLocalAddress) GetMessageType() api.MessageType { return api.RequestMessage }
5486
5487 func (m *SwInterfaceIP6SetLinkLocalAddress) Size() int {
5488         if m == nil {
5489                 return 0
5490         }
5491         var size int
5492         // field[1] m.SwIfIndex
5493         size += 4
5494         // field[1] m.IP
5495         size += 16
5496         return size
5497 }
5498 func (m *SwInterfaceIP6SetLinkLocalAddress) Marshal(b []byte) ([]byte, error) {
5499         o := binary.BigEndian
5500         _ = o
5501         pos := 0
5502         _ = pos
5503         var buf []byte
5504         if b == nil {
5505                 buf = make([]byte, m.Size())
5506         } else {
5507                 buf = b
5508         }
5509         // field[1] m.SwIfIndex
5510         o.PutUint32(buf[pos:pos+4], uint32(m.SwIfIndex))
5511         pos += 4
5512         // field[1] m.IP
5513         for i := 0; i < 16; i++ {
5514                 var x uint8
5515                 if i < len(m.IP) {
5516                         x = uint8(m.IP[i])
5517                 }
5518                 buf[pos] = uint8(x)
5519                 pos += 1
5520         }
5521         return buf, nil
5522 }
5523 func (m *SwInterfaceIP6SetLinkLocalAddress) Unmarshal(tmp []byte) error {
5524         o := binary.BigEndian
5525         _ = o
5526         pos := 0
5527         _ = pos
5528         // field[1] m.SwIfIndex
5529         m.SwIfIndex = InterfaceIndex(o.Uint32(tmp[pos : pos+4]))
5530         pos += 4
5531         // field[1] m.IP
5532         for i := 0; i < len(m.IP); i++ {
5533                 m.IP[i] = uint8(tmp[pos])
5534                 pos += 1
5535         }
5536         return nil
5537 }
5538
5539 // SwInterfaceIP6SetLinkLocalAddressReply represents VPP binary API message 'sw_interface_ip6_set_link_local_address_reply'.
5540 type SwInterfaceIP6SetLinkLocalAddressReply struct {
5541         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
5542 }
5543
5544 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Reset() {
5545         *m = SwInterfaceIP6SetLinkLocalAddressReply{}
5546 }
5547 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageName() string {
5548         return "sw_interface_ip6_set_link_local_address_reply"
5549 }
5550 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetCrcString() string { return "e8d4e804" }
5551 func (*SwInterfaceIP6SetLinkLocalAddressReply) GetMessageType() api.MessageType {
5552         return api.ReplyMessage
5553 }
5554
5555 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Size() int {
5556         if m == nil {
5557                 return 0
5558         }
5559         var size int
5560         // field[1] m.Retval
5561         size += 4
5562         return size
5563 }
5564 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Marshal(b []byte) ([]byte, error) {
5565         o := binary.BigEndian
5566         _ = o
5567         pos := 0
5568         _ = pos
5569         var buf []byte
5570         if b == nil {
5571                 buf = make([]byte, m.Size())
5572         } else {
5573                 buf = b
5574         }
5575         // field[1] m.Retval
5576         o.PutUint32(buf[pos:pos+4], uint32(m.Retval))
5577         pos += 4
5578         return buf, nil
5579 }
5580 func (m *SwInterfaceIP6SetLinkLocalAddressReply) Unmarshal(tmp []byte) error {
5581         o := binary.BigEndian
5582         _ = o
5583         pos := 0
5584         _ = pos
5585         // field[1] m.Retval
5586         m.Retval = int32(o.Uint32(tmp[pos : pos+4]))
5587         pos += 4
5588         return nil
5589 }
5590
5591 func init() { file_ip_binapi_init() }
5592 func file_ip_binapi_init() {
5593         api.RegisterMessage((*IoamDisable)(nil), "ip.IoamDisable")
5594         api.RegisterMessage((*IoamDisableReply)(nil), "ip.IoamDisableReply")
5595         api.RegisterMessage((*IoamEnable)(nil), "ip.IoamEnable")
5596         api.RegisterMessage((*IoamEnableReply)(nil), "ip.IoamEnableReply")
5597         api.RegisterMessage((*IPAddressDetails)(nil), "ip.IPAddressDetails")
5598         api.RegisterMessage((*IPAddressDump)(nil), "ip.IPAddressDump")
5599         api.RegisterMessage((*IPContainerProxyAddDel)(nil), "ip.IPContainerProxyAddDel")
5600         api.RegisterMessage((*IPContainerProxyAddDelReply)(nil), "ip.IPContainerProxyAddDelReply")
5601         api.RegisterMessage((*IPContainerProxyDetails)(nil), "ip.IPContainerProxyDetails")
5602         api.RegisterMessage((*IPContainerProxyDump)(nil), "ip.IPContainerProxyDump")
5603         api.RegisterMessage((*IPDetails)(nil), "ip.IPDetails")
5604         api.RegisterMessage((*IPDump)(nil), "ip.IPDump")
5605         api.RegisterMessage((*IPMrouteAddDel)(nil), "ip.IPMrouteAddDel")
5606         api.RegisterMessage((*IPMrouteAddDelReply)(nil), "ip.IPMrouteAddDelReply")
5607         api.RegisterMessage((*IPMrouteDetails)(nil), "ip.IPMrouteDetails")
5608         api.RegisterMessage((*IPMrouteDump)(nil), "ip.IPMrouteDump")
5609         api.RegisterMessage((*IPMtableDetails)(nil), "ip.IPMtableDetails")
5610         api.RegisterMessage((*IPMtableDump)(nil), "ip.IPMtableDump")
5611         api.RegisterMessage((*IPPuntPolice)(nil), "ip.IPPuntPolice")
5612         api.RegisterMessage((*IPPuntPoliceReply)(nil), "ip.IPPuntPoliceReply")
5613         api.RegisterMessage((*IPPuntRedirect)(nil), "ip.IPPuntRedirect")
5614         api.RegisterMessage((*IPPuntRedirectDetails)(nil), "ip.IPPuntRedirectDetails")
5615         api.RegisterMessage((*IPPuntRedirectDump)(nil), "ip.IPPuntRedirectDump")
5616         api.RegisterMessage((*IPPuntRedirectReply)(nil), "ip.IPPuntRedirectReply")
5617         api.RegisterMessage((*IPReassemblyEnableDisable)(nil), "ip.IPReassemblyEnableDisable")
5618         api.RegisterMessage((*IPReassemblyEnableDisableReply)(nil), "ip.IPReassemblyEnableDisableReply")
5619         api.RegisterMessage((*IPReassemblyGet)(nil), "ip.IPReassemblyGet")
5620         api.RegisterMessage((*IPReassemblyGetReply)(nil), "ip.IPReassemblyGetReply")
5621         api.RegisterMessage((*IPReassemblySet)(nil), "ip.IPReassemblySet")
5622         api.RegisterMessage((*IPReassemblySetReply)(nil), "ip.IPReassemblySetReply")
5623         api.RegisterMessage((*IPRouteAddDel)(nil), "ip.IPRouteAddDel")
5624         api.RegisterMessage((*IPRouteAddDelReply)(nil), "ip.IPRouteAddDelReply")
5625         api.RegisterMessage((*IPRouteDetails)(nil), "ip.IPRouteDetails")
5626         api.RegisterMessage((*IPRouteDump)(nil), "ip.IPRouteDump")
5627         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDel)(nil), "ip.IPSourceAndPortRangeCheckAddDel")
5628         api.RegisterMessage((*IPSourceAndPortRangeCheckAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckAddDelReply")
5629         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDel)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDel")
5630         api.RegisterMessage((*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil), "ip.IPSourceAndPortRangeCheckInterfaceAddDelReply")
5631         api.RegisterMessage((*IPSourceCheckInterfaceAddDel)(nil), "ip.IPSourceCheckInterfaceAddDel")
5632         api.RegisterMessage((*IPSourceCheckInterfaceAddDelReply)(nil), "ip.IPSourceCheckInterfaceAddDelReply")
5633         api.RegisterMessage((*IPTableAddDel)(nil), "ip.IPTableAddDel")
5634         api.RegisterMessage((*IPTableAddDelReply)(nil), "ip.IPTableAddDelReply")
5635         api.RegisterMessage((*IPTableDetails)(nil), "ip.IPTableDetails")
5636         api.RegisterMessage((*IPTableDump)(nil), "ip.IPTableDump")
5637         api.RegisterMessage((*IPTableFlush)(nil), "ip.IPTableFlush")
5638         api.RegisterMessage((*IPTableFlushReply)(nil), "ip.IPTableFlushReply")
5639         api.RegisterMessage((*IPTableReplaceBegin)(nil), "ip.IPTableReplaceBegin")
5640         api.RegisterMessage((*IPTableReplaceBeginReply)(nil), "ip.IPTableReplaceBeginReply")
5641         api.RegisterMessage((*IPTableReplaceEnd)(nil), "ip.IPTableReplaceEnd")
5642         api.RegisterMessage((*IPTableReplaceEndReply)(nil), "ip.IPTableReplaceEndReply")
5643         api.RegisterMessage((*IPUnnumberedDetails)(nil), "ip.IPUnnumberedDetails")
5644         api.RegisterMessage((*IPUnnumberedDump)(nil), "ip.IPUnnumberedDump")
5645         api.RegisterMessage((*MfibSignalDetails)(nil), "ip.MfibSignalDetails")
5646         api.RegisterMessage((*MfibSignalDump)(nil), "ip.MfibSignalDump")
5647         api.RegisterMessage((*SetIPFlowHash)(nil), "ip.SetIPFlowHash")
5648         api.RegisterMessage((*SetIPFlowHashReply)(nil), "ip.SetIPFlowHashReply")
5649         api.RegisterMessage((*SwInterfaceIP6EnableDisable)(nil), "ip.SwInterfaceIP6EnableDisable")
5650         api.RegisterMessage((*SwInterfaceIP6EnableDisableReply)(nil), "ip.SwInterfaceIP6EnableDisableReply")
5651         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddress)(nil), "ip.SwInterfaceIP6SetLinkLocalAddress")
5652         api.RegisterMessage((*SwInterfaceIP6SetLinkLocalAddressReply)(nil), "ip.SwInterfaceIP6SetLinkLocalAddressReply")
5653 }
5654
5655 // Messages returns list of all messages in this module.
5656 func AllMessages() []api.Message {
5657         return []api.Message{
5658                 (*IoamDisable)(nil),
5659                 (*IoamDisableReply)(nil),
5660                 (*IoamEnable)(nil),
5661                 (*IoamEnableReply)(nil),
5662                 (*IPAddressDetails)(nil),
5663                 (*IPAddressDump)(nil),
5664                 (*IPContainerProxyAddDel)(nil),
5665                 (*IPContainerProxyAddDelReply)(nil),
5666                 (*IPContainerProxyDetails)(nil),
5667                 (*IPContainerProxyDump)(nil),
5668                 (*IPDetails)(nil),
5669                 (*IPDump)(nil),
5670                 (*IPMrouteAddDel)(nil),
5671                 (*IPMrouteAddDelReply)(nil),
5672                 (*IPMrouteDetails)(nil),
5673                 (*IPMrouteDump)(nil),
5674                 (*IPMtableDetails)(nil),
5675                 (*IPMtableDump)(nil),
5676                 (*IPPuntPolice)(nil),
5677                 (*IPPuntPoliceReply)(nil),
5678                 (*IPPuntRedirect)(nil),
5679                 (*IPPuntRedirectDetails)(nil),
5680                 (*IPPuntRedirectDump)(nil),
5681                 (*IPPuntRedirectReply)(nil),
5682                 (*IPReassemblyEnableDisable)(nil),
5683                 (*IPReassemblyEnableDisableReply)(nil),
5684                 (*IPReassemblyGet)(nil),
5685                 (*IPReassemblyGetReply)(nil),
5686                 (*IPReassemblySet)(nil),
5687                 (*IPReassemblySetReply)(nil),
5688                 (*IPRouteAddDel)(nil),
5689                 (*IPRouteAddDelReply)(nil),
5690                 (*IPRouteDetails)(nil),
5691                 (*IPRouteDump)(nil),
5692                 (*IPSourceAndPortRangeCheckAddDel)(nil),
5693                 (*IPSourceAndPortRangeCheckAddDelReply)(nil),
5694                 (*IPSourceAndPortRangeCheckInterfaceAddDel)(nil),
5695                 (*IPSourceAndPortRangeCheckInterfaceAddDelReply)(nil),
5696                 (*IPSourceCheckInterfaceAddDel)(nil),
5697                 (*IPSourceCheckInterfaceAddDelReply)(nil),
5698                 (*IPTableAddDel)(nil),
5699                 (*IPTableAddDelReply)(nil),
5700                 (*IPTableDetails)(nil),
5701                 (*IPTableDump)(nil),
5702                 (*IPTableFlush)(nil),
5703                 (*IPTableFlushReply)(nil),
5704                 (*IPTableReplaceBegin)(nil),
5705                 (*IPTableReplaceBeginReply)(nil),
5706                 (*IPTableReplaceEnd)(nil),
5707                 (*IPTableReplaceEndReply)(nil),
5708                 (*IPUnnumberedDetails)(nil),
5709                 (*IPUnnumberedDump)(nil),
5710                 (*MfibSignalDetails)(nil),
5711                 (*MfibSignalDump)(nil),
5712                 (*SetIPFlowHash)(nil),
5713                 (*SetIPFlowHashReply)(nil),
5714                 (*SwInterfaceIP6EnableDisable)(nil),
5715                 (*SwInterfaceIP6EnableDisableReply)(nil),
5716                 (*SwInterfaceIP6SetLinkLocalAddress)(nil),
5717                 (*SwInterfaceIP6SetLinkLocalAddressReply)(nil),
5718         }
5719 }
5720
5721 // Reference imports to suppress errors if they are not otherwise used.
5722 var _ = api.RegisterMessage
5723 var _ = codec.DecodeString
5724 var _ = bytes.NewBuffer
5725 var _ = context.Background
5726 var _ = io.Copy
5727 var _ = strconv.Itoa
5728 var _ = struc.Pack
5729 var _ = binary.BigEndian
5730 var _ = math.Float32bits