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
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')
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')
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)
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()
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()
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)
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 __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()
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()
def cont_handler(self, event):
log.debug('Inferior continued')
if self.server == None:
self.server = Server()
self.server.start()
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()
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")
def cont_handler(self, event):
log.debug('Inferior continued')
if self.server == None:
self.server = Server()
self.server.start()
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()