def device(self): """The associated Device object.""" if self._device: return self._device device = Device(self, addr='::1') device.configure() self._device = device return self._device
def __init__(self, app, count, lang="-l chi_sim+normal", cleanup=False): self.app = app self.count = count self.lang = lang self.cleanup = cleanup if not DEBUG: Device.init() self.device = Device.getDevice()
def test_ssh_config(self): device = Device(self.buildenv, '::1') self.assertFalse(device.ssh_config) with self.assertRaises(ValueError): device.ssh_config = 'no_such_config' ssh_config = 'ssh_config' self.host.touch(ssh_config) device.ssh_config = ssh_config self.assertEqual(['-F', ssh_config], device.ssh_opts())
def test_ssh_identity(self): device = Device(self.buildenv, '::1') self.assertFalse(device.ssh_identity) with self.assertRaises(ValueError): device.ssh_identity = 'no_such_identity' ssh_identity = 'ssh_identity' self.host.touch(ssh_identity) device.ssh_identity = ssh_identity self.assertEqual(['-i', ssh_identity], device.ssh_opts())
def test_configure(self): device = Device(self.buildenv, '::1') device.configure() self.assertEqual( device.ssh_config, self.buildenv.path( self.buildenv.build_dir, 'ssh-keys', 'ssh_config')) self.assertFalse(device.ssh_identity) self.assertFalse(device.ssh_options) self.assertFalse(device.ssh_verbosity)
def init(self, dma_id): if self._init_done: logging.warning("Already initialized! Skip init") return self.dma_id = dma_id self.dev = Device() self.dev.open_device() self.sdl = StreamDescList(self.dev) self.ipc = Ipc(self.dev) self._init_done = True
def test_ssh_option(self): device = Device(self.factory, addr='::1') self.assertEqual(device.ssh_options, []) device.ssh_options = ['StrictHostKeyChecking no'] device.ssh_options.append('UserKnownHostsFile=/dev/null') self.assertEqual([ '-o', 'StrictHostKeyChecking no', '-o', 'UserKnownHostsFile=/dev/null', ], device.ssh_opts())
def parse_devices(self): """Creates an array of Device objects from the channel""" devices = [] for device in self._channel_dict["devices"]: devices.append( Device(device, self._is_sixteen_bit, self._ignore_list)) return devices
def test_from_args(self): host = MockHost() parser = Args.make_parser('description', name_required=False) # netaddr should get called with 'just-four-random-words', and fail with self.assertRaises(RuntimeError): args = parser.parse_args(['--device', 'just-four-random-words']) device = Device.from_args(host, args)
def main(): parser = Args.make_parser( 'Starts the named fuzzer. Additional arguments are passed through.') args, fuzzer_args = parser.parse_known_args() host = Host() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) with Cipd.from_args(fuzzer, args) as cipd: if cipd.install(): device.store(os.path.join(cipd.root, '*'), fuzzer.data_path('corpus')) print('\n****************************************************************') print(' Starting ' + str(fuzzer) + '.') print(' Outputs will be written to:') print(' ' + fuzzer.results()) if not args.foreground: print(' You should be notified when the fuzzer stops.') print(' To check its progress, use `fx fuzz check ' + str(fuzzer) + '`.') print(' To stop it manually, use `fx fuzz stop ' + str(fuzzer) + '`.') print('****************************************************************\n') fuzzer.start(fuzzer_args) title = str(fuzzer) + ' has stopped.' body = 'Output written to ' + fuzzer.results() + '.' print(title) print(body) host.notify_user(title, body) return 0
def main(): parser = ArgParser('Lists corpus instances in CIPD for the named fuzzer') args = parser.parse_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) with Corpus.from_args(fuzzer, args) as corpus: cipd = Cipd(corpus) print(cipd.instances()) return 0
def on_start_input(cmd: pcmd.Command, args: List[str], indi: int) -> None: """Callback for `start input` - adds an input device""" try: ch.add_ist( Device(pa, format=pyaudio.paFloat32, channels=1, rate=params.SMPRATE, input=True, input_device_index=indi)) except Exception as e: utils.printerr(str(e))
def main(): parser = Args.make_parser( 'Lists the fuzzing corpus instances in CIPD for a named fuzzer') args = parser.parse_args() host = Host() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) cipd = Cipd(fuzzer) if not cipd.list(): return 1 return 0
def main(): """ Main Entry Point """ args = parse_args() log_level = logging.INFO if args.debug: log_level = logging.DEBUG logging.basicConfig(level=log_level, format="%(message)s") dev = Device() dev.open_device() etrace = Etrace(dev) etrace.print() if args.hexdump: etrace.hexdump() if args.output_file: etrace.save(args.output_file)
def main(): parser = Args.make_parser('Stops the named fuzzer.') args = parser.parse_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if fuzzer.is_running(): print('Stopping ' + str(fuzzer) + '.') fuzzer.stop() else: print(str(fuzzer) + ' is already stopped.') return 0
def main(): parser = Args.make_parser( 'Runs the named fuzzer on provided test units, or all current test ' + 'units for the fuzzer. Use \'check-fuzzer\' to see current tests units.' ) args, fuzzer_args = parser.parse_known_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if fuzzer.repro(fuzzer_args) == 0: print('No matching artifacts found.') return 1 return 0
def main(): parser = Args.make_parser( 'Transfers a fuzzing corpus for a named fuzzer from a device to CIPD') args = parser.parse_args() host = Host() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if fuzzer.measure_corpus()[0] == 0: print('Ignoring ' + str(fuzzer) + '; corpus is empty.') return 0 with Cipd.from_args(fuzzer, args) as cipd: device.fetch(fuzzer.data_path('corpus/*'), cipd.root) if not cipd.create(): return 1 return 0
def main(): parser = Args.make_parser( 'Transfers corpus for a named fuzzer to a device', label_present=True) args = parser.parse_args() host = Host() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if os.path.isdir(args.label): device.store(os.path.join(args.label, '*'), fuzzer.data_path('corpus')) return 0 with Cipd.from_args(fuzzer, args, label=args.label) as cipd: if not cipd.install(): return 1 device.store(os.path.join(cipd.root, '*'), fuzzer.data_path('corpus')) return 0
def main(): parser = ArgParser( 'Transfers a fuzzing corpus for a named fuzzer from a device to CIPD') args = parser.parse_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if fuzzer.measure_corpus()[0] == 0: print('Ignoring ' + str(fuzzer) + '; corpus is empty.') return 0 with Corpus.from_args(fuzzer, args) as corpus: corpus.pull() cipd = Cipd(corpus) if not args.no_cipd: cipd.create() return 0
def main(): parser = ArgParser( 'Starts the named fuzzer. Additional arguments are passed through.') args, fuzzer_args = parser.parse_known_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) if not args.monitor: with Corpus.from_args(fuzzer, args) as corpus: cipd = Cipd(corpus) if not args.no_cipd: cipd.install('latest') corpus.push() print( '\n****************************************************************' ) print(' Starting ' + str(fuzzer) + '.') print(' Outputs will be written to:') print(' ' + fuzzer.results()) if not args.foreground: print(' You should be notified when the fuzzer stops.') print(' To check its progress, use `fx fuzz check ' + str(fuzzer) + '`.') print(' To stop it manually, use `fx fuzz stop ' + str(fuzzer) + '`.') print( '****************************************************************\n' ) fuzzer.start(fuzzer_args) if not args.foreground: subprocess.Popen(['python', sys.argv[0], '--monitor', str(fuzzer)]) else: fuzzer.monitor() title = str(fuzzer) + ' has stopped.' body = 'Output written to ' + fuzzer.results() + '.' print(title) print(body) host.notify_user(title, body) return 0
def on_start_input(cmd: pcmd.Command, args: List[str], indi: int, json: bool) -> None: """Callback for `start input` - adds an input device""" try: ch.add_ist( Device(pa, format=pyaudio.paFloat32, channels=1, rate=params.SMPRATE, input=True, input_device_index=indi)) if json: print(JSON.dumps({})) except Exception as e: if not json: utils.printerr(str(e)) else: print(JSON.dumps({ 'error': str(e), }))
def main(): parser = Args.make_parser( 'Minimizes the current corpus for the named fuzzer. This should be ' + 'used after running the fuzzer for a while, or after incorporating a ' + 'third-party corpus using \'fetch-corpus\'') args, fuzzer_args = parser.parse_known_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) with Cipd.from_args(fuzzer, args) as cipd: if cipd.install(): device.store(os.path.join(cipd.root, '*'), fuzzer.data_path('corpus')) if fuzzer.merge(fuzzer_args) == (0, 0): print('Corpus for ' + str(fuzzer) + ' is empty.') return 1 device.fetch(fuzzer.data_path('corpus/*'), cipd.root) if not cipd.create(): return 1 return 0
def main(): parser = Args.make_parser( description='Reports status for the fuzzer matching NAME if provided, ' + 'or for all running fuzzers. Status includes execution state, corpus ' + 'size, and number of artifacts.', name_required=False) args = parser.parse_args() host = Host() device = Device.from_args(host, args) fuzzers = Fuzzer.filter(host.fuzzers, args.name) pids = device.getpids() silent = True for pkg, tgt in fuzzers: fuzzer = Fuzzer(device, pkg, tgt) if not args.name and tgt not in pids: continue silent = False if tgt in pids: print(str(fuzzer) + ': RUNNING') else: print(str(fuzzer) + ': STOPPED') print(' Output path: ' + fuzzer.data_path()) print(' Corpus size: %d inputs / %d bytes' % fuzzer.measure_corpus()) artifacts = fuzzer.list_artifacts() if len(artifacts) == 0: print(' Artifacts: None') else: print(' Artifacts: ' + artifacts[0]) for artifact in artifacts[1:]: print(' ' + artifact) if silent: print( 'No fuzzers are running. Include \'name\' to check specific fuzzers.' ) return 1 return 0
def main(): parser = ArgParser( 'Minimizes the current corpus for the named fuzzer. This should be ' + 'used after running the fuzzer for a while, or after incorporating a ' + 'third-party corpus using \'fetch-corpus\'') args, fuzzer_args = parser.parse_known_args() host = Host.from_build() device = Device.from_args(host, args) fuzzer = Fuzzer.from_args(device, args) with Corpus.from_args(fuzzer, args) as corpus: cipd = Cipd(corpus) if not args.no_cipd: cipd.install('latest') corpus.push() if fuzzer.merge(fuzzer_args) == (0, 0): print('Corpus for ' + str(fuzzer) + ' is empty.') return 1 corpus.pull() if not args.no_cipd: cipd.create() return 0
def run(options, arguments): AVD_ROOT = os.path.abspath(os.path.dirname(sys.argv[0])) AVD_REPO_ROOT = os.path.abspath(options.repo) ANDROID_SDK_ROOT = os.path.abspath(options.sdk) if len(arguments) == 1: subject = arguments[0] if (subject == 'devices'): devices = [os.path.basename(entry) for entry in os.listdir(os.path.join(AVD_ROOT, 'devices')) if os.path.isfile(os.path.join(AVD_ROOT, 'devices', entry)) and os.path.splitext(os.path.join(AVD_ROOT, 'devices', entry))[1] == '.json'] # stupid Python and returning None instead of an empty List if (not devices): devices = [] for device_name in devices: device = Device(os.path.splitext(device_name)[0], AVD_ROOT, AVD_REPO_ROOT, ANDROID_SDK_ROOT) print 'Name: {name}'.format(name=device.name) if device.skin: print 'Skin: {skin}'.format(skin=device.skin.name) versions = ', '.join(device.supported_versions) if device.supported_versions else 'None' print 'Versions Supported: {versions}'.format(versions=versions) installed = ', '.join(device.installed_versions()) if device.installed_versions() else 'None' print 'Versions Installed: {installed}'.format(installed=installed) if not devices: print "No devices installed." elif (subject == 'skins'): skins = [os.path.basename(entry) for entry in os.listdir(os.path.join(AVD_ROOT, 'skins')) if os.path.isdir(os.path.join(AVD_ROOT, 'skins', entry))] # stupid Python and returning None instead of an empty List if (not skins): skins = [] for skin_name in skins: skin = Skin(skin_name, AVD_ROOT, ANDROID_SDK_ROOT) print 'Name: {name}'.format(name=skin.name) versions = ', '.join(skin.supported_versions) if skin.supported_versions else 'None' print 'Versions Supported: {versions}'.format(versions=versions) installed = ', '.join(skin.installed_versions()) if skin.installed_versions() else 'None' print 'Versions Installed: {installed}'.format(installed=installed) if not skins: print 'No skins installed.' elif len(arguments) == 3: subject, action, name = arguments if (subject == 'device'): device = Device(name, AVD_ROOT, AVD_REPO_ROOT, ANDROID_SDK_ROOT) if (action == 'info'): print 'Name: {name}'.format(name=device.name) if device.skin: print 'Skin: {skin}'.format(skin=device.skin.name) versions = ', '.join(device.supported_versions) if device.supported_versions else 'None' print 'Versions Supported: {versions}'.format(versions=versions) installed = ', '.join(device.installed_versions()) if device.installed_versions() else 'None' print 'Versions Installed: {installed}'.format(installed=installed) elif (action == 'install'): if (options.target): if (device.install(options.target)): print 'Successfully installed the device {name} for version {version}. The specific device name is {versioned_name}.'.format(name=device.name, version=options.target, versioned_name=device.versioned_name(options.target)) else: print 'Unable to install the device {name} for version {version}. Please check that the devices isn\'t already installed, {version} is one of the device\'s supported versions, and that the appropriate file permissions are set.'.format(name=device.name, version=options.target) else: results = [device.install(version) for version in device.supported_versions] if not False in results: print 'Successfully installed the device {name} for all supported versions: {versions}. The specific device names are: {versioned_names}.'.format(name=device.name, versions=', '.join(device.supported_versions), versioned_names=', '.join([device.versioned_name(version) for version in device.supported_versions])) else: print 'Unable to install the device {name} for one or more of the Android versions.'.format(name=device.name) elif (action == 'uninstall'): if (options.target): if (device.uninstall(options.target)): print 'Successfully uninstalled the device {name} for version {version}.'.format(name=device.name, version=options.target) else: print 'Unable to uninstall the device {name} for version {version}. Please check that the device isn\'t already uninstalled, {version} is one of the device\'s supported versions, and that the appropriate file permissions are set.'.format(name=device.name, version=options.target) else: results = [device.uninstall(version) for version in device.supported_versions] if not False in results: print 'Successfully uninstalled the device {name} for all supported versions: {versions}.'.format(name=device.name, versions=', '.join(device.supported_versions)) else: print 'Unable to uninstall the device {name} for one or more of the Android versions.'.format(name=device.name) else: print "Invalid action: {action}".format(action=action) return False elif (subject == 'skin'): skin = Skin(name, AVD_ROOT, ANDROID_SDK_ROOT) if (action == 'info'): print 'Name: {name}'.format(name=skin.name) versions = ', '.join(skin.supported_versions) if skin.supported_versions else 'None' print 'Versions Supported: {versions}'.format(versions=versions) installed = ', '.join(skin.installed_versions()) if skin.installed_versions() else 'None' print 'Versions Installed: {installed}'.format(installed=installed) elif (action == 'install'): if (options.target): if (skin.install(options.target)): print 'Successfully installed the skin {name} for version {version}.'.format(name=skin.name, version=options.target) else: print 'Unable to install the skin {name} for version {version}. Please check that the skins isn\'t already installed, {version} is one of the skin\'s supported versions, and that the appropriate file permissions are set.'.format(name=skin.name, version=options.target) else: results = [skin.install(version) for version in skin.supported_versions] if not False in results: print 'Successfully installed the skin {name} for all supported versions: {versions}.'.format(name=skin.name, versions=', '.join(skin.supported_versions)) else: print 'Unable to install the skin {name} for one or more of the Android versions.'.format(name=skin.name) elif (action == 'uninstall'): if (options.target): if (skin.uninstall(options.target)): print 'Successfully uninstalled the skin {name} for version {version}.'.format(name=skin.name, version=options.target) else: print 'Unable to uninstall the skin {name} for version {version}. Please check that the skin isn\'t already uninstalled, {version} is one of the skin\'s supported versions, and that the appropriate file permissions are set.'.format(name=skin.name, version=options.target) else: results = [skin.uninstall(version) for version in skin.supported_versions] if not False in results: print 'Successfully uninstalled the skin {name} for all supported versions: {versions}.'.format(name=skin.name, versions=', '.join(skin.supported_versions)) else: print 'Unable to uninstall the skin {name} for one or more of the Android versions.'.format(name=skin.name) else: print "Invalid action: {action}".format(action=action) return False else: print "Invalid subject: {subject}".format(subject=subject) return False
def test_ssh_verbosity(self): device = Device(self.buildenv, '::1') self.assertEqual(device.ssh_verbosity, 0) with self.assertRaises(ValueError): device.ssh_verbosity = 4 device.ssh_verbosity = 3 self.assertEqual(['-vvv'], device.ssh_opts()) device.ssh_verbosity = 2 self.assertEqual(['-vv'], device.ssh_opts()) device.ssh_verbosity = 1 self.assertEqual(['-v'], device.ssh_opts()) device.ssh_verbosity = 0 self.assertEqual([], device.ssh_opts()) with self.assertRaises(ValueError): device.ssh_verbosity = -1
def test_get_devices(self): """ Test set_copies() and set_rotation(90) should stack along x axis.""" for device in Device.get_printers(): print device.name assert 1 == 0
def test_get_devices(self): """ Test set_copies() and set_rotation(90) should stack along x axis.""" for device in Device.get_printers(): print device.name assert 1==0
def _create_device(self, name, params): return Device(name=params[name], terminal_list=params[name]['terminal'], default_terminal=params[name]['default_terminal'], logger=logger)
# Character passed in mailbox ID field def mailbox_poll_char(dev): while True: if dev.dsp_hipct.value & regs.ADSP_IPC_HIPCT_BUSY: # Use only id for passing character character = dev.dsp_hipct.value & regs.ADSP_IPC_HIPCT_MSG # Get readable character character &= 0x10FFFF print('{}'.format(chr(character)), end='') # Clear interrupt dev.dsp_hipct.value |= regs.ADSP_IPC_HIPCT_BUSY else: sleep(0.005) if __name__ == "__main__": # Clear Done if needed #dev.dsp_hipct.value |= regs.ADSP_IPC_HIPCT_BUSY # Use Device library for controlling registers device = Device() device.open_device() mailbox_poll_mem(device)
class FirmwareLoader(): def __init__(self): self._init_done = False self.dma_id = None self.dev = None self.sdl = None def init(self, dma_id): if self._init_done: logging.warning("Already initialized! Skip init") return self.dma_id = dma_id self.dev = Device() self.dev.open_device() self.sdl = StreamDescList(self.dev) self.ipc = Ipc(self.dev) self._init_done = True def close(self): if not self._init_done: logging.warning("Not initialized! Skip closing.") return self.sdl.close() self.dev.close() self._init_done = False def reset_dsp(self): logging.debug(">>> FirmwareLoader.reset_dsp()") logging.debug("Recycling controller power...") self.dev.power_cycle() # This should be enabled prior to power down the cores. self.dev.enable_proc_pipe_ctl() logging.debug("Power down cores...") self.dev.core_stall_reset(plat_def.CORE_MASK) self.dev.core_power_down(plat_def.CORE_MASK) logging.debug("<<< FirmwareLoader.reset_dsp()") def boot_dsp(self): logging.debug(">>> FirmwareLoader.boot_dsp()") self.dev.enable_proc_pipe_ctl() self.sdl.reset_all() self.dev.core_power_up(0x1) self.dev.dsp_hipct.value = self.dev.dsp_hipct.value logging.debug("Purging pending FW request") boot_config = plat_def.FW_IPC_PURGE | regs_def.ADSP_IPC_HIPCI_BUSY boot_config = boot_config | ((self.dma_id - 7) << 9) self.dev.dsp_hipci.value = boot_config time.sleep(0.1) logging.debug(" DSP_HIPCI=%s" % self.dev.dsp_hipci) self.dev.core_power_up(plat_def.CORE_MASK) self.dev.core_run(plat_def.CORE_0) self.dev.core_run(plat_def.CORE_1) logging.debug("Wait for IPC DONE bit from ROM") while True: ipc_ack = self.dev.dsp_hipcie.value if (ipc_ack & (1 << regs_def.ADSP_IPC_HIPCIE_DONE_OFFSET)) != 0: break time.sleep(0.1) logging.debug("<<< FirmwareLoader.boot_dsp()") def check_fw_boot_status(self, expected): logging.debug(">>> FirmwareLoader.check_fw_boot_status(0x%08X)" % expected) raw_status = self.dev.fw_status.value FirmwareStatus(raw_status).print() if (raw_status & plat_def.FW_STATUS_ERROR) != 0: output = ("Firmware Status error:" " Status: 0x%08X\n" " Error Code 0x%08X" % (raw_status, self.dev.fw_err_code.value)) raise RuntimeError(output) status = raw_status & plat_def.FW_STATUS_BOOT_STATE logging.debug("<<< FirmwareLoader.check_fw_boot_status()") return status == expected def wait_for_fw_boot_status(self, boot_status): logging.debug("Waiting for FW Boot Status: 0x%08X (%s)" % (boot_status, plat_def.BOOT_STATUS_STR(boot_status))) for _ in range(10): reg = self.dev.fw_status.value bs = reg & plat_def.FW_STATUS_BOOT_STATE if bs == boot_status: logging.debug("Received Expected Boot Status") return True time.sleep(0.01) logging.error("Failed to receive expected status") return False def wait_for_fw_wait_status(self, wait_status): logging.debug("Waiting for FW Wait Status: 0x%08X (%s)" % (wait_status, plat_def.WAIT_STATUS_STR(wait_status))) for _ in range(10): reg = self.dev.fw_status.value ws = reg & plat_def.FW_STATUS_WAIT_STATE if ws == (wait_status << plat_def.FW_STATUS_WAIT_STATE_OFFSET): logging.debug("Received Expected Wait Status") return True time.sleep(0.01) logging.error("Failed to receive expected status") return False def load_firmware(self, fw_file): logging.debug(">>> FirmwareLoader.load_firmware()") with open(fw_file, "rb") as fd: data = array.array('B', fd.read()) sd = self.sdl.get_sd(self.dma_id) sd.enable = True sd.alloc_memory(len(data)) sd.buf.copy(data, len(data)) sd.config() sd.set_stream_id(1) sd.set_traffic_priority(1) sd.set_bitrate(0x4) time.sleep(0.1) logging.debug("<<< FirmwareLoader.load_firmware()") return sd def download_firmware(self, fw_file): logging.debug(">>> FirmwareLoader.download_firmware(fw_file=%s)" % fw_file) # Load firmware to DMA buffer and update SD and SDL sd = self.load_firmware(fw_file) try: self.dev.hda_spibe.value |= (1 << self.dma_id) self.wait_for_fw_wait_status(plat_def.WAIT_STATUS_DMA_BUFFER_FULL) logging.info("Start firmware downloading...") sd.start() time.sleep(0.5) self.wait_for_fw_boot_status(plat_def.BOOT_STATUS_FW_ENTERED) finally: sd.pause() sd.reset() self.sdl.release_sd(sd.idx) self.dev.hda_spibe.value = 0 logging.debug("<<< FirmwareLoader.download_firmware()")