/*

Copyright (C) 2006 - 2015 Evan Teran

evan.teran@gmail.com

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "Debugger.h"

#include "ArchProcessor.h"

#include "CommentServer.h"

#include "Configuration.h"

#include "DebuggerInternal.h"

#include "DialogAbout.h"

#include "DialogArguments.h"

#include "DialogAttach.h"

#include "DialogMemoryRegions.h"

#include "DialogOpenProgram.h"

#include "DialogOptions.h"

#include "DialogPlugins.h"

#include "DialogThreads.h"

#include "Expression.h"

#include "IAnalyzer.h"

#include "IBinary.h"

#include "IBreakpoint.h"

#include "IDebugEvent.h"

#include "IDebugger.h"

#include "IPlugin.h"

#include "IProcess.h"

#include "IThread.h"

#include "Instruction.h"

#include "MemoryRegions.h"

#include "QHexView"

#include "RecentFileManager.h"

#include "RegionBuffer.h"

#include "RegisterViewModelBase.h"

#include "State.h"

#include "Symbol.h"

#include "SymbolManager.h"

#include "SessionManager.h"

#include "SessionError.h"

#include "edb.h"

#if defined(Q_OS_LINUX)

#include "linker.h"

#endif

#include <QCloseEvent>

#include <QDateTime>

#include <QDesktopServices>

#include <QDesktopWidget>

#include <QDir>

#include <QDragEnterEvent>

#include <QDropEvent>

#include <QFileDialog>

#include <QFileInfo>

#include <QHBoxLayout>

#include <QInputDialog>

#include <QLabel>

#include <QMessageBox>

#include <QMimeData>

#include <QSettings>

#include <QShortcut>

#include <QStringListModel>

#include <QTimer>

#include <QToolButton>

#include <QUrl>

#include <QVector>

#include <QtDebug>

#include <QJsonDocument>

#include <QJsonObject>

#include <QJsonParseError>

#include <memory>

#include <cstring>

#include <clocale>

#if defined(Q_OS_UNIX)

#include <signal.h>

#endif

#include <sys/types.h>

#include <sys/stat.h>

#if defined(Q_OS_LINUX) || defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)

#include <unistd.h>

#include <fcntl.h>

#endif

namespace {

constexpr quint64 initial_bp_tag = Q_UINT64_C(0x494e4954494e5433); // "INITINT3" in hex

constexpr quint64 stepover_bp_tag = Q_UINT64_C(0x535445504f564552); // "STEPOVER" in hex

constexpr quint64 run_to_cursor_tag = Q_UINT64_C(0x474f544f48455245); // "GOTOHERE" in hex

#ifdef Q_OS_LINUX

constexpr quint64 ld_loader_tag = Q_UINT64_C(0x4c49424556454e54); // "LIBEVENT" in hex

#endif

template <class Addr>

void handle_library_event(IProcess *process, edb::address_t debug_pointer) {

#ifdef Q_OS_LINUX

edb::linux_struct::r_debug<Addr> dynamic_info;

const bool ok = (process->read_bytes(debug_pointer, &dynamic_info, sizeof(dynamic_info)) == sizeof(dynamic_info));

if(ok) {

// NOTE(eteran): at least on my system, the name of

// what is being loaded is either in

// r8 or r13 depending on which event

// we are looking at.

// TODO(eteran): find a way to get the name reliably

switch(dynamic_info.r_state) {

case edb::linux_struct::r_debug<Addr>::RT_CONSISTENT:

// TODO(eteran): enable this once we are confident

#if 0

edb::v1::memory_regions().sync();

#endif

break;

case edb::linux_struct::r_debug<Addr>::RT_ADD:

//qDebug("LIBRARY LOAD EVENT");

break;

case edb::linux_struct::r_debug<Addr>::RT_DELETE:

//qDebug("LIBRARY UNLOAD EVENT");

break;

}

}

#else

Q_UNUSED(process)

Q_UNUSED(debug_pointer)

#endif

}

template <class Addr>

edb::address_t find_linker_hook_address(IProcess *process, edb::address_t debug_pointer) {

#ifdef Q_OS_LINUX

edb::linux_struct::r_debug<Addr> dynamic_info;

const bool ok = process->read_bytes(debug_pointer, &dynamic_info, sizeof(dynamic_info));

if(ok) {

return edb::address_t::fromZeroExtended(dynamic_info.r_brk);

}

#else

Q_UNUSED(process)

Q_UNUSED(debug_pointer)

#endif

return edb::address_t(0);

}

//--------------------------------------------------------------------------

// Name: is_instruction_ret

//--------------------------------------------------------------------------

bool is_instruction_ret(edb::address_t address) {

quint8 buffer[edb::Instruction::MAX_SIZE];

if(const int size = edb::v1::get_instruction_bytes(address, buffer)) {

edb::Instruction inst(buffer, buffer + size, address);

return is_ret(inst);

}

return false;

}

class RunUntilRet : public IDebugEventHandler {

Q_DECLARE_TR_FUNCTIONS(RunUntilRet)

public:

//--------------------------------------------------------------------------

// Name: RunUntilRet

//--------------------------------------------------------------------------

RunUntilRet() : last_call_return_(0) {

edb::v1::add_debug_event_handler(this);

}

//--------------------------------------------------------------------------

// Name: ~RunUntilRet

//--------------------------------------------------------------------------

~RunUntilRet() {

edb::v1::remove_debug_event_handler(this);

for(const auto& bp : own_breakpoints_) {

if(!bp.second.expired()) {

edb::v1::debugger_core->remove_breakpoint(bp.first);

}

}

}

//--------------------------------------------------------------------------

// Name: pass_back_to_debugger

// Desc: Makes the previous handler the event handler again and deletes this.

//--------------------------------------------------------------------------

virtual edb::EVENT_STATUS pass_back_to_debugger() {

delete this;

return edb::DEBUG_NEXT_HANDLER;

}

//--------------------------------------------------------------------------

// Name: handle_event

//--------------------------------------------------------------------------

//TODO: Need to handle stop/pause button

edb::EVENT_STATUS handle_event(const std::shared_ptr<IDebugEvent> &event) override {

if(!event->is_trap()) {

return pass_back_to_debugger();

}

if(IProcess *process = edb::v1::debugger_core->process()) {

State state;

process->current_thread()->get_state(&state);

edb::address_t address = state.instruction_pointer();

IDebugEvent::TRAP_REASON trap_reason = event->trap_reason();

IDebugEvent::REASON reason = event->reason();

qDebug() << QString("Event at address 0x%1").arg(address, 0, 16);

/*

* An IDebugEvent::TRAP_BREAKPOINT can happen for the following reasons:

* 1. We hit a user-set breakpoint.

* 2. We hit an internal breakpoint due to our RunUntilRet algorithm.

* 3. We hit a syscall (this shouldn't be; it may be a ptrace bug).

* 4. We have exited in some form or another.

* First check for exit, then breakpoint (user-set, then internal; adjust for RIP in both cases),

* then finally for the syscall bug.

*/

