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