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, PolicerAction
  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 IPPuntSetup(object):
1452     """ Setup for IPv4 Punt Police/Redirect """
1453
1454     def punt_setup(self):
1455         self.create_pg_interfaces(range(4))
1456
1457         for i in self.pg_interfaces:
1458             i.admin_up()
1459             i.config_ip4()
1460             i.resolve_arp()
1461
1462         # use UDP packet that have a port we need to explicitly
1463         # register to get punted.
1464         pt_l4 = VppEnum.vl_api_punt_type_t.PUNT_API_TYPE_L4
1465         af_ip4 = VppEnum.vl_api_address_family_t.ADDRESS_IP4
1466         udp_proto = VppEnum.vl_api_ip_proto_t.IP_API_PROTO_UDP
1467         punt_udp = {
1468             'type': pt_l4,
1469             'punt': {
1470                 'l4': {
1471                     'af': af_ip4,
1472                     'protocol': udp_proto,
1473                     'port': 1234,
1474                 }
1475             }
1476         }
1477
1478         self.vapi.set_punt(is_add=1, punt=punt_udp)
1479
1480         self.pkt = (Ether(src=self.pg0.remote_mac,
1481                           dst=self.pg0.local_mac) /
1482                     IP(src=self.pg0.remote_ip4, dst=self.pg0.local_ip4) /
1483                     UDP(sport=1234, dport=1234) /
1484                     Raw(b'\xa5' * 100))
1485
1486     def punt_teardown(self):
1487         for i in self.pg_interfaces:
1488             i.unconfig_ip4()
1489             i.admin_down()
1490
1491
1492 class TestIPPunt(IPPuntSetup, VppTestCase):
1493     """ IPv4 Punt Police/Redirect """
1494
1495     def setUp(self):
1496         super(TestIPPunt, self).setUp()
1497         super(TestIPPunt, self).punt_setup()
1498
1499     def tearDown(self):
1500         super(TestIPPunt, self).punt_teardown()
1501         super(TestIPPunt, self).tearDown()
1502
1503     def test_ip_punt(self):
1504         """ IP punt police and redirect """
1505
1506         pkts = self.pkt * 1025
1507
1508         #
1509         # Configure a punt redirect via pg1.
1510         #
1511         nh_addr = self.pg1.remote_ip4
1512         ip_punt_redirect = VppIpPuntRedirect(self, self.pg0.sw_if_index,
1513                                              self.pg1.sw_if_index, nh_addr)
1514         ip_punt_redirect.add_vpp_config()
1515
1516         self.send_and_expect(self.pg0, pkts, self.pg1)
1517
1518         #
1519         # add a policer
1520         #
1521         policer = VppPolicer(self, "ip4-punt", 400, 0, 10, 0, rate_type=1)
1522         policer.add_vpp_config()
1523         ip_punt_policer = VppIpPuntPolicer(self, policer.policer_index)
1524         ip_punt_policer.add_vpp_config()
1525
1526         self.vapi.cli("clear trace")
1527         self.pg0.add_stream(pkts)
1528         self.pg_enable_capture(self.pg_interfaces)
1529         self.pg_start()
1530
1531         #
1532         # the number of packet received should be greater than 0,
1533         # but not equal to the number sent, since some were policed
1534         #
1535         rx = self.pg1._get_capture(1)
1536         self.assertGreater(len(rx), 0)
1537         self.assertLess(len(rx), len(pkts))
1538
1539         #
1540         # remove the policer. back to full rx
1541         #
1542         ip_punt_policer.remove_vpp_config()
1543         policer.remove_vpp_config()
1544         self.send_and_expect(self.pg0, pkts, self.pg1)
1545
1546         #
1547         # remove the redirect. expect full drop.
1548         #
1549         ip_punt_redirect.remove_vpp_config()
1550         self.send_and_assert_no_replies(self.pg0, pkts,
1551                                         "IP no punt config")
1552
1553         #
1554         # Add a redirect that is not input port selective
1555         #
1556         ip_punt_redirect = VppIpPuntRedirect(self, 0xffffffff,
1557                                              self.pg1.sw_if_index, nh_addr)
1558         ip_punt_redirect.add_vpp_config()
1559         self.send_and_expect(self.pg0, pkts, self.pg1)
1560         ip_punt_redirect.remove_vpp_config()
1561
1562     def test_ip_punt_dump(self):
1563         """ IP4 punt redirect dump"""
1564
1565         #
1566         # Configure a punt redirects
1567         #
1568         nh_address = self.pg3.remote_ip4
1569         ipr_03 = VppIpPuntRedirect(self, self.pg0.sw_if_index,
1570                                    self.pg3.sw_if_index, nh_address)
1571         ipr_13 = VppIpPuntRedirect(self, self.pg1.sw_if_index,
1572                                    self.pg3.sw_if_index, nh_address)
1573         ipr_23 = VppIpPuntRedirect(self, self.pg2.sw_if_index,
1574                                    self.pg3.sw_if_index, "0.0.0.0")
1575         ipr_03.add_vpp_config()
1576         ipr_13.add_vpp_config()
1577         ipr_23.add_vpp_config()
1578
1579         #
1580         # Dump pg0 punt redirects
1581         #
1582         self.assertTrue(ipr_03.query_vpp_config())
1583         self.assertTrue(ipr_13.query_vpp_config())
1584         self.assertTrue(ipr_23.query_vpp_config())
1585
1586         #
1587         # Dump punt redirects for all interfaces
1588         #
1589         punts = self.vapi.ip_punt_redirect_dump(0xffffffff)
1590         self.assertEqual(len(punts), 3)
1591         for p in punts:
1592             self.assertEqual(p.punt.tx_sw_if_index, self.pg3.sw_if_index)
1593         self.assertNotEqual(punts[1].punt.nh, self.pg3.remote_ip4)
1594         self.assertEqual(str(punts[2].punt.nh), '0.0.0.0')
1595
1596
1597 class TestIPPuntHandoff(IPPuntSetup, VppTestCase):
1598     """ IPv4 Punt Policer thread handoff """
1599     worker_config = "workers 2"
1600
1601     def setUp(self):
1602         super(TestIPPuntHandoff, self).setUp()
1603         super(TestIPPuntHandoff, self).punt_setup()
1604
1605     def tearDown(self):
1606         super(TestIPPuntHandoff, self).punt_teardown()
1607         super(TestIPPuntHandoff, self).tearDown()
1608
1609     def test_ip_punt_policer_handoff(self):
1610         """ IP4 punt policer thread handoff """
1611         pkts = self.pkt * NUM_PKTS
1612
1613         #
1614         # Configure a punt redirect via pg1.
1615         #
1616         nh_addr = self.pg1.remote_ip4
1617         ip_punt_redirect = VppIpPuntRedirect(self, self.pg0.sw_if_index,
1618                                              self.pg1.sw_if_index, nh_addr)
1619         ip_punt_redirect.add_vpp_config()
1620
1621         action_tx = PolicerAction(
1622             VppEnum.vl_api_sse2_qos_action_type_t.SSE2_QOS_ACTION_API_TRANSMIT,
1623             0)
1624         #
1625         # This policer drops no packets, we are just
1626         # testing that they get to the right thread.
1627         #
1628         policer = VppPolicer(self, "ip4-punt", 400, 0, 10, 0, 1,
1629                              0, 0, False, action_tx, action_tx, action_tx)
1630         policer.add_vpp_config()
1631         ip_punt_policer = VppIpPuntPolicer(self, policer.policer_index)
1632         ip_punt_policer.add_vpp_config()
1633
1634         for worker in [0, 1]:
1635             self.send_and_expect(self.pg0, pkts, self.pg1, worker=worker)
1636             if worker == 0:
1637                 self.logger.debug(self.vapi.cli("show trace max 100"))
1638
1639         #
1640         # Clean up
1641         #
1642         ip_punt_policer.remove_vpp_config()
1643         policer.remove_vpp_config()
1644         ip_punt_redirect.remove_vpp_config()
1645
1646
1647 class TestIPDeag(VppTestCase):
1648     """ IPv4 Deaggregate Routes """
1649
1650     @classmethod
1651     def setUpClass(cls):
1652         super(TestIPDeag, cls).setUpClass()
1653
1654     @classmethod
1655     def tearDownClass(cls):
1656         super(TestIPDeag, cls).tearDownClass()
1657
1658     def setUp(self):
1659         super(TestIPDeag, self).setUp()
1660
1661         self.create_pg_interfaces(range(3))
1662
1663         for i in self.pg_interfaces:
1664             i.admin_up()
1665             i.config_ip4()
1666             i.resolve_arp()
1667
1668     def tearDown(self):
1669         super(TestIPDeag, self).tearDown()
1670         for i in self.pg_interfaces:
1671             i.unconfig_ip4()
1672             i.admin_down()
1673
1674     def test_ip_deag(self):
1675         """ IP Deag Routes """
1676
1677         #
1678         # Create a table to be used for:
1679         #  1 - another destination address lookup
1680         #  2 - a source address lookup
1681         #
1682         table_dst = VppIpTable(self, 1)
1683         table_src = VppIpTable(self, 2)
1684         table_dst.add_vpp_config()
1685         table_src.add_vpp_config()
1686
1687         #
1688         # Add a route in the default table to point to a deag/
1689         # second lookup in each of these tables
1690         #
1691         route_to_dst = VppIpRoute(self, "1.1.1.1", 32,
1692                                   [VppRoutePath("0.0.0.0",
1693                                                 0xffffffff,
1694                                                 nh_table_id=1)])
1695         route_to_src = VppIpRoute(
1696             self, "1.1.1.2", 32,
1697             [VppRoutePath("0.0.0.0",
1698                           0xffffffff,
1699                           nh_table_id=2,
1700                           type=FibPathType.FIB_PATH_TYPE_SOURCE_LOOKUP)])
1701         route_to_dst.add_vpp_config()
1702         route_to_src.add_vpp_config()
1703
1704         #
1705         # packets to these destination are dropped, since they'll
1706         # hit the respective default routes in the second table
1707         #
1708         p_dst = (Ether(src=self.pg0.remote_mac,
1709                        dst=self.pg0.local_mac) /
1710                  IP(src="5.5.5.5", dst="1.1.1.1") /
1711                  TCP(sport=1234, dport=1234) /
1712                  Raw(b'\xa5' * 100))
1713         p_src = (Ether(src=self.pg0.remote_mac,
1714                        dst=self.pg0.local_mac) /
1715                  IP(src="2.2.2.2", dst="1.1.1.2") /
1716                  TCP(sport=1234, dport=1234) /
1717                  Raw(b'\xa5' * 100))
1718         pkts_dst = p_dst * 257
1719         pkts_src = p_src * 257
1720
1721         self.send_and_assert_no_replies(self.pg0, pkts_dst,
1722                                         "IP in dst table")
1723         self.send_and_assert_no_replies(self.pg0, pkts_src,
1724                                         "IP in src table")
1725
1726         #
1727         # add a route in the dst table to forward via pg1
1728         #
1729         route_in_dst = VppIpRoute(self, "1.1.1.1", 32,
1730                                   [VppRoutePath(self.pg1.remote_ip4,
1731                                                 self.pg1.sw_if_index)],
1732                                   table_id=1)
1733         route_in_dst.add_vpp_config()
1734
1735         self.send_and_expect(self.pg0, pkts_dst, self.pg1)
1736
1737         #
1738         # add a route in the src table to forward via pg2
1739         #
1740         route_in_src = VppIpRoute(self, "2.2.2.2", 32,
1741                                   [VppRoutePath(self.pg2.remote_ip4,
1742                                                 self.pg2.sw_if_index)],
1743                                   table_id=2)
1744         route_in_src.add_vpp_config()
1745         self.send_and_expect(self.pg0, pkts_src, self.pg2)
1746
1747         #
1748         # loop in the lookup DP
1749         #
1750         route_loop = VppIpRoute(self, "2.2.2.3", 32,
1751                                 [VppRoutePath("0.0.0.0",
1752                                               0xffffffff,
1753                                               nh_table_id=0)])
1754         route_loop.add_vpp_config()
1755
1756         p_l = (Ether(src=self.pg0.remote_mac,
1757                      dst=self.pg0.local_mac) /
1758                IP(src="2.2.2.4", dst="2.2.2.3") /
1759                TCP(sport=1234, dport=1234) /
1760                Raw(b'\xa5' * 100))
1761
1762         self.send_and_assert_no_replies(self.pg0, p_l * 257,
1763                                         "IP lookup loop")
1764
1765
1766 class TestIPInput(VppTestCase):
1767     """ IPv4 Input Exceptions """
1768
1769     @classmethod
1770     def setUpClass(cls):
1771         super(TestIPInput, cls).setUpClass()
1772
1773     @classmethod
1774     def tearDownClass(cls):
1775         super(TestIPInput, cls).tearDownClass()
1776
1777     def setUp(self):
1778         super(TestIPInput, self).setUp()
1779
1780         self.create_pg_interfaces(range(2))
1781
1782         for i in self.pg_interfaces:
1783             i.admin_up()
1784             i.config_ip4()
1785             i.resolve_arp()
1786
1787     def tearDown(self):
1788         super(TestIPInput, self).tearDown()
1789         for i in self.pg_interfaces:
1790             i.unconfig_ip4()
1791             i.admin_down()
1792
1793     def test_ip_input(self):
1794         """ IP Input Exceptions """
1795
1796         # i can't find a way in scapy to construct an IP packet
1797         # with a length less than the IP header length
1798
1799         #
1800         # Packet too short - this is forwarded
1801         #
1802         p_short = (Ether(src=self.pg0.remote_mac,
1803                          dst=self.pg0.local_mac) /
1804                    IP(src=self.pg0.remote_ip4,
1805                       dst=self.pg1.remote_ip4,
1806                       len=40) /
1807                    UDP(sport=1234, dport=1234) /
1808                    Raw(b'\xa5' * 100))
1809
1810         rx = self.send_and_expect(self.pg0, p_short * NUM_PKTS, self.pg1)
1811
1812         #
1813         # Packet too long - this is dropped
1814         #
1815         p_long = (Ether(src=self.pg0.remote_mac,
1816                         dst=self.pg0.local_mac) /
1817                   IP(src=self.pg0.remote_ip4,
1818                      dst=self.pg1.remote_ip4,
1819                      len=400) /
1820                   UDP(sport=1234, dport=1234) /
1821                   Raw(b'\xa5' * 100))
1822
1823         rx = self.send_and_assert_no_replies(self.pg0, p_long * NUM_PKTS,
1824                                              "too long")
1825
1826         #
1827         # bad chksum - this is dropped
1828         #
1829         p_chksum = (Ether(src=self.pg0.remote_mac,
1830                           dst=self.pg0.local_mac) /
1831                     IP(src=self.pg0.remote_ip4,
1832                        dst=self.pg1.remote_ip4,
1833                        chksum=400) /
1834                     UDP(sport=1234, dport=1234) /
1835                     Raw(b'\xa5' * 100))
1836
1837         rx = self.send_and_assert_no_replies(self.pg0, p_chksum * NUM_PKTS,
1838                                              "bad checksum")
1839
1840         #
1841         # bad version - this is dropped
1842         #
1843         p_ver = (Ether(src=self.pg0.remote_mac,
1844                        dst=self.pg0.local_mac) /
1845                  IP(src=self.pg0.remote_ip4,
1846                     dst=self.pg1.remote_ip4,
1847                     version=3) /
1848                  UDP(sport=1234, dport=1234) /
1849                  Raw(b'\xa5' * 100))
1850
1851         rx = self.send_and_assert_no_replies(self.pg0, p_ver * NUM_PKTS,
1852                                              "funky version")
1853
1854         #
1855         # fragment offset 1 - this is dropped
1856         #
1857         p_frag = (Ether(src=self.pg0.remote_mac,
1858                         dst=self.pg0.local_mac) /
1859                   IP(src=self.pg0.remote_ip4,
1860                      dst=self.pg1.remote_ip4,
1861                      frag=1) /
1862                   UDP(sport=1234, dport=1234) /
1863                   Raw(b'\xa5' * 100))
1864
1865         rx = self.send_and_assert_no_replies(self.pg0, p_frag * NUM_PKTS,
1866                                              "frag offset")
1867
1868         #
1869         # TTL expired packet
1870         #
1871         p_ttl = (Ether(src=self.pg0.remote_mac,
1872                        dst=self.pg0.local_mac) /
1873                  IP(src=self.pg0.remote_ip4,
1874                     dst=self.pg1.remote_ip4,
1875                     ttl=1) /
1876                  UDP(sport=1234, dport=1234) /
1877                  Raw(b'\xa5' * 100))
1878
1879         rx = self.send_and_expect(self.pg0, p_ttl * NUM_PKTS, self.pg0)
1880
1881         rx = rx[0]
1882         icmp = rx[ICMP]
1883
1884         self.assertEqual(icmptypes[icmp.type], "time-exceeded")
1885         self.assertEqual(icmpcodes[icmp.type][icmp.code],
1886                          "ttl-zero-during-transit")
1887         self.assertEqual(icmp.src, self.pg0.remote_ip4)
1888         self.assertEqual(icmp.dst, self.pg1.remote_ip4)
1889
1890         #
1891         # MTU exceeded
1892         #
1893         p_mtu = (Ether(src=self.pg0.remote_mac,
1894                        dst=self.pg0.local_mac) /
1895                  IP(src=self.pg0.remote_ip4,
1896                     dst=self.pg1.remote_ip4,
1897                     ttl=10, flags='DF') /
1898                  UDP(sport=1234, dport=1234) /
1899                  Raw(b'\xa5' * 2000))
1900
1901         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [1500, 0, 0, 0])
1902
1903         rx = self.send_and_expect(self.pg0, p_mtu * NUM_PKTS, self.pg0)
1904         rx = rx[0]
1905         icmp = rx[ICMP]
1906
1907         self.assertEqual(icmptypes[icmp.type], "dest-unreach")
1908         self.assertEqual(icmpcodes[icmp.type][icmp.code],
1909                          "fragmentation-needed")
1910         self.assertEqual(icmp.src, self.pg0.remote_ip4)
1911         self.assertEqual(icmp.dst, self.pg1.remote_ip4)
1912
1913         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [2500, 0, 0, 0])
1914         rx = self.send_and_expect(self.pg0, p_mtu * NUM_PKTS, self.pg1)
1915
1916         # Reset MTU for subsequent tests
1917         self.vapi.sw_interface_set_mtu(self.pg1.sw_if_index, [9000, 0, 0, 0])
1918
1919         #
1920         # source address 0.0.0.0 and 25.255.255.255 and for-us
1921         #
1922         p_s0 = (Ether(src=self.pg0.remote_mac,
1923                       dst=self.pg0.local_mac) /
1924                 IP(src="0.0.0.0",
1925                    dst=self.pg0.local_ip4) /
1926                 ICMP(id=4, seq=4) /
1927                 Raw(load=b'\x0a' * 18))
1928         rx = self.send_and_assert_no_replies(self.pg0, p_s0 * 17)
1929
1930         p_s0 = (Ether(src=self.pg0.remote_mac,
1931                       dst=self.pg0.local_mac) /
1932                 IP(src="255.255.255.255",
1933                    dst=self.pg0.local_ip4) /
1934                 ICMP(id=4, seq=4) /
1935                 Raw(load=b'\x0a' * 18))
1936         rx = self.send_and_assert_no_replies(self.pg0, p_s0 * 17)
1937
1938
1939 class TestIPDirectedBroadcast(VppTestCase):
1940     """ IPv4 Directed Broadcast """
1941
1942     @classmethod
1943     def setUpClass(cls):
1944         super(TestIPDirectedBroadcast, cls).setUpClass()
1945
1946     @classmethod
1947     def tearDownClass(cls):
1948         super(TestIPDirectedBroadcast, cls).tearDownClass()
1949
1950     def setUp(self):
1951         super(TestIPDirectedBroadcast, self).setUp()
1952
1953         self.create_pg_interfaces(range(2))
1954
1955         for i in self.pg_interfaces:
1956             i.admin_up()
1957
1958     def tearDown(self):
1959         super(TestIPDirectedBroadcast, self).tearDown()
1960         for i in self.pg_interfaces:
1961             i.admin_down()
1962
1963     def test_ip_input(self):
1964         """ IP Directed Broadcast """
1965
1966         #
1967         # set the directed broadcast on pg0 first, then config IP4 addresses
1968         # for pg1 directed broadcast is always disabled
1969         self.vapi.sw_interface_set_ip_directed_broadcast(
1970             self.pg0.sw_if_index, 1)
1971
1972         p0 = (Ether(src=self.pg1.remote_mac,
1973                     dst=self.pg1.local_mac) /
1974               IP(src="1.1.1.1",
1975                  dst=self.pg0._local_ip4_bcast) /
1976               UDP(sport=1234, dport=1234) /
1977               Raw(b'\xa5' * 2000))
1978         p1 = (Ether(src=self.pg0.remote_mac,
1979                     dst=self.pg0.local_mac) /
1980               IP(src="1.1.1.1",
1981                  dst=self.pg1._local_ip4_bcast) /
1982               UDP(sport=1234, dport=1234) /
1983               Raw(b'\xa5' * 2000))
1984
1985         self.pg0.config_ip4()
1986         self.pg0.resolve_arp()
1987         self.pg1.config_ip4()
1988         self.pg1.resolve_arp()
1989
1990         #
1991         # test packet is L2 broadcast
1992         #
1993         rx = self.send_and_expect(self.pg1, p0 * NUM_PKTS, self.pg0)
1994         self.assertTrue(rx[0][Ether].dst, "ff:ff:ff:ff:ff:ff")
1995
1996         self.send_and_assert_no_replies(self.pg0, p1 * NUM_PKTS,
1997                                         "directed broadcast disabled")
1998
1999         #
2000         # toggle directed broadcast on pg0
2001         #
2002         self.vapi.sw_interface_set_ip_directed_broadcast(
2003             self.pg0.sw_if_index, 0)
2004         self.send_and_assert_no_replies(self.pg1, p0 * NUM_PKTS,
2005                                         "directed broadcast disabled")
2006
2007         self.vapi.sw_interface_set_ip_directed_broadcast(
2008             self.pg0.sw_if_index, 1)
2009         rx = self.send_and_expect(self.pg1, p0 * NUM_PKTS, self.pg0)
2010
2011         self.pg0.unconfig_ip4()
2012         self.pg1.unconfig_ip4()
2013
2014
2015 class TestIPLPM(VppTestCase):
2016     """ IPv4 longest Prefix Match """
2017
2018     @classmethod
2019     def setUpClass(cls):
2020         super(TestIPLPM, cls).setUpClass()
2021
2022     @classmethod
2023     def tearDownClass(cls):
2024         super(TestIPLPM, cls).tearDownClass()
2025
2026     def setUp(self):
2027         super(TestIPLPM, self).setUp()
2028
2029         self.create_pg_interfaces(range(4))
2030
2031         for i in self.pg_interfaces:
2032             i.admin_up()
2033             i.config_ip4()
2034             i.resolve_arp()
2035
2036     def tearDown(self):
2037         super(TestIPLPM, self).tearDown()
2038         for i in self.pg_interfaces:
2039             i.admin_down()
2040             i.unconfig_ip4()
2041
2042     def test_ip_lpm(self):
2043         """ IP longest Prefix Match """
2044
2045         s_24 = VppIpRoute(self, "10.1.2.0", 24,
2046                           [VppRoutePath(self.pg1.remote_ip4,
2047                                         self.pg1.sw_if_index)])
2048         s_24.add_vpp_config()
2049         s_8 = VppIpRoute(self, "10.0.0.0", 8,
2050                          [VppRoutePath(self.pg2.remote_ip4,
2051                                        self.pg2.sw_if_index)])
2052         s_8.add_vpp_config()
2053
2054         p_8 = (Ether(src=self.pg0.remote_mac,
2055                      dst=self.pg0.local_mac) /
2056                IP(src="1.1.1.1",
2057                   dst="10.1.1.1") /
2058                UDP(sport=1234, dport=1234) /
2059                Raw(b'\xa5' * 2000))
2060         p_24 = (Ether(src=self.pg0.remote_mac,
2061                       dst=self.pg0.local_mac) /
2062                 IP(src="1.1.1.1",
2063                    dst="10.1.2.1") /
2064                 UDP(sport=1234, dport=1234) /
2065                 Raw(b'\xa5' * 2000))
2066
2067         self.logger.info(self.vapi.cli("sh ip fib mtrie"))
2068         rx = self.send_and_expect(self.pg0, p_8 * NUM_PKTS, self.pg2)
2069         rx = self.send_and_expect(self.pg0, p_24 * NUM_PKTS, self.pg1)
2070
2071
2072 class TestIPv4Frag(VppTestCase):
2073     """ IPv4 fragmentation """
2074
2075     @classmethod
2076     def setUpClass(cls):
2077         super(TestIPv4Frag, cls).setUpClass()
2078
2079         cls.create_pg_interfaces([0, 1])
2080         cls.src_if = cls.pg0
2081         cls.dst_if = cls.pg1
2082
2083         # setup all interfaces
2084         for i in cls.pg_interfaces:
2085             i.admin_up()
2086             i.config_ip4()
2087             i.resolve_arp()
2088
2089     @classmethod
2090     def tearDownClass(cls):
2091         super(TestIPv4Frag, cls).tearDownClass()
2092
2093     def test_frag_large_packets(self):
2094         """ Fragmentation of large packets """
2095
2096         self.vapi.cli("adjacency counters enable")
2097
2098         p = (Ether(dst=self.src_if.local_mac, src=self.src_if.remote_mac) /
2099              IP(src=self.src_if.remote_ip4, dst=self.dst_if.remote_ip4) /
2100              UDP(sport=1234, dport=5678) / Raw())
2101         self.extend_packet(p, 6000, "abcde")
2102         saved_payload = p[Raw].load
2103
2104         nbr = VppNeighbor(self,
2105                           self.dst_if.sw_if_index,
2106                           self.dst_if.remote_mac,
2107                           self.dst_if.remote_ip4).add_vpp_config()
2108
2109         # Force fragmentation by setting MTU of output interface
2110         # lower than packet size
2111         self.vapi.sw_interface_set_mtu(self.dst_if.sw_if_index,
2112                                        [5000, 0, 0, 0])
2113
2114         self.pg_enable_capture()
2115         self.src_if.add_stream(p)
2116         self.pg_start()
2117
2118         # Expecting 3 fragments because size of created fragments currently
2119         # cannot be larger then VPP buffer size (which is 2048)
2120         packets = self.dst_if.get_capture(3)
2121
2122         # we should show 3 packets thru the neighbor
2123         self.assertEqual(3, nbr.get_stats()['packets'])
2124
2125         # Assume VPP sends the fragments in order
2126         payload = b''
2127         for p in packets:
2128             payload_offset = p.frag * 8
2129             if payload_offset > 0:
2130                 payload_offset -= 8  # UDP header is not in payload
2131             self.assert_equal(payload_offset, len(payload))
2132             payload += p[Raw].load
2133         self.assert_equal(payload, saved_payload, "payload")
2134
2135
2136 class TestIPReplace(VppTestCase):
2137     """ IPv4 Table Replace """
2138
2139     @classmethod
2140     def setUpClass(cls):
2141         super(TestIPReplace, cls).setUpClass()
2142
2143     @classmethod
2144     def tearDownClass(cls):
2145         super(TestIPReplace, cls).tearDownClass()
2146
2147     def setUp(self):
2148         super(TestIPReplace, self).setUp()
2149
2150         self.create_pg_interfaces(range(4))
2151
2152         table_id = 1
2153         self.tables = []
2154
2155         for i in self.pg_interfaces:
2156             i.admin_up()
2157             i.config_ip4()
2158             i.resolve_arp()
2159             i.generate_remote_hosts(2)
2160             self.tables.append(VppIpTable(self, table_id).add_vpp_config())
2161             table_id += 1
2162
2163     def tearDown(self):
2164         super(TestIPReplace, self).tearDown()
2165         for i in self.pg_interfaces:
2166             i.admin_down()
2167             i.unconfig_ip4()
2168
2169     def test_replace(self):
2170         """ IP Table Replace """
2171
2172         MRouteItfFlags = VppEnum.vl_api_mfib_itf_flags_t
2173         MRouteEntryFlags = VppEnum.vl_api_mfib_entry_flags_t
2174         N_ROUTES = 20
2175         links = [self.pg0, self.pg1, self.pg2, self.pg3]
2176         routes = [[], [], [], []]
2177
2178         # load up the tables with some routes
2179         for ii, t in enumerate(self.tables):
2180             for jj in range(N_ROUTES):
2181                 uni = VppIpRoute(
2182                     self, "10.0.0.%d" % jj, 32,
2183                     [VppRoutePath(links[ii].remote_hosts[0].ip4,
2184                                   links[ii].sw_if_index),
2185                      VppRoutePath(links[ii].remote_hosts[1].ip4,
2186                                   links[ii].sw_if_index)],
2187                     table_id=t.table_id).add_vpp_config()
2188                 multi = VppIpMRoute(
2189                     self, "0.0.0.0",
2190                     "239.0.0.%d" % jj, 32,
2191                     MRouteEntryFlags.MFIB_API_ENTRY_FLAG_NONE,
2192                     [VppMRoutePath(self.pg0.sw_if_index,
2193                                    MRouteItfFlags.MFIB_API_ITF_FLAG_ACCEPT),
2194                      VppMRoutePath(self.pg1.sw_if_index,
2195                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD),
2196                      VppMRoutePath(self.pg2.sw_if_index,
2197                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD),
2198                      VppMRoutePath(self.pg3.sw_if_index,
2199                                    MRouteItfFlags.MFIB_API_ITF_FLAG_FORWARD)],
2200                     table_id=t.table_id).add_vpp_config()
2201                 routes[ii].append({'uni': uni,
2202                                    'multi': multi})
2203
2204         #
2205         # replace the tables a few times
2206         #
2207         for kk in range(3):
2208             # replace_begin each table
2209             for t in self.tables:
2210                 t.replace_begin()
2211
2212             # all the routes are still there
2213             for ii, t in enumerate(self.tables):
2214                 dump = t.dump()
2215                 mdump = t.mdump()
2216                 for r in routes[ii]:
2217                     self.assertTrue(find_route_in_dump(dump, r['uni'], t))
2218                     self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t))
2219
2220             # redownload the even numbered routes
2221             for ii, t in enumerate(self.tables):
2222                 for jj in range(0, N_ROUTES, 2):
2223                     routes[ii][jj]['uni'].add_vpp_config()
2224                     routes[ii][jj]['multi'].add_vpp_config()
2225
2226             # signal each table replace_end
2227             for t in self.tables:
2228                 t.replace_end()
2229
2230             # we should find the even routes, but not the odd
2231             for ii, t in enumerate(self.tables):
2232                 dump = t.dump()
2233                 mdump = t.mdump()
2234                 for jj in range(0, N_ROUTES, 2):
2235                     self.assertTrue(find_route_in_dump(
2236                         dump, routes[ii][jj]['uni'], t))
2237                     self.assertTrue(find_mroute_in_dump(
2238                         mdump, routes[ii][jj]['multi'], t))
2239                 for jj in range(1, N_ROUTES - 1, 2):
2240                     self.assertFalse(find_route_in_dump(
2241                         dump, routes[ii][jj]['uni'], t))
2242                     self.assertFalse(find_mroute_in_dump(
2243                         mdump, routes[ii][jj]['multi'], t))
2244
2245             # reload all the routes
2246             for ii, t in enumerate(self.tables):
2247                 for r in routes[ii]:
2248                     r['uni'].add_vpp_config()
2249                     r['multi'].add_vpp_config()
2250
2251             # all the routes are still there
2252             for ii, t in enumerate(self.tables):
2253                 dump = t.dump()
2254                 mdump = t.mdump()
2255                 for r in routes[ii]:
2256                     self.assertTrue(find_route_in_dump(dump, r['uni'], t))
2257                     self.assertTrue(find_mroute_in_dump(mdump, r['multi'], t))
2258
2259         #
2260         # finally flush the tables for good measure
2261         #
2262         for t in self.tables:
2263             t.flush()
2264             self.assertEqual(len(t.dump()), 5)
2265             self.assertEqual(len(t.mdump()), 3)
2266
2267
2268 class TestIPCover(VppTestCase):
2269     """ IPv4 Table Cover """
2270
2271     @classmethod
2272     def setUpClass(cls):
2273         super(TestIPCover, cls).setUpClass()
2274
2275     @classmethod
2276     def tearDownClass(cls):
2277         super(TestIPCover, cls).tearDownClass()
2278
2279     def setUp(self):
2280         super(TestIPCover, self).setUp()
2281
2282         self.create_pg_interfaces(range(4))
2283
2284         table_id = 1
2285         self.tables = []
2286
2287         for i in self.pg_interfaces:
2288             i.admin_up()
2289             i.config_ip4()
2290             i.resolve_arp()
2291             i.generate_remote_hosts(2)
2292             self.tables.append(VppIpTable(self, table_id).add_vpp_config())
2293             table_id += 1
2294
2295     def tearDown(self):
2296         super(TestIPCover, self).tearDown()
2297         for i in self.pg_interfaces:
2298             i.admin_down()
2299             i.unconfig_ip4()
2300
2301     def test_cover(self):
2302         """ IP Table Cover """
2303
2304         # add a loop back with a /32 prefix
2305         lo = VppLoInterface(self)
2306         lo.admin_up()
2307         a = VppIpInterfaceAddress(self, lo, "127.0.0.1", 32).add_vpp_config()
2308
2309         # add a neighbour that matches the loopback's /32
2310         nbr = VppNeighbor(self,
2311                           lo.sw_if_index,
2312                           lo.remote_mac,
2313                           "127.0.0.1").add_vpp_config()
2314
2315         # add the default route which will be the cover for /32
2316         r = VppIpRoute(self, "0.0.0.0", 0,
2317                        [VppRoutePath("127.0.0.1",
2318                                      lo.sw_if_index)],
2319                        register=False).add_vpp_config()
2320
2321         # add/remove/add a longer mask cover
2322         r8 = VppIpRoute(self, "127.0.0.0", 8,
2323                         [VppRoutePath("127.0.0.1",
2324                                       lo.sw_if_index)]).add_vpp_config()
2325         r8.remove_vpp_config()
2326         r8.add_vpp_config()
2327         r8.remove_vpp_config()
2328
2329         # remove the default route
2330         r.remove_vpp_config()
2331
2332         # remove the interface prefix
2333         a.remove_vpp_config()
2334
2335
2336 class TestIP4Replace(VppTestCase):
2337     """ IPv4 Interface Address Replace """
2338
2339     @classmethod
2340     def setUpClass(cls):
2341         super(TestIP4Replace, cls).setUpClass()
2342
2343     @classmethod
2344     def tearDownClass(cls):
2345         super(TestIP4Replace, cls).tearDownClass()
2346
2347     def setUp(self):
2348         super(TestIP4Replace, self).setUp()
2349
2350         self.create_pg_interfaces(range(4))
2351
2352         for i in self.pg_interfaces:
2353             i.admin_up()
2354
2355     def tearDown(self):
2356         super(TestIP4Replace, self).tearDown()
2357         for i in self.pg_interfaces:
2358             i.admin_down()
2359
2360     def get_n_pfxs(self, intf):
2361         return len(self.vapi.ip_address_dump(intf.sw_if_index))
2362
2363     def test_replace(self):
2364         """ IP interface address replace """
2365
2366         intf_pfxs = [[], [], [], []]
2367
2368         # add prefixes to each of the interfaces
2369         for i in range(len(self.pg_interfaces)):
2370             intf = self.pg_interfaces[i]
2371
2372             # 172.16.x.1/24
2373             addr = "172.16.%d.1" % intf.sw_if_index
2374             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2375             intf_pfxs[i].append(a)
2376
2377             # 172.16.x.2/24 - a different address in the same subnet as above
2378             addr = "172.16.%d.2" % intf.sw_if_index
2379             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2380             intf_pfxs[i].append(a)
2381
2382             # 172.15.x.2/24 - a different address and subnet
2383             addr = "172.15.%d.2" % intf.sw_if_index
2384             a = VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2385             intf_pfxs[i].append(a)
2386
2387         # a dump should n_address in it
2388         for intf in self.pg_interfaces:
2389             self.assertEqual(self.get_n_pfxs(intf), 3)
2390
2391         #
2392         # remove all the address thru a replace
2393         #
2394         self.vapi.sw_interface_address_replace_begin()
2395         self.vapi.sw_interface_address_replace_end()
2396         for intf in self.pg_interfaces:
2397             self.assertEqual(self.get_n_pfxs(intf), 0)
2398
2399         #
2400         # add all the interface addresses back
2401         #
2402         for p in intf_pfxs:
2403             for v in p:
2404                 v.add_vpp_config()
2405         for intf in self.pg_interfaces:
2406             self.assertEqual(self.get_n_pfxs(intf), 3)
2407
2408         #
2409         # replace again, but this time update/re-add the address on the first
2410         # two interfaces
2411         #
2412         self.vapi.sw_interface_address_replace_begin()
2413
2414         for p in intf_pfxs[:2]:
2415             for v in p:
2416                 v.add_vpp_config()
2417
2418         self.vapi.sw_interface_address_replace_end()
2419
2420         # on the first two the address still exist,
2421         # on the other two they do not
2422         for intf in self.pg_interfaces[:2]:
2423             self.assertEqual(self.get_n_pfxs(intf), 3)
2424         for p in intf_pfxs[:2]:
2425             for v in p:
2426                 self.assertTrue(v.query_vpp_config())
2427         for intf in self.pg_interfaces[2:]:
2428             self.assertEqual(self.get_n_pfxs(intf), 0)
2429
2430         #
2431         # add all the interface addresses back on the last two
2432         #
2433         for p in intf_pfxs[2:]:
2434             for v in p:
2435                 v.add_vpp_config()
2436         for intf in self.pg_interfaces:
2437             self.assertEqual(self.get_n_pfxs(intf), 3)
2438
2439         #
2440         # replace again, this time add different prefixes on all the interfaces
2441         #
2442         self.vapi.sw_interface_address_replace_begin()
2443
2444         pfxs = []
2445         for intf in self.pg_interfaces:
2446             # 172.18.x.1/24
2447             addr = "172.18.%d.1" % intf.sw_if_index
2448             pfxs.append(VppIpInterfaceAddress(self, intf, addr,
2449                                               24).add_vpp_config())
2450
2451         self.vapi.sw_interface_address_replace_end()
2452
2453         # only .18 should exist on each interface
2454         for intf in self.pg_interfaces:
2455             self.assertEqual(self.get_n_pfxs(intf), 1)
2456         for pfx in pfxs:
2457             self.assertTrue(pfx.query_vpp_config())
2458
2459         #
2460         # remove everything
2461         #
2462         self.vapi.sw_interface_address_replace_begin()
2463         self.vapi.sw_interface_address_replace_end()
2464         for intf in self.pg_interfaces:
2465             self.assertEqual(self.get_n_pfxs(intf), 0)
2466
2467         #
2468         # add prefixes to each interface. post-begin add the prefix from
2469         # interface X onto interface Y. this would normally be an error
2470         # since it would generate a 'duplicate address' warning. but in
2471         # this case, since what is newly downloaded is sane, it's ok
2472         #
2473         for intf in self.pg_interfaces:
2474             # 172.18.x.1/24
2475             addr = "172.18.%d.1" % intf.sw_if_index
2476             VppIpInterfaceAddress(self, intf, addr, 24).add_vpp_config()
2477
2478         self.vapi.sw_interface_address_replace_begin()
2479
2480         pfxs = []
2481         for intf in self.pg_interfaces:
2482             # 172.18.x.1/24
2483             addr = "172.18.%d.1" % (intf.sw_if_index + 1)
2484             pfxs.append(VppIpInterfaceAddress(self, intf,
2485                                               addr, 24).add_vpp_config())
2486
2487         self.vapi.sw_interface_address_replace_end()
2488
2489         self.logger.info(self.vapi.cli("sh int addr"))
2490
2491         for intf in self.pg_interfaces:
2492             self.assertEqual(self.get_n_pfxs(intf), 1)
2493         for pfx in pfxs:
2494             self.assertTrue(pfx.query_vpp_config())
2495
2496
2497 if __name__ == '__main__':
2498     unittest.main(testRunner=VppTestRunner)