if (trap_reason == IDebugEvent::TRAP_BREAKPOINT) {

qDebug() << "Trap breakpoint";

//Take care of exit/terminated conditions; address == 0 may suffice to catch all, but not 100% sure.

if (reason == IDebugEvent::EVENT_EXITED || reason == IDebugEvent::EVENT_TERMINATED || address == 0) {

qDebug() << "The process is no longer running.";

return pass_back_to_debugger();

}

//Check the previous byte for 0xcc to see if it was an actual breakpoint

std::shared_ptr<IBreakpoint> bp = edb::v1::find_triggered_breakpoint(address);

//If there was a bp there, then we hit a block terminator as part of our RunUntilRet

//algorithm, or it is a user-set breakpoint.

if(bp && bp->enabled()) { //Isn't it always enabled if trap_reason is breakpoint, anyway?

const edb::address_t prev_address = bp->address();

bp->hit();

//Adjust RIP since 1st byte was replaced with 0xcc and we are now 1 byte after it.

state.set_instruction_pointer(prev_address);

process->current_thread()->set_state(state);

address = prev_address;

//If it wasn't internal, it was a user breakpoint. Pass back to Debugger.

if (!bp->internal()) {

qDebug() << "Previous was not an internal breakpoint.";

return pass_back_to_debugger();

}

qDebug() << "Previous was an internal breakpoint.";

bp->disable();

edb::v1::debugger_core->remove_breakpoint(bp->address());

}

else {

//No breakpoint if it was a syscall; continue.

return edb::DEBUG_CONTINUE;

}

}

//If we are on our ret (or the instr after?), then ret.

if (address == ret_address_) {

qDebug() << QString("On our terminator at 0x%1").arg(address, 0, 16);

if (is_instruction_ret(address)) {

qDebug() << "Found ret; passing back to debugger";

return pass_back_to_debugger();

}

else {

//If not a ret, then step so we can find the next block terminator.

qDebug() << "Not ret. Single-stepping";

return edb::DEBUG_CONTINUE_STEP;

}

}

//If we stepped (either because it was the first event or because we hit a jmp/jcc),

//then find the next block terminator and edb::DEBUG_CONTINUE.

//TODO: What if we started on a ret? Set bp, then the proc runs away?

quint8 buffer[edb::Instruction::MAX_SIZE];

