binapi/dns/dns.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/plugins/dns.api.json
   6
   7 // Package dns contains generated bindings for API file dns.api.
   8 //
   9 // Contents:
  10 //   8 messages
  11 //
  12 package dns
  13
  14 import (
  15         api "git.fd.io/govpp.git/api"
  16         codec "git.fd.io/govpp.git/codec"
  17 )
  18
  19 // This is a compile-time assertion to ensure that this generated file
  20 // is compatible with the GoVPP api package it is being compiled against.
  21 // A compilation error at this line likely means your copy of the
  22 // GoVPP api package needs to be updated.
  23 const _ = api.GoVppAPIPackageIsVersion2
  24
  25 const (
  26         APIFile    = "dns"
  27         APIVersion = "1.0.0"
  28         VersionCrc = 0x269575cd
  29 )
  30
  31 // DNSEnableDisable defines message 'dns_enable_disable'.
  32 type DNSEnableDisable struct {
  33         Enable uint8 `binapi:"u8,name=enable" json:"enable,omitempty"`
  34 }
  35
  36 func (m *DNSEnableDisable) Reset()               { *m = DNSEnableDisable{} }
  37 func (*DNSEnableDisable) GetMessageName() string { return "dns_enable_disable" }
  38 func (*DNSEnableDisable) GetCrcString() string   { return "8050327d" }
  39 func (*DNSEnableDisable) GetMessageType() api.MessageType {
  40         return api.RequestMessage
  41 }
  42
  43 func (m *DNSEnableDisable) Size() (size int) {
  44         if m == nil {
  45                 return 0
  46         }
  47         size += 1 // m.Enable
  48         return size
  49 }
  50 func (m *DNSEnableDisable) Marshal(b []byte) ([]byte, error) {
  51         if b == nil {
  52                 b = make([]byte, m.Size())
  53         }
  54         buf := codec.NewBuffer(b)
  55         buf.EncodeUint8(m.Enable)
  56         return buf.Bytes(), nil
  57 }
  58 func (m *DNSEnableDisable) Unmarshal(b []byte) error {
  59         buf := codec.NewBuffer(b)
  60         m.Enable = buf.DecodeUint8()
  61         return nil
  62 }
  63
  64 // DNSEnableDisableReply defines message 'dns_enable_disable_reply'.
  65 type DNSEnableDisableReply struct {
  66         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
  67 }
  68
  69 func (m *DNSEnableDisableReply) Reset()               { *m = DNSEnableDisableReply{} }
  70 func (*DNSEnableDisableReply) GetMessageName() string { return "dns_enable_disable_reply" }
  71 func (*DNSEnableDisableReply) GetCrcString() string   { return "e8d4e804" }
  72 func (*DNSEnableDisableReply) GetMessageType() api.MessageType {
  73         return api.ReplyMessage
  74 }
  75
  76 func (m *DNSEnableDisableReply) Size() (size int) {
  77         if m == nil {
  78                 return 0
  79         }
  80         size += 4 // m.Retval
  81         return size
  82 }
  83 func (m *DNSEnableDisableReply) Marshal(b []byte) ([]byte, error) {
  84         if b == nil {
  85                 b = make([]byte, m.Size())
  86         }
  87         buf := codec.NewBuffer(b)
  88         buf.EncodeInt32(m.Retval)
  89         return buf.Bytes(), nil
  90 }
  91 func (m *DNSEnableDisableReply) Unmarshal(b []byte) error {
  92         buf := codec.NewBuffer(b)
  93         m.Retval = buf.DecodeInt32()
  94         return nil
  95 }
  96
  97 // DNSNameServerAddDel defines message 'dns_name_server_add_del'.
  98 type DNSNameServerAddDel struct {
  99         IsIP6         uint8  `binapi:"u8,name=is_ip6" json:"is_ip6,omitempty"`
 100         IsAdd         uint8  `binapi:"u8,name=is_add" json:"is_add,omitempty"`
 101         ServerAddress []byte `binapi:"u8[16],name=server_address" json:"server_address,omitempty"`
 102 }
 103
 104 func (m *DNSNameServerAddDel) Reset()               { *m = DNSNameServerAddDel{} }
 105 func (*DNSNameServerAddDel) GetMessageName() string { return "dns_name_server_add_del" }
 106 func (*DNSNameServerAddDel) GetCrcString() string   { return "3bb05d8c" }
 107 func (*DNSNameServerAddDel) GetMessageType() api.MessageType {
 108         return api.RequestMessage
 109 }
 110
 111 func (m *DNSNameServerAddDel) Size() (size int) {
 112         if m == nil {
 113                 return 0
 114         }
 115         size += 1      // m.IsIP6
 116         size += 1      // m.IsAdd
 117         size += 1 * 16 // m.ServerAddress
 118         return size
 119 }
 120 func (m *DNSNameServerAddDel) Marshal(b []byte) ([]byte, error) {
 121         if b == nil {
 122                 b = make([]byte, m.Size())
 123         }
 124         buf := codec.NewBuffer(b)
 125         buf.EncodeUint8(m.IsIP6)
 126         buf.EncodeUint8(m.IsAdd)
 127         buf.EncodeBytes(m.ServerAddress, 16)
 128         return buf.Bytes(), nil
 129 }
 130 func (m *DNSNameServerAddDel) Unmarshal(b []byte) error {
 131         buf := codec.NewBuffer(b)
 132         m.IsIP6 = buf.DecodeUint8()
 133         m.IsAdd = buf.DecodeUint8()
 134         m.ServerAddress = make([]byte, 16)
 135         copy(m.ServerAddress, buf.DecodeBytes(len(m.ServerAddress)))
 136         return nil
 137 }
 138
 139 // DNSNameServerAddDelReply defines message 'dns_name_server_add_del_reply'.
 140 type DNSNameServerAddDelReply struct {
 141         Retval int32 `binapi:"i32,name=retval" json:"retval,omitempty"`
 142 }
 143
 144 func (m *DNSNameServerAddDelReply) Reset()               { *m = DNSNameServerAddDelReply{} }
 145 func (*DNSNameServerAddDelReply) GetMessageName() string { return "dns_name_server_add_del_reply" }
 146 func (*DNSNameServerAddDelReply) GetCrcString() string   { return "e8d4e804" }
 147 func (*DNSNameServerAddDelReply) GetMessageType() api.MessageType {
 148         return api.ReplyMessage
 149 }
 150
 151 func (m *DNSNameServerAddDelReply) Size() (size int) {
 152         if m == nil {
 153                 return 0
 154         }
 155         size += 4 // m.Retval
 156         return size
 157 }
 158 func (m *DNSNameServerAddDelReply) Marshal(b []byte) ([]byte, error) {
 159         if b == nil {
 160                 b = make([]byte, m.Size())
 161         }
 162         buf := codec.NewBuffer(b)
 163         buf.EncodeInt32(m.Retval)
 164         return buf.Bytes(), nil
 165 }
 166 func (m *DNSNameServerAddDelReply) Unmarshal(b []byte) error {
 167         buf := codec.NewBuffer(b)
 168         m.Retval = buf.DecodeInt32()
 169         return nil
 170 }
 171
 172 // DNSResolveIP defines message 'dns_resolve_ip'.
 173 type DNSResolveIP struct {
 174         IsIP6   uint8  `binapi:"u8,name=is_ip6" json:"is_ip6,omitempty"`
 175         Address []byte `binapi:"u8[16],name=address" json:"address,omitempty"`
 176 }
 177
 178 func (m *DNSResolveIP) Reset()               { *m = DNSResolveIP{} }
 179 func (*DNSResolveIP) GetMessageName() string { return "dns_resolve_ip" }
 180 func (*DNSResolveIP) GetCrcString() string   { return "ae96a1a3" }
 181 func (*DNSResolveIP) GetMessageType() api.MessageType {
 182         return api.RequestMessage
 183 }
 184
 185 func (m *DNSResolveIP) Size() (size int) {
 186         if m == nil {
 187                 return 0
 188         }
 189         size += 1      // m.IsIP6
 190         size += 1 * 16 // m.Address
 191         return size
 192 }
 193 func (m *DNSResolveIP) Marshal(b []byte) ([]byte, error) {
 194         if b == nil {
 195                 b = make([]byte, m.Size())
 196         }
 197         buf := codec.NewBuffer(b)
 198         buf.EncodeUint8(m.IsIP6)
 199         buf.EncodeBytes(m.Address, 16)
 200         return buf.Bytes(), nil
 201 }
 202 func (m *DNSResolveIP) Unmarshal(b []byte) error {
 203         buf := codec.NewBuffer(b)
 204         m.IsIP6 = buf.DecodeUint8()
 205         m.Address = make([]byte, 16)
 206         copy(m.Address, buf.DecodeBytes(len(m.Address)))
 207         return nil
 208 }
 209
 210 // DNSResolveIPReply defines message 'dns_resolve_ip_reply'.
 211 type DNSResolveIPReply struct {
 212         Retval int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 213         Name   []byte `binapi:"u8[256],name=name" json:"name,omitempty"`
 214 }
 215
 216 func (m *DNSResolveIPReply) Reset()               { *m = DNSResolveIPReply{} }
 217 func (*DNSResolveIPReply) GetMessageName() string { return "dns_resolve_ip_reply" }
 218 func (*DNSResolveIPReply) GetCrcString() string   { return "49ed78d6" }
 219 func (*DNSResolveIPReply) GetMessageType() api.MessageType {
 220         return api.ReplyMessage
 221 }
 222
 223 func (m *DNSResolveIPReply) Size() (size int) {
 224         if m == nil {
 225                 return 0
 226         }
 227         size += 4       // m.Retval
 228         size += 1 * 256 // m.Name
 229         return size
 230 }
 231 func (m *DNSResolveIPReply) Marshal(b []byte) ([]byte, error) {
 232         if b == nil {
 233                 b = make([]byte, m.Size())
 234         }
 235         buf := codec.NewBuffer(b)
 236         buf.EncodeInt32(m.Retval)
 237         buf.EncodeBytes(m.Name, 256)
 238         return buf.Bytes(), nil
 239 }
 240 func (m *DNSResolveIPReply) Unmarshal(b []byte) error {
 241         buf := codec.NewBuffer(b)
 242         m.Retval = buf.DecodeInt32()
 243         m.Name = make([]byte, 256)
 244         copy(m.Name, buf.DecodeBytes(len(m.Name)))
 245         return nil
 246 }
 247
 248 // DNSResolveName defines message 'dns_resolve_name'.
 249 type DNSResolveName struct {
 250         Name []byte `binapi:"u8[256],name=name" json:"name,omitempty"`
 251 }
 252
 253 func (m *DNSResolveName) Reset()               { *m = DNSResolveName{} }
 254 func (*DNSResolveName) GetMessageName() string { return "dns_resolve_name" }
 255 func (*DNSResolveName) GetCrcString() string   { return "c6566676" }
 256 func (*DNSResolveName) GetMessageType() api.MessageType {
 257         return api.RequestMessage
 258 }
 259
 260 func (m *DNSResolveName) Size() (size int) {
 261         if m == nil {
 262                 return 0
 263         }
 264         size += 1 * 256 // m.Name
 265         return size
 266 }
 267 func (m *DNSResolveName) Marshal(b []byte) ([]byte, error) {
 268         if b == nil {
 269                 b = make([]byte, m.Size())
 270         }
 271         buf := codec.NewBuffer(b)
 272         buf.EncodeBytes(m.Name, 256)
 273         return buf.Bytes(), nil
 274 }
 275 func (m *DNSResolveName) Unmarshal(b []byte) error {
 276         buf := codec.NewBuffer(b)
 277         m.Name = make([]byte, 256)
 278         copy(m.Name, buf.DecodeBytes(len(m.Name)))
 279         return nil
 280 }
 281
 282 // DNSResolveNameReply defines message 'dns_resolve_name_reply'.
 283 type DNSResolveNameReply struct {
 284         Retval     int32  `binapi:"i32,name=retval" json:"retval,omitempty"`
 285         IP4Set     uint8  `binapi:"u8,name=ip4_set" json:"ip4_set,omitempty"`
 286         IP6Set     uint8  `binapi:"u8,name=ip6_set" json:"ip6_set,omitempty"`
 287         IP4Address []byte `binapi:"u8[4],name=ip4_address" json:"ip4_address,omitempty"`
 288         IP6Address []byte `binapi:"u8[16],name=ip6_address" json:"ip6_address,omitempty"`
 289 }
 290
 291 func (m *DNSResolveNameReply) Reset()               { *m = DNSResolveNameReply{} }
 292 func (*DNSResolveNameReply) GetMessageName() string { return "dns_resolve_name_reply" }
 293 func (*DNSResolveNameReply) GetCrcString() string   { return "c2d758c3" }
 294 func (*DNSResolveNameReply) GetMessageType() api.MessageType {
 295         return api.ReplyMessage
 296 }
 297
 298 func (m *DNSResolveNameReply) Size() (size int) {
 299         if m == nil {
 300                 return 0
 301         }
 302         size += 4      // m.Retval
 303         size += 1      // m.IP4Set
 304         size += 1      // m.IP6Set
 305         size += 1 * 4  // m.IP4Address
 306         size += 1 * 16 // m.IP6Address
 307         return size
 308 }
 309 func (m *DNSResolveNameReply) Marshal(b []byte) ([]byte, error) {
 310         if b == nil {
 311                 b = make([]byte, m.Size())
 312         }
 313         buf := codec.NewBuffer(b)
 314         buf.EncodeInt32(m.Retval)
 315         buf.EncodeUint8(m.IP4Set)
 316         buf.EncodeUint8(m.IP6Set)
 317         buf.EncodeBytes(m.IP4Address, 4)
 318         buf.EncodeBytes(m.IP6Address, 16)
 319         return buf.Bytes(), nil
 320 }
 321 func (m *DNSResolveNameReply) Unmarshal(b []byte) error {
 322         buf := codec.NewBuffer(b)
 323         m.Retval = buf.DecodeInt32()
 324         m.IP4Set = buf.DecodeUint8()
 325         m.IP6Set = buf.DecodeUint8()
 326         m.IP4Address = make([]byte, 4)
 327         copy(m.IP4Address, buf.DecodeBytes(len(m.IP4Address)))
 328         m.IP6Address = make([]byte, 16)
 329         copy(m.IP6Address, buf.DecodeBytes(len(m.IP6Address)))
 330         return nil
 331 }
 332
 333 func init() { file_dns_binapi_init() }
 334 func file_dns_binapi_init() {
 335         api.RegisterMessage((*DNSEnableDisable)(nil), "dns_enable_disable_8050327d")
 336         api.RegisterMessage((*DNSEnableDisableReply)(nil), "dns_enable_disable_reply_e8d4e804")
 337         api.RegisterMessage((*DNSNameServerAddDel)(nil), "dns_name_server_add_del_3bb05d8c")
 338         api.RegisterMessage((*DNSNameServerAddDelReply)(nil), "dns_name_server_add_del_reply_e8d4e804")
 339         api.RegisterMessage((*DNSResolveIP)(nil), "dns_resolve_ip_ae96a1a3")
 340         api.RegisterMessage((*DNSResolveIPReply)(nil), "dns_resolve_ip_reply_49ed78d6")
 341         api.RegisterMessage((*DNSResolveName)(nil), "dns_resolve_name_c6566676")
 342         api.RegisterMessage((*DNSResolveNameReply)(nil), "dns_resolve_name_reply_c2d758c3")
 343 }
 344
 345 // Messages returns list of all messages in this module.
 346 func AllMessages() []api.Message {
 347         return []api.Message{
 348                 (*DNSEnableDisable)(nil),
 349                 (*DNSEnableDisableReply)(nil),
 350                 (*DNSNameServerAddDel)(nil),
 351                 (*DNSNameServerAddDelReply)(nil),
 352                 (*DNSResolveIP)(nil),
 353                 (*DNSResolveIPReply)(nil),
 354                 (*DNSResolveName)(nil),
 355                 (*DNSResolveNameReply)(nil),
 356         }
 357 }