IPv4/6 reassembly

Change-Id: Ic5dcadd13c88b8a5e7896dab82404509c081614a
Signed-off-by: Klement Sekera <ksekera@cisco.com>

13 files changed, 1392 insertions, 58 deletions

diff --git a/test/Makefile b/test/Makefile
index f3b7f5c6d51..155325a9f17 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -88,7 +88,7 @@ $(PAPI_INSTALL_DONE): $(PIP_PATCH_DONE)
 	@touch $@
 
 define retest-func
-	@env VPP_TEST_FAILED_DIR=$(VPP_TEST_FAILED_DIR) scripts/setsid_wrapper.sh $(FORCE_FOREGROUND) $(PYTHON_VENV_PATH)/bin/activate python run_tests.py -d $(TEST_DIR) $(UNITTEST_EXTRA_OPTS) || env VPP_TEST_FAILED_DIR=$(VPP_TEST_FAILED_DIR) COMPRESS_FAILED_TEST_LOGS=$(COMPRESS_FAILED_TEST_LOGS) scripts/compress_failed.sh
+@env VPP_TEST_FAILED_DIR=$(VPP_TEST_FAILED_DIR) scripts/setsid_wrapper.sh $(FORCE_FOREGROUND) $(PYTHON_VENV_PATH)/bin/activate python run_tests.py -d $(TEST_DIR) $(UNITTEST_EXTRA_OPTS) || env VPP_TEST_FAILED_DIR=$(VPP_TEST_FAILED_DIR) COMPRESS_FAILED_TEST_LOGS=$(COMPRESS_FAILED_TEST_LOGS) scripts/compress_failed.sh
 endef
 
 .PHONY: sanity
@@ -103,6 +103,7 @@ endif
 
 sanity: verify-no-running-vpp
 	@sys_req/dev_shm_size.sh
+	@sys_req/set_system_parameters.sh sys_req/system_parameters
 	@bash -c "$(SANITY_IMPORT_VPP_PAPI_CMD) ||\
 		(echo \"*******************************************************************\" &&\
 		 echo \"* Sanity check failed, cannot import vpp_papi\" &&\
diff --git a/test/framework.py b/test/framework.py
index 2e3f9781e5d..fc6f550184f 100644
--- a/test/framework.py
+++ b/test/framework.py
@@ -24,6 +24,7 @@ from vpp_lo_interface import VppLoInterface
 from vpp_papi_provider import VppPapiProvider
 from log import *
 from vpp_object import VppObjectRegistry
+from vpp_punt_socket import vpp_uds_socket_name
 if os.name == 'posix' and sys.version_info[0] < 3:
     # using subprocess32 is recommended by python official documentation
     # @ https://docs.python.org/2/library/subprocess.html
@@ -255,7 +256,8 @@ class VppTestCase(unittest.TestCase):
                            coredump_size, "}", "api-trace", "{", "on", "}",
                            "api-segment", "{", "prefix", cls.shm_prefix, "}",
                            "plugins", "{", "plugin", "dpdk_plugin.so", "{",
-                           "disable", "}", "}"]
+                           "disable", "}", "}",
+                           "punt", "{", "socket", cls.punt_socket_path, "}"]
         if plugin_path is not None:
             cls.vpp_cmdline.extend(["plugin_path", plugin_path])
         cls.logger.info("vpp_cmdline: %s" % cls.vpp_cmdline)
@@ -317,7 +319,7 @@ class VppTestCase(unittest.TestCase):
         Remove shared memory files, start vpp and connect the vpp-api
         """
         gc.collect()  # run garbage collection first
-        random.seed()
+        random.seed(1)
         cls.logger = getLogger(cls.__name__)
         cls.tempdir = tempfile.mkdtemp(
             prefix='vpp-unittest-%s-' % cls.__name__)
@@ -328,6 +330,7 @@ class VppTestCase(unittest.TestCase):
         cls.file_handler.setLevel(DEBUG)
         cls.logger.addHandler(cls.file_handler)
         cls.shm_prefix = cls.tempdir.split("/")[-1]
+        cls.punt_socket_path = '%s/%s' % (cls.tempdir, vpp_uds_socket_name)
         os.chdir(cls.tempdir)
         cls.logger.info("Temporary dir is %s, shm prefix is %s",
                         cls.tempdir, cls.shm_prefix)
@@ -499,13 +502,16 @@ class VppTestCase(unittest.TestCase):
         type(self).test_instance = self
 
     @classmethod
-    def pg_enable_capture(cls, interfaces):
+    def pg_enable_capture(cls, interfaces=None):
         """
         Enable capture on packet-generator interfaces
 
-        :param interfaces: iterable interface indexes
+        :param interfaces: iterable interface indexes (if None,
+                           use self.pg_interfaces)
 
         """
+        if interfaces is None:
+            interfaces = cls.pg_interfaces
         for i in interfaces:
             i.enable_capture()
 
@@ -573,19 +579,21 @@ class VppTestCase(unittest.TestCase):
         return result
 
     @staticmethod
-    def extend_packet(packet, size):
+    def extend_packet(packet, size, padding=' '):
         """
-        Extend packet to given size by padding with spaces
+        Extend packet to given size by padding with spaces or custom padding
         NOTE: Currently works only when Raw layer is present.
 
         :param packet: packet
         :param size: target size
