5 from random import shuffle
7 from framework import VppTestCase, VppTestRunner
9 from scapy.packet import Raw
10 from scapy.layers.l2 import Ether, GRE
11 from scapy.layers.inet import IP, UDP, ICMP
12 from util import ppp, fragment_rfc791, fragment_rfc8200
13 from scapy.layers.inet6 import IPv6, IPv6ExtHdrFragment, ICMPv6ParamProblem,\
15 from vpp_gre_interface import VppGreInterface, VppGre6Interface
16 from vpp_ip import DpoProto
17 from vpp_ip_route import VppIpRoute, VppRoutePath
19 test_packet_count = 257
22 class TestIPv4Reassembly(VppTestCase):
23 """ IPv4 Reassembly """
27 super(TestIPv4Reassembly, cls).setUpClass()
29 cls.create_pg_interfaces([0, 1])
33 # setup all interfaces
34 for i in cls.pg_interfaces:
40 cls.packet_sizes = [64, 512, 1518, 9018]
41 cls.padding = " abcdefghijklmn"
42 cls.create_stream(cls.packet_sizes)
43 cls.create_fragments()
46 """ Test setup - force timeout on existing reassemblies """
47 super(TestIPv4Reassembly, self).setUp()
48 self.vapi.ip_reassembly_enable_disable(
49 sw_if_index=self.src_if.sw_if_index, enable_ip4=True)
50 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
51 expire_walk_interval_ms=10)
53 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
54 expire_walk_interval_ms=10000)
57 super(TestIPv4Reassembly, self).tearDown()
58 self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
61 def create_stream(cls, packet_sizes, packet_count=test_packet_count):
62 """Create input packet stream for defined interface.
64 :param list packet_sizes: Required packet sizes.
66 for i in range(0, packet_count):
67 info = cls.create_packet_info(cls.src_if, cls.src_if)
68 payload = cls.info_to_payload(info)
69 p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
70 IP(id=info.index, src=cls.src_if.remote_ip4,
71 dst=cls.dst_if.remote_ip4) /
72 UDP(sport=1234, dport=5678) /
74 size = packet_sizes[(i // 2) % len(packet_sizes)]
75 cls.extend_packet(p, size, cls.padding)
79 def create_fragments(cls):
80 infos = cls._packet_infos
82 for index, info in six.iteritems(infos):
84 # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
85 fragments_400 = fragment_rfc791(p, 400)
86 fragments_300 = fragment_rfc791(p, 300)
88 x for f in fragments_400 for x in fragment_rfc791(f, 200)]
90 (index, fragments_400, fragments_300, fragments_200))
92 x for (_, frags, _, _) in cls.pkt_infos for x in frags]
94 x for (_, _, frags, _) in cls.pkt_infos for x in frags]
96 x for (_, _, _, frags) in cls.pkt_infos for x in frags]
97 cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
98 "%s 300-byte fragments and %s 200-byte fragments" %
99 (len(infos), len(cls.fragments_400),
100 len(cls.fragments_300), len(cls.fragments_200)))
102 def verify_capture(self, capture, dropped_packet_indexes=[]):
103 """Verify captured packet stream.
105 :param list capture: Captured packet stream.
109 for packet in capture:
111 self.logger.debug(ppp("Got packet:", packet))
114 payload_info = self.payload_to_info(str(packet[Raw]))
115 packet_index = payload_info.index
117 packet_index not in dropped_packet_indexes,
118 ppp("Packet received, but should be dropped:", packet))
119 if packet_index in seen:
120 raise Exception(ppp("Duplicate packet received", packet))
121 seen.add(packet_index)
122 self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
123 info = self._packet_infos[packet_index]
124 self.assertTrue(info is not None)
125 self.assertEqual(packet_index, info.index)
126 saved_packet = info.data
127 self.assertEqual(ip.src, saved_packet[IP].src)
128 self.assertEqual(ip.dst, saved_packet[IP].dst)
129 self.assertEqual(udp.payload, saved_packet[UDP].payload)
131 self.logger.error(ppp("Unexpected or invalid packet:", packet))
133 for index in self._packet_infos:
134 self.assertTrue(index in seen or index in dropped_packet_indexes,
135 "Packet with packet_index %d not received" % index)
137 def test_reassembly(self):
138 """ basic reassembly """
140 self.pg_enable_capture()
141 self.src_if.add_stream(self.fragments_200)
144 packets = self.dst_if.get_capture(len(self.pkt_infos))
145 self.verify_capture(packets)
146 self.src_if.assert_nothing_captured()
148 # run it all again to verify correctness
149 self.pg_enable_capture()
150 self.src_if.add_stream(self.fragments_200)
153 packets = self.dst_if.get_capture(len(self.pkt_infos))
154 self.verify_capture(packets)
155 self.src_if.assert_nothing_captured()
157 def test_reversed(self):
158 """ reverse order reassembly """
160 fragments = list(self.fragments_200)
163 self.pg_enable_capture()
164 self.src_if.add_stream(fragments)
167 packets = self.dst_if.get_capture(len(self.packet_infos))
168 self.verify_capture(packets)
169 self.src_if.assert_nothing_captured()
171 # run it all again to verify correctness
172 self.pg_enable_capture()
173 self.src_if.add_stream(fragments)
176 packets = self.dst_if.get_capture(len(self.packet_infos))
177 self.verify_capture(packets)
178 self.src_if.assert_nothing_captured()
180 def test_random(self):
181 """ random order reassembly """
183 fragments = list(self.fragments_200)
186 self.pg_enable_capture()
187 self.src_if.add_stream(fragments)
190 packets = self.dst_if.get_capture(len(self.packet_infos))
191 self.verify_capture(packets)
192 self.src_if.assert_nothing_captured()
194 # run it all again to verify correctness
195 self.pg_enable_capture()
196 self.src_if.add_stream(fragments)
199 packets = self.dst_if.get_capture(len(self.packet_infos))
200 self.verify_capture(packets)
201 self.src_if.assert_nothing_captured()
203 def test_duplicates(self):
204 """ duplicate fragments """
207 x for (_, frags, _, _) in self.pkt_infos
209 for _ in range(0, min(2, len(frags)))
212 self.pg_enable_capture()
213 self.src_if.add_stream(fragments)
216 packets = self.dst_if.get_capture(len(self.pkt_infos))
217 self.verify_capture(packets)
218 self.src_if.assert_nothing_captured()
220 def test_overlap1(self):
221 """ overlapping fragments case #1 """
224 for _, _, frags_300, frags_200 in self.pkt_infos:
225 if len(frags_300) == 1:
226 fragments.extend(frags_300)
228 for i, j in zip(frags_200, frags_300):
232 self.pg_enable_capture()
233 self.src_if.add_stream(fragments)
236 packets = self.dst_if.get_capture(len(self.pkt_infos))
237 self.verify_capture(packets)
238 self.src_if.assert_nothing_captured()
240 # run it all to verify correctness
241 self.pg_enable_capture()
242 self.src_if.add_stream(fragments)
245 packets = self.dst_if.get_capture(len(self.pkt_infos))
246 self.verify_capture(packets)
247 self.src_if.assert_nothing_captured()
249 def test_overlap2(self):
250 """ overlapping fragments case #2 """
253 for _, _, frags_300, frags_200 in self.pkt_infos:
254 if len(frags_300) == 1:
255 fragments.extend(frags_300)
257 # care must be taken here so that there are no fragments
258 # received by vpp after reassembly is finished, otherwise
259 # new reassemblies will be started and packet generator will
260 # freak out when it detects unfreed buffers
261 zipped = zip(frags_300, frags_200)
262 for i, j in zipped[:-1]:
265 fragments.append(zipped[-1][0])
267 self.pg_enable_capture()
268 self.src_if.add_stream(fragments)
271 packets = self.dst_if.get_capture(len(self.pkt_infos))
272 self.verify_capture(packets)
273 self.src_if.assert_nothing_captured()
275 # run it all to verify correctness
276 self.pg_enable_capture()
277 self.src_if.add_stream(fragments)
280 packets = self.dst_if.get_capture(len(self.pkt_infos))
281 self.verify_capture(packets)
282 self.src_if.assert_nothing_captured()
284 def test_timeout_inline(self):
285 """ timeout (inline) """
287 dropped_packet_indexes = set(
288 index for (index, frags, _, _) in self.pkt_infos if len(frags) > 1
291 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
292 expire_walk_interval_ms=10000)
294 self.pg_enable_capture()
295 self.src_if.add_stream(self.fragments_400)
298 packets = self.dst_if.get_capture(
299 len(self.pkt_infos) - len(dropped_packet_indexes))
300 self.verify_capture(packets, dropped_packet_indexes)
301 self.src_if.assert_nothing_captured()
303 def test_timeout_cleanup(self):
304 """ timeout (cleanup) """
306 # whole packets + fragmented packets sans last fragment
308 x for (_, frags_400, _, _) in self.pkt_infos
309 for x in frags_400[:-1 if len(frags_400) > 1 else None]
312 # last fragments for fragmented packets
313 fragments2 = [frags_400[-1]
314 for (_, frags_400, _, _) in self.pkt_infos
315 if len(frags_400) > 1]
317 dropped_packet_indexes = set(
318 index for (index, frags_400, _, _) in self.pkt_infos
319 if len(frags_400) > 1)
321 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
322 expire_walk_interval_ms=50)
324 self.pg_enable_capture()
325 self.src_if.add_stream(fragments)
328 self.sleep(.25, "wait before sending rest of fragments")
330 self.src_if.add_stream(fragments2)
333 packets = self.dst_if.get_capture(
334 len(self.pkt_infos) - len(dropped_packet_indexes))
335 self.verify_capture(packets, dropped_packet_indexes)
336 self.src_if.assert_nothing_captured()
338 def test_disabled(self):
339 """ reassembly disabled """
341 dropped_packet_indexes = set(
342 index for (index, frags_400, _, _) in self.pkt_infos
343 if len(frags_400) > 1)
345 self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,
346 expire_walk_interval_ms=10000)
348 self.pg_enable_capture()
349 self.src_if.add_stream(self.fragments_400)
352 packets = self.dst_if.get_capture(
353 len(self.pkt_infos) - len(dropped_packet_indexes))
354 self.verify_capture(packets, dropped_packet_indexes)
355 self.src_if.assert_nothing_captured()
358 class TestIPv6Reassembly(VppTestCase):
359 """ IPv6 Reassembly """
363 super(TestIPv6Reassembly, cls).setUpClass()
365 cls.create_pg_interfaces([0, 1])
369 # setup all interfaces
370 for i in cls.pg_interfaces:
376 cls.packet_sizes = [64, 512, 1518, 9018]
377 cls.padding = " abcdefghijklmn"
378 cls.create_stream(cls.packet_sizes)
379 cls.create_fragments()
382 """ Test setup - force timeout on existing reassemblies """
383 super(TestIPv6Reassembly, self).setUp()
384 self.vapi.ip_reassembly_enable_disable(
385 sw_if_index=self.src_if.sw_if_index, enable_ip6=True)
386 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
387 expire_walk_interval_ms=10, is_ip6=1)
389 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
390 expire_walk_interval_ms=10000, is_ip6=1)
391 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
394 super(TestIPv6Reassembly, self).tearDown()
395 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
398 def create_stream(cls, packet_sizes, packet_count=test_packet_count):
399 """Create input packet stream for defined interface.
401 :param list packet_sizes: Required packet sizes.
403 for i in range(0, packet_count):
404 info = cls.create_packet_info(cls.src_if, cls.src_if)
405 payload = cls.info_to_payload(info)
406 p = (Ether(dst=cls.src_if.local_mac, src=cls.src_if.remote_mac) /
407 IPv6(src=cls.src_if.remote_ip6,
408 dst=cls.dst_if.remote_ip6) /
409 UDP(sport=1234, dport=5678) /
411 size = packet_sizes[(i // 2) % len(packet_sizes)]
412 cls.extend_packet(p, size, cls.padding)
416 def create_fragments(cls):
417 infos = cls._packet_infos
419 for index, info in six.iteritems(infos):
421 # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
422 fragments_400 = fragment_rfc8200(p, info.index, 400)
423 fragments_300 = fragment_rfc8200(p, info.index, 300)
424 cls.pkt_infos.append((index, fragments_400, fragments_300))
425 cls.fragments_400 = [
426 x for _, frags, _ in cls.pkt_infos for x in frags]
427 cls.fragments_300 = [
428 x for _, _, frags in cls.pkt_infos for x in frags]
429 cls.logger.debug("Fragmented %s packets into %s 400-byte fragments, "
430 "and %s 300-byte fragments" %
431 (len(infos), len(cls.fragments_400),
432 len(cls.fragments_300)))
434 def verify_capture(self, capture, dropped_packet_indexes=[]):
435 """Verify captured packet strea .
437 :param list capture: Captured packet stream.
441 for packet in capture:
443 self.logger.debug(ppp("Got packet:", packet))
446 payload_info = self.payload_to_info(str(packet[Raw]))
447 packet_index = payload_info.index
449 packet_index not in dropped_packet_indexes,
450 ppp("Packet received, but should be dropped:", packet))
451 if packet_index in seen:
452 raise Exception(ppp("Duplicate packet received", packet))
453 seen.add(packet_index)
454 self.assertEqual(payload_info.dst, self.src_if.sw_if_index)
455 info = self._packet_infos[packet_index]
456 self.assertTrue(info is not None)
457 self.assertEqual(packet_index, info.index)
458 saved_packet = info.data
459 self.assertEqual(ip.src, saved_packet[IPv6].src)
460 self.assertEqual(ip.dst, saved_packet[IPv6].dst)
461 self.assertEqual(udp.payload, saved_packet[UDP].payload)
463 self.logger.error(ppp("Unexpected or invalid packet:", packet))
465 for index in self._packet_infos:
466 self.assertTrue(index in seen or index in dropped_packet_indexes,
467 "Packet with packet_index %d not received" % index)
469 def test_reassembly(self):
470 """ basic reassembly """
472 self.pg_enable_capture()
473 self.src_if.add_stream(self.fragments_400)
476 packets = self.dst_if.get_capture(len(self.pkt_infos))
477 self.verify_capture(packets)
478 self.src_if.assert_nothing_captured()
480 # run it all again to verify correctness
481 self.pg_enable_capture()
482 self.src_if.add_stream(self.fragments_400)
485 packets = self.dst_if.get_capture(len(self.pkt_infos))
486 self.verify_capture(packets)
487 self.src_if.assert_nothing_captured()
489 def test_reversed(self):
490 """ reverse order reassembly """
492 fragments = list(self.fragments_400)
495 self.pg_enable_capture()
496 self.src_if.add_stream(fragments)
499 packets = self.dst_if.get_capture(len(self.pkt_infos))
500 self.verify_capture(packets)
501 self.src_if.assert_nothing_captured()
503 # run it all again to verify correctness
504 self.pg_enable_capture()
505 self.src_if.add_stream(fragments)
508 packets = self.dst_if.get_capture(len(self.pkt_infos))
509 self.verify_capture(packets)
510 self.src_if.assert_nothing_captured()
512 def test_random(self):
513 """ random order reassembly """
515 fragments = list(self.fragments_400)
518 self.pg_enable_capture()
519 self.src_if.add_stream(fragments)
522 packets = self.dst_if.get_capture(len(self.pkt_infos))
523 self.verify_capture(packets)
524 self.src_if.assert_nothing_captured()
526 # run it all again to verify correctness
527 self.pg_enable_capture()
528 self.src_if.add_stream(fragments)
531 packets = self.dst_if.get_capture(len(self.pkt_infos))
532 self.verify_capture(packets)
533 self.src_if.assert_nothing_captured()
535 def test_duplicates(self):
536 """ duplicate fragments """
539 x for (_, frags, _) in self.pkt_infos
541 for _ in range(0, min(2, len(frags)))
544 self.pg_enable_capture()
545 self.src_if.add_stream(fragments)
548 packets = self.dst_if.get_capture(len(self.pkt_infos))
549 self.verify_capture(packets)
550 self.src_if.assert_nothing_captured()
552 def test_overlap1(self):
553 """ overlapping fragments case #1 """
556 for _, frags_400, frags_300 in self.pkt_infos:
557 if len(frags_300) == 1:
558 fragments.extend(frags_400)
560 for i, j in zip(frags_300, frags_400):
564 dropped_packet_indexes = set(
565 index for (index, _, frags) in self.pkt_infos if len(frags) > 1
568 self.pg_enable_capture()
569 self.src_if.add_stream(fragments)
572 packets = self.dst_if.get_capture(
573 len(self.pkt_infos) - len(dropped_packet_indexes))
574 self.verify_capture(packets, dropped_packet_indexes)
575 self.src_if.assert_nothing_captured()
577 def test_overlap2(self):
578 """ overlapping fragments case #2 """
581 for _, frags_400, frags_300 in self.pkt_infos:
582 if len(frags_400) == 1:
583 fragments.extend(frags_400)
585 # care must be taken here so that there are no fragments
586 # received by vpp after reassembly is finished, otherwise
587 # new reassemblies will be started and packet generator will
588 # freak out when it detects unfreed buffers
589 zipped = zip(frags_400, frags_300)
590 for i, j in zipped[:-1]:
593 fragments.append(zipped[-1][0])
595 dropped_packet_indexes = set(
596 index for (index, _, frags) in self.pkt_infos if len(frags) > 1
599 self.pg_enable_capture()
600 self.src_if.add_stream(fragments)
603 packets = self.dst_if.get_capture(
604 len(self.pkt_infos) - len(dropped_packet_indexes))
605 self.verify_capture(packets, dropped_packet_indexes)
606 self.src_if.assert_nothing_captured()
608 def test_timeout_inline(self):
609 """ timeout (inline) """
611 dropped_packet_indexes = set(
612 index for (index, frags, _) in self.pkt_infos if len(frags) > 1
615 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
616 expire_walk_interval_ms=10000, is_ip6=1)
618 self.pg_enable_capture()
619 self.src_if.add_stream(self.fragments_400)
622 packets = self.dst_if.get_capture(
623 len(self.pkt_infos) - len(dropped_packet_indexes))
624 self.verify_capture(packets, dropped_packet_indexes)
625 pkts = self.src_if.get_capture(
626 expected_count=len(dropped_packet_indexes))
628 self.assertIn(ICMPv6TimeExceeded, icmp)
629 self.assertIn(IPv6ExtHdrFragment, icmp)
630 self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
631 dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
633 def test_timeout_cleanup(self):
634 """ timeout (cleanup) """
636 # whole packets + fragmented packets sans last fragment
638 x for (_, frags_400, _) in self.pkt_infos
639 for x in frags_400[:-1 if len(frags_400) > 1 else None]
642 # last fragments for fragmented packets
643 fragments2 = [frags_400[-1]
644 for (_, frags_400, _) in self.pkt_infos
645 if len(frags_400) > 1]
647 dropped_packet_indexes = set(
648 index for (index, frags_400, _) in self.pkt_infos
649 if len(frags_400) > 1)
651 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
652 expire_walk_interval_ms=50)
654 self.vapi.ip_reassembly_set(timeout_ms=100, max_reassemblies=1000,
655 expire_walk_interval_ms=50, is_ip6=1)
657 self.pg_enable_capture()
658 self.src_if.add_stream(fragments)
661 self.sleep(.25, "wait before sending rest of fragments")
663 self.src_if.add_stream(fragments2)
666 packets = self.dst_if.get_capture(
667 len(self.pkt_infos) - len(dropped_packet_indexes))
668 self.verify_capture(packets, dropped_packet_indexes)
669 pkts = self.src_if.get_capture(
670 expected_count=len(dropped_packet_indexes))
672 self.assertIn(ICMPv6TimeExceeded, icmp)
673 self.assertIn(IPv6ExtHdrFragment, icmp)
674 self.assertIn(icmp[IPv6ExtHdrFragment].id, dropped_packet_indexes)
675 dropped_packet_indexes.remove(icmp[IPv6ExtHdrFragment].id)
677 def test_disabled(self):
678 """ reassembly disabled """
680 dropped_packet_indexes = set(
681 index for (index, frags_400, _) in self.pkt_infos
682 if len(frags_400) > 1)
684 self.vapi.ip_reassembly_set(timeout_ms=1000, max_reassemblies=0,
685 expire_walk_interval_ms=10000, is_ip6=1)
687 self.pg_enable_capture()
688 self.src_if.add_stream(self.fragments_400)
691 packets = self.dst_if.get_capture(
692 len(self.pkt_infos) - len(dropped_packet_indexes))
693 self.verify_capture(packets, dropped_packet_indexes)
694 self.src_if.assert_nothing_captured()
696 def test_missing_upper(self):
697 """ missing upper layer """
698 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
699 IPv6(src=self.src_if.remote_ip6,
700 dst=self.src_if.local_ip6) /
701 UDP(sport=1234, dport=5678) /
703 self.extend_packet(p, 1000, self.padding)
704 fragments = fragment_rfc8200(p, 1, 500)
705 bad_fragment = p.__class__(str(fragments[1]))
706 bad_fragment[IPv6ExtHdrFragment].nh = 59
707 bad_fragment[IPv6ExtHdrFragment].offset = 0
708 self.pg_enable_capture()
709 self.src_if.add_stream([bad_fragment])
711 pkts = self.src_if.get_capture(expected_count=1)
713 self.assertIn(ICMPv6ParamProblem, icmp)
714 self.assert_equal(icmp[ICMPv6ParamProblem].code, 3, "ICMP code")
716 def test_invalid_frag_size(self):
717 """ fragment size not a multiple of 8 """
718 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
719 IPv6(src=self.src_if.remote_ip6,
720 dst=self.src_if.local_ip6) /
721 UDP(sport=1234, dport=5678) /
723 self.extend_packet(p, 1000, self.padding)
724 fragments = fragment_rfc8200(p, 1, 500)
725 bad_fragment = fragments[0]
726 self.extend_packet(bad_fragment, len(bad_fragment) + 5)
727 self.pg_enable_capture()
728 self.src_if.add_stream([bad_fragment])
730 pkts = self.src_if.get_capture(expected_count=1)
732 self.assertIn(ICMPv6ParamProblem, icmp)
733 self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
735 def test_invalid_packet_size(self):
736 """ total packet size > 65535 """
737 p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
738 IPv6(src=self.src_if.remote_ip6,
739 dst=self.src_if.local_ip6) /
740 UDP(sport=1234, dport=5678) /
742 self.extend_packet(p, 1000, self.padding)
743 fragments = fragment_rfc8200(p, 1, 500)
744 bad_fragment = fragments[1]
745 bad_fragment[IPv6ExtHdrFragment].offset = 65500
746 self.pg_enable_capture()
747 self.src_if.add_stream([bad_fragment])
749 pkts = self.src_if.get_capture(expected_count=1)
751 self.assertIn(ICMPv6ParamProblem, icmp)
752 self.assert_equal(icmp[ICMPv6ParamProblem].code, 0, "ICMP code")
755 class TestIPv4ReassemblyLocalNode(VppTestCase):
756 """ IPv4 Reassembly for packets coming to ip4-local node """
760 super(TestIPv4ReassemblyLocalNode, cls).setUpClass()
762 cls.create_pg_interfaces([0])
763 cls.src_dst_if = cls.pg0
765 # setup all interfaces
766 for i in cls.pg_interfaces:
771 cls.padding = " abcdefghijklmn"
773 cls.create_fragments()
776 """ Test setup - force timeout on existing reassemblies """
777 super(TestIPv4ReassemblyLocalNode, self).setUp()
778 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
779 expire_walk_interval_ms=10)
781 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
782 expire_walk_interval_ms=10000)
785 super(TestIPv4ReassemblyLocalNode, self).tearDown()
786 self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
789 def create_stream(cls, packet_count=test_packet_count):
790 """Create input packet stream for defined interface.
792 :param list packet_sizes: Required packet sizes.
794 for i in range(0, packet_count):
795 info = cls.create_packet_info(cls.src_dst_if, cls.src_dst_if)
796 payload = cls.info_to_payload(info)
797 p = (Ether(dst=cls.src_dst_if.local_mac,
798 src=cls.src_dst_if.remote_mac) /
799 IP(id=info.index, src=cls.src_dst_if.remote_ip4,
800 dst=cls.src_dst_if.local_ip4) /
801 ICMP(type='echo-request', id=1234) /
803 cls.extend_packet(p, 1518, cls.padding)
807 def create_fragments(cls):
808 infos = cls._packet_infos
810 for index, info in six.iteritems(infos):
812 # cls.logger.debug(ppp("Packet:", p.__class__(str(p))))
813 fragments_300 = fragment_rfc791(p, 300)
814 cls.pkt_infos.append((index, fragments_300))
815 cls.fragments_300 = [x for (_, frags) in cls.pkt_infos for x in frags]
816 cls.logger.debug("Fragmented %s packets into %s 300-byte fragments" %
817 (len(infos), len(cls.fragments_300)))
819 def verify_capture(self, capture):
820 """Verify captured packet stream.
822 :param list capture: Captured packet stream.
826 for packet in capture:
828 self.logger.debug(ppp("Got packet:", packet))
831 payload_info = self.payload_to_info(str(packet[Raw]))
832 packet_index = payload_info.index
833 if packet_index in seen:
834 raise Exception(ppp("Duplicate packet received", packet))
835 seen.add(packet_index)
836 self.assertEqual(payload_info.dst, self.src_dst_if.sw_if_index)
837 info = self._packet_infos[packet_index]
838 self.assertTrue(info is not None)
839 self.assertEqual(packet_index, info.index)
840 saved_packet = info.data
841 self.assertEqual(ip.src, saved_packet[IP].dst)
842 self.assertEqual(ip.dst, saved_packet[IP].src)
843 self.assertEqual(icmp.type, 0) # echo reply
844 self.assertEqual(icmp.id, saved_packet[ICMP].id)
845 self.assertEqual(icmp.payload, saved_packet[ICMP].payload)
847 self.logger.error(ppp("Unexpected or invalid packet:", packet))
849 for index in self._packet_infos:
850 self.assertTrue(index in seen or index in dropped_packet_indexes,
851 "Packet with packet_index %d not received" % index)
853 def test_reassembly(self):
854 """ basic reassembly """
856 self.pg_enable_capture()
857 self.src_dst_if.add_stream(self.fragments_300)
860 packets = self.src_dst_if.get_capture(len(self.pkt_infos))
861 self.verify_capture(packets)
863 # run it all again to verify correctness
864 self.pg_enable_capture()
865 self.src_dst_if.add_stream(self.fragments_300)
868 packets = self.src_dst_if.get_capture(len(self.pkt_infos))
869 self.verify_capture(packets)
872 class TestFIFReassembly(VppTestCase):
873 """ Fragments in fragments reassembly """
877 super(TestFIFReassembly, cls).setUpClass()
879 cls.create_pg_interfaces([0, 1])
882 for i in cls.pg_interfaces:
889 cls.packet_sizes = [64, 512, 1518, 9018]
890 cls.padding = " abcdefghijklmn"
893 """ Test setup - force timeout on existing reassemblies """
894 super(TestFIFReassembly, self).setUp()
895 self.vapi.ip_reassembly_enable_disable(
896 sw_if_index=self.src_if.sw_if_index, enable_ip4=True,
898 self.vapi.ip_reassembly_enable_disable(
899 sw_if_index=self.dst_if.sw_if_index, enable_ip4=True,
901 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
902 expire_walk_interval_ms=10)
903 self.vapi.ip_reassembly_set(timeout_ms=0, max_reassemblies=1000,
904 expire_walk_interval_ms=10, is_ip6=1)
906 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
907 expire_walk_interval_ms=10000)
908 self.vapi.ip_reassembly_set(timeout_ms=1000000, max_reassemblies=1000,
909 expire_walk_interval_ms=10000, is_ip6=1)
912 self.logger.debug(self.vapi.ppcli("show ip4-reassembly details"))
913 self.logger.debug(self.vapi.ppcli("show ip6-reassembly details"))
914 super(TestFIFReassembly, self).tearDown()
916 def verify_capture(self, capture, ip_class, dropped_packet_indexes=[]):
917 """Verify captured packet stream.
919 :param list capture: Captured packet stream.
923 for packet in capture:
925 self.logger.debug(ppp("Got packet:", packet))
926 ip = packet[ip_class]
928 payload_info = self.payload_to_info(str(packet[Raw]))
929 packet_index = payload_info.index
931 packet_index not in dropped_packet_indexes,
932 ppp("Packet received, but should be dropped:", packet))
933 if packet_index in seen:
934 raise Exception(ppp("Duplicate packet received", packet))
935 seen.add(packet_index)
936 self.assertEqual(payload_info.dst, self.dst_if.sw_if_index)
937 info = self._packet_infos[packet_index]
938 self.assertTrue(info is not None)
939 self.assertEqual(packet_index, info.index)
940 saved_packet = info.data
941 self.assertEqual(ip.src, saved_packet[ip_class].src)
942 self.assertEqual(ip.dst, saved_packet[ip_class].dst)
943 self.assertEqual(udp.payload, saved_packet[UDP].payload)
945 self.logger.error(ppp("Unexpected or invalid packet:", packet))
947 for index in self._packet_infos:
948 self.assertTrue(index in seen or index in dropped_packet_indexes,
949 "Packet with packet_index %d not received" % index)
952 """ Fragments in fragments (4o4) """
954 # TODO this should be ideally in setUpClass, but then we hit a bug
955 # with VppIpRoute incorrectly reporting it's present when it's not
956 # so we need to manually remove the vpp config, thus we cannot have
957 # it shared for multiple test cases
958 self.tun_ip4 = "1.1.1.2"
960 self.gre4 = VppGreInterface(self, self.src_if.local_ip4, self.tun_ip4)
961 self.gre4.add_vpp_config()
963 self.gre4.config_ip4()
965 self.vapi.ip_reassembly_enable_disable(
966 sw_if_index=self.gre4.sw_if_index, enable_ip4=True)
968 self.route4 = VppIpRoute(self, self.tun_ip4, 32,
969 [VppRoutePath(self.src_if.remote_ip4,
970 self.src_if.sw_if_index)])
971 self.route4.add_vpp_config()
973 self.reset_packet_infos()
974 for i in range(test_packet_count):
975 info = self.create_packet_info(self.src_if, self.dst_if)
976 payload = self.info_to_payload(info)
977 # Ethernet header here is only for size calculation, thus it
978 # doesn't matter how it's initialized. This is to ensure that
979 # reassembled packet is not > 9000 bytes, so that it's not dropped
981 IP(id=i, src=self.src_if.remote_ip4,
982 dst=self.dst_if.remote_ip4) /
983 UDP(sport=1234, dport=5678) /
985 size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
986 self.extend_packet(p, size, self.padding)
987 info.data = p[IP] # use only IP part, without ethernet header
989 fragments = [x for _, p in six.iteritems(self._packet_infos)
990 for x in fragment_rfc791(p.data, 400)]
992 encapped_fragments = \
993 [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
994 IP(src=self.tun_ip4, dst=self.src_if.local_ip4) /
999 fragmented_encapped_fragments = \
1000 [x for p in encapped_fragments
1001 for x in fragment_rfc791(p, 200)]
1003 self.src_if.add_stream(fragmented_encapped_fragments)
1005 self.pg_enable_capture(self.pg_interfaces)
1008 self.src_if.assert_nothing_captured()
1009 packets = self.dst_if.get_capture(len(self._packet_infos))
1010 self.verify_capture(packets, IP)
1012 # TODO remove gre vpp config by hand until VppIpRoute gets fixed
1013 # so that it's query_vpp_config() works as it should
1014 self.gre4.remove_vpp_config()
1015 self.logger.debug(self.vapi.ppcli("show interface"))
1017 def test_fif6(self):
1018 """ Fragments in fragments (6o6) """
1019 # TODO this should be ideally in setUpClass, but then we hit a bug
1020 # with VppIpRoute incorrectly reporting it's present when it's not
1021 # so we need to manually remove the vpp config, thus we cannot have
1022 # it shared for multiple test cases
1023 self.tun_ip6 = "1002::1"
1025 self.gre6 = VppGre6Interface(self, self.src_if.local_ip6, self.tun_ip6)
1026 self.gre6.add_vpp_config()
1027 self.gre6.admin_up()
1028 self.gre6.config_ip6()
1030 self.vapi.ip_reassembly_enable_disable(
1031 sw_if_index=self.gre6.sw_if_index, enable_ip6=True)
1033 self.route6 = VppIpRoute(self, self.tun_ip6, 128,
1034 [VppRoutePath(self.src_if.remote_ip6,
1035 self.src_if.sw_if_index,
1036 proto=DpoProto.DPO_PROTO_IP6)],
1038 self.route6.add_vpp_config()
1040 self.reset_packet_infos()
1041 for i in range(test_packet_count):
1042 info = self.create_packet_info(self.src_if, self.dst_if)
1043 payload = self.info_to_payload(info)
1044 # Ethernet header here is only for size calculation, thus it
1045 # doesn't matter how it's initialized. This is to ensure that
1046 # reassembled packet is not > 9000 bytes, so that it's not dropped
1048 IPv6(src=self.src_if.remote_ip6, dst=self.dst_if.remote_ip6) /
1049 UDP(sport=1234, dport=5678) /
1051 size = self.packet_sizes[(i // 2) % len(self.packet_sizes)]
1052 self.extend_packet(p, size, self.padding)
1053 info.data = p[IPv6] # use only IPv6 part, without ethernet header
1055 fragments = [x for _, i in six.iteritems(self._packet_infos)
1056 for x in fragment_rfc8200(
1057 i.data, i.index, 400)]
1059 encapped_fragments = \
1060 [Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
1061 IPv6(src=self.tun_ip6, dst=self.src_if.local_ip6) /
1066 fragmented_encapped_fragments = \
1067 [x for p in encapped_fragments for x in (
1070 2 * len(self._packet_infos) + p[IPv6ExtHdrFragment].id,
1072 if IPv6ExtHdrFragment in p else [p]
1076 self.src_if.add_stream(fragmented_encapped_fragments)
1078 self.pg_enable_capture(self.pg_interfaces)
1081 self.src_if.assert_nothing_captured()
1082 packets = self.dst_if.get_capture(len(self._packet_infos))
1083 self.verify_capture(packets, IPv6)
1085 # TODO remove gre vpp config by hand until VppIpRoute gets fixed
1086 # so that it's query_vpp_config() works as it should
1087 self.gre6.remove_vpp_config()
1090 if __name__ == '__main__':
1091 unittest.main(testRunner=VppTestRunner)