ikev2: support responder hostname

[vpp.git] / test / test_reassembly.py

diff --git a/test/test_reassembly.py b/test/test_reassembly.py
index ace11f7..a8dc60a 100644 (file)
--- 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
 
@@ -95,7 +94,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 +170,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 """
 
@@ -589,6 +603,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
@@ -670,6 +720,72 @@ 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) """
@@ -745,7 +861,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))))
@@ -920,7 +1036,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))))
@@ -1008,6 +1124,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 """
 
@@ -1378,7 +1509,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))))
@@ -1570,6 +1701,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
@@ -1716,7 +1882,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))))
@@ -1907,7 +2073,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 = \
@@ -1972,7 +2138,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)]