def run_live_capture(wireless_interface, capture_file, sample_seconds):
pcap_dev = pcapy.create(wireless_interface)
pcap_dev.set_snaplen(65535)
pcap_dev.set_timeout(0)
pcap_dev.set_promisc(True)
pcap_dev.set_buffer_size(15 * 1024 * 1024)
procedure_logger.info("Opening capture file: {0}".format(capture_file))
procedure_logger.info("Arming and activating live capture...")
pcap_dev.activate()
timer_fd = timerfd.create(timerfd.CLOCK_MONOTONIC, 0)
try:
timerfd.settime(timer_fd, 0, sample_seconds, 0)
start_time = time.time()
dumper = pcap_dev.dump_open(capture_file)
hdr, data = pcap_dev.next()
while hdr and not select.select([timer_fd], [], [], 0)[0]:
dumper.dump(hdr, data)
hdr, data = pcap_dev.next()
dumper.close()
pcap_dev.close()
end_time = time.time()
return start_time, end_time, sample_seconds
finally:
os.close(timer_fd)
def create_timer(self, callback, timeout=None, interval=None):
"""
Creates a timer.
:param callback: Callback to fire on timeout
:param timeout: Delay before timer fires first
:param interval: Interval for repeating timers
:return: Timer object, which may be used to stop the timer
"""
if not self.event_loop:
raise PollableNotRegistered
if interval is not None and timeout is None:
timeout = interval
timer = timerfd.create(timerfd.CLOCK_MONOTONIC)
timerfd.settime(timer, 0,
timerfd.itimerspec(value=timeout, interval=interval))
class Timer(object):
def read(timer_self, file_object):
try:
if not os.read(timer, timerfd.bufsize):
return timer_self.close()
except OSError as e:
if e.args[0] in (errno.EINTR, errno.EAGAIN):
return
raise
try:
callback()
finally:
# Unregister the timer if it is a one-shot timer.
if interval is None:
timer_self.close()
def close(timer_self):
self.event_loop.unregister(timer)
self.timers.remove(timer_self)
os.close(timer)
handler = Timer()
self.event_loop.register(handler, timer, select.EPOLLIN)
self.timers.add(handler)
return handler
def create_timer(self, callback, timeout=None, interval=None):
"""
Creates a timer.
:param callback: Callback to fire on timeout
:param timeout: Delay before timer fires first
:param interval: Interval for repeating timers
:return: Timer object, which may be used to stop the timer
"""
if not self.event_loop:
raise PollableNotRegistered
if interval is not None and timeout is None:
timeout = interval
timer = timerfd.create(timerfd.CLOCK_MONOTONIC)
timerfd.settime(timer, 0, timerfd.itimerspec(value=timeout, interval=interval))
class Timer(object):
def read(timer_self, file_object):
try:
if not os.read(timer, timerfd.bufsize):
return timer_self.close()
except OSError as e:
if e.args[0] in (errno.EINTR, errno.EAGAIN):
return
raise
try:
callback()
finally:
# Unregister the timer if it is a one-shot timer.
if interval is None:
timer_self.close()
def close(timer_self):
self.event_loop.unregister(timer)
self.timers.remove(timer_self)
os.close(timer)
handler = Timer()
self.event_loop.register(handler, timer, select.EPOLLIN)
self.timers.add(handler)
return handler
def setupTimer(self):
if len(self.intervals) > 0:
earliest = min(self.intervals, key=lambda x: x["execTime"])
delay = max(0.001, earliest["execTime"] - time.time())
self.internalLog("setting delay " + str(delay) + " for interval " + earliest["id"])
timerfd.settime(self.timer, 0, delay, 0)
def get_timerfd(seconds: int):
fd = timerfd.create(timerfd.CLOCK_REALTIME, 0)
timerfd.settime(fd, 0, seconds, 0)
return fd
def set(self, seconds=None):
if seconds is None:
seconds = self.seconds
timerfd.settime(self.fd, 0, seconds, 0)
def settime(self, flags, new_value): return timerfd.settime(self.socket.fileno(), flags, new_value)
def settime(self, flags, new_value):
return timerfd.settime(self.socket.fileno(), flags, new_value)
