301 lines
8.5 KiB
C++
301 lines
8.5 KiB
C++
#include "IronPad.hpp"
|
|
#include <Windows.h>
|
|
#include <DbgHelp.h>
|
|
#include <filesystem>
|
|
#include <cstdarg>
|
|
#include <cstdio>
|
|
|
|
namespace IronPad {
|
|
|
|
#if defined(IRONPAD_ENABLED)
|
|
|
|
/**
|
|
* @brief true if the exception handler already registered.
|
|
* This variable is served for singleton.
|
|
*/
|
|
static bool g_IsRegistered = false;
|
|
/**
|
|
* @brief true if a exception handler is running.
|
|
* This variable is served for blocking possible infinity recursive exception handling.
|
|
*/
|
|
static bool g_IsProcessing = false;
|
|
/**
|
|
* @brief The backup of original exception handler.
|
|
*/
|
|
LPTOP_LEVEL_EXCEPTION_FILTER g_ProcBackup;
|
|
|
|
#pragma region Exception Handler Detail
|
|
|
|
static const char* UExceptionGetCodeName(DWORD code) {
|
|
switch (code) {
|
|
case EXCEPTION_ACCESS_VIOLATION:
|
|
return "access violation";
|
|
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
|
|
return "array index out of bound";
|
|
case EXCEPTION_BREAKPOINT:
|
|
return "breakpoint reached";
|
|
case EXCEPTION_DATATYPE_MISALIGNMENT:
|
|
return "misaligned data access";
|
|
case EXCEPTION_FLT_DENORMAL_OPERAND:
|
|
return "operand had denormal value";
|
|
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
|
|
return "floating-point division by zero";
|
|
case EXCEPTION_FLT_INEXACT_RESULT:
|
|
return "no decimal fraction representation for value";
|
|
case EXCEPTION_FLT_INVALID_OPERATION:
|
|
return "invalid floating-point operation";
|
|
case EXCEPTION_FLT_OVERFLOW:
|
|
return "floating-point overflow";
|
|
case EXCEPTION_FLT_STACK_CHECK:
|
|
return "floating-point stack corruption";
|
|
case EXCEPTION_FLT_UNDERFLOW:
|
|
return "floating-point underflow";
|
|
case EXCEPTION_ILLEGAL_INSTRUCTION:
|
|
return "illegal instruction";
|
|
case EXCEPTION_IN_PAGE_ERROR:
|
|
return "inaccessible page";
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
|
return "integer division by zero";
|
|
case EXCEPTION_INT_OVERFLOW:
|
|
return "integer overflow";
|
|
case EXCEPTION_INVALID_DISPOSITION:
|
|
return "documentation says this should never happen";
|
|
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
|
|
return "can't continue after a noncontinuable exception";
|
|
case EXCEPTION_PRIV_INSTRUCTION:
|
|
return "attempted to execute a privileged instruction";
|
|
case EXCEPTION_SINGLE_STEP:
|
|
return "one instruction has been executed";
|
|
case EXCEPTION_STACK_OVERFLOW:
|
|
return "stack overflow";
|
|
}
|
|
return "unknown exception";
|
|
}
|
|
|
|
static void UExceptionFormat(std::FILE* fs, const char* fmt, ...) {
|
|
// write to file
|
|
va_list arg1;
|
|
va_start(arg1, fmt);
|
|
std::vfprintf(fs, fmt, arg1);
|
|
va_end(arg1);
|
|
// write to stdout
|
|
va_list arg2;
|
|
va_start(arg2, fmt);
|
|
std::vfprintf(stdout, fmt, arg2);
|
|
va_end(arg2);
|
|
}
|
|
|
|
static void UExceptionPrint(std::FILE* fs, const char* strl) {
|
|
// write to file
|
|
std::fputs(strl, fs);
|
|
// write to stdout
|
|
std::fputs(strl, stdout);
|
|
}
|
|
|
|
static void UExceptionBacktrace(FILE* fs, LPCONTEXT context, int maxdepth) {
|
|
// setup loading symbol options
|
|
SymSetOptions(SymGetOptions() | SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES); // lazy load symbol, and load line number.
|
|
|
|
// setup handle
|
|
HANDLE process = GetCurrentProcess();
|
|
HANDLE thread = GetCurrentThread();
|
|
|
|
// init symbol
|
|
if (!SymInitialize(process, 0, TRUE)) {
|
|
// fail to load. return
|
|
UExceptionPrint(fs, "Lost symbol file!\n");
|
|
return;
|
|
}
|
|
|
|
// ========== CORE DUMP ==========
|
|
// prepare frame. setup correct fields
|
|
DWORD machine_type = 0;
|
|
STACKFRAME64 frame;
|
|
memset(&frame, 0, sizeof(frame));
|
|
#if defined(_M_IX86) || defined(__i386__)
|
|
machine_type = IMAGE_FILE_MACHINE_I386;
|
|
frame.AddrPC.Offset = context->Eip;
|
|
frame.AddrStack.Offset = context->Esp;
|
|
frame.AddrFrame.Offset = context->Ebp;
|
|
#elif defined(_M_IX64) || defined(__amd64__)
|
|
machine_type = IMAGE_FILE_MACHINE_AMD64;
|
|
frame.AddrPC.Offset = context->Rip;
|
|
frame.AddrStack.Offset = context->Rsp;
|
|
frame.AddrFrame.Offset = context->Rbp;
|
|
#else
|
|
#error "Unsupported platform"
|
|
//IA-64 anybody?
|
|
#endif
|
|
frame.AddrPC.Mode = AddrModeFlat;
|
|
frame.AddrStack.Mode = AddrModeFlat;
|
|
frame.AddrFrame.Mode = AddrModeFlat;
|
|
|
|
// other variables
|
|
char module_name_raw[MAX_PATH];
|
|
|
|
// stack walker
|
|
while (StackWalk64(machine_type, process, thread, &frame, context,
|
|
0, SymFunctionTableAccess64, SymGetModuleBase64, 0)) {
|
|
|
|
// depth breaker
|
|
--maxdepth;
|
|
if (maxdepth < 0) {
|
|
UExceptionPrint(fs, "...\n"); // indicate there are some frames not listed
|
|
break;
|
|
}
|
|
|
|
// get module name
|
|
DWORD64 module_base = SymGetModuleBase64(process, frame.AddrPC.Offset);
|
|
const char* module_name = "[unknown module]";
|
|
if (module_base && GetModuleFileNameA((HINSTANCE)module_base, module_name_raw, MAX_PATH)) {
|
|
module_name = module_name_raw;
|
|
}
|
|
|
|
// get source file and line
|
|
const char* source_file = "[unknow_source_file]";
|
|
DWORD64 source_file_line = 0;
|
|
DWORD dwDisplacement;
|
|
IMAGEHLP_LINE64 winline;
|
|
winline.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
|
if (SymGetLineFromAddr64(process, frame.AddrPC.Offset, &dwDisplacement, &winline)) {
|
|
source_file = winline.FileName;
|
|
source_file_line = winline.LineNumber;
|
|
}
|
|
|
|
// write to file
|
|
UExceptionFormat(fs, "0x%016llx(rel: 0x%016llx)[%s]\t%s#%llu\n",
|
|
frame.AddrPC.Offset, frame.AddrPC.Offset - module_base, module_name,
|
|
source_file, source_file_line
|
|
);
|
|
|
|
}
|
|
|
|
// ========== END CORE DUMP ==========
|
|
|
|
// free symbol
|
|
SymCleanup(process);
|
|
}
|
|
|
|
static void UExceptionCoreDump(LPCWSTR filename, LPEXCEPTION_POINTERS info) {
|
|
// setup handle
|
|
HANDLE hProcess = GetCurrentProcess();
|
|
DWORD dwProcessId = GetCurrentProcessId();
|
|
DWORD dwThreadId = GetCurrentThreadId();
|
|
|
|
// open file and write
|
|
if (hProcess != INVALID_HANDLE_VALUE) {
|
|
HANDLE hFile = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile != INVALID_HANDLE_VALUE) {
|
|
MINIDUMP_EXCEPTION_INFORMATION exception_info;
|
|
exception_info.ThreadId = dwThreadId;
|
|
exception_info.ExceptionPointers = info;
|
|
exception_info.ClientPointers = TRUE;
|
|
MiniDumpWriteDump(hProcess, dwProcessId, hFile, MiniDumpWithFullMemory, &exception_info, NULL, NULL);
|
|
CloseHandle(hFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
static LONG WINAPI UExceptionImpl(LPEXCEPTION_POINTERS info) {
|
|
// detect loop calling
|
|
if (g_IsProcessing) {
|
|
goto end_proc;
|
|
}
|
|
// start process
|
|
g_IsProcessing = true;
|
|
|
|
{
|
|
// get main folder first
|
|
std::filesystem::path ironpad_path;
|
|
WCHAR module_path[MAX_PATH];
|
|
std::memset(module_path, 0, sizeof(module_path));
|
|
if (GetModuleFileNameW(NULL, module_path, MAX_PATH) == 0) {
|
|
goto failed;
|
|
}
|
|
ironpad_path = module_path;
|
|
ironpad_path = ironpad_path.parent_path();
|
|
|
|
// create 2 filename
|
|
auto logfilename = ironpad_path / "IronPad.log";
|
|
auto dmpfilename = ironpad_path / "IronPad.dmp";
|
|
std::fputc('\n', stdout);
|
|
std::fprintf(stdout, "Exception Log: %s\n", logfilename.string().c_str());
|
|
std::fprintf(stdout, "Exception Coredump: %s\n", dmpfilename.string().c_str());
|
|
|
|
// output log file
|
|
{
|
|
std::FILE* fs = _wfopen(logfilename.wstring().c_str(), L"w");
|
|
if (fs == nullptr) {
|
|
goto failed;
|
|
}
|
|
|
|
// record exception type first
|
|
PEXCEPTION_RECORD rec = info->ExceptionRecord;
|
|
fprintf(fs, "Unhandled exception occured at 0x%08p: %s (%lu).\n",
|
|
rec->ExceptionAddress,
|
|
UExceptionGetCodeName(rec->ExceptionCode),
|
|
rec->ExceptionCode
|
|
);
|
|
|
|
// special proc for 2 exceptions
|
|
if (rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION || rec->ExceptionCode == EXCEPTION_IN_PAGE_ERROR) {
|
|
if (rec->NumberParameters >= 2) {
|
|
const char* op =
|
|
rec->ExceptionInformation[0] == 0 ? "read" :
|
|
rec->ExceptionInformation[0] == 1 ? "written" : "executed";
|
|
fprintf(fs, "The data at memory address 0x%08x could not be %s.\n",
|
|
rec->ExceptionInformation[1], op);
|
|
}
|
|
}
|
|
|
|
// output stacktrace
|
|
UExceptionBacktrace(fs, info->ContextRecord, 1024);
|
|
|
|
std::fclose(fs);
|
|
}
|
|
|
|
// output minidump
|
|
{
|
|
UExceptionCoreDump(dmpfilename.wstring().c_str(), info);
|
|
}
|
|
|
|
}
|
|
|
|
// end process
|
|
failed:
|
|
g_IsProcessing = false;
|
|
// if backup proc can be run, run it
|
|
// otherwise directly return.
|
|
end_proc:
|
|
if (g_ProcBackup != nullptr) {
|
|
return g_ProcBackup(info);
|
|
} else {
|
|
return EXCEPTION_CONTINUE_SEARCH;
|
|
}
|
|
}
|
|
|
|
#pragma endregion
|
|
|
|
void IronPadRegister() {
|
|
if (g_IsRegistered) return;
|
|
g_ProcBackup = SetUnhandledExceptionFilter(UExceptionImpl);
|
|
g_IsRegistered = true;
|
|
}
|
|
|
|
void IronPadUnregister() {
|
|
if (!g_IsRegistered) return;
|
|
SetUnhandledExceptionFilter(g_ProcBackup);
|
|
g_IsRegistered = false;
|
|
}
|
|
|
|
#else
|
|
|
|
// blank implement
|
|
|
|
void IronPadRegister() {}
|
|
void IronPadUnregister() {}
|
|
|
|
#endif
|
|
|
|
}
|