+        :param padding: padding used to extend the payload
 
         """
         packet_len = len(packet) + 4
         extend = size - packet_len
         if extend > 0:
-            packet[Raw].load += ' ' * extend
+            num = (extend / len(padding)) + 1
+            packet[Raw].load += (padding * num)[:extend]
 
     @classmethod
     def reset_packet_infos(cls):
diff --git a/test/hook.py b/test/hook.py
index 77a2fc5bb23..0ef1377ba99 100644
--- a/test/hook.py
+++ b/test/hook.py
@@ -2,7 +2,7 @@ import signal
 import os
 import traceback
 from log import RED, single_line_delim, double_line_delim
-from debug import spawn_gdb, gdb_path
+from debug import spawn_gdb
 
 
 class Hook(object):
@@ -62,14 +62,10 @@ class PollHook(Hook):
 
     def on_crash(self, core_path):
         if self.testcase.debug_core:
-            if not spawn_gdb(self.testcase.vpp_bin, core_path, self.logger):
-                self.logger.error(
-                    "Debugger '%s' does not exist or is not an executable.." %
-                    gdb_path)
-            else:
-                return
-        self.logger.critical("Core file present, debug with: gdb %s %s" %
-                             (self.testcase.vpp_bin, core_path))
+            spawn_gdb(self.testcase.vpp_bin, core_path, self.logger)
+        else:
+            self.logger.critical("Core file present, debug with: gdb %s %s" %
+                                 (self.testcase.vpp_bin, core_path))
 
     def poll_vpp(self):
         """
diff --git a/test/patches/scapy-2.3.3/inet6.py.patch b/test/patches/scapy-2.3.3/inet6.py.patch
index cf3217eb672..706e19738c4 100644
--- a/test/patches/scapy-2.3.3/inet6.py.patch
+++ b/test/patches/scapy-2.3.3/inet6.py.patch
@@ -1,7 +1,8 @@
 diff --git a/scapy/layers/inet6.py b/scapy/layers/inet6.py
---- a/scapy/layers/inet6.py	2017-06-01 14:04:18.160881034 +0200
-+++ b/scapy/layers/inet6.py	2017-06-02 09:08:40.133800208 +0200
-@@ -369,6 +369,8 @@
+index 03b80ec..06ef27f 100644
+--- a/scapy/layers/inet6.py
++++ b/scapy/layers/inet6.py
+@@ -369,6 +369,8 @@ class _IPv6GuessPayload:
              return Raw
          elif self.nh == 135 and len(p) > 3: # Mobile IPv6
              return _mip6_mhtype2cls.get(ord(p[2]), MIP6MH_Generic)
@@ -9,11 +10,11 @@ diff --git a/scapy/layers/inet6.py b/scapy/layers/inet6.py
 +            return IPv6ExtHdrSegmentRouting
          else:
              return get_cls(ipv6nhcls.get(self.nh,"Raw"), "Raw")
-
-@@ -430,6 +432,14 @@
+ 
+@@ -430,6 +432,14 @@ class IPv6(_IPv6GuessPayload, Packet, IPTools):
                      sd = strxor(sd, a)
                  sd = inet_ntop(socket.AF_INET6, sd)
-
+ 
 +        if self.nh == 43 and isinstance(self.payload, IPv6ExtHdrSegmentRouting):
 +            # With segment routing header (rh == 4), the destination is
 +            # the first address of the IPv6 addresses list
@@ -23,10 +24,10 @@ diff --git a/scapy/layers/inet6.py b/scapy/layers/inet6.py
 +                sd = self.dst
 +
          if self.nh == 44 and isinstance(self.payload, IPv6ExtHdrFragment):
-             nh = self.payload.nh
-
-@@ -489,6 +499,8 @@
-             return self.payload.answers(other.payload.payload)
+             nh = self.payload.nh 
+ 
+@@ -489,6 +499,8 @@ class IPv6(_IPv6GuessPayload, Packet, IPTools):
+             return self.payload.answers(other.payload.payload) 
          elif other.nh == 43 and isinstance(other.payload, IPv6ExtHdrRouting):
              return self.payload.answers(other.payload.payload) # Buggy if self.payload is a IPv6ExtHdrRouting
 +        elif other.nh == 43 and isinstance(other.payload, IPv6ExtHdrSegmentRouting):
@@ -34,10 +35,10 @@ diff --git a/scapy/layers/inet6.py b/scapy/layers/inet6.py
          elif other.nh == 60 and isinstance(other.payload, IPv6ExtHdrDestOpt):
              return self.payload.payload.answers(other.payload.payload)
          elif self.nh == 60 and isinstance(self.payload, IPv6ExtHdrDestOpt): # BU in reply to BRR, for instance
-@@ -919,6 +931,148 @@
+@@ -919,6 +931,148 @@ class IPv6ExtHdrRouting(_IPv6ExtHdr):
              pkt = pkt[:3]+struct.pack("B", len(self.addresses))+pkt[4:]
          return _IPv6ExtHdr.post_build(self, pkt, pay)
-
+ 
 +######################### Segment Routing Header ############################
 +
 +# This implementation is based on draft 06, available at:
diff --git a/test/sys_req/set_system_parameters.sh b/test/sys_req/set_system_parameters.sh
new file mode 100755
index 00000000000..533a02edbaa
--- /dev/null
+++ b/test/sys_req/set_system_parameters.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+
+file="$1"
+
+usage(){
+	echo "Usage: $0 <requirements file>"
+}
+
+if [ "$file" == "" ]
+then
+	echo "Invalid parameters specified."
+	usage
+	exit 1
+fi
+
+if [ ! -f $file ]
+then
+	echo "File '$file' does not exist."
+	usage
+	exit 1
+fi
+
+cat $file | grep -v -e '^#.*$' | grep -v -e '^ *$' | while read line
+do
+	value_file=`echo $line | awk '{print $1}'`
+	operator=`echo $line | awk '{print $2}'`
+	value=`echo $line | awk '{print $3}'`
+	set_value=`echo $line | awk '{print $4}'`
+	if [[ "$value_file" == "" || "$operator" == "" || "$value" == "" || "$set_value" == "" ]]
+	then
+		echo "Syntax error in requirements file."
+		exit 1
+	fi
+	current_value=`cat $value_file`
+	if test "$current_value" $operator "$value"
+	then
+		if test "$V" = "2"
+		then
+			echo "Requirement '$value_file $operator $value' satisfied."
+		fi
+	else
+		echo "Requirement '$value_file $operator $value' not satisfied."
+		echo "Writing '$set_value' to '$value_file'."
+		echo "$set_value" | tee "$value_file" > /dev/null
+		if ! test "`cat $value_file`" = "$set_value"
+		then
+			echo "Repeating the write using sudo..."
+			echo "$set_value" | sudo -n tee "$value_file" > /dev/null
+			if ! test "`cat $value_file`" = "$set_value"
+			then
+				echo "Couldn't set the required value. Is that value allowed? Is sudo working?"
+				exit 1
+			fi
+		fi
+		echo "Succesfully wrote '$set_value' to '$value_file'."
+	fi
+done
diff --git a/test/sys_req/system_parameters b/test/sys_req/system_parameters
new file mode 100644
index 00000000000..6373774dd94
--- /dev/null
+++ b/test/sys_req/system_parameters
@@ -0,0 +1,18 @@
+# test framework system requirements
+# format of this file is
+# <path> <operator> <comparison-value> <set-value>
+#
+# path - path to value e.g. in /proc which needs to be checked
+# operator - test operator (e.g. -gt)
+# comparison-value - value, against which the value read from <path> is compared
+# set-value - value, to which the path is set if the test fails
+#
+# the comparison is done using `test' command
+
+
+# test_reassembly.py
+# needed by test_reassembly which uses udp punt via unix domain sockets
+# to ensure that all data which vpp might produce in a burst fits into
+# the socket send buffer
+/proc/sys/net/core/wmem_max -ge 4636252 4636252
+/proc/sys/net/core/wmem_default -ge 4636252 4636252
diff --git a/test/test_reassembly.py b/test/test_reassembly.py
new file mode 100644
index 00000000000..a2d77d493de
--- /dev/null
+++ b/test/test_reassembly.py
@@ -0,0 +1,966 @@
+#!/usr/bin/env python
+import unittest
+from random import shuffle
+
+from framework import VppTestCase, VppTestRunner
+
+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 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
+
+test_packet_count = 257
+
+
+class TestIPv4Reassembly(VppTestCase):
+    """ IPv4 Reassembly """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestIPv4Reassembly, cls).setUpClass()
+
+        cls.create_pg_interfaces([0])
+        cls.pg_if = cls.pg0
+
+        # setup all interfaces
+        for i in cls.pg_interfaces:
+            i.admin_up()
+            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"
+        cls.create_stream(cls.packet_sizes)
+        cls.create_fragments()
+
+    def setUp(self):
+        """ Test setup - force timeout on existing reassemblies """
+        super(TestIPv4Reassembly, 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(TestIPv4Reassembly, self).tearDown()
+        self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
+
+    @classmethod
+    def create_stream(cls, packet_sizes, 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.pg_if, cls.pg_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) /
+                 Raw(payload))
+            size = packet_sizes[(i // 2) % len(packet_sizes)]
+            cls.extend_packet(p, size, cls.padding)
+            info.data = p
+
+    @classmethod
+    def create_fragments(cls):
+        infos = cls._packet_infos
+        cls.pkt_infos = []
+        for index, info in infos.iteritems():
+            p = info.data
+            # self.logger.debug(ppp("Packet:", p.__class__(str(p))))
+            fragments_400 = fragment_rfc791(p, 400)
+            fragments_300 = fragment_rfc791(p, 300)
+            fragments_200 = [
+                x for f in fragments_400 for x in fragment_rfc791(f, 200)]
+            cls.pkt_infos.append(
+                (index, fragments_400, fragments_300, fragments_200))
+        cls.fragments_400 = [
+            x for (_, frags, _, _) in cls.pkt_infos for x in frags]
+        cls.fragments_300 = [
+            x for (_, _, frags, _) in cls.pkt_infos for x in frags]
+        cls.fragments_200 = [
+            x for (_, _, _, frags) in cls.pkt_infos for x in frags]
+        cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
+                         "%s 300-byte fragments and %s 200-byte fragments" %
+                         (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:
+                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))
+                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.pg_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:
+                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):
+        """ basic reassembly """
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_200)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_200)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_reversed(self):
+        """ reverse order reassembly """
+
+        fragments = list(self.fragments_200)
+        fragments.reverse()
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_random(self):
+        """ random order reassembly """
+
+        fragments = list(self.fragments_200)
+        shuffle(fragments)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_duplicates(self):
+        """ duplicate fragments """
+
+        fragments = [
+            x for (_, frags, _, _) in self.pkt_infos
+            for x in frags
+            for _ in range(0, min(2, len(frags)))
+        ]
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_overlap1(self):
+        """ overlapping fragments case #1 """
+
+        fragments = []
+        for _, _, frags_300, frags_200 in self.pkt_infos:
+            if len(frags_300) == 1:
+                fragments.extend(frags_300)
+            else:
+                for i, j in zip(frags_200, frags_300):
+                    fragments.extend(i)
+                    fragments.extend(j)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_overlap2(self):
+        """ overlapping fragments case #2 """
+
+        fragments = []
+        for _, _, frags_300, frags_200 in self.pkt_infos:
+            if len(frags_300) == 1:
+                fragments.extend(frags_300)
+            else:
+                # care must be taken here so that there are no fragments
+                # 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_300, frags_200)
+                for i, j in zipped[:-1]:
+                    fragments.extend(i)
+                    fragments.extend(j)
+                fragments.append(zipped[-1][0])
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_timeout_inline(self):
+        """ timeout (inline) """
+
+        dropped_packet_indexes = set(
+            index for (index, frags, _, _) in self.pkt_infos if len(frags) > 1
+        )
+
+        self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
+                                    expire_walk_interval_ms=10000)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_if.assert_nothing_captured()
+
+    def test_timeout_cleanup(self):
+        """ timeout (cleanup) """
+
+        # whole packets + fragmented packets sans last fragment
+        fragments = [
+            x for (_, frags_400, _, _) in self.pkt_infos
+            for x in frags_400[:-1 if len(frags_400) > 1 else None]
+        ]
+
+        # last fragments for fragmented packets
+        fragments2 = [frags_400[-1]
+                      for (_, frags_400, _, _) in self.pkt_infos
+                      if len(frags_400) > 1]
+
+        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=100, max_reassemblies=1000,
+                                    expire_walk_interval_ms=50)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        self.sleep(.25, "wait before sending rest of fragments")
+
+        self.pg_if.add_stream(fragments2)
+        self.pg_start()
+        self.sleep(.25, "wait for vpp to process packets")
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_if.assert_nothing_captured()
+
+    def test_disabled(self):
+        """ reassembly disabled """
+
+        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.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_if.assert_nothing_captured()
+
+
+class TestIPv6Reassembly(VppTestCase):
+    """ IPv6 Reassembly """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestIPv6Reassembly, cls).setUpClass()
+
+        cls.create_pg_interfaces([0])
+        cls.pg_if = cls.pg0
+
+        # setup all interfaces
+        for i in cls.pg_interfaces:
+            i.admin_up()
+            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"
+        cls.create_stream(cls.packet_sizes)
+        cls.create_fragments()
+
+    def setUp(self):
+        """ Test setup - force timeout on existing reassemblies """
+        super(TestIPv6Reassembly, self).setUp()
+        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)
+
+    def tearDown(self):
+        super(TestIPv6Reassembly, self).tearDown()
+        self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
+
+    @classmethod
+    def create_stream(cls, packet_sizes, 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.pg_if, cls.pg_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) /
+                 Raw(payload))
+            size = packet_sizes[(i // 2) % len(packet_sizes)]
+            cls.extend_packet(p, size, cls.padding)
+            info.data = p
+
+    @classmethod
+    def create_fragments(cls):
+        infos = cls._packet_infos
+        cls.pkt_infos = []
+        for index, info in infos.iteritems():
+            p = info.data
+            # self.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))
+        cls.fragments_400 = [
+            x for _, frags, _ in cls.pkt_infos for x in frags]
+        cls.fragments_300 = [
+            x for _, _, frags in cls.pkt_infos for x in frags]
+        cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
+                         "and %s 300-byte fragments" %
+                         (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:
+                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))
+                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.pg_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:
+                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):
+        """ basic reassembly """
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_reversed(self):
+        """ reverse order reassembly """
+
+        fragments = list(self.fragments_400)
+        fragments.reverse()
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_random(self):
+        """ random order reassembly """
+
+        fragments = list(self.fragments_400)
+        shuffle(fragments)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+        # run it all again to verify correctness
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_duplicates(self):
+        """ duplicate fragments """
+
+        fragments = [
+            x for (_, frags, _) in self.pkt_infos
+            for x in frags
+            for _ in range(0, min(2, len(frags)))
+        ]
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+        self.verify_capture(packets)
+        self.pg_if.assert_nothing_captured()
+
+    def test_overlap1(self):
+        """ overlapping fragments case #1 """
+
+        fragments = []
+        for _, frags_400, frags_300 in self.pkt_infos:
+            if len(frags_300) == 1:
+                fragments.extend(frags_400)
+            else:
+                for i, j in zip(frags_300, frags_400):
+                    fragments.extend(i)
+                    fragments.extend(j)
+
+        dropped_packet_indexes = set(
+            index for (index, _, frags) in self.pkt_infos if len(frags) > 1
+        )
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        self.sleep(.1, "wait for vpp to process packets")
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_if.assert_nothing_captured()
+
+    def test_overlap2(self):
+        """ overlapping fragments case #2 """
+
+        fragments = []
+        for _, frags_400, frags_30 in self.pkt_infos:
+            if len(frags_400) == 1:
+                fragments.extend(frags_400)
+            else:
+                # care must be taken here so that there are no fragments
+                # 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)
+                for i, j in zipped[:-1]:
+                    fragments.extend(i)
+                    fragments.extend(j)
+                fragments.append(zipped[-1][0])
+
+        dropped_packet_indexes = set(
+            index for (index, _, frags) in self.pkt_infos if len(frags) > 1
+        )
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        self.sleep(.1, "wait for vpp to process packets")
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_if.assert_nothing_captured()
+
+    def test_timeout_inline(self):
+        """ timeout (inline) """
+
+        dropped_packet_indexes = set(
+            index for (index, frags, _) in self.pkt_infos if len(frags) > 1
+        )
+
+        self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
+                                    expire_walk_interval_ms=10000, is_ip6=1)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        pkts = self.pg_if.get_capture(
+            expected_count=len(dropped_packet_indexes))
+        for icmp in pkts:
+            self.assertIn(ICMPv6TimeExceeded, icmp)
+            self.assertIn(IPv6ExtHdrFragment, icmp)
+            self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
+            dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
+
+    def test_timeout_cleanup(self):
+        """ timeout (cleanup) """
+
+        # whole packets + fragmented packets sans last fragment
+        fragments = [
+            x for (_, frags_400, _) in self.pkt_infos
+            for x in frags_400[:-1 if len(frags_400) > 1 else None]
+        ]
+
+        # last fragments for fragmented packets
+        fragments2 = [frags_400[-1]
+                      for (_, frags_400, _) in self.pkt_infos
+                      if len(frags_400) > 1]
+
+        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=100, max_reassemblies=1000,
+                                    expire_walk_interval_ms=50)
+
+        self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
+                                    expire_walk_interval_ms=50, is_ip6=1)
+
+        self.pg_enable_capture()
+        self.pg_if.add_stream(fragments)
+        self.pg_start()
+
+        self.sleep(.25, "wait before sending rest of fragments")
+
+        self.pg_if.add_stream(fragments2)
+        self.pg_start()
+        self.sleep(.25, "wait for vpp to process packets")
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        pkts = self.pg_if.get_capture(
+            expected_count=len(dropped_packet_indexes))
+        for icmp in pkts:
+            self.assertIn(ICMPv6TimeExceeded, icmp)
+            self.assertIn(IPv6ExtHdrFragment, icmp)
+            self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
+            dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
+
+    def test_disabled(self):
+        """ reassembly disabled """
+
+        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.pg_if.add_stream(self.fragments_400)
+        self.pg_start()
+
+        packets = self.punt_socket.wait_for_packets(
+            len(self.pkt_infos) - len(dropped_packet_indexes))
+        self.verify_capture(packets, dropped_packet_indexes)
+        self.pg_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) /
+             Raw())
+        self.extend_packet(p, 1000, self.padding)
+        fragments = fragment_rfc8200(p, 1, 500)
+        bad_fragment = p.__class__(str(fragments[1]))
+        bad_fragment[IPv6ExtHdrFragment].nh = 59
+        bad_fragment[IPv6ExtHdrFragment].offset = 0
+        self.pg_enable_capture()
+        self.pg_if.add_stream([bad_fragment])
+        self.pg_start()
+        pkts = self.pg_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) /
+             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.pg_start()
+        pkts = self.pg_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) /
+             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.pg_start()
+        pkts = self.pg_if.get_capture(expected_count=1)
+        icmp = pkts[0]
+        self.assertIn(ICMPv6ParamProblem, icmp)
+        self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
+
+
+class TestFIFReassembly(VppTestCase):
+    """ Fragments in fragments reassembly """
+
+    @classmethod
+    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.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_set(timeout_ms=0, max_reassemblies=1000,
+                                    expire_walk_interval_ms=10)
+        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)
+        self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
+                                    expire_walk_interval_ms=10000, is_ip6=1)
+
+    def 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()
+
+    def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]):
+        """Verify captured packet stream.
+
+        :param list capture: Captured packet stream.
+        """
+        info = None
+        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))
+                ip = packet[ip_class]
+                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.pg_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_class].src)
+                self.assertEqual(ip.dst, saved_packet[ip_class].dst)
+                self.assertEqual(udp.payload, saved_packet[UDP].payload)
+            except:
+                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_fif4(self):
+        """ Fragments in fragments (4o4) """
+
+        # TODO this should be ideally in setUpClass, but then we hit a bug
+        # with VppIpRoute incorrectly reporting it's present when it's not
+        # so we need to manually remove the vpp config, thus we cannot have
+        # 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.add_vpp_config()
+        self.gre4.admin_up()
+        self.gre4.config_ip4()
+
+        self.route4 = VppIpRoute(self, self.tun_ip4, 32,
+                                 [VppRoutePath(self.pg0.remote_ip4,
+                                               self.pg0.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)
+            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) /
+                 Raw(payload))
+            size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
+            self.extend_packet(p, size, self.padding)
+            info.data = p
+
+        fragments = [x for _, p in self._packet_infos.iteritems()
+                     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) /
+                GRE() /
+                p
+                for p in fragments]
+
+        fragmented_encapped_fragments = \
+            [x for p in encapped_fragments
+             for x in fragment_rfc791(p, 200)]
+
+        self.pg0.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.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()
+
+    def test_fif6(self):
+        """ Fragments in fragments (6o6) """
+        # TODO this should be ideally in setUpClass, but then we hit a bug
+        # with VppIpRoute incorrectly reporting it's present when it's not
+        # so we need to manually remove the vpp config, thus we cannot have
+        # it shared for multiple test cases
+        self.tun_ip6 = "1002::1"
+
+        self.gre6 = VppGre6Interface(self, self.pg0.local_ip6, self.tun_ip6)
+        self.gre6.add_vpp_config()
+        self.gre6.admin_up()
+        self.gre6.config_ip6()
+
+        self.route6 = VppIpRoute(self, self.tun_ip6, 128,
+                                 [VppRoutePath(self.pg0.remote_ip6,
+                                               self.pg0.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)
+            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) /
+                 Raw(payload))
+            size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
+            self.extend_packet(p, size, self.padding)
+            info.data = p
+
+        fragments = [x for _, i in self._packet_infos.iteritems()
+                     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) /
+                GRE() /
+                p
+                for p in fragments]
+
+        fragmented_encapped_fragments = \
+            [x for p in encapped_fragments for x in (
+                fragment_rfc8200(
+                    p,
+                    2 * len(self._packet_infos) + p[IPv6ExtHdrFragment].id,
+                    200)
+                if IPv6ExtHdrFragment in p else [p]
+            )
+            ]
+
+        self.pg0.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.verify_capture(packets, IPv6)
+
+        # TODO remove gre vpp config by hand until VppIpRoute gets fixed
+        # so that it's query_vpp_config() works as it should
+        self.gre6.remove_vpp_config()
+
+
+if __name__ == '__main__':
+    unittest.main(testRunner=VppTestRunner)
diff --git a/test/util.py b/test/util.py
index 3e0267a3f4d..512bf9e3b7e 100644
--- a/test/util.py
+++ b/test/util.py
@@ -8,10 +8,10 @@ from scapy.layers.inet6 import in6_mactoifaceid
 
 from scapy.layers.l2 import Ether
 from scapy.packet import Raw
