3 from random import shuffle
5 from framework import VppTestCase, VppTestRunner
7 from scapy.packet import Raw
8 from scapy.layers.l2 import Ether, GRE
9 from scapy.layers.inet import IP, UDP
10 from util import ppp, fragment_rfc791, fragment_rfc8200
11 from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, ICMPv6ParamProblem,\
13 from vpp_gre_interface import VppGreInterface, VppGre6Interface
14 from vpp_ip_route import VppIpRoute, VppRoutePath, DpoProto
16 test_packet_count = 257
19 class TestIPv4Reassembly(VppTestCase):
20 """ IPv4 Reassembly """
24 super(TestIPv4Reassembly, cls).setUpClass()
26 cls.create_pg_interfaces([0, 1])
30 # setup all interfaces
31 for i in cls.pg_interfaces:
37 cls.packet_sizes = [64, 512, 1518, 9018]
38 cls.padding = " abcdefghijklmn"
39 cls.create_stream(cls.packet_sizes)
40 cls.create_fragments()
43 """ Test setup - force timeout on existing reassemblies """
44 super(TestIPv4Reassembly, self).setUp()
45 self.vapi.ip_reassembly_enable_disable(
46 sw_if_index=self.src_if.sw_if_index, enable_ip4=True)
47 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
48 expire_walk_interval_ms=10)
50 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
51 expire_walk_interval_ms=10000)
54 super(TestIPv4Reassembly, self).tearDown()
55 self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
58 def create_stream(cls, packet_sizes, packet_count=test_packet_count):
59 """Create input packet stream for defined interface.
61 :param list packet_sizes: Required packet sizes.
63 for i in range(0, packet_count):
64 info = cls.create_packet_info(cls.src_if, cls.src_if)
65 payload = cls.info_to_payload(info)
66 p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
67 IP(id=info.index, src=cls.src_if.remote_ip4,
68 dst=cls.dst_if.remote_ip4) /
69 UDP(sport=1234, dport=5678) /
71 size = packet_sizes[(i // 2) % len(packet_sizes)]
72 cls.extend_packet(p, size, cls.padding)
76 def create_fragments(cls):
77 infos = cls._packet_infos
79 for index, info in infos.iteritems():
81 # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
82 fragments_400 = fragment_rfc791(p, 400)
83 fragments_300 = fragment_rfc791(p, 300)
85 x for f in fragments_400 for x in fragment_rfc791(f, 200)]
87 (index, fragments_400, fragments_300, fragments_200))
89 x for (_, frags, _, _) in cls.pkt_infos for x in frags]
91 x for (_, _, frags, _) in cls.pkt_infos for x in frags]
93 x for (_, _, _, frags) in cls.pkt_infos for x in frags]
94 cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
95 "%s 300-byte fragments and %s 200-byte fragments" %
96 (len(infos), len(cls.fragments_400),
97 len(cls.fragments_300), len(cls.fragments_200)))
99 def verify_capture(self, capture, dropped_packet_indexes=[]):
100 """Verify captured packet stream.
102 :param list capture: Captured packet stream.
106 for packet in capture:
108 self.logger.debug(ppp("Got packet:", packet))
111 payload_info = self.payload_to_info(str(packet[Raw]))
112 packet_index = payload_info.index
114 packet_index not in dropped_packet_indexes,
115 ppp("Packet received, but should be dropped:", packet))
116 if packet_index in seen:
117 raise Exception(ppp("Duplicate packet received", packet))
118 seen.add(packet_index)
119 self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
120 info = self._packet_infos[packet_index]
121 self.assertTrue(info is not None)
122 self.assertEqual(packet_index, info.index)
123 saved_packet = info.data
124 self.assertEqual(ip.src, saved_packet[IP].src)
125 self.assertEqual(ip.dst, saved_packet[IP].dst)
126 self.assertEqual(udp.payload, saved_packet[UDP].payload)
128 self.logger.error(ppp("Unexpected or invalid packet:", packet))
130 for index in self._packet_infos:
131 self.assertTrue(index in seen or index in dropped_packet_indexes,
132 "Packet with packet_index %d not received" % index)
134 def test_reassembly(self):
135 """ basic reassembly """
137 self.pg_enable_capture()
138 self.src_if.add_stream(self.fragments_200)
141 packets = self.dst_if.get_capture(len(self.pkt_infos))
142 self.verify_capture(packets)
143 self.src_if.assert_nothing_captured()
145 # run it all again to verify correctness
146 self.pg_enable_capture()
147 self.src_if.add_stream(self.fragments_200)
150 packets = self.dst_if.get_capture(len(self.pkt_infos))
151 self.verify_capture(packets)
152 self.src_if.assert_nothing_captured()
154 def test_reversed(self):
155 """ reverse order reassembly """
157 fragments = list(self.fragments_200)
160 self.pg_enable_capture()
161 self.src_if.add_stream(fragments)
164 packets = self.dst_if.get_capture(len(self.packet_infos))
165 self.verify_capture(packets)
166 self.src_if.assert_nothing_captured()
168 # run it all again to verify correctness
169 self.pg_enable_capture()
170 self.src_if.add_stream(fragments)
173 packets = self.dst_if.get_capture(len(self.packet_infos))
174 self.verify_capture(packets)
175 self.src_if.assert_nothing_captured()
177 def test_random(self):
178 """ random order reassembly """
180 fragments = list(self.fragments_200)
183 self.pg_enable_capture()
184 self.src_if.add_stream(fragments)
187 packets = self.dst_if.get_capture(len(self.packet_infos))
188 self.verify_capture(packets)
189 self.src_if.assert_nothing_captured()
191 # run it all again to verify correctness
192 self.pg_enable_capture()
193 self.src_if.add_stream(fragments)
196 packets = self.dst_if.get_capture(len(self.packet_infos))
197 self.verify_capture(packets)
198 self.src_if.assert_nothing_captured()
200 def test_duplicates(self):
201 """ duplicate fragments """
204 x for (_, frags, _, _) in self.pkt_infos
206 for _ in range(0, min(2, len(frags)))
209 self.pg_enable_capture()
210 self.src_if.add_stream(fragments)
213 packets = self.dst_if.get_capture(len(self.pkt_infos))
214 self.verify_capture(packets)
215 self.src_if.assert_nothing_captured()
217 def test_overlap1(self):
218 """ overlapping fragments case #1 """
221 for _, _, frags_300, frags_200 in self.pkt_infos:
222 if len(frags_300) == 1:
223 fragments.extend(frags_300)
225 for i, j in zip(frags_200, frags_300):
229 self.pg_enable_capture()
230 self.src_if.add_stream(fragments)
233 packets = self.dst_if.get_capture(len(self.pkt_infos))
234 self.verify_capture(packets)
235 self.src_if.assert_nothing_captured()
237 # run it all to verify correctness
238 self.pg_enable_capture()
239 self.src_if.add_stream(fragments)
242 packets = self.dst_if.get_capture(len(self.pkt_infos))
243 self.verify_capture(packets)
244 self.src_if.assert_nothing_captured()
246 def test_overlap2(self):
247 """ overlapping fragments case #2 """
250 for _, _, frags_300, frags_200 in self.pkt_infos:
251 if len(frags_300) == 1:
252 fragments.extend(frags_300)
254 # care must be taken here so that there are no fragments
255 # received by vpp after reassembly is finished, otherwise
256 # new reassemblies will be started and packet generator will
257 # freak out when it detects unfreed buffers
258 zipped = zip(frags_300, frags_200)
259 for i, j in zipped[:-1]:
262 fragments.append(zipped[-1][0])
264 self.pg_enable_capture()
265 self.src_if.add_stream(fragments)
268 packets = self.dst_if.get_capture(len(self.pkt_infos))
269 self.verify_capture(packets)
270 self.src_if.assert_nothing_captured()
272 # run it all to verify correctness
273 self.pg_enable_capture()
274 self.src_if.add_stream(fragments)
277 packets = self.dst_if.get_capture(len(self.pkt_infos))
278 self.verify_capture(packets)
279 self.src_if.assert_nothing_captured()
281 def test_timeout_inline(self):
282 """ timeout (inline) """
284 dropped_packet_indexes = set(
285 index for (index, frags, _, _) in self.pkt_infos if len(frags) > 1
288 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
289 expire_walk_interval_ms=10000)
291 self.pg_enable_capture()
292 self.src_if.add_stream(self.fragments_400)
295 packets = self.dst_if.get_capture(
296 len(self.pkt_infos) - len(dropped_packet_indexes))
297 self.verify_capture(packets, dropped_packet_indexes)
298 self.src_if.assert_nothing_captured()
300 def test_timeout_cleanup(self):
301 """ timeout (cleanup) """
303 # whole packets + fragmented packets sans last fragment
305 x for (_, frags_400, _, _) in self.pkt_infos
306 for x in frags_400[:-1 if len(frags_400) > 1 else None]
309 # last fragments for fragmented packets
310 fragments2 = [frags_400[-1]
311 for (_, frags_400, _, _) in self.pkt_infos
312 if len(frags_400) > 1]
314 dropped_packet_indexes = set(
315 index for (index, frags_400, _, _) in self.pkt_infos
316 if len(frags_400) > 1)
318 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
319 expire_walk_interval_ms=50)
321 self.pg_enable_capture()
322 self.src_if.add_stream(fragments)
325 self.sleep(.25, "wait before sending rest of fragments")
327 self.src_if.add_stream(fragments2)
330 packets = self.dst_if.get_capture(
331 len(self.pkt_infos) - len(dropped_packet_indexes))
332 self.verify_capture(packets, dropped_packet_indexes)
333 self.src_if.assert_nothing_captured()
335 def test_disabled(self):
336 """ reassembly disabled """
338 dropped_packet_indexes = set(
339 index for (index, frags_400, _, _) in self.pkt_infos
340 if len(frags_400) > 1)
342 self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,
343 expire_walk_interval_ms=10000)
345 self.pg_enable_capture()
346 self.src_if.add_stream(self.fragments_400)
349 packets = self.dst_if.get_capture(
350 len(self.pkt_infos) - len(dropped_packet_indexes))
351 self.verify_capture(packets, dropped_packet_indexes)
352 self.src_if.assert_nothing_captured()
355 class TestIPv6Reassembly(VppTestCase):
356 """ IPv6 Reassembly """
360 super(TestIPv6Reassembly, cls).setUpClass()
362 cls.create_pg_interfaces([0, 1])
366 # setup all interfaces
367 for i in cls.pg_interfaces:
373 cls.packet_sizes = [64, 512, 1518, 9018]
374 cls.padding = " abcdefghijklmn"
375 cls.create_stream(cls.packet_sizes)
376 cls.create_fragments()
379 """ Test setup - force timeout on existing reassemblies """
380 super(TestIPv6Reassembly, self).setUp()
381 self.vapi.ip_reassembly_enable_disable(
382 sw_if_index=self.src_if.sw_if_index, enable_ip6=True)
383 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
384 expire_walk_interval_ms=10, is_ip6=1)
386 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
387 expire_walk_interval_ms=10000, is_ip6=1)
388 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
391 super(TestIPv6Reassembly, self).tearDown()
392 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
395 def create_stream(cls, packet_sizes, packet_count=test_packet_count):
396 """Create input packet stream for defined interface.
398 :param list packet_sizes: Required packet sizes.
400 for i in range(0, packet_count):
401 info = cls.create_packet_info(cls.src_if, cls.src_if)
402 payload = cls.info_to_payload(info)
403 p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
404 IPv6(src=cls.src_if.remote_ip6,
405 dst=cls.dst_if.remote_ip6) /
406 UDP(sport=1234, dport=5678) /
408 size = packet_sizes[(i // 2) % len(packet_sizes)]
409 cls.extend_packet(p, size, cls.padding)
413 def create_fragments(cls):
414 infos = cls._packet_infos
416 for index, info in infos.iteritems():
418 # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
419 fragments_400 = fragment_rfc8200(p, info.index, 400)
420 fragments_300 = fragment_rfc8200(p, info.index, 300)
421 cls.pkt_infos.append((index, fragments_400, fragments_300))
422 cls.fragments_400 = [
423 x for _, frags, _ in cls.pkt_infos for x in frags]
424 cls.fragments_300 = [
425 x for _, _, frags in cls.pkt_infos for x in frags]
426 cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
427 "and %s 300-byte fragments" %
428 (len(infos), len(cls.fragments_400),
429 len(cls.fragments_300)))
431 def verify_capture(self, capture, dropped_packet_indexes=[]):
432 """Verify captured packet strea .
434 :param list capture: Captured packet stream.
438 for packet in capture:
440 self.logger.debug(ppp("Got packet:", packet))
443 payload_info = self.payload_to_info(str(packet[Raw]))
444 packet_index = payload_info.index
446 packet_index not in dropped_packet_indexes,
447 ppp("Packet received, but should be dropped:", packet))
448 if packet_index in seen:
449 raise Exception(ppp("Duplicate packet received", packet))
450 seen.add(packet_index)
451 self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
452 info = self._packet_infos[packet_index]
453 self.assertTrue(info is not None)
454 self.assertEqual(packet_index, info.index)
455 saved_packet = info.data
456 self.assertEqual(ip.src, saved_packet[IPv6].src)
457 self.assertEqual(ip.dst, saved_packet[IPv6].dst)
458 self.assertEqual(udp.payload, saved_packet[UDP].payload)
460 self.logger.error(ppp("Unexpected or invalid packet:", packet))
462 for index in self._packet_infos:
463 self.assertTrue(index in seen or index in dropped_packet_indexes,
464 "Packet with packet_index %d not received" % index)
466 def test_reassembly(self):
467 """ basic reassembly """
469 self.pg_enable_capture()
470 self.src_if.add_stream(self.fragments_400)
473 packets = self.dst_if.get_capture(len(self.pkt_infos))
474 self.verify_capture(packets)
475 self.src_if.assert_nothing_captured()
477 # run it all again to verify correctness
478 self.pg_enable_capture()
479 self.src_if.add_stream(self.fragments_400)
482 packets = self.dst_if.get_capture(len(self.pkt_infos))
483 self.verify_capture(packets)
484 self.src_if.assert_nothing_captured()
486 def test_reversed(self):
487 """ reverse order reassembly """
489 fragments = list(self.fragments_400)
492 self.pg_enable_capture()
493 self.src_if.add_stream(fragments)
496 packets = self.dst_if.get_capture(len(self.pkt_infos))
497 self.verify_capture(packets)
498 self.src_if.assert_nothing_captured()
500 # run it all again to verify correctness
501 self.pg_enable_capture()
502 self.src_if.add_stream(fragments)
505 packets = self.dst_if.get_capture(len(self.pkt_infos))
506 self.verify_capture(packets)
507 self.src_if.assert_nothing_captured()
509 def test_random(self):
510 """ random order reassembly """
512 fragments = list(self.fragments_400)
515 self.pg_enable_capture()
516 self.src_if.add_stream(fragments)
519 packets = self.dst_if.get_capture(len(self.pkt_infos))
520 self.verify_capture(packets)
521 self.src_if.assert_nothing_captured()
523 # run it all again to verify correctness
524 self.pg_enable_capture()
525 self.src_if.add_stream(fragments)
528 packets = self.dst_if.get_capture(len(self.pkt_infos))
529 self.verify_capture(packets)
530 self.src_if.assert_nothing_captured()
532 def test_duplicates(self):
533 """ duplicate fragments """
536 x for (_, frags, _) in self.pkt_infos
538 for _ in range(0, min(2, len(frags)))
541 self.pg_enable_capture()
542 self.src_if.add_stream(fragments)
545 packets = self.dst_if.get_capture(len(self.pkt_infos))
546 self.verify_capture(packets)
547 self.src_if.assert_nothing_captured()
549 def test_overlap1(self):
550 """ overlapping fragments case #1 """
553 for _, frags_400, frags_300 in self.pkt_infos:
554 if len(frags_300) == 1:
555 fragments.extend(frags_400)
557 for i, j in zip(frags_300, frags_400):
561 dropped_packet_indexes = set(
562 index for (index, _, frags) in self.pkt_infos if len(frags) > 1
565 self.pg_enable_capture()
566 self.src_if.add_stream(fragments)
569 packets = self.dst_if.get_capture(
570 len(self.pkt_infos) - len(dropped_packet_indexes))
571 self.verify_capture(packets, dropped_packet_indexes)
572 self.src_if.assert_nothing_captured()
574 def test_overlap2(self):
575 """ overlapping fragments case #2 """
578 for _, frags_400, frags_300 in self.pkt_infos:
579 if len(frags_400) == 1:
580 fragments.extend(frags_400)
582 # care must be taken here so that there are no fragments
583 # received by vpp after reassembly is finished, otherwise
584 # new reassemblies will be started and packet generator will
585 # freak out when it detects unfreed buffers
586 zipped = zip(frags_400, frags_300)
587 for i, j in zipped[:-1]:
590 fragments.append(zipped[-1][0])
592 dropped_packet_indexes = set(
593 index for (index, _, frags) in self.pkt_infos if len(frags) > 1
596 self.pg_enable_capture()
597 self.src_if.add_stream(fragments)
600 packets = self.dst_if.get_capture(
601 len(self.pkt_infos) - len(dropped_packet_indexes))
602 self.verify_capture(packets, dropped_packet_indexes)
603 self.src_if.assert_nothing_captured()
605 def test_timeout_inline(self):
606 """ timeout (inline) """
608 dropped_packet_indexes = set(
609 index for (index, frags, _) in self.pkt_infos if len(frags) > 1
612 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
613 expire_walk_interval_ms=10000, is_ip6=1)
615 self.pg_enable_capture()
616 self.src_if.add_stream(self.fragments_400)
619 packets = self.dst_if.get_capture(
620 len(self.pkt_infos) - len(dropped_packet_indexes))
621 self.verify_capture(packets, dropped_packet_indexes)
622 pkts = self.src_if.get_capture(
623 expected_count=len(dropped_packet_indexes))
625 self.assertIn(ICMPv6TimeExceeded, icmp)
626 self.assertIn(IPv6ExtHdrFragment, icmp)
627 self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
628 dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
630 def test_timeout_cleanup(self):
631 """ timeout (cleanup) """
633 # whole packets + fragmented packets sans last fragment
635 x for (_, frags_400, _) in self.pkt_infos
636 for x in frags_400[:-1 if len(frags_400) > 1 else None]
639 # last fragments for fragmented packets
640 fragments2 = [frags_400[-1]
641 for (_, frags_400, _) in self.pkt_infos
642 if len(frags_400) > 1]
644 dropped_packet_indexes = set(
645 index for (index, frags_400, _) in self.pkt_infos
646 if len(frags_400) > 1)
648 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
649 expire_walk_interval_ms=50)
651 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
652 expire_walk_interval_ms=50, is_ip6=1)
654 self.pg_enable_capture()
655 self.src_if.add_stream(fragments)
658 self.sleep(.25, "wait before sending rest of fragments")
660 self.src_if.add_stream(fragments2)
663 packets = self.dst_if.get_capture(
664 len(self.pkt_infos) - len(dropped_packet_indexes))
665 self.verify_capture(packets, dropped_packet_indexes)
666 pkts = self.src_if.get_capture(
667 expected_count=len(dropped_packet_indexes))
669 self.assertIn(ICMPv6TimeExceeded, icmp)
670 self.assertIn(IPv6ExtHdrFragment, icmp)
671 self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
672 dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
674 def test_disabled(self):
675 """ reassembly disabled """
677 dropped_packet_indexes = set(
678 index for (index, frags_400, _) in self.pkt_infos
679 if len(frags_400) > 1)
681 self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,
682 expire_walk_interval_ms=10000, is_ip6=1)
684 self.pg_enable_capture()
685 self.src_if.add_stream(self.fragments_400)
688 packets = self.dst_if.get_capture(
689 len(self.pkt_infos) - len(dropped_packet_indexes))
690 self.verify_capture(packets, dropped_packet_indexes)
691 self.src_if.assert_nothing_captured()
693 def test_missing_upper(self):
694 """ missing upper layer """
695 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
696 IPv6(src=self.src_if.remote_ip6,
697 dst=self.src_if.local_ip6) /
698 UDP(sport=1234, dport=5678) /
700 self.extend_packet(p, 1000, self.padding)
701 fragments = fragment_rfc8200(p, 1, 500)
702 bad_fragment = p.__class__(str(fragments[1]))
703 bad_fragment[IPv6ExtHdrFragment].nh = 59
704 bad_fragment[IPv6ExtHdrFragment].offset = 0
705 self.pg_enable_capture()
706 self.src_if.add_stream([bad_fragment])
708 pkts = self.src_if.get_capture(expected_count=1)
710 self.assertIn(ICMPv6ParamProblem, icmp)
711 self.assert_equal(icmp[ICMPv6ParamProblem].code, 3, "ICMP code")
713 def test_invalid_frag_size(self):
714 """ fragment size not a multiple of 8 """
715 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
716 IPv6(src=self.src_if.remote_ip6,
717 dst=self.src_if.local_ip6) /
718 UDP(sport=1234, dport=5678) /
720 self.extend_packet(p, 1000, self.padding)
721 fragments = fragment_rfc8200(p, 1, 500)
722 bad_fragment = fragments[0]
723 self.extend_packet(bad_fragment, len(bad_fragment) + 5)
724 self.pg_enable_capture()
725 self.src_if.add_stream([bad_fragment])
727 pkts = self.src_if.get_capture(expected_count=1)
729 self.assertIn(ICMPv6ParamProblem, icmp)
730 self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
732 def test_invalid_packet_size(self):
733 """ total packet size > 65535 """
734 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
735 IPv6(src=self.src_if.remote_ip6,
736 dst=self.src_if.local_ip6) /
737 UDP(sport=1234, dport=5678) /
739 self.extend_packet(p, 1000, self.padding)
740 fragments = fragment_rfc8200(p, 1, 500)
741 bad_fragment = fragments[1]
742 bad_fragment[IPv6ExtHdrFragment].offset = 65500
743 self.pg_enable_capture()
744 self.src_if.add_stream([bad_fragment])
746 pkts = self.src_if.get_capture(expected_count=1)
748 self.assertIn(ICMPv6ParamProblem, icmp)
749 self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
752 class TestFIFReassembly(VppTestCase):
753 """ Fragments in fragments reassembly """
757 super(TestFIFReassembly, cls).setUpClass()
759 cls.create_pg_interfaces([0, 1])
762 for i in cls.pg_interfaces:
769 cls.packet_sizes = [64, 512, 1518, 9018]
770 cls.padding = " abcdefghijklmn"
773 """ Test setup - force timeout on existing reassemblies """
774 super(TestFIFReassembly, self).setUp()
775 self.vapi.ip_reassembly_enable_disable(
776 sw_if_index=self.src_if.sw_if_index, enable_ip4=True,
778 self.vapi.ip_reassembly_enable_disable(
779 sw_if_index=self.dst_if.sw_if_index, enable_ip4=True,
781 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
782 expire_walk_interval_ms=10)
783 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
784 expire_walk_interval_ms=10, is_ip6=1)
786 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
787 expire_walk_interval_ms=10000)
788 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
789 expire_walk_interval_ms=10000, is_ip6=1)
792 self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
793 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
794 super(TestFIFReassembly, self).tearDown()
796 def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]):
797 """Verify captured packet stream.
799 :param list capture: Captured packet stream.
803 for packet in capture:
805 self.logger.debug(ppp("Got packet:", packet))
806 ip = packet[ip_class]
808 payload_info = self.payload_to_info(str(packet[Raw]))
809 packet_index = payload_info.index
811 packet_index not in dropped_packet_indexes,
812 ppp("Packet received, but should be dropped:", packet))
813 if packet_index in seen:
814 raise Exception(ppp("Duplicate packet received", packet))
815 seen.add(packet_index)
816 self.assertEqual(payload_info.dst, self.dst_if.sw_if_index)
817 info = self._packet_infos[packet_index]
818 self.assertTrue(info is not None)
819 self.assertEqual(packet_index, info.index)
820 saved_packet = info.data
821 self.assertEqual(ip.src, saved_packet[ip_class].src)
822 self.assertEqual(ip.dst, saved_packet[ip_class].dst)
823 self.assertEqual(udp.payload, saved_packet[UDP].payload)
825 self.logger.error(ppp("Unexpected or invalid packet:", packet))
827 for index in self._packet_infos:
828 self.assertTrue(index in seen or index in dropped_packet_indexes,
829 "Packet with packet_index %d not received" % index)
832 """ Fragments in fragments (4o4) """
834 # TODO this should be ideally in setUpClass, but then we hit a bug
835 # with VppIpRoute incorrectly reporting it's present when it's not
836 # so we need to manually remove the vpp config, thus we cannot have
837 # it shared for multiple test cases
838 self.tun_ip4 = "1.1.1.2"
840 self.gre4 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4)
841 self.gre4.add_vpp_config()
843 self.gre4.config_ip4()
845 self.vapi.ip_reassembly_enable_disable(
846 sw_if_index=self.gre4.sw_if_index, enable_ip4=True)
848 self.route4 = VppIpRoute(self, self.tun_ip4, 32,
849 [VppRoutePath(self.src_if.remote_ip4,
850 self.src_if.sw_if_index)])
851 self.route4.add_vpp_config()
853 self.reset_packet_infos()
854 for i in range(test_packet_count):
855 info = self.create_packet_info(self.src_if, self.dst_if)
856 payload = self.info_to_payload(info)
857 # Ethernet header here is only for size calculation, thus it
858 # doesn't matter how it's initialized. This is to ensure that
859 # reassembled packet is not > 9000 bytes, so that it's not dropped
861 IP(id=i, src=self.src_if.remote_ip4,
862 dst=self.dst_if.remote_ip4) /
863 UDP(sport=1234, dport=5678) /
865 size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
866 self.extend_packet(p, size, self.padding)
867 info.data = p[IP] # use only IP part, without ethernet header
869 fragments = [x for _, p in self._packet_infos.iteritems()
870 for x in fragment_rfc791(p.data, 400)]
872 encapped_fragments = \
873 [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
874 IP(src=self.tun_ip4, dst=self.src_if.local_ip4) /
879 fragmented_encapped_fragments = \
880 [x for p in encapped_fragments
881 for x in fragment_rfc791(p, 200)]
883 self.src_if.add_stream(fragmented_encapped_fragments)
885 self.pg_enable_capture(self.pg_interfaces)
888 self.src_if.assert_nothing_captured()
889 packets = self.dst_if.get_capture(len(self._packet_infos))
890 self.verify_capture(packets, IP)
892 # TODO remove gre vpp config by hand until VppIpRoute gets fixed
893 # so that it's query_vpp_config() works as it should
894 self.gre4.remove_vpp_config()
895 self.logger.debug(self.vapi.ppcli("show interface"))
898 """ Fragments in fragments (6o6) """
899 # TODO this should be ideally in setUpClass, but then we hit a bug
900 # with VppIpRoute incorrectly reporting it's present when it's not
901 # so we need to manually remove the vpp config, thus we cannot have
902 # it shared for multiple test cases
903 self.tun_ip6 = "1002::1"
905 self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6)
906 self.gre6.add_vpp_config()
908 self.gre6.config_ip6()
910 self.vapi.ip_reassembly_enable_disable(
911 sw_if_index=self.gre6.sw_if_index, enable_ip6=True)
913 self.route6 = VppIpRoute(self, self.tun_ip6, 128,
914 [VppRoutePath(self.src_if.remote_ip6,
915 self.src_if.sw_if_index,
916 proto=DpoProto.DPO_PROTO_IP6)],
918 self.route6.add_vpp_config()
920 self.reset_packet_infos()
921 for i in range(test_packet_count):
922 info = self.create_packet_info(self.src_if, self.dst_if)
923 payload = self.info_to_payload(info)
924 # Ethernet header here is only for size calculation, thus it
925 # doesn't matter how it's initialized. This is to ensure that
926 # reassembled packet is not > 9000 bytes, so that it's not dropped
928 IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) /
929 UDP(sport=1234, dport=5678) /
931 size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
932 self.extend_packet(p, size, self.padding)
933 info.data = p[IPv6] # use only IPv6 part, without ethernet header
935 fragments = [x for _, i in self._packet_infos.iteritems()
936 for x in fragment_rfc8200(
937 i.data, i.index, 400)]
939 encapped_fragments = \
940 [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
941 IPv6(src=self.tun_ip6, dst=self.src_if.local_ip6) /
946 fragmented_encapped_fragments = \
947 [x for p in encapped_fragments for x in (
950 2 * len(self._packet_infos) + p[IPv6ExtHdrFragment].id,
952 if IPv6ExtHdrFragment in p else [p]
956 self.src_if.add_stream(fragmented_encapped_fragments)
958 self.pg_enable_capture(self.pg_interfaces)
961 self.src_if.assert_nothing_captured()
962 packets = self.dst_if.get_capture(len(self._packet_infos))
963 self.verify_capture(packets, IPv6)
965 # TODO remove gre vpp config by hand until VppIpRoute gets fixed
966 # so that it's query_vpp_config() works as it should
967 self.gre6.remove_vpp_config()
970 if __name__ == '__main__':
971 unittest.main(testRunner=VppTestRunner)