def open_coverage_xref(self, address, dctx=None): """ Open the 'Coverage Xref' dialog for a given address. """ lctx = self.get_context(dctx) # show the coverage xref dialog dialog = CoverageXref(lctx.director, address) if not dialog.exec_(): return # activate the user selected xref (if one was double clicked) if dialog.selected_coverage: lctx.director.select_coverage(dialog.selected_coverage) return # load a coverage file from disk disassembler.show_wait_box("Loading coverage from disk...") created_coverage, errors = lctx.director.load_coverage_files( [dialog.selected_filepath], disassembler.replace_wait_box ) if not created_coverage: lmsg("No coverage files could be loaded...") disassembler.hide_wait_box() warn_errors(errors) return disassembler.replace_wait_box("Selecting coverage...") lctx.director.select_coverage(created_coverage[0].name) disassembler.hide_wait_box()
def refresh_metadata(self): """ Hard refresh of the director and table metadata layers. """ disassembler.show_wait_box("Building database metadata...") self._model._director.refresh() # ensure the table's model gets refreshed disassembler.replace_wait_box("Refreshing Coverage Overview...") self._model.refresh() # all done disassembler.hide_wait_box()
def interactive_load_exec_tree(self,ctx): disassembler.show_wait_box("Start building execute trace metadata...") # Thx to Arnaud :) idx_l = list(ctx.chooser_selection) if len(idx_l) > 1: print "UI: multiple selection not allowed!" return 1 f = idaapi.getn_func(idx_l[0]) self.director.exec_tree_addr = f.startEA if self._ui_exe_tree_overview and self._ui_exe_tree_overview.isVisible(): self._ui_exe_tree_overview.show() return self._ui_exe_tree_overview =ExecuteTreeOverview(self) self._ui_exe_tree_overview.show()
def interactive_load_symbol(self,ctx): self.palette.refresh_colors() filenames = self._select_coverage_files() for filename in filenames: # attempt to load/parse a single coverage data file from disk try: disassembler.show_wait_box("Loading symbol from disk...") symbol_data = DrSymbolData(filename) self.director.symbol_data = symbol_data self.director.build_symbol_modules() except Exception as e: lmsg("Failed to load DrSymbolData %s" % filename) lmsg(" - Error: %s" % str(e)) logger.exception(" - Traceback:") load_failure = True continue disassembler.hide_wait_box()
def interactive_load_file(self, dctx=None): """ Perform the user-interactive loading of individual coverage files. """ lctx = self.get_context(dctx) # # kick off an asynchronous metadata refresh. this will run in the # background while the user is selecting which coverage files to load # future = lctx.metadata.refresh_async(progress_callback=metadata_progress) # # we will now prompt the user with an interactive file dialog so they # can select the coverage files they would like to load from disk # filenames = lctx.select_coverage_files() if not filenames: lctx.metadata.abort_refresh() return # # to begin mapping the loaded coverage data, we require that the # asynchronous database metadata refresh has completed. if it is # not done yet, we will block here until it completes. # # a progress dialog depicts the work remaining in the refresh # disassembler.show_wait_box("Building database metadata...") lctx.metadata.go_synchronous() await_future(future) # # now that the database metadata is available, we can use the director # to load and normalize the selected coverage files # disassembler.replace_wait_box("Loading coverage from disk...") created_coverage, errors = lctx.director.load_coverage_files(filenames, disassembler.replace_wait_box) # # if the director failed to map any coverage, the user probably # provided bad files. emit any warnings and bail... # if not created_coverage: lmsg("No coverage files could be loaded...") disassembler.hide_wait_box() warn_errors(errors) return # # activate the first of the newly loaded coverage file(s). this is the # one that will be visible in the coverage overview once opened # disassembler.replace_wait_box("Selecting coverage...") lctx.director.select_coverage(created_coverage[0].name) # all done! pop the coverage overview to show the user their results disassembler.hide_wait_box() lmsg("Successfully loaded %u coverage file(s)..." % len(created_coverage)) self.open_coverage_overview(lctx.dctx) # finally, emit any notable issues that occurred during load warn_errors(errors, lctx.director.suppressed_errors)
def interactive_load_batch(self, dctx=None): """ Perform the user-interactive loading of a coverage batch. """ lctx = self.get_context(dctx) # # kick off an asynchronous metadata refresh. this will run in the # background while the user is selecting which coverage files to load # future = lctx.metadata.refresh_async(progress_callback=metadata_progress) # # we will now prompt the user with an interactive file dialog so they # can select the coverage files they would like to load from disk # filepaths = lctx.select_coverage_files() if not filepaths: lctx.director.metadata.abort_refresh() return # prompt the user to name the new coverage aggregate default_name = "BATCH_%s" % lctx.director.peek_shorthand() ok, batch_name = prompt_string( "Batch Name:", "Please enter a name for this coverage", default_name ) # # if user didn't enter a name for the batch (or hit cancel) we should # abort the loading process... # if not (ok and batch_name): lmsg("User failed to enter a name for the batch coverage...") lctx.director.metadata.abort_refresh() return # # to begin mapping the loaded coverage data, we require that the # asynchronous database metadata refresh has completed. if it is # not done yet, we will block here until it completes. # # a progress dialog depicts the work remaining in the refresh # disassembler.show_wait_box("Building database metadata...") lctx.metadata.go_synchronous() await_future(future) # # now that the database metadata is available, we can use the director # to normalize and condense (aggregate) all the coverage data # disassembler.replace_wait_box("Loading coverage from disk...") batch_coverage, errors = lctx.director.load_coverage_batch( filepaths, batch_name, disassembler.replace_wait_box ) # if batch creation fails... if not batch_coverage: lmsg("Creation of batch '%s' failed..." % batch_name) disassembler.hide_wait_box() warn_errors(errors) return # select the newly created batch coverage disassembler.replace_wait_box("Selecting coverage...") lctx.director.select_coverage(batch_name) # all done! pop the coverage overview to show the user their results disassembler.hide_wait_box() lmsg("Successfully loaded batch %s..." % batch_name) self.open_coverage_overview(lctx.dctx) # finally, emit any notable issues that occurred during load warn_errors(errors, lctx.director.suppressed_errors)
def interactive_load_file(self): """ Perform the user-interactive loading of individual coverage files. """ self.palette.refresh_colors() # # kick off an asynchronous metadata refresh. this will run in the # background while the user is selecting which coverage files to load # future = self.director.refresh_metadata( progress_callback=metadata_progress) # # we will now prompt the user with an interactive file dialog so they # can select the coverage files they would like to load from disk # filenames = self._select_coverage_files() # # load the selected coverage files from disk (if any), returning a list # of loaded DrcovData objects (which contain coverage data) # disassembler.show_wait_box("Loading coverage from disk...") drcov_list = load_coverage_files(filenames) if not drcov_list: disassembler.hide_wait_box() self.director.metadata.abort_refresh() return # # to begin mapping the loaded coverage data, we require that the # asynchronous database metadata refresh has completed. if it is # not done yet, we will block here until it completes. # # a progress dialog depicts the work remaining in the refresh # disassembler.replace_wait_box("Building database metadata...") await_future(future) # insert the loaded drcov data objects into the director created_coverage, errors = self.director.create_coverage_from_drcov_list( drcov_list) # # if the director failed to map any coverage, the user probably # provided bad files. emit any warnings and bail... # if not created_coverage: lmsg("No coverage files could be loaded...") disassembler.hide_wait_box() warn_errors(errors) return # # activate the first of the newly loaded coverage file(s). this is the # one that will be visible in the coverage overview once opened # disassembler.replace_wait_box("Selecting coverage...") self.director.select_coverage(created_coverage[0]) # all done! pop the coverage overview to show the user their results disassembler.hide_wait_box() lmsg("Successfully loaded %u coverage file(s)..." % len(created_coverage)) self.open_coverage_overview() # finally, emit any notable issues that occurred during load warn_errors(errors)
def interactive_load_batch(self): """ Perform the user-interactive loading of a coverage batch. """ self.palette.refresh_colors() # # kick off an asynchronous metadata refresh. this will run in the # background while the user is selecting which coverage files to load # future = self.director.refresh_metadata( progress_callback=metadata_progress) # # we will now prompt the user with an interactive file dialog so they # can select the coverage files they would like to load from disk # filenames = self._select_coverage_files() # # load the selected coverage files from disk (if any), returning a list # of loaded DrcovData objects (which contain coverage data) # drcov_list = load_coverage_files(filenames) if not drcov_list: self.director.metadata.abort_refresh() return # prompt the user to name the new coverage aggregate default_name = "BATCH_%s" % self.director.peek_shorthand() ok, coverage_name = prompt_string( "Batch Name:", "Please enter a name for this coverage", default_name) # # if user didn't enter a name for the batch (or hit cancel) we should # abort the loading process... # if not (ok and coverage_name): lmsg("User failed to enter a name for the loaded batch...") self.director.metadata.abort_refresh() return # # to begin mapping the loaded coverage data, we require that the # asynchronous database metadata refresh has completed. if it is # not done yet, we will block here until it completes. # # a progress dialog depicts the work remaining in the refresh # disassembler.show_wait_box("Building database metadata...") await_future(future) # # now that the database metadata is available, we can use the director # to normalize and condense (aggregate) all the coverage data # new_coverage, errors = self.director.aggregate_drcov_batch(drcov_list) # # finally, we can inject the aggregated coverage data into the # director under the user specified batch name # disassembler.replace_wait_box("Mapping coverage...") self.director.create_coverage(coverage_name, new_coverage.data) # select the newly created batch coverage disassembler.replace_wait_box("Selecting coverage...") self.director.select_coverage(coverage_name) # all done! pop the coverage overview to show the user their results disassembler.hide_wait_box() lmsg("Successfully loaded batch %s..." % coverage_name) self.open_coverage_overview() # finally, emit any notable issues that occurred during load warn_errors(errors)