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
+from vpp_ip import DpoProto
+from vpp_ip_route import VppIpRoute, VppRoutePath
test_packet_count = 257
def setUpClass(cls):
super(TestIPv4Reassembly, cls).setUpClass()
- cls.create_pg_interfaces([0])
- cls.pg_if = cls.pg0
+ cls.create_pg_interfaces([0, 1])
+ cls.src_if = cls.pg0
+ cls.dst_if = cls.pg1
# setup all interfaces
for i in cls.pg_interfaces:
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"
def setUp(self):
""" Test setup - force timeout on existing reassemblies """
super(TestIPv4Reassembly, self).setUp()
+ self.vapi.ip_reassembly_enable_disable(
+ sw_if_index=self.src_if.sw_if_index, enable_ip4=True)
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
expire_walk_interval_ms=10)
self.sleep(.25)
: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)
+ info = cls.create_packet_info(cls.src_if, cls.src_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) /
+ p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
+ IP(id=info.index, src=cls.src_if.remote_ip4,
+ dst=cls.dst_if.remote_ip4) /
+ UDP(sport=1234, dport=5678) /
Raw(payload))
size = packet_sizes[(i // 2) % len(packet_sizes)]
cls.extend_packet(p, size, cls.padding)
cls.pkt_infos = []
for index, info in infos.iteritems():
p = info.data
- # self.logger.debug(ppp("Packet:", p.__class__(str(p))))
+ # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
fragments_400 = fragment_rfc791(p, 400)
fragments_300 = fragment_rfc791(p, 300)
fragments_200 = [
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))
+ self.logger.debug(ppp("Got packet:", packet))
ip = packet[IP]
udp = packet[UDP]
payload_info = self.payload_to_info(str(packet[Raw]))
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)
+ self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
info = self._packet_infos[packet_index]
self.assertTrue(info is not None)
self.assertEqual(packet_index, info.index)
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:
+ except Exception:
self.logger.error(ppp("Unexpected or invalid packet:", packet))
raise
for index in self._packet_infos:
""" basic reassembly """
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_200)
+ self.src_if.add_stream(self.fragments_200)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_200)
+ self.src_if.add_stream(self.fragments_200)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_reversed(self):
""" reverse order reassembly """
fragments.reverse()
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+ packets = self.dst_if.get_capture(len(self.packet_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+ packets = self.dst_if.get_capture(len(self.packet_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_random(self):
""" random order reassembly """
shuffle(fragments)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+ packets = self.dst_if.get_capture(len(self.packet_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.packet_infos))
+ packets = self.dst_if.get_capture(len(self.packet_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_duplicates(self):
""" duplicate fragments """
]
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_overlap1(self):
""" overlapping fragments case #1 """
fragments.extend(j)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_overlap2(self):
""" overlapping fragments case #2 """
fragments.append(zipped[-1][0])
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_timeout_inline(self):
""" timeout (inline) """
expire_walk_interval_ms=10000)
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_timeout_cleanup(self):
""" timeout (cleanup) """
expire_walk_interval_ms=50)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
self.sleep(.25, "wait before sending rest of fragments")
- self.pg_if.add_stream(fragments2)
+ self.src_if.add_stream(fragments2)
self.pg_start()
- self.sleep(.25, "wait for vpp to process packets")
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_disabled(self):
""" reassembly disabled """
expire_walk_interval_ms=10000)
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
class TestIPv6Reassembly(VppTestCase):
def setUpClass(cls):
super(TestIPv6Reassembly, cls).setUpClass()
- cls.create_pg_interfaces([0])
- cls.pg_if = cls.pg0
+ cls.create_pg_interfaces([0, 1])
+ cls.src_if = cls.pg0
+ cls.dst_if = cls.pg1
# setup all interfaces
for i in cls.pg_interfaces:
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"
def setUp(self):
""" Test setup - force timeout on existing reassemblies """
super(TestIPv6Reassembly, self).setUp()
+ self.vapi.ip_reassembly_enable_disable(
+ sw_if_index=self.src_if.sw_if_index, enable_ip6=True)
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
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)
+ self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
def tearDown(self):
super(TestIPv6Reassembly, self).tearDown()
: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)
+ info = cls.create_packet_info(cls.src_if, cls.src_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) /
+ p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
+ IPv6(src=cls.src_if.remote_ip6,
+ dst=cls.dst_if.remote_ip6) /
+ UDP(sport=1234, dport=5678) /
Raw(payload))
size = packet_sizes[(i // 2) % len(packet_sizes)]
cls.extend_packet(p, size, cls.padding)
cls.pkt_infos = []
for index, info in infos.iteritems():
p = info.data
- # self.logger.debug(ppp("Packet:", p.__class__(str(p))))
+ # cls.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))
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))
+ self.logger.debug(ppp("Got packet:", packet))
ip = packet[IPv6]
udp = packet[UDP]
payload_info = self.payload_to_info(str(packet[Raw]))
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)
+ self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
info = self._packet_infos[packet_index]
self.assertTrue(info is not None)
self.assertEqual(packet_index, info.index)
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:
+ except Exception:
self.logger.error(ppp("Unexpected or invalid packet:", packet))
raise
for index in self._packet_infos:
""" basic reassembly """
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_reversed(self):
""" reverse order reassembly """
fragments.reverse()
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_random(self):
""" random order reassembly """
shuffle(fragments)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
# run it all again to verify correctness
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_duplicates(self):
""" duplicate fragments """
]
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(len(self.pkt_infos))
+ packets = self.dst_if.get_capture(len(self.pkt_infos))
self.verify_capture(packets)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_overlap1(self):
""" overlapping fragments case #1 """
)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- self.sleep(.1, "wait for vpp to process packets")
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_overlap2(self):
""" overlapping fragments case #2 """
fragments = []
- for _, frags_400, frags_30 in self.pkt_infos:
+ for _, frags_400, frags_300 in self.pkt_infos:
if len(frags_400) == 1:
fragments.extend(frags_400)
else:
# 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)
+ zipped = zip(frags_400, frags_300)
for i, j in zipped[:-1]:
fragments.extend(i)
fragments.extend(j)
)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
- self.sleep(.1, "wait for vpp to process packets")
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_if.assert_nothing_captured()
def test_timeout_inline(self):
""" timeout (inline) """
expire_walk_interval_ms=10000, is_ip6=1)
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- pkts = self.pg_if.get_capture(
+ pkts = self.src_if.get_capture(
expected_count=len(dropped_packet_indexes))
for icmp in pkts:
self.assertIn(ICMPv6TimeExceeded, icmp)
expire_walk_interval_ms=50, is_ip6=1)
self.pg_enable_capture()
- self.pg_if.add_stream(fragments)
+ self.src_if.add_stream(fragments)
self.pg_start()
self.sleep(.25, "wait before sending rest of fragments")
- self.pg_if.add_stream(fragments2)
+ self.src_if.add_stream(fragments2)
self.pg_start()
- self.sleep(.25, "wait for vpp to process packets")
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- pkts = self.pg_if.get_capture(
+ pkts = self.src_if.get_capture(
expected_count=len(dropped_packet_indexes))
for icmp in pkts:
self.assertIn(ICMPv6TimeExceeded, icmp)
expire_walk_interval_ms=10000, is_ip6=1)
self.pg_enable_capture()
- self.pg_if.add_stream(self.fragments_400)
+ self.src_if.add_stream(self.fragments_400)
self.pg_start()
- packets = self.punt_socket.wait_for_packets(
+ packets = self.dst_if.get_capture(
len(self.pkt_infos) - len(dropped_packet_indexes))
self.verify_capture(packets, dropped_packet_indexes)
- self.pg_if.assert_nothing_captured()
+ self.src_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) /
+ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IPv6(src=self.src_if.remote_ip6,
+ dst=self.src_if.local_ip6) /
+ UDP(sport=1234, dport=5678) /
Raw())
self.extend_packet(p, 1000, self.padding)
fragments = fragment_rfc8200(p, 1, 500)
bad_fragment[IPv6ExtHdrFragment].nh = 59
bad_fragment[IPv6ExtHdrFragment].offset = 0
self.pg_enable_capture()
- self.pg_if.add_stream([bad_fragment])
+ self.src_if.add_stream([bad_fragment])
self.pg_start()
- pkts = self.pg_if.get_capture(expected_count=1)
+ pkts = self.src_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) /
+ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IPv6(src=self.src_if.remote_ip6,
+ dst=self.src_if.local_ip6) /
+ UDP(sport=1234, dport=5678) /
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.src_if.add_stream([bad_fragment])
self.pg_start()
- pkts = self.pg_if.get_capture(expected_count=1)
+ pkts = self.src_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) /
+ p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IPv6(src=self.src_if.remote_ip6,
+ dst=self.src_if.local_ip6) /
+ UDP(sport=1234, dport=5678) /
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.src_if.add_stream([bad_fragment])
self.pg_start()
- pkts = self.pg_if.get_capture(expected_count=1)
+ pkts = self.src_if.get_capture(expected_count=1)
icmp = pkts[0]
self.assertIn(ICMPv6ParamProblem, icmp)
self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
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.create_pg_interfaces([0, 1])
+ cls.src_if = cls.pg0
+ cls.dst_if = cls.pg1
+ for i in cls.pg_interfaces:
+ i.admin_up()
+ i.config_ip4()
+ i.resolve_arp()
+ i.config_ip6()
+ i.resolve_ndp()
+
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_enable_disable(
+ sw_if_index=self.src_if.sw_if_index, enable_ip4=True,
+ enable_ip6=True)
+ self.vapi.ip_reassembly_enable_disable(
+ sw_if_index=self.dst_if.sw_if_index, enable_ip4=True,
+ enable_ip6=True)
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
expire_walk_interval_ms=10)
self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
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))
+ self.logger.debug(ppp("Got packet:", packet))
ip = packet[ip_class]
udp = packet[UDP]
payload_info = self.payload_to_info(str(packet[Raw]))
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)
+ self.assertEqual(payload_info.dst, self.dst_if.sw_if_index)
info = self._packet_infos[packet_index]
self.assertTrue(info is not None)
self.assertEqual(packet_index, info.index)
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:
+ except Exception:
self.logger.error(ppp("Unexpected or invalid packet:", packet))
raise
for index in self._packet_infos:
# 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 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4)
self.gre4.add_vpp_config()
self.gre4.admin_up()
self.gre4.config_ip4()
+ self.vapi.ip_reassembly_enable_disable(
+ sw_if_index=self.gre4.sw_if_index, enable_ip4=True)
+
self.route4 = VppIpRoute(self, self.tun_ip4, 32,
- [VppRoutePath(self.pg0.remote_ip4,
- self.pg0.sw_if_index)])
+ [VppRoutePath(self.src_if.remote_ip4,
+ self.src_if.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)
+ info = self.create_packet_info(self.src_if, self.dst_if)
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) /
+ # Ethernet header here is only for size calculation, thus it
+ # doesn't matter how it's initialized. This is to ensure that
+ # reassembled packet is not > 9000 bytes, so that it's not dropped
+ p = (Ether() /
+ IP(id=i, src=self.src_if.remote_ip4,
+ dst=self.dst_if.remote_ip4) /
+ UDP(sport=1234, dport=5678) /
Raw(payload))
size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
self.extend_packet(p, size, self.padding)
- info.data = p
+ info.data = p[IP] # use only IP part, without ethernet header
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) /
+ [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IP(src=self.tun_ip4, dst=self.src_if.local_ip4) /
GRE() /
p
for p in fragments]
[x for p in encapped_fragments
for x in fragment_rfc791(p, 200)]
- self.pg0.add_stream(fragmented_encapped_fragments)
+ self.src_if.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.src_if.assert_nothing_captured()
+ packets = self.dst_if.get_capture(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()
+ self.logger.debug(self.vapi.ppcli("show interface"))
def test_fif6(self):
""" Fragments in fragments (6o6) """
# it shared for multiple test cases
self.tun_ip6 = "1002::1"
- self.gre6 = VppGre6Interface(self, self.pg0.local_ip6, self.tun_ip6)
+ self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6)
self.gre6.add_vpp_config()
self.gre6.admin_up()
self.gre6.config_ip6()
+ self.vapi.ip_reassembly_enable_disable(
+ sw_if_index=self.gre6.sw_if_index, enable_ip6=True)
+
self.route6 = VppIpRoute(self, self.tun_ip6, 128,
- [VppRoutePath(self.pg0.remote_ip6,
- self.pg0.sw_if_index,
+ [VppRoutePath(self.src_if.remote_ip6,
+ self.src_if.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)
+ info = self.create_packet_info(self.src_if, self.dst_if)
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) /
+ # Ethernet header here is only for size calculation, thus it
+ # doesn't matter how it's initialized. This is to ensure that
+ # reassembled packet is not > 9000 bytes, so that it's not dropped
+ p = (Ether() /
+ IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) /
+ UDP(sport=1234, dport=5678) /
Raw(payload))
size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
self.extend_packet(p, size, self.padding)
- info.data = p
+ info.data = p[IPv6] # use only IPv6 part, without ethernet header
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) /
+ [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
+ IPv6(src=self.tun_ip6, dst=self.src_if.local_ip6) /
GRE() /
p
for p in fragments]
)
]
- self.pg0.add_stream(fragmented_encapped_fragments)
+ self.src_if.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.src_if.assert_nothing_captured()
+ packets = self.dst_if.get_capture(len(self._packet_infos))
self.verify_capture(packets, IPv6)
# TODO remove gre vpp config by hand until VppIpRoute gets fixed