while (const int size = edb::v1::get_instruction_bytes(address, buffer)) {

//Get the instruction

edb::Instruction inst(buffer, buffer + size, 0);

qDebug() << QString("Scanning for terminator at 0x%1: found %2").arg(

address, 0, 16).arg(

inst.mnemonic().c_str());

//Check if it's a proper block terminator (ret/jmp/jcc/hlt)

if (inst) {

if (is_terminator(inst)) {

qDebug() << QString("Found terminator %1 at 0x%2").arg(

QString(inst.mnemonic().c_str())).arg(

address, 0, 16);

//If we already had a breakpoint there, then just continue.

if (std::shared_ptr<IBreakpoint> bp = edb::v1::debugger_core->find_breakpoint(address)) {

qDebug() << QString("Already a breakpoint at terminator 0x%1").arg(address, 0, 16);

return edb::DEBUG_CONTINUE;

}

//Otherwise, attempt to set a breakpoint there and continue.

if (std::shared_ptr<IBreakpoint> bp = edb::v1::debugger_core->add_breakpoint(address)) {

own_breakpoints_.emplace_back(address,bp);

qDebug() << QString("Setting breakpoint at terminator 0x%1").arg(address, 0, 16);

bp->set_internal(true);

bp->set_one_time(true); //If the 0xcc get's rm'd on next event, then

//don't set it one time; we'll hande it manually

ret_address_ = address;

return edb::DEBUG_CONTINUE;

}

else {

QMessageBox::critical(edb::v1::debugger_ui,

tr("Error running until return"),

tr("Failed to set breakpoint on a block terminator at address %1.").

arg(address.toPointerString()));

return pass_back_to_debugger();

}

}

}

else {

//Invalid instruction or some other problem. Pass it back to the debugger.

QMessageBox::critical(edb::v1::debugger_ui,

tr("Error running until return"),

tr("Failed to disassemble instruction at address %1.").

arg(address.toPointerString()));

return pass_back_to_debugger();

}

address += inst.byte_size();

}

//If we end up out here, we've got bigger problems. Pass it back to the debugger.

QMessageBox::critical(edb::v1::debugger_ui,

tr("Error running until return"),

tr("Stepped outside the loop, address=%1.").arg(address.toPointerString()));

return pass_back_to_debugger();

}

qDebug() << "The process is no longer running.";

return pass_back_to_debugger();

}

private:

std::vector<std::pair<edb::address_t,std::weak_ptr<IBreakpoint>>> own_breakpoints_;

edb::address_t last_call_return_;

edb::address_t ret_address_;

};

}

//------------------------------------------------------------------------------

// Name: Debugger

// Desc:

//------------------------------------------------------------------------------

Debugger::Debugger(QWidget *parent) : QMainWindow(parent),

tty_proc_(new QProcess(this)),

arguments_dialog_(new DialogArguments),

timer_(new QTimer(this)),

recent_file_manager_(new RecentFileManager(this)),

stack_view_info_(nullptr),

comment_server_(std::make_shared<CommentServer>())

