Code Review / vpp.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Typos. A bunch of typos I've been collecting.
[vpp.git] / test / test_map.py
diff --git a/test/test_map.py b/test/test_map.py
index d76c4bc..a8e8ab3 100644 (file)
--- a/test/test_map.py
+++ b/test/test_map.py
@@ -1,12 +1,12 @@
 #!/usr/bin/env python
 
 import unittest
 #!/usr/bin/env python
 
 import unittest
-import socket
 
 from framework import VppTestCase, VppTestRunner
 from vpp_ip import DpoProto
 from vpp_ip_route import VppIpRoute, VppRoutePath
 
 
 from framework import VppTestCase, VppTestRunner
 from vpp_ip import DpoProto
 from vpp_ip_route import VppIpRoute, VppRoutePath
 
+import scapy.compat
 from scapy.layers.l2 import Ether, Raw
 from scapy.layers.inet import IP, UDP, ICMP, TCP, fragment
 from scapy.layers.inet6 import IPv6, ICMPv6TimeExceeded
 from scapy.layers.l2 import Ether, Raw
 from scapy.layers.inet import IP, UDP, ICMP, TCP, fragment
 from scapy.layers.inet6 import IPv6, ICMPv6TimeExceeded
@@ -76,17 +76,26 @@ class TestMAP(VppTestCase):
         #
         # Add a domain that maps from pg0 to pg1
         #
         #
         # Add a domain that maps from pg0 to pg1
         #
-        map_dst = socket.inet_pton(socket.AF_INET6, map_br_pfx)
-        map_src = "3001::1"
-        map_src_n = socket.inet_pton(socket.AF_INET6, map_src)
-        client_pfx = socket.inet_pton(socket.AF_INET, "192.168.0.0")
-
-        self.vapi.map_add_domain(map_dst,
-                                 map_br_pfx_len,
-                                 map_src_n,
-                                 128,
-                                 client_pfx,
-                                 16)
+        map_dst = '2001::/64'
+        map_src = '3000::1/128'
+        client_pfx = '192.168.0.0/16'
+        self.vapi.map_add_domain(map_dst, client_pfx, map_src)
+
+        # Enable MAP on interface.
+        self.vapi.map_if_enable_disable(is_enable=1,
+                                        sw_if_index=self.pg0.sw_if_index,
+                                        is_translation=0)
+
+        # Ensure MAP doesn't steal all packets!
+        v4 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
+              IP(src=self.pg0.remote_ip4, dst=self.pg0.remote_ip4) /
+              UDP(sport=20000, dport=10000) /
+              Raw('\xa5' * 100))
+        rx = self.send_and_expect(self.pg0, v4*1, self.pg0)
+        v4_reply = v4[1]
+        v4_reply.ttl -= 1
+        for p in rx:
+            self.validate(p[1], v4_reply)
 
         #
         # Fire in a v4 packet that will be encapped to the BR
 
         #
         # Fire in a v4 packet that will be encapped to the BR
@@ -96,14 +105,30 @@ class TestMAP(VppTestCase):
               UDP(sport=20000, dport=10000) /
               Raw('\xa5' * 100))
 
               UDP(sport=20000, dport=10000) /
               Raw('\xa5' * 100))
 
-        self.send_and_assert_encapped(v4, map_src, "2001::c0a8:0:0")
+        self.send_and_assert_encapped(v4, "3000::1", "2001::c0a8:0:0")
+
+        # Enable MAP on interface.
+        self.vapi.map_if_enable_disable(is_enable=1,
+                                        sw_if_index=self.pg1.sw_if_index,
+                                        is_translation=0)
+
+        # Ensure MAP doesn't steal all packets
+        v6 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IPv6(src=self.pg1.remote_ip6, dst=self.pg1.remote_ip6) /
+              UDP(sport=20000, dport=10000) /
+              Raw('\xa5' * 100))
+        rx = self.send_and_expect(self.pg1, v6*1, self.pg1)
+        v6_reply = v6[1]
+        v6_reply.hlim -= 1
+        for p in rx:
+            self.validate(p[1], v6_reply)
 
         #
         # Fire in a V6 encapped packet.
         #  expect a decapped packet on the inside ip4 link
         #
         p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
 
         #
         # Fire in a V6 encapped packet.
         #  expect a decapped packet on the inside ip4 link
         #
         p = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
