X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_reassembly.py;h=4c7a7cd320ba47da2065403541373a4a09c5236f;hb=5c6dd17a373a2c56e57f02426d66a79af7faa19c;hp=ee7830e1762e337baf2298285e09ea80db67b551;hpb=de34c35fc73226943538149fae9dbc5cfbdc6e75;p=vpp.git diff --git a/test/test_reassembly.py b/test/test_reassembly.py index ee7830e1762..4c7a7cd320b 100644 --- a/test/test_reassembly.py +++ b/test/test_reassembly.py @@ -1,6 +1,5 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 -import six import unittest from random import shuffle, choice, randrange @@ -9,9 +8,11 @@ from framework import VppTestCase, VppTestRunner import scapy.compat from scapy.packet import Raw from scapy.layers.l2 import Ether, GRE -from scapy.layers.inet import IP, UDP, ICMP +from scapy.layers.inet import IP, UDP, ICMP, icmptypes from scapy.layers.inet6 import HBHOptUnknown, ICMPv6ParamProblem,\ - ICMPv6TimeExceeded, IPv6, IPv6ExtHdrFragment, IPv6ExtHdrHopByHop + ICMPv6TimeExceeded, IPv6, IPv6ExtHdrFragment,\ + IPv6ExtHdrHopByHop, IPv6ExtHdrDestOpt, PadN, ICMPv6EchoRequest,\ + ICMPv6EchoReply from framework import VppTestCase, VppTestRunner from util import ppp, ppc, fragment_rfc791, fragment_rfc8200 from vpp_gre_interface import VppGreInterface @@ -22,16 +23,13 @@ from vpp_papi import VppEnum # 35 is enough to have >257 400-byte fragments test_packet_count = 35 -# number of workers used for multi-worker test cases -worker_count = 3 - class TestIPv4Reassembly(VppTestCase): """ IPv4 Reassembly """ @classmethod def setUpClass(cls): - super(TestIPv4Reassembly, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0, 1]) cls.src_if = cls.pg0 @@ -51,23 +49,25 @@ class TestIPv4Reassembly(VppTestCase): @classmethod def tearDownClass(cls): - super(TestIPv4Reassembly, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv4Reassembly, self).setUp() + super().setUp() self.vapi.ip_reassembly_enable_disable( sw_if_index=self.src_if.sw_if_index, enable_ip4=True) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10000) def tearDown(self): - super(TestIPv4Reassembly, self).tearDown() + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.src_if.sw_if_index, enable_ip4=False) + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details")) @@ -95,7 +95,7 @@ class TestIPv4Reassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in six.iteritems(infos): + for index, info in infos.items(): p = info.data # cls.logger.debug(ppp("Packet:", # p.__class__(scapy.compat.raw(p)))) @@ -171,6 +171,21 @@ class TestIPv4Reassembly(VppTestCase): self.verify_capture(packets) self.src_if.assert_nothing_captured() + def test_verify_clear_trace_mid_reassembly(self): + """ verify clear trace works mid-reassembly """ + + self.pg_enable_capture() + self.src_if.add_stream(self.fragments_200[0:-1]) + self.pg_start() + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.src_if.add_stream(self.fragments_200[-1]) + self.pg_start() + packets = self.dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(packets) + def test_reversed(self): """ reverse order reassembly """ @@ -210,12 +225,12 @@ class TestIPv4Reassembly(VppTestCase): IP(id=1000, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) / UDP(sport=1234, dport=5678) / - Raw("X" * 1000)) + Raw(b"X" * 1000)) p2 = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / IP(id=1001, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) / UDP(sport=1234, dport=5678) / - Raw("X" * 1000)) + Raw(b"X" * 1000)) frags = fragment_rfc791(p1, 200) + fragment_rfc791(p2, 500) self.pg_enable_capture() @@ -228,11 +243,9 @@ class TestIPv4Reassembly(VppTestCase): def test_5737(self): """ fragment length + ip header size > 65535 """ self.vapi.cli("clear errors") - raw = ('E\x00\x00\x88,\xf8\x1f\xfe@\x01\x98\x00\xc0\xa8\n-\xc0\xa8\n' - '\x01\x08\x00\xf0J\xed\xcb\xf1\xf5Test-group: IPv4.IPv4.ipv4-' - 'message.Ethernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Of' - 'fset; Test-case: 5737') - + raw = b'''E\x00\x00\x88,\xf8\x1f\xfe@\x01\x98\x00\xc0\xa8\n-\xc0\xa8\n\ +\x01\x08\x00\xf0J\xed\xcb\xf1\xf5Test-group: IPv4.IPv4.ipv4-message.\ +Ethernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Offset; Test-case: 5737''' malformed_packet = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / IP(raw)) @@ -240,20 +253,19 @@ class TestIPv4Reassembly(VppTestCase): IP(id=1000, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) / UDP(sport=1234, dport=5678) / - Raw("X" * 1000)) + Raw(b"X" * 1000)) valid_fragments = fragment_rfc791(p, 400) + counter = "/err/ip4-full-reassembly-feature/malformed packets" + error_counter = self.statistics.get_err_counter(counter) self.pg_enable_capture() self.src_if.add_stream([malformed_packet] + valid_fragments) self.pg_start() self.dst_if.get_capture(1) self.logger.debug(self.vapi.ppcli("show error")) - self.assert_packet_counter_equal("ip4-full-reassembly-feature", 1) - # TODO remove above, uncomment below once clearing of counters - # is supported - # self.assert_packet_counter_equal( - # "/err/ip4-full-reassembly-feature/malformed packets", 1) + self.assertEqual(self.statistics.get_err_counter(counter), + error_counter + 1) def test_44924(self): """ compress tiny fragments """ @@ -300,14 +312,14 @@ class TestIPv4Reassembly(VppTestCase): IP(id=7, len=21, frag=1, ttl=64, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) / - Raw(load='\x08')), + Raw(load=b'\x08')), ] p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / IP(id=1000, src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) / UDP(sport=1234, dport=5678) / - Raw("X" * 1000)) + Raw(b"X" * 1000)) valid_fragments = fragment_rfc791(p, 400) self.pg_enable_capture() @@ -472,7 +484,7 @@ class TestIPv4Reassembly(VppTestCase): self.src_if.add_stream(fragments) self.pg_start() - self.sleep(.25, "wait before sending rest of fragments") + self.virtual_sleep(.25, "wait before sending rest of fragments") self.src_if.add_stream(fragments2) self.pg_start() @@ -502,13 +514,31 @@ class TestIPv4Reassembly(VppTestCase): self.verify_capture(packets, dropped_packet_indexes) self.src_if.assert_nothing_captured() + def test_local_enable_disable(self): + """ local reassembly enabled/disable """ + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.src_if.sw_if_index, enable_ip4=False) + self.vapi.ip_local_reass_enable_disable(enable_ip4=True) + p = (Ether(src=self.src_if.remote_mac, dst=self.src_if.local_mac) / + IP(src=self.src_if.remote_ip4, dst=self.src_if.local_ip4) / + ICMP(id=1234, type='echo-request') / + Raw('x' * 1000)) + frags = fragment_rfc791(p, 400) + r = self.send_and_expect(self.src_if, frags, self.src_if, n_rx=1)[0] + self.assertEqual(1234, r[ICMP].id) + self.assertEqual(icmptypes[r[ICMP].type], 'echo-reply') + self.vapi.ip_local_reass_enable_disable() + + self.send_and_assert_no_replies(self.src_if, frags) + self.vapi.ip_local_reass_enable_disable(enable_ip4=True) + class TestIPv4SVReassembly(VppTestCase): """ IPv4 Shallow Virtual Reassembly """ @classmethod def setUpClass(cls): - super(TestIPv4SVReassembly, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0, 1]) cls.src_if = cls.pg0 @@ -522,7 +552,7 @@ class TestIPv4SVReassembly(VppTestCase): def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv4SVReassembly, self).setUp() + super().setUp() self.vapi.ip_reassembly_enable_disable( sw_if_index=self.src_if.sw_if_index, enable_ip4=True, type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL) @@ -531,7 +561,7 @@ class TestIPv4SVReassembly(VppTestCase): max_reassembly_length=1000, type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL, expire_walk_interval_ms=10) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set( timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, @@ -539,7 +569,7 @@ class TestIPv4SVReassembly(VppTestCase): expire_walk_interval_ms=10000) def tearDown(self): - super(TestIPv4SVReassembly, self).tearDown() + super().tearDown() self.logger.debug(self.vapi.ppcli("show ip4-sv-reassembly details")) self.logger.debug(self.vapi.ppcli("show buffers")) @@ -592,6 +622,42 @@ class TestIPv4SVReassembly(VppTestCase): self.assertEqual(sent[IP].dst, recvd[IP].dst) self.assertEqual(sent[Raw].payload, recvd[Raw].payload) + def test_verify_clear_trace_mid_reassembly(self): + """ verify clear trace works mid-reassembly """ + payload_len = 1000 + payload = "" + counter = 0 + while len(payload) < payload_len: + payload += "%u " % counter + counter += 1 + + p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / + IP(id=1, src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + UDP(sport=1234, dport=5678) / + Raw(payload)) + fragments = fragment_rfc791(p, payload_len/4) + + self.pg_enable_capture() + self.src_if.add_stream(fragments[1]) + self.pg_start() + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.pg_enable_capture() + self.src_if.add_stream(fragments[0]) + self.pg_start() + self.dst_if.get_capture(2) + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.pg_enable_capture() + self.src_if.add_stream(fragments[2:]) + self.pg_start() + self.dst_if.get_capture(len(fragments[2:])) + def test_timeout(self): """ reassembly timeout """ payload_len = 1000 @@ -628,7 +694,7 @@ class TestIPv4SVReassembly(VppTestCase): self.assertEqual(sent[Raw].payload, recvd[Raw].payload) # wait for cleanup - self.sleep(.25, "wait before sending rest of fragments") + self.virtual_sleep(.25, "wait before sending rest of fragments") # send rest of fragments - shouldn't be forwarded self.pg_enable_capture() @@ -673,16 +739,82 @@ class TestIPv4SVReassembly(VppTestCase): self.assertEqual(sent[IP].dst, recvd[IP].dst) self.assertEqual(sent[Raw].payload, recvd[Raw].payload) + def send_mixed_and_verify_capture(self, traffic): + stream = [] + for t in traffic: + for c in range(t['count']): + stream.append( + (Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=self.counter, + flags=t['flags'], + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + UDP(sport=1234, dport=5678) / + Raw("abcdef"))) + self.counter = self.counter + 1 + + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() + self.logger.debug(self.vapi.ppcli("show ip4-sv-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) + self.logger.debug(self.vapi.ppcli("show trace")) + self.dst_if.get_capture(len(stream)) + + def test_mixed(self): + """ mixed traffic correctly passes through SVR """ + self.counter = 1 + + self.send_mixed_and_verify_capture([{'count': 1, 'flags': ''}]) + self.send_mixed_and_verify_capture([{'count': 2, 'flags': ''}]) + self.send_mixed_and_verify_capture([{'count': 3, 'flags': ''}]) + self.send_mixed_and_verify_capture([{'count': 8, 'flags': ''}]) + self.send_mixed_and_verify_capture([{'count': 257, 'flags': ''}]) + + self.send_mixed_and_verify_capture([{'count': 1, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture([{'count': 2, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture([{'count': 3, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture([{'count': 8, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture([{'count': 257, 'flags': 'MF'}]) + + self.send_mixed_and_verify_capture( + [{'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 129, 'flags': ''}, {'count': 129, 'flags': 'MF'}]) + + self.send_mixed_and_verify_capture( + [{'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'}, + {'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'}, + {'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'}, + {'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'}, + {'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'}]) + self.send_mixed_and_verify_capture( + [{'count': 65, 'flags': ''}, {'count': 65, 'flags': 'MF'}, + {'count': 65, 'flags': ''}, {'count': 65, 'flags': 'MF'}]) + class TestIPv4MWReassembly(VppTestCase): """ IPv4 Reassembly (multiple workers) """ - worker_config = "workers %d" % worker_count + vpp_worker_count = 3 @classmethod def setUpClass(cls): - super(TestIPv4MWReassembly, cls).setUpClass() + super().setUpClass() - cls.create_pg_interfaces(range(worker_count+1)) + cls.create_pg_interfaces(range(cls.vpp_worker_count+1)) cls.src_if = cls.pg0 cls.send_ifs = cls.pg_interfaces[:-1] cls.dst_if = cls.pg_interfaces[-1] @@ -704,24 +836,27 @@ class TestIPv4MWReassembly(VppTestCase): @classmethod def tearDownClass(cls): - super(TestIPv4MWReassembly, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv4MWReassembly, self).setUp() + super().setUp() for intf in self.send_ifs: self.vapi.ip_reassembly_enable_disable( sw_if_index=intf.sw_if_index, enable_ip4=True) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10000) def tearDown(self): - super(TestIPv4MWReassembly, self).tearDown() + for intf in self.send_ifs: + self.vapi.ip_reassembly_enable_disable( + sw_if_index=intf.sw_if_index, enable_ip4=False) + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details")) @@ -748,7 +883,7 @@ class TestIPv4MWReassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in six.iteritems(infos): + for index, info in infos.items(): p = info.data # cls.logger.debug(ppp("Packet:", # p.__class__(scapy.compat.raw(p)))) @@ -795,7 +930,7 @@ class TestIPv4MWReassembly(VppTestCase): "Packet with packet_index %d not received" % index) def send_packets(self, packets): - for counter in range(worker_count): + for counter in range(self.vpp_worker_count): if 0 == len(packets[counter]): continue send_if = self.send_ifs[counter] @@ -811,19 +946,19 @@ class TestIPv4MWReassembly(VppTestCase): # in first wave we send fragments which don't start at offset 0 # then we send fragments with offset 0 on a different thread # then the rest of packets on a random thread - first_packets = [[] for n in range(worker_count)] - second_packets = [[] for n in range(worker_count)] - rest_of_packets = [[] for n in range(worker_count)] + first_packets = [[] for n in range(self.vpp_worker_count)] + second_packets = [[] for n in range(self.vpp_worker_count)] + rest_of_packets = [[] for n in range(self.vpp_worker_count)] for (_, p) in self.pkt_infos: - wi = randrange(worker_count) + wi = randrange(self.vpp_worker_count) second_packets[wi].append(p[0]) if len(p) <= 1: continue wi2 = wi while wi2 == wi: - wi2 = randrange(worker_count) + wi2 = randrange(self.vpp_worker_count) first_packets[wi2].append(p[1]) - wi3 = randrange(worker_count) + wi3 = randrange(self.vpp_worker_count) rest_of_packets[wi3].extend(p[2:]) self.pg_enable_capture() @@ -836,6 +971,11 @@ class TestIPv4MWReassembly(VppTestCase): for send_if in self.send_ifs: send_if.assert_nothing_captured() + self.logger.debug(self.vapi.ppcli("show trace")) + self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) + self.vapi.cli("clear trace") + self.pg_enable_capture() self.send_packets(first_packets) self.send_packets(second_packets) @@ -852,7 +992,7 @@ class TestIPv6Reassembly(VppTestCase): @classmethod def setUpClass(cls): - super(TestIPv6Reassembly, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0, 1]) cls.src_if = cls.pg0 @@ -872,17 +1012,17 @@ class TestIPv6Reassembly(VppTestCase): @classmethod def tearDownClass(cls): - super(TestIPv6Reassembly, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv6Reassembly, self).setUp() + super().setUp() self.vapi.ip_reassembly_enable_disable( sw_if_index=self.src_if.sw_if_index, enable_ip6=True) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10, is_ip6=1) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10000, is_ip6=1) @@ -890,7 +1030,9 @@ class TestIPv6Reassembly(VppTestCase): self.logger.debug(self.vapi.ppcli("show buffers")) def tearDown(self): - super(TestIPv6Reassembly, self).tearDown() + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.src_if.sw_if_index, enable_ip6=False) + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip6-full-reassembly details")) @@ -918,7 +1060,7 @@ class TestIPv6Reassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in six.iteritems(infos): + for index, info in infos.items(): p = info.data # cls.logger.debug(ppp("Packet:", # p.__class__(scapy.compat.raw(p)))) @@ -1006,6 +1148,21 @@ class TestIPv6Reassembly(VppTestCase): self.src_if.assert_nothing_captured() self.dst_if.assert_nothing_captured() + def test_verify_clear_trace_mid_reassembly(self): + """ verify clear trace works mid-reassembly """ + + self.pg_enable_capture() + self.src_if.add_stream(self.fragments_400[0:-1]) + self.pg_start() + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.src_if.add_stream(self.fragments_400[-1]) + self.pg_start() + packets = self.dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(packets) + def test_reversed(self): """ reverse order reassembly """ @@ -1085,7 +1242,7 @@ class TestIPv6Reassembly(VppTestCase): IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / UDP(sport=1234, dport=5678) / - Raw("X" * 1000)) + Raw(b"X" * 1000)) frags = fragment_rfc8200(p, 1, 300) + fragment_rfc8200(p, 2, 500) self.pg_enable_capture() @@ -1169,8 +1326,7 @@ class TestIPv6Reassembly(VppTestCase): packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - pkts = self.src_if.get_capture( - expected_count=len(dropped_packet_indexes)) + pkts = self.src_if._get_capture(1) for icmp in pkts: self.assertIn(ICMPv6TimeExceeded, icmp) self.assertIn(IPv6ExtHdrFragment, icmp) @@ -1207,7 +1363,7 @@ class TestIPv6Reassembly(VppTestCase): self.src_if.add_stream(fragments) self.pg_start() - self.sleep(.25, "wait before sending rest of fragments") + self.virtual_sleep(.25, "wait before sending rest of fragments") self.src_if.add_stream(fragments2) self.pg_start() @@ -1215,8 +1371,7 @@ class TestIPv6Reassembly(VppTestCase): packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - pkts = self.src_if.get_capture( - expected_count=len(dropped_packet_indexes)) + pkts = self.src_if._get_capture(1) for icmp in pkts: self.assertIn(ICMPv6TimeExceeded, icmp) self.assertIn(IPv6ExtHdrFragment, icmp) @@ -1245,24 +1400,31 @@ class TestIPv6Reassembly(VppTestCase): def test_missing_upper(self): """ missing upper layer """ + optdata = '\x00' * 100 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / IPv6(src=self.src_if.remote_ip6, dst=self.src_if.local_ip6) / - UDP(sport=1234, dport=5678) / - Raw()) - self.extend_packet(p, 1000, self.padding) - fragments = fragment_rfc8200(p, 1, 500) - bad_fragment = p.__class__(scapy.compat.raw(fragments[1])) - bad_fragment[IPv6ExtHdrFragment].nh = 59 - bad_fragment[IPv6ExtHdrFragment].offset = 0 + IPv6ExtHdrFragment(m=1) / + IPv6ExtHdrDestOpt(nh=17, options=PadN(optdata='\101' * 255) / + PadN(optdata='\102'*255))) + self.pg_enable_capture() - self.src_if.add_stream([bad_fragment]) + self.src_if.add_stream([p]) self.pg_start() pkts = self.src_if.get_capture(expected_count=1) icmp = pkts[0] self.assertIn(ICMPv6ParamProblem, icmp) self.assert_equal(icmp[ICMPv6ParamProblem].code, 3, "ICMP code") + def test_truncated_fragment(self): + """ truncated fragment """ + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6, + nh=44, plen=2) / + IPv6ExtHdrFragment(nh=6)) + + self.send_and_assert_no_replies(self.pg0, [pkt], self.pg0) + def test_invalid_frag_size(self): """ fragment size not a multiple of 8 """ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / @@ -1301,16 +1463,98 @@ class TestIPv6Reassembly(VppTestCase): self.assertIn(ICMPv6ParamProblem, icmp) self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code") + def test_atomic_fragment(self): + """ IPv6 atomic fragment """ + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6, + nh=44, plen=65535) / + IPv6ExtHdrFragment(offset=8191, m=1, res1=0xFF, res2=0xFF, + nh=255, id=0xffff)/('X'*1452)) + + rx = self.send_and_expect(self.pg0, [pkt], self.pg0) + self.assertIn(ICMPv6ParamProblem, rx[0]) + + def test_truncated_fragment(self): + """ IPv6 truncated fragment header """ + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6, + nh=44, plen=2) / + IPv6ExtHdrFragment(nh=6)) + + self.send_and_assert_no_replies(self.pg0, [pkt]) + + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.remote_ip6) / + ICMPv6EchoRequest()) + rx = self.send_and_expect(self.pg0, [pkt], self.pg0) + + def test_one_fragment(self): + """ whole packet in one fragment processed independently """ + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / + ICMPv6EchoRequest()/Raw('X' * 1600)) + frags = fragment_rfc8200(pkt, 1, 400) + + # send a fragment with known id + self.send_and_assert_no_replies(self.pg0, [frags[0]]) + + # send an atomic fragment with same id - should be reassembled + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / + IPv6ExtHdrFragment(id=1)/ICMPv6EchoRequest()) + rx = self.send_and_expect(self.pg0, [pkt], self.pg0) + self.assertNotIn(IPv6ExtHdrFragment, rx) + + # now finish the original reassembly, this should still be possible + rx = self.send_and_expect(self.pg0, frags[1:], self.pg0, n_rx=1) + self.assertNotIn(IPv6ExtHdrFragment, rx) + + def test_bunch_of_fragments(self): + """ valid fragments followed by rogue fragments and atomic fragment""" + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / + ICMPv6EchoRequest()/Raw('X' * 1600)) + frags = fragment_rfc8200(pkt, 1, 400) + self.send_and_expect(self.pg0, frags, self.pg0, n_rx=1) + + inc_frag = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / + IPv6ExtHdrFragment(id=1, nh=58, offset=608)/Raw('X'*308)) + + self.send_and_assert_no_replies(self.pg0, inc_frag*604) + + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / + IPv6ExtHdrFragment(id=1)/ICMPv6EchoRequest()) + rx = self.send_and_expect(self.pg0, [pkt], self.pg0) + self.assertNotIn(IPv6ExtHdrFragment, rx) + + def test_local_enable_disable(self): + """ local reassembly enabled/disable """ + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.src_if.sw_if_index, enable_ip6=False) + self.vapi.ip_local_reass_enable_disable(enable_ip6=True) + pkt = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.src_if.local_ip6) / + ICMPv6EchoRequest(id=1234)/Raw('X' * 1600)) + frags = fragment_rfc8200(pkt, 1, 400) + r = self.send_and_expect(self.src_if, frags, self.src_if, n_rx=1)[0] + self.assertEqual(1234, r[ICMPv6EchoReply].id) + self.vapi.ip_local_reass_enable_disable() + + self.send_and_assert_no_replies(self.src_if, frags) + self.vapi.ip_local_reass_enable_disable(enable_ip6=True) + class TestIPv6MWReassembly(VppTestCase): """ IPv6 Reassembly (multiple workers) """ - worker_config = "workers %d" % worker_count + vpp_worker_count = 3 @classmethod def setUpClass(cls): - super(TestIPv6MWReassembly, cls).setUpClass() + super().setUpClass() - cls.create_pg_interfaces(range(worker_count+1)) + cls.create_pg_interfaces(range(cls.vpp_worker_count+1)) cls.src_if = cls.pg0 cls.send_ifs = cls.pg_interfaces[:-1] cls.dst_if = cls.pg_interfaces[-1] @@ -1332,24 +1576,27 @@ class TestIPv6MWReassembly(VppTestCase): @classmethod def tearDownClass(cls): - super(TestIPv6MWReassembly, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv6MWReassembly, self).setUp() + super().setUp() for intf in self.send_ifs: self.vapi.ip_reassembly_enable_disable( sw_if_index=intf.sw_if_index, enable_ip6=True) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10, is_ip6=1) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=1000, is_ip6=1) def tearDown(self): - super(TestIPv6MWReassembly, self).tearDown() + for intf in self.send_ifs: + self.vapi.ip_reassembly_enable_disable( + sw_if_index=intf.sw_if_index, enable_ip6=False) + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip6-full-reassembly details")) @@ -1376,7 +1623,7 @@ class TestIPv6MWReassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in six.iteritems(infos): + for index, info in infos.items(): p = info.data # cls.logger.debug(ppp("Packet:", # p.__class__(scapy.compat.raw(p)))) @@ -1423,7 +1670,7 @@ class TestIPv6MWReassembly(VppTestCase): "Packet with packet_index %d not received" % index) def send_packets(self, packets): - for counter in range(worker_count): + for counter in range(self.vpp_worker_count): if 0 == len(packets[counter]): continue send_if = self.send_ifs[counter] @@ -1439,19 +1686,19 @@ class TestIPv6MWReassembly(VppTestCase): # in first wave we send fragments which don't start at offset 0 # then we send fragments with offset 0 on a different thread # then the rest of packets on a random thread - first_packets = [[] for n in range(worker_count)] - second_packets = [[] for n in range(worker_count)] - rest_of_packets = [[] for n in range(worker_count)] + first_packets = [[] for n in range(self.vpp_worker_count)] + second_packets = [[] for n in range(self.vpp_worker_count)] + rest_of_packets = [[] for n in range(self.vpp_worker_count)] for (_, p) in self.pkt_infos: - wi = randrange(worker_count) + wi = randrange(self.vpp_worker_count) second_packets[wi].append(p[0]) if len(p) <= 1: continue wi2 = wi while wi2 == wi: - wi2 = randrange(worker_count) + wi2 = randrange(self.vpp_worker_count) first_packets[wi2].append(p[1]) - wi3 = randrange(worker_count) + wi3 = randrange(self.vpp_worker_count) rest_of_packets[wi3].extend(p[2:]) self.pg_enable_capture() @@ -1464,6 +1711,11 @@ class TestIPv6MWReassembly(VppTestCase): for send_if in self.send_ifs: send_if.assert_nothing_captured() + self.logger.debug(self.vapi.ppcli("show trace")) + self.logger.debug(self.vapi.ppcli("show ip6-full-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) + self.vapi.cli("clear trace") + self.pg_enable_capture() self.send_packets(first_packets) self.send_packets(second_packets) @@ -1480,7 +1732,7 @@ class TestIPv6SVReassembly(VppTestCase): @classmethod def setUpClass(cls): - super(TestIPv6SVReassembly, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0, 1]) cls.src_if = cls.pg0 @@ -1494,7 +1746,7 @@ class TestIPv6SVReassembly(VppTestCase): def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv6SVReassembly, self).setUp() + super().setUp() self.vapi.ip_reassembly_enable_disable( sw_if_index=self.src_if.sw_if_index, enable_ip6=True, type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL) @@ -1503,7 +1755,7 @@ class TestIPv6SVReassembly(VppTestCase): max_reassembly_length=1000, type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL, expire_walk_interval_ms=10, is_ip6=1) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set( timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, @@ -1511,7 +1763,7 @@ class TestIPv6SVReassembly(VppTestCase): expire_walk_interval_ms=10000, is_ip6=1) def tearDown(self): - super(TestIPv6SVReassembly, self).tearDown() + super().tearDown() self.logger.debug(self.vapi.ppcli("show ip6-sv-reassembly details")) self.logger.debug(self.vapi.ppcli("show buffers")) @@ -1563,6 +1815,41 @@ class TestIPv6SVReassembly(VppTestCase): self.assertEqual(sent[IPv6].dst, recvd[IPv6].dst) self.assertEqual(sent[Raw].payload, recvd[Raw].payload) + def test_verify_clear_trace_mid_reassembly(self): + """ verify clear trace works mid-reassembly """ + payload_len = 1000 + payload = "" + counter = 0 + while len(payload) < payload_len: + payload += "%u " % counter + counter += 1 + + p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + UDP(sport=1234, dport=5678) / + Raw(payload)) + fragments = fragment_rfc8200(p, 1, payload_len/4) + + self.pg_enable_capture() + self.src_if.add_stream(fragments[1]) + self.pg_start() + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.pg_enable_capture() + self.src_if.add_stream(fragments[0]) + self.pg_start() + self.dst_if.get_capture(2) + + self.logger.debug(self.vapi.cli("show trace")) + self.vapi.cli("clear trace") + + self.pg_enable_capture() + self.src_if.add_stream(fragments[2:]) + self.pg_start() + self.dst_if.get_capture(len(fragments[2:])) + def test_timeout(self): """ reassembly timeout """ payload_len = 1000 @@ -1599,7 +1886,7 @@ class TestIPv6SVReassembly(VppTestCase): self.assertEqual(sent[Raw].payload, recvd[Raw].payload) # wait for cleanup - self.sleep(.25, "wait before sending rest of fragments") + self.virtual_sleep(.25, "wait before sending rest of fragments") # send rest of fragments - shouldn't be forwarded self.pg_enable_capture() @@ -1644,13 +1931,60 @@ class TestIPv6SVReassembly(VppTestCase): self.assertEqual(sent[IPv6].dst, recvd[IPv6].dst) self.assertEqual(sent[Raw].payload, recvd[Raw].payload) + def test_one_fragment(self): + """ whole packet in one fragment processed independently """ + pkt = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + ICMPv6EchoRequest()/Raw('X' * 1600)) + frags = fragment_rfc8200(pkt, 1, 400) + + # send a fragment with known id + self.send_and_expect(self.src_if, [frags[0]], self.dst_if) + + # send an atomic fragment with same id - should be reassembled + pkt = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + IPv6ExtHdrFragment(id=1)/ICMPv6EchoRequest()) + rx = self.send_and_expect(self.src_if, [pkt], self.dst_if) + + # now forward packets matching original reassembly, should still work + rx = self.send_and_expect(self.src_if, frags[1:], self.dst_if) + + def test_bunch_of_fragments(self): + """ valid fragments followed by rogue fragments and atomic fragment""" + pkt = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + ICMPv6EchoRequest()/Raw('X' * 1600)) + frags = fragment_rfc8200(pkt, 1, 400) + rx = self.send_and_expect(self.src_if, frags, self.dst_if) + + rogue = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + IPv6ExtHdrFragment(id=1, nh=58, offset=608)/Raw('X'*308)) + + self.send_and_expect(self.src_if, rogue*604, self.dst_if) + + pkt = (Ether(src=self.src_if.local_mac, dst=self.src_if.remote_mac) / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + IPv6ExtHdrFragment(id=1)/ICMPv6EchoRequest()) + rx = self.send_and_expect(self.src_if, [pkt], self.dst_if) + + def test_truncated_fragment(self): + """ truncated fragment """ + pkt = (Ether(src=self.pg0.local_mac, dst=self.pg0.remote_mac) / + IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6, + nh=44, plen=2) / + IPv6ExtHdrFragment(nh=6)) + + self.send_and_assert_no_replies(self.pg0, [pkt], self.pg0) + class TestIPv4ReassemblyLocalNode(VppTestCase): """ IPv4 Reassembly for packets coming to ip4-local node """ @classmethod def setUpClass(cls): - super(TestIPv4ReassemblyLocalNode, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0]) cls.src_dst_if = cls.pg0 @@ -1667,21 +2001,21 @@ class TestIPv4ReassemblyLocalNode(VppTestCase): @classmethod def tearDownClass(cls): - super(TestIPv4ReassemblyLocalNode, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestIPv4ReassemblyLocalNode, self).setUp() + super().setUp() self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10000) def tearDown(self): - super(TestIPv4ReassemblyLocalNode, self).tearDown() + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details")) @@ -1709,7 +2043,7 @@ class TestIPv4ReassemblyLocalNode(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in six.iteritems(infos): + for index, info in infos.items(): p = info.data # cls.logger.debug(ppp("Packet:", # p.__class__(scapy.compat.raw(p)))) @@ -1777,7 +2111,7 @@ class TestFIFReassembly(VppTestCase): @classmethod def setUpClass(cls): - super(TestFIFReassembly, cls).setUpClass() + super().setUpClass() cls.create_pg_interfaces([0, 1]) cls.src_if = cls.pg0 @@ -1794,11 +2128,11 @@ class TestFIFReassembly(VppTestCase): @classmethod def tearDownClass(cls): - super(TestFIFReassembly, cls).tearDownClass() + super().tearDownClass() def setUp(self): """ Test setup - force timeout on existing reassemblies """ - super(TestFIFReassembly, self).setUp() + super().setUp() self.vapi.ip_reassembly_enable_disable( sw_if_index=self.src_if.sw_if_index, enable_ip4=True, enable_ip6=True) @@ -1811,7 +2145,7 @@ class TestFIFReassembly(VppTestCase): self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10, is_ip6=1) - self.sleep(.25) + self.virtual_sleep(.25) self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, max_reassembly_length=1000, expire_walk_interval_ms=10000) @@ -1820,7 +2154,7 @@ class TestFIFReassembly(VppTestCase): expire_walk_interval_ms=10000, is_ip6=1) def tearDown(self): - super(TestFIFReassembly, self).tearDown() + super().tearDown() def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details")) @@ -1900,7 +2234,7 @@ class TestFIFReassembly(VppTestCase): self.extend_packet(p, size, self.padding) info.data = p[IP] # use only IP part, without ethernet header - fragments = [x for _, p in six.iteritems(self._packet_infos) + fragments = [x for _, p in self._packet_infos.items() for x in fragment_rfc791(p.data, 400)] encapped_fragments = \ @@ -1965,7 +2299,7 @@ class TestFIFReassembly(VppTestCase): self.extend_packet(p, size, self.padding) info.data = p[IPv6] # use only IPv6 part, without ethernet header - fragments = [x for _, i in six.iteritems(self._packet_infos) + fragments = [x for _, i in self._packet_infos.items() for x in fragment_rfc8200( i.data, i.index, 400)]