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