x64dbg/x64dbg
x64dbg
/
x64dbg
1
0
Fork 0
Code Releases 5 Activity

DBG: remove CMDRESULT since it's become useless

This commit is contained in:
mrexodia 2016-10-13 17:14:17 +02:00
parent 37ff27c0b4
commit 94561bb255
No known key found for this signature in database
GPG Key ID: FC89E0AAA0C1AAD8
44 changed files with 1362 additions and 1363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/dbg/command.cpp
View File

@ -207,7 +207,7 @@ bool cbCommandProvider(char* cmd, int maxlen);
/**
\brief Initiates the command loop. This function will not return until a command returns ::STATUS_EXIT.
\return A CMDRESULT, will always be ::STATUS_EXIT.
\return A bool, will always be ::STATUS_EXIT.
*/
void cmdloop()
{
@ -266,13 +266,13 @@ void cmdloop()
\brief Directly execute a command.
\param [in,out] cmd_list Command list.
\param cmd The command to execute.
\return A CMDRESULT.
\return A bool.
*/
CMDRESULT cmddirectexec(const char* cmd)
bool cmddirectexec(const char* cmd)
{
// Don't allow anyone to send in empty strings
if(!cmd)
return STATUS_ERROR;
return false;
StringList commands;
StringUtils::Split(cmd, ';');
@ -285,12 +285,12 @@ CMDRESULT cmddirectexec(const char* cmd)
ExpressionParser parser(command);
duint result;
if(!parser.Calculate(result, valuesignedcalc(), true, false))
return STATUS_ERROR;
return false;
varset("$ans", result, true);
continue;
}
if(found->debugonly && !DbgIsDebugging())
return STATUS_ERROR;
return false;
Command cmdParsed(command);
int argcount = cmdParsed.GetArgCount();
char** argv = (char**)emalloc((argcount + 1) * sizeof(char*), "cmddirectexec:argv");
@ -301,12 +301,12 @@ CMDRESULT cmddirectexec(const char* cmd)
*argv[i + 1] = 0;
strcpy_s(argv[i + 1], deflen, cmdParsed.GetArg(i).c_str());
}
CMDRESULT res = found->cbCommand(argcount + 1, argv);
auto res = found->cbCommand(argcount + 1, argv);
for(int i = 0; i < argcount; i++)
efree(argv[i + 1], "cmddirectexec:argv[i+1]");
efree(argv, "cmddirectexec:argv");
if(res != STATUS_CONTINUE)
return res;
if(!res)
return false;
}
return STATUS_CONTINUE;
return true;
}

12
src/dbg/command.h
View File

@ -10,15 +10,7 @@ bool IsArgumentsLessThan(int argc, int minimumCount);
struct COMMAND;
enum CMDRESULT
{
STATUS_ERROR = false,
STATUS_CONTINUE = true,
STATUS_EXIT = 2,
STATUS_PAUSE = 3
};
typedef CMDRESULT(*CBCOMMAND)(int, char**);
typedef bool(*CBCOMMAND)(int, char**);
typedef bool (*CBCOMMANDPROVIDER)(char*, int);
typedef COMMAND* (*CBCOMMANDFINDER)(char*);
@ -39,6 +31,6 @@ COMMAND* cmdget(const char* cmd);
CBCOMMAND cmdset(const char* name, CBCOMMAND cbCommand, bool debugonly);
bool cmddel(const char* name);
void cmdloop();
CMDRESULT cmddirectexec(const char* cmd);
bool cmddirectexec(const char* cmd);
#endif // _COMMAND_H

6
src/dbg/commandline.cpp
View File

@ -133,20 +133,20 @@ void copyCommandLine(const char* cmdLine)
strcpy_s(commandLine, cmdLine);
}
CMDRESULT SetCommandLine()
bool SetCommandLine()
{
cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 };
if(!dbgsetcmdline(commandLine, &cmdline_error))
{
showcommandlineerror(&cmdline_error);
return STATUS_ERROR;
return false;
}
//update the memory map
MemUpdateMap();
GuiUpdateMemoryView();
return STATUS_CONTINUE;
return true;
}

2
src/dbg/commandline.h
View File

@ -11,6 +11,6 @@ char* getCommandLineArgs();
void CmdLineCacheSave(JSON Root);
void CmdLineCacheLoad(JSON Root);
void copyCommandLine(const char* cmdLine);
CMDRESULT setCommandLine();
bool setCommandLine();
#endif // _COMMANDLINE_H

106
src/dbg/commands/cmd-analysis.cpp
View File

