map: Add several more MAP-T BR tests

Add several more MAP-T BR tests for normal packet flow.

Type: test

Change-Id: Ica880dd23c923795279e9d08dca2796f2925069a
Signed-off-by: Jon Loeliger <jdl@netgate.com>

diff --git a/src/plugins/map/test/test_map_br.py b/src/plugins/map/test/test_map_br.py
index 7869e5f..3d30216 100644 (file)
--- a/src/plugins/map/test/test_map_br.py
+++ b/src/plugins/map/test/test_map_br.py
@@ -78,7 +78,9 @@ class TestMAPBR(VppTestCase):
         self.ipv6_map_address = (
             "2001:db8:ffff:ff00:ac:1001:200:0")         # 176.16.1.2
         self.ipv6_map_same_rule_diff_addr = (
-            "2001:db8:ffff:ff00:c6:1200:10:0")          # 198.18.0.16
+            "2001:db8:ffff:ff00:c6:1200:1000:0")        # 198.18.0.16
+        self.ipv6_map_same_rule_same_addr = (
+            "2001:db8:ffff:ff00:c6:1200:c00:0")         # 198.18.0.12
 
         self.map_br_prefix = "2001:db8:f0::"
         self.map_br_prefix_len = 48
@@ -94,13 +96,6 @@ class TestMAPBR(VppTestCase):
                                              self.pg1.sw_if_index)])
         map_route.add_vpp_config()
 
-        ip4_map_route = VppIpRoute(self,
-                                   "198.18.0.0",
-                                   24,
-                                   [VppRoutePath(self.pg1.remote_ip4,
-                                                 self.pg1.sw_if_index)])
-        ip4_map_route.add_vpp_config()
-
         #
         # Add a MAP BR domain that maps from pg0 to pg1.
         #
@@ -143,6 +138,253 @@ class TestMAPBR(VppTestCase):
             i.unconfig_ip6()
             i.admin_down()
 
