233 lines
7.6 KiB
C
233 lines
7.6 KiB
C
#include "log.h"
|
|
|
|
#include <dbghelp.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#pragma comment(lib, "DbgHelp.lib")
|
|
|
|
#include "../util/pid.h"
|
|
#include "config.h"
|
|
#include "ipc.h"
|
|
|
|
#define _LF(category, name, display) \
|
|
LOG_FACILITY lf##name = { \
|
|
.m_name = display, \
|
|
}; \
|
|
PLOG_FACILITY plf##name = &lf##name;
|
|
#include "log_facilities.def"
|
|
#undef _LF
|
|
|
|
static BOOL logIsMaster = FALSE;
|
|
|
|
CHAR logBasename[MAX_PATH + 1] = { 0 };
|
|
extern DWORD imageOffset;
|
|
|
|
extern BOOL(WINAPI* TrueWriteFile)(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
|
|
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped);
|
|
|
|
void MiceSetLogBasename(char* baseName) { strcpy_s(logBasename, sizeof logBasename, baseName); }
|
|
|
|
char _log_prelude[64];
|
|
char* log_prelude() {
|
|
time_t rawtime;
|
|
struct tm timeinfo;
|
|
|
|
time(&rawtime);
|
|
localtime_s(&timeinfo, &rawtime);
|
|
|
|
size_t offset = strftime(_log_prelude, sizeof _log_prelude, "[%Y/%m/%d %H:%M:%S] ", &timeinfo);
|
|
if (logBasename[0])
|
|
sprintf_s(_log_prelude + offset, sizeof _log_prelude - offset, "%s:", logBasename);
|
|
return _log_prelude;
|
|
}
|
|
|
|
static HANDLE log_file = INVALID_HANDLE_VALUE;
|
|
CRITICAL_SECTION logger_lock;
|
|
|
|
static char* log_colours[] = {
|
|
"", // Always
|
|
"\033[96m", // Game
|
|
"\033[91m", // Error
|
|
"\033[33m", // Warning
|
|
"\033[97m", // Info
|
|
"\033[90m", // Misc
|
|
"\033[90m", // Trace
|
|
};
|
|
static const char* COLOR_RESET = "\033[0m";
|
|
#define LOG_PREFIXES "!GEWIMT"
|
|
|
|
void logcb(LPCSTR param_1) { log_game(plfAmLog, "%s", param_1); }
|
|
void __stdcall amLogCallback(DWORD level, char* format) {
|
|
if (level == 0)
|
|
log_game(plfAmLog, "E:%s", format);
|
|
else if (level == 0)
|
|
log_game(plfAmLog, "W:%s", format);
|
|
else
|
|
log_game(plfAmLog, "I:%s", format);
|
|
}
|
|
|
|
DWORD pLogcb;
|
|
DWORD* ppLogcb;
|
|
|
|
static char log_buf[1024];
|
|
int _do_log(BYTE log_level, PLOG_FACILITY facility, const char* format, va_list args) {
|
|
// Early-return if we have nothing to do
|
|
if (MiceConfig.mice.log_level < log_level) return 0;
|
|
|
|
// TODO: These are all horrible bodges
|
|
// if (wcscmp(exeName, L"mxnetwork.exe") == 0) {
|
|
// // *((DWORD*)(imageOffset + 0x004438e8)) = (DWORD)(&logcb);
|
|
// *((DWORD*)(imageOffset + 0x004438e8)) = 0x00000000;
|
|
// }
|
|
// if (wcscmp(exeName, L"maimai_dump_.exe") == 0) {
|
|
// *((DWORD*)(imageOffset + 0x00c820ec)) = 0x00000001;
|
|
// pLogcb = (DWORD)(&amLogCallback);
|
|
// ppLogcb = &pLogcb;
|
|
// *((DWORD***)(imageOffset + 0x00c820F4)) = &ppLogcb;
|
|
// // *((DWORD*)(imageOffset + 0x004438e8)) = (DWORD)(&logcb);
|
|
// }
|
|
|
|
char prefix = LOG_PREFIXES[log_level];
|
|
|
|
size_t col_len = strlen(log_colours[log_level]);
|
|
|
|
EnterCriticalSection(&logger_lock);
|
|
int log_len = snprintf(log_buf, _countof(log_buf), "%s%s%c:%s:", log_colours[log_level],
|
|
log_prelude(), prefix, facility->m_name);
|
|
log_len += vsnprintf(log_buf + log_len, _countof(log_buf) - log_len, format, args);
|
|
log_len += snprintf(log_buf + log_len, _countof(log_buf) - log_len, "%s\n", COLOR_RESET);
|
|
log_buf[_countof(log_buf) - 1] = '\0';
|
|
|
|
MICE_IPC_MESSAGE ipcMessage;
|
|
ipcMessage.m_Type = MICE_IPC_TYPE_LOG;
|
|
memcpy_s(ipcMessage.m_Message, sizeof ipcMessage.m_Message, log_buf, log_len);
|
|
if (log_len < sizeof ipcMessage.m_Message) {
|
|
ipcMessage.m_Message[log_len] = '\0';
|
|
ipcMessage.m_Size = log_len;
|
|
} else {
|
|
ipcMessage.m_Message[sizeof ipcMessage.m_Message - 1] = '\0';
|
|
ipcMessage.m_Size = sizeof ipcMessage.m_Message;
|
|
}
|
|
|
|
if (!MiceIpcPushMessage(&ipcMessage, TRUE)) {
|
|
fprintf(stderr, "Failed to log: %.*s", log_len, log_buf);
|
|
}
|
|
|
|
LeaveCriticalSection(&logger_lock);
|
|
return log_len;
|
|
}
|
|
int vlog_trace(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_TRACE, facility, format, args);
|
|
}
|
|
int _log_trace(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_trace(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
int vlog_misc(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_MISC, facility, format, args);
|
|
}
|
|
int _log_misc(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_misc(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
int vlog_info(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_INFO, facility, format, args);
|
|
}
|
|
int _log_info(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_info(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
int vlog_warning(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_WARNING, facility, format, args);
|
|
}
|
|
int _log_warning(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_warning(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
int vlog_error(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_ERROR, facility, format, args);
|
|
}
|
|
int _log_error(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_error(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
int vlog_game(PLOG_FACILITY facility, const char* format, va_list args) {
|
|
return _do_log(LOG_GAME, facility, format, args);
|
|
}
|
|
int _log_game(PLOG_FACILITY facility, const char* format, ...) {
|
|
va_list args;
|
|
va_start(args, format);
|
|
int ret = vlog_game(facility, format, args);
|
|
va_end(args);
|
|
return ret;
|
|
}
|
|
|
|
void setup_logging() { InitializeCriticalSection(&logger_lock); }
|
|
|
|
void log_stack(PLOG_FACILITY facility) {
|
|
char name[MAX_PATH * sizeof(TCHAR)];
|
|
char Storage[sizeof(IMAGEHLP_SYMBOL64) + sizeof(name)];
|
|
|
|
IMAGEHLP_SYMBOL64* symbol = (IMAGEHLP_SYMBOL64*)Storage;
|
|
CONTEXT context;
|
|
RtlCaptureContext(&context);
|
|
|
|
STACKFRAME64 stack = { 0 };
|
|
#ifdef _WIN64
|
|
stack.AddrPC.Offset = context.Rip;
|
|
stack.AddrPC.Mode = AddrModeFlat;
|
|
stack.AddrStack.Offset = context.Rsp;
|
|
stack.AddrStack.Mode = AddrModeFlat;
|
|
stack.AddrFrame.Offset = context.Rbp;
|
|
stack.AddrFrame.Mode = AddrModeFlat;
|
|
#else
|
|
stack.AddrPC.Offset = context.Eip;
|
|
stack.AddrPC.Mode = AddrModeFlat;
|
|
stack.AddrStack.Offset = context.Esp;
|
|
stack.AddrStack.Mode = AddrModeFlat;
|
|
stack.AddrFrame.Offset = context.Ebp;
|
|
stack.AddrFrame.Mode = AddrModeFlat;
|
|
#endif
|
|
|
|
HANDLE process = GetCurrentProcess();
|
|
HANDLE thread = GetCurrentThread();
|
|
BOOL initres = SymInitialize(process, NULL, true);
|
|
for (ULONG frame = 0;; frame++) {
|
|
BOOL result = StackWalk64(IMAGE_FILE_MACHINE_I386, process, thread, &stack, &context, NULL,
|
|
SymFunctionTableAccess64, SymGetModuleBase64, NULL);
|
|
|
|
symbol->SizeOfStruct = sizeof(Storage);
|
|
symbol->MaxNameLength = sizeof(name);
|
|
|
|
DWORD64 displacement;
|
|
SymGetSymFromAddr64(process, (ULONG64)stack.AddrPC.Offset, &displacement, symbol);
|
|
UnDecorateSymbolName(symbol->Name, (PSTR)name, sizeof(name), UNDNAME_COMPLETE);
|
|
|
|
log_error(facility, "%02u called from 0x%08X STACK=0x%08X FRAME=0x%08X %s", frame,
|
|
(ULONG64)stack.AddrPC.Offset, (ULONG64)stack.AddrStack.Offset,
|
|
(ULONG64)stack.AddrFrame.Offset, symbol->Name);
|
|
|
|
if (result == FALSE) {
|
|
DWORD frameError = GetLastError();
|
|
break;
|
|
}
|
|
}
|
|
}
|