def __init__(self, address="localhost", port=None, *args, **kargs): if port is not None: args = ((address, port),) + args EPCClient.__init__(self, *args, **kargs) def complete(*cargs, **ckargs): return self.complete(*cargs, **ckargs) self.register_function(complete)
def main(port): client = EPCClient(("localhost", port), log_traceback=True) with contextlib.closing(client): print("Server provides these methods:") print(client.methods_sync()) print("Calling (add 1 2 3)") print("Got: {0}".format(client.call_sync('add', [1, 2, 3]))) print("Closing client...") print("Closing client... Done!")
def run_client(address, port, log, log_level): client = EPCClient((address, port), log_traceback=True) if log: level = getattr(logging, log_level.upper()) handler = logging.StreamHandler() handler.setLevel(level) client.logger.addHandler(handler) client.logger.setLevel(level) @client.register_function def pong(*args): print("PONG sending {0}".format(args)) return client.call_sync('echo', [args], timeout=1) print("Server provides these methods:") print(client.methods_sync()) print("Calling (echo 1)") print("Got: {0}".format(client.call_sync('echo', [1]))) print("Calling (ping-pong 111 222 333)") print("Got: {0}".format(client.call_sync('ping-pong', [111, 222, 333]))) print("Closing client...") client.close() print("Closing client... Done!")
def init_epc_client(emacs_server_port): global epc_client if epc_client == None: try: epc_client = EPCClient(("localhost", emacs_server_port), log_traceback=True) except ConnectionRefusedError: import traceback traceback.print_exc()
class RemoteREPLClient(Cmd): prompt = 'rrepl> ' def connect(self, address): self.client = EPCClient(address) def default(self, line): try: reply = str(self.client.call_sync('eval', [line], timeout=10)) except Exception as err: reply = str(err) self.stdout.write(reply) self.stdout.write("\n") def do_EOF(self, line): return True
def __init__(self, args): global emacs_width, emacs_height, eaf_config_dir, proxy_string # Parse init arguments. (emacs_width, emacs_height, proxy_host, proxy_port, proxy_type, config_dir, emacs_server_port, var_dict_string) = args emacs_width = int(emacs_width) emacs_height = int(emacs_height) eaf_config_dir = os.path.join(os.path.expanduser(config_dir), '') # Init variables. self.buffer_dict = {} self.view_dict = {} self.emacs_var_dict = {} self.session_file = os.path.join(eaf_config_dir, "session.json") # Update Emacs var dictionary. self.update_emacs_var_dict(var_dict_string) # Build EPC client. self.client = EPCClient(("localhost", int(emacs_server_port)), log_traceback=True) # Build EPC server. self.server = ThreadingEPCServer(('localhost', 0), log_traceback=True) self.server.logger.setLevel(logging.DEBUG) self.server.allow_reuse_address = True if not os.path.exists(eaf_config_dir): os.makedirs(eaf_config_dir) ch = logging.FileHandler(filename=os.path.join(eaf_config_dir, 'epc_log.txt'), mode='w') ch.setLevel(logging.DEBUG) self.server.logger.addHandler(ch) self.server.register_instance( self) # register instance functions let elisp side call # Start EPC server with sub-thread, avoid block Qt main loop. self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.start() # Pass epc port and webengine codec information to Emacs when first start EAF. self.first_start(self.server.server_address[1], self.webengine_include_private_codec()) # Set Network proxy. if proxy_host != "" and proxy_port != "": proxy_string = "{0}://{1}:{2}".format(proxy_type, proxy_host, proxy_port) proxy = QNetworkProxy() if proxy_type == "socks5": proxy.setType(QNetworkProxy.Socks5Proxy) elif proxy_type == "http": proxy.setType(QNetworkProxy.HttpProxy) proxy.setHostName(proxy_host) proxy.setPort(int(proxy_port)) QNetworkProxy.setApplicationProxy(proxy)
class EAF(object): def __init__(self, args): global emacs_width, emacs_height, eaf_config_dir, proxy_string # Parse init arguments. (emacs_width, emacs_height, proxy_host, proxy_port, proxy_type, config_dir, emacs_server_port, var_dict_string) = args emacs_width = int(emacs_width) emacs_height = int(emacs_height) eaf_config_dir = os.path.join(os.path.expanduser(config_dir), '') # Init variables. self.buffer_dict = {} self.view_dict = {} self.emacs_var_dict = {} self.session_file = os.path.join(eaf_config_dir, "session.json") # Update Emacs var dictionary. self.update_emacs_var_dict(var_dict_string) # Build EPC client. self.client = EPCClient(("localhost", int(emacs_server_port)), log_traceback=True) # Build EPC server. self.server = ThreadingEPCServer(('localhost', 0), log_traceback=True) self.server.logger.setLevel(logging.DEBUG) self.server.allow_reuse_address = True if not os.path.exists(eaf_config_dir): os.makedirs(eaf_config_dir) ch = logging.FileHandler(filename=os.path.join(eaf_config_dir, 'epc_log.txt'), mode='w') ch.setLevel(logging.DEBUG) self.server.logger.addHandler(ch) self.server.register_instance( self) # register instance functions let elisp side call # Start EPC server with sub-thread, avoid block Qt main loop. self.server_thread = threading.Thread(target=self.server.serve_forever) self.server_thread.start() # Pass epc port and webengine codec information to Emacs when first start EAF. self.first_start(self.server.server_address[1], self.webengine_include_private_codec()) # Set Network proxy. if proxy_host != "" and proxy_port != "": proxy_string = "{0}://{1}:{2}".format(proxy_type, proxy_host, proxy_port) proxy = QNetworkProxy() if proxy_type == "socks5": proxy.setType(QNetworkProxy.Socks5Proxy) elif proxy_type == "http": proxy.setType(QNetworkProxy.HttpProxy) proxy.setHostName(proxy_host) proxy.setPort(int(proxy_port)) QNetworkProxy.setApplicationProxy(proxy) def build_emacs_server_connect(self, port): conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) conn.connect(('127.0.0.1', port)) return conn def get_command_result(self, command): ''' Execute the command and return the result. ''' if version_info >= (3, 7): return subprocess.run(command, check=False, shell=True, stdout=subprocess.PIPE, text=True).stdout else: return subprocess.run(command, check=False, shell=True, stdout=subprocess.PIPE).stdout def webengine_include_private_codec(self): ''' Return bool of whether the QtWebEngineProcess include private codec. ''' if platform.system() == "Windows": return "False" path = os.path.join( QLibraryInfo.location(QLibraryInfo.LibraryExecutablesPath), "QtWebEngineProcess") return self.get_command_result( "ldd {} | grep libavformat".format(path)) != "" @PostGui() def update_emacs_var_dict(self, var_dict_string): ''' Update Python side emacs_var_dict.(Fix issue #206) ''' self.emacs_var_dict = json.loads(var_dict_string) for buffer in list(self.buffer_dict.values()): buffer.emacs_var_dict = self.emacs_var_dict @PostGui() def new_buffer(self, buffer_id, url, app_name, arguments): ''' Create new buffer. ''' self.create_app(buffer_id, str(url), "app.{0}.buffer".format(str(app_name)), str(arguments)) @PostGui() def update_buffer_with_url(self, module_path, buffer_url, update_data): ''' Update buffer with url ''' for buffer in list(self.buffer_dict.values()): if buffer.module_path == module_path and buffer.url == buffer_url: buffer.update_with_data(update_data) break @PostGui() def scroll_other_buffer(self, view_info, scroll_direction, scroll_type): ''' Scroll to other buffer ''' (buffer_id, _, _, _, _) = view_info.split(":") if buffer_id in self.buffer_dict: self.buffer_dict[buffer_id].scroll_other_buffer( scroll_direction, scroll_type) def get_new_browser_window_buffer_id(self): ''' Return new browser window's buffer ID. ''' import secrets return "{0}-{1}-{2}-{3}-{4}-{5}-{6}".format(secrets.token_hex(2), secrets.token_hex(2), secrets.token_hex(2), secrets.token_hex(2), secrets.token_hex(2), secrets.token_hex(2), secrets.token_hex(2)) def create_new_browser_window(self): ''' Create new browser window.''' # Generate buffer id same as eaf.el does. buffer_id = self.get_new_browser_window_buffer_id() # Create buffer for create new browser window. app_buffer = self.create_buffer(buffer_id, "http://0.0.0.0", "app.browser.buffer", "") # Create emacs buffer with buffer id. self.create_new_browser_buffer(buffer_id) # Return new QWebEngineView for create new browser window. return app_buffer.buffer_widget def create_app(self, buffer_id, url, module_path, arguments): ''' Create app using create_buffer.''' try: self.create_buffer(buffer_id, url, module_path, arguments) return "" except ImportError: import traceback traceback.print_exc() return "EAF: Something went wrong when trying to import {0}".format( module_path) def create_buffer(self, buffer_id, url, module_path, arguments): ''' Create buffer.''' global emacs_width, emacs_height, eaf_config_dir, proxy_string # Create application buffer. module = importlib.import_module(module_path) app_buffer = module.AppBuffer(buffer_id, url, eaf_config_dir, arguments, self.emacs_var_dict, module_path) # Add buffer to buffer dict. self.buffer_dict[buffer_id] = app_buffer # Resize buffer with emacs max window size, # view (QGraphicsView) will adjust visual area along with emacs window changed. app_buffer.buffer_widget.resize(emacs_width, emacs_height) # Monitor buffer signals. app_buffer.update_buffer_details.connect(self.update_buffer_details) app_buffer.translate_text.connect(self.translate_text) app_buffer.open_url_in_new_tab.connect(self.open_url_in_new_tab) app_buffer.duplicate_page_in_new_tab.connect( self.duplicate_page_in_new_tab) app_buffer.open_url_in_background_tab.connect( self.open_url_in_background_tab) app_buffer.goto_left_tab.connect(self.goto_left_tab) app_buffer.goto_right_tab.connect(self.goto_right_tab) # Send message to emacs. app_buffer.input_message.connect(self.input_message) # Handle buffer close request. app_buffer.request_close_buffer.connect(self.request_kill_buffer) # Handle message to emacs. app_buffer.message_to_emacs.connect(self.message_to_emacs) # Handle set emacs var signal. app_buffer.set_emacs_var.connect(self.set_emacs_var) # Handle eval form in emacs. app_buffer.eval_in_emacs.connect(self.eval_in_emacs) # Handle get_focus_text signal. if getattr(app_buffer, "get_focus_text", False) and getattr( app_buffer.get_focus_text, "connect", False): app_buffer.get_focus_text.connect(self.atomic_edit) if getattr( app_buffer.buffer_widget, "get_focus_text", False) and getattr( app_buffer.buffer_widget.get_focus_text, "connect", False): app_buffer.buffer_widget.get_focus_text.connect(self.atomic_edit) # Handle get_sub_node_id signal. if getattr(app_buffer, "get_sub_node_id", False) and getattr( app_buffer.get_sub_node_id, "connect", False): app_buffer.get_sub_node_id.connect(self.add_multiple_sub_nodes) # Handle get_brother_node_id signal. if getattr(app_buffer, "get_brother_node_id", False) and getattr( app_buffer.get_brother_node_id, "connect", False): app_buffer.get_brother_node_id.connect( self.add_multiple_brother_nodes) # Handle get_middle_node_id signal. if getattr(app_buffer, "get_middle_node_id", False) and getattr( app_buffer.get_middle_node_id, "connect", False): app_buffer.get_middle_node_id.connect( self.add_multiple_middle_nodes) # Handle trigger_focus_event signal. if getattr(app_buffer.buffer_widget, "trigger_focus_event", False) and getattr( app_buffer.buffer_widget.trigger_focus_event, "connect", False): app_buffer.buffer_widget.trigger_focus_event.connect( self.focus_emacs_buffer) # Handle export_org_json signal. if getattr(app_buffer, "export_org_json", False) and getattr( app_buffer.export_org_json, "connect", False): app_buffer.export_org_json.connect(self.export_org_json) # Handle dev tools signal. if getattr(app_buffer, "open_dev_tools_tab", False) and getattr( app_buffer.open_dev_tools_tab, "connect", False): app_buffer.open_dev_tools_tab.connect(self.open_dev_tools_tab) # Handle fulllscreen signal. if getattr(app_buffer, "enter_fullscreen_request", False) and getattr( app_buffer.enter_fullscreen_request, "connect", False): app_buffer.enter_fullscreen_request.connect( self.enter_fullscreen_request) if getattr(app_buffer, "exit_fullscreen_request", False) and getattr( app_buffer.exit_fullscreen_request, "connect", False): app_buffer.exit_fullscreen_request.connect( self.exit_fullscreen_request) # Add create new window when create_new_browser_window_callback is call. if module_path == "app.browser.buffer" or module_path == "app.terminal.buffer": app_buffer.buffer_widget.create_new_browser_window_callback = self.create_new_browser_window elif module_path == "app.rss-reader.buffer": app_buffer.buffer_widget.browser.create_new_browser_window_callback = self.create_new_browser_window if module_path == "app.browser.buffer": app_buffer.proxy_string = proxy_string # If arguments is dev_tools, create dev tools page. if module_path == "app.browser.buffer" and arguments == "dev_tools" and self.dev_tools_page: self.dev_tools_page.setDevToolsPage( app_buffer.buffer_widget.web_page) self.dev_tools_page = None # Restore buffer session. self.restore_buffer_session(app_buffer) return app_buffer @PostGui() def update_views(self, args): ''' Update views.''' view_infos = args.split(",") # Show cursor anyway. QtWidgets.qApp.restoreOverrideCursor() # Do something if buffer's all view hide after update_views operation. old_view_buffer_ids = list( set(map(lambda v: v.buffer_id, self.view_dict.values()))) new_view_buffer_ids = list( set(map(lambda v: v.split(":")[0], view_infos))) # Call all_views_hide interface when buffer's all views will hide. # We do something in app's buffer interface, such as videoplayer will pause video when all views hide. # Note, we must call this function before last view destroy, # such as QGraphicsVideoItem will report "Internal data stream error" error. for old_view_buffer_id in old_view_buffer_ids: if old_view_buffer_id not in new_view_buffer_ids: self.buffer_dict[old_view_buffer_id].all_views_hide() # Remove old key from view dict and destroy old view. for key in list(self.view_dict): if key not in view_infos: self.view_dict[key].destroy_view() self.view_dict.pop(key, None) # Create new view and update in view dict. if view_infos != ['']: for view_info in view_infos: if view_info not in self.view_dict: (buffer_id, _, _, _, _, _) = view_info.split(":") view = View(self.buffer_dict[buffer_id], view_info) self.view_dict[view_info] = view view.trigger_focus_event.connect(self.focus_emacs_buffer) # Call some_view_show interface when buffer's view switch back. # Note, this must call after new view create, otherwise some buffer, # such as QGraphicsVideoItem will report "Internal data stream error" error. if view_infos != ['']: for new_view_buffer_id in new_view_buffer_ids: if new_view_buffer_id not in old_view_buffer_ids: self.buffer_dict[new_view_buffer_id].some_view_show() # Adjust buffer size along with views change. # Note: just buffer that option `fit_to_view' is False need to adjust, # if buffer option fit_to_view is True, buffer render adjust by view.resizeEvent() for buffer in list(self.buffer_dict.values()): if not buffer.fit_to_view: buffer_views = list( filter(lambda v: v.buffer_id == buffer.buffer_id, list(self.view_dict.values()))) # Adjust buffer size to max view's size. if len(buffer_views) > 0: max_view = max(buffer_views, key=lambda v: v.width * v.height) buffer.buffer_widget.resize(max_view.width, max_view.height) # Adjust buffer size to emacs window size if not match view found. else: buffer.buffer_widget.resize(emacs_width, emacs_height) # Send resize signal to buffer. buffer.resize_view() @PostGui() def kill_emacs(self): ''' Kill all buffurs from buffer dict.''' tmp_buffer_dict = {} for buffer_id in self.buffer_dict: tmp_buffer_dict[buffer_id] = self.buffer_dict[buffer_id] for buffer_id in tmp_buffer_dict: self.kill_buffer(buffer_id) @PostGui() def kill_buffer(self, buffer_id): ''' Kill all view based on buffer_id and clean buffer from buffer dict.''' # Kill all view base on buffer_id. for key in list(self.view_dict): if buffer_id == self.view_dict[key].buffer_id: self.view_dict[key].destroy_view() self.view_dict.pop(key, None) # Clean buffer from buffer dict. if buffer_id in self.buffer_dict: # Save buffer session. self.save_buffer_session(self.buffer_dict[buffer_id]) self.buffer_dict[buffer_id].destroy_buffer() self.buffer_dict.pop(buffer_id, None) @PostGui() def execute_function(self, buffer_id, function_name, event_string): ''' Execute function and do not return anything. ''' if buffer_id in self.buffer_dict: try: buffer = self.buffer_dict[buffer_id] buffer.current_event_string = event_string buffer.execute_function(function_name) except AttributeError: import traceback traceback.print_exc() self.message_to_emacs("Cannot execute function: " + function_name + " (" + buffer_id + ")") def call_function(self, buffer_id, function_name): ''' Call function and return the result. ''' if buffer_id in self.buffer_dict: try: return str( self.buffer_dict[buffer_id].call_function(function_name)) except AttributeError: import traceback traceback.print_exc() self.message_to_emacs("Cannot call function: " + function_name) return "" def call_function_with_args(self, buffer_id, function_name, *args, **kwargs): ''' Call function with arguments and return the result. ''' if buffer_id in self.buffer_dict: try: return str(self.buffer_dict[buffer_id].call_function_with_args( function_name, *args, **kwargs)) except AttributeError: import traceback traceback.print_exc() self.message_to_emacs("Cannot call function: " + function_name) return "" @PostGui() def action_quit(self, buffer_id): ''' Execute action_quit() for specified buffer.''' if buffer_id in self.buffer_dict: self.buffer_dict[buffer_id].action_quit() @PostGui() def send_key(self, buffer_id, event_string): ''' Send event to buffer when found match buffer.''' if buffer_id in self.buffer_dict: self.buffer_dict[buffer_id].fake_key_event(event_string) @PostGui() def send_key_sequence(self, buffer_id, event_string): ''' Send event to buffer when found match buffer.''' if buffer_id in self.buffer_dict: self.buffer_dict[buffer_id].fake_key_sequence(event_string) @PostGui() def handle_input_response(self, buffer_id, callback_tag, callback_result): ''' Handle input message for specified buffer.''' for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: buffer.handle_input_response(callback_tag, callback_result) @PostGui() def cancel_input_response(self, buffer_id, callback_tag): ''' Cancel input message for specified buffer.''' for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: buffer.cancel_input_response(callback_tag) @PostGui() def update_focus_text(self, buffer_id, new_text): ''' Update focus text for specified buffer.''' import base64 for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: buffer.set_focus_text( base64.b64decode(new_text).decode("utf-8")) @PostGui() def update_multiple_sub_nodes(self, buffer_id, new_text): ''' Update multiplt sub nodes.''' for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: for line in str(new_text).split("\n"): buffer.add_texted_sub_node(line) @PostGui() def update_multiple_brother_nodes(self, buffer_id, new_text): ''' Update multiplt brother nodes.''' for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: for line in str(new_text).split("\n"): buffer.add_texted_brother_node(line) @PostGui() def update_multiple_middle_nodes(self, buffer_id, new_text): ''' Update multiplt middle nodes.''' for buffer in list(self.buffer_dict.values()): if buffer.buffer_id == buffer_id: for line in str(new_text).split("\n"): buffer.add_texted_middle_node(line) def eval_in_emacs(self, method_name, args): # Make argument encode with Base64, avoid string quote problem pass to elisp side. args = list(map(string_to_base64, args)) args.insert(0, method_name) # Call eval-in-emacs elisp function. self.client.call("eval-in-emacs", args) def add_multiple_sub_nodes(self, buffer_id): self.eval_in_emacs('eaf--add-multiple-sub-nodes', [buffer_id]) def add_multiple_brother_nodes(self, buffer_id): self.eval_in_emacs('eaf--add-multiple-brother-nodes', [buffer_id]) def add_multiple_middle_nodes(self, buffer_id): self.eval_in_emacs('eaf--add-multiple-middle-nodes', [buffer_id]) def focus_emacs_buffer(self, message): self.eval_in_emacs('eaf-focus-buffer', [message]) def first_start(self, port, webengine_include_private_codec): self.eval_in_emacs('eaf--first-start', [port, webengine_include_private_codec]) def update_buffer_details(self, buffer_id, title, url): self.eval_in_emacs('eaf--update-buffer-details', [buffer_id, title, url]) def open_url_in_new_tab(self, url): self.eval_in_emacs('eaf-open-browser', [url]) def duplicate_page_in_new_tab(self, url): self.eval_in_emacs('eaf-browser--duplicate-page-in-new-tab', [url]) def open_dev_tools_page(self): self.eval_in_emacs('eaf-open-dev-tool-page', []) def open_url_in_background_tab(self, url): self.eval_in_emacs('eaf-open-browser-in-background', [url]) def goto_left_tab(self): self.eval_in_emacs('eaf-goto-left-tab', []) def goto_right_tab(self): self.eval_in_emacs('eaf-goto-right-tab', []) def translate_text(self, text): self.eval_in_emacs('eaf-translate-text', [text]) def input_message(self, buffer_id, message, callback_tag, input_type, input_content): self.eval_in_emacs( 'eaf--input-message', [buffer_id, message, callback_tag, input_type, input_content]) def create_new_browser_buffer(self, buffer_id): self.eval_in_emacs('eaf--create-new-browser-buffer', [buffer_id]) def request_kill_buffer(self, buffer_id): self.eval_in_emacs('eaf-request-kill-buffer', [buffer_id]) def message_to_emacs(self, message): self.eval_in_emacs('eaf--show-message', [message]) def set_emacs_var(self, var_name, var_value, eaf_specific): self.eval_in_emacs('eaf--set-emacs-var', [var_name, var_value, eaf_specific]) def atomic_edit(self, buffer_id, focus_text): self.eval_in_emacs('eaf--atomic-edit', [buffer_id, focus_text]) def export_org_json(self, org_json_content, org_file_path): self.eval_in_emacs('eaf--export-org-json', [org_json_content, org_file_path]) def enter_fullscreen_request(self): self.eval_in_emacs('eaf--enter-fullscreen-request', []) def exit_fullscreen_request(self): self.eval_in_emacs('eaf--exit_fullscreen_request', []) def open_dev_tools_tab(self, web_page): ''' Open dev-tools tab''' self.dev_tools_page = web_page self.open_dev_tools_page() def save_buffer_session(self, buf): ''' Save buffer session to file.''' # Create config file it not exist. if not os.path.exists(self.session_file): basedir = os.path.dirname(self.session_file) if not os.path.exists(basedir): os.makedirs(basedir) with open(self.session_file, 'a'): os.utime(self.session_file, None) print("Create session file %s" % (self.session_file)) # Save buffer session to file. buf_session_data = buf.save_session_data() if buf_session_data != "": with open(self.session_file, "r+") as session_file: # Init session dict. session_dict = {} try: session_dict = json.load(session_file) except ValueError: pass # Init module path dict. if buf.module_path not in session_dict: session_dict[buf.module_path] = {} # Update session data. session_dict[buf.module_path].update( {buf.url: buf_session_data}) # Clean session file and update new content. session_file.seek(0) session_file.truncate(0) json.dump(session_dict, session_file) print("Saved session: ", buf.module_path, buf.url, buf_session_data) def restore_buffer_session(self, buf): ''' Restore buffer session from file.''' if os.path.exists(self.session_file): with open(self.session_file, "r+") as session_file: session_dict = {} try: session_dict = json.load(session_file) except ValueError: pass if buf.module_path in session_dict: if buf.url in session_dict[buf.module_path]: buf.restore_session_data( session_dict[buf.module_path][buf.url]) print("Session restored: ", buf.buffer_id, buf.module_path, self.session_file) else: print("Session is not restored, as no data about %s." % (buf.url)) else: print( "Session is not restored, as no data present in session file." ) else: print("Session is not restored, as %s cannot be found." % (self.session_file))
def connect(self, address): self.client = EPCClient(address)
def init_epc_client(emacs_server_port): global epc_client if epc_client == None: epc_client = EPCClient(("localhost", emacs_server_port), log_traceback=True)
def get_source(lib, off): import os import subprocess import atexit import time import random import string from epc.client import EPCClient global temp_dir global _global_servers def get_ida_server_port(lib): global idb_ext global server_ports_filename lib = lib.replace('\\', '/') ida_input_filename = (lib + ".idb", lib + ".i64") ida_servers = [ l.split(None, 1) for l in open(server_ports_filename, 'r+t').readlines() ] ida_servers = [ port for port, image in ida_servers if image.replace('\n', '') in ida_input_filename ] assert len(ida_servers) > 0, "%s not found in ida server database" % ( ','.join(ida_input_filename), ) assert ida_servers[0] != '-', "%s not found in ida server database" % ( ','.join(ida_input_filename), ) return int(ida_servers[0]) def run_ida_with_server(lib, client_identifier): global ida_paths global ida64_paths if os.path.exists(lib + ".til"): raise Exception("idb is already opened or not closed correctly", lib) elif os.path.exists(lib + ".idb"): ida_input_filename = lib + ".idb" _ida_path = ida_paths[0] elif os.path.exists(lib + ".i64"): ida_input_filename = lib + ".i64" _ida_path = ida64_paths[0] elif os.path.exists(lib): raise Exception("binary found but without idb", lib) else: raise Exception("binary not found", lib) ida_tmp_script = os.path.join( temp_dir, 'idatmpscript_%s.py' % (client_identifier, )) command = [_ida_path, '-S%s' % (ida_tmp_script, ), ida_input_filename] atexit.register(os.unlink, ida_tmp_script) with open(ida_tmp_script, 'wt') as f: f.write("_IDA_INTERNAL_SCRIPT") print('running command: %s' % (' '.join(command), )) def run_and_delete(args, filename): proc = subprocess.Popen(args) proc.wait() os.unlink(filename) threading.Thread(target=run_and_delete, args=(command, ida_tmp_script)).start() print('command returned: %s' % (' '.join(command), )) def generate_random_string(len): return ''.join(random.choice(string.ascii_letters) for i in range(len)) if lib.startswith('/'): lib = lib[1:] base_dir = os.getcwd() lib = os.path.join(base_dir, lib) error_filename = "%s_idaerror.txt" % (os.path.join( temp_dir, os.path.basename(lib)), ) try: os.unlink(error_filename) except: pass try: port = get_ida_server_port(lib) except (FileNotFoundError, AssertionError): client_identifier = generate_random_string(6) run_ida_with_server(lib, client_identifier) port = None for _ in range(10): try: port = get_ida_server_port(lib) if port is not None: time.sleep(0.5) break except (FileNotFoundError, AssertionError): time.sleep(0.5) else: try: extra_info = open(error_filename, 'rt').read() except FileNotFoundError: extra_info = "ida seems to start correctly" raise Exception("cannot connect to ida server", extra_info) expected_server_address = ("localhost", port) if lib in _global_servers: current_connection = _global_servers[lib] if current_connection.socket.getpeername() != expected_server_address: current_connection.close() del _global_servers[lib] if lib not in _global_servers: print('connect to port %d' % (port, )) _global_servers[lib] = EPCClient(expected_server_address) print('requesting offset %X' % (off, )) return _global_servers[lib].call_sync('decompile_with_ea_lines', [ off, ])