-from scapy.layers.inet import IP, UDP, TCP
-from scapy.layers.inet6 import IPv6, ICMPv6Unknown, ICMPv6EchoRequest
-from scapy.packet import Packet
-from socket import inet_pton, AF_INET, AF_INET6
+from scapy.layers.inet import IP
+from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, IPv6ExtHdrRouting,\
+    IPv6ExtHdrHopByHop
+from socket import AF_INET6
 
 
 def ppp(headline, packet):
@@ -37,8 +37,7 @@ def ppc(headline, capture, limit=10):
     tail = ""
     if limit < len(capture):
         tail = "\nPrint limit reached, %s out of %s packets printed" % (
-            len(capture), limit)
-        limit = len(capture)
+            limit, len(capture))
     body = "".join([ppp("Packet #%s:" % count, p)
                     for count, p in zip(range(0, limit), capture)])
     return "%s\n%s%s" % (headline, body, tail)
@@ -174,6 +173,7 @@ class ForeignAddressFactory(object):
 
 class L4_Conn():
     """ L4 'connection' tied to two VPP interfaces """
+
     def __init__(self, testcase, if1, if2, af, l4proto, port1, port2):
         self.testcase = testcase
         self.ifs = [None, None]
@@ -189,7 +189,7 @@ class L4_Conn():
     def pkt(self, side, l4args={}, payload="x"):
         is_ip6 = 1 if self.address_family == AF_INET6 else 0
         s0 = side
