test/test_ip4.py

   1 #!/usr/bin/env python3
   2 import binascii
   3 import random
   4 import socket
   5 import unittest
   6
   7 import scapy.compat
   8 from scapy.contrib.mpls import MPLS
   9 from scapy.layers.inet import IP, UDP, TCP, ICMP, icmptypes, icmpcodes
  10 from scapy.layers.l2 import Ether, Dot1Q, ARP
  11 from scapy.packet import Raw
  12 from six import moves
  13
  14 from framework import VppTestCase, VppTestRunner
  15 from util import ppp
  16 from vpp_ip_route import VppIpRoute, VppRoutePath, VppIpMRoute, \
  17     VppMRoutePath, VppMplsIpBind, \
  18     VppMplsTable, VppIpTable, FibPathType, find_route, \
  19     VppIpInterfaceAddress, find_route_in_dump, find_mroute_in_dump
  20 from vpp_ip import VppIpPuntPolicer, VppIpPuntRedirect
  21 from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint
  22 from vpp_papi import VppEnum
  23 from vpp_neighbor import VppNeighbor
  24 from vpp_lo_interface import VppLoInterface
  25 from vpp_policer import VppPolicer
  26
  27 NUM_PKTS = 67
  28
  29
  30 class TestIPv4(VppTestCase):
  31     """ IPv4 Test Case """
  32
  33     @classmethod
  34     def setUpClass(cls):
  35         super(TestIPv4, cls).setUpClass()
  36
  37     @classmethod
  38     def tearDownClass(cls):
  39         super(TestIPv4, cls).tearDownClass()
  40
  41     def setUp(self):
  42         """
  43         Perform test setup before test case.
  44
  45         **Config:**
  46             - create 3 pg interfaces
  47                 - untagged pg0 interface
  48                 - Dot1Q subinterface on pg1
  49                 - Dot1AD subinterface on pg2
  50             - setup interfaces:
  51                 - put it into UP state
  52                 - set IPv4 addresses
  53                 - resolve neighbor address using ARP
  54             - configure 200 fib entries
  55
  56         :ivar list interfaces: pg interfaces and subinterfaces.
  57         :ivar dict flows: IPv4 packet flows in test.
  58         """
  59         super(TestIPv4, self).setUp()
  60
  61         # create 3 pg interfaces
  62         self.create_pg_interfaces(range(3))
  63
  64         # create 2 subinterfaces for pg1 and pg2
  65         self.sub_interfaces = [
  66             VppDot1QSubint(self, self.pg1, 100),
  67             VppDot1ADSubint(self, self.pg2, 200, 300, 400)]
  68
  69         # packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
  70         self.flows = dict()
  71         self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
  72         self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
  73         self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
  74
  75         # packet sizes
  76         self.pg_if_packet_sizes = [64, 1500, 9020]
  77
  78         self.interfaces = list(self.pg_interfaces)
  79         self.interfaces.extend(self.sub_interfaces)
  80
  81         # setup all interfaces
  82         for i in self.interfaces:
  83             i.admin_up()
  84             i.config_ip4()
  85             i.resolve_arp()
  86
  87         # config 2M FIB entries
  88
  89     def tearDown(self):
  90         """Run standard test teardown and log ``show ip arp``."""
  91         super(TestIPv4, self).tearDown()
  92
  93     def show_commands_at_teardown(self):
  94         self.logger.info(self.vapi.cli("show ip4 neighbors"))
  95         # info(self.vapi.cli("show ip fib"))  # many entries
  96
  97     def modify_packet(self, src_if, packet_size, pkt):
  98         """Add load, set destination IP and extend packet to required packet
  99         size for defined interface.
 100
 101         :param VppInterface src_if: Interface to create packet for.
 102         :param int packet_size: Required packet size.
 103         :param Scapy pkt: Packet to be modified.
 104         """
 105         dst_if_idx = int(packet_size / 10 % 2)
 106         dst_if = self.flows[src_if][dst_if_idx]
 107         info = self.create_packet_info(src_if, dst_if)
 108         payload = self.info_to_payload(info)
 109         p = pkt/Raw(payload)
 110         p[IP].dst = dst_if.remote_ip4
 111         info.data = p.copy()
 112         if isinstance(src_if, VppSubInterface):
 113             p = src_if.add_dot1_layer(p)
 114         self.extend_packet(p, packet_size)
 115
 116         return p
 117
 118     def create_stream(self, src_if):
 119         """Create input packet stream for defined interface.
 120
 121         :param VppInterface src_if: Interface to create packet stream for.
 122         """
 123         hdr_ext = 4 if isinstance(src_if, VppSubInterface) else 0
 124         pkt_tmpl = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
 125                     IP(src=src_if.remote_ip4) /
 126                     UDP(sport=1234, dport=1234))
 127
 128         pkts = [self.modify_packet(src_if, i, pkt_tmpl)
 129                 for i in moves.range(self.pg_if_packet_sizes[0],
 130                                      self.pg_if_packet_sizes[1], 10)]
 131         pkts_b = [self.modify_packet(src_if, i, pkt_tmpl)
 132                   for i in moves.range(self.pg_if_packet_sizes[1] + hdr_ext,
 133                                        self.pg_if_packet_sizes[2] + hdr_ext,
 134                                        50)]
 135         pkts.extend(pkts_b)
 136
 137         return pkts
 138
 139     def verify_capture(self, dst_if, capture):
 140         """Verify captured input packet stream for defined interface.
 141
 142         :param VppInterface dst_if: Interface to verify captured packet stream
 143             for.
 144         :param list capture: Captured packet stream.
 145         """
 146         self.logger.info("Verifying capture on interface %s" % dst_if.name)
 147         last_info = dict()
 148         for i in self.interfaces:
 149             last_info[i.sw_if_index] = None
 150         is_sub_if = False
 151         dst_sw_if_index = dst_if.sw_if_index
 152         if hasattr(dst_if, 'parent'):
 153             is_sub_if = True
 154         for packet in capture:
 155             if is_sub_if:
 156                 # Check VLAN tags and Ethernet header
 157                 packet = dst_if.remove_dot1_layer(packet)
 158             self.assertTrue(Dot1Q not in packet)
 159             try:
 160                 ip = packet[IP]
 161                 udp = packet[UDP]
 162                 payload_info = self.payload_to_info(packet[Raw])
 163                 packet_index = payload_info.index
 164                 self.assertEqual(payload_info.dst, dst_sw_if_index)
 165                 self.logger.debug(
 166                     "Got packet on port %s: src=%u (id=%u)" %
 167                     (dst_if.name, payload_info.src, packet_index))
 168                 next_info = self.get_next_packet_info_for_interface2(
 169                     payload_info.src, dst_sw_if_index,
 170                     last_info[payload_info.src])
 171                 last_info[payload_info.src] = next_info
 172                 self.assertTrue(next_info is not None)
 173                 self.assertEqual(packet_index, next_info.index)
 174                 saved_packet = next_info.data
 175                 # Check standard fields
 176                 self.assertEqual(ip.src, saved_packet[IP].src)
 177                 self.assertEqual(ip.dst, saved_packet[IP].dst)
 178                 self.assertEqual(udp.sport, saved_packet[UDP].sport)
 179                 self.assertEqual(udp.dport, saved_packet[UDP].dport)
 180             except:
 181                 self.logger.error(ppp("Unexpected or invalid packet:", packet))
 182                 raise
 183         for i in self.interfaces:
 184             remaining_packet = self.get_next_packet_info_for_interface2(
 185                 i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index])
 186             self.assertTrue(remaining_packet is None,
 187                             "Interface %s: Packet expected from interface %s "
 188                             "didn't arrive" % (dst_if.name, i.name))
 189
 190     def test_fib(self):
 191         """ IPv4 FIB test
 192
 193         Test scenario:
 194
 195             - Create IPv4 stream for pg0 interface
 196             - Create IPv4 tagged streams for pg1's and pg2's sub-interface.
 197             - Send and verify received packets on each interface.
 198         """
 199
 200         pkts = self.create_stream(self.pg0)
 201         self.pg0.add_stream(pkts)
 202
 203         for i in self.sub_interfaces:
 204             pkts = self.create_stream(i)
 205             i.parent.add_stream(pkts)
 206
 207         self.pg_enable_capture(self.pg_interfaces)
 208         self.pg_start()
 209
 210         pkts = self.pg0.get_capture()
 211         self.verify_capture(self.pg0, pkts)
 212
 213         for i in self.sub_interfaces:
 214             pkts = i.parent.get_capture()
 215             self.verify_capture(i, pkts)
 216
 217
 218 class TestIPv4RouteLookup(VppTestCase):
 219     """ IPv4 Route Lookup Test Case """
 220     routes = []
 221
 222     def route_lookup(self, prefix, exact):
 223         return self.vapi.api(self.vapi.papi.ip_route_lookup,
 224                              {
 225                                  'table_id': 0,
 226                                  'exact': exact,
 227                                  'prefix': prefix,
 228                              })
 229
 230     @classmethod
 231     def setUpClass(cls):
 232         super(TestIPv4RouteLookup, cls).setUpClass()
 233
 234     @classmethod
 235     def tearDownClass(cls):
 236         super(TestIPv4RouteLookup, cls).tearDownClass()
 237
 238     def setUp(self):
 239         super(TestIPv4RouteLookup, self).setUp()
 240
 241         drop_nh = VppRoutePath("127.0.0.1", 0xffffffff,
 242                                type=FibPathType.FIB_PATH_TYPE_DROP)
 243
 244         # Add 3 routes
 245         r = VppIpRoute(self, "1.1.0.0", 16, [drop_nh])
 246         r.add_vpp_config()
 247         self.routes.append(r)
 248
 249         r = VppIpRoute(self, "1.1.1.0", 24, [drop_nh])
 250         r.add_vpp_config()
 251         self.routes.append(r)
 252
 253         r = VppIpRoute(self, "1.1.1.1", 32, [drop_nh])
 254         r.add_vpp_config()
 255         self.routes.append(r)
 256
 257     def tearDown(self):
 258         # Remove the routes we added
 259         for r in self.routes:
 260             r.remove_vpp_config()
 261
 262         super(TestIPv4RouteLookup, self).tearDown()
 263
 264     def test_exact_match(self):
 265         # Verify we find the host route
 266         prefix = "1.1.1.1/32"
 267         result = self.route_lookup(prefix, True)
 268         assert (prefix == str(result.route.prefix))
 269
 270         # Verify we find a middle prefix route
 271         prefix = "1.1.1.0/24"
 272         result = self.route_lookup(prefix, True)
 273         assert (prefix == str(result.route.prefix))
 274
 275         # Verify we do not find an available LPM.
 276         with self.vapi.assert_negative_api_retval():
 277             self.route_lookup("1.1.1.2/32", True)
 278
 279     def test_longest_prefix_match(self):
 280         # verify we find lpm
 281         lpm_prefix = "1.1.1.0/24"
 282         result = self.route_lookup("1.1.1.2/32", False)
 283         assert (lpm_prefix == str(result.route.prefix))
 284
 285         # Verify we find the exact when not requested
 286         result = self.route_lookup(lpm_prefix, False)
 287         assert (lpm_prefix == str(result.route.prefix))
 288
 289         # Can't seem to delete the default route so no negative LPM test.
 290
 291
 292 class TestIPv4IfAddrRoute(VppTestCase):
 293     """ IPv4 Interface Addr Route Test Case """
 294
 295     @classmethod
 296     def setUpClass(cls):
 297         super(TestIPv4IfAddrRoute, cls).setUpClass()
 298
 299     @classmethod
 300     def tearDownClass(cls):
 301         super(TestIPv4IfAddrRoute, cls).tearDownClass()
 302
 303     def setUp(self):
 304         super(TestIPv4IfAddrRoute, self).setUp()
 305
 306         # create 1 pg interface
 307         self.create_pg_interfaces(range(1))
 308
 309         for i in self.pg_interfaces:
 310             i.admin_up()
 311             i.config_ip4()
 312             i.resolve_arp()
 313
 314     def tearDown(self):
 315         super(TestIPv4IfAddrRoute, self).tearDown()
 316         for i in self.pg_interfaces:
 317             i.unconfig_ip4()
 318             i.admin_down()
 319
 320     def test_ipv4_ifaddrs_same_prefix(self):
 321         """ IPv4 Interface Addresses Same Prefix test
 322
 323         Test scenario:
 324
 325             - Verify no route in FIB for prefix 10.10.10.0/24
 326             - Configure IPv4 address 10.10.10.10/24 on an interface
 327             - Verify route in FIB for prefix 10.10.10.0/24
 328             - Configure IPv4 address 10.10.10.20/24 on an interface
 329             - Delete 10.10.10.10/24 from interface
 330             - Verify route in FIB for prefix 10.10.10.0/24
 331             - Delete 10.10.10.20/24 from interface
 332             - Verify no route in FIB for prefix 10.10.10.0/24
 333         """
 334
 335         # create two addresses, verify route not present
 336         if_addr1 = VppIpInterfaceAddress(self, self.pg0, "10.10.10.10", 24)
 337         if_addr2 = VppIpInterfaceAddress(self, self.pg0, "10.10.10.20", 24)
 338         self.assertFalse(if_addr1.query_vpp_config())  # 10.10.10.10/24
 339         self.assertFalse(find_route(self, "10.10.10.10", 32))
 340         self.assertFalse(find_route(self, "10.10.10.20", 32))
 341         self.assertFalse(find_route(self, "10.10.10.255", 32))
 342         self.assertFalse(find_route(self, "10.10.10.0", 32))
 343
 344         # configure first address, verify route present
 345         if_addr1.add_vpp_config()
 346         self.assertTrue(if_addr1.query_vpp_config())  # 10.10.10.10/24
 347         self.assertTrue(find_route(self, "10.10.10.10", 32))
 348         self.assertFalse(find_route(self, "10.10.10.20", 32))
 349         self.assertTrue(find_route(self, "10.10.10.255", 32))
 350         self.assertTrue(find_route(self, "10.10.10.0", 32))
 351
 352         # configure second address, delete first, verify route not removed
 353         if_addr2.add_vpp_config()
 354         if_addr1.remove_vpp_config()
 355         self.assertFalse(if_addr1.query_vpp_config())  # 10.10.10.10/24
 356         self.assertTrue(if_addr2.query_vpp_config())  # 10.10.10.20/24
 357         self.assertFalse(find_route(self, "10.10.10.10", 32))
 358         self.assertTrue(find_route(self, "10.10.10.20", 32))
 359         self.assertTrue(find_route(self, "10.10.10.255", 32))
 360         self.assertTrue(find_route(self, "10.10.10.0", 32))
 361
 362         # delete second address, verify route removed
 363         if_addr2.remove_vpp_config()
 364         self.assertFalse(if_addr2.query_vpp_config())  # 10.10.10.20/24
 365         self.assertFalse(find_route(self, "10.10.10.10", 32))
 366         self.assertFalse(find_route(self, "10.10.10.20", 32))
 367         self.assertFalse(find_route(self, "10.10.10.255", 32))
 368         self.assertFalse(find_route(self, "10.10.10.0", 32))
 369
 370     def test_ipv4_ifaddr_route(self):
 371         """ IPv4 Interface Address Route test
 372
 373         Test scenario:
 374
 375             - Create loopback
 376             - Configure IPv4 address on loopback
 377             - Verify that address is not in the FIB
 378             - Bring loopback up
 379             - Verify that address is in the FIB now
 380             - Bring loopback down
 381             - Verify that address is not in the FIB anymore
 382             - Bring loopback up
 383             - Configure IPv4 address on loopback
 384             - Verify that address is in the FIB now
 385         """
 386
 387         # create a loopback and configure IPv4
 388         loopbacks = self.create_loopback_interfaces(1)
 389         lo_if = self.lo_interfaces[0]
 390
 391         lo_if.local_ip4_prefix_len = 32
 392         lo_if.config_ip4()
 393
 394         # The intf was down when addr was added -> entry not in FIB
 395         fib4_dump = self.vapi.ip_route_dump(0)
 396         self.assertFalse(lo_if.is_ip4_entry_in_fib_dump(fib4_dump))
 397
 398         # When intf is brought up, entry is added
 399         lo_if.admin_up()
 400         fib4_dump = self.vapi.ip_route_dump(0)
 401         self.assertTrue(lo_if.is_ip4_entry_in_fib_dump(fib4_dump))
 402
 403         # When intf is brought down, entry is removed
 404         lo_if.admin_down()
 405         fib4_dump = self.vapi.ip_route_dump(0)
 406         self.assertFalse(lo_if.is_ip4_entry_in_fib_dump(fib4_dump))
 407
 408         # Remove addr, bring up interface, re-add -> entry in FIB
 409         lo_if.unconfig_ip4()
 410         lo_if.admin_up()
 411         lo_if.config_ip4()
 412         fib4_dump = self.vapi.ip_route_dump(0)
 413         self.assertTrue(lo_if.is_ip4_entry_in_fib_dump(fib4_dump))
 414
 415     def test_ipv4_ifaddr_del(self):
 416         """ Delete an interface address that does not exist """
 417
 418         loopbacks = self.create_loopback_interfaces(1)
 419         lo = self.lo_interfaces[0]
 420
 421         lo.config_ip4()
 422         lo.admin_up()
 423
 424         #
 425         # try and remove pg0's subnet from lo
 426         #
 427         with self.vapi.assert_negative_api_retval():
 428             self.vapi.sw_interface_add_del_address(
 429                 sw_if_index=lo.sw_if_index,
 430                 prefix=self.pg0.local_ip4_prefix,
 431                 is_add=0)
 432
 433
 434 class TestICMPEcho(VppTestCase):
 435     """ ICMP Echo Test Case """
 436
 437     @classmethod
 438     def setUpClass(cls):
 439         super(TestICMPEcho, cls).setUpClass()
 440
 441     @classmethod
 442     def tearDownClass(cls):
 443         super(TestICMPEcho, cls).tearDownClass()
 444
 445     def setUp(self):
 446         super(TestICMPEcho, self).setUp()
 447
 448         # create 1 pg interface
 449         self.create_pg_interfaces(range(1))
 450
 451         for i in self.pg_interfaces:
 452             i.admin_up()
 453             i.config_ip4()
 454             i.resolve_arp()
 455
 456     def tearDown(self):
 457         super(TestICMPEcho, self).tearDown()
 458         for i in self.pg_interfaces:
 459             i.unconfig_ip4()
 460             i.admin_down()
 461
 462     def test_icmp_echo(self):
 463         """ VPP replies to ICMP Echo Request
 464
 465         Test scenario:
 466
 467             - Receive ICMP Echo Request message on pg0 interface.
 468             - Check outgoing ICMP Echo Reply message on pg0 interface.
 469         """
 470
 471         icmp_id = 0xb
 472         icmp_seq = 5
 473         icmp_load = b'\x0a' * 18
 474         p_echo_request = (Ether(src=self.pg0.remote_mac,
 475                                 dst=self.pg0.local_mac) /
 476                           IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
 477                           ICMP(id=icmp_id, seq=icmp_seq) /
 478                           Raw(load=icmp_load))
 479
 480         self.pg0.add_stream(p_echo_request)
 481         self.pg_enable_capture(self.pg_interfaces)
 482         self.pg_start()
 483
 484         rx = self.pg0.get_capture(1)
 485         rx = rx[0]
 486         ether = rx[Ether]
 487         ipv4 = rx[IP]
 488         icmp = rx[ICMP]
 489
 490         self.assertEqual(ether.src, self.pg0.local_mac)
 491         self.assertEqual(ether.dst, self.pg0.remote_mac)
 492
 493         self.assertEqual(ipv4.src, self.pg0.local_ip4)
 494         self.assertEqual(ipv4.dst, self.pg0.remote_ip4)
 495
 496         self.assertEqual(icmptypes[icmp.type], "echo-reply")
 497         self.assertEqual(icmp.id, icmp_id)
 498         self.assertEqual(icmp.seq, icmp_seq)
 499         self.assertEqual(icmp[Raw].load, icmp_load)
 500
 501
 502 class TestIPv4FibCrud(VppTestCase):
 503     """ FIB - add/update/delete - ip4 routes
 504
 505     Test scenario:
 506         - add 1k,
 507         - del 100,
 508         - add new 1k,
 509         - del 1.5k
 510
 511     ..note:: Python API is too slow to add many routes, needs replacement.
 512     """
 513
 514     def config_fib_many_to_one(self, start_dest_addr, next_hop_addr,
 515                                count, start=0):
 516         """
 517
 518         :param start_dest_addr:
 519         :param next_hop_addr:
 520         :param count:
 521         :return list: added ips with 32 prefix
 522         """
 523         routes = []
 524         for i in range(count):
 525             r = VppIpRoute(self, start_dest_addr % (i + start), 32,
 526                            [VppRoutePath(next_hop_addr, 0xffffffff)])
 527             r.add_vpp_config()
 528             routes.append(r)
 529         return routes
 530
 531     def unconfig_fib_many_to_one(self, start_dest_addr, next_hop_addr,
 532                                  count, start=0):
 533
 534         routes = []
 535         for i in range(count):
 536             r = VppIpRoute(self, start_dest_addr % (i + start), 32,
 537                            [VppRoutePath(next_hop_addr, 0xffffffff)])
 538             r.remove_vpp_config()
 539             routes.append(r)
 540         return routes
 541
 542     def create_stream(self, src_if, dst_if, routes, count):
 543         pkts = []
 544
 545         for _ in range(count):
 546             dst_addr = random.choice(routes).prefix.network_address
 547             info = self.create_packet_info(src_if, dst_if)
 548             payload = self.info_to_payload(info)
 549             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
 550                  IP(src=src_if.remote_ip4, dst=str(dst_addr)) /
 551                  UDP(sport=1234, dport=1234) /
 552                  Raw(payload))
 553             info.data = p.copy()
 554             self.extend_packet(p, random.choice(self.pg_if_packet_sizes))
 555             pkts.append(p)
 556
 557         return pkts
 558
 559     def _find_ip_match(self, find_in, pkt):
 560         for p in find_in:
 561             if self.payload_to_info(p[Raw]) == \
 562                     self.payload_to_info(pkt[Raw]):
 563                 if p[IP].src != pkt[IP].src:
 564                     break
 565                 if p[IP].dst != pkt[IP].dst:
 566                     break
 567                 if p[UDP].sport != pkt[UDP].sport:
 568                     break
 569                 if p[UDP].dport != pkt[UDP].dport:
 570                     break
 571                 return p
 572         return None
 573
 574     def verify_capture(self, dst_interface, received_pkts, expected_pkts):
 575         self.assertEqual(len(received_pkts), len(expected_pkts))
 576         to_verify = list(expected_pkts)
 577         for p in received_pkts:
 578             self.assertEqual(p.src, dst_interface.local_mac)
 579             self.assertEqual(p.dst, dst_interface.remote_mac)
 580             x = self._find_ip_match(to_verify, p)
 581             to_verify.remove(x)
 582         self.assertListEqual(to_verify, [])
 583
 584     def verify_route_dump(self, routes):
 585         for r in routes:
 586             self.assertTrue(find_route(self,
 587                                        r.prefix.network_address,
 588                                        r.prefix.prefixlen))
 589
 590     def verify_not_in_route_dump(self, routes):
 591         for r in routes:
 592             self.assertFalse(find_route(self,
 593                                         r.prefix.network_address,
 594                                         r.prefix.prefixlen))
 595
 596     @classmethod
 597     def setUpClass(cls):
 598         """
 599         #. Create and initialize 3 pg interfaces.
 600         #. initialize class attributes configured_routes and deleted_routes
 601            to store information between tests.
 602         """
 603         super(TestIPv4FibCrud, cls).setUpClass()
 604
 605         try:
 606             # create 3 pg interfaces
 607             cls.create_pg_interfaces(range(3))
 608
 609             cls.interfaces = list(cls.pg_interfaces)
 610
 611             # setup all interfaces
 612             for i in cls.interfaces:
 613                 i.admin_up()
 614                 i.config_ip4()
 615                 i.resolve_arp()
 616
 617             cls.configured_routes = []
 618             cls.deleted_routes = []
 619             cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
 620
 621         except Exception:
 622             super(TestIPv4FibCrud, cls).tearDownClass()
 623             raise
 624
 625     @classmethod
 626     def tearDownClass(cls):
 627         super(TestIPv4FibCrud, cls).tearDownClass()
 628
 629     def setUp(self):
 630         super(TestIPv4FibCrud, self).setUp()
 631         self.reset_packet_infos()
 632
 633         self.configured_routes = []
 634         self.deleted_routes = []
 635
 636     def test_1_add_routes(self):
 637         """ Add 1k routes """
 638
 639         # add 100 routes check with traffic script.
 640         self.configured_routes.extend(self.config_fib_many_to_one(
 641             "10.0.0.%d", self.pg0.remote_ip4, 100))
 642
 643         self.verify_route_dump(self.configured_routes)
 644
 645         self.stream_1 = self.create_stream(
 646             self.pg1, self.pg0, self.configured_routes, 100)
 647         self.stream_2 = self.create_stream(
 648             self.pg2, self.pg0, self.configured_routes, 100)
 649         self.pg1.add_stream(self.stream_1)
 650         self.pg2.add_stream(self.stream_2)
 651
 652         self.pg_enable_capture(self.pg_interfaces)
 653         self.pg_start()
 654
 655         pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
 656         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 657
 658     def test_2_del_routes(self):
 659         """ Delete 100 routes
 660
 661         - delete 10 routes check with traffic script.
 662         """
 663         # config 1M FIB entries
 664         self.configured_routes.extend(self.config_fib_many_to_one(
 665             "10.0.0.%d", self.pg0.remote_ip4, 100))
 666         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 667             "10.0.0.%d", self.pg0.remote_ip4, 10, start=10))
 668         for x in self.deleted_routes:
 669             self.configured_routes.remove(x)
 670
 671         self.verify_route_dump(self.configured_routes)
 672
 673         self.stream_1 = self.create_stream(
 674             self.pg1, self.pg0, self.configured_routes, 100)
 675         self.stream_2 = self.create_stream(
 676             self.pg2, self.pg0, self.configured_routes, 100)
 677         self.stream_3 = self.create_stream(
 678             self.pg1, self.pg0, self.deleted_routes, 100)
 679         self.stream_4 = self.create_stream(
 680             self.pg2, self.pg0, self.deleted_routes, 100)
 681         self.pg1.add_stream(self.stream_1 + self.stream_3)
 682         self.pg2.add_stream(self.stream_2 + self.stream_4)
 683         self.pg_enable_capture(self.pg_interfaces)
 684         self.pg_start()
 685
 686         pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
 687         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 688
 689     def test_3_add_new_routes(self):
 690         """ Add 1k routes
 691
 692         - re-add 5 routes check with traffic script.
 693         - add 100 routes check with traffic script.
 694         """
 695         # config 1M FIB entries
 696         self.configured_routes.extend(self.config_fib_many_to_one(
 697             "10.0.0.%d", self.pg0.remote_ip4, 100))
 698         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 699             "10.0.0.%d", self.pg0.remote_ip4, 10, start=10))
 700         for x in self.deleted_routes:
 701             self.configured_routes.remove(x)
 702
 703         tmp = self.config_fib_many_to_one(
 704             "10.0.0.%d", self.pg0.remote_ip4, 5, start=10)
 705         self.configured_routes.extend(tmp)
 706         for x in tmp:
 707             self.deleted_routes.remove(x)
 708
 709         self.configured_routes.extend(self.config_fib_many_to_one(
 710             "10.0.1.%d", self.pg0.remote_ip4, 100))
 711
 712         self.verify_route_dump(self.configured_routes)
 713
 714         self.stream_1 = self.create_stream(
 715             self.pg1, self.pg0, self.configured_routes, 300)
 716         self.stream_2 = self.create_stream(
 717             self.pg2, self.pg0, self.configured_routes, 300)
 718         self.stream_3 = self.create_stream(
 719             self.pg1, self.pg0, self.deleted_routes, 100)
 720         self.stream_4 = self.create_stream(
 721             self.pg2, self.pg0, self.deleted_routes, 100)
 722
 723         self.pg1.add_stream(self.stream_1 + self.stream_3)
 724         self.pg2.add_stream(self.stream_2 + self.stream_4)
 725         self.pg_enable_capture(self.pg_interfaces)
 726         self.pg_start()
 727
 728         pkts = self.pg0.get_capture(len(self.stream_1) + len(self.stream_2))
 729         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 730
 731         # delete 5 routes check with traffic script.
 732         # add 100 routes check with traffic script.
 733         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 734             "10.0.0.%d", self.pg0.remote_ip4, 15))
 735         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 736             "10.0.0.%d", self.pg0.remote_ip4, 85))
 737         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 738             "10.0.1.%d", self.pg0.remote_ip4, 100))
 739         self.verify_not_in_route_dump(self.deleted_routes)
 740
 741
 742 class TestIPNull(VppTestCase):
 743     """ IPv4 routes via NULL """
 744
 745     @classmethod
 746     def setUpClass(cls):
 747         super(TestIPNull, cls).setUpClass()
 748
 749     @classmethod
 750     def tearDownClass(cls):
 751         super(TestIPNull, cls).tearDownClass()
 752
 753     def setUp(self):
 754         super(TestIPNull, self).setUp()
 755
 756         # create 2 pg interfaces
 757         self.create_pg_interfaces(range(2))
 758
 759         for i in self.pg_interfaces:
 760             i.admin_up()
 761             i.config_ip4()
 762             i.resolve_arp()
 763
 764     def tearDown(self):
 765         super(TestIPNull, self).tearDown()
 766         for i in self.pg_interfaces:
 767             i.unconfig_ip4()
 768             i.admin_down()
 769
 770     def test_ip_null(self):
 771         """ IP NULL route """
 772
 773         #
 774         # A route via IP NULL that will reply with ICMP unreachables
 775         #
 776         ip_unreach = VppIpRoute(
 777             self, "10.0.0.1", 32,
 778             [VppRoutePath("0.0.0.0",
 779                           0xffffffff,
 780                           type=FibPathType.FIB_PATH_TYPE_ICMP_UNREACH)])
 781         ip_unreach.add_vpp_config()
 782
 783         p_unreach = (Ether(src=self.pg0.remote_mac,
 784                            dst=self.pg0.local_mac) /
 785                      IP(src=self.pg0.remote_ip4, dst="10.0.0.1") /
 786                      UDP(sport=1234, dport=1234) /
 787                      Raw(b'\xa5' * 100))
 788         self.pg0.add_stream(p_unreach)
 789         self.pg_enable_capture(self.pg_interfaces)
 790         self.pg_start()
 791
 792         rx = self.pg0.get_capture(1)
 793         rx = rx[0]
 794         icmp = rx[ICMP]
 795
 796         self.assertEqual(icmptypes[icmp.type], "dest-unreach")
 797         self.assertEqual(icmpcodes[icmp.type][icmp.code], "host-unreachable")
 798         self.assertEqual(icmp.src, self.pg0.remote_ip4)
 799         self.assertEqual(icmp.dst, "10.0.0.1")
 800
 801         #
 802         # ICMP replies are rate limited. so sit and spin.
 803         #
 804         self.sleep(1)
 805
 806         #
 807         # A route via IP NULL that will reply with ICMP prohibited
 808         #
 809         ip_prohibit = VppIpRoute(
 810             self, "10.0.0.2", 32,
 811             [VppRoutePath("0.0.0.0",
 812                           0xffffffff,
 813                           type=FibPathType.FIB_PATH_TYPE_ICMP_PROHIBIT)])
 814         ip_prohibit.add_vpp_config()
 815
 816         p_prohibit = (Ether(src=self.pg0.remote_mac,
 817                             dst=self.pg0.local_mac) /
 818                       IP(src=self.pg0.remote_ip4, dst="10.0.0.2") /
 819                       UDP(sport=1234, dport=1234) /
 820                       Raw(b'\xa5' * 100))
 821
 822         self.pg0.add_stream(p_prohibit)
 823         self.pg_enable_capture(self.pg_interfaces)
 824         self.pg_start()
 825
 826         rx = self.pg0.get_capture(1)
 827
 828         rx = rx[0]
 829         icmp = rx[ICMP]
 830
 831         self.assertEqual(icmptypes[icmp.type], "dest-unreach")
 832         self.assertEqual(icmpcodes[icmp.type][icmp.code], "host-prohibited")
 833         self.assertEqual(icmp.src, self.pg0.remote_ip4)
 834         self.assertEqual(icmp.dst, "10.0.0.2")
 835
 836     def test_ip_drop(self):
 837         """ IP Drop Routes """
 838
 839         p = (Ether(src=self.pg0.remote_mac,
 840                    dst=self.pg0.local_mac) /
 841              IP(src=self.pg0.remote_ip4, dst="1.1.1.1") /
 842              UDP(sport=1234, dport=1234) /
 843              Raw(b'\xa5' * 100))
 844
 845         r1 = VppIpRoute(self, "1.1.1.0", 24,
 846                         [VppRoutePath(self.pg1.remote_ip4,
 847                                       self.pg1.sw_if_index)])
 848         r1.add_vpp_config()
 849
 850         rx = self.send_and_expect(self.pg0, p * NUM_PKTS, self.pg1)
 851
 852         #
 853         # insert a more specific as a drop
 854         #
 855         r2 = VppIpRoute(self, "1.1.1.1", 32,
 856                         [VppRoutePath("0.0.0.0",
 857                                       0xffffffff,
 858                                       type=FibPathType.FIB_PATH_TYPE_DROP)])
 859         r2.add_vpp_config()
 860
 861         self.send_and_assert_no_replies(self.pg0, p * NUM_PKTS, "Drop Route")
 862         r2.remove_vpp_config()
 863         rx = self.send_and_expect(self.pg0, p * NUM_PKTS, self.pg1)
 864
 865
 866 class TestIPDisabled(VppTestCase):
 867     """ IPv4 disabled """
 868
 869     @classmethod
 870     def setUpClass(cls):
 871         super(TestIPDisabled, cls).setUpClass()
 872
 873     @classmethod
 874     def tearDownClass(cls):
 875         super(TestIPDisabled, cls).tearDownClass()
 876
 877     def setUp(self):
 878         super(TestIPDisabled, self).setUp()
 879
 880         # create 2 pg interfaces
 881         self.create_pg_interfaces(range(2))
 882
 883         # PG0 is IP enalbed
 884         self.pg0.admin_up()
 885         self.pg0.config_ip4()
 886         self.pg0.resolve_arp()
 887
 888         # PG 1 is not IP enabled
 889         self.pg1.admin_up()
 890
 891     def tearDown(self):
 892         super(TestIPDisabled, self).tearDown()
 893         for i in self.pg_interfaces:
 894             i.unconfig_ip4()
 895             i.admin_down()
 896
 897     def test_ip_disabled(self):
 898         """ IP Disabled """
 899
 900         MRouteItfFlags = VppEnum.vl_api_mfib_itf_flags_t
 901         MRouteEntryFlags = VppEnum.vl_api_mfib_entry_flags_t
 902
 903         #
 904         # An (S,G).
 905         # one accepting interface, pg0, 2 forwarding interfaces
 906         #
 907         route_232_1_1_1 = VppIpMRoute(
 908             self,
 909             "0.0.0.0",
 910             "232.1.1.1", 32,
 911             MRouteEntryFlags.MFIB_API_ENTRY_FLAG_NONE,
 912             [VppMRoutePath(self.pg1.sw_if_index,
 913                            MRouteItfFlags.MFIB_API_ITF_FLAG_ACCEPT),
 914              VppMRoutePath(self.pg0.sw_if_index,
 915                            MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD)])
 916         route_232_1_1_1.add_vpp_config()
 917
 918         pu = (Ether(src=self.pg1.remote_mac,
 919                     dst=self.pg1.local_mac) /
 920               IP(src="10.10.10.10", dst=self.pg0.remote_ip4) /
 921               UDP(sport=1234, dport=1234) /
 922               Raw(b'\xa5' * 100))
 923         pm = (Ether(src=self.pg1.remote_mac,
 924                     dst=self.pg1.local_mac) /
 925               IP(src="10.10.10.10", dst="232.1.1.1") /
 926               UDP(sport=1234, dport=1234) /
 927               Raw(b'\xa5' * 100))
 928
 929         #
 930         # PG1 does not forward IP traffic
 931         #
 932         self.send_and_assert_no_replies(self.pg1, pu, "IP disabled")
 933         self.send_and_assert_no_replies(self.pg1, pm, "IP disabled")
 934
 935         #
 936         # IP enable PG1
 937         #
 938         self.pg1.config_ip4()
 939
 940         #
 941         # Now we get packets through
 942         #
 943         self.pg1.add_stream(pu)
 944         self.pg_enable_capture(self.pg_interfaces)
 945         self.pg_start()
 946         rx = self.pg0.get_capture(1)
 947
 948         self.pg1.add_stream(pm)
 949         self.pg_enable_capture(self.pg_interfaces)
 950         self.pg_start()
 951         rx = self.pg0.get_capture(1)
 952
 953         #
 954         # Disable PG1
 955         #
 956         self.pg1.unconfig_ip4()
 957
 958         #
 959         # PG1 does not forward IP traffic
 960         #
 961         self.send_and_assert_no_replies(self.pg1, pu, "IP disabled")
 962         self.send_and_assert_no_replies(self.pg1, pm, "IP disabled")
 963
 964
 965 class TestIPSubNets(VppTestCase):
 966     """ IPv4 Subnets """
 967
 968     @classmethod
 969     def setUpClass(cls):
 970         super(TestIPSubNets, cls).setUpClass()
 971
 972     @classmethod
 973     def tearDownClass(cls):
 974         super(TestIPSubNets, cls).tearDownClass()
 975
 976     def setUp(self):
 977         super(TestIPSubNets, self).setUp()
 978
 979         # create a 2 pg interfaces
 980         self.create_pg_interfaces(range(2))
 981
 982         # pg0 we will use to experiment
 983         self.pg0.admin_up()
 984
 985         # pg1 is setup normally
 986         self.pg1.admin_up()
 987         self.pg1.config_ip4()
 988         self.pg1.resolve_arp()
 989
 990     def tearDown(self):
 991         super(TestIPSubNets, self).tearDown()
 992         for i in self.pg_interfaces:
 993             i.admin_down()
 994
 995     def test_ip_sub_nets(self):
 996         """ IP Sub Nets """
 997
 998         #
 999         # Configure a covering route to forward so we know
