import os import time from scapy.utils import wrpcap, rdpcap, PcapReader from vpp_interface import VppInterface from scapy.layers.l2 import Ether, ARP from scapy.layers.inet6 import IPv6, ICMPv6ND_NS, ICMPv6ND_NA,\ ICMPv6NDOptSrcLLAddr, ICMPv6NDOptDstLLAddr from util import ppp class VppPGInterface(VppInterface): """ VPP packet-generator interface """ @property def pg_index(self): """packet-generator interface index assigned by VPP""" return self._pg_index @property def out_path(self): """pcap file path - captured packets""" return self._out_path @property def in_path(self): """ pcap file path - injected packets""" return self._in_path @property def capture_cli(self): """CLI string to start capture on this interface""" return self._capture_cli @property def cap_name(self): """capture name for this interface""" return self._cap_name @property def input_cli(self): """CLI string to load the injected packets""" return self._input_cli @property def in_history_counter(self): """Self-incrementing counter used when renaming old pcap files""" v = self._in_history_counter self._in_history_counter += 1 return v @property def out_history_counter(self): """Self-incrementing counter used when renaming old pcap files""" v = self._out_history_counter self._out_history_counter += 1 return v def __init__(self, test, pg_index): """ Create VPP packet-generator interface """ r = test.vapi.pg_create_interface(pg_index) self._sw_if_index = r.sw_if_index super(VppPGInterface, self).__init__(test) self._in_history_counter = 0 self._out_history_counter = 0 self._pg_index = pg_index self._out_file = "pg%u_out.pcap" % self.pg_index self._out_path = self.test.tempdir + "/" + self._out_file self._in_file = "pg%u_in.pcap" % self.pg_index self._in_path = self.test.tempdir + "/" + self._in_file self._capture_cli = "packet-generator capture pg%u pcap %s" % ( self.pg_index, self.out_path) self._cap_name = "pcap%u" % self.sw_if_index self._input_cli = "packet-generator new pcap %s source pg%u name %s" % ( self.in_path, self.pg_index, self.cap_name) def enable_capture(self): """ Enable capture on this packet-generator interface""" try: if os.path.isfile(self.out_path): os.rename(self.out_path, "%s/history.[timestamp:%f].[%s-counter:%04d].%s" % (self.test.tempdir, time.time(), self.name, self.out_history_counter, self._out_file)) except: pass # FIXME this should be an API, but no such exists atm self.test.vapi.cli(self.capture_cli) self._pcap_reader = None def add_stream(self, pkts): """ Add a stream of packets to this packet-generator :param pkts: iterable packets """ try: if os.path.isfile(self.in_path): os.rename(self.in_path, "%s/history.[timestamp:%f].[%s-counter:%04d].%s" % (self.test.tempdir, time.time(), self.name, self.in_history_counter, self._in_file)) except: pass wrpcap(self.in_path, pkts) # FIXME this should be an API, but no such exists atm self.test.vapi.cli(self.input_cli) self.test.pg_streams.append(self.cap_name) self.test.vapi.cli("trace add pg-input %d" % len(pkts)) def get_capture(self): """ Get captured packets :returns: iterable packets """ try: output = rdpcap(self.out_path) except IOError: # TODO self.test.logger.error("File %s does not exist, probably because no" " packets arrived" % self.out_path) return [] return output def wait_for_packet(self, timeout): """ Wait for next packet captured with a timeout :param timeout: How long to wait for the packet :returns: Captured packet if no packet arrived within timeout :raises Exception: if no packet arrives within timeout """ limit = time.time() + timeout if self._pcap_reader is None: self.test.logger.debug("Waiting for the capture file to appear") while time.time() < limit: if os.path.isfile(self.out_path): break time.sleep(0) # yield if os.path.isfile(self.out_path): self.test.logger.debug("Capture file appeared after %fs" % (time.time() - (limit - timeout))) self._pcap_reader = PcapReader(self.out_path) else: self.test.logger.debug("Timeout - capture file still nowhere") raise Exception("Packet didn't arrive within timeout") self.test.logger.debug("Waiting for packet") while time.time() < limit: p = self._pcap_reader.recv() if p is not None: self.test.logger.debug("Packet received after %fs", (time.time() - (limit - timeout))) return p time.sleep(0) # yield self.test.logger.debug("Timeout - no packets received") raise Exception("Packet didn't arrive within timeout") def create_arp_req(self): """Create ARP request applicable for this interface""" return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) / ARP(op=ARP.who_has, pdst=self.local_ip4, psrc=self.remote_ip4, hwsrc=self.remote_mac)) def create_ndp_req(self): """Create NDP - NS applicable for this interface""" return (Ether(dst="ff:ff:ff:ff:ff:ff", src=self.remote_mac) / IPv6(src=self.remote_ip6, dst=self.local_ip6) / ICMPv6ND_NS(tgt=self.local_ip6) / ICMPv6NDOptSrcLLAddr(lladdr=self.remote_mac)) def resolve_arp(self, pg_interface=None): """Resolve ARP using provided packet-generator interface :param pg_interface: interface used to resolve, if None then this interface is used """ if pg_interface is None: pg_interface = self self.test.logger.info("Sending ARP request for %s on port %s" % (self.local_ip4, pg_interface.name)) arp_req = self.create_arp_req() pg_interface.add_stream(arp_req) pg_interface.enable_capture() self.test.pg_start() self.test.logger.info(self.test.vapi.cli("show trace")) arp_reply = pg_interface.get_capture() if arp_reply is None or len(arp_reply) == 0: self.test.logger.info( "No ARP received on port %s" % pg_interface.name) return arp_reply = arp_reply[0] # Make Dot1AD packet content recognizable to scapy if arp_reply.type == 0x88a8: arp_reply.type = 0x8100 arp_reply = Ether(str(arp_reply)) try: if arp_reply[ARP].op == ARP.is_at: self.test.logger.info("VPP %s MAC address is %s " % (self.name, arp_reply[ARP].hwsrc)) self._local_mac = arp_reply[ARP].hwsrc else: self.test.logger.info( "No ARP received on port %s" % pg_interface.name) except: self.test.logger.error( ppp("Unexpected response to ARP request:", arp_reply)) raise def resolve_ndp(self, pg_interface=None): """Resolve NDP using provided packet-generator interface :param pg_interface: interface used to resolve, if None then this interface is used """ if pg_interface is None: pg_interface = self self.test.logger.info("Sending NDP request for %s on port %s" % (self.local_ip6, pg_interface.name)) ndp_req = self.create_ndp_req() pg_interface.add_stream(ndp_req) pg_interface.enable_capture() self.test.pg_start() self.test.logger.info(self.test.vapi.cli("show trace")) replies = pg_interface.get_capture() if replies is None or len(replies) == 0: self.test.logger.info( "No NDP received on port %s" % pg_interface.name) return # Enabling IPv6 on an interface can generate more than the # ND reply we are looking for (namely MLD). So loop through # the replies to look for want we want. for ndp_reply in replies: # Make Dot1AD packet content recognizable to scapy if ndp_reply.type == 0x88a8: ndp_reply.type = 0x8100 ndp_reply = Ether(str(ndp_reply)) try: ndp_na = ndp_reply[ICMPv6ND_NA] opt = ndp_na[ICMPv6NDOptDstLLAddr] self.test.logger.info("VPP %s MAC address is %s " % (self.name, opt.lladdr)) self._local_mac = opt.lladdr except: self.test.logger.info( ppp("Unexpected response to NDP request:", ndp_reply)) # if no packets above provided the local MAC, then this failed. if not hasattr(self, '_local_mac'): raise