summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/Makefile3
-rw-r--r--test/framework.py22
-rw-r--r--test/hook.py14
-rw-r--r--test/patches/scapy-2.3.3/inet6.py.patch25
-rwxr-xr-xtest/sys_req/set_system_parameters.sh57
-rw-r--r--test/sys_req/system_parameters18
-rw-r--r--test/test_reassembly.py966
-rw-r--r--test/util.py195
-rw-r--r--test/vpp_gre_interface.py28
-rw-r--r--test/vpp_interface.py12
-rw-r--r--test/vpp_lo_interface.py12
-rw-r--r--test/vpp_papi_provider.py23
-rw-r--r--test/vpp_punt_socket.py75
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))