JumpAvg: Fix string format
[csit.git] / resources / libraries / python / Classify.py
1 # Copyright (c) 2021 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 re
17
18 from ipaddress import ip_address
19
20 from robot.api import logger
21
22 from resources.libraries.python.Constants import Constants
23 from resources.libraries.python.InterfaceUtil import InterfaceUtil
24 from resources.libraries.python.IPUtil import IPUtil
25 from resources.libraries.python.PapiExecutor import PapiSocketExecutor
26
27
28 class Classify:
29     """Classify utilities."""
30
31     @staticmethod
32     def _build_mac_mask(dst_mac=u"", src_mac=u"", ether_type=u""):
33         """Build MAC ACL mask data in bytes format.
34
35         :param dst_mac: Source MAC address <0-ffffffffffff>.
36         :param src_mac: Destination MAC address <0-ffffffffffff>.
37         :param ether_type: Ethernet type <0-ffff>.
38         :type dst_mac: str
39         :type src_mac: str
40         :type ether_type: str
41         :returns MAC ACL mask in bytes format.
42         :rtype: bytes
43         """
44         return bytes.fromhex(
45             f"{dst_mac.replace(u':', u'')!s:0>12}"
46             f"{src_mac.replace(u':', u'')!s:0>12}"
47             f"{ether_type!s:0>4}"
48         ).rstrip(b'\0')
49
50     @staticmethod
51     def _build_ip_mask(
52             proto=u"", src_ip=u"", dst_ip=u"", src_port=u"", dst_port=u""):
53         """Build IP ACL mask data in bytes format.
54
55         :param proto: Protocol number <0-ff>.
56         :param src_ip: Source ip address <0-ffffffff>.
57         :param dst_ip: Destination ip address <0-ffffffff>.
58         :param src_port: Source port number <0-ffff>.
59         :param str dst_port: Destination port number <0-ffff>.
60         :type proto: str
61         :type src_ip: str
62         :type dst_ip: str
63         :type src_port: str
64         :type dst_port:src
65         :returns: IP mask in bytes format.
66         :rtype: bytes
67         """
68         return bytes.fromhex(
69             f"{proto!s:0>20}{src_ip!s:0>12}{dst_ip!s:0>8}{src_port!s:0>4}"
70             f"{dst_port!s:0>4}"
71         ).rstrip(b'\0')
72
73     @staticmethod
74     def _build_ip6_mask(
75             next_hdr=u"", src_ip=u"", dst_ip=u"", src_port=u"", dst_port=u""):
76         """Build IPv6 ACL mask data in bytes format.
77
78         :param next_hdr: Next header number <0-ff>.
79         :param src_ip: Source ip address <0-ffffffff>.
80         :param dst_ip: Destination ip address <0-ffffffff>.
81         :param src_port: Source port number <0-ffff>.
82         :param dst_port: Destination port number <0-ffff>.
83         :type next_hdr: str
84         :type src_ip: str
85         :type dst_ip: str
86         :type src_port: str
87         :type dst_port: str
88         :returns: IPv6 ACL mask in bytes format.
89         :rtype: bytes
90         """
91         return bytes.fromhex(
92             f"{next_hdr!s:0>14}{src_ip!s:0>34}{dst_ip!s:0>32}{src_port!s:0>4}"
93             f"{dst_port!s:0>4}"
94         ).rstrip(b'\0')
95
96     @staticmethod
97     def _build_mac_match(dst_mac=u"", src_mac=u"", ether_type=u""):
98         """Build MAC ACL match data in  bytes format.
99
100         :param dst_mac: Source MAC address <x:x:x:x:x:x>.
101         :param src_mac: Destination MAC address <x:x:x:x:x:x>.
102         :param ether_type: Ethernet type <0-ffff>.
103         :type dst_mac: str
104         :type src_mac: str
105         :type ether_type: str
106         :returns: MAC ACL match data in bytes format.
107         :rtype: bytes
108         """
109         return bytes.fromhex(
110             f"{dst_mac.replace(u':', u'')!s:0>12}"
111             f"{src_mac.replace(u':', u'')!s:0>12}"
112             f"{ether_type!s:0>4}"
113         ).rstrip(b'\0')
114
115     @staticmethod
116     def _build_ip_match(
117             proto=0, src_ip=4*b"\0", dst_ip=4*b"\0", src_port=0, dst_port=0):
118         """Build IP ACL match data in bytes format.
119
120         :param proto: Protocol number with valid option "x".
121         :param src_ip: Source ip address in packed format.
122         :param dst_ip: Destination ip address in packed format.
123         :param src_port: Source port number "x".
124         :param dst_port: Destination port number "x".
125         :type proto: int
126         :type src_ip: bytes
127         :type dst_ip: bytes
128         :type src_port: int
129         :type dst_port: int
130         :returns: IP ACL match data in byte-string format.
131         :rtype: str
132         """
133         return bytes.fromhex(
134             f"{hex(proto)[2:]!s:0>20}{src_ip.hex()!s:0>12}{dst_ip.hex()!s:0>8}"
135             f"{hex(src_port)[2:]!s:0>4}{hex(dst_port)[2:]!s:0>4}"
136         ).rstrip(b'\0')
137
138     @staticmethod
139     def _build_ip6_match(
140             next_hdr=0, src_ip=16*b"\0", dst_ip=16*b"\0", src_port=0,
141             dst_port=0):
142         """Build IPv6 ACL match data in byte-string format.
143
144         :param next_hdr: Next header number with valid option "x".
145         :param src_ip: Source ip6 address in packed format.
146         :param dst_ip: Destination ip6 address in packed format.
147         :param src_port: Source port number "x".
148         :param dst_port: Destination port number "x".
149         :type next_hdr: int
150         :type src_ip: bytes
151         :type dst_ip: bytes
152         :type src_port: int
153         :type dst_port: int
154         :returns: IPv6 ACL match data in bytes format.
155         :rtype: bytes
156         """
157         return bytes.fromhex(
158             f"{hex(next_hdr)[2:]!s:0>14}{src_ip.hex()!s:0>34}"
159             f"{dst_ip.hex()!s:0>32}{hex(src_port)[2:]!s:0>4}"
160             f"{hex(dst_port)[2:]!s:0>4}"
161         ).rstrip(b'\0')
162
163     @staticmethod
164     def _classify_add_del_table(
165             node, is_add, mask, match_n_vectors=Constants.BITWISE_NON_ZERO,
166             table_index=Constants.BITWISE_NON_ZERO, nbuckets=2,
167             memory_size=2097152, skip_n_vectors=Constants.BITWISE_NON_ZERO,
168             next_table_index=Constants.BITWISE_NON_ZERO,
169             miss_next_index=Constants.BITWISE_NON_ZERO,
170             current_data_flag=0, current_data_offset=0):
171         """Add or delete a classify table.
172
173         :param node: VPP node to create classify table.
174         :param is_add: If True the table is added, if False table is deleted.
175         :param mask: ACL mask in hexstring format.
176         :param match_n_vectors: Number of vectors to match (Default value = ~0).
177         :param table_index: Index of the classify table. (Default value = ~0)
178         :param nbuckets: Number of buckets when adding a table.
179             (Default value = 2)
180         :param memory_size: Memory size when adding a table.
181             (Default value = 2097152)
182         :param skip_n_vectors: Number of skip vectors (Default value = ~0).
183         :param next_table_index: Index of next table. (Default value = ~0)
184         :param miss_next_index: Index of miss table. (Default value = ~0)
185         :param current_data_flag: Option to use current node's packet payload
186             as the starting point from where packets are classified.
187             This option is only valid for L2/L3 input ACL for now.
188             0: by default, classify data from the buffer's start location
189             1: classify packets from VPP node's current data pointer.
190         :param current_data_offset: A signed value to shift the start location
191             of the packet to be classified.
192             For example, if input IP ACL node is used, L2 header's first byte
193             can be accessible by configuring current_data_offset to -14
194             if there is no vlan tag.
195             This is valid only if current_data_flag is set to 1.
196             (Default value = 0)
197         :type node: dict
198         :type is_add: bool
199         :type mask: str
200         :type match_n_vectors: int
201         :type table_index: int
202         :type nbuckets: int
203         :type memory_size: int
204         :type skip_n_vectors: int
205         :type next_table_index: int
206         :type miss_next_index: int
207         :type current_data_flag: int
208         :type current_data_offset: int
209         :returns: (table_index, skip_n, match_n)
210             table_index: Classify table index.
211             skip_n: Number of skip vectors.
212             match_n: Number of match vectors.
213         :rtype: tuple(int, int, int)
214         """
215         cmd = u"classify_add_del_table"
216         args = dict(
217             is_add=is_add,
218             del_chain=False,
219             table_index=table_index,
220             nbuckets=nbuckets,
221             memory_size=memory_size,
222             skip_n_vectors=skip_n_vectors,
223             match_n_vectors=match_n_vectors,
224             next_table_index=next_table_index,
225             miss_next_index=miss_next_index,
226             current_data_flag=current_data_flag,
227             current_data_offset=current_data_offset,
228             mask_len=len(mask),
229             mask=mask
230         )
231         err_msg = f"Failed to create a classify table on host {node[u'host']}"
232
233         with PapiSocketExecutor(node) as papi_exec:
234             reply = papi_exec.add(cmd, **args).get_reply(err_msg)
235
236         return int(reply[u"new_table_index"]), int(reply[u"skip_n_vectors"]),\
237             int(reply[u"match_n_vectors"])
238
239     @staticmethod
240     def _classify_add_del_session(
241             node, is_add, table_index, match,
242             opaque_index=Constants.BITWISE_NON_ZERO,
243             hit_next_index=Constants.BITWISE_NON_ZERO, advance=0,
244             action=0, metadata=0):
245         """Add or delete a classify session.
246
247         :param node: VPP node to create classify session.
248         :param is_add: If True the session is added, if False the session
249             is deleted.
250         :param table_index: Index of the table to add/del the session.
251         :param match: For add, match value for session, required, needs to
252             include bytes in front with length of skip_n_vectors of target table
253             times sizeof (u32x4) (values of those bytes will be ignored).
254         :param opaque_index: For add, opaque_index of new session.
255             (Default value = ~0)
256         :param hit_next_index: For add, hit_next_index of new session.
257             (Default value = ~0)
258         :param advance: For add, advance value for session. (Default value = 0)
259         :param action: 0: No action (by default) metadata is not used.
260             1: Classified IP packets will be looked up from the specified ipv4
261             fib table (configured by metadata as VRF id).
262             Only valid for L3 input ACL node
263             2: Classified IP packets will be looked up from the specified ipv6
264             fib table (configured by metadata as VRF id).
265             Only valid for L3 input ACL node
266             3: Classified packet will be steered to source routing policy of
267             given index (in metadata).
268             This is only valid for IPv6 packets redirected to a source
269             routing node.
270         :param metadata: Valid only if action != 0. VRF id if action is 1 or 2.
271             SR policy index if action is 3. (Default value = 0)
272         :type node: dict
273         :type is_add: bool
274         :type table_index: int
275         :type match: bytes
276         :type opaque_index: int
277         :type hit_next_index: int
278         :type advance: int
279         :type action: int
280         :type metadata: int
281         """
282         cmd = u"classify_add_del_session"
283         args = dict(
284             is_add=is_add,
285             table_index=table_index,
286             hit_next_index=hit_next_index,
287             opaque_index=opaque_index,
288             advance=advance,
289             action=action,
290             metadata=metadata,
291             match_len=len(match),
292             match=match
293         )
294         err_msg = f"Failed to create a classify session on host {node[u'host']}"
295
296         with PapiSocketExecutor(node) as papi_exec:
297             papi_exec.add(cmd, **args).get_reply(err_msg)
298
299     @staticmethod
300     def _macip_acl_add(node, rules, tag=""):
301         """Add MACIP ACL.
302
303         :param node: VPP node to add MACIP ACL.
304         :param rules: List of rules for given ACL.
305         :param tag: ACL tag.
306         :type node: dict
307         :type rules: list
308         :type tag: str
309         """
310         cmd = u"macip_acl_add"
311         args = dict(
312             r=rules,
313             count=len(rules),
314             tag=tag
315         )
316
317         err_msg = f"Failed to add MACIP ACL on host {node[u'host']}"
318
319         with PapiSocketExecutor(node) as papi_exec:
320             papi_exec.add(cmd, **args).get_reply(err_msg)
321
322     @staticmethod
323     def _acl_interface_set_acl_list(node, sw_if_index, acl_type, acls):
324         """Set ACL list for interface.
325
326         :param node: VPP node to set ACL list for interface.
327         :param sw_if_index: sw_if_index of the used interface.
328         :param acl_type: Type of ACL(s) - input or output.
329         :param acls: List of ACLs.
330         :type node: dict
331         :type sw_if_index: int
332         :type acl_type: str
333         :type acls: list
334         """
335         cmd = u"acl_interface_set_acl_list"
336         args = dict(
337             sw_if_index=sw_if_index,
338             acls=acls,
339             n_input=len(acls) if acl_type == u"input" else 0,
340             count=len(acls)
341         )
342
343         err_msg = f"Failed to set acl list for interface {sw_if_index} " \
344             f"on host {node[u'host']}"
345
346         with PapiSocketExecutor(node) as papi_exec:
347             papi_exec.add(cmd, **args).get_reply(err_msg)
348
349     @staticmethod
350     def _acl_add_replace(node, acl_idx, rules, tag=""):
351         """ Add/replace ACLs.
352
353         :param node: VPP node to add MACIP ACL.
354         :param acl_idx: ACL index.
355         :param rules: List of rules for given ACL.
356         :param tag: ACL tag.
357         :type node: dict
358         :type acl_idx: int
359         :type rules: list
360         :type tag: str
361         """
362         cmd = u"acl_add_replace"
363         args = dict(
364             tag=tag,
365             acl_index=4294967295 if acl_idx is None else acl_idx,
366             count=len(rules),
367             r=rules
368         )
369
370         err_msg = f"Failed to add/replace ACLs on host {node[u'host']}"
371
372         with PapiSocketExecutor(node) as papi_exec:
373             papi_exec.add(cmd, **args).get_reply(err_msg)
374
375     @staticmethod
376     def vpp_creates_classify_table_l3(node, ip_version, direction, netmask):
377         """Create classify table for IP address filtering.
378
379         :param node: VPP node to create classify table.
380         :param ip_version: Version of IP protocol.
381         :param direction: Direction of traffic - src/dst.
382         :param netmask: IPv4 or Ipv6 (depending on the parameter 'ip_version')
383             netmask (decimal, e.g. 255.255.255.255).
384         :type node: dict
385         :type ip_version: str
386         :type direction: str
387         :type netmask: str
388         :returns: (table_index, skip_n, match_n)
389             table_index: Classify table index.
390             skip_n: Number of skip vectors.
391             match_n: Number of match vectors.
392         :rtype: tuple(int, int, int)
393         :raises ValueError: If the parameters 'ip_version' or 'direction' have
394             incorrect values.
395         """
396         mask_f = dict(
397             ip4=Classify._build_ip_mask,
398             ip6=Classify._build_ip6_mask
399         )
400
401         if ip_version in (u"ip4", u"ip6"):
402             netmask = ip_address(netmask).packed
403         else:
404             raise ValueError(f"IP version {ip_version} is not supported.")
405
406         if direction == u"src":
407             mask = mask_f[ip_version](src_ip=netmask.hex())
408         elif direction == u"dst":
409             mask = mask_f[ip_version](dst_ip=netmask.hex())
410         else:
411             raise ValueError(f"Direction {direction} is not supported.")
412
413         # Add l2 ethernet header to mask
414         mask = 14 * b'\0' + mask
415
416         # Get index of the first significant mask octet
417         i = len(mask) - len(mask.lstrip(b'\0'))
418
419         # Compute skip_n parameter
420         skip_n = i // 16
421         # Remove octets to be skipped from the mask
422         mask = mask[skip_n*16:]
423         # Pad mask to an even multiple of the vector size
424         mask = mask + (16 - len(mask) % 16 if len(mask) % 16 else 0) * b'\0'
425         # Compute match_n parameter
426         match_n = len(mask) // 16
427
428         return Classify._classify_add_del_table(
429             node,
430             is_add=True,
431             mask=mask,
432             match_n_vectors=match_n,
433             skip_n_vectors=skip_n
434         )
435
436     @staticmethod
437     def vpp_configures_classify_session_l3(
438             node, acl_method, table_index, skip_n, match_n, ip_version,
439             direction, address, hit_next_index=None,
440             opaque_index=Constants.BITWISE_NON_ZERO, action=0, metadata=0):
441         """Configuration of classify session for IP address filtering.
442
443         :param node: VPP node to setup classify session.
444         :param acl_method: ACL method - deny/permit.
445         :param table_index: Classify table index.
446         :param skip_n: Number of skip vectors.
447         :param match_n: Number of vectors to match.
448         :param ip_version: Version of IP protocol.
449         :param direction: Direction of traffic - src/dst.
450         :param address: IPv4 or IPv6 address.
451         :param hit_next_index: hit_next_index of new session.
452             (Default value = None)
453         :param opaque_index: opaque_index of new session. (Default value = ~0)
454         :param action: 0: No action (by default) metadata is not used.
455             1: Classified IP packets will be looked up from the specified ipv4
456             fib table (configured by metadata as VRF id).
457             Only valid for L3 input ACL node
458             2: Classified IP packets will be looked up from the specified ipv6
459             fib table (configured by metadata as VRF id).
460             Only valid for L3 input ACL node
461             3: Classified packet will be steered to source routing policy of
462             given index (in metadata).
463             This is only valid for IPv6 packets redirected to a source
464             routing node.
465         :param metadata: Valid only if action != 0. VRF id if action is 1 or 2.
466             SR policy index if action is 3. (Default value = 0)
467         :type node: dict
468         :type acl_method: str
469         :type table_index: int
470         :type skip_n: int
471         :type match_n: int
472         :type ip_version: str
473         :type direction: str
474         :type address: str
475         :type hit_next_index: int
476         :type opaque_index: int
477         :type action: int
478         :type metadata: int
479         :raises ValueError: If the parameter 'direction' has incorrect value.
480         """
481         match_f = dict(
482             ip4=Classify._build_ip_match,
483             ip6=Classify._build_ip6_match
484         )
485         acl_hit_next_index = dict(
486             permit=Constants.BITWISE_NON_ZERO,
487             deny=0
488         )
489
490         if ip_version in (u"ip4", u"ip6"):
491             address = ip_address(address).packed
492         else:
493             raise ValueError(f"IP version {ip_version} is not supported.")
494
495         if direction == u"src":
496             match = match_f[ip_version](src_ip=address)
497         elif direction == u"dst":
498             match = match_f[ip_version](dst_ip=address)
499         else:
500             raise ValueError(f"Direction {direction} is not supported.")
501
502         # Prepend match with l2 ethernet header part
503         match = 14 * b'\0' + match
504
505         # Pad match to match skip_n_vector + match_n_vector size
506         match = match + ((match_n + skip_n) * 16 - len(match)
507                          if len(match) < (match_n + skip_n) * 16
508                          else 0) * b'\0'
509
510         Classify._classify_add_del_session(
511             node,
512             is_add=True,
513             table_index=table_index,
514             hit_next_index=hit_next_index if hit_next_index is not None
515             else acl_hit_next_index[acl_method],
516             opaque_index=opaque_index,
517             match=match,
518             action=action,
519             metadata=metadata
520         )
521
522     @staticmethod
523     def get_classify_table_data(node, table_index):
524         """Retrieve settings for classify table by ID.
525
526         :param node: VPP node to retrieve classify data from.
527         :param table_index: Index of a specific classify table.
528         :type node: dict
529         :type table_index: int
530         :returns: Classify table settings.
531         :rtype: dict
532         """
533         cmd = u"classify_table_info"
534         err_msg = f"Failed to get 'classify_table_info' on host {node[u'host']}"
535         args = dict(
536             table_id=int(table_index)
537         )
538         with PapiSocketExecutor(node) as papi_exec:
539             reply = papi_exec.add(cmd, **args).get_reply(err_msg)
540         return reply
541
542     @staticmethod
543     def get_classify_session_data(node, table_index):
544         """Retrieve settings for all classify sessions in a table.
545
546         :param node: VPP node to retrieve classify data from.
547         :param table_index: Index of a classify table.
548         :type node: dict
549         :type table_index: int
550         :returns: List of classify session settings.
551         :rtype: list or dict
552         """
553         cmd = u"classify_session_dump"
554         args = dict(
555             table_id=int(table_index)
556         )
557         with PapiSocketExecutor(node) as papi_exec:
558             details = papi_exec.add(cmd, **args).get_details()
559
560         return details
561
562     @staticmethod
563     def show_classify_tables_verbose(node):
564         """Show classify tables verbose.
565
566         :param node: Topology node.
567         :type node: dict
568         :returns: Classify tables verbose data.
569         :rtype: str
570         """
571         return PapiSocketExecutor.run_cli_cmd(
572             node, u"show classify tables verbose"
573         )
574
575     @staticmethod
576     def vpp_log_plugin_acl_settings(node):
577         """Retrieve configured settings from the ACL plugin and write to robot
578         log.
579
580         :param node: VPP node.
581         :type node: dict
582         """
583         PapiSocketExecutor.dump_and_log(node, [u"acl_dump", ])
584
585     @staticmethod
586     def vpp_log_plugin_acl_interface_assignment(node):
587         """Retrieve interface assignment from the ACL plugin and write to robot
588         log.
589
590         :param node: VPP node.
591         :type node: dict
592         """
593         PapiSocketExecutor.dump_and_log(node, [u"acl_interface_list_dump", ])
594
595     @staticmethod
596     def set_acl_list_for_interface(node, interface, acl_type, acl_idx=None):
597         """Set the list of input or output ACLs applied to the interface. It
598         unapplies any previously applied ACLs.
599
600         :param node: VPP node to set ACL on.
601         :param interface: Interface name or sw_if_index.
602         :param acl_type: Type of ACL(s) - input or output.
603         :param acl_idx: Index(ies) of ACLs to be applied on the interface.
604         :type node: dict
605         :type interface: str or int
606         :type acl_type: str
607         :type acl_idx: list
608         """
609         Classify._acl_interface_set_acl_list(
610             node=node,
611             sw_if_index=int(InterfaceUtil.get_interface_index(node, interface)),
612             acl_type=acl_type,
613             acls=acl_idx if isinstance(acl_idx, list) else list()
614         )
615
616     @staticmethod
617     def add_replace_acl_multi_entries(node, acl_idx=None, rules=None, tag=u""):
618         """Add a new ACL or replace the existing one. To replace an existing
619         ACL, pass the ID of this ACL.
620
621         :param node: VPP node to set ACL on.
622         :param acl_idx: ID of ACL. (Optional)
623         :param rules: Required rules. (Optional)
624         :param tag: ACL tag (Optional).
625         :type node: dict
626         :type acl_idx: int
627         :type rules: str
628         :type tag: str
629         """
630         reg_ex_src_ip = re.compile(r"(src [0-9a-fA-F.:/\d{1,2}]*)")
631         reg_ex_dst_ip = re.compile(r"(dst [0-9a-fA-F.:/\d{1,2}]*)")
632         reg_ex_sport = re.compile(r"(sport \d{1,5})")
633         reg_ex_dport = re.compile(r"(dport \d{1,5})")
634         reg_ex_proto = re.compile(r"(proto \d{1,5})")
635
636         acl_rules = list()
637         for rule in rules.split(u", "):
638             acl_rule = dict(
639                 is_permit=2 if u"permit+reflect" in rule
640                 else 1 if u"permit" in rule else 0,
641                 src_prefix=0,
642                 dst_prefix=0,
643                 proto=0,
644                 srcport_or_icmptype_first=0,
645                 srcport_or_icmptype_last=65535,
646                 dstport_or_icmpcode_first=0,
647                 dstport_or_icmpcode_last=65535,
648                 tcp_flags_mask=0,
649                 tcp_flags_value=0
650             )
651
652             groups = re.search(reg_ex_src_ip, rule)
653             if groups:
654                 grp = groups.group(1).split(u" ")[1].split(u"/")
655                 acl_rule[u"src_prefix"] = IPUtil.create_prefix_object(
656                     ip_address(grp[0]), int(grp[1])
657                 )
658
659             groups = re.search(reg_ex_dst_ip, rule)
660             if groups:
661                 grp = groups.group(1).split(u" ")[1].split(u"/")
662                 acl_rule[u"dst_prefix"] = IPUtil.create_prefix_object(
663                     ip_address(grp[0]), int(grp[1])
664                 )
665
666             groups = re.search(reg_ex_sport, rule)
667             if groups:
668                 port = int(groups.group(1).split(u" ")[1])
669                 acl_rule[u"srcport_or_icmptype_first"] = port
670                 acl_rule[u"srcport_or_icmptype_last"] = port
671
672             groups = re.search(reg_ex_dport, rule)
673             if groups:
674                 port = int(groups.group(1).split(u" ")[1])
675                 acl_rule[u"dstport_or_icmpcode_first"] = port
676                 acl_rule[u"dstport_or_icmpcode_last"] = port
677
678             groups = re.search(reg_ex_proto, rule)
679             if groups:
680                 proto = int(groups.group(1).split(' ')[1])
681                 acl_rule[u"proto"] = proto
682
683             acl_rules.append(acl_rule)
684
685         Classify._acl_add_replace(
686             node, acl_idx=acl_idx, rules=acl_rules, tag=tag
687         )
688
689     @staticmethod
690     def add_macip_acl_multi_entries(node, rules=u""):
691         """Add a new MACIP ACL.
692
693         :param node: VPP node to set MACIP ACL on.
694         :param rules: Required MACIP rules.
695         :type node: dict
696         :type rules: str
697         """
698         reg_ex_ip = re.compile(r"(ip [0-9a-fA-F.:/\d{1,2}]*)")
699         reg_ex_mac = re.compile(r"(mac \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)")
700         reg_ex_mask = re.compile(r"(mask \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)")
701
702         acl_rules = list()
703         for rule in rules.split(u", "):
704             acl_rule = dict(
705                 is_permit=2 if u"permit+reflect" in rule
706                 else 1 if u"permit" in rule else 0,
707                 src_mac=6*b'0',
708                 src_mac_mask=6*b'0',
709                 prefix=0
710             )
711
712             groups = re.search(reg_ex_mac, rule)
713             if groups:
714                 mac = groups.group(1).split(u" ")[1].replace(u":", u"")
715                 acl_rule[u"src_mac"] = bytes.fromhex(mac)
716
717             groups = re.search(reg_ex_mask, rule)
718             if groups:
719                 mask = groups.group(1).split(u" ")[1].replace(u":", u"")
720                 acl_rule[u"src_mac_mask"] = bytes.fromhex(mask)
721
722             groups = re.search(reg_ex_ip, rule)
723             if groups:
724                 grp = groups.group(1).split(u" ")[1].split(u"/")
725                 acl_rule[u"src_prefix"] = IPUtil.create_prefix_object(
726                     ip_address((grp[0])), int(grp[1])
727                 )
728
729             acl_rules.append(acl_rule)
730
731         Classify._macip_acl_add(node=node, rules=acl_rules)
732
733     @staticmethod
734     def vpp_log_macip_acl_settings(node):
735         """Retrieve configured MACIP settings from the ACL plugin and write to
736         robot log.
737
738         :param node: VPP node.
739         :type node: dict
740         """
741         PapiSocketExecutor.dump_and_log(node, [u"macip_acl_dump", ])
742
743     @staticmethod
744     def add_del_macip_acl_interface(node, interface, action, acl_idx):
745         """Apply/un-apply the MACIP ACL to/from a given interface.
746
747         :param node: VPP node to set MACIP ACL on.
748         :param interface: Interface name or sw_if_index.
749         :param action: Required action - add or del.
750         :param acl_idx: ACL index to be applied on the interface.
751         :type node: dict
752         :type interface: str or int
753         :type action: str
754         :type acl_idx: str or int
755         :raises RuntimeError: If unable to set MACIP ACL for the interface.
756         """
757         cmd = u"macip_acl_interface_add_del"
758         err_msg = f"Failed to get 'macip_acl_interface' on host {node[u'host']}"
759         args = dict(
760             is_add=bool(action == u"add"),
761             sw_if_index=int(InterfaceUtil.get_interface_index(node, interface)),
762             acl_index=int(acl_idx)
763         )
764         with PapiSocketExecutor(node) as papi_exec:
765             papi_exec.add(cmd, **args).get_reply(err_msg)
766
767     @staticmethod
768     def vpp_log_macip_acl_interface_assignment(node):
769         """Get interface list and associated MACIP ACLs and write to robot log.
770
771         :param node: VPP node.
772         :type node: dict
773         """
774         cmd = u"macip_acl_interface_get"
775         err_msg = f"Failed to get 'macip_acl_interface' on host {node[u'host']}"
776         with PapiSocketExecutor(node) as papi_exec:
777             reply = papi_exec.add(cmd).get_reply(err_msg)
778         logger.info(reply)