Beispiel #1
0
            def __init__(self, debugger, dict):
                super(VoltronCommand, self).__init__()

                # grab the debugger and command interpreter
                self.debugger = debugger
                self.ci = self.debugger.GetCommandInterpreter()

                # install the voltron command handler
                self.debugger.HandleCommand(
                    'command script add -f dbgentry.lldb_invoke voltron')

                # load plugins
                self.pm = voltron.plugin.pm

                # set up an lldb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host(
                    'lldb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # start the server
                self.server = Server()
                self.server.start()

                self.hook_idx = None
Beispiel #2
0
        class VoltronVDBCommand(VoltronCommand, vtrace.Notifier):
            """
            Debugger command class for VDB
            """
            def __init__(self, vdb, vtrace):
                """
                vdb is the debugger instance
                vtrace is the vtrace module?
                """
                super(VoltronCommand, self).__init__()
                self._vdb = vdb
                self._vtrace = vtrace

                self.pm = PluginManager()

                self.adaptor = self.pm.debugger_plugin_for_host(
                    'vdb').adaptor_class(self._vdb, self._vtrace)
                voltron.debugger = self.adaptor

                self.pm.register_plugins()

                self.server = Server()
                self.server.start()

            def invoke(self, arg, from_tty):
                self.handle_command(arg)

            def register_hooks(self):
                self._vdb.registerNotifier(vtrace.NOTIFY_ALL, self)

            def unregister_hooks(self):
                self._vdb.deregisterNotifier(vtrace.NOTIFY_ALL, self)

            def notify(self, event, trace):
                if event == self._vtrace.NOTIFY_DETACH:
                    self.exit_handler(event)
                elif event == self._vtrace.NOTIFY_EXIT:
                    self.exit_handler(event)
                elif event == self._vtrace.NOTIFY_BREAK:
                    self.stop_handler(event)
                elif event == self._vtrace.NOTIFY_STEP:
                    self.stop_handler(event)
                elif event == self._vtrace.NOTIFY_CONTINUE:
                    self.cont_handler(event)

            def stop_handler(self, event):
                self.adaptor.update_state()
                log.debug('Inferior stopped')

            def exit_handler(self, event):
                log.debug('Inferior exited')
                self.server.stop()
                # vdb doesn't signal STOP/BREAK on exit, so we
                #   clear an outstanding Wait requests
                self.adaptor.update_state()

            def cont_handler(self, event):
                log.debug('Inferior continued')
Beispiel #3
0
        class VoltronVDBCommand(VoltronCommand, vtrace.Notifier):
            """
            Debugger command class for VDB
            """
            def __init__(self, vdb, vtrace):
                """
                vdb is the debugger instance
                vtrace is the vtrace module?
                """
                super(VoltronCommand, self).__init__()
                self._vdb = vdb
                self._vtrace = vtrace

                self.pm = PluginManager()

                self.adaptor = self.pm.debugger_plugin_for_host('vdb').adaptor_class(self._vdb, self._vtrace)
                voltron.debugger = self.adaptor

                self.pm.register_plugins()

                self.server = Server()
                self.server.start()

            def invoke(self, arg, from_tty):
                self.handle_command(arg)

            def register_hooks(self):
                self._vdb.registerNotifier(vtrace.NOTIFY_ALL, self)

            def unregister_hooks(self):
                self._vdb.deregisterNotifier(vtrace.NOTIFY_ALL, self)

            def notify(self, event, trace):
                if event == self._vtrace.NOTIFY_DETACH:
                    self.exit_handler(event)
                elif event == self._vtrace.NOTIFY_EXIT:
                    self.exit_handler(event)
                elif event == self._vtrace.NOTIFY_BREAK:
                    self.stop_handler(event)
                elif event == self._vtrace.NOTIFY_STEP:
                    self.stop_handler(event)
                elif event == self._vtrace.NOTIFY_CONTINUE:
                    self.cont_handler(event)

            def stop_handler(self, event):
                self.adaptor.update_state()
                log.debug('Inferior stopped')

            def exit_handler(self, event):
                log.debug('Inferior exited')
                self.server.stop()
                # vdb doesn't signal STOP/BREAK on exit, so we
                #   clear an outstanding Wait requests
                self.adaptor.update_state()

            def cont_handler(self, event):
                log.debug('Inferior continued')
