src/plugins/map/test/test_map_br.py

   1 #!/usr/bin/env python3
   2
   3 import ipaddress
   4 import unittest
   5
   6 from framework import VppTestCase, VppTestRunner
   7 from vpp_ip import DpoProto
   8 from vpp_ip_route import VppIpRoute, VppRoutePath
   9 from util import fragment_rfc791, fragment_rfc8200
  10
  11 import scapy.compat
  12 from scapy.layers.l2 import Ether
  13 from scapy.packet import Raw
  14 from scapy.layers.inet import IP, UDP, ICMP, TCP
  15 from scapy.layers.inet6 import IPv6, ICMPv6TimeExceeded, IPv6ExtHdrFragment
  16 from scapy.layers.inet6 import ICMPv6EchoRequest, ICMPv6EchoReply
  17
  18
  19 class TestMAPBR(VppTestCase):
  20     """ MAP-T Test Cases """
  21
  22     @classmethod
  23     def setUpClass(cls):
  24         super(TestMAPBR, cls).setUpClass()
  25
  26     @classmethod
  27     def tearDownClass(cls):
  28         super(TestMAPBR, cls).tearDownClass()
  29
  30     def setUp(self):
  31         super(TestMAPBR, self).setUp()
  32
  33         #
  34         # Create 2 pg interfaces.
  35         # pg0 is IPv4
  36         # pg1 is IPv6
  37         #
  38         self.create_pg_interfaces(range(2))
  39
  40         self.pg0.admin_up()
  41         self.pg0.config_ip4()
  42         self.pg1.generate_remote_hosts(20)
  43         self.pg1.configure_ipv4_neighbors()
  44         self.pg0.resolve_arp()
  45
  46         self.pg1.admin_up()
  47         self.pg1.config_ip6()
  48         self.pg1.generate_remote_hosts(20)
  49         self.pg1.configure_ipv6_neighbors()
  50
  51         #
  52         # BR configuration parameters used for all test.
  53         #
  54         self.ip4_prefix = '198.18.0.0/24'
  55         self.ip6_prefix = '2001:db8:f0::/48'
  56         self.ip6_src = '2001:db8:ffff:ff00::/64'
  57         self.ea_bits_len = 12
  58         self.psid_offset = 6
  59         self.psid_length = 4
  60         self.mtu = 1500
  61         self.tag = 'MAP-T BR'
  62
  63         self.ipv4_internet_address = self.pg0.remote_ip4
  64         self.ipv4_map_address = "198.18.0.12"
  65         self.ipv4_udp_or_tcp_internet_port = 65000
  66         self.ipv4_udp_or_tcp_map_port = 16606
  67
  68         self.ipv6_cpe_address = "2001:db8:f0:c30:0:c612:c:3"      # 198.18.0.12
  69         self.ipv6_spoof_address = "2001:db8:f0:c30:0:c612:1c:3"   # 198.18.0.28
  70         self.ipv6_spoof_prefix = "2001:db8:f0:c30:0:a00:c:3"      # 10.0.0.12
  71         self.ipv6_spoof_psid = "2001:db8:f0:c30:0:c612:c:4"       # 4
  72         self.ipv6_spoof_subnet = "2001:db8:f1:c30:0:c612:c:3"     # f1
  73
  74         self.ipv6_udp_or_tcp_internet_port = 65000
  75         self.ipv6_udp_or_tcp_map_port = 16606
  76         self.ipv6_udp_or_tcp_spoof_port = 16862
  77
  78         self.ipv6_map_address = (
  79             "2001:db8:ffff:ff00:ac:1001:200:0")         # 176.16.1.2
  80         self.ipv6_map_same_rule_diff_addr = (
  81             "2001:db8:ffff:ff00:c6:1200:1000:0")        # 198.18.0.16
  82         self.ipv6_map_same_rule_same_addr = (
  83             "2001:db8:ffff:ff00:c6:1200:c00:0")         # 198.18.0.12
  84
  85         self.map_br_prefix = "2001:db8:f0::"
  86         self.map_br_prefix_len = 48
  87         self.psid_number = 3
  88
  89         #
  90         # Add an IPv6 route to the MAP-BR.
  91         #
  92         map_route = VppIpRoute(self,
  93                                self.map_br_prefix,
  94                                self.map_br_prefix_len,
  95                                [VppRoutePath(self.pg1.remote_ip6,
  96                                              self.pg1.sw_if_index)])
  97         map_route.add_vpp_config()
  98
  99         #
 100         # Add a MAP BR domain that maps from pg0 to pg1.
 101         #
 102         self.vapi.map_add_domain(ip4_prefix=self.ip4_prefix,
 103                                  ip6_prefix=self.ip6_prefix,
 104                                  ip6_src=self.ip6_src,
 105                                  ea_bits_len=self.ea_bits_len,
 106                                  psid_offset=self.psid_offset,
 107                                  psid_length=self.psid_length,
 108                                  mtu=self.mtu,
 109                                  tag=self.tag)
 110
 111         #
 112         # Set BR parameters.
 113         #
 114         self.vapi.map_param_set_fragmentation(inner=1, ignore_df=0)
 115         self.vapi.map_param_set_fragmentation(inner=0, ignore_df=0)
 116         self.vapi.map_param_set_icmp(ip4_err_relay_src=self.pg0.local_ip4)
 117         self.vapi.map_param_set_traffic_class(copy=1)
 118
 119         #
 120         # Enable MAP-T on interfaces.
 121         #
 122         self.vapi.map_if_enable_disable(is_enable=1,
 123                                         sw_if_index=self.pg0.sw_if_index,
 124                                         is_translation=1)
 125
 126         self.vapi.map_if_enable_disable(is_enable=1,
 127                                         sw_if_index=self.pg1.sw_if_index,
 128                                         is_translation=1)
 129
 130         self.vapi.map_if_enable_disable(is_enable=1,
 131                                         sw_if_index=self.pg1.sw_if_index,
 132                                         is_translation=1)
 133
 134     def tearDown(self):
 135         super(TestMAPBR, self).tearDown()
 136         for i in self.pg_interfaces:
 137             i.unconfig_ip4()
 138             i.unconfig_ip6()
 139             i.admin_down()
 140
 141     def v4_address_check(self, pkt):
 142         self.assertEqual(pkt[IP].src, self.ipv4_map_address)
 143         self.assertEqual(pkt[IP].dst, self.ipv4_internet_address)
 144
 145     def v4_port_check(self, pkt, proto):
 146         self.assertEqual(pkt[proto].sport, self.ipv4_udp_or_tcp_map_port)
 147         self.assertEqual(pkt[proto].dport, self.ipv4_udp_or_tcp_internet_port)
 148
 149     def v6_address_check(self, pkt):
 150         self.assertEqual(pkt[IPv6].src, self.ipv6_map_address)
 151         self.assertEqual(pkt[IPv6].dst, self.ipv6_cpe_address)
 152
 153     def v6_port_check(self, pkt, proto):
 154         self.assertEqual(pkt[proto].sport, self.ipv6_udp_or_tcp_internet_port)
 155         self.assertEqual(pkt[proto].dport, self.ipv6_udp_or_tcp_map_port)
 156
 157     #
 158     # Normal translation of UDP packets v4 -> v6 direction
 159     # Send 128 frame size packet for IPv4/UDP.
 160     # Received packet should be translated into IPv6 packet with no
 161     # fragment header.
 162     #
 163
 164     def test_map_t_udp_ip4_to_ip6(self):
 165         """ MAP-T UDP IPv4 -> IPv6 """
 166
 167         eth = Ether(src=self.pg0.remote_mac,
 168                     dst=self.pg0.local_mac)
 169         ip = IP(src=self.pg0.remote_ip4,
 170                 dst=self.ipv4_map_address,
 171                 tos=0)
 172         udp = UDP(sport=self.ipv4_udp_or_tcp_internet_port,
 173                   dport=self.ipv4_udp_or_tcp_map_port)
 174         payload = "a" * 82
 175         tx_pkt = eth / ip / udp / payload
 176
 177         self.pg_send(self.pg0, tx_pkt * 1)
 178
 179         rx_pkts = self.pg1.get_capture(1)
 180         rx_pkt = rx_pkts[0]
 181
 182         self.v6_address_check(rx_pkt)
 183         self.v6_port_check(rx_pkt, UDP)
 184         self.assertEqual(rx_pkt[IPv6].tc, 0)    # IPv4 ToS passed to v6 TC
 185         self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="UDP").nh)
 186
 187     #
 188     # Normal translation of TCP packets v4 -> v6 direction.
 189     # Send 128 frame size packet for IPv4/TCP.
 190     # Received packet should be translated into IPv6 packet with no
 191     # fragment header.
 192     #
 193
 194     def test_map_t_tcp_ip4_to_ip6(self):
 195         """ MAP-T TCP IPv4 -> IPv6 """
 196
 197         eth = Ether(src=self.pg0.remote_mac,
 198                     dst=self.pg0.local_mac)
 199         ip = IP(src=self.pg0.remote_ip4,
 200                 dst=self.ipv4_map_address,
 201                 tos=0)
 202         tcp = TCP(sport=self.ipv4_udp_or_tcp_internet_port,
 203                   dport=self.ipv4_udp_or_tcp_map_port)
 204         payload = "a" * 82
 205         tx_pkt = eth / ip / tcp / payload
 206
 207         self.pg_send(self.pg0, tx_pkt * 1)
 208
 209         rx_pkts = self.pg1.get_capture(1)
 210         rx_pkt = rx_pkts[0]
 211
 212         self.v6_address_check(rx_pkt)
 213         self.v6_port_check(rx_pkt, TCP)
 214         self.assertEqual(rx_pkt[IPv6].tc, 0)    # IPv4 ToS passed to v6 TC
 215         self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="TCP").nh)
 216
 217     #
 218     # Normal translation of UDP packets v6 -> v4 direction
 219     # Send 128 frame size packet for IPv6/UDP.
 220     # Received packet should be translated into an IPv4 packet with DF=1.
 221     #
 222
 223     def test_map_t_udp_ip6_to_ip4(self):
 224         """ MAP-T UDP IPv6 -> IPv4 """
 225
 226         eth = Ether(src=self.pg1.remote_mac,
 227                     dst=self.pg1.local_mac)
 228         ip = IPv6(src=self.ipv6_cpe_address,
 229                   dst=self.ipv6_map_address)
 230         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 231                   dport=self.ipv6_udp_or_tcp_internet_port)
 232         payload = "a" * 82
 233         tx_pkt = eth / ip / udp / payload
 234
 235         self.pg_send(self.pg1, tx_pkt * 1)
 236
 237         rx_pkts = self.pg0.get_capture(1)
 238         rx_pkt = rx_pkts[0]
 239
 240         self.v4_address_check(rx_pkt)
 241         self.v4_port_check(rx_pkt, UDP)
 242         self.assertEqual(rx_pkt[IP].proto, IP(proto="udp").proto)
 243         self.assertEqual(rx_pkt[IP].tos, 0)    # IPv6 TC passed to v4 ToS
 244         df_bit = IP(flags="DF").flags
 245         self.assertNotEqual(rx_pkt[IP].flags & df_bit, df_bit)
 246
 247     #
 248     # Normal translation of TCP packets v6 -> v4 direction
 249     # Send 128 frame size packet for IPv6/TCP.
 250     # Received packet should be translated into an IPv4 packet with DF=1
 251     #
 252
 253     def test_map_t_tcp_ip6_to_ip4(self):
 254         """ MAP-T TCP IPv6 -> IPv4 """
 255
 256         eth = Ether(src=self.pg1.remote_mac,
 257                     dst=self.pg1.local_mac)
 258         ip = IPv6(src=self.ipv6_cpe_address,
 259                   dst=self.ipv6_map_address)
 260         tcp = TCP(sport=self.ipv6_udp_or_tcp_map_port,
 261                   dport=self.ipv6_udp_or_tcp_internet_port)
 262         payload = "a" * 82
 263         tx_pkt = eth / ip / tcp / payload
 264
 265         self.pg_send(self.pg1, tx_pkt * 1)
 266
 267         rx_pkts = self.pg0.get_capture(1)
 268         rx_pkt = rx_pkts[0]
 269
 270         self.v4_address_check(rx_pkt)
 271         self.v4_port_check(rx_pkt, TCP)
 272         self.assertEqual(rx_pkt[IP].proto, IP(proto="tcp").proto)
 273         self.assertEqual(rx_pkt[IP].tos, 0)    # IPv6 TC passed to v4 ToS
 274         df_bit = IP(flags="DF").flags
 275         self.assertNotEqual(rx_pkt[IP].flags & df_bit, df_bit)
 276
 277     #
 278     # Translation of ICMP Echo Request v4 -> v6 direction
 279     # Received packet should be translated into an IPv6 Echo Request.
 280     #
 281
 282     def test_map_t_echo_request_ip4_to_ip6(self):
 283         """ MAP-T echo request IPv4 -> IPv6 """
 284
 285         eth = Ether(src=self.pg1.remote_mac,
 286                     dst=self.pg1.local_mac)
 287         ip = IP(src=self.pg0.remote_ip4,
 288                 dst=self.ipv4_map_address)
 289         icmp = ICMP(type="echo-request",
 290                     id=self.ipv6_udp_or_tcp_map_port)
 291         payload = "H" * 10
 292         tx_pkt = eth / ip / icmp / payload
 293
 294         self.pg_send(self.pg0, tx_pkt * 1)
 295
 296         rx_pkts = self.pg1.get_capture(1)
 297         rx_pkt = rx_pkts[0]
 298
 299         self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="ICMPv6").nh)
 300         self.assertEqual(rx_pkt[ICMPv6EchoRequest].type,
 301                          ICMPv6EchoRequest(type="Echo Request").type)
 302         self.assertEqual(rx_pkt[ICMPv6EchoRequest].code, 0)
 303         self.assertEqual(rx_pkt[ICMPv6EchoRequest].id,
 304                          self.ipv6_udp_or_tcp_map_port)
 305
 306     #
 307     # Translation of ICMP Echo Reply v4 -> v6 direction
 308     # Received packet should be translated into an IPv6 Echo Reply.
 309     #
 310
 311     def test_map_t_echo_reply_ip4_to_ip6(self):
 312         """ MAP-T echo reply IPv4 -> IPv6 """
 313
 314         eth = Ether(src=self.pg1.remote_mac,
 315                     dst=self.pg1.local_mac)
 316         ip = IP(src=self.pg0.remote_ip4,
 317                 dst=self.ipv4_map_address)
 318         icmp = ICMP(type="echo-reply",
 319                     id=self.ipv6_udp_or_tcp_map_port)
 320         payload = "H" * 10
 321         tx_pkt = eth / ip / icmp / payload
 322
 323         self.pg_send(self.pg0, tx_pkt * 1)
 324
 325         rx_pkts = self.pg1.get_capture(1)
 326         rx_pkt = rx_pkts[0]
 327
 328         self.assertEqual(rx_pkt[IPv6].nh, IPv6(nh="ICMPv6").nh)
 329         self.assertEqual(rx_pkt[ICMPv6EchoReply].type,
 330                          ICMPv6EchoReply(type="Echo Reply").type)
 331         self.assertEqual(rx_pkt[ICMPv6EchoReply].code, 0)
 332         self.assertEqual(rx_pkt[ICMPv6EchoReply].id,
 333                          self.ipv6_udp_or_tcp_map_port)
 334
 335     #
 336     # Translation of ICMP Echo Request v6 -> v4 direction
 337     # Received packet should be translated into an IPv4 Echo Request.
 338     #
 339
 340     def test_map_t_echo_request_ip6_to_ip4(self):
 341         """ MAP-T echo request IPv6 -> IPv4 """
 342
 343         eth = Ether(src=self.pg1.remote_mac,
 344                     dst=self.pg1.local_mac)
 345         ip = IPv6(src=self.ipv6_cpe_address,
 346                   dst=self.ipv6_map_address)
 347         icmp = ICMPv6EchoRequest()
 348         icmp.id = self.ipv6_udp_or_tcp_map_port
 349         payload = "H" * 10
 350         tx_pkt = eth / ip / icmp / payload
 351
 352         self.pg_send(self.pg1, tx_pkt * 1)
 353
 354         rx_pkts = self.pg0.get_capture(1)
 355         rx_pkt = rx_pkts[0]
 356
 357         self.assertEqual(rx_pkt[IP].proto, IP(proto="icmp").proto)
 358         self.assertEqual(rx_pkt[ICMP].type, ICMP(type="echo-request").type)
 359         self.assertEqual(rx_pkt[ICMP].code, 0)
 360         self.assertEqual(rx_pkt[ICMP].id, self.ipv6_udp_or_tcp_map_port)
 361
 362     #
 363     # Translation of ICMP Echo Reply v6 -> v4 direction
 364     # Received packet should be translated into an IPv4 Echo Reply.
 365     #
 366
 367     def test_map_t_echo_reply_ip6_to_ip4(self):
 368         """ MAP-T echo reply IPv6 -> IPv4 """
 369
 370         eth = Ether(src=self.pg1.remote_mac,
 371                     dst=self.pg1.local_mac)
 372         ip = IPv6(src=self.ipv6_cpe_address,
 373                   dst=self.ipv6_map_address)
 374         icmp = ICMPv6EchoReply(id=self.ipv6_udp_or_tcp_map_port)
 375         payload = "H" * 10
 376         tx_pkt = eth / ip / icmp / payload
 377
 378         self.pg_send(self.pg1, tx_pkt * 1)
 379
 380         rx_pkts = self.pg0.get_capture(1)
 381         rx_pkt = rx_pkts[0]
 382
 383         self.assertEqual(rx_pkt[IP].proto, IP(proto="icmp").proto)
 384         self.assertEqual(rx_pkt[ICMP].type, ICMP(type="echo-reply").type)
 385         self.assertEqual(rx_pkt[ICMP].code, 0)
 386         self.assertEqual(rx_pkt[ICMP].id, self.ipv6_udp_or_tcp_map_port)
 387
 388     #
 389     # Spoofed IPv4 Source Address v6 -> v4 direction
 390     # Send a packet with a wrong IPv4 address embedded in bits 72-103.
 391     # The BR should either drop the packet, or rewrite the spoofed
 392     # source IPv4 as the actual source IPv4 address.
 393     # The BR really should drop the packet.
 394     #
 395
 396     def test_map_t_spoof_ipv4_src_addr_ip6_to_ip4(self):
 397         """ MAP-T spoof ipv4 src addr IPv6 -> IPv4 """
 398
 399         eth = Ether(src=self.pg1.remote_mac,
 400                     dst=self.pg1.local_mac)
 401         ip = IPv6(src=self.ipv6_spoof_address,
 402                   dst=self.ipv6_map_address)
 403         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 404                   dport=self.ipv6_udp_or_tcp_internet_port)
 405         payload = "a" * 82
 406         tx_pkt = eth / ip / udp / payload
 407
 408         self.pg_send(self.pg1, tx_pkt * 1)
 409
 410         self.pg0.get_capture(0, timeout=1)
 411         self.pg0.assert_nothing_captured("Should drop IPv4 spoof address")
 412
 413     #
 414     # Spoofed IPv4 Source Prefix v6 -> v4 direction
 415     # Send a packet with a wrong IPv4 prefix embedded in bits 72-103.
 416     # The BR should either drop the packet, or rewrite the source IPv4
 417     # to the prefix that matches the source IPv4 address.
 418     #
 419
 420     def test_map_t_spoof_ipv4_src_prefix_ip6_to_ip4(self):
 421         """ MAP-T spoof ipv4 src prefix IPv6 -> IPv4 """
 422
 423         eth = Ether(src=self.pg1.remote_mac,
 424                     dst=self.pg1.local_mac)
 425         ip = IPv6(src=self.ipv6_spoof_prefix,
 426                   dst=self.ipv6_map_address)
 427         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 428                   dport=self.ipv6_udp_or_tcp_internet_port)
 429         payload = "a" * 82
 430         tx_pkt = eth / ip / udp / payload
 431
 432         self.pg_send(self.pg1, tx_pkt * 1)
 433
 434         self.pg0.get_capture(0, timeout=1)
 435         self.pg0.assert_nothing_captured("Should drop IPv4 spoof prefix")
 436
 437     #
 438     # Spoofed IPv6 PSID v6 -> v4 direction
 439     # Send a packet with a wrong IPv6 port PSID
 440     # The BR should drop the packet.
 441     #
 442
 443     def test_map_t_spoof_psid_ip6_to_ip4(self):
 444         """ MAP-T spoof psid IPv6 -> IPv4 """
 445
 446         eth = Ether(src=self.pg1.remote_mac,
 447                     dst=self.pg1.local_mac)
 448         ip = IPv6(src=self.ipv6_spoof_psid,
 449                   dst=self.ipv6_map_address)
 450         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 451                   dport=self.ipv6_udp_or_tcp_internet_port)
 452         payload = "a" * 82
 453         tx_pkt = eth / ip / udp / payload
 454
 455         self.pg_send(self.pg1, tx_pkt * 1)
 456
 457         self.pg0.get_capture(0, timeout=1)
 458         self.pg0.assert_nothing_captured("Should drop IPv6 spoof PSID")
 459
 460     #
 461     # Spoofed IPv6 subnet field v6 -> v4 direction
 462     # Send a packet with a wrong IPv6 subnet as "2001:db8:f1"
 463     # The BR should drop the packet.
 464     #
 465
 466     def test_map_t_spoof_subnet_ip6_to_ip4(self):
 467         """ MAP-T spoof subnet IPv6 -> IPv4 """
 468
 469         eth = Ether(src=self.pg1.remote_mac,
 470                     dst=self.pg1.local_mac)
 471         ip = IPv6(src=self.ipv6_spoof_subnet,
 472                   dst=self.ipv6_map_address)
 473         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 474                   dport=self.ipv6_udp_or_tcp_internet_port)
 475         payload = "a" * 82
 476         tx_pkt = eth / ip / udp / payload
 477
 478         self.pg_send(self.pg1, tx_pkt * 1)
 479
 480         self.pg0.get_capture(0, timeout=1)
 481         self.pg0.assert_nothing_captured("Should drop IPv6 spoof subnet")
 482
 483     #
 484     # Spoofed IPv6 port PSID v6 -> v4 direction
 485     # Send a packet with a wrong IPv6 port PSID
 486     # The BR should drop the packet.
 487     #
 488
 489     def test_map_t_spoof_port_psid_ip6_to_ip4(self):
 490         """ MAP-T spoof port psid IPv6 -> IPv4 """
 491
 492         eth = Ether(src=self.pg1.remote_mac,
 493                     dst=self.pg1.local_mac)
 494         ip = IPv6(src=self.ipv6_cpe_address,
 495                   dst=self.ipv6_map_address)
 496         udp = UDP(sport=self.ipv6_udp_or_tcp_spoof_port,
 497                   dport=self.ipv6_udp_or_tcp_internet_port)
 498         payload = "a" * 82
 499         tx_pkt = eth / ip / udp / payload
 500
 501         self.pg_send(self.pg1, tx_pkt * 1)
 502
 503         self.pg0.get_capture(0, timeout=1)
 504         self.pg0.assert_nothing_captured("Should drop IPv6 spoof port PSID")
 505
 506     #
 507     # Spoofed IPv6 ICMP ID PSID v6 -> v4 direction
 508     # Send a packet with a wrong IPv6 IMCP ID PSID
 509     # The BR should drop the packet.
 510     #
 511
 512     def test_map_t_spoof_icmp_id_psid_ip6_to_ip4(self):
 513         """ MAP-T spoof ICMP id psid IPv6 -> IPv4 """
 514
 515         eth = Ether(src=self.pg1.remote_mac,
 516                     dst=self.pg1.local_mac)
 517         ip = IPv6(src=self.ipv6_cpe_address,
 518                   dst=self.ipv6_map_address)
 519         icmp = ICMPv6EchoRequest()
 520         icmp.id = self.ipv6_udp_or_tcp_spoof_port
 521         payload = "H" * 10
 522         tx_pkt = eth / ip / icmp / payload
 523
 524         self.pg_send(self.pg1, tx_pkt * 1)
 525
 526         self.pg0.get_capture(0, timeout=1)
 527         self.pg0.assert_nothing_captured("Should drop IPv6 spoof port PSID")
 528
 529     #
 530     # Map to Map - same rule, different address
 531     #
 532
 533     @unittest.skip("Fixme: correct behavior needs clarification")
 534     def test_map_t_same_rule_diff_addr_ip6_to_ip4(self):
 535         """ MAP-T same rule, diff addr IPv6 -> IPv6 """
 536
 537         eth = Ether(src=self.pg1.remote_mac,
 538                     dst=self.pg1.local_mac)
 539         ip = IPv6(src=self.ipv6_cpe_address,
 540                   dst=self.ipv6_map_same_rule_diff_addr)
 541         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 542                   dport=1025)
 543         payload = "a" * 82
 544         tx_pkt = eth / ip / udp / payload
 545
 546         self.pg_send(self.pg1, tx_pkt * 1)
 547
 548         rx_pkts = self.pg1.get_capture(1)
 549         rx_pkt = rx_pkts[0]
 550
 551     #
 552     # Map to Map - same rule, same address
 553     #
 554
 555     @unittest.skip("Fixme: correct behavior needs clarification")
 556     def test_map_t_same_rule_same_addr_ip6_to_ip4(self):
 557         """ MAP-T same rule, same addr IPv6 -> IPv6 """
 558
 559         eth = Ether(src=self.pg1.remote_mac,
 560                     dst=self.pg1.local_mac)
 561         ip = IPv6(src=self.ipv6_cpe_address,
 562                   dst=self.ipv6_map_same_rule_same_addr)
 563         udp = UDP(sport=self.ipv6_udp_or_tcp_map_port,
 564                   dport=1025)
 565         payload = "a" * 82
 566         tx_pkt = eth / ip / udp / payload
 567
 568         self.pg_send(self.pg1, tx_pkt * 1)
 569
 570         rx_pkts = self.pg1.get_capture(1)
 571         rx_pkt = rx_pkts[0]
 572
 573 if __name__ == '__main__':
 574     unittest.main(testRunner=VppTestRunner)