-             IPv6(dst=map_src, src="2001::1") /
+             IPv6(dst='3000::1', src="2001::1") /
              IP(dst=self.pg0.remote_ip4, src='192.168.1.1') /
              UDP(sport=20000, dport=10000) /
              Raw('\xa5' * 100))
              IP(dst=self.pg0.remote_ip4, src='192.168.1.1') /
              UDP(sport=20000, dport=10000) /
              Raw('\xa5' * 100))
@@ -126,7 +151,7 @@ class TestMAP(VppTestCase):
         self.vapi.ppcli("map params pre-resolve ip6-nh 4001::1")
 
         self.send_and_assert_no_replies(self.pg0, v4,
         self.vapi.ppcli("map params pre-resolve ip6-nh 4001::1")
 
         self.send_and_assert_no_replies(self.pg0, v4,
-                                        "resovled via default route")
+                                        "resolved via default route")
 
         #
         # Add a route to 4001::1. Expect the encapped traffic to be
 
         #
         # Add a route to 4001::1. Expect the encapped traffic to be
@@ -140,7 +165,7 @@ class TestMAP(VppTestCase):
             is_ip6=1)
         pre_res_route.add_vpp_config()
 
             is_ip6=1)
         pre_res_route.add_vpp_config()
 
-        self.send_and_assert_encapped(v4, map_src,
+        self.send_and_assert_encapped(v4, "3000::1",
                                       "2001::c0a8:0:0",
                                       dmac=self.pg1.remote_hosts[2].mac)
 
                                       "2001::c0a8:0:0",
                                       dmac=self.pg1.remote_hosts[2].mac)
 
@@ -152,7 +177,7 @@ class TestMAP(VppTestCase):
                                            proto=DpoProto.DPO_PROTO_IP6)])
         pre_res_route.add_vpp_config()
 
                                            proto=DpoProto.DPO_PROTO_IP6)])
         pre_res_route.add_vpp_config()
 
-        self.send_and_assert_encapped(v4, map_src,
+        self.send_and_assert_encapped(v4, "3000::1",
                                       "2001::c0a8:0:0",
                                       dmac=self.pg1.remote_hosts[3].mac)
 
                                       "2001::c0a8:0:0",
                                       dmac=self.pg1.remote_hosts[3].mac)
 
@@ -164,7 +189,7 @@ class TestMAP(VppTestCase):
         self.vapi.ppcli("map params pre-resolve del ip6-nh 4001::1")
 
     def validate(self, rx, expected):
         self.vapi.ppcli("map params pre-resolve del ip6-nh 4001::1")
 
     def validate(self, rx, expected):
-        self.assertEqual(rx, expected.__class__(str(expected)))
+        self.assertEqual(rx, expected.__class__(scapy.compat.raw(expected)))
 
     def payload(self, len):
         return 'x' * len
 
     def payload(self, len):
         return 'x' * len
@@ -175,17 +200,41 @@ class TestMAP(VppTestCase):
         #
         # Add a domain that maps from pg0 to pg1
         #
         #
         # Add a domain that maps from pg0 to pg1
         #
-        map_dst = socket.inet_pton(socket.AF_INET6, "2001:db8::")
-        map_src = socket.inet_pton(socket.AF_INET6, "1234:5678:90ab:cdef::")
-        ip4_pfx = socket.inet_pton(socket.AF_INET, "192.168.0.0")
+        map_dst = '2001:db8::/32'
+        map_src = '1234:5678:90ab:cdef::/64'
+        ip4_pfx = '192.168.0.0/24'
 
 
-        self.vapi.map_add_domain(map_dst, 32, map_src, 64, ip4_pfx,
-                                 24, 16, 6, 4, 1)
+        self.vapi.map_add_domain(map_dst, ip4_pfx, map_src,
+                                 16, 6, 4, mtu=1500)
 
         # Enable MAP-T on interfaces.
 
         # Enable MAP-T on interfaces.
