fib: fib api updates

[vpp.git] / test / test_gre.py

diff --git a/test/test_gre.py b/test/test_gre.py
index ccd66c4..c5239b2 100644 (file)
--- a/test/test_gre.py
+++ b/test/test_gre.py
@@ -2,6 +2,7 @@
 
 import unittest
 
 
 import unittest
 

+import scapy.compat

 from scapy.packet import Raw
 from scapy.layers.l2 import Ether, Dot1Q, GRE
 from scapy.layers.inet import IP, UDP
 from scapy.packet import Raw
 from scapy.layers.l2 import Ether, Dot1Q, GRE
 from scapy.layers.inet import IP, UDP


@@ -9,18 +10,58 @@ from scapy.layers.inet6 import IPv6
 from scapy.volatile import RandMAC, RandIP
 
 from framework import VppTestCase, VppTestRunner
 from scapy.volatile import RandMAC, RandIP
 
 from framework import VppTestCase, VppTestRunner

-from vpp_sub_interface import VppDot1QSubint
-from vpp_gre_interface import VppGreInterface, VppGre6Interface
+from vpp_sub_interface import L2_VTR_OP, VppDot1QSubint
+from vpp_gre_interface import VppGreInterface

 from vpp_ip import DpoProto
 from vpp_ip import DpoProto

-from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable
-from vpp_papi_provider import L2_VTR_OP
+from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpTable, FibPathProto

 from util import ppp, ppc
 from util import ppp, ppc

+from vpp_papi import VppEnum

 
 
 
 

-class GreTunnelTypes:
-    TT_L3 = 0
-    TT_TEB = 1
-    TT_ERSPAN = 2
+class TestGREInputNodes(VppTestCase):
+    """ GRE Input Nodes Test Case """
+
+    def setUp(self):
+        super(TestGREInputNodes, self).setUp()
+
+        # create 3 pg interfaces - set one in a non-default table.
+        self.create_pg_interfaces(range(1))
+
+        for i in self.pg_interfaces:
+            i.admin_up()
+            i.config_ip4()
+
+    def tearDown(self):
+        for i in self.pg_interfaces:
+            i.unconfig_ip4()
+            i.admin_down()
+        super(TestGREInputNodes, self).tearDown()
+
+    def test_gre_input_node(self):
+        """ GRE gre input nodes not registerd unless configured """
+        pkt = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
+               IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
+               GRE())
+
+        self.pg0.add_stream(pkt)
+        self.pg_start()
+        # no tunnel created, gre-input not registered
+        err = self.statistics.get_counter(
+            '/err/ip4-input/unknown ip protocol')[0]
+        self.assertEqual(err, 1)
+        err_count = err
+
+        # create gre tunnel
+        gre_if = VppGreInterface(self, self.pg0.local_ip4, "1.1.1.2")
+        gre_if.add_vpp_config()
+
+        self.pg0.add_stream(pkt)
+        self.pg_start()
+        # tunnel created, gre-input registered
+        err = self.statistics.get_counter(
+            '/err/ip4-input/unknown ip protocol')[0]
+        # expect no new errors
+        self.assertEqual(err, err_count)

 
 
 class TestGRE(VppTestCase):
 
 
 class TestGRE(VppTestCase):


@@ -30,6 +71,10 @@ class TestGRE(VppTestCase):
     def setUpClass(cls):
         super(TestGRE, cls).setUpClass()
 
     def setUpClass(cls):
         super(TestGRE, cls).setUpClass()
 

+    @classmethod
+    def tearDownClass(cls):
+        super(TestGRE, cls).tearDownClass()
+

     def setUp(self):
         super(TestGRE, self).setUp()
 
     def setUp(self):
         super(TestGRE, self).setUp()
 


@@ -146,7 +191,8 @@ class TestGRE(VppTestCase):
                  GRE() /
                  Ether(dst=RandMAC('*:*:*:*:*:*'),
                        src=RandMAC('*:*:*:*:*:*')) /
                  GRE() /
                  Ether(dst=RandMAC('*:*:*:*:*:*'),
                        src=RandMAC('*:*:*:*:*:*')) /

