6 from scapy.packet import Raw
7 from scapy.layers.l2 import Ether, Dot1Q, GRE
8 from scapy.layers.inet import IP, UDP
9 from scapy.layers.inet6 import IPv6
10 from scapy.volatile import RandMAC, RandIP
12 from framework import VppTestCase, VppTestRunner
13 from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint
14 from vpp_gre_interface import VppGreInterface
15 from vpp_nhrp import VppNhrp
16 from vpp_ip import DpoProto
17 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable, FibPathProto
18 from util import ppp, ppc
19 from vpp_papi import VppEnum
22 class TestGREInputNodes(VppTestCase):
23 """ GRE Input Nodes Test Case """
26 super(TestGREInputNodes, self).setUp()
28 # create 3 pg interfaces - set one in a non-default table.
29 self.create_pg_interfaces(range(1))
31 for i in self.pg_interfaces:
36 for i in self.pg_interfaces:
39 super(TestGREInputNodes, self).tearDown()
41 def test_gre_input_node(self):
42 """ GRE gre input nodes not registerd unless configured """
43 pkt = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
44 IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
47 self.pg0.add_stream(pkt)
49 # no tunnel created, gre-input not registered
50 err = self.statistics.get_counter(
51 '/err/ip4-input/unknown ip protocol')[0]
52 self.assertEqual(err, 1)
56 gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
57 gre_if.add_vpp_config()
59 self.pg0.add_stream(pkt)
61 # tunnel created, gre-input registered
62 err = self.statistics.get_counter(
63 '/err/ip4-input/unknown ip protocol')[0]
64 # expect no new errors
65 self.assertEqual(err, err_count)
68 class TestGRE(VppTestCase):
73 super(TestGRE, cls).setUpClass()
76 def tearDownClass(cls):
77 super(TestGRE, cls).tearDownClass()
80 super(TestGRE, self).setUp()
82 # create 3 pg interfaces - set one in a non-default table.
83 self.create_pg_interfaces(range(5))
85 self.tbl = VppIpTable(self, 1)
86 self.tbl.add_vpp_config()
87 self.pg1.set_table_ip4(1)
89 for i in self.pg_interfaces:
93 self.pg0.resolve_arp()
95 self.pg1.resolve_arp()
97 self.pg2.resolve_ndp()
99 self.pg3.resolve_arp()
100 self.pg4.config_ip4()
101 self.pg4.resolve_arp()
104 for i in self.pg_interfaces:
108 self.pg1.set_table_ip4(0)
109 super(TestGRE, self).tearDown()
111 def create_stream_ip4(self, src_if, src_ip, dst_ip):
113 for i in range(0, 257):
114 info = self.create_packet_info(src_if, src_if)
115 payload = self.info_to_payload(info)
116 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
117 IP(src=src_ip, dst=dst_ip) /
118 UDP(sport=1234, dport=1234) /
124 def create_stream_ip6(self, src_if, src_ip, dst_ip):
126 for i in range(0, 257):
127 info = self.create_packet_info(src_if, src_if)
128 payload = self.info_to_payload(info)
129 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
130 IPv6(src=src_ip, dst=dst_ip) /
131 UDP(sport=1234, dport=1234) /
137 def create_tunnel_stream_4o4(self, src_if,
138 tunnel_src, tunnel_dst,
141 for i in range(0, 257):
142 info = self.create_packet_info(src_if, src_if)
143 payload = self.info_to_payload(info)
144 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
145 IP(src=tunnel_src, dst=tunnel_dst) /
147 IP(src=src_ip, dst=dst_ip) /
148 UDP(sport=1234, dport=1234) /
154 def create_tunnel_stream_6o4(self, src_if,
155 tunnel_src, tunnel_dst,
158 for i in range(0, 257):
159 info = self.create_packet_info(src_if, src_if)
160 payload = self.info_to_payload(info)
161 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
162 IP(src=tunnel_src, dst=tunnel_dst) /
164 IPv6(src=src_ip, dst=dst_ip) /
165 UDP(sport=1234, dport=1234) /
171 def create_tunnel_stream_6o6(self, src_if,
172 tunnel_src, tunnel_dst,
175 for i in range(0, 257):
176 info = self.create_packet_info(src_if, src_if)
177 payload = self.info_to_payload(info)
178 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
179 IPv6(src=tunnel_src, dst=tunnel_dst) /
181 IPv6(src=src_ip, dst=dst_ip) /
182 UDP(sport=1234, dport=1234) /
188 def create_tunnel_stream_l2o4(self, src_if,
189 tunnel_src, tunnel_dst):
191 for i in range(0, 257):
192 info = self.create_packet_info(src_if, src_if)
193 payload = self.info_to_payload(info)
194 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
195 IP(src=tunnel_src, dst=tunnel_dst) /
197 Ether(dst=RandMAC('*:*:*:*:*:*'),
198 src=RandMAC('*:*:*:*:*:*')) /
199 IP(src=scapy.compat.raw(RandIP()),
200 dst=scapy.compat.raw(RandIP())) /
201 UDP(sport=1234, dport=1234) /
207 def create_tunnel_stream_vlano4(self, src_if,
208 tunnel_src, tunnel_dst, vlan):
210 for i in range(0, 257):
211 info = self.create_packet_info(src_if, src_if)
212 payload = self.info_to_payload(info)
213 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
214 IP(src=tunnel_src, dst=tunnel_dst) /
216 Ether(dst=RandMAC('*:*:*:*:*:*'),
217 src=RandMAC('*:*:*:*:*:*')) /
219 IP(src=scapy.compat.raw(RandIP()),
220 dst=scapy.compat.raw(RandIP())) /
221 UDP(sport=1234, dport=1234) /
227 def verify_tunneled_4o4(self, src_if, capture, sent,
228 tunnel_src, tunnel_dst):
230 self.assertEqual(len(capture), len(sent))
232 for i in range(len(capture)):
240 self.assertEqual(rx_ip.src, tunnel_src)
241 self.assertEqual(rx_ip.dst, tunnel_dst)
246 self.assertEqual(rx_ip.src, tx_ip.src)
247 self.assertEqual(rx_ip.dst, tx_ip.dst)
248 # IP processing post pop has decremented the TTL
249 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
252 self.logger.error(ppp("Rx:", rx))
253 self.logger.error(ppp("Tx:", tx))
256 def verify_tunneled_6o6(self, src_if, capture, sent,
257 tunnel_src, tunnel_dst):
259 self.assertEqual(len(capture), len(sent))
261 for i in range(len(capture)):
269 self.assertEqual(rx_ip.src, tunnel_src)
270 self.assertEqual(rx_ip.dst, tunnel_dst)
272 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
275 self.assertEqual(rx_ip.src, tx_ip.src)
276 self.assertEqual(rx_ip.dst, tx_ip.dst)
279 self.logger.error(ppp("Rx:", rx))
280 self.logger.error(ppp("Tx:", tx))
283 def verify_tunneled_4o6(self, src_if, capture, sent,
284 tunnel_src, tunnel_dst):
286 self.assertEqual(len(capture), len(sent))
288 for i in range(len(capture)):
295 self.assertEqual(rx_ip.src, tunnel_src)
296 self.assertEqual(rx_ip.dst, tunnel_dst)
298 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
302 self.assertEqual(rx_ip.src, tx_ip.src)
303 self.assertEqual(rx_ip.dst, tx_ip.dst)
306 self.logger.error(ppp("Rx:", rx))
307 self.logger.error(ppp("Tx:", tx))
310 def verify_tunneled_6o4(self, src_if, capture, sent,
311 tunnel_src, tunnel_dst):
313 self.assertEqual(len(capture), len(sent))
315 for i in range(len(capture)):
322 self.assertEqual(rx_ip.src, tunnel_src)
323 self.assertEqual(rx_ip.dst, tunnel_dst)
325 rx_gre = GRE(scapy.compat.raw(rx_ip[IP].payload))
329 self.assertEqual(rx_ip.src, tx_ip.src)
330 self.assertEqual(rx_ip.dst, tx_ip.dst)
333 self.logger.error(ppp("Rx:", rx))
334 self.logger.error(ppp("Tx:", tx))
337 def verify_tunneled_l2o4(self, src_if, capture, sent,
338 tunnel_src, tunnel_dst):
339 self.assertEqual(len(capture), len(sent))
341 for i in range(len(capture)):
349 self.assertEqual(rx_ip.src, tunnel_src)
350 self.assertEqual(rx_ip.dst, tunnel_dst)
353 rx_l2 = rx_gre[Ether]
356 tx_l2 = tx_gre[Ether]
359 self.assertEqual(rx_ip.src, tx_ip.src)
360 self.assertEqual(rx_ip.dst, tx_ip.dst)
361 # bridged, not L3 forwarded, so no TTL decrement
362 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
365 self.logger.error(ppp("Rx:", rx))
366 self.logger.error(ppp("Tx:", tx))
369 def verify_tunneled_vlano4(self, src_if, capture, sent,
370 tunnel_src, tunnel_dst, vlan):
372 self.assertEqual(len(capture), len(sent))
374 ppc("Unexpected packets captured:", capture)
377 for i in range(len(capture)):
385 self.assertEqual(rx_ip.src, tunnel_src)
386 self.assertEqual(rx_ip.dst, tunnel_dst)
389 rx_l2 = rx_gre[Ether]
390 rx_vlan = rx_l2[Dot1Q]
393 self.assertEqual(rx_vlan.vlan, vlan)
396 tx_l2 = tx_gre[Ether]
399 self.assertEqual(rx_ip.src, tx_ip.src)
400 self.assertEqual(rx_ip.dst, tx_ip.dst)
401 # bridged, not L3 forwarded, so no TTL decrement
402 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
405 self.logger.error(ppp("Rx:", rx))
406 self.logger.error(ppp("Tx:", tx))
409 def verify_decapped_4o4(self, src_if, capture, sent):
410 self.assertEqual(len(capture), len(sent))
412 for i in range(len(capture)):
422 self.assertEqual(rx_ip.src, tx_ip.src)
423 self.assertEqual(rx_ip.dst, tx_ip.dst)
424 # IP processing post pop has decremented the TTL
425 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
428 self.logger.error(ppp("Rx:", rx))
429 self.logger.error(ppp("Tx:", tx))
432 def verify_decapped_6o4(self, src_if, capture, sent):
433 self.assertEqual(len(capture), len(sent))
435 for i in range(len(capture)):
445 self.assertEqual(rx_ip.src, tx_ip.src)
446 self.assertEqual(rx_ip.dst, tx_ip.dst)
447 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
450 self.logger.error(ppp("Rx:", rx))
451 self.logger.error(ppp("Tx:", tx))
455 """ GRE IPv4 tunnel Tests """
458 # Create an L3 GRE tunnel.
460 # - assign an IP Addres
461 # - Add a route via the tunnel
463 gre_if = VppGreInterface(self,
466 gre_if.add_vpp_config()
469 # The double create (create the same tunnel twice) should fail,
470 # and we should still be able to use the original
473 gre_if.add_vpp_config()
477 self.fail("Double GRE tunnel add does not fail")
482 route_via_tun = VppIpRoute(self, "4.4.4.4", 32,
483 [VppRoutePath("0.0.0.0",
484 gre_if.sw_if_index)])
486 route_via_tun.add_vpp_config()
489 # Send a packet stream that is routed into the tunnel
490 # - they are all dropped since the tunnel's destintation IP
491 # is unresolved - or resolves via the default route - which
494 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
496 self.send_and_assert_no_replies(self.pg0, tx)
499 # Add a route that resolves the tunnel's destination
501 route_tun_dst = VppIpRoute(self, "1.1.1.2", 32,
502 [VppRoutePath(self.pg0.remote_ip4,
503 self.pg0.sw_if_index)])
504 route_tun_dst.add_vpp_config()
507 # Send a packet stream that is routed into the tunnel
508 # - packets are GRE encapped
510 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
511 rx = self.send_and_expect(self.pg0, tx, self.pg0)
512 self.verify_tunneled_4o4(self.pg0, rx, tx,
513 self.pg0.local_ip4, "1.1.1.2")
516 # Send tunneled packets that match the created tunnel and
517 # are decapped and forwarded
519 tx = self.create_tunnel_stream_4o4(self.pg0,
524 rx = self.send_and_expect(self.pg0, tx, self.pg0)
525 self.verify_decapped_4o4(self.pg0, rx, tx)
528 # Send tunneled packets that do not match the tunnel's src
530 self.vapi.cli("clear trace")
531 tx = self.create_tunnel_stream_4o4(self.pg0,
536 self.send_and_assert_no_replies(
538 remark="GRE packets forwarded despite no SRC address match")
541 # Configure IPv6 on the PG interface so we can route IPv6
544 self.pg0.config_ip6()
545 self.pg0.resolve_ndp()
548 # Send IPv6 tunnel encapslated packets
549 # - dropped since IPv6 is not enabled on the tunnel
551 tx = self.create_tunnel_stream_6o4(self.pg0,
556 self.send_and_assert_no_replies(self.pg0, tx,
557 "IPv6 GRE packets forwarded "
558 "despite IPv6 not enabled on tunnel")
561 # Enable IPv6 on the tunnel
566 # Send IPv6 tunnel encapslated packets
567 # - forwarded since IPv6 is enabled on the tunnel
569 tx = self.create_tunnel_stream_6o4(self.pg0,
574 rx = self.send_and_expect(self.pg0, tx, self.pg0)
575 self.verify_decapped_6o4(self.pg0, rx, tx)
578 # Send v6 packets for v4 encap
580 route6_via_tun = VppIpRoute(
581 self, "2001::1", 128,
584 proto=DpoProto.DPO_PROTO_IP6)])
585 route6_via_tun.add_vpp_config()
587 tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
588 rx = self.send_and_expect(self.pg0, tx, self.pg0)
590 self.verify_tunneled_6o4(self.pg0, rx, tx,
591 self.pg0.local_ip4, "1.1.1.2")
596 route_tun_dst.remove_vpp_config()
597 route_via_tun.remove_vpp_config()
598 route6_via_tun.remove_vpp_config()
599 gre_if.remove_vpp_config()
601 self.pg0.unconfig_ip6()
604 """ GRE IPv6 tunnel Tests """
606 self.pg1.config_ip6()
607 self.pg1.resolve_ndp()
610 # Create an L3 GRE tunnel.
612 # - assign an IP Address
613 # - Add a route via the tunnel
615 gre_if = VppGreInterface(self,
618 gre_if.add_vpp_config()
622 route_via_tun = VppIpRoute(self, "4004::1", 128,
623 [VppRoutePath("0::0",
624 gre_if.sw_if_index)])
626 route_via_tun.add_vpp_config()
629 # Send a packet stream that is routed into the tunnel
630 # - they are all dropped since the tunnel's destintation IP
631 # is unresolved - or resolves via the default route - which
634 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
635 self.send_and_assert_no_replies(
637 "GRE packets forwarded without DIP resolved")
640 # Add a route that resolves the tunnel's destination
642 route_tun_dst = VppIpRoute(self, "1002::1", 128,
643 [VppRoutePath(self.pg2.remote_ip6,
644 self.pg2.sw_if_index)])
645 route_tun_dst.add_vpp_config()
648 # Send a packet stream that is routed into the tunnel
649 # - packets are GRE encapped
651 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
652 rx = self.send_and_expect(self.pg2, tx, self.pg2)
653 self.verify_tunneled_6o6(self.pg2, rx, tx,
654 self.pg2.local_ip6, "1002::1")
657 # Test decap. decapped packets go out pg1
659 tx = self.create_tunnel_stream_6o6(self.pg2,
664 rx = self.send_and_expect(self.pg2, tx, self.pg1)
667 # RX'd packet is UDP over IPv6, test the GRE header is gone.
669 self.assertFalse(rx[0].haslayer(GRE))
670 self.assertEqual(rx[0][IPv6].dst, self.pg1.remote_ip6)
675 route4_via_tun = VppIpRoute(self, "1.1.1.1", 32,
676 [VppRoutePath("0.0.0.0",
677 gre_if.sw_if_index)])
678 route4_via_tun.add_vpp_config()
680 tx = self.create_stream_ip4(self.pg0, "1.1.1.2", "1.1.1.1")
681 rx = self.send_and_expect(self.pg0, tx, self.pg2)
683 self.verify_tunneled_4o6(self.pg0, rx, tx,
684 self.pg2.local_ip6, "1002::1")
689 route_tun_dst.remove_vpp_config()
690 route_via_tun.remove_vpp_config()
691 route4_via_tun.remove_vpp_config()
692 gre_if.remove_vpp_config()
694 self.pg2.unconfig_ip6()
695 self.pg1.unconfig_ip6()
697 def test_gre_vrf(self):
698 """ GRE tunnel VRF Tests """
701 # Create an L3 GRE tunnel whose destination is in the non-default
702 # table. The underlay is thus non-default - the overlay is still
705 # - assign an IP Addres
707 gre_if = VppGreInterface(self, self.pg1.local_ip4,
710 gre_if.add_vpp_config()
715 # Add a route via the tunnel - in the overlay
717 route_via_tun = VppIpRoute(self, "9.9.9.9", 32,
718 [VppRoutePath("0.0.0.0",
719 gre_if.sw_if_index)])
720 route_via_tun.add_vpp_config()
723 # Add a route that resolves the tunnel's destination - in the
726 route_tun_dst = VppIpRoute(self, "2.2.2.2", 32, table_id=1,
727 paths=[VppRoutePath(self.pg1.remote_ip4,
728 self.pg1.sw_if_index)])
729 route_tun_dst.add_vpp_config()
732 # Send a packet stream that is routed into the tunnel
733 # packets are sent in on pg0 which is in the default table
734 # - packets are GRE encapped
736 self.vapi.cli("clear trace")
737 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "9.9.9.9")
738 rx = self.send_and_expect(self.pg0, tx, self.pg1)
739 self.verify_tunneled_4o4(self.pg1, rx, tx,
740 self.pg1.local_ip4, "2.2.2.2")
743 # Send tunneled packets that match the created tunnel and
744 # are decapped and forwarded. This tests the decap lookup
745 # does not happen in the encap table
747 self.vapi.cli("clear trace")
748 tx = self.create_tunnel_stream_4o4(self.pg1,
753 rx = self.send_and_expect(self.pg1, tx, self.pg0)
754 self.verify_decapped_4o4(self.pg0, rx, tx)
757 # Send tunneled packets that match the created tunnel
758 # but arrive on an interface that is not in the tunnel's
759 # encap VRF, these are dropped.
760 # IP enable the interface so they aren't dropped due to
761 # IP not being enabled.
763 self.pg2.config_ip4()
764 self.vapi.cli("clear trace")
765 tx = self.create_tunnel_stream_4o4(self.pg2,
770 rx = self.send_and_assert_no_replies(
772 "GRE decap packets in wrong VRF")
774 self.pg2.unconfig_ip4()
779 route_tun_dst.remove_vpp_config()
780 route_via_tun.remove_vpp_config()
781 gre_if.remove_vpp_config()
783 def test_gre_l2(self):
784 """ GRE tunnel L2 Tests """
787 # Add routes to resolve the tunnel destinations
789 route_tun1_dst = VppIpRoute(self, "2.2.2.2", 32,
790 [VppRoutePath(self.pg0.remote_ip4,
791 self.pg0.sw_if_index)])
792 route_tun2_dst = VppIpRoute(self, "2.2.2.3", 32,
793 [VppRoutePath(self.pg0.remote_ip4,
794 self.pg0.sw_if_index)])
796 route_tun1_dst.add_vpp_config()
797 route_tun2_dst.add_vpp_config()
800 # Create 2 L2 GRE tunnels and x-connect them
802 gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
804 type=(VppEnum.vl_api_gre_tunnel_type_t.
805 GRE_API_TUNNEL_TYPE_TEB))
806 gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
808 type=(VppEnum.vl_api_gre_tunnel_type_t.
809 GRE_API_TUNNEL_TYPE_TEB))
810 gre_if1.add_vpp_config()
811 gre_if2.add_vpp_config()
816 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
819 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
824 # Send in tunnel encapped L2. expect out tunnel encapped L2
827 tx = self.create_tunnel_stream_l2o4(self.pg0,
830 rx = self.send_and_expect(self.pg0, tx, self.pg0)
831 self.verify_tunneled_l2o4(self.pg0, rx, tx,
835 tx = self.create_tunnel_stream_l2o4(self.pg0,
838 rx = self.send_and_expect(self.pg0, tx, self.pg0)
839 self.verify_tunneled_l2o4(self.pg0, rx, tx,
843 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
846 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
851 # Create a VLAN sub-interfaces on the GRE TEB interfaces
852 # then x-connect them
854 gre_if_11 = VppDot1QSubint(self, gre_if1, 11)
855 gre_if_12 = VppDot1QSubint(self, gre_if2, 12)
857 # gre_if_11.add_vpp_config()
858 # gre_if_12.add_vpp_config()
863 self.vapi.sw_interface_set_l2_xconnect(gre_if_11.sw_if_index,
864 gre_if_12.sw_if_index,
866 self.vapi.sw_interface_set_l2_xconnect(gre_if_12.sw_if_index,
867 gre_if_11.sw_if_index,
871 # Configure both to pop thier respective VLAN tags,
872 # so that during the x-coonect they will subsequently push
874 self.vapi.l2_interface_vlan_tag_rewrite(
875 sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
877 self.vapi.l2_interface_vlan_tag_rewrite(
878 sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
882 # Send traffic in both directiond - expect the VLAN tags to
885 tx = self.create_tunnel_stream_vlano4(self.pg0,
889 rx = self.send_and_expect(self.pg0, tx, self.pg0)
890 self.verify_tunneled_vlano4(self.pg0, rx, tx,
895 tx = self.create_tunnel_stream_vlano4(self.pg0,
899 rx = self.send_and_expect(self.pg0, tx, self.pg0)
900 self.verify_tunneled_vlano4(self.pg0, rx, tx,
906 # Cleanup Test resources
908 gre_if_11.remove_vpp_config()
909 gre_if_12.remove_vpp_config()
910 gre_if1.remove_vpp_config()
911 gre_if2.remove_vpp_config()
912 route_tun1_dst.add_vpp_config()
913 route_tun2_dst.add_vpp_config()
915 def test_gre_loop(self):
916 """ GRE tunnel loop Tests """
919 # Create an L3 GRE tunnel.
921 # - assign an IP Addres
923 gre_if = VppGreInterface(self,
926 gre_if.add_vpp_config()
931 # add a route to the tunnel's destination that points
932 # through the tunnel, hence forming a loop in the forwarding
935 route_dst = VppIpRoute(self, "1.1.1.2", 32,
936 [VppRoutePath("0.0.0.0",
937 gre_if.sw_if_index)])
938 route_dst.add_vpp_config()
941 # packets to the tunnels destination should be dropped
943 tx = self.create_stream_ip4(self.pg0, "1.1.1.1", "1.1.1.2")
944 self.send_and_assert_no_replies(self.pg2, tx)
946 self.logger.info(self.vapi.ppcli("sh adj 7"))
951 route_dst.modify([VppRoutePath(self.pg1.remote_ip4,
952 self.pg1.sw_if_index)])
953 route_dst.add_vpp_config()
955 rx = self.send_and_expect(self.pg0, tx, self.pg1)
958 # a good route throught the tunnel to check it restacked
960 route_via_tun_2 = VppIpRoute(self, "2.2.2.2", 32,
961 [VppRoutePath("0.0.0.0",
962 gre_if.sw_if_index)])
963 route_via_tun_2.add_vpp_config()
965 tx = self.create_stream_ip4(self.pg0, "2.2.2.3", "2.2.2.2")
966 rx = self.send_and_expect(self.pg0, tx, self.pg1)
967 self.verify_tunneled_4o4(self.pg1, rx, tx,
968 self.pg0.local_ip4, "1.1.1.2")
973 route_via_tun_2.remove_vpp_config()
974 gre_if.remove_vpp_config()
977 """ mGRE IPv4 tunnel Tests """
979 for itf in self.pg_interfaces[3:]:
981 # one underlay nh for each overlay/tunnel peer
983 itf.generate_remote_hosts(4)
984 itf.configure_ipv4_neighbors()
987 # Create an L3 GRE tunnel.
989 # - assign an IP Addres
990 # - Add a route via the tunnel
992 gre_if = VppGreInterface(self,
995 mode=(VppEnum.vl_api_gre_tunnel_mode_t.
996 GRE_API_TUNNEL_MODE_MP))
997 gre_if.add_vpp_config()
1000 gre_if.generate_remote_hosts(4)
1005 for ii in range(1, 4):
1006 route_addr = "4.4.4.%d" % ii
1009 # route traffic via the peer
1011 route_via_tun = VppIpRoute(
1012 self, route_addr, 32,
1013 [VppRoutePath(gre_if._remote_hosts[ii].ip4,
1014 gre_if.sw_if_index)])
1015 route_via_tun.add_vpp_config()
1018 # Add a NHRP entry resolves the peer
1020 nhrp = VppNhrp(self, gre_if,
1021 gre_if._remote_hosts[ii].ip4,
1022 itf._remote_hosts[ii].ip4)
1023 nhrp.add_vpp_config()
1026 # Send a packet stream that is routed into the tunnel
1027 # - packets are GRE encapped
1029 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", route_addr)
1030 rx = self.send_and_expect(self.pg0, tx, itf)
1031 self.verify_tunneled_4o4(self.pg0, rx, tx,
1033 gre_if._remote_hosts[ii].ip4)
1036 # delete and re-add the NHRP
1038 nhrp.remove_vpp_config()
1039 self.send_and_assert_no_replies(self.pg0, tx)
1041 nhrp.add_vpp_config()
1042 rx = self.send_and_expect(self.pg0, tx, itf)
1043 self.verify_tunneled_4o4(self.pg0, rx, tx,
1045 gre_if._remote_hosts[ii].ip4)
1048 if __name__ == '__main__':
1049 unittest.main(testRunner=VppTestRunner)