+    def v4_address_check(self, pkt):
+        self.assertEqual(pkt[IP].src, self.ipv4_map_address)
+        self.assertEqual(pkt[IP].dst, self.ipv4_internet_address)
+
+    def v4_port_check(self, pkt, proto):
+        self.assertEqual(pkt[proto].sport, self.ipv4_udp_or_tcp_map_port)
+        self.assertEqual(pkt[proto].dport, self.ipv4_udp_or_tcp_internet_port)
+
+    def v6_address_check(self, pkt):
+        self.assertEqual(pkt[IPv6].src, self.ipv6_map_address)
+        self.assertEqual(pkt[IPv6].dst, self.ipv6_cpe_address)
+
+    def v6_port_check(self, pkt, proto):
+        self.assertEqual(pkt[proto].sport, self.ipv6_udp_or_tcp_internet_port)
+        self.assertEqual(pkt[proto].dport, self.ipv6_udp_or_tcp_map_port)
+
+    #
+    # Normal translation of UDP packets v4 -> v6 direction
+    # Send 128 frame size packet for IPv4/UDP.
+    # Received packet should be translated into IPv6 packet with no
+    # fragment header.
+    #
+
+    def test_map_t_udp_ip4_to_ip6(self):
+        """ MAP-T UDP IPv4 -> IPv6 """
+
+        eth = Ether(src=self.pg0.remote_mac,
+                    dst=self.pg0.local_mac)
+        ip = IP(src=self.pg0.remote_ip4,
+                dst=self.ipv4_map_address,
+                tos=0)
+        udp = UDP(sport=self.ipv4_udp_or_tcp_internet_port,
+                  dport=self.ipv4_udp_or_tcp_map_port)
+        payload = "a" * 82
+        tx_pkt = eth / ip / udp / payload
+
+        self.pg_send(self.pg0, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.v6_address_check(rx_pkt)
+        self.v6_port_check(rx_pkt, UDP)
+        self.assertEqual(rx_pkt[IPv6].tc, 0)    # IPv4 ToS passed to v6 TC
+        self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="UDP").nh)
+
+    #
+    # Normal translation of TCP packets v4 -> v6 direction.
+    # Send 128 frame size packet for IPv4/TCP.
+    # Received packet should be translated into IPv6 packet with no
+    # fragment header.
+    #
+
+    def test_map_t_tcp_ip4_to_ip6(self):
+        """ MAP-T TCP IPv4 -> IPv6 """
+
+        eth = Ether(src=self.pg0.remote_mac,
+                    dst=self.pg0.local_mac)
+        ip = IP(src=self.pg0.remote_ip4,
+                dst=self.ipv4_map_address,
+                tos=0)
+        tcp = TCP(sport=self.ipv4_udp_or_tcp_internet_port,
+                  dport=self.ipv4_udp_or_tcp_map_port)
+        payload = "a" * 82
+        tx_pkt = eth / ip / tcp / payload
+
+        self.pg_send(self.pg0, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.v6_address_check(rx_pkt)
+        self.v6_port_check(rx_pkt, TCP)
+        self.assertEqual(rx_pkt[IPv6].tc, 0)    # IPv4 ToS passed to v6 TC
+        self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="TCP").nh)
+
+    #
+    # Normal translation of UDP packets v6 -> v4 direction
+    # Send 128 frame size packet for IPv6/UDP.
+    # Received packet should be translated into an IPv4 packet with DF=1.
+    #
+
+    def test_map_t_udp_ip6_to_ip4(self):
+        """ MAP-T UDP IPv6 -> IPv4 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_address)
+        udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
+                  dport=self.ipv6_udp_or_tcp_internet_port)
+        payload = "a" * 82
+        tx_pkt = eth / ip / udp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg0.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.v4_address_check(rx_pkt)
+        self.v4_port_check(rx_pkt, UDP)
+        self.assertEqual(rx_pkt[IP].proto, IP(proto="udp").proto)
+        self.assertEqual(rx_pkt[IP].tos, 0)    # IPv6 TC passed to v4 ToS
+        df_bit = IP(flags="DF").flags
+        self.assertNotEqual(rx_pkt[IP].flags & df_bit, df_bit)
+
+    #
+    # Normal translation of TCP packets v6 -> v4 direction
+    # Send 128 frame size packet for IPv6/TCP.
+    # Received packet should be translated into an IPv4 packet with DF=1
+    #
+
+    def test_map_t_tcp_ip6_to_ip4(self):
+        """ MAP-T TCP IPv6 -> IPv4 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_address)
+        tcp = TCP(sport=self.ipv6_udp_or_tcp_map_port,
+                  dport=self.ipv6_udp_or_tcp_internet_port)
+        payload = "a" * 82
+        tx_pkt = eth / ip / tcp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg0.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.v4_address_check(rx_pkt)
+        self.v4_port_check(rx_pkt, TCP)
+        self.assertEqual(rx_pkt[IP].proto, IP(proto="tcp").proto)
+        self.assertEqual(rx_pkt[IP].tos, 0)    # IPv6 TC passed to v4 ToS
+        df_bit = IP(flags="DF").flags
+        self.assertNotEqual(rx_pkt[IP].flags & df_bit, df_bit)
+
+    #
+    # Translation of ICMP Echo Request v4 -> v6 direction
+    # Received packet should be translated into an IPv6 Echo Request.
+    #
+
+    def test_map_t_echo_request_ip4_to_ip6(self):
+        """ MAP-T echo request IPv4 -> IPv6 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IP(src=self.pg0.remote_ip4,
+                dst=self.ipv4_map_address)
+        icmp = ICMP(type="echo-request",
+                    id=self.ipv6_udp_or_tcp_map_port)
+        payload = "H" * 10
+        tx_pkt = eth / ip / icmp / payload
+
+        self.pg_send(self.pg0, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="ICMPv6").nh)
+        self.assertEqual(rx_pkt[ICMPv6EchoRequest].type,
+                         ICMPv6EchoRequest(type="Echo Request").type)
+        self.assertEqual(rx_pkt[ICMPv6EchoRequest].code, 0)
+        self.assertEqual(rx_pkt[ICMPv6EchoRequest].id,
+                         self.ipv6_udp_or_tcp_map_port)
+
+    #
+    # Translation of ICMP Echo Reply v4 -> v6 direction
+    # Received packet should be translated into an IPv6 Echo Reply.
+    #
+
+    def test_map_t_echo_reply_ip4_to_ip6(self):
+        """ MAP-T echo reply IPv4 -> IPv6 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IP(src=self.pg0.remote_ip4,
+                dst=self.ipv4_map_address)
+        icmp = ICMP(type="echo-reply",
+                    id=self.ipv6_udp_or_tcp_map_port)
+        payload = "H" * 10
+        tx_pkt = eth / ip / icmp / payload
+
+        self.pg_send(self.pg0, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="ICMPv6").nh)
+        self.assertEqual(rx_pkt[ICMPv6EchoReply].type,
+                         ICMPv6EchoReply(type="Echo Reply").type)
+        self.assertEqual(rx_pkt[ICMPv6EchoReply].code, 0)
+        self.assertEqual(rx_pkt[ICMPv6EchoReply].id,
+                         self.ipv6_udp_or_tcp_map_port)
+
+    #
+    # Translation of ICMP Echo Request v6 -> v4 direction
+    # Received packet should be translated into an IPv4 Echo Request.
+    #
+
+    def test_map_t_echo_request_ip6_to_ip4(self):
+        """ MAP-T echo request IPv6 -> IPv4 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_address)
+        icmp = ICMPv6EchoRequest()
+        icmp.id = self.ipv6_udp_or_tcp_map_port
+        payload = "H" * 10
+        tx_pkt = eth / ip / icmp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg0.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.assertEqual(rx_pkt[IP].proto, IP(proto="icmp").proto)
+        self.assertEqual(rx_pkt[ICMP].type, ICMP(type="echo-request").type)
+        self.assertEqual(rx_pkt[ICMP].code, 0)
+        self.assertEqual(rx_pkt[ICMP].id, self.ipv6_udp_or_tcp_map_port)
+
+    #
+    # Translation of ICMP Echo Reply v6 -> v4 direction
+    # Received packet should be translated into an IPv4 Echo Reply.
+    #
+
+    def test_map_t_echo_reply_ip6_to_ip4(self):
+        """ MAP-T echo reply IPv6 -> IPv4 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_address)
+        icmp = ICMPv6EchoReply(id=self.ipv6_udp_or_tcp_map_port)
+        payload = "H" * 10
+        tx_pkt = eth / ip / icmp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg0.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+        self.assertEqual(rx_pkt[IP].proto, IP(proto="icmp").proto)
+        self.assertEqual(rx_pkt[ICMP].type, ICMP(type="echo-reply").type)
+        self.assertEqual(rx_pkt[ICMP].code, 0)
+        self.assertEqual(rx_pkt[ICMP].id, self.ipv6_udp_or_tcp_map_port)
+
     #
     # Spoofed IPv4 Source Address v6 -> v4 direction
     # Send a packet with a wrong IPv4 address embedded in bits 72-103.
