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_ip import DpoProto
16 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
17 from util import ppp, ppc
18 from vpp_papi import VppEnum
21 class TestGRE(VppTestCase):
26 super(TestGRE, cls).setUpClass()
29 def tearDownClass(cls):
30 super(TestGRE, cls).tearDownClass()
33 super(TestGRE, self).setUp()
35 # create 3 pg interfaces - set one in a non-default table.
36 self.create_pg_interfaces(range(3))
38 self.tbl = VppIpTable(self, 1)
39 self.tbl.add_vpp_config()
40 self.pg1.set_table_ip4(1)
42 for i in self.pg_interfaces:
46 self.pg0.resolve_arp()
48 self.pg1.resolve_arp()
50 self.pg2.resolve_ndp()
53 for i in self.pg_interfaces:
57 self.pg1.set_table_ip4(0)
58 super(TestGRE, self).tearDown()
60 def create_stream_ip4(self, src_if, src_ip, dst_ip):
62 for i in range(0, 257):
63 info = self.create_packet_info(src_if, src_if)
64 payload = self.info_to_payload(info)
65 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
66 IP(src=src_ip, dst=dst_ip) /
67 UDP(sport=1234, dport=1234) /
73 def create_stream_ip6(self, src_if, src_ip, dst_ip):
75 for i in range(0, 257):
76 info = self.create_packet_info(src_if, src_if)
77 payload = self.info_to_payload(info)
78 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
79 IPv6(src=src_ip, dst=dst_ip) /
80 UDP(sport=1234, dport=1234) /
86 def create_tunnel_stream_4o4(self, src_if,
87 tunnel_src, tunnel_dst,
90 for i in range(0, 257):
91 info = self.create_packet_info(src_if, src_if)
92 payload = self.info_to_payload(info)
93 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
94 IP(src=tunnel_src, dst=tunnel_dst) /
96 IP(src=src_ip, dst=dst_ip) /
97 UDP(sport=1234, dport=1234) /
103 def create_tunnel_stream_6o4(self, src_if,
104 tunnel_src, tunnel_dst,
107 for i in range(0, 257):
108 info = self.create_packet_info(src_if, src_if)
109 payload = self.info_to_payload(info)
110 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
111 IP(src=tunnel_src, dst=tunnel_dst) /
113 IPv6(src=src_ip, dst=dst_ip) /
114 UDP(sport=1234, dport=1234) /
120 def create_tunnel_stream_6o6(self, src_if,
121 tunnel_src, tunnel_dst,
124 for i in range(0, 257):
125 info = self.create_packet_info(src_if, src_if)
126 payload = self.info_to_payload(info)
127 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
128 IPv6(src=tunnel_src, dst=tunnel_dst) /
130 IPv6(src=src_ip, dst=dst_ip) /
131 UDP(sport=1234, dport=1234) /
137 def create_tunnel_stream_l2o4(self, src_if,
138 tunnel_src, tunnel_dst):
140 for i in range(0, 257):
141 info = self.create_packet_info(src_if, src_if)
142 payload = self.info_to_payload(info)
143 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
144 IP(src=tunnel_src, dst=tunnel_dst) /
146 Ether(dst=RandMAC('*:*:*:*:*:*'),
147 src=RandMAC('*:*:*:*:*:*')) /
148 IP(src=scapy.compat.raw(RandIP()),
149 dst=scapy.compat.raw(RandIP())) /
150 UDP(sport=1234, dport=1234) /
156 def create_tunnel_stream_vlano4(self, src_if,
157 tunnel_src, tunnel_dst, vlan):
159 for i in range(0, 257):
160 info = self.create_packet_info(src_if, src_if)
161 payload = self.info_to_payload(info)
162 p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
163 IP(src=tunnel_src, dst=tunnel_dst) /
165 Ether(dst=RandMAC('*:*:*:*:*:*'),
166 src=RandMAC('*:*:*:*:*:*')) /
168 IP(src=scapy.compat.raw(RandIP()),
169 dst=scapy.compat.raw(RandIP())) /
170 UDP(sport=1234, dport=1234) /
176 def verify_tunneled_4o4(self, src_if, capture, sent,
177 tunnel_src, tunnel_dst):
179 self.assertEqual(len(capture), len(sent))
181 for i in range(len(capture)):
189 self.assertEqual(rx_ip.src, tunnel_src)
190 self.assertEqual(rx_ip.dst, tunnel_dst)
195 self.assertEqual(rx_ip.src, tx_ip.src)
196 self.assertEqual(rx_ip.dst, tx_ip.dst)
197 # IP processing post pop has decremented the TTL
198 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
201 self.logger.error(ppp("Rx:", rx))
202 self.logger.error(ppp("Tx:", tx))
205 def verify_tunneled_6o6(self, src_if, capture, sent,
206 tunnel_src, tunnel_dst):
208 self.assertEqual(len(capture), len(sent))
210 for i in range(len(capture)):
218 self.assertEqual(rx_ip.src, tunnel_src)
219 self.assertEqual(rx_ip.dst, tunnel_dst)
221 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
224 self.assertEqual(rx_ip.src, tx_ip.src)
225 self.assertEqual(rx_ip.dst, tx_ip.dst)
228 self.logger.error(ppp("Rx:", rx))
229 self.logger.error(ppp("Tx:", tx))
232 def verify_tunneled_4o6(self, src_if, capture, sent,
233 tunnel_src, tunnel_dst):
235 self.assertEqual(len(capture), len(sent))
237 for i in range(len(capture)):
244 self.assertEqual(rx_ip.src, tunnel_src)
245 self.assertEqual(rx_ip.dst, tunnel_dst)
247 rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))
251 self.assertEqual(rx_ip.src, tx_ip.src)
252 self.assertEqual(rx_ip.dst, tx_ip.dst)
255 self.logger.error(ppp("Rx:", rx))
256 self.logger.error(ppp("Tx:", tx))
259 def verify_tunneled_6o4(self, src_if, capture, sent,
260 tunnel_src, tunnel_dst):
262 self.assertEqual(len(capture), len(sent))
264 for i in range(len(capture)):
271 self.assertEqual(rx_ip.src, tunnel_src)
272 self.assertEqual(rx_ip.dst, tunnel_dst)
274 rx_gre = GRE(scapy.compat.raw(rx_ip[IP].payload))
278 self.assertEqual(rx_ip.src, tx_ip.src)
279 self.assertEqual(rx_ip.dst, tx_ip.dst)
282 self.logger.error(ppp("Rx:", rx))
283 self.logger.error(ppp("Tx:", tx))
286 def verify_tunneled_l2o4(self, src_if, capture, sent,
287 tunnel_src, tunnel_dst):
288 self.assertEqual(len(capture), len(sent))
290 for i in range(len(capture)):
298 self.assertEqual(rx_ip.src, tunnel_src)
299 self.assertEqual(rx_ip.dst, tunnel_dst)
302 rx_l2 = rx_gre[Ether]
305 tx_l2 = tx_gre[Ether]
308 self.assertEqual(rx_ip.src, tx_ip.src)
309 self.assertEqual(rx_ip.dst, tx_ip.dst)
310 # bridged, not L3 forwarded, so no TTL decrement
311 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
314 self.logger.error(ppp("Rx:", rx))
315 self.logger.error(ppp("Tx:", tx))
318 def verify_tunneled_vlano4(self, src_if, capture, sent,
319 tunnel_src, tunnel_dst, vlan):
321 self.assertEqual(len(capture), len(sent))
323 ppc("Unexpected packets captured:", capture)
326 for i in range(len(capture)):
334 self.assertEqual(rx_ip.src, tunnel_src)
335 self.assertEqual(rx_ip.dst, tunnel_dst)
338 rx_l2 = rx_gre[Ether]
339 rx_vlan = rx_l2[Dot1Q]
342 self.assertEqual(rx_vlan.vlan, vlan)
345 tx_l2 = tx_gre[Ether]
348 self.assertEqual(rx_ip.src, tx_ip.src)
349 self.assertEqual(rx_ip.dst, tx_ip.dst)
350 # bridged, not L3 forwarded, so no TTL decrement
351 self.assertEqual(rx_ip.ttl, tx_ip.ttl)
354 self.logger.error(ppp("Rx:", rx))
355 self.logger.error(ppp("Tx:", tx))
358 def verify_decapped_4o4(self, src_if, capture, sent):
359 self.assertEqual(len(capture), len(sent))
361 for i in range(len(capture)):
371 self.assertEqual(rx_ip.src, tx_ip.src)
372 self.assertEqual(rx_ip.dst, tx_ip.dst)
373 # IP processing post pop has decremented the TTL
374 self.assertEqual(rx_ip.ttl + 1, tx_ip.ttl)
377 self.logger.error(ppp("Rx:", rx))
378 self.logger.error(ppp("Tx:", tx))
381 def verify_decapped_6o4(self, src_if, capture, sent):
382 self.assertEqual(len(capture), len(sent))
384 for i in range(len(capture)):
394 self.assertEqual(rx_ip.src, tx_ip.src)
395 self.assertEqual(rx_ip.dst, tx_ip.dst)
396 self.assertEqual(rx_ip.hlim + 1, tx_ip.hlim)
399 self.logger.error(ppp("Rx:", rx))
400 self.logger.error(ppp("Tx:", tx))
404 """ GRE IPv4 tunnel Tests """
407 # Create an L3 GRE tunnel.
409 # - assign an IP Addres
410 # - Add a route via the tunnel
412 gre_if = VppGreInterface(self,
415 gre_if.add_vpp_config()
418 # The double create (create the same tunnel twice) should fail,
419 # and we should still be able to use the original
422 gre_if.add_vpp_config()
426 self.fail("Double GRE tunnel add does not fail")
431 route_via_tun = VppIpRoute(self, "4.4.4.4", 32,
432 [VppRoutePath("0.0.0.0",
433 gre_if.sw_if_index)])
435 route_via_tun.add_vpp_config()
438 # Send a packet stream that is routed into the tunnel
439 # - they are all dropped since the tunnel's destintation IP
440 # is unresolved - or resolves via the default route - which
443 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
445 self.send_and_assert_no_replies(self.pg0, tx)
448 # Add a route that resolves the tunnel's destination
450 route_tun_dst = VppIpRoute(self, "1.1.1.2", 32,
451 [VppRoutePath(self.pg0.remote_ip4,
452 self.pg0.sw_if_index)])
453 route_tun_dst.add_vpp_config()
456 # Send a packet stream that is routed into the tunnel
457 # - packets are GRE encapped
459 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "4.4.4.4")
460 rx = self.send_and_expect(self.pg0, tx, self.pg0)
461 self.verify_tunneled_4o4(self.pg0, rx, tx,
462 self.pg0.local_ip4, "1.1.1.2")
465 # Send tunneled packets that match the created tunnel and
466 # are decapped and forwarded
468 tx = self.create_tunnel_stream_4o4(self.pg0,
473 rx = self.send_and_expect(self.pg0, tx, self.pg0)
474 self.verify_decapped_4o4(self.pg0, rx, tx)
477 # Send tunneled packets that do not match the tunnel's src
479 self.vapi.cli("clear trace")
480 tx = self.create_tunnel_stream_4o4(self.pg0,
485 self.send_and_assert_no_replies(
487 remark="GRE packets forwarded despite no SRC address match")
490 # Configure IPv6 on the PG interface so we can route IPv6
493 self.pg0.config_ip6()
494 self.pg0.resolve_ndp()
497 # Send IPv6 tunnel encapslated packets
498 # - dropped since IPv6 is not enabled on the tunnel
500 tx = self.create_tunnel_stream_6o4(self.pg0,
505 self.send_and_assert_no_replies(self.pg0, tx,
506 "IPv6 GRE packets forwarded "
507 "despite IPv6 not enabled on tunnel")
510 # Enable IPv6 on the tunnel
515 # Send IPv6 tunnel encapslated packets
516 # - forwarded since IPv6 is enabled on the tunnel
518 tx = self.create_tunnel_stream_6o4(self.pg0,
523 rx = self.send_and_expect(self.pg0, tx, self.pg0)
524 self.verify_decapped_6o4(self.pg0, rx, tx)
527 # Send v6 packets for v4 encap
529 route6_via_tun = VppIpRoute(
530 self, "2001::1", 128,
533 proto=DpoProto.DPO_PROTO_IP6)],
535 route6_via_tun.add_vpp_config()
537 tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
538 rx = self.send_and_expect(self.pg0, tx, self.pg0)
540 self.verify_tunneled_6o4(self.pg0, rx, tx,
541 self.pg0.local_ip4, "1.1.1.2")
546 route_tun_dst.remove_vpp_config()
547 route_via_tun.remove_vpp_config()
548 route6_via_tun.remove_vpp_config()
549 gre_if.remove_vpp_config()
551 self.pg0.unconfig_ip6()
554 """ GRE IPv6 tunnel Tests """
556 self.pg1.config_ip6()
557 self.pg1.resolve_ndp()
560 # Create an L3 GRE tunnel.
562 # - assign an IP Address
563 # - Add a route via the tunnel
565 gre_if = VppGreInterface(self,
568 gre_if.add_vpp_config()
572 route_via_tun = VppIpRoute(
573 self, "4004::1", 128,
574 [VppRoutePath("0::0",
576 proto=DpoProto.DPO_PROTO_IP6)],
579 route_via_tun.add_vpp_config()
582 # Send a packet stream that is routed into the tunnel
583 # - they are all dropped since the tunnel's destintation IP
584 # is unresolved - or resolves via the default route - which
587 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
588 self.send_and_assert_no_replies(
590 "GRE packets forwarded without DIP resolved")
593 # Add a route that resolves the tunnel's destination
595 route_tun_dst = VppIpRoute(
596 self, "1002::1", 128,
597 [VppRoutePath(self.pg2.remote_ip6,
598 self.pg2.sw_if_index,
599 proto=DpoProto.DPO_PROTO_IP6)],
601 route_tun_dst.add_vpp_config()
604 # Send a packet stream that is routed into the tunnel
605 # - packets are GRE encapped
607 tx = self.create_stream_ip6(self.pg2, "5005::1", "4004::1")
608 rx = self.send_and_expect(self.pg2, tx, self.pg2)
609 self.verify_tunneled_6o6(self.pg2, rx, tx,
610 self.pg2.local_ip6, "1002::1")
613 # Test decap. decapped packets go out pg1
615 tx = self.create_tunnel_stream_6o6(self.pg2,
620 rx = self.send_and_expect(self.pg2, tx, self.pg1)
623 # RX'd packet is UDP over IPv6, test the GRE header is gone.
625 self.assertFalse(rx[0].haslayer(GRE))
626 self.assertEqual(rx[0][IPv6].dst, self.pg1.remote_ip6)
631 route4_via_tun = VppIpRoute(self, "1.1.1.1", 32,
632 [VppRoutePath("0.0.0.0",
633 gre_if.sw_if_index)])
634 route4_via_tun.add_vpp_config()
636 tx = self.create_stream_ip4(self.pg0, "1.1.1.2", "1.1.1.1")
637 rx = self.send_and_expect(self.pg0, tx, self.pg2)
639 self.verify_tunneled_4o6(self.pg0, rx, tx,
640 self.pg2.local_ip6, "1002::1")
645 route_tun_dst.remove_vpp_config()
646 route_via_tun.remove_vpp_config()
647 route4_via_tun.remove_vpp_config()
648 gre_if.remove_vpp_config()
650 self.pg2.unconfig_ip6()
651 self.pg1.unconfig_ip6()
653 def test_gre_vrf(self):
654 """ GRE tunnel VRF Tests """
657 # Create an L3 GRE tunnel whose destination is in the non-default
658 # table. The underlay is thus non-default - the overlay is still
661 # - assign an IP Addres
663 gre_if = VppGreInterface(self, self.pg1.local_ip4,
666 gre_if.add_vpp_config()
671 # Add a route via the tunnel - in the overlay
673 route_via_tun = VppIpRoute(self, "9.9.9.9", 32,
674 [VppRoutePath("0.0.0.0",
675 gre_if.sw_if_index)])
676 route_via_tun.add_vpp_config()
679 # Add a route that resolves the tunnel's destination - in the
682 route_tun_dst = VppIpRoute(self, "2.2.2.2", 32, table_id=1,
683 paths=[VppRoutePath(self.pg1.remote_ip4,
684 self.pg1.sw_if_index)])
685 route_tun_dst.add_vpp_config()
688 # Send a packet stream that is routed into the tunnel
689 # packets are sent in on pg0 which is in the default table
690 # - packets are GRE encapped
692 self.vapi.cli("clear trace")
693 tx = self.create_stream_ip4(self.pg0, "5.5.5.5", "9.9.9.9")
694 rx = self.send_and_expect(self.pg0, tx, self.pg1)
695 self.verify_tunneled_4o4(self.pg1, rx, tx,
696 self.pg1.local_ip4, "2.2.2.2")
699 # Send tunneled packets that match the created tunnel and
700 # are decapped and forwarded. This tests the decap lookup
701 # does not happen in the encap table
703 self.vapi.cli("clear trace")
704 tx = self.create_tunnel_stream_4o4(self.pg1,
709 rx = self.send_and_expect(self.pg1, tx, self.pg0)
710 self.verify_decapped_4o4(self.pg0, rx, tx)
713 # Send tunneled packets that match the created tunnel
714 # but arrive on an interface that is not in the tunnel's
715 # encap VRF, these are dropped.
716 # IP enable the interface so they aren't dropped due to
717 # IP not being enabled.
719 self.pg2.config_ip4()
720 self.vapi.cli("clear trace")
721 tx = self.create_tunnel_stream_4o4(self.pg2,
726 rx = self.send_and_assert_no_replies(
728 "GRE decap packets in wrong VRF")
730 self.pg2.unconfig_ip4()
735 route_tun_dst.remove_vpp_config()
736 route_via_tun.remove_vpp_config()
737 gre_if.remove_vpp_config()
739 def test_gre_l2(self):
740 """ GRE tunnel L2 Tests """
743 # Add routes to resolve the tunnel destinations
745 route_tun1_dst = VppIpRoute(self, "2.2.2.2", 32,
746 [VppRoutePath(self.pg0.remote_ip4,
747 self.pg0.sw_if_index)])
748 route_tun2_dst = VppIpRoute(self, "2.2.2.3", 32,
749 [VppRoutePath(self.pg0.remote_ip4,
750 self.pg0.sw_if_index)])
752 route_tun1_dst.add_vpp_config()
753 route_tun2_dst.add_vpp_config()
756 # Create 2 L2 GRE tunnels and x-connect them
758 gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
760 type=(VppEnum.vl_api_gre_tunnel_type_t.
761 GRE_API_TUNNEL_TYPE_TEB))
762 gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
764 type=(VppEnum.vl_api_gre_tunnel_type_t.
765 GRE_API_TUNNEL_TYPE_TEB))
766 gre_if1.add_vpp_config()
767 gre_if2.add_vpp_config()
772 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
775 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
780 # Send in tunnel encapped L2. expect out tunnel encapped L2
783 tx = self.create_tunnel_stream_l2o4(self.pg0,
786 rx = self.send_and_expect(self.pg0, tx, self.pg0)
787 self.verify_tunneled_l2o4(self.pg0, rx, tx,
791 tx = self.create_tunnel_stream_l2o4(self.pg0,
794 rx = self.send_and_expect(self.pg0, tx, self.pg0)
795 self.verify_tunneled_l2o4(self.pg0, rx, tx,
799 self.vapi.sw_interface_set_l2_xconnect(gre_if1.sw_if_index,
802 self.vapi.sw_interface_set_l2_xconnect(gre_if2.sw_if_index,
807 # Create a VLAN sub-interfaces on the GRE TEB interfaces
808 # then x-connect them
810 gre_if_11 = VppDot1QSubint(self, gre_if1, 11)
811 gre_if_12 = VppDot1QSubint(self, gre_if2, 12)
813 # gre_if_11.add_vpp_config()
814 # gre_if_12.add_vpp_config()
819 self.vapi.sw_interface_set_l2_xconnect(gre_if_11.sw_if_index,
820 gre_if_12.sw_if_index,
822 self.vapi.sw_interface_set_l2_xconnect(gre_if_12.sw_if_index,
823 gre_if_11.sw_if_index,
827 # Configure both to pop thier respective VLAN tags,
828 # so that during the x-coonect they will subsequently push
830 self.vapi.l2_interface_vlan_tag_rewrite(
831 sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
833 self.vapi.l2_interface_vlan_tag_rewrite(
834 sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
838 # Send traffic in both directiond - expect the VLAN tags to
841 tx = self.create_tunnel_stream_vlano4(self.pg0,
845 rx = self.send_and_expect(self.pg0, tx, self.pg0)
846 self.verify_tunneled_vlano4(self.pg0, rx, tx,
851 tx = self.create_tunnel_stream_vlano4(self.pg0,
855 rx = self.send_and_expect(self.pg0, tx, self.pg0)
856 self.verify_tunneled_vlano4(self.pg0, rx, tx,
862 # Cleanup Test resources
864 gre_if_11.remove_vpp_config()
865 gre_if_12.remove_vpp_config()
866 gre_if1.remove_vpp_config()
867 gre_if2.remove_vpp_config()
868 route_tun1_dst.add_vpp_config()
869 route_tun2_dst.add_vpp_config()
871 def test_gre_loop(self):
872 """ GRE tunnel loop Tests """
875 # Create an L3 GRE tunnel.
877 # - assign an IP Addres
879 gre_if = VppGreInterface(self,
882 gre_if.add_vpp_config()
887 # add a route to the tunnel's destination that points
888 # through the tunnel, hence forming a loop in the forwarding
891 route_dst = VppIpRoute(self, "1.1.1.2", 32,
892 [VppRoutePath("0.0.0.0",
893 gre_if.sw_if_index)])
894 route_dst.add_vpp_config()
897 # packets to the tunnels destination should be dropped
899 tx = self.create_stream_ip4(self.pg0, "1.1.1.1", "1.1.1.2")
900 self.send_and_assert_no_replies(self.pg2, tx)
902 self.logger.info(self.vapi.ppcli("sh adj 7"))
907 route_dst.modify([VppRoutePath(self.pg1.remote_ip4,
908 self.pg1.sw_if_index)])
909 route_dst.add_vpp_config()
911 rx = self.send_and_expect(self.pg0, tx, self.pg1)
914 # a good route throught the tunnel to check it restacked
916 route_via_tun_2 = VppIpRoute(self, "2.2.2.2", 32,
917 [VppRoutePath("0.0.0.0",
918 gre_if.sw_if_index)])
919 route_via_tun_2.add_vpp_config()
921 tx = self.create_stream_ip4(self.pg0, "2.2.2.3", "2.2.2.2")
922 rx = self.send_and_expect(self.pg0, tx, self.pg1)
923 self.verify_tunneled_4o4(self.pg1, rx, tx,
924 self.pg0.local_ip4, "1.1.1.2")
929 route_via_tun_2.remove_vpp_config()
930 gre_if.remove_vpp_config()
933 if __name__ == '__main__':
934 unittest.main(testRunner=VppTestRunner)