X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=test%2Ftest_reassembly.py;h=353433c55584521763b8b2302bdd32d26379979c;hb=bde17bd6ef391766712ae7fbd766371037dfd3de;hp=a2d77d493de649435e6d7528f4ba6f6de19981f2;hpb=75e7d1301475d49311d14e202936c62df0c07d10;p=vpp.git diff --git a/test/test_reassembly.py b/test/test_reassembly.py index a2d77d493de..353433c5558 100644 --- a/test/test_reassembly.py +++ b/test/test_reassembly.py @@ -1,20 +1,24 @@ #!/usr/bin/env python + +import six import unittest from random import shuffle -from framework import VppTestCase, VppTestRunner +from framework import VppTestCase, VppTestRunner, is_skip_aarch64_set,\ + is_platform_aarch64 from scapy.packet import Raw from scapy.layers.l2 import Ether, GRE -from scapy.layers.inet import IP, UDP +from scapy.layers.inet import IP, UDP, ICMP from util import ppp, fragment_rfc791, fragment_rfc8200 -from vpp_punt_socket import VppUDSPuntSocket from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, ICMPv6ParamProblem,\ ICMPv6TimeExceeded from vpp_gre_interface import VppGreInterface, VppGre6Interface -from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto +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 class TestIPv4Reassembly(VppTestCase): @@ -24,8 +28,9 @@ class TestIPv4Reassembly(VppTestCase): def setUpClass(cls): super(TestIPv4Reassembly, cls).setUpClass() - cls.create_pg_interfaces([0]) - cls.pg_if = cls.pg0 + cls.create_pg_interfaces([0, 1]) + cls.src_if = cls.pg0 + cls.dst_if = cls.pg1 # setup all interfaces for i in cls.pg_interfaces: @@ -33,9 +38,6 @@ class TestIPv4Reassembly(VppTestCase): i.config_ip4() i.resolve_arp() - cls.punt_port = 9999 - cls.punt_socket = VppUDSPuntSocket(cls, cls.punt_port) - # packet sizes cls.packet_sizes = [64, 512, 1518, 9018] cls.padding = " abcdefghijklmn" @@ -45,6 +47,8 @@ class TestIPv4Reassembly(VppTestCase): def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestIPv4Reassembly, self).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, expire_walk_interval_ms=10) self.sleep(.25) @@ -57,17 +61,17 @@ class TestIPv4Reassembly(VppTestCase): @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. """ for i in range(0, packet_count): - info = cls.create_packet_info(cls.pg_if, cls.pg_if) + info = cls.create_packet_info(cls.src_if, cls.src_if) payload = cls.info_to_payload(info) - p = (Ether(dst=cls.pg_if.local_mac, src=cls.pg_if.remote_mac) / - IP(id=info.index, src=cls.pg_if.remote_ip4, - dst=cls.pg_if.local_ip4) / - UDP(sport=1234, dport=cls.punt_port) / + p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) / + IP(id=info.index, src=cls.src_if.remote_ip4, + dst=cls.dst_if.remote_ip4) / + UDP(sport=1234, dport=5678) / Raw(payload)) size = packet_sizes[(i // 2) % len(packet_sizes)] cls.extend_packet(p, size, cls.padding) @@ -77,9 +81,9 @@ 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 - # self.logger.debug(ppp("Packet:", p.__class__(str(p)))) + # cls.logger.debug(ppp("Packet:", p.__class__(str(p)))) fragments_400 = fragment_rfc791(p, 400) fragments_300 = fragment_rfc791(p, 300) fragments_200 = [ @@ -106,11 +110,7 @@ class TestIPv4Reassembly(VppTestCase): seen = set() for packet in capture: try: - sw_if_index = packet['sw_if_index'] - punt_action = packet['punt_action'] - packet = Ether(packet['packet']) - self.logger.debug(ppp("Got packet from %s, action %s" % - (sw_if_index, punt_action), packet)) + self.logger.debug(ppp("Got packet:", packet)) ip = packet[IP] udp = packet[UDP] payload_info = self.payload_to_info(str(packet[Raw])) @@ -121,7 +121,7 @@ class TestIPv4Reassembly(VppTestCase): if packet_index in seen: raise Exception(ppp("Duplicate packet received", packet)) seen.add(packet_index) - self.assertEqual(payload_info.dst, self.pg_if.sw_if_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) @@ -129,7 +129,7 @@ class TestIPv4Reassembly(VppTestCase): 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: + except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise for index in self._packet_infos: @@ -140,21 +140,21 @@ class TestIPv4Reassembly(VppTestCase): """ basic reassembly """ self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_200) + self.src_if.add_stream(self.fragments_200) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_200) + self.src_if.add_stream(self.fragments_200) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_reversed(self): """ reverse order reassembly """ @@ -163,22 +163,120 @@ class TestIPv4Reassembly(VppTestCase): fragments.reverse() self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.packet_infos)) + packets = self.dst_if.get_capture(len(self.packet_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.packet_infos)) + packets = self.dst_if.get_capture(len(self.packet_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() + + 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([malformed_packet] + valid_fragments) + self.pg_start() + + 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')) + ] + + self.pg_enable_capture() + self.src_if.add_stream(packets) + self.pg_start() + + 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')), + ] + + 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(malformed_packets + valid_fragments) + self.pg_start() + + 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) + + @unittest.skipIf(is_skip_aarch64_set and is_platform_aarch64, + "test doesn't work on aarch64") def test_random(self): """ random order reassembly """ @@ -186,21 +284,21 @@ class TestIPv4Reassembly(VppTestCase): shuffle(fragments) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.packet_infos)) + packets = self.dst_if.get_capture(len(self.packet_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.packet_infos)) + packets = self.dst_if.get_capture(len(self.packet_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_duplicates(self): """ duplicate fragments """ @@ -212,12 +310,12 @@ class TestIPv4Reassembly(VppTestCase): ] self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_overlap1(self): """ overlapping fragments case #1 """ @@ -232,21 +330,21 @@ class TestIPv4Reassembly(VppTestCase): fragments.extend(j) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_overlap2(self): """ overlapping fragments case #2 """ @@ -267,21 +365,21 @@ class TestIPv4Reassembly(VppTestCase): fragments.append(zipped[-1][0]) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_timeout_inline(self): """ timeout (inline) """ @@ -294,13 +392,13 @@ class TestIPv4Reassembly(VppTestCase): expire_walk_interval_ms=10000) self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_timeout_cleanup(self): """ timeout (cleanup) """ @@ -324,19 +422,18 @@ class TestIPv4Reassembly(VppTestCase): expire_walk_interval_ms=50) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() self.sleep(.25, "wait before sending rest of fragments") - self.pg_if.add_stream(fragments2) + self.src_if.add_stream(fragments2) self.pg_start() - self.sleep(.25, "wait for vpp to process packets") - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_disabled(self): """ reassembly disabled """ @@ -349,13 +446,13 @@ class TestIPv4Reassembly(VppTestCase): expire_walk_interval_ms=10000) self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() class TestIPv6Reassembly(VppTestCase): @@ -365,8 +462,9 @@ class TestIPv6Reassembly(VppTestCase): def setUpClass(cls): super(TestIPv6Reassembly, cls).setUpClass() - cls.create_pg_interfaces([0]) - cls.pg_if = cls.pg0 + cls.create_pg_interfaces([0, 1]) + cls.src_if = cls.pg0 + cls.dst_if = cls.pg1 # setup all interfaces for i in cls.pg_interfaces: @@ -374,9 +472,6 @@ class TestIPv6Reassembly(VppTestCase): i.config_ip6() i.resolve_ndp() - cls.punt_port = 9999 - cls.punt_socket = VppUDSPuntSocket(cls, cls.punt_port, is_ip4=0) - # packet sizes cls.packet_sizes = [64, 512, 1518, 9018] cls.padding = " abcdefghijklmn" @@ -386,11 +481,14 @@ class TestIPv6Reassembly(VppTestCase): def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestIPv6Reassembly, self).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, expire_walk_interval_ms=10, is_ip6=1) self.sleep(.25) 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")) def tearDown(self): super(TestIPv6Reassembly, self).tearDown() @@ -403,12 +501,12 @@ class TestIPv6Reassembly(VppTestCase): :param list packet_sizes: Required packet sizes. """ for i in range(0, packet_count): - info = cls.create_packet_info(cls.pg_if, cls.pg_if) + info = cls.create_packet_info(cls.src_if, cls.src_if) payload = cls.info_to_payload(info) - p = (Ether(dst=cls.pg_if.local_mac, src=cls.pg_if.remote_mac) / - IPv6(src=cls.pg_if.remote_ip6, - dst=cls.pg_if.local_ip6) / - UDP(sport=1234, dport=cls.punt_port) / + p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) / + IPv6(src=cls.src_if.remote_ip6, + dst=cls.dst_if.remote_ip6) / + UDP(sport=1234, dport=5678) / Raw(payload)) size = packet_sizes[(i // 2) % len(packet_sizes)] cls.extend_packet(p, size, cls.padding) @@ -418,9 +516,9 @@ 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 - # self.logger.debug(ppp("Packet:", p.__class__(str(p)))) + # cls.logger.debug(ppp("Packet:", p.__class__(str(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)) @@ -442,11 +540,7 @@ class TestIPv6Reassembly(VppTestCase): seen = set() for packet in capture: try: - sw_if_index = packet['sw_if_index'] - punt_action = packet['punt_action'] - packet = Ether(packet['packet']) - self.logger.debug(ppp("Got packet from %s, action %s" % - (sw_if_index, punt_action), packet)) + self.logger.debug(ppp("Got packet:", packet)) ip = packet[IPv6] udp = packet[UDP] payload_info = self.payload_to_info(str(packet[Raw])) @@ -457,7 +551,7 @@ class TestIPv6Reassembly(VppTestCase): if packet_index in seen: raise Exception(ppp("Duplicate packet received", packet)) seen.add(packet_index) - self.assertEqual(payload_info.dst, self.pg_if.sw_if_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) @@ -465,7 +559,7 @@ class TestIPv6Reassembly(VppTestCase): 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: + except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise for index in self._packet_infos: @@ -476,21 +570,21 @@ class TestIPv6Reassembly(VppTestCase): """ basic reassembly """ self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_reversed(self): """ reverse order reassembly """ @@ -499,21 +593,21 @@ class TestIPv6Reassembly(VppTestCase): fragments.reverse() self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_random(self): """ random order reassembly """ @@ -522,21 +616,21 @@ class TestIPv6Reassembly(VppTestCase): shuffle(fragments) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() # run it all again to verify correctness self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_duplicates(self): """ duplicate fragments """ @@ -548,12 +642,12 @@ class TestIPv6Reassembly(VppTestCase): ] self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - packets = self.punt_socket.wait_for_packets(len(self.pkt_infos)) + packets = self.dst_if.get_capture(len(self.pkt_infos)) self.verify_capture(packets) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_overlap1(self): """ overlapping fragments case #1 """ @@ -572,20 +666,19 @@ class TestIPv6Reassembly(VppTestCase): ) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - self.sleep(.1, "wait for vpp to process packets") - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_overlap2(self): """ overlapping fragments case #2 """ fragments = [] - for _, frags_400, frags_30 in self.pkt_infos: + for _, frags_400, frags_300 in self.pkt_infos: if len(frags_400) == 1: fragments.extend(frags_400) else: @@ -593,7 +686,7 @@ class TestIPv6Reassembly(VppTestCase): # received by vpp after reassembly is finished, otherwise # new reassemblies will be started and packet generator will # freak out when it detects unfreed buffers - zipped = zip(frags_400, frags_30) + zipped = zip(frags_400, frags_300) for i, j in zipped[:-1]: fragments.extend(i) fragments.extend(j) @@ -604,14 +697,13 @@ class TestIPv6Reassembly(VppTestCase): ) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() - self.sleep(.1, "wait for vpp to process packets") - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_timeout_inline(self): """ timeout (inline) """ @@ -624,13 +716,13 @@ class TestIPv6Reassembly(VppTestCase): expire_walk_interval_ms=10000, is_ip6=1) self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - pkts = self.pg_if.get_capture( + pkts = self.src_if.get_capture( expected_count=len(dropped_packet_indexes)) for icmp in pkts: self.assertIn(ICMPv6TimeExceeded, icmp) @@ -663,19 +755,18 @@ class TestIPv6Reassembly(VppTestCase): expire_walk_interval_ms=50, is_ip6=1) self.pg_enable_capture() - self.pg_if.add_stream(fragments) + self.src_if.add_stream(fragments) self.pg_start() self.sleep(.25, "wait before sending rest of fragments") - self.pg_if.add_stream(fragments2) + self.src_if.add_stream(fragments2) self.pg_start() - self.sleep(.25, "wait for vpp to process packets") - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - pkts = self.pg_if.get_capture( + pkts = self.src_if.get_capture( expected_count=len(dropped_packet_indexes)) for icmp in pkts: self.assertIn(ICMPv6TimeExceeded, icmp) @@ -694,20 +785,20 @@ class TestIPv6Reassembly(VppTestCase): expire_walk_interval_ms=10000, is_ip6=1) self.pg_enable_capture() - self.pg_if.add_stream(self.fragments_400) + self.src_if.add_stream(self.fragments_400) self.pg_start() - packets = self.punt_socket.wait_for_packets( + packets = self.dst_if.get_capture( len(self.pkt_infos) - len(dropped_packet_indexes)) self.verify_capture(packets, dropped_packet_indexes) - self.pg_if.assert_nothing_captured() + self.src_if.assert_nothing_captured() def test_missing_upper(self): """ missing upper layer """ - p = (Ether(dst=self.pg_if.local_mac, src=self.pg_if.remote_mac) / - IPv6(src=self.pg_if.remote_ip6, - dst=self.pg_if.local_ip6) / - UDP(sport=1234, dport=self.punt_port) / + 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) @@ -715,52 +806,169 @@ class TestIPv6Reassembly(VppTestCase): bad_fragment[IPv6ExtHdrFragment].nh = 59 bad_fragment[IPv6ExtHdrFragment].offset = 0 self.pg_enable_capture() - self.pg_if.add_stream([bad_fragment]) + self.src_if.add_stream([bad_fragment]) self.pg_start() - pkts = self.pg_if.get_capture(expected_count=1) + 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_invalid_frag_size(self): """ fragment size not a multiple of 8 """ - p = (Ether(dst=self.pg_if.local_mac, src=self.pg_if.remote_mac) / - IPv6(src=self.pg_if.remote_ip6, - dst=self.pg_if.local_ip6) / - UDP(sport=1234, dport=self.punt_port) / + 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 = fragments[0] self.extend_packet(bad_fragment, len(bad_fragment) + 5) self.pg_enable_capture() - self.pg_if.add_stream([bad_fragment]) + self.src_if.add_stream([bad_fragment]) self.pg_start() - pkts = self.pg_if.get_capture(expected_count=1) + pkts = self.src_if.get_capture(expected_count=1) icmp = pkts[0] self.assertIn(ICMPv6ParamProblem, icmp) self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code") def test_invalid_packet_size(self): """ total packet size > 65535 """ - p = (Ether(dst=self.pg_if.local_mac, src=self.pg_if.remote_mac) / - IPv6(src=self.pg_if.remote_ip6, - dst=self.pg_if.local_ip6) / - UDP(sport=1234, dport=self.punt_port) / + 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 = fragments[1] bad_fragment[IPv6ExtHdrFragment].offset = 65500 self.pg_enable_capture() - self.pg_if.add_stream([bad_fragment]) + self.src_if.add_stream([bad_fragment]) self.pg_start() - pkts = self.pg_if.get_capture(expected_count=1) + pkts = self.src_if.get_capture(expected_count=1) icmp = pkts[0] self.assertIn(ICMPv6ParamProblem, icmp) 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() + + 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() + self.logger.debug(self.vapi.ppcli("show ip4-reassembly details")) + + @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__(str(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(str(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 """ @@ -768,23 +976,28 @@ class TestFIFReassembly(VppTestCase): def setUpClass(cls): super(TestFIFReassembly, cls).setUpClass() - cls.create_pg_interfaces([0]) - cls.pg_if = cls.pg0 - cls.pg_if.admin_up() - cls.pg_if.config_ip4() - cls.pg_if.resolve_arp() - cls.pg_if.config_ip6() - cls.pg_if.resolve_ndp() - - cls.punt_port = 9999 - cls.punt4_socket = VppUDSPuntSocket(cls, cls.punt_port) - cls.punt6_socket = VppUDSPuntSocket(cls, cls.punt_port, is_ip4=0) + cls.create_pg_interfaces([0, 1]) + cls.src_if = cls.pg0 + cls.dst_if = cls.pg1 + for i in cls.pg_interfaces: + i.admin_up() + i.config_ip4() + i.resolve_arp() + i.config_ip6() + i.resolve_ndp() + cls.packet_sizes = [64, 512, 1518, 9018] cls.padding = " abcdefghijklmn" def setUp(self): """ Test setup - force timeout on existing reassemblies """ super(TestFIFReassembly, self).setUp() + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.src_if.sw_if_index, enable_ip4=True, + enable_ip6=True) + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.dst_if.sw_if_index, enable_ip4=True, + enable_ip6=True) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, expire_walk_interval_ms=10) self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000, @@ -809,11 +1022,7 @@ class TestFIFReassembly(VppTestCase): seen = set() for packet in capture: try: - sw_if_index = packet['sw_if_index'] - punt_action = packet['punt_action'] - packet = Ether(packet['packet']) - self.logger.debug(ppp("Got packet from %s, action %s" % - (sw_if_index, punt_action), packet)) + self.logger.debug(ppp("Got packet:", packet)) ip = packet[ip_class] udp = packet[UDP] payload_info = self.payload_to_info(str(packet[Raw])) @@ -824,7 +1033,7 @@ class TestFIFReassembly(VppTestCase): if packet_index in seen: raise Exception(ppp("Duplicate packet received", packet)) seen.add(packet_index) - self.assertEqual(payload_info.dst, self.pg_if.sw_if_index) + self.assertEqual(payload_info.dst, self.dst_if.sw_if_index) info = self._packet_infos[packet_index] self.assertTrue(info is not None) self.assertEqual(packet_index, info.index) @@ -832,7 +1041,7 @@ class TestFIFReassembly(VppTestCase): self.assertEqual(ip.src, saved_packet[ip_class].src) self.assertEqual(ip.dst, saved_packet[ip_class].dst) self.assertEqual(udp.payload, saved_packet[UDP].payload) - except: + except Exception: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise for index in self._packet_infos: @@ -848,33 +1057,41 @@ class TestFIFReassembly(VppTestCase): # it shared for multiple test cases self.tun_ip4 = "1.1.1.2" - self.gre4 = VppGreInterface(self, self.pg0.local_ip4, self.tun_ip4) + self.gre4 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4) self.gre4.add_vpp_config() self.gre4.admin_up() self.gre4.config_ip4() + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.gre4.sw_if_index, enable_ip4=True) + self.route4 = VppIpRoute(self, self.tun_ip4, 32, - [VppRoutePath(self.pg0.remote_ip4, - self.pg0.sw_if_index)]) + [VppRoutePath(self.src_if.remote_ip4, + self.src_if.sw_if_index)]) self.route4.add_vpp_config() self.reset_packet_infos() for i in range(test_packet_count): - info = self.create_packet_info(self.pg0, self.pg0) + info = self.create_packet_info(self.src_if, self.dst_if) payload = self.info_to_payload(info) - p = (IP(id=i, src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) / - UDP(sport=1234, dport=self.punt_port) / + # Ethernet header here is only for size calculation, thus it + # doesn't matter how it's initialized. This is to ensure that + # reassembled packet is not > 9000 bytes, so that it's not dropped + p = (Ether() / + IP(id=i, src=self.src_if.remote_ip4, + dst=self.dst_if.remote_ip4) / + UDP(sport=1234, dport=5678) / Raw(payload)) size = self.packet_sizes[(i // 2) % len(self.packet_sizes)] self.extend_packet(p, size, self.padding) - info.data = p + 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 = \ - [Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / - IP(src=self.tun_ip4, dst=self.pg0.local_ip4) / + [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / + IP(src=self.tun_ip4, dst=self.src_if.local_ip4) / GRE() / p for p in fragments] @@ -883,18 +1100,19 @@ class TestFIFReassembly(VppTestCase): [x for p in encapped_fragments for x in fragment_rfc791(p, 200)] - self.pg0.add_stream(fragmented_encapped_fragments) + self.src_if.add_stream(fragmented_encapped_fragments) self.pg_enable_capture(self.pg_interfaces) self.pg_start() - self.pg0.assert_nothing_captured() - packets = self.punt4_socket.wait_for_packets(len(self._packet_infos)) + self.src_if.assert_nothing_captured() + packets = self.dst_if.get_capture(len(self._packet_infos)) self.verify_capture(packets, IP) # TODO remove gre vpp config by hand until VppIpRoute gets fixed # so that it's query_vpp_config() works as it should self.gre4.remove_vpp_config() + self.logger.debug(self.vapi.ppcli("show interface")) def test_fif6(self): """ Fragments in fragments (6o6) """ @@ -904,36 +1122,43 @@ class TestFIFReassembly(VppTestCase): # it shared for multiple test cases self.tun_ip6 = "1002::1" - self.gre6 = VppGre6Interface(self, self.pg0.local_ip6, self.tun_ip6) + self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6) self.gre6.add_vpp_config() self.gre6.admin_up() self.gre6.config_ip6() + self.vapi.ip_reassembly_enable_disable( + sw_if_index=self.gre6.sw_if_index, enable_ip6=True) + self.route6 = VppIpRoute(self, self.tun_ip6, 128, - [VppRoutePath(self.pg0.remote_ip6, - self.pg0.sw_if_index, + [VppRoutePath(self.src_if.remote_ip6, + self.src_if.sw_if_index, proto=DpoProto.DPO_PROTO_IP6)], is_ip6=1) self.route6.add_vpp_config() self.reset_packet_infos() for i in range(test_packet_count): - info = self.create_packet_info(self.pg0, self.pg0) + info = self.create_packet_info(self.src_if, self.dst_if) payload = self.info_to_payload(info) - p = (IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / - UDP(sport=1234, dport=self.punt_port) / + # Ethernet header here is only for size calculation, thus it + # doesn't matter how it's initialized. This is to ensure that + # reassembled packet is not > 9000 bytes, so that it's not dropped + p = (Ether() / + IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) / + UDP(sport=1234, dport=5678) / Raw(payload)) size = self.packet_sizes[(i // 2) % len(self.packet_sizes)] self.extend_packet(p, size, self.padding) - info.data = p + 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)] encapped_fragments = \ - [Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / - IPv6(src=self.tun_ip6, dst=self.pg0.local_ip6) / + [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) / + IPv6(src=self.tun_ip6, dst=self.src_if.local_ip6) / GRE() / p for p in fragments] @@ -948,13 +1173,13 @@ class TestFIFReassembly(VppTestCase): ) ] - self.pg0.add_stream(fragmented_encapped_fragments) + self.src_if.add_stream(fragmented_encapped_fragments) self.pg_enable_capture(self.pg_interfaces) self.pg_start() - self.pg0.assert_nothing_captured() - packets = self.punt6_socket.wait_for_packets(len(self._packet_infos)) + self.src_if.assert_nothing_captured() + packets = self.dst_if.get_capture(len(self._packet_infos)) self.verify_capture(packets, IPv6) # TODO remove gre vpp config by hand until VppIpRoute gets fixed