-                 IP(src=str(RandIP()), dst=str(RandIP())) /
+                 IP(src=scapy.compat.raw(RandIP()),
+                    dst=scapy.compat.raw(RandIP())) /

                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()


@@ -165,7 +211,8 @@ class TestGRE(VppTestCase):
                  Ether(dst=RandMAC('*:*:*:*:*:*'),
                        src=RandMAC('*:*:*:*:*:*')) /
                  Dot1Q(vlan=vlan) /
                  Ether(dst=RandMAC('*:*:*:*:*:*'),
                        src=RandMAC('*:*:*:*:*:*')) /
                  Dot1Q(vlan=vlan) /

-                 IP(src=str(RandIP()), dst=str(RandIP())) /
+                 IP(src=scapy.compat.raw(RandIP()),
+                    dst=scapy.compat.raw(RandIP())) /

                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()
                  UDP(sport=1234, dport=1234) /
                  Raw(payload))
             info.data = p.copy()


@@ -217,7 +264,7 @@ class TestGRE(VppTestCase):
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 

-                rx_gre = GRE(str(rx_ip[IPv6].payload))
+                rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))

                 rx_ip = rx_gre[IPv6]
 
                 self.assertEqual(rx_ip.src, tx_ip.src)
                 rx_ip = rx_gre[IPv6]
 
                 self.assertEqual(rx_ip.src, tx_ip.src)


@@ -243,7 +290,7 @@ class TestGRE(VppTestCase):
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 

-                rx_gre = GRE(str(rx_ip[IPv6].payload))
+                rx_gre = GRE(scapy.compat.raw(rx_ip[IPv6].payload))

                 tx_ip = tx[IP]
                 rx_ip = rx_gre[IP]
 
                 tx_ip = tx[IP]
                 rx_ip = rx_gre[IP]
 


@@ -270,7 +317,7 @@ class TestGRE(VppTestCase):
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 
                 self.assertEqual(rx_ip.src, tunnel_src)
                 self.assertEqual(rx_ip.dst, tunnel_dst)
 

-                rx_gre = GRE(str(rx_ip[IP].payload))
+                rx_gre = GRE(scapy.compat.raw(rx_ip[IP].payload))

                 rx_ip = rx_gre[IPv6]
                 tx_ip = tx[IPv6]
 
                 rx_ip = rx_gre[IPv6]
                 tx_ip = tx[IPv6]
 


@@ -435,7 +482,7 @@ class TestGRE(VppTestCase):
 
         #
         # Send a packet stream that is routed into the tunnel
 
         #
         # Send a packet stream that is routed into the tunnel

-        #  - they are all dropped since the tunnel's desintation IP
+        #  - they are all dropped since the tunnel's destintation IP

         #    is unresolved - or resolves via the default route - which
         #    which is a drop.
         #
         #    is unresolved - or resolves via the default route - which
         #    which is a drop.
         #


@@ -529,8 +576,7 @@ class TestGRE(VppTestCase):
             self, "2001::1", 128,
             [VppRoutePath("::",
                           gre_if.sw_if_index,
             self, "2001::1", 128,
             [VppRoutePath("::",
                           gre_if.sw_if_index,

-                          proto=DpoProto.DPO_PROTO_IP6)],
-            is_ip6=1)
+                          proto=DpoProto.DPO_PROTO_IP6)])

         route6_via_tun.add_vpp_config()
 
         tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")
         route6_via_tun.add_vpp_config()
 
         tx = self.create_stream_ip6(self.pg0, "2001::2", "2001::1")


@@ -561,25 +607,22 @@ class TestGRE(VppTestCase):
         #  - assign an IP Address
         #  - Add a route via the tunnel
         #
         #  - assign an IP Address
         #  - Add a route via the tunnel
         #

-        gre_if = VppGre6Interface(self,
-                                  self.pg2.local_ip6,
-                                  "1002::1")
+        gre_if = VppGreInterface(self,
+                                 self.pg2.local_ip6,
+                                 "1002::1")

         gre_if.add_vpp_config()
         gre_if.admin_up()
         gre_if.config_ip6()
 
         gre_if.add_vpp_config()
         gre_if.admin_up()
         gre_if.config_ip6()
 

