X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_reassembly.py;h=8cfb109b0b5ec8f259a38337402b42fe4e64fec1;hb=90cf21b5d8fd2d3e531e841dcd752311df5f8a50;hp=b2c271decacdf1297090b3c32ea98249b5cd3ad5;hpb=c0a93143412b4be7bba087bf633855aeeaee7c56;p=vpp.git diff --git a/test/test_reassembly.py b/test/test_reassembly.py index b2c271decac..8cfb109b0b5 100644 --- a/test/test_reassembly.py +++ b/test/test_reassembly.py @@ -1,23 +1,202 @@ #!/usr/bin/env python -import unittest -from random import shuffle -from framework import VppTestCase, VppTestRunner +from random import shuffle +import six +import unittest +from parameterized import parameterized +import scapy.compat from scapy.packet import Raw from scapy.layers.l2 import Ether, GRE -from scapy.layers.inet import IP, UDP -from util import ppp, fragment_rfc791, fragment_rfc8200 +from scapy.layers.inet import IP, UDP, ICMP + from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, ICMPv6ParamProblem,\ ICMPv6TimeExceeded + +from framework import VppTestCase, VppTestRunner +from util import ppp, fragment_rfc791, fragment_rfc8200 from vpp_gre_interface import VppGreInterface, VppGre6Interface from vpp_ip import DpoProto from vpp_ip_route import VppIpRoute, VppRoutePath -test_packet_count = 257 +# 35 is enough to have >257 400-byte fragments +test_packet_count = 35 + +# +# +_scapy_ip_family_types = (IP, IPv6) + + +def validate_scapy_ip_family(scapy_ip_family): + + if scapy_ip_family not in _scapy_ip_family_types: + raise ValueError("'scapy_ip_family' must be of type: %s. Got %s" % + (_scapy_ip_family_types, scapy_ip_family)) + + +class TestIPReassemblyMixin(object): + + def verify_capture(self, scapy_ip_family, capture, + dropped_packet_indexes=None): + """Verify captured packet stream. + + :param list capture: Captured packet stream. + """ + validate_scapy_ip_family(scapy_ip_family) + + if dropped_packet_indexes is None: + dropped_packet_indexes = [] + info = None + seen = set() + for packet in capture: + try: + self.logger.debug(ppp("Got packet:", packet)) + ip = packet[scapy_ip_family] + udp = packet[UDP] + payload_info = self.payload_to_info(packet[Raw]) + packet_index = payload_info.index + self.assertTrue( + packet_index not in dropped_packet_indexes, + ppp("Packet received, but should be dropped:", packet)) + if packet_index in seen: + raise Exception(ppp("Duplicate packet received", packet)) + seen.add(packet_index) + self.assertEqual(payload_info.dst, self.src_if.sw_if_index) + info = self._packet_infos[packet_index] + self.assertTrue(info is not None) + self.assertEqual(packet_index, info.index) + saved_packet = info.data + self.assertEqual(ip.src, saved_packet[scapy_ip_family].src) + self.assertEqual(ip.dst, saved_packet[scapy_ip_family].dst) + self.assertEqual(udp.payload, saved_packet[UDP].payload) + except Exception: + self.logger.error(ppp("Unexpected or invalid packet:", packet)) + raise + for index in self._packet_infos: + self.assertTrue(index in seen or index in dropped_packet_indexes, + "Packet with packet_index %d not received" % index) + + def test_disabled(self, scapy_ip_family, stream, + dropped_packet_indexes): + """ reassembly disabled """ + validate_scapy_ip_family(scapy_ip_family) + is_ip6 = 1 if scapy_ip_family == IPv6 else 0 + + self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0, + expire_walk_interval_ms=10000, + is_ip6=is_ip6) + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() -class TestIPv4Reassembly(VppTestCase): + packets = self.dst_if.get_capture( + len(self.pkt_infos) - len(dropped_packet_indexes)) + self.verify_capture(scapy_ip_family, packets, dropped_packet_indexes) + self.src_if.assert_nothing_captured() + + def test_duplicates(self, scapy_ip_family, stream): + """ duplicate fragments """ + validate_scapy_ip_family(scapy_ip_family) + + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + def test_random(self, scapy_ip_family, stream): + """ random order reassembly """ + validate_scapy_ip_family(scapy_ip_family) + + fragments = list(stream) + shuffle(fragments) + + self.pg_enable_capture() + self.src_if.add_stream(fragments) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.packet_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + # run it all again to verify correctness + self.pg_enable_capture() + self.src_if.add_stream(fragments) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.packet_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + def test_reassembly(self, scapy_ip_family, stream): + """ basic reassembly """ + validate_scapy_ip_family(scapy_ip_family) + + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + # run it all again to verify correctness + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + def test_reversed(self, scapy_ip_family, stream): + """ reverse order reassembly """ + validate_scapy_ip_family(scapy_ip_family) + + fragments = list(stream) + fragments.reverse() + + self.pg_enable_capture() + self.src_if.add_stream(fragments) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.packet_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + # run it all again to verify correctness + self.pg_enable_capture() + self.src_if.add_stream(fragments) + self.pg_start() + + packets = self.dst_if.get_capture(len(self.packet_infos)) + self.verify_capture(scapy_ip_family, packets) + self.src_if.assert_nothing_captured() + + def test_timeout_inline(self, scapy_ip_family, stream, + dropped_packet_indexes): + """ timeout (inline) """ + validate_scapy_ip_family(scapy_ip_family) + is_ip6 = 1 if scapy_ip_family == IPv6 else 0 + + self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, + expire_walk_interval_ms=10000, + is_ip6=is_ip6) + + self.pg_enable_capture() + self.src_if.add_stream(stream) + self.pg_start() + + packets = self.dst_if.get_capture( + len(self.pkt_infos) - len(dropped_packet_indexes)) + self.verify_capture(scapy_ip_family, packets, + dropped_packet_indexes) + + +class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase): """ IPv4 Reassembly """ @classmethod @@ -40,6 +219,10 @@ class TestIPv4Reassembly(VppTestCase): cls.create_stream(cls.packet_sizes) cls.create_fragments() + @classmethod + def tearDownClass(cls): + super(TestIPv4Reassembly, cls).tearDownClass() + def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestIPv4Reassembly, self).setUp() @@ -53,11 +236,14 @@ class TestIPv4Reassembly(VppTestCase): def tearDown(self): super(TestIPv4Reassembly, self).tearDown() + + def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) @classmethod def create_stream(cls, packet_sizes, packet_count=test_packet_count): - """Create input packet stream for defined interface. + """Create input packet stream :param list packet_sizes: Required packet sizes. """ @@ -77,9 +263,10 @@ class TestIPv4Reassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in infos.iteritems(): + for index, info in six.iteritems(infos): p = info.data - # cls.logger.debug(ppp("Packet:", p.__class__(str(p)))) + # cls.logger.debug(ppp("Packet:", + # p.__class__(scapy.compat.raw(p)))) fragments_400 = fragment_rfc791(p, 400) fragments_300 = fragment_rfc791(p, 300) fragments_200 = [ @@ -97,123 +284,129 @@ class TestIPv4Reassembly(VppTestCase): (len(infos), len(cls.fragments_400), len(cls.fragments_300), len(cls.fragments_200))) - def verify_capture(self, capture, dropped_packet_indexes=[]): - """Verify captured packet stream. - - :param list capture: Captured packet stream. - """ - info = None - seen = set() - for packet in capture: - try: - self.logger.debug(ppp("Got packet:", packet)) - ip = packet[IP] - udp = packet[UDP] - payload_info = self.payload_to_info(str(packet[Raw])) - packet_index = payload_info.index - self.assertTrue( - packet_index not in dropped_packet_indexes, - ppp("Packet received, but should be dropped:", packet)) - if packet_index in seen: - raise Exception(ppp("Duplicate packet received", packet)) - seen.add(packet_index) - self.assertEqual(payload_info.dst, self.src_if.sw_if_index) - info = self._packet_infos[packet_index] - self.assertTrue(info is not None) - self.assertEqual(packet_index, info.index) - saved_packet = info.data - self.assertEqual(ip.src, saved_packet[IP].src) - self.assertEqual(ip.dst, saved_packet[IP].dst) - self.assertEqual(udp.payload, saved_packet[UDP].payload) - except Exception: - self.logger.error(ppp("Unexpected or invalid packet:", packet)) - raise - for index in self._packet_infos: - self.assertTrue(index in seen or index in dropped_packet_indexes, - "Packet with packet_index %d not received" % index) - - def test_reassembly(self): + @parameterized.expand([(IP, None)]) + def test_reassembly(self, family, stream): """ basic reassembly """ + stream = self.__class__.fragments_200 + super(TestIPv4Reassembly, self).test_reassembly(family, stream) - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_200) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - # run it all again to verify correctness - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_200) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - def test_reversed(self): + @parameterized.expand([(IP, None)]) + def test_reversed(self, family, stream): """ reverse order reassembly """ - - fragments = list(self.fragments_200) - fragments.reverse() + stream = self.__class__.fragments_200 + super(TestIPv4Reassembly, self).test_reversed(family, stream) + + @parameterized.expand([(IP, None)]) + def test_random(self, family, stream): + stream = self.__class__.fragments_200 + super(TestIPv4Reassembly, self).test_random(family, stream) + + 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') + + malformed_packet = (Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(raw)) + 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)) + valid_fragments = fragment_rfc791(p, 400) self.pg_enable_capture() - self.src_if.add_stream(fragments) + self.src_if.add_stream([malformed_packet] + valid_fragments) self.pg_start() - packets = self.dst_if.get_capture(len(self.packet_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() + self.dst_if.get_capture(1) + self.assert_packet_counter_equal("ip4-reassembly-feature", 1) + # TODO remove above, uncomment below once clearing of counters + # is supported + # self.assert_packet_counter_equal( + # "/err/ip4-reassembly-feature/malformed packets", 1) + + def test_44924(self): + """ compress tiny fragments """ + packets = [(Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=24339, flags="MF", frag=0, ttl=64, + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + ICMP(type="echo-request", code=0, id=0x1fe6, seq=0x2407) / + Raw(load='Test-group: IPv4')), + (Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=24339, flags="MF", frag=3, ttl=64, + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + ICMP(type="echo-request", code=0, id=0x1fe6, seq=0x2407) / + Raw(load='.IPv4.Fragmentation.vali')), + (Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=24339, frag=6, ttl=64, + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + ICMP(type="echo-request", code=0, id=0x1fe6, seq=0x2407) / + Raw(load='d; Test-case: 44924')) + ] - # run it all again to verify correctness self.pg_enable_capture() - self.src_if.add_stream(fragments) + self.src_if.add_stream(packets) self.pg_start() - packets = self.dst_if.get_capture(len(self.packet_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() + self.dst_if.get_capture(1) + + def test_frag_1(self): + """ fragment of size 1 """ + self.vapi.cli("clear errors") + malformed_packets = [(Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=7, len=21, flags="MF", frag=0, ttl=64, + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + ICMP(type="echo-request")), + (Ether(dst=self.src_if.local_mac, + src=self.src_if.remote_mac) / + IP(id=7, len=21, frag=1, ttl=64, + src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + Raw(load='\x08')), + ] - def test_random(self): - """ random order reassembly """ - - fragments = list(self.fragments_200) - shuffle(fragments) + 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)) + valid_fragments = fragment_rfc791(p, 400) self.pg_enable_capture() - self.src_if.add_stream(fragments) + self.src_if.add_stream(malformed_packets + valid_fragments) self.pg_start() - packets = self.dst_if.get_capture(len(self.packet_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() + self.dst_if.get_capture(1) - # run it all again to verify correctness - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() + self.assert_packet_counter_equal("ip4-reassembly-feature", 1) + # TODO remove above, uncomment below once clearing of counters + # is supported + # self.assert_packet_counter_equal( + # "/err/ip4-reassembly-feature/malformed packets", 1) - packets = self.dst_if.get_capture(len(self.packet_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - def test_duplicates(self): + @parameterized.expand([(IP, None)]) + def test_duplicates(self, family, stream): """ duplicate fragments """ - fragments = [ + # IPv4 uses 4 fields in pkt_infos, IPv6 uses 3. x for (_, frags, _, _) in self.pkt_infos for x in frags for _ in range(0, min(2, len(frags))) ] - - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() + super(TestIPv4Reassembly, self).test_duplicates(family, fragments) def test_overlap1(self): """ overlapping fragments case #1 """ @@ -232,7 +425,7 @@ class TestIPv4Reassembly(VppTestCase): self.pg_start() packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) + self.verify_capture(IP, packets) self.src_if.assert_nothing_captured() # run it all to verify correctness @@ -241,7 +434,7 @@ class TestIPv4Reassembly(VppTestCase): self.pg_start() packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) + self.verify_capture(IP, packets) self.src_if.assert_nothing_captured() def test_overlap2(self): @@ -267,7 +460,7 @@ class TestIPv4Reassembly(VppTestCase): self.pg_start() packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) + self.verify_capture(IP, packets) self.src_if.assert_nothing_captured() # run it all to verify correctness @@ -276,26 +469,20 @@ class TestIPv4Reassembly(VppTestCase): self.pg_start() packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) + self.verify_capture(IP, packets) self.src_if.assert_nothing_captured() - def test_timeout_inline(self): + @parameterized.expand([(IP, None, None)]) + def test_timeout_inline(self, family, stream, dropped_packet_indexes): """ timeout (inline) """ + stream = self.fragments_400 dropped_packet_indexes = set( index for (index, frags, _, _) in self.pkt_infos if len(frags) > 1 ) + super(TestIPv4Reassembly, self).test_timeout_inline( + family, stream, dropped_packet_indexes) - self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, - expire_walk_interval_ms=10000) - - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - packets = self.dst_if.get_capture( - len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) self.src_if.assert_nothing_captured() def test_timeout_cleanup(self): @@ -330,30 +517,22 @@ class TestIPv4Reassembly(VppTestCase): packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) + self.verify_capture(IP, packets, dropped_packet_indexes) self.src_if.assert_nothing_captured() - def test_disabled(self): + @parameterized.expand([(IP, None, None)]) + def test_disabled(self, family, stream, dropped_packet_indexes): """ reassembly disabled """ + stream = self.__class__.fragments_400 dropped_packet_indexes = set( index for (index, frags_400, _, _) in self.pkt_infos if len(frags_400) > 1) - - self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0, - expire_walk_interval_ms=10000) - - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - packets = self.dst_if.get_capture( - len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) - self.src_if.assert_nothing_captured() + super(TestIPv4Reassembly, self).test_disabled( + family, stream, dropped_packet_indexes) -class TestIPv6Reassembly(VppTestCase): +class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase): """ IPv6 Reassembly """ @classmethod @@ -376,6 +555,10 @@ class TestIPv6Reassembly(VppTestCase): cls.create_stream(cls.packet_sizes) cls.create_fragments() + @classmethod + def tearDownClass(cls): + super(TestIPv6Reassembly, cls).tearDownClass() + def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestIPv6Reassembly, self).setUp() @@ -387,10 +570,14 @@ class TestIPv6Reassembly(VppTestCase): self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, expire_walk_interval_ms=10000, is_ip6=1) self.logger.debug(self.vapi.ppcli("show ip6-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) def tearDown(self): super(TestIPv6Reassembly, self).tearDown() + + def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip6-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) @classmethod def create_stream(cls, packet_sizes, packet_count=test_packet_count): @@ -414,9 +601,10 @@ class TestIPv6Reassembly(VppTestCase): def create_fragments(cls): infos = cls._packet_infos cls.pkt_infos = [] - for index, info in infos.iteritems(): + for index, info in six.iteritems(infos): p = info.data - # cls.logger.debug(ppp("Packet:", p.__class__(str(p)))) + # cls.logger.debug(ppp("Packet:", + # p.__class__(scapy.compat.raw(p)))) fragments_400 = fragment_rfc8200(p, info.index, 400) fragments_300 = fragment_rfc8200(p, info.index, 300) cls.pkt_infos.append((index, fragments_400, fragments_300)) @@ -429,126 +617,38 @@ class TestIPv6Reassembly(VppTestCase): (len(infos), len(cls.fragments_400), len(cls.fragments_300))) - def verify_capture(self, capture, dropped_packet_indexes=[]): - """Verify captured packet strea . - - :param list capture: Captured packet stream. - """ - info = None - seen = set() - for packet in capture: - try: - self.logger.debug(ppp("Got packet:", packet)) - ip = packet[IPv6] - udp = packet[UDP] - payload_info = self.payload_to_info(str(packet[Raw])) - packet_index = payload_info.index - self.assertTrue( - packet_index not in dropped_packet_indexes, - ppp("Packet received, but should be dropped:", packet)) - if packet_index in seen: - raise Exception(ppp("Duplicate packet received", packet)) - seen.add(packet_index) - self.assertEqual(payload_info.dst, self.src_if.sw_if_index) - info = self._packet_infos[packet_index] - self.assertTrue(info is not None) - self.assertEqual(packet_index, info.index) - saved_packet = info.data - self.assertEqual(ip.src, saved_packet[IPv6].src) - self.assertEqual(ip.dst, saved_packet[IPv6].dst) - self.assertEqual(udp.payload, saved_packet[UDP].payload) - except Exception: - self.logger.error(ppp("Unexpected or invalid packet:", packet)) - raise - for index in self._packet_infos: - self.assertTrue(index in seen or index in dropped_packet_indexes, - "Packet with packet_index %d not received" % index) - - def test_reassembly(self): + @parameterized.expand([(IPv6, None)]) + def test_reassembly(self, family, stream): """ basic reassembly """ + stream = self.__class__.fragments_400 + super(TestIPv6Reassembly, self).test_reassembly(family, stream) - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - # run it all again to verify correctness - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - def test_reversed(self): + @parameterized.expand([(IPv6, None)]) + def test_reversed(self, family, stream): """ reverse order reassembly """ + stream = self.__class__.fragments_400 + super(TestIPv6Reassembly, self).test_reversed(family, stream) - fragments = list(self.fragments_400) - fragments.reverse() - - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - # run it all again to verify correctness - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - def test_random(self): + @parameterized.expand([(IPv6, None)]) + def test_random(self, family, stream): """ random order reassembly """ + stream = self.__class__.fragments_400 + super(TestIPv6Reassembly, self).test_random(family, stream) - fragments = list(self.fragments_400) - shuffle(fragments) - - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - # run it all again to verify correctness - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() - - def test_duplicates(self): + @parameterized.expand([(IPv6, None)]) + def test_duplicates(self, family, stream): """ duplicate fragments """ fragments = [ + # IPv4 uses 4 fields in pkt_infos, IPv6 uses 3. x for (_, frags, _) in self.pkt_infos for x in frags for _ in range(0, min(2, len(frags))) ] - - self.pg_enable_capture() - self.src_if.add_stream(fragments) - self.pg_start() - - packets = self.dst_if.get_capture(len(self.pkt_infos)) - self.verify_capture(packets) - self.src_if.assert_nothing_captured() + super(TestIPv6Reassembly, self).test_duplicates(family, fragments) def test_overlap1(self): - """ overlapping fragments case #1 """ + """ overlapping fragments case #1 (differs from IP test case)""" fragments = [] for _, frags_400, frags_300 in self.pkt_infos: @@ -569,11 +669,11 @@ class TestIPv6Reassembly(VppTestCase): packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) + self.verify_capture(IPv6, packets, dropped_packet_indexes) self.src_if.assert_nothing_captured() def test_overlap2(self): - """ overlapping fragments case #2 """ + """ overlapping fragments case #2 (differs from IP test case)""" fragments = [] for _, frags_400, frags_300 in self.pkt_infos: @@ -600,26 +700,20 @@ class TestIPv6Reassembly(VppTestCase): packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) + self.verify_capture(IPv6, packets, dropped_packet_indexes) self.src_if.assert_nothing_captured() - def test_timeout_inline(self): + @parameterized.expand([(IPv6, None, None)]) + def test_timeout_inline(self, family, stream, dropped_packets_index): """ timeout (inline) """ + stream = self.__class__.fragments_400 dropped_packet_indexes = set( index for (index, frags, _) in self.pkt_infos if len(frags) > 1 ) + super(TestIPv6Reassembly, self).test_timeout_inline( + family, stream, dropped_packet_indexes) - self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, - expire_walk_interval_ms=10000, is_ip6=1) - - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - 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)) for icmp in pkts: @@ -663,7 +757,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) + self.verify_capture(IPv6, packets, dropped_packet_indexes) pkts = self.src_if.get_capture( expected_count=len(dropped_packet_indexes)) for icmp in pkts: @@ -672,23 +766,16 @@ class TestIPv6Reassembly(VppTestCase): self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes) dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id) - def test_disabled(self): + @parameterized.expand([(IPv6, None, None)]) + def test_disabled(self, family, stream, dropped_packet_indexes): """ reassembly disabled """ + stream = self.__class__.fragments_400 dropped_packet_indexes = set( index for (index, frags_400, _) in self.pkt_infos if len(frags_400) > 1) - - self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0, - expire_walk_interval_ms=10000, is_ip6=1) - - self.pg_enable_capture() - self.src_if.add_stream(self.fragments_400) - self.pg_start() - - packets = self.dst_if.get_capture( - len(self.pkt_infos) - len(dropped_packet_indexes)) - self.verify_capture(packets, dropped_packet_indexes) + super(TestIPv6Reassembly, self).test_disabled( + family, stream, dropped_packet_indexes) self.src_if.assert_nothing_captured() def test_missing_upper(self): @@ -700,7 +787,7 @@ class TestIPv6Reassembly(VppTestCase): Raw()) self.extend_packet(p, 1000, self.padding) fragments = fragment_rfc8200(p, 1, 500) - bad_fragment = p.__class__(str(fragments[1])) + bad_fragment = p.__class__(scapy.compat.raw(fragments[1])) bad_fragment[IPv6ExtHdrFragment].nh = 59 bad_fragment[IPv6ExtHdrFragment].offset = 0 self.pg_enable_capture() @@ -750,6 +837,131 @@ class TestIPv6Reassembly(VppTestCase): self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code") +class TestIPv4ReassemblyLocalNode(VppTestCase): + """ IPv4 Reassembly for packets coming to ip4-local node """ + + @classmethod + def setUpClass(cls): + super(TestIPv4ReassemblyLocalNode, cls).setUpClass() + + cls.create_pg_interfaces([0]) + cls.src_dst_if = cls.pg0 + + # setup all interfaces + for i in cls.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + + cls.padding = " abcdefghijklmn" + cls.create_stream() + cls.create_fragments() + + @classmethod + def tearDownClass(cls): + super(TestIPv4ReassemblyLocalNode, cls).tearDownClass() + + def setUp(self): + """ Test setup - force timeout on existing reassemblies """ + super(TestIPv4ReassemblyLocalNode, self).setUp() + self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, + expire_walk_interval_ms=10) + self.sleep(.25) + self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000, + expire_walk_interval_ms=10000) + + def tearDown(self): + super(TestIPv4ReassemblyLocalNode, self).tearDown() + + def show_commands_at_teardown(self): + self.logger.debug(self.vapi.ppcli("show ip4-reassembly details")) + self.logger.debug(self.vapi.ppcli("show buffers")) + + @classmethod + def create_stream(cls, packet_count=test_packet_count): + """Create input packet stream for defined interface. + + :param list packet_sizes: Required packet sizes. + """ + for i in range(0, packet_count): + info = cls.create_packet_info(cls.src_dst_if, cls.src_dst_if) + payload = cls.info_to_payload(info) + p = (Ether(dst=cls.src_dst_if.local_mac, + src=cls.src_dst_if.remote_mac) / + IP(id=info.index, src=cls.src_dst_if.remote_ip4, + dst=cls.src_dst_if.local_ip4) / + ICMP(type='echo-request', id=1234) / + Raw(payload)) + cls.extend_packet(p, 1518, cls.padding) + info.data = p + + @classmethod + def create_fragments(cls): + infos = cls._packet_infos + cls.pkt_infos = [] + for index, info in six.iteritems(infos): + p = info.data + # cls.logger.debug(ppp("Packet:", + # p.__class__(scapy.compat.raw(p)))) + fragments_300 = fragment_rfc791(p, 300) + cls.pkt_infos.append((index, fragments_300)) + cls.fragments_300 = [x for (_, frags) in cls.pkt_infos for x in frags] + cls.logger.debug("Fragmented %s packets into %s 300-byte fragments" % + (len(infos), len(cls.fragments_300))) + + def verify_capture(self, capture): + """Verify captured packet stream. + + :param list capture: Captured packet stream. + """ + info = None + seen = set() + for packet in capture: + try: + self.logger.debug(ppp("Got packet:", packet)) + ip = packet[IP] + icmp = packet[ICMP] + payload_info = self.payload_to_info(packet[Raw]) + packet_index = payload_info.index + if packet_index in seen: + raise Exception(ppp("Duplicate packet received", packet)) + seen.add(packet_index) + self.assertEqual(payload_info.dst, self.src_dst_if.sw_if_index) + info = self._packet_infos[packet_index] + self.assertIsNotNone(info) + self.assertEqual(packet_index, info.index) + saved_packet = info.data + self.assertEqual(ip.src, saved_packet[IP].dst) + self.assertEqual(ip.dst, saved_packet[IP].src) + self.assertEqual(icmp.type, 0) # echo reply + self.assertEqual(icmp.id, saved_packet[ICMP].id) + self.assertEqual(icmp.payload, saved_packet[ICMP].payload) + except Exception: + self.logger.error(ppp("Unexpected or invalid packet:", packet)) + raise + for index in self._packet_infos: + self.assertIn(index, seen, + "Packet with packet_index %d not received" % index) + + def test_reassembly(self): + """ basic reassembly """ + + self.pg_enable_capture() + self.src_dst_if.add_stream(self.fragments_300) + self.pg_start() + + packets = self.src_dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(packets) + + # run it all again to verify correctness + self.pg_enable_capture() + self.src_dst_if.add_stream(self.fragments_300) + self.pg_start() + + packets = self.src_dst_if.get_capture(len(self.pkt_infos)) + self.verify_capture(packets) + + class TestFIFReassembly(VppTestCase): """ Fragments in fragments reassembly """ @@ -770,6 +982,10 @@ class TestFIFReassembly(VppTestCase): cls.packet_sizes = [64, 512, 1518, 9018] cls.padding = " abcdefghijklmn" + @classmethod + def tearDownClass(cls): + super(TestFIFReassembly, cls).tearDownClass() + def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestFIFReassembly, self).setUp() @@ -790,9 +1006,12 @@ class TestFIFReassembly(VppTestCase): expire_walk_interval_ms=10000, is_ip6=1) def tearDown(self): + super(TestFIFReassembly, self).tearDown() + + def show_commands_at_teardown(self): self.logger.debug(self.vapi.ppcli("show ip4-reassembly details")) self.logger.debug(self.vapi.ppcli("show ip6-reassembly details")) - super(TestFIFReassembly, self).tearDown() + self.logger.debug(self.vapi.ppcli("show buffers")) def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]): """Verify captured packet stream. @@ -806,7 +1025,7 @@ class TestFIFReassembly(VppTestCase): self.logger.debug(ppp("Got packet:", packet)) ip = packet[ip_class] udp = packet[UDP] - payload_info = self.payload_to_info(str(packet[Raw])) + payload_info = self.payload_to_info(packet[Raw]) packet_index = payload_info.index self.assertTrue( packet_index not in dropped_packet_indexes, @@ -867,7 +1086,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 self._packet_infos.iteritems() + fragments = [x for _, p in six.iteritems(self._packet_infos) for x in fragment_rfc791(p.data, 400)] encapped_fragments = \ @@ -933,7 +1152,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 self._packet_infos.iteritems() + fragments = [x for _, i in six.iteritems(self._packet_infos) for x in fragment_rfc8200( i.data, i.index, 400)]