binapi/gbp/gbp.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // versions:
   3 //  binapi-generator: v0.4.0-dev
   4 //  VPP:              20.05-release
   5 // source: /usr/share/vpp/api/plugins/gbp.api.json
   6
   7 // Package gbp contains generated bindings for API file gbp.api.
   8 //
   9 // Contents:
  10 //   1 alias
  11 //   7 enums
  12 //  14 structs
  13 //  48 messages
  14 //
  15 package gbp
  16
  17 import (
  18         "strconv"
  19
  20         api "git.fd.io/govpp.git/api"
  21         ethernet_types "git.fd.io/govpp.git/binapi/ethernet_types"
  22         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  23         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  24         codec "git.fd.io/govpp.git/codec"
  25 )
  26
  27 // This is a compile-time assertion to ensure that this generated file
  28 // is compatible with the GoVPP api package it is being compiled against.
  29 // A compilation error at this line likely means your copy of the
  30 // GoVPP api package needs to be updated.
  31 const _ = api.GoVppAPIPackageIsVersion2
  32
  33 const (
  34         APIFile    = "gbp"
  35         APIVersion = "2.0.0"
  36         VersionCrc = 0xa084c6b0
  37 )
  38
  39 // GbpBridgeDomainFlags defines enum 'gbp_bridge_domain_flags'.
  40 type GbpBridgeDomainFlags uint32
  41
  42 const (
  43         GBP_BD_API_FLAG_NONE         GbpBridgeDomainFlags = 0
  44         GBP_BD_API_FLAG_DO_NOT_LEARN GbpBridgeDomainFlags = 1
  45         GBP_BD_API_FLAG_UU_FWD_DROP  GbpBridgeDomainFlags = 2
  46         GBP_BD_API_FLAG_MCAST_DROP   GbpBridgeDomainFlags = 4
  47         GBP_BD_API_FLAG_UCAST_ARP    GbpBridgeDomainFlags = 8
  48 )
  49
  50 var (
  51         GbpBridgeDomainFlags_name = map[uint32]string{
  52                 0: "GBP_BD_API_FLAG_NONE",
  53                 1: "GBP_BD_API_FLAG_DO_NOT_LEARN",
  54                 2: "GBP_BD_API_FLAG_UU_FWD_DROP",
  55                 4: "GBP_BD_API_FLAG_MCAST_DROP",
  56                 8: "GBP_BD_API_FLAG_UCAST_ARP",
  57         }
  58         GbpBridgeDomainFlags_value = map[string]uint32{
  59                 "GBP_BD_API_FLAG_NONE":         0,
  60                 "GBP_BD_API_FLAG_DO_NOT_LEARN": 1,
  61                 "GBP_BD_API_FLAG_UU_FWD_DROP":  2,
  62                 "GBP_BD_API_FLAG_MCAST_DROP":   4,
  63                 "GBP_BD_API_FLAG_UCAST_ARP":    8,
  64         }
  65 )
  66
  67 func (x GbpBridgeDomainFlags) String() string {
  68         s, ok := GbpBridgeDomainFlags_name[uint32(x)]
  69         if ok {
  70                 return s
  71         }
  72         str := func(n uint32) string {
  73                 s, ok := GbpBridgeDomainFlags_name[uint32(n)]
  74                 if ok {
  75                         return s
  76                 }
  77                 return "GbpBridgeDomainFlags(" + strconv.Itoa(int(n)) + ")"
  78         }
  79         for i := uint32(0); i <= 32; i++ {
  80                 val := uint32(x)
  81                 if val&(1<<i) != 0 {
  82                         if s != "" {
  83                                 s += "|"
  84                         }
  85                         s += str(1 << i)
  86                 }
  87         }
  88         if s == "" {
  89                 return str(uint32(x))
  90         }
  91         return s
  92 }
  93
  94 // GbpEndpointFlags defines enum 'gbp_endpoint_flags'.
  95 type GbpEndpointFlags uint32
  96
  97 const (
  98         GBP_API_ENDPOINT_FLAG_NONE     GbpEndpointFlags = 0
  99         GBP_API_ENDPOINT_FLAG_BOUNCE   GbpEndpointFlags = 1
 100         GBP_API_ENDPOINT_FLAG_REMOTE   GbpEndpointFlags = 2
 101         GBP_API_ENDPOINT_FLAG_LEARNT   GbpEndpointFlags = 4
 102         GBP_API_ENDPOINT_FLAG_EXTERNAL GbpEndpointFlags = 8
 103 )
 104
 105 var (
 106         GbpEndpointFlags_name = map[uint32]string{
 107                 0: "GBP_API_ENDPOINT_FLAG_NONE",
 108                 1: "GBP_API_ENDPOINT_FLAG_BOUNCE",
 109                 2: "GBP_API_ENDPOINT_FLAG_REMOTE",
 110                 4: "GBP_API_ENDPOINT_FLAG_LEARNT",
 111                 8: "GBP_API_ENDPOINT_FLAG_EXTERNAL",
 112         }
 113         GbpEndpointFlags_value = map[string]uint32{
 114                 "GBP_API_ENDPOINT_FLAG_NONE":     0,
 115                 "GBP_API_ENDPOINT_FLAG_BOUNCE":   1,
 116                 "GBP_API_ENDPOINT_FLAG_REMOTE":   2,
 117                 "GBP_API_ENDPOINT_FLAG_LEARNT":   4,
 118                 "GBP_API_ENDPOINT_FLAG_EXTERNAL": 8,
 119         }
 120 )
 121
 122 func (x GbpEndpointFlags) String() string {
 123         s, ok := GbpEndpointFlags_name[uint32(x)]
 124         if ok {
 125                 return s
 126         }
 127         str := func(n uint32) string {
 128                 s, ok := GbpEndpointFlags_name[uint32(n)]
 129                 if ok {
 130                         return s
 131                 }
 132                 return "GbpEndpointFlags(" + strconv.Itoa(int(n)) + ")"
 133         }
 134         for i := uint32(0); i <= 32; i++ {
 135                 val := uint32(x)
 136                 if val&(1<<i) != 0 {
 137                         if s != "" {
 138                                 s += "|"
 139                         }
 140                         s += str(1 << i)
 141                 }
 142         }
 143         if s == "" {
 144                 return str(uint32(x))
 145         }
 146         return s
 147 }
 148
 149 // GbpExtItfFlags defines enum 'gbp_ext_itf_flags'.
 150 type GbpExtItfFlags uint32
 151
 152 const (
 153         GBP_API_EXT_ITF_F_NONE GbpExtItfFlags = 0
 154         GBP_API_EXT_ITF_F_ANON GbpExtItfFlags = 1
 155 )
 156
 157 var (
 158         GbpExtItfFlags_name = map[uint32]string{
 159                 0: "GBP_API_EXT_ITF_F_NONE",
 160                 1: "GBP_API_EXT_ITF_F_ANON",
 161         }
 162         GbpExtItfFlags_value = map[string]uint32{
 163                 "GBP_API_EXT_ITF_F_NONE": 0,
 164                 "GBP_API_EXT_ITF_F_ANON": 1,
 165         }
 166 )
 167
 168 func (x GbpExtItfFlags) String() string {
 169         s, ok := GbpExtItfFlags_name[uint32(x)]
 170         if ok {
 171                 return s
 172         }
 173         str := func(n uint32) string {
 174                 s, ok := GbpExtItfFlags_name[uint32(n)]
 175                 if ok {
 176                         return s
 177                 }
 178                 return "GbpExtItfFlags(" + strconv.Itoa(int(n)) + ")"
 179         }
 180         for i := uint32(0); i <= 32; i++ {
 181                 val := uint32(x)
 182                 if val&(1<<i) != 0 {
 183                         if s != "" {
 184                                 s += "|"
 185                         }
 186                         s += str(1 << i)
 187                 }
 188         }
 189         if s == "" {
 190                 return str(uint32(x))
 191         }
 192         return s
 193 }
 194
 195 // GbpHashMode defines enum 'gbp_hash_mode'.
 196 type GbpHashMode uint32
 197
 198 const (
 199         GBP_API_HASH_MODE_SRC_IP    GbpHashMode = 1
 200         GBP_API_HASH_MODE_DST_IP    GbpHashMode = 2
 201         GBP_API_HASH_MODE_SYMMETRIC GbpHashMode = 3
 202 )
 203
 204 var (
 205         GbpHashMode_name = map[uint32]string{
 206                 1: "GBP_API_HASH_MODE_SRC_IP",
 207                 2: "GBP_API_HASH_MODE_DST_IP",
 208                 3: "GBP_API_HASH_MODE_SYMMETRIC",
 209         }
 210         GbpHashMode_value = map[string]uint32{
 211                 "GBP_API_HASH_MODE_SRC_IP":    1,
 212                 "GBP_API_HASH_MODE_DST_IP":    2,
 213                 "GBP_API_HASH_MODE_SYMMETRIC": 3,
 214         }
 215 )
 216
 217 func (x GbpHashMode) String() string {
 218         s, ok := GbpHashMode_name[uint32(x)]
 219         if ok {
 220                 return s
 221         }
 222         return "GbpHashMode(" + strconv.Itoa(int(x)) + ")"
 223 }
 224
 225 // GbpRuleAction defines enum 'gbp_rule_action'.
 226 type GbpRuleAction uint32
 227
 228 const (
 229         GBP_API_RULE_PERMIT   GbpRuleAction = 1
 230         GBP_API_RULE_DENY     GbpRuleAction = 2
 231         GBP_API_RULE_REDIRECT GbpRuleAction = 3
 232 )
 233
 234 var (
 235         GbpRuleAction_name = map[uint32]string{
 236                 1: "GBP_API_RULE_PERMIT",
 237                 2: "GBP_API_RULE_DENY",
 238                 3: "GBP_API_RULE_REDIRECT",
 239         }
 240         GbpRuleAction_value = map[string]uint32{
 241                 "GBP_API_RULE_PERMIT":   1,
 242                 "GBP_API_RULE_DENY":     2,
 243                 "GBP_API_RULE_REDIRECT": 3,
 244         }
 245 )
 246
 247 func (x GbpRuleAction) String() string {
 248         s, ok := GbpRuleAction_name[uint32(x)]
 249         if ok {
 250                 return s
 251         }
 252         return "GbpRuleAction(" + strconv.Itoa(int(x)) + ")"
 253 }
 254
 255 // GbpSubnetType defines enum 'gbp_subnet_type'.
 256 type GbpSubnetType uint32
 257
 258 const (
 259         GBP_API_SUBNET_TRANSPORT         GbpSubnetType = 1
 260         GBP_API_SUBNET_STITCHED_INTERNAL GbpSubnetType = 2
 261         GBP_API_SUBNET_STITCHED_EXTERNAL GbpSubnetType = 3
 262         GBP_API_SUBNET_L3_OUT            GbpSubnetType = 4
 263         GBP_API_SUBNET_ANON_L3_OUT       GbpSubnetType = 5
 264 )
 265
 266 var (
 267         GbpSubnetType_name = map[uint32]string{
 268                 1: "GBP_API_SUBNET_TRANSPORT",
 269                 2: "GBP_API_SUBNET_STITCHED_INTERNAL",
 270                 3: "GBP_API_SUBNET_STITCHED_EXTERNAL",
 271                 4: "GBP_API_SUBNET_L3_OUT",
 272                 5: "GBP_API_SUBNET_ANON_L3_OUT",
 273         }
 274         GbpSubnetType_value = map[string]uint32{
 275                 "GBP_API_SUBNET_TRANSPORT":         1,
 276                 "GBP_API_SUBNET_STITCHED_INTERNAL": 2,
 277                 "GBP_API_SUBNET_STITCHED_EXTERNAL": 3,
 278                 "GBP_API_SUBNET_L3_OUT":            4,
 279                 "GBP_API_SUBNET_ANON_L3_OUT":       5,
 280         }
 281 )
 282
 283 func (x GbpSubnetType) String() string {
 284         s, ok := GbpSubnetType_name[uint32(x)]
 285         if ok {
 286                 return s
 287         }
 288         return "GbpSubnetType(" + strconv.Itoa(int(x)) + ")"
 289 }
 290
 291 // GbpVxlanTunnelMode defines enum 'gbp_vxlan_tunnel_mode'.
 292 type GbpVxlanTunnelMode uint32
 293
 294 const (
 295         GBP_VXLAN_TUNNEL_MODE_L2 GbpVxlanTunnelMode = 1
 296         GBP_VXLAN_TUNNEL_MODE_L3 GbpVxlanTunnelMode = 2
 297 )
 298
 299 var (
 300         GbpVxlanTunnelMode_name = map[uint32]string{
 301                 1: "GBP_VXLAN_TUNNEL_MODE_L2",
 302                 2: "GBP_VXLAN_TUNNEL_MODE_L3",
 303         }
 304         GbpVxlanTunnelMode_value = map[string]uint32{
 305                 "GBP_VXLAN_TUNNEL_MODE_L2": 1,
 306                 "GBP_VXLAN_TUNNEL_MODE_L3": 2,
 307         }
 308 )
 309
 310 func (x GbpVxlanTunnelMode) String() string {
 311         s, ok := GbpVxlanTunnelMode_name[uint32(x)]
 312         if ok {
 313                 return s
 314         }
 315         return "GbpVxlanTunnelMode(" + strconv.Itoa(int(x)) + ")"
 316 }
 317
 318 // GbpScope defines alias 'gbp_scope'.
 319 type GbpScope uint16
 320
 321 // GbpBridgeDomain defines type 'gbp_bridge_domain'.
 322 type GbpBridgeDomain struct {
 323         BdID             uint32                         `binapi:"u32,name=bd_id" json:"bd_id,omitempty"`
 324         RdID             uint32                         `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 325         Flags            GbpBridgeDomainFlags           `binapi:"gbp_bridge_domain_flags,name=flags" json:"flags,omitempty"`
 326         BviSwIfIndex     interface_types.InterfaceIndex `binapi:"interface_index,name=bvi_sw_if_index" json:"bvi_sw_if_index,omitempty"`
 327         UuFwdSwIfIndex   interface_types.InterfaceIndex `binapi:"interface_index,name=uu_fwd_sw_if_index" json:"uu_fwd_sw_if_index,omitempty"`
 328         BmFloodSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=bm_flood_sw_if_index" json:"bm_flood_sw_if_index,omitempty"`
 329 }
 330
 331 // GbpContract defines type 'gbp_contract'.
 332 type GbpContract struct {
 333         Scope             GbpScope  `binapi:"gbp_scope,name=scope" json:"scope,omitempty"`
 334         Sclass            uint16    `binapi:"u16,name=sclass" json:"sclass,omitempty"`
 335         Dclass            uint16    `binapi:"u16,name=dclass" json:"dclass,omitempty"`
 336         ACLIndex          uint32    `binapi:"u32,name=acl_index" json:"acl_index,omitempty"`
 337         NEtherTypes       uint8     `binapi:"u8,name=n_ether_types" json:"n_ether_types,omitempty"`
 338         AllowedEthertypes []uint16  `binapi:"u16[16],name=allowed_ethertypes" json:"allowed_ethertypes,omitempty"`
 339         NRules            uint8     `binapi:"u8,name=n_rules" json:"-"`
 340         Rules             []GbpRule `binapi:"gbp_rule[n_rules],name=rules" json:"rules,omitempty"`
 341 }
 342
 343 // GbpEndpoint defines type 'gbp_endpoint'.
 344 type GbpEndpoint struct {
 345         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 346         Sclass    uint16                         `binapi:"u16,name=sclass" json:"sclass,omitempty"`
 347         Flags     GbpEndpointFlags               `binapi:"gbp_endpoint_flags,name=flags" json:"flags,omitempty"`
 348         Mac       ethernet_types.MacAddress      `binapi:"mac_address,name=mac" json:"mac,omitempty"`
 349         Tun       GbpEndpointTun                 `binapi:"gbp_endpoint_tun,name=tun" json:"tun,omitempty"`
 350         NIps      uint8                          `binapi:"u8,name=n_ips" json:"-"`
 351         Ips       []ip_types.Address             `binapi:"address[n_ips],name=ips" json:"ips,omitempty"`
 352 }
 353
 354 // GbpEndpointGroup defines type 'gbp_endpoint_group'.
 355 type GbpEndpointGroup struct {
 356         Vnid            uint32                         `binapi:"u32,name=vnid" json:"vnid,omitempty"`
 357         Sclass          uint16                         `binapi:"u16,name=sclass" json:"sclass,omitempty"`
 358         BdID            uint32                         `binapi:"u32,name=bd_id" json:"bd_id,omitempty"`
 359         RdID            uint32                         `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 360         UplinkSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=uplink_sw_if_index" json:"uplink_sw_if_index,omitempty"`
 361         Retention       GbpEndpointRetention           `binapi:"gbp_endpoint_retention,name=retention" json:"retention,omitempty"`
 362 }
 363
 364 // GbpEndpointRetention defines type 'gbp_endpoint_retention'.
 365 type GbpEndpointRetention struct {
 366         RemoteEpTimeout uint32 `binapi:"u32,name=remote_ep_timeout" json:"remote_ep_timeout,omitempty"`
 367 }
 368
 369 // GbpEndpointTun defines type 'gbp_endpoint_tun'.
 370 type GbpEndpointTun struct {
 371         Src ip_types.Address `binapi:"address,name=src" json:"src,omitempty"`
 372         Dst ip_types.Address `binapi:"address,name=dst" json:"dst,omitempty"`
 373 }
 374
 375 // GbpExtItf defines type 'gbp_ext_itf'.
 376 type GbpExtItf struct {
 377         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 378         BdID      uint32                         `binapi:"u32,name=bd_id" json:"bd_id,omitempty"`
 379         RdID      uint32                         `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 380         Flags     GbpExtItfFlags                 `binapi:"gbp_ext_itf_flags,name=flags" json:"flags,omitempty"`
 381 }
 382
 383 // GbpNextHop defines type 'gbp_next_hop'.
 384 type GbpNextHop struct {
 385         IP   ip_types.Address          `binapi:"address,name=ip" json:"ip,omitempty"`
 386         Mac  ethernet_types.MacAddress `binapi:"mac_address,name=mac" json:"mac,omitempty"`
 387         BdID uint32                    `binapi:"u32,name=bd_id" json:"bd_id,omitempty"`
 388         RdID uint32                    `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 389 }
 390
 391 // GbpNextHopSet defines type 'gbp_next_hop_set'.
 392 type GbpNextHopSet struct {
 393         HashMode GbpHashMode   `binapi:"gbp_hash_mode,name=hash_mode" json:"hash_mode,omitempty"`
 394         NNhs     uint8         `binapi:"u8,name=n_nhs" json:"n_nhs,omitempty"`
 395         Nhs      [8]GbpNextHop `binapi:"gbp_next_hop[8],name=nhs" json:"nhs,omitempty"`
 396 }
 397
 398 // GbpRecirc defines type 'gbp_recirc'.
 399 type GbpRecirc struct {
 400         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 401         Sclass    uint16                         `binapi:"u16,name=sclass" json:"sclass,omitempty"`
 402         IsExt     bool                           `binapi:"bool,name=is_ext" json:"is_ext,omitempty"`
 403 }
 404
 405 // GbpRouteDomain defines type 'gbp_route_domain'.
 406 type GbpRouteDomain struct {
 407         RdID           uint32                         `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 408         IP4TableID     uint32                         `binapi:"u32,name=ip4_table_id" json:"ip4_table_id,omitempty"`
 409         IP6TableID     uint32                         `binapi:"u32,name=ip6_table_id" json:"ip6_table_id,omitempty"`
 410         IP4UuSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=ip4_uu_sw_if_index" json:"ip4_uu_sw_if_index,omitempty"`
 411         IP6UuSwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=ip6_uu_sw_if_index" json:"ip6_uu_sw_if_index,omitempty"`
 412         Scope          GbpScope                       `binapi:"gbp_scope,name=scope" json:"scope,omitempty"`
 413 }
 414
 415 // GbpRule defines type 'gbp_rule'.
 416 type GbpRule struct {
 417         Action GbpRuleAction `binapi:"gbp_rule_action,name=action" json:"action,omitempty"`
 418         NhSet  GbpNextHopSet `binapi:"gbp_next_hop_set,name=nh_set" json:"nh_set,omitempty"`
 419 }
 420
 421 // GbpSubnet defines type 'gbp_subnet'.
 422 type GbpSubnet struct {
 423         RdID      uint32                         `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
 424         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 425         Sclass    uint16                         `binapi:"u16,name=sclass" json:"sclass,omitempty"`
 426         Type      GbpSubnetType                  `binapi:"gbp_subnet_type,name=type" json:"type,omitempty"`
 427         Prefix    ip_types.Prefix                `binapi:"prefix,name=prefix" json:"prefix,omitempty"`
 428 }
 429
 430 // GbpVxlanTunnel defines type 'gbp_vxlan_tunnel'.
 431 type GbpVxlanTunnel struct {
 432         Vni    uint32              `binapi:"u32,name=vni" json:"vni,omitempty"`
 433         Mode   GbpVxlanTunnelMode  `binapi:"gbp_vxlan_tunnel_mode,name=mode" json:"mode,omitempty"`
 434         BdRdID uint32              `binapi:"u32,name=bd_rd_id" json:"bd_rd_id,omitempty"`
 435         Src    ip_types.IP4Address `binapi:"ip4_address,name=src" json:"src,omitempty"`
 436 }
 437
 438 // GbpBridgeDomainAdd defines message 'gbp_bridge_domain_add'.
 439 type GbpBridgeDomainAdd struct {
 440         Bd GbpBridgeDomain `binapi:"gbp_bridge_domain,name=bd" json:"bd,omitempty"`
 441 }
 442
 443 func (m *GbpBridgeDomainAdd) Reset()               { *m = GbpBridgeDomainAdd{} }
 444 func (*GbpBridgeDomainAdd) GetMessageName() string { return "gbp_bridge_domain_add" }
 445 func (*GbpBridgeDomainAdd) GetCrcString() string   { return "8454bfdf" }
 446 func (*GbpBridgeDomainAdd) GetMessageType() api.MessageType {
 447         return api.RequestMessage
 448 }
 449
 450 func (m *GbpBridgeDomainAdd) Size() (size int) {
 451         if m == nil {
 452                 return 0
 453         }
 454         size += 4 // m.Bd.BdID
 455         size += 4 // m.Bd.RdID
 456         size += 4 // m.Bd.Flags
 457         size += 4 // m.Bd.BviSwIfIndex
 458         size += 4 // m.Bd.UuFwdSwIfIndex
 459         size += 4 // m.Bd.BmFloodSwIfIndex
 460         return size
 461 }
 462 func (m *GbpBridgeDomainAdd) Marshal(b []byte) ([]byte, error) {
 463         if b == nil {
 464                 b = make([]byte, m.Size())
 465         }
 466         buf := codec.NewBuffer(b)
 467         buf.EncodeUint32(m.Bd.BdID)
 468         buf.EncodeUint32(m.Bd.RdID)
 469         buf.EncodeUint32(uint32(m.Bd.Flags))
 470         buf.EncodeUint32(uint32(m.Bd.BviSwIfIndex))
 471         buf.EncodeUint32(uint32(m.Bd.UuFwdSwIfIndex))
 472         buf.EncodeUint32(uint32(m.Bd.BmFloodSwIfIndex))
 473         return buf.Bytes(), nil
 474 }
 475 func (m *GbpBridgeDomainAdd) Unmarshal(b []byte) error {
 476         buf := codec.NewBuffer(b)
 477         m.Bd.BdID = buf.DecodeUint32()
 478         m.Bd.RdID = buf.DecodeUint32()
 479         m.Bd.Flags = GbpBridgeDomainFlags(buf.DecodeUint32())
 480         m.Bd.BviSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 481         m.Bd.UuFwdSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 482         m.Bd.BmFloodSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 483         return nil
 484 }
 485
 486 // GbpBridgeDomainAddReply defines message 'gbp_bridge_domain_add_reply'.
 487 type GbpBridgeDomainAddReply struct {
 488         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 489 }
 490
 491 func (m *GbpBridgeDomainAddReply) Reset()               { *m = GbpBridgeDomainAddReply{} }
 492 func (*GbpBridgeDomainAddReply) GetMessageName() string { return "gbp_bridge_domain_add_reply" }
 493 func (*GbpBridgeDomainAddReply) GetCrcString() string   { return "e8d4e804" }
 494 func (*GbpBridgeDomainAddReply) GetMessageType() api.MessageType {
 495         return api.ReplyMessage
 496 }
 497
 498 func (m *GbpBridgeDomainAddReply) Size() (size int) {
 499         if m == nil {
 500                 return 0
 501         }
 502         size += 4 // m.Retval
 503         return size
 504 }
 505 func (m *GbpBridgeDomainAddReply) Marshal(b []byte) ([]byte, error) {
 506         if b == nil {
 507                 b = make([]byte, m.Size())
 508         }
 509         buf := codec.NewBuffer(b)
 510         buf.EncodeInt32(m.Retval)
 511         return buf.Bytes(), nil
 512 }
 513 func (m *GbpBridgeDomainAddReply) Unmarshal(b []byte) error {
 514         buf := codec.NewBuffer(b)
 515         m.Retval = buf.DecodeInt32()
 516         return nil
 517 }
 518
 519 // GbpBridgeDomainDel defines message 'gbp_bridge_domain_del'.
 520 type GbpBridgeDomainDel struct {
 521         BdID uint32 `binapi:"u32,name=bd_id" json:"bd_id,omitempty"`
 522 }
 523
 524 func (m *GbpBridgeDomainDel) Reset()               { *m = GbpBridgeDomainDel{} }
 525 func (*GbpBridgeDomainDel) GetMessageName() string { return "gbp_bridge_domain_del" }
 526 func (*GbpBridgeDomainDel) GetCrcString() string   { return "c25fdce6" }
 527 func (*GbpBridgeDomainDel) GetMessageType() api.MessageType {
 528         return api.RequestMessage
 529 }
 530
 531 func (m *GbpBridgeDomainDel) Size() (size int) {
 532         if m == nil {
 533                 return 0
 534         }
 535         size += 4 // m.BdID
 536         return size
 537 }
 538 func (m *GbpBridgeDomainDel) Marshal(b []byte) ([]byte, error) {
 539         if b == nil {
 540                 b = make([]byte, m.Size())
 541         }
 542         buf := codec.NewBuffer(b)
 543         buf.EncodeUint32(m.BdID)
 544         return buf.Bytes(), nil
 545 }
 546 func (m *GbpBridgeDomainDel) Unmarshal(b []byte) error {
 547         buf := codec.NewBuffer(b)
 548         m.BdID = buf.DecodeUint32()
 549         return nil
 550 }
 551
 552 // GbpBridgeDomainDelReply defines message 'gbp_bridge_domain_del_reply'.
 553 type GbpBridgeDomainDelReply struct {
 554         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 555 }
 556
 557 func (m *GbpBridgeDomainDelReply) Reset()               { *m = GbpBridgeDomainDelReply{} }
 558 func (*GbpBridgeDomainDelReply) GetMessageName() string { return "gbp_bridge_domain_del_reply" }
 559 func (*GbpBridgeDomainDelReply) GetCrcString() string   { return "e8d4e804" }
 560 func (*GbpBridgeDomainDelReply) GetMessageType() api.MessageType {
 561         return api.ReplyMessage
 562 }
 563
 564 func (m *GbpBridgeDomainDelReply) Size() (size int) {
 565         if m == nil {
 566                 return 0
 567         }
 568         size += 4 // m.Retval
 569         return size
 570 }
 571 func (m *GbpBridgeDomainDelReply) Marshal(b []byte) ([]byte, error) {
 572         if b == nil {
 573                 b = make([]byte, m.Size())
 574         }
 575         buf := codec.NewBuffer(b)
 576         buf.EncodeInt32(m.Retval)
 577         return buf.Bytes(), nil
 578 }
 579 func (m *GbpBridgeDomainDelReply) Unmarshal(b []byte) error {
 580         buf := codec.NewBuffer(b)
 581         m.Retval = buf.DecodeInt32()
 582         return nil
 583 }
 584
 585 // GbpBridgeDomainDetails defines message 'gbp_bridge_domain_details'.
 586 type GbpBridgeDomainDetails struct {
 587         Bd GbpBridgeDomain `binapi:"gbp_bridge_domain,name=bd" json:"bd,omitempty"`
 588 }
 589
 590 func (m *GbpBridgeDomainDetails) Reset()               { *m = GbpBridgeDomainDetails{} }
 591 func (*GbpBridgeDomainDetails) GetMessageName() string { return "gbp_bridge_domain_details" }
 592 func (*GbpBridgeDomainDetails) GetCrcString() string   { return "2acd15f9" }
 593 func (*GbpBridgeDomainDetails) GetMessageType() api.MessageType {
 594         return api.ReplyMessage
 595 }
 596
 597 func (m *GbpBridgeDomainDetails) Size() (size int) {
 598         if m == nil {
 599                 return 0
 600         }
 601         size += 4 // m.Bd.BdID
 602         size += 4 // m.Bd.RdID
 603         size += 4 // m.Bd.Flags
 604         size += 4 // m.Bd.BviSwIfIndex
 605         size += 4 // m.Bd.UuFwdSwIfIndex
 606         size += 4 // m.Bd.BmFloodSwIfIndex
 607         return size
 608 }
 609 func (m *GbpBridgeDomainDetails) Marshal(b []byte) ([]byte, error) {
 610         if b == nil {
 611                 b = make([]byte, m.Size())
 612         }
 613         buf := codec.NewBuffer(b)
 614         buf.EncodeUint32(m.Bd.BdID)
 615         buf.EncodeUint32(m.Bd.RdID)
 616         buf.EncodeUint32(uint32(m.Bd.Flags))
 617         buf.EncodeUint32(uint32(m.Bd.BviSwIfIndex))
 618         buf.EncodeUint32(uint32(m.Bd.UuFwdSwIfIndex))
 619         buf.EncodeUint32(uint32(m.Bd.BmFloodSwIfIndex))
 620         return buf.Bytes(), nil
 621 }
 622 func (m *GbpBridgeDomainDetails) Unmarshal(b []byte) error {
 623         buf := codec.NewBuffer(b)
 624         m.Bd.BdID = buf.DecodeUint32()
 625         m.Bd.RdID = buf.DecodeUint32()
 626         m.Bd.Flags = GbpBridgeDomainFlags(buf.DecodeUint32())
 627         m.Bd.BviSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 628         m.Bd.UuFwdSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 629         m.Bd.BmFloodSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 630         return nil
 631 }
 632
 633 // GbpBridgeDomainDump defines message 'gbp_bridge_domain_dump'.
 634 type GbpBridgeDomainDump struct{}
 635
 636 func (m *GbpBridgeDomainDump) Reset()               { *m = GbpBridgeDomainDump{} }
 637 func (*GbpBridgeDomainDump) GetMessageName() string { return "gbp_bridge_domain_dump" }
 638 func (*GbpBridgeDomainDump) GetCrcString() string   { return "51077d14" }
 639 func (*GbpBridgeDomainDump) GetMessageType() api.MessageType {
 640         return api.RequestMessage
 641 }
 642
 643 func (m *GbpBridgeDomainDump) Size() (size int) {
 644         if m == nil {
 645                 return 0
 646         }
 647         return size
 648 }
 649 func (m *GbpBridgeDomainDump) Marshal(b []byte) ([]byte, error) {
 650         if b == nil {
 651                 b = make([]byte, m.Size())
 652         }
 653         buf := codec.NewBuffer(b)
 654         return buf.Bytes(), nil
 655 }
 656 func (m *GbpBridgeDomainDump) Unmarshal(b []byte) error {
 657         return nil
 658 }
 659
 660 // GbpBridgeDomainDumpReply defines message 'gbp_bridge_domain_dump_reply'.
 661 type GbpBridgeDomainDumpReply struct {
 662         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 663 }
 664
 665 func (m *GbpBridgeDomainDumpReply) Reset()               { *m = GbpBridgeDomainDumpReply{} }
 666 func (*GbpBridgeDomainDumpReply) GetMessageName() string { return "gbp_bridge_domain_dump_reply" }
 667 func (*GbpBridgeDomainDumpReply) GetCrcString() string   { return "e8d4e804" }
 668 func (*GbpBridgeDomainDumpReply) GetMessageType() api.MessageType {
 669         return api.ReplyMessage
 670 }
 671
 672 func (m *GbpBridgeDomainDumpReply) Size() (size int) {
 673         if m == nil {
 674                 return 0
 675         }
 676         size += 4 // m.Retval
 677         return size
 678 }
 679 func (m *GbpBridgeDomainDumpReply) Marshal(b []byte) ([]byte, error) {
 680         if b == nil {
 681                 b = make([]byte, m.Size())
 682         }
 683         buf := codec.NewBuffer(b)
 684         buf.EncodeInt32(m.Retval)
 685         return buf.Bytes(), nil
 686 }
 687 func (m *GbpBridgeDomainDumpReply) Unmarshal(b []byte) error {
 688         buf := codec.NewBuffer(b)
 689         m.Retval = buf.DecodeInt32()
 690         return nil
 691 }
 692
 693 // GbpContractAddDel defines message 'gbp_contract_add_del'.
 694 type GbpContractAddDel struct {
 695         IsAdd    bool        `binapi:"bool,name=is_add" json:"is_add,omitempty"`
 696         Contract GbpContract `binapi:"gbp_contract,name=contract" json:"contract,omitempty"`
 697 }
 698
 699 func (m *GbpContractAddDel) Reset()               { *m = GbpContractAddDel{} }
 700 func (*GbpContractAddDel) GetMessageName() string { return "gbp_contract_add_del" }
 701 func (*GbpContractAddDel) GetCrcString() string   { return "553e275b" }
 702 func (*GbpContractAddDel) GetMessageType() api.MessageType {
 703         return api.RequestMessage
 704 }
 705
 706 func (m *GbpContractAddDel) Size() (size int) {
 707         if m == nil {
 708                 return 0
 709         }
 710         size += 1      // m.IsAdd
 711         size += 2      // m.Contract.Scope
 712         size += 2      // m.Contract.Sclass
 713         size += 2      // m.Contract.Dclass
 714         size += 4      // m.Contract.ACLIndex
 715         size += 1      // m.Contract.NEtherTypes
 716         size += 2 * 16 // m.Contract.AllowedEthertypes
 717         size += 1      // m.Contract.NRules
 718         for j2 := 0; j2 < len(m.Contract.Rules); j2++ {
 719                 var s2 GbpRule
 720                 _ = s2
 721                 if j2 < len(m.Contract.Rules) {
 722                         s2 = m.Contract.Rules[j2]
 723                 }
 724                 size += 4 // s2.Action
 725                 size += 4 // s2.NhSet.HashMode
 726                 size += 1 // s2.NhSet.NNhs
 727                 for j4 := 0; j4 < 8; j4++ {
 728                         size += 1      // s2.NhSet.Nhs[j4].IP.Af
 729                         size += 1 * 16 // s2.NhSet.Nhs[j4].IP.Un
 730                         size += 1 * 6  // s2.NhSet.Nhs[j4].Mac
 731                         size += 4      // s2.NhSet.Nhs[j4].BdID
 732                         size += 4      // s2.NhSet.Nhs[j4].RdID
 733                 }
 734         }
 735         return size
 736 }
 737 func (m *GbpContractAddDel) Marshal(b []byte) ([]byte, error) {
 738         if b == nil {
 739                 b = make([]byte, m.Size())
 740         }
 741         buf := codec.NewBuffer(b)
 742         buf.EncodeBool(m.IsAdd)
 743         buf.EncodeUint16(uint16(m.Contract.Scope))
 744         buf.EncodeUint16(m.Contract.Sclass)
 745         buf.EncodeUint16(m.Contract.Dclass)
 746         buf.EncodeUint32(m.Contract.ACLIndex)
 747         buf.EncodeUint8(m.Contract.NEtherTypes)
 748         for i := 0; i < 16; i++ {
 749                 var x uint16
 750                 if i < len(m.Contract.AllowedEthertypes) {
 751                         x = uint16(m.Contract.AllowedEthertypes[i])
 752                 }
 753                 buf.EncodeUint16(x)
 754         }
 755         buf.EncodeUint8(uint8(len(m.Contract.Rules)))
 756         for j1 := 0; j1 < len(m.Contract.Rules); j1++ {
 757                 var v1 GbpRule // Rules
 758                 if j1 < len(m.Contract.Rules) {
 759                         v1 = m.Contract.Rules[j1]
 760                 }
 761                 buf.EncodeUint32(uint32(v1.Action))
 762                 buf.EncodeUint32(uint32(v1.NhSet.HashMode))
 763                 buf.EncodeUint8(v1.NhSet.NNhs)
 764                 for j3 := 0; j3 < 8; j3++ {
 765                         buf.EncodeUint8(uint8(v1.NhSet.Nhs[j3].IP.Af))
 766                         buf.EncodeBytes(v1.NhSet.Nhs[j3].IP.Un.XXX_UnionData[:], 16)
 767                         buf.EncodeBytes(v1.NhSet.Nhs[j3].Mac[:], 6)
 768                         buf.EncodeUint32(v1.NhSet.Nhs[j3].BdID)
 769                         buf.EncodeUint32(v1.NhSet.Nhs[j3].RdID)
 770                 }
 771         }
 772         return buf.Bytes(), nil
 773 }
 774 func (m *GbpContractAddDel) Unmarshal(b []byte) error {
 775         buf := codec.NewBuffer(b)
 776         m.IsAdd = buf.DecodeBool()
 777         m.Contract.Scope = GbpScope(buf.DecodeUint16())
 778         m.Contract.Sclass = buf.DecodeUint16()
 779         m.Contract.Dclass = buf.DecodeUint16()
 780         m.Contract.ACLIndex = buf.DecodeUint32()
 781         m.Contract.NEtherTypes = buf.DecodeUint8()
 782         m.Contract.AllowedEthertypes = make([]uint16, 16)
 783         for i := 0; i < len(m.Contract.AllowedEthertypes); i++ {
 784                 m.Contract.AllowedEthertypes[i] = buf.DecodeUint16()
 785         }
 786         m.Contract.NRules = buf.DecodeUint8()
 787         m.Contract.Rules = make([]GbpRule, m.Contract.NRules)
 788         for j1 := 0; j1 < len(m.Contract.Rules); j1++ {
 789                 m.Contract.Rules[j1].Action = GbpRuleAction(buf.DecodeUint32())
 790                 m.Contract.Rules[j1].NhSet.HashMode = GbpHashMode(buf.DecodeUint32())
 791                 m.Contract.Rules[j1].NhSet.NNhs = buf.DecodeUint8()
 792                 for j3 := 0; j3 < 8; j3++ {
 793                         m.Contract.Rules[j1].NhSet.Nhs[j3].IP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 794                         copy(m.Contract.Rules[j1].NhSet.Nhs[j3].IP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 795                         copy(m.Contract.Rules[j1].NhSet.Nhs[j3].Mac[:], buf.DecodeBytes(6))
 796                         m.Contract.Rules[j1].NhSet.Nhs[j3].BdID = buf.DecodeUint32()
 797                         m.Contract.Rules[j1].NhSet.Nhs[j3].RdID = buf.DecodeUint32()
 798                 }
 799         }
 800         return nil
 801 }
 802
 803 // GbpContractAddDelReply defines message 'gbp_contract_add_del_reply'.
 804 type GbpContractAddDelReply struct {
 805         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 806         StatsIndex uint32 `binapi:"u32,name=stats_index" json:"stats_index,omitempty"`
 807 }
 808
 809 func (m *GbpContractAddDelReply) Reset()               { *m = GbpContractAddDelReply{} }
 810 func (*GbpContractAddDelReply) GetMessageName() string { return "gbp_contract_add_del_reply" }
 811 func (*GbpContractAddDelReply) GetCrcString() string   { return "1992deab" }
 812 func (*GbpContractAddDelReply) GetMessageType() api.MessageType {
 813         return api.ReplyMessage
 814 }
 815
 816 func (m *GbpContractAddDelReply) Size() (size int) {
 817         if m == nil {
 818                 return 0
 819         }
 820         size += 4 // m.Retval
 821         size += 4 // m.StatsIndex
 822         return size
 823 }
 824 func (m *GbpContractAddDelReply) Marshal(b []byte) ([]byte, error) {
 825         if b == nil {
 826                 b = make([]byte, m.Size())
 827         }
 828         buf := codec.NewBuffer(b)
 829         buf.EncodeInt32(m.Retval)
 830         buf.EncodeUint32(m.StatsIndex)
 831         return buf.Bytes(), nil
 832 }
 833 func (m *GbpContractAddDelReply) Unmarshal(b []byte) error {
 834         buf := codec.NewBuffer(b)
 835         m.Retval = buf.DecodeInt32()
 836         m.StatsIndex = buf.DecodeUint32()
 837         return nil
 838 }
 839
 840 // GbpContractDetails defines message 'gbp_contract_details'.
 841 type GbpContractDetails struct {
 842         Contract GbpContract `binapi:"gbp_contract,name=contract" json:"contract,omitempty"`
 843 }
 844
 845 func (m *GbpContractDetails) Reset()               { *m = GbpContractDetails{} }
 846 func (*GbpContractDetails) GetMessageName() string { return "gbp_contract_details" }
 847 func (*GbpContractDetails) GetCrcString() string   { return "2a18db6e" }
 848 func (*GbpContractDetails) GetMessageType() api.MessageType {
 849         return api.ReplyMessage
 850 }
 851
 852 func (m *GbpContractDetails) Size() (size int) {
 853         if m == nil {
 854                 return 0
 855         }
 856         size += 2      // m.Contract.Scope
 857         size += 2      // m.Contract.Sclass
 858         size += 2      // m.Contract.Dclass
 859         size += 4      // m.Contract.ACLIndex
 860         size += 1      // m.Contract.NEtherTypes
 861         size += 2 * 16 // m.Contract.AllowedEthertypes
 862         size += 1      // m.Contract.NRules
 863         for j2 := 0; j2 < len(m.Contract.Rules); j2++ {
 864                 var s2 GbpRule
 865                 _ = s2
 866                 if j2 < len(m.Contract.Rules) {
 867                         s2 = m.Contract.Rules[j2]
 868                 }
 869                 size += 4 // s2.Action
 870                 size += 4 // s2.NhSet.HashMode
 871                 size += 1 // s2.NhSet.NNhs
 872                 for j4 := 0; j4 < 8; j4++ {
 873                         size += 1      // s2.NhSet.Nhs[j4].IP.Af
 874                         size += 1 * 16 // s2.NhSet.Nhs[j4].IP.Un
 875                         size += 1 * 6  // s2.NhSet.Nhs[j4].Mac
 876                         size += 4      // s2.NhSet.Nhs[j4].BdID
 877                         size += 4      // s2.NhSet.Nhs[j4].RdID
 878                 }
 879         }
 880         return size
 881 }
 882 func (m *GbpContractDetails) Marshal(b []byte) ([]byte, error) {
 883         if b == nil {
 884                 b = make([]byte, m.Size())
 885         }
 886         buf := codec.NewBuffer(b)
 887         buf.EncodeUint16(uint16(m.Contract.Scope))
 888         buf.EncodeUint16(m.Contract.Sclass)
 889         buf.EncodeUint16(m.Contract.Dclass)
 890         buf.EncodeUint32(m.Contract.ACLIndex)
 891         buf.EncodeUint8(m.Contract.NEtherTypes)
 892         for i := 0; i < 16; i++ {
 893                 var x uint16
 894                 if i < len(m.Contract.AllowedEthertypes) {
 895                         x = uint16(m.Contract.AllowedEthertypes[i])
 896                 }
 897                 buf.EncodeUint16(x)
 898         }
 899         buf.EncodeUint8(uint8(len(m.Contract.Rules)))
 900         for j1 := 0; j1 < len(m.Contract.Rules); j1++ {
 901                 var v1 GbpRule // Rules
 902                 if j1 < len(m.Contract.Rules) {
 903                         v1 = m.Contract.Rules[j1]
 904                 }
 905                 buf.EncodeUint32(uint32(v1.Action))
 906                 buf.EncodeUint32(uint32(v1.NhSet.HashMode))
 907                 buf.EncodeUint8(v1.NhSet.NNhs)
 908                 for j3 := 0; j3 < 8; j3++ {
 909                         buf.EncodeUint8(uint8(v1.NhSet.Nhs[j3].IP.Af))
 910                         buf.EncodeBytes(v1.NhSet.Nhs[j3].IP.Un.XXX_UnionData[:], 16)
 911                         buf.EncodeBytes(v1.NhSet.Nhs[j3].Mac[:], 6)
 912                         buf.EncodeUint32(v1.NhSet.Nhs[j3].BdID)
 913                         buf.EncodeUint32(v1.NhSet.Nhs[j3].RdID)
 914                 }
 915         }
 916         return buf.Bytes(), nil
 917 }
 918 func (m *GbpContractDetails) Unmarshal(b []byte) error {
 919         buf := codec.NewBuffer(b)
 920         m.Contract.Scope = GbpScope(buf.DecodeUint16())
 921         m.Contract.Sclass = buf.DecodeUint16()
 922         m.Contract.Dclass = buf.DecodeUint16()
 923         m.Contract.ACLIndex = buf.DecodeUint32()
 924         m.Contract.NEtherTypes = buf.DecodeUint8()
 925         m.Contract.AllowedEthertypes = make([]uint16, 16)
 926         for i := 0; i < len(m.Contract.AllowedEthertypes); i++ {
 927                 m.Contract.AllowedEthertypes[i] = buf.DecodeUint16()
 928         }
 929         m.Contract.NRules = buf.DecodeUint8()
 930         m.Contract.Rules = make([]GbpRule, m.Contract.NRules)
 931         for j1 := 0; j1 < len(m.Contract.Rules); j1++ {
 932                 m.Contract.Rules[j1].Action = GbpRuleAction(buf.DecodeUint32())
 933                 m.Contract.Rules[j1].NhSet.HashMode = GbpHashMode(buf.DecodeUint32())
 934                 m.Contract.Rules[j1].NhSet.NNhs = buf.DecodeUint8()
 935                 for j3 := 0; j3 < 8; j3++ {
 936                         m.Contract.Rules[j1].NhSet.Nhs[j3].IP.Af = ip_types.AddressFamily(buf.DecodeUint8())
 937                         copy(m.Contract.Rules[j1].NhSet.Nhs[j3].IP.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 938                         copy(m.Contract.Rules[j1].NhSet.Nhs[j3].Mac[:], buf.DecodeBytes(6))
 939                         m.Contract.Rules[j1].NhSet.Nhs[j3].BdID = buf.DecodeUint32()
 940                         m.Contract.Rules[j1].NhSet.Nhs[j3].RdID = buf.DecodeUint32()
 941                 }
 942         }
 943         return nil
 944 }
 945
 946 // GbpContractDump defines message 'gbp_contract_dump'.
 947 type GbpContractDump struct{}
 948
 949 func (m *GbpContractDump) Reset()               { *m = GbpContractDump{} }
 950 func (*GbpContractDump) GetMessageName() string { return "gbp_contract_dump" }
 951 func (*GbpContractDump) GetCrcString() string   { return "51077d14" }
 952 func (*GbpContractDump) GetMessageType() api.MessageType {
 953         return api.RequestMessage
 954 }
 955
 956 func (m *GbpContractDump) Size() (size int) {
 957         if m == nil {
 958                 return 0
 959         }
 960         return size
 961 }
 962 func (m *GbpContractDump) Marshal(b []byte) ([]byte, error) {
 963         if b == nil {
 964                 b = make([]byte, m.Size())
 965         }
 966         buf := codec.NewBuffer(b)
 967         return buf.Bytes(), nil
 968 }
 969 func (m *GbpContractDump) Unmarshal(b []byte) error {
 970         return nil
 971 }
 972
 973 // GbpEndpointAdd defines message 'gbp_endpoint_add'.
 974 type GbpEndpointAdd struct {
 975         Endpoint GbpEndpoint `binapi:"gbp_endpoint,name=endpoint" json:"endpoint,omitempty"`
 976 }
 977
 978 func (m *GbpEndpointAdd) Reset()               { *m = GbpEndpointAdd{} }
 979 func (*GbpEndpointAdd) GetMessageName() string { return "gbp_endpoint_add" }
 980 func (*GbpEndpointAdd) GetCrcString() string   { return "9ce16d5a" }
 981 func (*GbpEndpointAdd) GetMessageType() api.MessageType {
 982         return api.RequestMessage
 983 }
 984
 985 func (m *GbpEndpointAdd) Size() (size int) {
 986         if m == nil {
 987                 return 0
 988         }
 989         size += 4      // m.Endpoint.SwIfIndex
 990         size += 2      // m.Endpoint.Sclass
 991         size += 4      // m.Endpoint.Flags
 992         size += 1 * 6  // m.Endpoint.Mac
 993         size += 1      // m.Endpoint.Tun.Src.Af
 994         size += 1 * 16 // m.Endpoint.Tun.Src.Un
 995         size += 1      // m.Endpoint.Tun.Dst.Af
 996         size += 1 * 16 // m.Endpoint.Tun.Dst.Un
 997         size += 1      // m.Endpoint.NIps
 998         for j2 := 0; j2 < len(m.Endpoint.Ips); j2++ {
 999                 var s2 ip_types.Address
1000                 _ = s2
1001                 if j2 < len(m.Endpoint.Ips) {
1002                         s2 = m.Endpoint.Ips[j2]
1003                 }
1004                 size += 1      // s2.Af
1005                 size += 1 * 16 // s2.Un
1006         }
1007         return size
1008 }
1009 func (m *GbpEndpointAdd) Marshal(b []byte) ([]byte, error) {
1010         if b == nil {
1011                 b = make([]byte, m.Size())
1012         }
1013         buf := codec.NewBuffer(b)
1014         buf.EncodeUint32(uint32(m.Endpoint.SwIfIndex))
1015         buf.EncodeUint16(m.Endpoint.Sclass)
1016         buf.EncodeUint32(uint32(m.Endpoint.Flags))
1017         buf.EncodeBytes(m.Endpoint.Mac[:], 6)
1018         buf.EncodeUint8(uint8(m.Endpoint.Tun.Src.Af))
1019         buf.EncodeBytes(m.Endpoint.Tun.Src.Un.XXX_UnionData[:], 16)
1020         buf.EncodeUint8(uint8(m.Endpoint.Tun.Dst.Af))
1021         buf.EncodeBytes(m.Endpoint.Tun.Dst.Un.XXX_UnionData[:], 16)
1022         buf.EncodeUint8(uint8(len(m.Endpoint.Ips)))
1023         for j1 := 0; j1 < len(m.Endpoint.Ips); j1++ {
1024                 var v1 ip_types.Address // Ips
1025                 if j1 < len(m.Endpoint.Ips) {
1026                         v1 = m.Endpoint.Ips[j1]
1027                 }
1028                 buf.EncodeUint8(uint8(v1.Af))
1029                 buf.EncodeBytes(v1.Un.XXX_UnionData[:], 16)
1030         }
1031         return buf.Bytes(), nil
1032 }
1033 func (m *GbpEndpointAdd) Unmarshal(b []byte) error {
1034         buf := codec.NewBuffer(b)
1035         m.Endpoint.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1036         m.Endpoint.Sclass = buf.DecodeUint16()
1037         m.Endpoint.Flags = GbpEndpointFlags(buf.DecodeUint32())
1038         copy(m.Endpoint.Mac[:], buf.DecodeBytes(6))
1039         m.Endpoint.Tun.Src.Af = ip_types.AddressFamily(buf.DecodeUint8())
1040         copy(m.Endpoint.Tun.Src.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1041         m.Endpoint.Tun.Dst.Af = ip_types.AddressFamily(buf.DecodeUint8())
1042         copy(m.Endpoint.Tun.Dst.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1043         m.Endpoint.NIps = buf.DecodeUint8()
1044         m.Endpoint.Ips = make([]ip_types.Address, m.Endpoint.NIps)
1045         for j1 := 0; j1 < len(m.Endpoint.Ips); j1++ {
1046                 m.Endpoint.Ips[j1].Af = ip_types.AddressFamily(buf.DecodeUint8())
1047                 copy(m.Endpoint.Ips[j1].Un.XXX_UnionData[:], buf.DecodeBytes(16))
1048         }
1049         return nil
1050 }
1051
1052 // GbpEndpointAddReply defines message 'gbp_endpoint_add_reply'.
1053 type GbpEndpointAddReply struct {
1054         Retval int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1055         Handle uint32 `binapi:"u32,name=handle" json:"handle,omitempty"`
1056 }
1057
1058 func (m *GbpEndpointAddReply) Reset()               { *m = GbpEndpointAddReply{} }
1059 func (*GbpEndpointAddReply) GetMessageName() string { return "gbp_endpoint_add_reply" }
1060 func (*GbpEndpointAddReply) GetCrcString() string   { return "1dd3ff3e" }
1061 func (*GbpEndpointAddReply) GetMessageType() api.MessageType {
1062         return api.ReplyMessage
1063 }
1064
1065 func (m *GbpEndpointAddReply) Size() (size int) {
1066         if m == nil {
1067                 return 0
1068         }
1069         size += 4 // m.Retval
1070         size += 4 // m.Handle
1071         return size
1072 }
1073 func (m *GbpEndpointAddReply) Marshal(b []byte) ([]byte, error) {
1074         if b == nil {
1075                 b = make([]byte, m.Size())
1076         }
1077         buf := codec.NewBuffer(b)
1078         buf.EncodeInt32(m.Retval)
1079         buf.EncodeUint32(m.Handle)
1080         return buf.Bytes(), nil
1081 }
1082 func (m *GbpEndpointAddReply) Unmarshal(b []byte) error {
1083         buf := codec.NewBuffer(b)
1084         m.Retval = buf.DecodeInt32()
1085         m.Handle = buf.DecodeUint32()
1086         return nil
1087 }
1088
1089 // GbpEndpointDel defines message 'gbp_endpoint_del'.
1090 type GbpEndpointDel struct {
1091         Handle uint32 `binapi:"u32,name=handle" json:"handle,omitempty"`
1092 }
1093
1094 func (m *GbpEndpointDel) Reset()               { *m = GbpEndpointDel{} }
1095 func (*GbpEndpointDel) GetMessageName() string { return "gbp_endpoint_del" }
1096 func (*GbpEndpointDel) GetCrcString() string   { return "b93cd566" }
1097 func (*GbpEndpointDel) GetMessageType() api.MessageType {
1098         return api.RequestMessage
1099 }
1100
1101 func (m *GbpEndpointDel) Size() (size int) {
1102         if m == nil {
1103                 return 0
1104         }
1105         size += 4 // m.Handle
1106         return size
1107 }
1108 func (m *GbpEndpointDel) Marshal(b []byte) ([]byte, error) {
1109         if b == nil {
1110                 b = make([]byte, m.Size())
1111         }
1112         buf := codec.NewBuffer(b)
1113         buf.EncodeUint32(m.Handle)
1114         return buf.Bytes(), nil
1115 }
1116 func (m *GbpEndpointDel) Unmarshal(b []byte) error {
1117         buf := codec.NewBuffer(b)
1118         m.Handle = buf.DecodeUint32()
1119         return nil
1120 }
1121
1122 // GbpEndpointDelReply defines message 'gbp_endpoint_del_reply'.
1123 type GbpEndpointDelReply struct {
1124         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1125 }
1126
1127 func (m *GbpEndpointDelReply) Reset()               { *m = GbpEndpointDelReply{} }
1128 func (*GbpEndpointDelReply) GetMessageName() string { return "gbp_endpoint_del_reply" }
1129 func (*GbpEndpointDelReply) GetCrcString() string   { return "e8d4e804" }
1130 func (*GbpEndpointDelReply) GetMessageType() api.MessageType {
1131         return api.ReplyMessage
1132 }
1133
1134 func (m *GbpEndpointDelReply) Size() (size int) {
1135         if m == nil {
1136                 return 0
1137         }
1138         size += 4 // m.Retval
1139         return size
1140 }
1141 func (m *GbpEndpointDelReply) Marshal(b []byte) ([]byte, error) {
1142         if b == nil {
1143                 b = make([]byte, m.Size())
1144         }
1145         buf := codec.NewBuffer(b)
1146         buf.EncodeInt32(m.Retval)
1147         return buf.Bytes(), nil
1148 }
1149 func (m *GbpEndpointDelReply) Unmarshal(b []byte) error {
1150         buf := codec.NewBuffer(b)
1151         m.Retval = buf.DecodeInt32()
1152         return nil
1153 }
1154
1155 // GbpEndpointDetails defines message 'gbp_endpoint_details'.
1156 type GbpEndpointDetails struct {
1157         Age      float64     `binapi:"f64,name=age" json:"age,omitempty"`
1158         Handle   uint32      `binapi:"u32,name=handle" json:"handle,omitempty"`
1159         Endpoint GbpEndpoint `binapi:"gbp_endpoint,name=endpoint" json:"endpoint,omitempty"`
1160 }
1161
1162 func (m *GbpEndpointDetails) Reset()               { *m = GbpEndpointDetails{} }
1163 func (*GbpEndpointDetails) GetMessageName() string { return "gbp_endpoint_details" }
1164 func (*GbpEndpointDetails) GetCrcString() string   { return "08aecb60" }
1165 func (*GbpEndpointDetails) GetMessageType() api.MessageType {
1166         return api.ReplyMessage
1167 }
1168
1169 func (m *GbpEndpointDetails) Size() (size int) {
1170         if m == nil {
1171                 return 0
1172         }
1173         size += 8      // m.Age
1174         size += 4      // m.Handle
1175         size += 4      // m.Endpoint.SwIfIndex
1176         size += 2      // m.Endpoint.Sclass
1177         size += 4      // m.Endpoint.Flags
1178         size += 1 * 6  // m.Endpoint.Mac
1179         size += 1      // m.Endpoint.Tun.Src.Af
1180         size += 1 * 16 // m.Endpoint.Tun.Src.Un
1181         size += 1      // m.Endpoint.Tun.Dst.Af
1182         size += 1 * 16 // m.Endpoint.Tun.Dst.Un
1183         size += 1      // m.Endpoint.NIps
1184         for j2 := 0; j2 < len(m.Endpoint.Ips); j2++ {
1185                 var s2 ip_types.Address
1186                 _ = s2
1187                 if j2 < len(m.Endpoint.Ips) {
1188                         s2 = m.Endpoint.Ips[j2]
1189                 }
1190                 size += 1      // s2.Af
1191                 size += 1 * 16 // s2.Un
1192         }
1193         return size
1194 }
1195 func (m *GbpEndpointDetails) Marshal(b []byte) ([]byte, error) {
1196         if b == nil {
1197                 b = make([]byte, m.Size())
1198         }
1199         buf := codec.NewBuffer(b)
1200         buf.EncodeFloat64(m.Age)
1201         buf.EncodeUint32(m.Handle)
1202         buf.EncodeUint32(uint32(m.Endpoint.SwIfIndex))
1203         buf.EncodeUint16(m.Endpoint.Sclass)
1204         buf.EncodeUint32(uint32(m.Endpoint.Flags))
1205         buf.EncodeBytes(m.Endpoint.Mac[:], 6)
1206         buf.EncodeUint8(uint8(m.Endpoint.Tun.Src.Af))
1207         buf.EncodeBytes(m.Endpoint.Tun.Src.Un.XXX_UnionData[:], 16)
1208         buf.EncodeUint8(uint8(m.Endpoint.Tun.Dst.Af))
1209         buf.EncodeBytes(m.Endpoint.Tun.Dst.Un.XXX_UnionData[:], 16)
1210         buf.EncodeUint8(uint8(len(m.Endpoint.Ips)))
1211         for j1 := 0; j1 < len(m.Endpoint.Ips); j1++ {
1212                 var v1 ip_types.Address // Ips
1213                 if j1 < len(m.Endpoint.Ips) {
1214                         v1 = m.Endpoint.Ips[j1]
1215                 }
1216                 buf.EncodeUint8(uint8(v1.Af))
1217                 buf.EncodeBytes(v1.Un.XXX_UnionData[:], 16)
1218         }
1219         return buf.Bytes(), nil
1220 }
1221 func (m *GbpEndpointDetails) Unmarshal(b []byte) error {
1222         buf := codec.NewBuffer(b)
1223         m.Age = buf.DecodeFloat64()
1224         m.Handle = buf.DecodeUint32()
1225         m.Endpoint.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1226         m.Endpoint.Sclass = buf.DecodeUint16()
1227         m.Endpoint.Flags = GbpEndpointFlags(buf.DecodeUint32())
1228         copy(m.Endpoint.Mac[:], buf.DecodeBytes(6))
1229         m.Endpoint.Tun.Src.Af = ip_types.AddressFamily(buf.DecodeUint8())
1230         copy(m.Endpoint.Tun.Src.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1231         m.Endpoint.Tun.Dst.Af = ip_types.AddressFamily(buf.DecodeUint8())
1232         copy(m.Endpoint.Tun.Dst.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1233         m.Endpoint.NIps = buf.DecodeUint8()
1234         m.Endpoint.Ips = make([]ip_types.Address, m.Endpoint.NIps)
1235         for j1 := 0; j1 < len(m.Endpoint.Ips); j1++ {
1236                 m.Endpoint.Ips[j1].Af = ip_types.AddressFamily(buf.DecodeUint8())
1237                 copy(m.Endpoint.Ips[j1].Un.XXX_UnionData[:], buf.DecodeBytes(16))
1238         }
1239         return nil
1240 }
1241
1242 // GbpEndpointDump defines message 'gbp_endpoint_dump'.
1243 type GbpEndpointDump struct{}
1244
1245 func (m *GbpEndpointDump) Reset()               { *m = GbpEndpointDump{} }
1246 func (*GbpEndpointDump) GetMessageName() string { return "gbp_endpoint_dump" }
1247 func (*GbpEndpointDump) GetCrcString() string   { return "51077d14" }
1248 func (*GbpEndpointDump) GetMessageType() api.MessageType {
1249         return api.RequestMessage
1250 }
1251
1252 func (m *GbpEndpointDump) Size() (size int) {
1253         if m == nil {
1254                 return 0
1255         }
1256         return size
1257 }
1258 func (m *GbpEndpointDump) Marshal(b []byte) ([]byte, error) {
1259         if b == nil {
1260                 b = make([]byte, m.Size())
1261         }
1262         buf := codec.NewBuffer(b)
1263         return buf.Bytes(), nil
1264 }
1265 func (m *GbpEndpointDump) Unmarshal(b []byte) error {
1266         return nil
1267 }
1268
1269 // GbpEndpointGroupAdd defines message 'gbp_endpoint_group_add'.
1270 type GbpEndpointGroupAdd struct {
1271         Epg GbpEndpointGroup `binapi:"gbp_endpoint_group,name=epg" json:"epg,omitempty"`
1272 }
1273
1274 func (m *GbpEndpointGroupAdd) Reset()               { *m = GbpEndpointGroupAdd{} }
1275 func (*GbpEndpointGroupAdd) GetMessageName() string { return "gbp_endpoint_group_add" }
1276 func (*GbpEndpointGroupAdd) GetCrcString() string   { return "8e0f4054" }
1277 func (*GbpEndpointGroupAdd) GetMessageType() api.MessageType {
1278         return api.RequestMessage
1279 }
1280
1281 func (m *GbpEndpointGroupAdd) Size() (size int) {
1282         if m == nil {
1283                 return 0
1284         }
1285         size += 4 // m.Epg.Vnid
1286         size += 2 // m.Epg.Sclass
1287         size += 4 // m.Epg.BdID
1288         size += 4 // m.Epg.RdID
1289         size += 4 // m.Epg.UplinkSwIfIndex
1290         size += 4 // m.Epg.Retention.RemoteEpTimeout
1291         return size
1292 }
1293 func (m *GbpEndpointGroupAdd) Marshal(b []byte) ([]byte, error) {
1294         if b == nil {
1295                 b = make([]byte, m.Size())
1296         }
1297         buf := codec.NewBuffer(b)
1298         buf.EncodeUint32(m.Epg.Vnid)
1299         buf.EncodeUint16(m.Epg.Sclass)
1300         buf.EncodeUint32(m.Epg.BdID)
1301         buf.EncodeUint32(m.Epg.RdID)
1302         buf.EncodeUint32(uint32(m.Epg.UplinkSwIfIndex))
1303         buf.EncodeUint32(m.Epg.Retention.RemoteEpTimeout)
1304         return buf.Bytes(), nil
1305 }
1306 func (m *GbpEndpointGroupAdd) Unmarshal(b []byte) error {
1307         buf := codec.NewBuffer(b)
1308         m.Epg.Vnid = buf.DecodeUint32()
1309         m.Epg.Sclass = buf.DecodeUint16()
1310         m.Epg.BdID = buf.DecodeUint32()
1311         m.Epg.RdID = buf.DecodeUint32()
1312         m.Epg.UplinkSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1313         m.Epg.Retention.RemoteEpTimeout = buf.DecodeUint32()
1314         return nil
1315 }
1316
1317 // GbpEndpointGroupAddReply defines message 'gbp_endpoint_group_add_reply'.
1318 type GbpEndpointGroupAddReply struct {
1319         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1320 }
1321
1322 func (m *GbpEndpointGroupAddReply) Reset()               { *m = GbpEndpointGroupAddReply{} }
1323 func (*GbpEndpointGroupAddReply) GetMessageName() string { return "gbp_endpoint_group_add_reply" }
1324 func (*GbpEndpointGroupAddReply) GetCrcString() string   { return "e8d4e804" }
1325 func (*GbpEndpointGroupAddReply) GetMessageType() api.MessageType {
1326         return api.ReplyMessage
1327 }
1328
1329 func (m *GbpEndpointGroupAddReply) Size() (size int) {
1330         if m == nil {
1331                 return 0
1332         }
1333         size += 4 // m.Retval
1334         return size
1335 }
1336 func (m *GbpEndpointGroupAddReply) Marshal(b []byte) ([]byte, error) {
1337         if b == nil {
1338                 b = make([]byte, m.Size())
1339         }
1340         buf := codec.NewBuffer(b)
1341         buf.EncodeInt32(m.Retval)
1342         return buf.Bytes(), nil
1343 }
1344 func (m *GbpEndpointGroupAddReply) Unmarshal(b []byte) error {
1345         buf := codec.NewBuffer(b)
1346         m.Retval = buf.DecodeInt32()
1347         return nil
1348 }
1349
1350 // GbpEndpointGroupDel defines message 'gbp_endpoint_group_del'.
1351 type GbpEndpointGroupDel struct {
1352         Sclass uint16 `binapi:"u16,name=sclass" json:"sclass,omitempty"`
1353 }
1354
1355 func (m *GbpEndpointGroupDel) Reset()               { *m = GbpEndpointGroupDel{} }
1356 func (*GbpEndpointGroupDel) GetMessageName() string { return "gbp_endpoint_group_del" }
1357 func (*GbpEndpointGroupDel) GetCrcString() string   { return "3436b8b7" }
1358 func (*GbpEndpointGroupDel) GetMessageType() api.MessageType {
1359         return api.RequestMessage
1360 }
1361
1362 func (m *GbpEndpointGroupDel) Size() (size int) {
1363         if m == nil {
1364                 return 0
1365         }
1366         size += 2 // m.Sclass
1367         return size
1368 }
1369 func (m *GbpEndpointGroupDel) Marshal(b []byte) ([]byte, error) {
1370         if b == nil {
1371                 b = make([]byte, m.Size())
1372         }
1373         buf := codec.NewBuffer(b)
1374         buf.EncodeUint16(m.Sclass)
1375         return buf.Bytes(), nil
1376 }
1377 func (m *GbpEndpointGroupDel) Unmarshal(b []byte) error {
1378         buf := codec.NewBuffer(b)
1379         m.Sclass = buf.DecodeUint16()
1380         return nil
1381 }
1382
1383 // GbpEndpointGroupDelReply defines message 'gbp_endpoint_group_del_reply'.
1384 type GbpEndpointGroupDelReply struct {
1385         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1386 }
1387
1388 func (m *GbpEndpointGroupDelReply) Reset()               { *m = GbpEndpointGroupDelReply{} }
1389 func (*GbpEndpointGroupDelReply) GetMessageName() string { return "gbp_endpoint_group_del_reply" }
1390 func (*GbpEndpointGroupDelReply) GetCrcString() string   { return "e8d4e804" }
1391 func (*GbpEndpointGroupDelReply) GetMessageType() api.MessageType {
1392         return api.ReplyMessage
1393 }
1394
1395 func (m *GbpEndpointGroupDelReply) Size() (size int) {
1396         if m == nil {
1397                 return 0
1398         }
1399         size += 4 // m.Retval
1400         return size
1401 }
1402 func (m *GbpEndpointGroupDelReply) Marshal(b []byte) ([]byte, error) {
1403         if b == nil {
1404                 b = make([]byte, m.Size())
1405         }
1406         buf := codec.NewBuffer(b)
1407         buf.EncodeInt32(m.Retval)
1408         return buf.Bytes(), nil
1409 }
1410 func (m *GbpEndpointGroupDelReply) Unmarshal(b []byte) error {
1411         buf := codec.NewBuffer(b)
1412         m.Retval = buf.DecodeInt32()
1413         return nil
1414 }
1415
1416 // GbpEndpointGroupDetails defines message 'gbp_endpoint_group_details'.
1417 type GbpEndpointGroupDetails struct {
1418         Epg GbpEndpointGroup `binapi:"gbp_endpoint_group,name=epg" json:"epg,omitempty"`
1419 }
1420
1421 func (m *GbpEndpointGroupDetails) Reset()               { *m = GbpEndpointGroupDetails{} }
1422 func (*GbpEndpointGroupDetails) GetMessageName() string { return "gbp_endpoint_group_details" }
1423 func (*GbpEndpointGroupDetails) GetCrcString() string   { return "8f38292c" }
1424 func (*GbpEndpointGroupDetails) GetMessageType() api.MessageType {
1425         return api.ReplyMessage
1426 }
1427
1428 func (m *GbpEndpointGroupDetails) Size() (size int) {
1429         if m == nil {
1430                 return 0
1431         }
1432         size += 4 // m.Epg.Vnid
1433         size += 2 // m.Epg.Sclass
1434         size += 4 // m.Epg.BdID
1435         size += 4 // m.Epg.RdID
1436         size += 4 // m.Epg.UplinkSwIfIndex
1437         size += 4 // m.Epg.Retention.RemoteEpTimeout
1438         return size
1439 }
1440 func (m *GbpEndpointGroupDetails) Marshal(b []byte) ([]byte, error) {
1441         if b == nil {
1442                 b = make([]byte, m.Size())
1443         }
1444         buf := codec.NewBuffer(b)
1445         buf.EncodeUint32(m.Epg.Vnid)
1446         buf.EncodeUint16(m.Epg.Sclass)
1447         buf.EncodeUint32(m.Epg.BdID)
1448         buf.EncodeUint32(m.Epg.RdID)
1449         buf.EncodeUint32(uint32(m.Epg.UplinkSwIfIndex))
1450         buf.EncodeUint32(m.Epg.Retention.RemoteEpTimeout)
1451         return buf.Bytes(), nil
1452 }
1453 func (m *GbpEndpointGroupDetails) Unmarshal(b []byte) error {
1454         buf := codec.NewBuffer(b)
1455         m.Epg.Vnid = buf.DecodeUint32()
1456         m.Epg.Sclass = buf.DecodeUint16()
1457         m.Epg.BdID = buf.DecodeUint32()
1458         m.Epg.RdID = buf.DecodeUint32()
1459         m.Epg.UplinkSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1460         m.Epg.Retention.RemoteEpTimeout = buf.DecodeUint32()
1461         return nil
1462 }
1463
1464 // GbpEndpointGroupDump defines message 'gbp_endpoint_group_dump'.
1465 type GbpEndpointGroupDump struct{}
1466
1467 func (m *GbpEndpointGroupDump) Reset()               { *m = GbpEndpointGroupDump{} }
1468 func (*GbpEndpointGroupDump) GetMessageName() string { return "gbp_endpoint_group_dump" }
1469 func (*GbpEndpointGroupDump) GetCrcString() string   { return "51077d14" }
1470 func (*GbpEndpointGroupDump) GetMessageType() api.MessageType {
1471         return api.RequestMessage
1472 }
1473
1474 func (m *GbpEndpointGroupDump) Size() (size int) {
1475         if m == nil {
1476                 return 0
1477         }
1478         return size
1479 }
1480 func (m *GbpEndpointGroupDump) Marshal(b []byte) ([]byte, error) {
1481         if b == nil {
1482                 b = make([]byte, m.Size())
1483         }
1484         buf := codec.NewBuffer(b)
1485         return buf.Bytes(), nil
1486 }
1487 func (m *GbpEndpointGroupDump) Unmarshal(b []byte) error {
1488         return nil
1489 }
1490
1491 // GbpExtItfAddDel defines message 'gbp_ext_itf_add_del'.
1492 type GbpExtItfAddDel struct {
1493         IsAdd  bool      `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1494         ExtItf GbpExtItf `binapi:"gbp_ext_itf,name=ext_itf" json:"ext_itf,omitempty"`
1495 }
1496
1497 func (m *GbpExtItfAddDel) Reset()               { *m = GbpExtItfAddDel{} }
1498 func (*GbpExtItfAddDel) GetMessageName() string { return "gbp_ext_itf_add_del" }
1499 func (*GbpExtItfAddDel) GetCrcString() string   { return "12ed5700" }
1500 func (*GbpExtItfAddDel) GetMessageType() api.MessageType {
1501         return api.RequestMessage
1502 }
1503
1504 func (m *GbpExtItfAddDel) Size() (size int) {
1505         if m == nil {
1506                 return 0
1507         }
1508         size += 1 // m.IsAdd
1509         size += 4 // m.ExtItf.SwIfIndex
1510         size += 4 // m.ExtItf.BdID
1511         size += 4 // m.ExtItf.RdID
1512         size += 4 // m.ExtItf.Flags
1513         return size
1514 }
1515 func (m *GbpExtItfAddDel) Marshal(b []byte) ([]byte, error) {
1516         if b == nil {
1517                 b = make([]byte, m.Size())
1518         }
1519         buf := codec.NewBuffer(b)
1520         buf.EncodeBool(m.IsAdd)
1521         buf.EncodeUint32(uint32(m.ExtItf.SwIfIndex))
1522         buf.EncodeUint32(m.ExtItf.BdID)
1523         buf.EncodeUint32(m.ExtItf.RdID)
1524         buf.EncodeUint32(uint32(m.ExtItf.Flags))
1525         return buf.Bytes(), nil
1526 }
1527 func (m *GbpExtItfAddDel) Unmarshal(b []byte) error {
1528         buf := codec.NewBuffer(b)
1529         m.IsAdd = buf.DecodeBool()
1530         m.ExtItf.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1531         m.ExtItf.BdID = buf.DecodeUint32()
1532         m.ExtItf.RdID = buf.DecodeUint32()
1533         m.ExtItf.Flags = GbpExtItfFlags(buf.DecodeUint32())
1534         return nil
1535 }
1536
1537 // GbpExtItfAddDelReply defines message 'gbp_ext_itf_add_del_reply'.
1538 type GbpExtItfAddDelReply struct {
1539         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1540 }
1541
1542 func (m *GbpExtItfAddDelReply) Reset()               { *m = GbpExtItfAddDelReply{} }
1543 func (*GbpExtItfAddDelReply) GetMessageName() string { return "gbp_ext_itf_add_del_reply" }
1544 func (*GbpExtItfAddDelReply) GetCrcString() string   { return "e8d4e804" }
1545 func (*GbpExtItfAddDelReply) GetMessageType() api.MessageType {
1546         return api.ReplyMessage
1547 }
1548
1549 func (m *GbpExtItfAddDelReply) Size() (size int) {
1550         if m == nil {
1551                 return 0
1552         }
1553         size += 4 // m.Retval
1554         return size
1555 }
1556 func (m *GbpExtItfAddDelReply) Marshal(b []byte) ([]byte, error) {
1557         if b == nil {
1558                 b = make([]byte, m.Size())
1559         }
1560         buf := codec.NewBuffer(b)
1561         buf.EncodeInt32(m.Retval)
1562         return buf.Bytes(), nil
1563 }
1564 func (m *GbpExtItfAddDelReply) Unmarshal(b []byte) error {
1565         buf := codec.NewBuffer(b)
1566         m.Retval = buf.DecodeInt32()
1567         return nil
1568 }
1569
1570 // GbpExtItfDetails defines message 'gbp_ext_itf_details'.
1571 type GbpExtItfDetails struct {
1572         ExtItf GbpExtItf `binapi:"gbp_ext_itf,name=ext_itf" json:"ext_itf,omitempty"`
1573 }
1574
1575 func (m *GbpExtItfDetails) Reset()               { *m = GbpExtItfDetails{} }
1576 func (*GbpExtItfDetails) GetMessageName() string { return "gbp_ext_itf_details" }
1577 func (*GbpExtItfDetails) GetCrcString() string   { return "408a45c0" }
1578 func (*GbpExtItfDetails) GetMessageType() api.MessageType {
1579         return api.ReplyMessage
1580 }
1581
1582 func (m *GbpExtItfDetails) Size() (size int) {
1583         if m == nil {
1584                 return 0
1585         }
1586         size += 4 // m.ExtItf.SwIfIndex
1587         size += 4 // m.ExtItf.BdID
1588         size += 4 // m.ExtItf.RdID
1589         size += 4 // m.ExtItf.Flags
1590         return size
1591 }
1592 func (m *GbpExtItfDetails) Marshal(b []byte) ([]byte, error) {
1593         if b == nil {
1594                 b = make([]byte, m.Size())
1595         }
1596         buf := codec.NewBuffer(b)
1597         buf.EncodeUint32(uint32(m.ExtItf.SwIfIndex))
1598         buf.EncodeUint32(m.ExtItf.BdID)
1599         buf.EncodeUint32(m.ExtItf.RdID)
1600         buf.EncodeUint32(uint32(m.ExtItf.Flags))
1601         return buf.Bytes(), nil
1602 }
1603 func (m *GbpExtItfDetails) Unmarshal(b []byte) error {
1604         buf := codec.NewBuffer(b)
1605         m.ExtItf.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1606         m.ExtItf.BdID = buf.DecodeUint32()
1607         m.ExtItf.RdID = buf.DecodeUint32()
1608         m.ExtItf.Flags = GbpExtItfFlags(buf.DecodeUint32())
1609         return nil
1610 }
1611
1612 // GbpExtItfDump defines message 'gbp_ext_itf_dump'.
1613 type GbpExtItfDump struct{}
1614
1615 func (m *GbpExtItfDump) Reset()               { *m = GbpExtItfDump{} }
1616 func (*GbpExtItfDump) GetMessageName() string { return "gbp_ext_itf_dump" }
1617 func (*GbpExtItfDump) GetCrcString() string   { return "51077d14" }
1618 func (*GbpExtItfDump) GetMessageType() api.MessageType {
1619         return api.RequestMessage
1620 }
1621
1622 func (m *GbpExtItfDump) Size() (size int) {
1623         if m == nil {
1624                 return 0
1625         }
1626         return size
1627 }
1628 func (m *GbpExtItfDump) Marshal(b []byte) ([]byte, error) {
1629         if b == nil {
1630                 b = make([]byte, m.Size())
1631         }
1632         buf := codec.NewBuffer(b)
1633         return buf.Bytes(), nil
1634 }
1635 func (m *GbpExtItfDump) Unmarshal(b []byte) error {
1636         return nil
1637 }
1638
1639 // GbpRecircAddDel defines message 'gbp_recirc_add_del'.
1640 type GbpRecircAddDel struct {
1641         IsAdd  bool      `binapi:"bool,name=is_add" json:"is_add,omitempty"`
1642         Recirc GbpRecirc `binapi:"gbp_recirc,name=recirc" json:"recirc,omitempty"`
1643 }
1644
1645 func (m *GbpRecircAddDel) Reset()               { *m = GbpRecircAddDel{} }
1646 func (*GbpRecircAddDel) GetMessageName() string { return "gbp_recirc_add_del" }
1647 func (*GbpRecircAddDel) GetCrcString() string   { return "718c69c3" }
1648 func (*GbpRecircAddDel) GetMessageType() api.MessageType {
1649         return api.RequestMessage
1650 }
1651
1652 func (m *GbpRecircAddDel) Size() (size int) {
1653         if m == nil {
1654                 return 0
1655         }
1656         size += 1 // m.IsAdd
1657         size += 4 // m.Recirc.SwIfIndex
1658         size += 2 // m.Recirc.Sclass
1659         size += 1 // m.Recirc.IsExt
1660         return size
1661 }
1662 func (m *GbpRecircAddDel) Marshal(b []byte) ([]byte, error) {
1663         if b == nil {
1664                 b = make([]byte, m.Size())
1665         }
1666         buf := codec.NewBuffer(b)
1667         buf.EncodeBool(m.IsAdd)
1668         buf.EncodeUint32(uint32(m.Recirc.SwIfIndex))
1669         buf.EncodeUint16(m.Recirc.Sclass)
1670         buf.EncodeBool(m.Recirc.IsExt)
1671         return buf.Bytes(), nil
1672 }
1673 func (m *GbpRecircAddDel) Unmarshal(b []byte) error {
1674         buf := codec.NewBuffer(b)
1675         m.IsAdd = buf.DecodeBool()
1676         m.Recirc.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1677         m.Recirc.Sclass = buf.DecodeUint16()
1678         m.Recirc.IsExt = buf.DecodeBool()
1679         return nil
1680 }
1681
1682 // GbpRecircAddDelReply defines message 'gbp_recirc_add_del_reply'.
1683 type GbpRecircAddDelReply struct {
1684         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1685 }
1686
1687 func (m *GbpRecircAddDelReply) Reset()               { *m = GbpRecircAddDelReply{} }
1688 func (*GbpRecircAddDelReply) GetMessageName() string { return "gbp_recirc_add_del_reply" }
1689 func (*GbpRecircAddDelReply) GetCrcString() string   { return "e8d4e804" }
1690 func (*GbpRecircAddDelReply) GetMessageType() api.MessageType {
1691         return api.ReplyMessage
1692 }
1693
1694 func (m *GbpRecircAddDelReply) Size() (size int) {
1695         if m == nil {
1696                 return 0
1697         }
1698         size += 4 // m.Retval
1699         return size
1700 }
1701 func (m *GbpRecircAddDelReply) Marshal(b []byte) ([]byte, error) {
1702         if b == nil {
1703                 b = make([]byte, m.Size())
1704         }
1705         buf := codec.NewBuffer(b)
1706         buf.EncodeInt32(m.Retval)
1707         return buf.Bytes(), nil
1708 }
1709 func (m *GbpRecircAddDelReply) Unmarshal(b []byte) error {
1710         buf := codec.NewBuffer(b)
1711         m.Retval = buf.DecodeInt32()
1712         return nil
1713 }
1714
1715 // GbpRecircDetails defines message 'gbp_recirc_details'.
1716 type GbpRecircDetails struct {
1717         Recirc GbpRecirc `binapi:"gbp_recirc,name=recirc" json:"recirc,omitempty"`
1718 }
1719
1720 func (m *GbpRecircDetails) Reset()               { *m = GbpRecircDetails{} }
1721 func (*GbpRecircDetails) GetMessageName() string { return "gbp_recirc_details" }
1722 func (*GbpRecircDetails) GetCrcString() string   { return "66ecc42e" }
1723 func (*GbpRecircDetails) GetMessageType() api.MessageType {
1724         return api.ReplyMessage
1725 }
1726
1727 func (m *GbpRecircDetails) Size() (size int) {
1728         if m == nil {
1729                 return 0
1730         }
1731         size += 4 // m.Recirc.SwIfIndex
1732         size += 2 // m.Recirc.Sclass
1733         size += 1 // m.Recirc.IsExt
1734         return size
1735 }
1736 func (m *GbpRecircDetails) Marshal(b []byte) ([]byte, error) {
1737         if b == nil {
1738                 b = make([]byte, m.Size())
1739         }
1740         buf := codec.NewBuffer(b)
1741         buf.EncodeUint32(uint32(m.Recirc.SwIfIndex))
1742         buf.EncodeUint16(m.Recirc.Sclass)
1743         buf.EncodeBool(m.Recirc.IsExt)
1744         return buf.Bytes(), nil
1745 }
1746 func (m *GbpRecircDetails) Unmarshal(b []byte) error {
1747         buf := codec.NewBuffer(b)
1748         m.Recirc.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1749         m.Recirc.Sclass = buf.DecodeUint16()
1750         m.Recirc.IsExt = buf.DecodeBool()
1751         return nil
1752 }
1753
1754 // GbpRecircDump defines message 'gbp_recirc_dump'.
1755 type GbpRecircDump struct{}
1756
1757 func (m *GbpRecircDump) Reset()               { *m = GbpRecircDump{} }
1758 func (*GbpRecircDump) GetMessageName() string { return "gbp_recirc_dump" }
1759 func (*GbpRecircDump) GetCrcString() string   { return "51077d14" }
1760 func (*GbpRecircDump) GetMessageType() api.MessageType {
1761         return api.RequestMessage
1762 }
1763
1764 func (m *GbpRecircDump) Size() (size int) {
1765         if m == nil {
1766                 return 0
1767         }
1768         return size
1769 }
1770 func (m *GbpRecircDump) Marshal(b []byte) ([]byte, error) {
1771         if b == nil {
1772                 b = make([]byte, m.Size())
1773         }
1774         buf := codec.NewBuffer(b)
1775         return buf.Bytes(), nil
1776 }
1777 func (m *GbpRecircDump) Unmarshal(b []byte) error {
1778         return nil
1779 }
1780
1781 // GbpRouteDomainAdd defines message 'gbp_route_domain_add'.
1782 type GbpRouteDomainAdd struct {
1783         Rd GbpRouteDomain `binapi:"gbp_route_domain,name=rd" json:"rd,omitempty"`
1784 }
1785
1786 func (m *GbpRouteDomainAdd) Reset()               { *m = GbpRouteDomainAdd{} }
1787 func (*GbpRouteDomainAdd) GetMessageName() string { return "gbp_route_domain_add" }
1788 func (*GbpRouteDomainAdd) GetCrcString() string   { return "2d0afe38" }
1789 func (*GbpRouteDomainAdd) GetMessageType() api.MessageType {
1790         return api.RequestMessage
1791 }
1792
1793 func (m *GbpRouteDomainAdd) Size() (size int) {
1794         if m == nil {
1795                 return 0
1796         }
1797         size += 4 // m.Rd.RdID
1798         size += 4 // m.Rd.IP4TableID
1799         size += 4 // m.Rd.IP6TableID
1800         size += 4 // m.Rd.IP4UuSwIfIndex
1801         size += 4 // m.Rd.IP6UuSwIfIndex
1802         size += 2 // m.Rd.Scope
1803         return size
1804 }
1805 func (m *GbpRouteDomainAdd) Marshal(b []byte) ([]byte, error) {
1806         if b == nil {
1807                 b = make([]byte, m.Size())
1808         }
1809         buf := codec.NewBuffer(b)
1810         buf.EncodeUint32(m.Rd.RdID)
1811         buf.EncodeUint32(m.Rd.IP4TableID)
1812         buf.EncodeUint32(m.Rd.IP6TableID)
1813         buf.EncodeUint32(uint32(m.Rd.IP4UuSwIfIndex))
1814         buf.EncodeUint32(uint32(m.Rd.IP6UuSwIfIndex))
1815         buf.EncodeUint16(uint16(m.Rd.Scope))
1816         return buf.Bytes(), nil
1817 }
1818 func (m *GbpRouteDomainAdd) Unmarshal(b []byte) error {
1819         buf := codec.NewBuffer(b)
1820         m.Rd.RdID = buf.DecodeUint32()
1821         m.Rd.IP4TableID = buf.DecodeUint32()
1822         m.Rd.IP6TableID = buf.DecodeUint32()
1823         m.Rd.IP4UuSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1824         m.Rd.IP6UuSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1825         m.Rd.Scope = GbpScope(buf.DecodeUint16())
1826         return nil
1827 }
1828
1829 // GbpRouteDomainAddReply defines message 'gbp_route_domain_add_reply'.
1830 type GbpRouteDomainAddReply struct {
1831         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1832 }
1833
1834 func (m *GbpRouteDomainAddReply) Reset()               { *m = GbpRouteDomainAddReply{} }
1835 func (*GbpRouteDomainAddReply) GetMessageName() string { return "gbp_route_domain_add_reply" }
1836 func (*GbpRouteDomainAddReply) GetCrcString() string   { return "e8d4e804" }
1837 func (*GbpRouteDomainAddReply) GetMessageType() api.MessageType {
1838         return api.ReplyMessage
1839 }
1840
1841 func (m *GbpRouteDomainAddReply) Size() (size int) {
1842         if m == nil {
1843                 return 0
1844         }
1845         size += 4 // m.Retval
1846         return size
1847 }
1848 func (m *GbpRouteDomainAddReply) Marshal(b []byte) ([]byte, error) {
1849         if b == nil {
1850                 b = make([]byte, m.Size())
1851         }
1852         buf := codec.NewBuffer(b)
1853         buf.EncodeInt32(m.Retval)
1854         return buf.Bytes(), nil
1855 }
1856 func (m *GbpRouteDomainAddReply) Unmarshal(b []byte) error {
1857         buf := codec.NewBuffer(b)
1858         m.Retval = buf.DecodeInt32()
1859         return nil
1860 }
1861
1862 // GbpRouteDomainDel defines message 'gbp_route_domain_del'.
1863 type GbpRouteDomainDel struct {
1864         RdID uint32 `binapi:"u32,name=rd_id" json:"rd_id,omitempty"`
1865 }
1866
1867 func (m *GbpRouteDomainDel) Reset()               { *m = GbpRouteDomainDel{} }
1868 func (*GbpRouteDomainDel) GetMessageName() string { return "gbp_route_domain_del" }
1869 func (*GbpRouteDomainDel) GetCrcString() string   { return "bee4edcd" }
1870 func (*GbpRouteDomainDel) GetMessageType() api.MessageType {
1871         return api.RequestMessage
1872 }
1873
1874 func (m *GbpRouteDomainDel) Size() (size int) {
1875         if m == nil {
1876                 return 0
1877         }
1878         size += 4 // m.RdID
1879         return size
1880 }
1881 func (m *GbpRouteDomainDel) Marshal(b []byte) ([]byte, error) {
1882         if b == nil {
1883                 b = make([]byte, m.Size())
1884         }
1885         buf := codec.NewBuffer(b)
1886         buf.EncodeUint32(m.RdID)
1887         return buf.Bytes(), nil
1888 }
1889 func (m *GbpRouteDomainDel) Unmarshal(b []byte) error {
1890         buf := codec.NewBuffer(b)
1891         m.RdID = buf.DecodeUint32()
1892         return nil
1893 }
1894
1895 // GbpRouteDomainDelReply defines message 'gbp_route_domain_del_reply'.
1896 type GbpRouteDomainDelReply struct {
1897         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1898 }
1899
1900 func (m *GbpRouteDomainDelReply) Reset()               { *m = GbpRouteDomainDelReply{} }
1901 func (*GbpRouteDomainDelReply) GetMessageName() string { return "gbp_route_domain_del_reply" }
1902 func (*GbpRouteDomainDelReply) GetCrcString() string   { return "e8d4e804" }
1903 func (*GbpRouteDomainDelReply) GetMessageType() api.MessageType {
1904         return api.ReplyMessage
1905 }
1906
1907 func (m *GbpRouteDomainDelReply) Size() (size int) {
1908         if m == nil {
1909                 return 0
1910         }
1911         size += 4 // m.Retval
1912         return size
1913 }
1914 func (m *GbpRouteDomainDelReply) Marshal(b []byte) ([]byte, error) {
1915         if b == nil {
1916                 b = make([]byte, m.Size())
1917         }
1918         buf := codec.NewBuffer(b)
1919         buf.EncodeInt32(m.Retval)
1920         return buf.Bytes(), nil
1921 }
1922 func (m *GbpRouteDomainDelReply) Unmarshal(b []byte) error {
1923         buf := codec.NewBuffer(b)
1924         m.Retval = buf.DecodeInt32()
1925         return nil
1926 }
1927
1928 // GbpRouteDomainDetails defines message 'gbp_route_domain_details'.
1929 type GbpRouteDomainDetails struct {
1930         Rd GbpRouteDomain `binapi:"gbp_route_domain,name=rd" json:"rd,omitempty"`
1931 }
1932
1933 func (m *GbpRouteDomainDetails) Reset()               { *m = GbpRouteDomainDetails{} }
1934 func (*GbpRouteDomainDetails) GetMessageName() string { return "gbp_route_domain_details" }
1935 func (*GbpRouteDomainDetails) GetCrcString() string   { return "8ab11375" }
1936 func (*GbpRouteDomainDetails) GetMessageType() api.MessageType {
1937         return api.ReplyMessage
1938 }
1939
1940 func (m *GbpRouteDomainDetails) Size() (size int) {
1941         if m == nil {
1942                 return 0
1943         }
1944         size += 4 // m.Rd.RdID
1945         size += 4 // m.Rd.IP4TableID
1946         size += 4 // m.Rd.IP6TableID
1947         size += 4 // m.Rd.IP4UuSwIfIndex
1948         size += 4 // m.Rd.IP6UuSwIfIndex
1949         size += 2 // m.Rd.Scope
1950         return size
1951 }
1952 func (m *GbpRouteDomainDetails) Marshal(b []byte) ([]byte, error) {
1953         if b == nil {
1954                 b = make([]byte, m.Size())
1955         }
1956         buf := codec.NewBuffer(b)
1957         buf.EncodeUint32(m.Rd.RdID)
1958         buf.EncodeUint32(m.Rd.IP4TableID)
1959         buf.EncodeUint32(m.Rd.IP6TableID)
1960         buf.EncodeUint32(uint32(m.Rd.IP4UuSwIfIndex))
1961         buf.EncodeUint32(uint32(m.Rd.IP6UuSwIfIndex))
1962         buf.EncodeUint16(uint16(m.Rd.Scope))
1963         return buf.Bytes(), nil
1964 }
1965 func (m *GbpRouteDomainDetails) Unmarshal(b []byte) error {
1966         buf := codec.NewBuffer(b)
1967         m.Rd.RdID = buf.DecodeUint32()
1968         m.Rd.IP4TableID = buf.DecodeUint32()
1969         m.Rd.IP6TableID = buf.DecodeUint32()
1970         m.Rd.IP4UuSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1971         m.Rd.IP6UuSwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1972         m.Rd.Scope = GbpScope(buf.DecodeUint16())
1973         return nil
1974 }
1975
1976 // GbpRouteDomainDump defines message 'gbp_route_domain_dump'.
1977 type GbpRouteDomainDump struct{}
1978
1979 func (m *GbpRouteDomainDump) Reset()               { *m = GbpRouteDomainDump{} }
1980 func (*GbpRouteDomainDump) GetMessageName() string { return "gbp_route_domain_dump" }
1981 func (*GbpRouteDomainDump) GetCrcString() string   { return "51077d14" }
1982 func (*GbpRouteDomainDump) GetMessageType() api.MessageType {
1983         return api.RequestMessage
1984 }
1985
1986 func (m *GbpRouteDomainDump) Size() (size int) {
1987         if m == nil {
1988                 return 0
1989         }
1990         return size
1991 }
1992 func (m *GbpRouteDomainDump) Marshal(b []byte) ([]byte, error) {
1993         if b == nil {
1994                 b = make([]byte, m.Size())
1995         }
1996         buf := codec.NewBuffer(b)
1997         return buf.Bytes(), nil
1998 }
1999 func (m *GbpRouteDomainDump) Unmarshal(b []byte) error {
2000         return nil
2001 }
2002
2003 // GbpRouteDomainDumpReply defines message 'gbp_route_domain_dump_reply'.
2004 type GbpRouteDomainDumpReply struct {
2005         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2006 }
2007
2008 func (m *GbpRouteDomainDumpReply) Reset()               { *m = GbpRouteDomainDumpReply{} }
2009 func (*GbpRouteDomainDumpReply) GetMessageName() string { return "gbp_route_domain_dump_reply" }
2010 func (*GbpRouteDomainDumpReply) GetCrcString() string   { return "e8d4e804" }
2011 func (*GbpRouteDomainDumpReply) GetMessageType() api.MessageType {
2012         return api.ReplyMessage
2013 }
2014
2015 func (m *GbpRouteDomainDumpReply) Size() (size int) {
2016         if m == nil {
2017                 return 0
2018         }
2019         size += 4 // m.Retval
2020         return size
2021 }
2022 func (m *GbpRouteDomainDumpReply) Marshal(b []byte) ([]byte, error) {
2023         if b == nil {
2024                 b = make([]byte, m.Size())
2025         }
2026         buf := codec.NewBuffer(b)
2027         buf.EncodeInt32(m.Retval)
2028         return buf.Bytes(), nil
2029 }
2030 func (m *GbpRouteDomainDumpReply) Unmarshal(b []byte) error {
2031         buf := codec.NewBuffer(b)
2032         m.Retval = buf.DecodeInt32()
2033         return nil
2034 }
2035
2036 // GbpSubnetAddDel defines message 'gbp_subnet_add_del'.
2037 type GbpSubnetAddDel struct {
2038         IsAdd  bool      `binapi:"bool,name=is_add" json:"is_add,omitempty"`
2039         Subnet GbpSubnet `binapi:"gbp_subnet,name=subnet" json:"subnet,omitempty"`
2040 }
2041
2042 func (m *GbpSubnetAddDel) Reset()               { *m = GbpSubnetAddDel{} }
2043 func (*GbpSubnetAddDel) GetMessageName() string { return "gbp_subnet_add_del" }
2044 func (*GbpSubnetAddDel) GetCrcString() string   { return "888aca35" }
2045 func (*GbpSubnetAddDel) GetMessageType() api.MessageType {
2046         return api.RequestMessage
2047 }
2048
2049 func (m *GbpSubnetAddDel) Size() (size int) {
2050         if m == nil {
2051                 return 0
2052         }
2053         size += 1      // m.IsAdd
2054         size += 4      // m.Subnet.RdID
2055         size += 4      // m.Subnet.SwIfIndex
2056         size += 2      // m.Subnet.Sclass
2057         size += 4      // m.Subnet.Type
2058         size += 1      // m.Subnet.Prefix.Address.Af
2059         size += 1 * 16 // m.Subnet.Prefix.Address.Un
2060         size += 1      // m.Subnet.Prefix.Len
2061         return size
2062 }
2063 func (m *GbpSubnetAddDel) Marshal(b []byte) ([]byte, error) {
2064         if b == nil {
2065                 b = make([]byte, m.Size())
2066         }
2067         buf := codec.NewBuffer(b)
2068         buf.EncodeBool(m.IsAdd)
2069         buf.EncodeUint32(m.Subnet.RdID)
2070         buf.EncodeUint32(uint32(m.Subnet.SwIfIndex))
2071         buf.EncodeUint16(m.Subnet.Sclass)
2072         buf.EncodeUint32(uint32(m.Subnet.Type))
2073         buf.EncodeUint8(uint8(m.Subnet.Prefix.Address.Af))
2074         buf.EncodeBytes(m.Subnet.Prefix.Address.Un.XXX_UnionData[:], 16)
2075         buf.EncodeUint8(m.Subnet.Prefix.Len)
2076         return buf.Bytes(), nil
2077 }
2078 func (m *GbpSubnetAddDel) Unmarshal(b []byte) error {
2079         buf := codec.NewBuffer(b)
2080         m.IsAdd = buf.DecodeBool()
2081         m.Subnet.RdID = buf.DecodeUint32()
2082         m.Subnet.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
2083         m.Subnet.Sclass = buf.DecodeUint16()
2084         m.Subnet.Type = GbpSubnetType(buf.DecodeUint32())
2085         m.Subnet.Prefix.Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
2086         copy(m.Subnet.Prefix.Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2087         m.Subnet.Prefix.Len = buf.DecodeUint8()
2088         return nil
2089 }
2090
2091 // GbpSubnetAddDelReply defines message 'gbp_subnet_add_del_reply'.
2092 type GbpSubnetAddDelReply struct {
2093         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2094 }
2095
2096 func (m *GbpSubnetAddDelReply) Reset()               { *m = GbpSubnetAddDelReply{} }
2097 func (*GbpSubnetAddDelReply) GetMessageName() string { return "gbp_subnet_add_del_reply" }
2098 func (*GbpSubnetAddDelReply) GetCrcString() string   { return "e8d4e804" }
2099 func (*GbpSubnetAddDelReply) GetMessageType() api.MessageType {
2100         return api.ReplyMessage
2101 }
2102
2103 func (m *GbpSubnetAddDelReply) Size() (size int) {
2104         if m == nil {
2105                 return 0
2106         }
2107         size += 4 // m.Retval
2108         return size
2109 }
2110 func (m *GbpSubnetAddDelReply) Marshal(b []byte) ([]byte, error) {
2111         if b == nil {
2112                 b = make([]byte, m.Size())
2113         }
2114         buf := codec.NewBuffer(b)
2115         buf.EncodeInt32(m.Retval)
2116         return buf.Bytes(), nil
2117 }
2118 func (m *GbpSubnetAddDelReply) Unmarshal(b []byte) error {
2119         buf := codec.NewBuffer(b)
2120         m.Retval = buf.DecodeInt32()
2121         return nil
2122 }
2123
2124 // GbpSubnetDetails defines message 'gbp_subnet_details'.
2125 type GbpSubnetDetails struct {
2126         Subnet GbpSubnet `binapi:"gbp_subnet,name=subnet" json:"subnet,omitempty"`
2127 }
2128
2129 func (m *GbpSubnetDetails) Reset()               { *m = GbpSubnetDetails{} }
2130 func (*GbpSubnetDetails) GetMessageName() string { return "gbp_subnet_details" }
2131 func (*GbpSubnetDetails) GetCrcString() string   { return "4ed84156" }
2132 func (*GbpSubnetDetails) GetMessageType() api.MessageType {
2133         return api.ReplyMessage
2134 }
2135
2136 func (m *GbpSubnetDetails) Size() (size int) {
2137         if m == nil {
2138                 return 0
2139         }
2140         size += 4      // m.Subnet.RdID
2141         size += 4      // m.Subnet.SwIfIndex
2142         size += 2      // m.Subnet.Sclass
2143         size += 4      // m.Subnet.Type
2144         size += 1      // m.Subnet.Prefix.Address.Af
2145         size += 1 * 16 // m.Subnet.Prefix.Address.Un
2146         size += 1      // m.Subnet.Prefix.Len
2147         return size
2148 }
2149 func (m *GbpSubnetDetails) Marshal(b []byte) ([]byte, error) {
2150         if b == nil {
2151                 b = make([]byte, m.Size())
2152         }
2153         buf := codec.NewBuffer(b)
2154         buf.EncodeUint32(m.Subnet.RdID)
2155         buf.EncodeUint32(uint32(m.Subnet.SwIfIndex))
2156         buf.EncodeUint16(m.Subnet.Sclass)
2157         buf.EncodeUint32(uint32(m.Subnet.Type))
2158         buf.EncodeUint8(uint8(m.Subnet.Prefix.Address.Af))
2159         buf.EncodeBytes(m.Subnet.Prefix.Address.Un.XXX_UnionData[:], 16)
2160         buf.EncodeUint8(m.Subnet.Prefix.Len)
2161         return buf.Bytes(), nil
2162 }
2163 func (m *GbpSubnetDetails) Unmarshal(b []byte) error {
2164         buf := codec.NewBuffer(b)
2165         m.Subnet.RdID = buf.DecodeUint32()
2166         m.Subnet.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
2167         m.Subnet.Sclass = buf.DecodeUint16()
2168         m.Subnet.Type = GbpSubnetType(buf.DecodeUint32())
2169         m.Subnet.Prefix.Address.Af = ip_types.AddressFamily(buf.DecodeUint8())
2170         copy(m.Subnet.Prefix.Address.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2171         m.Subnet.Prefix.Len = buf.DecodeUint8()
2172         return nil
2173 }
2174
2175 // GbpSubnetDump defines message 'gbp_subnet_dump'.
2176 type GbpSubnetDump struct{}
2177
2178 func (m *GbpSubnetDump) Reset()               { *m = GbpSubnetDump{} }
2179 func (*GbpSubnetDump) GetMessageName() string { return "gbp_subnet_dump" }
2180 func (*GbpSubnetDump) GetCrcString() string   { return "51077d14" }
2181 func (*GbpSubnetDump) GetMessageType() api.MessageType {
2182         return api.RequestMessage
2183 }
2184
2185 func (m *GbpSubnetDump) Size() (size int) {
2186         if m == nil {
2187                 return 0
2188         }
2189         return size
2190 }
2191 func (m *GbpSubnetDump) Marshal(b []byte) ([]byte, error) {
2192         if b == nil {
2193                 b = make([]byte, m.Size())
2194         }
2195         buf := codec.NewBuffer(b)
2196         return buf.Bytes(), nil
2197 }
2198 func (m *GbpSubnetDump) Unmarshal(b []byte) error {
2199         return nil
2200 }
2201
2202 // GbpVxlanTunnelAdd defines message 'gbp_vxlan_tunnel_add'.
2203 type GbpVxlanTunnelAdd struct {
2204         Tunnel GbpVxlanTunnel `binapi:"gbp_vxlan_tunnel,name=tunnel" json:"tunnel,omitempty"`
2205 }
2206
2207 func (m *GbpVxlanTunnelAdd) Reset()               { *m = GbpVxlanTunnelAdd{} }
2208 func (*GbpVxlanTunnelAdd) GetMessageName() string { return "gbp_vxlan_tunnel_add" }
2209 func (*GbpVxlanTunnelAdd) GetCrcString() string   { return "3e070b35" }
2210 func (*GbpVxlanTunnelAdd) GetMessageType() api.MessageType {
2211         return api.RequestMessage
2212 }
2213
2214 func (m *GbpVxlanTunnelAdd) Size() (size int) {
2215         if m == nil {
2216                 return 0
2217         }
2218         size += 4     // m.Tunnel.Vni
2219         size += 4     // m.Tunnel.Mode
2220         size += 4     // m.Tunnel.BdRdID
2221         size += 1 * 4 // m.Tunnel.Src
2222         return size
2223 }
2224 func (m *GbpVxlanTunnelAdd) Marshal(b []byte) ([]byte, error) {
2225         if b == nil {
2226                 b = make([]byte, m.Size())
2227         }
2228         buf := codec.NewBuffer(b)
2229         buf.EncodeUint32(m.Tunnel.Vni)
2230         buf.EncodeUint32(uint32(m.Tunnel.Mode))
2231         buf.EncodeUint32(m.Tunnel.BdRdID)
2232         buf.EncodeBytes(m.Tunnel.Src[:], 4)
2233         return buf.Bytes(), nil
2234 }
2235 func (m *GbpVxlanTunnelAdd) Unmarshal(b []byte) error {
2236         buf := codec.NewBuffer(b)
2237         m.Tunnel.Vni = buf.DecodeUint32()
2238         m.Tunnel.Mode = GbpVxlanTunnelMode(buf.DecodeUint32())
2239         m.Tunnel.BdRdID = buf.DecodeUint32()
2240         copy(m.Tunnel.Src[:], buf.DecodeBytes(4))
2241         return nil
2242 }
2243
2244 // GbpVxlanTunnelAddReply defines message 'gbp_vxlan_tunnel_add_reply'.
2245 type GbpVxlanTunnelAddReply struct {
2246         Retval    int32                          `binapi:"i32,name=retval" json:"retval,omitempty"`
2247         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
2248 }
2249
2250 func (m *GbpVxlanTunnelAddReply) Reset()               { *m = GbpVxlanTunnelAddReply{} }
2251 func (*GbpVxlanTunnelAddReply) GetMessageName() string { return "gbp_vxlan_tunnel_add_reply" }
2252 func (*GbpVxlanTunnelAddReply) GetCrcString() string   { return "5383d31f" }
2253 func (*GbpVxlanTunnelAddReply) GetMessageType() api.MessageType {
2254         return api.ReplyMessage
2255 }
2256
2257 func (m *GbpVxlanTunnelAddReply) Size() (size int) {
2258         if m == nil {
2259                 return 0
2260         }
2261         size += 4 // m.Retval
2262         size += 4 // m.SwIfIndex
2263         return size
2264 }
2265 func (m *GbpVxlanTunnelAddReply) Marshal(b []byte) ([]byte, error) {
2266         if b == nil {
2267                 b = make([]byte, m.Size())
2268         }
2269         buf := codec.NewBuffer(b)
2270         buf.EncodeInt32(m.Retval)
2271         buf.EncodeUint32(uint32(m.SwIfIndex))
2272         return buf.Bytes(), nil
2273 }
2274 func (m *GbpVxlanTunnelAddReply) Unmarshal(b []byte) error {
2275         buf := codec.NewBuffer(b)
2276         m.Retval = buf.DecodeInt32()
2277         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
2278         return nil
2279 }
2280
2281 // GbpVxlanTunnelDel defines message 'gbp_vxlan_tunnel_del'.
2282 type GbpVxlanTunnelDel struct {
2283         Vni uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
2284 }
2285
2286 func (m *GbpVxlanTunnelDel) Reset()               { *m = GbpVxlanTunnelDel{} }
2287 func (*GbpVxlanTunnelDel) GetMessageName() string { return "gbp_vxlan_tunnel_del" }
2288 func (*GbpVxlanTunnelDel) GetCrcString() string   { return "8d1f2fe9" }
2289 func (*GbpVxlanTunnelDel) GetMessageType() api.MessageType {
2290         return api.RequestMessage
2291 }
2292
2293 func (m *GbpVxlanTunnelDel) Size() (size int) {
2294         if m == nil {
2295                 return 0
2296         }
2297         size += 4 // m.Vni
2298         return size
2299 }
2300 func (m *GbpVxlanTunnelDel) Marshal(b []byte) ([]byte, error) {
2301         if b == nil {
2302                 b = make([]byte, m.Size())
2303         }
2304         buf := codec.NewBuffer(b)
2305         buf.EncodeUint32(m.Vni)
2306         return buf.Bytes(), nil
2307 }
2308 func (m *GbpVxlanTunnelDel) Unmarshal(b []byte) error {
2309         buf := codec.NewBuffer(b)
2310         m.Vni = buf.DecodeUint32()
2311         return nil
2312 }
2313
2314 // GbpVxlanTunnelDelReply defines message 'gbp_vxlan_tunnel_del_reply'.
2315 type GbpVxlanTunnelDelReply struct {
2316         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2317 }
2318
2319 func (m *GbpVxlanTunnelDelReply) Reset()               { *m = GbpVxlanTunnelDelReply{} }
2320 func (*GbpVxlanTunnelDelReply) GetMessageName() string { return "gbp_vxlan_tunnel_del_reply" }
2321 func (*GbpVxlanTunnelDelReply) GetCrcString() string   { return "e8d4e804" }
2322 func (*GbpVxlanTunnelDelReply) GetMessageType() api.MessageType {
2323         return api.ReplyMessage
2324 }
2325
2326 func (m *GbpVxlanTunnelDelReply) Size() (size int) {
2327         if m == nil {
2328                 return 0
2329         }
2330         size += 4 // m.Retval
2331         return size
2332 }
2333 func (m *GbpVxlanTunnelDelReply) Marshal(b []byte) ([]byte, error) {
2334         if b == nil {
2335                 b = make([]byte, m.Size())
2336         }
2337         buf := codec.NewBuffer(b)
2338         buf.EncodeInt32(m.Retval)
2339         return buf.Bytes(), nil
2340 }
2341 func (m *GbpVxlanTunnelDelReply) Unmarshal(b []byte) error {
2342         buf := codec.NewBuffer(b)
2343         m.Retval = buf.DecodeInt32()
2344         return nil
2345 }
2346
2347 // GbpVxlanTunnelDetails defines message 'gbp_vxlan_tunnel_details'.
2348 type GbpVxlanTunnelDetails struct {
2349         Tunnel GbpVxlanTunnel `binapi:"gbp_vxlan_tunnel,name=tunnel" json:"tunnel,omitempty"`
2350 }
2351
2352 func (m *GbpVxlanTunnelDetails) Reset()               { *m = GbpVxlanTunnelDetails{} }
2353 func (*GbpVxlanTunnelDetails) GetMessageName() string { return "gbp_vxlan_tunnel_details" }
2354 func (*GbpVxlanTunnelDetails) GetCrcString() string   { return "65c6c818" }
2355 func (*GbpVxlanTunnelDetails) GetMessageType() api.MessageType {
2356         return api.ReplyMessage
2357 }
2358
2359 func (m *GbpVxlanTunnelDetails) Size() (size int) {
2360         if m == nil {
2361                 return 0
2362         }
2363         size += 4     // m.Tunnel.Vni
2364         size += 4     // m.Tunnel.Mode
2365         size += 4     // m.Tunnel.BdRdID
2366         size += 1 * 4 // m.Tunnel.Src
2367         return size
2368 }
2369 func (m *GbpVxlanTunnelDetails) Marshal(b []byte) ([]byte, error) {
2370         if b == nil {
2371                 b = make([]byte, m.Size())
2372         }
2373         buf := codec.NewBuffer(b)
2374         buf.EncodeUint32(m.Tunnel.Vni)
2375         buf.EncodeUint32(uint32(m.Tunnel.Mode))
2376         buf.EncodeUint32(m.Tunnel.BdRdID)
2377         buf.EncodeBytes(m.Tunnel.Src[:], 4)
2378         return buf.Bytes(), nil
2379 }
2380 func (m *GbpVxlanTunnelDetails) Unmarshal(b []byte) error {
2381         buf := codec.NewBuffer(b)
2382         m.Tunnel.Vni = buf.DecodeUint32()
2383         m.Tunnel.Mode = GbpVxlanTunnelMode(buf.DecodeUint32())
2384         m.Tunnel.BdRdID = buf.DecodeUint32()
2385         copy(m.Tunnel.Src[:], buf.DecodeBytes(4))
2386         return nil
2387 }
2388
2389 // GbpVxlanTunnelDump defines message 'gbp_vxlan_tunnel_dump'.
2390 type GbpVxlanTunnelDump struct{}
2391
2392 func (m *GbpVxlanTunnelDump) Reset()               { *m = GbpVxlanTunnelDump{} }
2393 func (*GbpVxlanTunnelDump) GetMessageName() string { return "gbp_vxlan_tunnel_dump" }
2394 func (*GbpVxlanTunnelDump) GetCrcString() string   { return "51077d14" }
2395 func (*GbpVxlanTunnelDump) GetMessageType() api.MessageType {
2396         return api.RequestMessage
2397 }
2398
2399 func (m *GbpVxlanTunnelDump) Size() (size int) {
2400         if m == nil {
2401                 return 0
2402         }
2403         return size
2404 }
2405 func (m *GbpVxlanTunnelDump) Marshal(b []byte) ([]byte, error) {
2406         if b == nil {
2407                 b = make([]byte, m.Size())
2408         }
2409         buf := codec.NewBuffer(b)
2410         return buf.Bytes(), nil
2411 }
2412 func (m *GbpVxlanTunnelDump) Unmarshal(b []byte) error {
2413         return nil
2414 }
2415
2416 func init() { file_gbp_binapi_init() }
2417 func file_gbp_binapi_init() {
2418         api.RegisterMessage((*GbpBridgeDomainAdd)(nil), "gbp_bridge_domain_add_8454bfdf")
2419         api.RegisterMessage((*GbpBridgeDomainAddReply)(nil), "gbp_bridge_domain_add_reply_e8d4e804")
2420         api.RegisterMessage((*GbpBridgeDomainDel)(nil), "gbp_bridge_domain_del_c25fdce6")
2421         api.RegisterMessage((*GbpBridgeDomainDelReply)(nil), "gbp_bridge_domain_del_reply_e8d4e804")
2422         api.RegisterMessage((*GbpBridgeDomainDetails)(nil), "gbp_bridge_domain_details_2acd15f9")
2423         api.RegisterMessage((*GbpBridgeDomainDump)(nil), "gbp_bridge_domain_dump_51077d14")
2424         api.RegisterMessage((*GbpBridgeDomainDumpReply)(nil), "gbp_bridge_domain_dump_reply_e8d4e804")
2425         api.RegisterMessage((*GbpContractAddDel)(nil), "gbp_contract_add_del_553e275b")
2426         api.RegisterMessage((*GbpContractAddDelReply)(nil), "gbp_contract_add_del_reply_1992deab")
2427         api.RegisterMessage((*GbpContractDetails)(nil), "gbp_contract_details_2a18db6e")
2428         api.RegisterMessage((*GbpContractDump)(nil), "gbp_contract_dump_51077d14")
2429         api.RegisterMessage((*GbpEndpointAdd)(nil), "gbp_endpoint_add_9ce16d5a")
2430         api.RegisterMessage((*GbpEndpointAddReply)(nil), "gbp_endpoint_add_reply_1dd3ff3e")
2431         api.RegisterMessage((*GbpEndpointDel)(nil), "gbp_endpoint_del_b93cd566")
2432         api.RegisterMessage((*GbpEndpointDelReply)(nil), "gbp_endpoint_del_reply_e8d4e804")
2433         api.RegisterMessage((*GbpEndpointDetails)(nil), "gbp_endpoint_details_08aecb60")
2434         api.RegisterMessage((*GbpEndpointDump)(nil), "gbp_endpoint_dump_51077d14")
2435         api.RegisterMessage((*GbpEndpointGroupAdd)(nil), "gbp_endpoint_group_add_8e0f4054")
2436         api.RegisterMessage((*GbpEndpointGroupAddReply)(nil), "gbp_endpoint_group_add_reply_e8d4e804")
2437         api.RegisterMessage((*GbpEndpointGroupDel)(nil), "gbp_endpoint_group_del_3436b8b7")
2438         api.RegisterMessage((*GbpEndpointGroupDelReply)(nil), "gbp_endpoint_group_del_reply_e8d4e804")
2439         api.RegisterMessage((*GbpEndpointGroupDetails)(nil), "gbp_endpoint_group_details_8f38292c")
2440         api.RegisterMessage((*GbpEndpointGroupDump)(nil), "gbp_endpoint_group_dump_51077d14")
2441         api.RegisterMessage((*GbpExtItfAddDel)(nil), "gbp_ext_itf_add_del_12ed5700")
2442         api.RegisterMessage((*GbpExtItfAddDelReply)(nil), "gbp_ext_itf_add_del_reply_e8d4e804")
2443         api.RegisterMessage((*GbpExtItfDetails)(nil), "gbp_ext_itf_details_408a45c0")
2444         api.RegisterMessage((*GbpExtItfDump)(nil), "gbp_ext_itf_dump_51077d14")
2445         api.RegisterMessage((*GbpRecircAddDel)(nil), "gbp_recirc_add_del_718c69c3")
2446         api.RegisterMessage((*GbpRecircAddDelReply)(nil), "gbp_recirc_add_del_reply_e8d4e804")
2447         api.RegisterMessage((*GbpRecircDetails)(nil), "gbp_recirc_details_66ecc42e")
2448         api.RegisterMessage((*GbpRecircDump)(nil), "gbp_recirc_dump_51077d14")
2449         api.RegisterMessage((*GbpRouteDomainAdd)(nil), "gbp_route_domain_add_2d0afe38")
2450         api.RegisterMessage((*GbpRouteDomainAddReply)(nil), "gbp_route_domain_add_reply_e8d4e804")
2451         api.RegisterMessage((*GbpRouteDomainDel)(nil), "gbp_route_domain_del_bee4edcd")
2452         api.RegisterMessage((*GbpRouteDomainDelReply)(nil), "gbp_route_domain_del_reply_e8d4e804")
2453         api.RegisterMessage((*GbpRouteDomainDetails)(nil), "gbp_route_domain_details_8ab11375")
2454         api.RegisterMessage((*GbpRouteDomainDump)(nil), "gbp_route_domain_dump_51077d14")
2455         api.RegisterMessage((*GbpRouteDomainDumpReply)(nil), "gbp_route_domain_dump_reply_e8d4e804")
2456         api.RegisterMessage((*GbpSubnetAddDel)(nil), "gbp_subnet_add_del_888aca35")
2457         api.RegisterMessage((*GbpSubnetAddDelReply)(nil), "gbp_subnet_add_del_reply_e8d4e804")
2458         api.RegisterMessage((*GbpSubnetDetails)(nil), "gbp_subnet_details_4ed84156")
2459         api.RegisterMessage((*GbpSubnetDump)(nil), "gbp_subnet_dump_51077d14")
2460         api.RegisterMessage((*GbpVxlanTunnelAdd)(nil), "gbp_vxlan_tunnel_add_3e070b35")
2461         api.RegisterMessage((*GbpVxlanTunnelAddReply)(nil), "gbp_vxlan_tunnel_add_reply_5383d31f")
2462         api.RegisterMessage((*GbpVxlanTunnelDel)(nil), "gbp_vxlan_tunnel_del_8d1f2fe9")
2463         api.RegisterMessage((*GbpVxlanTunnelDelReply)(nil), "gbp_vxlan_tunnel_del_reply_e8d4e804")
2464         api.RegisterMessage((*GbpVxlanTunnelDetails)(nil), "gbp_vxlan_tunnel_details_65c6c818")
2465         api.RegisterMessage((*GbpVxlanTunnelDump)(nil), "gbp_vxlan_tunnel_dump_51077d14")
2466 }
2467
2468 // Messages returns list of all messages in this module.
2469 func AllMessages() []api.Message {
2470         return []api.Message{
2471                 (*GbpBridgeDomainAdd)(nil),
2472                 (*GbpBridgeDomainAddReply)(nil),
2473                 (*GbpBridgeDomainDel)(nil),
2474                 (*GbpBridgeDomainDelReply)(nil),
2475                 (*GbpBridgeDomainDetails)(nil),
2476                 (*GbpBridgeDomainDump)(nil),
2477                 (*GbpBridgeDomainDumpReply)(nil),
2478                 (*GbpContractAddDel)(nil),
2479                 (*GbpContractAddDelReply)(nil),
2480                 (*GbpContractDetails)(nil),
2481                 (*GbpContractDump)(nil),
2482                 (*GbpEndpointAdd)(nil),
2483                 (*GbpEndpointAddReply)(nil),
2484                 (*GbpEndpointDel)(nil),
2485                 (*GbpEndpointDelReply)(nil),
2486                 (*GbpEndpointDetails)(nil),
2487                 (*GbpEndpointDump)(nil),
2488                 (*GbpEndpointGroupAdd)(nil),
2489                 (*GbpEndpointGroupAddReply)(nil),
2490                 (*GbpEndpointGroupDel)(nil),
2491                 (*GbpEndpointGroupDelReply)(nil),
2492                 (*GbpEndpointGroupDetails)(nil),
2493                 (*GbpEndpointGroupDump)(nil),
2494                 (*GbpExtItfAddDel)(nil),
2495                 (*GbpExtItfAddDelReply)(nil),
2496                 (*GbpExtItfDetails)(nil),
2497                 (*GbpExtItfDump)(nil),
2498                 (*GbpRecircAddDel)(nil),
2499                 (*GbpRecircAddDelReply)(nil),
2500                 (*GbpRecircDetails)(nil),
2501                 (*GbpRecircDump)(nil),
2502                 (*GbpRouteDomainAdd)(nil),
2503                 (*GbpRouteDomainAddReply)(nil),
2504                 (*GbpRouteDomainDel)(nil),
2505                 (*GbpRouteDomainDelReply)(nil),
2506                 (*GbpRouteDomainDetails)(nil),
2507                 (*GbpRouteDomainDump)(nil),
2508                 (*GbpRouteDomainDumpReply)(nil),
2509                 (*GbpSubnetAddDel)(nil),
2510                 (*GbpSubnetAddDelReply)(nil),
2511                 (*GbpSubnetDetails)(nil),
2512                 (*GbpSubnetDump)(nil),
2513                 (*GbpVxlanTunnelAdd)(nil),
2514                 (*GbpVxlanTunnelAddReply)(nil),
2515                 (*GbpVxlanTunnelDel)(nil),
2516                 (*GbpVxlanTunnelDelReply)(nil),
2517                 (*GbpVxlanTunnelDetails)(nil),
2518                 (*GbpVxlanTunnelDump)(nil),
2519         }
2520 }