#!/usr/bin/env python import socket import unittest from parameterized import parameterized import scapy.layers.inet6 as inet6 from scapy.contrib.mpls import MPLS from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_RS, \ ICMPv6ND_RA, ICMPv6NDOptMTU, ICMPv6NDOptSrcLLAddr, ICMPv6NDOptPrefixInfo, \ ICMPv6ND_NA, ICMPv6NDOptDstLLAddr, ICMPv6DestUnreach, icmp6types, \ ICMPv6TimeExceeded, ICMPv6EchoRequest, ICMPv6EchoReply from scapy.layers.l2 import Ether, Dot1Q from scapy.packet import Raw from scapy.utils import inet_pton, inet_ntop from scapy.utils6 import in6_getnsma, in6_getnsmac, in6_ptop, in6_islladdr, \ in6_mactoifaceid from six import moves from framework import VppTestCase, VppTestRunner from util import ppp, ip6_normalize, mk_ll_addr from vpp_ip import DpoProto from vpp_ip_route import VppIpRoute, VppRoutePath, find_route, VppIpMRoute, \ VppMRoutePath, MRouteItfFlags, MRouteEntryFlags, VppMplsIpBind, \ VppMplsRoute, VppMplsTable, VppIpTable from vpp_neighbor import find_nbr, VppNeighbor from vpp_pg_interface import is_ipv6_misc from vpp_sub_interface import VppSubInterface, VppDot1QSubint from ipaddress import IPv6Network, IPv4Network AF_INET6 = socket.AF_INET6 try: text_type = unicode except NameError: text_type = str class TestIPv6ND(VppTestCase): def validate_ra(self, intf, rx, dst_ip=None): if not dst_ip: dst_ip = intf.remote_ip6 # unicasted packets must come to the unicast mac self.assertEqual(rx[Ether].dst, intf.remote_mac) # and from the router's MAC self.assertEqual(rx[Ether].src, intf.local_mac) # the rx'd RA should be addressed to the sender's source self.assertTrue(rx.haslayer(ICMPv6ND_RA)) self.assertEqual(in6_ptop(rx[IPv6].dst), in6_ptop(dst_ip)) # and come from the router's link local self.assertTrue(in6_islladdr(rx[IPv6].src)) self.assertEqual(in6_ptop(rx[IPv6].src), in6_ptop(mk_ll_addr(intf.local_mac))) def validate_na(self, intf, rx, dst_ip=None, tgt_ip=None): if not dst_ip: dst_ip = intf.remote_ip6 if not tgt_ip: dst_ip = intf.local_ip6 # unicasted packets must come to the unicast mac self.assertEqual(rx[Ether].dst, intf.remote_mac) # and from the router's MAC self.assertEqual(rx[Ether].src, intf.local_mac) # the rx'd NA should be addressed to the sender's source self.assertTrue(rx.haslayer(ICMPv6ND_NA)) self.assertEqual(in6_ptop(rx[IPv6].dst), in6_ptop(dst_ip)) # and come from the target address self.assertEqual( in6_ptop(rx[IPv6].src), in6_ptop(tgt_ip)) # Dest link-layer options should have the router's MAC dll = rx[ICMPv6NDOptDstLLAddr] self.assertEqual(dll.lladdr, intf.local_mac) def validate_ns(self, intf, rx, tgt_ip): nsma = in6_getnsma(inet_pton(AF_INET6, tgt_ip)) dst_ip = inet_ntop(AF_INET6, nsma) # NS is broadcast self.assertEqual(rx[Ether].dst, in6_getnsmac(nsma)) # and from the router's MAC self.assertEqual(rx[Ether].src, intf.local_mac) # the rx'd NS should be addressed to an mcast address # derived from the target address self.assertEqual( in6_ptop(rx[IPv6].dst), in6_ptop(dst_ip)) # expect the tgt IP in the NS header ns = rx[ICMPv6ND_NS] self.assertEqual(in6_ptop(ns.tgt), in6_ptop(tgt_ip)) # packet is from the router's local address self.assertEqual( in6_ptop(rx[IPv6].src), intf.local_ip6) # Src link-layer options should have the router's MAC sll = rx[ICMPv6NDOptSrcLLAddr] self.assertEqual(sll.lladdr, intf.local_mac) def send_and_expect_ra(self, intf, pkts, remark, dst_ip=None, filter_out_fn=is_ipv6_misc): intf.add_stream(pkts) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = intf.get_capture(1, filter_out_fn=filter_out_fn) self.assertEqual(len(rx), 1) rx = rx[0] self.validate_ra(intf, rx, dst_ip) def send_and_expect_na(self, intf, pkts, remark, dst_ip=None, tgt_ip=None, filter_out_fn=is_ipv6_misc): intf.add_stream(pkts) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = intf.get_capture(1, filter_out_fn=filter_out_fn) self.assertEqual(len(rx), 1) rx = rx[0] self.validate_na(intf, rx, dst_ip, tgt_ip) def send_and_expect_ns(self, tx_intf, rx_intf, pkts, tgt_ip, filter_out_fn=is_ipv6_misc): tx_intf.add_stream(pkts) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = rx_intf.get_capture(1, filter_out_fn=filter_out_fn) self.assertEqual(len(rx), 1) rx = rx[0] self.validate_ns(rx_intf, rx, tgt_ip) def verify_ip(self, rx, smac, dmac, sip, dip): ether = rx[Ether] self.assertEqual(ether.dst, dmac) self.assertEqual(ether.src, smac) ip = rx[IPv6] self.assertEqual(ip.src, sip) self.assertEqual(ip.dst, dip) class TestIPv6(TestIPv6ND): """ IPv6 Test Case """ @classmethod def setUpClass(cls): super(TestIPv6, cls).setUpClass() def setUp(self): """ Perform test setup before test case. **Config:** - create 3 pg interfaces - untagged pg0 interface - Dot1Q subinterface on pg1 - Dot1AD subinterface on pg2 - setup interfaces: - put it into UP state - set IPv6 addresses - resolve neighbor address using NDP - configure 200 fib entries :ivar list interfaces: pg interfaces and subinterfaces. :ivar dict flows: IPv4 packet flows in test. *TODO:* Create AD sub interface """ super(TestIPv6, self).setUp() # create 3 pg interfaces self.create_pg_interfaces(range(3)) # create 2 subinterfaces for p1 and pg2 self.sub_interfaces = [ VppDot1QSubint(self, self.pg1, 100), VppDot1QSubint(self, self.pg2, 200) # TODO: VppDot1ADSubint(self, self.pg2, 200, 300, 400) ] # packet flows mapping pg0 -> pg1.sub, pg2.sub, etc. self.flows = dict() self.flows[self.pg0] = [self.pg1.sub_if, self.pg2.sub_if] self.flows[self.pg1.sub_if] = [self.pg0, self.pg2.sub_if] self.flows[self.pg2.sub_if] = [self.pg0, self.pg1.sub_if] # packet sizes self.pg_if_packet_sizes = [64, 1500, 9020] self.interfaces = list(self.pg_interfaces) self.interfaces.extend(self.sub_interfaces) # setup all interfaces for i in self.interfaces: i.admin_up() i.config_ip6() i.resolve_ndp() # config 2M FIB entries self.config_fib_entries(200) def tearDown(self): """Run standard test teardown and log ``show ip6 neighbors``.""" for i in self.interfaces: i.unconfig_ip6() i.ip6_disable() i.admin_down() for i in self.sub_interfaces: i.remove_vpp_config() super(TestIPv6, self).tearDown() if not self.vpp_dead: self.logger.info(self.vapi.cli("show ip6 neighbors")) # info(self.vapi.cli("show ip6 fib")) # many entries def config_fib_entries(self, count): """For each interface add to the FIB table *count* routes to "fd02::1/128" destination with interface's local address as next-hop address. :param int count: Number of FIB entries. - *TODO:* check if the next-hop address shouldn't be remote address instead of local address. """ n_int = len(self.interfaces) percent = 0 counter = 0.0 dest_addr = inet_pton(AF_INET6, "fd02::1") dest_addr_len = 128 for i in self.interfaces: next_hop_address = i.local_ip6n for j in range(count / n_int): self.vapi.ip_add_del_route( dest_addr, dest_addr_len, next_hop_address, is_ipv6=1) counter += 1 if counter / count * 100 > percent: self.logger.info("Configure %d FIB entries .. %d%% done" % (count, percent)) percent += 1 def modify_packet(self, src_if, packet_size, pkt): """Add load, set destination IP and extend packet to required packet size for defined interface. :param VppInterface src_if: Interface to create packet for. :param int packet_size: Required packet size. :param Scapy pkt: Packet to be modified. """ dst_if_idx = packet_size / 10 % 2 dst_if = self.flows[src_if][dst_if_idx] info = self.create_packet_info(src_if, dst_if) payload = self.info_to_payload(info) p = pkt / Raw(payload) p[IPv6].dst = dst_if.remote_ip6 info.data = p.copy() if isinstance(src_if, VppSubInterface): p = src_if.add_dot1_layer(p) self.extend_packet(p, packet_size) return p def create_stream(self, src_if): """Create input packet stream for defined interface. :param VppInterface src_if: Interface to create packet stream for. """ hdr_ext = 4 if isinstance(src_if, VppSubInterface) else 0 pkt_tmpl = (Ether(dst=src_if.local_mac, src=src_if.remote_mac) / IPv6(src=src_if.remote_ip6) / inet6.UDP(sport=1234, dport=1234)) pkts = [self.modify_packet(src_if, i, pkt_tmpl) for i in moves.range(self.pg_if_packet_sizes[0], self.pg_if_packet_sizes[1], 10)] pkts_b = [self.modify_packet(src_if, i, pkt_tmpl) for i in moves.range(self.pg_if_packet_sizes[1] + hdr_ext, self.pg_if_packet_sizes[2] + hdr_ext, 50)] pkts.extend(pkts_b) return pkts def verify_capture(self, dst_if, capture): """Verify captured input packet stream for defined interface. :param VppInterface dst_if: Interface to verify captured packet stream for. :param list capture: Captured packet stream. """ self.logger.info("Verifying capture on interface %s" % dst_if.name) last_info = dict() for i in self.interfaces: last_info[i.sw_if_index] = None is_sub_if = False dst_sw_if_index = dst_if.sw_if_index if hasattr(dst_if, 'parent'): is_sub_if = True for packet in capture: if is_sub_if: # Check VLAN tags and Ethernet header packet = dst_if.remove_dot1_layer(packet) self.assertTrue(Dot1Q not in packet) try: ip = packet[IPv6] udp = packet[inet6.UDP] payload_info = self.payload_to_info(str(packet[Raw])) packet_index = payload_info.index self.assertEqual(payload_info.dst, dst_sw_if_index) self.logger.debug( "Got packet on port %s: src=%u (id=%u)" % (dst_if.name, payload_info.src, packet_index)) next_info = self.get_next_packet_info_for_interface2( payload_info.src, dst_sw_if_index, last_info[payload_info.src]) last_info[payload_info.src] = next_info self.assertTrue(next_info is not None) self.assertEqual(packet_index, next_info.index) saved_packet = next_info.data # Check standard fields self.assertEqual( ip.src, saved_packet[IPv6].src) self.assertEqual( ip.dst, saved_packet[IPv6].dst) self.assertEqual( udp.sport, saved_packet[inet6.UDP].sport) self.assertEqual( udp.dport, saved_packet[inet6.UDP].dport) except: self.logger.error(ppp("Unexpected or invalid packet:", packet)) raise for i in self.interfaces: remaining_packet = self.get_next_packet_info_for_interface2( i.sw_if_index, dst_sw_if_index, last_info[i.sw_if_index]) self.assertTrue(remaining_packet is None, "Interface %s: Packet expected from interface %s " "didn't arrive" % (dst_if.name, i.name)) def test_fib(self): """ IPv6 FIB test Test scenario: - Create IPv6 stream for pg0 interface - Create IPv6 tagged streams for pg1's and pg2's subinterface. - Send and verify received packets on each interface. """ pkts = self.create_stream(self.pg0) self.pg0.add_stream(pkts) for i in self.sub_interfaces: pkts = self.create_stream(i) i.parent.add_stream(pkts) self.pg_enable_capture(self.pg_interfaces) self.pg_start() pkts = self.pg0.get_capture() self.verify_capture(self.pg0, pkts) for i in self.sub_interfaces: pkts = i.parent.get_capture() self.verify_capture(i, pkts) def test_ns(self): """ IPv6 Neighbour Solicitation Exceptions Test scenario: - Send an NS Sourced from an address not covered by the link sub-net - Send an NS to an mcast address the router has not joined - Send NS for a target address the router does not onn. """ # # An NS from a non link source address # nsma = in6_getnsma(inet_pton(AF_INET6, self.pg0.local_ip6)) d = inet_ntop(AF_INET6, nsma) p = (Ether(dst=in6_getnsmac(nsma)) / IPv6(dst=d, src="2002::2") / ICMPv6ND_NS(tgt=self.pg0.local_ip6) / ICMPv6NDOptSrcLLAddr( lladdr=self.pg0.remote_mac)) pkts = [p] self.send_and_assert_no_replies( self.pg0, pkts, "No response to NS source by address not on sub-net") # # An NS for sent to a solicited mcast group the router is # not a member of FAILS # if 0: nsma = in6_getnsma(inet_pton(AF_INET6, "fd::ffff")) d = inet_ntop(AF_INET6, nsma) p = (Ether(dst=in6_getnsmac(nsma)) / IPv6(dst=d, src=self.pg0.remote_ip6) / ICMPv6ND_NS(tgt=self.pg0.local_ip6) / ICMPv6NDOptSrcLLAddr( lladdr=self.pg0.remote_mac)) pkts = [p] self.send_and_assert_no_replies( self.pg0, pkts, "No response to NS sent to unjoined mcast address") # # An NS whose target address is one the router does not own # nsma = in6_getnsma(inet_pton(AF_INET6, self.pg0.local_ip6)) d = inet_ntop(AF_INET6, nsma) p = (Ether(dst=in6_getnsmac(nsma)) / IPv6(dst=d, src=self.pg0.remote_ip6) / ICMPv6ND_NS(tgt="fd::ffff") / ICMPv6NDOptSrcLLAddr( lladdr=self.pg0.remote_mac)) pkts = [p] self.send_and_assert_no_replies(self.pg0, pkts, "No response to NS for unknown target") # # A neighbor entry that has no associated FIB-entry # self.pg0.generate_remote_hosts(4) nd_entry = VppNeighbor(self, self.pg0.sw_if_index, self.pg0.remote_hosts[2].mac, self.pg0.remote_hosts[2].ip6, is_no_fib_entry=1) nd_entry.add_vpp_config() # # check we have the neighbor, but no route # self.assertTrue(find_nbr(self, self.pg0.sw_if_index, self.pg0._remote_hosts[2].ip6)) self.assertFalse(find_route(self, self.pg0._remote_hosts[2].ip6, 128, inet=AF_INET6)) # # send an NS from a link local address to the interface's global # address # p = (Ether(dst=in6_getnsmac(nsma), src=self.pg0.remote_mac) / IPv6( dst=d, src=self.pg0._remote_hosts[2].ip6_ll) / ICMPv6ND_NS(tgt=self.pg0.local_ip6) / ICMPv6NDOptSrcLLAddr( lladdr=self.pg0.remote_mac)) self.send_and_expect_na(self.pg0, p, "NS from link-local", dst_ip=self.pg0._remote_hosts[2].ip6_ll, tgt_ip=self.pg0.local_ip6) # # we should have learned an ND entry for the peer's link-local # but not inserted a route to it in the FIB # self.assertTrue(find_nbr(self, self.pg0.sw_if_index, self.pg0._remote_hosts[2].ip6_ll)) self.assertFalse(find_route(self, self.pg0._remote_hosts[2].ip6_ll, 128, inet=AF_INET6)) # # An NS to the router's own Link-local # p = (Ether(dst=in6_getnsmac(nsma), src=self.pg0.remote_mac) / IPv6( dst=d, src=self.pg0._remote_hosts[3].ip6_ll) / ICMPv6ND_NS(tgt=self.pg0.local_ip6_ll) / ICMPv6NDOptSrcLLAddr( lladdr=self.pg0.remote_mac)) self.send_and_expect_na(self.pg0, p, "NS to/from link-local", dst_ip=self.pg0._remote_hosts[3].ip6_ll, tgt_ip=self.pg0.local_ip6_ll) # # we should have learned an ND entry for the peer's link-local # but not inserted a route to it in the FIB # self.assertTrue(find_nbr(self, self.pg0.sw_if_index, self.pg0._remote_hosts[3].ip6_ll)) self.assertFalse(find_route(self, self.pg0._remote_hosts[3].ip6_ll, 128, inet=AF_INET6)) def test_ns_duplicates(self): """ ND Duplicates""" # # Generate some hosts on the LAN # self.pg1.generate_remote_hosts(3) # # Add host 1 on pg1 and pg2 # ns_pg1 = VppNeighbor(self, self.pg1.sw_if_index, self.pg1.remote_hosts[1].mac, self.pg1.remote_hosts[1].ip6) ns_pg1.add_vpp_config() ns_pg2 = VppNeighbor(self, self.pg2.sw_if_index, self.pg2.remote_mac, self.pg1.remote_hosts[1].ip6) ns_pg2.add_vpp_config() # # IP packet destined for pg1 remote host arrives on pg1 again. # p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(src=self.pg0.remote_ip6, dst=self.pg1.remote_hosts[1].ip6) / inet6.UDP(sport=1234, dport=1234) / Raw()) self.pg0.add_stream(p) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx1 = self.pg1.get_capture(1) self.verify_ip(rx1[0], self.pg1.local_mac, self.pg1.remote_hosts[1].mac, self.pg0.remote_ip6, self.pg1.remote_hosts[1].ip6) # # remove the duplicate on pg1 # packet stream shoud generate NSs out of pg1 # ns_pg1.remove_vpp_config() self.send_and_expect_ns(self.pg0, self.pg1, p, self.pg1.remote_hosts[1].ip6) # # Add it back # ns_pg1.add_vpp_config() self.pg0.add_stream(p) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx1 = self.pg1.get_capture(1) self.verify_ip(rx1[0], self.pg1.local_mac, self.pg1.remote_hosts[1].mac, self.pg0.remote_ip6, self.pg1.remote_hosts[1].ip6) def validate_ra(self, intf, rx, dst_ip=None, mtu=9000, pi_opt=None): if not dst_ip: dst_ip = intf.remote_ip6 # unicasted packets must come to the unicast mac self.assertEqual(rx[Ether].dst, intf.remote_mac) # and from the router's MAC self.assertEqual(rx[Ether].src, intf.local_mac) # the rx'd RA should be addressed to the sender's source self.assertTrue(rx.haslayer(ICMPv6ND_RA)) self.assertEqual(in6_ptop(rx[IPv6].dst), in6_ptop(dst_ip)) # and come from the router's link local self.assertTrue(in6_islladdr(rx[IPv6].src)) self.assertEqual(in6_ptop(rx[IPv6].src), in6_ptop(mk_ll_addr(intf.local_mac))) # it should contain the links MTU ra = rx[ICMPv6ND_RA] self.assertEqual(ra[ICMPv6NDOptMTU].mtu, mtu) # it should contain the source's link layer address option sll = ra[ICMPv6NDOptSrcLLAddr] self.assertEqual(sll.lladdr, intf.local_mac) if not pi_opt: # the RA should not contain prefix information self.assertFalse(ra.haslayer( ICMPv6NDOptPrefixInfo)) else: raos = rx.getlayer(ICMPv6NDOptPrefixInfo, 1) # the options are nested in the scapy packet in way that i cannot # decipher how to decode. this 1st layer of option always returns # nested classes, so a direct obj1=obj2 comparison always fails. # however, the getlayer(.., 2) does give one instnace. # so we cheat here and construct a new opt instnace for comparison rd = ICMPv6NDOptPrefixInfo( prefixlen=raos.prefixlen, prefix=raos.prefix, L=raos.L, A=raos.A) if type(pi_opt) is list: for ii in range(len(pi_opt)): self.assertEqual(pi_opt[ii], rd) rd = rx.getlayer( ICMPv6NDOptPrefixInfo, ii + 2) else: self.assertEqual(pi_opt, raos) def send_and_expect_ra(self, intf, pkts, remark, dst_ip=None, filter_out_fn=is_ipv6_misc, opt=None): intf.add_stream(pkts) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = intf.get_capture(1, filter_out_fn=filter_out_fn) self.assertEqual(len(rx), 1) rx = rx[0] self.validate_ra(intf, rx, dst_ip, pi_opt=opt) def test_rs(self): """ IPv6 Router Solicitation Exceptions Test scenario: """ # # Before we begin change the IPv6 RA responses to use the unicast # address - that way we will not confuse them with the periodic # RAs which go to the mcast address # Sit and wait for the first periodic RA. # # TODO # self.pg0.ip6_ra_config(send_unicast=1) # # An RS from a link source address # - expect an RA in return # p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6( dst=self.pg0.local_ip6, src=self.pg0.remote_ip6) / ICMPv6ND_RS()) pkts = [p] self.send_and_expect_ra(self.pg0, pkts, "Genuine RS") # # For the next RS sent the RA should be rate limited # self.send_and_assert_no_replies(self.pg0, pkts, "RA rate limited") # # When we reconfiure the IPv6 RA config, we reset the RA rate limiting, # so we need to do this before each test below so as not to drop # packets for rate limiting reasons. Test this works here. # self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, pkts, "Rate limit reset RS") # # An RS sent from a non-link local source # self.pg0.ip6_ra_config(send_unicast=1) p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(dst=self.pg0.local_ip6, src="2002::ffff") / ICMPv6ND_RS()) pkts = [p] self.send_and_assert_no_replies(self.pg0, pkts, "RS from non-link source") # # Source an RS from a link local address # self.pg0.ip6_ra_config(send_unicast=1) ll = mk_ll_addr(self.pg0.remote_mac) p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(dst=self.pg0.local_ip6, src=ll) / ICMPv6ND_RS()) pkts = [p] self.send_and_expect_ra(self.pg0, pkts, "RS sourced from link-local", dst_ip=ll) # # Send the RS multicast # self.pg0.ip6_ra_config(send_unicast=1) dmac = in6_getnsmac(inet_pton(AF_INET6, "ff02::2")) ll = mk_ll_addr(self.pg0.remote_mac) p = (Ether(dst=dmac, src=self.pg0.remote_mac) / IPv6(dst="ff02::2", src=ll) / ICMPv6ND_RS()) pkts = [p] self.send_and_expect_ra(self.pg0, pkts, "RS sourced from link-local", dst_ip=ll) # # Source from the unspecified address ::. This happens when the RS # is sent before the host has a configured address/sub-net, # i.e. auto-config. Since the sender has no IP address, the reply # comes back mcast - so the capture needs to not filter this. # If we happen to pick up the periodic RA at this point then so be it, # it's not an error. # self.pg0.ip6_ra_config(send_unicast=1, suppress=1) p = (Ether(dst=dmac, src=self.pg0.remote_mac) / IPv6(dst="ff02::2", src="::") / ICMPv6ND_RS()) pkts = [p] self.send_and_expect_ra(self.pg0, pkts, "RS sourced from unspecified", dst_ip="ff02::1", filter_out_fn=None) # # Configure The RA to announce the links prefix # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len) # # RAs should now contain the prefix information option # opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=1, A=1) self.pg0.ip6_ra_config(send_unicast=1) ll = mk_ll_addr(self.pg0.remote_mac) p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(dst=self.pg0.local_ip6, src=ll) / ICMPv6ND_RS()) self.send_and_expect_ra(self.pg0, p, "RA with prefix-info", dst_ip=ll, opt=opt) # # Change the prefix info to not off-link # L-flag is clear # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len, off_link=1) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=0, A=1) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix info with L-flag=0", dst_ip=ll, opt=opt) # # Change the prefix info to not off-link, no-autoconfig # L and A flag are clear in the advert # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len, off_link=1, no_autoconfig=1) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=0, A=0) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix info with A & L-flag=0", dst_ip=ll, opt=opt) # # Change the flag settings back to the defaults # L and A flag are set in the advert # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=1, A=1) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix info", dst_ip=ll, opt=opt) # # Change the prefix info to not off-link, no-autoconfig # L and A flag are clear in the advert # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len, off_link=1, no_autoconfig=1) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=0, A=0) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix info with A & L-flag=0", dst_ip=ll, opt=opt) # # Use the reset to defults option to revert to defaults # L and A flag are clear in the advert # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len, use_default=1) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=1, A=1) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix reverted to defaults", dst_ip=ll, opt=opt) # # Advertise Another prefix. With no L-flag/A-flag # self.pg0.ip6_ra_prefix(self.pg1.local_ip6, self.pg1.local_ip6_prefix_len, off_link=1, no_autoconfig=1) opt = [ICMPv6NDOptPrefixInfo( prefixlen=self.pg0.local_ip6_prefix_len, prefix=self.pg0.local_ip6, L=1, A=1), ICMPv6NDOptPrefixInfo( prefixlen=self.pg1.local_ip6_prefix_len, prefix=self.pg1.local_ip6, L=0, A=0)] self.pg0.ip6_ra_config(send_unicast=1) ll = mk_ll_addr(self.pg0.remote_mac) p = (Ether(dst=self.pg0.local_mac, src=self.pg0.remote_mac) / IPv6(dst=self.pg0.local_ip6, src=ll) / ICMPv6ND_RS()) self.send_and_expect_ra(self.pg0, p, "RA with multiple Prefix infos", dst_ip=ll, opt=opt) # # Remove the first refix-info - expect the second is still in the # advert # self.pg0.ip6_ra_prefix(self.pg0.local_ip6, self.pg0.local_ip6_prefix_len, is_no=1) opt = ICMPv6NDOptPrefixInfo( prefixlen=self.pg1.local_ip6_prefix_len, prefix=self.pg1.local_ip6, L=0, A=0) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix reverted to defaults", dst_ip=ll, opt=opt) # # Remove the second prefix-info - expect no prefix-info i nthe adverts # self.pg0.ip6_ra_prefix(self.pg1.local_ip6, self.pg1.local_ip6_prefix_len, is_no=1) self.pg0.ip6_ra_config(send_unicast=1) self.send_and_expect_ra(self.pg0, p, "RA with Prefix reverted to defaults", dst_ip=ll) # # Reset the periodic advertisements back to default values # self.pg0.ip6_ra_config(no=1, suppress=1, send_unicast=0) class TestICMPv6Echo(VppTestCase): """ ICMPv6 Echo Test Case """ def setUp(self): super(TestICMPv6Echo, self).setUp() # create 1 pg interface self.create_pg_interfaces(range(1)) for i in self.pg_interfaces: i.admin_up() i.config_ip6() i.resolve_ndp() def tearDown(self): super(TestICMPv6Echo, self).tearDown() for i in self.pg_interfaces: i.unconfig_ip6() i.ip6_disable() i.admin_down() def test_icmpv6_echo(self): """ VPP replies to ICMPv6 Echo Request Test scenario: - Receive ICMPv6 Echo Request message on pg0 interface. - Check outgoing ICMPv6 Echo Reply message on pg0 interface. """ icmpv6_id = 0xb icmpv6_seq = 5 icmpv6_data = '\x0a' * 18 p_echo_request = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) / IPv6(src=self.pg0.remote_ip6, dst=self.pg0.local_ip6) / ICMPv6EchoRequest( id=icmpv6_id, seq=icmpv6_seq, data=icmpv6_data)) self.pg0.add_stream(p_echo_request) self.pg_enable_capture(self.pg_interfaces) self.pg_start() rx = self.pg0.get_capture(1) rx = rx[0] ether = rx[Ether] ipv6 = rx[IPv6] icmpv6 = rx[ICMPv6EchoReply] self.assertEqual(ether.src, self.pg0.local_mac) self.assertEqual(ether.dst, self.pg0.remote_mac) self.assertEqual(ipv6.src, self.pg0.local_ip6) self.assertEqual(ipv6.dst, self.pg0.remote_ip6) self.assertEqual( icmp6types[icmpv6.type], "Echo Reply") self.assertEqual(icmpv6.id, icmpv6_id) self.assertEqual(icmpv6.seq, icmpv6_seq) self.assertEqual(icmpv6.data, icmpv6_data) class TestIPv6RD(TestIPv6ND): """ IPv6 Router Discovery Test Case """ @classmethod def setUpClass(cls): super(TestIPv6RD, cls).setUpClass() def setUp(self): super(TestIPv6RD, self).setUp() # create 2 pg interfaces s
/*
* Copyright (c) 2018 Cisco and/or its affiliates.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <vppinfra/types.h>
#include <vlib/vlib.h>
#include <vlib/pci/pci.h>
#include <vnet/ethernet/ethernet.h>
#include <vnet/plugin/plugin.h>
#include <vpp/app/version.h>
#include <vmxnet3/vmxnet3.h>
#define PCI_VENDOR_ID_VMWARE 0x15ad
#define PCI_DEVICE_ID_VMWARE_VMXNET3 0x07b0
vmxnet3_main_t vmxnet3_main;
static pci_device_id_t vmxnet3_pci_device_ids[] = {
{
.vendor_id = PCI_VENDOR_ID_VMWARE,
.device_id = PCI_DEVICE_ID_VMWARE_VMXNET3},
{0},
};
static clib_error_t *
vmxnet3_interface_admin_up_down (vnet_main_t * vnm, u32 hw_if_index,
u32 flags)
{
vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
vmxnet3_main_t *vmxm = &vmxnet3_main;
vmxnet3_device_t *vd = vec_elt_at_index (vmxm->devices, hi->dev_instance);
uword is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
if (vd->flags & VMXNET3_DEVICE_F_ERROR)
return clib_error_return (0, "device is in error state");
if (is_up)
{
vnet_hw_interface_set_flags (vnm, vd->hw_if_index,
VNET_HW_INTERFACE_FLAG_LINK_UP);
vd->flags |= VMXNET3_DEVICE_F_ADMIN_UP;
}
else
{
vnet_hw_interface_set_flags (vnm, vd->hw_if_index, 0);
vd->flags &= ~VMXNET3_DEVICE_F_ADMIN_UP;
}
return 0;
}
static clib_error_t *
vmxnet3_interface_rx_mode_change (vnet_main_t * vnm, u32 hw_if_index, u32 qid,
vnet_hw_interface_rx_mode mode)
{
vmxnet3_main_t *vmxm = &vmxnet3_main;
vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);
vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
rxq->int_mode = 0;
else
rxq->int_mode = 1;
return 0;
}
static void
vmxnet3_set_interface_next_node (vnet_main_t * vnm, u32 hw_if_index,
u32 node_index)
{
vmxnet3_main_t *vmxm = &vmxnet3_main;
vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, hw->dev_instance);
/* Shut off redirection */
if (node_index == ~0)
{
vd->per_interface_next_index = node_index;
return;
}
vd->per_interface_next_index =
vlib_node_add_next (vlib_get_main (), vmxnet3_input_node.index,
node_index);
}
static void
vmxnet3_clear_hw_interface_counters (u32 instance)
{
vmxnet3_main_t *vmxm = &vmxnet3_main;
vmxnet3_device_t *vd = pool_elt_at_index (vmxm->devices, instance);
vmxnet3_tx_queue *tx = VMXNET3_TX_START (vd);
vmxnet3_rx_queue *rx = VMXNET3_RX_START (vd);
u16 qid;
/*
* Set the "last_cleared_stats" to the current stats, so that
* things appear to clear from a display perspective.
*/
vmxnet3_reg_write (vd, 1, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS);
vec_foreach_index (qid, vd->txqs)
{
vmxnet3_tx_stats *txs = vec_elt_at_index (vd->tx_stats, qid);
clib_memcpy (txs, &tx->stats, sizeof (*txs));
tx++;
}
vec_foreach_index (qid, vd->rxqs)
{
vmxnet3_rx_stats *rxs = vec_elt_at_index (vd->rx_stats, qid);
clib_memcpy (rxs, &rx->stats, sizeof (*rxs));
rx++;
}
}
static char *vmxnet3_tx_func_error_strings[] = {
#define _(n,s) s,
foreach_vmxnet3_tx_func_error
#undef _
};
/* *INDENT-OFF* */
VNET_DEVICE_CLASS (vmxnet3_device_class,) =
{
.name = "VMXNET3 interface",
.format_device = format_vmxnet3_device,
.format_device_name = format_vmxnet3_device_name,
.admin_up_down_function = vmxnet3_interface_admin_up_down,
.clear_counters = vmxnet3_clear_hw_interface_counters,
.rx_mode_change_function = vmxnet3_interface_rx_mode_change,
.rx_redirect_to_node = vmxnet3_set_interface_next_node,
.tx_function_n_errors = VMXNET3_TX_N_ERROR,
.tx_function_error_strings = vmxnet3_tx_func_error_strings,
};
/* *INDENT-ON* */
static u32
vmxnet3_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw, u32 flags)
{
return 0;
}
static void
vmxnet3_write_mac (vmxnet3_device_t * vd)
{
u32 val;
memcpy (&val, vd->mac_addr, 4);
vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACL, val);
val = 0;
memcpy (&val, vd->mac_addr + 4, 2);
vmxnet3_reg_write (vd, 1, VMXNET3_REG_MACH, val);
}
static clib_error_t *
vmxnet3_provision_driver_shared (vlib_main_t * vm, vmxnet3_device_t * vd)
{
vmxnet3_shared *shared;
u64 shared_dma;
u16 qid, rid;
vmxnet3_tx_queue *tx = VMXNET3_TX_START (vd);
vmxnet3_rx_queue *rx = VMXNET3_RX_START (vd);
vd->driver_shared =
vlib_physmem_alloc_aligned_on_numa (vm, sizeof (*vd->driver_shared), 512,
vd->numa_node);
if (vd->driver_shared == 0)
return vlib_physmem_last_error (vm);
clib_memset (vd->driver_shared, 0, sizeof (*vd->driver_shared));
vec_foreach_index (qid, vd->txqs)
{
vmxnet3_txq_t *txq = vec_elt_at_index (vd->txqs, qid);
tx->cfg.desc_address = vmxnet3_dma_addr (vm, vd, txq->tx_desc);
tx->cfg.comp_address = vmxnet3_dma_addr (vm, vd, txq->tx_comp);
tx->cfg.num_desc = txq->size;
tx->cfg.num_comp = txq->size;
tx++;
}
vec_foreach_index (qid, vd->rxqs)
{
vmxnet3_rxq_t *rxq = vec_elt_at_index (vd->rxqs, qid);
for (rid = 0; rid < VMXNET3_RX_RING_SIZE; rid++)
{
rx->cfg.desc_address[rid] = vmxnet3_dma_addr (vm, vd,
rxq->rx_desc[rid]);
rx->cfg.num_desc[rid] = rxq->size;
}
rx->cfg.comp_address = vmxnet3_dma_addr (vm, vd, rxq->rx_comp);
rx->cfg.num_comp = rxq->size;
rx->cfg.intr_index = qid;
rx++;
}
shared = vd->driver_shared;
shared->magic = VMXNET3_SHARED_MAGIC;
shared->misc.version = VMXNET3_VERSION_MAGIC;
if (sizeof (void *) == 4)
shared->misc.guest_info = VMXNET3_GOS_BITS_32;
else
shared->misc.guest_info = VMXNET3_GOS_BITS_64;
shared->misc.guest_info |= VMXNET3_GOS_TYPE_LINUX;
shared->misc.version_support = VMXNET3_VERSION_SELECT;
shared->misc.upt_features = VMXNET3_F_RXCSUM;
if (vd->lro_enable)
shared->misc.upt_features |= VMXNET3_F_LRO;
if (vd->num_rx_queues > 1)
{
shared->misc.upt_features |= VMXNET3_F_RSS;
shared->rss.version = 1;
shared->rss.address = vmxnet3_dma_addr (vm, vd, vd->rss);
shared->rss.length = sizeof (*vd->rss);
}
shared->misc.max_num_rx_sg = 0;
shared->misc.upt_version_support = VMXNET3_UPT_VERSION_SELECT;
shared->misc.queue_desc_address = vmxnet3_dma_addr (vm, vd, vd->queues);
shared->misc.queue_desc_len = sizeof (*tx) * vd->num_tx_queues +
sizeof (*rx) * vd->num_rx_queues;
shared->misc.mtu = VMXNET3_MTU;
shared->misc.num_tx_queues = vd->num_tx_queues;
shared->misc.num_rx_queues = vd->num_rx_queues;
shared->interrupt.num_intrs = vd->num_intrs;
shared->interrupt.event_intr_index = vd->num_rx_queues;
shared->interrupt.control = VMXNET3_IC_DISABLE_ALL;
shared->rx_filter.mode = VMXNET3_RXMODE_UCAST