{

setup_ui();

// connect the timer to the debug event

connect(timer_, &QTimer::timeout, this, &Debugger::next_debug_event);

// create a context menu for the tab bar as well

connect(ui.tabWidget, &TabWidget::customContextMenuRequested, this, &Debugger::tab_context_menu);

// CPU Shortcuts

gotoAddressAction_ = createAction(tr("&Goto Expression..."), QKeySequence(tr("Ctrl+G")), &Debugger::goto_triggered);

editCommentAction_ = createAction(tr("Add &Comment..."), QKeySequence(tr(";")), &Debugger::mnuCPUEditComment);

toggleBreakpointAction_ = createAction(tr("&Toggle Breakpoint"), QKeySequence(tr("F2")), &Debugger::mnuCPUToggleBreakpoint);

conditionalBreakpointAction_ = createAction(tr("Add &Conditional Breakpoint"), QKeySequence(tr("Shift+F2")), &Debugger::mnuCPUAddConditionalBreakpoint);

runToThisLineAction_ = createAction(tr("R&un to this Line"), QKeySequence(tr("F4")), &Debugger::mnuCPURunToThisLine);

runToLinePassAction_ = createAction(tr("Run to this Line (Pass Signal To Application)"), QKeySequence(tr("Shift+F4")), &Debugger::mnuCPURunToThisLinePassSignal);

editBytesAction_ = createAction(tr("Binary &Edit..."), QKeySequence(tr("Ctrl+E")), &Debugger::mnuModifyBytes);

fillWithZerosAction_ = createAction(tr("&Fill with 00's"), QKeySequence(), &Debugger::mnuCPUFillZero);

fillWithNOPsAction_ = createAction(tr("Fill with &NOPs"), QKeySequence(), &Debugger::mnuCPUFillNop);

setAddressLabelAction_ = createAction(tr("Set &Label..."), QKeySequence(tr(":")), &Debugger::mnuCPULabelAddress);

followConstantInDumpAction_ = createAction(tr("Follow Constant In &Dump"), QKeySequence(), &Debugger::mnuCPUFollowInDump);

followConstantInStackAction_ = createAction(tr("Follow Constant In &Stack"), QKeySequence(), &Debugger::mnuCPUFollowInStack);

followAction_ = createAction(tr("&Follow"), QKeySequence(tr("Return")), &Debugger::mnuCPUFollow);

// these get updated when we attach/run a new process, so it's OK to hard code them here

#if defined(EDB_X86_64)

setRIPAction_ = createAction(tr("&Set %1 to this Instruction").arg("RIP"), QKeySequence(tr("Ctrl+*")), &Debugger::mnuCPUSetEIP);

gotoRIPAction_ = createAction(tr("&Goto %1").arg("RIP"), QKeySequence(tr("*")), &Debugger::mnuCPUJumpToEIP);

#elif defined(EDB_X86)

setRIPAction_ = createAction(tr("&Set %1 to this Instruction").arg("EIP"), QKeySequence(tr("Ctrl+*")), &Debugger::mnuCPUSetEIP);

gotoRIPAction_ = createAction(tr("&Goto %1").arg("EIP"), QKeySequence(tr("*")), &Debugger::mnuCPUJumpToEIP);

#elif defined(EDB_ARM32) || defined(EDB_ARM64)

setRIPAction_ = createAction(tr("&Set %1 to this Instruction").arg("PC"), QKeySequence(tr("Ctrl+*")), &Debugger::mnuCPUSetEIP);

gotoRIPAction_ = createAction(tr("&Goto %1").arg("PC"), QKeySequence(tr("*")), &Debugger::mnuCPUJumpToEIP);

#else

#error "This doesn't initialize actions and will lead to crash"

#endif

// Data Dump Shorcuts

dumpFollowInCPUAction_ = createAction(tr("Follow Address In &CPU"), QKeySequence(), &Debugger::mnuDumpFollowInCPU);

dumpFollowInDumpAction_ = createAction(tr("Follow Address In &Dump"), QKeySequence(), &Debugger::mnuDumpFollowInDump);

dumpFollowInStackAction_ = createAction(tr("Follow Address In &Stack"), QKeySequence(), &Debugger::mnuDumpFollowInStack);

dumpSaveToFileAction_ = createAction(tr("&Save To File"), QKeySequence(), &Debugger::mnuDumpSaveToFile);

// Register View Shortcuts

registerFollowInDumpAction_ = createAction(tr("&Follow In Dump"), QKeySequence(), &Debugger::mnuRegisterFollowInDump);

registerFollowInDumpTabAction_ = createAction(tr("&Follow In Dump (New Tab)"), QKeySequence(), &Debugger::mnuRegisterFollowInDumpNewTab);

registerFollowInStackAction_ = createAction(tr("&Follow In Stack"), QKeySequence(), &Debugger::mnuRegisterFollowInStack);

// Stack View Shortcuts

stackFollowInCPUAction_ = createAction(tr("Follow Address In &CPU"), QKeySequence(), &Debugger::mnuStackFollowInCPU);

stackFollowInDumpAction_ = createAction(tr("Follow Address In &Dump"), QKeySequence(), &Debugger::mnuStackFollowInDump);

stackFollowInStackAction_ = createAction(tr("Follow Address In &Stack"), QKeySequence(), &Debugger::mnuStackFollowInStack);

// these get updated when we attach/run a new process, so it's OK to hard code them here

#if defined(EDB_X86_64)

stackGotoRSPAction_ = createAction(tr("Goto %1").arg("RSP"), QKeySequence(), &Debugger::mnuStackGotoESP);

stackGotoRBPAction_ = createAction(tr("Goto %1").arg("RBP"), QKeySequence(), &Debugger::mnuStackGotoEBP);

stackPushAction_ = createAction(tr("&Push %1").arg("QWORD"), QKeySequence(), &Debugger::mnuStackPush);

stackPopAction_ = createAction(tr("P&op %1").arg("QWORD"), QKeySequence(), &Debugger::mnuStackPop);

#elif defined(EDB_X86)

stackGotoRSPAction_ = createAction(tr("Goto %1").arg("ESP"), QKeySequence(), &Debugger::mnuStackGotoESP);

stackGotoRBPAction_ = createAction(tr("Goto %1").arg("EBP"), QKeySequence(), &Debugger::mnuStackGotoEBP);

stackPushAction_ = createAction(tr("&Push %1").arg("DWORD"), QKeySequence(), &Debugger::mnuStackPush);

stackPopAction_ = createAction(tr("P&op %1").arg("DWORD"), QKeySequence(), &Debugger::mnuStackPop);

#elif defined(EDB_ARM32)

stackGotoRSPAction_ = createAction(tr("Goto %1").arg("SP"), QKeySequence(), &Debugger::mnuStackGotoESP);

stackGotoRBPAction_ = createAction(tr("Goto %1").arg("FP"), QKeySequence(), &Debugger::mnuStackGotoEBP);

stackGotoRBPAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

stackPushAction_ = createAction(tr("&Push %1").arg("DWORD"), QKeySequence(), &Debugger::mnuStackPush);

stackPushAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

stackPopAction_ = createAction(tr("P&op %1").arg("DWORD"), QKeySequence(), &Debugger::mnuStackPop);

stackPopAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

#elif defined(EDB_ARM64)

stackGotoRSPAction_ = createAction(tr("Goto %1").arg("SP"), QKeySequence(), &Debugger::mnuStackGotoESP);

stackGotoRSPAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

stackGotoRBPAction_ = createAction(tr("Goto %1").arg("FP"), QKeySequence(), &Debugger::mnuStackGotoEBP);

stackGotoRBPAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

stackPushAction_ = createAction(tr("&Push %1").arg("QWORD"), QKeySequence(), &Debugger::mnuStackPush);

stackPushAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

stackPopAction_ = createAction(tr("P&op %1").arg("QWORD"), QKeySequence(), &Debugger::mnuStackPop);

stackPopAction_->setDisabled(true); // FIXME(ARM): this just stubs it out since it likely won't really work

#else

#error "This doesn't initialize actions and will lead to crash"

#endif

// set these to have no meaningful "data" (yet)

followConstantInDumpAction_->setData(qlonglong(0));

followConstantInStackAction_->setData(qlonglong(0));

setAcceptDrops(true);

// setup the list model for instruction details list

list_model_ = new QStringListModel(this);

ui.listView->setModel(list_model_);

// setup the recent file manager

ui.action_Recent_Files->setMenu(recent_file_manager_->create_menu());

connect(recent_file_manager_, &RecentFileManager::file_selected, this, &Debugger::open_file);

// make us the default event handler

edb::v1::add_debug_event_handler(this);

// enable the arch processor

#if 0

ui.registerList->setModel(&edb::v1::arch_processor().get_register_view_model());

edb::v1::arch_processor().setup_register_view();

#endif

// default the working directory to ours

working_directory_ = QDir().absolutePath();

// let the plugins setup their menus

finish_plugin_setup();

// Make sure number formatting and reading code behaves predictably when using standard C++ facilities.

// NOTE: this should only be done after the plugins have finished loading, since some dynamic libraries

// (e.g. libkdecore), which are indirectly loaded by the plugins, re-set locale to "" once again. (This

// first time is QApplication.)

std::setlocale(LC_NUMERIC, "C");

}