-        s1 = 1-side
+        s1 = 1 - side
         src_if = self.ifs[s0]
         dst_if = self.ifs[s1]
         layer_3 = [IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4),
@@ -208,7 +208,7 @@ class L4_Conn():
             l4args['flags'] = flags
         self.ifs[side].add_stream(self.pkt(side,
                                            l4args=l4args, payload=payload))
-        self.ifs[1-side].enable_capture()
+        self.ifs[1 - side].enable_capture()
         self.testcase.pg_start()
 
     def recv(self, side):
@@ -217,15 +217,190 @@ class L4_Conn():
 
     def send_through(self, side, flags=None, payload=""):
         self.send(side, flags, payload)
-        p = self.recv(1-side)
+        p = self.recv(1 - side)
         return p
 
     def send_pingpong(self, side, flags1=None, flags2=None):
         p1 = self.send_through(side, flags1)
-        p2 = self.send_through(1-side, flags2)
+        p2 = self.send_through(1 - side, flags2)
         return [p1, p2]
 
 
 class L4_CONN_SIDE:
     L4_CONN_SIDE_ZERO = 0
     L4_CONN_SIDE_ONE = 1
+
+
+class LoggerWrapper(object):
+    def __init__(self, logger=None):
+        self._logger = logger
+
+    def debug(self, *args, **kwargs):
+        if self._logger:
+            self._logger.debug(*args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        if self._logger:
+            self._logger.error(*args, **kwargs)
+
+
+def fragment_rfc791(packet, fragsize, _logger=None):
+    """
+    Fragment an IPv4 packet per RFC 791
+    :param packet: packet to fragment
+    :param fragsize: size at which to fragment
+    :note: IP options are not supported
+    :returns: list of fragments
+    """
+    logger = LoggerWrapper(_logger)
+    logger.debug(ppp("Fragmenting packet:", packet))
+    packet = packet.__class__(str(packet))  # recalculate all values
+    if len(packet[IP].options) > 0:
+        raise Exception("Not implemented")
+    if len(packet) <= fragsize:
+        return [packet]
+
+    pre_ip_len = len(packet) - len(packet[IP])
+    ip_header_len = packet[IP].ihl * 4
+    hex_packet = str(packet)
+    hex_headers = hex_packet[:(pre_ip_len + ip_header_len)]
+    hex_payload = hex_packet[(pre_ip_len + ip_header_len):]
+
+    pkts = []
+    ihl = packet[IP].ihl
+    otl = len(packet[IP])
+    nfb = (fragsize - pre_ip_len - ihl * 4) / 8
+    fo = packet[IP].frag
+
+    p = packet.__class__(hex_headers + hex_payload[:nfb * 8])
+    p[IP].flags = "MF"
+    p[IP].frag = fo
+    p[IP].len = ihl * 4 + nfb * 8
+    del p[IP].chksum
+    pkts.append(p)
+
+    p = packet.__class__(hex_headers + hex_payload[nfb * 8:])
+    p[IP].len = otl - nfb * 8
+    p[IP].frag = fo + nfb
+    del p[IP].chksum
+
+    more_fragments = fragment_rfc791(p, fragsize, _logger)
+    pkts.extend(more_fragments)
+
+    return pkts
+
+
+def fragment_rfc8200(packet, identification, fragsize, _logger=None):
+    """
+    Fragment an IPv6 packet per RFC 8200
+    :param packet: packet to fragment
+    :param fragsize: size at which to fragment
+    :note: IP options are not supported
+    :returns: list of fragments
+    """
+    logger = LoggerWrapper(_logger)
+    packet = packet.__class__(str(packet))  # recalculate all values
+    if len(packet) <= fragsize:
+        return [packet]
+    logger.debug(ppp("Fragmenting packet:", packet))
+    pkts = []
+    counter = 0
+    routing_hdr = None
+    hop_by_hop_hdr = None
+    upper_layer = None
+    seen_ipv6 = False
+    ipv6_nr = -1
+    l = packet.getlayer(counter)
+    while l is not None:
+        if l.__class__ is IPv6:
+            if seen_ipv6:
+                # ignore 2nd IPv6 header and everything below..
+                break
+            ipv6_nr = counter
+            seen_ipv6 = True
+        elif l.__class__ is IPv6ExtHdrFragment:
+            raise Exception("Already fragmented")
+        elif l.__class__ is IPv6ExtHdrRouting:
+            routing_hdr = counter
+        elif l.__class__ is IPv6ExtHdrHopByHop:
+            hop_by_hop_hdr = counter
+        elif seen_ipv6 and not upper_layer and \
+                not l.__class__.__name__.startswith('IPv6ExtHdr'):
+            upper_layer = counter
+        counter = counter + 1
+        l = packet.getlayer(counter)
+
+    logger.debug(
+        "Layers seen: IPv6(#%s), Routing(#%s), HopByHop(#%s), upper(#%s)" %
+        (ipv6_nr, routing_hdr, hop_by_hop_hdr, upper_layer))
+
+    if upper_layer is None:
+        raise Exception("Upper layer header not found in IPv6 packet")
+
+    last_per_fragment_hdr = ipv6_nr
+    if routing_hdr is None:
+        if hop_by_hop_hdr is not None:
+            last_per_fragment_hdr = hop_by_hop_hdr
+    else:
+        last_per_fragment_hdr = routing_hdr
+    logger.debug("Last per-fragment hdr is #%s" % (last_per_fragment_hdr))
+
+    per_fragment_headers = packet.copy()
+    per_fragment_headers[last_per_fragment_hdr].remove_payload()
+    logger.debug(ppp("Per-fragment headers:", per_fragment_headers))
+
+    ext_and_upper_layer = packet.getlayer(last_per_fragment_hdr)[1]
+    hex_payload = str(ext_and_upper_layer)
+    logger.debug("Payload length is %s" % len(hex_payload))
+    logger.debug(ppp("Ext and upper layer:", ext_and_upper_layer))
+
+    fragment_ext_hdr = IPv6ExtHdrFragment()
+    logger.debug(ppp("Fragment header:", fragment_ext_hdr))
+
+    if len(per_fragment_headers) + len(fragment_ext_hdr) +\
+            len(ext_and_upper_layer) - len(ext_and_upper_layer.payload)\
+            > fragsize:
+        raise Exception("Cannot fragment this packet - MTU too small "
+                        "(%s, %s, %s, %s, %s)" % (
+                            len(per_fragment_headers), len(fragment_ext_hdr),
+                            len(ext_and_upper_layer),
+                            len(ext_and_upper_layer.payload), fragsize))
+
+    orig_nh = packet[IPv6].nh
+    p = per_fragment_headers
+    del p[IPv6].plen
+    del p[IPv6].nh
+    p = p / fragment_ext_hdr
+    del p[IPv6ExtHdrFragment].nh
+    first_payload_len_nfb = (fragsize - len(p)) / 8
+    p = p / Raw(hex_payload[:first_payload_len_nfb * 8])
+    del p[IPv6].plen
+    p[IPv6ExtHdrFragment].nh = orig_nh
+    p[IPv6ExtHdrFragment].id = identification
+    p[IPv6ExtHdrFragment].offset = 0
+    p[IPv6ExtHdrFragment].m = 1
+    p = p.__class__(str(p))
+    logger.debug(ppp("Fragment %s:" % len(pkts), p))
+    pkts.append(p)
+    offset = first_payload_len_nfb * 8
+    logger.debug("Offset after first fragment: %s" % offset)
+    while len(hex_payload) > offset:
+        p = per_fragment_headers
+        del p[IPv6].plen
+        del p[IPv6].nh
+        p = p / fragment_ext_hdr
+        del p[IPv6ExtHdrFragment].nh
+        l_nfb = (fragsize - len(p)) / 8
+        p = p / Raw(hex_payload[offset:offset + l_nfb * 8])
+        p[IPv6ExtHdrFragment].nh = orig_nh
+        p[IPv6ExtHdrFragment].id = identification
+        p[IPv6ExtHdrFragment].offset = offset / 8
+        p[IPv6ExtHdrFragment].m = 1
+        p = p.__class__(str(p))
+        logger.debug(ppp("Fragment %s:" % len(pkts), p))
+        pkts.append(p)
+        offset = offset + l_nfb * 8
+
+    pkts[-1][IPv6ExtHdrFragment].m = 0  # reset more-flags in last fragment
+
+    return pkts
diff --git a/test/vpp_gre_interface.py b/test/vpp_gre_interface.py
index acfd348d64f..998f6eab32b 100644
--- a/test/vpp_gre_interface.py
+++ b/test/vpp_gre_interface.py
@@ -26,14 +26,21 @@ class VppGreInterface(VppInterface):
                                               is_teb=self.t_is_teb)
         self._sw_if_index = r.sw_if_index
         self.generate_remote_hosts()