Beispiel #4
0
        class VoltronLLDBCommand(VoltronCommand):
            """
            Debugger command class for LLDB
            """
            def __init__(self, debugger, dict):
                super(VoltronCommand, self).__init__()

                # grab the debugger and command interpreter
                self.debugger = debugger
                self.ci = self.debugger.GetCommandInterpreter()

                # install the voltron command handler
                self.debugger.HandleCommand(
                    'command script add -f dbgentry.lldb_invoke voltron')

                # load plugins
                self.pm = voltron.plugin.pm

                # set up an lldb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host(
                    'lldb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # start the server
                self.server = Server()
                self.server.start()

                self.hook_idx = None

            def invoke(self, debugger, command, result, dict):
                self.handle_command(command)

            def register_hooks(self):
                try:
                    output = self.adaptor.command("target stop-hook list")
                    if 'voltron' not in output:
                        output = self.adaptor.command(
                            'target stop-hook add -o \'voltron stopped\'')
                        try:
                            # hahaha this sucks
                            self.hook_idx = int(
                                res.GetOutput().strip().split()[2][1:])
                        except:
                            pass
                    print("Registered stop-hook")
                except:
                    print("No targets")

            def unregister_hooks(self):
                cmd = 'target stop-hook delete {}'.format(
                    self.hook_idx if self.hook_idx else '')
                self.debugger.HandleCommand(cmd)
Beispiel #5
0
        class VoltronGDBCommand(VoltronCommand, gdb.Command):
            """
            Debugger command class for GDB
            """
            def __init__(self):
                super(VoltronCommand,
                      self).__init__("voltron", gdb.COMMAND_NONE,
                                     gdb.COMPLETE_NONE)

                # load plugins
                self.pm = PluginManager()

                # set up a gdb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host(
                    'gdb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # server is started and stopped with the inferior to avoid GDB hanging on exit
                self.server = None

            def invoke(self, arg, from_tty):
                self.handle_command(arg)

            def register_hooks(self):
                gdb.events.stop.connect(self.stop_handler)
                gdb.events.exited.connect(self.stop_and_exit_handler)
                gdb.events.cont.connect(self.cont_handler)

            def unregister_hooks(self):
                gdb.events.stop.disconnect(self.stop_handler)
                gdb.events.exited.disconnect(self.stop_and_exit_handler)
                gdb.events.cont.disconnect(self.cont_handler)

            def stop_handler(self, event):
                self.adaptor.update_state()
                self.server.dispatch_queue()
                log.debug('Inferior stopped')

            def exit_handler(self, event):
                log.debug('Inferior exited')
                self.server.stop()

            def stop_and_exit_handler(self, event):
                log.debug('Inferior stopped and exited')
                self.stop_handler(event)
                self.exit_handler(event)

            def cont_handler(self, event):
                log.debug('Inferior continued')
                if self.server == None or self.server.is_running == False:
                    self.server = Server()
                    self.server.start()
Beispiel #6
0
        class VoltronGDBCommand (VoltronCommand, gdb.Command):
            """
            Debugger command class for GDB
            """
            def __init__(self):
                super(VoltronCommand, self).__init__("voltron", gdb.COMMAND_NONE, gdb.COMPLETE_NONE)

                # load plugins
                self.pm = PluginManager()

                # set up a gdb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host('gdb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # server is started and stopped with the inferior to avoid GDB hanging on exit
                self.server = None
                self.registered = False

            def invoke(self, arg, from_tty):
                self.handle_command(arg)

            def register_hooks(self):
                if not self.registered:
                    gdb.events.stop.connect(self.stop_handler)
                    gdb.events.exited.connect(self.stop_and_exit_handler)
                    gdb.events.cont.connect(self.cont_handler)

            def unregister_hooks(self):
                if self.registered:
                    gdb.events.stop.disconnect(self.stop_handler)
                    gdb.events.exited.disconnect(self.stop_and_exit_handler)
                    gdb.events.cont.disconnect(self.cont_handler)

            def stop_handler(self, event):
                self.adaptor.update_state()
                self.server.dispatch_queue()
                log.debug('Inferior stopped')

            def exit_handler(self, event):
                log.debug('Inferior exited')
                self.server.stop()

            def stop_and_exit_handler(self, event):
                log.debug('Inferior stopped and exited')
                self.stop_handler(event)
                self.exit_handler(event)

            def cont_handler(self, event):
                log.debug('Inferior continued')
                if not self.server:
                    self.server = Server()
                    self.server.start()
