examples/binapi/acl/acl.ba.go

   1 // Code generated by GoVPP's binapi-generator. DO NOT EDIT.
   2 // source: /usr/share/vpp/api/plugins/acl.api.json
   3
   4 /*
   5 Package acl is a generated VPP binary API for 'acl' module.
   6
   7 It consists of:
   8           2 types
   9          36 messages
  10          18 services
  11 */
  12 package acl
  13
  14 import (
  15         bytes "bytes"
  16         context "context"
  17         api "git.fd.io/govpp.git/api"
  18         struc "github.com/lunixbochs/struc"
  19         io "io"
  20         strconv "strconv"
  21 )
  22
  23 const (
  24         // ModuleName is the name of this module.
  25         ModuleName = "acl"
  26         // APIVersion is the API version of this module.
  27         APIVersion = "1.0.1"
  28         // VersionCrc is the CRC of this module.
  29         VersionCrc = 0x8ed22cb9
  30 )
  31
  32 // ACLRule represents VPP binary API type 'acl_rule'.
  33 type ACLRule struct {
  34         IsPermit               uint8
  35         IsIPv6                 uint8
  36         SrcIPAddr              []byte `struc:"[16]byte"`
  37         SrcIPPrefixLen         uint8
  38         DstIPAddr              []byte `struc:"[16]byte"`
  39         DstIPPrefixLen         uint8
  40         Proto                  uint8
  41         SrcportOrIcmptypeFirst uint16
  42         SrcportOrIcmptypeLast  uint16
  43         DstportOrIcmpcodeFirst uint16
  44         DstportOrIcmpcodeLast  uint16
  45         TCPFlagsMask           uint8
  46         TCPFlagsValue          uint8
  47 }
  48
  49 func (*ACLRule) GetTypeName() string {
  50         return "acl_rule"
  51 }
  52 func (*ACLRule) GetCrcString() string {
  53         return "6f99bf4d"
  54 }
  55
  56 // MacipACLRule represents VPP binary API type 'macip_acl_rule'.
  57 type MacipACLRule struct {
  58         IsPermit       uint8
  59         IsIPv6         uint8
  60         SrcMac         []byte `struc:"[6]byte"`
  61         SrcMacMask     []byte `struc:"[6]byte"`
  62         SrcIPAddr      []byte `struc:"[16]byte"`
  63         SrcIPPrefixLen uint8
  64 }
  65
  66 func (*MacipACLRule) GetTypeName() string {
  67         return "macip_acl_rule"
  68 }
  69 func (*MacipACLRule) GetCrcString() string {
  70         return "70589f1e"
  71 }
  72
  73 // ACLAddReplace represents VPP binary API message 'acl_add_replace'.
  74 type ACLAddReplace struct {
  75         ACLIndex uint32
  76         Tag      []byte `struc:"[64]byte"`
  77         Count    uint32 `struc:"sizeof=R"`
  78         R        []ACLRule
  79 }
  80
  81 func (*ACLAddReplace) GetMessageName() string {
  82         return "acl_add_replace"
  83 }
  84 func (*ACLAddReplace) GetCrcString() string {
  85         return "e839997e"
  86 }
  87 func (*ACLAddReplace) GetMessageType() api.MessageType {
  88         return api.RequestMessage
  89 }
  90
  91 // ACLAddReplaceReply represents VPP binary API message 'acl_add_replace_reply'.
  92 type ACLAddReplaceReply struct {
  93         ACLIndex uint32
  94         Retval   int32
  95 }
  96
  97 func (*ACLAddReplaceReply) GetMessageName() string {
  98         return "acl_add_replace_reply"
  99 }
 100 func (*ACLAddReplaceReply) GetCrcString() string {
 101         return "ac407b0c"
 102 }
 103 func (*ACLAddReplaceReply) GetMessageType() api.MessageType {
 104         return api.ReplyMessage
 105 }
 106
 107 // ACLDel represents VPP binary API message 'acl_del'.
 108 type ACLDel struct {
 109         ACLIndex uint32
 110 }
 111
 112 func (*ACLDel) GetMessageName() string {
 113         return "acl_del"
 114 }
 115 func (*ACLDel) GetCrcString() string {
 116         return "ef34fea4"
 117 }
 118 func (*ACLDel) GetMessageType() api.MessageType {
 119         return api.RequestMessage
 120 }
 121
 122 // ACLDelReply represents VPP binary API message 'acl_del_reply'.
 123 type ACLDelReply struct {
 124         Retval int32
 125 }
 126
 127 func (*ACLDelReply) GetMessageName() string {
 128         return "acl_del_reply"
 129 }
 130 func (*ACLDelReply) GetCrcString() string {
 131         return "e8d4e804"
 132 }
 133 func (*ACLDelReply) GetMessageType() api.MessageType {
 134         return api.ReplyMessage
 135 }
 136
 137 // ACLDetails represents VPP binary API message 'acl_details'.
 138 type ACLDetails struct {
 139         ACLIndex uint32
 140         Tag      []byte `struc:"[64]byte"`
 141         Count    uint32 `struc:"sizeof=R"`
 142         R        []ACLRule
 143 }
 144
 145 func (*ACLDetails) GetMessageName() string {
 146         return "acl_details"
 147 }
 148 func (*ACLDetails) GetCrcString() string {
 149         return "5bd895be"
 150 }
 151 func (*ACLDetails) GetMessageType() api.MessageType {
 152         return api.ReplyMessage
 153 }
 154
 155 // ACLDump represents VPP binary API message 'acl_dump'.
 156 type ACLDump struct {
 157         ACLIndex uint32
 158 }
 159
 160 func (*ACLDump) GetMessageName() string {
 161         return "acl_dump"
 162 }
 163 func (*ACLDump) GetCrcString() string {
 164         return "ef34fea4"
 165 }
 166 func (*ACLDump) GetMessageType() api.MessageType {
 167         return api.RequestMessage
 168 }
 169
 170 // ACLInterfaceAddDel represents VPP binary API message 'acl_interface_add_del'.
 171 type ACLInterfaceAddDel struct {
 172         IsAdd     uint8
 173         IsInput   uint8
 174         SwIfIndex uint32
 175         ACLIndex  uint32
 176 }
 177
 178 func (*ACLInterfaceAddDel) GetMessageName() string {
 179         return "acl_interface_add_del"
 180 }
 181 func (*ACLInterfaceAddDel) GetCrcString() string {
 182         return "0b2aedd1"
 183 }
 184 func (*ACLInterfaceAddDel) GetMessageType() api.MessageType {
 185         return api.RequestMessage
 186 }
 187
 188 // ACLInterfaceAddDelReply represents VPP binary API message 'acl_interface_add_del_reply'.
 189 type ACLInterfaceAddDelReply struct {
 190         Retval int32
 191 }
 192
 193 func (*ACLInterfaceAddDelReply) GetMessageName() string {
 194         return "acl_interface_add_del_reply"
 195 }
 196 func (*ACLInterfaceAddDelReply) GetCrcString() string {
 197         return "e8d4e804"
 198 }
 199 func (*ACLInterfaceAddDelReply) GetMessageType() api.MessageType {
 200         return api.ReplyMessage
 201 }
 202
 203 // ACLInterfaceEtypeWhitelistDetails represents VPP binary API message 'acl_interface_etype_whitelist_details'.
 204 type ACLInterfaceEtypeWhitelistDetails struct {
 205         SwIfIndex uint32
 206         Count     uint8 `struc:"sizeof=Whitelist"`
 207         NInput    uint8
 208         Whitelist []uint16
 209 }
 210
 211 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageName() string {
 212         return "acl_interface_etype_whitelist_details"
 213 }
 214 func (*ACLInterfaceEtypeWhitelistDetails) GetCrcString() string {
 215         return "6a5d4e81"
 216 }
 217 func (*ACLInterfaceEtypeWhitelistDetails) GetMessageType() api.MessageType {
 218         return api.ReplyMessage
 219 }
 220
 221 // ACLInterfaceEtypeWhitelistDump represents VPP binary API message 'acl_interface_etype_whitelist_dump'.
 222 type ACLInterfaceEtypeWhitelistDump struct {
 223         SwIfIndex uint32
 224 }
 225
 226 func (*ACLInterfaceEtypeWhitelistDump) GetMessageName() string {
 227         return "acl_interface_etype_whitelist_dump"
 228 }
 229 func (*ACLInterfaceEtypeWhitelistDump) GetCrcString() string {
 230         return "529cb13f"
 231 }
 232 func (*ACLInterfaceEtypeWhitelistDump) GetMessageType() api.MessageType {
 233         return api.RequestMessage
 234 }
 235
 236 // ACLInterfaceListDetails represents VPP binary API message 'acl_interface_list_details'.
 237 type ACLInterfaceListDetails struct {
 238         SwIfIndex uint32
 239         Count     uint8 `struc:"sizeof=Acls"`
 240         NInput    uint8
 241         Acls      []uint32
 242 }
 243
 244 func (*ACLInterfaceListDetails) GetMessageName() string {
 245         return "acl_interface_list_details"
 246 }
 247 func (*ACLInterfaceListDetails) GetCrcString() string {
 248         return "d5e80809"
 249 }
 250 func (*ACLInterfaceListDetails) GetMessageType() api.MessageType {
 251         return api.ReplyMessage
 252 }
 253
 254 // ACLInterfaceListDump represents VPP binary API message 'acl_interface_list_dump'.
 255 type ACLInterfaceListDump struct {
 256         SwIfIndex uint32
 257 }
 258
 259 func (*ACLInterfaceListDump) GetMessageName() string {
 260         return "acl_interface_list_dump"
 261 }
 262 func (*ACLInterfaceListDump) GetCrcString() string {
 263         return "529cb13f"
 264 }
 265 func (*ACLInterfaceListDump) GetMessageType() api.MessageType {
 266         return api.RequestMessage
 267 }
 268
 269 // ACLInterfaceSetACLList represents VPP binary API message 'acl_interface_set_acl_list'.
 270 type ACLInterfaceSetACLList struct {
 271         SwIfIndex uint32
 272         Count     uint8 `struc:"sizeof=Acls"`
 273         NInput    uint8
 274         Acls      []uint32
 275 }
 276
 277 func (*ACLInterfaceSetACLList) GetMessageName() string {
 278         return "acl_interface_set_acl_list"
 279 }
 280 func (*ACLInterfaceSetACLList) GetCrcString() string {
 281         return "8baece38"
 282 }
 283 func (*ACLInterfaceSetACLList) GetMessageType() api.MessageType {
 284         return api.RequestMessage
 285 }
 286
 287 // ACLInterfaceSetACLListReply represents VPP binary API message 'acl_interface_set_acl_list_reply'.
 288 type ACLInterfaceSetACLListReply struct {
 289         Retval int32
 290 }
 291
 292 func (*ACLInterfaceSetACLListReply) GetMessageName() string {
 293         return "acl_interface_set_acl_list_reply"
 294 }
 295 func (*ACLInterfaceSetACLListReply) GetCrcString() string {
 296         return "e8d4e804"
 297 }
 298 func (*ACLInterfaceSetACLListReply) GetMessageType() api.MessageType {
 299         return api.ReplyMessage
 300 }
 301
 302 // ACLInterfaceSetEtypeWhitelist represents VPP binary API message 'acl_interface_set_etype_whitelist'.
 303 type ACLInterfaceSetEtypeWhitelist struct {
 304         SwIfIndex uint32
 305         Count     uint8 `struc:"sizeof=Whitelist"`
 306         NInput    uint8
 307         Whitelist []uint16
 308 }
 309
 310 func (*ACLInterfaceSetEtypeWhitelist) GetMessageName() string {
 311         return "acl_interface_set_etype_whitelist"
 312 }
 313 func (*ACLInterfaceSetEtypeWhitelist) GetCrcString() string {
 314         return "f515efc5"
 315 }
 316 func (*ACLInterfaceSetEtypeWhitelist) GetMessageType() api.MessageType {
 317         return api.RequestMessage
 318 }
 319
 320 // ACLInterfaceSetEtypeWhitelistReply represents VPP binary API message 'acl_interface_set_etype_whitelist_reply'.
 321 type ACLInterfaceSetEtypeWhitelistReply struct {
 322         Retval int32
 323 }
 324
 325 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageName() string {
 326         return "acl_interface_set_etype_whitelist_reply"
 327 }
 328 func (*ACLInterfaceSetEtypeWhitelistReply) GetCrcString() string {
 329         return "e8d4e804"
 330 }
 331 func (*ACLInterfaceSetEtypeWhitelistReply) GetMessageType() api.MessageType {
 332         return api.ReplyMessage
 333 }
 334
 335 // ACLPluginControlPing represents VPP binary API message 'acl_plugin_control_ping'.
 336 type ACLPluginControlPing struct{}
 337
 338 func (*ACLPluginControlPing) GetMessageName() string {
 339         return "acl_plugin_control_ping"
 340 }
 341 func (*ACLPluginControlPing) GetCrcString() string {
 342         return "51077d14"
 343 }
 344 func (*ACLPluginControlPing) GetMessageType() api.MessageType {
 345         return api.RequestMessage
 346 }
 347
 348 // ACLPluginControlPingReply represents VPP binary API message 'acl_plugin_control_ping_reply'.
 349 type ACLPluginControlPingReply struct {
 350         Retval      int32
 351         ClientIndex uint32
 352         VpePID      uint32
 353 }
 354
 355 func (*ACLPluginControlPingReply) GetMessageName() string {
 356         return "acl_plugin_control_ping_reply"
 357 }
 358 func (*ACLPluginControlPingReply) GetCrcString() string {
 359         return "f6b0b8ca"
 360 }
 361 func (*ACLPluginControlPingReply) GetMessageType() api.MessageType {
 362         return api.ReplyMessage
 363 }
 364
 365 // ACLPluginGetConnTableMaxEntries represents VPP binary API message 'acl_plugin_get_conn_table_max_entries'.
 366 type ACLPluginGetConnTableMaxEntries struct{}
 367
 368 func (*ACLPluginGetConnTableMaxEntries) GetMessageName() string {
 369         return "acl_plugin_get_conn_table_max_entries"
 370 }
 371 func (*ACLPluginGetConnTableMaxEntries) GetCrcString() string {
 372         return "51077d14"
 373 }
 374 func (*ACLPluginGetConnTableMaxEntries) GetMessageType() api.MessageType {
 375         return api.RequestMessage
 376 }
 377
 378 // ACLPluginGetConnTableMaxEntriesReply represents VPP binary API message 'acl_plugin_get_conn_table_max_entries_reply'.
 379 type ACLPluginGetConnTableMaxEntriesReply struct {
 380         ConnTableMaxEntries uint64
 381 }
 382
 383 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageName() string {
 384         return "acl_plugin_get_conn_table_max_entries_reply"
 385 }
 386 func (*ACLPluginGetConnTableMaxEntriesReply) GetCrcString() string {
 387         return "7a096d3d"
 388 }
 389 func (*ACLPluginGetConnTableMaxEntriesReply) GetMessageType() api.MessageType {
 390         return api.ReplyMessage
 391 }
 392
 393 // ACLPluginGetVersion represents VPP binary API message 'acl_plugin_get_version'.
 394 type ACLPluginGetVersion struct{}
 395
 396 func (*ACLPluginGetVersion) GetMessageName() string {
 397         return "acl_plugin_get_version"
 398 }
 399 func (*ACLPluginGetVersion) GetCrcString() string {
 400         return "51077d14"
 401 }
 402 func (*ACLPluginGetVersion) GetMessageType() api.MessageType {
 403         return api.RequestMessage
 404 }
 405
 406 // ACLPluginGetVersionReply represents VPP binary API message 'acl_plugin_get_version_reply'.
 407 type ACLPluginGetVersionReply struct {
 408         Major uint32
 409         Minor uint32
 410 }
 411
 412 func (*ACLPluginGetVersionReply) GetMessageName() string {
 413         return "acl_plugin_get_version_reply"
 414 }
 415 func (*ACLPluginGetVersionReply) GetCrcString() string {
 416         return "9b32cf86"
 417 }
 418 func (*ACLPluginGetVersionReply) GetMessageType() api.MessageType {
 419         return api.ReplyMessage
 420 }
 421
 422 // MacipACLAdd represents VPP binary API message 'macip_acl_add'.
 423 type MacipACLAdd struct {
 424         Tag   []byte `struc:"[64]byte"`
 425         Count uint32 `struc:"sizeof=R"`
 426         R     []MacipACLRule
 427 }
 428
 429 func (*MacipACLAdd) GetMessageName() string {
 430         return "macip_acl_add"
 431 }
 432 func (*MacipACLAdd) GetCrcString() string {
 433         return "b3d3d65a"
 434 }
 435 func (*MacipACLAdd) GetMessageType() api.MessageType {
 436         return api.RequestMessage
 437 }
 438
 439 // MacipACLAddReplace represents VPP binary API message 'macip_acl_add_replace'.
 440 type MacipACLAddReplace struct {
 441         ACLIndex uint32
 442         Tag      []byte `struc:"[64]byte"`
 443         Count    uint32 `struc:"sizeof=R"`
 444         R        []MacipACLRule
 445 }
 446
 447 func (*MacipACLAddReplace) GetMessageName() string {
 448         return "macip_acl_add_replace"
 449 }
 450 func (*MacipACLAddReplace) GetCrcString() string {
 451         return "a0e8c01b"
 452 }
 453 func (*MacipACLAddReplace) GetMessageType() api.MessageType {
 454         return api.RequestMessage
 455 }
 456
 457 // MacipACLAddReplaceReply represents VPP binary API message 'macip_acl_add_replace_reply'.
 458 type MacipACLAddReplaceReply struct {
 459         ACLIndex uint32
 460         Retval   int32
 461 }
 462
 463 func (*MacipACLAddReplaceReply) GetMessageName() string {
 464         return "macip_acl_add_replace_reply"
 465 }
 466 func (*MacipACLAddReplaceReply) GetCrcString() string {
 467         return "ac407b0c"
 468 }
 469 func (*MacipACLAddReplaceReply) GetMessageType() api.MessageType {
 470         return api.ReplyMessage
 471 }
 472
 473 // MacipACLAddReply represents VPP binary API message 'macip_acl_add_reply'.
 474 type MacipACLAddReply struct {
 475         ACLIndex uint32
 476         Retval   int32
 477 }
 478
 479 func (*MacipACLAddReply) GetMessageName() string {
 480         return "macip_acl_add_reply"
 481 }
 482 func (*MacipACLAddReply) GetCrcString() string {
 483         return "ac407b0c"
 484 }
 485 func (*MacipACLAddReply) GetMessageType() api.MessageType {
 486         return api.ReplyMessage
 487 }
 488
 489 // MacipACLDel represents VPP binary API message 'macip_acl_del'.
 490 type MacipACLDel struct {
 491         ACLIndex uint32
 492 }
 493
 494 func (*MacipACLDel) GetMessageName() string {
 495         return "macip_acl_del"
 496 }
 497 func (*MacipACLDel) GetCrcString() string {
 498         return "ef34fea4"
 499 }
 500 func (*MacipACLDel) GetMessageType() api.MessageType {
 501         return api.RequestMessage
 502 }
 503
 504 // MacipACLDelReply represents VPP binary API message 'macip_acl_del_reply'.
 505 type MacipACLDelReply struct {
 506         Retval int32
 507 }
 508
 509 func (*MacipACLDelReply) GetMessageName() string {
 510         return "macip_acl_del_reply"
 511 }
 512 func (*MacipACLDelReply) GetCrcString() string {
 513         return "e8d4e804"
 514 }
 515 func (*MacipACLDelReply) GetMessageType() api.MessageType {
 516         return api.ReplyMessage
 517 }
 518
 519 // MacipACLDetails represents VPP binary API message 'macip_acl_details'.
 520 type MacipACLDetails struct {
 521         ACLIndex uint32
 522         Tag      []byte `struc:"[64]byte"`
 523         Count    uint32 `struc:"sizeof=R"`
 524         R        []MacipACLRule
 525 }
 526
 527 func (*MacipACLDetails) GetMessageName() string {
 528         return "macip_acl_details"
 529 }
 530 func (*MacipACLDetails) GetCrcString() string {
 531         return "dd2b55ba"
 532 }
 533 func (*MacipACLDetails) GetMessageType() api.MessageType {
 534         return api.ReplyMessage
 535 }
 536
 537 // MacipACLDump represents VPP binary API message 'macip_acl_dump'.
 538 type MacipACLDump struct {
 539         ACLIndex uint32
 540 }
 541
 542 func (*MacipACLDump) GetMessageName() string {
 543         return "macip_acl_dump"
 544 }
 545 func (*MacipACLDump) GetCrcString() string {
 546         return "ef34fea4"
 547 }
 548 func (*MacipACLDump) GetMessageType() api.MessageType {
 549         return api.RequestMessage
 550 }
 551
 552 // MacipACLInterfaceAddDel represents VPP binary API message 'macip_acl_interface_add_del'.
 553 type MacipACLInterfaceAddDel struct {
 554         IsAdd     uint8
 555         SwIfIndex uint32
 556         ACLIndex  uint32
 557 }
 558
 559 func (*MacipACLInterfaceAddDel) GetMessageName() string {
 560         return "macip_acl_interface_add_del"
 561 }
 562 func (*MacipACLInterfaceAddDel) GetCrcString() string {
 563         return "6a6be97c"
 564 }
 565 func (*MacipACLInterfaceAddDel) GetMessageType() api.MessageType {
 566         return api.RequestMessage
 567 }
 568
 569 // MacipACLInterfaceAddDelReply represents VPP binary API message 'macip_acl_interface_add_del_reply'.
 570 type MacipACLInterfaceAddDelReply struct {
 571         Retval int32
 572 }
 573
 574 func (*MacipACLInterfaceAddDelReply) GetMessageName() string {
 575         return "macip_acl_interface_add_del_reply"
 576 }
 577 func (*MacipACLInterfaceAddDelReply) GetCrcString() string {
 578         return "e8d4e804"
 579 }
 580 func (*MacipACLInterfaceAddDelReply) GetMessageType() api.MessageType {
 581         return api.ReplyMessage
 582 }
 583
 584 // MacipACLInterfaceGet represents VPP binary API message 'macip_acl_interface_get'.
 585 type MacipACLInterfaceGet struct{}
 586
 587 func (*MacipACLInterfaceGet) GetMessageName() string {
 588         return "macip_acl_interface_get"
 589 }
 590 func (*MacipACLInterfaceGet) GetCrcString() string {
 591         return "51077d14"
 592 }
 593 func (*MacipACLInterfaceGet) GetMessageType() api.MessageType {
 594         return api.RequestMessage
 595 }
 596
 597 // MacipACLInterfaceGetReply represents VPP binary API message 'macip_acl_interface_get_reply'.
 598 type MacipACLInterfaceGetReply struct {
 599         Count uint32 `struc:"sizeof=Acls"`
 600         Acls  []uint32
 601 }
 602
 603 func (*MacipACLInterfaceGetReply) GetMessageName() string {
 604         return "macip_acl_interface_get_reply"
 605 }
 606 func (*MacipACLInterfaceGetReply) GetCrcString() string {
 607         return "accf9b05"
 608 }
 609 func (*MacipACLInterfaceGetReply) GetMessageType() api.MessageType {
 610         return api.ReplyMessage
 611 }
 612
 613 // MacipACLInterfaceListDetails represents VPP binary API message 'macip_acl_interface_list_details'.
 614 type MacipACLInterfaceListDetails struct {
 615         SwIfIndex uint32
 616         Count     uint8 `struc:"sizeof=Acls"`
 617         Acls      []uint32
 618 }
 619
 620 func (*MacipACLInterfaceListDetails) GetMessageName() string {
 621         return "macip_acl_interface_list_details"
 622 }
 623 func (*MacipACLInterfaceListDetails) GetCrcString() string {
 624         return "29783fa0"
 625 }
 626 func (*MacipACLInterfaceListDetails) GetMessageType() api.MessageType {
 627         return api.ReplyMessage
 628 }
 629
 630 // MacipACLInterfaceListDump represents VPP binary API message 'macip_acl_interface_list_dump'.
 631 type MacipACLInterfaceListDump struct {
 632         SwIfIndex uint32
 633 }
 634
 635 func (*MacipACLInterfaceListDump) GetMessageName() string {
 636         return "macip_acl_interface_list_dump"
 637 }
 638 func (*MacipACLInterfaceListDump) GetCrcString() string {
 639         return "529cb13f"
 640 }
 641 func (*MacipACLInterfaceListDump) GetMessageType() api.MessageType {
 642         return api.RequestMessage
 643 }
 644
 645 func init() {
 646         api.RegisterMessage((*ACLAddReplace)(nil), "acl.ACLAddReplace")
 647         api.RegisterMessage((*ACLAddReplaceReply)(nil), "acl.ACLAddReplaceReply")
 648         api.RegisterMessage((*ACLDel)(nil), "acl.ACLDel")
 649         api.RegisterMessage((*ACLDelReply)(nil), "acl.ACLDelReply")
 650         api.RegisterMessage((*ACLDetails)(nil), "acl.ACLDetails")
 651         api.RegisterMessage((*ACLDump)(nil), "acl.ACLDump")
 652         api.RegisterMessage((*ACLInterfaceAddDel)(nil), "acl.ACLInterfaceAddDel")
 653         api.RegisterMessage((*ACLInterfaceAddDelReply)(nil), "acl.ACLInterfaceAddDelReply")
 654         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDetails)(nil), "acl.ACLInterfaceEtypeWhitelistDetails")
 655         api.RegisterMessage((*ACLInterfaceEtypeWhitelistDump)(nil), "acl.ACLInterfaceEtypeWhitelistDump")
 656         api.RegisterMessage((*ACLInterfaceListDetails)(nil), "acl.ACLInterfaceListDetails")
 657         api.RegisterMessage((*ACLInterfaceListDump)(nil), "acl.ACLInterfaceListDump")
 658         api.RegisterMessage((*ACLInterfaceSetACLList)(nil), "acl.ACLInterfaceSetACLList")
 659         api.RegisterMessage((*ACLInterfaceSetACLListReply)(nil), "acl.ACLInterfaceSetACLListReply")
 660         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelist)(nil), "acl.ACLInterfaceSetEtypeWhitelist")
 661         api.RegisterMessage((*ACLInterfaceSetEtypeWhitelistReply)(nil), "acl.ACLInterfaceSetEtypeWhitelistReply")
 662         api.RegisterMessage((*ACLPluginControlPing)(nil), "acl.ACLPluginControlPing")
 663         api.RegisterMessage((*ACLPluginControlPingReply)(nil), "acl.ACLPluginControlPingReply")
 664         api.RegisterMessage((*ACLPluginGetConnTableMaxEntries)(nil), "acl.ACLPluginGetConnTableMaxEntries")
 665         api.RegisterMessage((*ACLPluginGetConnTableMaxEntriesReply)(nil), "acl.ACLPluginGetConnTableMaxEntriesReply")
 666         api.RegisterMessage((*ACLPluginGetVersion)(nil), "acl.ACLPluginGetVersion")
 667         api.RegisterMessage((*ACLPluginGetVersionReply)(nil), "acl.ACLPluginGetVersionReply")
 668         api.RegisterMessage((*MacipACLAdd)(nil), "acl.MacipACLAdd")
 669         api.RegisterMessage((*MacipACLAddReplace)(nil), "acl.MacipACLAddReplace")
 670         api.RegisterMessage((*MacipACLAddReplaceReply)(nil), "acl.MacipACLAddReplaceReply")
 671         api.RegisterMessage((*MacipACLAddReply)(nil), "acl.MacipACLAddReply")
 672         api.RegisterMessage((*MacipACLDel)(nil), "acl.MacipACLDel")
 673         api.RegisterMessage((*MacipACLDelReply)(nil), "acl.MacipACLDelReply")
 674         api.RegisterMessage((*MacipACLDetails)(nil), "acl.MacipACLDetails")
 675         api.RegisterMessage((*MacipACLDump)(nil), "acl.MacipACLDump")
 676         api.RegisterMessage((*MacipACLInterfaceAddDel)(nil), "acl.MacipACLInterfaceAddDel")
 677         api.RegisterMessage((*MacipACLInterfaceAddDelReply)(nil), "acl.MacipACLInterfaceAddDelReply")
 678         api.RegisterMessage((*MacipACLInterfaceGet)(nil), "acl.MacipACLInterfaceGet")
 679         api.RegisterMessage((*MacipACLInterfaceGetReply)(nil), "acl.MacipACLInterfaceGetReply")
 680         api.RegisterMessage((*MacipACLInterfaceListDetails)(nil), "acl.MacipACLInterfaceListDetails")
 681         api.RegisterMessage((*MacipACLInterfaceListDump)(nil), "acl.MacipACLInterfaceListDump")
 682 }
 683
 684 // Messages returns list of all messages in this module.
 685 func AllMessages() []api.Message {
 686         return []api.Message{
 687                 (*ACLAddReplace)(nil),
 688                 (*ACLAddReplaceReply)(nil),
 689                 (*ACLDel)(nil),
 690                 (*ACLDelReply)(nil),
 691                 (*ACLDetails)(nil),
 692                 (*ACLDump)(nil),
 693                 (*ACLInterfaceAddDel)(nil),
 694                 (*ACLInterfaceAddDelReply)(nil),
 695                 (*ACLInterfaceEtypeWhitelistDetails)(nil),
 696                 (*ACLInterfaceEtypeWhitelistDump)(nil),
 697                 (*ACLInterfaceListDetails)(nil),
 698                 (*ACLInterfaceListDump)(nil),
 699                 (*ACLInterfaceSetACLList)(nil),
 700                 (*ACLInterfaceSetACLListReply)(nil),
 701                 (*ACLInterfaceSetEtypeWhitelist)(nil),
 702                 (*ACLInterfaceSetEtypeWhitelistReply)(nil),
 703                 (*ACLPluginControlPing)(nil),
 704                 (*ACLPluginControlPingReply)(nil),
 705                 (*ACLPluginGetConnTableMaxEntries)(nil),
 706                 (*ACLPluginGetConnTableMaxEntriesReply)(nil),
 707                 (*ACLPluginGetVersion)(nil),
 708                 (*ACLPluginGetVersionReply)(nil),
 709                 (*MacipACLAdd)(nil),
 710                 (*MacipACLAddReplace)(nil),
 711                 (*MacipACLAddReplaceReply)(nil),
 712                 (*MacipACLAddReply)(nil),
 713                 (*MacipACLDel)(nil),
 714                 (*MacipACLDelReply)(nil),
 715                 (*MacipACLDetails)(nil),
 716                 (*MacipACLDump)(nil),
 717                 (*MacipACLInterfaceAddDel)(nil),
 718                 (*MacipACLInterfaceAddDelReply)(nil),
 719                 (*MacipACLInterfaceGet)(nil),
 720                 (*MacipACLInterfaceGetReply)(nil),
 721                 (*MacipACLInterfaceListDetails)(nil),
 722                 (*MacipACLInterfaceListDump)(nil),
 723         }
 724 }
 725
 726 // RPCService represents RPC service API for acl module.
 727 type RPCService interface {
 728         DumpACL(ctx context.Context, in *ACLDump) (RPCService_DumpACLClient, error)
 729         DumpACLInterfaceEtypeWhitelist(ctx context.Context, in *ACLInterfaceEtypeWhitelistDump) (RPCService_DumpACLInterfaceEtypeWhitelistClient, error)
 730         DumpACLInterfaceList(ctx context.Context, in *ACLInterfaceListDump) (RPCService_DumpACLInterfaceListClient, error)
 731         DumpMacipACL(ctx context.Context, in *MacipACLDump) (RPCService_DumpMacipACLClient, error)
 732         DumpMacipACLInterfaceList(ctx context.Context, in *MacipACLInterfaceListDump) (RPCService_DumpMacipACLInterfaceListClient, error)
 733         ACLAddReplace(ctx context.Context, in *ACLAddReplace) (*ACLAddReplaceReply, error)
 734         ACLDel(ctx context.Context, in *ACLDel) (*ACLDelReply, error)
 735         ACLInterfaceAddDel(ctx context.Context, in *ACLInterfaceAddDel) (*ACLInterfaceAddDelReply, error)
 736         ACLInterfaceSetACLList(ctx context.Context, in *ACLInterfaceSetACLList) (*ACLInterfaceSetACLListReply, error)
 737         ACLInterfaceSetEtypeWhitelist(ctx context.Context, in *ACLInterfaceSetEtypeWhitelist) (*ACLInterfaceSetEtypeWhitelistReply, error)
 738         ACLPluginControlPing(ctx context.Context, in *ACLPluginControlPing) (*ACLPluginControlPingReply, error)
 739         ACLPluginGetConnTableMaxEntries(ctx context.Context, in *ACLPluginGetConnTableMaxEntries) (*ACLPluginGetConnTableMaxEntriesReply, error)
 740         ACLPluginGetVersion(ctx context.Context, in *ACLPluginGetVersion) (*ACLPluginGetVersionReply, error)
 741         MacipACLAdd(ctx context.Context, in *MacipACLAdd) (*MacipACLAddReply, error)
 742         MacipACLAddReplace(ctx context.Context, in *MacipACLAddReplace) (*MacipACLAddReplaceReply, error)
 743         MacipACLDel(ctx context.Context, in *MacipACLDel) (*MacipACLDelReply, error)
 744         MacipACLInterfaceAddDel(ctx context.Context, in *MacipACLInterfaceAddDel) (*MacipACLInterfaceAddDelReply, error)
 745         MacipACLInterfaceGet(ctx context.Context, in *MacipACLInterfaceGet) (*MacipACLInterfaceGetReply, error)
 746 }
 747
 748 type serviceClient struct {
 749         ch api.Channel
 750 }
 751
 752 func NewServiceClient(ch api.Channel) RPCService {
 753         return &serviceClient{ch}
 754 }
 755
 756 func (c *serviceClient) DumpACL(ctx context.Context, in *ACLDump) (RPCService_DumpACLClient, error) {
 757         stream := c.ch.SendMultiRequest(in)
 758         x := &serviceClient_DumpACLClient{stream}
 759         return x, nil
 760 }
 761
 762 type RPCService_DumpACLClient interface {
 763         Recv() (*ACLDetails, error)
 764 }
 765
 766 type serviceClient_DumpACLClient struct {
 767         api.MultiRequestCtx
 768 }
 769
 770 func (c *serviceClient_DumpACLClient) Recv() (*ACLDetails, error) {
 771         m := new(ACLDetails)
 772         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 773         if err != nil {
 774                 return nil, err
 775         }
 776         if stop {
 777                 return nil, io.EOF
 778         }
 779         return m, nil
 780 }
 781
 782 func (c *serviceClient) DumpACLInterfaceEtypeWhitelist(ctx context.Context, in *ACLInterfaceEtypeWhitelistDump) (RPCService_DumpACLInterfaceEtypeWhitelistClient, error) {
 783         stream := c.ch.SendMultiRequest(in)
 784         x := &serviceClient_DumpACLInterfaceEtypeWhitelistClient{stream}
 785         return x, nil
 786 }
 787
 788 type RPCService_DumpACLInterfaceEtypeWhitelistClient interface {
 789         Recv() (*ACLInterfaceEtypeWhitelistDetails, error)
 790 }
 791
 792 type serviceClient_DumpACLInterfaceEtypeWhitelistClient struct {
 793         api.MultiRequestCtx
 794 }
 795
 796 func (c *serviceClient_DumpACLInterfaceEtypeWhitelistClient) Recv() (*ACLInterfaceEtypeWhitelistDetails, error) {
 797         m := new(ACLInterfaceEtypeWhitelistDetails)
 798         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 799         if err != nil {
 800                 return nil, err
 801         }
 802         if stop {
 803                 return nil, io.EOF
 804         }
 805         return m, nil
 806 }
 807
 808 func (c *serviceClient) DumpACLInterfaceList(ctx context.Context, in *ACLInterfaceListDump) (RPCService_DumpACLInterfaceListClient, error) {
 809         stream := c.ch.SendMultiRequest(in)
 810         x := &serviceClient_DumpACLInterfaceListClient{stream}
 811         return x, nil
 812 }
 813
 814 type RPCService_DumpACLInterfaceListClient interface {
 815         Recv() (*ACLInterfaceListDetails, error)
 816 }
 817
 818 type serviceClient_DumpACLInterfaceListClient struct {
 819         api.MultiRequestCtx
 820 }
 821
 822 func (c *serviceClient_DumpACLInterfaceListClient) Recv() (*ACLInterfaceListDetails, error) {
 823         m := new(ACLInterfaceListDetails)
 824         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 825         if err != nil {
 826                 return nil, err
 827         }
 828         if stop {
 829                 return nil, io.EOF
 830         }
 831         return m, nil
 832 }
 833
 834 func (c *serviceClient) DumpMacipACL(ctx context.Context, in *MacipACLDump) (RPCService_DumpMacipACLClient, error) {
 835         stream := c.ch.SendMultiRequest(in)
 836         x := &serviceClient_DumpMacipACLClient{stream}
 837         return x, nil
 838 }
 839
 840 type RPCService_DumpMacipACLClient interface {
 841         Recv() (*MacipACLDetails, error)
 842 }
 843
 844 type serviceClient_DumpMacipACLClient struct {
 845         api.MultiRequestCtx
 846 }
 847
 848 func (c *serviceClient_DumpMacipACLClient) Recv() (*MacipACLDetails, error) {
 849         m := new(MacipACLDetails)
 850         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 851         if err != nil {
 852                 return nil, err
 853         }
 854         if stop {
 855                 return nil, io.EOF
 856         }
 857         return m, nil
 858 }
 859
 860 func (c *serviceClient) DumpMacipACLInterfaceList(ctx context.Context, in *MacipACLInterfaceListDump) (RPCService_DumpMacipACLInterfaceListClient, error) {
 861         stream := c.ch.SendMultiRequest(in)
 862         x := &serviceClient_DumpMacipACLInterfaceListClient{stream}
 863         return x, nil
 864 }
 865
 866 type RPCService_DumpMacipACLInterfaceListClient interface {
 867         Recv() (*MacipACLInterfaceListDetails, error)
 868 }
 869
 870 type serviceClient_DumpMacipACLInterfaceListClient struct {
 871         api.MultiRequestCtx
 872 }
 873
 874 func (c *serviceClient_DumpMacipACLInterfaceListClient) Recv() (*MacipACLInterfaceListDetails, error) {
 875         m := new(MacipACLInterfaceListDetails)
 876         stop, err := c.MultiRequestCtx.ReceiveReply(m)
 877         if err != nil {
 878                 return nil, err
 879         }
 880         if stop {
 881                 return nil, io.EOF
 882         }
 883         return m, nil
 884 }
 885
 886 func (c *serviceClient) ACLAddReplace(ctx context.Context, in *ACLAddReplace) (*ACLAddReplaceReply, error) {
 887         out := new(ACLAddReplaceReply)
 888         err := c.ch.SendRequest(in).ReceiveReply(out)
 889         if err != nil {
 890                 return nil, err
 891         }
 892         return out, nil
 893 }
 894
 895 func (c *serviceClient) ACLDel(ctx context.Context, in *ACLDel) (*ACLDelReply, error) {
 896         out := new(ACLDelReply)
 897         err := c.ch.SendRequest(in).ReceiveReply(out)
 898         if err != nil {
 899                 return nil, err
 900         }
 901         return out, nil
 902 }
 903
 904 func (c *serviceClient) ACLInterfaceAddDel(ctx context.Context, in *ACLInterfaceAddDel) (*ACLInterfaceAddDelReply, error) {
 905         out := new(ACLInterfaceAddDelReply)
 906         err := c.ch.SendRequest(in).ReceiveReply(out)
 907         if err != nil {
 908                 return nil, err
 909         }
 910         return out, nil
 911 }
 912
 913 func (c *serviceClient) ACLInterfaceSetACLList(ctx context.Context, in *ACLInterfaceSetACLList) (*ACLInterfaceSetACLListReply, error) {
 914         out := new(ACLInterfaceSetACLListReply)
 915         err := c.ch.SendRequest(in).ReceiveReply(out)
 916         if err != nil {
 917                 return nil, err
 918         }
 919         return out, nil
 920 }
 921
 922 func (c *serviceClient) ACLInterfaceSetEtypeWhitelist(ctx context.Context, in *ACLInterfaceSetEtypeWhitelist) (*ACLInterfaceSetEtypeWhitelistReply, error) {
 923         out := new(ACLInterfaceSetEtypeWhitelistReply)
 924         err := c.ch.SendRequest(in).ReceiveReply(out)
 925         if err != nil {
 926                 return nil, err
 927         }
 928         return out, nil
 929 }
 930
 931 func (c *serviceClient) ACLPluginControlPing(ctx context.Context, in *ACLPluginControlPing) (*ACLPluginControlPingReply, error) {
 932         out := new(ACLPluginControlPingReply)
 933         err := c.ch.SendRequest(in).ReceiveReply(out)
 934         if err != nil {
 935                 return nil, err
 936         }
 937         return out, nil
 938 }
 939
 940 func (c *serviceClient) ACLPluginGetConnTableMaxEntries(ctx context.Context, in *ACLPluginGetConnTableMaxEntries) (*ACLPluginGetConnTableMaxEntriesReply, error) {
 941         out := new(ACLPluginGetConnTableMaxEntriesReply)
 942         err := c.ch.SendRequest(in).ReceiveReply(out)
 943         if err != nil {
 944                 return nil, err
 945         }
 946         return out, nil
 947 }
 948
 949 func (c *serviceClient) ACLPluginGetVersion(ctx context.Context, in *ACLPluginGetVersion) (*ACLPluginGetVersionReply, error) {
 950         out := new(ACLPluginGetVersionReply)
 951         err := c.ch.SendRequest(in).ReceiveReply(out)
 952         if err != nil {
 953                 return nil, err
 954         }
 955         return out, nil
 956 }
 957
 958 func (c *serviceClient) MacipACLAdd(ctx context.Context, in *MacipACLAdd) (*MacipACLAddReply, error) {
 959         out := new(MacipACLAddReply)
 960         err := c.ch.SendRequest(in).ReceiveReply(out)
 961         if err != nil {
 962                 return nil, err
 963         }
 964         return out, nil
 965 }
 966
 967 func (c *serviceClient) MacipACLAddReplace(ctx context.Context, in *MacipACLAddReplace) (*MacipACLAddReplaceReply, error) {
 968         out := new(MacipACLAddReplaceReply)
 969         err := c.ch.SendRequest(in).ReceiveReply(out)
 970         if err != nil {
 971                 return nil, err
 972         }
 973         return out, nil
 974 }
 975
 976 func (c *serviceClient) MacipACLDel(ctx context.Context, in *MacipACLDel) (*MacipACLDelReply, error) {
 977         out := new(MacipACLDelReply)
 978         err := c.ch.SendRequest(in).ReceiveReply(out)
 979         if err != nil {
 980                 return nil, err
 981         }
 982         return out, nil
 983 }
 984
 985 func (c *serviceClient) MacipACLInterfaceAddDel(ctx context.Context, in *MacipACLInterfaceAddDel) (*MacipACLInterfaceAddDelReply, error) {
 986         out := new(MacipACLInterfaceAddDelReply)
 987         err := c.ch.SendRequest(in).ReceiveReply(out)
 988         if err != nil {
 989                 return nil, err
 990         }
 991         return out, nil
 992 }
 993
 994 func (c *serviceClient) MacipACLInterfaceGet(ctx context.Context, in *MacipACLInterfaceGet) (*MacipACLInterfaceGetReply, error) {
 995         out := new(MacipACLInterfaceGetReply)
 996         err := c.ch.SendRequest(in).ReceiveReply(out)
 997         if err != nil {
 998                 return nil, err
 999         }
1000         return out, nil
1001 }
1002
1003 // This is a compile-time assertion to ensure that this generated file
1004 // is compatible with the GoVPP api package it is being compiled against.
1005 // A compilation error at this line likely means your copy of the
1006 // GoVPP api package needs to be updated.
1007 const _ = api.GoVppAPIPackageIsVersion1 // please upgrade the GoVPP api package
1008
1009 // Reference imports to suppress errors if they are not otherwise used.
1010 var _ = api.RegisterMessage
1011 var _ = bytes.NewBuffer
1012 var _ = context.Background
1013 var _ = io.Copy
1014 var _ = strconv.Itoa
1015 var _ = struc.Pack