internal/testbinapi/binapi2001/lisp/lisp.ba.go

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