//------------------------------------------------------------------------------

// Name: ~Debugger

// Desc:

//------------------------------------------------------------------------------

Debugger::~Debugger() {

for(QObject *plugin: edb::v1::plugin_list()) {

if(auto p = qobject_cast<IPlugin *>(plugin)) {

p->fini();

}

}

// kill our xterm and wait for it to die

tty_proc_->kill();

tty_proc_->waitForFinished(3000);

edb::v1::remove_debug_event_handler(this);

}

QAction *Debugger::createAction(const QString &text, const QKeySequence &keySequence, void(Debugger::*slotPtr)()) {

auto action = new QAction(text, this);

action->setShortcut(keySequence);

addAction(action);

connect(action, &QAction::triggered, this, slotPtr);

return action;

}

//------------------------------------------------------------------------------

// Name: update_menu_state

// Desc:

//------------------------------------------------------------------------------

void Debugger::update_menu_state(GUI_STATE state) {

static const QString Paused = tr("paused");

static const QString Running = tr("running");

static const QString Terminated = tr("terminated");

switch(state) {

case PAUSED:

ui.actionRun_Until_Return->setEnabled(true);

ui.action_Restart->setEnabled(true);

ui.action_Run->setEnabled(true);

ui.action_Pause->setEnabled(false);

ui.action_Step_Into->setEnabled(true);

ui.action_Step_Over->setEnabled(true);

ui.actionStep_Out->setEnabled(true);

ui.action_Step_Into_Pass_Signal_To_Application->setEnabled(true);

ui.action_Step_Over_Pass_Signal_To_Application->setEnabled(true);

ui.action_Run_Pass_Signal_To_Application->setEnabled(true);

ui.action_Detach->setEnabled(true);

ui.action_Kill->setEnabled(true);

add_tab_->setEnabled(true);

status_->setText(Paused);

status_->repaint();

break;

case RUNNING:

ui.actionRun_Until_Return->setEnabled(false);

ui.action_Restart->setEnabled(false);

ui.action_Run->setEnabled(false);

ui.action_Pause->setEnabled(true);

ui.action_Step_Into->setEnabled(false);

ui.action_Step_Over->setEnabled(false);

ui.actionStep_Out->setEnabled(false);

ui.action_Step_Into_Pass_Signal_To_Application->setEnabled(false);

ui.action_Step_Over_Pass_Signal_To_Application->setEnabled(false);

ui.action_Run_Pass_Signal_To_Application->setEnabled(false);

ui.action_Detach->setEnabled(true);

ui.action_Kill->setEnabled(true);

add_tab_->setEnabled(true);

status_->setText(Running);

status_->repaint();

break;

case TERMINATED:

ui.actionRun_Until_Return->setEnabled(false);

ui.action_Restart->setEnabled(recent_file_manager_->entry_count()>0);

ui.action_Run->setEnabled(false);

ui.action_Pause->setEnabled(false);

ui.action_Step_Into->setEnabled(false);

ui.action_Step_Over->setEnabled(false);

ui.actionStep_Out->setEnabled(false);

ui.action_Step_Into_Pass_Signal_To_Application->setEnabled(false);

ui.action_Step_Over_Pass_Signal_To_Application->setEnabled(false);

ui.action_Run_Pass_Signal_To_Application->setEnabled(false);

ui.action_Detach->setEnabled(false);

ui.action_Kill->setEnabled(false);

add_tab_->setEnabled(false);

status_->setText(Terminated);

status_->repaint();

break;

}

gui_state_ = state;

}

