examples/binapi/acl/acl.ba.go

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