1000         # when we are dropping
1001         #
1002         cover_route = VppIpRoute(self, "10.0.0.0", 8,
1003                                  [VppRoutePath(self.pg1.remote_ip4,
1004                                                self.pg1.sw_if_index)])
1005         cover_route.add_vpp_config()
1006
1007         p = (Ether(src=self.pg1.remote_mac,
1008                    dst=self.pg1.local_mac) /
1009              IP(dst="10.10.10.10", src=self.pg0.local_ip4) /
1010              UDP(sport=1234, dport=1234) /
1011              Raw(b'\xa5' * 100))
1012
1013         self.pg1.add_stream(p)
1014         self.pg_enable_capture(self.pg_interfaces)
1015         self.pg_start()
1016         rx = self.pg1.get_capture(1)
1017
1018         #
1019         # Configure some non-/24 subnets on an IP interface
1020         #
1021         ip_addr_n = socket.inet_pton(socket.AF_INET, "10.10.10.10")
1022
1023         self.vapi.sw_interface_add_del_address(
1024             sw_if_index=self.pg0.sw_if_index,
1025             prefix="10.10.10.10/16")
1026
1027         pn = (Ether(src=self.pg1.remote_mac,
1028                     dst=self.pg1.local_mac) /
1029               IP(dst="10.10.0.0", src=self.pg0.local_ip4) /
1030               UDP(sport=1234, dport=1234) /
1031               Raw(b'\xa5' * 100))
1032         pb = (Ether(src=self.pg1.remote_mac,
1033                     dst=self.pg1.local_mac) /
1034               IP(dst="10.10.255.255", src=self.pg0.local_ip4) /
1035               UDP(sport=1234, dport=1234) /
1036               Raw(b'\xa5' * 100))
1037
1038         self.send_and_assert_no_replies(self.pg1, pn, "IP Network address")
1039         self.send_and_assert_no_replies(self.pg1, pb, "IP Broadcast address")
1040
1041         # remove the sub-net and we are forwarding via the cover again
1042         self.vapi.sw_interface_add_del_address(
1043             sw_if_index=self.pg0.sw_if_index,
1044             prefix="10.10.10.10/16",
1045             is_add=0)
1046
1047         self.pg1.add_stream(pn)
1048         self.pg_enable_capture(self.pg_interfaces)
1049         self.pg_start()
1050         rx = self.pg1.get_capture(1)
1051         self.pg1.add_stream(pb)
1052         self.pg_enable_capture(self.pg_interfaces)
1053         self.pg_start()
1054         rx = self.pg1.get_capture(1)
1055
1056         #
1057         # A /31 is a special case where the 'other-side' is an attached host
1058         # packets to that peer generate ARP requests
1059         #
1060         ip_addr_n = socket.inet_pton(socket.AF_INET, "10.10.10.10")
1061
1062         self.vapi.sw_interface_add_del_address(
1063             sw_if_index=self.pg0.sw_if_index,
1064             prefix="10.10.10.10/31")
1065
1066         pn = (Ether(src=self.pg1.remote_mac,
1067                     dst=self.pg1.local_mac) /
1068               IP(dst="10.10.10.11", src=self.pg0.local_ip4) /
1069               UDP(sport=1234, dport=1234) /
1070               Raw(b'\xa5' * 100))
1071
1072         self.pg1.add_stream(pn)
1073         self.pg_enable_capture(self.pg_interfaces)
1074         self.pg_start()
1075         rx = self.pg0.get_capture(1)
1076         rx[ARP]
1077
1078         # remove the sub-net and we are forwarding via the cover again
1079         self.vapi.sw_interface_add_del_address(
1080             sw_if_index=self.pg0.sw_if_index,
1081             prefix="10.10.10.10/31", is_add=0)
1082
1083         self.pg1.add_stream(pn)
1084         self.pg_enable_capture(self.pg_interfaces)
1085         self.pg_start()
1086         rx = self.pg1.get_capture(1)
1087
1088
1089 class TestIPLoadBalance(VppTestCase):
1090     """ IPv4 Load-Balancing """
1091
1092     @classmethod
1093     def setUpClass(cls):
1094         super(TestIPLoadBalance, cls).setUpClass()
1095
1096     @classmethod
1097     def tearDownClass(cls):
1098         super(TestIPLoadBalance, cls).tearDownClass()
1099
1100     def setUp(self):
1101         super(TestIPLoadBalance, self).setUp()
1102
1103         self.create_pg_interfaces(range(5))
1104         mpls_tbl = VppMplsTable(self, 0)
1105         mpls_tbl.add_vpp_config()
1106
1107         for i in self.pg_interfaces:
1108             i.admin_up()
1109             i.config_ip4()
1110             i.resolve_arp()
1111             i.enable_mpls()
1112
1113     def tearDown(self):
1114         for i in self.pg_interfaces:
1115             i.disable_mpls()
1116             i.unconfig_ip4()
1117             i.admin_down()
1118         super(TestIPLoadBalance, self).tearDown()
1119
1120     def send_and_expect_load_balancing(self, input, pkts, outputs):
1121         self.vapi.cli("clear trace")
1122         input.add_stream(pkts)
1123         self.pg_enable_capture(self.pg_interfaces)
1124         self.pg_start()
1125         rxs = []
1126         for oo in outputs:
1127             rx = oo._get_capture(1)
1128             self.assertNotEqual(0, len(rx))
1129             rxs.append(rx)
1130         return rxs
1131
1132     def send_and_expect_one_itf(self, input, pkts, itf):
1133         input.add_stream(pkts)
1134         self.pg_enable_capture(self.pg_interfaces)
1135         self.pg_start()
1136         rx = itf.get_capture(len(pkts))
1137
1138     def total_len(self, rxs):
1139         n = 0
1140         for rx in rxs:
1141             n += len(rx)
1142         return n
1143
1144     def test_ip_load_balance(self):
1145         """ IP Load-Balancing """
1146
1147         fhc = VppEnum.vl_api_ip_flow_hash_config_t
1148         af = VppEnum.vl_api_address_family_t
1149
1150         #
1151         # An array of packets that differ only in the destination port
1152         #
1153         port_ip_pkts = []
1154         port_mpls_pkts = []
1155
1156         #
1157         # An array of packets that differ only in the source address
1158         #
1159         src_ip_pkts = []
1160         src_mpls_pkts = []
1161
1162         for ii in range(NUM_PKTS):
1163             port_ip_hdr = (IP(dst="10.0.0.1", src="20.0.0.1") /
1164                            UDP(sport=1234, dport=1234 + ii) /
1165                            Raw(b'\xa5' * 100))
1166             port_ip_pkts.append((Ether(src=self.pg0.remote_mac,
1167                                        dst=self.pg0.local_mac) /
1168                                  port_ip_hdr))
1169             port_mpls_pkts.append((Ether(src=self.pg0.remote_mac,
1170                                          dst=self.pg0.local_mac) /
1171                                    MPLS(label=66, ttl=2) /
1172                                    port_ip_hdr))
1173
1174             src_ip_hdr = (IP(dst="10.0.0.1", src="20.0.0.%d" % ii) /
1175                           UDP(sport=1234, dport=1234) /
1176                           Raw(b'\xa5' * 100))
1177             src_ip_pkts.append((Ether(src=self.pg0.remote_mac,
1178                                       dst=self.pg0.local_mac) /
1179                                 src_ip_hdr))
1180             src_mpls_pkts.append((Ether(src=self.pg0.remote_mac,
1181                                         dst=self.pg0.local_mac) /
1182                                   MPLS(label=66, ttl=2) /
1183                                   src_ip_hdr))
1184
1185         route_10_0_0_1 = VppIpRoute(self, "10.0.0.1", 32,
1186                                     [VppRoutePath(self.pg1.remote_ip4,
1187                                                   self.pg1.sw_if_index),
1188                                      VppRoutePath(self.pg2.remote_ip4,
1189                                                   self.pg2.sw_if_index)])
1190         route_10_0_0_1.add_vpp_config()
1191
1192         binding = VppMplsIpBind(self, 66, "10.0.0.1", 32)
1193         binding.add_vpp_config()
1194
1195         #
1196         # inject the packet on pg0 - expect load-balancing across the 2 paths
1197         #  - since the default hash config is to use IP src,dst and port
1198         #    src,dst
1199         # We are not going to ensure equal amounts of packets across each link,
1200         # since the hash algorithm is statistical and therefore this can never
1201         # be guaranteed. But with 64 different packets we do expect some
1202         # balancing. So instead just ensure there is traffic on each link.
1203         #
1204         rx = self.send_and_expect_load_balancing(self.pg0, port_ip_pkts,
1205                                                  [self.pg1, self.pg2])
1206         n_ip_pg0 = len(rx[0])
1207         self.send_and_expect_load_balancing(self.pg0, src_ip_pkts,
1208                                             [self.pg1, self.pg2])
1209         self.send_and_expect_load_balancing(self.pg0, port_mpls_pkts,
1210                                             [self.pg1, self.pg2])
1211         rx = self.send_and_expect_load_balancing(self.pg0, src_mpls_pkts,
1212                                                  [self.pg1, self.pg2])
1213         n_mpls_pg0 = len(rx[0])
1214
1215         #
1216         # change the router ID and expect the distribution changes
1217         #
1218         self.vapi.set_ip_flow_hash_router_id(router_id=0x11111111)
1219
1220         rx = self.send_and_expect_load_balancing(self.pg0, port_ip_pkts,
1221                                                  [self.pg1, self.pg2])
1222         self.assertNotEqual(n_ip_pg0, len(rx[0]))
1223
1224         rx = self.send_and_expect_load_balancing(self.pg0, src_mpls_pkts,
1225                                                  [self.pg1, self.pg2])
1226         self.assertNotEqual(n_mpls_pg0, len(rx[0]))
1227
1228         #
1229         # change the flow hash config so it's only IP src,dst
1230         #  - now only the stream with differing source address will
1231         #    load-balance
1232         #
1233         self.vapi.set_ip_flow_hash_v2(
1234             af=af.ADDRESS_IP4,
1235             table_id=0,
1236             flow_hash_config=(fhc.IP_API_FLOW_HASH_SRC_IP |
1237                               fhc.IP_API_FLOW_HASH_DST_IP |
1238                               fhc.IP_API_FLOW_HASH_PROTO))
1239
1240         self.send_and_expect_load_balancing(self.pg0, src_ip_pkts,
1241                                             [self.pg1, self.pg2])
1242         self.send_and_expect_load_balancing(self.pg0, src_mpls_pkts,
1243                                             [self.pg1, self.pg2])
1244
1245         self.send_and_expect_one_itf(self.pg0, port_ip_pkts, self.pg2)
1246
1247         #
1248         # change the flow hash config back to defaults
1249         #
1250         self.vapi.set_ip_flow_hash(vrf_id=0, src=1, dst=1,
1251                                    proto=1, sport=1, dport=1)
1252
1253         #
1254         # Recursive prefixes
1255         #  - testing that 2 stages of load-balancing occurs and there is no
1256         #    polarisation (i.e. only 2 of 4 paths are used)
1257         #
1258         port_pkts = []
1259         src_pkts = []
1260
1261         for ii in range(257):
1262             port_pkts.append((Ether(src=self.pg0.remote_mac,
1263                                     dst=self.pg0.local_mac) /
1264                               IP(dst="1.1.1.1", src="20.0.0.1") /
1265                               UDP(sport=1234, dport=1234 + ii) /
1266                               Raw(b'\xa5' * 100)))
1267             src_pkts.append((Ether(src=self.pg0.remote_mac,
1268                                    dst=self.pg0.local_mac) /
1269                              IP(dst="1.1.1.1", src="20.0.0.%d" % ii) /
1270                              UDP(sport=1234, dport=1234) /
1271                              Raw(b'\xa5' * 100)))
1272
1273         route_10_0_0_2 = VppIpRoute(self, "10.0.0.2", 32,
1274                                     [VppRoutePath(self.pg3.remote_ip4,
1275                                                   self.pg3.sw_if_index),
1276                                      VppRoutePath(self.pg4.remote_ip4,
1277                                                   self.pg4.sw_if_index)])
1278         route_10_0_0_2.add_vpp_config()
1279
1280         route_1_1_1_1 = VppIpRoute(self, "1.1.1.1", 32,
1281                                    [VppRoutePath("10.0.0.2", 0xffffffff),
1282                                     VppRoutePath("10.0.0.1", 0xffffffff)])
1283         route_1_1_1_1.add_vpp_config()
1284
1285         #
1286         # inject the packet on pg0 - expect load-balancing across all 4 paths
1287         #
1288         self.vapi.cli("clear trace")
1289         self.send_and_expect_load_balancing(self.pg0, port_pkts,
1290                                             [self.pg1, self.pg2,
1291                                              self.pg3, self.pg4])
1292         self.send_and_expect_load_balancing(self.pg0, src_pkts,
1293                                             [self.pg1, self.pg2,
1294                                              self.pg3, self.pg4])
1295
1296         #
1297         # bring down pg1 expect LB to adjust to use only those that are up
1298         #
1299         self.pg1.link_down()
1300
1301         rx = self.send_and_expect_load_balancing(self.pg0, src_pkts,
1302                                                  [self.pg2, self.pg3,
1303                                                   self.pg4])
1304         self.assertEqual(len(src_pkts), self.total_len(rx))
1305
1306         #
1307         # bring down pg2 expect LB to adjust to use only those that are up
1308         #
1309         self.pg2.link_down()
1310
1311         rx = self.send_and_expect_load_balancing(self.pg0, src_pkts,
1312                                                  [self.pg3, self.pg4])
1313         self.assertEqual(len(src_pkts), self.total_len(rx))
1314
1315         #
1316         # bring the links back up - expect LB over all again
1317         #
1318         self.pg1.link_up()
1319         self.pg2.link_up()
1320
1321         rx = self.send_and_expect_load_balancing(self.pg0, src_pkts,
1322                                                  [self.pg1, self.pg2,
1323                                                   self.pg3, self.pg4])
1324         self.assertEqual(len(src_pkts), self.total_len(rx))
1325
1326         #
1327         # The same link-up/down but this time admin state
1328         #
1329         self.pg1.admin_down()
1330         self.pg2.admin_down()
1331         rx = self.send_and_expect_load_balancing(self.pg0, src_pkts,
1332                                                  [self.pg3, self.pg4])
1333         self.assertEqual(len(src_pkts), self.total_len(rx))
1334         self.pg1.admin_up()
1335         self.pg2.admin_up()
1336         self.pg1.resolve_arp()
1337         self.pg2.resolve_arp()
1338         rx = self.send_and_expect_load_balancing(self.pg0, src_pkts,
1339                                                  [self.pg1, self.pg2,
1340                                                   self.pg3, self.pg4])
1341         self.assertEqual(len(src_pkts), self.total_len(rx))
1342
1343         #
1344         # Recursive prefixes
1345         #  - testing that 2 stages of load-balancing, no choices
1346         #
1347         port_pkts = []
1348
1349         for ii in range(257):
1350             port_pkts.append((Ether(src=self.pg0.remote_mac,
1351                                     dst=self.pg0.local_mac) /
1352                               IP(dst="1.1.1.2", src="20.0.0.2") /
1353                               UDP(sport=1234, dport=1234 + ii) /
1354                               Raw(b'\xa5' * 100)))
1355
1356         route_10_0_0_3 = VppIpRoute(self, "10.0.0.3", 32,
1357                                     [VppRoutePath(self.pg3.remote_ip4,
1358                                                   self.pg3.sw_if_index)])
1359         route_10_0_0_3.add_vpp_config()
1360
1361         route_1_1_1_2 = VppIpRoute(self, "1.1.1.2", 32,
1362                                    [VppRoutePath("10.0.0.3", 0xffffffff)])
1363         route_1_1_1_2.add_vpp_config()
1364
1365         #
1366         # inject the packet on pg0 - rx only on via routes output interface
1367         #
1368         self.vapi.cli("clear trace")
1369         self.send_and_expect_one_itf(self.pg0, port_pkts, self.pg3)
1370
1371         #
1372         # Add a LB route in the presence of a down link - expect no
1373         # packets over the down link
1374         #
1375         self.pg3.link_down()
1376
1377         route_10_0_0_3 = VppIpRoute(self, "10.0.0.3", 32,
1378                                     [VppRoutePath(self.pg3.remote_ip4,
1379                                                   self.pg3.sw_if_index),
1380                                      VppRoutePath(self.pg4.remote_ip4,
1381                                                   self.pg4.sw_if_index)])
1382         route_10_0_0_3.add_vpp_config()
1383
1384         port_pkts = []
1385         for ii in range(257):
1386             port_pkts.append(Ether(src=self.pg0.remote_mac,
1387                                    dst=self.pg0.local_mac) /
1388                              IP(dst="10.0.0.3", src="20.0.0.2") /
1389                              UDP(sport=1234, dport=1234 + ii) /
1390                              Raw(b'\xa5' * 100))
1391
1392         self.send_and_expect_one_itf(self.pg0, port_pkts, self.pg4)
1393
1394         # bring the link back up
1395         self.pg3.link_up()
1396
1397         rx = self.send_and_expect_load_balancing(self.pg0, port_pkts,
1398                                                  [self.pg3, self.pg4])
1399         self.assertEqual(len(src_pkts), self.total_len(rx))
1400
1401
1402 class TestIPVlan0(VppTestCase):
1403     """ IPv4 VLAN-0 """
1404
1405     @classmethod
1406     def setUpClass(cls):
1407         super(TestIPVlan0, cls).setUpClass()
1408
1409     @classmethod
1410     def tearDownClass(cls):
1411         super(TestIPVlan0, cls).tearDownClass()
1412
1413     def setUp(self):
1414         super(TestIPVlan0, self).setUp()
1415
1416         self.create_pg_interfaces(range(2))
1417         mpls_tbl = VppMplsTable(self, 0)
1418         mpls_tbl.add_vpp_config()
1419
1420         for i in self.pg_interfaces:
1421             i.admin_up()
1422             i.config_ip4()
1423             i.resolve_arp()
1424             i.enable_mpls()
1425
1426     def tearDown(self):
1427         for i in self.pg_interfaces:
1428             i.disable_mpls()
1429             i.unconfig_ip4()
1430             i.admin_down()
1431         super(TestIPVlan0, self).tearDown()
1432
1433     def test_ip_vlan_0(self):
1434         """ IP VLAN-0 """
1435
1436         pkts = (Ether(src=self.pg0.remote_mac,
1437                       dst=self.pg0.local_mac) /
1438                 Dot1Q(vlan=0) /
1439                 IP(dst=self.pg1.remote_ip4,
1440                    src=self.pg0.remote_ip4) /
1441                 UDP(sport=1234, dport=1234) /
1442                 Raw(b'\xa5' * 100)) * NUM_PKTS
1443
1444         #
1445         # Expect that packets sent on VLAN-0 are forwarded on the
1446         # main interface.
1447         #
1448         self.send_and_expect(self.pg0, pkts, self.pg1)
1449
1450
1451 class TestIPPunt(VppTestCase):
1452     """ IPv4 Punt Police/Redirect """
1453
1454     @classmethod
1455     def setUpClass(cls):
1456         super(TestIPPunt, cls).setUpClass()
1457
1458     @classmethod
1459     def tearDownClass(cls):
1460         super(TestIPPunt, cls).tearDownClass()
1461
1462     def setUp(self):
1463         super(TestIPPunt, self).setUp()
1464
1465         self.create_pg_interfaces(range(4))
1466
1467         for i in self.pg_interfaces:
1468             i.admin_up()
1469             i.config_ip4()
1470             i.resolve_arp()
1471
1472     def tearDown(self):
1473         super(TestIPPunt, self).tearDown()
1474         for i in self.pg_interfaces:
1475             i.unconfig_ip4()
1476             i.admin_down()
1477
1478     def test_ip_punt(self):
1479         """ IP punt police and redirect """
1480
1481         # use UDP packet that have a port we need to explicitly
1482         # register to get punted.
1483         pt_l4 = VppEnum.vl_api_punt_type_t.PUNT_API_TYPE_L4
1484         af_ip4 = VppEnum.vl_api_address_family_t.ADDRESS_IP4
1485         udp_proto = VppEnum.vl_api_ip_proto_t.IP_API_PROTO_UDP
1486         punt_udp = {
1487             'type': pt_l4,
1488             'punt': {
1489                 'l4': {
1490                     'af': af_ip4,
1491                     'protocol': udp_proto,
1492                     'port': 1234,
1493                 }
1494             }
1495         }
1496
1497         self.vapi.set_punt(is_add=1, punt=punt_udp)
1498
1499         p = (Ether(src=self.pg0.remote_mac,
1500                    dst=self.pg0.local_mac) /
1501              IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
1502              UDP(sport=1234, dport=1234) /
1503              Raw(b'\xa5' * 100))
1504
1505         pkts = p * 1025
1506
1507         #
1508         # Configure a punt redirect via pg1.
1509         #
1510         nh_addr = self.pg1.remote_ip4
1511         ip_punt_redirect = VppIpPuntRedirect(self, self.pg0.sw_if_index,
1512                                              self.pg1.sw_if_index, nh_addr)
1513         ip_punt_redirect.add_vpp_config()
1514
1515         self.send_and_expect(self.pg0, pkts, self.pg1)
1516
1517         #
1518         # add a policer
1519         #
1520         policer = VppPolicer(self, "ip4-punt", 400, 0, 10, 0, rate_type=1)
1521         policer.add_vpp_config()
1522         ip_punt_policer = VppIpPuntPolicer(self, policer.policer_index)
1523         ip_punt_policer.add_vpp_config()
1524
1525         self.vapi.cli("clear trace")
1526         self.pg0.add_stream(pkts)
1527         self.pg_enable_capture(self.pg_interfaces)
1528         self.pg_start()
1529
1530         #
1531         # the number of packet received should be greater than 0,
1532         # but not equal to the number sent, since some were policed
1533         #
1534         rx = self.pg1._get_capture(1)
1535         self.assertGreater(len(rx), 0)
1536         self.assertLess(len(rx), len(pkts))
1537
1538         #
1539         # remove the policer. back to full rx
1540         #
1541         ip_punt_policer.remove_vpp_config()
1542         policer.remove_vpp_config()
1543         self.send_and_expect(self.pg0, pkts, self.pg1)
1544
1545         #
1546         # remove the redirect. expect full drop.
1547         #
1548         ip_punt_redirect.remove_vpp_config()
1549         self.send_and_assert_no_replies(self.pg0, pkts,
1550                                         "IP no punt config")
1551
1552         #
1553         # Add a redirect that is not input port selective
1554         #
1555         ip_punt_redirect = VppIpPuntRedirect(self, 0xffffffff,
1556                                              self.pg1.sw_if_index, nh_addr)
1557         ip_punt_redirect.add_vpp_config()
1558         self.send_and_expect(self.pg0, pkts, self.pg1)
1559         ip_punt_redirect.remove_vpp_config()
1560
1561     def test_ip_punt_dump(self):
1562         """ IP4 punt redirect dump"""
1563
1564         #
1565         # Configure a punt redirects
1566         #
1567         nh_address = self.pg3.remote_ip4
1568         ipr_03 = VppIpPuntRedirect(self, self.pg0.sw_if_index,
1569                                    self.pg3.sw_if_index, nh_address)
1570         ipr_13 = VppIpPuntRedirect(self, self.pg1.sw_if_index,
1571                                    self.pg3.sw_if_index, nh_address)
1572         ipr_23 = VppIpPuntRedirect(self, self.pg2.sw_if_index,
1573                                    self.pg3.sw_if_index, "0.0.0.0")
1574         ipr_03.add_vpp_config()
1575         ipr_13.add_vpp_config()
1576         ipr_23.add_vpp_config()
1577
1578         #
1579         # Dump pg0 punt redirects
1580         #
1581         self.assertTrue(ipr_03.query_vpp_config())
1582         self.assertTrue(ipr_13.query_vpp_config())
1583         self.assertTrue(ipr_23.query_vpp_config())
1584
1585         #
1586         # Dump punt redirects for all interfaces
1587         #
1588         punts = self.vapi.ip_punt_redirect_dump(0xffffffff)
1589         self.assertEqual(len(punts), 3)
1590         for p in punts:
1591             self.assertEqual(p.punt.tx_sw_if_index, self.pg3.sw_if_index)
1592         self.assertNotEqual(punts[1].punt.nh, self.pg3.remote_ip4)
1593         self.assertEqual(str(punts[2].punt.nh), '0.0.0.0')
1594
1595
1596 class TestIPDeag(VppTestCase):
1597     """ IPv4 Deaggregate Routes """
1598
1599     @classmethod
1600     def setUpClass(cls):
1601         super(TestIPDeag, cls).setUpClass()
1602
1603     @classmethod
1604     def tearDownClass(cls):
1605         super(TestIPDeag, cls).tearDownClass()
1606
1607     def setUp(self):
1608         super(TestIPDeag, self).setUp()
1609
1610         self.create_pg_interfaces(range(3))
1611
1612         for i in self.pg_interfaces:
1613             i.admin_up()
1614             i.config_ip4()
1615             i.resolve_arp()
1616
1617     def tearDown(self):
1618         super(TestIPDeag, self).tearDown()
1619         for i in self.pg_interfaces:
1620             i.unconfig_ip4()
1621             i.admin_down()
1622
1623     def test_ip_deag(self):
1624         """ IP Deag Routes """
1625
1626         #
1627         # Create a table to be used for:
1628         #  1 - another destination address lookup
1629         #  2 - a source address lookup
1630         #
1631         table_dst = VppIpTable(self, 1)
1632         table_src = VppIpTable(self, 2)
1633         table_dst.add_vpp_config()
1634         table_src.add_vpp_config()
1635
1636         #
1637         # Add a route in the default table to point to a deag/
1638         # second lookup in each of these tables
1639         #
1640         route_to_dst = VppIpRoute(self, "1.1.1.1", 32,
1641                                   [VppRoutePath("0.0.0.0",
1642                                                 0xffffffff,
1643                                                 nh_table_id=1)])
1644         route_to_src = VppIpRoute(
1645             self, "1.1.1.2", 32,
1646             [VppRoutePath("0.0.0.0",
1647                           0xffffffff,
1648                           nh_table_id=2,
1649                           type=FibPathType.FIB_PATH_TYPE_SOURCE_LOOKUP)])
1650         route_to_dst.add_vpp_config()
1651         route_to_src.add_vpp_config()
1652
1653         #
1654         # packets to these destination are dropped, since they'll
1655         # hit the respective default routes in the second table
1656         #
1657         p_dst = (Ether(src=self.pg0.remote_mac,
1658                        dst=self.pg0.local_mac) /
1659                  IP(src="5.5.5.5", dst="1.1.1.1") /
1660                  TCP(sport=1234, dport=1234) /
1661                  Raw(b'\xa5' * 100))
1662         p_src = (Ether(src=self.pg0.remote_mac,
1663                        dst=self.pg0.local_mac) /
1664                  IP(src="2.2.2.2", dst="1.1.1.2") /
1665                  TCP(sport=1234, dport=1234) /
1666                  Raw(b'\xa5' * 100))
1667         pkts_dst = p_dst * 257
1668         pkts_src = p_src * 257
1669
1670         self.send_and_assert_no_replies(self.pg0, pkts_dst,
1671                                         "IP in dst table")
1672         self.send_and_assert_no_replies(self.pg0, pkts_src,
1673                                         "IP in src table")
1674
1675         #
1676         # add a route in the dst table to forward via pg1
1677         #
1678         route_in_dst = VppIpRoute(self, "1.1.1.1", 32,
1679                                   [VppRoutePath(self.pg1.remote_ip4,
1680                                                 self.pg1.sw_if_index)],
1681                                   table_id=1)
1682         route_in_dst.add_vpp_config()
1683
1684         self.send_and_expect(self.pg0, pkts_dst, self.pg1)
1685
1686         #
1687         # add a route in the src table to forward via pg2
1688         #
1689         route_in_src = VppIpRoute(self, "2.2.2.2", 32,
1690                                   [VppRoutePath(self.pg2.remote_ip4,
1691                                                 self.pg2.sw_if_index)],
1692                                   table_id=2)
1693         route_in_src.add_vpp_config()
1694         self.send_and_expect(self.pg0, pkts_src, self.pg2)
1695
1696         #
1697         # loop in the lookup DP
1698         #
1699         route_loop = VppIpRoute(self, "2.2.2.3", 32,
1700                                 [VppRoutePath("0.0.0.0",
1701                                               0xffffffff,
1702                                               nh_table_id=0)])
1703         route_loop.add_vpp_config()
1704
1705         p_l = (Ether(src=self.pg0.remote_mac,
1706                      dst=self.pg0.local_mac) /
1707                IP(src="2.2.2.4", dst="2.2.2.3") /
1708                TCP(sport=1234, dport=1234) /
1709                Raw(b'\xa5' * 100))
1710
1711         self.send_and_assert_no_replies(self.pg0, p_l * 257,
1712                                         "IP lookup loop")
1713
1714
1715 class TestIPInput(VppTestCase):
1716     """ IPv4 Input Exceptions """
1717
1718     @classmethod
1719     def setUpClass(cls):
1720         super(TestIPInput, cls).setUpClass()
1721
1722     @classmethod
1723     def tearDownClass(cls):
1724         super(TestIPInput, cls).tearDownClass()
1725
1726     def setUp(self):
1727         super(TestIPInput, self).setUp()
1728
1729         self.create_pg_interfaces(range(2))
1730
1731         for i in self.pg_interfaces:
1732             i.admin_up()
1733             i.config_ip4()
1734             i.resolve_arp()
1735
1736     def tearDown(self):
1737         super(TestIPInput, self).tearDown()
1738         for i in self.pg_interfaces:
1739             i.unconfig_ip4()
1740             i.admin_down()
1741
1742     def test_ip_input(self):
1743         """ IP Input Exceptions """
1744
1745         # i can't find a way in scapy to construct an IP packet
1746         # with a length less than the IP header length
1747
1748         #
1749         # Packet too short - this is forwarded
1750         #
1751         p_short = (Ether(src=self.pg0.remote_mac,
1752                          dst=self.pg0.local_mac) /
1753                    IP(src=self.pg0.remote_ip4,
1754                       dst=self.pg1.remote_ip4,
1755                       len=40) /
1756                    UDP(sport=1234, dport=1234) /
1757                    Raw(b'\xa5' * 100))
1758
1759         rx = self.send_and_expect(self.pg0, p_short * NUM_PKTS, self.pg1)
1760
1761         #
1762         # Packet too long - this is dropped
1763         #
1764         p_long = (Ether(src=self.pg0.remote_mac,
1765                         dst=self.pg0.local_mac) /
1766                   IP(src=self.pg0.remote_ip4,
1767                      dst=self.pg1.remote_ip4,
1768                      len=400) /
1769                   UDP(sport=1234, dport=1234) /
1770                   Raw(b'\xa5' * 100))
1771
1772         rx = self.send_and_assert_no_replies(self.pg0, p_long * NUM_PKTS,
1773                                              "too long")
1774
1775         #
1776         # bad chksum - this is dropped
1777         #
1778         p_chksum = (Ether(src=self.pg0.remote_mac,
1779                           dst=self.pg0.local_mac) /
1780                     IP(src=self.pg0.remote_ip4,
1781                        dst=self.pg1.remote_ip4,
1782                        chksum=400) /
1783                     UDP(sport=1234, dport=1234) /
1784                     Raw(b'\xa5' * 100))
1785
1786         rx = self.send_and_assert_no_replies(self.pg0, p_chksum * NUM_PKTS,
1787                                              "bad checksum")
1788
1789         #
1790         # bad version - this is dropped
1791         #
1792         p_ver = (Ether(src=self.pg0.remote_mac,
1793                        dst=self.pg0.local_mac) /
1794                  IP(src=self.pg0.remote_ip4,
1795                     dst=self.pg1.remote_ip4,
1796                     version=3) /
1797                  UDP(sport=1234, dport=1234) /
1798                  Raw(b'\xa5' * 100))
1799
1800         rx = self.send_and_assert_no_replies(self.pg0, p_ver * NUM_PKTS,
1801                                              "funky version")
1802
1803         #
1804         # fragment offset 1 - this is dropped
1805         #
1806         p_frag = (Ether(src=self.pg0.remote_mac,
1807                         dst=self.pg0.local_mac) /
1808                   IP(src=self.pg0.remote_ip4,
1809                      dst=self.pg1.remote_ip4,
1810                      frag=1) /
1811                   UDP(sport=1234, dport=1234) /
1812                   Raw(b'\xa5' * 100))
1813
1814         rx = self.send_and_assert_no_replies(self.pg0, p_frag * NUM_PKTS,
1815                                              "frag offset")
1816
1817         #
1818         # TTL expired packet
1819         #
1820         p_ttl = (Ether(src=self.pg0.remote_mac,
1821                        dst=self.pg0.local_mac) /
1822                  IP(src=self.pg0.remote_ip4,
1823                     dst=self.pg1.remote_ip4,
1824                     ttl=1) /
1825                  UDP(sport=1234, dport=1234) /
1826                  Raw(b'\xa5' * 100))
1827
1828         rx = self.send_and_expect(self.pg0, p_ttl * NUM_PKTS, self.pg0)
1829
1830         rx = rx[0]
1831         icmp = rx[ICMP]
1832
1833         self.assertEqual(icmptypes[icmp.type], "time-exceeded")
1834         self.assertEqual(icmpcodes[icmp.type][icmp.code],
1835                          "ttl-zero-during-transit")
1836         self.assertEqual(icmp.src, self.pg0.remote_ip4)
1837         self.assertEqual(icmp.dst, self.pg1.remote_ip4)
1838
1839         #
1840         # MTU exceeded
1841         #
1842         p_mtu = (Ether(src=self.pg0.remote_mac,
1843                        dst=self.pg0.local_mac) /
1844                  IP(src=self.pg0.remote_ip4,
1845                     dst=self.pg1.remote_ip4,
1846                     ttl=10, flags='DF') /
1847                  UDP(sport=1234, dport=1234) /
1848                  Raw(b'\xa5' * 2000))
1849
1850         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1500, 0, 0, 0])
1851
1852         rx = self.send_and_expect(self.pg0, p_mtu * NUM_PKTS, self.pg0)
1853         rx = rx[0]
1854         icmp = rx[ICMP]
1855
1856         self.assertEqual(icmptypes[icmp.type], "dest-unreach")
1857         self.assertEqual(icmpcodes[icmp.type][icmp.code],
1858                          "fragmentation-needed")
1859         self.assertEqual(icmp.src, self.pg0.remote_ip4)
1860         self.assertEqual(icmp.dst, self.pg1.remote_ip4)
1861
1862         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [2500, 0, 0, 0])
1863         rx = self.send_and_expect(self.pg0, p_mtu * NUM_PKTS, self.pg1)
1864
1865         # Reset MTU for subsequent tests
1866         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [9000, 0, 0, 0])
1867
1868         #
1869         # source address 0.0.0.0 and 25.255.255.255 and for-us
1870         #
1871         p_s0 = (Ether(src=self.pg0.remote_mac,
1872                       dst=self.pg0.local_mac) /
1873                 IP(src="0.0.0.0",
1874                    dst=self.pg0.local_ip4) /
1875                 ICMP(id=4, seq=4) /
1876                 Raw(load=b'\x0a' * 18))
1877         rx = self.send_and_assert_no_replies(self.pg0, p_s0 * 17)
1878
1879         p_s0 = (Ether(src=self.pg0.remote_mac,
1880                       dst=self.pg0.local_mac) /
1881                 IP(src="255.255.255.255",
1882                    dst=self.pg0.local_ip4) /
1883                 ICMP(id=4, seq=4) /
1884                 Raw(load=b'\x0a' * 18))
1885         rx = self.send_and_assert_no_replies(self.pg0, p_s0 * 17)
1886
1887
1888 class TestIPDirectedBroadcast(VppTestCase):
1889     """ IPv4 Directed Broadcast """
1890
1891     @classmethod
1892     def setUpClass(cls):
1893         super(TestIPDirectedBroadcast, cls).setUpClass()
1894
1895     @classmethod
1896     def tearDownClass(cls):
1897         super(TestIPDirectedBroadcast, cls).tearDownClass()
1898
1899     def setUp(self):
1900         super(TestIPDirectedBroadcast, self).setUp()
1901
1902         self.create_pg_interfaces(range(2))
1903
1904         for i in self.pg_interfaces:
1905             i.admin_up()
1906
1907     def tearDown(self):
1908         super(TestIPDirectedBroadcast, self).tearDown()
1909         for i in self.pg_interfaces:
1910             i.admin_down()
1911
1912     def test_ip_input(self):
1913         """ IP Directed Broadcast """
1914
1915         #
1916         # set the directed broadcast on pg0 first, then config IP4 addresses
1917         # for pg1 directed broadcast is always disabled
1918         self.vapi.sw_interface_set_ip_directed_broadcast(
1919             self.pg0.sw_if_index, 1)
1920
1921         p0 = (Ether(src=self.pg1.remote_mac,
1922                     dst=self.pg1.local_mac) /
1923               IP(src="1.1.1.1",
1924                  dst=self.pg0._local_ip4_bcast) /
1925               UDP(sport=1234, dport=1234) /
1926               Raw(b'\xa5' * 2000))
1927         p1 = (Ether(src=self.pg0.remote_mac,
1928                     dst=self.pg0.local_mac) /
1929               IP(src="1.1.1.1",
1930                  dst=self.pg1._local_ip4_bcast) /
1931               UDP(sport=1234, dport=1234) /
1932               Raw(b'\xa5' * 2000))
1933
1934         self.pg0.config_ip4()
1935         self.pg0.resolve_arp()
1936         self.pg1.config_ip4()
1937         self.pg1.resolve_arp()
1938
1939         #
1940         # test packet is L2 broadcast
1941         #
1942         rx = self.send_and_expect(self.pg1, p0 * NUM_PKTS, self.pg0)
1943         self.assertTrue(rx[0][Ether].dst, "ff:ff:ff:ff:ff:ff")
1944
1945         self.send_and_assert_no_replies(self.pg0, p1 * NUM_PKTS,
1946                                         "directed broadcast disabled")
1947
1948         #
1949         # toggle directed broadcast on pg0
1950         #
1951         self.vapi.sw_interface_set_ip_directed_broadcast(
1952             self.pg0.sw_if_index, 0)
1953         self.send_and_assert_no_replies(self.pg1, p0 * NUM_PKTS,
1954                                         "directed broadcast disabled")
1955
1956         self.vapi.sw_interface_set_ip_directed_broadcast(
1957             self.pg0.sw_if_index, 1)
1958         rx = self.send_and_expect(self.pg1, p0 * NUM_PKTS, self.pg0)
1959
1960         self.pg0.unconfig_ip4()
1961         self.pg1.unconfig_ip4()
1962
1963
1964 class TestIPLPM(VppTestCase):
1965     """ IPv4 longest Prefix Match """
1966
1967     @classmethod
1968     def setUpClass(cls):
1969         super(TestIPLPM, cls).setUpClass()
1970
1971     @classmethod
1972     def tearDownClass(cls):
1973         super(TestIPLPM, cls).tearDownClass()
1974
1975     def setUp(self):
1976         super(TestIPLPM, self).setUp()
1977
1978         self.create_pg_interfaces(range(4))
1979
1980         for i in self.pg_interfaces:
1981             i.admin_up()
1982             i.config_ip4()
1983             i.resolve_arp()
1984
1985     def tearDown(self):
1986         super(TestIPLPM, self).tearDown()
1987         for i in self.pg_interfaces:
1988             i.admin_down()
1989             i.unconfig_ip4()
1990
1991     def test_ip_lpm(self):
1992         """ IP longest Prefix Match """
1993
1994         s_24 = VppIpRoute(self, "10.1.2.0", 24,
1995                           [VppRoutePath(self.pg1.remote_ip4,
1996                                         self.pg1.sw_if_index)])
1997         s_24.add_vpp_config()
1998         s_8 = VppIpRoute(self, "10.0.0.0", 8,
1999                          [VppRoutePath(self.pg2.remote_ip4,
2000                                        self.pg2.sw_if_index)])
2001         s_8.add_vpp_config()
2002
2003         p_8 = (Ether(src=self.pg0.remote_mac,
2004                      dst=self.pg0.local_mac) /
2005                IP(src="1.1.1.1",
2006                   dst="10.1.1.1") /
2007                UDP(sport=1234, dport=1234) /
2008                Raw(b'\xa5' * 2000))
2009         p_24 = (Ether(src=self.pg0.remote_mac,
2010                       dst=self.pg0.local_mac) /
2011                 IP(src="1.1.1.1",
2012                    dst="10.1.2.1") /
2013                 UDP(sport=1234, dport=1234) /
2014                 Raw(b'\xa5' * 2000))
2015
2016         self.logger.info(self.vapi.cli("sh ip fib mtrie"))
2017         rx = self.send_and_expect(self.pg0, p_8 * NUM_PKTS, self.pg2)
2018         rx = self.send_and_expect(self.pg0, p_24 * NUM_PKTS, self.pg1)
2019
2020
2021 class TestIPv4Frag(VppTestCase):
2022     """ IPv4 fragmentation """
2023
2024     @classmethod
2025     def setUpClass(cls):
2026         super(TestIPv4Frag, cls).setUpClass()
2027
2028         cls.create_pg_interfaces([0, 1])
2029         cls.src_if = cls.pg0
2030         cls.dst_if = cls.pg1
2031
2032         # setup all interfaces
2033         for i in cls.pg_interfaces:
2034             i.admin_up()
2035             i.config_ip4()
2036             i.resolve_arp()
2037
2038     @classmethod
2039     def tearDownClass(cls):
2040         super(TestIPv4Frag, cls).tearDownClass()
2041
2042     def test_frag_large_packets(self):
2043         """ Fragmentation of large packets """
2044
2045         self.vapi.cli("adjacency counters enable")
2046
2047         p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
2048              IP(src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) /
2049              UDP(sport=1234, dport=5678) / Raw())
2050         self.extend_packet(p, 6000, "abcde")
2051         saved_payload = p[Raw].load
2052
2053         nbr = VppNeighbor(self,
2054                           self.dst_if.sw_if_index,
2055                           self.dst_if.remote_mac,
2056                           self.dst_if.remote_ip4).add_vpp_config()
2057
2058         # Force fragmentation by setting MTU of output interface
2059         # lower than packet size
2060         self.vapi.sw_interface_set_mtu(self.dst_if.sw_if_index,
2061                                        [5000, 0, 0, 0])
2062
2063         self.pg_enable_capture()
2064         self.src_if.add_stream(p)
2065         self.pg_start()
2066
2067         # Expecting 3 fragments because size of created fragments currently
2068         # cannot be larger then VPP buffer size (which is 2048)
2069         packets = self.dst_if.get_capture(3)
2070
2071         # we should show 3 packets thru the neighbor
2072         self.assertEqual(3, nbr.get_stats()['packets'])
2073
2074         # Assume VPP sends the fragments in order
2075         payload = b''
2076         for p in packets:
2077             payload_offset = p.frag * 8
2078             if payload_offset > 0:
2079                 payload_offset -= 8  # UDP header is not in payload
2080             self.assert_equal(payload_offset, len(payload))
2081             payload += p[Raw].load
2082         self.assert_equal(payload, saved_payload, "payload")
2083
2084
2085 class TestIPReplace(VppTestCase):
2086     """ IPv4 Table Replace """
2087
2088     @classmethod
2089     def setUpClass(cls):
2090         super(TestIPReplace, cls).setUpClass()
2091
2092     @classmethod
2093     def tearDownClass(cls):
2094         super(TestIPReplace, cls).tearDownClass()
2095
2096     def setUp(self):
2097         super(TestIPReplace, self).setUp()
2098
2099         self.create_pg_interfaces(range(4))
2100
2101         table_id = 1
2102         self.tables = []
2103
2104         for i in self.pg_interfaces:
2105             i.admin_up()
2106             i.config_ip4()
2107             i.resolve_arp()
2108             i.generate_remote_hosts(2)
2109             self.tables.append(VppIpTable(self, table_id).add_vpp_config())
2110             table_id += 1
2111
2112     def tearDown(self):
2113         super(TestIPReplace, self).tearDown()
2114         for i in self.pg_interfaces:
2115             i.admin_down()
2116             i.unconfig_ip4()
2117
2118     def test_replace(self):
2119         """ IP Table Replace """
2120
2121         MRouteItfFlags = VppEnum.vl_api_mfib_itf_flags_t
2122         MRouteEntryFlags = VppEnum.vl_api_mfib_entry_flags_t
2123         N_ROUTES = 20
2124         links = [self.pg0, self.pg1, self.pg2, self.pg3]
2125         routes = [[], [], [], []]
2126
2127         # load up the tables with some routes
2128         for ii, t in enumerate(self.tables):
2129             for jj in range(N_ROUTES):
2130                 uni = VppIpRoute(
2131                     self, "10.0.0.%d" % jj, 32,
2132                     [VppRoutePath(links[ii].remote_hosts[0].ip4,
2133                                   links[ii].sw_if_index),
2134                      VppRoutePath(links[ii].remote_hosts[1].ip4,
2135                                   links[ii].sw_if_index)],
2136                     table_id=t.table_id).add_vpp_config()
2137                 multi = VppIpMRoute(
2138                     self, "0.0.0.0",
2139                     "239.0.0.%d" % jj, 32,
2140                     MRouteEntryFlags.MFIB_API_ENTRY_FLAG_NONE,
2141                     [VppMRoutePath(self.pg0.sw_if_index,
2142                                    MRouteItfFlags.MFIB_API_ITF_FLAG_ACCEPT),
2143                      VppMRoutePath(self.pg1.sw_if_index,
2144                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD),
2145                      VppMRoutePath(self.pg2.sw_if_index,
2146                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD),
2147                      VppMRoutePath(self.pg3.sw_if_index,
2148                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD)],
2149                     table_id=t.table_id).add_vpp_config()
2150                 routes[ii].append({'uni': uni,
2151                                    'multi': multi})
2152
2153         #
2154         # replace the tables a few times
2155         #
2156         for kk in range(3):
2157             # replace_begin each table
2158             for t in self.tables:
2159                 t.replace_begin()
2160
2161             # all the routes are still there
2162             for ii, t in enumerate(self.tables):
2163                 dump = t.dump()
2164                 mdump = t.mdump()
2165                 for r in routes[ii]:
2166                     self.assertTrue(find_route_in_dump(dump, r['uni'], t))
2167                     self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t))
2168
2169             # redownload the even numbered routes
2170             for ii, t in enumerate(self.tables):
2171                 for jj in range(0, N_ROUTES, 2):
2172                     routes[ii][jj]['uni'].add_vpp_config()
2173                     routes[ii][jj]['multi'].add_vpp_config()
2174
2175             # signal each table replace_end
2176             for t in self.tables:
2177                 t.replace_end()
2178
2179             # we should find the even routes, but not the odd
2180             for ii, t in enumerate(self.tables):
2181                 dump = t.dump()
2182                 mdump = t.mdump()
2183                 for jj in range(0, N_ROUTES, 2):
2184                     self.assertTrue(find_route_in_dump(
2185                         dump, routes[ii][jj]['uni'], t))
2186                     self.assertTrue(find_mroute_in_dump(
2187                         mdump, routes[ii][jj]['multi'], t))
2188                 for jj in range(1, N_ROUTES - 1, 2):
2189                     self.assertFalse(find_route_in_dump(
2190                         dump, routes[ii][jj]['uni'], t))
2191                     self.assertFalse(find_mroute_in_dump(
2192                         mdump, routes[ii][jj]['multi'], t))
2193
2194             # reload all the routes
2195             for ii, t in enumerate(self.tables):
2196                 for r in routes[ii]:
2197                     r['uni'].add_vpp_config()
2198                     r['multi'].add_vpp_config()
2199
2200             # all the routes are still there
2201             for ii, t in enumerate(self.tables):
2202                 dump = t.dump()
2203                 mdump = t.mdump()
2204                 for r in routes[ii]:
2205                     self.assertTrue(find_route_in_dump(dump, r['uni'], t))
2206                     self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t))
2207
2208         #
2209         # finally flush the tables for good measure
2210         #
2211         for t in self.tables:
2212             t.flush()
2213             self.assertEqual(len(t.dump()), 5)
2214             self.assertEqual(len(t.mdump()), 3)
2215
2216
2217 class TestIPCover(VppTestCase):
2218     """ IPv4 Table Cover """
2219
2220     @classmethod
2221     def setUpClass(cls):
2222         super(TestIPCover, cls).setUpClass()
2223
2224     @classmethod
2225     def tearDownClass(cls):
2226         super(TestIPCover, cls).tearDownClass()
2227
2228     def setUp(self):
2229         super(TestIPCover, self).setUp()
2230
2231         self.create_pg_interfaces(range(4))
2232
2233         table_id = 1
2234         self.tables = []
2235
2236         for i in self.pg_interfaces:
2237             i.admin_up()
2238             i.config_ip4()
2239             i.resolve_arp()
2240             i.generate_remote_hosts(2)
2241             self.tables.append(VppIpTable(self, table_id).add_vpp_config())
2242             table_id += 1
2243
2244     def tearDown(self):
2245         super(TestIPCover, self).tearDown()
2246         for i in self.pg_interfaces:
2247             i.admin_down()
2248             i.unconfig_ip4()
2249
2250     def test_cover(self):
2251         """ IP Table Cover """
2252
2253         # add a loop back with a /32 prefix
2254         lo = VppLoInterface(self)
2255         lo.admin_up()
2256         a = VppIpInterfaceAddress(self, lo, "127.0.0.1", 32).add_vpp_config()
2257
2258         # add a neighbour that matches the loopback's /32
2259         nbr = VppNeighbor(self,
2260                           lo.sw_if_index,
2261                           lo.remote_mac,
2262                           "127.0.0.1").add_vpp_config()
2263
2264         # add the default route which will be the cover for /32
2265         r = VppIpRoute(self, "0.0.0.0", 0,
2266                        [VppRoutePath("127.0.0.1",
2267                                      lo.sw_if_index)],
2268                        register=False).add_vpp_config()
2269
2270         # add/remove/add a longer mask cover
2271         r8 = VppIpRoute(self, "127.0.0.0", 8,
2272                         [VppRoutePath("127.0.0.1",
2273                                       lo.sw_if_index)]).add_vpp_config()
2274         r8.remove_vpp_config()
2275         r8.add_vpp_config()
2276         r8.remove_vpp_config()
2277
2278         # remove the default route
2279         r.remove_vpp_config()
2280
2281         # remove the interface prefix
2282         a.remove_vpp_config()
2283
2284
2285 class TestIP4Replace(VppTestCase):
2286     """ IPv4 Interface Address Replace """
2287
2288     @classmethod
2289     def setUpClass(cls):
2290         super(TestIP4Replace, cls).setUpClass()
2291
2292     @classmethod
2293     def tearDownClass(cls):
2294         super(TestIP4Replace, cls).tearDownClass()
2295
2296     def setUp(self):
2297         super(TestIP4Replace, self).setUp()
2298
2299         self.create_pg_interfaces(range(4))
2300
2301         for i in self.pg_interfaces:
2302             i.admin_up()
2303
2304     def tearDown(self):
2305         super(TestIP4Replace, self).tearDown()
2306         for i in self.pg_interfaces:
2307             i.admin_down()
2308
2309     def get_n_pfxs(self, intf):
2310         return len(self.vapi.ip_address_dump(intf.sw_if_index))
2311
2312     def test_replace(self):
2313         """ IP interface address replace """
2314
2315         intf_pfxs = [[], [], [], []]
2316
2317         # add prefixes to each of the interfaces
2318         for i in range(len(self.pg_interfaces)):
2319             intf = self.pg_interfaces[i]
2320
2321             # 172.16.x.1/24
2322             addr = "172.16.%d.1" % intf.sw_if_index
2323             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2324             intf_pfxs[i].append(a)
2325
2326             # 172.16.x.2/24 - a different address in the same subnet as above
2327             addr = "172.16.%d.2" % intf.sw_if_index
2328             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2329             intf_pfxs[i].append(a)
2330
2331             # 172.15.x.2/24 - a different address and subnet
2332             addr = "172.15.%d.2" % intf.sw_if_index
2333             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2334             intf_pfxs[i].append(a)
2335
2336         # a dump should n_address in it
2337         for intf in self.pg_interfaces:
2338             self.assertEqual(self.get_n_pfxs(intf), 3)
2339
2340         #
2341         # remove all the address thru a replace
2342         #
2343         self.vapi.sw_interface_address_replace_begin()
2344         self.vapi.sw_interface_address_replace_end()
2345         for intf in self.pg_interfaces:
2346             self.assertEqual(self.get_n_pfxs(intf), 0)
2347
2348         #
2349         # add all the interface addresses back
2350         #
2351         for p in intf_pfxs:
2352             for v in p:
2353                 v.add_vpp_config()
2354         for intf in self.pg_interfaces:
2355             self.assertEqual(self.get_n_pfxs(intf), 3)
2356
2357         #
2358         # replace again, but this time update/re-add the address on the first
2359         # two interfaces
2360         #
2361         self.vapi.sw_interface_address_replace_begin()
2362
2363         for p in intf_pfxs[:2]:
2364             for v in p:
2365                 v.add_vpp_config()
2366
2367         self.vapi.sw_interface_address_replace_end()
2368
2369         # on the first two the address still exist,
2370         # on the other two they do not
2371         for intf in self.pg_interfaces[:2]:
2372             self.assertEqual(self.get_n_pfxs(intf), 3)
2373         for p in intf_pfxs[:2]:
2374             for v in p:
2375                 self.assertTrue(v.query_vpp_config())
2376         for intf in self.pg_interfaces[2:]:
2377             self.assertEqual(self.get_n_pfxs(intf), 0)
2378
2379         #
2380         # add all the interface addresses back on the last two
2381         #
2382         for p in intf_pfxs[2:]:
2383             for v in p:
2384                 v.add_vpp_config()
2385         for intf in self.pg_interfaces:
2386             self.assertEqual(self.get_n_pfxs(intf), 3)
2387
2388         #
2389         # replace again, this time add different prefixes on all the interfaces
2390         #
2391         self.vapi.sw_interface_address_replace_begin()
2392
2393         pfxs = []
2394         for intf in self.pg_interfaces:
2395             # 172.18.x.1/24
2396             addr = "172.18.%d.1" % intf.sw_if_index
2397             pfxs.append(VppIpInterfaceAddress(self, intf, addr,
2398                                               24).add_vpp_config())
2399
2400         self.vapi.sw_interface_address_replace_end()
2401
2402         # only .18 should exist on each interface
2403         for intf in self.pg_interfaces:
2404             self.assertEqual(self.get_n_pfxs(intf), 1)
2405         for pfx in pfxs:
2406             self.assertTrue(pfx.query_vpp_config())
2407
2408         #
2409         # remove everything
2410         #
2411         self.vapi.sw_interface_address_replace_begin()
2412         self.vapi.sw_interface_address_replace_end()
2413         for intf in self.pg_interfaces:
2414             self.assertEqual(self.get_n_pfxs(intf), 0)
2415
2416         #
2417         # add prefixes to each interface. post-begin add the prefix from
2418         # interface X onto interface Y. this would normally be an error
2419         # since it would generate a 'duplicate address' warning. but in
2420         # this case, since what is newly downloaded is sane, it's ok
2421         #
2422         for intf in self.pg_interfaces:
2423             # 172.18.x.1/24
2424             addr = "172.18.%d.1" % intf.sw_if_index
2425             VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2426
2427         self.vapi.sw_interface_address_replace_begin()
2428
2429         pfxs = []
2430         for intf in self.pg_interfaces:
2431             # 172.18.x.1/24
2432             addr = "172.18.%d.1" % (intf.sw_if_index + 1)
2433             pfxs.append(VppIpInterfaceAddress(self, intf,
2434                                               addr, 24).add_vpp_config())
2435
2436         self.vapi.sw_interface_address_replace_end()
2437
2438         self.logger.info(self.vapi.cli("sh int addr"))
2439
2440         for intf in self.pg_interfaces:
2441             self.assertEqual(self.get_n_pfxs(intf), 1)
2442         for pfx in pfxs:
2443             self.assertTrue(pfx.query_vpp_config())
2444
2445
2446 if __name__ == '__main__':
2447     unittest.main(testRunner=VppTestRunner)