+        self._test.registry.register(self, self._test.logger)
 
     def remove_vpp_config(self):
         s = socket.inet_pton(socket.AF_INET, self.t_src)
         d = socket.inet_pton(socket.AF_INET, self.t_dst)
         self.unconfig()
-        r = self.test.vapi.gre_tunnel_add_del(s, d,
-                                              outer_fib_id=self.t_outer_fib,
-                                              is_add=0)
+        self.test.vapi.gre_tunnel_add_del(s, d,
+                                          outer_fib_id=self.t_outer_fib,
+                                          is_add=0)
+
+    def __str__(self):
+        return self.object_id()
+
+    def object_id(self):
+        return "gre-%d" % self._sw_if_index
 
 
 class VppGre6Interface(VppInterface):
@@ -60,12 +67,19 @@ class VppGre6Interface(VppInterface):
                                               is_ip6=1)
         self._sw_if_index = r.sw_if_index
         self.generate_remote_hosts()
+        self._test.registry.register(self, self._test.logger)
 
     def remove_vpp_config(self):
         s = socket.inet_pton(socket.AF_INET6, self.t_src)
         d = socket.inet_pton(socket.AF_INET6, self.t_dst)
         self.unconfig()
-        r = self.test.vapi.gre_tunnel_add_del(s, d,
-                                              outer_fib_id=self.t_outer_fib,
-                                              is_add=0,
-                                              is_ip6=1)
+        self.test.vapi.gre_tunnel_add_del(s, d,
+                                          outer_fib_id=self.t_outer_fib,
+                                          is_add=0,
+                                          is_ip6=1)
+
+    def __str__(self):
+        return self.object_id()
+
+    def object_id(self):
+        return "gre-%d" % self._sw_if_index
diff --git a/test/vpp_interface.py b/test/vpp_interface.py
index b8505ce39d7..8891dde6afe 100644
--- a/test/vpp_interface.py
+++ b/test/vpp_interface.py
@@ -372,3 +372,15 @@ class VppInterface(object):
         self.test.vapi.proxy_arp_intfc_enable_disable(
             self.sw_if_index,
             enable)
