def pseudo_startup_tasks(grfstate):
config = grfstate.config
loadedmods = grfstate.loadedmods
system_mods = grfstate.system_mods
devmod = system_mods['devices']
devid = PSEUDO_DEVNUM_BASE
while True:
try:
cmdline = config['startup']['startup_{}'.format(devid)]
except KeyError:
break
try:
module, args = cmdline.split(None, 1)
except ValueError:
module = cmdline.strip()
args = None
if module in system_mods or module not in loadedmods:
continue
if not 'pseudo' in loadedmods[module].devices():
gammarf_util.console_message("module {} does not support pseudo devices"
.format(module))
if loadedmods[module].run(grfstate, devid, args):
devmod.occupy(devid, module, args, pseudo=True)
devid += 1
def setting(self, setting, arg=None):
if setting == None:
for setting, state in self.settings.items():
gammarf_util.console_message("{}: {} ({})".format(
setting, state, type(state)))
return True
if setting == 0:
return self.settings.keys()
if setting not in self.settings:
return False
if isinstance(self.settings[setting], bool):
new = not self.settings[setting]
elif not arg:
gammarf_util.console_message(
"non-boolean setting requires an argument")
return True
else:
if isinstance(self.settings[setting], int):
new = int(arg)
elif isinstance(self.settings[setting], float):
new = float(arg)
else:
new = arg
self.settings[setting] = new
def cmd_reserve(self, grfstate, args):
"""Reserve a device"""
system_mods = grfstate.system_mods
devmod = system_mods['devices']
try:
devid = int(args)
except (ValueError, TypeError):
gammarf_util.console_message(
"command takes a device number as its argument")
return
if devmod.hackrf():
if devmod.ishackrf(devid):
gammarf_util.console_message(
"invalid device: {}".format(HACKRF_DEVNUM))
if not devmod.isdev(devid):
gammarf_util.console_message(
"not a valid device number: {}".format(devid))
return
if devmod.occupied(devid):
gammarf_util.console_message("device occupied: {}".format(devid))
return
if devmod.reserved(devid):
gammarf_util.console_message(
"device {} already reserved".format(devid))
return
devmod.reserve(devid)
return
def __init__(self, config, devmod):
if not devmod.hackrf():
return
if not 'hackrfdevs' in config:
raise Exception("No hackrf section defined in config")
try:
hackrf_path = config['hackrfdevs']['hackrf_path']
except KeyError:
raise Exception("param 'hackrf_path' not appropriately "\
"defined in config")
hackrf_cmd = hackrf_path + '/' + 'hackrf_sweep'
if not os.path.isfile(hackrf_cmd)\
or not os.access(hackrf_cmd, os.X_OK):
raise Exception("executable hackrf_sweep not found "\
"in specified path")
self.description = "spectrum module"
self.settings = {}
self.worker = SpectrumWorker(devmod, hackrf_cmd)
self.worker.daemon = True
self.worker.start()
self.thread_timeout = 3
gammarf_util.console_message("loaded", MOD_NAME)
def cmd_p25_add(grfstate, args):
"""Add a p25 talkgroup to this node's set"""
system_mods = grfstate.system_mods
if not args:
cmd_p25_add_usage()
return
if not args:
cmd_p25_add_usage()
return
if len(args) < 3:
cmd_p25_add_usage()
return
split_args = args.split(' ', 2)
if len(split_args) < 3:
cmd_p25_add_usage()
return
try:
talkgroup = int(split_args[0])
except ValueError:
cmd_p25_add_usage()
return
tag = split_args[1]
description = split_args[2]
if system_mods['connector'].p25_add(talkgroup, tag, description):
gammarf_util.console_message("talkgroups updated - restart the client")
else:
gammarf_util.console_message("error updating talkgroups")
def setting(self, setting, arg=None):
"""Show/toggle module settings"""
if setting == None:
for setting, state in self.settings.items():
gammarf_util.console_message("{}: {} ({})".format(
setting, state, type(state)))
return True
if setting == 0:
return self.settings.keys()
if setting not in self.settings:
return False
if isinstance(self.settings[setting], bool):
new = not self.settings[setting]
elif not arg:
gammarf_util.console_message(
"Non-boolean setting requires an argument")
return True
else:
if isinstance(self.settings[setting], int):
new = int(arg)
elif isinstance(self.settings[setting], float):
try:
new = float(arg)
except ValueError:
print("bad argument for setting")
return
else:
new = arg
self.settings[setting] = new
def run(self):
data = {}
data['module'] = MODULE_ISM433
data['protocol'] = PROTOCOL_VERSION
while not self.stoprequest.isSet():
msg = self.cmdpipe.stdout.readline().strip()
if len(msg) == 0:
time.sleep(LOOP_SLEEP)
continue
msg = msg.decode('utf-8')
try:
msg = json.loads(msg)
except Exception as e:
continue
try:
ism433_model = msg['model']
ism433_type = msg['type']
ism433_id = int(msg['id'], 16)
except Exception:
continue
data['model'] = ism433_model
data['type'] = ism433_type
data['id'] = ism433_id
self.connector.senddat(data)
if self.settings['print_all']:
gammarf_util.console_message("Model: {}, Type: {}, ID: {}"
.format(ism433_model, ism433_type, ism433_id),
MOD_NAME)
return
def run(self, grfstate, devid, cmdline, remotetask=False):
self.remotetask = remotetask
self.system_mods = grfstate.system_mods
devmod = self.system_mods['devices']
if self.worker:
gammarf_util.console_message("module already running", MOD_NAME)
return
try:
freq, thresh = cmdline.split()
except (ValueError, AttributeError):
gammarf_util.console_message(self.__doc__)
return
freq = gammarf_util.str_to_hz(freq)
if not freq:
gammarf_util.console_message(self.__doc__)
return
try:
thresh = float(thresh)
except ValueError:
gammarf_util.console_message(self.__doc__)
return
opts = {'devid': devid, 'freq': freq, 'thresh': thresh}
self.worker = Single(opts, self.system_mods, self.settings)
self.worker.daemon = True
self.worker.start()
gammarf_util.console_message("{} added on device {}".format(
self.description, devid))
return True
def run(self):
data = {}
snapshotid = str(uuid4())
data['snapshotid'] = snapshotid
data['module'] = MODULE_SNAPSHOT
data['protocol'] = PROTOCOL_VERSION
freq = self.lowfreq
step = self.devmod.get_hackrf_step()
while freq <= self.highfreq:
pwr = str(self.spectrum.pwr(freq))
if not pwr:
continue
data['freq'] = freq
data['pwr'] = pwr
try:
self.connector.senddat(data)
except: # shutting down
pass
freq += step
time.sleep(SEND_SLEEP)
data['freq'] = 0 # inform server this is final
self.connector.senddat(data)
gammarf_util.console_message(
"sent snapshot (id: {}) at {}".format(snapshotid,
datetime.datetime.now()),
MOD_NAME)
if not self.remotetask:
self.devmod.freedev(self.devid)
return
def shutdown(self):
gammarf_util.console_message("shutting down {}".format(
self.description))
for worker in self.workers:
devid, thread = worker
thread.join(self.thread_timeout)
return
def __init__(self, config):
self.device_list = ["hackrf", "virtual"]
self.description = "channels module"
self.settings = {'print_all': False}
self.worker = None
self.thread_timeout = 3
gammarf_util.console_message("loaded", MOD_NAME)
def __init__(self, config):
self.description = "remotetask module"
self.config = config
self.settings = {'print_tasks': True}
self.workers = []
self.thread_timeout = 3
gammarf_util.console_message("loaded", MOD_NAME)
def __init__(self, config):
self.device_list = ['pseudo']
self.description = "p25 receiver module"
self.settings = {'print_all': False}
self.worker = None
self.thread_timeout = 3
gammarf_util.console_message("loaded", MOD_NAME)
def __init__(self, config):
self.device_list = ["rtlsdr"]
self.description = "single module"
self.settings = {'print_all': False}
self.worker = None
self.thread_timeout = 5
gammarf_util.console_message("loaded", MOD_NAME)
def shutdown(self):
try:
gammarf_util.console_message("shutting down {}".format(
self.description))
except AttributeError:
pass
try:
if self.worker:
self.worker.join(self.thread_timeout)
except AttributeError:
pass
def interesting_pretty(self):
req = {'request': REQ_INTERESTING_GET}
resp = self.sendcmd(req)
if resp['reply'] == 'ok':
interesting = resp['freqs'].split(None)
out = []
for freq, name in zip(interesting[0::2], interesting[1::2]):
out.append((int(freq), name))
out = sorted(out, key=lambda tup: tup[0])
for freq, name in out:
gammarf_util.console_message("{:11d} {}".format(freq, name))
return True
return
def __init__(self, config):
try:
hit_db = config['scanner']['hit_db']
except KeyError:
hit_db = DEFAULT_HIT_DB
hit_db = float(hit_db)
self.device_list = ["hackrf", "virtual"]
self.description = "scanner module"
self.settings = {'print_hits': False, 'hit_db': hit_db}
self.worker = None
self.thread_timeout = 3
gammarf_util.console_message("loaded", MOD_NAME)
def cmd_interesting_clone(grfstate, args):
"""Clone another station's interesting freqs"""
system_mods = grfstate.system_mods
if not args:
cmd_interesting_clone_usage()
return
source = args.split()[0]
if system_mods['connector'].interesting_clone(source):
gammarf_util.console_message("interesting freqs updated")
else:
gammarf_util.console_message("error updating interesting freqs")
def run(self, grfstate, devid, cmdline, remotetask=False):
self.remotetask = remotetask
system_mods = grfstate.system_mods
if self.worker:
gammarf_util.console_message("module already running", MOD_NAME)
return
self.worker = Freqwatch(system_mods, self.settings)
self.worker.daemon = True
self.worker.start()
gammarf_util.console_message("{} added on device {}".format(
self.description, devid))
return True
def info(self):
for devtuple in self.devs.items():
dev = devtuple[1]
if dev.job:
try:
module, args, started = dev.job
argstr = args if args else "no args"
jobstr = "{}, {}, started: {}"\
.format(module, argstr, started)
except ValueError:
jobstr = dev.job
else:
jobstr = "no job"
gammarf_util.console_message("{}: {}".format(dev.name, jobstr))
def run(self):
data = {}
data['module'] = MODULE_P25LOG
data['protocol'] = PROTOCOL_VERSION
self.lstsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
self.lstsock.bind(('', self.port))
except Exception as e:
gammarf_util.console_message(
"could not listen on port {}: {}".format(self.port, e),
MOD_NAME)
return
self.lstsock_file = self.lstsock.makefile()
try:
for line in self.lstsock_file:
if '\t' in line:
tmp = line.split('\t')
else:
continue
if len(tmp) != 4:
continue
msg = tmp[1]
if msg.startswith('TG:'):
talkgroup = msg.split()[1].strip()
else:
continue
if self.settings['print_all']:
gammarf_util.console_message(
"talkgroup: {}".format(talkgroup), MOD_NAME)
data['talkgroup'] = talkgroup
try:
self.connector.senddat(data)
except:
pass
except ValueError:
pass # while stopping module
return
def cmd_pwr(grfstate, args):
"""Show the power at the specified frequency"""
system_mods = grfstate.system_mods
if not args:
cmd_pwr_usage()
return
freq = gammarf_util.str_to_hz(args.split()[0])
if not freq:
cmd_pwr_usage()
return
pwr = system_mods['spectrum'].pwr(freq)
if pwr:
gammarf_util.console_message(pwr)
def run(self, grfstate, devid, cmdline, remotetask=False):
self.remotetask = remotetask
self.system_mods = grfstate.system_mods
devmod = self.system_mods['devices']
if self.worker:
gammarf_util.console_message("module already running", MOD_NAME)
return
opts = {'cmd': self.cmd, 'devid': devid}
self.worker = Tpms(opts, self.system_mods, self.settings)
self.worker.daemon = True
self.worker.start()
gammarf_util.console_message("{} added on device {}".format(
self.description, devid))
return True
def __init__(self, config):
if not 'rtl_path' in config['rtldevs']:
raise Exception("'rtl_path' not appropriately defined in config")
rtl_path = config['rtldevs']['rtl_path']
command = rtl_path + '/' + 'rtl_433'
if not os.path.isfile(command) or not os.access(command, os.X_OK):
raise Exception("executable rtl_433 not found in specified path")
self.device_list = ["rtlsdr"]
self.description = "tpms module"
self.settings = {'print_all': False}
self.worker = None
self.cmd = command
self.thread_timeout = 5
gammarf_util.console_message("loaded", MOD_NAME)
def info(self):
if self.usegps:
gammarf_util.console_message("using GPS", MOD_NAME)
else:
gammarf_util.console_message("using static location", MOD_NAME)
fix = self.worker.get_current()
if not fix:
gammarf_util.console_message("no gps fix", MOD_NAME)
else:
gammarf_util.console_message(
"lat: {}, lng: {}".format(fix['lat'], fix['lng']), MOD_NAME)
def cmd_mods(grfstate, args):
"""Show available modules"""
config = grfstate.config
loadedmods = grfstate.loadedmods
system_mods = grfstate.system_mods
modules = loadedmods
for module in modules:
gammarf_util.console_message(module, showdt=False)
gammarf_util.console_message('=' * len(module), showdt=False)
gammarf_util.console_message(loadedmods[module].__doc__, showdt=False)
gammarf_util.console_message('', showdt=False)
def run(self, grfstate, devid, cmdline, remotetask=False):
self.remotetask = remotetask
self.system_mods = grfstate.system_mods
self.devid = devid
if self.worker:
gammarf_util.console_message("module already running", MOD_NAME)
return
if not cmdline:
self.usage()
return
try:
port = int(cmdline.strip())
except Exception:
gammarf_util.console_message("bad port number", MOD_NAME)
return
self.worker = P25Log(port, self.system_mods, self.settings)
self.worker.daemon = True
self.worker.start()
gammarf_util.console_message("{} added on device {}".format(
self.description, devid))
return True
def cmd_message(grfstate, args):
"""Send a message to another station: > message target the message"""
config = grfstate.config
system_mods = grfstate.system_mods
if not args:
cmd_message_usage()
return
try:
target, message = args.split(" ", 1)
except ValueError:
cmd_message_usage()
return
req = {'request': REQ_MESSAGE, 'target': target, 'message': message}
resp = system_mods['connector'].sendcmd(req)
if resp['reply'] == 'ok':
gammarf_util.console_message("message sent")
else:
gammarf_util.console_message("error sending message")
def cmd_stop(self, grfstate, args):
"""Stop a task occupying a device (> stop device)"""
loadedmods = grfstate.loadedmods
system_mods = grfstate.system_mods
devmod = system_mods['devices']
if not args:
gammarf_util.console_message(
"command takes a device number or letter as its argument")
return
try:
devid = int(args)
virtual = False
except ValueError:
devid = args.strip()
virtual = True
if devmod.hackrf():
if devmod.ishackrf(devid):
gammarf_util.console_message(
"invalid device: {}".format(HACKRF_DEVNUM))
if not devmod.isdev(devid):
gammarf_util.console_message("not a device: {}".format(devid))
return
if devmod.reserved(devid):
gammarf_util.console_message("device {} is reserved".format(devid))
return
module = devmod.devid_to_module(devid)
if module:
loadedmods[module].stop(devid, devmod)
else:
gammarf_util.console_message(
"device {} not occupied".format(devid))
return
def run(self):
data = {}
data['module'] = MODULE_P25RX
data['protocol'] = PROTOCOL_VERSION
self.lstsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
self.lstsock.bind( ('', self.port) )
except Exception as e:
gammarf_util.console_message("could not listen on port {}: {}"
.format(self.port, e), MOD_NAME)
return
while not self.stoprequest.isSet():
for line in self.lstsock.makefile():
if '\t' in line:
_, msg = line.split('\t', 1)
else:
continue
if msg.startswith('Recording'):
talkgroup = msg.split()[-1].strip()
else:
continue
if self.settings['print_all']:
gammarf_util.console_message("talkgroup: {}"
.format(talkgroup), MOD_NAME)
data['talkgroup'] = talkgroup
try:
self.connector.senddat(data)
except:
pass
return
