binapi/lisp/lisp.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 lisp contains generated bindings for API file lisp.api.
   7 //
   8 // Contents:
   9 //   1 enum
  10 //   1 struct
  11 //  60 messages
  12 //
  13 package lisp
  14
  15 import (
  16         "strconv"
  17
  18         api "git.fd.io/govpp.git/api"
  19         _ "git.fd.io/govpp.git/binapi/ethernet_types"
  20         interface_types "git.fd.io/govpp.git/binapi/interface_types"
  21         ip_types "git.fd.io/govpp.git/binapi/ip_types"
  22         lisp_types "git.fd.io/govpp.git/binapi/lisp_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    = "lisp"
  34         APIVersion = "2.0.0"
  35         VersionCrc = 0xf2d169ad
  36 )
  37
  38 // LispLocatorSetFilter defines enum 'lisp_locator_set_filter'.
  39 type LispLocatorSetFilter uint8
  40
  41 const (
  42         LISP_LOCATOR_SET_FILTER_API_ALL    LispLocatorSetFilter = 0
  43         LISP_LOCATOR_SET_FILTER_API_LOCAL  LispLocatorSetFilter = 1
  44         LISP_LOCATOR_SET_FILTER_API_REMOTE LispLocatorSetFilter = 2
  45 )
  46
  47 var (
  48         LispLocatorSetFilter_name = map[uint8]string{
  49                 0: "LISP_LOCATOR_SET_FILTER_API_ALL",
  50                 1: "LISP_LOCATOR_SET_FILTER_API_LOCAL",
  51                 2: "LISP_LOCATOR_SET_FILTER_API_REMOTE",
  52         }
  53         LispLocatorSetFilter_value = map[string]uint8{
  54                 "LISP_LOCATOR_SET_FILTER_API_ALL":    0,
  55                 "LISP_LOCATOR_SET_FILTER_API_LOCAL":  1,
  56                 "LISP_LOCATOR_SET_FILTER_API_REMOTE": 2,
  57         }
  58 )
  59
  60 func (x LispLocatorSetFilter) String() string {
  61         s, ok := LispLocatorSetFilter_name[uint8(x)]
  62         if ok {
  63                 return s
  64         }
  65         return "LispLocatorSetFilter(" + strconv.Itoa(int(x)) + ")"
  66 }
  67
  68 // LispAdjacency defines type 'lisp_adjacency'.
  69 type LispAdjacency struct {
  70         Reid lisp_types.Eid `binapi:"eid,name=reid" json:"reid,omitempty"`
  71         Leid lisp_types.Eid `binapi:"eid,name=leid" json:"leid,omitempty"`
  72 }
  73
  74 // LispAddDelAdjacency defines message 'lisp_add_del_adjacency'.
  75 type LispAddDelAdjacency struct {
  76         IsAdd bool           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
  77         Vni   uint32         `binapi:"u32,name=vni" json:"vni,omitempty"`
  78         Reid  lisp_types.Eid `binapi:"eid,name=reid" json:"reid,omitempty"`
  79         Leid  lisp_types.Eid `binapi:"eid,name=leid" json:"leid,omitempty"`
  80 }
  81
  82 func (m *LispAddDelAdjacency) Reset()               { *m = LispAddDelAdjacency{} }
  83 func (*LispAddDelAdjacency) GetMessageName() string { return "lisp_add_del_adjacency" }
  84 func (*LispAddDelAdjacency) GetCrcString() string   { return "cf5edb61" }
  85 func (*LispAddDelAdjacency) GetMessageType() api.MessageType {
  86         return api.RequestMessage
  87 }
  88
  89 func (m *LispAddDelAdjacency) Size() (size int) {
  90         if m == nil {
  91                 return 0
  92         }
  93         size += 1     // m.IsAdd
  94         size += 4     // m.Vni
  95         size += 1     // m.Reid.Type
  96         size += 1 * 6 // m.Reid.Address
  97         size += 1     // m.Leid.Type
  98         size += 1 * 6 // m.Leid.Address
  99         return size
 100 }
 101 func (m *LispAddDelAdjacency) Marshal(b []byte) ([]byte, error) {
 102         if b == nil {
 103                 b = make([]byte, m.Size())
 104         }
 105         buf := codec.NewBuffer(b)
 106         buf.EncodeBool(m.IsAdd)
 107         buf.EncodeUint32(m.Vni)
 108         buf.EncodeUint8(uint8(m.Reid.Type))
 109         buf.EncodeBytes(m.Reid.Address.XXX_UnionData[:], 6)
 110         buf.EncodeUint8(uint8(m.Leid.Type))
 111         buf.EncodeBytes(m.Leid.Address.XXX_UnionData[:], 6)
 112         return buf.Bytes(), nil
 113 }
 114 func (m *LispAddDelAdjacency) Unmarshal(b []byte) error {
 115         buf := codec.NewBuffer(b)
 116         m.IsAdd = buf.DecodeBool()
 117         m.Vni = buf.DecodeUint32()
 118         m.Reid.Type = lisp_types.EidType(buf.DecodeUint8())
 119         copy(m.Reid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 120         m.Leid.Type = lisp_types.EidType(buf.DecodeUint8())
 121         copy(m.Leid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 122         return nil
 123 }
 124
 125 // LispAddDelAdjacencyReply defines message 'lisp_add_del_adjacency_reply'.
 126 type LispAddDelAdjacencyReply struct {
 127         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 128 }
 129
 130 func (m *LispAddDelAdjacencyReply) Reset()               { *m = LispAddDelAdjacencyReply{} }
 131 func (*LispAddDelAdjacencyReply) GetMessageName() string { return "lisp_add_del_adjacency_reply" }
 132 func (*LispAddDelAdjacencyReply) GetCrcString() string   { return "e8d4e804" }
 133 func (*LispAddDelAdjacencyReply) GetMessageType() api.MessageType {
 134         return api.ReplyMessage
 135 }
 136
 137 func (m *LispAddDelAdjacencyReply) Size() (size int) {
 138         if m == nil {
 139                 return 0
 140         }
 141         size += 4 // m.Retval
 142         return size
 143 }
 144 func (m *LispAddDelAdjacencyReply) Marshal(b []byte) ([]byte, error) {
 145         if b == nil {
 146                 b = make([]byte, m.Size())
 147         }
 148         buf := codec.NewBuffer(b)
 149         buf.EncodeInt32(m.Retval)
 150         return buf.Bytes(), nil
 151 }
 152 func (m *LispAddDelAdjacencyReply) Unmarshal(b []byte) error {
 153         buf := codec.NewBuffer(b)
 154         m.Retval = buf.DecodeInt32()
 155         return nil
 156 }
 157
 158 // LispAddDelLocalEid defines message 'lisp_add_del_local_eid'.
 159 type LispAddDelLocalEid struct {
 160         IsAdd          bool               `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 161         Eid            lisp_types.Eid     `binapi:"eid,name=eid" json:"eid,omitempty"`
 162         LocatorSetName string             `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
 163         Vni            uint32             `binapi:"u32,name=vni" json:"vni,omitempty"`
 164         Key            lisp_types.HmacKey `binapi:"hmac_key,name=key" json:"key,omitempty"`
 165 }
 166
 167 func (m *LispAddDelLocalEid) Reset()               { *m = LispAddDelLocalEid{} }
 168 func (*LispAddDelLocalEid) GetMessageName() string { return "lisp_add_del_local_eid" }
 169 func (*LispAddDelLocalEid) GetCrcString() string   { return "21f573bd" }
 170 func (*LispAddDelLocalEid) GetMessageType() api.MessageType {
 171         return api.RequestMessage
 172 }
 173
 174 func (m *LispAddDelLocalEid) Size() (size int) {
 175         if m == nil {
 176                 return 0
 177         }
 178         size += 1      // m.IsAdd
 179         size += 1      // m.Eid.Type
 180         size += 1 * 6  // m.Eid.Address
 181         size += 64     // m.LocatorSetName
 182         size += 4      // m.Vni
 183         size += 1      // m.Key.ID
 184         size += 1 * 64 // m.Key.Key
 185         return size
 186 }
 187 func (m *LispAddDelLocalEid) Marshal(b []byte) ([]byte, error) {
 188         if b == nil {
 189                 b = make([]byte, m.Size())
 190         }
 191         buf := codec.NewBuffer(b)
 192         buf.EncodeBool(m.IsAdd)
 193         buf.EncodeUint8(uint8(m.Eid.Type))
 194         buf.EncodeBytes(m.Eid.Address.XXX_UnionData[:], 6)
 195         buf.EncodeString(m.LocatorSetName, 64)
 196         buf.EncodeUint32(m.Vni)
 197         buf.EncodeUint8(uint8(m.Key.ID))
 198         buf.EncodeBytes(m.Key.Key, 64)
 199         return buf.Bytes(), nil
 200 }
 201 func (m *LispAddDelLocalEid) Unmarshal(b []byte) error {
 202         buf := codec.NewBuffer(b)
 203         m.IsAdd = buf.DecodeBool()
 204         m.Eid.Type = lisp_types.EidType(buf.DecodeUint8())
 205         copy(m.Eid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 206         m.LocatorSetName = buf.DecodeString(64)
 207         m.Vni = buf.DecodeUint32()
 208         m.Key.ID = lisp_types.HmacKeyID(buf.DecodeUint8())
 209         m.Key.Key = make([]byte, 64)
 210         copy(m.Key.Key, buf.DecodeBytes(len(m.Key.Key)))
 211         return nil
 212 }
 213
 214 // LispAddDelLocalEidReply defines message 'lisp_add_del_local_eid_reply'.
 215 type LispAddDelLocalEidReply struct {
 216         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 217 }
 218
 219 func (m *LispAddDelLocalEidReply) Reset()               { *m = LispAddDelLocalEidReply{} }
 220 func (*LispAddDelLocalEidReply) GetMessageName() string { return "lisp_add_del_local_eid_reply" }
 221 func (*LispAddDelLocalEidReply) GetCrcString() string   { return "e8d4e804" }
 222 func (*LispAddDelLocalEidReply) GetMessageType() api.MessageType {
 223         return api.ReplyMessage
 224 }
 225
 226 func (m *LispAddDelLocalEidReply) Size() (size int) {
 227         if m == nil {
 228                 return 0
 229         }
 230         size += 4 // m.Retval
 231         return size
 232 }
 233 func (m *LispAddDelLocalEidReply) Marshal(b []byte) ([]byte, error) {
 234         if b == nil {
 235                 b = make([]byte, m.Size())
 236         }
 237         buf := codec.NewBuffer(b)
 238         buf.EncodeInt32(m.Retval)
 239         return buf.Bytes(), nil
 240 }
 241 func (m *LispAddDelLocalEidReply) Unmarshal(b []byte) error {
 242         buf := codec.NewBuffer(b)
 243         m.Retval = buf.DecodeInt32()
 244         return nil
 245 }
 246
 247 // LispAddDelLocator defines message 'lisp_add_del_locator'.
 248 type LispAddDelLocator struct {
 249         IsAdd          bool                           `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 250         LocatorSetName string                         `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
 251         SwIfIndex      interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
 252         Priority       uint8                          `binapi:"u8,name=priority" json:"priority,omitempty"`
 253         Weight         uint8                          `binapi:"u8,name=weight" json:"weight,omitempty"`
 254 }
 255
 256 func (m *LispAddDelLocator) Reset()               { *m = LispAddDelLocator{} }
 257 func (*LispAddDelLocator) GetMessageName() string { return "lisp_add_del_locator" }
 258 func (*LispAddDelLocator) GetCrcString() string   { return "af4d8f13" }
 259 func (*LispAddDelLocator) GetMessageType() api.MessageType {
 260         return api.RequestMessage
 261 }
 262
 263 func (m *LispAddDelLocator) Size() (size int) {
 264         if m == nil {
 265                 return 0
 266         }
 267         size += 1  // m.IsAdd
 268         size += 64 // m.LocatorSetName
 269         size += 4  // m.SwIfIndex
 270         size += 1  // m.Priority
 271         size += 1  // m.Weight
 272         return size
 273 }
 274 func (m *LispAddDelLocator) Marshal(b []byte) ([]byte, error) {
 275         if b == nil {
 276                 b = make([]byte, m.Size())
 277         }
 278         buf := codec.NewBuffer(b)
 279         buf.EncodeBool(m.IsAdd)
 280         buf.EncodeString(m.LocatorSetName, 64)
 281         buf.EncodeUint32(uint32(m.SwIfIndex))
 282         buf.EncodeUint8(m.Priority)
 283         buf.EncodeUint8(m.Weight)
 284         return buf.Bytes(), nil
 285 }
 286 func (m *LispAddDelLocator) Unmarshal(b []byte) error {
 287         buf := codec.NewBuffer(b)
 288         m.IsAdd = buf.DecodeBool()
 289         m.LocatorSetName = buf.DecodeString(64)
 290         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 291         m.Priority = buf.DecodeUint8()
 292         m.Weight = buf.DecodeUint8()
 293         return nil
 294 }
 295
 296 // LispAddDelLocatorReply defines message 'lisp_add_del_locator_reply'.
 297 type LispAddDelLocatorReply struct {
 298         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 299 }
 300
 301 func (m *LispAddDelLocatorReply) Reset()               { *m = LispAddDelLocatorReply{} }
 302 func (*LispAddDelLocatorReply) GetMessageName() string { return "lisp_add_del_locator_reply" }
 303 func (*LispAddDelLocatorReply) GetCrcString() string   { return "e8d4e804" }
 304 func (*LispAddDelLocatorReply) GetMessageType() api.MessageType {
 305         return api.ReplyMessage
 306 }
 307
 308 func (m *LispAddDelLocatorReply) Size() (size int) {
 309         if m == nil {
 310                 return 0
 311         }
 312         size += 4 // m.Retval
 313         return size
 314 }
 315 func (m *LispAddDelLocatorReply) Marshal(b []byte) ([]byte, error) {
 316         if b == nil {
 317                 b = make([]byte, m.Size())
 318         }
 319         buf := codec.NewBuffer(b)
 320         buf.EncodeInt32(m.Retval)
 321         return buf.Bytes(), nil
 322 }
 323 func (m *LispAddDelLocatorReply) Unmarshal(b []byte) error {
 324         buf := codec.NewBuffer(b)
 325         m.Retval = buf.DecodeInt32()
 326         return nil
 327 }
 328
 329 // LispAddDelLocatorSet defines message 'lisp_add_del_locator_set'.
 330 type LispAddDelLocatorSet struct {
 331         IsAdd          bool                      `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 332         LocatorSetName string                    `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
 333         LocatorNum     uint32                    `binapi:"u32,name=locator_num" json:"-"`
 334         Locators       []lisp_types.LocalLocator `binapi:"local_locator[locator_num],name=locators" json:"locators,omitempty"`
 335 }
 336
 337 func (m *LispAddDelLocatorSet) Reset()               { *m = LispAddDelLocatorSet{} }
 338 func (*LispAddDelLocatorSet) GetMessageName() string { return "lisp_add_del_locator_set" }
 339 func (*LispAddDelLocatorSet) GetCrcString() string   { return "6fcd6471" }
 340 func (*LispAddDelLocatorSet) GetMessageType() api.MessageType {
 341         return api.RequestMessage
 342 }
 343
 344 func (m *LispAddDelLocatorSet) Size() (size int) {
 345         if m == nil {
 346                 return 0
 347         }
 348         size += 1  // m.IsAdd
 349         size += 64 // m.LocatorSetName
 350         size += 4  // m.LocatorNum
 351         for j1 := 0; j1 < len(m.Locators); j1++ {
 352                 var s1 lisp_types.LocalLocator
 353                 _ = s1
 354                 if j1 < len(m.Locators) {
 355                         s1 = m.Locators[j1]
 356                 }
 357                 size += 4 // s1.SwIfIndex
 358                 size += 1 // s1.Priority
 359                 size += 1 // s1.Weight
 360         }
 361         return size
 362 }
 363 func (m *LispAddDelLocatorSet) Marshal(b []byte) ([]byte, error) {
 364         if b == nil {
 365                 b = make([]byte, m.Size())
 366         }
 367         buf := codec.NewBuffer(b)
 368         buf.EncodeBool(m.IsAdd)
 369         buf.EncodeString(m.LocatorSetName, 64)
 370         buf.EncodeUint32(uint32(len(m.Locators)))
 371         for j0 := 0; j0 < len(m.Locators); j0++ {
 372                 var v0 lisp_types.LocalLocator // Locators
 373                 if j0 < len(m.Locators) {
 374                         v0 = m.Locators[j0]
 375                 }
 376                 buf.EncodeUint32(uint32(v0.SwIfIndex))
 377                 buf.EncodeUint8(v0.Priority)
 378                 buf.EncodeUint8(v0.Weight)
 379         }
 380         return buf.Bytes(), nil
 381 }
 382 func (m *LispAddDelLocatorSet) Unmarshal(b []byte) error {
 383         buf := codec.NewBuffer(b)
 384         m.IsAdd = buf.DecodeBool()
 385         m.LocatorSetName = buf.DecodeString(64)
 386         m.LocatorNum = buf.DecodeUint32()
 387         m.Locators = make([]lisp_types.LocalLocator, m.LocatorNum)
 388         for j0 := 0; j0 < len(m.Locators); j0++ {
 389                 m.Locators[j0].SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
 390                 m.Locators[j0].Priority = buf.DecodeUint8()
 391                 m.Locators[j0].Weight = buf.DecodeUint8()
 392         }
 393         return nil
 394 }
 395
 396 // LispAddDelLocatorSetReply defines message 'lisp_add_del_locator_set_reply'.
 397 type LispAddDelLocatorSetReply struct {
 398         Retval  int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 399         LsIndex uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
 400 }
 401
 402 func (m *LispAddDelLocatorSetReply) Reset()               { *m = LispAddDelLocatorSetReply{} }
 403 func (*LispAddDelLocatorSetReply) GetMessageName() string { return "lisp_add_del_locator_set_reply" }
 404 func (*LispAddDelLocatorSetReply) GetCrcString() string   { return "b6666db4" }
 405 func (*LispAddDelLocatorSetReply) GetMessageType() api.MessageType {
 406         return api.ReplyMessage
 407 }
 408
 409 func (m *LispAddDelLocatorSetReply) Size() (size int) {
 410         if m == nil {
 411                 return 0
 412         }
 413         size += 4 // m.Retval
 414         size += 4 // m.LsIndex
 415         return size
 416 }
 417 func (m *LispAddDelLocatorSetReply) Marshal(b []byte) ([]byte, error) {
 418         if b == nil {
 419                 b = make([]byte, m.Size())
 420         }
 421         buf := codec.NewBuffer(b)
 422         buf.EncodeInt32(m.Retval)
 423         buf.EncodeUint32(m.LsIndex)
 424         return buf.Bytes(), nil
 425 }
 426 func (m *LispAddDelLocatorSetReply) Unmarshal(b []byte) error {
 427         buf := codec.NewBuffer(b)
 428         m.Retval = buf.DecodeInt32()
 429         m.LsIndex = buf.DecodeUint32()
 430         return nil
 431 }
 432
 433 // LispAddDelMapRequestItrRlocs defines message 'lisp_add_del_map_request_itr_rlocs'.
 434 type LispAddDelMapRequestItrRlocs struct {
 435         IsAdd          bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 436         LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
 437 }
 438
 439 func (m *LispAddDelMapRequestItrRlocs) Reset() { *m = LispAddDelMapRequestItrRlocs{} }
 440 func (*LispAddDelMapRequestItrRlocs) GetMessageName() string {
 441         return "lisp_add_del_map_request_itr_rlocs"
 442 }
 443 func (*LispAddDelMapRequestItrRlocs) GetCrcString() string { return "6be88e45" }
 444 func (*LispAddDelMapRequestItrRlocs) GetMessageType() api.MessageType {
 445         return api.RequestMessage
 446 }
 447
 448 func (m *LispAddDelMapRequestItrRlocs) Size() (size int) {
 449         if m == nil {
 450                 return 0
 451         }
 452         size += 1  // m.IsAdd
 453         size += 64 // m.LocatorSetName
 454         return size
 455 }
 456 func (m *LispAddDelMapRequestItrRlocs) Marshal(b []byte) ([]byte, error) {
 457         if b == nil {
 458                 b = make([]byte, m.Size())
 459         }
 460         buf := codec.NewBuffer(b)
 461         buf.EncodeBool(m.IsAdd)
 462         buf.EncodeString(m.LocatorSetName, 64)
 463         return buf.Bytes(), nil
 464 }
 465 func (m *LispAddDelMapRequestItrRlocs) Unmarshal(b []byte) error {
 466         buf := codec.NewBuffer(b)
 467         m.IsAdd = buf.DecodeBool()
 468         m.LocatorSetName = buf.DecodeString(64)
 469         return nil
 470 }
 471
 472 // LispAddDelMapRequestItrRlocsReply defines message 'lisp_add_del_map_request_itr_rlocs_reply'.
 473 type LispAddDelMapRequestItrRlocsReply struct {
 474         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 475 }
 476
 477 func (m *LispAddDelMapRequestItrRlocsReply) Reset() { *m = LispAddDelMapRequestItrRlocsReply{} }
 478 func (*LispAddDelMapRequestItrRlocsReply) GetMessageName() string {
 479         return "lisp_add_del_map_request_itr_rlocs_reply"
 480 }
 481 func (*LispAddDelMapRequestItrRlocsReply) GetCrcString() string { return "e8d4e804" }
 482 func (*LispAddDelMapRequestItrRlocsReply) GetMessageType() api.MessageType {
 483         return api.ReplyMessage
 484 }
 485
 486 func (m *LispAddDelMapRequestItrRlocsReply) Size() (size int) {
 487         if m == nil {
 488                 return 0
 489         }
 490         size += 4 // m.Retval
 491         return size
 492 }
 493 func (m *LispAddDelMapRequestItrRlocsReply) Marshal(b []byte) ([]byte, error) {
 494         if b == nil {
 495                 b = make([]byte, m.Size())
 496         }
 497         buf := codec.NewBuffer(b)
 498         buf.EncodeInt32(m.Retval)
 499         return buf.Bytes(), nil
 500 }
 501 func (m *LispAddDelMapRequestItrRlocsReply) Unmarshal(b []byte) error {
 502         buf := codec.NewBuffer(b)
 503         m.Retval = buf.DecodeInt32()
 504         return nil
 505 }
 506
 507 // LispAddDelMapResolver defines message 'lisp_add_del_map_resolver'.
 508 type LispAddDelMapResolver struct {
 509         IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 510         IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
 511 }
 512
 513 func (m *LispAddDelMapResolver) Reset()               { *m = LispAddDelMapResolver{} }
 514 func (*LispAddDelMapResolver) GetMessageName() string { return "lisp_add_del_map_resolver" }
 515 func (*LispAddDelMapResolver) GetCrcString() string   { return "6598ea7c" }
 516 func (*LispAddDelMapResolver) GetMessageType() api.MessageType {
 517         return api.RequestMessage
 518 }
 519
 520 func (m *LispAddDelMapResolver) Size() (size int) {
 521         if m == nil {
 522                 return 0
 523         }
 524         size += 1      // m.IsAdd
 525         size += 1      // m.IPAddress.Af
 526         size += 1 * 16 // m.IPAddress.Un
 527         return size
 528 }
 529 func (m *LispAddDelMapResolver) Marshal(b []byte) ([]byte, error) {
 530         if b == nil {
 531                 b = make([]byte, m.Size())
 532         }
 533         buf := codec.NewBuffer(b)
 534         buf.EncodeBool(m.IsAdd)
 535         buf.EncodeUint8(uint8(m.IPAddress.Af))
 536         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
 537         return buf.Bytes(), nil
 538 }
 539 func (m *LispAddDelMapResolver) Unmarshal(b []byte) error {
 540         buf := codec.NewBuffer(b)
 541         m.IsAdd = buf.DecodeBool()
 542         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 543         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 544         return nil
 545 }
 546
 547 // LispAddDelMapResolverReply defines message 'lisp_add_del_map_resolver_reply'.
 548 type LispAddDelMapResolverReply struct {
 549         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 550 }
 551
 552 func (m *LispAddDelMapResolverReply) Reset()               { *m = LispAddDelMapResolverReply{} }
 553 func (*LispAddDelMapResolverReply) GetMessageName() string { return "lisp_add_del_map_resolver_reply" }
 554 func (*LispAddDelMapResolverReply) GetCrcString() string   { return "e8d4e804" }
 555 func (*LispAddDelMapResolverReply) GetMessageType() api.MessageType {
 556         return api.ReplyMessage
 557 }
 558
 559 func (m *LispAddDelMapResolverReply) Size() (size int) {
 560         if m == nil {
 561                 return 0
 562         }
 563         size += 4 // m.Retval
 564         return size
 565 }
 566 func (m *LispAddDelMapResolverReply) Marshal(b []byte) ([]byte, error) {
 567         if b == nil {
 568                 b = make([]byte, m.Size())
 569         }
 570         buf := codec.NewBuffer(b)
 571         buf.EncodeInt32(m.Retval)
 572         return buf.Bytes(), nil
 573 }
 574 func (m *LispAddDelMapResolverReply) Unmarshal(b []byte) error {
 575         buf := codec.NewBuffer(b)
 576         m.Retval = buf.DecodeInt32()
 577         return nil
 578 }
 579
 580 // LispAddDelMapServer defines message 'lisp_add_del_map_server'.
 581 type LispAddDelMapServer struct {
 582         IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 583         IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
 584 }
 585
 586 func (m *LispAddDelMapServer) Reset()               { *m = LispAddDelMapServer{} }
 587 func (*LispAddDelMapServer) GetMessageName() string { return "lisp_add_del_map_server" }
 588 func (*LispAddDelMapServer) GetCrcString() string   { return "6598ea7c" }
 589 func (*LispAddDelMapServer) GetMessageType() api.MessageType {
 590         return api.RequestMessage
 591 }
 592
 593 func (m *LispAddDelMapServer) Size() (size int) {
 594         if m == nil {
 595                 return 0
 596         }
 597         size += 1      // m.IsAdd
 598         size += 1      // m.IPAddress.Af
 599         size += 1 * 16 // m.IPAddress.Un
 600         return size
 601 }
 602 func (m *LispAddDelMapServer) Marshal(b []byte) ([]byte, error) {
 603         if b == nil {
 604                 b = make([]byte, m.Size())
 605         }
 606         buf := codec.NewBuffer(b)
 607         buf.EncodeBool(m.IsAdd)
 608         buf.EncodeUint8(uint8(m.IPAddress.Af))
 609         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
 610         return buf.Bytes(), nil
 611 }
 612 func (m *LispAddDelMapServer) Unmarshal(b []byte) error {
 613         buf := codec.NewBuffer(b)
 614         m.IsAdd = buf.DecodeBool()
 615         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 616         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 617         return nil
 618 }
 619
 620 // LispAddDelMapServerReply defines message 'lisp_add_del_map_server_reply'.
 621 type LispAddDelMapServerReply struct {
 622         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 623 }
 624
 625 func (m *LispAddDelMapServerReply) Reset()               { *m = LispAddDelMapServerReply{} }
 626 func (*LispAddDelMapServerReply) GetMessageName() string { return "lisp_add_del_map_server_reply" }
 627 func (*LispAddDelMapServerReply) GetCrcString() string   { return "e8d4e804" }
 628 func (*LispAddDelMapServerReply) GetMessageType() api.MessageType {
 629         return api.ReplyMessage
 630 }
 631
 632 func (m *LispAddDelMapServerReply) Size() (size int) {
 633         if m == nil {
 634                 return 0
 635         }
 636         size += 4 // m.Retval
 637         return size
 638 }
 639 func (m *LispAddDelMapServerReply) Marshal(b []byte) ([]byte, error) {
 640         if b == nil {
 641                 b = make([]byte, m.Size())
 642         }
 643         buf := codec.NewBuffer(b)
 644         buf.EncodeInt32(m.Retval)
 645         return buf.Bytes(), nil
 646 }
 647 func (m *LispAddDelMapServerReply) Unmarshal(b []byte) error {
 648         buf := codec.NewBuffer(b)
 649         m.Retval = buf.DecodeInt32()
 650         return nil
 651 }
 652
 653 // LispAddDelRemoteMapping defines message 'lisp_add_del_remote_mapping'.
 654 type LispAddDelRemoteMapping struct {
 655         IsAdd    bool                       `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 656         IsSrcDst bool                       `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
 657         DelAll   bool                       `binapi:"bool,name=del_all" json:"del_all,omitempty"`
 658         Vni      uint32                     `binapi:"u32,name=vni" json:"vni,omitempty"`
 659         Action   uint8                      `binapi:"u8,name=action" json:"action,omitempty"`
 660         Deid     lisp_types.Eid             `binapi:"eid,name=deid" json:"deid,omitempty"`
 661         Seid     lisp_types.Eid             `binapi:"eid,name=seid" json:"seid,omitempty"`
 662         RlocNum  uint32                     `binapi:"u32,name=rloc_num" json:"-"`
 663         Rlocs    []lisp_types.RemoteLocator `binapi:"remote_locator[rloc_num],name=rlocs" json:"rlocs,omitempty"`
 664 }
 665
 666 func (m *LispAddDelRemoteMapping) Reset()               { *m = LispAddDelRemoteMapping{} }
 667 func (*LispAddDelRemoteMapping) GetMessageName() string { return "lisp_add_del_remote_mapping" }
 668 func (*LispAddDelRemoteMapping) GetCrcString() string   { return "fae8ed77" }
 669 func (*LispAddDelRemoteMapping) GetMessageType() api.MessageType {
 670         return api.RequestMessage
 671 }
 672
 673 func (m *LispAddDelRemoteMapping) Size() (size int) {
 674         if m == nil {
 675                 return 0
 676         }
 677         size += 1     // m.IsAdd
 678         size += 1     // m.IsSrcDst
 679         size += 1     // m.DelAll
 680         size += 4     // m.Vni
 681         size += 1     // m.Action
 682         size += 1     // m.Deid.Type
 683         size += 1 * 6 // m.Deid.Address
 684         size += 1     // m.Seid.Type
 685         size += 1 * 6 // m.Seid.Address
 686         size += 4     // m.RlocNum
 687         for j1 := 0; j1 < len(m.Rlocs); j1++ {
 688                 var s1 lisp_types.RemoteLocator
 689                 _ = s1
 690                 if j1 < len(m.Rlocs) {
 691                         s1 = m.Rlocs[j1]
 692                 }
 693                 size += 1      // s1.Priority
 694                 size += 1      // s1.Weight
 695                 size += 1      // s1.IPAddress.Af
 696                 size += 1 * 16 // s1.IPAddress.Un
 697         }
 698         return size
 699 }
 700 func (m *LispAddDelRemoteMapping) Marshal(b []byte) ([]byte, error) {
 701         if b == nil {
 702                 b = make([]byte, m.Size())
 703         }
 704         buf := codec.NewBuffer(b)
 705         buf.EncodeBool(m.IsAdd)
 706         buf.EncodeBool(m.IsSrcDst)
 707         buf.EncodeBool(m.DelAll)
 708         buf.EncodeUint32(m.Vni)
 709         buf.EncodeUint8(m.Action)
 710         buf.EncodeUint8(uint8(m.Deid.Type))
 711         buf.EncodeBytes(m.Deid.Address.XXX_UnionData[:], 6)
 712         buf.EncodeUint8(uint8(m.Seid.Type))
 713         buf.EncodeBytes(m.Seid.Address.XXX_UnionData[:], 6)
 714         buf.EncodeUint32(uint32(len(m.Rlocs)))
 715         for j0 := 0; j0 < len(m.Rlocs); j0++ {
 716                 var v0 lisp_types.RemoteLocator // Rlocs
 717                 if j0 < len(m.Rlocs) {
 718                         v0 = m.Rlocs[j0]
 719                 }
 720                 buf.EncodeUint8(v0.Priority)
 721                 buf.EncodeUint8(v0.Weight)
 722                 buf.EncodeUint8(uint8(v0.IPAddress.Af))
 723                 buf.EncodeBytes(v0.IPAddress.Un.XXX_UnionData[:], 16)
 724         }
 725         return buf.Bytes(), nil
 726 }
 727 func (m *LispAddDelRemoteMapping) Unmarshal(b []byte) error {
 728         buf := codec.NewBuffer(b)
 729         m.IsAdd = buf.DecodeBool()
 730         m.IsSrcDst = buf.DecodeBool()
 731         m.DelAll = buf.DecodeBool()
 732         m.Vni = buf.DecodeUint32()
 733         m.Action = buf.DecodeUint8()
 734         m.Deid.Type = lisp_types.EidType(buf.DecodeUint8())
 735         copy(m.Deid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 736         m.Seid.Type = lisp_types.EidType(buf.DecodeUint8())
 737         copy(m.Seid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 738         m.RlocNum = buf.DecodeUint32()
 739         m.Rlocs = make([]lisp_types.RemoteLocator, m.RlocNum)
 740         for j0 := 0; j0 < len(m.Rlocs); j0++ {
 741                 m.Rlocs[j0].Priority = buf.DecodeUint8()
 742                 m.Rlocs[j0].Weight = buf.DecodeUint8()
 743                 m.Rlocs[j0].IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
 744                 copy(m.Rlocs[j0].IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
 745         }
 746         return nil
 747 }
 748
 749 // LispAddDelRemoteMappingReply defines message 'lisp_add_del_remote_mapping_reply'.
 750 type LispAddDelRemoteMappingReply struct {
 751         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 752 }
 753
 754 func (m *LispAddDelRemoteMappingReply) Reset() { *m = LispAddDelRemoteMappingReply{} }
 755 func (*LispAddDelRemoteMappingReply) GetMessageName() string {
 756         return "lisp_add_del_remote_mapping_reply"
 757 }
 758 func (*LispAddDelRemoteMappingReply) GetCrcString() string { return "e8d4e804" }
 759 func (*LispAddDelRemoteMappingReply) GetMessageType() api.MessageType {
 760         return api.ReplyMessage
 761 }
 762
 763 func (m *LispAddDelRemoteMappingReply) Size() (size int) {
 764         if m == nil {
 765                 return 0
 766         }
 767         size += 4 // m.Retval
 768         return size
 769 }
 770 func (m *LispAddDelRemoteMappingReply) Marshal(b []byte) ([]byte, error) {
 771         if b == nil {
 772                 b = make([]byte, m.Size())
 773         }
 774         buf := codec.NewBuffer(b)
 775         buf.EncodeInt32(m.Retval)
 776         return buf.Bytes(), nil
 777 }
 778 func (m *LispAddDelRemoteMappingReply) Unmarshal(b []byte) error {
 779         buf := codec.NewBuffer(b)
 780         m.Retval = buf.DecodeInt32()
 781         return nil
 782 }
 783
 784 // LispAdjacenciesGet defines message 'lisp_adjacencies_get'.
 785 type LispAdjacenciesGet struct {
 786         Vni uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
 787 }
 788
 789 func (m *LispAdjacenciesGet) Reset()               { *m = LispAdjacenciesGet{} }
 790 func (*LispAdjacenciesGet) GetMessageName() string { return "lisp_adjacencies_get" }
 791 func (*LispAdjacenciesGet) GetCrcString() string   { return "8d1f2fe9" }
 792 func (*LispAdjacenciesGet) GetMessageType() api.MessageType {
 793         return api.RequestMessage
 794 }
 795
 796 func (m *LispAdjacenciesGet) Size() (size int) {
 797         if m == nil {
 798                 return 0
 799         }
 800         size += 4 // m.Vni
 801         return size
 802 }
 803 func (m *LispAdjacenciesGet) Marshal(b []byte) ([]byte, error) {
 804         if b == nil {
 805                 b = make([]byte, m.Size())
 806         }
 807         buf := codec.NewBuffer(b)
 808         buf.EncodeUint32(m.Vni)
 809         return buf.Bytes(), nil
 810 }
 811 func (m *LispAdjacenciesGet) Unmarshal(b []byte) error {
 812         buf := codec.NewBuffer(b)
 813         m.Vni = buf.DecodeUint32()
 814         return nil
 815 }
 816
 817 // LispAdjacenciesGetReply defines message 'lisp_adjacencies_get_reply'.
 818 type LispAdjacenciesGetReply struct {
 819         Retval      int32           `binapi:"i32,name=retval" json:"retval,omitempty"`
 820         Count       uint32          `binapi:"u32,name=count" json:"-"`
 821         Adjacencies []LispAdjacency `binapi:"lisp_adjacency[count],name=adjacencies" json:"adjacencies,omitempty"`
 822 }
 823
 824 func (m *LispAdjacenciesGetReply) Reset()               { *m = LispAdjacenciesGetReply{} }
 825 func (*LispAdjacenciesGetReply) GetMessageName() string { return "lisp_adjacencies_get_reply" }
 826 func (*LispAdjacenciesGetReply) GetCrcString() string   { return "3f97bcdd" }
 827 func (*LispAdjacenciesGetReply) GetMessageType() api.MessageType {
 828         return api.ReplyMessage
 829 }
 830
 831 func (m *LispAdjacenciesGetReply) Size() (size int) {
 832         if m == nil {
 833                 return 0
 834         }
 835         size += 4 // m.Retval
 836         size += 4 // m.Count
 837         for j1 := 0; j1 < len(m.Adjacencies); j1++ {
 838                 var s1 LispAdjacency
 839                 _ = s1
 840                 if j1 < len(m.Adjacencies) {
 841                         s1 = m.Adjacencies[j1]
 842                 }
 843                 size += 1     // s1.Reid.Type
 844                 size += 1 * 6 // s1.Reid.Address
 845                 size += 1     // s1.Leid.Type
 846                 size += 1 * 6 // s1.Leid.Address
 847         }
 848         return size
 849 }
 850 func (m *LispAdjacenciesGetReply) Marshal(b []byte) ([]byte, error) {
 851         if b == nil {
 852                 b = make([]byte, m.Size())
 853         }
 854         buf := codec.NewBuffer(b)
 855         buf.EncodeInt32(m.Retval)
 856         buf.EncodeUint32(uint32(len(m.Adjacencies)))
 857         for j0 := 0; j0 < len(m.Adjacencies); j0++ {
 858                 var v0 LispAdjacency // Adjacencies
 859                 if j0 < len(m.Adjacencies) {
 860                         v0 = m.Adjacencies[j0]
 861                 }
 862                 buf.EncodeUint8(uint8(v0.Reid.Type))
 863                 buf.EncodeBytes(v0.Reid.Address.XXX_UnionData[:], 6)
 864                 buf.EncodeUint8(uint8(v0.Leid.Type))
 865                 buf.EncodeBytes(v0.Leid.Address.XXX_UnionData[:], 6)
 866         }
 867         return buf.Bytes(), nil
 868 }
 869 func (m *LispAdjacenciesGetReply) Unmarshal(b []byte) error {
 870         buf := codec.NewBuffer(b)
 871         m.Retval = buf.DecodeInt32()
 872         m.Count = buf.DecodeUint32()
 873         m.Adjacencies = make([]LispAdjacency, m.Count)
 874         for j0 := 0; j0 < len(m.Adjacencies); j0++ {
 875                 m.Adjacencies[j0].Reid.Type = lisp_types.EidType(buf.DecodeUint8())
 876                 copy(m.Adjacencies[j0].Reid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 877                 m.Adjacencies[j0].Leid.Type = lisp_types.EidType(buf.DecodeUint8())
 878                 copy(m.Adjacencies[j0].Leid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
 879         }
 880         return nil
 881 }
 882
 883 // LispEidTableAddDelMap defines message 'lisp_eid_table_add_del_map'.
 884 type LispEidTableAddDelMap struct {
 885         IsAdd   bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
 886         Vni     uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
 887         DpTable uint32 `binapi:"u32,name=dp_table" json:"dp_table,omitempty"`
 888         IsL2    bool   `binapi:"bool,name=is_l2" json:"is_l2,omitempty"`
 889 }
 890
 891 func (m *LispEidTableAddDelMap) Reset()               { *m = LispEidTableAddDelMap{} }
 892 func (*LispEidTableAddDelMap) GetMessageName() string { return "lisp_eid_table_add_del_map" }
 893 func (*LispEidTableAddDelMap) GetCrcString() string   { return "9481416b" }
 894 func (*LispEidTableAddDelMap) GetMessageType() api.MessageType {
 895         return api.RequestMessage
 896 }
 897
 898 func (m *LispEidTableAddDelMap) Size() (size int) {
 899         if m == nil {
 900                 return 0
 901         }
 902         size += 1 // m.IsAdd
 903         size += 4 // m.Vni
 904         size += 4 // m.DpTable
 905         size += 1 // m.IsL2
 906         return size
 907 }
 908 func (m *LispEidTableAddDelMap) Marshal(b []byte) ([]byte, error) {
 909         if b == nil {
 910                 b = make([]byte, m.Size())
 911         }
 912         buf := codec.NewBuffer(b)
 913         buf.EncodeBool(m.IsAdd)
 914         buf.EncodeUint32(m.Vni)
 915         buf.EncodeUint32(m.DpTable)
 916         buf.EncodeBool(m.IsL2)
 917         return buf.Bytes(), nil
 918 }
 919 func (m *LispEidTableAddDelMap) Unmarshal(b []byte) error {
 920         buf := codec.NewBuffer(b)
 921         m.IsAdd = buf.DecodeBool()
 922         m.Vni = buf.DecodeUint32()
 923         m.DpTable = buf.DecodeUint32()
 924         m.IsL2 = buf.DecodeBool()
 925         return nil
 926 }
 927
 928 // LispEidTableAddDelMapReply defines message 'lisp_eid_table_add_del_map_reply'.
 929 type LispEidTableAddDelMapReply struct {
 930         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 931 }
 932
 933 func (m *LispEidTableAddDelMapReply) Reset()               { *m = LispEidTableAddDelMapReply{} }
 934 func (*LispEidTableAddDelMapReply) GetMessageName() string { return "lisp_eid_table_add_del_map_reply" }
 935 func (*LispEidTableAddDelMapReply) GetCrcString() string   { return "e8d4e804" }
 936 func (*LispEidTableAddDelMapReply) GetMessageType() api.MessageType {
 937         return api.ReplyMessage
 938 }
 939
 940 func (m *LispEidTableAddDelMapReply) Size() (size int) {
 941         if m == nil {
 942                 return 0
 943         }
 944         size += 4 // m.Retval
 945         return size
 946 }
 947 func (m *LispEidTableAddDelMapReply) Marshal(b []byte) ([]byte, error) {
 948         if b == nil {
 949                 b = make([]byte, m.Size())
 950         }
 951         buf := codec.NewBuffer(b)
 952         buf.EncodeInt32(m.Retval)
 953         return buf.Bytes(), nil
 954 }
 955 func (m *LispEidTableAddDelMapReply) Unmarshal(b []byte) error {
 956         buf := codec.NewBuffer(b)
 957         m.Retval = buf.DecodeInt32()
 958         return nil
 959 }
 960
 961 // LispEidTableDetails defines message 'lisp_eid_table_details'.
 962 type LispEidTableDetails struct {
 963         LocatorSetIndex uint32             `binapi:"u32,name=locator_set_index" json:"locator_set_index,omitempty"`
 964         Action          uint8              `binapi:"u8,name=action" json:"action,omitempty"`
 965         IsLocal         bool               `binapi:"bool,name=is_local" json:"is_local,omitempty"`
 966         IsSrcDst        bool               `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
 967         Vni             uint32             `binapi:"u32,name=vni" json:"vni,omitempty"`
 968         Deid            lisp_types.Eid     `binapi:"eid,name=deid" json:"deid,omitempty"`
 969         Seid            lisp_types.Eid     `binapi:"eid,name=seid" json:"seid,omitempty"`
 970         TTL             uint32             `binapi:"u32,name=ttl" json:"ttl,omitempty"`
 971         Authoritative   uint8              `binapi:"u8,name=authoritative" json:"authoritative,omitempty"`
 972         Key             lisp_types.HmacKey `binapi:"hmac_key,name=key" json:"key,omitempty"`
 973 }
 974
 975 func (m *LispEidTableDetails) Reset()               { *m = LispEidTableDetails{} }
 976 func (*LispEidTableDetails) GetMessageName() string { return "lisp_eid_table_details" }
 977 func (*LispEidTableDetails) GetCrcString() string   { return "4bc32e3a" }
 978 func (*LispEidTableDetails) GetMessageType() api.MessageType {
 979         return api.ReplyMessage
 980 }
 981
 982 func (m *LispEidTableDetails) Size() (size int) {
 983         if m == nil {
 984                 return 0
 985         }
 986         size += 4      // m.LocatorSetIndex
 987         size += 1      // m.Action
 988         size += 1      // m.IsLocal
 989         size += 1      // m.IsSrcDst
 990         size += 4      // m.Vni
 991         size += 1      // m.Deid.Type
 992         size += 1 * 6  // m.Deid.Address
 993         size += 1      // m.Seid.Type
 994         size += 1 * 6  // m.Seid.Address
 995         size += 4      // m.TTL
 996         size += 1      // m.Authoritative
 997         size += 1      // m.Key.ID
 998         size += 1 * 64 // m.Key.Key
 999         return size
1000 }
1001 func (m *LispEidTableDetails) Marshal(b []byte) ([]byte, error) {
1002         if b == nil {
1003                 b = make([]byte, m.Size())
1004         }
1005         buf := codec.NewBuffer(b)
1006         buf.EncodeUint32(m.LocatorSetIndex)
1007         buf.EncodeUint8(m.Action)
1008         buf.EncodeBool(m.IsLocal)
1009         buf.EncodeBool(m.IsSrcDst)
1010         buf.EncodeUint32(m.Vni)
1011         buf.EncodeUint8(uint8(m.Deid.Type))
1012         buf.EncodeBytes(m.Deid.Address.XXX_UnionData[:], 6)
1013         buf.EncodeUint8(uint8(m.Seid.Type))
1014         buf.EncodeBytes(m.Seid.Address.XXX_UnionData[:], 6)
1015         buf.EncodeUint32(m.TTL)
1016         buf.EncodeUint8(m.Authoritative)
1017         buf.EncodeUint8(uint8(m.Key.ID))
1018         buf.EncodeBytes(m.Key.Key, 64)
1019         return buf.Bytes(), nil
1020 }
1021 func (m *LispEidTableDetails) Unmarshal(b []byte) error {
1022         buf := codec.NewBuffer(b)
1023         m.LocatorSetIndex = buf.DecodeUint32()
1024         m.Action = buf.DecodeUint8()
1025         m.IsLocal = buf.DecodeBool()
1026         m.IsSrcDst = buf.DecodeBool()
1027         m.Vni = buf.DecodeUint32()
1028         m.Deid.Type = lisp_types.EidType(buf.DecodeUint8())
1029         copy(m.Deid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
1030         m.Seid.Type = lisp_types.EidType(buf.DecodeUint8())
1031         copy(m.Seid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
1032         m.TTL = buf.DecodeUint32()
1033         m.Authoritative = buf.DecodeUint8()
1034         m.Key.ID = lisp_types.HmacKeyID(buf.DecodeUint8())
1035         m.Key.Key = make([]byte, 64)
1036         copy(m.Key.Key, buf.DecodeBytes(len(m.Key.Key)))
1037         return nil
1038 }
1039
1040 // LispEidTableDump defines message 'lisp_eid_table_dump'.
1041 type LispEidTableDump struct {
1042         EidSet       uint8                `binapi:"u8,name=eid_set" json:"eid_set,omitempty"`
1043         PrefixLength uint8                `binapi:"u8,name=prefix_length" json:"prefix_length,omitempty"`
1044         Vni          uint32               `binapi:"u32,name=vni" json:"vni,omitempty"`
1045         Eid          lisp_types.Eid       `binapi:"eid,name=eid" json:"eid,omitempty"`
1046         Filter       LispLocatorSetFilter `binapi:"lisp_locator_set_filter,name=filter" json:"filter,omitempty"`
1047 }
1048
1049 func (m *LispEidTableDump) Reset()               { *m = LispEidTableDump{} }
1050 func (*LispEidTableDump) GetMessageName() string { return "lisp_eid_table_dump" }
1051 func (*LispEidTableDump) GetCrcString() string   { return "b959b73b" }
1052 func (*LispEidTableDump) GetMessageType() api.MessageType {
1053         return api.RequestMessage
1054 }
1055
1056 func (m *LispEidTableDump) Size() (size int) {
1057         if m == nil {
1058                 return 0
1059         }
1060         size += 1     // m.EidSet
1061         size += 1     // m.PrefixLength
1062         size += 4     // m.Vni
1063         size += 1     // m.Eid.Type
1064         size += 1 * 6 // m.Eid.Address
1065         size += 1     // m.Filter
1066         return size
1067 }
1068 func (m *LispEidTableDump) Marshal(b []byte) ([]byte, error) {
1069         if b == nil {
1070                 b = make([]byte, m.Size())
1071         }
1072         buf := codec.NewBuffer(b)
1073         buf.EncodeUint8(m.EidSet)
1074         buf.EncodeUint8(m.PrefixLength)
1075         buf.EncodeUint32(m.Vni)
1076         buf.EncodeUint8(uint8(m.Eid.Type))
1077         buf.EncodeBytes(m.Eid.Address.XXX_UnionData[:], 6)
1078         buf.EncodeUint8(uint8(m.Filter))
1079         return buf.Bytes(), nil
1080 }
1081 func (m *LispEidTableDump) Unmarshal(b []byte) error {
1082         buf := codec.NewBuffer(b)
1083         m.EidSet = buf.DecodeUint8()
1084         m.PrefixLength = buf.DecodeUint8()
1085         m.Vni = buf.DecodeUint32()
1086         m.Eid.Type = lisp_types.EidType(buf.DecodeUint8())
1087         copy(m.Eid.Address.XXX_UnionData[:], buf.DecodeBytes(6))
1088         m.Filter = LispLocatorSetFilter(buf.DecodeUint8())
1089         return nil
1090 }
1091
1092 // LispEidTableMapDetails defines message 'lisp_eid_table_map_details'.
1093 type LispEidTableMapDetails struct {
1094         Vni     uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
1095         DpTable uint32 `binapi:"u32,name=dp_table" json:"dp_table,omitempty"`
1096 }
1097
1098 func (m *LispEidTableMapDetails) Reset()               { *m = LispEidTableMapDetails{} }
1099 func (*LispEidTableMapDetails) GetMessageName() string { return "lisp_eid_table_map_details" }
1100 func (*LispEidTableMapDetails) GetCrcString() string   { return "0b6859e2" }
1101 func (*LispEidTableMapDetails) GetMessageType() api.MessageType {
1102         return api.ReplyMessage
1103 }
1104
1105 func (m *LispEidTableMapDetails) Size() (size int) {
1106         if m == nil {
1107                 return 0
1108         }
1109         size += 4 // m.Vni
1110         size += 4 // m.DpTable
1111         return size
1112 }
1113 func (m *LispEidTableMapDetails) Marshal(b []byte) ([]byte, error) {
1114         if b == nil {
1115                 b = make([]byte, m.Size())
1116         }
1117         buf := codec.NewBuffer(b)
1118         buf.EncodeUint32(m.Vni)
1119         buf.EncodeUint32(m.DpTable)
1120         return buf.Bytes(), nil
1121 }
1122 func (m *LispEidTableMapDetails) Unmarshal(b []byte) error {
1123         buf := codec.NewBuffer(b)
1124         m.Vni = buf.DecodeUint32()
1125         m.DpTable = buf.DecodeUint32()
1126         return nil
1127 }
1128
1129 // LispEidTableMapDump defines message 'lisp_eid_table_map_dump'.
1130 type LispEidTableMapDump struct {
1131         IsL2 bool `binapi:"bool,name=is_l2" json:"is_l2,omitempty"`
1132 }
1133
1134 func (m *LispEidTableMapDump) Reset()               { *m = LispEidTableMapDump{} }
1135 func (*LispEidTableMapDump) GetMessageName() string { return "lisp_eid_table_map_dump" }
1136 func (*LispEidTableMapDump) GetCrcString() string   { return "d6cf0c3d" }
1137 func (*LispEidTableMapDump) GetMessageType() api.MessageType {
1138         return api.RequestMessage
1139 }
1140
1141 func (m *LispEidTableMapDump) Size() (size int) {
1142         if m == nil {
1143                 return 0
1144         }
1145         size += 1 // m.IsL2
1146         return size
1147 }
1148 func (m *LispEidTableMapDump) Marshal(b []byte) ([]byte, error) {
1149         if b == nil {
1150                 b = make([]byte, m.Size())
1151         }
1152         buf := codec.NewBuffer(b)
1153         buf.EncodeBool(m.IsL2)
1154         return buf.Bytes(), nil
1155 }
1156 func (m *LispEidTableMapDump) Unmarshal(b []byte) error {
1157         buf := codec.NewBuffer(b)
1158         m.IsL2 = buf.DecodeBool()
1159         return nil
1160 }
1161
1162 // LispEidTableVniDetails defines message 'lisp_eid_table_vni_details'.
1163 type LispEidTableVniDetails struct {
1164         Vni uint32 `binapi:"u32,name=vni" json:"vni,omitempty"`
1165 }
1166
1167 func (m *LispEidTableVniDetails) Reset()               { *m = LispEidTableVniDetails{} }
1168 func (*LispEidTableVniDetails) GetMessageName() string { return "lisp_eid_table_vni_details" }
1169 func (*LispEidTableVniDetails) GetCrcString() string   { return "64abc01e" }
1170 func (*LispEidTableVniDetails) GetMessageType() api.MessageType {
1171         return api.ReplyMessage
1172 }
1173
1174 func (m *LispEidTableVniDetails) Size() (size int) {
1175         if m == nil {
1176                 return 0
1177         }
1178         size += 4 // m.Vni
1179         return size
1180 }
1181 func (m *LispEidTableVniDetails) Marshal(b []byte) ([]byte, error) {
1182         if b == nil {
1183                 b = make([]byte, m.Size())
1184         }
1185         buf := codec.NewBuffer(b)
1186         buf.EncodeUint32(m.Vni)
1187         return buf.Bytes(), nil
1188 }
1189 func (m *LispEidTableVniDetails) Unmarshal(b []byte) error {
1190         buf := codec.NewBuffer(b)
1191         m.Vni = buf.DecodeUint32()
1192         return nil
1193 }
1194
1195 // LispEidTableVniDump defines message 'lisp_eid_table_vni_dump'.
1196 type LispEidTableVniDump struct{}
1197
1198 func (m *LispEidTableVniDump) Reset()               { *m = LispEidTableVniDump{} }
1199 func (*LispEidTableVniDump) GetMessageName() string { return "lisp_eid_table_vni_dump" }
1200 func (*LispEidTableVniDump) GetCrcString() string   { return "51077d14" }
1201 func (*LispEidTableVniDump) GetMessageType() api.MessageType {
1202         return api.RequestMessage
1203 }
1204
1205 func (m *LispEidTableVniDump) Size() (size int) {
1206         if m == nil {
1207                 return 0
1208         }
1209         return size
1210 }
1211 func (m *LispEidTableVniDump) Marshal(b []byte) ([]byte, error) {
1212         if b == nil {
1213                 b = make([]byte, m.Size())
1214         }
1215         buf := codec.NewBuffer(b)
1216         return buf.Bytes(), nil
1217 }
1218 func (m *LispEidTableVniDump) Unmarshal(b []byte) error {
1219         return nil
1220 }
1221
1222 // LispEnableDisable defines message 'lisp_enable_disable'.
1223 type LispEnableDisable struct {
1224         IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
1225 }
1226
1227 func (m *LispEnableDisable) Reset()               { *m = LispEnableDisable{} }
1228 func (*LispEnableDisable) GetMessageName() string { return "lisp_enable_disable" }
1229 func (*LispEnableDisable) GetCrcString() string   { return "c264d7bf" }
1230 func (*LispEnableDisable) GetMessageType() api.MessageType {
1231         return api.RequestMessage
1232 }
1233
1234 func (m *LispEnableDisable) Size() (size int) {
1235         if m == nil {
1236                 return 0
1237         }
1238         size += 1 // m.IsEnable
1239         return size
1240 }
1241 func (m *LispEnableDisable) Marshal(b []byte) ([]byte, error) {
1242         if b == nil {
1243                 b = make([]byte, m.Size())
1244         }
1245         buf := codec.NewBuffer(b)
1246         buf.EncodeBool(m.IsEnable)
1247         return buf.Bytes(), nil
1248 }
1249 func (m *LispEnableDisable) Unmarshal(b []byte) error {
1250         buf := codec.NewBuffer(b)
1251         m.IsEnable = buf.DecodeBool()
1252         return nil
1253 }
1254
1255 // LispEnableDisableReply defines message 'lisp_enable_disable_reply'.
1256 type LispEnableDisableReply struct {
1257         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1258 }
1259
1260 func (m *LispEnableDisableReply) Reset()               { *m = LispEnableDisableReply{} }
1261 func (*LispEnableDisableReply) GetMessageName() string { return "lisp_enable_disable_reply" }
1262 func (*LispEnableDisableReply) GetCrcString() string   { return "e8d4e804" }
1263 func (*LispEnableDisableReply) GetMessageType() api.MessageType {
1264         return api.ReplyMessage
1265 }
1266
1267 func (m *LispEnableDisableReply) Size() (size int) {
1268         if m == nil {
1269                 return 0
1270         }
1271         size += 4 // m.Retval
1272         return size
1273 }
1274 func (m *LispEnableDisableReply) Marshal(b []byte) ([]byte, error) {
1275         if b == nil {
1276                 b = make([]byte, m.Size())
1277         }
1278         buf := codec.NewBuffer(b)
1279         buf.EncodeInt32(m.Retval)
1280         return buf.Bytes(), nil
1281 }
1282 func (m *LispEnableDisableReply) Unmarshal(b []byte) error {
1283         buf := codec.NewBuffer(b)
1284         m.Retval = buf.DecodeInt32()
1285         return nil
1286 }
1287
1288 // LispGetMapRequestItrRlocs defines message 'lisp_get_map_request_itr_rlocs'.
1289 type LispGetMapRequestItrRlocs struct{}
1290
1291 func (m *LispGetMapRequestItrRlocs) Reset()               { *m = LispGetMapRequestItrRlocs{} }
1292 func (*LispGetMapRequestItrRlocs) GetMessageName() string { return "lisp_get_map_request_itr_rlocs" }
1293 func (*LispGetMapRequestItrRlocs) GetCrcString() string   { return "51077d14" }
1294 func (*LispGetMapRequestItrRlocs) GetMessageType() api.MessageType {
1295         return api.RequestMessage
1296 }
1297
1298 func (m *LispGetMapRequestItrRlocs) Size() (size int) {
1299         if m == nil {
1300                 return 0
1301         }
1302         return size
1303 }
1304 func (m *LispGetMapRequestItrRlocs) Marshal(b []byte) ([]byte, error) {
1305         if b == nil {
1306                 b = make([]byte, m.Size())
1307         }
1308         buf := codec.NewBuffer(b)
1309         return buf.Bytes(), nil
1310 }
1311 func (m *LispGetMapRequestItrRlocs) Unmarshal(b []byte) error {
1312         return nil
1313 }
1314
1315 // LispGetMapRequestItrRlocsReply defines message 'lisp_get_map_request_itr_rlocs_reply'.
1316 type LispGetMapRequestItrRlocsReply struct {
1317         Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
1318         LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
1319 }
1320
1321 func (m *LispGetMapRequestItrRlocsReply) Reset() { *m = LispGetMapRequestItrRlocsReply{} }
1322 func (*LispGetMapRequestItrRlocsReply) GetMessageName() string {
1323         return "lisp_get_map_request_itr_rlocs_reply"
1324 }
1325 func (*LispGetMapRequestItrRlocsReply) GetCrcString() string { return "76580f3a" }
1326 func (*LispGetMapRequestItrRlocsReply) GetMessageType() api.MessageType {
1327         return api.ReplyMessage
1328 }
1329
1330 func (m *LispGetMapRequestItrRlocsReply) Size() (size int) {
1331         if m == nil {
1332                 return 0
1333         }
1334         size += 4  // m.Retval
1335         size += 64 // m.LocatorSetName
1336         return size
1337 }
1338 func (m *LispGetMapRequestItrRlocsReply) Marshal(b []byte) ([]byte, error) {
1339         if b == nil {
1340                 b = make([]byte, m.Size())
1341         }
1342         buf := codec.NewBuffer(b)
1343         buf.EncodeInt32(m.Retval)
1344         buf.EncodeString(m.LocatorSetName, 64)
1345         return buf.Bytes(), nil
1346 }
1347 func (m *LispGetMapRequestItrRlocsReply) Unmarshal(b []byte) error {
1348         buf := codec.NewBuffer(b)
1349         m.Retval = buf.DecodeInt32()
1350         m.LocatorSetName = buf.DecodeString(64)
1351         return nil
1352 }
1353
1354 // LispLocatorDetails defines message 'lisp_locator_details'.
1355 type LispLocatorDetails struct {
1356         Local     uint8                          `binapi:"u8,name=local" json:"local,omitempty"`
1357         SwIfIndex interface_types.InterfaceIndex `binapi:"interface_index,name=sw_if_index" json:"sw_if_index,omitempty"`
1358         IPAddress ip_types.Address               `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
1359         Priority  uint8                          `binapi:"u8,name=priority" json:"priority,omitempty"`
1360         Weight    uint8                          `binapi:"u8,name=weight" json:"weight,omitempty"`
1361 }
1362
1363 func (m *LispLocatorDetails) Reset()               { *m = LispLocatorDetails{} }
1364 func (*LispLocatorDetails) GetMessageName() string { return "lisp_locator_details" }
1365 func (*LispLocatorDetails) GetCrcString() string   { return "c0c4c2a7" }
1366 func (*LispLocatorDetails) GetMessageType() api.MessageType {
1367         return api.ReplyMessage
1368 }
1369
1370 func (m *LispLocatorDetails) Size() (size int) {
1371         if m == nil {
1372                 return 0
1373         }
1374         size += 1      // m.Local
1375         size += 4      // m.SwIfIndex
1376         size += 1      // m.IPAddress.Af
1377         size += 1 * 16 // m.IPAddress.Un
1378         size += 1      // m.Priority
1379         size += 1      // m.Weight
1380         return size
1381 }
1382 func (m *LispLocatorDetails) Marshal(b []byte) ([]byte, error) {
1383         if b == nil {
1384                 b = make([]byte, m.Size())
1385         }
1386         buf := codec.NewBuffer(b)
1387         buf.EncodeUint8(m.Local)
1388         buf.EncodeUint32(uint32(m.SwIfIndex))
1389         buf.EncodeUint8(uint8(m.IPAddress.Af))
1390         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
1391         buf.EncodeUint8(m.Priority)
1392         buf.EncodeUint8(m.Weight)
1393         return buf.Bytes(), nil
1394 }
1395 func (m *LispLocatorDetails) Unmarshal(b []byte) error {
1396         buf := codec.NewBuffer(b)
1397         m.Local = buf.DecodeUint8()
1398         m.SwIfIndex = interface_types.InterfaceIndex(buf.DecodeUint32())
1399         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1400         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1401         m.Priority = buf.DecodeUint8()
1402         m.Weight = buf.DecodeUint8()
1403         return nil
1404 }
1405
1406 // LispLocatorDump defines message 'lisp_locator_dump'.
1407 type LispLocatorDump struct {
1408         LsIndex    uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
1409         LsName     string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
1410         IsIndexSet uint8  `binapi:"u8,name=is_index_set" json:"is_index_set,omitempty"`
1411 }
1412
1413 func (m *LispLocatorDump) Reset()               { *m = LispLocatorDump{} }
1414 func (*LispLocatorDump) GetMessageName() string { return "lisp_locator_dump" }
1415 func (*LispLocatorDump) GetCrcString() string   { return "b954fad7" }
1416 func (*LispLocatorDump) GetMessageType() api.MessageType {
1417         return api.RequestMessage
1418 }
1419
1420 func (m *LispLocatorDump) Size() (size int) {
1421         if m == nil {
1422                 return 0
1423         }
1424         size += 4  // m.LsIndex
1425         size += 64 // m.LsName
1426         size += 1  // m.IsIndexSet
1427         return size
1428 }
1429 func (m *LispLocatorDump) Marshal(b []byte) ([]byte, error) {
1430         if b == nil {
1431                 b = make([]byte, m.Size())
1432         }
1433         buf := codec.NewBuffer(b)
1434         buf.EncodeUint32(m.LsIndex)
1435         buf.EncodeString(m.LsName, 64)
1436         buf.EncodeUint8(m.IsIndexSet)
1437         return buf.Bytes(), nil
1438 }
1439 func (m *LispLocatorDump) Unmarshal(b []byte) error {
1440         buf := codec.NewBuffer(b)
1441         m.LsIndex = buf.DecodeUint32()
1442         m.LsName = buf.DecodeString(64)
1443         m.IsIndexSet = buf.DecodeUint8()
1444         return nil
1445 }
1446
1447 // LispLocatorSetDetails defines message 'lisp_locator_set_details'.
1448 type LispLocatorSetDetails struct {
1449         LsIndex uint32 `binapi:"u32,name=ls_index" json:"ls_index,omitempty"`
1450         LsName  string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
1451 }
1452
1453 func (m *LispLocatorSetDetails) Reset()               { *m = LispLocatorSetDetails{} }
1454 func (*LispLocatorSetDetails) GetMessageName() string { return "lisp_locator_set_details" }
1455 func (*LispLocatorSetDetails) GetCrcString() string   { return "5b33a105" }
1456 func (*LispLocatorSetDetails) GetMessageType() api.MessageType {
1457         return api.ReplyMessage
1458 }
1459
1460 func (m *LispLocatorSetDetails) Size() (size int) {
1461         if m == nil {
1462                 return 0
1463         }
1464         size += 4  // m.LsIndex
1465         size += 64 // m.LsName
1466         return size
1467 }
1468 func (m *LispLocatorSetDetails) Marshal(b []byte) ([]byte, error) {
1469         if b == nil {
1470                 b = make([]byte, m.Size())
1471         }
1472         buf := codec.NewBuffer(b)
1473         buf.EncodeUint32(m.LsIndex)
1474         buf.EncodeString(m.LsName, 64)
1475         return buf.Bytes(), nil
1476 }
1477 func (m *LispLocatorSetDetails) Unmarshal(b []byte) error {
1478         buf := codec.NewBuffer(b)
1479         m.LsIndex = buf.DecodeUint32()
1480         m.LsName = buf.DecodeString(64)
1481         return nil
1482 }
1483
1484 // LispLocatorSetDump defines message 'lisp_locator_set_dump'.
1485 type LispLocatorSetDump struct {
1486         Filter LispLocatorSetFilter `binapi:"lisp_locator_set_filter,name=filter" json:"filter,omitempty"`
1487 }
1488
1489 func (m *LispLocatorSetDump) Reset()               { *m = LispLocatorSetDump{} }
1490 func (*LispLocatorSetDump) GetMessageName() string { return "lisp_locator_set_dump" }
1491 func (*LispLocatorSetDump) GetCrcString() string   { return "c2cb5922" }
1492 func (*LispLocatorSetDump) GetMessageType() api.MessageType {
1493         return api.RequestMessage
1494 }
1495
1496 func (m *LispLocatorSetDump) Size() (size int) {
1497         if m == nil {
1498                 return 0
1499         }
1500         size += 1 // m.Filter
1501         return size
1502 }
1503 func (m *LispLocatorSetDump) Marshal(b []byte) ([]byte, error) {
1504         if b == nil {
1505                 b = make([]byte, m.Size())
1506         }
1507         buf := codec.NewBuffer(b)
1508         buf.EncodeUint8(uint8(m.Filter))
1509         return buf.Bytes(), nil
1510 }
1511 func (m *LispLocatorSetDump) Unmarshal(b []byte) error {
1512         buf := codec.NewBuffer(b)
1513         m.Filter = LispLocatorSetFilter(buf.DecodeUint8())
1514         return nil
1515 }
1516
1517 // LispMapRegisterEnableDisable defines message 'lisp_map_register_enable_disable'.
1518 type LispMapRegisterEnableDisable struct {
1519         IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
1520 }
1521
1522 func (m *LispMapRegisterEnableDisable) Reset() { *m = LispMapRegisterEnableDisable{} }
1523 func (*LispMapRegisterEnableDisable) GetMessageName() string {
1524         return "lisp_map_register_enable_disable"
1525 }
1526 func (*LispMapRegisterEnableDisable) GetCrcString() string { return "c264d7bf" }
1527 func (*LispMapRegisterEnableDisable) GetMessageType() api.MessageType {
1528         return api.RequestMessage
1529 }
1530
1531 func (m *LispMapRegisterEnableDisable) Size() (size int) {
1532         if m == nil {
1533                 return 0
1534         }
1535         size += 1 // m.IsEnable
1536         return size
1537 }
1538 func (m *LispMapRegisterEnableDisable) Marshal(b []byte) ([]byte, error) {
1539         if b == nil {
1540                 b = make([]byte, m.Size())
1541         }
1542         buf := codec.NewBuffer(b)
1543         buf.EncodeBool(m.IsEnable)
1544         return buf.Bytes(), nil
1545 }
1546 func (m *LispMapRegisterEnableDisable) Unmarshal(b []byte) error {
1547         buf := codec.NewBuffer(b)
1548         m.IsEnable = buf.DecodeBool()
1549         return nil
1550 }
1551
1552 // LispMapRegisterEnableDisableReply defines message 'lisp_map_register_enable_disable_reply'.
1553 type LispMapRegisterEnableDisableReply struct {
1554         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1555 }
1556
1557 func (m *LispMapRegisterEnableDisableReply) Reset() { *m = LispMapRegisterEnableDisableReply{} }
1558 func (*LispMapRegisterEnableDisableReply) GetMessageName() string {
1559         return "lisp_map_register_enable_disable_reply"
1560 }
1561 func (*LispMapRegisterEnableDisableReply) GetCrcString() string { return "e8d4e804" }
1562 func (*LispMapRegisterEnableDisableReply) GetMessageType() api.MessageType {
1563         return api.ReplyMessage
1564 }
1565
1566 func (m *LispMapRegisterEnableDisableReply) Size() (size int) {
1567         if m == nil {
1568                 return 0
1569         }
1570         size += 4 // m.Retval
1571         return size
1572 }
1573 func (m *LispMapRegisterEnableDisableReply) Marshal(b []byte) ([]byte, error) {
1574         if b == nil {
1575                 b = make([]byte, m.Size())
1576         }
1577         buf := codec.NewBuffer(b)
1578         buf.EncodeInt32(m.Retval)
1579         return buf.Bytes(), nil
1580 }
1581 func (m *LispMapRegisterEnableDisableReply) Unmarshal(b []byte) error {
1582         buf := codec.NewBuffer(b)
1583         m.Retval = buf.DecodeInt32()
1584         return nil
1585 }
1586
1587 // LispMapRequestMode defines message 'lisp_map_request_mode'.
1588 type LispMapRequestMode struct {
1589         IsSrcDst bool `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
1590 }
1591
1592 func (m *LispMapRequestMode) Reset()               { *m = LispMapRequestMode{} }
1593 func (*LispMapRequestMode) GetMessageName() string { return "lisp_map_request_mode" }
1594 func (*LispMapRequestMode) GetCrcString() string   { return "f43c26ae" }
1595 func (*LispMapRequestMode) GetMessageType() api.MessageType {
1596         return api.RequestMessage
1597 }
1598
1599 func (m *LispMapRequestMode) Size() (size int) {
1600         if m == nil {
1601                 return 0
1602         }
1603         size += 1 // m.IsSrcDst
1604         return size
1605 }
1606 func (m *LispMapRequestMode) Marshal(b []byte) ([]byte, error) {
1607         if b == nil {
1608                 b = make([]byte, m.Size())
1609         }
1610         buf := codec.NewBuffer(b)
1611         buf.EncodeBool(m.IsSrcDst)
1612         return buf.Bytes(), nil
1613 }
1614 func (m *LispMapRequestMode) Unmarshal(b []byte) error {
1615         buf := codec.NewBuffer(b)
1616         m.IsSrcDst = buf.DecodeBool()
1617         return nil
1618 }
1619
1620 // LispMapRequestModeReply defines message 'lisp_map_request_mode_reply'.
1621 type LispMapRequestModeReply struct {
1622         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1623 }
1624
1625 func (m *LispMapRequestModeReply) Reset()               { *m = LispMapRequestModeReply{} }
1626 func (*LispMapRequestModeReply) GetMessageName() string { return "lisp_map_request_mode_reply" }
1627 func (*LispMapRequestModeReply) GetCrcString() string   { return "e8d4e804" }
1628 func (*LispMapRequestModeReply) GetMessageType() api.MessageType {
1629         return api.ReplyMessage
1630 }
1631
1632 func (m *LispMapRequestModeReply) Size() (size int) {
1633         if m == nil {
1634                 return 0
1635         }
1636         size += 4 // m.Retval
1637         return size
1638 }
1639 func (m *LispMapRequestModeReply) Marshal(b []byte) ([]byte, error) {
1640         if b == nil {
1641                 b = make([]byte, m.Size())
1642         }
1643         buf := codec.NewBuffer(b)
1644         buf.EncodeInt32(m.Retval)
1645         return buf.Bytes(), nil
1646 }
1647 func (m *LispMapRequestModeReply) Unmarshal(b []byte) error {
1648         buf := codec.NewBuffer(b)
1649         m.Retval = buf.DecodeInt32()
1650         return nil
1651 }
1652
1653 // LispMapResolverDetails defines message 'lisp_map_resolver_details'.
1654 type LispMapResolverDetails struct {
1655         IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
1656 }
1657
1658 func (m *LispMapResolverDetails) Reset()               { *m = LispMapResolverDetails{} }
1659 func (*LispMapResolverDetails) GetMessageName() string { return "lisp_map_resolver_details" }
1660 func (*LispMapResolverDetails) GetCrcString() string   { return "82a09deb" }
1661 func (*LispMapResolverDetails) GetMessageType() api.MessageType {
1662         return api.ReplyMessage
1663 }
1664
1665 func (m *LispMapResolverDetails) Size() (size int) {
1666         if m == nil {
1667                 return 0
1668         }
1669         size += 1      // m.IPAddress.Af
1670         size += 1 * 16 // m.IPAddress.Un
1671         return size
1672 }
1673 func (m *LispMapResolverDetails) Marshal(b []byte) ([]byte, error) {
1674         if b == nil {
1675                 b = make([]byte, m.Size())
1676         }
1677         buf := codec.NewBuffer(b)
1678         buf.EncodeUint8(uint8(m.IPAddress.Af))
1679         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
1680         return buf.Bytes(), nil
1681 }
1682 func (m *LispMapResolverDetails) Unmarshal(b []byte) error {
1683         buf := codec.NewBuffer(b)
1684         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1685         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1686         return nil
1687 }
1688
1689 // LispMapResolverDump defines message 'lisp_map_resolver_dump'.
1690 type LispMapResolverDump struct{}
1691
1692 func (m *LispMapResolverDump) Reset()               { *m = LispMapResolverDump{} }
1693 func (*LispMapResolverDump) GetMessageName() string { return "lisp_map_resolver_dump" }
1694 func (*LispMapResolverDump) GetCrcString() string   { return "51077d14" }
1695 func (*LispMapResolverDump) GetMessageType() api.MessageType {
1696         return api.RequestMessage
1697 }
1698
1699 func (m *LispMapResolverDump) Size() (size int) {
1700         if m == nil {
1701                 return 0
1702         }
1703         return size
1704 }
1705 func (m *LispMapResolverDump) Marshal(b []byte) ([]byte, error) {
1706         if b == nil {
1707                 b = make([]byte, m.Size())
1708         }
1709         buf := codec.NewBuffer(b)
1710         return buf.Bytes(), nil
1711 }
1712 func (m *LispMapResolverDump) Unmarshal(b []byte) error {
1713         return nil
1714 }
1715
1716 // LispMapServerDetails defines message 'lisp_map_server_details'.
1717 type LispMapServerDetails struct {
1718         IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
1719 }
1720
1721 func (m *LispMapServerDetails) Reset()               { *m = LispMapServerDetails{} }
1722 func (*LispMapServerDetails) GetMessageName() string { return "lisp_map_server_details" }
1723 func (*LispMapServerDetails) GetCrcString() string   { return "82a09deb" }
1724 func (*LispMapServerDetails) GetMessageType() api.MessageType {
1725         return api.ReplyMessage
1726 }
1727
1728 func (m *LispMapServerDetails) Size() (size int) {
1729         if m == nil {
1730                 return 0
1731         }
1732         size += 1      // m.IPAddress.Af
1733         size += 1 * 16 // m.IPAddress.Un
1734         return size
1735 }
1736 func (m *LispMapServerDetails) Marshal(b []byte) ([]byte, error) {
1737         if b == nil {
1738                 b = make([]byte, m.Size())
1739         }
1740         buf := codec.NewBuffer(b)
1741         buf.EncodeUint8(uint8(m.IPAddress.Af))
1742         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
1743         return buf.Bytes(), nil
1744 }
1745 func (m *LispMapServerDetails) Unmarshal(b []byte) error {
1746         buf := codec.NewBuffer(b)
1747         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1748         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1749         return nil
1750 }
1751
1752 // LispMapServerDump defines message 'lisp_map_server_dump'.
1753 type LispMapServerDump struct{}
1754
1755 func (m *LispMapServerDump) Reset()               { *m = LispMapServerDump{} }
1756 func (*LispMapServerDump) GetMessageName() string { return "lisp_map_server_dump" }
1757 func (*LispMapServerDump) GetCrcString() string   { return "51077d14" }
1758 func (*LispMapServerDump) GetMessageType() api.MessageType {
1759         return api.RequestMessage
1760 }
1761
1762 func (m *LispMapServerDump) Size() (size int) {
1763         if m == nil {
1764                 return 0
1765         }
1766         return size
1767 }
1768 func (m *LispMapServerDump) Marshal(b []byte) ([]byte, error) {
1769         if b == nil {
1770                 b = make([]byte, m.Size())
1771         }
1772         buf := codec.NewBuffer(b)
1773         return buf.Bytes(), nil
1774 }
1775 func (m *LispMapServerDump) Unmarshal(b []byte) error {
1776         return nil
1777 }
1778
1779 // LispPitrSetLocatorSet defines message 'lisp_pitr_set_locator_set'.
1780 type LispPitrSetLocatorSet struct {
1781         IsAdd  bool   `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1782         LsName string `binapi:"string[64],name=ls_name" json:"ls_name,omitempty"`
1783 }
1784
1785 func (m *LispPitrSetLocatorSet) Reset()               { *m = LispPitrSetLocatorSet{} }
1786 func (*LispPitrSetLocatorSet) GetMessageName() string { return "lisp_pitr_set_locator_set" }
1787 func (*LispPitrSetLocatorSet) GetCrcString() string   { return "486e2b76" }
1788 func (*LispPitrSetLocatorSet) GetMessageType() api.MessageType {
1789         return api.RequestMessage
1790 }
1791
1792 func (m *LispPitrSetLocatorSet) Size() (size int) {
1793         if m == nil {
1794                 return 0
1795         }
1796         size += 1  // m.IsAdd
1797         size += 64 // m.LsName
1798         return size
1799 }
1800 func (m *LispPitrSetLocatorSet) Marshal(b []byte) ([]byte, error) {
1801         if b == nil {
1802                 b = make([]byte, m.Size())
1803         }
1804         buf := codec.NewBuffer(b)
1805         buf.EncodeBool(m.IsAdd)
1806         buf.EncodeString(m.LsName, 64)
1807         return buf.Bytes(), nil
1808 }
1809 func (m *LispPitrSetLocatorSet) Unmarshal(b []byte) error {
1810         buf := codec.NewBuffer(b)
1811         m.IsAdd = buf.DecodeBool()
1812         m.LsName = buf.DecodeString(64)
1813         return nil
1814 }
1815
1816 // LispPitrSetLocatorSetReply defines message 'lisp_pitr_set_locator_set_reply'.
1817 type LispPitrSetLocatorSetReply struct {
1818         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1819 }
1820
1821 func (m *LispPitrSetLocatorSetReply) Reset()               { *m = LispPitrSetLocatorSetReply{} }
1822 func (*LispPitrSetLocatorSetReply) GetMessageName() string { return "lisp_pitr_set_locator_set_reply" }
1823 func (*LispPitrSetLocatorSetReply) GetCrcString() string   { return "e8d4e804" }
1824 func (*LispPitrSetLocatorSetReply) GetMessageType() api.MessageType {
1825         return api.ReplyMessage
1826 }
1827
1828 func (m *LispPitrSetLocatorSetReply) Size() (size int) {
1829         if m == nil {
1830                 return 0
1831         }
1832         size += 4 // m.Retval
1833         return size
1834 }
1835 func (m *LispPitrSetLocatorSetReply) Marshal(b []byte) ([]byte, error) {
1836         if b == nil {
1837                 b = make([]byte, m.Size())
1838         }
1839         buf := codec.NewBuffer(b)
1840         buf.EncodeInt32(m.Retval)
1841         return buf.Bytes(), nil
1842 }
1843 func (m *LispPitrSetLocatorSetReply) Unmarshal(b []byte) error {
1844         buf := codec.NewBuffer(b)
1845         m.Retval = buf.DecodeInt32()
1846         return nil
1847 }
1848
1849 // LispRlocProbeEnableDisable defines message 'lisp_rloc_probe_enable_disable'.
1850 type LispRlocProbeEnableDisable struct {
1851         IsEnable bool `binapi:"bool,name=is_enable,default=true" json:"is_enable,omitempty"`
1852 }
1853
1854 func (m *LispRlocProbeEnableDisable) Reset()               { *m = LispRlocProbeEnableDisable{} }
1855 func (*LispRlocProbeEnableDisable) GetMessageName() string { return "lisp_rloc_probe_enable_disable" }
1856 func (*LispRlocProbeEnableDisable) GetCrcString() string   { return "c264d7bf" }
1857 func (*LispRlocProbeEnableDisable) GetMessageType() api.MessageType {
1858         return api.RequestMessage
1859 }
1860
1861 func (m *LispRlocProbeEnableDisable) Size() (size int) {
1862         if m == nil {
1863                 return 0
1864         }
1865         size += 1 // m.IsEnable
1866         return size
1867 }
1868 func (m *LispRlocProbeEnableDisable) Marshal(b []byte) ([]byte, error) {
1869         if b == nil {
1870                 b = make([]byte, m.Size())
1871         }
1872         buf := codec.NewBuffer(b)
1873         buf.EncodeBool(m.IsEnable)
1874         return buf.Bytes(), nil
1875 }
1876 func (m *LispRlocProbeEnableDisable) Unmarshal(b []byte) error {
1877         buf := codec.NewBuffer(b)
1878         m.IsEnable = buf.DecodeBool()
1879         return nil
1880 }
1881
1882 // LispRlocProbeEnableDisableReply defines message 'lisp_rloc_probe_enable_disable_reply'.
1883 type LispRlocProbeEnableDisableReply struct {
1884         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1885 }
1886
1887 func (m *LispRlocProbeEnableDisableReply) Reset() { *m = LispRlocProbeEnableDisableReply{} }
1888 func (*LispRlocProbeEnableDisableReply) GetMessageName() string {
1889         return "lisp_rloc_probe_enable_disable_reply"
1890 }
1891 func (*LispRlocProbeEnableDisableReply) GetCrcString() string { return "e8d4e804" }
1892 func (*LispRlocProbeEnableDisableReply) GetMessageType() api.MessageType {
1893         return api.ReplyMessage
1894 }
1895
1896 func (m *LispRlocProbeEnableDisableReply) Size() (size int) {
1897         if m == nil {
1898                 return 0
1899         }
1900         size += 4 // m.Retval
1901         return size
1902 }
1903 func (m *LispRlocProbeEnableDisableReply) Marshal(b []byte) ([]byte, error) {
1904         if b == nil {
1905                 b = make([]byte, m.Size())
1906         }
1907         buf := codec.NewBuffer(b)
1908         buf.EncodeInt32(m.Retval)
1909         return buf.Bytes(), nil
1910 }
1911 func (m *LispRlocProbeEnableDisableReply) Unmarshal(b []byte) error {
1912         buf := codec.NewBuffer(b)
1913         m.Retval = buf.DecodeInt32()
1914         return nil
1915 }
1916
1917 // LispUsePetr defines message 'lisp_use_petr'.
1918 type LispUsePetr struct {
1919         IPAddress ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
1920         IsAdd     bool             `binapi:"bool,name=is_add,default=true" json:"is_add,omitempty"`
1921 }
1922
1923 func (m *LispUsePetr) Reset()               { *m = LispUsePetr{} }
1924 func (*LispUsePetr) GetMessageName() string { return "lisp_use_petr" }
1925 func (*LispUsePetr) GetCrcString() string   { return "9e141831" }
1926 func (*LispUsePetr) GetMessageType() api.MessageType {
1927         return api.RequestMessage
1928 }
1929
1930 func (m *LispUsePetr) Size() (size int) {
1931         if m == nil {
1932                 return 0
1933         }
1934         size += 1      // m.IPAddress.Af
1935         size += 1 * 16 // m.IPAddress.Un
1936         size += 1      // m.IsAdd
1937         return size
1938 }
1939 func (m *LispUsePetr) Marshal(b []byte) ([]byte, error) {
1940         if b == nil {
1941                 b = make([]byte, m.Size())
1942         }
1943         buf := codec.NewBuffer(b)
1944         buf.EncodeUint8(uint8(m.IPAddress.Af))
1945         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
1946         buf.EncodeBool(m.IsAdd)
1947         return buf.Bytes(), nil
1948 }
1949 func (m *LispUsePetr) Unmarshal(b []byte) error {
1950         buf := codec.NewBuffer(b)
1951         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
1952         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
1953         m.IsAdd = buf.DecodeBool()
1954         return nil
1955 }
1956
1957 // LispUsePetrReply defines message 'lisp_use_petr_reply'.
1958 type LispUsePetrReply struct {
1959         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
1960 }
1961
1962 func (m *LispUsePetrReply) Reset()               { *m = LispUsePetrReply{} }
1963 func (*LispUsePetrReply) GetMessageName() string { return "lisp_use_petr_reply" }
1964 func (*LispUsePetrReply) GetCrcString() string   { return "e8d4e804" }
1965 func (*LispUsePetrReply) GetMessageType() api.MessageType {
1966         return api.ReplyMessage
1967 }
1968
1969 func (m *LispUsePetrReply) Size() (size int) {
1970         if m == nil {
1971                 return 0
1972         }
1973         size += 4 // m.Retval
1974         return size
1975 }
1976 func (m *LispUsePetrReply) Marshal(b []byte) ([]byte, error) {
1977         if b == nil {
1978                 b = make([]byte, m.Size())
1979         }
1980         buf := codec.NewBuffer(b)
1981         buf.EncodeInt32(m.Retval)
1982         return buf.Bytes(), nil
1983 }
1984 func (m *LispUsePetrReply) Unmarshal(b []byte) error {
1985         buf := codec.NewBuffer(b)
1986         m.Retval = buf.DecodeInt32()
1987         return nil
1988 }
1989
1990 // ShowLispMapRegisterState defines message 'show_lisp_map_register_state'.
1991 type ShowLispMapRegisterState struct{}
1992
1993 func (m *ShowLispMapRegisterState) Reset()               { *m = ShowLispMapRegisterState{} }
1994 func (*ShowLispMapRegisterState) GetMessageName() string { return "show_lisp_map_register_state" }
1995 func (*ShowLispMapRegisterState) GetCrcString() string   { return "51077d14" }
1996 func (*ShowLispMapRegisterState) GetMessageType() api.MessageType {
1997         return api.RequestMessage
1998 }
1999
2000 func (m *ShowLispMapRegisterState) Size() (size int) {
2001         if m == nil {
2002                 return 0
2003         }
2004         return size
2005 }
2006 func (m *ShowLispMapRegisterState) Marshal(b []byte) ([]byte, error) {
2007         if b == nil {
2008                 b = make([]byte, m.Size())
2009         }
2010         buf := codec.NewBuffer(b)
2011         return buf.Bytes(), nil
2012 }
2013 func (m *ShowLispMapRegisterState) Unmarshal(b []byte) error {
2014         return nil
2015 }
2016
2017 // ShowLispMapRegisterStateReply defines message 'show_lisp_map_register_state_reply'.
2018 type ShowLispMapRegisterStateReply struct {
2019         Retval    int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2020         IsEnabled bool  `binapi:"bool,name=is_enabled,default=true" json:"is_enabled,omitempty"`
2021 }
2022
2023 func (m *ShowLispMapRegisterStateReply) Reset() { *m = ShowLispMapRegisterStateReply{} }
2024 func (*ShowLispMapRegisterStateReply) GetMessageName() string {
2025         return "show_lisp_map_register_state_reply"
2026 }
2027 func (*ShowLispMapRegisterStateReply) GetCrcString() string { return "e33a377b" }
2028 func (*ShowLispMapRegisterStateReply) GetMessageType() api.MessageType {
2029         return api.ReplyMessage
2030 }
2031
2032 func (m *ShowLispMapRegisterStateReply) Size() (size int) {
2033         if m == nil {
2034                 return 0
2035         }
2036         size += 4 // m.Retval
2037         size += 1 // m.IsEnabled
2038         return size
2039 }
2040 func (m *ShowLispMapRegisterStateReply) Marshal(b []byte) ([]byte, error) {
2041         if b == nil {
2042                 b = make([]byte, m.Size())
2043         }
2044         buf := codec.NewBuffer(b)
2045         buf.EncodeInt32(m.Retval)
2046         buf.EncodeBool(m.IsEnabled)
2047         return buf.Bytes(), nil
2048 }
2049 func (m *ShowLispMapRegisterStateReply) Unmarshal(b []byte) error {
2050         buf := codec.NewBuffer(b)
2051         m.Retval = buf.DecodeInt32()
2052         m.IsEnabled = buf.DecodeBool()
2053         return nil
2054 }
2055
2056 // ShowLispMapRequestMode defines message 'show_lisp_map_request_mode'.
2057 type ShowLispMapRequestMode struct{}
2058
2059 func (m *ShowLispMapRequestMode) Reset()               { *m = ShowLispMapRequestMode{} }
2060 func (*ShowLispMapRequestMode) GetMessageName() string { return "show_lisp_map_request_mode" }
2061 func (*ShowLispMapRequestMode) GetCrcString() string   { return "51077d14" }
2062 func (*ShowLispMapRequestMode) GetMessageType() api.MessageType {
2063         return api.RequestMessage
2064 }
2065
2066 func (m *ShowLispMapRequestMode) Size() (size int) {
2067         if m == nil {
2068                 return 0
2069         }
2070         return size
2071 }
2072 func (m *ShowLispMapRequestMode) Marshal(b []byte) ([]byte, error) {
2073         if b == nil {
2074                 b = make([]byte, m.Size())
2075         }
2076         buf := codec.NewBuffer(b)
2077         return buf.Bytes(), nil
2078 }
2079 func (m *ShowLispMapRequestMode) Unmarshal(b []byte) error {
2080         return nil
2081 }
2082
2083 // ShowLispMapRequestModeReply defines message 'show_lisp_map_request_mode_reply'.
2084 type ShowLispMapRequestModeReply struct {
2085         Retval   int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2086         IsSrcDst bool  `binapi:"bool,name=is_src_dst" json:"is_src_dst,omitempty"`
2087 }
2088
2089 func (m *ShowLispMapRequestModeReply) Reset() { *m = ShowLispMapRequestModeReply{} }
2090 func (*ShowLispMapRequestModeReply) GetMessageName() string {
2091         return "show_lisp_map_request_mode_reply"
2092 }
2093 func (*ShowLispMapRequestModeReply) GetCrcString() string { return "5b05038e" }
2094 func (*ShowLispMapRequestModeReply) GetMessageType() api.MessageType {
2095         return api.ReplyMessage
2096 }
2097
2098 func (m *ShowLispMapRequestModeReply) Size() (size int) {
2099         if m == nil {
2100                 return 0
2101         }
2102         size += 4 // m.Retval
2103         size += 1 // m.IsSrcDst
2104         return size
2105 }
2106 func (m *ShowLispMapRequestModeReply) Marshal(b []byte) ([]byte, error) {
2107         if b == nil {
2108                 b = make([]byte, m.Size())
2109         }
2110         buf := codec.NewBuffer(b)
2111         buf.EncodeInt32(m.Retval)
2112         buf.EncodeBool(m.IsSrcDst)
2113         return buf.Bytes(), nil
2114 }
2115 func (m *ShowLispMapRequestModeReply) Unmarshal(b []byte) error {
2116         buf := codec.NewBuffer(b)
2117         m.Retval = buf.DecodeInt32()
2118         m.IsSrcDst = buf.DecodeBool()
2119         return nil
2120 }
2121
2122 // ShowLispPitr defines message 'show_lisp_pitr'.
2123 type ShowLispPitr struct{}
2124
2125 func (m *ShowLispPitr) Reset()               { *m = ShowLispPitr{} }
2126 func (*ShowLispPitr) GetMessageName() string { return "show_lisp_pitr" }
2127 func (*ShowLispPitr) GetCrcString() string   { return "51077d14" }
2128 func (*ShowLispPitr) GetMessageType() api.MessageType {
2129         return api.RequestMessage
2130 }
2131
2132 func (m *ShowLispPitr) Size() (size int) {
2133         if m == nil {
2134                 return 0
2135         }
2136         return size
2137 }
2138 func (m *ShowLispPitr) Marshal(b []byte) ([]byte, error) {
2139         if b == nil {
2140                 b = make([]byte, m.Size())
2141         }
2142         buf := codec.NewBuffer(b)
2143         return buf.Bytes(), nil
2144 }
2145 func (m *ShowLispPitr) Unmarshal(b []byte) error {
2146         return nil
2147 }
2148
2149 // ShowLispPitrReply defines message 'show_lisp_pitr_reply'.
2150 type ShowLispPitrReply struct {
2151         Retval         int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
2152         IsEnabled      bool   `binapi:"bool,name=is_enabled" json:"is_enabled,omitempty"`
2153         LocatorSetName string `binapi:"string[64],name=locator_set_name" json:"locator_set_name,omitempty"`
2154 }
2155
2156 func (m *ShowLispPitrReply) Reset()               { *m = ShowLispPitrReply{} }
2157 func (*ShowLispPitrReply) GetMessageName() string { return "show_lisp_pitr_reply" }
2158 func (*ShowLispPitrReply) GetCrcString() string   { return "27aa69b1" }
2159 func (*ShowLispPitrReply) GetMessageType() api.MessageType {
2160         return api.ReplyMessage
2161 }
2162
2163 func (m *ShowLispPitrReply) Size() (size int) {
2164         if m == nil {
2165                 return 0
2166         }
2167         size += 4  // m.Retval
2168         size += 1  // m.IsEnabled
2169         size += 64 // m.LocatorSetName
2170         return size
2171 }
2172 func (m *ShowLispPitrReply) Marshal(b []byte) ([]byte, error) {
2173         if b == nil {
2174                 b = make([]byte, m.Size())
2175         }
2176         buf := codec.NewBuffer(b)
2177         buf.EncodeInt32(m.Retval)
2178         buf.EncodeBool(m.IsEnabled)
2179         buf.EncodeString(m.LocatorSetName, 64)
2180         return buf.Bytes(), nil
2181 }
2182 func (m *ShowLispPitrReply) Unmarshal(b []byte) error {
2183         buf := codec.NewBuffer(b)
2184         m.Retval = buf.DecodeInt32()
2185         m.IsEnabled = buf.DecodeBool()
2186         m.LocatorSetName = buf.DecodeString(64)
2187         return nil
2188 }
2189
2190 // ShowLispRlocProbeState defines message 'show_lisp_rloc_probe_state'.
2191 type ShowLispRlocProbeState struct{}
2192
2193 func (m *ShowLispRlocProbeState) Reset()               { *m = ShowLispRlocProbeState{} }
2194 func (*ShowLispRlocProbeState) GetMessageName() string { return "show_lisp_rloc_probe_state" }
2195 func (*ShowLispRlocProbeState) GetCrcString() string   { return "51077d14" }
2196 func (*ShowLispRlocProbeState) GetMessageType() api.MessageType {
2197         return api.RequestMessage
2198 }
2199
2200 func (m *ShowLispRlocProbeState) Size() (size int) {
2201         if m == nil {
2202                 return 0
2203         }
2204         return size
2205 }
2206 func (m *ShowLispRlocProbeState) Marshal(b []byte) ([]byte, error) {
2207         if b == nil {
2208                 b = make([]byte, m.Size())
2209         }
2210         buf := codec.NewBuffer(b)
2211         return buf.Bytes(), nil
2212 }
2213 func (m *ShowLispRlocProbeState) Unmarshal(b []byte) error {
2214         return nil
2215 }
2216
2217 // ShowLispRlocProbeStateReply defines message 'show_lisp_rloc_probe_state_reply'.
2218 type ShowLispRlocProbeStateReply struct {
2219         Retval    int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2220         IsEnabled bool  `binapi:"bool,name=is_enabled,default=true" json:"is_enabled,omitempty"`
2221 }
2222
2223 func (m *ShowLispRlocProbeStateReply) Reset() { *m = ShowLispRlocProbeStateReply{} }
2224 func (*ShowLispRlocProbeStateReply) GetMessageName() string {
2225         return "show_lisp_rloc_probe_state_reply"
2226 }
2227 func (*ShowLispRlocProbeStateReply) GetCrcString() string { return "e33a377b" }
2228 func (*ShowLispRlocProbeStateReply) GetMessageType() api.MessageType {
2229         return api.ReplyMessage
2230 }
2231
2232 func (m *ShowLispRlocProbeStateReply) Size() (size int) {
2233         if m == nil {
2234                 return 0
2235         }
2236         size += 4 // m.Retval
2237         size += 1 // m.IsEnabled
2238         return size
2239 }
2240 func (m *ShowLispRlocProbeStateReply) Marshal(b []byte) ([]byte, error) {
2241         if b == nil {
2242                 b = make([]byte, m.Size())
2243         }
2244         buf := codec.NewBuffer(b)
2245         buf.EncodeInt32(m.Retval)
2246         buf.EncodeBool(m.IsEnabled)
2247         return buf.Bytes(), nil
2248 }
2249 func (m *ShowLispRlocProbeStateReply) Unmarshal(b []byte) error {
2250         buf := codec.NewBuffer(b)
2251         m.Retval = buf.DecodeInt32()
2252         m.IsEnabled = buf.DecodeBool()
2253         return nil
2254 }
2255
2256 // ShowLispStatus defines message 'show_lisp_status'.
2257 type ShowLispStatus struct{}
2258
2259 func (m *ShowLispStatus) Reset()               { *m = ShowLispStatus{} }
2260 func (*ShowLispStatus) GetMessageName() string { return "show_lisp_status" }
2261 func (*ShowLispStatus) GetCrcString() string   { return "51077d14" }
2262 func (*ShowLispStatus) GetMessageType() api.MessageType {
2263         return api.RequestMessage
2264 }
2265
2266 func (m *ShowLispStatus) Size() (size int) {
2267         if m == nil {
2268                 return 0
2269         }
2270         return size
2271 }
2272 func (m *ShowLispStatus) Marshal(b []byte) ([]byte, error) {
2273         if b == nil {
2274                 b = make([]byte, m.Size())
2275         }
2276         buf := codec.NewBuffer(b)
2277         return buf.Bytes(), nil
2278 }
2279 func (m *ShowLispStatus) Unmarshal(b []byte) error {
2280         return nil
2281 }
2282
2283 // ShowLispStatusReply defines message 'show_lisp_status_reply'.
2284 type ShowLispStatusReply struct {
2285         Retval        int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
2286         IsLispEnabled bool  `binapi:"bool,name=is_lisp_enabled" json:"is_lisp_enabled,omitempty"`
2287         IsGpeEnabled  bool  `binapi:"bool,name=is_gpe_enabled" json:"is_gpe_enabled,omitempty"`
2288 }
2289
2290 func (m *ShowLispStatusReply) Reset()               { *m = ShowLispStatusReply{} }
2291 func (*ShowLispStatusReply) GetMessageName() string { return "show_lisp_status_reply" }
2292 func (*ShowLispStatusReply) GetCrcString() string   { return "9e8f10c0" }
2293 func (*ShowLispStatusReply) GetMessageType() api.MessageType {
2294         return api.ReplyMessage
2295 }
2296
2297 func (m *ShowLispStatusReply) Size() (size int) {
2298         if m == nil {
2299                 return 0
2300         }
2301         size += 4 // m.Retval
2302         size += 1 // m.IsLispEnabled
2303         size += 1 // m.IsGpeEnabled
2304         return size
2305 }
2306 func (m *ShowLispStatusReply) Marshal(b []byte) ([]byte, error) {
2307         if b == nil {
2308                 b = make([]byte, m.Size())
2309         }
2310         buf := codec.NewBuffer(b)
2311         buf.EncodeInt32(m.Retval)
2312         buf.EncodeBool(m.IsLispEnabled)
2313         buf.EncodeBool(m.IsGpeEnabled)
2314         return buf.Bytes(), nil
2315 }
2316 func (m *ShowLispStatusReply) Unmarshal(b []byte) error {
2317         buf := codec.NewBuffer(b)
2318         m.Retval = buf.DecodeInt32()
2319         m.IsLispEnabled = buf.DecodeBool()
2320         m.IsGpeEnabled = buf.DecodeBool()
2321         return nil
2322 }
2323
2324 // ShowLispUsePetr defines message 'show_lisp_use_petr'.
2325 type ShowLispUsePetr struct{}
2326
2327 func (m *ShowLispUsePetr) Reset()               { *m = ShowLispUsePetr{} }
2328 func (*ShowLispUsePetr) GetMessageName() string { return "show_lisp_use_petr" }
2329 func (*ShowLispUsePetr) GetCrcString() string   { return "51077d14" }
2330 func (*ShowLispUsePetr) GetMessageType() api.MessageType {
2331         return api.RequestMessage
2332 }
2333
2334 func (m *ShowLispUsePetr) Size() (size int) {
2335         if m == nil {
2336                 return 0
2337         }
2338         return size
2339 }
2340 func (m *ShowLispUsePetr) Marshal(b []byte) ([]byte, error) {
2341         if b == nil {
2342                 b = make([]byte, m.Size())
2343         }
2344         buf := codec.NewBuffer(b)
2345         return buf.Bytes(), nil
2346 }
2347 func (m *ShowLispUsePetr) Unmarshal(b []byte) error {
2348         return nil
2349 }
2350
2351 // ShowLispUsePetrReply defines message 'show_lisp_use_petr_reply'.
2352 type ShowLispUsePetrReply struct {
2353         Retval       int32            `binapi:"i32,name=retval" json:"retval,omitempty"`
2354         IsPetrEnable bool             `binapi:"bool,name=is_petr_enable,default=true" json:"is_petr_enable,omitempty"`
2355         IPAddress    ip_types.Address `binapi:"address,name=ip_address" json:"ip_address,omitempty"`
2356 }
2357
2358 func (m *ShowLispUsePetrReply) Reset()               { *m = ShowLispUsePetrReply{} }
2359 func (*ShowLispUsePetrReply) GetMessageName() string { return "show_lisp_use_petr_reply" }
2360 func (*ShowLispUsePetrReply) GetCrcString() string   { return "dcad8a81" }
2361 func (*ShowLispUsePetrReply) GetMessageType() api.MessageType {
2362         return api.ReplyMessage
2363 }
2364
2365 func (m *ShowLispUsePetrReply) Size() (size int) {
2366         if m == nil {
2367                 return 0
2368         }
2369         size += 4      // m.Retval
2370         size += 1      // m.IsPetrEnable
2371         size += 1      // m.IPAddress.Af
2372         size += 1 * 16 // m.IPAddress.Un
2373         return size
2374 }
2375 func (m *ShowLispUsePetrReply) Marshal(b []byte) ([]byte, error) {
2376         if b == nil {
2377                 b = make([]byte, m.Size())
2378         }
2379         buf := codec.NewBuffer(b)
2380         buf.EncodeInt32(m.Retval)
2381         buf.EncodeBool(m.IsPetrEnable)
2382         buf.EncodeUint8(uint8(m.IPAddress.Af))
2383         buf.EncodeBytes(m.IPAddress.Un.XXX_UnionData[:], 16)
2384         return buf.Bytes(), nil
2385 }
2386 func (m *ShowLispUsePetrReply) Unmarshal(b []byte) error {
2387         buf := codec.NewBuffer(b)
2388         m.Retval = buf.DecodeInt32()
2389         m.IsPetrEnable = buf.DecodeBool()
2390         m.IPAddress.Af = ip_types.AddressFamily(buf.DecodeUint8())
2391         copy(m.IPAddress.Un.XXX_UnionData[:], buf.DecodeBytes(16))
2392         return nil
2393 }
2394
2395 func init() { file_lisp_binapi_init() }
2396 func file_lisp_binapi_init() {
2397         api.RegisterMessage((*LispAddDelAdjacency)(nil), "lisp_add_del_adjacency_cf5edb61")
2398         api.RegisterMessage((*LispAddDelAdjacencyReply)(nil), "lisp_add_del_adjacency_reply_e8d4e804")
2399         api.RegisterMessage((*LispAddDelLocalEid)(nil), "lisp_add_del_local_eid_21f573bd")
2400         api.RegisterMessage((*LispAddDelLocalEidReply)(nil), "lisp_add_del_local_eid_reply_e8d4e804")
2401         api.RegisterMessage((*LispAddDelLocator)(nil), "lisp_add_del_locator_af4d8f13")
2402         api.RegisterMessage((*LispAddDelLocatorReply)(nil), "lisp_add_del_locator_reply_e8d4e804")
2403         api.RegisterMessage((*LispAddDelLocatorSet)(nil), "lisp_add_del_locator_set_6fcd6471")
2404         api.RegisterMessage((*LispAddDelLocatorSetReply)(nil), "lisp_add_del_locator_set_reply_b6666db4")
2405         api.RegisterMessage((*LispAddDelMapRequestItrRlocs)(nil), "lisp_add_del_map_request_itr_rlocs_6be88e45")
2406         api.RegisterMessage((*LispAddDelMapRequestItrRlocsReply)(nil), "lisp_add_del_map_request_itr_rlocs_reply_e8d4e804")
2407         api.RegisterMessage((*LispAddDelMapResolver)(nil), "lisp_add_del_map_resolver_6598ea7c")
2408         api.RegisterMessage((*LispAddDelMapResolverReply)(nil), "lisp_add_del_map_resolver_reply_e8d4e804")
2409         api.RegisterMessage((*LispAddDelMapServer)(nil), "lisp_add_del_map_server_6598ea7c")
2410         api.RegisterMessage((*LispAddDelMapServerReply)(nil), "lisp_add_del_map_server_reply_e8d4e804")
2411         api.RegisterMessage((*LispAddDelRemoteMapping)(nil), "lisp_add_del_remote_mapping_fae8ed77")
2412         api.RegisterMessage((*LispAddDelRemoteMappingReply)(nil), "lisp_add_del_remote_mapping_reply_e8d4e804")
2413         api.RegisterMessage((*LispAdjacenciesGet)(nil), "lisp_adjacencies_get_8d1f2fe9")
2414         api.RegisterMessage((*LispAdjacenciesGetReply)(nil), "lisp_adjacencies_get_reply_3f97bcdd")
2415         api.RegisterMessage((*LispEidTableAddDelMap)(nil), "lisp_eid_table_add_del_map_9481416b")
2416         api.RegisterMessage((*LispEidTableAddDelMapReply)(nil), "lisp_eid_table_add_del_map_reply_e8d4e804")
2417         api.RegisterMessage((*LispEidTableDetails)(nil), "lisp_eid_table_details_4bc32e3a")
2418         api.RegisterMessage((*LispEidTableDump)(nil), "lisp_eid_table_dump_b959b73b")
2419         api.RegisterMessage((*LispEidTableMapDetails)(nil), "lisp_eid_table_map_details_0b6859e2")
2420         api.RegisterMessage((*LispEidTableMapDump)(nil), "lisp_eid_table_map_dump_d6cf0c3d")
2421         api.RegisterMessage((*LispEidTableVniDetails)(nil), "lisp_eid_table_vni_details_64abc01e")
2422         api.RegisterMessage((*LispEidTableVniDump)(nil), "lisp_eid_table_vni_dump_51077d14")
2423         api.RegisterMessage((*LispEnableDisable)(nil), "lisp_enable_disable_c264d7bf")
2424         api.RegisterMessage((*LispEnableDisableReply)(nil), "lisp_enable_disable_reply_e8d4e804")
2425         api.RegisterMessage((*LispGetMapRequestItrRlocs)(nil), "lisp_get_map_request_itr_rlocs_51077d14")
2426         api.RegisterMessage((*LispGetMapRequestItrRlocsReply)(nil), "lisp_get_map_request_itr_rlocs_reply_76580f3a")
2427         api.RegisterMessage((*LispLocatorDetails)(nil), "lisp_locator_details_c0c4c2a7")
2428         api.RegisterMessage((*LispLocatorDump)(nil), "lisp_locator_dump_b954fad7")
2429         api.RegisterMessage((*LispLocatorSetDetails)(nil), "lisp_locator_set_details_5b33a105")
2430         api.RegisterMessage((*LispLocatorSetDump)(nil), "lisp_locator_set_dump_c2cb5922")
2431         api.RegisterMessage((*LispMapRegisterEnableDisable)(nil), "lisp_map_register_enable_disable_c264d7bf")
2432         api.RegisterMessage((*LispMapRegisterEnableDisableReply)(nil), "lisp_map_register_enable_disable_reply_e8d4e804")
2433         api.RegisterMessage((*LispMapRequestMode)(nil), "lisp_map_request_mode_f43c26ae")
2434         api.RegisterMessage((*LispMapRequestModeReply)(nil), "lisp_map_request_mode_reply_e8d4e804")
2435         api.RegisterMessage((*LispMapResolverDetails)(nil), "lisp_map_resolver_details_82a09deb")
2436         api.RegisterMessage((*LispMapResolverDump)(nil), "lisp_map_resolver_dump_51077d14")
2437         api.RegisterMessage((*LispMapServerDetails)(nil), "lisp_map_server_details_82a09deb")
2438         api.RegisterMessage((*LispMapServerDump)(nil), "lisp_map_server_dump_51077d14")
2439         api.RegisterMessage((*LispPitrSetLocatorSet)(nil), "lisp_pitr_set_locator_set_486e2b76")
2440         api.RegisterMessage((*LispPitrSetLocatorSetReply)(nil), "lisp_pitr_set_locator_set_reply_e8d4e804")
2441         api.RegisterMessage((*LispRlocProbeEnableDisable)(nil), "lisp_rloc_probe_enable_disable_c264d7bf")
2442         api.RegisterMessage((*LispRlocProbeEnableDisableReply)(nil), "lisp_rloc_probe_enable_disable_reply_e8d4e804")
2443         api.RegisterMessage((*LispUsePetr)(nil), "lisp_use_petr_9e141831")
2444         api.RegisterMessage((*LispUsePetrReply)(nil), "lisp_use_petr_reply_e8d4e804")
2445         api.RegisterMessage((*ShowLispMapRegisterState)(nil), "show_lisp_map_register_state_51077d14")
2446         api.RegisterMessage((*ShowLispMapRegisterStateReply)(nil), "show_lisp_map_register_state_reply_e33a377b")
2447         api.RegisterMessage((*ShowLispMapRequestMode)(nil), "show_lisp_map_request_mode_51077d14")
2448         api.RegisterMessage((*ShowLispMapRequestModeReply)(nil), "show_lisp_map_request_mode_reply_5b05038e")
2449         api.RegisterMessage((*ShowLispPitr)(nil), "show_lisp_pitr_51077d14")
2450         api.RegisterMessage((*ShowLispPitrReply)(nil), "show_lisp_pitr_reply_27aa69b1")
2451         api.RegisterMessage((*ShowLispRlocProbeState)(nil), "show_lisp_rloc_probe_state_51077d14")
2452         api.RegisterMessage((*ShowLispRlocProbeStateReply)(nil), "show_lisp_rloc_probe_state_reply_e33a377b")
2453         api.RegisterMessage((*ShowLispStatus)(nil), "show_lisp_status_51077d14")
2454         api.RegisterMessage((*ShowLispStatusReply)(nil), "show_lisp_status_reply_9e8f10c0")
2455         api.RegisterMessage((*ShowLispUsePetr)(nil), "show_lisp_use_petr_51077d14")
2456         api.RegisterMessage((*ShowLispUsePetrReply)(nil), "show_lisp_use_petr_reply_dcad8a81")
2457 }
2458
2459 // Messages returns list of all messages in this module.
2460 func AllMessages() []api.Message {
2461         return []api.Message{
2462                 (*LispAddDelAdjacency)(nil),
2463                 (*LispAddDelAdjacencyReply)(nil),
2464                 (*LispAddDelLocalEid)(nil),
2465                 (*LispAddDelLocalEidReply)(nil),
2466                 (*LispAddDelLocator)(nil),
2467                 (*LispAddDelLocatorReply)(nil),
2468                 (*LispAddDelLocatorSet)(nil),
2469                 (*LispAddDelLocatorSetReply)(nil),
2470                 (*LispAddDelMapRequestItrRlocs)(nil),
2471                 (*LispAddDelMapRequestItrRlocsReply)(nil),
2472                 (*LispAddDelMapResolver)(nil),
2473                 (*LispAddDelMapResolverReply)(nil),
2474                 (*LispAddDelMapServer)(nil),
2475                 (*LispAddDelMapServerReply)(nil),
2476                 (*LispAddDelRemoteMapping)(nil),
2477                 (*LispAddDelRemoteMappingReply)(nil),
2478                 (*LispAdjacenciesGet)(nil),
2479                 (*LispAdjacenciesGetReply)(nil),
2480                 (*LispEidTableAddDelMap)(nil),
2481                 (*LispEidTableAddDelMapReply)(nil),
2482                 (*LispEidTableDetails)(nil),
2483                 (*LispEidTableDump)(nil),
2484                 (*LispEidTableMapDetails)(nil),
2485                 (*LispEidTableMapDump)(nil),
2486                 (*LispEidTableVniDetails)(nil),
2487                 (*LispEidTableVniDump)(nil),
2488                 (*LispEnableDisable)(nil),
2489                 (*LispEnableDisableReply)(nil),
2490                 (*LispGetMapRequestItrRlocs)(nil),
2491                 (*LispGetMapRequestItrRlocsReply)(nil),
2492                 (*LispLocatorDetails)(nil),
2493                 (*LispLocatorDump)(nil),
2494                 (*LispLocatorSetDetails)(nil),
2495                 (*LispLocatorSetDump)(nil),
2496                 (*LispMapRegisterEnableDisable)(nil),
2497                 (*LispMapRegisterEnableDisableReply)(nil),
2498                 (*LispMapRequestMode)(nil),
2499                 (*LispMapRequestModeReply)(nil),
2500                 (*LispMapResolverDetails)(nil),
2501                 (*LispMapResolverDump)(nil),
2502                 (*LispMapServerDetails)(nil),
2503                 (*LispMapServerDump)(nil),
2504                 (*LispPitrSetLocatorSet)(nil),
2505                 (*LispPitrSetLocatorSetReply)(nil),
2506                 (*LispRlocProbeEnableDisable)(nil),
2507                 (*LispRlocProbeEnableDisableReply)(nil),
2508                 (*LispUsePetr)(nil),
2509                 (*LispUsePetrReply)(nil),
2510                 (*ShowLispMapRegisterState)(nil),
2511                 (*ShowLispMapRegisterStateReply)(nil),
2512                 (*ShowLispMapRequestMode)(nil),
2513                 (*ShowLispMapRequestModeReply)(nil),
2514                 (*ShowLispPitr)(nil),
2515                 (*ShowLispPitrReply)(nil),
2516                 (*ShowLispRlocProbeState)(nil),
2517                 (*ShowLispRlocProbeStateReply)(nil),
2518                 (*ShowLispStatus)(nil),
2519                 (*ShowLispStatusReply)(nil),
2520                 (*ShowLispUsePetr)(nil),
2521                 (*ShowLispUsePetrReply)(nil),
2522         }
2523 }