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