papi: prevent message_table inconsistencies

[vpp.git] / test / test_reassembly.py

diff --git a/test/test_reassembly.py b/test/test_reassembly.py
index 8004f36..6a356a0 100644 (file)
--- a/test/test_reassembly.py
+++ b/test/test_reassembly.py
@@ -5,6 +5,7 @@ import six
 import unittest
 
 from parameterized import parameterized
 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, ICMP
 from scapy.packet import Raw
 from scapy.layers.l2 import Ether, GRE
 from scapy.layers.inet import IP, UDP, ICMP


@@ -14,9 +15,9 @@ from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, ICMPv6ParamProblem,\
 
 from framework import VppTestCase, VppTestRunner
 from util import ppp, fragment_rfc791, fragment_rfc8200
 
 from framework import VppTestCase, VppTestRunner
 from util import ppp, fragment_rfc791, fragment_rfc8200

-from vpp_gre_interface import VppGreInterface, VppGre6Interface
+from vpp_gre_interface import VppGreInterface

 from vpp_ip import DpoProto
 from vpp_ip import DpoProto

-from vpp_ip_route import VppIpRoute, VppRoutePath
+from vpp_ip_route import VppIpRoute, VppRoutePath, FibPathProto

 
 # 35 is enough to have >257 400-byte fragments
 test_packet_count = 35
 
 # 35 is enough to have >257 400-byte fragments
 test_packet_count = 35


@@ -82,6 +83,7 @@ class TestIPReassemblyMixin(object):
         is_ip6 = 1 if scapy_ip_family == IPv6 else 0
 
         self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,
         is_ip6 = 1 if scapy_ip_family == IPv6 else 0
 
         self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10000,
                                     is_ip6=is_ip6)
 
                                     expire_walk_interval_ms=10000,
                                     is_ip6=is_ip6)
 


@@ -182,6 +184,7 @@ class TestIPReassemblyMixin(object):
         is_ip6 = 1 if scapy_ip_family == IPv6 else 0
 
         self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
         is_ip6 = 1 if scapy_ip_family == IPv6 else 0
 
         self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10000,
                                     is_ip6=is_ip6)
 
                                     expire_walk_interval_ms=10000,
                                     is_ip6=is_ip6)
 


@@ -218,19 +221,27 @@ class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase):
         cls.create_stream(cls.packet_sizes)
         cls.create_fragments()
 
         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()
         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,
     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,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10)
         self.sleep(.25)
         self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
                                     expire_walk_interval_ms=10)
         self.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()
                                     expire_walk_interval_ms=10000)
 
     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"))
 
         self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
         self.logger.debug(self.vapi.ppcli("show buffers"))
 


@@ -258,7 +269,8 @@ class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase):
         cls.pkt_infos = []
         for index, info in six.iteritems(infos):
             p = info.data
         cls.pkt_infos = []
         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 = [
             fragments_400 = fragment_rfc791(p, 400)
             fragments_300 = fragment_rfc791(p, 300)
             fragments_200 = [


@@ -293,6 +305,37 @@ class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase):
         stream = self.__class__.fragments_200
         super(TestIPv4Reassembly, self).test_random(family, stream)
 
         stream = self.__class__.fragments_200
         super(TestIPv4Reassembly, self).test_random(family, stream)
 

+    def test_long_fragment_chain(self):
+        """ long fragment chain """
+
+        error_cnt_str = \
+            "/err/ip4-reassembly-feature/fragment chain too long (drop)"
+
+        error_cnt = self.statistics.get_err_counter(error_cnt_str)
+
+        self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
+                                    max_reassembly_length=3,
+                                    expire_walk_interval_ms=50)
+
+        p1 = (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))
+        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))
+        frags = fragment_rfc791(p1, 200) + fragment_rfc791(p2, 500)
+
+        self.pg_enable_capture()
+        self.src_if.add_stream(frags)
+        self.pg_start()
+
+        self.dst_if.get_capture(1)
+        self.assert_error_counter_equal(error_cnt_str, error_cnt + 1)
+

     def test_5737(self):
         """ fragment length + ip header size > 65535 """
         self.vapi.cli("clear errors")
     def test_5737(self):
         """ fragment length + ip header size > 65535 """
         self.vapi.cli("clear errors")


