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))
454 def verify_decapped_6o6(self, src_if, capture, sent):
455 self.assertEqual(len(capture), len(sent))
457 for i in range(len(capture)):
467 self.assertEqual(rx_ip.src, tx_ip.src)
468 self.assertEqual(rx_ip.dst, tx_ip.dst)
469 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
472 self.logger.error(ppp("Rx:", rx))
473 self.logger.error(ppp("Tx:", tx))
477 """ GRE IPv4 tunnel Tests """
480 # Create an L3 GRE tunnel.
482 # - assign an IP Addres
483 # - Add a route via the tunnel
485 gre_if = VppGreInterface(self,
488 gre_if.add_vpp_config()
491 # The double create (create the same tunnel twice) should fail,
492 # and we should still be able to use the original
495 gre_if.add_vpp_config()
499 self.fail("Double GRE tunnel add does not fail")
504 route_via_tun = VppIpRoute(self, "4.4.4.4", 32,
505 [VppRoutePath("0.0.0.0",
506 gre_if.sw_if_index)])
508 route_via_tun.add_vpp_config()
511 # Send a packet stream that is routed into the tunnel
512 # - they are all dropped since the tunnel's destintation IP
513 # is unresolved - or resolves via the default route - which
516 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
518 self.send_and_assert_no_replies(self.pg0, tx)
521 # Add a route that resolves the tunnel's destination
523 route_tun_dst = VppIpRoute(self, "1.1.1.2", 32,
524 [VppRoutePath(self.pg0.remote_ip4,
525 self.pg0.sw_if_index)])
526 route_tun_dst.add_vpp_config()
529 # Send a packet stream that is routed into the tunnel
530 # - packets are GRE encapped
532 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
533 rx = self.send_and_expect(self.pg0, tx, self.pg0)
534 self.verify_tunneled_4o4(self.pg0, rx, tx,
535 self.pg0.local_ip4, "1.1.1.2")
538 # Send tunneled packets that match the created tunnel and
539 # are decapped and forwarded
541 tx = self.create_tunnel_stream_4o4(self.pg0,
546 rx = self.send_and_expect(self.pg0, tx, self.pg0)
547 self.verify_decapped_4o4(self.pg0, rx, tx)
550 # Send tunneled packets that do not match the tunnel's src
552 self.vapi.cli("clear trace")
553 tx = self.create_tunnel_stream_4o4(self.pg0,
558 self.send_and_assert_no_replies(
560 remark="GRE packets forwarded despite no SRC address match")
563 # Configure IPv6 on the PG interface so we can route IPv6
566 self.pg0.config_ip6()
567 self.pg0.resolve_ndp()
570 # Send IPv6 tunnel encapslated packets
571 # - dropped since IPv6 is not enabled on the tunnel
573 tx = self.create_tunnel_stream_6o4(self.pg0,
578 self.send_and_assert_no_replies(self.pg0, tx,
579 "IPv6 GRE packets forwarded "
580 "despite IPv6 not enabled on tunnel")
583 # Enable IPv6 on the tunnel
588 # Send IPv6 tunnel encapslated packets
589 # - forwarded since IPv6 is enabled on the tunnel
591 tx = self.create_tunnel_stream_6o4(self.pg0,
596 rx = self.send_and_expect(self.pg0, tx, self.pg0)
597 self.verify_decapped_6o4(self.pg0, rx, tx)
600 # Send v6 packets for v4 encap
602 route6_via_tun = VppIpRoute(
603 self, "2001::1", 128,
606 proto=DpoProto.DPO_PROTO_IP6)])
607 route6_via_tun.add_vpp_config()
609 tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
610 rx = self.send_and_expect(self.pg0, tx, self.pg0)
612 self.verify_tunneled_6o4(self.pg0, rx, tx,
613 self.pg0.local_ip4, "1.1.1.2")
618 route_tun_dst.remove_vpp_config()
619 route_via_tun.remove_vpp_config()
620 route6_via_tun.remove_vpp_config()
621 gre_if.remove_vpp_config()
623 self.pg0.unconfig_ip6()
626 """ GRE IPv6 tunnel Tests """
628 self.pg1.config_ip6()
629 self.pg1.resolve_ndp()
632 # Create an L3 GRE tunnel.
634 # - assign an IP Address
635 # - Add a route via the tunnel
637 gre_if = VppGreInterface(self,
640 gre_if.add_vpp_config()
644 route_via_tun = VppIpRoute(self, "4004::1", 128,
645 [VppRoutePath("0::0",
646 gre_if.sw_if_index)])
648 route_via_tun.add_vpp_config()
651 # Send a packet stream that is routed into the tunnel
652 # - they are all dropped since the tunnel's destintation IP
653 # is unresolved - or resolves via the default route - which
656 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
657 self.send_and_assert_no_replies(
659 "GRE packets forwarded without DIP resolved")
662 # Add a route that resolves the tunnel's destination
664 route_tun_dst = VppIpRoute(self, "1002::1", 128,
665 [VppRoutePath(self.pg2.remote_ip6,
666 self.pg2.sw_if_index)])
667 route_tun_dst.add_vpp_config()
670 # Send a packet stream that is routed into the tunnel
671 # - packets are GRE encapped
673 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
674 rx = self.send_and_expect(self.pg2, tx, self.pg2)
675 self.verify_tunneled_6o6(self.pg2, rx, tx,
676 self.pg2.local_ip6, "1002::1")
679 # Test decap. decapped packets go out pg1
681 tx = self.create_tunnel_stream_6o6(self.pg2,
686 rx = self.send_and_expect(self.pg2, tx, self.pg1)
689 # RX'd packet is UDP over IPv6, test the GRE header is gone.
691 self.assertFalse(rx[0].haslayer(GRE))
692 self.assertEqual(rx[0][IPv6].dst, self.pg1.remote_ip6)
697 route4_via_tun = VppIpRoute(self, "1.1.1.1", 32,
698 [VppRoutePath("0.0.0.0",
699 gre_if.sw_if_index)])
700 route4_via_tun.add_vpp_config()
702 tx = self.create_stream_ip4(self.pg0, "1.1.1.2", "1.1.1.1")
703 rx = self.send_and_expect(self.pg0, tx, self.pg2)
705 self.verify_tunneled_4o6(self.pg0, rx, tx,
706 self.pg2.local_ip6, "1002::1")
711 route_tun_dst.remove_vpp_config()
712 route_via_tun.remove_vpp_config()
713 route4_via_tun.remove_vpp_config()
714 gre_if.remove_vpp_config()
716 self.pg2.unconfig_ip6()
717 self.pg1.unconfig_ip6()
719 def test_gre_vrf(self):
720 """ GRE tunnel VRF Tests """
723 # Create an L3 GRE tunnel whose destination is in the non-default
724 # table. The underlay is thus non-default - the overlay is still
727 # - assign an IP Addres
729 gre_if = VppGreInterface(self, self.pg1.local_ip4,
732 gre_if.add_vpp_config()
737 # Add a route via the tunnel - in the overlay
739 route_via_tun = VppIpRoute(self, "9.9.9.9", 32,
740 [VppRoutePath("0.0.0.0",
741 gre_if.sw_if_index)])
742 route_via_tun.add_vpp_config()
745 # Add a route that resolves the tunnel's destination - in the
748 route_tun_dst = VppIpRoute(self, "2.2.2.2", 32, table_id=1,
749 paths=[VppRoutePath(self.pg1.remote_ip4,
750 self.pg1.sw_if_index)])
751 route_tun_dst.add_vpp_config()
754 # Send a packet stream that is routed into the tunnel
755 # packets are sent in on pg0 which is in the default table
756 # - packets are GRE encapped
758 self.vapi.cli("clear trace")
759 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "9.9.9.9")
760 rx = self.send_and_expect(self.pg0, tx, self.pg1)
761 self.verify_tunneled_4o4(self.pg1, rx, tx,
762 self.pg1.local_ip4, "2.2.2.2")
765 # Send tunneled packets that match the created tunnel and
766 # are decapped and forwarded. This tests the decap lookup
767 # does not happen in the encap table
769 self.vapi.cli("clear trace")
770 tx = self.create_tunnel_stream_4o4(self.pg1,
775 rx = self.send_and_expect(self.pg1, tx, self.pg0)
776 self.verify_decapped_4o4(self.pg0, rx, tx)
779 # Send tunneled packets that match the created tunnel
780 # but arrive on an interface that is not in the tunnel's
781 # encap VRF, these are dropped.
782 # IP enable the interface so they aren't dropped due to
783 # IP not being enabled.
785 self.pg2.config_ip4()
786 self.vapi.cli("clear trace")
787 tx = self.create_tunnel_stream_4o4(self.pg2,
792 rx = self.send_and_assert_no_replies(
794 "GRE decap packets in wrong VRF")
796 self.pg2.unconfig_ip4()
801 route_tun_dst.remove_vpp_config()
802 route_via_tun.remove_vpp_config()
803 gre_if.remove_vpp_config()
805 def test_gre_l2(self):
806 """ GRE tunnel L2 Tests """
809 # Add routes to resolve the tunnel destinations
811 route_tun1_dst = VppIpRoute(self, "2.2.2.2", 32,
812 [VppRoutePath(self.pg0.remote_ip4,
813 self.pg0.sw_if_index)])
814 route_tun2_dst = VppIpRoute(self, "2.2.2.3", 32,
815 [VppRoutePath(self.pg0.remote_ip4,
816 self.pg0.sw_if_index)])
818 route_tun1_dst.add_vpp_config()
819 route_tun2_dst.add_vpp_config()
822 # Create 2 L2 GRE tunnels and x-connect them
824 gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
826 type=(VppEnum.vl_api_gre_tunnel_type_t.
827 GRE_API_TUNNEL_TYPE_TEB))
828 gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
830 type=(VppEnum.vl_api_gre_tunnel_type_t.
831 GRE_API_TUNNEL_TYPE_TEB))
832 gre_if1.add_vpp_config()
833 gre_if2.add_vpp_config()
838 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
841 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
846 # Send in tunnel encapped L2. expect out tunnel encapped L2
849 tx = self.create_tunnel_stream_l2o4(self.pg0,
852 rx = self.send_and_expect(self.pg0, tx, self.pg0)
853 self.verify_tunneled_l2o4(self.pg0, rx, tx,
857 tx = self.create_tunnel_stream_l2o4(self.pg0,
860 rx = self.send_and_expect(self.pg0, tx, self.pg0)
861 self.verify_tunneled_l2o4(self.pg0, rx, tx,
865 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
868 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
873 # Create a VLAN sub-interfaces on the GRE TEB interfaces
874 # then x-connect them
876 gre_if_11 = VppDot1QSubint(self, gre_if1, 11)
877 gre_if_12 = VppDot1QSubint(self, gre_if2, 12)
879 # gre_if_11.add_vpp_config()
880 # gre_if_12.add_vpp_config()
885 self.vapi.sw_interface_set_l2_xconnect(gre_if_11.sw_if_index,
886 gre_if_12.sw_if_index,
888 self.vapi.sw_interface_set_l2_xconnect(gre_if_12.sw_if_index,
889 gre_if_11.sw_if_index,
893 # Configure both to pop thier respective VLAN tags,
894 # so that during the x-coonect they will subsequently push
896 self.vapi.l2_interface_vlan_tag_rewrite(
897 sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
899 self.vapi.l2_interface_vlan_tag_rewrite(
900 sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
904 # Send traffic in both directiond - expect the VLAN tags to
907 tx = self.create_tunnel_stream_vlano4(self.pg0,
911 rx = self.send_and_expect(self.pg0, tx, self.pg0)
912 self.verify_tunneled_vlano4(self.pg0, rx, tx,
917 tx = self.create_tunnel_stream_vlano4(self.pg0,
921 rx = self.send_and_expect(self.pg0, tx, self.pg0)
922 self.verify_tunneled_vlano4(self.pg0, rx, tx,
928 # Cleanup Test resources
930 gre_if_11.remove_vpp_config()
931 gre_if_12.remove_vpp_config()
932 gre_if1.remove_vpp_config()
933 gre_if2.remove_vpp_config()
934 route_tun1_dst.add_vpp_config()
935 route_tun2_dst.add_vpp_config()
937 def test_gre_loop(self):
938 """ GRE tunnel loop Tests """
941 # Create an L3 GRE tunnel.
943 # - assign an IP Addres
945 gre_if = VppGreInterface(self,
948 gre_if.add_vpp_config()
953 # add a route to the tunnel's destination that points
954 # through the tunnel, hence forming a loop in the forwarding
957 route_dst = VppIpRoute(self, "1.1.1.2", 32,
958 [VppRoutePath("0.0.0.0",
959 gre_if.sw_if_index)])
960 route_dst.add_vpp_config()
963 # packets to the tunnels destination should be dropped
965 tx = self.create_stream_ip4(self.pg0, "1.1.1.1", "1.1.1.2")
966 self.send_and_assert_no_replies(self.pg2, tx)
968 self.logger.info(self.vapi.ppcli("sh adj 7"))
973 route_dst.modify([VppRoutePath(self.pg1.remote_ip4,
974 self.pg1.sw_if_index)])
975 route_dst.add_vpp_config()
977 rx = self.send_and_expect(self.pg0, tx, self.pg1)
980 # a good route throught the tunnel to check it restacked
982 route_via_tun_2 = VppIpRoute(self, "2.2.2.2", 32,
983 [VppRoutePath("0.0.0.0",
984 gre_if.sw_if_index)])
985 route_via_tun_2.add_vpp_config()
987 tx = self.create_stream_ip4(self.pg0, "2.2.2.3", "2.2.2.2")
988 rx = self.send_and_expect(self.pg0, tx, self.pg1)
989 self.verify_tunneled_4o4(self.pg1, rx, tx,
990 self.pg0.local_ip4, "1.1.1.2")
995 route_via_tun_2.remove_vpp_config()
996 gre_if.remove_vpp_config()
999 """ mGRE IPv4 tunnel Tests """
1001 for itf in self.pg_interfaces[3:]:
1003 # one underlay nh for each overlay/tunnel peer
1005 itf.generate_remote_hosts(4)
1006 itf.configure_ipv4_neighbors()
1009 # Create an L3 GRE tunnel.
1011 # - assign an IP Addres
1012 # - Add a route via the tunnel
1014 gre_if = VppGreInterface(self,
1017 mode=(VppEnum.vl_api_gre_tunnel_mode_t.
1018 GRE_API_TUNNEL_MODE_MP))
1019 gre_if.add_vpp_config()
1022 gre_if.generate_remote_hosts(4)
1024 self.logger.info(self.vapi.cli("sh adj"))
1025 self.logger.info(self.vapi.cli("sh ip fib"))
1028 # ensure we don't match to the tunnel if the source address
1031 tx = self.create_tunnel_stream_4o4(self.pg0,
1035 self.pg0.remote_ip4)
1036 self.send_and_assert_no_replies(self.pg0, tx)
1041 for ii in range(1, 4):
1042 route_addr = "4.4.4.%d" % ii
1045 # route traffic via the peer
1047 route_via_tun = VppIpRoute(
1048 self, route_addr, 32,
1049 [VppRoutePath(gre_if._remote_hosts[ii].ip4,
1050 gre_if.sw_if_index)])
1051 route_via_tun.add_vpp_config()
1054 # Add a NHRP entry resolves the peer
1056 nhrp = VppNhrp(self, gre_if,
1057 gre_if._remote_hosts[ii].ip4,
1058 itf._remote_hosts[ii].ip4)
1059 nhrp.add_vpp_config()
1062 # Send a packet stream that is routed into the tunnel
1063 # - packets are GRE encapped
1065 tx_e = self.create_stream_ip4(self.pg0, "5.5.5.5", route_addr)
1066 rx = self.send_and_expect(self.pg0, tx_e, itf)
1067 self.verify_tunneled_4o4(self.pg0, rx, tx_e,
1069 gre_if._remote_hosts[ii].ip4)
1071 tx_i = self.create_tunnel_stream_4o4(self.pg0,
1072 itf._remote_hosts[ii].ip4,
1075 self.pg0.remote_ip4)
1076 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1077 self.verify_decapped_4o4(self.pg0, rx, tx_i)
1080 # delete and re-add the NHRP
1082 nhrp.remove_vpp_config()
1083 self.send_and_assert_no_replies(self.pg0, tx_e)
1084 self.send_and_assert_no_replies(self.pg0, tx_i)
1086 nhrp.add_vpp_config()
1087 rx = self.send_and_expect(self.pg0, tx_e, itf)
1088 self.verify_tunneled_4o4(self.pg0, rx, tx_e,
1090 gre_if._remote_hosts[ii].ip4)
1091 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1092 self.verify_decapped_4o4(self.pg0, rx, tx_i)
1095 gre_if.unconfig_ip4()
1097 def test_mgre6(self):
1098 """ mGRE IPv6 tunnel Tests """
1100 self.pg0.config_ip6()
1101 self.pg0.resolve_ndp()
1103 for itf in self.pg_interfaces[3:]:
1105 # one underlay nh for each overlay/tunnel peer
1108 itf.generate_remote_hosts(4)
1109 itf.configure_ipv6_neighbors()
1112 # Create an L3 GRE tunnel.
1114 # - assign an IP Addres
1115 # - Add a route via the tunnel
1117 gre_if = VppGreInterface(self,
1120 mode=(VppEnum.vl_api_gre_tunnel_mode_t.
1121 GRE_API_TUNNEL_MODE_MP))
1122 gre_if.add_vpp_config()
1125 gre_if.generate_remote_hosts(4)
1130 for ii in range(1, 4):
1131 route_addr = "4::%d" % ii
1134 # route traffic via the peer
1136 route_via_tun = VppIpRoute(
1137 self, route_addr, 128,
1138 [VppRoutePath(gre_if._remote_hosts[ii].ip6,
1139 gre_if.sw_if_index)])
1140 route_via_tun.add_vpp_config()
1143 # Add a NHRP entry resolves the peer
1145 nhrp = VppNhrp(self, gre_if,
1146 gre_if._remote_hosts[ii].ip6,
1147 itf._remote_hosts[ii].ip6)
1148 nhrp.add_vpp_config()
1151 # Send a packet stream that is routed into the tunnel
1152 # - packets are GRE encapped
1154 tx_e = self.create_stream_ip6(self.pg0, "5::5", route_addr)
1155 rx = self.send_and_expect(self.pg0, tx_e, itf)
1156 self.verify_tunneled_6o6(self.pg0, rx, tx_e,
1158 gre_if._remote_hosts[ii].ip6)
1159 tx_i = self.create_tunnel_stream_6o6(self.pg0,
1160 itf._remote_hosts[ii].ip6,
1163 self.pg0.remote_ip6)
1164 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1165 self.verify_decapped_6o6(self.pg0, rx, tx_i)
1168 # delete and re-add the NHRP
1170 nhrp.remove_vpp_config()
1171 self.send_and_assert_no_replies(self.pg0, tx_e)
1173 nhrp.add_vpp_config()
1174 rx = self.send_and_expect(self.pg0, tx_e, itf)
1175 self.verify_tunneled_6o6(self.pg0, rx, tx_e,
1177 gre_if._remote_hosts[ii].ip6)
1178 rx = self.send_and_expect(self.pg0, tx_i, self.pg0)
1179 self.verify_decapped_6o6(self.pg0, rx, tx_i)
1182 gre_if.unconfig_ip4()
1184 self.pg0.unconfig_ip6()
1187 if __name__ == '__main__':
1188 unittest.main(testRunner=VppTestRunner)