-#!/usr/bin/env python
+#!/usr/bin/env python3
-import six
import unittest
from random import shuffle, choice, randrange
# 35 is enough to have >257 400-byte fragments
test_packet_count = 35
-# number of workers used for multi-worker test cases
-worker_count = 3
-
class TestIPv4Reassembly(VppTestCase):
""" IPv4 Reassembly """
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10000)
def create_fragments(cls):
infos = cls._packet_infos
cls.pkt_infos = []
- for index, info in six.iteritems(infos):
+ for index, info in infos.items():
p = info.data
# cls.logger.debug(ppp("Packet:",
# p.__class__(scapy.compat.raw(p))))
self.verify_capture(packets)
self.src_if.assert_nothing_captured()
+ def test_verify_clear_trace_mid_reassembly(self):
+ """ verify clear trace works mid-reassembly """
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(self.fragments_200[0:-1])
+ self.pg_start()
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.src_if.add_stream(self.fragments_200[-1])
+ self.pg_start()
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
+ self.verify_capture(packets)
+
def test_reversed(self):
""" reverse order reassembly """
IP(id=1000, src=self.src_if.remote_ip4,
dst=self.dst_if.remote_ip4) /
UDP(sport=1234, dport=5678) /
- Raw("X" * 1000))
+ Raw(b"X" * 1000))
p2 = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
IP(id=1001, src=self.src_if.remote_ip4,
dst=self.dst_if.remote_ip4) /
UDP(sport=1234, dport=5678) /
- Raw("X" * 1000))
+ Raw(b"X" * 1000))
frags = fragment_rfc791(p1, 200) + fragment_rfc791(p2, 500)
self.pg_enable_capture()
def test_5737(self):
""" fragment length + ip header size > 65535 """
self.vapi.cli("clear errors")
- raw = ('E\x00\x00\x88,\xf8\x1f\xfe@\x01\x98\x00\xc0\xa8\n-\xc0\xa8\n'
- '\x01\x08\x00\xf0J\xed\xcb\xf1\xf5Test-group: IPv4.IPv4.ipv4-'
- 'message.Ethernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Of'
- 'fset; Test-case: 5737')
-
+ raw = b'''E\x00\x00\x88,\xf8\x1f\xfe@\x01\x98\x00\xc0\xa8\n-\xc0\xa8\n\
+\x01\x08\x00\xf0J\xed\xcb\xf1\xf5Test-group: IPv4.IPv4.ipv4-message.\
+Ethernet-Payload.IPv4-Packet.IPv4-Header.Fragment-Offset; Test-case: 5737'''
malformed_packet = (Ether(dst=self.src_if.local_mac,
src=self.src_if.remote_mac) /
IP(raw))
IP(id=1000, src=self.src_if.remote_ip4,
dst=self.dst_if.remote_ip4) /
UDP(sport=1234, dport=5678) /
- Raw("X" * 1000))
+ Raw(b"X" * 1000))
valid_fragments = fragment_rfc791(p, 400)
+ counter = "/err/ip4-full-reassembly-feature/malformed packets"
+ error_counter = self.statistics.get_err_counter(counter)
self.pg_enable_capture()
self.src_if.add_stream([malformed_packet] + valid_fragments)
self.pg_start()
self.dst_if.get_capture(1)
self.logger.debug(self.vapi.ppcli("show error"))
- self.assert_packet_counter_equal("ip4-full-reassembly-feature", 1)
- # TODO remove above, uncomment below once clearing of counters
- # is supported
- # self.assert_packet_counter_equal(
- # "/err/ip4-full-reassembly-feature/malformed packets", 1)
+ self.assertEqual(self.statistics.get_err_counter(counter),
+ error_counter + 1)
def test_44924(self):
""" compress tiny fragments """
IP(id=7, len=21, frag=1, ttl=64,
src=self.src_if.remote_ip4,
dst=self.dst_if.remote_ip4) /
- Raw(load='\x08')),
+ Raw(load=b'\x08')),
]
p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
IP(id=1000, src=self.src_if.remote_ip4,
dst=self.dst_if.remote_ip4) /
UDP(sport=1234, dport=5678) /
- Raw("X" * 1000))
+ Raw(b"X" * 1000))
valid_fragments = fragment_rfc791(p, 400)
self.pg_enable_capture()
self.src_if.add_stream(fragments)
self.pg_start()
- self.sleep(.25, "wait before sending rest of fragments")
+ self.virtual_sleep(.25, "wait before sending rest of fragments")
self.src_if.add_stream(fragments2)
self.pg_start()
max_reassembly_length=1000,
type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL,
expire_walk_interval_ms=10)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(
timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
self.assertEqual(sent[IP].dst, recvd[IP].dst)
self.assertEqual(sent[Raw].payload, recvd[Raw].payload)
+ def test_verify_clear_trace_mid_reassembly(self):
+ """ verify clear trace works mid-reassembly """
+ payload_len = 1000
+ payload = ""
+ counter = 0
+ while len(payload) < payload_len:
+ payload += "%u " % counter
+ counter += 1
+
+ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IP(id=1, src=self.src_if.remote_ip4,
+ dst=self.dst_if.remote_ip4) /
+ UDP(sport=1234, dport=5678) /
+ Raw(payload))
+ fragments = fragment_rfc791(p, payload_len/4)
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[1])
+ self.pg_start()
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[0])
+ self.pg_start()
+ self.dst_if.get_capture(2)
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[2:])
+ self.pg_start()
+ self.dst_if.get_capture(len(fragments[2:]))
+
def test_timeout(self):
""" reassembly timeout """
payload_len = 1000
self.assertEqual(sent[Raw].payload, recvd[Raw].payload)
# wait for cleanup
- self.sleep(.25, "wait before sending rest of fragments")
+ self.virtual_sleep(.25, "wait before sending rest of fragments")
# send rest of fragments - shouldn't be forwarded
self.pg_enable_capture()
self.assertEqual(sent[IP].dst, recvd[IP].dst)
self.assertEqual(sent[Raw].payload, recvd[Raw].payload)
+ def send_mixed_and_verify_capture(self, traffic):
+ stream = []
+ for t in traffic:
+ for c in range(t['count']):
+ stream.append(
+ (Ether(dst=self.src_if.local_mac,
+ src=self.src_if.remote_mac) /
+ IP(id=self.counter,
+ flags=t['flags'],
+ src=self.src_if.remote_ip4,
+ dst=self.dst_if.remote_ip4) /
+ UDP(sport=1234, dport=5678) /
+ Raw("abcdef")))
+ self.counter = self.counter + 1
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(stream)
+ self.pg_start()
+ self.logger.debug(self.vapi.ppcli("show ip4-sv-reassembly details"))
+ self.logger.debug(self.vapi.ppcli("show buffers"))
+ self.logger.debug(self.vapi.ppcli("show trace"))
+ self.dst_if.get_capture(len(stream))
+
+ def test_mixed(self):
+ """ mixed traffic correctly passes through SVR """
+ self.counter = 1
+
+ self.send_mixed_and_verify_capture([{'count': 1, 'flags': ''}])
+ self.send_mixed_and_verify_capture([{'count': 2, 'flags': ''}])
+ self.send_mixed_and_verify_capture([{'count': 3, 'flags': ''}])
+ self.send_mixed_and_verify_capture([{'count': 8, 'flags': ''}])
+ self.send_mixed_and_verify_capture([{'count': 257, 'flags': ''}])
+
+ self.send_mixed_and_verify_capture([{'count': 1, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture([{'count': 2, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture([{'count': 3, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture([{'count': 8, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture([{'count': 257, 'flags': 'MF'}])
+
+ self.send_mixed_and_verify_capture(
+ [{'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 129, 'flags': ''}, {'count': 129, 'flags': 'MF'}])
+
+ self.send_mixed_and_verify_capture(
+ [{'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'},
+ {'count': 1, 'flags': ''}, {'count': 1, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'},
+ {'count': 2, 'flags': ''}, {'count': 2, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'},
+ {'count': 3, 'flags': ''}, {'count': 3, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'},
+ {'count': 8, 'flags': ''}, {'count': 8, 'flags': 'MF'}])
+ self.send_mixed_and_verify_capture(
+ [{'count': 65, 'flags': ''}, {'count': 65, 'flags': 'MF'},
+ {'count': 65, 'flags': ''}, {'count': 65, 'flags': 'MF'}])
+
class TestIPv4MWReassembly(VppTestCase):
""" IPv4 Reassembly (multiple workers) """
- worker_config = "workers %d" % worker_count
+ vpp_worker_count = 3
@classmethod
def setUpClass(cls):
super(TestIPv4MWReassembly, cls).setUpClass()
- cls.create_pg_interfaces(range(worker_count+1))
+ cls.create_pg_interfaces(range(cls.vpp_worker_count+1))
cls.src_if = cls.pg0
cls.send_ifs = cls.pg_interfaces[:-1]
cls.dst_if = cls.pg_interfaces[-1]
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10000)
def create_fragments(cls):
infos = cls._packet_infos
cls.pkt_infos = []
- for index, info in six.iteritems(infos):
+ for index, info in infos.items():
p = info.data
# cls.logger.debug(ppp("Packet:",
# p.__class__(scapy.compat.raw(p))))
"Packet with packet_index %d not received" % index)
def send_packets(self, packets):
- for counter in range(worker_count):
+ for counter in range(self.vpp_worker_count):
if 0 == len(packets[counter]):
continue
send_if = self.send_ifs[counter]
# in first wave we send fragments which don't start at offset 0
# then we send fragments with offset 0 on a different thread
# then the rest of packets on a random thread
- first_packets = [[] for n in range(worker_count)]
- second_packets = [[] for n in range(worker_count)]
- rest_of_packets = [[] for n in range(worker_count)]
+ first_packets = [[] for n in range(self.vpp_worker_count)]
+ second_packets = [[] for n in range(self.vpp_worker_count)]
+ rest_of_packets = [[] for n in range(self.vpp_worker_count)]
for (_, p) in self.pkt_infos:
- wi = randrange(worker_count)
+ wi = randrange(self.vpp_worker_count)
second_packets[wi].append(p[0])
if len(p) <= 1:
continue
wi2 = wi
while wi2 == wi:
- wi2 = randrange(worker_count)
+ wi2 = randrange(self.vpp_worker_count)
first_packets[wi2].append(p[1])
- wi3 = randrange(worker_count)
+ wi3 = randrange(self.vpp_worker_count)
rest_of_packets[wi3].extend(p[2:])
self.pg_enable_capture()
for send_if in self.send_ifs:
send_if.assert_nothing_captured()
+ self.logger.debug(self.vapi.ppcli("show trace"))
+ self.logger.debug(self.vapi.ppcli("show ip4-full-reassembly details"))
+ self.logger.debug(self.vapi.ppcli("show buffers"))
+ self.vapi.cli("clear trace")
+
self.pg_enable_capture()
self.send_packets(first_packets)
self.send_packets(second_packets)
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10, is_ip6=1)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10000, is_ip6=1)
def create_fragments(cls):
infos = cls._packet_infos
cls.pkt_infos = []
- for index, info in six.iteritems(infos):
+ for index, info in infos.items():
p = info.data
# cls.logger.debug(ppp("Packet:",
# p.__class__(scapy.compat.raw(p))))
self.src_if.assert_nothing_captured()
self.dst_if.assert_nothing_captured()
+ def test_verify_clear_trace_mid_reassembly(self):
+ """ verify clear trace works mid-reassembly """
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(self.fragments_400[0:-1])
+ self.pg_start()
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.src_if.add_stream(self.fragments_400[-1])
+ self.pg_start()
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
+ self.verify_capture(packets)
+
def test_reversed(self):
""" reverse order reassembly """
IPv6(src=self.src_if.remote_ip6,
dst=self.dst_if.remote_ip6) /
UDP(sport=1234, dport=5678) /
- Raw("X" * 1000))
+ Raw(b"X" * 1000))
frags = fragment_rfc8200(p, 1, 300) + fragment_rfc8200(p, 2, 500)
self.pg_enable_capture()
self.src_if.add_stream(fragments)
self.pg_start()
- self.sleep(.25, "wait before sending rest of fragments")
+ self.virtual_sleep(.25, "wait before sending rest of fragments")
self.src_if.add_stream(fragments2)
self.pg_start()
class TestIPv6MWReassembly(VppTestCase):
""" IPv6 Reassembly (multiple workers) """
- worker_config = "workers %d" % worker_count
+ vpp_worker_count = 3
@classmethod
def setUpClass(cls):
super(TestIPv6MWReassembly, cls).setUpClass()
- cls.create_pg_interfaces(range(worker_count+1))
+ cls.create_pg_interfaces(range(cls.vpp_worker_count+1))
cls.src_if = cls.pg0
cls.send_ifs = cls.pg_interfaces[:-1]
cls.dst_if = cls.pg_interfaces[-1]
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10, is_ip6=1)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=1000, is_ip6=1)
def create_fragments(cls):
infos = cls._packet_infos
cls.pkt_infos = []
- for index, info in six.iteritems(infos):
+ for index, info in infos.items():
p = info.data
# cls.logger.debug(ppp("Packet:",
# p.__class__(scapy.compat.raw(p))))
"Packet with packet_index %d not received" % index)
def send_packets(self, packets):
- for counter in range(worker_count):
+ for counter in range(self.vpp_worker_count):
if 0 == len(packets[counter]):
continue
send_if = self.send_ifs[counter]
# in first wave we send fragments which don't start at offset 0
# then we send fragments with offset 0 on a different thread
# then the rest of packets on a random thread
- first_packets = [[] for n in range(worker_count)]
- second_packets = [[] for n in range(worker_count)]
- rest_of_packets = [[] for n in range(worker_count)]
+ first_packets = [[] for n in range(self.vpp_worker_count)]
+ second_packets = [[] for n in range(self.vpp_worker_count)]
+ rest_of_packets = [[] for n in range(self.vpp_worker_count)]
for (_, p) in self.pkt_infos:
- wi = randrange(worker_count)
+ wi = randrange(self.vpp_worker_count)
second_packets[wi].append(p[0])
if len(p) <= 1:
continue
wi2 = wi
while wi2 == wi:
- wi2 = randrange(worker_count)
+ wi2 = randrange(self.vpp_worker_count)
first_packets[wi2].append(p[1])
- wi3 = randrange(worker_count)
+ wi3 = randrange(self.vpp_worker_count)
rest_of_packets[wi3].extend(p[2:])
self.pg_enable_capture()
for send_if in self.send_ifs:
send_if.assert_nothing_captured()
+ self.logger.debug(self.vapi.ppcli("show trace"))
+ self.logger.debug(self.vapi.ppcli("show ip6-full-reassembly details"))
+ self.logger.debug(self.vapi.ppcli("show buffers"))
+ self.vapi.cli("clear trace")
+
self.pg_enable_capture()
self.send_packets(first_packets)
self.send_packets(second_packets)
max_reassembly_length=1000,
type=VppEnum.vl_api_ip_reass_type_t.IP_REASS_TYPE_SHALLOW_VIRTUAL,
expire_walk_interval_ms=10, is_ip6=1)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(
timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
self.assertEqual(sent[IPv6].dst, recvd[IPv6].dst)
self.assertEqual(sent[Raw].payload, recvd[Raw].payload)
+ def test_verify_clear_trace_mid_reassembly(self):
+ """ verify clear trace works mid-reassembly """
+ payload_len = 1000
+ payload = ""
+ counter = 0
+ while len(payload) < payload_len:
+ payload += "%u " % counter
+ counter += 1
+
+ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) /
+ UDP(sport=1234, dport=5678) /
+ Raw(payload))
+ fragments = fragment_rfc8200(p, 1, payload_len/4)
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[1])
+ self.pg_start()
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[0])
+ self.pg_start()
+ self.dst_if.get_capture(2)
+
+ self.logger.debug(self.vapi.cli("show trace"))
+ self.vapi.cli("clear trace")
+
+ self.pg_enable_capture()
+ self.src_if.add_stream(fragments[2:])
+ self.pg_start()
+ self.dst_if.get_capture(len(fragments[2:]))
+
def test_timeout(self):
""" reassembly timeout """
payload_len = 1000
self.assertEqual(sent[Raw].payload, recvd[Raw].payload)
# wait for cleanup
- self.sleep(.25, "wait before sending rest of fragments")
+ self.virtual_sleep(.25, "wait before sending rest of fragments")
# send rest of fragments - shouldn't be forwarded
self.pg_enable_capture()
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10000)
def create_fragments(cls):
infos = cls._packet_infos
cls.pkt_infos = []
- for index, info in six.iteritems(infos):
+ for index, info in infos.items():
p = info.data
# cls.logger.debug(ppp("Packet:",
# p.__class__(scapy.compat.raw(p))))
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10, is_ip6=1)
- self.sleep(.25)
+ self.virtual_sleep(.25)
self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
max_reassembly_length=1000,
expire_walk_interval_ms=10000)
self.extend_packet(p, size, self.padding)
info.data = p[IP] # use only IP part, without ethernet header
- fragments = [x for _, p in six.iteritems(self._packet_infos)
+ fragments = [x for _, p in self._packet_infos.items()
for x in fragment_rfc791(p.data, 400)]
encapped_fragments = \
self.extend_packet(p, size, self.padding)
info.data = p[IPv6] # use only IPv6 part, without ethernet header
- fragments = [x for _, i in six.iteritems(self._packet_infos)
+ fragments = [x for _, i in self._packet_infos.items()
for x in fragment_rfc8200(
i.data, i.index, 400)]
Code Review / vpp.git / blobdiff