binapi/lisp/lisp.ba.go

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