test/vpp_papi_provider.py

   1 import os
   2 import fnmatch
   3 import time
   4 from hook import Hook
   5 from collections import deque
   6
   7 # Sphinx creates auto-generated documentation by importing the python source
   8 # files and collecting the docstrings from them. The NO_VPP_PAPI flag allows
   9 # the vpp_papi_provider.py file to be importable without having to build
  10 # the whole vpp api if the user only wishes to generate the test documentation.
  11 do_import = True
  12 try:
  13     no_vpp_papi = os.getenv("NO_VPP_PAPI")
  14     if no_vpp_papi == "1":
  15         do_import = False
  16 except:
  17     pass
  18
  19 if do_import:
  20     from vpp_papi import VPP
  21
  22 # from vnet/vnet/mpls/mpls_types.h
  23 MPLS_IETF_MAX_LABEL = 0xfffff
  24 MPLS_LABEL_INVALID = MPLS_IETF_MAX_LABEL + 1
  25
  26
  27 class L2_VTR_OP:
  28     L2_DISABLED = 0
  29     L2_PUSH_1 = 1
  30     L2_PUSH_2 = 2
  31     L2_POP_1 = 3
  32     L2_POP_2 = 4
  33     L2_TRANSLATE_1_1 = 5
  34     L2_TRANSLATE_1_2 = 6
  35     L2_TRANSLATE_2_1 = 7
  36     L2_TRANSLATE_2_2 = 8
  37
  38
  39 class UnexpectedApiReturnValueError(Exception):
  40     """ exception raised when the API return value is unexpected """
  41     pass
  42
  43
  44 class VppPapiProvider(object):
  45     """VPP-api provider using vpp-papi
  46
  47     @property hook: hook object providing before and after api/cli hooks
  48     """
  49
  50     _zero, _negative = range(2)
  51
  52     def __init__(self, name, shm_prefix, test_class):
  53         self.hook = Hook("vpp-papi-provider")
  54         self.name = name
  55         self.shm_prefix = shm_prefix
  56         self.test_class = test_class
  57         self._expect_api_retval = self._zero
  58         self._expect_stack = []
  59         jsonfiles = []
  60
  61         install_dir = os.getenv('VPP_TEST_INSTALL_PATH')
  62         for root, dirnames, filenames in os.walk(install_dir):
  63             for filename in fnmatch.filter(filenames, '*.api.json'):
  64                 jsonfiles.append(os.path.join(root, filename))
  65
  66         self.vpp = VPP(jsonfiles, logger=test_class.logger)
  67         self._events = deque()
  68
  69     def __enter__(self):
  70         return self
  71
  72     def expect_negative_api_retval(self):
  73         """ Expect API failure """
  74         self._expect_stack.append(self._expect_api_retval)
  75         self._expect_api_retval = self._negative
  76         return self
  77
  78     def expect_zero_api_retval(self):
  79         """ Expect API success """
  80         self._expect_stack.append(self._expect_api_retval)
  81         self._expect_api_retval = self._zero
  82         return self
  83
  84     def __exit__(self, exc_type, exc_value, traceback):
  85         self._expect_api_retval = self._expect_stack.pop()
  86
  87     def register_hook(self, hook):
  88         """Replace hook registration with new hook
  89
  90         :param hook:
  91
  92         """
  93         self.hook = hook
  94
  95     def collect_events(self):
  96         """ Collect all events from the internal queue and clear the queue. """
  97         e = self._events
  98         self._events = deque()
  99         return e
 100
 101     def wait_for_event(self, timeout, name=None):
 102         """ Wait for and return next event. """
 103         if name:
 104             self.test_class.logger.debug("Expecting event '%s' within %ss",
 105                                          name, timeout)
 106         else:
 107             self.test_class.logger.debug("Expecting event within %ss",
 108                                          timeout)
 109         if self._events:
 110             self.test_class.logger.debug("Not waiting, event already queued")
 111         limit = time.time() + timeout
 112         while time.time() < limit:
 113             if self._events:
 114                 e = self._events.popleft()
 115                 if name and type(e).__name__ != name:
 116                     raise Exception(
 117                         "Unexpected event received: %s, expected: %s" %
 118                         (type(e).__name__, name))
 119                 self.test_class.logger.debug("Returning event %s:%s" %
 120                                              (name, e))
 121                 return e
 122             time.sleep(0)  # yield
 123         raise Exception("Event did not occur within timeout")
 124
 125     def __call__(self, name, event):
 126         """ Enqueue event in the internal event queue. """
 127         # FIXME use the name instead of relying on type(e).__name__ ?
 128         # FIXME #2 if this throws, it is eaten silently, Ole?
 129         self.test_class.logger.debug("New event: %s: %s" % (name, event))
 130         self._events.append(event)
 131
 132     def connect(self):
 133         """Connect the API to VPP"""
 134         self.vpp.connect(self.name, self.shm_prefix)
 135         self.papi = self.vpp.api
 136         self.vpp.register_event_callback(self)
 137
 138     def disconnect(self):
 139         """Disconnect the API from VPP"""
 140         self.vpp.disconnect()
 141
 142     def api(self, api_fn, api_args, expected_retval=0):
 143         """ Call API function and check it's return value.
 144         Call the appropriate hooks before and after the API call
 145
 146         :param api_fn: API function to call
 147         :param api_args: tuple of API function arguments
 148         :param expected_retval: Expected return value (Default value = 0)
 149         :returns: reply from the API
 150
 151         """
 152         self.hook.before_api(api_fn.__name__, api_args)
 153         reply = api_fn(**api_args)
 154         if self._expect_api_retval == self._negative:
 155             if hasattr(reply, 'retval') and reply.retval >= 0:
 156                 msg = "API call passed unexpectedly: expected negative "\
 157                     "return value instead of %d in %s" % \
 158                     (reply.retval, repr(reply))
 159                 self.test_class.logger.info(msg)
 160                 raise UnexpectedApiReturnValueError(msg)
 161         elif self._expect_api_retval == self._zero:
 162             if hasattr(reply, 'retval') and reply.retval != expected_retval:
 163                 msg = "API call failed, expected %d return value instead "\
 164                     "of %d in %s" % (expected_retval, reply.retval,
 165                                      repr(reply))
 166                 self.test_class.logger.info(msg)
 167                 raise UnexpectedApiReturnValueError(msg)
 168         else:
 169             raise Exception("Internal error, unexpected value for "
 170                             "self._expect_api_retval %s" %
 171                             self._expect_api_retval)
 172         self.hook.after_api(api_fn.__name__, api_args)
 173         return reply
 174
 175     def cli(self, cli):
 176         """ Execute a CLI, calling the before/after hooks appropriately.
 177
 178         :param cli: CLI to execute
 179         :returns: CLI output
 180
 181         """
 182         self.hook.before_cli(cli)
 183         cli += '\n'
 184         r = self.papi.cli_inband(length=len(cli), cmd=cli)
 185         self.hook.after_cli(cli)
 186         if hasattr(r, 'reply'):
 187             return r.reply.decode().rstrip('\x00')
 188
 189     def ppcli(self, cli):
 190         """ Helper method to print CLI command in case of info logging level.
 191
 192         :param cli: CLI to execute
 193         :returns: CLI output
 194         """
 195         return cli + "\n" + str(self.cli(cli))
 196
 197     def _convert_mac(self, mac):
 198         return mac.replace(':', '').decode('hex')
 199
 200     def show_version(self):
 201         """ """
 202         return self.api(self.papi.show_version, {})
 203
 204     def pg_create_interface(self, pg_index):
 205         """
 206
 207         :param pg_index:
 208
 209         """
 210         return self.api(self.papi.pg_create_interface,
 211                         {"interface_id": pg_index})
 212
 213     def sw_interface_dump(self, filter=None):
 214         """
 215
 216         :param filter:  (Default value = None)
 217
 218         """
 219         if filter is not None:
 220             args = {"name_filter_valid": 1, "name_filter": filter}
 221         else:
 222             args = {}
 223         return self.api(self.papi.sw_interface_dump, args)
 224
 225     def sw_interface_set_table(self, sw_if_index, is_ipv6, table_id):
 226         """ Set the IPvX Table-id for the Interface
 227
 228         :param sw_if_index:
 229         :param is_ipv6:
 230         :param table_id:
 231
 232         """
 233         return self.api(self.papi.sw_interface_set_table,
 234                         {'sw_if_index': sw_if_index, 'is_ipv6': is_ipv6,
 235                          'vrf_id': table_id})
 236
 237     def sw_interface_add_del_address(self, sw_if_index, addr, addr_len,
 238                                      is_ipv6=0, is_add=1, del_all=0):
 239         """
 240
 241         :param addr: param is_ipv6:  (Default value = 0)
 242         :param sw_if_index:
 243         :param addr_len:
 244         :param is_ipv6:  (Default value = 0)
 245         :param is_add:  (Default value = 1)
 246         :param del_all:  (Default value = 0)
 247
 248         """
 249         return self.api(self.papi.sw_interface_add_del_address,
 250                         {'sw_if_index': sw_if_index,
 251                          'is_add': is_add,
 252                          'is_ipv6': is_ipv6,
 253                          'del_all': del_all,
 254                          'address_length': addr_len,
 255                          'address': addr})
 256
 257     def sw_interface_set_unnumbered(self, sw_if_index, ip_sw_if_index,
 258                                     is_add=1):
 259         """ Set the Interface to be unnumbered
 260
 261         :param is_add:  (Default value = 1)
 262         :param sw_if_index - interface That will be unnumbered
 263         :param ip_sw_if_index - interface with an IP addres
 264
 265         """
 266         return self.api(self.papi.sw_interface_set_unnumbered,
 267                         {'sw_if_index': ip_sw_if_index,
 268                          'unnumbered_sw_if_index': sw_if_index,
 269                          'is_add': is_add})
 270
 271     def sw_interface_enable_disable_mpls(self, sw_if_index,
 272                                          is_enable=1):
 273         """
 274         Enable/Disable MPLS on the interface
 275         :param sw_if_index:
 276         :param is_enable:  (Default value = 1)
 277
 278         """
 279         return self.api(self.papi.sw_interface_set_mpls_enable,
 280                         {'sw_if_index': sw_if_index,
 281                          'enable': is_enable})
 282
 283     def sw_interface_ra_suppress(self, sw_if_index, suppress=1):
 284         return self.api(self.papi.sw_interface_ip6nd_ra_config,
 285                         {'sw_if_index': sw_if_index,
 286                          'suppress': suppress})
 287
 288     def set_ip_flow_hash(self,
 289                          table_id,
 290                          src=1,
 291                          dst=1,
 292                          sport=1,
 293                          dport=1,
 294                          proto=1,
 295                          reverse=0,
 296                          is_ip6=0):
 297         return self.api(self.papi.set_ip_flow_hash,
 298                         {'vrf_id': table_id,
 299                          'src': src,
 300                          'dst': dst,
 301                          'dport': dport,
 302                          'sport': sport,
 303                          'proto': proto,
 304                          'reverse': reverse,
 305                          'is_ipv6': is_ip6})
 306
 307     def ip6_nd_proxy(self, address, sw_if_index, is_del=0):
 308         return self.api(self.papi.ip6nd_proxy_add_del,
 309                         {'address': address,
 310                          'sw_if_index': sw_if_index,
 311                          'is_del': is_del})
 312
 313     def ip6_sw_interface_ra_config(self, sw_if_index,
 314                                    no,
 315                                    suppress,
 316                                    send_unicast):
 317         return self.api(self.papi.sw_interface_ip6nd_ra_config,
 318                         {'sw_if_index': sw_if_index,
 319                          'is_no': no,
 320                          'suppress': suppress,
 321                          'send_unicast': send_unicast})
 322
 323     def ip6_sw_interface_ra_prefix(self,
 324                                    sw_if_index,
 325                                    address,
 326                                    address_length,
 327                                    use_default=0,
 328                                    no_advertise=0,
 329                                    off_link=0,
 330                                    no_autoconfig=0,
 331                                    no_onlink=0,
 332                                    is_no=0,
 333                                    val_lifetime=0xffffffff,
 334                                    pref_lifetime=0xffffffff):
 335         return self.api(self.papi.sw_interface_ip6nd_ra_prefix,
 336                         {'sw_if_index': sw_if_index,
 337                          'address': address,
 338                          'address_length': address_length,
 339                          'use_default': use_default,
 340                          'no_advertise': no_advertise,
 341                          'off_link': off_link,
 342                          'no_autoconfig': no_autoconfig,
 343                          'no_onlink': no_onlink,
 344                          'is_no': is_no,
 345                          'val_lifetime': val_lifetime,
 346                          'pref_lifetime': pref_lifetime})
 347
 348     def ip6_sw_interface_enable_disable(self, sw_if_index, enable):
 349         """
 350         Enable/Disable An interface for IPv6
 351         """
 352         return self.api(self.papi.sw_interface_ip6_enable_disable,
 353                         {'sw_if_index': sw_if_index,
 354                          'enable': enable})
 355
 356     def vxlan_add_del_tunnel(
 357             self,
 358             src_addr,
 359             dst_addr,
 360             mcast_sw_if_index=0xFFFFFFFF,
 361             is_add=1,
 362             is_ipv6=0,
 363             encap_vrf_id=0,
 364             decap_next_index=0xFFFFFFFF,
 365             vni=0,
 366             instance=0xFFFFFFFF):
 367         """
 368
 369         :param dst_addr:
 370         :param src_addr:
 371         :param is_add:  (Default value = 1)
 372         :param is_ipv6:  (Default value = 0)
 373         :param encap_vrf_id:  (Default value = 0)
 374         :param decap_next_index:  (Default value = 0xFFFFFFFF)
 375         :param mcast_sw_if_index:  (Default value = 0xFFFFFFFF)
 376         :param vni:  (Default value = 0)
 377         :param instance:  (Default value = 0xFFFFFFFF)
 378
 379         """
 380         return self.api(self.papi.vxlan_add_del_tunnel,
 381                         {'is_add': is_add,
 382                          'is_ipv6': is_ipv6,
 383                          'src_address': src_addr,
 384                          'dst_address': dst_addr,
 385                          'mcast_sw_if_index': mcast_sw_if_index,
 386                          'encap_vrf_id': encap_vrf_id,
 387                          'decap_next_index': decap_next_index,
 388                          'vni': vni,
 389                          'instance': instance})
 390
 391     def geneve_add_del_tunnel(
 392             self,
 393             local_addr,
 394             remote_addr,
 395             mcast_sw_if_index=0xFFFFFFFF,
 396             is_add=1,
 397             is_ipv6=0,
 398             encap_vrf_id=0,
 399             decap_next_index=0xFFFFFFFF,
 400             vni=0):
 401         """
 402
 403         :param remote_addr:
 404         :param local_addr:
 405         :param is_add:  (Default value = 1)
 406         :param is_ipv6:  (Default value = 0)
 407         :param encap_vrf_id:  (Default value = 0)
 408         :param decap_next_index:  (Default value = 0xFFFFFFFF)
 409         :param mcast_sw_if_index:  (Default value = 0xFFFFFFFF)
 410         :param vni:  (Default value = 0)
 411
 412         """
 413         return self.api(self.papi.geneve_add_del_tunnel,
 414                         {'is_add': is_add,
 415                          'is_ipv6': is_ipv6,
 416                          'local_address': local_addr,
 417                          'remote_address': remote_addr,
 418                          'mcast_sw_if_index': mcast_sw_if_index,
 419                          'encap_vrf_id': encap_vrf_id,
 420                          'decap_next_index': decap_next_index,
 421                          'vni': vni})
 422
 423     def bridge_domain_add_del(self, bd_id, flood=1, uu_flood=1, forward=1,
 424                               learn=1, arp_term=0, is_add=1):
 425         """Create/delete bridge domain.
 426
 427         :param int bd_id: Bridge domain index.
 428         :param int flood: Enable/disable bcast/mcast flooding in the BD.
 429             (Default value = 1)
 430         :param int uu_flood: Enable/disable unknown unicast flood in the BD.
 431             (Default value = 1)
 432         :param int forward: Enable/disable forwarding on all interfaces in
 433             the BD. (Default value = 1)
 434         :param int learn: Enable/disable learning on all interfaces in the BD.
 435             (Default value = 1)
 436         :param int arp_term: Enable/disable arp termination in the BD.
 437             (Default value = 1)
 438         :param int is_add: Add or delete flag. (Default value = 1)
 439         """
 440         return self.api(self.papi.bridge_domain_add_del,
 441                         {'bd_id': bd_id,
 442                          'flood': flood,
 443                          'uu_flood': uu_flood,
 444                          'forward': forward,
 445                          'learn': learn,
 446                          'arp_term': arp_term,
 447                          'is_add': is_add})
 448
 449     def bd_ip_mac_add_del(self, bd_id, mac, ip, is_ipv6=0, is_add=1):
 450         return self.api(self.papi.bd_ip_mac_add_del,
 451                         {'bd_id': bd_id,
 452                          'is_add': is_add,
 453                          'is_ipv6': is_ipv6,
 454                          'ip_address': ip,
 455                          'mac_address': mac})
 456
 457     def want_ip4_arp_events(self, enable_disable=1, address=0):
 458         return self.api(self.papi.want_ip4_arp_events,
 459                         {'enable_disable': enable_disable,
 460                          'address': address,
 461                          'pid': os.getpid(), })
 462
 463     def want_ip6_nd_events(self, enable_disable=1, address=0):
 464         return self.api(self.papi.want_ip6_nd_events,
 465                         {'enable_disable': enable_disable,
 466                          'address': address,
 467                          'pid': os.getpid(), })
 468
 469     def want_macs_learn_events(self, enable_disable=1, scan_delay=0,
 470                                max_macs_in_event=0, learn_limit=0):
 471         return self.api(self.papi.want_l2_macs_events,
 472                         {'enable_disable': enable_disable,
 473                          'scan_delay': scan_delay,
 474                          'max_macs_in_event': max_macs_in_event,
 475                          'learn_limit': learn_limit,
 476                          'pid': os.getpid(), })
 477
 478     def l2fib_add_del(self, mac, bd_id, sw_if_index, is_add=1, static_mac=0,
 479                       filter_mac=0, bvi_mac=0):
 480         """Create/delete L2 FIB entry.
 481
 482         :param str mac: MAC address to create FIB entry for.
 483         :param int bd_id: Bridge domain index.
 484         :param int sw_if_index: Software interface index of the interface.
 485         :param int is_add: Add or delete flag. (Default value = 1)
 486         :param int static_mac: Set to 1 to create static MAC entry.
 487             (Default value = 0)
 488         :param int filter_mac: Set to 1 to drop packet that's source or
 489             destination MAC address contains defined MAC address.
 490             (Default value = 0)
 491         :param int bvi_mac: Set to 1 to create entry that points to BVI
 492             interface. (Default value = 0)
 493         """
 494         return self.api(self.papi.l2fib_add_del,
 495                         {'mac': self._convert_mac(mac),
 496                          'bd_id': bd_id,
 497                          'sw_if_index': sw_if_index,
 498                          'is_add': is_add,
 499                          'static_mac': static_mac,
 500                          'filter_mac': filter_mac,
 501                          'bvi_mac': bvi_mac})
 502
 503     def l2fib_flush_int(self, sw_if_index):
 504         """Flush L2 FIB entries for sw_if_index.
 505
 506         :param int sw_if_index: Software interface index of the interface.
 507         """
 508         return self.api(self.papi.l2fib_flush_int,
 509                         {'sw_if_index': sw_if_index})
 510
 511     def l2fib_flush_bd(self, bd_id):
 512         """Flush L2 FIB entries for bd_id.
 513
 514         :param int sw_if_index: Bridge Domain id.
 515         """
 516         return self.api(self.papi.l2fib_flush_bd,
 517                         {'bd_id': bd_id})
 518
 519     def l2fib_flush_all(self):
 520         """Flush all L2 FIB.
 521         """
 522         return self.api(self.papi.l2fib_flush_all, {})
 523
 524     def sw_interface_set_l2_bridge(self, sw_if_index, bd_id,
 525                                    shg=0, bvi=0, enable=1):
 526         """Add/remove interface to/from bridge domain.
 527
 528         :param int sw_if_index: Software interface index of the interface.
 529         :param int bd_id: Bridge domain index.
 530         :param int shg: Split-horizon group index. (Default value = 0)
 531         :param int bvi: Set interface as a bridge group virtual interface.
 532             (Default value = 0)
 533         :param int enable: Add or remove interface. (Default value = 1)
 534         """
 535         return self.api(self.papi.sw_interface_set_l2_bridge,
 536                         {'rx_sw_if_index': sw_if_index,
 537                          'bd_id': bd_id,
 538                          'shg': shg,
 539                          'bvi': bvi,
 540                          'enable': enable})
 541
 542     def bridge_flags(self, bd_id, is_set, feature_bitmap):
 543         """Enable/disable required feature of the bridge domain with defined ID.
 544
 545         :param int bd_id: Bridge domain ID.
 546         :param int is_set: Set to 1 to enable, set to 0 to disable the feature.
 547         :param int feature_bitmap: Bitmap value of the feature to be set:
 548             - learn (1 << 0),
 549             - forward (1 << 1),
 550             - flood (1 << 2),
 551             - uu-flood (1 << 3) or
 552             - arp-term (1 << 4).
 553         """
 554         return self.api(self.papi.bridge_flags,
 555                         {'bd_id': bd_id,
 556                          'is_set': is_set,
 557                          'feature_bitmap': feature_bitmap})
 558
 559     def bridge_domain_dump(self, bd_id=0):
 560         """
 561
 562         :param int bd_id: Bridge domain ID. (Default value = 0 => dump of all
 563             existing bridge domains returned)
 564         :return: Dictionary of bridge domain(s) data.
 565         """
 566         return self.api(self.papi.bridge_domain_dump,
 567                         {'bd_id': bd_id})
 568
 569     def sw_interface_set_l2_xconnect(self, rx_sw_if_index, tx_sw_if_index,
 570                                      enable):
 571         """Create or delete unidirectional cross-connect from Tx interface to
 572         Rx interface.
 573
 574         :param int rx_sw_if_index: Software interface index of Rx interface.
 575         :param int tx_sw_if_index: Software interface index of Tx interface.
 576         :param int enable: Create cross-connect if equal to 1, delete
 577             cross-connect if equal to 0.
 578
 579         """
 580         return self.api(self.papi.sw_interface_set_l2_xconnect,
 581                         {'rx_sw_if_index': rx_sw_if_index,
 582                          'tx_sw_if_index': tx_sw_if_index,
 583                          'enable': enable})
 584
 585     def sw_interface_set_l2_tag_rewrite(
 586             self,
 587             sw_if_index,
 588             vtr_oper,
 589             push=0,
 590             tag1=0,
 591             tag2=0):
 592         """L2 interface vlan tag rewrite configure request
 593         :param client_index - opaque cookie to identify the sender
 594         :param context - sender context, to match reply w/ request
 595         :param sw_if_index - interface the operation is applied to
 596         :param vtr_op - Choose from l2_vtr_op_t enum values
 597         :param push_dot1q - first pushed flag dot1q id set, else dot1ad
 598         :param tag1 - Needed for any push or translate vtr op
 599         :param tag2 - Needed for any push 2 or translate x-2 vtr ops
 600
 601         """
 602         return self.api(self.papi.l2_interface_vlan_tag_rewrite,
 603                         {'sw_if_index': sw_if_index,
 604                          'vtr_op': vtr_oper,
 605                          'push_dot1q': push,
 606                          'tag1': tag1,
 607                          'tag2': tag2})
 608
 609     def sw_interface_set_l2_emulation(
 610             self,
 611             sw_if_index,
 612             enable=1):
 613         """L2 Emulation
 614         :param sw_if_index - interface the operation is applied to
 615
 616         """
 617         return self.api(self.papi.l2_emulation,
 618                         {'sw_if_index': sw_if_index,
 619                          'enable': enable})
 620
 621     def sw_interface_set_flags(self, sw_if_index, admin_up_down):
 622         """
 623
 624         :param admin_up_down:
 625         :param sw_if_index:
 626
 627         """
 628         return self.api(self.papi.sw_interface_set_flags,
 629                         {'sw_if_index': sw_if_index,
 630                          'admin_up_down': admin_up_down})
 631
 632     def sw_interface_set_mtu(self, sw_if_index, mtu):
 633         """
 634         :param sw_if_index:
 635         :param mtu:
 636
 637         """
 638         return self.api(self.papi.sw_interface_set_mtu,
 639                         {'sw_if_index': sw_if_index,
 640                          'mtu': mtu})
 641
 642     def create_subif(self, sw_if_index, sub_id, outer_vlan, inner_vlan,
 643                      no_tags=0, one_tag=0, two_tags=0, dot1ad=0, exact_match=0,
 644                      default_sub=0, outer_vlan_id_any=0, inner_vlan_id_any=0):
 645         """Create subinterface
 646         from vpe.api: set dot1ad = 0 for dot1q, set dot1ad = 1 for dot1ad
 647
 648         :param sub_id: param inner_vlan:
 649         :param sw_if_index:
 650         :param outer_vlan:
 651         :param inner_vlan:
 652         :param no_tags:  (Default value = 0)
 653         :param one_tag:  (Default value = 0)
 654         :param two_tags:  (Default value = 0)
 655         :param dot1ad:  (Default value = 0)
 656         :param exact_match:  (Default value = 0)
 657         :param default_sub:  (Default value = 0)
 658         :param outer_vlan_id_any:  (Default value = 0)
 659         :param inner_vlan_id_any:  (Default value = 0)
 660
 661         """
 662         return self.api(
 663             self.papi.create_subif,
 664             {'sw_if_index': sw_if_index,
 665              'sub_id': sub_id,
 666              'no_tags': no_tags,
 667              'one_tag': one_tag,
 668              'two_tags': two_tags,
 669              'dot1ad': dot1ad,
 670              'exact_match': exact_match,
 671              'default_sub': default_sub,
 672              'outer_vlan_id_any': outer_vlan_id_any,
 673              'inner_vlan_id_any': inner_vlan_id_any,
 674              'outer_vlan_id': outer_vlan,
 675              'inner_vlan_id': inner_vlan})
 676
 677     def create_p2pethernet_subif(self, sw_if_index, remote_mac, subif_id):
 678         """Create p2p ethernet subinterface
 679
 680         :param sw_if_index: main (parent) interface
 681         :param remote_mac: client (remote) mac address
 682
 683         """
 684         return self.api(
 685             self.papi.p2p_ethernet_add,
 686             {'parent_if_index': sw_if_index,
 687              'remote_mac': remote_mac,
 688              'subif_id': subif_id})
 689
 690     def delete_subif(self, sw_if_index):
 691         """Delete subinterface
 692
 693         :param sw_if_index:
 694         """
 695         return self.api(self.papi.delete_subif,
 696                         {'sw_if_index': sw_if_index})
 697
 698     def delete_p2pethernet_subif(self, sw_if_index, remote_mac):
 699         """Delete p2p ethernet subinterface
 700
 701         :param sw_if_index: main (parent) interface
 702         :param remote_mac: client (remote) mac address
 703
 704         """
 705         return self.api(
 706             self.papi.p2p_ethernet_del,
 707             {'parent_if_index': sw_if_index,
 708              'remote_mac': remote_mac})
 709
 710     def create_vlan_subif(self, sw_if_index, vlan):
 711         """
 712
 713         :param vlan:
 714         :param sw_if_index:
 715
 716         """
 717         return self.api(self.papi.create_vlan_subif,
 718                         {'sw_if_index': sw_if_index,
 719                          'vlan_id': vlan})
 720
 721     def create_loopback(self, mac=''):
 722         """
 723
 724         :param mac: (Optional)
 725         """
 726         return self.api(self.papi.create_loopback,
 727                         {'mac_address': mac})
 728
 729     def delete_loopback(self, sw_if_index):
 730         return self.api(self.papi.delete_loopback,
 731                         {'sw_if_index': sw_if_index, })
 732
 733     def ip_table_add_del(self,
 734                          table_id,
 735                          is_add=1,
 736                          is_ipv6=0):
 737         """
 738
 739         :param table_id
 740         :param is_add:  (Default value = 1)
 741         :param is_ipv6:  (Default value = 0)
 742
 743         """
 744
 745         return self.api(
 746             self.papi.ip_table_add_del,
 747             {'table_id': table_id,
 748              'is_add': is_add,
 749              'is_ipv6': is_ipv6})
 750
 751     def ip_add_del_route(
 752             self,
 753             dst_address,
 754             dst_address_length,
 755             next_hop_address,
 756             next_hop_sw_if_index=0xFFFFFFFF,
 757             table_id=0,
 758             next_hop_table_id=0,
 759             next_hop_weight=1,
 760             next_hop_n_out_labels=0,
 761             next_hop_out_label_stack=[],
 762             next_hop_via_label=MPLS_LABEL_INVALID,
 763             next_hop_id=0xFFFFFFFF,
 764             is_resolve_host=0,
 765             is_resolve_attached=0,
 766             classify_table_index=0xFFFFFFFF,
 767             is_add=1,
 768             is_drop=0,
 769             is_unreach=0,
 770             is_prohibit=0,
 771             is_ipv6=0,
 772             is_local=0,
 773             is_classify=0,
 774             is_multipath=0,
 775             is_dvr=0,
 776             is_udp_encap=0,
 777             is_source_lookup=0):
 778         """
 779
 780         :param dst_address_length:
 781         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
 782         :param dst_address:
 783         :param next_hop_address:
 784         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
 785         :param vrf_id:  (Default value = 0)
 786         :param lookup_in_vrf:  (Default value = 0)
 787         :param classify_table_index:  (Default value = 0xFFFFFFFF)
 788         :param is_add:  (Default value = 1)
 789         :param is_drop:  (Default value = 0)
 790         :param is_ipv6:  (Default value = 0)
 791         :param is_local:  (Default value = 0)
 792         :param is_classify:  (Default value = 0)
 793         :param is_multipath:  (Default value = 0)
 794         :param is_resolve_host:  (Default value = 0)
 795         :param is_resolve_attached:  (Default value = 0)
 796         :param is_dvr:  (Default value = 0)
 797         :param is_source_lookup:  (Default value = 0)
 798         :param next_hop_weight:  (Default value = 1)
 799
 800         """
 801
 802         return self.api(
 803             self.papi.ip_add_del_route,
 804             {'next_hop_sw_if_index': next_hop_sw_if_index,
 805              'table_id': table_id,
 806              'classify_table_index': classify_table_index,
 807              'next_hop_table_id': next_hop_table_id,
 808              'is_add': is_add,
 809              'is_drop': is_drop,
 810              'is_unreach': is_unreach,
 811              'is_prohibit': is_prohibit,
 812              'is_ipv6': is_ipv6,
 813              'is_local': is_local,
 814              'is_classify': is_classify,
 815              'is_multipath': is_multipath,
 816              'is_resolve_host': is_resolve_host,
 817              'is_resolve_attached': is_resolve_attached,
 818              'is_dvr': is_dvr,
 819              'is_source_lookup': is_source_lookup,
 820              'is_udp_encap': is_udp_encap,
 821              'next_hop_weight': next_hop_weight,
 822              'dst_address_length': dst_address_length,
 823              'dst_address': dst_address,
 824              'next_hop_id': next_hop_id,
 825              'next_hop_address': next_hop_address,
 826              'next_hop_n_out_labels': next_hop_n_out_labels,
 827              'next_hop_via_label': next_hop_via_label,
 828              'next_hop_out_label_stack': next_hop_out_label_stack})
 829
 830     def ip_fib_dump(self):
 831         return self.api(self.papi.ip_fib_dump, {})
 832
 833     def ip6_fib_dump(self):
 834         return self.api(self.papi.ip6_fib_dump, {})
 835
 836     def ip_neighbor_add_del(self,
 837                             sw_if_index,
 838                             mac_address,
 839                             dst_address,
 840                             is_add=1,
 841                             is_ipv6=0,
 842                             is_static=0,
 843                             is_no_adj_fib=0,
 844                             ):
 845         """ Add neighbor MAC to IPv4 or IPv6 address.
 846
 847         :param sw_if_index:
 848         :param mac_address:
 849         :param dst_address:
 850         :param is_add:  (Default value = 1)
 851         :param is_ipv6:  (Default value = 0)
 852         :param is_static:  (Default value = 0)
 853         :param is_no_adj_fib:  (Default value = 0)
 854         """
 855
 856         return self.api(
 857             self.papi.ip_neighbor_add_del,
 858             {'sw_if_index': sw_if_index,
 859              'is_add': is_add,
 860              'is_ipv6': is_ipv6,
 861              'is_static': is_static,
 862              'is_no_adj_fib': is_no_adj_fib,
 863              'mac_address': mac_address,
 864              'dst_address': dst_address
 865              }
 866         )
 867
 868     def ip_neighbor_dump(self,
 869                          sw_if_index,
 870                          is_ipv6=0):
 871         """ Return IP neighbor dump.
 872
 873         :param sw_if_index:
 874         :param int is_ipv6: 1 for IPv6 neighbor, 0 for IPv4. (Default = 0)
 875         """
 876
 877         return self.api(
 878             self.papi.ip_neighbor_dump,
 879             {'is_ipv6': is_ipv6,
 880              'sw_if_index': sw_if_index
 881              }
 882         )
 883
 884     def proxy_arp_add_del(self,
 885                           low_address,
 886                           hi_address,
 887                           vrf_id=0,
 888                           is_add=1):
 889         """ Config Proxy Arp Range.
 890
 891         :param low_address: Start address in the rnage to Proxy for
 892         :param hi_address: End address in the rnage to Proxy for
 893         :param vrf_id: The VRF/table in which to proxy
 894         """
 895
 896         return self.api(
 897             self.papi.proxy_arp_add_del,
 898             {'vrf_id': vrf_id,
 899              'is_add': is_add,
 900              'low_address': low_address,
 901              'hi_address': hi_address,
 902              }
 903         )
 904
 905     def proxy_arp_intfc_enable_disable(self,
 906                                        sw_if_index,
 907                                        is_enable=1):
 908         """ Enable/Disable an interface for proxy ARP requests
 909
 910         :param sw_if_index: Interface
 911         :param enable_disable: Enable/Disable
 912         """
 913
 914         return self.api(
 915             self.papi.proxy_arp_intfc_enable_disable,
 916             {'sw_if_index': sw_if_index,
 917              'enable_disable': is_enable
 918              }
 919         )
 920
 921     def reset_vrf(self,
 922                   vrf_id,
 923                   is_ipv6=0,
 924                   ):
 925         """ Reset VRF (remove all routes etc.) request.
 926
 927         :param int vrf_id: ID of the FIB table / VRF to reset.
 928         :param int is_ipv6: 1 for IPv6 neighbor, 0 for IPv4. (Default = 0)
 929         """
 930
 931         return self.api(
 932             self.papi.reset_vrf,
 933             {'vrf_id': vrf_id,
 934              'is_ipv6': is_ipv6,
 935              }
 936         )
 937
 938     def reset_fib(self,
 939                   vrf_id,
 940                   is_ipv6=0,
 941                   ):
 942         """ Reset VRF (remove all routes etc.) request.
 943
 944         :param int vrf_id: ID of the FIB table / VRF to reset.
 945         :param int is_ipv6: 1 for IPv6 neighbor, 0 for IPv4. (Default = 0)
 946         """
 947
 948         return self.api(
 949             self.papi.reset_fib,
 950             {'vrf_id': vrf_id,
 951              'is_ipv6': is_ipv6,
 952              }
 953         )
 954
 955     def ip_dump(self,
 956                 is_ipv6=0,
 957                 ):
 958         """ Return IP dump.
 959
 960         :param int is_ipv6: 1 for IPv6 neighbor, 0 for IPv4. (Default = 0)
 961         """
 962
 963         return self.api(
 964             self.papi.ip_dump,
 965             {'is_ipv6': is_ipv6,
 966              }
 967         )
 968
 969     def sw_interface_span_enable_disable(
 970             self, sw_if_index_from, sw_if_index_to, state=1, is_l2=0):
 971         """
 972
 973         :param sw_if_index_from:
 974         :param sw_if_index_to:
 975         :param state:
 976         :param is_l2:
 977         """
 978         return self.api(self.papi.sw_interface_span_enable_disable,
 979                         {'sw_if_index_from': sw_if_index_from,
 980                          'sw_if_index_to': sw_if_index_to,
 981                          'state': state,
 982                          'is_l2': is_l2,
 983                          })
 984
 985     def gre_tunnel_add_del(self,
 986                            src_address,
 987                            dst_address,
 988                            outer_fib_id=0,
 989                            tunnel_type=0,
 990                            instance=0xFFFFFFFF,
 991                            session_id=0,
 992                            is_add=1,
 993                            is_ip6=0):
 994         """ Add a GRE tunnel
 995
 996         :param src_address:
 997         :param dst_address:
 998         :param outer_fib_id:  (Default value = 0)
 999         :param tunnel_type:  (Default value = 0)
1000         :param instance:  (Default value = 0xFFFFFFFF)
1001         :param session_id: (Defalt value = 0)
1002         :param is_add:  (Default value = 1)
1003         :param is_ipv6:  (Default value = 0)
1004         """
1005
1006         return self.api(
1007             self.papi.gre_add_del_tunnel,
1008             {'is_add': is_add,
1009              'is_ipv6': is_ip6,
1010              'tunnel_type': tunnel_type,
1011              'instance': instance,
1012              'src_address': src_address,
1013              'dst_address': dst_address,
1014              'outer_fib_id': outer_fib_id,
1015              'session_id': session_id}
1016         )
1017
1018     def udp_encap_add_del(self,
1019                           id,
1020                           src_ip,
1021                           dst_ip,
1022                           src_port,
1023                           dst_port,
1024                           table_id=0,
1025                           is_add=1,
1026                           is_ip6=0):
1027         """ Add a GRE tunnel
1028         :param id: user provided ID
1029         :param src_ip:
1030         :param dst_ip:
1031         :param src_port:
1032         :param dst_port:
1033         :param outer_fib_id:  (Default value = 0)
1034         :param is_add:  (Default value = 1)
1035         :param is_ipv6:  (Default value = 0)
1036         """
1037
1038         return self.api(
1039             self.papi.udp_encap_add_del,
1040             {'id': id,
1041              'is_add': is_add,
1042              'is_ip6': is_ip6,
1043              'src_ip': src_ip,
1044              'dst_ip': dst_ip,
1045              'src_port': src_port,
1046              'dst_port': dst_port,
1047              'table_id': table_id}
1048         )
1049
1050     def udp_encap_dump(self):
1051         return self.api(self.papi.udp_encap_dump, {})
1052
1053     def mpls_fib_dump(self):
1054         return self.api(self.papi.mpls_fib_dump, {})
1055
1056     def mpls_table_add_del(
1057             self,
1058             table_id,
1059             is_add=1):
1060         """
1061
1062         :param table_id
1063         :param is_add:  (Default value = 1)
1064
1065         """
1066
1067         return self.api(
1068             self.papi.mpls_table_add_del,
1069             {'mt_table_id': table_id,
1070              'mt_is_add': is_add})
1071
1072     def mpls_route_add_del(
1073             self,
1074             label,
1075             eos,
1076             next_hop_proto,
1077             next_hop_address,
1078             next_hop_sw_if_index=0xFFFFFFFF,
1079             table_id=0,
1080             next_hop_table_id=0,
1081             next_hop_weight=1,
1082             next_hop_n_out_labels=0,
1083             next_hop_out_label_stack=[],
1084             next_hop_via_label=MPLS_LABEL_INVALID,
1085             is_resolve_host=0,
1086             is_resolve_attached=0,
1087             is_interface_rx=0,
1088             is_rpf_id=0,
1089             is_multicast=0,
1090             is_add=1,
1091             is_drop=0,
1092             is_multipath=0,
1093             classify_table_index=0xFFFFFFFF,
1094             is_classify=0):
1095         """
1096
1097         :param dst_address_length:
1098         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
1099         :param dst_address:
1100         :param next_hop_address:
1101         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
1102         :param vrf_id:  (Default value = 0)
1103         :param lookup_in_vrf:  (Default value = 0)
1104         :param classify_table_index:  (Default value = 0xFFFFFFFF)
1105         :param is_add:  (Default value = 1)
1106         :param is_drop:  (Default value = 0)
1107         :param is_ipv6:  (Default value = 0)
1108         :param is_local:  (Default value = 0)
1109         :param is_classify:  (Default value = 0)
1110         :param is_multipath:  (Default value = 0)
1111         :param is_multicast:  (Default value = 0)
1112         :param is_resolve_host:  (Default value = 0)
1113         :param is_resolve_attached:  (Default value = 0)
1114         :param next_hop_weight:  (Default value = 1)
1115
1116         """
1117
1118         return self.api(
1119             self.papi.mpls_route_add_del,
1120             {'mr_label': label,
1121              'mr_eos': eos,
1122              'mr_table_id': table_id,
1123              'mr_classify_table_index': classify_table_index,
1124              'mr_is_add': is_add,
1125              'mr_is_classify': is_classify,
1126              'mr_is_multipath': is_multipath,
1127              'mr_is_multicast': is_multicast,
1128              'mr_is_resolve_host': is_resolve_host,
1129              'mr_is_resolve_attached': is_resolve_attached,
1130              'mr_is_interface_rx': is_interface_rx,
1131              'mr_is_rpf_id': is_rpf_id,
1132              'mr_next_hop_proto': next_hop_proto,
1133              'mr_next_hop_weight': next_hop_weight,
1134              'mr_next_hop': next_hop_address,
1135              'mr_next_hop_n_out_labels': next_hop_n_out_labels,
1136              'mr_next_hop_sw_if_index': next_hop_sw_if_index,
1137              'mr_next_hop_table_id': next_hop_table_id,
1138              'mr_next_hop_via_label': next_hop_via_label,
1139              'mr_next_hop_out_label_stack': next_hop_out_label_stack})
1140
1141     def mpls_ip_bind_unbind(
1142             self,
1143             label,
1144             dst_address,
1145             dst_address_length,
1146             table_id=0,
1147             ip_table_id=0,
1148             is_ip4=1,
1149             is_bind=1):
1150         """
1151         """
1152         return self.api(
1153             self.papi.mpls_ip_bind_unbind,
1154             {'mb_mpls_table_id': table_id,
1155              'mb_label': label,
1156              'mb_ip_table_id': ip_table_id,
1157              'mb_is_bind': is_bind,
1158              'mb_is_ip4': is_ip4,
1159              'mb_address_length': dst_address_length,
1160              'mb_address': dst_address})
1161
1162     def mpls_tunnel_add_del(
1163             self,
1164             tun_sw_if_index,
1165             next_hop_proto_is_ip4,
1166             next_hop_address,
1167             next_hop_sw_if_index=0xFFFFFFFF,
1168             next_hop_table_id=0,
1169             next_hop_weight=1,
1170             next_hop_n_out_labels=0,
1171             next_hop_out_label_stack=[],
1172             next_hop_via_label=MPLS_LABEL_INVALID,
1173             is_add=1,
1174             l2_only=0,
1175             is_multicast=0):
1176         """
1177
1178         :param dst_address_length:
1179         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
1180         :param dst_address:
1181         :param next_hop_address:
1182         :param next_hop_sw_if_index:  (Default value = 0xFFFFFFFF)
1183         :param vrf_id:  (Default value = 0)
1184         :param lookup_in_vrf:  (Default value = 0)
1185         :param classify_table_index:  (Default value = 0xFFFFFFFF)
1186         :param is_add:  (Default value = 1)
1187         :param is_drop:  (Default value = 0)
1188         :param is_ipv6:  (Default value = 0)
1189         :param is_local:  (Default value = 0)
1190         :param is_classify:  (Default value = 0)
1191         :param is_multipath:  (Default value = 0)
1192         :param is_resolve_host:  (Default value = 0)
1193         :param is_resolve_attached:  (Default value = 0)
1194         :param next_hop_weight:  (Default value = 1)
1195         :param is_multicast:  (Default value = 0)
1196
1197         """
1198         return self.api(
1199             self.papi.mpls_tunnel_add_del,
1200             {'mt_sw_if_index': tun_sw_if_index,
1201              'mt_is_add': is_add,
1202              'mt_l2_only': l2_only,
1203              'mt_is_multicast': is_multicast,
1204              'mt_next_hop_proto_is_ip4': next_hop_proto_is_ip4,
1205              'mt_next_hop_weight': next_hop_weight,
1206              'mt_next_hop': next_hop_address,
1207              'mt_next_hop_n_out_labels': next_hop_n_out_labels,
1208              'mt_next_hop_sw_if_index': next_hop_sw_if_index,
1209              'mt_next_hop_table_id': next_hop_table_id,
1210              'mt_next_hop_out_label_stack': next_hop_out_label_stack})
1211
1212     def nat44_interface_add_del_feature(
1213             self,
1214             sw_if_index,
1215             is_inside=1,
1216             is_add=1):
1217         """Enable/disable NAT44 feature on the interface
1218
1219         :param sw_if_index: Software index of the interface
1220         :param is_inside: 1 if inside, 0 if outside (Default value = 1)
1221         :param is_add: 1 if add, 0 if delete (Default value = 1)
1222         """
1223         return self.api(
1224             self.papi.nat44_interface_add_del_feature,
1225             {'is_add': is_add,
1226              'is_inside': is_inside,
1227              'sw_if_index': sw_if_index})
1228
1229     def nat44_interface_add_del_output_feature(
1230             self,
1231             sw_if_index,
1232             is_inside=1,
1233             is_add=1):
1234         """Enable/disable NAT44 output feature on the interface
1235
1236         :param sw_if_index: Software index of the interface
1237         :param is_inside: 1 if inside, 0 if outside (Default value = 1)
1238         :param is_add: 1 if add, 0 if delete (Default value = 1)
1239         """
1240         return self.api(
1241             self.papi.nat44_interface_add_del_output_feature,
1242             {'is_add': is_add,
1243              'is_inside': is_inside,
1244              'sw_if_index': sw_if_index})
1245
1246     def nat44_add_del_static_mapping(
1247             self,
1248             local_ip,
1249             external_ip=0,
1250             external_sw_if_index=0xFFFFFFFF,
1251             local_port=0,
1252             external_port=0,
1253             addr_only=1,
1254             vrf_id=0,
1255             protocol=0,
1256             twice_nat=0,
1257             out2in_only=0,
1258             tag="",
1259             is_add=1):
1260         """Add/delete NAT44 static mapping
1261
1262         :param local_ip: Local IP address
1263         :param external_ip: External IP address
1264         :param external_sw_if_index: External interface instead of IP address
1265         :param local_port: Local port number (Default value = 0)
1266         :param external_port: External port number (Default value = 0)
1267         :param addr_only: 1 if address only mapping, 0 if address and port
1268         :param vrf_id: VRF ID
1269         :param protocol: IP protocol (Default value = 0)
1270         :param twice_nat: 1 if translate external host address and port
1271         :param out2in_only: if 1 rule is matching only out2in direction
1272         :param tag: Opaque string tag
1273         :param is_add: 1 if add, 0 if delete (Default value = 1)
1274         """
1275         return self.api(
1276             self.papi.nat44_add_del_static_mapping,
1277             {'is_add': is_add,
1278              'addr_only': addr_only,
1279              'local_ip_address': local_ip,
1280              'external_ip_address': external_ip,
1281              'local_port': local_port,
1282              'external_port': external_port,
1283              'external_sw_if_index': external_sw_if_index,
1284              'vrf_id': vrf_id,
1285              'protocol': protocol,
1286              'twice_nat': twice_nat,
1287              'out2in_only': out2in_only,
1288              'tag': tag})
1289
1290     def nat44_add_del_identity_mapping(
1291             self,
1292             ip='0',
1293             sw_if_index=0xFFFFFFFF,
1294             port=0,
1295             addr_only=1,
1296             vrf_id=0,
1297             protocol=0,
1298             tag='',
1299             is_add=1):
1300         """Add/delete NAT44 identity mapping
1301
1302         :param ip: IP address (Default value = 0)
1303         :param sw_if_index: Interface instead of IP address
1304         :param port: Port number (Default value = 0)
1305         :param addr_only: 1 if address only mapping, 0 if address and port
1306         :param vrf_id: VRF ID
1307         :param protocol: IP protocol (Default value = 0)
1308         :param tag: Opaque string tag
1309         :param is_add: 1 if add, 0 if delete (Default value = 1)
1310         """
1311         return self.api(
1312             self.papi.nat44_add_del_identity_mapping,
1313             {'is_add': is_add,
1314              'addr_only': addr_only,
1315              'ip_address': ip,
1316              'port': port,
1317              'sw_if_index': sw_if_index,
1318              'vrf_id': vrf_id,
1319              'tag': tag,
1320              'protocol': protocol})
1321
1322     def nat44_add_del_address_range(
1323             self,
1324             first_ip_address,
1325             last_ip_address,
1326             is_add=1,
1327             vrf_id=0xFFFFFFFF,
1328             twice_nat=0):
1329         """Add/del NAT44 address range
1330
1331         :param first_ip_address: First IP address
1332         :param last_ip_address: Last IP address
1333         :param vrf_id: VRF id for the address range
1334         :param twice_nat: twice NAT address for extenal hosts
1335         :param is_add: 1 if add, 0 if delete (Default value = 1)
1336         """
1337         return self.api(
1338             self.papi.nat44_add_del_address_range,
1339             {'first_ip_address': first_ip_address,
1340              'last_ip_address': last_ip_address,
1341              'vrf_id': vrf_id,
1342              'twice_nat': twice_nat,
1343              'is_add': is_add})
1344
1345     def nat44_address_dump(self):
1346         """Dump NAT44 addresses
1347         :return: Dictionary of NAT44 addresses
1348         """
1349         return self.api(self.papi.nat44_address_dump, {})
1350
1351     def nat44_interface_dump(self):
1352         """Dump interfaces with NAT44 feature
1353         :return: Dictionary of interfaces with NAT44 feature
1354         """
1355         return self.api(self.papi.nat44_interface_dump, {})
1356
1357     def nat44_interface_output_feature_dump(self):
1358         """Dump interfaces with NAT44 output feature
1359         :return: Dictionary of interfaces with NAT44 output feature
1360         """
1361         return self.api(self.papi.nat44_interface_output_feature_dump, {})
1362
1363     def nat44_static_mapping_dump(self):
1364         """Dump NAT44 static mappings
1365         :return: Dictionary of NAT44 static mappings
1366         """
1367         return self.api(self.papi.nat44_static_mapping_dump, {})
1368
1369     def nat44_identity_mapping_dump(self):
1370         """Dump NAT44 identity mappings
1371         :return: Dictionary of NAT44 identity mappings
1372         """
1373         return self.api(self.papi.nat44_identity_mapping_dump, {})
1374
1375     def nat_show_config(self):
1376         """Show NAT plugin config
1377         :return: NAT plugin config parameters
1378         """
1379         return self.api(self.papi.nat_show_config, {})
1380
1381     def nat44_add_interface_addr(
1382             self,
1383             sw_if_index,
1384             twice_nat=0,
1385             is_add=1):
1386         """Add/del NAT44 address from interface
1387
1388         :param sw_if_index: Software index of the interface
1389         :param twice_nat: twice NAT address for extenal hosts
1390         :param is_add: 1 if add, 0 if delete (Default value = 1)
1391         """
1392         return self.api(
1393             self.papi.nat44_add_del_interface_addr,
1394             {'is_add': is_add,
1395              'sw_if_index': sw_if_index,
1396              'twice_nat': twice_nat})
1397
1398     def nat44_interface_addr_dump(self):
1399         """Dump NAT44 addresses interfaces
1400         :return: Dictionary of NAT44 addresses interfaces
1401         """
1402         return self.api(self.papi.nat44_interface_addr_dump, {})
1403
1404     def nat_ipfix(
1405             self,
1406             domain_id=1,
1407             src_port=4739,
1408             enable=1):
1409         """Enable/disable NAT IPFIX logging
1410
1411         :param domain_id: Observation domain ID (Default value = 1)
1412         :param src_port: Source port number (Default value = 4739)
1413         :param enable: 1 if enable, 0 if disable (Default value = 1)
1414         """
1415         return self.api(
1416             self.papi.nat_ipfix_enable_disable,
1417             {'domain_id': domain_id,
1418              'src_port': src_port,
1419              'enable': enable})
1420
1421     def nat44_user_session_dump(
1422             self,
1423             ip_address,
1424             vrf_id):
1425         """Dump NAT44 user's sessions
1426
1427         :param ip_address: ip adress of the user to be dumped
1428         :param cpu_index: cpu_index on which the user is
1429         :param vrf_id: VRF ID
1430         :return: Dictionary of S-NAT sessions
1431         """
1432         return self.api(
1433             self.papi.nat44_user_session_dump,
1434             {'ip_address': ip_address,
1435              'vrf_id': vrf_id})
1436
1437     def nat44_user_dump(self):
1438         """Dump NAT44 users
1439
1440         :return: Dictionary of NAT44 users
1441         """
1442         return self.api(self.papi.nat44_user_dump, {})
1443
1444     def nat44_add_del_lb_static_mapping(
1445             self,
1446             external_addr,
1447             external_port,
1448             protocol,
1449             vrf_id=0,
1450             twice_nat=0,
1451             out2in_only=0,
1452             tag='',
1453             local_num=0,
1454             locals=[],
1455             is_add=1):
1456         """Add/delete NAT44 load balancing static mapping
1457
1458         :param twice_nat: 1 if translate external host address and port
1459         :param tag: Opaque string tag
1460         :param is_add - 1 if add, 0 if delete
1461         """
1462         return self.api(
1463             self.papi.nat44_add_del_lb_static_mapping,
1464             {'is_add': is_add,
1465              'external_addr': external_addr,
1466              'external_port': external_port,
1467              'protocol': protocol,
1468              'vrf_id': vrf_id,
1469              'twice_nat': twice_nat,
1470              'out2in_only': out2in_only,
1471              'tag': tag,
1472              'local_num': local_num,
1473              'locals': locals})
1474
1475     def nat44_lb_static_mapping_dump(self):
1476         """Dump NAT44 load balancing static mappings
1477
1478         :return: Dictionary of NAT44 load balancing static mapping
1479         """
1480         return self.api(self.papi.nat44_lb_static_mapping_dump, {})
1481
1482     def nat44_del_session(
1483             self,
1484             addr,
1485             port,
1486             protocol,
1487             vrf_id=0,
1488             is_in=1):
1489         """Delete NAT44 session
1490
1491         :param addr: IPv4 address
1492         :param por: port number
1493         :param protocol: IP protocol number
1494         :param vrf_id: VRF ID
1495         :param is_in: 1 if inside network addres and port pari, 0 if outside
1496         """
1497         return self.api(
1498             self.papi.nat44_del_session,
1499             {'address': addr,
1500              'port': port,
1501              'protocol': protocol,
1502              'vrf_id': vrf_id,
1503              'is_in': is_in})
1504
1505     def nat44_forwarding_enable_disable(
1506             self,
1507             enable):
1508         """Enable/disable forwarding for NAT44
1509
1510         :param enable: 1 for enable, 0 for disable
1511         """
1512         return self.api(
1513             self.papi.nat44_forwarding_enable_disable,
1514             {'enable': enable})
1515
1516     def nat_set_reass(
1517             self,
1518             timeout=2,
1519             max_reass=1024,
1520             max_frag=5,
1521             drop_frag=0,
1522             is_ip6=0):
1523         """Set NAT virtual fragmentation reassembly
1524
1525         :param timeout: reassembly timeout (Default 2sec)
1526         :param max_reass: maximum concurrent reassemblies (Default 1024)
1527         :param max_frag: maximum fragmets per reassembly (Default 5)
1528         :param drop_frag: if 0 translate fragments, otherwise drop fragments
1529         :param is_ip6: 1 if IPv6, 0 if IPv4
1530         """
1531         return self.api(
1532             self.papi.nat_set_reass,
1533             {'timeout': timeout,
1534              'max_reass': max_reass,
1535              'max_frag': max_frag,
1536              'drop_frag': drop_frag,
1537              'is_ip6': is_ip6})
1538
1539     def nat_get_reass(self):
1540         """Get NAT virtual fragmentation reassembly configuration
1541
1542         :return: NAT virtual fragmentation reassembly configuration
1543         """
1544         return self.api(self.papi.nat_get_reass, {})
1545
1546     def nat_reass_dump(self):
1547         """Dump NAT virtual fragmentation reassemblies
1548
1549         :return: Dictionary of NAT virtual fragmentation reassemblies
1550         """
1551         return self.api(self.papi.nat_reass_dump, {})
1552
1553     def nat_det_add_del_map(
1554             self,
1555             in_addr,
1556             in_plen,
1557             out_addr,
1558             out_plen,
1559             is_add=1):
1560         """Add/delete deterministic NAT mapping
1561
1562         :param is_add - 1 if add, 0 if delete
1563         :param in_addr - inside IP address
1564         :param in_plen - inside IP address prefix length
1565         :param out_addr - outside IP address
1566         :param out_plen - outside IP address prefix length
1567         """
1568         return self.api(
1569             self.papi.nat_det_add_del_map,
1570             {'is_add': is_add,
1571              'is_nat44': 1,
1572              'in_addr': in_addr,
1573              'in_plen': in_plen,
1574              'out_addr': out_addr,
1575              'out_plen': out_plen})
1576
1577     def nat_det_forward(
1578             self,
1579             in_addr):
1580         """Get outside address and port range from inside address
1581
1582         :param in_addr - inside IP address
1583         """
1584         return self.api(
1585             self.papi.nat_det_forward,
1586             {'in_addr': in_addr,
1587              'is_nat44': 1})
1588
1589     def nat_det_reverse(
1590             self,
1591             out_addr,
1592             out_port):
1593         """Get inside address from outside address and port
1594
1595         :param out_addr - outside IP address
1596         :param out_port - outside port
1597         """
1598         return self.api(
1599             self.papi.nat_det_reverse,
1600             {'out_addr': out_addr,
1601              'out_port': out_port})
1602
1603     def nat_det_map_dump(self):
1604         """Dump deterministic NAT mappings
1605
1606         :return: Dictionary of deterministic NAT mappings
1607         """
1608         return self.api(self.papi.nat_det_map_dump, {})
1609
1610     def nat_det_set_timeouts(
1611             self,
1612             udp=300,
1613             tcp_established=7440,
1614             tcp_transitory=240,
1615             icmp=60):
1616         """Set values of timeouts for deterministic NAT (in seconds)
1617
1618         :param udp - UDP timeout (Default value = 300)
1619         :param tcp_established - TCP established timeout (Default value = 7440)
1620         :param tcp_transitory - TCP transitory timeout (Default value = 240)
1621         :param icmp - ICMP timeout (Default value = 60)
1622         """
1623         return self.api(
1624             self.papi.nat_det_set_timeouts,
1625             {'udp': udp,
1626              'tcp_established': tcp_established,
1627              'tcp_transitory': tcp_transitory,
1628              'icmp': icmp})
1629
1630     def nat_det_get_timeouts(self):
1631         """Get values of timeouts for deterministic NAT
1632
1633         :return: Timeouts for deterministic NAT (in seconds)
1634         """
1635         return self.api(self.papi.nat_det_get_timeouts, {})
1636
1637     def nat_det_close_session_out(
1638             self,
1639             out_addr,
1640             out_port,
1641             ext_addr,
1642             ext_port):
1643         """Close deterministic NAT session using outside address and port
1644
1645         :param out_addr - outside IP address
1646         :param out_port - outside port
1647         :param ext_addr - external host IP address
1648         :param ext_port - external host port
1649         """
1650         return self.api(
1651             self.papi.nat_det_close_session_out,
1652             {'out_addr': out_addr,
1653              'out_port': out_port,
1654              'ext_addr': ext_addr,
1655              'ext_port': ext_port})
1656
1657     def nat_det_close_session_in(
1658             self,
1659             in_addr,
1660             in_port,
1661             ext_addr,
1662             ext_port):
1663         """Close deterministic NAT session using inside address and port
1664
1665         :param in_addr - inside IP address
1666         :param in_port - inside port
1667         :param ext_addr - external host IP address
1668         :param ext_port - external host port
1669         """
1670         return self.api(
1671             self.papi.nat_det_close_session_in,
1672             {'in_addr': in_addr,
1673              'in_port': in_port,
1674              'ext_addr': ext_addr,
1675              'ext_port': ext_port,
1676              'is_nat44': 1})
1677
1678     def nat_det_session_dump(
1679             self,
1680             user_addr):
1681         """Dump deterministic NAT sessions belonging to a user
1682
1683         :param user_addr - inside IP address of the user
1684         :return: Dictionary of deterministic NAT sessions
1685         """
1686         return self.api(
1687             self.papi.nat_det_session_dump,
1688             {'is_nat44': 1,
1689              'user_addr': user_addr})
1690
1691     def nat64_add_del_pool_addr_range(
1692             self,
1693             start_addr,
1694             end_addr,
1695             vrf_id=0xFFFFFFFF,
1696             is_add=1):
1697         """Add/del address range to NAT64 pool
1698
1699         :param start_addr: First IP address
1700         :param end_addr: Last IP address
1701         :param vrf_id: VRF id for the address range
1702         :param is_add: 1 if add, 0 if delete (Default value = 1)
1703         """
1704         return self.api(
1705             self.papi.nat64_add_del_pool_addr_range,
1706             {'start_addr': start_addr,
1707              'end_addr': end_addr,
1708              'vrf_id': vrf_id,
1709              'is_add': is_add})
1710
1711     def nat64_pool_addr_dump(self):
1712         """Dump NAT64 pool addresses
1713         :return: Dictionary of NAT64 pool addresses
1714         """
1715         return self.api(self.papi.nat64_pool_addr_dump, {})
1716
1717     def nat64_add_del_interface(
1718             self,
1719             sw_if_index,
1720             is_inside=1,
1721             is_add=1):
1722         """Enable/disable NAT64 feature on the interface
1723            :param sw_if_index: Index of the interface
1724            :param is_inside: 1 if inside, 0 if outside (Default value = 1)
1725            :param is_add: 1 if add, 0 if delete (Default value = 1)
1726         """
1727         return self.api(
1728             self.papi.nat64_add_del_interface,
1729             {'sw_if_index': sw_if_index,
1730              'is_inside': is_inside,
1731              'is_add': is_add})
1732
1733     def nat64_interface_dump(self):
1734         """Dump interfaces with NAT64 feature
1735         :return: Dictionary of interfaces with NAT64 feature
1736         """
1737         return self.api(self.papi.nat64_interface_dump, {})
1738
1739     def nat64_add_del_static_bib(
1740             self,
1741             in_ip,
1742             out_ip,
1743             in_port,
1744             out_port,
1745             protocol,
1746             vrf_id=0,
1747             is_add=1):
1748         """Add/delete S-NAT static BIB entry
1749
1750         :param in_ip: Inside IPv6 address
1751         :param out_ip: Outside IPv4 address
1752         :param in_port: Inside port number
1753         :param out_port: Outside port number
1754         :param protocol: IP protocol
1755         :param vrf_id: VRF ID (Default value = 0)
1756         :param is_add: 1 if add, 0 if delete (Default value = 1)
1757         """
1758         return self.api(
1759             self.papi.nat64_add_del_static_bib,
1760             {'i_addr': in_ip,
1761              'o_addr': out_ip,
1762              'i_port': in_port,
1763              'o_port': out_port,
1764              'vrf_id': vrf_id,
1765              'proto': protocol,
1766              'is_add': is_add})
1767
1768     def nat64_bib_dump(self, protocol=255):
1769         """Dump NAT64 BIB
1770
1771         :param protocol: IP protocol (Default value = 255, all BIBs)
1772         :returns: Dictionary of NAT64 BIB entries
1773         """
1774         return self.api(self.papi.nat64_bib_dump, {'proto': protocol})
1775
1776     def nat64_set_timeouts(self, udp=300, icmp=60, tcp_trans=240, tcp_est=7440,
1777                            tcp_incoming_syn=6):
1778         """Set values of timeouts for NAT64 (in seconds)
1779
1780         :param udpi: UDP timeout (Default value = 300)
1781         :param icmp: ICMP timeout (Default value = 60)
1782         :param tcp_trans: TCP transitory timeout (Default value = 240)
1783         :param tcp_est: TCP established timeout (Default value = 7440)
1784         :param tcp_incoming_syn: TCP incoming SYN timeout (Default value = 6)
1785         """
1786         return self.api(
1787             self.papi.nat64_set_timeouts,
1788             {'udp': udp,
1789              'icmp': icmp,
1790              'tcp_trans': tcp_trans,
1791              'tcp_est': tcp_est,
1792              'tcp_incoming_syn': tcp_incoming_syn})
1793
1794     def nat64_get_timeouts(self):
1795         """Get values of timeouts for NAT64
1796
1797         :return: Timeouts for NAT64 (in seconds)
1798         """
1799         return self.api(self.papi.nat64_get_timeouts, {})
1800
1801     def nat64_st_dump(self, protocol=255):
1802         """Dump NAT64 session table
1803
1804         :param protocol: IP protocol (Default value = 255, all STs)
1805         :returns: Dictionary of NAT64 sesstion table entries
1806         """
1807         return self.api(self.papi.nat64_st_dump, {'proto': protocol})
1808
1809     def nat64_add_del_prefix(self, prefix, plen, vrf_id=0, is_add=1):
1810         """Add/del NAT64 prefix
1811
1812         :param prefix: NAT64 prefix
1813         :param plen: NAT64 prefix length
1814         :param vrf_id: VRF id of tenant (Default 0)
1815         :param is_add: 1 if add, 0 if delete (Default value = 1)
1816         """
1817         return self.api(
1818             self.papi.nat64_add_del_prefix,
1819             {'prefix': prefix,
1820              'prefix_len': plen,
1821              'vrf_id': vrf_id,
1822              'is_add': is_add})
1823
1824     def nat64_prefix_dump(self):
1825         """Dump NAT64 prefix
1826
1827         :returns: Dictionary of NAT64 prefixes
1828         """
1829         return self.api(self.papi.nat64_prefix_dump, {})
1830
1831     def nat64_add_interface_addr(
1832             self,
1833             sw_if_index,
1834             is_add=1):
1835         """Add/del NAT64 address from interface
1836
1837         :param sw_if_index: Software index of the interface
1838         :param is_add: 1 if add, 0 if delete (Default value = 1)
1839         """
1840         return self.api(self.papi.nat64_add_del_interface_addr,
1841                         {'is_add': is_add, 'sw_if_index': sw_if_index})
1842
1843     def dslite_set_aftr_addr(self, ip6, ip4):
1844         """Set DS-Lite AFTR addresses
1845
1846         :param ip4: IPv4 address
1847         :param ip6: IPv6 address
1848         """
1849         return self.api(
1850             self.papi.dslite_set_aftr_addr,
1851             {'ip4_addr': ip4,
1852              'ip6_addr': ip6})
1853
1854     def dslite_set_b4_addr(self, ip6, ip4):
1855         """Set DS-Lite B4 IPv6 address
1856
1857         :param ip4: IPv4 address
1858         :param ip6: IPv6 address
1859         """
1860         return self.api(
1861             self.papi.dslite_set_b4_addr,
1862             {'ip4_addr': ip4,
1863              'ip6_addr': ip6})
1864
1865     def dslite_add_del_pool_addr_range(
1866             self,
1867             start_addr,
1868             end_addr,
1869             is_add=1):
1870         """Add/del address range to DS-Lite pool
1871
1872         :param start_addr: First IP address
1873         :param end_addr: Last IP address
1874         :param is_add: 1 if add, 0 if delete (Default value = 1)
1875         """
1876         return self.api(
1877             self.papi.dslite_add_del_pool_addr_range,
1878             {'start_addr': start_addr,
1879              'end_addr': end_addr,
1880              'is_add': is_add})
1881
1882     def nat66_add_del_interface(
1883             self,
1884             sw_if_index,
1885             is_inside=1,
1886             is_add=1):
1887         """Enable/disable NAT66 feature on the interface
1888            :param sw_if_index: Index of the interface
1889            :param is_inside: 1 if inside, 0 if outside (Default value = 1)
1890            :param is_add: 1 if add, 0 if delete (Default value = 1)
1891         """
1892         return self.api(
1893             self.papi.nat66_add_del_interface,
1894             {'sw_if_index': sw_if_index,
1895              'is_inside': is_inside,
1896              'is_add': is_add})
1897
1898     def nat66_add_del_static_mapping(
1899             self,
1900             in_ip,
1901             out_ip,
1902             vrf_id=0,
1903             is_add=1):
1904         """Add/delete NAT66 static mapping
1905
1906         :param in_ip: Inside IPv6 address
1907         :param out_ip: Outside IPv6 address
1908         :param vrf_id: VRF ID (Default value = 0)
1909         :param is_add: 1 if add, 0 if delete (Default value = 1)
1910         """
1911         return self.api(
1912             self.papi.nat66_add_del_static_mapping,
1913             {'local_ip_address': in_ip,
1914              'external_ip_address': out_ip,
1915              'vrf_id': vrf_id,
1916              'is_add': is_add})
1917
1918     def nat66_interface_dump(self):
1919         """Dump interfaces with NAT66 feature
1920         :return: Dictionary of interfaces with NAT66 feature
1921         """
1922         return self.api(self.papi.nat66_interface_dump, {})
1923
1924     def nat66_static_mapping_dump(self):
1925         """Dump NAT66 static mappings
1926         :return: Dictionary of NAT66 static mappings
1927         """
1928         return self.api(self.papi.nat66_static_mapping_dump, {})
1929
1930     def control_ping(self):
1931         self.api(self.papi.control_ping)
1932
1933     def bfd_udp_add(self, sw_if_index, desired_min_tx, required_min_rx,
1934                     detect_mult, local_addr, peer_addr, is_ipv6=0,
1935                     bfd_key_id=None, conf_key_id=None):
1936         if bfd_key_id is None:
1937             return self.api(self.papi.bfd_udp_add,
1938                             {
1939                                 'sw_if_index': sw_if_index,
1940                                 'desired_min_tx': desired_min_tx,
1941                                 'required_min_rx': required_min_rx,
1942                                 'local_addr': local_addr,
1943                                 'peer_addr': peer_addr,
1944                                 'is_ipv6': is_ipv6,
1945                                 'detect_mult': detect_mult,
1946                             })
1947         else:
1948             return self.api(self.papi.bfd_udp_add,
1949                             {
1950                                 'sw_if_index': sw_if_index,
1951                                 'desired_min_tx': desired_min_tx,
1952                                 'required_min_rx': required_min_rx,
1953                                 'local_addr': local_addr,
1954                                 'peer_addr': peer_addr,
1955                                 'is_ipv6': is_ipv6,
1956                                 'detect_mult': detect_mult,
1957                                 'is_authenticated': 1,
1958                                 'bfd_key_id': bfd_key_id,
1959                                 'conf_key_id': conf_key_id,
1960                             })
1961
1962     def bfd_udp_mod(self, sw_if_index, desired_min_tx, required_min_rx,
1963                     detect_mult, local_addr, peer_addr, is_ipv6=0):
1964         return self.api(self.papi.bfd_udp_mod,
1965                         {
1966                             'sw_if_index': sw_if_index,
1967                             'desired_min_tx': desired_min_tx,
1968                             'required_min_rx': required_min_rx,
1969                             'local_addr': local_addr,
1970                             'peer_addr': peer_addr,
1971                             'is_ipv6': is_ipv6,
1972                             'detect_mult': detect_mult,
1973                         })
1974
1975     def bfd_udp_auth_activate(self, sw_if_index, local_addr, peer_addr,
1976                               is_ipv6=0, bfd_key_id=None, conf_key_id=None,
1977                               is_delayed=False):
1978         return self.api(self.papi.bfd_udp_auth_activate,
1979                         {
1980                             'sw_if_index': sw_if_index,
1981                             'local_addr': local_addr,
1982                             'peer_addr': peer_addr,
1983                             'is_ipv6': is_ipv6,
1984                             'is_delayed': 1 if is_delayed else 0,
1985                             'bfd_key_id': bfd_key_id,
1986                             'conf_key_id': conf_key_id,
1987                         })
1988
1989     def bfd_udp_auth_deactivate(self, sw_if_index, local_addr, peer_addr,
1990                                 is_ipv6=0, is_delayed=False):
1991         return self.api(self.papi.bfd_udp_auth_deactivate,
1992                         {
1993                             'sw_if_index': sw_if_index,
1994                             'local_addr': local_addr,
1995                             'peer_addr': peer_addr,
1996                             'is_ipv6': is_ipv6,
1997                             'is_delayed': 1 if is_delayed else 0,
1998                         })
1999
2000     def bfd_udp_del(self, sw_if_index, local_addr, peer_addr, is_ipv6=0):
2001         return self.api(self.papi.bfd_udp_del,
2002                         {
2003                             'sw_if_index': sw_if_index,
2004                             'local_addr': local_addr,
2005                             'peer_addr': peer_addr,
2006                             'is_ipv6': is_ipv6,
2007                         })
2008
2009     def bfd_udp_session_dump(self):
2010         return self.api(self.papi.bfd_udp_session_dump, {})
2011
2012     def bfd_udp_session_set_flags(self, admin_up_down, sw_if_index, local_addr,
2013                                   peer_addr, is_ipv6=0):
2014         return self.api(self.papi.bfd_udp_session_set_flags, {
2015             'admin_up_down': admin_up_down,
2016             'sw_if_index': sw_if_index,
2017             'local_addr': local_addr,
2018             'peer_addr': peer_addr,
2019             'is_ipv6': is_ipv6,
2020         })
2021
2022     def want_bfd_events(self, enable_disable=1):
2023         return self.api(self.papi.want_bfd_events, {
2024             'enable_disable': enable_disable,
2025             'pid': os.getpid(),
2026         })
2027
2028     def bfd_auth_set_key(self, conf_key_id, auth_type, key):
2029         return self.api(self.papi.bfd_auth_set_key, {
2030             'conf_key_id': conf_key_id,
2031             'auth_type': auth_type,
2032             'key': key,
2033             'key_len': len(key),
2034         })
2035
2036     def bfd_auth_del_key(self, conf_key_id):
2037         return self.api(self.papi.bfd_auth_del_key, {
2038             'conf_key_id': conf_key_id,
2039         })
2040
2041     def bfd_auth_keys_dump(self):
2042         return self.api(self.papi.bfd_auth_keys_dump, {})
2043
2044     def bfd_udp_set_echo_source(self, sw_if_index):
2045         return self.api(self.papi.bfd_udp_set_echo_source,
2046                         {'sw_if_index': sw_if_index})
2047
2048     def bfd_udp_del_echo_source(self):
2049         return self.api(self.papi.bfd_udp_del_echo_source, {})
2050
2051     def classify_add_del_table(
2052             self,
2053             is_add,
2054             mask,
2055             match_n_vectors=1,
2056             table_index=0xFFFFFFFF,
2057             nbuckets=2,
2058             memory_size=2097152,
2059             skip_n_vectors=0,
2060             next_table_index=0xFFFFFFFF,
2061             miss_next_index=0xFFFFFFFF,
2062             current_data_flag=0,
2063             current_data_offset=0):
2064         """
2065         :param is_add:
2066         :param mask:
2067         :param match_n_vectors: (Default value = 1)
2068         :param table_index: (Default value = 0xFFFFFFFF)
2069         :param nbuckets:  (Default value = 2)
2070         :param memory_size:  (Default value = 2097152)
2071         :param skip_n_vectors:  (Default value = 0)
2072         :param next_table_index:  (Default value = 0xFFFFFFFF)
2073         :param miss_next_index:  (Default value = 0xFFFFFFFF)
2074         :param current_data_flag:  (Default value = 0)
2075         :param current_data_offset:  (Default value = 0)
2076         """
2077
2078         return self.api(
2079             self.papi.classify_add_del_table,
2080             {'is_add': is_add,
2081              'table_index': table_index,
2082              'nbuckets': nbuckets,
2083              'memory_size': memory_size,
2084              'skip_n_vectors': skip_n_vectors,
2085              'match_n_vectors': match_n_vectors,
2086              'next_table_index': next_table_index,
2087              'miss_next_index': miss_next_index,
2088              'current_data_flag': current_data_flag,
2089              'current_data_offset': current_data_offset,
2090              'mask': mask})
2091
2092     def classify_add_del_session(
2093             self,
2094             is_add,
2095             table_index,
2096             match,
2097             opaque_index=0xFFFFFFFF,
2098             hit_next_index=0xFFFFFFFF,
2099             advance=0,
2100             action=0,
2101             metadata=0):
2102         """
2103         :param is_add:
2104         :param table_index:
2105         :param match:
2106         :param opaque_index:  (Default value = 0xFFFFFFFF)
2107         :param hit_next_index:  (Default value = 0xFFFFFFFF)
2108         :param advance:  (Default value = 0)
2109         :param action:  (Default value = 0)
2110         :param metadata:  (Default value = 0)
2111         """
2112
2113         return self.api(
2114             self.papi.classify_add_del_session,
2115             {'is_add': is_add,
2116              'table_index': table_index,
2117              'hit_next_index': hit_next_index,
2118              'opaque_index': opaque_index,
2119              'advance': advance,
2120              'action': action,
2121              'metadata': metadata,
2122              'match': match})
2123
2124     def input_acl_set_interface(
2125             self,
2126             is_add,
2127             sw_if_index,
2128             ip4_table_index=0xFFFFFFFF,
2129             ip6_table_index=0xFFFFFFFF,
2130             l2_table_index=0xFFFFFFFF):
2131         """
2132         :param is_add:
2133         :param sw_if_index:
2134         :param ip4_table_index:  (Default value = 0xFFFFFFFF)
2135         :param ip6_table_index:  (Default value = 0xFFFFFFFF)
2136         :param l2_table_index:  (Default value = 0xFFFFFFFF)
2137         """
2138
2139         return self.api(
2140             self.papi.input_acl_set_interface,
2141             {'sw_if_index': sw_if_index,
2142              'ip4_table_index': ip4_table_index,
2143              'ip6_table_index': ip6_table_index,
2144              'l2_table_index': l2_table_index,
2145              'is_add': is_add})
2146
2147     def output_acl_set_interface(
2148             self,
2149             is_add,
2150             sw_if_index,
2151             ip4_table_index=0xFFFFFFFF,
2152             ip6_table_index=0xFFFFFFFF,
2153             l2_table_index=0xFFFFFFFF):
2154         """
2155         :param is_add:
2156         :param sw_if_index:
2157         :param ip4_table_index:  (Default value = 0xFFFFFFFF)
2158         :param ip6_table_index:  (Default value = 0xFFFFFFFF)
2159         :param l2_table_index:  (Default value = 0xFFFFFFFF)
2160         """
2161
2162         return self.api(
2163             self.papi.output_acl_set_interface,
2164             {'sw_if_index': sw_if_index,
2165              'ip4_table_index': ip4_table_index,
2166              'ip6_table_index': ip6_table_index,
2167              'l2_table_index': l2_table_index,
2168              'is_add': is_add})
2169
2170     def set_ipfix_exporter(
2171             self,
2172             collector_address,
2173             src_address,
2174             path_mtu,
2175             template_interval,
2176             vrf_id=0,
2177             collector_port=4739,
2178             udp_checksum=0):
2179         return self.api(
2180             self.papi.set_ipfix_exporter,
2181             {
2182                 'collector_address': collector_address,
2183                 'collector_port': collector_port,
2184                 'src_address': src_address,
2185                 'vrf_id': vrf_id,
2186                 'path_mtu': path_mtu,
2187                 'template_interval': template_interval,
2188                 'udp_checksum': udp_checksum,
2189             })
2190
2191     def dhcp_proxy_config(self,
2192                           dhcp_server,
2193                           dhcp_src_address,
2194                           rx_table_id=0,
2195                           server_table_id=0,
2196                           is_add=1,
2197                           is_ipv6=0):
2198         return self.api(
2199             self.papi.dhcp_proxy_config,
2200             {
2201                 'rx_vrf_id': rx_table_id,
2202                 'server_vrf_id': server_table_id,
2203                 'is_ipv6': is_ipv6,
2204                 'is_add': is_add,
2205                 'dhcp_server': dhcp_server,
2206                 'dhcp_src_address': dhcp_src_address,
2207             })
2208
2209     def dhcp_proxy_set_vss(self,
2210                            table_id,
2211                            vss_type=255,
2212                            vpn_ascii_id="",
2213                            oui=0,
2214                            vpn_index=0,
2215                            is_add=1,
2216                            is_ip6=0):
2217         return self.api(
2218             self.papi.dhcp_proxy_set_vss,
2219             {
2220                 'tbl_id': table_id,
2221                 'vss_type': vss_type,
2222                 'vpn_ascii_id': vpn_ascii_id,
2223                 'oui': oui,
2224                 'vpn_index': vpn_index,
2225                 'is_add': is_add,
2226                 'is_ipv6': is_ip6,
2227             })
2228
2229     def dhcp_client(self,
2230                     sw_if_index,
2231                     hostname,
2232                     client_id='',
2233                     is_add=1,
2234                     set_broadcast_flag=1,
2235                     want_dhcp_events=0):
2236         return self.api(
2237             self.papi.dhcp_client_config,
2238             {
2239                 'sw_if_index': sw_if_index,
2240                 'hostname': hostname,
2241                 'client_id': client_id,
2242                 'is_add': is_add,
2243                 'want_dhcp_event': want_dhcp_events,
2244                 'set_broadcast_flag': set_broadcast_flag,
2245                 'pid': os.getpid(),
2246             })
2247
2248     def ip_mroute_add_del(self,
2249                           src_address,
2250                           grp_address,
2251                           grp_address_length,
2252                           e_flags,
2253                           next_hop_afi,
2254                           next_hop_sw_if_index,
2255                           i_flags,
2256                           bier_imp=0,
2257                           rpf_id=0,
2258                           table_id=0,
2259                           is_add=1,
2260                           is_ipv6=0,
2261                           is_local=0):
2262         """
2263         IP Multicast Route add/del
2264         """
2265         return self.api(
2266             self.papi.ip_mroute_add_del,
2267             {'next_hop_sw_if_index': next_hop_sw_if_index,
2268              'entry_flags': e_flags,
2269              'itf_flags': i_flags,
2270              'table_id': table_id,
2271              'rpf_id': rpf_id,
2272              'is_add': is_add,
2273              'is_ipv6': is_ipv6,
2274              'is_local': is_local,
2275              'bier_imp': bier_imp,
2276              'next_hop_afi': next_hop_afi,
2277              'grp_address_length': grp_address_length,
2278              'grp_address': grp_address,
2279              'src_address': src_address})
2280
2281     def mfib_signal_dump(self):
2282         return self.api(self.papi.mfib_signal_dump, {})
2283
2284     def ip_mfib_dump(self):
2285         return self.api(self.papi.ip_mfib_dump, {})
2286
2287     def ip6_mfib_dump(self):
2288         return self.api(self.papi.ip6_mfib_dump, {})
2289
2290     def lisp_enable_disable(self, is_enabled):
2291         return self.api(
2292             self.papi.lisp_enable_disable,
2293             {
2294                 'is_en': is_enabled,
2295             })
2296
2297     def lisp_locator_set(self,
2298                          ls_name,
2299                          is_add=1):
2300         return self.api(
2301             self.papi.lisp_add_del_locator_set,
2302             {
2303                 'is_add': is_add,
2304                 'locator_set_name': ls_name
2305             })
2306
2307     def lisp_locator_set_dump(self):
2308         return self.api(self.papi.lisp_locator_set_dump, {})
2309
2310     def lisp_locator(self,
2311                      ls_name,
2312                      sw_if_index,
2313                      priority=1,
2314                      weight=1,
2315                      is_add=1):
2316         return self.api(
2317             self.papi.lisp_add_del_locator,
2318             {
2319                 'is_add': is_add,
2320                 'locator_set_name': ls_name,
2321                 'sw_if_index': sw_if_index,
2322                 'priority': priority,
2323                 'weight': weight
2324             })
2325
2326     def lisp_locator_dump(self, is_index_set, ls_name=None, ls_index=0):
2327         return self.api(
2328             self.papi.lisp_locator_dump,
2329             {
2330                 'is_index_set': is_index_set,
2331                 'ls_name': ls_name,
2332                 'ls_index': ls_index,
2333             })
2334
2335     def lisp_local_mapping(self,
2336                            ls_name,
2337                            eid_type,
2338                            eid,
2339                            prefix_len,
2340                            vni=0,
2341                            key_id=0,
2342                            key="",
2343                            is_add=1):
2344         return self.api(
2345             self.papi.lisp_add_del_local_eid,
2346             {
2347                 'locator_set_name': ls_name,
2348                 'is_add': is_add,
2349                 'eid_type': eid_type,
2350                 'eid': eid,
2351                 'prefix_len': prefix_len,
2352                 'vni': vni,
2353                 'key_id': key_id,
2354                 'key': key
2355             })
2356
2357     def lisp_eid_table_dump(self,
2358                             eid_set=0,
2359                             prefix_length=0,
2360                             vni=0,
2361                             eid_type=0,
2362                             eid=None,
2363                             filter_opt=0):
2364         return self.api(
2365             self.papi.lisp_eid_table_dump,
2366             {
2367                 'eid_set': eid_set,
2368                 'prefix_length': prefix_length,
2369                 'vni': vni,
2370                 'eid_type': eid_type,
2371                 'eid': eid,
2372                 'filter': filter_opt,
2373             })
2374
2375     def lisp_remote_mapping(self,
2376                             eid_type,
2377                             eid,
2378                             eid_prefix_len=0,
2379                             vni=0,
2380                             rlocs=[],
2381                             rlocs_num=0,
2382                             is_src_dst=0,
2383                             is_add=1):
2384         return self.api(
2385             self.papi.lisp_add_del_remote_mapping,
2386             {
2387                 'is_add': is_add,
2388                 'eid_type': eid_type,
2389                 'eid': eid,
2390                 'eid_len': eid_prefix_len,
2391                 'rloc_num': rlocs_num,
2392                 'rlocs': rlocs,
2393                 'vni': vni,
2394                 'is_src_dst': is_src_dst,
2395             })
2396
2397     def lisp_adjacency(self,
2398                        leid,
2399                        reid,
2400                        leid_len,
2401                        reid_len,
2402                        eid_type,
2403                        is_add=1,
2404                        vni=0):
2405         return self.api(
2406             self.papi.lisp_add_del_adjacency,
2407             {
2408                 'is_add': is_add,
2409                 'vni': vni,
2410                 'eid_type': eid_type,
2411                 'leid': leid,
2412                 'reid': reid,
2413                 'leid_len': leid_len,
2414                 'reid_len': reid_len,
2415             })
2416
2417     def lisp_adjacencies_get(self, vni=0):
2418         return self.api(
2419             self.papi.lisp_adjacencies_get,
2420             {
2421                 'vni': vni
2422             })
2423
2424     def map_add_domain(self,
2425                        ip6_prefix,
2426                        ip6_prefix_len,
2427                        ip6_src,
2428                        ip6_src_prefix_len,
2429                        ip4_prefix,
2430                        ip4_prefix_len,
2431                        ea_bits_len=0,
2432                        psid_offset=0,
2433                        psid_length=0,
2434                        is_translation=0,
2435                        is_rfc6052=0,
2436                        mtu=1280):
2437         return self.api(
2438             self.papi.map_add_domain,
2439             {
2440                 'ip6_prefix': ip6_prefix,
2441                 'ip6_prefix_len': ip6_prefix_len,
2442                 'ip4_prefix': ip4_prefix,
2443                 'ip4_prefix_len': ip4_prefix_len,
2444                 'ip6_src': ip6_src,
2445                 'ip6_src_prefix_len': ip6_src_prefix_len,
2446                 'ea_bits_len': ea_bits_len,
2447                 'psid_offset': psid_offset,
2448                 'psid_length': psid_length,
2449                 'is_translation': is_translation,
2450                 'is_rfc6052': is_rfc6052,
2451                 'mtu': mtu
2452             })
2453
2454     def gtpu_add_del_tunnel(
2455             self,
2456             src_addr,
2457             dst_addr,
2458             is_add=1,
2459             is_ipv6=0,
2460             mcast_sw_if_index=0xFFFFFFFF,
2461             encap_vrf_id=0,
2462             decap_next_index=0xFFFFFFFF,
2463             teid=0):
2464         """
2465
2466         :param is_add:  (Default value = 1)
2467         :param is_ipv6:  (Default value = 0)
2468         :param src_addr:
2469         :param dst_addr:
2470         :param mcast_sw_if_index:  (Default value = 0xFFFFFFFF)
2471         :param encap_vrf_id:  (Default value = 0)
2472         :param decap_next_index:  (Default value = 0xFFFFFFFF)
2473         :param teid:  (Default value = 0)
2474
2475         """
2476         return self.api(self.papi.gtpu_add_del_tunnel,
2477                         {'is_add': is_add,
2478                          'is_ipv6': is_ipv6,
2479                          'src_address': src_addr,
2480                          'dst_address': dst_addr,
2481                          'mcast_sw_if_index': mcast_sw_if_index,
2482                          'encap_vrf_id': encap_vrf_id,
2483                          'decap_next_index': decap_next_index,
2484                          'teid': teid})
2485
2486     def vxlan_gpe_add_del_tunnel(
2487             self,
2488             src_addr,
2489             dst_addr,
2490             mcast_sw_if_index=0xFFFFFFFF,
2491             is_add=1,
2492             is_ipv6=0,
2493             encap_vrf_id=0,
2494             decap_vrf_id=0,
2495             protocol=3,
2496             vni=0):
2497         """
2498
2499         :param local:
2500         :param remote:
2501         :param is_add:  (Default value = 1)
2502         :param is_ipv6:  (Default value = 0)
2503         :param encap_vrf_id:  (Default value = 0)
2504         :param decap_vrf_id:  (Default value = 0)
2505         :param mcast_sw_if_index:  (Default value = 0xFFFFFFFF)
2506         :param protocol:  (Default value = 3)
2507         :param vni:  (Default value = 0)
2508
2509         """
2510         return self.api(self.papi.vxlan_gpe_add_del_tunnel,
2511                         {'is_add': is_add,
2512                          'is_ipv6': is_ipv6,
2513                          'local': src_addr,
2514                          'remote': dst_addr,
2515                          'mcast_sw_if_index': mcast_sw_if_index,
2516                          'encap_vrf_id': encap_vrf_id,
2517                          'decap_vrf_id': decap_vrf_id,
2518                          'protocol': protocol,
2519                          'vni': vni})
2520
2521     def pppoe_add_del_session(
2522             self,
2523             client_ip,
2524             client_mac,
2525             session_id=0,
2526             is_add=1,
2527             is_ipv6=0,
2528             decap_vrf_id=0):
2529         """
2530
2531         :param is_add:  (Default value = 1)
2532         :param is_ipv6:  (Default value = 0)
2533         :param client_ip:
2534         :param session_id:  (Default value = 0)
2535         :param client_mac:
2536         :param decap_vrf_id:  (Default value = 0)
2537
2538         """
2539         return self.api(self.papi.pppoe_add_del_session,
2540                         {'is_add': is_add,
2541                          'is_ipv6': is_ipv6,
2542                          'session_id': session_id,
2543                          'client_ip': client_ip,
2544                          'decap_vrf_id': decap_vrf_id,
2545                          'client_mac': client_mac})
2546
2547     def sr_localsid_add_del(self,
2548                             localsid_addr,
2549                             behavior,
2550                             nh_addr,
2551                             is_del=0,
2552                             end_psp=0,
2553                             sw_if_index=0xFFFFFFFF,
2554                             vlan_index=0,
2555                             fib_table=0,
2556                             ):
2557         """ Add/del IPv6 SR local-SID.
2558
2559         :param localsid_addr:
2560         :param behavior: END=1; END.X=2; END.DX2=4; END.DX6=5;
2561         :param behavior: END.DX4=6; END.DT6=7; END.DT4=8
2562         :param nh_addr:
2563         :param is_del:  (Default value = 0)
2564         :param end_psp: (Default value = 0)
2565         :param sw_if_index: (Default value = 0xFFFFFFFF)
2566         :param vlan_index:  (Default value = 0)
2567         :param fib_table:   (Default value = 0)
2568         """
2569         return self.api(
2570             self.papi.sr_localsid_add_del,
2571             {'is_del': is_del,
2572              'localsid_addr': localsid_addr,
2573              'end_psp': end_psp,
2574              'behavior': behavior,
2575              'sw_if_index': sw_if_index,
2576              'vlan_index': vlan_index,
2577              'fib_table': fib_table,
2578              'nh_addr': nh_addr
2579              }
2580         )
2581
2582     def sr_policy_add(
2583             self,
2584             bsid_addr,
2585             weight=1,
2586             is_encap=1,
2587             type=0,
2588             fib_table=0,
2589             n_segments=0,
2590             segments=[]):
2591         """
2592         :param bsid_addr: bindingSID of the SR Policy
2593         :param weight: weight of the sid list. optional. (default: 1)
2594         :param is_encap: (bool) whether SR policy should Encap or SRH insert \
2595             (default: Encap)
2596         :param type: type/behavior of the SR policy. (default or spray) \
2597             (default: default)
2598         :param fib_table: VRF where to install the FIB entry for the BSID \
2599             (default: 0)
2600         :param n_segments: number of segments \
2601             (default: 0)
2602         :param segments: a vector of IPv6 address composing the segment list \
2603             (default: [])
2604         """
2605         return self.api(
2606             self.papi.sr_policy_add,
2607             {'bsid_addr': bsid_addr,
2608              'weight': weight,
2609              'is_encap': is_encap,
2610              'type': type,
2611              'fib_table': fib_table,
2612              'n_segments': n_segments,
2613              'segments': segments
2614              }
2615         )
2616
2617     def sr_policy_del(
2618             self,
2619             bsid_addr,
2620             sr_policy_index=0):
2621         """
2622         :param bsid: bindingSID of the SR Policy
2623         :param sr_policy_index: index of the sr policy (default: 0)
2624         """
2625         return self.api(
2626             self.papi.sr_policy_del,
2627             {'bsid_addr': bsid_addr,
2628              'sr_policy_index': sr_policy_index
2629              })
2630
2631     def sr_steering_add_del(
2632             self,
2633             is_del,
2634             bsid_addr,
2635             sr_policy_index,
2636             table_id,
2637             prefix_addr,
2638             mask_width,
2639             sw_if_index,
2640             traffic_type):
2641         """
2642         Steer traffic L2 and L3 traffic through a given SR policy
2643
2644         :param is_del: delete or add
2645         :param bsid_addr: bindingSID of the SR Policy (alt to sr_policy_index)
2646         :param sr_policy: is the index of the SR Policy (alt to bsid)
2647         :param table_id: is the VRF where to install the FIB entry for the BSID
2648         :param prefix_addr: is the IPv4/v6 address for L3 traffic type
2649         :param mask_width: is the mask for L3 traffic type
2650         :param sw_if_index: is the incoming interface for L2 traffic
2651         :param traffic_type: type of traffic (IPv4: 4, IPv6: 6, L2: 2)
2652         """
2653         return self.api(
2654             self.papi.sr_steering_add_del,
2655             {'is_del': is_del,
2656              'bsid_addr': bsid_addr,
2657              'sr_policy_index': sr_policy_index,
2658              'table_id': table_id,
2659              'prefix_addr': prefix_addr,
2660              'mask_width': mask_width,
2661              'sw_if_index': sw_if_index,
2662              'traffic_type': traffic_type
2663              })
2664
2665     def acl_add_replace(self, acl_index, r, tag='',
2666                         expected_retval=0):
2667         """Add/replace an ACL
2668         :param int acl_index: ACL index to replace, 2^32-1 to create new ACL.
2669         :param acl_rule r: ACL rules array.
2670         :param str tag: symbolic tag (description) for this ACL.
2671         :param int count: number of rules.
2672         """
2673         return self.api(self.papi.acl_add_replace,
2674                         {'acl_index': acl_index,
2675                          'r': r,
2676                          'count': len(r),
2677                          'tag': tag},
2678                         expected_retval=expected_retval)
2679
2680     def acl_del(self, acl_index, expected_retval=0):
2681         """
2682
2683         :param acl_index:
2684         :return:
2685         """
2686         return self.api(self.papi.acl_del,
2687                         {'acl_index': acl_index},
2688                         expected_retval=expected_retval)
2689
2690     def acl_interface_set_acl_list(self, sw_if_index, n_input, acls,
2691                                    expected_retval=0):
2692         return self.api(self.papi.acl_interface_set_acl_list,
2693                         {'sw_if_index': sw_if_index,
2694                          'count': len(acls),
2695                          'n_input': n_input,
2696                          'acls': acls},
2697                         expected_retval=expected_retval)
2698
2699     def acl_interface_set_etype_whitelist(self, sw_if_index,
2700                                           n_input, whitelist,
2701                                           expected_retval=0):
2702         return self.api(self.papi.acl_interface_set_etype_whitelist,
2703                         {'sw_if_index': sw_if_index,
2704                          'count': len(whitelist),
2705                          'n_input': n_input,
2706                          'whitelist': whitelist},
2707                         expected_retval=expected_retval)
2708
2709     def acl_interface_add_del(self,
2710                               sw_if_index,
2711                               acl_index,
2712                               is_add=1):
2713         """ Add/Delete ACL to/from interface
2714
2715         :param sw_if_index:
2716         :param acl_index:
2717         :param is_add:  (Default value = 1)
2718         """
2719
2720         return self.api(self.papi.acl_interface_add_del,
2721                         {'is_add': is_add,
2722                          'is_input': 1,
2723                          'sw_if_index': sw_if_index,
2724                          'acl_index': acl_index})
2725
2726     def acl_dump(self, acl_index, expected_retval=0):
2727         return self.api(self.papi.acl_dump,
2728                         {'acl_index': acl_index},
2729                         expected_retval=expected_retval)
2730
2731     def macip_acl_add(self, rules, tag=""):
2732         """ Add MACIP acl
2733
2734         :param rules: list of rules for given acl
2735         :param tag: acl tag
2736         """
2737
2738         return self.api(self.papi.macip_acl_add,
2739                         {'r': rules,
2740                          'count': len(rules),
2741                          'tag': tag})
2742
2743     def macip_acl_add_replace(self, rules, acl_index=0xFFFFFFFF, tag=""):
2744         """ Add MACIP acl
2745
2746         :param rules: list of rules for given acl
2747         :param tag: acl tag
2748         """
2749
2750         return self.api(self.papi.macip_acl_add_replace,
2751                         {'acl_index': acl_index,
2752                          'r': rules,
2753                          'count': len(rules),
2754                          'tag': tag})
2755
2756     def macip_acl_del(self, acl_index):
2757         """
2758
2759         :param acl_index:
2760         :return:
2761         """
2762         return self.api(self.papi.macip_acl_del,
2763                         {'acl_index': acl_index})
2764
2765     def macip_acl_interface_add_del(self,
2766                                     sw_if_index,
2767                                     acl_index,
2768                                     is_add=1):
2769         """ Add MACIP acl to interface
2770
2771         :param sw_if_index:
2772         :param acl_index:
2773         :param is_add:  (Default value = 1)
2774         """
2775
2776         return self.api(self.papi.macip_acl_interface_add_del,
2777                         {'is_add': is_add,
2778                          'sw_if_index': sw_if_index,
2779                          'acl_index': acl_index})
2780
2781     def macip_acl_interface_get(self):
2782         """ Return interface acls dump
2783         """
2784         return self.api(
2785             self.papi.macip_acl_interface_get, {})
2786
2787     def macip_acl_dump(self, acl_index=4294967295):
2788         """ Return MACIP acl dump
2789         """
2790
2791         return self.api(
2792             self.papi.macip_acl_dump, {'acl_index': acl_index})
2793
2794     def policer_add_del(self,
2795                         name,
2796                         cir,
2797                         eir,
2798                         cb,
2799                         eb,
2800                         is_add=1,
2801                         rate_type=0,
2802                         round_type=0,
2803                         ptype=0,
2804                         color_aware=0,
2805                         conform_action_type=1,
2806                         conform_dscp=0,
2807                         exceed_action_type=0,
2808                         exceed_dscp=0,
2809                         violate_action_type=0,
2810                         violate_dscp=0):
2811         return self.api(self.papi.policer_add_del,
2812                         {'name': name,
2813                          'cir': cir,
2814                          'eir': eir,
2815                          'cb': cb,
2816                          'eb': eb,
2817                          'is_add': is_add,
2818                          'rate_type': rate_type,
2819                          'round_type': round_type,
2820                          'type': ptype,
2821                          'color_aware': color_aware,
2822                          'conform_action_type': conform_action_type,
2823                          'conform_dscp': conform_dscp,
2824                          'exceed_action_type': exceed_action_type,
2825                          'exceed_dscp': exceed_dscp,
2826                          'violate_action_type': violate_action_type,
2827                          'violate_dscp': violate_dscp})
2828
2829     def ip_punt_police(self,
2830                        policer_index,
2831                        is_ip6=0,
2832                        is_add=1):
2833         return self.api(self.papi.ip_punt_police,
2834                         {'policer_index': policer_index,
2835                          'is_add': is_add,
2836                          'is_ip6': is_ip6})
2837
2838     def ip_punt_redirect(self,
2839                          rx_sw_if_index,
2840                          tx_sw_if_index,
2841                          nh,
2842                          is_ip6=0,
2843                          is_add=1):
2844         return self.api(self.papi.ip_punt_redirect,
2845                         {'rx_sw_if_index': rx_sw_if_index,
2846                          'tx_sw_if_index': tx_sw_if_index,
2847                          'nh': nh,
2848                          'is_add': is_add,
2849                          'is_ip6': is_ip6})
2850
2851     def bier_table_add_del(self,
2852                            bti,
2853                            mpls_label,
2854                            is_add=1):
2855         """ BIER Table add/del """
2856         return self.api(
2857             self.papi.bier_table_add_del,
2858             {'bt_tbl_id': {"bt_set": bti.set_id,
2859                            "bt_sub_domain": bti.sub_domain_id,
2860                            "bt_hdr_len_id": bti.hdr_len_id},
2861              'bt_label': mpls_label,
2862              'bt_is_add': is_add})
2863
2864     def bier_table_dump(self):
2865         return self.api(self.papi.bier_table_dump, {})
2866
2867     def bier_route_add_del(self,
2868                            bti,
2869                            bp,
2870                            paths,
2871                            is_add=1):
2872         """ BIER Route add/del """
2873         br_paths = []
2874         for p in paths:
2875             br_paths.append({'next_hop': p.nh_addr,
2876                              'weight': 1,
2877                              'afi': 0,
2878                              'preference': 0,
2879                              'table_id': p.nh_table_id,
2880                              'next_hop_id': p.next_hop_id,
2881                              'is_udp_encap': p.is_udp_encap,
2882                              'n_labels': len(p.nh_labels),
2883                              'label_stack': p.nh_labels})
2884         return self.api(
2885             self.papi.bier_route_add_del,
2886             {'br_tbl_id': {"bt_set": bti.set_id,
2887                            "bt_sub_domain": bti.sub_domain_id,
2888                            "bt_hdr_len_id": bti.hdr_len_id},
2889              'br_bp': bp,
2890              'br_n_paths': len(br_paths),
2891              'br_paths': br_paths,
2892              'br_is_add': is_add})
2893
2894     def bier_route_dump(self, bti):
2895         return self.api(
2896             self.papi.bier_route_dump,
2897             {'br_tbl_id': {"bt_set": bti.set_id,
2898                            "bt_sub_domain": bti.sub_domain_id,
2899                            "bt_hdr_len_id": bti.hdr_len_id}})
2900
2901     def bier_imp_add(self,
2902                      bti,
2903                      src,
2904                      ibytes,
2905                      is_add=1):
2906         """ BIER Imposition Add """
2907         return self.api(
2908             self.papi.bier_imp_add,
2909             {'bi_tbl_id': {"bt_set": bti.set_id,
2910                            "bt_sub_domain": bti.sub_domain_id,
2911                            "bt_hdr_len_id": bti.hdr_len_id},
2912              'bi_src': src,
2913              'bi_n_bytes': len(ibytes),
2914              'bi_bytes': ibytes})
2915
2916     def bier_imp_del(self, bi_index):
2917         """ BIER Imposition del """
2918         return self.api(
2919             self.papi.bier_imp_del,
2920             {'bi_index': bi_index})
2921
2922     def bier_imp_dump(self):
2923         return self.api(self.papi.bier_imp_dump, {})
2924
2925     def bier_disp_table_add_del(self,
2926                                 bdti,
2927                                 is_add=1):
2928         """ BIER Disposition Table add/del """
2929         return self.api(
2930             self.papi.bier_disp_table_add_del,
2931             {'bdt_tbl_id': bdti,
2932              'bdt_is_add': is_add})
2933
2934     def bier_disp_table_dump(self):
2935         return self.api(self.papi.bier_disp_table_dump, {})
2936
2937     def bier_disp_entry_add_del(self,
2938                                 bdti,
2939                                 bp,
2940                                 payload_proto,
2941                                 next_hop_afi,
2942                                 next_hop,
2943                                 next_hop_tbl_id=0,
2944                                 next_hop_rpf_id=~0,
2945                                 next_hop_is_ip4=1,
2946                                 is_add=1):
2947         """ BIER Route add/del """
2948         return self.api(
2949             self.papi.bier_disp_entry_add_del,
2950             {'bde_tbl_id': bdti,
2951              'bde_bp': bp,
2952              'bde_payload_proto': payload_proto,
2953              'bde_n_paths': 1,
2954              'bde_paths': [{'next_hop': next_hop,
2955                             'table_id': next_hop_tbl_id,
2956                             'afi': next_hop_afi,
2957                             'rpf_id': next_hop_rpf_id,
2958                             'n_labels': 0,
2959                             'label_stack': [0]}],
2960              'bde_is_add': is_add})
2961
2962     def bier_disp_entry_dump(self, bdti):
2963         return self.api(
2964             self.papi.bier_disp_entry_dump,
2965             {'bde_tbl_id': bdti})
2966
2967     def add_node_next(self, node_name, next_name):
2968         """ Set the next node for a given node request
2969
2970         :param node_name:
2971         :param next_name:
2972         """
2973         return self.api(self.papi.add_node_next,
2974                         {'node_name': node_name,
2975                          'next_name': next_name})
2976
2977     def session_enable_disable(self, is_enabled):
2978         return self.api(
2979             self.papi.session_enable_disable,
2980             {'is_enable': is_enabled})
2981
2982     def ipsec_spd_add_del(self, spd_id, is_add=1):
2983         """ SPD add/del - Wrapper to add or del ipsec SPD
2984         Sample CLI : 'ipsec spd add 1'
2985
2986         :param spd_id - SPD ID to be created in the vpp . mandatory
2987         :param is_add - create (1) or delete(0) SPD (Default 1 - add) .
2988               optional
2989         :returns: reply from the API
2990         """
2991         return self.api(
2992             self.papi.ipsec_spd_add_del, {
2993                 'spd_id': spd_id, 'is_add': is_add})
2994
2995     def ipsec_interface_add_del_spd(self, spd_id, sw_if_index, is_add=1):
2996         """ IPSEC interface SPD add/del - \
2997              Wrapper to associate/disassociate SPD to interface in VPP
2998         Sample CLI : 'set interface ipsec spd GigabitEthernet0/6/0 1'
2999
3000         :param spd_id - SPD ID to associate with the interface . mandatory
3001         :param sw_if_index - Interface Index which needs to ipsec \
3002             association mandatory
3003         :param is_add - add(1) or del(0) association with interface \
3004                 (Default 1 - add) . optional
3005         :returns: reply from the API
3006         """
3007         return self.api(
3008             self.papi.ipsec_interface_add_del_spd, {
3009                 'spd_id': spd_id,
3010                 'sw_if_index': sw_if_index, 'is_add': is_add})
3011
3012     def ipsec_sad_add_del_entry(self,
3013                                 sad_id,
3014                                 spi,
3015                                 tunnel_src_address='',
3016                                 tunnel_dst_address='',
3017                                 protocol=0,
3018                                 integrity_algorithm=2,
3019                                 integrity_key_length=0,
3020                                 integrity_key='C91KUR9GYMm5GfkEvNjX',
3021                                 crypto_algorithm=1,
3022                                 crypto_key_length=0,
3023                                 crypto_key='JPjyOWBeVEQiMe7h',
3024                                 is_add=1,
3025                                 is_tunnel=1):
3026         """ IPSEC SA add/del
3027         Sample CLI : 'ipsec sa add 10 spi 1001 esp \
3028             crypto-key 4a506a794f574265564551694d653768 \
3029             crypto-alg aes-cbc-128 \
3030             integ-key 4339314b55523947594d6d3547666b45764e6a58 \
3031             integ-alg sha1-96 tunnel-src 192.168.100.3 \
3032             tunnel-dst 192.168.100.2'
3033         Sample CLI : 'ipsec sa add 20 spi 2001 \
3034             integ-key 4339314b55523947594d6d3547666b45764e6a58 \
3035             integ-alg sha1-96'
3036
3037         :param sad_id -  Security Association ID to be \
3038             created or deleted. mandatory
3039         :param spi - security param index of the SA in decimal. mandatory
3040         :param tunnel_src_address - incase of tunnel mode outer src address .\
3041              mandatory for tunnel mode
3042         :param tunnel_dst_address - incase of transport mode \
3043              outer dst address. mandatory for tunnel mode
3044         :param protocol - AH(0) or ESP(1) protocol (Default 0 - AH). optional
3045         :param integrity_algorithm - value range 1-6 Default(2 - SHA1_96).\
3046              optional **
3047         :param integrity_key - value in string \
3048              (Default C91KUR9GYMm5GfkEvNjX).optional
3049         :param integrity_key_length - length of the key string in bytes\
3050              (Default 0 - integrity disabled). optional
3051         :param crypto_algorithm - value range 1-11 Default \
3052              (1- AES_CBC_128).optional **
3053         :param crypto_key - value in string(Default JPjyOWBeVEQiMe7h).optional
3054         :param crypto_key_length - length of the key string in bytes\
3055              (Default 0 - crypto disabled). optional
3056         :param is_add - add(1) or del(0) ipsec SA entry(Default 1 - add) .\
3057              optional
3058         :param is_tunnel - tunnel mode (1) or transport mode(0) \
3059              (Default 1 - tunnel). optional
3060         :returns: reply from the API
3061         :** reference /vpp/src/vnet/ipsec/ipsec.h file for enum values of
3062              crypto and ipsec algorithms
3063         """
3064         return self.api(
3065             self.papi.ipsec_sad_add_del_entry,
3066             {'sad_id': sad_id,
3067              'spi': spi,
3068              'tunnel_src_address': tunnel_src_address,
3069              'tunnel_dst_address': tunnel_dst_address,
3070              'protocol': protocol,
3071              'integrity_algorithm': integrity_algorithm,
3072              'integrity_key_length': integrity_key_length,
3073              'integrity_key': integrity_key,
3074              'crypto_algorithm': crypto_algorithm,
3075              'crypto_key_length': crypto_key_length,
3076              'crypto_key': crypto_key,
3077              'is_add': is_add,
3078              'is_tunnel': is_tunnel})
3079
3080     def ipsec_spd_add_del_entry(self,
3081                                 spd_id,
3082                                 local_address_start,
3083                                 local_address_stop,
3084                                 remote_address_start,
3085                                 remote_address_stop,
3086                                 local_port_start=0,
3087                                 local_port_stop=65535,
3088                                 remote_port_start=0,
3089                                 remote_port_stop=65535,
3090                                 protocol=0,
3091                                 sa_id=10,
3092                                 policy=0,
3093                                 priority=100,
3094                                 is_outbound=1,
3095                                 is_add=1,
3096                                 is_ip_any=0):
3097         """ IPSEC policy SPD add/del   -
3098                     Wrapper to configure ipsec SPD policy entries in VPP
3099         Sample CLI : 'ipsec policy add spd 1 inbound priority 10 action \
3100                      protect sa 20 local-ip-range 192.168.4.4 - 192.168.4.4 \
3101                      remote-ip-range 192.168.3.3 - 192.168.3.3'
3102
3103         :param spd_id -  SPD ID for the policy . mandatory
3104         :param local_address_start - local-ip-range start address . mandatory
3105         :param local_address_stop  - local-ip-range stop address . mandatory
3106         :param remote_address_start - remote-ip-range start address . mandatory
3107         :param remote_address_stop  - remote-ip-range stop address . mandatory
3108         :param local_port_start - (Default 0) . optional
3109         :param local_port_stop - (Default 65535). optional
3110         :param remote_port_start - (Default 0). optional
3111         :param remote_port_stop - (Default 65535). optional
3112         :param protocol - Any(0), AH(51) & ESP(50) protocol (Default 0 - Any).
3113                optional
3114         :param sa_id -  Security Association ID for mapping it to SPD
3115                (default 10).   optional
3116         :param policy - bypass(0), discard(1), resolve(2) or protect(3)action
3117                (Default 0 - bypass). optional
3118         :param priotity - value for the spd action (Default 100). optional
3119         :param is_outbound - flag for inbound(0) or outbound(1)
3120                (Default 1 - outbound). optional
3121         :param is_add flag - for addition(1) or deletion(0) of the spd
3122                (Default 1 - addtion). optional
3123         :returns: reply from the API
3124         """
3125         return self.api(
3126             self.papi.ipsec_spd_add_del_entry,
3127             {'spd_id': spd_id,
3128              'local_address_start': local_address_start,
3129              'local_address_stop': local_address_stop,
3130              'remote_address_start': remote_address_start,
3131              'remote_address_stop': remote_address_stop,
3132              'local_port_start': local_port_start,
3133              'local_port_stop': local_port_stop,
3134              'remote_port_start': remote_port_start,
3135              'remote_port_stop': remote_port_stop,
3136              'is_add': is_add,
3137              'protocol': protocol,
3138              'policy': policy,
3139              'priority': priority,
3140              'is_outbound': is_outbound,
3141              'sa_id': sa_id,
3142              'is_ip_any': is_ip_any})
3143
3144     def app_namespace_add(self,
3145                           namespace_id,
3146                           ip4_fib_id=0,
3147                           ip6_fib_id=0,
3148                           sw_if_index=0xFFFFFFFF,
3149                           secret=0):
3150         return self.api(
3151             self.papi.app_namespace_add_del,
3152             {'secret': secret,
3153              'sw_if_index': sw_if_index,
3154              'ip4_fib_id': ip4_fib_id,
3155              'ip6_fib_id': ip6_fib_id,
3156              'namespace_id': namespace_id,
3157              'namespace_id_len': len(namespace_id)})
3158
3159     def punt_socket_register(self, l4_port, pathname, header_version=1,
3160                              is_ip4=1, l4_protocol=0x11):
3161         """ Punt to socket """
3162         return self.api(self.papi.punt_socket_register,
3163                         {'is_ip4': is_ip4,
3164                          'l4_protocol': l4_protocol,
3165                          'l4_port': l4_port,
3166                          'pathname': pathname,
3167                          'header_version': header_version})
3168
3169     def ip_reassembly_set(self, timeout_ms, max_reassemblies,
3170                           expire_walk_interval_ms, is_ip6=0):
3171         """ Set IP reassembly parameters """
3172         return self.api(self.papi.ip_reassembly_set,
3173                         {'is_ip6': is_ip6,
3174                          'timeout_ms': timeout_ms,
3175                          'expire_walk_interval_ms': expire_walk_interval_ms,
3176                          'max_reassemblies': max_reassemblies})
3177
3178     def ip_reassembly_get(self, is_ip6=0):
3179         """ Get IP reassembly parameters """
3180         return self.api(self.papi.ip_reassembly_get, {'is_ip6': is_ip6})
3181
3182     def gbp_endpoint_add_del(self, is_add, sw_if_index, addr, is_ip6, epg):
3183         """ GBP endpoint Add/Del """
3184         return self.api(self.papi.gbp_endpoint_add_del,
3185                         {'is_add': is_add,
3186                          'endpoint': {
3187                              'is_ip6': is_ip6,
3188                              'sw_if_index': sw_if_index,
3189                              'address': addr,
3190                              'epg_id': epg}})
3191
3192     def gbp_endpoint_dump(self):
3193         """ GBP endpoint Dump """
3194         return self.api(self.papi.gbp_endpoint_dump, {})
3195
3196     def gbp_contract_add_del(self, is_add, src_epg, dst_epg, acl_index):
3197         """ GBP contract Add/Del """
3198         return self.api(self.papi.gbp_contract_add_del,
3199                         {'is_add': is_add,
3200                          'contract': {
3201                              'acl_index': acl_index,
3202                              'src_epg': src_epg,
3203                              'dst_epg': dst_epg}})
3204
3205     def gbp_contract_dump(self):
3206         """ GBP contract Dump """
3207         return self.api(self.papi.gbp_contract_dump, {})