@@ -442,10 +485,10 @@ class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase):
                 # new reassemblies will be started and packet generator will
                 # freak out when it detects unfreed buffers
                 zipped = zip(frags_300, frags_200)
                 # new reassemblies will be started and packet generator will
                 # freak out when it detects unfreed buffers
                 zipped = zip(frags_300, frags_200)

-                for i, j in zipped[:-1]:
+                for i, j in zipped:

                     fragments.extend(i)
                     fragments.extend(j)
                     fragments.extend(i)
                     fragments.extend(j)

-                fragments.append(zipped[-1][0])
+                fragments.pop()

 
         self.pg_enable_capture()
         self.src_if.add_stream(fragments)
 
         self.pg_enable_capture()
         self.src_if.add_stream(fragments)


@@ -496,6 +539,7 @@ class TestIPv4Reassembly(TestIPReassemblyMixin, VppTestCase):
             if len(frags_400) > 1)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
             if len(frags_400) > 1)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=50)
 
         self.pg_enable_capture()
                                     expire_walk_interval_ms=50)
 
         self.pg_enable_capture()


@@ -547,21 +591,29 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
         cls.create_stream(cls.packet_sizes)
         cls.create_fragments()
 
         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()
         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,
     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,

+                                    max_reassembly_length=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=10, is_ip6=1)
         self.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)
         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()
                                     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"))
 
         self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
         self.logger.debug(self.vapi.ppcli("show buffers"))
 


@@ -589,7 +641,8 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
         cls.pkt_infos = []
         for index, info in six.iteritems(infos):
             p = info.data
         cls.pkt_infos = []
         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))
             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))


@@ -632,6 +685,32 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
         ]
         super(TestIPv6Reassembly, self).test_duplicates(family, fragments)
 
         ]
         super(TestIPv6Reassembly, self).test_duplicates(family, fragments)
 

+    def test_long_fragment_chain(self):
+        """ long fragment chain """
+
+        error_cnt_str = \
+            "/err/ip6-reassembly-feature/fragment chain too long (drop)"
+
+        error_cnt = self.statistics.get_err_counter(error_cnt_str)
+
+        self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
+                                    max_reassembly_length=3,
+                                    expire_walk_interval_ms=50, is_ip6=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("X" * 1000))
+        frags = fragment_rfc8200(p, 1, 300) + fragment_rfc8200(p, 2, 500)
+
+        self.pg_enable_capture()
+        self.src_if.add_stream(frags)
+        self.pg_start()
+
+        self.dst_if.get_capture(1)
+        self.assert_error_counter_equal(error_cnt_str, error_cnt + 1)
+

     def test_overlap1(self):
         """ overlapping fragments case #1 (differs from IP test case)"""
 
     def test_overlap1(self):
         """ overlapping fragments case #1 (differs from IP test case)"""
 


@@ -670,10 +749,10 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
                 # new reassemblies will be started and packet generator will
                 # freak out when it detects unfreed buffers
                 zipped = zip(frags_400, frags_300)
                 # new reassemblies will be started and packet generator will
                 # freak out when it detects unfreed buffers
                 zipped = zip(frags_400, frags_300)

-                for i, j in zipped[:-1]:
+                for i, j in zipped:

                     fragments.extend(i)
                     fragments.extend(j)
                     fragments.extend(i)
                     fragments.extend(j)

-                fragments.append(zipped[-1][0])
+                fragments.pop()

 
         dropped_packet_indexes = set(
             index for (index, _, frags) in self.pkt_infos if len(frags) > 1
 
         dropped_packet_indexes = set(
             index for (index, _, frags) in self.pkt_infos if len(frags) > 1


@@ -726,9 +805,11 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
             if len(frags_400) > 1)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
             if len(frags_400) > 1)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=50)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
                                     expire_walk_interval_ms=50)
 
         self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=50, is_ip6=1)
 
         self.pg_enable_capture()
                                     expire_walk_interval_ms=50, is_ip6=1)
 
         self.pg_enable_capture()