@ -15,7 +15,7 @@
#include "exception.h"
#include "TraceRecord.h"
CMDRESULT cbInstrAnalyse(int argc, char* argv[])
bool cbInstrAnalyse(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -25,10 +25,10 @@ CMDRESULT cbInstrAnalyse(int argc, char* argv[])
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrExanalyse(int argc, char* argv[])
bool cbInstrExanalyse(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -38,10 +38,10 @@ CMDRESULT cbInstrExanalyse(int argc, char* argv[])
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCfanalyse(int argc, char* argv[])
bool cbInstrCfanalyse(int argc, char* argv[])
{
bool exceptionDirectory = false;
if(argc > 1)
@ -54,10 +54,10 @@ CMDRESULT cbInstrCfanalyse(int argc, char* argv[])
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAnalyseNukem(int argc, char* argv[])
bool cbInstrAnalyseNukem(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -65,10 +65,10 @@ CMDRESULT cbInstrAnalyseNukem(int argc, char* argv[])
duint base = MemFindBaseAddr(sel.start, &size);
Analyse_nukem(base, size);
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAnalxrefs(int argc, char* argv[])
bool cbInstrAnalxrefs(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -78,27 +78,27 @@ CMDRESULT cbInstrAnalxrefs(int argc, char* argv[])
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAnalrecur(int argc, char* argv[])
bool cbInstrAnalrecur(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint entry;
if(!valfromstring(argv[1], &entry, false))
return STATUS_ERROR;
return false;
duint size;
auto base = MemFindBaseAddr(entry, &size);
if(!base)
return STATUS_ERROR;
return false;
RecursiveAnalysis analysis(base, size, entry, 0);
analysis.Analyse();
analysis.SetMarkers();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAnalyseadv(int argc, char* argv[])
bool cbInstrAnalyseadv(int argc, char* argv[])
{
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -108,23 +108,23 @@ CMDRESULT cbInstrAnalyseadv(int argc, char* argv[])
anal.Analyse();
anal.SetMarkers();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrVirtualmod(int argc, char* argv[])
bool cbInstrVirtualmod(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint base;
if(!valfromstring(argv[2], &base))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [base]!"));
return STATUS_ERROR;
return false;
}
if(!MemIsValidReadPtr(base))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid memory address!"));
return STATUS_ERROR;
return false;
}
duint size;
if(argc < 4)
@ -132,13 +132,13 @@ CMDRESULT cbInstrVirtualmod(int argc, char* argv[])
else if(!valfromstring(argv[3], &size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid parameter [size]"));
return STATUS_ERROR;
return false;
}
auto name = String("virtual:\\") + (argv[1]);
if(!ModLoad(base, size, name.c_str()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to load module (ModLoad)..."));
return STATUS_ERROR;
return false;
}
char modname[256] = "";
@ -147,10 +147,10 @@ CMDRESULT cbInstrVirtualmod(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "Virtual module \"%s\" loaded on %p[%p]!\n"), argv[1], base, size);
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[])
bool cbDebugDownloadSymbol(int argc, char* argv[])
{
dputs(QT_TRANSLATE_NOOP("DBG", "This may take very long, depending on your network connection and data in the debug directory..."));
Memory<char*> szDefaultStore(MAX_SETTING_SIZE + 1);
@ -165,26 +165,26 @@ CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[])
SymDownloadAllSymbols(szSymbolStore); //download symbols for all modules
GuiSymbolRefreshCurrent();
dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information"));
return STATUS_CONTINUE;
return true;
}
//get some module information
duint modbase = ModBaseFromName(argv[1]);
if(!modbase)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid module \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
wchar_t wszModulePath[MAX_PATH] = L"";
if(!GetModuleFileNameExW(fdProcessInfo->hProcess, (HMODULE)modbase, wszModulePath, MAX_PATH))
{
dputs(QT_TRANSLATE_NOOP("DBG", "GetModuleFileNameExA failed!"));
return STATUS_ERROR;
return false;
}
wchar_t szOldSearchPath[MAX_PATH] = L"";
if(!SafeSymGetSearchPathW(fdProcessInfo->hProcess, szOldSearchPath, MAX_PATH)) //backup current search path
{
dputs(QT_TRANSLATE_NOOP("DBG", "SymGetSearchPath failed!"));
return STATUS_ERROR;
return false;
}
char szServerSearchPath[MAX_PATH * 2] = "";
if(argc > 2)
@ -193,13 +193,13 @@ CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[])
if(!SafeSymSetSearchPathW(fdProcessInfo->hProcess, StringUtils::Utf8ToUtf16(szServerSearchPath).c_str())) //set new search path
{
dputs(QT_TRANSLATE_NOOP("DBG", "SymSetSearchPath (1) failed!"));
return STATUS_ERROR;
return false;
}
if(!SafeSymUnloadModule64(fdProcessInfo->hProcess, (DWORD64)modbase)) //unload module
{
SafeSymSetSearchPathW(fdProcessInfo->hProcess, szOldSearchPath);
dputs(QT_TRANSLATE_NOOP("DBG", "SymUnloadModule64 failed!"));
return STATUS_ERROR;
return false;
}
auto symOptions = SafeSymGetOptions();
SafeSymSetOptions(symOptions & ~SYMOPT_IGNORE_CVREC);
@ -208,20 +208,20 @@ CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "SymLoadModuleEx failed!"));
SafeSymSetOptions(symOptions);
SafeSymSetSearchPathW(fdProcessInfo->hProcess, szOldSearchPath);
return STATUS_ERROR;
return false;
}
SafeSymSetOptions(symOptions);
if(!SafeSymSetSearchPathW(fdProcessInfo->hProcess, szOldSearchPath))
{
dputs(QT_TRANSLATE_NOOP("DBG", "SymSetSearchPathW (2) failed!"));
return STATUS_ERROR;
return false;
}
GuiSymbolRefreshCurrent();
dputs(QT_TRANSLATE_NOOP("DBG", "Done! See symbol log for more information"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrImageinfo(int argc, char* argv[])
bool cbInstrImageinfo(int argc, char* argv[])
{
duint mod;
SHARED_ACQUIRE(LockModules);
@ -234,20 +234,20 @@ CMDRESULT cbInstrImageinfo(int argc, char* argv[])
if(!valfromstring(argv[1], &address))
{
dputs(QT_TRANSLATE_NOOP("DBG", "invalid argument"));
return STATUS_ERROR;
return false;
}
}
mod = MemFindBaseAddr(address, nullptr);
if(mod == 0)
{
dputs(QT_TRANSLATE_NOOP("DBG", "invalid argument"));
return STATUS_ERROR;
return false;
}
info = ModInfoFromAddr(mod);
if(info == nullptr)
{
dputs(QT_TRANSLATE_NOOP("DBG", "invalid argument"));
return STATUS_ERROR;
return false;
}
auto c = GetPE32DataFromMappedFile(info->fileMapVA, 0, UE_CHARACTERISTICS);
auto dllc = GetPE32DataFromMappedFile(info->fileMapVA, 0, UE_DLLCHARACTERISTICS);
@ -302,21 +302,21 @@ CMDRESULT cbInstrImageinfo(int argc, char* argv[])
dputs_untranslated("---------------");
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrGetRelocSize(int argc, char* argv[])
bool cbInstrGetRelocSize(int argc, char* argv[])
{
//Original tool "GetRelocSize" by Killboy/SND
if(argc < 2)
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint RelocDirAddr;
if(!valfromstring(argv[1], &RelocDirAddr, false))
return STATUS_ERROR;
return false;
duint RelocSize = 0;
varset("$result", RelocSize, false);
@ -326,7 +326,7 @@ CMDRESULT cbInstrGetRelocSize(int argc, char* argv[])
if(!MemRead(RelocDirAddr, &RelocDir, sizeof(IMAGE_RELOCATION)))
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!"));
return STATUS_ERROR;
return false;
}
if(!RelocDir.SymbolTableIndex)
break;
@ -338,13 +338,13 @@ CMDRESULT cbInstrGetRelocSize(int argc, char* argv[])
if(!RelocSize)
{
_plugin_logputs(QT_TRANSLATE_NOOP("DBG", "Invalid relocation table!"));
return STATUS_ERROR;
return false;
}
varset("$result", RelocSize, false);
_plugin_logprintf(QT_TRANSLATE_NOOP("DBG", "Relocation table size: %X\n"), RelocSize);
return STATUS_CONTINUE;
return true;
}
static void printExhandlers(const char* name, const std::vector<duint> & entries)
@ -362,7 +362,7 @@ static void printExhandlers(const char* name, const std::vector<duint> & entries
}
}
CMDRESULT cbInstrExhandlers(int argc, char* argv[])
bool cbInstrExhandlers(int argc, char* argv[])
{
std::vector<duint> entries;
#ifndef _WIN64
@ -395,10 +395,10 @@ CMDRESULT cbInstrExhandlers(int argc, char* argv[])
printExhandlers("UnhandledExceptionFilter", entries);
else
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to get UnhandledExceptionFilter (loaded symbols for kernelbase.dll?)"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrExinfo(int argc, char* argv[])
bool cbInstrExinfo(int argc, char* argv[])
{
auto info = getLastExceptionInfo();
const auto & record = info.ExceptionRecord;
@ -427,16 +427,16 @@ CMDRESULT cbInstrExinfo(int argc, char* argv[])
else
dprintf("ExceptionInformation[%02u]: %p\n", i, record.ExceptionInformation[i]);
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrTraceexecute(int argc, char* argv[])
bool cbInstrTraceexecute(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
_dbg_dbgtraceexecute(addr);
return STATUS_CONTINUE;
return true;
}

28
src/dbg/commands/cmd-analysis.h
View File

@ -2,18 +2,18 @@
#include "command.h"
CMDRESULT cbInstrAnalyse(int argc, char* argv[]);
CMDRESULT cbInstrExanalyse(int argc, char* argv[]);
CMDRESULT cbInstrCfanalyse(int argc, char* argv[]);
CMDRESULT cbInstrAnalyseNukem(int argc, char* argv[]);
CMDRESULT cbInstrAnalxrefs(int argc, char* argv[]);
CMDRESULT cbInstrAnalrecur(int argc, char* argv[]);
CMDRESULT cbInstrAnalyseadv(int argc, char* argv[]);
bool cbInstrAnalyse(int argc, char* argv[]);
bool cbInstrExanalyse(int argc, char* argv[]);
bool cbInstrCfanalyse(int argc, char* argv[]);
bool cbInstrAnalyseNukem(int argc, char* argv[]);
bool cbInstrAnalxrefs(int argc, char* argv[]);
bool cbInstrAnalrecur(int argc, char* argv[]);
bool cbInstrAnalyseadv(int argc, char* argv[]);
CMDRESULT cbInstrVirtualmod(int argc, char* argv[]);
CMDRESULT cbDebugDownloadSymbol(int argc, char* argv[]);
CMDRESULT cbInstrImageinfo(int argc, char* argv[]);
CMDRESULT cbInstrGetRelocSize(int argc, char* argv[]);
CMDRESULT cbInstrExhandlers(int argc, char* argv[]);
CMDRESULT cbInstrExinfo(int argc, char* argv[]);
CMDRESULT cbInstrTraceexecute(int argc, char* argv[]);
bool cbInstrVirtualmod(int argc, char* argv[]);
bool cbDebugDownloadSymbol(int argc, char* argv[]);
bool cbInstrImageinfo(int argc, char* argv[]);
bool cbInstrGetRelocSize(int argc, char* argv[]);
bool cbInstrExhandlers(int argc, char* argv[]);
bool cbInstrExinfo(int argc, char* argv[]);
bool cbInstrTraceexecute(int argc, char* argv[]);

414
src/dbg/commands/cmd-breakpoint-control.cpp
View File

File diff suppressed because it is too large Load Diff

46
src/dbg/commands/cmd-breakpoint-control.h
View File

@ -2,26 +2,26 @@
#include "command.h"
CMDRESULT cbDebugSetBPX(int argc, char* argv[]);
CMDRESULT cbDebugDeleteBPX(int argc, char* argv[]);
CMDRESULT cbDebugEnableBPX(int argc, char* argv[]);
CMDRESULT cbDebugDisableBPX(int argc, char* argv[]);
CMDRESULT cbDebugSetHardwareBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugDeleteHardwareBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugEnableHardwareBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugDisableHardwareBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugSetMemoryBpx(int argc, char* argv[]);
CMDRESULT cbDebugDeleteMemoryBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugEnableMemoryBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugDisableMemoryBreakpoint(int argc, char* argv[]);
CMDRESULT cbDebugBpDll(int argc, char* argv[]);
CMDRESULT cbDebugBcDll(int argc, char* argv[]);
CMDRESULT cbDebugBpDllEnable(int argc, char* argv[]);
CMDRESULT cbDebugBpDllDisable(int argc, char* argv[]);
CMDRESULT cbDebugSetExceptionBPX(int argc, char* argv[]);
CMDRESULT cbDebugDeleteExceptionBPX(int argc, char* argv[]);
CMDRESULT cbDebugEnableExceptionBPX(int argc, char* argv[]);
CMDRESULT cbDebugDisableExceptionBPX(int argc, char* argv[]);
CMDRESULT cbDebugSetBPGoto(int argc, char* argv[]);
CMDRESULT cbDebugBplist(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXOptions(int argc, char* argv[]);
bool cbDebugSetBPX(int argc, char* argv[]);
bool cbDebugDeleteBPX(int argc, char* argv[]);
bool cbDebugEnableBPX(int argc, char* argv[]);
bool cbDebugDisableBPX(int argc, char* argv[]);
bool cbDebugSetHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugDeleteHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugEnableHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugDisableHardwareBreakpoint(int argc, char* argv[]);
bool cbDebugSetMemoryBpx(int argc, char* argv[]);
bool cbDebugDeleteMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugEnableMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugDisableMemoryBreakpoint(int argc, char* argv[]);
bool cbDebugBpDll(int argc, char* argv[]);
bool cbDebugBcDll(int argc, char* argv[]);
bool cbDebugBpDllEnable(int argc, char* argv[]);
bool cbDebugBpDllDisable(int argc, char* argv[]);
bool cbDebugSetExceptionBPX(int argc, char* argv[]);
bool cbDebugDeleteExceptionBPX(int argc, char* argv[]);
bool cbDebugEnableExceptionBPX(int argc, char* argv[]);
bool cbDebugDisableExceptionBPX(int argc, char* argv[]);
bool cbDebugSetBPGoto(int argc, char* argv[]);
bool cbDebugBplist(int argc, char* argv[]);
bool cbDebugSetBPXOptions(int argc, char* argv[]);

188
src/dbg/commands/cmd-conditional-breakpoint-control.cpp
View File

@ -5,11 +5,11 @@
#include "variable.h"
#include "value.h"
static CMDRESULT cbDebugSetBPXTextCommon(BP_TYPE Type, int argc, char* argv[], const String & description, const std::function<bool(duint, BP_TYPE, const char*)> & setFunction)
static bool cbDebugSetBPXTextCommon(BP_TYPE Type, int argc, char* argv[], const String & description, const std::function<bool(duint, BP_TYPE, const char*)> & setFunction)
{
BREAKPOINT bp;
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
char* value = "";
if(argc > 2)
value = argv[2];
@ -17,452 +17,452 @@ static CMDRESULT cbDebugSetBPXTextCommon(BP_TYPE Type, int argc, char* argv[], c
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!setFunction(bp.addr, Type, value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set %s on breakpoint \"%s\"\n"), description.c_str(), argv[1]);
return STATUS_ERROR;
return false;
}
DebugUpdateBreakpointsViewAsync();
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbDebugSetBPXNameCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXNameCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "breakpoint name"))), BpSetName);
}
static CMDRESULT cbDebugSetBPXConditionCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "break condition"))), BpSetBreakCondition);
}
static CMDRESULT cbDebugSetBPXLogCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXLogCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging text"))), BpSetLogText);
}
static CMDRESULT cbDebugSetBPXLogConditionCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXLogConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "logging condition"))), BpSetLogCondition);
}
static CMDRESULT cbDebugSetBPXCommandCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXCommandCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command on hit"))), BpSetCommandText);
}
static CMDRESULT cbDebugSetBPXCommandConditionCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXCommandConditionCommon(BP_TYPE Type, int argc, char* argv[])
{
return cbDebugSetBPXTextCommon(Type, argc, argv, String(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "command condition"))), BpSetCommandCondition);
}
static CMDRESULT cbDebugSetBPXFastResumeCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXFastResumeCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!\n"));
return STATUS_ERROR;
return false;
}
auto fastResume = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return STATUS_ERROR;
return false;
fastResume = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!BpSetFastResume(bp.addr, Type, fastResume))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set fast resume on breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
DebugUpdateBreakpointsViewAsync();
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbDebugSetBPXSingleshootCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXSingleshootCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!\n"));
return STATUS_ERROR;
return false;
}
auto singleshoot = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return STATUS_ERROR;
return false;
singleshoot = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!BpSetSingleshoot(bp.addr, Type, singleshoot))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set singleshoot on breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
DebugUpdateBreakpointsViewAsync();
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbDebugSetBPXSilentCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugSetBPXSilentCommon(BP_TYPE Type, int argc, char* argv[])
{
BREAKPOINT bp;
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!\n"));
return STATUS_ERROR;
return false;
}
auto silent = true;
if(argc > 2)
{
duint value;
if(!valfromstring(argv[2], &value, false))
return STATUS_ERROR;
return false;
silent = value != 0;
}
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!BpSetSilent(bp.addr, Type, silent))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set silent on breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
DebugUpdateBreakpointsViewAsync();
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbDebugGetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugGetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!\n"));
return STATUS_ERROR;
return false;
}
BREAKPOINT bp;
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
varset("$result", bp.hitcount, false);
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbDebugResetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
static bool cbDebugResetBPXHitCountCommon(BP_TYPE Type, int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!\n"));
return STATUS_ERROR;
return false;
}
duint value = 0;
if(argc > 2)
if(!valfromstring(argv[2], &value, false))
return STATUS_ERROR;
return false;
BREAKPOINT bp;
if(!BpGetAny(Type, argv[1], &bp))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "No such breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!BpResetHitCount(bp.addr, Type, (uint32)value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Can't set hit count on breakpoint \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
DebugUpdateBreakpointsViewAsync();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetBPXName(int argc, char* argv[])
bool cbDebugSetBPXName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXCondition(int argc, char* argv[])
bool cbDebugSetBPXCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXLog(int argc, char* argv[])
bool cbDebugSetBPXLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXLogCondition(int argc, char* argv[])
bool cbDebugSetBPXLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXCommand(int argc, char* argv[])
bool cbDebugSetBPXCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXCommandCondition(int argc, char* argv[])
bool cbDebugSetBPXCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXFastResume(int argc, char* argv[])
bool cbDebugSetBPXFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXSingleshoot(int argc, char* argv[])
bool cbDebugSetBPXSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXSilent(int argc, char* argv[])
bool cbDebugSetBPXSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugGetBPXHitCount(int argc, char* argv[])
bool cbDebugGetBPXHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugResetBPXHitCount(int argc, char* argv[])
bool cbDebugResetBPXHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPNORMAL, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareName(int argc, char* argv[])
bool cbDebugSetBPXHardwareName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareCondition(int argc, char* argv[])
bool cbDebugSetBPXHardwareCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareLog(int argc, char* argv[])
bool cbDebugSetBPXHardwareLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareLogCondition(int argc, char* argv[])
bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareCommand(int argc, char* argv[])
bool cbDebugSetBPXHardwareCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[])
bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareFastResume(int argc, char* argv[])
bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[])
bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXHardwareSilent(int argc, char* argv[])
bool cbDebugSetBPXHardwareSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugGetBPXHardwareHitCount(int argc, char* argv[])
bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugResetBPXHardwareHitCount(int argc, char* argv[])
bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPHARDWARE, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryName(int argc, char* argv[])
bool cbDebugSetBPXMemoryName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryCondition(int argc, char* argv[])
bool cbDebugSetBPXMemoryCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryLog(int argc, char* argv[])
bool cbDebugSetBPXMemoryLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryLogCondition(int argc, char* argv[])
bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryCommand(int argc, char* argv[])
bool cbDebugSetBPXMemoryCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[])
bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemoryFastResume(int argc, char* argv[])
bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemorySingleshoot(int argc, char* argv[])
bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXMemorySilent(int argc, char* argv[])
bool cbDebugSetBPXMemorySilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugGetBPXMemoryHitCount(int argc, char* argv[])
bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugResetBPXMemoryHitCount(int argc, char* argv[])
bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPMEMORY, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLName(int argc, char* argv[])
bool cbDebugSetBPXDLLName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLCondition(int argc, char* argv[])
bool cbDebugSetBPXDLLCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLLog(int argc, char* argv[])
bool cbDebugSetBPXDLLLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLLogCondition(int argc, char* argv[])
bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLCommand(int argc, char* argv[])
bool cbDebugSetBPXDLLCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLCommandCondition(int argc, char* argv[])
bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLFastResume(int argc, char* argv[])
bool cbDebugSetBPXDLLFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLSingleshoot(int argc, char* argv[])
bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXDLLSilent(int argc, char* argv[])
bool cbDebugSetBPXDLLSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugGetBPXDLLHitCount(int argc, char* argv[])
bool cbDebugGetBPXDLLHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugResetBPXDLLHitCount(int argc, char* argv[])
bool cbDebugResetBPXDLLHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPDLL, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionName(int argc, char* argv[])
bool cbDebugSetBPXExceptionName(int argc, char* argv[])
{
return cbDebugSetBPXNameCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionCondition(int argc, char* argv[])
bool cbDebugSetBPXExceptionCondition(int argc, char* argv[])
{
return cbDebugSetBPXConditionCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionLog(int argc, char* argv[])
bool cbDebugSetBPXExceptionLog(int argc, char* argv[])
{
return cbDebugSetBPXLogCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionLogCondition(int argc, char* argv[])
bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[])
{
return cbDebugSetBPXLogConditionCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionCommand(int argc, char* argv[])
bool cbDebugSetBPXExceptionCommand(int argc, char* argv[])
{
return cbDebugSetBPXCommandCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[])
bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[])
{
return cbDebugSetBPXCommandConditionCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionFastResume(int argc, char* argv[])
bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[])
{
return cbDebugSetBPXFastResumeCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[])
bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[])
{
return cbDebugSetBPXSingleshootCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugSetBPXExceptionSilent(int argc, char* argv[])
bool cbDebugSetBPXExceptionSilent(int argc, char* argv[])
{
return cbDebugSetBPXSilentCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugGetBPXExceptionHitCount(int argc, char* argv[])
bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[])
{
return cbDebugGetBPXHitCountCommon(BPEXCEPTION, argc, argv);
}
CMDRESULT cbDebugResetBPXExceptionHitCount(int argc, char* argv[])
bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[])
{
return cbDebugResetBPXHitCountCommon(BPEXCEPTION, argc, argv);
}

110
src/dbg/commands/cmd-conditional-breakpoint-control.h
View File

@ -2,62 +2,62 @@
#include "command.h"
CMDRESULT cbDebugSetBPXName(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXLog(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXLogCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXCommand(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXCommandCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXFastResume(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXSingleshoot(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXSilent(int argc, char* argv[]);
CMDRESULT cbDebugGetBPXHitCount(int argc, char* argv[]);
CMDRESULT cbDebugResetBPXHitCount(int argc, char* argv[]);
bool cbDebugSetBPXName(int argc, char* argv[]);
bool cbDebugSetBPXCondition(int argc, char* argv[]);
bool cbDebugSetBPXLog(int argc, char* argv[]);
bool cbDebugSetBPXLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXCommand(int argc, char* argv[]);
bool cbDebugSetBPXCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXFastResume(int argc, char* argv[]);
bool cbDebugSetBPXSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXSilent(int argc, char* argv[]);
bool cbDebugGetBPXHitCount(int argc, char* argv[]);
bool cbDebugResetBPXHitCount(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareName(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareLog(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareLogCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareCommand(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareFastResume(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXHardwareSilent(int argc, char* argv[]);
CMDRESULT cbDebugGetBPXHardwareHitCount(int argc, char* argv[]);
CMDRESULT cbDebugResetBPXHardwareHitCount(int argc, char* argv[]);
bool cbDebugSetBPXHardwareName(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareLog(int argc, char* argv[]);
bool cbDebugSetBPXHardwareLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCommand(int argc, char* argv[]);
bool cbDebugSetBPXHardwareCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXHardwareFastResume(int argc, char* argv[]);
bool cbDebugSetBPXHardwareSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXHardwareSilent(int argc, char* argv[]);
bool cbDebugGetBPXHardwareHitCount(int argc, char* argv[]);
bool cbDebugResetBPXHardwareHitCount(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryName(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryLog(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryLogCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryCommand(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemoryFastResume(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemorySingleshoot(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXMemorySilent(int argc, char* argv[]);
CMDRESULT cbDebugGetBPXMemoryHitCount(int argc, char* argv[]);
CMDRESULT cbDebugResetBPXMemoryHitCount(int argc, char* argv[]);
bool cbDebugSetBPXMemoryName(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryLog(int argc, char* argv[]);
bool cbDebugSetBPXMemoryLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCommand(int argc, char* argv[]);
bool cbDebugSetBPXMemoryCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXMemoryFastResume(int argc, char* argv[]);
bool cbDebugSetBPXMemorySingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXMemorySilent(int argc, char* argv[]);
bool cbDebugGetBPXMemoryHitCount(int argc, char* argv[]);
bool cbDebugResetBPXMemoryHitCount(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLName(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLLog(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLLogCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLCommand(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLCommandCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLFastResume(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLSingleshoot(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXDLLSilent(int argc, char* argv[]);
CMDRESULT cbDebugGetBPXDLLHitCount(int argc, char* argv[]);
CMDRESULT cbDebugResetBPXDLLHitCount(int argc, char* argv[]);
bool cbDebugSetBPXDLLName(int argc, char* argv[]);
bool cbDebugSetBPXDLLCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLLog(int argc, char* argv[]);
bool cbDebugSetBPXDLLLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLCommand(int argc, char* argv[]);
bool cbDebugSetBPXDLLCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXDLLFastResume(int argc, char* argv[]);
bool cbDebugSetBPXDLLSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXDLLSilent(int argc, char* argv[]);
bool cbDebugGetBPXDLLHitCount(int argc, char* argv[]);
bool cbDebugResetBPXDLLHitCount(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionName(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionLog(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionLogCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionCommand(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionFastResume(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[]);
CMDRESULT cbDebugSetBPXExceptionSilent(int argc, char* argv[]);
CMDRESULT cbDebugGetBPXExceptionHitCount(int argc, char* argv[]);
CMDRESULT cbDebugResetBPXExceptionHitCount(int argc, char* argv[]);
bool cbDebugSetBPXExceptionName(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionLog(int argc, char* argv[]);
bool cbDebugSetBPXExceptionLogCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCommand(int argc, char* argv[]);
bool cbDebugSetBPXExceptionCommandCondition(int argc, char* argv[]);
bool cbDebugSetBPXExceptionFastResume(int argc, char* argv[]);
bool cbDebugSetBPXExceptionSingleshoot(int argc, char* argv[]);
bool cbDebugSetBPXExceptionSilent(int argc, char* argv[]);
bool cbDebugGetBPXExceptionHitCount(int argc, char* argv[]);
bool cbDebugResetBPXExceptionHitCount(int argc, char* argv[]);

110
src/dbg/commands/cmd-debug-control.cpp
View File

@ -9,21 +9,21 @@
#include "plugin_loader.h"
#include "value.h"
CMDRESULT cbDebugRunInternal(int argc, char* argv[])
bool cbDebugRunInternal(int argc, char* argv[])
{
// Don't "run" twice if the program is already running
if(dbgisrunning())
return STATUS_ERROR;
return false;
dbgsetispausedbyuser(false);
GuiSetDebugStateAsync(running);
unlock(WAITID_RUN);
PLUG_CB_RESUMEDEBUG callbackInfo;
callbackInfo.reserved = 0;
plugincbcall(CB_RESUMEDEBUG, &callbackInfo);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugInit(int argc, char* argv[])
bool cbDebugInit(int argc, char* argv[])
{
cbDebugStop(argc, argv);
@ -31,7 +31,7 @@ CMDRESULT cbDebugInit(int argc, char* argv[])
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!"));
return STATUS_ERROR;
return false;
}
strcpy_s(arg1, argv[1]);
char szResolvedPath[MAX_PATH] = "";
@ -43,13 +43,13 @@ CMDRESULT cbDebugInit(int argc, char* argv[])
if(!FileExists(arg1))
{
dputs(QT_TRANSLATE_NOOP("DBG", "File does not exist!"));
return STATUS_ERROR;
return false;
}
Handle hFile = CreateFileW(StringUtils::Utf8ToUtf16(arg1).c_str(), GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if(hFile == INVALID_HANDLE_VALUE)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Could not open file!"));
return STATUS_ERROR;
return false;
}
GetFileNameFromHandle(hFile, arg1); //get full path of the file
hFile.Close();
@ -59,7 +59,7 @@ CMDRESULT cbDebugInit(int argc, char* argv[])
{
case invalid:
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid PE file!"));
return STATUS_ERROR;
return false;
#ifdef _WIN64
case x32:
dputs(QT_TRANSLATE_NOOP("DBG", "Use x32dbg to debug this file!"));
@ -67,7 +67,7 @@ CMDRESULT cbDebugInit(int argc, char* argv[])
case x64:
dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this file!"));
#endif //_WIN64
return STATUS_ERROR;
return false;
case dotnet:
dputs(QT_TRANSLATE_NOOP("DBG", "This file is a dotNET application."));
break;
@ -103,10 +103,10 @@ CMDRESULT cbDebugInit(int argc, char* argv[])
if(*currentfolder)
init.currentfolder = currentfolder;
CloseHandle(CreateThread(0, 0, threadDebugLoop, &init, 0, 0));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugStop(int argc, char* argv[])
bool cbDebugStop(int argc, char* argv[])
{
// HACK: TODO: Don't kill script on debugger ending a process
//scriptreset(); //reset the currently-loaded script
@ -123,29 +123,29 @@ CMDRESULT cbDebugStop(int argc, char* argv[])
if(CurrentTick - BeginTick > 10000)
{
dputs(QT_TRANSLATE_NOOP("DBG", "The debuggee does not stop after 10 seconds. The debugger state may be corrupted."));
return STATUS_ERROR;
return false;
}
if(CurrentTick - BeginTick >= 300)
TerminateProcess(fdProcessInfo->hProcess, -1);
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugAttach(int argc, char* argv[])
bool cbDebugAttach(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint pid = 0;
if(!valfromstring(argv[1], &pid, false))
return STATUS_ERROR;
return false;
if(argc > 2)
{
duint eventHandle = 0;
if(!valfromstring(argv[2], &eventHandle, false))
return STATUS_ERROR;
return false;
dbgsetattachevent((HANDLE)eventHandle);
}
if(DbgIsDebugging())
@ -154,13 +154,13 @@ CMDRESULT cbDebugAttach(int argc, char* argv[])
if(!hProcess)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not open process %X!\n"), DWORD(pid));
return STATUS_ERROR;
return false;
}
BOOL wow64 = false, mewow64 = false;
if(!IsWow64Process(hProcess, &wow64) || !IsWow64Process(GetCurrentProcess(), &mewow64))
{
dputs(QT_TRANSLATE_NOOP("DBG", "IsWow64Process failed!"));
return STATUS_ERROR;
return false;
}
if((mewow64 && !wow64) || (!mewow64 && wow64))
{
@ -169,35 +169,35 @@ CMDRESULT cbDebugAttach(int argc, char* argv[])
#else
dputs(QT_TRANSLATE_NOOP("DBG", "Use x64dbg to debug this process!"));
#endif // _WIN64
return STATUS_ERROR;
return false;
}
wchar_t wszFileName[MAX_PATH] = L"";
if(!GetModuleFileNameExW(hProcess, 0, wszFileName, MAX_PATH))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not get module filename %X!\n"), DWORD(pid));
return STATUS_ERROR;
return false;
}
strcpy_s(szFileName, StringUtils::Utf16ToUtf8(wszFileName).c_str());
CloseHandle(CreateThread(0, 0, threadAttachLoop, (void*)pid, 0, 0));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugDetach(int argc, char* argv[])
bool cbDebugDetach(int argc, char* argv[])
{
unlock(WAITID_RUN); //run
dbgsetisdetachedbyuser(true); //detach when paused
StepInto((void*)cbDetach);
DebugBreakProcess(fdProcessInfo->hProcess);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugRun(int argc, char* argv[])
bool cbDebugRun(int argc, char* argv[])
{
HistoryClear();
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugErun(int argc, char* argv[])
bool cbDebugErun(int argc, char* argv[])
{
HistoryClear();
if(!dbgisrunning())
@ -205,38 +205,38 @@ CMDRESULT cbDebugErun(int argc, char* argv[])
else
{
dbgsetskipexceptions(false);
return STATUS_CONTINUE;
return true;
}
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugSerun(int argc, char* argv[])
bool cbDebugSerun(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugPause(int argc, char* argv[])
bool cbDebugPause(int argc, char* argv[])
{
if(_dbg_isanimating())
{
_dbg_animatestop(); // pause when animating
return STATUS_CONTINUE;
return true;
}
if(!DbgIsDebugging())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not debugging!"));
return STATUS_ERROR;
return false;
}
if(!dbgisrunning())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Program is not running"));
return STATUS_ERROR;
return false;
}
if(SuspendThread(hActiveThread) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error suspending thread"));
return STATUS_ERROR;
return false;
}
duint CIP = GetContextDataEx(hActiveThread, UE_CIP);
if(!SetBPX(CIP, UE_BREAKPOINT, (void*)cbPauseBreakpoint))
@ -245,20 +245,20 @@ CMDRESULT cbDebugPause(int argc, char* argv[])
if(ResumeThread(hActiveThread) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return STATUS_ERROR;
return false;
}
return STATUS_ERROR;
return false;
}
dbgsetispausedbyuser(true);
if(ResumeThread(hActiveThread) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugContinue(int argc, char* argv[])
bool cbDebugContinue(int argc, char* argv[])
{
if(argc < 2)
{
@ -270,7 +270,7 @@ CMDRESULT cbDebugContinue(int argc, char* argv[])
SetNextDbgContinueStatus(DBG_EXCEPTION_NOT_HANDLED);
dputs(QT_TRANSLATE_NOOP("DBG", "Exception will be thrown in the program"));
}
return STATUS_CONTINUE;
return true;
}
static bool skipInt3Stepping(int argc, char* argv[])
@ -289,10 +289,10 @@ static bool skipInt3Stepping(int argc, char* argv[])
return false;
}
CMDRESULT cbDebugStepInto(int argc, char* argv[])
bool cbDebugStepInto(int argc, char* argv[])
{
if(skipInt3Stepping(argc, argv))
return STATUS_CONTINUE;
return true;
StepInto((void*)cbStep);
// History
HistoryAdd();
@ -300,22 +300,22 @@ CMDRESULT cbDebugStepInto(int argc, char* argv[])
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugeStepInto(int argc, char* argv[])
bool cbDebugeStepInto(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepInto(argc, argv);
}
CMDRESULT cbDebugseStepInto(int argc, char* argv[])
bool cbDebugseStepInto(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugStepInto(argc, argv);
}
CMDRESULT cbDebugStepOver(int argc, char* argv[])
bool cbDebugStepOver(int argc, char* argv[])
{
if(skipInt3Stepping(argc, argv))
return STATUS_CONTINUE;
return true;
StepOver((void*)cbStep);
// History
HistoryClear();
@ -323,19 +323,19 @@ CMDRESULT cbDebugStepOver(int argc, char* argv[])
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugeStepOver(int argc, char* argv[])
bool cbDebugeStepOver(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepOver(argc, argv);
}
CMDRESULT cbDebugseStepOver(int argc, char* argv[])
bool cbDebugseStepOver(int argc, char* argv[])
{
cbDebugContinue(argc, argv);
return cbDebugStepOver(argc, argv);
}
CMDRESULT cbDebugSingleStep(int argc, char* argv[])
bool cbDebugSingleStep(int argc, char* argv[])
{
duint stepcount = 1;
if(argc > 1)
@ -347,26 +347,26 @@ CMDRESULT cbDebugSingleStep(int argc, char* argv[])
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugeSingleStep(int argc, char* argv[])
bool cbDebugeSingleStep(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugSingleStep(argc, argv);
}
CMDRESULT cbDebugStepOut(int argc, char* argv[])
bool cbDebugStepOut(int argc, char* argv[])
{
HistoryClear();
StepOver((void*)cbRtrStep);
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugeStepOut(int argc, char* argv[])
bool cbDebugeStepOut(int argc, char* argv[])
{
dbgsetskipexceptions(true);
return cbDebugStepOut(argc, argv);
}
CMDRESULT cbDebugSkip(int argc, char* argv[])
bool cbDebugSkip(int argc, char* argv[])
{
SetNextDbgContinueStatus(DBG_CONTINUE); //swallow the exception
duint cip = GetContextDataEx(hActiveThread, UE_CIP);
@ -376,12 +376,12 @@ CMDRESULT cbDebugSkip(int argc, char* argv[])
cip += basicinfo.size;
SetContextDataEx(hActiveThread, UE_CIP, cip);
DebugUpdateGuiAsync(cip, false); //update GUI
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrInstrUndo(int argc, char* argv[])
bool cbInstrInstrUndo(int argc, char* argv[])
{
HistoryRestore();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}

44
src/dbg/commands/cmd-debug-control.h
View File

@ -2,25 +2,25 @@
#include "command.h"
CMDRESULT cbDebugRunInternal(int argc, char* argv[]);
CMDRESULT cbDebugInit(int argc, char* argv[]);
CMDRESULT cbDebugStop(int argc, char* argv[]);
CMDRESULT cbDebugAttach(int argc, char* argv[]);
CMDRESULT cbDebugDetach(int argc, char* argv[]);
CMDRESULT cbDebugRun(int argc, char* argv[]);
CMDRESULT cbDebugErun(int argc, char* argv[]);
CMDRESULT cbDebugSerun(int argc, char* argv[]);
CMDRESULT cbDebugPause(int argc, char* argv[]);
CMDRESULT cbDebugContinue(int argc, char* argv[]);
CMDRESULT cbDebugStepInto(int argc, char* argv[]);
CMDRESULT cbDebugeStepInto(int argc, char* argv[]);
CMDRESULT cbDebugseStepInto(int argc, char* argv[]);
CMDRESULT cbDebugStepOver(int argc, char* argv[]);
CMDRESULT cbDebugeStepOver(int argc, char* argv[]);
CMDRESULT cbDebugseStepOver(int argc, char* argv[]);
CMDRESULT cbDebugSingleStep(int argc, char* argv[]);
CMDRESULT cbDebugeSingleStep(int argc, char* argv[]);
CMDRESULT cbDebugStepOut(int argc, char* argv[]);
CMDRESULT cbDebugeStepOut(int argc, char* argv[]);
CMDRESULT cbDebugSkip(int argc, char* argv[]);
CMDRESULT cbInstrInstrUndo(int argc, char* argv[]);
bool cbDebugRunInternal(int argc, char* argv[]);
bool cbDebugInit(int argc, char* argv[]);
bool cbDebugStop(int argc, char* argv[]);
bool cbDebugAttach(int argc, char* argv[]);
bool cbDebugDetach(int argc, char* argv[]);
bool cbDebugRun(int argc, char* argv[]);
bool cbDebugErun(int argc, char* argv[]);
bool cbDebugSerun(int argc, char* argv[]);
bool cbDebugPause(int argc, char* argv[]);
bool cbDebugContinue(int argc, char* argv[]);
bool cbDebugStepInto(int argc, char* argv[]);
bool cbDebugeStepInto(int argc, char* argv[]);
bool cbDebugseStepInto(int argc, char* argv[]);
bool cbDebugStepOver(int argc, char* argv[]);
bool cbDebugeStepOver(int argc, char* argv[]);
bool cbDebugseStepOver(int argc, char* argv[]);
bool cbDebugSingleStep(int argc, char* argv[]);
bool cbDebugeSingleStep(int argc, char* argv[]);
bool cbDebugStepOut(int argc, char* argv[]);
bool cbDebugeStepOut(int argc, char* argv[]);
bool cbDebugSkip(int argc, char* argv[]);
bool cbInstrInstrUndo(int argc, char* argv[]);

148
src/dbg/commands/cmd-general-purpose.cpp
View File

@ -5,7 +5,7 @@
#include "_scriptapi_stack.h"
#include "debugger.h"
static CMDRESULT ReadWriteVariable(const char* varname, const std::function<CMDRESULT(duint*, int)> & callback)
static bool ReadWriteVariable(const char* varname, const std::function<bool(duint*, int)> & callback)
{
duint set_value = 0;
bool isvar;
@ -13,10 +13,10 @@ static CMDRESULT ReadWriteVariable(const char* varname, const std::function<CMDR
if(!valfromstring(varname, &set_value, true, true, &varsize, &isvar))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid variable \"%s\"\n"), varname);
return STATUS_ERROR;
return false;
}
CMDRESULT retVal = callback(&set_value, varsize);
if(retVal != STATUS_CONTINUE)
bool retVal = callback(&set_value, varsize);
if(retVal != true)
return retVal;
duint temp = 0;
valfromstring(varname, &temp, true, true, 0, nullptr, 0); //there is no return check on this because the destination might not exist yet
@ -28,94 +28,94 @@ static CMDRESULT ReadWriteVariable(const char* varname, const std::function<CMDR
if(valfromstring(varname, &value)) //if the var is a value already it's an invalid destination
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid variable \"%s\"\n"), varname);
return STATUS_ERROR;
return false;
}
varnew(varname, set_value, VAR_USER);
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrInc(int argc, char* argv[])
bool cbInstrInc(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s++", argv[1]).c_str());
}
CMDRESULT cbInstrDec(int argc, char* argv[])
bool cbInstrDec(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s--", argv[1]).c_str());
}
CMDRESULT cbInstrAdd(int argc, char* argv[])
bool cbInstrAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s+=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrSub(int argc, char* argv[])
bool cbInstrSub(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s-=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrMul(int argc, char* argv[])
bool cbInstrMul(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s*=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrDiv(int argc, char* argv[])
bool cbInstrDiv(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s/=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrAnd(int argc, char* argv[])
bool cbInstrAnd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s&=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrOr(int argc, char* argv[])
bool cbInstrOr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s|=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrXor(int argc, char* argv[])
bool cbInstrXor(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s^=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrNeg(int argc, char* argv[])
bool cbInstrNeg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s=-%s", argv[1], argv[1]).c_str());
}
CMDRESULT cbInstrNot(int argc, char* argv[])
bool cbInstrNot(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
return cmddirectexec(StringUtils::sprintf("%s=~%s", argv[1], argv[1]).c_str());
}
CMDRESULT cbInstrBswap(int argc, char* argv[])
bool cbInstrBswap(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
return ReadWriteVariable(argv[1], [](duint * value, int size)
{
if(size == 2)
@ -129,17 +129,17 @@ CMDRESULT cbInstrBswap(int argc, char* argv[])
else if(size != 1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
});
}
CMDRESULT cbInstrRol(int argc, char* argv[])
bool cbInstrRol(int argc, char* argv[])
{
duint value2;
if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false))
return STATUS_ERROR;
return false;
return ReadWriteVariable(argv[1], [value2](duint * value, int size)
{
if(size == 1)
@ -155,17 +155,17 @@ CMDRESULT cbInstrRol(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
});
}
CMDRESULT cbInstrRor(int argc, char* argv[])
bool cbInstrRor(int argc, char* argv[])
{
duint value2;
if(IsArgumentsLessThan(argc, 3) || !valfromstring(argv[2], &value2, false))
return STATUS_ERROR;
return false;
return ReadWriteVariable(argv[1], [value2](duint * value, int size)
{
if(size == 1)
@ -181,24 +181,24 @@ CMDRESULT cbInstrRor(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Variable size not supported."));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
});
}
CMDRESULT cbInstrShl(int argc, char* argv[])
bool cbInstrShl(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
//SHL and SAL have the same semantics
return cmddirectexec(StringUtils::sprintf("%s<<=%s", argv[1], argv[2]).c_str());
}
CMDRESULT cbInstrShr(int argc, char* argv[])
bool cbInstrShr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
auto oldType = valuesignedcalc();
valuesetsignedcalc(false); //SHR is unsigned
auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str());
@ -206,10 +206,10 @@ CMDRESULT cbInstrShr(int argc, char* argv[])
return result;
}
CMDRESULT cbInstrSar(int argc, char* argv[])
bool cbInstrSar(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
auto oldType = valuesignedcalc();
valuesetsignedcalc(true); //SAR is signed
auto result = cmddirectexec(StringUtils::sprintf("%s>>=%s", argv[1], argv[2]).c_str());
@ -217,27 +217,27 @@ CMDRESULT cbInstrSar(int argc, char* argv[])
return result;
}
CMDRESULT cbInstrPush(int argc, char* argv[])
bool cbInstrPush(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint value;
if(!valfromstring(argv[1], &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid argument \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
Script::Stack::Push(value);
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
DebugUpdateStack(csp, csp);
GuiUpdateRegisterView();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrPop(int argc, char* argv[])
bool cbInstrPop(int argc, char* argv[])
{
duint value = Script::Stack::Pop();
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
@ -246,22 +246,22 @@ CMDRESULT cbInstrPop(int argc, char* argv[])
if(argc > 1)
{
if(!valtostring(argv[1], value, false))
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrTest(int argc, char* argv[])
bool cbInstrTest(int argc, char* argv[])
{
//TODO: test
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint arg1 = 0;
if(!valfromstring(argv[1], &arg1, false))
return STATUS_ERROR;
return false;
duint arg2 = 0;
if(!valfromstring(argv[2], &arg2, false))
return STATUS_ERROR;
return false;
duint ezflag;
duint bsflag = 0;
if(!(arg1 & arg2))
@ -271,19 +271,19 @@ CMDRESULT cbInstrTest(int argc, char* argv[])
varset("$_EZ_FLAG", ezflag, true);
varset("$_BS_FLAG", bsflag, true);
//dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCmp(int argc, char* argv[])
bool cbInstrCmp(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint arg1 = 0;
if(!valfromstring(argv[1], &arg1, false))
return STATUS_ERROR;
return false;
duint arg2 = 0;
if(!valfromstring(argv[2], &arg2, false))
return STATUS_ERROR;
return false;
duint ezflag;
duint bsflag;
if(arg1 == arg2)
@ -307,13 +307,13 @@ CMDRESULT cbInstrCmp(int argc, char* argv[])
varset("$_EZ_FLAG", ezflag, true);
varset("$_BS_FLAG", bsflag, true);
//dprintf(QT_TRANSLATE_NOOP("DBG", "$_EZ_FLAG=%d, $_BS_FLAG=%d\n"), ezflag, bsflag);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrMov(int argc, char* argv[])
bool cbInstrMov(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
String srcText = argv[2];
if(srcText[0] == '#' && srcText[srcText.length() - 1] == '#') //handle mov addr, #DATA#
{
@ -323,14 +323,14 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(len % 2)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid hex string \"%s\" (length not divisible by 2)\n"), dataText.c_str());
return STATUS_ERROR;
return false;
}
for(int i = 0; i < len; i++)
{
if(!isxdigit(dataText[i]))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid hex string \"%s\" (contains invalid characters)\n"), dataText.c_str());
return STATUS_ERROR;
return false;
}
}
//Check the destination
@ -338,7 +338,7 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(!valfromstring(argv[1], &dest) || !MemIsValidReadPtr(dest))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid destination \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
//Convert text to byte array (very ugly)
Memory<unsigned char*> data(len / 2);
@ -351,7 +351,7 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(sscanf_s(b, "%X", &res) != 1)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid hex byte \"%s\"\n"), b);
return STATUS_ERROR;
return false;
}
data()[j] = res;
}
@ -359,10 +359,10 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(!MemWrite(dest, data(), data.size()))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to write to %p\n"), dest);
return STATUS_ERROR;
return false;
}
GuiUpdateAllViews(); //refresh disassembly/dump/etc
return STATUS_CONTINUE;
return true;
}
else
{
@ -370,7 +370,7 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(!valfromstring(srcText.c_str(), &set_value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid src \"%s\"\n"), argv[2]);
return STATUS_ERROR;
return false;
}
bool isvar = false;
duint temp = 0;
@ -383,10 +383,10 @@ CMDRESULT cbInstrMov(int argc, char* argv[])
if(valfromstring(argv[1], &value)) //if the var is a value already it's an invalid destination
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid dest \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
varnew(argv[1], set_value, VAR_USER);
}
}
return STATUS_CONTINUE;
return true;
}

44
src/dbg/commands/cmd-general-purpose.h
View File

@ -2,25 +2,25 @@
#include "command.h"
CMDRESULT cbInstrInc(int argc, char* argv[]);
CMDRESULT cbInstrDec(int argc, char* argv[]);
CMDRESULT cbInstrAdd(int argc, char* argv[]);
CMDRESULT cbInstrSub(int argc, char* argv[]);
CMDRESULT cbInstrMul(int argc, char* argv[]);
CMDRESULT cbInstrDiv(int argc, char* argv[]);
CMDRESULT cbInstrAnd(int argc, char* argv[]);
CMDRESULT cbInstrOr(int argc, char* argv[]);
CMDRESULT cbInstrXor(int argc, char* argv[]);
CMDRESULT cbInstrNeg(int argc, char* argv[]);
CMDRESULT cbInstrNot(int argc, char* argv[]);
CMDRESULT cbInstrBswap(int argc, char* argv[]);
CMDRESULT cbInstrRol(int argc, char* argv[]);
CMDRESULT cbInstrRor(int argc, char* argv[]);
CMDRESULT cbInstrShl(int argc, char* argv[]);
CMDRESULT cbInstrShr(int argc, char* argv[]);
CMDRESULT cbInstrSar(int argc, char* argv[]);
CMDRESULT cbInstrPush(int argc, char* argv[]);
CMDRESULT cbInstrPop(int argc, char* argv[]);
CMDRESULT cbInstrTest(int argc, char* argv[]);
CMDRESULT cbInstrCmp(int argc, char* argv[]);
CMDRESULT cbInstrMov(int argc, char* argv[]);
bool cbInstrInc(int argc, char* argv[]);
bool cbInstrDec(int argc, char* argv[]);
bool cbInstrAdd(int argc, char* argv[]);
bool cbInstrSub(int argc, char* argv[]);
bool cbInstrMul(int argc, char* argv[]);
bool cbInstrDiv(int argc, char* argv[]);
bool cbInstrAnd(int argc, char* argv[]);
bool cbInstrOr(int argc, char* argv[]);
bool cbInstrXor(int argc, char* argv[]);
bool cbInstrNeg(int argc, char* argv[]);
bool cbInstrNot(int argc, char* argv[]);
bool cbInstrBswap(int argc, char* argv[]);
bool cbInstrRol(int argc, char* argv[]);
bool cbInstrRor(int argc, char* argv[]);
bool cbInstrShl(int argc, char* argv[]);
bool cbInstrShr(int argc, char* argv[]);
bool cbInstrSar(int argc, char* argv[]);
bool cbInstrPush(int argc, char* argv[]);
bool cbInstrPop(int argc, char* argv[]);
bool cbInstrTest(int argc, char* argv[]);
bool cbInstrCmp(int argc, char* argv[]);
bool cbInstrMov(int argc, char* argv[]);

100
src/dbg/commands/cmd-gui.cpp
View File

@ -7,7 +7,7 @@
#include "stringformat.h"
#include "value.h"
CMDRESULT cbDebugDisasm(int argc, char* argv[])
bool cbDebugDisasm(int argc, char* argv[])
{
duint addr = 0;
if(argc > 1)
@ -22,21 +22,21 @@ CMDRESULT cbDebugDisasm(int argc, char* argv[])
DebugUpdateGui(addr, false);
GuiShowCpu();
GuiFocusView(GUI_DISASSEMBLY);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugDump(int argc, char* argv[])
bool cbDebugDump(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint addr = 0;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(argc > 2)
{
@ -44,7 +44,7 @@ CMDRESULT cbDebugDump(int argc, char* argv[])
if(!valfromstring(argv[2], &index))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
GuiDumpAtN(addr, int(index));
}
@ -52,10 +52,10 @@ CMDRESULT cbDebugDump(int argc, char* argv[])
GuiDumpAt(addr);
GuiShowCpu();
GuiFocusView(GUI_DUMP);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugStackDump(int argc, char* argv[])
bool cbDebugStackDump(int argc, char* argv[])
{
duint addr = 0;
if(argc < 2)
@ -63,7 +63,7 @@ CMDRESULT cbDebugStackDump(int argc, char* argv[])
else if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
duint csp = GetContextDataEx(hActiveThread, UE_CSP);
duint size = 0;
@ -74,25 +74,25 @@ CMDRESULT cbDebugStackDump(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid stack address!"));
GuiShowCpu();
GuiFocusView(GUI_STACK);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugMemmapdump(int argc, char* argv[])
bool cbDebugMemmapdump(int argc, char* argv[])
{
if(argc < 2)
return STATUS_ERROR;
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false) || !MemIsValidReadPtr(addr, true))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
GuiSelectInMemoryMap(addr);
GuiFocusView(GUI_MEMMAP);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrGraph(int argc, char* argv[])
bool cbInstrGraph(int argc, char* argv[])
{
duint entry;
if(argc < 2 || !valfromstring(argv[1], &entry))
@ -105,7 +105,7 @@ CMDRESULT cbInstrGraph(int argc, char* argv[])
{
if(argc <= 2) //undocumented silent option
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid address %p!\n"), entry);
return STATUS_ERROR;
return false;
}
if(!GuiGraphAt(sel))
{
@ -118,42 +118,42 @@ CMDRESULT cbInstrGraph(int argc, char* argv[])
if(!graph)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No graph generated..."));
return STATUS_ERROR;
return false;
}
auto graphList = graph->ToGraphList();
GuiLoadGraph(&graphList, sel);
}
GuiUpdateAllViews();
GuiFocusView(GUI_GRAPH);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrEnableGuiUpdate(int argc, char* argv[])
bool cbInstrEnableGuiUpdate(int argc, char* argv[])
{
if(GuiIsUpdateDisabled())
GuiUpdateEnable(false);
duint value;
//default: update gui
if(argc > 1 && valfromstring(argv[1], &value) && value == 0)
return STATUS_CONTINUE;
return true;
duint cip = GetContextDataEx(hActiveThread, UE_CIP);
DebugUpdateGuiAsync(cip, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrDisableGuiUpdate(int argc, char* argv[])
bool cbInstrDisableGuiUpdate(int argc, char* argv[])
{
if(!GuiIsUpdateDisabled())
GuiUpdateDisable();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetfreezestack(int argc, char* argv[])
bool cbDebugSetfreezestack(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
bool freeze = *argv[1] != '0';
dbgsetfreezestack(freeze);
@ -161,12 +161,12 @@ CMDRESULT cbDebugSetfreezestack(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now freezed\n"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Stack is now unfreezed\n"));
return STATUS_CONTINUE;
return true;
}
static bool bRefinit = false;
CMDRESULT cbInstrRefinit(int argc, char* argv[])
bool cbInstrRefinit(int argc, char* argv[])
{
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Script")));
GuiReferenceAddColumn(sizeof(duint) * 2, GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Address")));
@ -174,16 +174,16 @@ CMDRESULT cbInstrRefinit(int argc, char* argv[])
GuiReferenceSetRowCount(0);
GuiReferenceReloadData();
bRefinit = true;
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrRefadd(int argc, char* argv[])
bool cbInstrRefadd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!bRefinit)
cbInstrRefinit(argc, argv);
int index = GuiReferenceGetRowCount();
@ -193,74 +193,74 @@ CMDRESULT cbInstrRefadd(int argc, char* argv[])
GuiReferenceSetCellContent(index, 0, addr_text);
GuiReferenceSetCellContent(index, 1, stringformatinline(argv[2]).c_str());
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrEnableLog(int argc, char* argv[])
bool cbInstrEnableLog(int argc, char* argv[])
{
GuiEnableLog();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrDisableLog(int argc, char* argv[])
bool cbInstrDisableLog(int argc, char* argv[])
{
GuiDisableLog();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddFavTool(int argc, char* argv[])
bool cbInstrAddFavTool(int argc, char* argv[])
{
// filename, description
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(argc == 2)
GuiAddFavouriteTool(argv[1], nullptr);
else
GuiAddFavouriteTool(argv[1], argv[2]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddFavCmd(int argc, char* argv[])
bool cbInstrAddFavCmd(int argc, char* argv[])
{
// command, shortcut
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(argc == 2)
GuiAddFavouriteCommand(argv[1], nullptr);
else
GuiAddFavouriteCommand(argv[1], argv[2]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrSetFavToolShortcut(int argc, char* argv[])
bool cbInstrSetFavToolShortcut(int argc, char* argv[])
{
// filename, shortcut
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
GuiSetFavouriteToolShortcut(argv[1], argv[2]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFoldDisassembly(int argc, char* argv[])
bool cbInstrFoldDisassembly(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint start, length;
if(!valfromstring(argv[1], &start))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 1 : %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!valfromstring(argv[2], &length))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid argument 2 : %s\n"), argv[2]);
return STATUS_ERROR;
return false;
}
GuiFoldDisassembly(start, length);
return STATUS_CONTINUE;
return true;
}

32
src/dbg/commands/cmd-gui.h
View File

@ -2,19 +2,19 @@
#include "command.h"
CMDRESULT cbDebugDisasm(int argc, char* argv[]);
CMDRESULT cbDebugDump(int argc, char* argv[]);
CMDRESULT cbDebugStackDump(int argc, char* argv[]);
CMDRESULT cbDebugMemmapdump(int argc, char* argv[]);
CMDRESULT cbInstrGraph(int argc, char* argv[]);
CMDRESULT cbInstrEnableGuiUpdate(int argc, char* argv[]);
CMDRESULT cbInstrDisableGuiUpdate(int argc, char* argv[]);
CMDRESULT cbDebugSetfreezestack(int argc, char* argv[]);
CMDRESULT cbInstrRefinit(int argc, char* argv[]);
CMDRESULT cbInstrRefadd(int argc, char* argv[]);
CMDRESULT cbInstrEnableLog(int argc, char* argv[]);
CMDRESULT cbInstrDisableLog(int argc, char* argv[]);
CMDRESULT cbInstrAddFavTool(int argc, char* argv[]);
CMDRESULT cbInstrAddFavCmd(int argc, char* argv[]);
CMDRESULT cbInstrSetFavToolShortcut(int argc, char* argv[]);
CMDRESULT cbInstrFoldDisassembly(int argc, char* argv[]);
bool cbDebugDisasm(int argc, char* argv[]);
bool cbDebugDump(int argc, char* argv[]);
bool cbDebugStackDump(int argc, char* argv[]);
bool cbDebugMemmapdump(int argc, char* argv[]);
bool cbInstrGraph(int argc, char* argv[]);
bool cbInstrEnableGuiUpdate(int argc, char* argv[]);
bool cbInstrDisableGuiUpdate(int argc, char* argv[]);
bool cbDebugSetfreezestack(int argc, char* argv[]);
bool cbInstrRefinit(int argc, char* argv[]);
bool cbInstrRefadd(int argc, char* argv[]);
bool cbInstrEnableLog(int argc, char* argv[]);
bool cbInstrDisableLog(int argc, char* argv[]);
bool cbInstrAddFavTool(int argc, char* argv[]);
bool cbInstrAddFavCmd(int argc, char* argv[]);
bool cbInstrSetFavToolShortcut(int argc, char* argv[]);
bool cbInstrFoldDisassembly(int argc, char* argv[]);

58
src/dbg/commands/cmd-memory-operations.cpp
View File

@ -6,15 +6,15 @@
#include "filehelper.h"
#include "value.h"
CMDRESULT cbDebugAlloc(int argc, char* argv[])
bool cbDebugAlloc(int argc, char* argv[])
{
duint size = 0x1000, addr = 0;
if(argc > 1)
if(!valfromstring(argv[1], &size, false))
return STATUS_ERROR;
return false;
if(argc > 2)
if(!valfromstring(argv[2], &addr, false))
return STATUS_ERROR;
return false;
duint mem = (duint)MemAllocRemote(addr, size);
if(!mem)
dputs(QT_TRANSLATE_NOOP("DBG", "VirtualAllocEx failed"));
@ -27,10 +27,10 @@ CMDRESULT cbDebugAlloc(int argc, char* argv[])
GuiUpdateMemoryView();
varset("$res", mem, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugFree(int argc, char* argv[])
bool cbDebugFree(int argc, char* argv[])
{
duint lastalloc;
varget("$lastalloc", &lastalloc, 0, 0);
@ -38,12 +38,12 @@ CMDRESULT cbDebugFree(int argc, char* argv[])
if(argc > 1)
{
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
}
else if(!lastalloc)
{
dputs(QT_TRANSLATE_NOOP("DBG", "$lastalloc is zero, provide a page address"));
return STATUS_ERROR;
return false;
}
if(addr == lastalloc)
varset("$lastalloc", (duint)0, true);
@ -55,10 +55,10 @@ CMDRESULT cbDebugFree(int argc, char* argv[])
GuiUpdateMemoryView();
varset("$res", ok, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugMemset(int argc, char* argv[])
bool cbDebugMemset(int argc, char* argv[])
{
duint addr;
duint value;
@ -66,14 +66,14 @@ CMDRESULT cbDebugMemset(int argc, char* argv[])
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments"));
return STATUS_ERROR;
return false;
}
if(!valfromstring(argv[1], &addr, false) || !valfromstring(argv[2], &value, false))
return STATUS_ERROR;
return false;
if(argc > 3)
{
if(!valfromstring(argv[3], &size, false))
return STATUS_ERROR;
return false;
}
else
{
@ -81,7 +81,7 @@ CMDRESULT cbDebugMemset(int argc, char* argv[])
if(!base)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Invalid address specified"));
return STATUS_ERROR;
return false;
}
duint diff = addr - base;
addr = base + diff;
@ -92,10 +92,10 @@ CMDRESULT cbDebugMemset(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Memset failed"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Memory %p (size: %.8X) set to %.2X\n"), addr, DWORD(size & 0xFFFFFFFF), BYTE(value & 0xFF));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugGetPageRights(int argc, char* argv[])
bool cbDebugGetPageRights(int argc, char* argv[])
{
duint addr = 0;
char rights[RIGHTS_STRING_SIZE];
@ -103,21 +103,21 @@ CMDRESULT cbDebugGetPageRights(int argc, char* argv[])
if(argc != 2 || !valfromstring(argv[1], &addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: using an address as arg1\n"));
return STATUS_ERROR;
return false;
}
if(!MemGetPageRights(addr, rights))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Page: %p, Rights: %s\n"), addr, rights);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetPageRights(int argc, char* argv[])
bool cbDebugSetPageRights(int argc, char* argv[])
{
duint addr = 0;
char rights[RIGHTS_STRING_SIZE];
@ -125,19 +125,19 @@ CMDRESULT cbDebugSetPageRights(int argc, char* argv[])
if(argc < 3 || !valfromstring(argv[1], &addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: Using an address as arg1 and as arg2: Execute, ExecuteRead, ExecuteReadWrite, ExecuteWriteCopy, NoAccess, ReadOnly, ReadWrite, WriteCopy. You can add a G at first for add PAGE GUARD, example: GReadOnly\n"));
return STATUS_ERROR;
return false;
}
if(!MemSetPageRights(addr, argv[2]))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error: Set rights of %p with Rights: %s\n"), addr, argv[2]);
return STATUS_ERROR;
return false;
}
if(!MemGetPageRights(addr, rights))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting rights of page: %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
//update the memory map
@ -146,22 +146,22 @@ CMDRESULT cbDebugSetPageRights(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "New rights of %p: %s\n"), addr, rights);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrSavedata(int argc, char* argv[])
bool cbInstrSavedata(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return STATUS_ERROR;
return false;
duint addr, size;
if(!valfromstring(argv[2], &addr, false) || !valfromstring(argv[3], &size, false))
return STATUS_ERROR;
return false;
Memory<unsigned char*> data(size);
if(!MemRead(addr, data(), data.size()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to read memory..."));
return STATUS_ERROR;
return false;
}
String name = argv[1];
@ -171,7 +171,7 @@ CMDRESULT cbInstrSavedata(int argc, char* argv[])
if(!FileHelper::WriteAllData(name, data(), data.size()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Failed to write file..."));
return STATUS_ERROR;
return false;
}
#ifdef _WIN64
dprintf(QT_TRANSLATE_NOOP("DBG", "%p[% llX] written to \"%s\" !\n"), addr, size, name.c_str());
@ -179,5 +179,5 @@ CMDRESULT cbInstrSavedata(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "%p[% X] written to \"%s\" !\n"), addr, size, name.c_str());
#endif
return STATUS_CONTINUE;
return true;
}

12
src/dbg/commands/cmd-memory-operations.h
View File

@ -2,9 +2,9 @@
#include "command.h"
CMDRESULT cbDebugAlloc(int argc, char* argv[]);
CMDRESULT cbDebugFree(int argc, char* argv[]);
CMDRESULT cbDebugMemset(int argc, char* argv[]);
CMDRESULT cbDebugGetPageRights(int argc, char* argv[]);
CMDRESULT cbDebugSetPageRights(int argc, char* argv[]);
CMDRESULT cbInstrSavedata(int argc, char* argv[]);
bool cbDebugAlloc(int argc, char* argv[]);
bool cbDebugFree(int argc, char* argv[]);
bool cbDebugMemset(int argc, char* argv[]);
bool cbDebugGetPageRights(int argc, char* argv[]);
bool cbDebugSetPageRights(int argc, char* argv[]);
bool cbInstrSavedata(int argc, char* argv[]);

148
src/dbg/commands/cmd-misc.cpp
View File

@ -12,40 +12,40 @@
#include "mnemonichelp.h"
#include "commandline.h"
CMDRESULT cbInstrChd(int argc, char* argv[])
bool cbInstrChd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(!DirExists(argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "directory doesn't exist"));
return STATUS_ERROR;
return false;
}
SetCurrentDirectoryW(StringUtils::Utf8ToUtf16(argv[1]).c_str());
dputs(QT_TRANSLATE_NOOP("DBG", "current directory changed!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrZzz(int argc, char* argv[])
bool cbInstrZzz(int argc, char* argv[])
{
duint value = 100;
if(argc > 1)
if(!valfromstring(argv[1], &value, false))
return STATUS_ERROR;
return false;
auto ms = DWORD(value);
if(ms == INFINITE)
ms = 100;
Sleep(ms);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugHide(int argc, char* argv[])
bool cbDebugHide(int argc, char* argv[])
{
if(HideDebugger(fdProcessInfo->hProcess, UE_HIDE_PEBONLY))
dputs(QT_TRANSLATE_NOOP("DBG", "Debugger hidden"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Something went wrong"));
return STATUS_CONTINUE;
return true;
}
static duint LoadLibThreadID;
@ -77,12 +77,12 @@ static void cbDebugLoadLibBPX()
wait(WAITID_RUN);
}
CMDRESULT cbDebugLoadLib(int argc, char* argv[])
bool cbDebugLoadLib(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: you must specify the name of the DLL to load\n"));
return STATUS_ERROR;
return false;
}
LoadLibThreadID = fdProcessInfo->dwThreadId;
@ -94,13 +94,13 @@ CMDRESULT cbDebugLoadLib(int argc, char* argv[])
if(!DLLNameMem || !ASMAddr)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't allocate memory in debuggee"));
return STATUS_ERROR;
return false;
}
if(!MemWrite(DLLNameMem, argv[1], strlen(argv[1])))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't write process memory"));
return STATUS_ERROR;
return false;
}
int size = 0;
@ -114,7 +114,7 @@ CMDRESULT cbDebugLoadLib(int argc, char* argv[])
if(!valfromstring("kernel32:LoadLibraryA", &LoadLibraryA, false))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: couldn't get kernel32:LoadLibraryA"));
return STATUS_ERROR;
return false;
}
// Arch specific asm code
@ -147,23 +147,23 @@ CMDRESULT cbDebugLoadLib(int argc, char* argv[])
unlock(WAITID_RUN);
return ok ? STATUS_CONTINUE : STATUS_ERROR;
return ok;
}
CMDRESULT cbInstrAssemble(int argc, char* argv[])
bool cbInstrAssemble(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid expression: \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!DbgMemIsValidReadPtr(addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid address: %p!\n"), addr);
return STATUS_ERROR;
return false;
}
bool fillnop = false;
if(argc > 3)
@ -174,17 +174,17 @@ CMDRESULT cbInstrAssemble(int argc, char* argv[])
{
varset("$result", size, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to assemble \"%s\" (%s)\n"), argv[2], error);
return STATUS_ERROR;
return false;
}
varset("$result", size, false);
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrGpa(int argc, char* argv[])
bool cbInstrGpa(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
char newcmd[deflen] = "";
if(argc >= 3)
sprintf_s(newcmd, "\"%s\":%s", argv[2], argv[1]);
@ -192,12 +192,12 @@ CMDRESULT cbInstrGpa(int argc, char* argv[])
sprintf_s(newcmd, "%s", argv[1]);
duint result = 0;
if(!valfromstring(newcmd, &result, false))
return STATUS_ERROR;
return false;
varset("$RESULT", result, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetJIT(int argc, char* argv[])
bool cbDebugSetJIT(int argc, char* argv[])
{
arch actual_arch = invalid;
char* jit_debugger_cmd = "";
@ -206,7 +206,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!IsProcessElevated())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjit\n"));
return STATUS_ERROR;
return false;
}
if(argc < 2)
{
@ -216,7 +216,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
else if(argc == 2)
@ -227,13 +227,13 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!BridgeSettingGet("JIT", "Old", jit_debugger_cmd))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored."));
return STATUS_ERROR;
return false;
}
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
else if(!_strcmpi(argv[1], "oldsave"))
@ -253,7 +253,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
if(get_last_jit)
{
@ -268,13 +268,13 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!BridgeSettingGet("JIT", "Old", jit_debugger_cmd))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error there is no old JIT entry stored."));
return STATUS_ERROR;
return false;
}
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
BridgeSettingSet("JIT", 0, 0);
}
@ -284,7 +284,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
if(!dbgsetjit(jit_debugger_cmd, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
}
@ -298,7 +298,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "New OLD JIT stored: %s\n"), argv[2]);
return STATUS_CONTINUE;
return true;
}
else if(_strcmpi(argv[1], "x64") == 0)
@ -308,7 +308,7 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter."));
return STATUS_ERROR;
return false;
}
jit_debugger_cmd = argv[2];
@ -318,21 +318,21 @@ CMDRESULT cbDebugSetJIT(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error setting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use old, oldsave, restore, x86 or x64 as parameter."));
return STATUS_ERROR;
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_debugger_cmd);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugGetJIT(int argc, char* argv[])
bool cbDebugGetJIT(int argc, char* argv[])
{
char get_entry[JIT_ENTRY_MAX_SIZE] = "";
arch actual_arch;
@ -342,7 +342,7 @@ CMDRESULT cbDebugGetJIT(int argc, char* argv[])
if(!dbggetjit(get_entry, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
else
@ -354,12 +354,12 @@ CMDRESULT cbDebugGetJIT(int argc, char* argv[])
if(!BridgeSettingGet("JIT", "Old", oldjit()))
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: there is not an OLD JIT entry stored yet."));
return STATUS_ERROR;
return false;
}
else
{
dprintf(QT_TRANSLATE_NOOP("DBG", "OLD JIT entry stored: %s\n"), oldjit());
return STATUS_CONTINUE;
return true;
}
}
else if(_strcmpi(argv[1], "x64") == 0)
@ -369,7 +369,7 @@ CMDRESULT cbDebugGetJIT(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT entry type. Use OLD, x64 or x32 as parameter."));
return STATUS_ERROR;
return false;
}
if(!dbggetjit(get_entry, actual_arch, NULL, &rw_error))
@ -378,16 +378,16 @@ CMDRESULT cbDebugGetJIT(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg. The debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
}
dprintf(QT_TRANSLATE_NOOP("DBG", "JIT %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", get_entry);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
bool cbDebugGetJITAuto(int argc, char* argv[])
{
bool jit_auto = false;
arch actual_arch = invalid;
@ -397,7 +397,7 @@ CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
if(!dbggetjitauto(&jit_auto, notfound, &actual_arch, NULL))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), (actual_arch == x64) ? "x64" : "x32");
return STATUS_ERROR;
return false;
}
}
else if(argc == 2)
@ -410,7 +410,7 @@ CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter."));
return STATUS_ERROR;
return false;
}
if(!dbggetjitauto(&jit_auto, actual_arch, NULL, &rw_error))
@ -419,7 +419,7 @@ CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Error using x64 arg the debugger is not a WOW64 process\n"));
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
}
else
@ -429,22 +429,22 @@ CMDRESULT cbDebugGetJITAuto(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", jit_auto ? "ON" : "OFF");
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
bool cbDebugSetJITAuto(int argc, char* argv[])
{
arch actual_arch;
bool set_jit_auto;
if(!IsProcessElevated())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error run the debugger as Admin to setjitauto\n"));
return STATUS_ERROR;
return false;
}
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT Auto. Use ON:1 or OFF:0 arg or x64/x32, ON:1 or OFF:0.\n"));
return STATUS_ERROR;
return false;
}
else if(argc == 2)
{
@ -455,7 +455,7 @@ CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use ON:1 or OFF:0"));
return STATUS_ERROR;
return false;
}
if(!dbgsetjitauto(set_jit_auto, notfound, &actual_arch, NULL))
@ -464,7 +464,7 @@ CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x64"));
else
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting JIT auto x32"));
return STATUS_ERROR;
return false;
}
}
else if(argc == 3)
@ -479,7 +479,7 @@ CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown JIT auto entry type. Use x64 or x32 as parameter"));
return STATUS_ERROR;
return false;
}
if(_strcmpi(argv[2], "1") == 0 || _strcmpi(argv[2], "ON") == 0)
@ -489,7 +489,7 @@ CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters. Use x86 or x64 and ON:1 or OFF:0\n"));
return STATUS_ERROR;
return false;
}
if(!dbgsetjitauto(set_jit_auto, actual_arch, NULL, &rw_error))
@ -503,20 +503,20 @@ CMDRESULT cbDebugSetJITAuto(int argc, char* argv[])
else
dputs(QT_TRANSLATE_NOOP("DBG", "Error getting JIT auto x32"));
}
return STATUS_ERROR;
return false;
}
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error unknown parameters use x86 or x64, ON/1 or OFF/0\n"));
return STATUS_ERROR;
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "New JIT auto %s: %s\n"), (actual_arch == x64) ? "x64" : "x32", set_jit_auto ? "ON" : "OFF");
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugGetCmdline(int argc, char* argv[])
bool cbDebugGetCmdline(int argc, char* argv[])
{
char* cmd_line;
cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 };
@ -524,30 +524,30 @@ CMDRESULT cbDebugGetCmdline(int argc, char* argv[])
if(!dbggetcmdline(&cmd_line, &cmdline_error))
{
showcommandlineerror(&cmdline_error);
return STATUS_ERROR;
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Command line: %s\n"), cmd_line);
efree(cmd_line);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetCmdline(int argc, char* argv[])
bool cbDebugSetCmdline(int argc, char* argv[])
{
cmdline_error_t cmdline_error = { (cmdline_error_type_t)0, 0 };
if(argc != 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error: write the arg1 with the new command line of the process debugged"));
return STATUS_ERROR;
return false;
}
if(!dbgsetcmdline(argv[1], &cmdline_error))
{
showcommandlineerror(&cmdline_error);
return STATUS_ERROR;
return false;
}
//update the memory map
@ -556,13 +556,13 @@ CMDRESULT cbDebugSetCmdline(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "New command line: %s\n"), argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrMnemonichelp(int argc, char* argv[])
bool cbInstrMnemonichelp(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
auto description = MnemonicHelp::getDescription(argv[1]);
if(!description.length())
dputs(QT_TRANSLATE_NOOP("DBG", "no description or empty description"));
@ -572,13 +572,13 @@ CMDRESULT cbInstrMnemonichelp(int argc, char* argv[])
auto logText = StringUtils::sprintf("%s%s%s\n", padding, description.c_str(), padding);
GuiAddLogMessage(logText.c_str());
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrMnemonicbrief(int argc, char* argv[])
bool cbInstrMnemonicbrief(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
dputs(MnemonicHelp::getBriefDescription(argv[1]).c_str());
return STATUS_CONTINUE;
return true;
}

28
src/dbg/commands/cmd-misc.h
View File

@ -2,21 +2,21 @@
#include "command.h"
CMDRESULT cbInstrChd(int argc, char* argv[]);
CMDRESULT cbInstrZzz(int argc, char* argv[]);
bool cbInstrChd(int argc, char* argv[]);
bool cbInstrZzz(int argc, char* argv[]);
CMDRESULT cbDebugHide(int argc, char* argv[]);
CMDRESULT cbDebugLoadLib(int argc, char* argv[]);
CMDRESULT cbInstrAssemble(int argc, char* argv[]);
CMDRESULT cbInstrGpa(int argc, char* argv[]);
bool cbDebugHide(int argc, char* argv[]);
bool cbDebugLoadLib(int argc, char* argv[]);
bool cbInstrAssemble(int argc, char* argv[]);
bool cbInstrGpa(int argc, char* argv[]);
CMDRESULT cbDebugSetJIT(int argc, char* argv[]);
CMDRESULT cbDebugGetJIT(int argc, char* argv[]);
CMDRESULT cbDebugGetJITAuto(int argc, char* argv[]);
CMDRESULT cbDebugSetJITAuto(int argc, char* argv[]);
bool cbDebugSetJIT(int argc, char* argv[]);
bool cbDebugGetJIT(int argc, char* argv[]);
bool cbDebugGetJITAuto(int argc, char* argv[]);
bool cbDebugSetJITAuto(int argc, char* argv[]);
CMDRESULT cbDebugGetCmdline(int argc, char* argv[]);
CMDRESULT cbDebugSetCmdline(int argc, char* argv[]);
bool cbDebugGetCmdline(int argc, char* argv[]);
bool cbDebugSetCmdline(int argc, char* argv[]);
CMDRESULT cbInstrMnemonichelp(int argc, char* argv[]);
CMDRESULT cbInstrMnemonicbrief(int argc, char* argv[]);
bool cbInstrMnemonichelp(int argc, char* argv[]);
bool cbInstrMnemonicbrief(int argc, char* argv[]);

43
src/dbg/commands/cmd-operating-system-control.cpp
View File

@ -4,16 +4,16 @@
#include "exception.h"
#include "value.h"
CMDRESULT cbGetPrivilegeState(int argc, char* argv[])
bool cbGetPrivilegeState(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
DWORD returnLength;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
varset("$result", (duint)0, false);
return STATUS_CONTINUE;
return true;
}
Memory <TOKEN_PRIVILEGES*> Privileges(64 * 16 + 8, "_dbg_getprivilegestate");
if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), 64 * 16 + 8, &returnLength) == 0)
@ -21,78 +21,77 @@ CMDRESULT cbGetPrivilegeState(int argc, char* argv[])
if(returnLength > 4 * 1024 * 1024)
{
varset("$result", (duint)0, false);
return STATUS_CONTINUE;
return true;
}
Privileges.realloc(returnLength, "_dbg_getprivilegestate");
if(GetTokenInformation(hProcessToken, TokenPrivileges, Privileges(), returnLength, &returnLength) == 0)
return STATUS_ERROR;
return false;
}
for(unsigned int i = 0; i < Privileges()->PrivilegeCount; i++)
{
if(4 + sizeof(LUID_AND_ATTRIBUTES) * i > returnLength)
return STATUS_ERROR;
return false;
if(memcmp(&Privileges()->Privileges[i].Luid, &luid, sizeof(LUID)) == 0)
{
varset("$result", (duint)(Privileges()->Privileges[i].Attributes + 1), false); // 2=enabled, 3=default, 1=disabled
return STATUS_CONTINUE;
return true;
}
}
varset("$result", (duint)0, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbEnablePrivilege(int argc, char* argv[])
bool cbEnablePrivilege(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
TOKEN_PRIVILEGES Privilege;
Privilege.PrivilegeCount = 1;
Privilege.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
Privilege.Privileges[0].Luid = luid;
bool ret = AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR;
return ret ? STATUS_CONTINUE : STATUS_ERROR;
return AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR;
}
CMDRESULT cbDisablePrivilege(int argc, char* argv[])
bool cbDisablePrivilege(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
LUID luid;
if(LookupPrivilegeValueW(nullptr, StringUtils::Utf8ToUtf16(argv[1]).c_str(), &luid) == 0)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Could not find the specified privilege: %s\n"), argv[1]);
return STATUS_ERROR;
return false;
}
TOKEN_PRIVILEGES Privilege;
Privilege.PrivilegeCount = 1;
Privilege.Privileges[0].Attributes = 0;
Privilege.Privileges[0].Luid = luid;
bool ret = AdjustTokenPrivileges(hProcessToken, FALSE, &Privilege, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr) != NO_ERROR;
return ret ? STATUS_CONTINUE : STATUS_ERROR;
return ret ? true : false;
}
CMDRESULT cbHandleClose(int argc, char* argv[])
bool cbHandleClose(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint handle;
if(!valfromstring(argv[1], &handle, false))
return STATUS_ERROR;
return false;
if(!handle || !DuplicateHandle(fdProcessInfo->hProcess, HANDLE(handle), NULL, NULL, 0, FALSE, DUPLICATE_CLOSE_SOURCE))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "DuplicateHandle failed: %s\n"), ErrorCodeToName(GetLastError()).c_str());
return STATUS_ERROR;
return false;
}
#ifdef _WIN64
dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %llX closed!\n"), handle);
#else //x86
dprintf(QT_TRANSLATE_NOOP("DBG", "Handle %X closed!\n"), handle);
#endif
return STATUS_CONTINUE;
return true;
}

8
src/dbg/commands/cmd-operating-system-control.h
View File

@ -2,7 +2,7 @@
#include "command.h"
CMDRESULT cbGetPrivilegeState(int argc, char* argv[]);
CMDRESULT cbEnablePrivilege(int argc, char* argv[]);
CMDRESULT cbDisablePrivilege(int argc, char* argv[]);
CMDRESULT cbHandleClose(int argc, char* argv[]);
bool cbGetPrivilegeState(int argc, char* argv[]);
bool cbEnablePrivilege(int argc, char* argv[]);
bool cbDisablePrivilege(int argc, char* argv[]);
bool cbHandleClose(int argc, char* argv[]);

22
src/dbg/commands/cmd-plugins.cpp
View File

@ -33,32 +33,32 @@ static DWORD WINAPI scyllaThread(void* lpParam)
return 0;
}
CMDRESULT cbDebugStartScylla(int argc, char* argv[])
bool cbDebugStartScylla(int argc, char* argv[])
{
if(bScyllaLoaded)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Scylla is already loaded"));
return STATUS_ERROR;
return false;
}
bScyllaLoaded = true;
CloseHandle(CreateThread(0, 0, scyllaThread, 0, 0, 0));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrPluginLoad(int argc, char* argv[])
bool cbInstrPluginLoad(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(pluginload(argv[1]))
return STATUS_CONTINUE;
return STATUS_ERROR;
return true;
return false;
}
CMDRESULT cbInstrPluginUnload(int argc, char* argv[])
bool cbInstrPluginUnload(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(pluginunload(argv[1]))
return STATUS_CONTINUE;
return STATUS_ERROR;
return true;
return false;
}

6
src/dbg/commands/cmd-plugins.h
View File

@ -2,6 +2,6 @@
#include "command.h"
CMDRESULT cbDebugStartScylla(int argc, char* argv[]);
CMDRESULT cbInstrPluginLoad(int argc, char* argv[]);
CMDRESULT cbInstrPluginUnload(int argc, char* argv[]);
bool cbDebugStartScylla(int argc, char* argv[]);
bool cbInstrPluginLoad(int argc, char* argv[]);
bool cbInstrPluginUnload(int argc, char* argv[]);

24
src/dbg/commands/cmd-script.cpp
View File

@ -4,42 +4,42 @@
#include "variable.h"
#include "simplescript.h"
CMDRESULT cbScriptLoad(int argc, char* argv[])
bool cbScriptLoad(int argc, char* argv[])
{
if(argc < 2)
return STATUS_ERROR;
return false;
scriptload(argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbScriptMsg(int argc, char* argv[])
bool cbScriptMsg(int argc, char* argv[])
{
if(argc < 2)
{
dputs(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "not enough arguments!")));
return STATUS_ERROR;
return false;
}
GuiScriptMessage(stringformatinline(argv[1]).c_str());
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbScriptMsgyn(int argc, char* argv[])
bool cbScriptMsgyn(int argc, char* argv[])
{
if(argc < 2)
{
dputs(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "not enough arguments!")));
return STATUS_ERROR;
return false;
}
varset("$RESULT", GuiScriptMsgyn(stringformatinline(argv[1]).c_str()), false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLog(int argc, char* argv[])
bool cbInstrLog(int argc, char* argv[])
{
if(argc == 1) //just log newline
{
dputs_untranslated("");
return STATUS_CONTINUE;
return true;
}
if(argc == 2) //inline logging: log "format {rax}"
{
@ -52,5 +52,5 @@ CMDRESULT cbInstrLog(int argc, char* argv[])
formatArgs.push_back(argv[i]);
dputs_untranslated(stringformat(argv[1], formatArgs).c_str());
}
return STATUS_CONTINUE;
return true;
}

8
src/dbg/commands/cmd-script.h
View File

@ -2,7 +2,7 @@
#include "command.h"
CMDRESULT cbScriptLoad(int argc, char* argv[]);
CMDRESULT cbScriptMsg(int argc, char* argv[]);
CMDRESULT cbScriptMsgyn(int argc, char* argv[]);
CMDRESULT cbInstrLog(int argc, char* argv[]);
bool cbScriptLoad(int argc, char* argv[]);
bool cbScriptMsg(int argc, char* argv[]);
bool cbScriptMsgyn(int argc, char* argv[]);
bool cbInstrLog(int argc, char* argv[]);

102
src/dbg/commands/cmd-searching.cpp
View File

@ -11,13 +11,13 @@
static int maxFindResults = 5000;
CMDRESULT cbInstrFind(int argc, char* argv[])
bool cbInstrFind(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
char pattern[deflen] = "";
//remove # from the start and end of the pattern (ODBGScript support)
if(argv[2][0] == '#')
@ -32,13 +32,13 @@ CMDRESULT cbInstrFind(int argc, char* argv[])
if(!base)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid memory address %p!\n"), addr);
return STATUS_ERROR;
return false;
}
Memory<unsigned char*> data(size, "cbInstrFind:data");
if(!MemRead(base, data(), size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to read memory!"));
return STATUS_ERROR;
return false;
}
duint start = addr - base;
duint find_size = 0;
@ -56,16 +56,16 @@ CMDRESULT cbInstrFind(int argc, char* argv[])
if(foundoffset != -1)
result = addr + foundoffset;
varset("$result", result, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFindAll(int argc, char* argv[])
bool cbInstrFindAll(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
char pattern[deflen] = "";
//remove # from the start and end of the pattern (ODBGScript support)
@ -81,7 +81,7 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
if(!base)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid memory address %p!\n"), addr);
return STATUS_ERROR;
return false;
}
if(argc >= 4)
{
@ -93,7 +93,7 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
if(!MemRead(base, data(), size))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to read memory!"));
return STATUS_ERROR;
return false;
}
duint start = addr - base;
duint find_size = 0;
@ -133,7 +133,7 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
if(!patterntransform(pattern, searchpattern))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to transform pattern!"));
return STATUS_ERROR;
return false;
}
while(refCount < maxFindResults)
{
@ -169,16 +169,16 @@ CMDRESULT cbInstrFindAll(int argc, char* argv[])
GuiReferenceReloadData();
dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks);
varset("$result", refCount, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFindAllMem(int argc, char* argv[])
bool cbInstrFindAllMem(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
char pattern[deflen] = "";
//remove # from the start and end of the pattern (ODBGScript support)
@ -193,7 +193,7 @@ CMDRESULT cbInstrFindAllMem(int argc, char* argv[])
if(!patterntransform(pattern, searchpattern))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to transform pattern!"));
return STATUS_ERROR;
return false;
}
duint endAddr = -1;
@ -224,7 +224,7 @@ CMDRESULT cbInstrFindAllMem(int argc, char* argv[])
if(!MemFindInMap(searchPages, searchpattern, results, maxFindResults))
{
dputs(QT_TRANSLATE_NOOP("DBG", "MemFindInMap failed!"));
return STATUS_ERROR;
return false;
}
//setup reference view
@ -274,7 +274,7 @@ CMDRESULT cbInstrFindAllMem(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "%d occurrences found in %ums\n"), refCount, GetTickCount() - ticks);
varset("$result", refCount, false);
return STATUS_CONTINUE;
return true;
}
static bool cbFindAsm(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
@ -305,10 +305,10 @@ static bool cbFindAsm(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFIN
return found;
}
CMDRESULT cbInstrFindAsm(int argc, char* argv[])
bool cbInstrFindAsm(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(argc < 3 || !valfromstring(argv[2], &addr))
@ -329,7 +329,7 @@ CMDRESULT cbInstrFindAsm(int argc, char* argv[])
if(!assemble(addr + size / 2, dest, &asmsize, argv[1], error))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to assemble \"%s\" (%s)!\n"), argv[1], error);
return STATUS_ERROR;
return false;
}
BASIC_INSTRUCTION_INFO basicinfo;
memset(&basicinfo, 0, sizeof(BASIC_INSTRUCTION_INFO));
@ -341,13 +341,13 @@ CMDRESULT cbInstrFindAsm(int argc, char* argv[])
int found = RefFind(addr, size, cbFindAsm, (void*)&basicinfo.instruction[0], false, title, (REFFINDTYPE)refFindType, true);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u result(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrRefFind(int argc, char* argv[])
bool cbInstrRefFind(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
std::string newCommand = std::string("reffindrange ") + argv[1] + std::string(",") + argv[1];
if(argc > 2)
newCommand += std::string(",") + argv[2];
@ -412,13 +412,13 @@ static bool cbRefFind(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFIN
return found;
}
CMDRESULT cbInstrRefFindRange(int argc, char* argv[])
bool cbInstrRefFindRange(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
VALUERANGE range;
if(!valfromstring(argv[1], &range.start, false))
return STATUS_ERROR;
return false;
if(argc < 3 || !valfromstring(argv[2], &range.end, false))
range.end = range.start;
duint addr = 0;
@ -443,7 +443,7 @@ CMDRESULT cbInstrRefFindRange(int argc, char* argv[])
int found = RefFind(addr, size, cbRefFind, &range, false, title, (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u reference(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return STATUS_CONTINUE;
return true;
}
static bool cbRefStr(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
@ -489,7 +489,7 @@ static bool cbRefStr(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINF
return found;
}
CMDRESULT cbInstrRefStr(int argc, char* argv[])
bool cbInstrRefStr(int argc, char* argv[])
{
duint ticks = GetTickCount();
duint addr;
@ -512,7 +512,7 @@ CMDRESULT cbInstrRefStr(int argc, char* argv[])
int found = RefFind(addr, size, cbRefStr, 0, false, TranslatedString.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u string(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return STATUS_CONTINUE;
return true;
}
static bool cbModCallFind(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFINFO* refinfo)
@ -558,7 +558,7 @@ static bool cbModCallFind(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, R
return found;
}
CMDRESULT cbInstrModCallFind(int argc, char* argv[])
bool cbInstrModCallFind(int argc, char* argv[])
{
duint addr;
if(argc < 2 || !valfromstring(argv[1], &addr, true))
@ -578,7 +578,7 @@ CMDRESULT cbInstrModCallFind(int argc, char* argv[])
int found = RefFind(addr, size, cbModCallFind, 0, false, Calls.c_str(), (REFFINDTYPE)refFindType, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%u call(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
return STATUS_CONTINUE;
return true;
}
struct GUIDHashObject
@ -762,7 +762,7 @@ static bool cbGUIDFind(Capstone* disasm, BASIC_INSTRUCTION_INFO* basicinfo, REFI
return found;
}
CMDRESULT cbInstrGUIDFind(int argc, char* argv[])
bool cbInstrGUIDFind(int argc, char* argv[])
{
duint ticks = GetTickCount();
duint addr;
@ -788,7 +788,7 @@ CMDRESULT cbInstrGUIDFind(int argc, char* argv[])
if(RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID", 0, KEY_READ, &CLSID))
{
dputs(QT_TRANSLATE_NOOP("DBG", "RegOpenKeyExW() failed. Cannot enumerate GUIDs."));
return STATUS_ERROR;
return false;
}
wchar_t subkeyName[40];
@ -820,7 +820,7 @@ CMDRESULT cbInstrGUIDFind(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "%u GUID(s) in %ums\n"), DWORD(found), GetTickCount() - DWORD(ticks));
varset("$result", found, false);
RegCloseKey(CLSID);
return STATUS_CONTINUE;
return true;
}
static void yaraCompilerCallback(int error_level, const char* file_name, int line_number, const char* message, void* user_data)
@ -976,10 +976,10 @@ static int yaraScanCallback(int message, void* message_data, void* user_data)
return ERROR_SUCCESS; //nicely undocumented what this should be
}
CMDRESULT cbInstrYara(int argc, char* argv[])
bool cbInstrYara(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
SELECTIONDATA sel;
GuiSelectionGet(GUI_DISASSEMBLY, &sel);
@ -1000,7 +1000,7 @@ CMDRESULT cbInstrYara(int argc, char* argv[])
if(!valfromstring(argv[2], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid value \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
size = 0;
@ -1018,12 +1018,12 @@ CMDRESULT cbInstrYara(int argc, char* argv[])
if(!ModPathFromAddr(base, modPath, MAX_PATH))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to get module path for %p!\n"), base);
return STATUS_ERROR;
return false;
}
if(!FileHelper::ReadAllData(modPath, rawFileData))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to read file \"%s\"!\n"), modPath);
return STATUS_ERROR;
return false;
}
size = rawFileData.size();
}
@ -1033,14 +1033,14 @@ CMDRESULT cbInstrYara(int argc, char* argv[])
else if(!MemRead(base, data(), size))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to read memory page %p[%X]!\n"), base, DWORD(size));
return STATUS_ERROR;
return false;
}
String rulesContent;
if(!FileHelper::ReadAllText(argv[1], rulesContent))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to read the rules file \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
bool bSuccess = false;
@ -1101,31 +1101,31 @@ CMDRESULT cbInstrYara(int argc, char* argv[])
}
else
dputs(QT_TRANSLATE_NOOP("DBG", "yr_compiler_create failed!"));
return bSuccess ? STATUS_CONTINUE : STATUS_ERROR;
return bSuccess;
}
CMDRESULT cbInstrYaramod(int argc, char* argv[])
bool cbInstrYaramod(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
if(!ModBaseFromName(argv[2]))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid module \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
return cmddirectexec(StringUtils::sprintf("yara \"%s\",\"%s\",%s", argv[1], argv[2], argc > 3 && *argv[3] == '1' ? "1" : "0").c_str());
}
CMDRESULT cbInstrSetMaxFindResult(int argc, char* argv[])
bool cbInstrSetMaxFindResult(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint num;
if(!valfromstring(argv[1], &num))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression: \"%s\""), argv[1]);
return STATUS_ERROR;
return false;
}
maxFindResults = int(num & 0x7FFFFFFF);
return STATUS_CONTINUE;
return true;
}

24
src/dbg/commands/cmd-searching.h
View File

@ -2,15 +2,15 @@
#include "command.h"
CMDRESULT cbInstrFind(int argc, char* argv[]);
CMDRESULT cbInstrFindAll(int argc, char* argv[]);
CMDRESULT cbInstrFindAllMem(int argc, char* argv[]);
CMDRESULT cbInstrFindAsm(int argc, char* argv[]);
CMDRESULT cbInstrRefFind(int argc, char* argv[]);
CMDRESULT cbInstrRefFindRange(int argc, char* argv[]);
CMDRESULT cbInstrRefStr(int argc, char* argv[]);
CMDRESULT cbInstrModCallFind(int argc, char* argv[]);
CMDRESULT cbInstrGUIDFind(int argc, char* argv[]);
CMDRESULT cbInstrYara(int argc, char* argv[]);
CMDRESULT cbInstrYaramod(int argc, char* argv[]);
CMDRESULT cbInstrSetMaxFindResult(int argc, char* argv[]);
bool cbInstrFind(int argc, char* argv[]);
bool cbInstrFindAll(int argc, char* argv[]);
bool cbInstrFindAllMem(int argc, char* argv[]);
bool cbInstrFindAsm(int argc, char* argv[]);
bool cbInstrRefFind(int argc, char* argv[]);
bool cbInstrRefFindRange(int argc, char* argv[]);
bool cbInstrRefStr(int argc, char* argv[]);
bool cbInstrModCallFind(int argc, char* argv[]);
bool cbInstrGUIDFind(int argc, char* argv[]);
bool cbInstrYara(int argc, char* argv[]);
bool cbInstrYaramod(int argc, char* argv[]);
bool cbInstrSetMaxFindResult(int argc, char* argv[]);

90
src/dbg/commands/cmd-thread-control.cpp
View File

@ -8,26 +8,26 @@
#include "historycontext.h"
#include "thread.h"
CMDRESULT cbDebugCreatethread(int argc, char* argv[])
bool cbDebugCreatethread(int argc, char* argv[])
{
if(argc < 2)
return STATUS_ERROR;
return false;
duint Entry = 0;
duint Argument = 0;
if(!valfromstring(argv[1], &Entry))
return STATUS_ERROR;
return false;
if(!MemIsCodePage(Entry, false))
return STATUS_ERROR;
return false;
if(argc > 2)
{
if(!valfromstring(argv[2], &Argument))
return STATUS_ERROR;
return false;
}
DWORD ThreadId = 0;
if(ThreaderCreateRemoteThread(Entry, true, reinterpret_cast<LPVOID>(Argument), &ThreadId) != 0)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Create thread failed!"));
return STATUS_ERROR;
return false;
}
else
{
@ -40,20 +40,20 @@ CMDRESULT cbDebugCreatethread(int argc, char* argv[])
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread %X created at %s %p(Argument=%X)\n"), ThreadId, label, Entry, Argument);
#endif
varset("$result", ThreadId, false);
return STATUS_CONTINUE;
return true;
}
}
CMDRESULT cbDebugSwitchthread(int argc, char* argv[])
bool cbDebugSwitchthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId; //main thread
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
//switch thread
if(ThreadGetId(hActiveThread) != threadid)
@ -63,105 +63,105 @@ CMDRESULT cbDebugSwitchthread(int argc, char* argv[])
DebugUpdateGuiAsync(GetContextDataEx(hActiveThread, UE_CIP), true);
dputs(QT_TRANSLATE_NOOP("DBG", "Thread switched!"));
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSuspendthread(int argc, char* argv[])
bool cbDebugSuspendthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
//suspend thread
if(SuspendThread(ThreadGetHandle((DWORD)threadid)) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error suspending thread"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread suspended"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugResumethread(int argc, char* argv[])
bool cbDebugResumethread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
//resume thread
if(ResumeThread(ThreadGetHandle((DWORD)threadid)) == -1)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error resuming thread"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread resumed!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugKillthread(int argc, char* argv[])
bool cbDebugKillthread(int argc, char* argv[])
{
duint threadid = fdProcessInfo->dwThreadId;
if(argc > 1)
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
duint exitcode = 0;
if(argc > 2)
if(!valfromstring(argv[2], &exitcode, false))
return STATUS_ERROR;
return false;
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
//terminate thread
if(TerminateThread(ThreadGetHandle((DWORD)threadid), (DWORD)exitcode) != 0)
{
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "Thread terminated"));
return STATUS_CONTINUE;
return true;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Error terminating thread!"));
return STATUS_ERROR;
return false;
}
CMDRESULT cbDebugSuspendAllThreads(int argc, char* argv[])
bool cbDebugSuspendAllThreads(int argc, char* argv[])
{
dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) suspended\n"), ThreadSuspendAll(), ThreadGetCount());
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugResumeAllThreads(int argc, char* argv[])
bool cbDebugResumeAllThreads(int argc, char* argv[])
{
dprintf(QT_TRANSLATE_NOOP("DBG", "%d/%d thread(s) resumed\n"), ThreadResumeAll(), ThreadGetCount());
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetPriority(int argc, char* argv[])
bool cbDebugSetPriority(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint threadid;
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
duint priority;
if(!valfromstring(argv[2], &priority))
{
@ -182,7 +182,7 @@ CMDRESULT cbDebugSetPriority(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!"));
return STATUS_ERROR;
return false;
}
}
else
@ -199,51 +199,51 @@ CMDRESULT cbDebugSetPriority(int argc, char* argv[])
break;
default:
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown priority value, read the help!"));
return STATUS_ERROR;
return false;
}
}
if(!ThreadIsValid((DWORD)threadid)) //check if the thread is valid
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
//set thread priority
if(SetThreadPriority(ThreadGetHandle((DWORD)threadid), (int)priority) == 0)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error setting thread priority"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "Thread priority changed!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugSetthreadname(int argc, char* argv[])
bool cbDebugSetthreadname(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments!"));
return STATUS_ERROR;
return false;
}
duint threadid;
if(!valfromstring(argv[1], &threadid, false))
return STATUS_ERROR;
return false;
THREADINFO info;
if(!ThreadGetInfo(DWORD(threadid), info))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
auto newname = argc > 2 ? argv[2] : "";
if(!ThreadSetName(DWORD(threadid), newname))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Failed to change the name for thread %X\n"), DWORD(threadid));
return STATUS_ERROR;
return false;
}
if(!*info.threadName)
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name set to \"%s\"!\n"), newname);
else
dprintf(QT_TRANSLATE_NOOP("DBG", "Thread name changed from \"%s\" to \"%s\"!\n"), info.threadName, newname);
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}

18
src/dbg/commands/cmd-thread-control.h
View File

@ -2,12 +2,12 @@
#include "command.h"
CMDRESULT cbDebugCreatethread(int argc, char* argv[]);
CMDRESULT cbDebugSwitchthread(int argc, char* argv[]);
CMDRESULT cbDebugSuspendthread(int argc, char* argv[]);
CMDRESULT cbDebugResumethread(int argc, char* argv[]);
CMDRESULT cbDebugKillthread(int argc, char* argv[]);
CMDRESULT cbDebugSuspendAllThreads(int argc, char* argv[]);
CMDRESULT cbDebugResumeAllThreads(int argc, char* argv[]);
CMDRESULT cbDebugSetPriority(int argc, char* argv[]);
CMDRESULT cbDebugSetthreadname(int argc, char* argv[]);
bool cbDebugCreatethread(int argc, char* argv[]);
bool cbDebugSwitchthread(int argc, char* argv[]);
bool cbDebugSuspendthread(int argc, char* argv[]);
bool cbDebugResumethread(int argc, char* argv[]);
bool cbDebugKillthread(int argc, char* argv[]);
bool cbDebugSuspendAllThreads(int argc, char* argv[]);
bool cbDebugResumeAllThreads(int argc, char* argv[]);
bool cbDebugSetPriority(int argc, char* argv[]);
bool cbDebugSetthreadname(int argc, char* argv[]);

28
src/dbg/commands/cmd-tracing.cpp
View File

@ -9,25 +9,25 @@
extern std::vector<std::pair<duint, duint>> RunToUserCodeBreakpoints;
static CMDRESULT cbDebugConditionalTrace(void* callBack, bool stepOver, int argc, char* argv[])
static bool cbDebugConditionalTrace(void* callBack, bool stepOver, int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Not enough arguments"));
return STATUS_ERROR;
return false;
}
if(dbgtraceactive())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Trace already active"));
return STATUS_ERROR;
return false;
}
duint maxCount = 50000;
if(argc > 2 && !valfromstring(argv[2], &maxCount, false))
return STATUS_ERROR;
return false;
if(!dbgsettracecondition(argv[1], maxCount))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Invalid expression \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
HistoryClear();
if(stepOver)
@ -37,17 +37,17 @@ static CMDRESULT cbDebugConditionalTrace(void* callBack, bool stepOver, int argc
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugTraceIntoConditional(int argc, char* argv[])
bool cbDebugTraceIntoConditional(int argc, char* argv[])
{
return cbDebugConditionalTrace((void*)cbTICNDStep, false, argc, argv);
}
CMDRESULT cbDebugTraceOverConditional(int argc, char* argv[])
bool cbDebugTraceOverConditional(int argc, char* argv[])
{
return cbDebugConditionalTrace((void*)cbTOCNDStep, true, argc, argv);
}
CMDRESULT cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[])
bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
@ -58,7 +58,7 @@ CMDRESULT cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[])
return cbDebugConditionalTrace((void*)cbTIBTStep, false, argc, argv);
}
CMDRESULT cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[])
bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
@ -69,7 +69,7 @@ CMDRESULT cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[])
return cbDebugConditionalTrace((void*)cbTOBTStep, true, argc, argv);
}
CMDRESULT cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[])
bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
@ -80,7 +80,7 @@ CMDRESULT cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[])
return cbDebugConditionalTrace((void*)cbTIITStep, false, argc, argv);
}
CMDRESULT cbDebugTraceOverIntoTraceRecord(int argc, char* argv[])
bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[])
{
if(argc == 1)
{
@ -91,7 +91,7 @@ CMDRESULT cbDebugTraceOverIntoTraceRecord(int argc, char* argv[])
return cbDebugConditionalTrace((void*)cbTOITStep, true, argc, argv);
}
CMDRESULT cbDebugRunToParty(int argc, char* argv[])
bool cbDebugRunToParty(int argc, char* argv[])
{
HistoryClear();
EXCLUSIVE_ACQUIRE(LockRunToUserCode);
@ -100,7 +100,7 @@ CMDRESULT cbDebugRunToParty(int argc, char* argv[])
if(!RunToUserCodeBreakpoints.empty())
{
dputs(QT_TRANSLATE_NOOP("DBG", "Run to party is busy.\n"));
return STATUS_ERROR;
return false;
}
int party = atoi(argv[1]); // party is a signed integer
for(auto i : AllModules)
@ -121,7 +121,7 @@ CMDRESULT cbDebugRunToParty(int argc, char* argv[])
return cbDebugRunInternal(argc, argv);
}
CMDRESULT cbDebugRunToUserCode(int argc, char* argv[])
bool cbDebugRunToUserCode(int argc, char* argv[])
{
char* newargv[] = { "RunToParty", "0" };
return cbDebugRunToParty(argc, newargv);

16
src/dbg/commands/cmd-tracing.h
View File

@ -2,11 +2,11 @@
#include "command.h"
CMDRESULT cbDebugTraceIntoConditional(int argc, char* argv[]);
CMDRESULT cbDebugTraceOverConditional(int argc, char* argv[]);
CMDRESULT cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[]);
CMDRESULT cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[]);
CMDRESULT cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[]);
CMDRESULT cbDebugTraceOverIntoTraceRecord(int argc, char* argv[]);
CMDRESULT cbDebugRunToParty(int argc, char* argv[]);
CMDRESULT cbDebugRunToUserCode(int argc, char* argv[]);
bool cbDebugTraceIntoConditional(int argc, char* argv[]);
bool cbDebugTraceOverConditional(int argc, char* argv[]);
bool cbDebugTraceIntoBeyondTraceRecord(int argc, char* argv[]);
bool cbDebugTraceOverBeyondTraceRecord(int argc, char* argv[]);
bool cbDebugTraceIntoIntoTraceRecord(int argc, char* argv[]);
bool cbDebugTraceOverIntoTraceRecord(int argc, char* argv[]);
bool cbDebugRunToParty(int argc, char* argv[]);
bool cbDebugRunToUserCode(int argc, char* argv[]);

162
src/dbg/commands/cmd-types.cpp
View File

@ -8,170 +8,170 @@
using namespace Types;
static CMDRESULT cbInstrDataGeneric(ENCODETYPE type, int argc, char* argv[])
static bool cbInstrDataGeneric(ENCODETYPE type, int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
duint size = 1;
if(argc >= 3)
if(!valfromstring(argv[2], &size, false))
return STATUS_ERROR;
return false;
bool created;
if(!EncodeMapSetType(addr, size, type, &created))
{
dputs(QT_TRANSLATE_NOOP("DBG", "EncodeMapSetType failed..."));
return STATUS_ERROR;
return false;
}
if(created)
DbgCmdExec("disasm dis.sel()");
else
GuiUpdateDisassemblyView();
return STATUS_ERROR;
return false;
}
CMDRESULT cbInstrDataUnknown(int argc, char* argv[])
bool cbInstrDataUnknown(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_unknown, argc, argv);
}
CMDRESULT cbInstrDataByte(int argc, char* argv[])
bool cbInstrDataByte(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_byte, argc, argv);
}
CMDRESULT cbInstrDataWord(int argc, char* argv[])
bool cbInstrDataWord(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_word, argc, argv);
}
CMDRESULT cbInstrDataDword(int argc, char* argv[])
bool cbInstrDataDword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_dword, argc, argv);
}
CMDRESULT cbInstrDataFword(int argc, char* argv[])
bool cbInstrDataFword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_fword, argc, argv);
}
CMDRESULT cbInstrDataQword(int argc, char* argv[])
bool cbInstrDataQword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_qword, argc, argv);
}
CMDRESULT cbInstrDataTbyte(int argc, char* argv[])
bool cbInstrDataTbyte(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_tbyte, argc, argv);
}
CMDRESULT cbInstrDataOword(int argc, char* argv[])
bool cbInstrDataOword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_oword, argc, argv);
}
CMDRESULT cbInstrDataMmword(int argc, char* argv[])
bool cbInstrDataMmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_mmword, argc, argv);
}
CMDRESULT cbInstrDataXmmword(int argc, char* argv[])
bool cbInstrDataXmmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_xmmword, argc, argv);
}
CMDRESULT cbInstrDataYmmword(int argc, char* argv[])
bool cbInstrDataYmmword(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_ymmword, argc, argv);
}
CMDRESULT cbInstrDataFloat(int argc, char* argv[])
bool cbInstrDataFloat(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real4, argc, argv);
}
CMDRESULT cbInstrDataDouble(int argc, char* argv[])
bool cbInstrDataDouble(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real8, argc, argv);
}
CMDRESULT cbInstrDataLongdouble(int argc, char* argv[])
bool cbInstrDataLongdouble(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_real10, argc, argv);
}
CMDRESULT cbInstrDataAscii(int argc, char* argv[])
bool cbInstrDataAscii(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_ascii, argc, argv);
}
CMDRESULT cbInstrDataUnicode(int argc, char* argv[])
bool cbInstrDataUnicode(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_unicode, argc, argv);
}
CMDRESULT cbInstrDataCode(int argc, char* argv[])
bool cbInstrDataCode(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_code, argc, argv);
}
CMDRESULT cbInstrDataJunk(int argc, char* argv[])
bool cbInstrDataJunk(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_junk, argc, argv);
}
CMDRESULT cbInstrDataMiddle(int argc, char* argv[])
bool cbInstrDataMiddle(int argc, char* argv[])
{
return cbInstrDataGeneric(enc_middle, argc, argv);
}
#define towner "cmd"
CMDRESULT cbInstrAddType(int argc, char* argv[])
bool cbInstrAddType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
if(!AddType(towner, argv[1], argv[2]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddType failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("typedef %s %s;\n", argv[2], argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddStruct(int argc, char* argv[])
bool cbInstrAddStruct(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(!AddStruct(towner, argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddStruct failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("struct %s;\n", argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddUnion(int argc, char* argv[])
bool cbInstrAddUnion(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(!AddUnion(towner, argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddUnion failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("union %s;\n", argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddMember(int argc, char* argv[])
bool cbInstrAddMember(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return STATUS_ERROR;
return false;
auto parent = argv[1];
auto type = argv[2];
auto name = argv[3];
@ -180,19 +180,19 @@ CMDRESULT cbInstrAddMember(int argc, char* argv[])
{
duint value;
if(!valfromstring(argv[4], &value, false))
return STATUS_ERROR;
return false;
arrsize = int(value);
if(argc > 4)
{
if(!valfromstring(argv[5], &value, false))
return STATUS_ERROR;
return false;
offset = int(value);
}
}
if(!AddMember(parent, type, name, arrsize, offset))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddMember failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s: %s %s", parent, type, name);
if(arrsize > 0)
@ -200,13 +200,13 @@ CMDRESULT cbInstrAddMember(int argc, char* argv[])
if(offset >= 0)
dprintf_untranslated(" (offset: %d)", offset);
dputs_untranslated(";");
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAppendMember(int argc, char* argv[])
bool cbInstrAppendMember(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
auto type = argv[1];
auto name = argv[2];
int arrsize = 0, offset = -1;
@ -214,19 +214,19 @@ CMDRESULT cbInstrAppendMember(int argc, char* argv[])
{
duint value;
if(!valfromstring(argv[3], &value, false))
return STATUS_ERROR;
return false;
arrsize = int(value);
if(argc > 4)
{
if(!valfromstring(argv[4], &value, false))
return STATUS_ERROR;
return false;
offset = int(value);
}
}
if(!AppendMember(type, name, arrsize, offset))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AppendMember failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s %s", type, name);
if(arrsize > 0)
@ -234,13 +234,13 @@ CMDRESULT cbInstrAppendMember(int argc, char* argv[])
if(offset >= 0)
dprintf_untranslated(" (offset: %d)", offset);
dputs_untranslated(";");
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddFunction(int argc, char* argv[])
bool cbInstrAddFunction(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
auto name = argv[1];
auto rettype = argv[2];
auto callconv = Cdecl;
@ -258,65 +258,65 @@ CMDRESULT cbInstrAddFunction(int argc, char* argv[])
else
{
dprintf(QT_TRANSLATE_NOOP("DBG", "Unknown calling convention \"%s\"\n"), argv[3]);
return STATUS_ERROR;
return false;
}
if(argc > 4)
{
duint value;
if(!valfromstring(argv[4], &value, false))
return STATUS_ERROR;
return false;
noreturn = value != 0;
}
}
if(!AddFunction(towner, name, rettype, callconv, noreturn))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddFunction failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s %s();\n", rettype, name);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAddArg(int argc, char* argv[])
bool cbInstrAddArg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 4))
return STATUS_ERROR;
return false;
if(!AddArg(argv[1], argv[2], argv[3]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AddArg failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s: %s %s;\n", argv[1], argv[2], argv[3]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrAppendArg(int argc, char* argv[])
bool cbInstrAppendArg(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
if(!AppendArg(argv[1], argv[2]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "AppendArg failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s %s;\n", argv[1], argv[2]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrSizeofType(int argc, char* argv[])
bool cbInstrSizeofType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
auto size = SizeofType(argv[1]);
if(!size)
{
dputs(QT_TRANSLATE_NOOP("DBG", "SizeofType failed"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("sizeof(%s) = %d\n", argv[1], size);
varset("$result", size, false);
return STATUS_CONTINUE;
return true;
}
struct PrintVisitor : TypeManager::Visitor
@ -528,10 +528,10 @@ private:
int mMaxPtrDepth = 0;
};
CMDRESULT cbInstrVisitType(int argc, char* argv[])
bool cbInstrVisitType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
auto type = argv[1];
auto name = "visit";
duint addr = 0;
@ -539,12 +539,12 @@ CMDRESULT cbInstrVisitType(int argc, char* argv[])
if(argc > 2)
{
if(!valfromstring(argv[2], &addr, false))
return STATUS_ERROR;
return false;
if(argc > 3)
{
duint value;
if(!valfromstring(argv[3], &value, false))
return STATUS_ERROR;
return false;
maxPtrDepth = int(value);
if(argc > 4)
name = argv[4];
@ -554,34 +554,34 @@ CMDRESULT cbInstrVisitType(int argc, char* argv[])
if(!VisitType(type, name, visitor))
{
dputs(QT_TRANSLATE_NOOP("DBG", "VisitType failed"));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrClearTypes(int argc, char* argv[])
bool cbInstrClearTypes(int argc, char* argv[])
{
auto owner = towner;
if(argc > 1)
owner = argv[1];
ClearTypes(owner);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrRemoveType(int argc, char* argv[])
bool cbInstrRemoveType(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(!RemoveType(argv[1]))
{
dputs(QT_TRANSLATE_NOOP("DBG", "RemoveType failed"));
return STATUS_ERROR;
return false;
}
dprintf(QT_TRANSLATE_NOOP("DBG", "Type %s removed\n"), argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrEnumTypes(int argc, char* argv[])
bool cbInstrEnumTypes(int argc, char* argv[])
{
std::vector<TypeManager::Summary> typeList;
EnumTypes(typeList);
@ -591,5 +591,5 @@ CMDRESULT cbInstrEnumTypes(int argc, char* argv[])
type.owner.assign("x64dbg");
dprintf_untranslated("%s: %s %s, sizeof(%s) = %d\n", type.owner.c_str(), type.kind.c_str(), type.name.c_str(), type.name.c_str(), type.size);
}
return STATUS_CONTINUE;
return true;
}

64
src/dbg/commands/cmd-types.h
View File

@ -2,36 +2,36 @@
#include "command.h"
CMDRESULT cbInstrDataUnknown(int argc, char* argv[]);
CMDRESULT cbInstrDataByte(int argc, char* argv[]);
CMDRESULT cbInstrDataWord(int argc, char* argv[]);
CMDRESULT cbInstrDataDword(int argc, char* argv[]);
CMDRESULT cbInstrDataFword(int argc, char* argv[]);
CMDRESULT cbInstrDataQword(int argc, char* argv[]);
CMDRESULT cbInstrDataTbyte(int argc, char* argv[]);
CMDRESULT cbInstrDataOword(int argc, char* argv[]);
CMDRESULT cbInstrDataMmword(int argc, char* argv[]);
CMDRESULT cbInstrDataXmmword(int argc, char* argv[]);
CMDRESULT cbInstrDataYmmword(int argc, char* argv[]);
CMDRESULT cbInstrDataFloat(int argc, char* argv[]);
CMDRESULT cbInstrDataDouble(int argc, char* argv[]);
CMDRESULT cbInstrDataLongdouble(int argc, char* argv[]);
CMDRESULT cbInstrDataAscii(int argc, char* argv[]);
CMDRESULT cbInstrDataUnicode(int argc, char* argv[]);
CMDRESULT cbInstrDataCode(int argc, char* argv[]);
CMDRESULT cbInstrDataJunk(int argc, char* argv[]);
CMDRESULT cbInstrDataMiddle(int argc, char* argv[]);
bool cbInstrDataUnknown(int argc, char* argv[]);
bool cbInstrDataByte(int argc, char* argv[]);
bool cbInstrDataWord(int argc, char* argv[]);
bool cbInstrDataDword(int argc, char* argv[]);
bool cbInstrDataFword(int argc, char* argv[]);
bool cbInstrDataQword(int argc, char* argv[]);
bool cbInstrDataTbyte(int argc, char* argv[]);
bool cbInstrDataOword(int argc, char* argv[]);
bool cbInstrDataMmword(int argc, char* argv[]);
bool cbInstrDataXmmword(int argc, char* argv[]);
bool cbInstrDataYmmword(int argc, char* argv[]);
bool cbInstrDataFloat(int argc, char* argv[]);
bool cbInstrDataDouble(int argc, char* argv[]);
bool cbInstrDataLongdouble(int argc, char* argv[]);
bool cbInstrDataAscii(int argc, char* argv[]);
bool cbInstrDataUnicode(int argc, char* argv[]);
bool cbInstrDataCode(int argc, char* argv[]);
bool cbInstrDataJunk(int argc, char* argv[]);
bool cbInstrDataMiddle(int argc, char* argv[]);
CMDRESULT cbInstrAddType(int argc, char* argv[]);
CMDRESULT cbInstrAddStruct(int argc, char* argv[]);
CMDRESULT cbInstrAddUnion(int argc, char* argv[]);
CMDRESULT cbInstrAddMember(int argc, char* argv[]);
CMDRESULT cbInstrAppendMember(int argc, char* argv[]);
CMDRESULT cbInstrAddFunction(int argc, char* argv[]);
CMDRESULT cbInstrAddArg(int argc, char* argv[]);
CMDRESULT cbInstrAppendArg(int argc, char* argv[]);
CMDRESULT cbInstrSizeofType(int argc, char* argv[]);
CMDRESULT cbInstrVisitType(int argc, char* argv[]);
CMDRESULT cbInstrClearTypes(int argc, char* argv[]);
CMDRESULT cbInstrRemoveType(int argc, char* argv[]);
CMDRESULT cbInstrEnumTypes(int argc, char* argv[]);
bool cbInstrAddType(int argc, char* argv[]);
bool cbInstrAddStruct(int argc, char* argv[]);
bool cbInstrAddUnion(int argc, char* argv[]);
bool cbInstrAddMember(int argc, char* argv[]);
bool cbInstrAppendMember(int argc, char* argv[]);
bool cbInstrAddFunction(int argc, char* argv[]);
bool cbInstrAddArg(int argc, char* argv[]);
bool cbInstrAppendArg(int argc, char* argv[]);
bool cbInstrSizeofType(int argc, char* argv[]);
bool cbInstrVisitType(int argc, char* argv[]);
bool cbInstrClearTypes(int argc, char* argv[]);
bool cbInstrRemoveType(int argc, char* argv[]);
bool cbInstrEnumTypes(int argc, char* argv[]);

102
src/dbg/commands/cmd-undocumented.cpp
View File

@ -12,7 +12,7 @@
#include "value.h"
#include "symbolinfo.h"
CMDRESULT cbBadCmd(int argc, char* argv[])
bool cbBadCmd(int argc, char* argv[])
{
duint value = 0;
int valsize = 0;
@ -90,12 +90,12 @@ CMDRESULT cbBadCmd(int argc, char* argv[])
else //unknown command
{
dprintf(QT_TRANSLATE_NOOP("DBG", "unknown command/expression: \"%s\"\n"), *argv);
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDebugBenchmark(int argc, char* argv[])
bool cbDebugBenchmark(int argc, char* argv[])
{
duint addr = MemFindBaseAddr(GetContextDataEx(hActiveThread, UE_CIP), 0);
DWORD ticks = GetTickCount();
@ -107,104 +107,104 @@ CMDRESULT cbDebugBenchmark(int argc, char* argv[])
FunctionAdd(i, i, false);
}
dprintf(QT_TRANSLATE_NOOP("DBG", "%ums\n"), GetTickCount() - ticks);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrSetstr(int argc, char* argv[])
bool cbInstrSetstr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
varnew(argv[1], 0, VAR_USER);
if(!vargettype(argv[1], 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "no such variable \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!varset(argv[1], argv[2], false))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to set variable \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
cmddirectexec(StringUtils::sprintf("getstr \"%s\"", argv[1]).c_str());
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrGetstr(int argc, char* argv[])
bool cbInstrGetstr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
VAR_VALUE_TYPE valtype;
if(!vargettype(argv[1], 0, &valtype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "no such variable \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(valtype != VAR_STRING)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "variable \"%s\" is not a string!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
int size;
if(!varget(argv[1], (char*)0, &size, 0) || !size)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to get variable size \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
Memory<char*> string(size + 1, "cbInstrGetstr:string");
if(!varget(argv[1], string(), &size, 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to get variable data \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
dprintf_untranslated("%s=\"%s\"\n", argv[1], string());
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCopystr(int argc, char* argv[])
bool cbInstrCopystr(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
VAR_VALUE_TYPE valtype;
if(!vargettype(argv[2], 0, &valtype))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "no such variable \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
if(valtype != VAR_STRING)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "variable \"%s\" is not a string!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
int size;
if(!varget(argv[2], (char*)0, &size, 0) || !size)
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to get variable size \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
Memory<char*> string(size + 1, "cbInstrGetstr:string");
if(!varget(argv[2], string(), &size, 0))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "failed to get variable data \"%s\"!\n"), argv[2]);
return STATUS_ERROR;
return false;
}
duint addr;
if(!valfromstring(argv[1], &addr))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid address \"%s\"!\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!MemPatch(addr, string(), strlen(string())))
{
dputs(QT_TRANSLATE_NOOP("DBG", "memwrite failed!"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "string written!"));
GuiUpdateAllViews();
GuiUpdatePatches();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLoopList(int argc, char* argv[])
bool cbInstrLoopList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Loops")));
@ -219,7 +219,7 @@ CMDRESULT cbInstrLoopList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "no loops"));
return STATUS_CONTINUE;
return true;
}
Memory<LOOPSINFO*> loops(cbsize, "cbInstrLoopList:loops");
LoopEnum(loops(), 0);
@ -248,37 +248,37 @@ CMDRESULT cbInstrLoopList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d loop(s) listed\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCapstone(int argc, char* argv[])
bool cbInstrCapstone(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr) || !MemIsValidReadPtr(addr))
{
dprintf("invalid address \"%s\"\n", argv[1]);
return STATUS_ERROR;
return false;
}
unsigned char data[16];
if(!MemRead(addr, data, sizeof(data)))
{
dprintf("could not read memory at %p\n", addr);
return STATUS_ERROR;
return false;
}
if(argc > 2)
if(!valfromstring(argv[2], &addr, false))
return STATUS_ERROR;
return false;
Capstone cp;
if(!cp.Disassemble(addr, data))
{
dputs("failed to disassemble!\n");
return STATUS_ERROR;
return false;
}
const cs_insn* instr = cp.GetInstr();
@ -313,19 +313,19 @@ CMDRESULT cbInstrCapstone(int argc, char* argv[])
}
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrVisualize(int argc, char* argv[])
bool cbInstrVisualize(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint start;
duint maxaddr;
if(!valfromstring(argv[1], &start) || !valfromstring(argv[2], &maxaddr))
{
dputs("invalid arguments!");
return STATUS_ERROR;
return false;
}
//actual algorithm
//make sure to set these options in the INI (rest the default theme of x64dbg):
@ -409,21 +409,21 @@ CMDRESULT cbInstrVisualize(int argc, char* argv[])
SetContextDataEx(fdProcessInfo->hThread, UE_CIP, start);
DebugUpdateGuiAsync(start, false);
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrMeminfo(int argc, char* argv[])
bool cbInstrMeminfo(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "usage: meminfo a/r, addr"));
return STATUS_ERROR;
return false;
}
duint addr;
if(!valfromstring(argv[2], &addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "invalid argument"));
return STATUS_ERROR;
return false;
}
if(argv[1][0] == 'a')
{
@ -439,20 +439,20 @@ CMDRESULT cbInstrMeminfo(int argc, char* argv[])
GuiUpdateMemoryView();
dputs(QT_TRANSLATE_NOOP("DBG", "memory map updated!"));
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrBriefcheck(int argc, char* argv[])
bool cbInstrBriefcheck(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
duint size;
auto base = DbgMemFindBaseAddr(addr, &size);
if(!base)
return STATUS_ERROR;
return false;
Memory<unsigned char*> buffer(size + 16);
DbgMemRead(base, buffer(), size);
Capstone cp;
@ -472,13 +472,13 @@ CMDRESULT cbInstrBriefcheck(int argc, char* argv[])
reported.insert(mnem);
dprintf("%p: %s\n", cp.Address(), mnem.c_str());
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFocusinfo(int argc, char* argv[])
bool cbInstrFocusinfo(int argc, char* argv[])
{
ACTIVEVIEW activeView;
GuiGetActiveView(&activeView);
dprintf("activeTitle: %s, activeClass: %s\n", activeView.title, activeView.className);
return STATUS_CONTINUE;
return true;
}

22
src/dbg/commands/cmd-undocumented.h
View File

@ -2,14 +2,14 @@
#include "command.h"
CMDRESULT cbBadCmd(int argc, char* argv[]);
CMDRESULT cbDebugBenchmark(int argc, char* argv[]);
CMDRESULT cbInstrSetstr(int argc, char* argv[]);
CMDRESULT cbInstrGetstr(int argc, char* argv[]);
CMDRESULT cbInstrCopystr(int argc, char* argv[]);
CMDRESULT cbInstrLoopList(int argc, char* argv[]);
CMDRESULT cbInstrCapstone(int argc, char* argv[]);
CMDRESULT cbInstrVisualize(int argc, char* argv[]);
CMDRESULT cbInstrMeminfo(int argc, char* argv[]);
CMDRESULT cbInstrBriefcheck(int argc, char* argv[]);
CMDRESULT cbInstrFocusinfo(int argc, char* argv[]);
bool cbBadCmd(int argc, char* argv[]);
bool cbDebugBenchmark(int argc, char* argv[]);
bool cbInstrSetstr(int argc, char* argv[]);
bool cbInstrGetstr(int argc, char* argv[]);
bool cbInstrCopystr(int argc, char* argv[]);
bool cbInstrLoopList(int argc, char* argv[]);
bool cbInstrCapstone(int argc, char* argv[]);
bool cbInstrVisualize(int argc, char* argv[]);
bool cbInstrMeminfo(int argc, char* argv[]);
bool cbInstrBriefcheck(int argc, char* argv[]);
bool cbInstrFocusinfo(int argc, char* argv[]);

162
src/dbg/commands/cmd-user-database.cpp
View File

@ -9,60 +9,60 @@
#include "function.h"
#include "argument.h"
CMDRESULT cbInstrDbsave(int argc, char* argv[])
bool cbInstrDbsave(int argc, char* argv[])
{
DbSave(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr, argc > 1);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrDbload(int argc, char* argv[])
bool cbInstrDbload(int argc, char* argv[])
{
if(argc <= 1)
DbClear();
DbLoad(DbLoadSaveType::All, argc > 1 ? argv[1] : nullptr);
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrDbclear(int argc, char* argv[])
bool cbInstrDbclear(int argc, char* argv[])
{
DbClear();
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCommentSet(int argc, char* argv[])
bool cbInstrCommentSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!CommentSet(addr, argv[2], true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "error setting comment"));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCommentDel(int argc, char* argv[])
bool cbInstrCommentDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!CommentDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "error deleting comment"));
return STATUS_ERROR;
return false;
}
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCommentList(int argc, char* argv[])
bool cbInstrCommentList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Comments")));
@ -76,7 +76,7 @@ CMDRESULT cbInstrCommentList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "no comments"));
return STATUS_CONTINUE;
return true;
}
Memory<COMMENTSINFO*> comments(cbsize, "cbInstrCommentList:comments");
CommentEnum(comments(), 0);
@ -95,49 +95,49 @@ CMDRESULT cbInstrCommentList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d comment(s) listed in Reference View\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrCommentClear(int argc, char* argv[])
bool cbInstrCommentClear(int argc, char* argv[])
{
CommentClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "all comments deleted!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLabelSet(int argc, char* argv[])
bool cbInstrLabelSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!LabelSet(addr, argv[2], true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "error setting label"));
return STATUS_ERROR;
return false;
}
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLabelDel(int argc, char* argv[])
bool cbInstrLabelDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!LabelDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "error deleting label"));
return STATUS_ERROR;
return false;
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLabelList(int argc, char* argv[])
bool cbInstrLabelList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Labels")));
@ -151,7 +151,7 @@ CMDRESULT cbInstrLabelList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "no labels"));
return STATUS_CONTINUE;
return true;
}
Memory<LABELSINFO*> labels(cbsize, "cbInstrLabelList:labels");
LabelEnum(labels(), 0);
@ -170,50 +170,50 @@ CMDRESULT cbInstrLabelList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d label(s) listed in Reference View\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrLabelClear(int argc, char* argv[])
bool cbInstrLabelClear(int argc, char* argv[])
{
LabelClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "all labels deleted!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrBookmarkSet(int argc, char* argv[])
bool cbInstrBookmarkSet(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!BookmarkSet(addr, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to set bookmark!"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "bookmark set!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrBookmarkDel(int argc, char* argv[])
bool cbInstrBookmarkDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!BookmarkDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to delete bookmark!"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "bookmark deleted!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrBookmarkList(int argc, char* argv[])
bool cbInstrBookmarkList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Bookmarks")));
@ -227,7 +227,7 @@ CMDRESULT cbInstrBookmarkList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No bookmarks found"));
return STATUS_CONTINUE;
return true;
}
Memory<BOOKMARKSINFO*> bookmarks(cbsize, "cbInstrBookmarkList:bookmarks");
BookmarkEnum(bookmarks(), 0);
@ -254,53 +254,53 @@ CMDRESULT cbInstrBookmarkList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d bookmark(s) listed\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrBookmarkClear(int argc, char* argv[])
bool cbInstrBookmarkClear(int argc, char* argv[])
{
LabelClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "all bookmarks deleted!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFunctionAdd(int argc, char* argv[])
bool cbInstrFunctionAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint start = 0;
duint end = 0;
if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false))
return STATUS_ERROR;
return false;
if(!FunctionAdd(start, end, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to add function"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "function added!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFunctionDel(int argc, char* argv[])
bool cbInstrFunctionDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!FunctionDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to delete function"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "function deleted!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFunctionList(int argc, char* argv[])
bool cbInstrFunctionList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Functions")));
@ -315,7 +315,7 @@ CMDRESULT cbInstrFunctionList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No functions"));
return STATUS_CONTINUE;
return true;
}
Memory<FUNCTIONSINFO*> functions(cbsize, "cbInstrFunctionList:functions");
FunctionEnum(functions(), 0);
@ -344,53 +344,53 @@ CMDRESULT cbInstrFunctionList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d function(s) listed\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrFunctionClear(int argc, char* argv[])
bool cbInstrFunctionClear(int argc, char* argv[])
{
FunctionClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "all functions deleted!"));
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrArgumentAdd(int argc, char* argv[])
bool cbInstrArgumentAdd(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 3))
return STATUS_ERROR;
return false;
duint start = 0;
duint end = 0;
if(!valfromstring(argv[1], &start, false) || !valfromstring(argv[2], &end, false))
return STATUS_ERROR;
return false;
if(!ArgumentAdd(start, end, true))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to add argument"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "argument added!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrArgumentDel(int argc, char* argv[])
bool cbInstrArgumentDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
duint addr = 0;
if(!valfromstring(argv[1], &addr, false))
return STATUS_ERROR;
return false;
if(!ArgumentDelete(addr))
{
dputs(QT_TRANSLATE_NOOP("DBG", "failed to delete argument"));
return STATUS_ERROR;
return false;
}
dputs(QT_TRANSLATE_NOOP("DBG", "argument deleted!"));
GuiUpdateAllViews();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrArgumentList(int argc, char* argv[])
bool cbInstrArgumentList(int argc, char* argv[])
{
//setup reference view
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Arguments")));
@ -405,7 +405,7 @@ CMDRESULT cbInstrArgumentList(int argc, char* argv[])
if(!cbsize)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No arguments"));
return STATUS_CONTINUE;
return true;
}
Memory<ARGUMENTSINFO*> arguments(cbsize, "cbInstrArgumentList:arguments");
ArgumentEnum(arguments(), 0);
@ -434,13 +434,13 @@ CMDRESULT cbInstrArgumentList(int argc, char* argv[])
varset("$result", count, false);
dprintf(QT_TRANSLATE_NOOP("DBG", "%d argument(s) listed\n"), count);
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrArgumentClear(int argc, char* argv[])
bool cbInstrArgumentClear(int argc, char* argv[])
{
ArgumentClear();
GuiUpdateAllViews();
dputs(QT_TRANSLATE_NOOP("DBG", "all arguments deleted!"));
return STATUS_CONTINUE;
return true;
}

46
src/dbg/commands/cmd-user-database.h
View File

@ -2,33 +2,33 @@
#include "command.h"
CMDRESULT cbInstrDbsave(int argc, char* argv[]);
CMDRESULT cbInstrDbload(int argc, char* argv[]);
CMDRESULT cbInstrDbclear(int argc, char* argv[]);
bool cbInstrDbsave(int argc, char* argv[]);
bool cbInstrDbload(int argc, char* argv[]);
bool cbInstrDbclear(int argc, char* argv[]);
CMDRESULT cbInstrCommentSet(int argc, char* argv[]);
CMDRESULT cbInstrCommentDel(int argc, char* argv[]);
CMDRESULT cbInstrCommentList(int argc, char* argv[]);
CMDRESULT cbInstrCommentClear(int argc, char* argv[]);
bool cbInstrCommentSet(int argc, char* argv[]);
bool cbInstrCommentDel(int argc, char* argv[]);
bool cbInstrCommentList(int argc, char* argv[]);
bool cbInstrCommentClear(int argc, char* argv[]);
CMDRESULT cbInstrLabelSet(int argc, char* argv[]);
CMDRESULT cbInstrLabelDel(int argc, char* argv[]);
CMDRESULT cbInstrLabelList(int argc, char* argv[]);
CMDRESULT cbInstrLabelClear(int argc, char* argv[]);
bool cbInstrLabelSet(int argc, char* argv[]);
bool cbInstrLabelDel(int argc, char* argv[]);
bool cbInstrLabelList(int argc, char* argv[]);
bool cbInstrLabelClear(int argc, char* argv[]);
CMDRESULT cbInstrBookmarkSet(int argc, char* argv[]);
CMDRESULT cbInstrBookmarkDel(int argc, char* argv[]);
CMDRESULT cbInstrBookmarkList(int argc, char* argv[]);
CMDRESULT cbInstrBookmarkClear(int argc, char* argv[]);
bool cbInstrBookmarkSet(int argc, char* argv[]);
bool cbInstrBookmarkDel(int argc, char* argv[]);
bool cbInstrBookmarkList(int argc, char* argv[]);
bool cbInstrBookmarkClear(int argc, char* argv[]);
CMDRESULT cbInstrFunctionAdd(int argc, char* argv[]);
CMDRESULT cbInstrFunctionDel(int argc, char* argv[]);
CMDRESULT cbInstrFunctionList(int argc, char* argv[]);
CMDRESULT cbInstrFunctionClear(int argc, char* argv[]);
bool cbInstrFunctionAdd(int argc, char* argv[]);
bool cbInstrFunctionDel(int argc, char* argv[]);
bool cbInstrFunctionList(int argc, char* argv[]);
bool cbInstrFunctionClear(int argc, char* argv[]);
CMDRESULT cbInstrArgumentAdd(int argc, char* argv[]);
CMDRESULT cbInstrArgumentDel(int argc, char* argv[]);
CMDRESULT cbInstrArgumentList(int argc, char* argv[]);
CMDRESULT cbInstrArgumentClear(int argc, char* argv[]);
bool cbInstrArgumentAdd(int argc, char* argv[]);
bool cbInstrArgumentDel(int argc, char* argv[]);
bool cbInstrArgumentList(int argc, char* argv[]);
bool cbInstrArgumentClear(int argc, char* argv[]);

26
src/dbg/commands/cmd-variables.cpp
View File

@ -3,10 +3,10 @@
#include "variable.h"
#include "value.h"
CMDRESULT cbInstrVar(int argc, char* argv[])
bool cbInstrVar(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
char arg2[deflen] = ""; //var value (optional)
if(argc > 2)
strcpy_s(arg2, argv[2]);
@ -17,17 +17,17 @@ CMDRESULT cbInstrVar(int argc, char* argv[])
if(valfromstring(argv[1] + add, &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid variable name \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
if(!valfromstring(arg2, &value))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "invalid value \"%s\"\n"), arg2);
return STATUS_ERROR;
return false;
}
if(!varnew(argv[1], value, VAR_USER))
{
dprintf(QT_TRANSLATE_NOOP("DBG", "error creating variable \"%s\"\n"), argv[1]);
return STATUS_ERROR;
return false;
}
else
{
@ -44,21 +44,21 @@ CMDRESULT cbInstrVar(int argc, char* argv[])
dprintf_untranslated("%s=%X\n", argv[1], value);
#endif //_WIN64
}
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrVarDel(int argc, char* argv[])
bool cbInstrVarDel(int argc, char* argv[])
{
if(IsArgumentsLessThan(argc, 2))
return STATUS_ERROR;
return false;
if(!vardel(argv[1], false))
dprintf(QT_TRANSLATE_NOOP("DBG", "could not delete variable \"%s\"\n"), argv[1]);
else
dprintf(QT_TRANSLATE_NOOP("DBG", "deleted variable \"%s\"\n"), argv[1]);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbInstrVarList(int argc, char* argv[])
bool cbInstrVarList(int argc, char* argv[])
{
int filter = 0;
if(argc > 1)
@ -75,13 +75,13 @@ CMDRESULT cbInstrVarList(int argc, char* argv[])
if(!varenum(0, &cbsize))
{
dputs(QT_TRANSLATE_NOOP("DBG", "no variables!"));
return STATUS_CONTINUE;
return true;
}
Memory<VAR*> variables(cbsize, "cbInstrVarList:variables");
if(!varenum(variables(), 0))
{
dputs(QT_TRANSLATE_NOOP("DBG", "error listing variables!"));
return STATUS_ERROR;
return false;
}
GuiReferenceInitialize(GuiTranslateText(QT_TRANSLATE_NOOP("DBG", "Variables")));
@ -133,5 +133,5 @@ CMDRESULT cbInstrVarList(int argc, char* argv[])
}
}
GuiReferenceReloadData();
return STATUS_CONTINUE;
return true;
}

6
src/dbg/commands/cmd-variables.h
View File

@ -2,6 +2,6 @@
#include "command.h"
CMDRESULT cbInstrVar(int argc, char* argv[]);
CMDRESULT cbInstrVarDel(int argc, char* argv[]);
CMDRESULT cbInstrVarList(int argc, char* argv[]);
bool cbInstrVar(int argc, char* argv[]);
bool cbInstrVarDel(int argc, char* argv[]);
bool cbInstrVarList(int argc, char* argv[]);

44
src/dbg/commands/cmd-watch-control.cpp
View File

@ -4,12 +4,12 @@
#include "console.h"
#include "threading.h"
CMDRESULT cbAddWatch(int argc, char* argv[])
bool cbAddWatch(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for addwatch\n"));
return STATUS_ERROR;
return false;
}
WATCHVARTYPE newtype = WATCHVARTYPE::TYPE_UINT;
if(argc > 2)
@ -27,40 +27,40 @@ CMDRESULT cbAddWatch(int argc, char* argv[])
}
unsigned int newid = WatchAddExpr(argv[1], newtype);
varset("$result", newid, false);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbDelWatch(int argc, char* argv[])
bool cbDelWatch(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n"));
return STATUS_ERROR;
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(!ok)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return STATUS_ERROR;
return false;
}
WatchDelete((unsigned int)id);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbSetWatchdog(int argc, char* argv[])
bool cbSetWatchdog(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for delwatch\n"));
return STATUS_ERROR;
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(!ok)
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return STATUS_ERROR;
return false;
}
WATCHDOGMODE mode;
if(argc > 2)
@ -78,21 +78,21 @@ CMDRESULT cbSetWatchdog(int argc, char* argv[])
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Unknown watchdog mode.\n"));
return STATUS_ERROR;
return false;
}
}
else
mode = (WatchGetWatchdogEnabled((unsigned int)id) == WATCHDOGMODE::MODE_DISABLED) ? WATCHDOGMODE::MODE_CHANGED : WATCHDOGMODE::MODE_DISABLED;
WatchSetWatchdogMode((unsigned int)id, mode);
return STATUS_CONTINUE;
return true;
}
CMDRESULT cbSetWatchExpression(int argc, char* argv[])
bool cbSetWatchExpression(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchExpression"));
return STATUS_ERROR;
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
@ -117,37 +117,37 @@ CMDRESULT cbSetWatchExpression(int argc, char* argv[])
else
varType = WATCHVARTYPE::TYPE_UINT;
WatchModifyExpr((unsigned int)id, argv[2], varType);
return STATUS_CONTINUE;
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return STATUS_ERROR;
return false;
}
}
CMDRESULT cbSetWatchName(int argc, char* argv[])
bool cbSetWatchName(int argc, char* argv[])
{
if(argc < 3)
{
dputs(QT_TRANSLATE_NOOP("DBG", "No enough arguments for SetWatchName"));
return STATUS_ERROR;
return false;
}
duint id;
bool ok = valfromstring(argv[1], &id);
if(ok)
{
WatchModifyName((unsigned int)id, argv[2]);
return STATUS_CONTINUE;
return true;
}
else
{
dputs(QT_TRANSLATE_NOOP("DBG", "Error expression in argument 1.\n"));
return STATUS_ERROR;
return false;
}
}
CMDRESULT cbCheckWatchdog(int argc, char* argv[])
bool cbCheckWatchdog(int argc, char* argv[])
{
EXCLUSIVE_ACQUIRE(LockWatch);
bool watchdogTriggered = false;
@ -162,5 +162,5 @@ CMDRESULT cbCheckWatchdog(int argc, char* argv[])
if(watchdogTriggered)
GuiUpdateWatchViewAsync();
varset("$result", watchdogTriggered ? 1 : 0, false);
return STATUS_CONTINUE;
return true;
}

12
src/dbg/commands/cmd-watch-control.h
View File

@ -2,9 +2,9 @@
#include "command.h"
CMDRESULT cbAddWatch(int argc, char* argv[]);
CMDRESULT cbDelWatch(int argc, char* argv[]);
CMDRESULT cbSetWatchdog(int argc, char* argv[]);
CMDRESULT cbSetWatchExpression(int argc, char* argv[]);
CMDRESULT cbSetWatchName(int argc, char* argv[]);
CMDRESULT cbCheckWatchdog(int argc, char* argv[]);
bool cbAddWatch(int argc, char* argv[]);
bool cbDelWatch(int argc, char* argv[]);
bool cbSetWatchdog(int argc, char* argv[]);
bool cbSetWatchExpression(int argc, char* argv[]);
bool cbSetWatchName(int argc, char* argv[]);
bool cbCheckWatchdog(int argc, char* argv[]);

12
src/dbg/simplescript.cpp
View File

@ -22,6 +22,14 @@ static bool volatile bAbort = false;
static bool volatile bIsRunning = false;
enum CMDRESULT
{
STATUS_ERROR = false,
STATUS_CONTINUE = true,
STATUS_EXIT = 2,
STATUS_PAUSE = 3
};
static SCRIPTBRANCHTYPE scriptgetbranchtype(const char* text)
{
char newtext[MAX_SCRIPT_LINE_SIZE] = "";
@ -317,10 +325,10 @@ static CMDRESULT scriptinternalcmdexec(const char* cmd)
return STATUS_PAUSE;
else if(scriptisinternalcommand(cmd, "nop")) //do nothing
return STATUS_CONTINUE;
CMDRESULT res = cmddirectexec(cmd);
auto res = cmddirectexec(cmd);
while(DbgIsDebugging() && dbgisrunning() && !bAbort) //while not locked (NOTE: possible deadlock)
Sleep(1);
return res;
return res ? STATUS_CONTINUE : STATUS_ERROR;
}
static bool scriptinternalbranch(SCRIPTBRANCHTYPE type) //determine if we should jump

22
src/dbg/x64dbg.cpp
View File

@ -34,42 +34,42 @@ static bool bIsStopped = true;
static char scriptDllDir[MAX_PATH] = "";
static String notesFile;
static CMDRESULT cbStrLen(int argc, char* argv[])
static bool cbStrLen(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!"));
return STATUS_ERROR;
return false;
}
dprintf_untranslated("\"%s\"[%d]\n", argv[1], int(strlen(argv[1])));
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbClearLog(int argc, char* argv[])
static bool cbClearLog(int argc, char* argv[])
{
GuiLogClear();
return STATUS_CONTINUE;
return true;
}
static CMDRESULT cbPrintf(int argc, char* argv[])
static bool cbPrintf(int argc, char* argv[])
{
if(argc < 2)
dprintf("\n");
else
dprintf("%s", argv[1]);
return STATUS_CONTINUE;
return true;
}
static bool DbgScriptDllExec(const char* dll);
static CMDRESULT cbScriptDll(int argc, char* argv[])
static bool cbScriptDll(int argc, char* argv[])
{
if(argc < 2)
{
dputs(QT_TRANSLATE_NOOP("DBG", "not enough arguments!"));
return STATUS_ERROR;
return false;
}
return DbgScriptDllExec(argv[1]) ? STATUS_CONTINUE : STATUS_ERROR;
return DbgScriptDllExec(argv[1]);
}
#include "cmd-all.h"
@ -759,7 +759,7 @@ extern "C" DLL_EXPORT void _dbg_dbgexitsignal()
extern "C" DLL_EXPORT bool _dbg_dbgcmddirectexec(const char* cmd)
{
if(cmddirectexec(cmd) == STATUS_ERROR)
if(cmddirectexec(cmd) == false)
return false;
return true;
}