-
-        # self.vapi.map_if_enable_disable(1, self.pg0.sw_if_index, 1)
-        # self.vapi.map_if_enable_disable(1, self.pg1.sw_if_index, 1)
+        self.vapi.map_if_enable_disable(is_enable=1,
+                                        sw_if_index=self.pg0.sw_if_index,
+                                        is_translation=1)
+        self.vapi.map_if_enable_disable(is_enable=1,
+                                        sw_if_index=self.pg1.sw_if_index,
+                                        is_translation=1)
+
+        # Ensure MAP doesn't steal all packets!
+        v4 = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) /
+              IP(src=self.pg0.remote_ip4, dst=self.pg0.remote_ip4) /
+              UDP(sport=20000, dport=10000) /
+              Raw('\xa5' * 100))
+        rx = self.send_and_expect(self.pg0, v4*1, self.pg0)
+        v4_reply = v4[1]
+        v4_reply.ttl -= 1
+        for p in rx:
+            self.validate(p[1], v4_reply)
+        # Ensure MAP doesn't steal all packets
+        v6 = (Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac) /
+              IPv6(src=self.pg1.remote_ip6, dst=self.pg1.remote_ip6) /
+              UDP(sport=20000, dport=10000) /
+              Raw('\xa5' * 100))
+        rx = self.send_and_expect(self.pg1, v6*1, self.pg1)
+        v6_reply = v6[1]
+        v6_reply.hlim -= 1
+        for p in rx:
+            self.validate(p[1], v6_reply)
 
         map_route = VppIpRoute(self,
                                "2001:db8::",
 
         map_route = VppIpRoute(self,
                                "2001:db8::",
@@ -307,6 +356,40 @@ class TestMAP(VppTestCase):
         # p4_reply.id = 256
         # self.validate(reass_pkt, p4_reply)
 
         # p4_reply.id = 256
         # self.validate(reass_pkt, p4_reply)
 
+        # TCP MSS clamping
+        self.vapi.map_param_set_tcp(1300)
+
+        #
+        # Send a v4 TCP SYN packet that will be translated and MSS clamped
+        #
+        p_ether = Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac)
+        p_ip4 = IP(src=self.pg0.remote_ip4, dst='192.168.0.1')
+        payload = TCP(sport=0xabcd, dport=0xabcd, flags="S",
+                      options=[('MSS', 1460)])
+
+        p4 = (p_ether / p_ip4 / payload)
+        p6_translated = (IPv6(src="1234:5678:90ab:cdef:ac:1001:200:0",
+                              dst="2001:db8:1f0::c0a8:1:f") / payload)
+        p6_translated.hlim -= 1
+        p6_translated[TCP].options = [('MSS', 1300)]
+        rx = self.send_and_expect(self.pg0, p4*1, self.pg1)
+        for p in rx:
+            self.validate(p[1], p6_translated)
+
+        # Send back an IPv6 packet that will be "untranslated"
+        p_ether6 = Ether(dst=self.pg1.local_mac, src=self.pg1.remote_mac)
+        p_ip6 = IPv6(src='2001:db8:1f0::c0a8:1:f',
+                     dst='1234:5678:90ab:cdef:ac:1001:200:0')
+        p6 = (p_ether6 / p_ip6 / payload)
+        p4_translated = (IP(src='192.168.0.1',
+                            dst=self.pg0.remote_ip4) / payload)
+        p4_translated.id = 0
+        p4_translated.ttl -= 1
+        p4_translated[TCP].options = [('MSS', 1300)]
+        rx = self.send_and_expect(self.pg1, p6*1, self.pg0)
+        for p in rx:
+            self.validate(p[1], p4_translated)
+
 
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)
 
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)
Vector Packet Processing