resources/libraries/python/Classify.py

   1 # Copyright (c) 2019 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """Classify utilities library."""
  15
  16 import binascii
  17 import re
  18
  19 from ipaddress import ip_address
  20
  21 from robot.api import logger
  22
  23 from resources.libraries.python.topology import Topology
  24 from resources.libraries.python.PapiExecutor import PapiExecutor
  25
  26
  27 class Classify(object):
  28     """Classify utilities."""
  29
  30     @staticmethod
  31     def _build_mac_mask(dst_mac='', src_mac='', ether_type=''):
  32         """Build MAC ACL mask data in hexstring format.
  33
  34         :param dst_mac: Source MAC address <0-ffffffffffff>.
  35         :param src_mac: Destination MAC address <0-ffffffffffff>.
  36         :param ether_type: Ethernet type <0-ffff>.
  37         :type dst_mac: str
  38         :type src_mac: str
  39         :type ether_type: str
  40         :returns MAC ACL mask in hexstring format.
  41         :rtype: str
  42         """
  43         if ether_type:
  44             end = 28
  45         elif src_mac:
  46             end = 24
  47         else:
  48             end = 12
  49
  50         return ('{!s:0>12}{!s:0>12}{!s:0>4}'.format(
  51             dst_mac.replace(':', ''), src_mac.replace(':', ''),
  52             ether_type))[0:end]
  53
  54     @staticmethod
  55     def _build_ip_mask(proto='', src_ip='', dst_ip='', src_port='',
  56                        dst_port=''):
  57         """Build IP ACL mask data in hexstring format.
  58
  59         :param proto: Protocol number <0-ff>.
  60         :param src_ip: Source ip address <0-ffffffff>.
  61         :param dst_ip: Destination ip address <0-ffffffff>.
  62         :param src_port: Source port number <0-ffff>.
  63         :param str dst_port: Destination port number <0-ffff>.
  64         :type proto: str
  65         :type src_ip: str
  66         :type dst_ip: str
  67         :type src_port: str
  68         :type dst_port:src
  69         :returns: IP mask in hexstring format.
  70         :rtype: str
  71         """
  72         if dst_port:
  73             end = 48
  74         elif src_port:
  75             end = 44
  76         elif dst_ip:
  77             end = 40
  78         elif src_ip:
  79             end = 32
  80         else:
  81             end = 20
  82
  83         return ('{!s:0>20}{!s:0>12}{!s:0>8}{!s:0>4}{!s:0>4}'.format(
  84             proto, src_ip, dst_ip, src_port, dst_port))[0:end]
  85
  86     @staticmethod
  87     def _build_ip6_mask(next_hdr='', src_ip='', dst_ip='', src_port='',
  88                         dst_port=''):
  89         """Build IPv6 ACL mask data in hexstring format.
  90
  91         :param next_hdr: Next header number <0-ff>.
  92         :param src_ip: Source ip address <0-ffffffff>.
  93         :param dst_ip: Destination ip address <0-ffffffff>.
  94         :param src_port: Source port number <0-ffff>.
  95         :param dst_port: Destination port number <0-ffff>.
  96         :type next_hdr: str
  97         :type src_ip: str
  98         :type dst_ip: str
  99         :type src_port: str
 100         :type dst_port: str
 101         :returns: IPv6 ACL mask in hexstring format.
 102         :rtype: str
 103         """
 104         if dst_port:
 105             end = 88
 106         elif src_port:
 107             end = 84
 108         elif dst_ip:
 109             end = 80
 110         elif src_ip:
 111             end = 48
 112         else:
 113             end = 14
 114
 115         return ('{!s:0>14}{!s:0>34}{!s:0>32}{!s:0>4}{!s:0>4}'.format(
 116             next_hdr, src_ip, dst_ip, src_port, dst_port))[0:end]
 117
 118     @staticmethod
 119     def _build_mac_match(dst_mac='', src_mac='', ether_type=''):
 120         """Build MAC ACL match data in  hexstring format.
 121
 122         :param dst_mac: Source MAC address <x:x:x:x:x:x>.
 123         :param src_mac: Destination MAC address <x:x:x:x:x:x>.
 124         :param ether_type: Ethernet type <0-ffff>.
 125         :type dst_mac: str
 126         :type src_mac: str
 127         :type ether_type: str
 128         :returns: MAC ACL match data in hexstring format.
 129         :rtype: str
 130         """
 131         if ether_type:
 132             end = 28
 133         elif src_mac:
 134             end = 24
 135         else:
 136             end = 12
 137
 138         return ('{!s:0>12}{!s:0>12}{!s:0>4}'.format(
 139             dst_mac.replace(':', ''), src_mac.replace(':', ''),
 140             ether_type))[0:end]
 141
 142     @staticmethod
 143     def _build_ip_match(proto=0, src_ip='', dst_ip='', src_port=0, dst_port=0):
 144         """Build IP ACL match data in hexstring format.
 145
 146         :param proto: Protocol number with valid option "x".
 147         :param src_ip: Source ip address with format of "x.x.x.x".
 148         :param dst_ip: Destination ip address with format of "x.x.x.x".
 149         :param src_port: Source port number "x".
 150         :param dst_port: Destination port number "x".
 151         :type proto: int
 152         :type src_ip: str
 153         :type dst_ip: str
 154         :type src_port: int
 155         :type dst_port: int
 156         :returns: IP ACL match data in hexstring format.
 157         :rtype: str
 158         """
 159         if src_ip:
 160             src_ip = binascii.hexlify(ip_address(unicode(src_ip)).packed)
 161         if dst_ip:
 162             dst_ip = binascii.hexlify(ip_address(unicode(dst_ip)).packed)
 163         if dst_port:
 164             end = 48
 165         elif src_port:
 166             end = 44
 167         elif dst_ip:
 168             end = 40
 169         elif src_ip:
 170             end = 32
 171         else:
 172             end = 20
 173
 174         return ('{!s:0>20}{!s:0>12}{!s:0>8}{!s:0>4}{!s:0>4}'.format(
 175             hex(proto)[2:], src_ip, dst_ip, hex(src_port)[2:],
 176             hex(dst_port)[2:]))[0:end]
 177
 178     @staticmethod
 179     def _build_ip6_match(next_hdr=0, src_ip='', dst_ip='', src_port=0,
 180                          dst_port=0):
 181         """Build IPv6 ACL match data in hexstring format.
 182
 183         :param next_hdr: Next header number with valid option "x".
 184         :param src_ip: Source ip6 address with format of "xxxx:xxxx::xxxx".
 185         :param dst_ip: Destination ip6 address with format of
 186             "xxxx:xxxx::xxxx".
 187         :param src_port: Source port number "x".
 188         :param dst_port: Destination port number "x".
 189         :type next_hdr: int
 190         :type src_ip: str
 191         :type dst_ip: str
 192         :type src_port: int
 193         :type dst_port: int
 194         :returns: IPv6 ACL match data in hexstring format.
 195         :rtype: str
 196         """
 197         if src_ip:
 198             src_ip = binascii.hexlify(ip_address(unicode(src_ip)).packed)
 199         if dst_ip:
 200             dst_ip = binascii.hexlify(ip_address(unicode(dst_ip)).packed)
 201         if dst_port:
 202             end = 88
 203         elif src_port:
 204             end = 84
 205         elif dst_ip:
 206             end = 80
 207         elif src_ip:
 208             end = 48
 209         else:
 210             end = 14
 211
 212         return ('{!s:0>14}{!s:0>34}{!s:0>32}{!s:0>4}{!s:0>4}'.format(
 213             hex(next_hdr)[2:], src_ip, dst_ip, hex(src_port)[2:],
 214             hex(dst_port)[2:]))[0:end]
 215
 216     @staticmethod
 217     def _classify_add_del_table(node, is_add, mask, match_n_vectors=1,
 218                                 table_index=0xFFFFFFFF, nbuckets=2,
 219                                 memory_size=2097152, skip_n_vectors=0,
 220                                 next_table_index=0xFFFFFFFF,
 221                                 miss_next_index=0xFFFFFFFF, current_data_flag=0,
 222                                 current_data_offset=0):
 223         """Add or delete a classify table.
 224
 225         :param node: VPP node to create classify table.
 226         :param is_add: If 1 the table is added, if 0 the table is deleted.
 227         :param mask: ACL mask in hexstring format.
 228         :param match_n_vectors: Number of vectors to match (Default value = 1).
 229         :param table_index: Index of the classify table.
 230             (Default value = 0xFFFFFFFF)
 231         :param nbuckets: Number of buckets when adding a table.
 232             (Default value = 2)
 233         :param memory_size: Memory size when adding a table.
 234             (Default value = 2097152)
 235         :param skip_n_vectors: Number of skip vectors (Default value = 0).
 236         :param next_table_index: Index of next table.
 237             (Default value = 0xFFFFFFFF)
 238         :param miss_next_index: Index of miss table.
 239             (Default value = 0xFFFFFFFF)
 240         :param current_data_flag: Option to use current node's packet payload
 241             as the starting point from where packets are classified.
 242             This option is only valid for L2/L3 input ACL for now.
 243             0: by default, classify data from the buffer's start location
 244             1: classify packets from VPP node's current data pointer.
 245         :param current_data_offset: A signed value to shift the start location
 246             of the packet to be classified.
 247             For example, if input IP ACL node is used, L2 header's first byte
 248             can be accessible by configuring current_data_offset to -14
 249             if there is no vlan tag.
 250             This is valid only if current_data_flag is set to 1.
 251             (Default value = 0)
 252         :type node: dict
 253         :type is_add: int
 254         :type mask: str
 255         :type match_n_vectors: int
 256         :type table_index: int
 257         :type nbuckets: int
 258         :type memory_size: int
 259         :type skip_n_vectors: int
 260         :type next_table_index: int
 261         :type miss_next_index: int
 262         :type current_data_flag: int
 263         :type current_data_offset: int
 264         :returns: (table_index, skip_n, match_n)
 265             table_index: Classify table index.
 266             skip_n: Number of skip vectors.
 267             match_n: Number of match vectors.
 268         :rtype: tuple(int, int, int)
 269         """
 270         mask_len = ((len(mask) - 1) / 16 + 1) * 16
 271         mask = mask + '\0' * (mask_len - len(mask))
 272
 273         args = dict(
 274             is_add=is_add,
 275             table_index=table_index,
 276             nbuckets=nbuckets,
 277             memory_size=memory_size,
 278             skip_n_vectors=skip_n_vectors,
 279             match_n_vectors=match_n_vectors,
 280             next_table_index=next_table_index,
 281             miss_next_index=miss_next_index,
 282             current_data_flag=current_data_flag,
 283             current_data_offset=current_data_offset,
 284             mask_len=mask_len,
 285             mask=mask
 286         )
 287
 288         cmd = 'classify_add_del_table'
 289         err_msg = "Failed to create a classify table on host {host}".format(
 290             host=node['host'])
 291
 292         with PapiExecutor(node) as papi_exec:
 293             data = papi_exec.add(cmd, **args).get_replies(err_msg).\
 294                 verify_reply(err_msg=err_msg)
 295
 296         return int(data["new_table_index"]), int(data["skip_n_vectors"]),\
 297             int(data["match_n_vectors"])
 298
 299     @staticmethod
 300     def _classify_add_del_session(node, is_add, table_index, match,
 301                                   opaque_index=0xFFFFFFFF,
 302                                   hit_next_index=0xFFFFFFFF, advance=0,
 303                                   action=0, metadata=0):
 304         """Add or delete a classify session.
 305
 306         :param node: VPP node to create classify session.
 307         :param is_add: If 1 the session is added, if 0 the session is deleted.
 308         :param table_index: Index of the table to add/del the session.
 309         :param match: For add, match value for session, required, needs to
 310             include bytes in front with length of skip_n_vectors of target table
 311             times sizeof (u32x4) (values of those bytes will be ignored).
 312         :param opaque_index: For add, opaque_index of new session.
 313             (Default value = 0xFFFFFFFF)
 314         :param hit_next_index: For add, hit_next_index of new session.
 315             (Default value = 0xFFFFFFFF)
 316         :param advance: For add, advance value for session. (Default value = 0)
 317         :param action: 0: No action (by default) metadata is not used.
 318             1: Classified IP packets will be looked up from the specified ipv4
 319                fib table (configured by metadata as VRF id).
 320                Only valid for L3 input ACL node
 321             2: Classified IP packets will be looked up from the specified ipv6
 322                fib table (configured by metadata as VRF id).
 323                Only valid for L3 input ACL node
 324             3: Classified packet will be steered to source routig policy of
 325                given index (in metadata).
 326                This is only valid for IPv6 packets redirected to a source
 327                routing node.
 328         :param metadata: Valid only if action != 0
 329             VRF id if action is 1 or 2. SR policy index if action is 3.
 330             (Default value = 0)
 331         :type node: dict
 332         :type is_add: int
 333         :type table_index: int
 334         :type match: str
 335         :type opaque_index: int
 336         :type hit_next_index: int
 337         :type advance: int
 338         :type action: int
 339         :type metadata: int
 340         """
 341
 342         match_len = ((len(match) - 1) / 16 + 1) * 16
 343         match = match + '\0' * (match_len - len(match))
 344         args = dict(
 345             is_add=is_add,
 346             table_index=table_index,
 347             hit_next_index=hit_next_index,
 348             opaque_index=opaque_index,
 349             advance=advance,
 350             action=action,
 351             metadata=metadata,
 352             match_len=match_len,
 353             match=match
 354         )
 355         cmd = 'classify_add_del_session'
 356         err_msg = "Failed to create a classify session on host {host}".format(
 357             host=node['host'])
 358
 359         with PapiExecutor(node) as papi_exec:
 360             papi_exec.add(cmd, **args).get_replies(err_msg). \
 361                 verify_reply(err_msg=err_msg)
 362
 363     @staticmethod
 364     def _macip_acl_add(node, rules, tag=""):
 365         """Add MACIP ACL.
 366
 367         :param node: VPP node to add MACIP ACL.
 368         :param rules: List of rules for given ACL.
 369         :param tag: ACL tag.
 370         :type node: dict
 371         :type rules: list
 372         :type tag: str
 373         """
 374         cmd = "macip_acl_add"
 375         args = dict(
 376             r=rules,
 377             count=len(rules),
 378             tag=tag
 379         )
 380
 381         err_msg = "Failed to create a classify session on host {host}".format(
 382             host=node['host'])
 383
 384         with PapiExecutor(node) as papi_exec:
 385             papi_exec.add(cmd, **args).get_replies(err_msg). \
 386                 verify_reply(err_msg=err_msg)
 387
 388     @staticmethod
 389     def _acl_interface_set_acl_list(node, sw_if_index, acl_type, acls):
 390         """Set ACL list for interface.
 391
 392         :param node: VPP node to set ACL list for interface.
 393         :param sw_if_index: sw_if_index of the used interface.
 394         :param acl_type: Type of ACL(s) - input or output.
 395         :param acls: List of ACLs.
 396         :type node: dict
 397         :type sw_if_index: int
 398         :type acl_type: str
 399         :type acls: list
 400         """
 401         cmd = "acl_interface_set_acl_list"
 402         n_input = len(acls) if acl_type == "input" else 0
 403         args = dict(
 404             sw_if_index=sw_if_index,
 405             acls=acls,
 406             n_input=n_input,
 407             count=len(acls)
 408         )
 409
 410         err_msg = "Failed to set acl list for interface {idx} on host {host}".\
 411             format(idx=sw_if_index, host=node['host'])
 412
 413         with PapiExecutor(node) as papi_exec:
 414             papi_exec.add(cmd, **args).get_replies(err_msg). \
 415                 verify_reply(err_msg=err_msg)
 416
 417     @staticmethod
 418     def _acl_add_replace(node, acl_idx, rules, tag=""):
 419         """ Add/replace ACLs.
 420
 421         :param node: VPP node to add MACIP ACL.
 422         :param acl_idx: ACL index.
 423         :param rules: List of rules for given ACL.
 424         :param tag: ACL tag.
 425         :type node: dict
 426         :type acl_idx: int
 427         :type rules: list
 428         :type tag: str
 429         """
 430         cmd = "acl_add_replace"
 431         args = dict(
 432             tag=tag,
 433             acl_index=4294967295 if acl_idx is None else acl_idx,
 434             count=len(rules),
 435             r=rules
 436         )
 437
 438         err_msg = "Failed to add/replace acls on host {host}".format(
 439             host=node['host'])
 440
 441         with PapiExecutor(node) as papi_exec:
 442             papi_exec.add(cmd, **args).get_replies(err_msg). \
 443                 verify_reply(err_msg=err_msg)
 444
 445     @staticmethod
 446     def vpp_creates_classify_table_l3(node, ip_version, direction, ip_addr):
 447         """Create classify table for IP address filtering.
 448
 449         :param node: VPP node to create classify table.
 450         :param ip_version: Version of IP protocol.
 451         :param direction: Direction of traffic - src/dst.
 452         :param ip_addr: IPv4 or Ipv6 (depending on the parameter 'ip_version')
 453             address.
 454         :type node: dict
 455         :type ip_version: str
 456         :type direction: str
 457         :type ip_addr: str
 458         :returns: (table_index, skip_n, match_n)
 459             table_index: Classify table index.
 460             skip_n: Number of skip vectors.
 461             match_n: Number of match vectors.
 462         :rtype: tuple(int, int, int)
 463         :raises ValueError: If the parameters 'ip_version' or 'direction' have
 464             incorrect values.
 465         """
 466         mask_f = dict(
 467             ip4=Classify._build_ip_mask,
 468             ip6=Classify._build_ip6_mask
 469         )
 470         if ip_version == "ip4" or ip_version == "ip6":
 471             ip_addr = binascii.hexlify(ip_address(unicode(ip_addr)).packed)
 472         else:
 473             raise ValueError("IP version {ver} is not supported.".
 474                              format(ver=ip_version))
 475
 476         if direction == "src":
 477             mask = mask_f[ip_version](src_ip=ip_addr)
 478         elif direction == "dst":
 479             mask = mask_f[ip_version](dst_ip=ip_addr)
 480         else:
 481             raise ValueError("Direction {dir} is not supported.".
 482                              format(dir=direction))
 483
 484         return Classify._classify_add_del_table(
 485             node,
 486             is_add=1,
 487             mask=binascii.unhexlify(mask),
 488             match_n_vectors=(len(mask) - 1) // 32 + 1
 489         )
 490
 491     @staticmethod
 492     def vpp_creates_classify_table_l2(node, direction, mac=""):
 493         """Create classify table for MAC address filtering.
 494
 495         :param node: VPP node to create classify table.
 496         :param direction: Direction of traffic - src/dst.
 497         :param mac: Source or destination (depending on the parameter
 498             'direction') MAC address.
 499         :type node: dict
 500         :type direction: str
 501         :type mac: str
 502         :returns: (table_index, skip_n, match_n)
 503             table_index: Classify table index.
 504             skip_n: Number of skip vectors.
 505             match_n: Number of match vectors.
 506         :rtype: tuple(int, int, int)
 507         :raises ValueError: If the parameter 'direction' has incorrect value.
 508         """
 509         if direction == "src":
 510             mask = Classify._build_mac_mask(src_mac=mac)
 511         elif direction == "dst":
 512             mask = Classify._build_mac_mask(dst_mac=mac)
 513         else:
 514             raise ValueError("Direction {dir} is not supported.".
 515                              format(dir=direction))
 516
 517         return Classify._classify_add_del_table(
 518             node,
 519             is_add=1,
 520             mask=binascii.unhexlify(mask),
 521             match_n_vectors=(len(mask) - 1) // 32 + 1
 522         )
 523
 524     @staticmethod
 525     def vpp_creates_classify_table_hex(node, hex_mask):
 526         """Create classify table with hex mask.
 527
 528         :param node: VPP node to create classify table based on hex mask.
 529         :param hex_mask: Classify hex mask.
 530         :type node: dict
 531         :type hex_mask: str
 532         :returns: (table_index, skip_n, match_n)
 533             table_index: Classify table index.
 534             skip_n: Number of skip vectors.
 535             match_n: Number of match vectors.
 536         :rtype: tuple(int, int, int)
 537         """
 538         return Classify._classify_add_del_table(
 539             node,
 540             is_add=1,
 541             mask=binascii.unhexlify(hex_mask),
 542             match_n_vectors=(len(hex_mask) - 1) // 32 + 1
 543         )
 544
 545     @staticmethod
 546     def vpp_configures_classify_session_l3(node, acl_method, table_index,
 547                                            ip_version, direction, address):
 548         """Configuration of classify session for IP address filtering.
 549
 550         :param node: VPP node to setup classify session.
 551         :param acl_method: ACL method - deny/permit.
 552         :param table_index: Classify table index.
 553         :param ip_version: Version of IP protocol.
 554         :param direction: Direction of traffic - src/dst.
 555         :param address: IPv4 or IPv6 address.
 556         :type node: dict
 557         :type acl_method: str
 558         :type table_index: int
 559         :type ip_version: str
 560         :type direction: str
 561         :type address: str
 562         :raises ValueError: If the parameter 'direction' has incorrect value.
 563         """
 564         match_f = dict(
 565             ip4=Classify._build_ip_match,
 566             ip6=Classify._build_ip6_match
 567         )
 568         if direction == "src":
 569             match = match_f[ip_version](src_ip=address)
 570         elif direction == "dst":
 571             match = match_f[ip_version](dst_ip=address)
 572         else:
 573             raise ValueError("Direction {dir} is not supported.".
 574                              format(dir=direction))
 575         action = dict(
 576             permit=0,
 577             deny=1
 578         )
 579         Classify._classify_add_del_session(
 580             node,
 581             is_add=1,
 582             table_index=table_index,
 583             match=binascii.unhexlify(match),
 584             action=action[acl_method])
 585
 586     @staticmethod
 587     def vpp_configures_classify_session_l2(node, acl_method, table_index,
 588                                            direction, address):
 589         """Configuration of classify session for MAC address filtering.
 590
 591         :param node: VPP node to setup classify session.
 592         :param acl_method: ACL method - deny/permit.
 593         :param table_index: Classify table index.
 594         :param direction: Direction of traffic - src/dst.
 595         :param address: MAC address.
 596         :type node: dict
 597         :type acl_method: str
 598         :type table_index: int
 599         :type direction: str
 600         :type address: str
 601         :raises ValueError: If the parameter 'direction' has incorrect value.
 602         """
 603         if direction == "src":
 604             match = Classify._build_mac_match(src_mac=address)
 605         elif direction == "dst":
 606             match = Classify._build_mac_match(dst_mac=address)
 607         else:
 608             raise ValueError("Direction {dir} is not supported.".
 609                              format(dir=direction))
 610         action = dict(
 611             permit=0,
 612             deny=1
 613         )
 614         Classify._classify_add_del_session(
 615             node,
 616             is_add=1,
 617             table_index=table_index,
 618             match=binascii.unhexlify(match),
 619             action=action[acl_method])
 620
 621     @staticmethod
 622     def vpp_configures_classify_session_hex(node, acl_method, table_index,
 623                                             hex_value):
 624         """Configuration of classify session with hex value.
 625
 626         :param node: VPP node to setup classify session.
 627         :param acl_method: ACL method - deny/permit.
 628         :param table_index: Classify table index.
 629         :param hex_value: Classify hex value.
 630         :type node: dict
 631         :type acl_method: str
 632         :type table_index: int
 633         :type hex_value: str
 634         """
 635         action = dict(
 636             permit=0,
 637             deny=1
 638         )
 639         Classify._classify_add_del_session(
 640             node,
 641             is_add=1,
 642             table_index=table_index,
 643             match=binascii.unhexlify(hex_value),
 644             action=action[acl_method])
 645
 646     @staticmethod
 647     def compute_classify_hex_mask(ip_version, protocol, direction):
 648         """Compute classify hex mask for TCP or UDP packet matching.
 649
 650         :param ip_version: Version of IP protocol.
 651         :param protocol: Type of protocol.
 652         :param direction: Traffic direction.
 653         :type ip_version: str
 654         :type protocol: str
 655         :type direction: str
 656         :returns: Classify hex mask.
 657         :rtype: str
 658         :raises ValueError: If protocol is not TCP or UDP.
 659         :raises ValueError: If direction is not source or destination or
 660             source + destination.
 661         """
 662         if protocol in ('TCP', 'UDP'):
 663             base_mask = Classify._compute_base_mask(ip_version)
 664
 665             if direction == 'source':
 666                 return base_mask + 'FFFF0000'
 667             elif direction == 'destination':
 668                 return base_mask + '0000FFFF'
 669             elif direction == 'source + destination':
 670                 return base_mask + 'FFFFFFFF'
 671             else:
 672                 raise ValueError("Invalid direction!")
 673         else:
 674             raise ValueError("Invalid protocol!")
 675
 676     @staticmethod
 677     def compute_classify_hex_value(hex_mask, source_port, destination_port):
 678         """Compute classify hex value for TCP or UDP packet matching.
 679
 680         :param hex_mask: Classify hex mask.
 681         :param source_port: Source TCP/UDP port.
 682         :param destination_port: Destination TCP/UDP port.
 683         :type hex_mask: str
 684         :type source_port: str
 685         :type destination_port: str
 686         :returns: Classify hex value.
 687         :rtype: str
 688         """
 689         source_port_hex = Classify._port_convert(source_port)
 690         destination_port_hex = Classify._port_convert(destination_port)
 691
 692         return hex_mask[:-8] + source_port_hex + destination_port_hex
 693
 694     @staticmethod
 695     def _port_convert(port):
 696         """Convert port number for classify hex table format.
 697
 698         :param port: TCP/UDP port number.
 699         :type port: str
 700         :returns: TCP/UDP port number in 4-digit hexadecimal format.
 701         :rtype: str
 702         """
 703         return '{0:04x}'.format(int(port))
 704
 705     @staticmethod
 706     def _compute_base_mask(ip_version):
 707         """Compute base classify hex mask based on IP version.
 708
 709         :param ip_version: Version of IP protocol.
 710         :type ip_version: str
 711         :returns: Base hex mask.
 712         :rtype: str
 713         """
 714         if ip_version == 'ip4':
 715             return 68 * '0'
 716             # base value of classify hex table for IPv4 TCP/UDP ports
 717         elif ip_version == 'ip6':
 718             return 108 * '0'
 719             # base value of classify hex table for IPv6 TCP/UDP ports
 720         else:
 721             raise ValueError("Invalid IP version!")
 722
 723     @staticmethod
 724     def get_classify_table_data(node, table_index):
 725         """Retrieve settings for classify table by ID.
 726
 727         :param node: VPP node to retrieve classify data from.
 728         :param table_index: Index of a specific classify table.
 729         :type node: dict
 730         :type table_index: int
 731         :returns: Classify table settings.
 732         :rtype: dict
 733         """
 734         cmd = 'classify_table_info'
 735         err_msg = "Failed to get 'classify_table_info' on host {host}".format(
 736             host=node['host'])
 737         args = dict(
 738             table_id=int(table_index)
 739         )
 740         with PapiExecutor(node) as papi_exec:
 741             data = papi_exec.add(cmd, **args).get_replies(err_msg).\
 742                 verify_reply(err_msg=err_msg)
 743
 744         return data
 745
 746     @staticmethod
 747     def get_classify_session_data(node, table_index):
 748         """Retrieve settings for all classify sessions in a table.
 749
 750         :param node: VPP node to retrieve classify data from.
 751         :param table_index: Index of a classify table.
 752         :type node: dict
 753         :type table_index: int
 754         :returns: List of classify session settings.
 755         :rtype: list or dict
 756         """
 757         args = dict(
 758             table_id=int(table_index)
 759         )
 760         with PapiExecutor(node) as papi_exec:
 761             dump = papi_exec.add("classify_session_dump", **args).\
 762                 get_dump().reply[0]["api_reply"]["classify_session_details"]
 763
 764         return dump
 765
 766     @staticmethod
 767     def vpp_log_plugin_acl_settings(node):
 768         """Retrieve configured settings from the ACL plugin and write to robot
 769         log.
 770
 771         :param node: VPP node.
 772         :type node: dict
 773         """
 774         PapiExecutor.dump_and_log(node, ["acl_dump", ])
 775
 776     @staticmethod
 777     def vpp_log_plugin_acl_interface_assignment(node):
 778         """Retrieve interface assignment from the ACL plugin and write to robot
 779         log.
 780
 781         :param node: VPP node.
 782         :type node: dict
 783         """
 784         PapiExecutor.dump_and_log(node, ["acl_interface_list_dump", ])
 785
 786     @staticmethod
 787     def set_acl_list_for_interface(node, interface, acl_type, acl_idx=None):
 788         """Set the list of input or output ACLs applied to the interface. It
 789         unapplies any previously applied ACLs.
 790
 791         :param node: VPP node to set ACL on.
 792         :param interface: Interface name or sw_if_index.
 793         :param acl_type: Type of ACL(s) - input or output.
 794         :param acl_idx: Index(ies) of ACLs to be applied on the interface.
 795         :type node: dict
 796         :type interface: str or int
 797         :type acl_type: str
 798         :type acl_idx: list
 799         """
 800         if isinstance(interface, basestring):
 801             sw_if_index = Topology.get_interface_sw_index(node, interface)
 802         else:
 803             sw_if_index = int(interface)
 804
 805         acls = acl_idx if isinstance(acl_idx, list) else list()
 806
 807         Classify._acl_interface_set_acl_list(node=node,
 808                                              sw_if_index=sw_if_index,
 809                                              acl_type=acl_type,
 810                                              acls=acls)
 811
 812     @staticmethod
 813     def add_replace_acl_multi_entries(node, acl_idx=None, rules=None):
 814         """Add a new ACL or replace the existing one. To replace an existing
 815         ACL, pass the ID of this ACL.
 816
 817         :param node: VPP node to set ACL on.
 818         :param acl_idx: ID of ACL. (Optional)
 819         :param rules: Required rules. (Optional)
 820         :type node: dict
 821         :type acl_idx: int
 822         :type rules: str
 823         """
 824         reg_ex_src_ip = re.compile(r'(src [0-9a-fA-F.:/\d{1,2}]*)')
 825         reg_ex_dst_ip = re.compile(r'(dst [0-9a-fA-F.:/\d{1,2}]*)')
 826         reg_ex_sport = re.compile(r'(sport \d{1,5})')
 827         reg_ex_dport = re.compile(r'(dport \d{1,5})')
 828
 829         acl_rules = list()
 830         for rule in rules.split(", "):
 831             acl_rule = dict()
 832             acl_rule["is_permit"] = 1 if "permit" in rule else 0
 833             acl_rule["is_ipv6"] = 1 if "ipv6" in rule else 0
 834
 835             groups = re.search(reg_ex_src_ip, rule)
 836             if groups:
 837                 grp = groups.group(1).split(' ')[1].split('/')
 838                 acl_rule["src_ip_addr"] = ip_address(unicode(grp[0])).packed
 839                 acl_rule["src_ip_prefix_len"] = int(grp[1])
 840
 841             groups = re.search(reg_ex_dst_ip, rule)
 842             if groups:
 843                 grp = groups.group(1).split(' ')[1].split('/')
 844                 acl_rule["dst_ip_addr"] = ip_address(unicode(grp[0])).packed
 845                 acl_rule["dst_ip_prefix_len"] = int(grp[1])
 846
 847             groups = re.search(reg_ex_sport, rule)
 848             if groups:
 849                 port = int(groups.group(1).split(' ')[1])
 850                 acl_rule["srcport_or_icmptype_first"] = port
 851                 acl_rule["srcport_or_icmptype_last"] = port
 852
 853             groups = re.search(reg_ex_dport, rule)
 854             if groups:
 855                 port = int(groups.group(1).split(' ')[1])
 856                 acl_rule["dstport_or_icmpcode_first"] = port
 857                 acl_rule["dstport_or_icmpcode_last"] = port
 858
 859             acl_rule["proto"] = 0
 860
 861             acl_rules.append(acl_rule)
 862
 863         Classify._acl_add_replace(node, acl_idx=acl_idx, rules=acl_rules)
 864
 865     @staticmethod
 866     def add_macip_acl_multi_entries(node, rules=""):
 867         """Add a new MACIP ACL.
 868
 869         :param node: VPP node to set MACIP ACL on.
 870         :param rules: Required MACIP rules.
 871         :type node: dict
 872         :type rules: str
 873         """
 874         reg_ex_ip = re.compile(r'(ip [0-9a-fA-F.:/\d{1,2}]*)')
 875         reg_ex_mac = re.compile(r'(mac \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)')
 876         reg_ex_mask = re.compile(r'(mask \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)')
 877
 878         acl_rules = list()
 879         for rule in rules.split(", "):
 880             acl_rule = dict()
 881             acl_rule["is_permit"] = 1 if "permit" in rule else 0
 882             acl_rule["is_ipv6"] = 1 if "ipv6" in rule else 0
 883
 884             groups = re.search(reg_ex_mac, rule)
 885             if groups:
 886                 mac = groups.group(1).split(' ')[1].replace(':', '')
 887                 acl_rule["src_mac"] = unicode(mac)
 888
 889             groups = re.search(reg_ex_mask, rule)
 890             if groups:
 891                 mask = groups.group(1).split(' ')[1].replace(':', '')
 892                 acl_rule["src_mac_mask"] = unicode(mask)
 893
 894             groups = re.search(reg_ex_ip, rule)
 895             if groups:
 896                 grp = groups.group(1).split(' ')[1].split('/')
 897                 acl_rule["src_ip_addr"] = ip_address(unicode(grp[0])).packed
 898                 acl_rule["src_ip_prefix_len"] = int(grp[1])
 899
 900             acl_rules.append(acl_rule)
 901
 902         Classify._macip_acl_add(node=node, rules=acl_rules)
 903
 904     @staticmethod
 905     def vpp_log_macip_acl_settings(node):
 906         """Retrieve configured MACIP settings from the ACL plugin and write to
 907         robot log.
 908
 909         :param node: VPP node.
 910         :type node: dict
 911         """
 912         PapiExecutor.dump_and_log(node, ["macip_acl_dump", ])
 913
 914     @staticmethod
 915     def add_del_macip_acl_interface(node, interface, action, acl_idx):
 916         """Apply/un-apply the MACIP ACL to/from a given interface.
 917
 918         :param node: VPP node to set MACIP ACL on.
 919         :param interface: Interface name or sw_if_index.
 920         :param action: Required action - add or del.
 921         :param acl_idx: ACL index to be applied on the interface.
 922         :type node: dict
 923         :type interface: str or int
 924         :type action: str
 925         :type acl_idx: str or int
 926         :raises RuntimeError: If unable to set MACIP ACL for the interface.
 927         """
 928         if isinstance(interface, basestring):
 929             sw_if_index = Topology.get_interface_sw_index(node, interface)
 930         else:
 931             sw_if_index = interface
 932
 933         is_add = 1 if action == "add" else 0
 934
 935         cmd = 'macip_acl_interface_add_del'
 936         err_msg = "Failed to get 'macip_acl_interface' on host {host}".format(
 937             host=node['host'])
 938         args = dict(
 939             is_add=is_add,
 940             sw_if_index=int(sw_if_index),
 941             acl_index=int(acl_idx)
 942         )
 943         with PapiExecutor(node) as papi_exec:
 944             papi_exec.add(cmd, **args).get_replies(err_msg).\
 945                 verify_reply(err_msg=err_msg)
 946
 947     @staticmethod
 948     def vpp_log_macip_acl_interface_assignment(node):
 949         """Get interface list and associated MACIP ACLs and write to robot log.
 950
 951         :param node: VPP node.
 952         :type node: dict
 953         """
 954         cmd = 'macip_acl_interface_get'
 955         err_msg = "Failed to get 'macip_acl_interface' on host {host}".format(
 956             host=node['host'])
 957         with PapiExecutor(node) as papi_exec:
 958             rpl = papi_exec.add(cmd).get_replies(err_msg).reply[0]["api_reply"]
 959         logger.info(rpl["macip_acl_interface_get_reply"])