//------------------------------------------------------------------------------

// Name: create_tty

// Desc: creates a TTY object for our command line I/O

//------------------------------------------------------------------------------

QString Debugger::create_tty() {

QString result_tty = tty_file_;

#if defined(Q_OS_LINUX) || defined(Q_OS_OPENBSD) || defined(Q_OS_FREEBSD)

// we attempt to reuse an open output window

if(edb::v1::config().tty_enabled && tty_proc_->state() != QProcess::Running) {

const QString command = edb::v1::config().tty_command;

if(!command.isEmpty()) {

// ok, creating a new one...

// first try to get a 'unique' filename, i would love to use a system

// temp file API... but there doesn't seem to be one which will create

// a pipe...only ordinary files!

const QString temp_pipe = QString("%1/edb_temp_file_%2_%3").arg(QDir::tempPath()).arg(qrand()).arg(getpid());

// make sure it isn't already there, and then make the pipe

::unlink(qPrintable(temp_pipe));

::mkfifo(qPrintable(temp_pipe), S_IRUSR | S_IWUSR);

// this is a basic shell script which will output the tty to a file (the pipe),

// ignore kill sigs, close all standard IO, and then just hang

const QString shell_script = QString(

"tty > %1;"

"trap \"\" INT QUIT TSTP;"

"exec<&-; exec>&-;"

"while :; do sleep 3600; done"

).arg(temp_pipe);

// parse up the command from the options, white space delimited

QStringList proc_args = edb::v1::parse_command_line(command);

const QString tty_command = proc_args.takeFirst().trimmed();

// start constructing the arguments for the term

const QFileInfo command_info(tty_command);

if(command_info.fileName() == "gnome-terminal") {

proc_args << "--hide-menubar" << "--title" << tr("edb output");

} else if(command_info.fileName() == "konsole") {

proc_args << "--hide-menubar" << "--title" << tr("edb output") << "--nofork" << "-hold";

} else {

proc_args << "-title" << tr("edb output") << "-hold";

}

proc_args << "-e" << "sh" << "-c" << QString("%1").arg(shell_script);

qDebug() << "Running Terminal: " << tty_command;

qDebug() << "Terminal Args: " << proc_args;

// make the tty process object and connect it's death signal to our cleanup

connect(tty_proc_, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(tty_proc_finished(int, QProcess::ExitStatus)));

tty_proc_->start(tty_command, proc_args);

if(tty_proc_->waitForStarted(3000)) {

// try to read from the pipe, but with a 2 second timeout

int fd = open(qPrintable(temp_pipe), O_RDWR);

if(fd != -1) {

fd_set set;

FD_ZERO(&set); // clear the set

FD_SET(fd, &set); // add our file descriptor to the set

struct timeval timeout;

timeout.tv_sec = 2;

timeout.tv_usec = 0;

char buf[256] = {};

const int rv = select(fd + 1, &set, nullptr, nullptr, &timeout);

switch(rv) {

case -1:

qDebug() << "An error occured while attempting to get the TTY of the terminal sub-process";

break;

case 0:

qDebug() << "A Timeout occured while attempting to get the TTY of the terminal sub-process";

break;

default:

if(read(fd, buf, sizeof(buf)) != -1) {

result_tty = QString(buf).trimmed();

}

break;

}

::close(fd);

}

} else {

qDebug().nospace() << "Could not launch the desired terminal [" << tty_command << "], please check that it exists and you have proper permissions.";

}

// cleanup, god i wish there was an easier way than this!

::unlink(qPrintable(temp_pipe));

}

}

#endif

qDebug() << "Terminal process has TTY: " << result_tty;

return result_tty;

}

//------------------------------------------------------------------------------

// Name: tty_proc_finished

// Desc: cleans up the data associated with a TTY when the terminal dies

//------------------------------------------------------------------------------