@@ -261,5 +503,49 @@ class TestMAPBR(VppTestCase):
         self.pg0.get_capture(0, timeout=1)
         self.pg0.assert_nothing_captured("Should drop IPv6 spoof port PSID")
 
+    #
+    # Map to Map - same rule, different address
+    #
+
+    @unittest.skip("Fixme: correct behavior needs clarification")
+    def test_map_t_same_rule_diff_addr_ip6_to_ip4(self):
+        """ MAP-T same rule, diff addr IPv6 -> IPv6 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_same_rule_diff_addr)
+        udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
+                  dport=1025)
+        payload = "a" * 82
+        tx_pkt = eth / ip / udp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
+    #
+    # Map to Map - same rule, same address
+    #
+
+    @unittest.skip("Fixme: correct behavior needs clarification")
+    def test_map_t_same_rule_same_addr_ip6_to_ip4(self):
+        """ MAP-T same rule, same addr IPv6 -> IPv6 """
+
+        eth = Ether(src=self.pg1.remote_mac,
+                    dst=self.pg1.local_mac)
+        ip = IPv6(src=self.ipv6_cpe_address,
+                  dst=self.ipv6_map_same_rule_same_addr)
+        udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
+                  dport=1025)
+        payload = "a" * 82
+        tx_pkt = eth / ip / udp / payload
+
+        self.pg_send(self.pg1, tx_pkt * 1)
+
+        rx_pkts = self.pg1.get_capture(1)
+        rx_pkt = rx_pkts[0]
+
 if __name__ == '__main__':
     unittest.main(testRunner=VppTestRunner)