Beispiel #7
0
        class VoltronLLDBCommand (VoltronCommand):
            """
            Debugger command class for LLDB
            """
            def __init__(self, debugger, dict):
                super(VoltronCommand, self).__init__()

                # grab the debugger and command interpreter
                self.debugger = debugger
                self.ci = self.debugger.GetCommandInterpreter()

                # install the voltron command handler
                self.debugger.HandleCommand('command script add -f dbgentry.lldb_invoke voltron')

                # load plugins
                self.pm = voltron.plugin.pm

                # set up an lldb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host('lldb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # start the server
                self.server = Server()
                self.server.start()
                voltron.server = self.server

                self.hook_idx = None

            def invoke(self, debugger, command, result, dict):
                self.handle_command(command)

            def register_hooks(self):
                try:
                    output = self.adaptor.command("target stop-hook list")
                    if 'voltron' not in output:
                        output = self.adaptor.command('target stop-hook add -o \'voltron stopped\'')
                        try:
                            # hahaha this sucks
                            self.hook_idx = int(res.GetOutput().strip().split()[2][1:])
                        except:
                            pass
                    print("Registered stop-hook")
                except:
                    print("No targets")

            def unregister_hooks(self):
                cmd = 'target stop-hook delete {}'.format(self.hook_idx if self.hook_idx else '')
                self.debugger.HandleCommand(cmd)
Beispiel #8
0
            def __init__(self, debugger, dict):
                super(VoltronCommand, self).__init__()

                # grab the debugger and command interpreter
                self.debugger = debugger
                self.ci = self.debugger.GetCommandInterpreter()

                # install the voltron command handler
                self.debugger.HandleCommand('command script add -f dbgentry.lldb_invoke voltron')

                # load plugins
                self.pm = voltron.plugin.pm

                # set up an lldb adaptor and set it as the package-wide adaptor
                self.adaptor = self.pm.debugger_plugin_for_host('lldb').adaptor_class()
                voltron.debugger = self.adaptor

                # register plugins now that we have a debugger
                self.pm.register_plugins()

                # start the server
                self.server = Server()
                self.server.start()

                self.hook_idx = None
Beispiel #9
0
            def __init__(self, vdb, vtrace):
                """
                vdb is the debugger instance
                vtrace is the vtrace module?
                """
                super(VoltronCommand, self).__init__()
                self._vdb = vdb
                self._vtrace = vtrace

                self.pm = PluginManager()

                self.adaptor = self.pm.debugger_plugin_for_host(
                    'vdb').adaptor_class(self._vdb, self._vtrace)
                voltron.debugger = self.adaptor

                self.server = Server()
                self.server.start()
Beispiel #10
0
            def __init__(self, vdb, vtrace):
                """
                vdb is the debugger instance
                vtrace is the vtrace module?
                """
                super(VoltronCommand, self).__init__()
                self._vdb = vdb
                self._vtrace = vtrace

                self.pm = PluginManager()

                self.adaptor = self.pm.debugger_plugin_for_host('vdb').adaptor_class(self._vdb, self._vtrace)
                voltron.debugger = self.adaptor

                self.server = Server()
                self.server.start()
Beispiel #11
0
 def cont_handler(self, event):
     log.debug('Inferior continued')
     if self.server == None:
         self.server = Server()
         self.server.start()
Beispiel #12
0
 def cont_handler(self, event):
     log.debug('Inferior continued')
     if self.server == None or self.server.is_running == False:
         self.server = Server()
         self.server.start()
Beispiel #13
0
    if not host:
        raise Exception("No debugger host is present")

    # register any plugins that were loaded
    pm.register_plugins()

    # get the debugger plugin for the host we're in
    plugin = pm.debugger_plugin_for_host(host)

    if not voltron.command:
        # set up command and adaptor instances
        voltron.debugger = plugin.adaptor_class(*args)
        voltron.command = plugin.command_class(*args)

        # create and start the voltron server
        voltron.server = Server()
        if host != "gdb":
            voltron.server.start()

        print(blessed.Terminal().bold_red("Voltron loaded."))
        if host == 'lldb' and not voltron.command.registered:
            print("Run `voltron init` after you load a target.")

except Exception as e:
    import traceback
    msg = "An error occurred while loading Voltron:\n\n{}".format(
        traceback.format_exc())
    if blessed:
        msg = blessed.Terminal().bold_red(msg)
    if log:
        log.exception("Exception raised while loading Voltron")
Beispiel #14
0
 def cont_handler(self, event):
     log.debug('Inferior continued')
     if self.server == None:
         self.server = Server()
         self.server.start()
Beispiel #15
0
 def cont_handler(self, event):
     log.debug('Inferior continued')
     if self.server == None or self.server.is_running == False:
         self.server = Server()
         self.server.start()