@@ -772,7 +853,7 @@ class TestIPv6Reassembly(TestIPReassemblyMixin, VppTestCase):
              Raw())
         self.extend_packet(p, 1000, self.padding)
         fragments = fragment_rfc8200(p, 1, 500)
              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()
         bad_fragment[IPv6ExtHdrFragment].nh = 59
         bad_fragment[IPv6ExtHdrFragment].offset = 0
         self.pg_enable_capture()


@@ -842,17 +923,25 @@ class TestIPv4ReassemblyLocalNode(VppTestCase):
         cls.create_stream()
         cls.create_fragments()
 
         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,
     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,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10)
         self.sleep(.25)
         self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
                                     expire_walk_interval_ms=10)
         self.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()
                                     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"))
 
         self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
         self.logger.debug(self.vapi.ppcli("show buffers"))
 


@@ -880,7 +969,8 @@ class TestIPv4ReassemblyLocalNode(VppTestCase):
         cls.pkt_infos = []
         for index, info in six.iteritems(infos):
             p = info.data
         cls.pkt_infos = []
         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_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]
             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]


@@ -960,6 +1050,10 @@ class TestFIFReassembly(VppTestCase):
         cls.packet_sizes = [64, 512, 1518, 9018]
         cls.padding = " abcdefghijklmn"
 
         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()
     def setUp(self):
         """ Test setup - force timeout on existing reassemblies """
         super(TestFIFReassembly, self).setUp()


@@ -970,20 +1064,26 @@ class TestFIFReassembly(VppTestCase):
             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,
             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,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10)
         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,

+                                    max_reassembly_length=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=10, is_ip6=1)
         self.sleep(.25)
         self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10000)
         self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
                                     expire_walk_interval_ms=10000)
         self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,

+                                    max_reassembly_length=1000,

                                     expire_walk_interval_ms=10000, is_ip6=1)
 
     def tearDown(self):
                                     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"))
         self.logger.debug(self.vapi.ppcli("show buffers"))
         self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
         self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
         self.logger.debug(self.vapi.ppcli("show buffers"))

-        super(TestFIFReassembly, self).tearDown()

 
     def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]):
         """Verify captured packet stream.
 
     def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]):
         """Verify captured packet stream.


@@ -1094,7 +1194,7 @@ class TestFIFReassembly(VppTestCase):
         # it shared for multiple test cases
         self.tun_ip6 = "1002::1"
 
         # it shared for multiple test cases
         self.tun_ip6 = "1002::1"
 

-        self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6)
+        self.gre6 = VppGreInterface(self, self.src_if.local_ip6, self.tun_ip6)

         self.gre6.add_vpp_config()
         self.gre6.admin_up()
         self.gre6.config_ip6()
         self.gre6.add_vpp_config()
         self.gre6.admin_up()
         self.gre6.config_ip6()


@@ -1103,10 +1203,9 @@ class TestFIFReassembly(VppTestCase):
             sw_if_index=self.gre6.sw_if_index, enable_ip6=True)
 
         self.route6 = VppIpRoute(self, self.tun_ip6, 128,
             sw_if_index=self.gre6.sw_if_index, enable_ip6=True)
 
         self.route6 = VppIpRoute(self, self.tun_ip6, 128,

-                                 [VppRoutePath(self.src_if.remote_ip6,
-                                               self.src_if.sw_if_index,
-                                               proto=DpoProto.DPO_PROTO_IP6)],
-                                 is_ip6=1)
+                                 [VppRoutePath(
+                                     self.src_if.remote_ip6,
+                                     self.src_if.sw_if_index)])

         self.route6.add_vpp_config()
 
         self.reset_packet_infos()
         self.route6.add_vpp_config()
 
         self.reset_packet_infos()