from scapy.utils import inet_pton, inet_ntop
+class CaptureTimeoutError(Exception):
+ """ Exception raised if capture or packet doesn't appear within timeout """
+ pass
+
+
def is_ipv6_misc(p):
""" Is packet one of uninteresting IPv6 broadcasts? """
if p.haslayer(ICMPv6ND_RA):
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)
+ r = test.vapi.pg_create_interface(pg_index)
+ self.set_sw_if_index(r.sw_if_index)
+
self._in_history_counter = 0
self._out_history_counter = 0
self._out_assert_counter = 0
""" 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))
+ name = "%s/history.[timestamp:%f].[%s-counter:%04d].%s" % \
+ (self.test.tempdir,
+ time.time(),
+ self.name,
+ self.out_history_counter,
+ self._out_file)
+ self.test.logger.debug("Renaming %s->%s" %
+ (self.out_path, name))
+ os.rename(self.out_path, name)
except:
pass
# FIXME this should be an API, but no such exists atm
"""
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))
+ name = "%s/history.[timestamp:%f].[%s-counter:%04d].%s" %\
+ (self.test.tempdir,
+ time.time(),
+ self.name,
+ self.in_history_counter,
+ self._in_file)
+ self.test.logger.debug("Renaming %s->%s" %
+ (self.in_path, name))
+ os.rename(self.in_path, name)
except:
pass
wrpcap(self.in_path, pkts)
if len(capture.res) == expected_count:
# bingo, got the packets we expected
return capture
+ elif len(capture.res) > expected_count:
+ self.test.logger.error(
+ ppc("Unexpected packets captured:", capture))
+ break
else:
self.test.logger.debug("Partial capture containing %s "
"packets doesn't match expected "
if not capture or len(capture.res) == 0:
# junk filtered out, we're good
return
- self.test.logger.error(
- ppc("Unexpected packets captured:", capture))
except:
pass
self.generate_debug_aid("empty-assert")
:returns: True/False if the file is present or appears within timeout
"""
- limit = time.time() + timeout
+ deadline = time.time() + timeout
if not os.path.isfile(self.out_path):
self.test.logger.debug("Waiting for capture file %s to appear, "
"timeout is %ss" % (self.out_path, timeout))
else:
- self.test.logger.debug(
- "Capture file %s already exists" %
- self.out_path)
+ self.test.logger.debug("Capture file %s already exists" %
+ self.out_path)
return True
- while time.time() < limit:
+ while time.time() < deadline:
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)))
+ (time.time() - (deadline - timeout)))
else:
self.test.logger.debug("Timeout - capture file still nowhere")
return False
return True
- def wait_for_packet_data(self, deadline):
+ def verify_enough_packet_data_in_pcap(self):
"""
- Wait until enough data is available in the file handled by internal
- pcap reader so that a whole packet can be read.
+ Check if enough data is available in file handled by internal pcap
+ reader so that a whole packet can be read.
- :param deadline: timestamp by which the data must arrive
- :raises Exception: if not enough data by deadline
+ :returns: True if enough data present, else False
"""
orig_pos = self._pcap_reader.f.tell() # save file position
enough_data = False
- while time.time() < deadline:
- # read packet header from pcap
- hdr = self._pcap_reader.f.read(16)
- if len(hdr) < 16:
- time.sleep(0) # yield
- continue # cannot read full header, continue looping
- # find the capture length - caplen
+ # read packet header from pcap
+ packet_header_size = 16
+ caplen = None
+ end_pos = None
+ hdr = self._pcap_reader.f.read(packet_header_size)
+ if len(hdr) == packet_header_size:
+ # parse the capture length - caplen
sec, usec, caplen, wirelen = struct.unpack(
self._pcap_reader.endian + "IIII", hdr)
self._pcap_reader.f.seek(0, 2) # seek to end of file
end_pos = self._pcap_reader.f.tell() # get position at end
if end_pos >= orig_pos + len(hdr) + caplen:
enough_data = True # yay, we have enough data
- break
- self.test.logger.debug("Partial packet data in pcap")
- time.sleep(0) # yield
self._pcap_reader.f.seek(orig_pos, 0) # restore original position
- if not enough_data:
- raise Exception(
- "Not enough data to read a full packet within deadline")
+ return enough_data
def wait_for_packet(self, timeout, filter_out_fn=is_ipv6_misc):
"""
deadline = time.time() + timeout
if self._pcap_reader is None:
if not self.wait_for_capture_file(timeout):
- raise Exception("Capture file %s did not appear within "
- "timeout" % self.out_path)
+ raise CaptureTimeoutError("Capture file %s did not appear "
+ "within timeout" % self.out_path)
while time.time() < deadline:
try:
self._pcap_reader = PcapReader(self.out_path)
"Exception in scapy.PcapReader(%s): %s" %
(self.out_path, format_exc()))
if not self._pcap_reader:
- raise Exception("Capture file %s did not appear within "
- "timeout" % self.out_path)
+ raise CaptureTimeoutError("Capture file %s did not appear within "
+ "timeout" % self.out_path)
- self.test.logger.debug("Waiting for packet")
- while time.time() < deadline:
- self.wait_for_packet_data(deadline)
+ poll = False
+ if timeout > 0:
+ self.test.logger.debug("Waiting for packet")
+ else:
+ poll = True
+ self.test.logger.debug("Polling for packet")
+ while time.time() < deadline or poll:
+ if not self.verify_enough_packet_data_in_pcap():
+ time.sleep(0) # yield
+ poll = False
+ continue
p = self._pcap_reader.recv()
if p is not None:
if filter_out_fn is not None and filter_out_fn(p):
(time.time() - (deadline - timeout)))
return p
time.sleep(0) # yield
+ poll = False
self.test.logger.debug("Timeout - no packets received")
- raise Exception("Packet didn't arrive within timeout")
+ raise CaptureTimeoutError("Packet didn't arrive within timeout")
def create_arp_req(self):
"""Create ARP request applicable for this interface"""