void Debugger::tty_proc_finished(int exit_code, QProcess::ExitStatus exit_status) {

Q_UNUSED(exit_code)

Q_UNUSED(exit_status)

tty_file_.clear();

}

//------------------------------------------------------------------------------

// Name: current_tab

// Desc:

//------------------------------------------------------------------------------

int Debugger::current_tab() const {

return ui.tabWidget->currentIndex();

}

//------------------------------------------------------------------------------

// Name: current_data_view_info

// Desc:

//------------------------------------------------------------------------------

std::shared_ptr<DataViewInfo> Debugger::current_data_view_info() const {

return data_regions_[current_tab()];

}

//------------------------------------------------------------------------------

// Name: set_debugger_caption

// Desc: sets the caption part to also show the application name and pid

//------------------------------------------------------------------------------

void Debugger::set_debugger_caption(const QString &appname) {

setWindowTitle(tr("edb - %1 [%2]").arg(appname).arg(edb::v1::debugger_core->process()->pid()));

}

//------------------------------------------------------------------------------

// Name: delete_data_tab

// Desc:

//------------------------------------------------------------------------------

void Debugger::delete_data_tab() {

const int current = current_tab();

// get a pointer to the info we need (before removing it from the list!)

// this seems redundant to current_data_view_info(), but we need the

// index too, so may as well waste one line to avoid duplicate work

std::shared_ptr<DataViewInfo> info = data_regions_[current];

// remove it from the list

data_regions_.remove(current);

// remove the tab associated with it

ui.tabWidget->removeTab(current);

}

//------------------------------------------------------------------------------

// Name: create_data_tab

// Desc:

//------------------------------------------------------------------------------

void Debugger::create_data_tab() {

const int current = current_tab();

// duplicate the current region

auto new_data_view = std::make_shared<DataViewInfo>((current != -1) ? data_regions_[current]->region : nullptr);

auto hexview = std::make_shared<QHexView>();

new_data_view->view = hexview;

// setup the context menu

hexview->setContextMenuPolicy(Qt::CustomContextMenu);

connect(hexview.get(), &QHexView::customContextMenuRequested, this, &Debugger::mnuDumpContextMenu);

// show the initial data for this new view

if(new_data_view->region) {

hexview->setAddressOffset(new_data_view->region->start());

} else {

hexview->setAddressOffset(0);

}

// NOTE(eteran): for issue #522, allow comments in data view when single word width

hexview->setCommentServer(comment_server_.get());

hexview->setData(new_data_view->stream.get());

const Configuration &config = edb::v1::config();

// set the default view options

hexview->setShowAddress(config.data_show_address);

hexview->setShowHexDump(config.data_show_hex);

hexview->setShowAsciiDump(config.data_show_ascii);

hexview->setShowComments(config.data_show_comments);

hexview->setRowWidth(config.data_row_width);

hexview->setWordWidth(config.data_word_width);

hexview->setShowAddressSeparator(config.show_address_separator);

// Setup data views according to debuggee bitness

if(edb::v1::debuggeeIs64Bit()) {

hexview->setAddressSize(QHexView::Address64);

} else {

hexview->setAddressSize(QHexView::Address32);

}

// set the default font

QFont dump_font;

dump_font.fromString(config.data_font);

hexview->setFont(dump_font);

data_regions_.push_back(new_data_view);

// create the tab!

if(new_data_view->region) {

ui.tabWidget->addTab(hexview.get(), tr("%1-%2").arg(

edb::v1::format_pointer(new_data_view->region->start()),

edb::v1::format_pointer(new_data_view->region->end())));

} else {

ui.tabWidget->addTab(hexview.get(), tr("%1-%2").arg(

edb::v1::format_pointer(edb::address_t(0)),

edb::v1::format_pointer(edb::address_t(0))));

}

ui.tabWidget->setCurrentIndex(ui.tabWidget->count() - 1);

}

//------------------------------------------------------------------------------

// Name: finish_plugin_setup

// Desc: finalizes plugin setup by adding each to the menu, we can do this now

// that we have a GUI widget to attach it to

//------------------------------------------------------------------------------

void Debugger::finish_plugin_setup() {

// call the init function for each plugin, this is done after

// ALL plugins are loaded in case there are inter-plugin dependencies

for(QObject *plugin: edb::v1::plugin_list()) {

if(auto p = qobject_cast<IPlugin *>(plugin)) {

p->init();

}

}

// setup the menu for all plugins that which to do so

QPointer<DialogOptions> options = qobject_cast<DialogOptions *>(edb::v1::dialog_options());

for(QObject *plugin: edb::v1::plugin_list()) {

if(auto p = qobject_cast<IPlugin *>(plugin)) {

if(QMenu *const menu = p->menu(this)) {

ui.menu_Plugins->addMenu(menu);

}

if(QWidget *const options_page = p->options_page()) {

if(options) {

options->addOptionsPage(options_page);

}

}

// setup the shortcuts for these actions

const QList<QAction *> register_actions = p->register_context_menu();

const QList<QAction *> cpu_actions = p->cpu_context_menu();

const QList<QAction *> stack_actions = p->stack_context_menu();

const QList<QAction *> data_actions = p->data_context_menu();

const QList<QAction *> actions = register_actions + cpu_actions + stack_actions + data_actions;

for(QAction *action : actions) {

QKeySequence shortcut = action->shortcut();

if(!shortcut.isEmpty()) {

connect(new QShortcut(shortcut, this), &QShortcut::activated, action, &QAction::trigger);

}

}

}

}

}