+
+    def query_vpp_config(self):
+        dump = self.test.vapi.sw_interface_dump()
+        return self.is_interface_config_in_dump(dump)
+
+    def is_interface_config_in_dump(self, dump):
+        for i in dump:
+            if i.interface_name.rstrip(' \t\r\n\0') == self.name and \
+               i.sw_if_index == self.sw_if_index:
+                return True
+        else:
+            return False
diff --git a/test/vpp_lo_interface.py b/test/vpp_lo_interface.py
index 963123f6404..ae4111bec82 100644
--- a/test/vpp_lo_interface.py
+++ b/test/vpp_lo_interface.py
@@ -19,17 +19,5 @@ class VppLoInterface(VppInterface, VppObject):
     def remove_vpp_config(self):
         self.test.vapi.delete_loopback(self.sw_if_index)
 
-    def query_vpp_config(self):
-        dump = self.test.vapi.sw_interface_dump()
-        return self.is_interface_config_in_dump(dump)
-
-    def is_interface_config_in_dump(self, dump):
-        for i in dump:
-            if i.interface_name.rstrip(' \t\r\n\0') == self.name and \
-               i.sw_if_index == self.sw_if_index:
-                return True
-        else:
-            return False
-
     def object_id(self):
         return "loopback-%d" % self._sw_if_index
