test/test_ip4.py

   1 #!/usr/bin/env python
   2 import random
   3 import socket
   4 import unittest
   5
   6 from framework import VppTestCase, VppTestRunner
   7 from vpp_sub_interface import VppSubInterface, VppDot1QSubint, VppDot1ADSubint
   8
   9 from scapy.packet import Raw
  10 from scapy.layers.l2 import Ether, Dot1Q
  11 from scapy.layers.inet import IP, UDP
  12 from util import ppp
  13
  14
  15 class TestIPv4(VppTestCase):
  16     """ IPv4 Test Case """
  17
  18     def setUp(self):
  19         """
  20         Perform test setup before test case.
  21
  22         **Config:**
  23             - create 3 pg interfaces
  24                 - untagged pg0 interface
  25                 - Dot1Q subinterface on pg1
  26                 - Dot1AD subinterface on pg2
  27             - setup interfaces:
  28                 - put it into UP state
  29                 - set IPv4 addresses
  30                 - resolve neighbor address using ARP
  31             - configure 200 fib entries
  32
  33         :ivar list interfaces: pg interfaces and subinterfaces.
  34         :ivar dict flows: IPv4 packet flows in test.
  35         :ivar list pg_if_packet_sizes: packet sizes in test.
  36         """
  37         super(TestIPv4, self).setUp()
  38
  39         # create 3 pg interfaces
  40         self.create_pg_interfaces(range(3))
  41
  42         # create 2 subinterfaces for pg1 and pg2
  43         self.sub_interfaces = [
  44             VppDot1QSubint(self, self.pg1, 100),
  45             VppDot1ADSubint(self, self.pg2, 200, 300, 400)]
  46
  47         # packet flows mapping pg0 -> pg1.sub, pg2.sub, etc.
  48         self.flows = dict()
  49         self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if]
  50         self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if]
  51         self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if]
  52
  53         # packet sizes
  54         self.pg_if_packet_sizes = [64, 512, 1518, 9018]
  55         self.sub_if_packet_sizes = [64, 512, 1518 + 4, 9018 + 4]
  56
  57         self.interfaces = list(self.pg_interfaces)
  58         self.interfaces.extend(self.sub_interfaces)
  59
  60         # setup all interfaces
  61         for i in self.interfaces:
  62             i.admin_up()
  63             i.config_ip4()
  64             i.resolve_arp()
  65
  66         # config 2M FIB entries
  67         self.config_fib_entries(200)
  68
  69     def tearDown(self):
  70         """Run standard test teardown and log ``show ip arp``."""
  71         super(TestIPv4, self).tearDown()
  72         if not self.vpp_dead:
  73             self.logger.info(self.vapi.cli("show ip arp"))
  74             # info(self.vapi.cli("show ip fib"))  # many entries
  75
  76     def config_fib_entries(self, count):
  77         """For each interface add to the FIB table *count* routes to
  78         "10.0.0.1/32" destination with interface's local address as next-hop
  79         address.
  80
  81         :param int count: Number of FIB entries.
  82
  83         - *TODO:* check if the next-hop address shouldn't be remote address
  84           instead of local address.
  85         """
  86         n_int = len(self.interfaces)
  87         percent = 0
  88         counter = 0.0
  89         dest_addr = socket.inet_pton(socket.AF_INET, "10.0.0.1")
  90         dest_addr_len = 32
  91         for i in self.interfaces:
  92             next_hop_address = i.local_ip4n
  93             for j in range(count / n_int):
  94                 self.vapi.ip_add_del_route(
  95                     dest_addr, dest_addr_len, next_hop_address)
  96                 counter += 1
  97                 if counter / count * 100 > percent:
  98                     self.logger.info("Configure %d FIB entries .. %d%% done" %
  99                                      (count, percent))
 100                     percent += 1
 101
 102     def create_stream(self, src_if, packet_sizes):
 103         """Create input packet stream for defined interface.
 104
 105         :param VppInterface src_if: Interface to create packet stream for.
 106         :param list packet_sizes: Required packet sizes.
 107         """
 108         pkts = []
 109         for i in range(0, 257):
 110             dst_if = self.flows[src_if][i % 2]
 111             info = self.create_packet_info(
 112                 src_if.sw_if_index, dst_if.sw_if_index)
 113             payload = self.info_to_payload(info)
 114             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
 115                  IP(src=src_if.remote_ip4, dst=dst_if.remote_ip4) /
 116                  UDP(sport=1234, dport=1234) /
 117                  Raw(payload))
 118             info.data = p.copy()
 119             if isinstance(src_if, VppSubInterface):
 120                 p = src_if.add_dot1_layer(p)
 121             size = packet_sizes[(i // 2) % len(packet_sizes)]
 122             self.extend_packet(p, size)
 123             pkts.append(p)
 124         return pkts
 125
 126     def verify_capture(self, dst_if, capture):
 127         """Verify captured input packet stream for defined interface.
 128
 129         :param VppInterface dst_if: Interface to verify captured packet stream
 130                                     for.
 131         :param list capture: Captured packet stream.
 132         """
 133         self.logger.info("Verifying capture on interface %s" % dst_if.name)
 134         last_info = dict()
 135         for i in self.interfaces:
 136             last_info[i.sw_if_index] = None
 137         is_sub_if = False
 138         dst_sw_if_index = dst_if.sw_if_index
 139         if hasattr(dst_if, 'parent'):
 140             is_sub_if = True
 141         for packet in capture:
 142             if is_sub_if:
 143                 # Check VLAN tags and Ethernet header
 144                 packet = dst_if.remove_dot1_layer(packet)
 145             self.assertTrue(Dot1Q not in packet)
 146             try:
 147                 ip = packet[IP]
 148                 udp = packet[UDP]
 149                 payload_info = self.payload_to_info(str(packet[Raw]))
 150                 packet_index = payload_info.index
 151                 self.assertEqual(payload_info.dst, dst_sw_if_index)
 152                 self.logger.debug("Got packet on port %s: src=%u (id=%u)" %
 153                                   (dst_if.name, payload_info.src, packet_index))
 154                 next_info = self.get_next_packet_info_for_interface2(
 155                     payload_info.src, dst_sw_if_index,
 156                     last_info[payload_info.src])
 157                 last_info[payload_info.src] = next_info
 158                 self.assertTrue(next_info is not None)
 159                 self.assertEqual(packet_index, next_info.index)
 160                 saved_packet = next_info.data
 161                 # Check standard fields
 162                 self.assertEqual(ip.src, saved_packet[IP].src)
 163                 self.assertEqual(ip.dst, saved_packet[IP].dst)
 164                 self.assertEqual(udp.sport, saved_packet[UDP].sport)
 165                 self.assertEqual(udp.dport, saved_packet[UDP].dport)
 166             except:
 167                 self.logger.error(ppp("Unexpected or invalid packet:", packet))
 168                 raise
 169         for i in self.interfaces:
 170             remaining_packet = self.get_next_packet_info_for_interface2(
 171                 i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index])
 172             self.assertTrue(remaining_packet is None,
 173                             "Interface %s: Packet expected from interface %s "
 174                             "didn't arrive" % (dst_if.name, i.name))
 175
 176     def test_fib(self):
 177         """ IPv4 FIB test
 178
 179         Test scenario:
 180
 181             - Create IPv4 stream for pg0 interface
 182             - Create IPv4 tagged streams for pg1's and pg2's subinterface.
 183             - Send and verify received packets on each interface.
 184         """
 185
 186         pkts = self.create_stream(self.pg0, self.pg_if_packet_sizes)
 187         self.pg0.add_stream(pkts)
 188
 189         for i in self.sub_interfaces:
 190             pkts = self.create_stream(i, self.sub_if_packet_sizes)
 191             i.parent.add_stream(pkts)
 192
 193         self.pg_enable_capture(self.pg_interfaces)
 194         self.pg_start()
 195
 196         pkts = self.pg0.get_capture()
 197         self.verify_capture(self.pg0, pkts)
 198
 199         for i in self.sub_interfaces:
 200             pkts = i.parent.get_capture()
 201             self.verify_capture(i, pkts)
 202
 203
 204 class TestIPv4FibCrud(VppTestCase):
 205     """ FIB - add/update/delete - ip4 routes
 206
 207     Test scenario:
 208         - add 1k,
 209         - del 100,
 210         - add new 1k,
 211         - del 1.5k
 212
 213     ..note:: Python API is to slow to add many routes, needs C code replacement.
 214     """
 215
 216     def config_fib_many_to_one(self, start_dest_addr, next_hop_addr, count):
 217         """
 218
 219         :param start_dest_addr:
 220         :param next_hop_addr:
 221         :param count:
 222         :return list: added ips with 32 prefix
 223         """
 224         added_ips = []
 225         dest_addr = int(
 226             socket.inet_pton(socket.AF_INET, start_dest_addr).encode('hex'), 16)
 227         dest_addr_len = 32
 228         n_next_hop_addr = socket.inet_pton(socket.AF_INET, next_hop_addr)
 229         for _ in range(count):
 230             n_dest_addr = '{:08x}'.format(dest_addr).decode('hex')
 231             self.vapi.ip_add_del_route(n_dest_addr, dest_addr_len,
 232                                        n_next_hop_addr)
 233             added_ips.append(socket.inet_ntoa(n_dest_addr))
 234             dest_addr += 1
 235         return added_ips
 236
 237     def unconfig_fib_many_to_one(self, start_dest_addr, next_hop_addr, count):
 238
 239         removed_ips = []
 240         dest_addr = int(
 241             socket.inet_pton(socket.AF_INET, start_dest_addr).encode('hex'), 16)
 242         dest_addr_len = 32
 243         n_next_hop_addr = socket.inet_pton(socket.AF_INET, next_hop_addr)
 244         for _ in range(count):
 245             n_dest_addr = '{:08x}'.format(dest_addr).decode('hex')
 246             self.vapi.ip_add_del_route(n_dest_addr, dest_addr_len,
 247                                        n_next_hop_addr, is_add=0)
 248             removed_ips.append(socket.inet_ntoa(n_dest_addr))
 249             dest_addr += 1
 250         return removed_ips
 251
 252     def create_stream(self, src_if, dst_if, dst_ips, count):
 253         pkts = []
 254
 255         for _ in range(count):
 256             dst_addr = random.choice(dst_ips)
 257             info = self.create_packet_info(
 258                 src_if.sw_if_index, dst_if.sw_if_index)
 259             payload = self.info_to_payload(info)
 260             p = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) /
 261                  IP(src=src_if.remote_ip4, dst=dst_addr) /
 262                  UDP(sport=1234, dport=1234) /
 263                  Raw(payload))
 264             info.data = p.copy()
 265             size = random.choice(self.pg_if_packet_sizes)
 266             self.extend_packet(p, random.choice(self.pg_if_packet_sizes))
 267             pkts.append(p)
 268
 269         return pkts
 270
 271     def _find_ip_match(self, find_in, pkt):
 272         for p in find_in:
 273             if self.payload_to_info(str(p[Raw])) == self.payload_to_info(str(pkt[Raw])):
 274                 if p[IP].src != pkt[IP].src:
 275                     break
 276                 if p[IP].dst != pkt[IP].dst:
 277                     break
 278                 if p[UDP].sport != pkt[UDP].sport:
 279                     break
 280                 if p[UDP].dport != pkt[UDP].dport:
 281                     break
 282                 return p
 283         return None
 284
 285     @staticmethod
 286     def _match_route_detail(route_detail, ip, address_length=32, table_id=0):
 287         if route_detail.address == socket.inet_pton(socket.AF_INET, ip):
 288             if route_detail.table_id != table_id:
 289                 return False
 290             elif route_detail.address_length != address_length:
 291                 return False
 292             else:
 293                 return True
 294         else:
 295             return False
 296
 297     def verify_capture(self, dst_interface, received_pkts, expected_pkts):
 298         self.assertEqual(len(received_pkts), len(expected_pkts))
 299         to_verify = list(expected_pkts)
 300         for p in received_pkts:
 301             self.assertEqual(p.src, dst_interface.local_mac)
 302             self.assertEqual(p.dst, dst_interface.remote_mac)
 303             x = self._find_ip_match(to_verify, p)
 304             to_verify.remove(x)
 305         self.assertListEqual(to_verify, [])
 306
 307     def verify_route_dump(self, fib_dump, ips):
 308
 309         def _ip_in_route_dump(ip, fib_dump):
 310             return next((route for route in fib_dump
 311                          if self._match_route_detail(route, ip)),
 312                         False)
 313
 314         for ip in ips:
 315             self.assertTrue(_ip_in_route_dump(ip, fib_dump),
 316                             'IP {} is not in fib dump.'.format(ip))
 317
 318     def verify_not_in_route_dump(self, fib_dump, ips):
 319
 320         def _ip_in_route_dump(ip, fib_dump):
 321             return next((route for route in fib_dump
 322                          if self._match_route_detail(route, ip)),
 323                         False)
 324
 325         for ip in ips:
 326             self.assertFalse(_ip_in_route_dump(ip, fib_dump),
 327                              'IP {} is in fib dump.'.format(ip))
 328
 329     @classmethod
 330     def setUpClass(cls):
 331         """
 332         #. Create and initialize 3 pg interfaces.
 333         #. initialize class attributes configured_routes and deleted_routes
 334            to store information between tests.
 335         """
 336         super(TestIPv4FibCrud, cls).setUpClass()
 337
 338         try:
 339             # create 3 pg interfaces
 340             cls.create_pg_interfaces(range(3))
 341
 342             cls.interfaces = list(cls.pg_interfaces)
 343
 344             # setup all interfaces
 345             for i in cls.interfaces:
 346                 i.admin_up()
 347                 i.config_ip4()
 348                 i.resolve_arp()
 349
 350             cls.configured_routes = []
 351             cls.deleted_routes = []
 352             cls.pg_if_packet_sizes = [64, 512, 1518, 9018]
 353
 354         except Exception:
 355             super(TestIPv4FibCrud, cls).tearDownClass()
 356             raise
 357
 358     def setUp(self):
 359         super(TestIPv4FibCrud, self).setUp()
 360         self.packet_infos = {}
 361
 362     def test_1_add_routes(self):
 363         """ Add 1k routes
 364
 365         - add 100 routes check with traffic script.
 366         """
 367         # config 1M FIB entries
 368         self.configured_routes.extend(self.config_fib_many_to_one(
 369             "10.0.0.0", self.pg0.remote_ip4, 100))
 370
 371         fib_dump = self.vapi.ip_fib_dump()
 372         self.verify_route_dump(fib_dump, self.configured_routes)
 373
 374         self.stream_1 = self.create_stream(
 375             self.pg1, self.pg0, self.configured_routes, 100)
 376         self.stream_2 = self.create_stream(
 377             self.pg2, self.pg0, self.configured_routes, 100)
 378         self.pg1.add_stream(self.stream_1)
 379         self.pg2.add_stream(self.stream_2)
 380
 381         self.pg_enable_capture(self.pg_interfaces)
 382         self.pg_start()
 383
 384         pkts = self.pg0.get_capture()
 385         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 386
 387
 388     def test_2_del_routes(self):
 389         """ Delete 100 routes
 390
 391         - delete 10 routes check with traffic script.
 392         """
 393         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 394             "10.0.0.10", self.pg0.remote_ip4, 10))
 395         for x in self.deleted_routes:
 396             self.configured_routes.remove(x)
 397
 398         fib_dump = self.vapi.ip_fib_dump()
 399         self.verify_route_dump(fib_dump, self.configured_routes)
 400
 401         self.stream_1 = self.create_stream(
 402             self.pg1, self.pg0, self.configured_routes, 100)
 403         self.stream_2 = self.create_stream(
 404             self.pg2, self.pg0, self.configured_routes, 100)
 405         self.stream_3 = self.create_stream(
 406             self.pg1, self.pg0, self.deleted_routes, 100)
 407         self.stream_4 = self.create_stream(
 408             self.pg2, self.pg0, self.deleted_routes, 100)
 409         self.pg1.add_stream(self.stream_1 + self.stream_3)
 410         self.pg2.add_stream(self.stream_2 + self.stream_4)
 411         self.pg_enable_capture(self.pg_interfaces)
 412         self.pg_start()
 413
 414         pkts = self.pg0.get_capture()
 415         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 416
 417     def test_3_add_new_routes(self):
 418         """ Add 1k routes
 419
 420         - re-add 5 routes check with traffic script.
 421         - add 100 routes check with traffic script.
 422         """
 423         tmp = self.config_fib_many_to_one(
 424             "10.0.0.10", self.pg0.remote_ip4, 5)
 425         self.configured_routes.extend(tmp)
 426         for x in tmp:
 427             self.deleted_routes.remove(x)
 428
 429         self.configured_routes.extend(self.config_fib_many_to_one(
 430             "10.0.1.0", self.pg0.remote_ip4, 100))
 431
 432         fib_dump = self.vapi.ip_fib_dump()
 433         self.verify_route_dump(fib_dump, self.configured_routes)
 434
 435         self.stream_1 = self.create_stream(
 436             self.pg1, self.pg0, self.configured_routes, 300)
 437         self.stream_2 = self.create_stream(
 438             self.pg2, self.pg0, self.configured_routes, 300)
 439         self.stream_3 = self.create_stream(
 440             self.pg1, self.pg0, self.deleted_routes, 100)
 441         self.stream_4 = self.create_stream(
 442             self.pg2, self.pg0, self.deleted_routes, 100)
 443
 444         self.pg1.add_stream(self.stream_1 + self.stream_3)
 445         self.pg2.add_stream(self.stream_2 + self.stream_4)
 446         self.pg_enable_capture(self.pg_interfaces)
 447         self.pg_start()
 448
 449         pkts = self.pg0.get_capture()
 450         self.verify_capture(self.pg0, pkts, self.stream_1 + self.stream_2)
 451
 452     def test_4_del_routes(self):
 453         """ Delete 1.5k routes
 454
 455         - delete 5 routes check with traffic script.
 456         - add 100 routes check with traffic script.
 457         """
 458         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 459             "10.0.0.0", self.pg0.remote_ip4, 15))
 460         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 461             "10.0.0.20", self.pg0.remote_ip4, 85))
 462         self.deleted_routes.extend(self.unconfig_fib_many_to_one(
 463             "10.0.1.0", self.pg0.remote_ip4, 100))
 464         fib_dump = self.vapi.ip_fib_dump()
 465         self.verify_not_in_route_dump(fib_dump, self.deleted_routes)
 466
 467
 468 if __name__ == '__main__':
 469     unittest.main(testRunner=VppTestRunner)