def parse(self, data):
""" unpacks iwparam"""
size = struct_calcsize(self.fmt)
m, e, i, pad = struct_unpack(self.fmt, data[:size])
# XXX well, its not *the* frequency - we need a better name
if e == 0:
return m
else:
return float(m)*10**e
def parse(self, data):
""" unpacks iwparam"""
size = struct_calcsize(self.fmt)
m, e, i, pad = struct_unpack(self.fmt, data[:size])
# XXX well, its not *the* frequency - we need a better name
if e == 0:
return m
else:
return float(m) * 10**e
def parse_data(self, fmt, data):
""" unpacks raw C data """
size = struct_calcsize(fmt)
idx = self.idx
str = data[idx:idx + size]
self.idx = idx+size
value = struct_unpack(fmt, str)
# take care of a tuple like (int, )
if len(value) == 1:
return value[0]
else:
return value
def parse_data(self, fmt, data):
""" unpacks raw C data """
size = struct_calcsize(fmt)
idx = self.idx
str = data[idx:idx + size]
self.idx = idx + size
value = struct_unpack(fmt, str)
# take care of a tuple like (int, )
if len(value) == 1:
return value[0]
else:
return value
def import_bytes(cls, data: bytes, hash_function=None, base_offset: int = 0) -> BloomFilter:
"""
Import an exported `BloomFilter` byte sequence and make an instance.
:param data: A byte sequence from which to extract the data representing a `BloomFilter`.
:param hash_function: A hash function to use in case the exported name cannot be looked up in the `hashlib`.
module.
:param base_offset: The offset from the start of the byte sequence from where to start extracting.
:return: A `BloomFilter` instance as represented by the pointed-to byte sequence.
"""
offset = base_offset
capacity = struct_unpack_from('>Q', buffer=data, offset=offset)[0]
offset += struct_calcsize('>Q')
false_positive_probability = struct_unpack_from('f', buffer=data, offset=offset)[0]
offset += struct_calcsize('f')
hash_function_name_bytes_len: int = struct_unpack_from(cls._IMPORT_EXPORT_LENGTH_FORMAT, buffer=data, offset=offset)[0]
offset += struct_calcsize(cls._IMPORT_EXPORT_LENGTH_FORMAT)
hash_function_name: str = data[offset:offset+hash_function_name_bytes_len].decode()
offset += hash_function_name_bytes_len
bit_array_bytes_len: int = struct_unpack_from(cls._IMPORT_EXPORT_LENGTH_FORMAT, buffer=data, offset=offset)[0]
offset += struct_calcsize(cls._IMPORT_EXPORT_LENGTH_FORMAT)
bit_array = bitarray()
bit_array.frombytes(data[offset:offset + bit_array_bytes_len])
return cls(
capacity=capacity,
false_positive_probability=false_positive_probability,
hash_function=hash_function or getattr(hashlib, hash_function_name),
bit_array=bit_array
)
def addEvent(self, cmd, data):
"""Attempts to add the data from an event to a scanresult
Only certain data is accept, in which case the result is True
If the event data is invalid, None is returned
If the data is valid but unused, False is returned
"""
if cmd <= SIOCIWLAST:
if cmd < SIOCIWFIRST:
return None
elif cmd >= IWEVFIRST:
if cmd > IWEVLAST:
return None
else:
return None
if cmd == SIOCGIWESSID:
self.essid = data[4:]
elif cmd == SIOCGIWMODE:
self.mode = modes[self.iwstruct.unpack('i', data[:4])[0]]
elif cmd == SIOCGIWRATE:
# TODO, deal with multiple rates, or at least the highest rate
freqsize = struct_calcsize("ihbb")
while len(data) >= freqsize:
iwfreq = Iwfreq(data)
self.rate.append(iwfreq.getBitrate())
data = data[freqsize:]
elif cmd == IWEVQUAL:
self.quality.parse(data)
elif cmd == SIOCGIWFREQ:
self.frequency = Iwfreq(data)
elif cmd == SIOCGIWENCODE:
self.encode = data
elif cmd == IWEVCUSTOM:
self.custom.append(data[1:])
elif cmd == SIOCGIWNAME:
self.protocol = data[:len(data)-2]
else:
#print "Cmd:", cmd
return False
return True
def addEvent(self, cmd, data):
"""Attempts to add the data from an event to a scanresult
Only certain data is accept, in which case the result is True
If the event data is invalid, None is returned
If the data is valid but unused, False is returned
"""
if cmd <= SIOCIWLAST:
if cmd < SIOCIWFIRST:
return None
elif cmd >= IWEVFIRST:
if cmd > IWEVLAST:
return None
else:
return None
if cmd == SIOCGIWESSID:
self.essid = data[4:]
elif cmd == SIOCGIWMODE:
self.mode = modes[self.iwstruct.unpack('i', data[:4])[0]]
elif cmd == SIOCGIWRATE:
# TODO, deal with multiple rates, or at least the highest rate
freqsize = struct_calcsize("ihbb")
while len(data) >= freqsize:
iwfreq = Iwfreq(data)
self.rate.append(iwfreq.getBitrate())
data = data[freqsize:]
elif cmd == IWEVQUAL:
self.quality.parse(data)
elif cmd == SIOCGIWFREQ:
self.frequency = Iwfreq(data)
elif cmd == SIOCGIWENCODE:
self.encode = data
elif cmd == IWEVCUSTOM:
self.custom.append(data[1:])
elif cmd == SIOCGIWNAME:
self.protocol = data[:len(data) - 2]
else:
#print "Cmd:", cmd
return False
return True
def start_C_prog(self):
pid = os.fork()
if pid == 0:
#Child
sleep(1)
try:
os.execl(self.prog_path, self.prog_path, *self.prog_params)
except OSError:
print("OSerror exception")
raise
else:
#Parent
self.child_pid = pid
cycle_prev, cycle_curr = -1, -1
exe_time_prev, exe_time_curr = -1, -1
counts_prev = [-1, -1, -1, -1]
counts_curr = [-1, -1, -1, -1]
import zmq
context = zmq.Context()
zmq_subscriber = context.socket(zmq.SUB)
zmq_subscriber.connect("tcp://*****:*****@7L", out_str)
except struct_error:
#End of *DRAINER should be OR syncro problems
print("STRUCT UNPACK ERROR | out_str = {} (len={})".format(
out_str, len(out_str)))
print("msg size should be = {}".format(
struct_calcsize("@7L")))
cycles = 0
exe_time = 0
counts = [0, 0, 0, 0]
exe_m_time = 1
None
#Now exe_time in miliseconds. It should be in seconds!
if abs(exe_time) >= const.EPS:
exe_time /= 1000.0
self.exec_time = exe_time
print("cycles = {}, execution_time = {} | type = {}".format(
cycles, self.exec_time, type(cycles)))
if cycle_prev == -1:
cycle_prev = cycles
exe_time_prev = exe_time
else:
if cycle_curr == -1:
cycle_curr = cycles
exe_time_curr = exe_time
else:
cycle_prev, cycle_curr = cycle_curr, cycles
exe_time_prev, exe_time_curr = exe_time_curr, exe_time
if (exe_time_curr - exe_time_prev == 0):
None
else:
self.cycles_per_time = (cycle_curr - cycle_prev) / (
exe_time_curr - exe_time_prev)
self.cycles_per_time *= self.coinc + 1
while Gtk.events_pending():
Gtk.main_iteration_do(False)
print("cycle_per_time = {:f}".format(
self.cycles_per_time))
'''
for i in range(4):
diff_per_s = round( diff_counts[i]/(exe_m_time/1000.0) )
self.det_counts[i] = diff_per_s
print("det_counts[{}] = {}".format(i, self.det_counts[i]))
print("exe_m_time = {:d}".format(exe_m_time))
'''
if counts != [0, 0, 0, 0]:
for i in range(const.DET_NUM):
self.det_counts[i] = 0
if counts_prev[i] == -1:
counts_prev[i] = counts[i]
else:
if counts_curr[i] == -1:
counts_curr[i] = counts[i]
else:
counts_prev[i] = counts_curr[i]
counts_curr[i] = counts[i]
#diff_per_s = round( (counts_curr[i] - counts_prev[i])/(exe_m_time/1000) )
diff_per_s = round(
(counts_curr[i] - counts_prev[i]) /
(exe_time_curr - exe_time_prev))
self.det_counts[i] = diff_per_s
print("exe_m_time = {:d}".format(exe_m_time))
sleep(const.SLEEP_S_SOCK_READ)
return 0
