PapiExecutor always verifies
[csit.git] / 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             reply = papi_exec.add(cmd, **args).get_reply(err_msg)
294
295         return int(reply["new_table_index"]), int(reply["skip_n_vectors"]),\
296             int(reply["match_n_vectors"])
297
298     @staticmethod
299     def _classify_add_del_session(node, is_add, table_index, match,
300                                   opaque_index=0xFFFFFFFF,
301                                   hit_next_index=0xFFFFFFFF, advance=0,
302                                   action=0, metadata=0):
303         """Add or delete a classify session.
304
305         :param node: VPP node to create classify session.
306         :param is_add: If 1 the session is added, if 0 the session is deleted.
307         :param table_index: Index of the table to add/del the session.
308         :param match: For add, match value for session, required, needs to
309             include bytes in front with length of skip_n_vectors of target table
310             times sizeof (u32x4) (values of those bytes will be ignored).
311         :param opaque_index: For add, opaque_index of new session.
312             (Default value = 0xFFFFFFFF)
313         :param hit_next_index: For add, hit_next_index of new session.
314             (Default value = 0xFFFFFFFF)
315         :param advance: For add, advance value for session. (Default value = 0)
316         :param action: 0: No action (by default) metadata is not used.
317             1: Classified IP packets will be looked up from the specified ipv4
318                fib table (configured by metadata as VRF id).
319                Only valid for L3 input ACL node
320             2: Classified IP packets will be looked up from the specified ipv6
321                fib table (configured by metadata as VRF id).
322                Only valid for L3 input ACL node
323             3: Classified packet will be steered to source routig policy of
324                given index (in metadata).
325                This is only valid for IPv6 packets redirected to a source
326                routing node.
327         :param metadata: Valid only if action != 0
328             VRF id if action is 1 or 2. SR policy index if action is 3.
329             (Default value = 0)
330         :type node: dict
331         :type is_add: int
332         :type table_index: int
333         :type match: str
334         :type opaque_index: int
335         :type hit_next_index: int
336         :type advance: int
337         :type action: int
338         :type metadata: int
339         """
340
341         match_len = ((len(match) - 1) / 16 + 1) * 16
342         match = match + '\0' * (match_len - len(match))
343         args = dict(
344             is_add=is_add,
345             table_index=table_index,
346             hit_next_index=hit_next_index,
347             opaque_index=opaque_index,
348             advance=advance,
349             action=action,
350             metadata=metadata,
351             match_len=match_len,
352             match=match
353         )
354         cmd = 'classify_add_del_session'
355         err_msg = "Failed to create a classify session on host {host}".format(
356             host=node['host'])
357
358         with PapiExecutor(node) as papi_exec:
359             papi_exec.add(cmd, **args).get_reply(err_msg)
360
361     @staticmethod
362     def _macip_acl_add(node, rules, tag=""):
363         """Add MACIP ACL.
364
365         :param node: VPP node to add MACIP ACL.
366         :param rules: List of rules for given ACL.
367         :param tag: ACL tag.
368         :type node: dict
369         :type rules: list
370         :type tag: str
371         """
372         cmd = "macip_acl_add"
373         args = dict(
374             r=rules,
375             count=len(rules),
376             tag=tag
377         )
378
379         err_msg = "Failed to create a classify session on host {host}".format(
380             host=node['host'])
381
382         with PapiExecutor(node) as papi_exec:
383             papi_exec.add(cmd, **args).get_reply(err_msg)
384
385     @staticmethod
386     def _acl_interface_set_acl_list(node, sw_if_index, acl_type, acls):
387         """Set ACL list for interface.
388
389         :param node: VPP node to set ACL list for interface.
390         :param sw_if_index: sw_if_index of the used interface.
391         :param acl_type: Type of ACL(s) - input or output.
392         :param acls: List of ACLs.
393         :type node: dict
394         :type sw_if_index: int
395         :type acl_type: str
396         :type acls: list
397         """
398         cmd = "acl_interface_set_acl_list"
399         n_input = len(acls) if acl_type == "input" else 0
400         args = dict(
401             sw_if_index=sw_if_index,
402             acls=acls,
403             n_input=n_input,
404             count=len(acls)
405         )
406
407         err_msg = "Failed to set acl list for interface {idx} on host {host}".\
408             format(idx=sw_if_index, host=node['host'])
409
410         with PapiExecutor(node) as papi_exec:
411             papi_exec.add(cmd, **args).get_reply(err_msg)
412
413     @staticmethod
414     def _acl_add_replace(node, acl_idx, rules, tag=""):
415         """ Add/replace ACLs.
416
417         :param node: VPP node to add MACIP ACL.
418         :param acl_idx: ACL index.
419         :param rules: List of rules for given ACL.
420         :param tag: ACL tag.
421         :type node: dict
422         :type acl_idx: int
423         :type rules: list
424         :type tag: str
425         """
426         cmd = "acl_add_replace"
427         args = dict(
428             tag=tag,
429             acl_index=4294967295 if acl_idx is None else acl_idx,
430             count=len(rules),
431             r=rules
432         )
433
434         err_msg = "Failed to add/replace acls on host {host}".format(
435             host=node['host'])
436
437         with PapiExecutor(node) as papi_exec:
438             papi_exec.add(cmd, **args).get_reply(err_msg)
439
440     @staticmethod
441     def vpp_creates_classify_table_l3(node, ip_version, direction, ip_addr):
442         """Create classify table for IP address filtering.
443
444         :param node: VPP node to create classify table.
445         :param ip_version: Version of IP protocol.
446         :param direction: Direction of traffic - src/dst.
447         :param ip_addr: IPv4 or Ipv6 (depending on the parameter 'ip_version')
448             address.
449         :type node: dict
450         :type ip_version: str
451         :type direction: str
452         :type ip_addr: str
453         :returns: (table_index, skip_n, match_n)
454             table_index: Classify table index.
455             skip_n: Number of skip vectors.
456             match_n: Number of match vectors.
457         :rtype: tuple(int, int, int)
458         :raises ValueError: If the parameters 'ip_version' or 'direction' have
459             incorrect values.
460         """
461         mask_f = dict(
462             ip4=Classify._build_ip_mask,
463             ip6=Classify._build_ip6_mask
464         )
465         if ip_version == "ip4" or ip_version == "ip6":
466             ip_addr = binascii.hexlify(ip_address(unicode(ip_addr)).packed)
467         else:
468             raise ValueError("IP version {ver} is not supported.".
469                              format(ver=ip_version))
470
471         if direction == "src":
472             mask = mask_f[ip_version](src_ip=ip_addr)
473         elif direction == "dst":
474             mask = mask_f[ip_version](dst_ip=ip_addr)
475         else:
476             raise ValueError("Direction {dir} is not supported.".
477                              format(dir=direction))
478
479         return Classify._classify_add_del_table(
480             node,
481             is_add=1,
482             mask=binascii.unhexlify(mask),
483             match_n_vectors=(len(mask) - 1) // 32 + 1
484         )
485
486     @staticmethod
487     def vpp_creates_classify_table_l2(node, direction, mac=""):
488         """Create classify table for MAC address filtering.
489
490         :param node: VPP node to create classify table.
491         :param direction: Direction of traffic - src/dst.
492         :param mac: Source or destination (depending on the parameter
493             'direction') MAC address.
494         :type node: dict
495         :type direction: str
496         :type mac: str
497         :returns: (table_index, skip_n, match_n)
498             table_index: Classify table index.
499             skip_n: Number of skip vectors.
500             match_n: Number of match vectors.
501         :rtype: tuple(int, int, int)
502         :raises ValueError: If the parameter 'direction' has incorrect value.
503         """
504         if direction == "src":
505             mask = Classify._build_mac_mask(src_mac=mac)
506         elif direction == "dst":
507             mask = Classify._build_mac_mask(dst_mac=mac)
508         else:
509             raise ValueError("Direction {dir} is not supported.".
510                              format(dir=direction))
511
512         return Classify._classify_add_del_table(
513             node,
514             is_add=1,
515             mask=binascii.unhexlify(mask),
516             match_n_vectors=(len(mask) - 1) // 32 + 1
517         )
518
519     @staticmethod
520     def vpp_creates_classify_table_hex(node, hex_mask):
521         """Create classify table with hex mask.
522
523         :param node: VPP node to create classify table based on hex mask.
524         :param hex_mask: Classify hex mask.
525         :type node: dict
526         :type hex_mask: str
527         :returns: (table_index, skip_n, match_n)
528             table_index: Classify table index.
529             skip_n: Number of skip vectors.
530             match_n: Number of match vectors.
531         :rtype: tuple(int, int, int)
532         """
533         return Classify._classify_add_del_table(
534             node,
535             is_add=1,
536             mask=binascii.unhexlify(hex_mask),
537             match_n_vectors=(len(hex_mask) - 1) // 32 + 1
538         )
539
540     @staticmethod
541     def vpp_configures_classify_session_l3(node, acl_method, table_index,
542                                            ip_version, direction, address):
543         """Configuration of classify session for IP address filtering.
544
545         :param node: VPP node to setup classify session.
546         :param acl_method: ACL method - deny/permit.
547         :param table_index: Classify table index.
548         :param ip_version: Version of IP protocol.
549         :param direction: Direction of traffic - src/dst.
550         :param address: IPv4 or IPv6 address.
551         :type node: dict
552         :type acl_method: str
553         :type table_index: int
554         :type ip_version: str
555         :type direction: str
556         :type address: str
557         :raises ValueError: If the parameter 'direction' has incorrect value.
558         """
559         match_f = dict(
560             ip4=Classify._build_ip_match,
561             ip6=Classify._build_ip6_match
562         )
563         if direction == "src":
564             match = match_f[ip_version](src_ip=address)
565         elif direction == "dst":
566             match = match_f[ip_version](dst_ip=address)
567         else:
568             raise ValueError("Direction {dir} is not supported.".
569                              format(dir=direction))
570         action = dict(
571             permit=0,
572             deny=1
573         )
574         Classify._classify_add_del_session(
575             node,
576             is_add=1,
577             table_index=table_index,
578             match=binascii.unhexlify(match),
579             action=action[acl_method])
580
581     @staticmethod
582     def vpp_configures_classify_session_l2(node, acl_method, table_index,
583                                            direction, address):
584         """Configuration of classify session for MAC address filtering.
585
586         :param node: VPP node to setup classify session.
587         :param acl_method: ACL method - deny/permit.
588         :param table_index: Classify table index.
589         :param direction: Direction of traffic - src/dst.
590         :param address: MAC address.
591         :type node: dict
592         :type acl_method: str
593         :type table_index: int
594         :type direction: str
595         :type address: str
596         :raises ValueError: If the parameter 'direction' has incorrect value.
597         """
598         if direction == "src":
599             match = Classify._build_mac_match(src_mac=address)
600         elif direction == "dst":
601             match = Classify._build_mac_match(dst_mac=address)
602         else:
603             raise ValueError("Direction {dir} is not supported.".
604                              format(dir=direction))
605         action = dict(
606             permit=0,
607             deny=1
608         )
609         Classify._classify_add_del_session(
610             node,
611             is_add=1,
612             table_index=table_index,
613             match=binascii.unhexlify(match),
614             action=action[acl_method])
615
616     @staticmethod
617     def vpp_configures_classify_session_hex(node, acl_method, table_index,
618                                             hex_value):
619         """Configuration of classify session with hex value.
620
621         :param node: VPP node to setup classify session.
622         :param acl_method: ACL method - deny/permit.
623         :param table_index: Classify table index.
624         :param hex_value: Classify hex value.
625         :type node: dict
626         :type acl_method: str
627         :type table_index: int
628         :type hex_value: str
629         """
630         action = dict(
631             permit=0,
632             deny=1
633         )
634         Classify._classify_add_del_session(
635             node,
636             is_add=1,
637             table_index=table_index,
638             match=binascii.unhexlify(hex_value),
639             action=action[acl_method])
640
641     @staticmethod
642     def compute_classify_hex_mask(ip_version, protocol, direction):
643         """Compute classify hex mask for TCP or UDP packet matching.
644
645         :param ip_version: Version of IP protocol.
646         :param protocol: Type of protocol.
647         :param direction: Traffic direction.
648         :type ip_version: str
649         :type protocol: str
650         :type direction: str
651         :returns: Classify hex mask.
652         :rtype: str
653         :raises ValueError: If protocol is not TCP or UDP.
654         :raises ValueError: If direction is not source or destination or
655             source + destination.
656         """
657         if protocol in ('TCP', 'UDP'):
658             base_mask = Classify._compute_base_mask(ip_version)
659
660             if direction == 'source':
661                 return base_mask + 'FFFF0000'
662             elif direction == 'destination':
663                 return base_mask + '0000FFFF'
664             elif direction == 'source + destination':
665                 return base_mask + 'FFFFFFFF'
666             else:
667                 raise ValueError("Invalid direction!")
668         else:
669             raise ValueError("Invalid protocol!")
670
671     @staticmethod
672     def compute_classify_hex_value(hex_mask, source_port, destination_port):
673         """Compute classify hex value for TCP or UDP packet matching.
674
675         :param hex_mask: Classify hex mask.
676         :param source_port: Source TCP/UDP port.
677         :param destination_port: Destination TCP/UDP port.
678         :type hex_mask: str
679         :type source_port: str
680         :type destination_port: str
681         :returns: Classify hex value.
682         :rtype: str
683         """
684         source_port_hex = Classify._port_convert(source_port)
685         destination_port_hex = Classify._port_convert(destination_port)
686
687         return hex_mask[:-8] + source_port_hex + destination_port_hex
688
689     @staticmethod
690     def _port_convert(port):
691         """Convert port number for classify hex table format.
692
693         :param port: TCP/UDP port number.
694         :type port: str
695         :returns: TCP/UDP port number in 4-digit hexadecimal format.
696         :rtype: str
697         """
698         return '{0:04x}'.format(int(port))
699
700     @staticmethod
701     def _compute_base_mask(ip_version):
702         """Compute base classify hex mask based on IP version.
703
704         :param ip_version: Version of IP protocol.
705         :type ip_version: str
706         :returns: Base hex mask.
707         :rtype: str
708         """
709         if ip_version == 'ip4':
710             return 68 * '0'
711             # base value of classify hex table for IPv4 TCP/UDP ports
712         elif ip_version == 'ip6':
713             return 108 * '0'
714             # base value of classify hex table for IPv6 TCP/UDP ports
715         else:
716             raise ValueError("Invalid IP version!")
717
718     @staticmethod
719     def get_classify_table_data(node, table_index):
720         """Retrieve settings for classify table by ID.
721
722         :param node: VPP node to retrieve classify data from.
723         :param table_index: Index of a specific classify table.
724         :type node: dict
725         :type table_index: int
726         :returns: Classify table settings.
727         :rtype: dict
728         """
729         cmd = 'classify_table_info'
730         err_msg = "Failed to get 'classify_table_info' on host {host}".format(
731             host=node['host'])
732         args = dict(
733             table_id=int(table_index)
734         )
735         with PapiExecutor(node) as papi_exec:
736             reply = papi_exec.add(cmd, **args).get_reply(err_msg)
737         return reply
738
739     @staticmethod
740     def get_classify_session_data(node, table_index):
741         """Retrieve settings for all classify sessions in a table.
742
743         :param node: VPP node to retrieve classify data from.
744         :param table_index: Index of a classify table.
745         :type node: dict
746         :type table_index: int
747         :returns: List of classify session settings.
748         :rtype: list or dict
749         """
750         cmd = "classify_session_dump"
751         args = dict(
752             table_id=int(table_index)
753         )
754         with PapiExecutor(node) as papi_exec:
755             details = papi_exec.add(cmd, **args).get_details()
756
757         return details
758
759     @staticmethod
760     def vpp_log_plugin_acl_settings(node):
761         """Retrieve configured settings from the ACL plugin and write to robot
762         log.
763
764         :param node: VPP node.
765         :type node: dict
766         """
767         PapiExecutor.dump_and_log(node, ["acl_dump", ])
768
769     @staticmethod
770     def vpp_log_plugin_acl_interface_assignment(node):
771         """Retrieve interface assignment from the ACL plugin and write to robot
772         log.
773
774         :param node: VPP node.
775         :type node: dict
776         """
777         PapiExecutor.dump_and_log(node, ["acl_interface_list_dump", ])
778
779     @staticmethod
780     def set_acl_list_for_interface(node, interface, acl_type, acl_idx=None):
781         """Set the list of input or output ACLs applied to the interface. It
782         unapplies any previously applied ACLs.
783
784         :param node: VPP node to set ACL on.
785         :param interface: Interface name or sw_if_index.
786         :param acl_type: Type of ACL(s) - input or output.
787         :param acl_idx: Index(ies) of ACLs to be applied on the interface.
788         :type node: dict
789         :type interface: str or int
790         :type acl_type: str
791         :type acl_idx: list
792         """
793         if isinstance(interface, basestring):
794             sw_if_index = Topology.get_interface_sw_index(node, interface)
795         else:
796             sw_if_index = int(interface)
797
798         acls = acl_idx if isinstance(acl_idx, list) else list()
799
800         Classify._acl_interface_set_acl_list(node=node,
801                                              sw_if_index=sw_if_index,
802                                              acl_type=acl_type,
803                                              acls=acls)
804
805     @staticmethod
806     def add_replace_acl_multi_entries(node, acl_idx=None, rules=None):
807         """Add a new ACL or replace the existing one. To replace an existing
808         ACL, pass the ID of this ACL.
809
810         :param node: VPP node to set ACL on.
811         :param acl_idx: ID of ACL. (Optional)
812         :param rules: Required rules. (Optional)
813         :type node: dict
814         :type acl_idx: int
815         :type rules: str
816         """
817         reg_ex_src_ip = re.compile(r'(src [0-9a-fA-F.:/\d{1,2}]*)')
818         reg_ex_dst_ip = re.compile(r'(dst [0-9a-fA-F.:/\d{1,2}]*)')
819         reg_ex_sport = re.compile(r'(sport \d{1,5})')
820         reg_ex_dport = re.compile(r'(dport \d{1,5})')
821
822         acl_rules = list()
823         for rule in rules.split(", "):
824             acl_rule = dict()
825             acl_rule["is_permit"] = 1 if "permit" in rule else 0
826             acl_rule["is_ipv6"] = 1 if "ipv6" in rule else 0
827
828             groups = re.search(reg_ex_src_ip, rule)
829             if groups:
830                 grp = groups.group(1).split(' ')[1].split('/')
831                 acl_rule["src_ip_addr"] = ip_address(unicode(grp[0])).packed
832                 acl_rule["src_ip_prefix_len"] = int(grp[1])
833
834             groups = re.search(reg_ex_dst_ip, rule)
835             if groups:
836                 grp = groups.group(1).split(' ')[1].split('/')
837                 acl_rule["dst_ip_addr"] = ip_address(unicode(grp[0])).packed
838                 acl_rule["dst_ip_prefix_len"] = int(grp[1])
839
840             groups = re.search(reg_ex_sport, rule)
841             if groups:
842                 port = int(groups.group(1).split(' ')[1])
843                 acl_rule["srcport_or_icmptype_first"] = port
844                 acl_rule["srcport_or_icmptype_last"] = port
845
846             groups = re.search(reg_ex_dport, rule)
847             if groups:
848                 port = int(groups.group(1).split(' ')[1])
849                 acl_rule["dstport_or_icmpcode_first"] = port
850                 acl_rule["dstport_or_icmpcode_last"] = port
851
852             acl_rule["proto"] = 0
853
854             acl_rules.append(acl_rule)
855
856         Classify._acl_add_replace(node, acl_idx=acl_idx, rules=acl_rules)
857
858     @staticmethod
859     def add_macip_acl_multi_entries(node, rules=""):
860         """Add a new MACIP ACL.
861
862         :param node: VPP node to set MACIP ACL on.
863         :param rules: Required MACIP rules.
864         :type node: dict
865         :type rules: str
866         """
867         reg_ex_ip = re.compile(r'(ip [0-9a-fA-F.:/\d{1,2}]*)')
868         reg_ex_mac = re.compile(r'(mac \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)')
869         reg_ex_mask = re.compile(r'(mask \S\S:\S\S:\S\S:\S\S:\S\S:\S\S)')
870
871         acl_rules = list()
872         for rule in rules.split(", "):
873             acl_rule = dict()
874             acl_rule["is_permit"] = 1 if "permit" in rule else 0
875             acl_rule["is_ipv6"] = 1 if "ipv6" in rule else 0
876
877             groups = re.search(reg_ex_mac, rule)
878             if groups:
879                 mac = groups.group(1).split(' ')[1].replace(':', '')
880                 acl_rule["src_mac"] = unicode(mac)
881
882             groups = re.search(reg_ex_mask, rule)
883             if groups:
884                 mask = groups.group(1).split(' ')[1].replace(':', '')
885                 acl_rule["src_mac_mask"] = unicode(mask)
886
887             groups = re.search(reg_ex_ip, rule)
888             if groups:
889                 grp = groups.group(1).split(' ')[1].split('/')
890                 acl_rule["src_ip_addr"] = ip_address(unicode(grp[0])).packed
891                 acl_rule["src_ip_prefix_len"] = int(grp[1])
892
893             acl_rules.append(acl_rule)
894
895         Classify._macip_acl_add(node=node, rules=acl_rules)
896
897     @staticmethod
898     def vpp_log_macip_acl_settings(node):
899         """Retrieve configured MACIP settings from the ACL plugin and write to
900         robot log.
901
902         :param node: VPP node.
903         :type node: dict
904         """
905         PapiExecutor.dump_and_log(node, ["macip_acl_dump", ])
906
907     @staticmethod
908     def add_del_macip_acl_interface(node, interface, action, acl_idx):
909         """Apply/un-apply the MACIP ACL to/from a given interface.
910
911         :param node: VPP node to set MACIP ACL on.
912         :param interface: Interface name or sw_if_index.
913         :param action: Required action - add or del.
914         :param acl_idx: ACL index to be applied on the interface.
915         :type node: dict
916         :type interface: str or int
917         :type action: str
918         :type acl_idx: str or int
919         :raises RuntimeError: If unable to set MACIP ACL for the interface.
920         """
921         if isinstance(interface, basestring):
922             sw_if_index = Topology.get_interface_sw_index(node, interface)
923         else:
924             sw_if_index = interface
925
926         is_add = 1 if action == "add" else 0
927
928         cmd = 'macip_acl_interface_add_del'
929         err_msg = "Failed to get 'macip_acl_interface' on host {host}".format(
930             host=node['host'])
931         args = dict(
932             is_add=is_add,
933             sw_if_index=int(sw_if_index),
934             acl_index=int(acl_idx)
935         )
936         with PapiExecutor(node) as papi_exec:
937             papi_exec.add(cmd, **args).get_reply(err_msg)
938
939     @staticmethod
940     def vpp_log_macip_acl_interface_assignment(node):
941         """Get interface list and associated MACIP ACLs and write to robot log.
942
943         :param node: VPP node.
944         :type node: dict
945         """
946         cmd = 'macip_acl_interface_get'
947         err_msg = "Failed to get 'macip_acl_interface' on host {host}".format(
948             host=node['host'])
949         with PapiExecutor(node) as papi_exec:
950             reply = papi_exec.add(cmd).get_reply(err_msg)
951         logger.info(reply)

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.