150 lines
4.0 KiB
C++
150 lines
4.0 KiB
C++
#include "client/linux/handler/exception_handler.h"
|
|
#include "common/linux/linux_libc_support.h"
|
|
#include "third_party/lss/linux_syscall_support.h"
|
|
|
|
#include <google_breakpad/processor/minidump.h>
|
|
#include <google_breakpad/processor/minidump_processor.h>
|
|
#include <google_breakpad/processor/process_state.h>
|
|
#include <google_breakpad/processor/call_stack.h>
|
|
#include <google_breakpad/processor/stack_frame.h>
|
|
#include <processor/pathname_stripper.h>
|
|
|
|
#include <signal.h>
|
|
#include <dirent.h>
|
|
#include <unistd.h>
|
|
#include <setjmp.h>
|
|
|
|
#include <streambuf>
|
|
|
|
extern "C" {
|
|
#include "sha256.h"
|
|
}
|
|
|
|
using google_breakpad::MinidumpDescriptor;
|
|
using google_breakpad::ExceptionHandler;
|
|
|
|
using google_breakpad::Minidump;
|
|
using google_breakpad::MinidumpProcessor;
|
|
using google_breakpad::ProcessState;
|
|
using google_breakpad::ProcessResult;
|
|
using google_breakpad::CallStack;
|
|
using google_breakpad::StackFrame;
|
|
using google_breakpad::PathnameStripper;
|
|
|
|
sigjmp_buf envbuf;
|
|
char path[1024];
|
|
|
|
static bool dumpCallback(const MinidumpDescriptor &descriptor, void *context, bool succeeded)
|
|
{
|
|
if (succeeded) {
|
|
sys_write(STDOUT_FILENO, "Wrote minidump to: ", 19);
|
|
} else {
|
|
sys_write(STDOUT_FILENO, "Failed to write minidump to: ", 29);
|
|
}
|
|
|
|
sys_write(STDOUT_FILENO, descriptor.path(), my_strlen(descriptor.path()));
|
|
sys_write(STDOUT_FILENO, "\n", 1);
|
|
|
|
my_strlcpy(path, descriptor.path(), sizeof(path));
|
|
siglongjmp(envbuf, 1);
|
|
|
|
return succeeded;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
bool generateCrash = false;
|
|
if (argc <= 1) {
|
|
generateCrash = true;
|
|
|
|
if (sigsetjmp(envbuf, 0) == 0) {
|
|
MinidumpDescriptor descriptor(".");
|
|
ExceptionHandler *handler = new ExceptionHandler(descriptor, NULL, dumpCallback, NULL, true, -1);
|
|
|
|
// Test shit here.
|
|
__builtin_trap();
|
|
|
|
delete handler;
|
|
return 0;
|
|
}
|
|
|
|
printf("Returned from signal handler, path: %s\n", path);
|
|
|
|
argc = 2;
|
|
}
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
if (!generateCrash) {
|
|
my_strlcpy(path, argv[i], sizeof(path));
|
|
}
|
|
|
|
MinidumpProcessor minidumpProcessor(nullptr, nullptr);
|
|
|
|
std::streambuf *old = std::clog.rdbuf();
|
|
std::clog.rdbuf(nullptr);
|
|
|
|
ProcessState processState;
|
|
ProcessResult processResult = minidumpProcessor.Process(path, &processState);
|
|
|
|
std::clog.rdbuf(old);
|
|
|
|
if (processResult != google_breakpad::PROCESS_OK) {
|
|
continue;
|
|
}
|
|
|
|
int requestingThread = processState.requesting_thread();
|
|
if (requestingThread == -1) {
|
|
requestingThread = 0;
|
|
}
|
|
|
|
const CallStack *stack = processState.threads()->at(requestingThread);
|
|
if (!stack) {
|
|
fprintf(stderr, "Minidump missing stack!\n");
|
|
continue;
|
|
}
|
|
|
|
int frameCount = stack->frames()->size();
|
|
if (frameCount > 10) {
|
|
frameCount = 10;
|
|
}
|
|
|
|
SHA256_CTX hashctx;
|
|
sha256_init(&hashctx);
|
|
|
|
sha256_update(&hashctx, (const unsigned char *)processState.crash_reason().data(), processState.crash_reason().length());
|
|
|
|
//printf("1|%d|%s|%x|%d", processState.crashed(), processState.crash_reason().c_str(), (intptr_t)processState.crash_address(), requestingThread);
|
|
for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
|
|
const StackFrame *frame = stack->frames()->at(frameIndex);
|
|
if (frame->module) {
|
|
auto codeFile = PathnameStripper::File(frame->module->code_file());
|
|
auto debugId = frame->module->debug_identifier();
|
|
auto moduleOffset = frame->ReturnAddress() - frame->module->base_address();
|
|
|
|
sha256_update(&hashctx, (const unsigned char *)codeFile.data(), codeFile.length());
|
|
sha256_update(&hashctx, (const unsigned char *)debugId.data(), debugId.length());
|
|
sha256_update(&hashctx, (const unsigned char *)&moduleOffset, sizeof(moduleOffset));
|
|
|
|
//printf("|%d|%s|%s|%x", frame->trust, codeFile.c_str(), debugId.c_str(), (intptr_t)moduleOffset);
|
|
} else {
|
|
//printf("|%d|||%x", frame->trust, (intptr_t)frame->ReturnAddress());
|
|
}
|
|
}
|
|
//printf("\n");
|
|
|
|
unsigned char hash[SHA256_BLOCK_SIZE];
|
|
sha256_final(&hashctx, hash);
|
|
|
|
for (int c = 0; c < SHA256_BLOCK_SIZE; ++c) {
|
|
printf("%02x", hash[c]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
|
|
if (generateCrash) {
|
|
unlink(path);
|
|
}
|
|
|
|
return 0;
|
|
}
|