//------------------------------------------------------------------------------

// Name: get_goto_expression

// Desc:

//------------------------------------------------------------------------------

Result<edb::address_t, QString> Debugger::get_goto_expression() {

boost::optional<edb::address_t> address = edb::v2::get_expression_from_user(tr("Goto Expression"), tr("Expression:"));

if(address) {

return *address;

} else {

return make_unexpected(tr("No Address"));

}

}

//------------------------------------------------------------------------------

// Name: get_follow_register

// Desc:

//------------------------------------------------------------------------------

Result<edb::reg_t, QString> Debugger::get_follow_register() const {

const Register reg = active_register();

if(!reg || reg.bitSize() > 8 * sizeof(edb::address_t)) {

return make_unexpected(tr("No Value"));

}

return reg.valueAsAddress();

}

//------------------------------------------------------------------------------

// Name: goto_triggered

// Desc:

//------------------------------------------------------------------------------

void Debugger::goto_triggered() {

QWidget *const widget = QApplication::focusWidget();

if(auto hexview = qobject_cast<QHexView*>(widget)) {

if(hexview == stack_view_.get()) {

mnuStackGotoAddress();

} else {

mnuDumpGotoAddress();

}

} else if(qobject_cast<QDisassemblyView*>(widget)) {

mnuCPUJumpToAddress();

}

}

//------------------------------------------------------------------------------

// Name: setup_ui

// Desc: creates the UI

//------------------------------------------------------------------------------

void Debugger::setup_ui() {

// setup the global pointers as early as possible.

// NOTE: this should never be changed after this point

// NOTE: this is important that this happens BEFORE any components which

// read settings as it could end up being a memory leak (and therefore never

// calling it's destructor which writes the settings to disk!).

edb::v1::debugger_ui = this;

ui.setupUi(this);

status_ = new QLabel(this);

ui.statusbar->insertPermanentWidget(0, status_);

// add toggles for the dock windows

ui.menu_View->addAction(ui.dataDock ->toggleViewAction());

ui.menu_View->addAction(ui.stackDock ->toggleViewAction());

ui.menu_View->addAction(ui.toolBar ->toggleViewAction());

ui.action_Restart->setEnabled(recent_file_manager_->entry_count()>0);

// make sure our widgets use custom context menus

ui.cpuView ->setContextMenuPolicy(Qt::CustomContextMenu);

// set the listbox to about 4 lines

const QFontMetrics &fm = ui.listView->fontMetrics();

ui.listView->setFixedHeight(fm.height() * 4);

setup_stack_view();

setup_tab_buttons();

// remove the one in the designer and put in our built one.

// it's a bit ugly to do it this way, but the designer wont let me

// make a tabless entry..and the ones i create look slightly diff

// (probably lack of layout manager in mine...

ui.tabWidget->clear();

mnuDumpCreateTab();

// apply any fonts we may have stored

apply_default_fonts();

// apply the default setting for showing address separators

apply_default_show_separator();

}

//------------------------------------------------------------------------------

// Name: setup_stack_view

// Desc:

//------------------------------------------------------------------------------

void Debugger::setup_stack_view() {

stack_view_ = std::make_shared<QHexView>();

stack_view_->setUserConfigRowWidth(false);

stack_view_->setUserConfigWordWidth(false);

ui.stackDock->setWidget(stack_view_.get());

// setup the context menu

stack_view_->setContextMenuPolicy(Qt::CustomContextMenu);

connect(stack_view_.get(), &QHexView::customContextMenuRequested, this, &Debugger::mnuStackContextMenu);

// we placed a view in the designer, so just set it here

// this may get transitioned to heap allocated, we'll see

stack_view_info_.view = stack_view_;

// setup the comment server for the stack viewer

stack_view_->setCommentServer(comment_server_.get());

}

//------------------------------------------------------------------------------

// Name: closeEvent

// Desc: triggered on main window close, saves window state

//------------------------------------------------------------------------------

void Debugger::closeEvent(QCloseEvent *event) {

// make sure sessions still get recorded even if they just close us

const QString filename = session_filename();

if(!filename.isEmpty()) {

SessionManager::instance().save_session(filename);

}

if(IDebugger *core = edb::v1::debugger_core) {

core->end_debug_session();