diff --git a/test/vpp_papi_provider.py b/test/vpp_papi_provider.py
index 0269736cd78..087a14b7fad 100644
--- a/test/vpp_papi_provider.py
+++ b/test/vpp_papi_provider.py
@@ -3102,3 +3102,26 @@ class VppPapiProvider(object):
              'ip6_fib_id': ip6_fib_id,
              'namespace_id': namespace_id,
              'namespace_id_len': len(namespace_id)})
+
+    def punt_socket_register(self, l4_port, pathname, header_version=1,
+                             is_ip4=1, l4_protocol=0x11):
+        """ Punt to socket """
+        return self.api(self.papi.punt_socket_register,
+                        {'is_ip4': is_ip4,
+                         'l4_protocol': l4_protocol,
+                         'l4_port': l4_port,
+                         'pathname': pathname,
+                         'header_version': header_version})
+
+    def ip_reassembly_set(self, timeout_ms, max_reassemblies,
+                          expire_walk_interval_ms, is_ip6=0):
+        """ Set IP reassembly parameters """
+        return self.api(self.papi.ip_reassembly_set,
+                        {'is_ip6': is_ip6,
+                         'timeout_ms': timeout_ms,
+                         'expire_walk_interval_ms': expire_walk_interval_ms,
+                         'max_reassemblies': max_reassemblies})
+
+    def ip_reassembly_get(self, is_ip6=0):
+        """ Get IP reassembly parameters """
+        return self.api(self.papi.ip_reassembly_get, {'is_ip6': is_ip6})
diff --git a/test/vpp_punt_socket.py b/test/vpp_punt_socket.py
new file mode 100644
index 00000000000..5004b23396d
--- /dev/null
+++ b/test/vpp_punt_socket.py
@@ -0,0 +1,75 @@
+from socket import socket, AF_UNIX, SOCK_DGRAM
+from select import select
+from time import time
+from struct import unpack, calcsize
+from util import ppc
+from scapy.layers.l2 import Ether
+
+client_uds_socket_name = "client-uds-socket"
+vpp_uds_socket_name = "vpp-uds-socket"
+
+VPP_PUNT_HEADER_FMT = '=Ii'
+VPP_PUNT_HEADER_SIZE = calcsize(VPP_PUNT_HEADER_FMT)
+
+
+class VppPuntAction:
+    PUNT_L2 = 0
+    PUNT_IP4_ROUTED = 1
+    PUNT_IP6_ROUTED = 2
+
+
+class VppUDSPuntSocket(object):
+    def __init__(self, testcase, port, is_ip4=1, l4_protocol=0x11):
+        client_path = '%s/%s-%s-%s' % (testcase.tempdir,
+                                       client_uds_socket_name,
+                                       "4" if is_ip4 else "6", port)
+        testcase.vapi.punt_socket_register(
+            port, client_path, is_ip4=is_ip4, l4_protocol=l4_protocol)
+        self.testcase = testcase
+        self.uds = socket(AF_UNIX, SOCK_DGRAM)
+        self.uds.bind(client_path)
+        self.uds.connect(testcase.punt_socket_path)
+
+    def wait_for_packets(self, count, timeout=1):
+        packets = []
+        now = time()
+        deadline = now + timeout
+        while len(packets) < count and now < deadline:
+            r, w, e = select([self.uds], [], [self.uds], deadline - now)
+            if self.uds in r:
+                x = self.uds.recv(1024 * 1024)
+                sw_if_index, punt_action = unpack(
+                    VPP_PUNT_HEADER_FMT, x[:VPP_PUNT_HEADER_SIZE])
+                packets.append({'sw_if_index': sw_if_index,
+                                'punt_action': punt_action,
+                                'packet': x[VPP_PUNT_HEADER_SIZE:]})
+
+            if self.uds in e:
+                raise Exception("select() indicates error on UDS socket")
+            now = time()
+
+        if len(packets) != count:
+            raise Exception("Unexpected packet count received, got %s packets,"
+                            " expected %s packets" % (len(packets), count))
+        self.testcase.logger.debug(
+            "Got %s packets via punt socket" % len(packets))
+        return packets
+
+    def assert_nothing_captured(self, timeout=.25):
+        packets = []
+        now = time()
+        deadline = now + timeout
+        while now < deadline:
+            r, w, e = select([self.uds], [], [self.uds], deadline - now)
+            if self.uds in r:
+                x = self.uds.recv(1024 * 1024)
+                packets.append(Ether(x[VPP_PUNT_HEADER_SIZE:]))
+            if self.uds in e:
+                raise Exception("select() indicates error on UDS socket")
+            now = time()
+
+        if len(packets) > 0:
+            self.testcase.logger.error(
+                ppc("Unexpected packets captured:", packets))
+            raise Exception("Unexpected packet count received, got %s packets,"
+                            " expected no packets" % len(packets))