-        route_via_tun = VppIpRoute(
-            self, "4004::1", 128,
-            [VppRoutePath("0::0",
-                          gre_if.sw_if_index,
-                          proto=DpoProto.DPO_PROTO_IP6)],
-            is_ip6=1)
+        route_via_tun = VppIpRoute(self, "4004::1", 128,
+                                   [VppRoutePath("0::0",
+                                                 gre_if.sw_if_index)])

 
         route_via_tun.add_vpp_config()
 
         #
         # Send a packet stream that is routed into the tunnel
 
         route_via_tun.add_vpp_config()
 
         #
         # Send a packet stream that is routed into the tunnel

-        #  - they are all dropped since the tunnel's desintation IP
+        #  - they are all dropped since the tunnel's destintation IP

         #    is unresolved - or resolves via the default route - which
         #    which is a drop.
         #
         #    is unresolved - or resolves via the default route - which
         #    which is a drop.
         #


@@ -591,12 +634,9 @@ class TestGRE(VppTestCase):
         #
         # Add a route that resolves the tunnel's destination
         #
         #
         # Add a route that resolves the tunnel's destination
         #

-        route_tun_dst = VppIpRoute(
-            self, "1002::1", 128,
-            [VppRoutePath(self.pg2.remote_ip6,
-                          self.pg2.sw_if_index,
-                          proto=DpoProto.DPO_PROTO_IP6)],
-            is_ip6=1)
+        route_tun_dst = VppIpRoute(self, "1002::1", 128,
+                                   [VppRoutePath(self.pg2.remote_ip6,
+                                                 self.pg2.sw_if_index)])

         route_tun_dst.add_vpp_config()
 
         #
         route_tun_dst.add_vpp_config()
 
         #


@@ -756,10 +796,12 @@ class TestGRE(VppTestCase):
         #
         gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
                                   "2.2.2.2",
         #
         gre_if1 = VppGreInterface(self, self.pg0.local_ip4,
                                   "2.2.2.2",

-                                  type=GreTunnelTypes.TT_TEB)
+                                  type=(VppEnum.vl_api_gre_tunnel_type_t.
+                                        GRE_API_TUNNEL_TYPE_TEB))

         gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
                                   "2.2.2.3",
         gre_if2 = VppGreInterface(self, self.pg0.local_ip4,
                                   "2.2.2.3",

-                                  type=GreTunnelTypes.TT_TEB)
+                                  type=(VppEnum.vl_api_gre_tunnel_type_t.
+                                        GRE_API_TUNNEL_TYPE_TEB))

         gre_if1.add_vpp_config()
         gre_if2.add_vpp_config()
 
         gre_if1.add_vpp_config()
         gre_if2.add_vpp_config()
 


@@ -824,12 +866,12 @@ class TestGRE(VppTestCase):
         # Configure both to pop thier respective VLAN tags,
         # so that during the x-coonect they will subsequently push
         #
         # Configure both to pop thier respective VLAN tags,
         # so that during the x-coonect they will subsequently push
         #

-        self.vapi.l2_interface_vlan_tag_rewrite(gre_if_12.sw_if_index,
-                                                L2_VTR_OP.L2_POP_1,
-                                                12)
-        self.vapi.l2_interface_vlan_tag_rewrite(gre_if_11.sw_if_index,
-                                                L2_VTR_OP.L2_POP_1,
-                                                11)
+        self.vapi.l2_interface_vlan_tag_rewrite(
+            sw_if_index=gre_if_12.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
+            push_dot1q=12)
+        self.vapi.l2_interface_vlan_tag_rewrite(
+            sw_if_index=gre_if_11.sw_if_index, vtr_op=L2_VTR_OP.L2_POP_1,
+            push_dot1q=11)

 
         #
         # Send traffic in both directiond - expect the VLAN tags to
 
         #
         # Send traffic in both directiond - expect the VLAN tags to