/************************************************************************
  *   IRC - Internet Relay Chat, windows/windebug.c
  *   Copyright (C) 2002-2004 Dominick Meglio (codemastr)
  *   
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 1, or (at your option)
  *   any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; if not, write to the Free Software
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include "unrealircd.h"
 #include <dbghelp.h>
 
 #ifndef IRCDTOTALVERSION
 #define IRCDTOTALVERSION BASE_VERSION "-" PATCH1 PATCH2 PATCH3 PATCH4 PATCH5 PATCH6 PATCH7 PATCH8 PATCH9
 #endif
 
 extern OSVERSIONINFO VerInfo;
 extern char OSName[256];
 extern char backupbuf[8192];
 extern char *buildid;
 extern char *extraflags;
 
 /* crappy, but safe :p */
 typedef BOOL (WINAPI *MINIDUMPWRITEDUMP)(HANDLE hProcess, DWORD dwPid, HANDLE hFile, MINIDUMP_TYPE DumpType,
 										CONST PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
 										CONST PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
 										CONST PMINIDUMP_CALLBACK_INFORMATION CallbackParam
 										);
 
 
 /* Runs a stack trace 
  * Parameters:
  *  e - The exception information
  * Returns:
  *  The stack trace with function and line number information
  */
 __inline char *StackTrace(EXCEPTION_POINTERS *e) 
 {
 	static char buffer[5000];
 	char curmodule[256];
 	DWORD symOptions;
 	DWORD64 dwDisp;
 	DWORD dwDisp32;
 	int frame;
 	HANDLE hProcess = GetCurrentProcess();
 	IMAGEHLP_SYMBOL64 *pSym = safe_alloc(sizeof(IMAGEHLP_SYMBOL64)+500);
 	IMAGEHLP_LINE64 pLine;
 	IMAGEHLP_MODULE64 pMod;
 	STACKFRAME64 Stack;
 	CONTEXT context;
 
 	memcpy(&context, e->ContextRecord, sizeof(CONTEXT));
 
 	/* Load the stack information */
 	memset(&Stack, 0, sizeof(Stack));
 	Stack.AddrPC.Offset = e->ContextRecord->Rip;
 	Stack.AddrPC.Mode = AddrModeFlat;
 	Stack.AddrFrame.Offset = e->ContextRecord->Rbp;
 	Stack.AddrFrame.Mode = AddrModeFlat;
 	Stack.AddrStack.Offset = e->ContextRecord->Rsp;
 	Stack.AddrStack.Mode = AddrModeFlat;
 	hProcess = GetCurrentProcess();
 
 	/* Initialize symbol retrieval system */
 	SymInitialize(hProcess, NULL, TRUE);
 	SymSetOptions(SYMOPT_LOAD_LINES|SYMOPT_UNDNAME);
 	pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
 	pSym->MaxNameLength = 500;
 
 	/* Retrieve the first module name */
 	memset(&pMod, 0, sizeof(pMod));
 	pMod.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
 	SymGetModuleInfo64(hProcess, Stack.AddrPC.Offset, &pMod);
 	strcpy(curmodule, pMod.ModuleName);
 	sprintf(buffer, "\tModule: %s\n", pMod.ModuleName);
 
 	/* Walk through the stack */
 	for (frame = 0; ; frame++) 
 	{
 		char buf[500];
 		if (!StackWalk64(IMAGE_FILE_MACHINE_AMD64, GetCurrentProcess(), GetCurrentThread(),
 			&Stack, &context, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
 			break;
 
 		memset(&pMod, 0, sizeof(pMod));
 		pMod.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
 		SymGetModuleInfo64(hProcess, Stack.AddrPC.Offset, &pMod);
 		if (strcmp(curmodule, pMod.ModuleName)) 
 		{
 			strcpy(curmodule, pMod.ModuleName);
 			sprintf(buf, "\tModule: %s\n", pMod.ModuleName);
 			strcat(buffer, buf);
 		}
 
 		memset(&pLine, 0, sizeof(pLine));
 		pLine.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
 		SymGetLineFromAddr64(hProcess, Stack.AddrPC.Offset, &dwDisp32, &pLine);
 		SymGetSymFromAddr64(hProcess, Stack.AddrPC.Offset, &dwDisp, pSym);
 		sprintf(buf, "\t\t#%d %s:%d: %s\n", frame, pLine.FileName, pLine.LineNumber, 
 		        pSym->Name);
 		strcat(buffer, buf);
 	}
 	strcat(buffer, "End of Stack trace\n");
 	return buffer;
 
 }
 
 /* Retrieves the values of several registers
  * Parameters:
  *  context - The CPU context
  * Returns:
  *  The values of the registers as a string.
  */
 __inline char *GetRegisters(CONTEXT *context) 
 {
 	static char buffer[1024];
 
 	sprintf(buffer,
 		"\tRAX=%p"
 		"\tRBX=%p"
 		"\tRCX=%p"
 		"\tRDX=%p\n"
 		"\tRSI=%p"
 		"\tRDI=%p"
 		"\tRBP=%p"
 		"\tRSP=%p\n"
 		"\tR8=%p"
 		"\tR9=%p"
 		"\tR10=%p"
 		"\tR11=%p\n"
 		"\tR12=%p"
 		"\tR13=%p"
 		"\tR14=%p"
 		"\tR15=%p\n"
 		"\tRIP=%p\n",
 		(void *)context->Rax,
 		(void *)context->Rbx,
 		(void *)context->Rcx,
 		(void *)context->Rdx,
 		(void *)context->Rsi,
 		(void *)context->Rdi,
 		(void *)context->Rbp,
 		(void *)context->Rsp,
 		(void *)context->R8,
 		(void *)context->R9,
 		(void *)context->R10,
 		(void *)context->R11,
 		(void *)context->R12,
 		(void *)context->R13,
 		(void *)context->R14,
 		(void *)context->R15,
 		(void *)context->Rip);
 
 	return buffer;
 }
 
 /* Convert the exception code to a human readable string
  * Parameters:
  *  code - The exception code to convert
  * Returns:
  *  The exception code represented as a string
  */
 __inline char *GetException(DWORD code) 
 {
 	switch (code) 
 	{
 		case EXCEPTION_ACCESS_VIOLATION:
 			return "Access Violation";
 		case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 			return "Array Bounds Exceeded";
 		case EXCEPTION_BREAKPOINT:
 			return "Breakpoint";
 		case EXCEPTION_DATATYPE_MISALIGNMENT:
 			return "Datatype Misalignment";
 		case EXCEPTION_FLT_DENORMAL_OPERAND:
 			return "Floating Point Denormal Operand";
 		case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 			return "Floating Point Division By Zero";
 		case EXCEPTION_FLT_INEXACT_RESULT:
 			return "Floating Point Inexact Result";
 		case EXCEPTION_FLT_INVALID_OPERATION:
 			return "Floating Point Invalid Operation";
 		case EXCEPTION_FLT_OVERFLOW:
 			return "Floating Point Overflow";
 		case EXCEPTION_FLT_STACK_CHECK:
 			return "Floating Point Stack Overflow";
 		case EXCEPTION_FLT_UNDERFLOW:
 			return "Floating Point Underflow";
 		case EXCEPTION_ILLEGAL_INSTRUCTION:
 			return "Illegal Instruction";
 		case EXCEPTION_IN_PAGE_ERROR:
 			return "In Page Error";
 		case EXCEPTION_INT_DIVIDE_BY_ZERO:
 			return "Integer Division By Zero";
 		case EXCEPTION_INT_OVERFLOW:
 			return "Integer Overflow";
 		case EXCEPTION_INVALID_DISPOSITION:
 			return "Invalid Disposition";
 		case EXCEPTION_NONCONTINUABLE_EXCEPTION:
 			return "Noncontinuable Exception";
 		case EXCEPTION_PRIV_INSTRUCTION:
 			return "Unallowed Instruction";
 		case EXCEPTION_SINGLE_STEP:
 			return "Single Step";
 		case EXCEPTION_STACK_OVERFLOW:
 			return "Stack Overflow";
 		default:
 			return "Unknown Exception";
 	}
 }
 
 void StartCrashReporter(void)
 {
 	char fname[MAX_PATH], fnamewarg[MAX_PATH+32];
 	PROCESS_INFORMATION pi;
 	STARTUPINFO si;
 	
 	memset(&pi, 0, sizeof(pi));
 	memset(&si, 0, sizeof(si));
 	
 	GetModuleFileName(GetModuleHandle(NULL), fname, MAX_PATH);
 	
 	snprintf(fnamewarg, sizeof(fnamewarg), "\"%s\" %s", fname, "-R");
 	CreateProcess(fname, fnamewarg, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 }
 
 void StartUnrealAgain(void)
 {
 	char fname[MAX_PATH], fnamewarg[MAX_PATH+32];
 	PROCESS_INFORMATION pi;
 	STARTUPINFO si;
 	
 	memset(&pi, 0, sizeof(pi));
 	memset(&si, 0, sizeof(si));
 	
 	GetModuleFileName(GetModuleHandle(NULL), fname, MAX_PATH);
 	
 	snprintf(fnamewarg, sizeof(fnamewarg), "\"%s\"", fname);
 	CreateProcess(fname, NULL, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
 }
 
 /* Callback for the exception handler
  * Parameters:
  *  e - The exception information
  * Returns:
  *  EXCEPTION_EXECUTE_HANDLER to terminate the process
  * Side Effects:
  *  unrealircd.PID.core is created
  *  If not running in service mode, a message box is displayed, 
  *   else output is written to service.log
  */
 LONG __stdcall ExceptionFilter(EXCEPTION_POINTERS *e) 
 {
 	MEMORYSTATUSEX memStats;
 	char file[512], text[1024], minidumpf[512];
 	FILE *fd;
 	time_t timet = time(NULL);
 #ifndef NOMINIDUMP
 	HANDLE hDump;
 	HMODULE hDll = NULL;
 #endif
 
 	sprintf(file, "unrealircd.%d.core", getpid());
 	fd = fopen(file, "w");
 	GlobalMemoryStatusEx(&memStats);
 	fprintf(fd, "Generated at %s\nOS: %s\n%s[%s%s%s] (%s) on %s\n"
 		    "-----------------\nMemory Information:\n"
 		    "\tPhysical: (Available:%lluMB/Total:%lluMB)\n"
 		    "\tVirtual: (Available:%lluMB/Total:%lluMB)\n"
 		    "-----------------\nException:\n\t%s\n-----------------\n"
 		    "Backup Buffer:\n\t%s\n-----------------\nRegisters:\n"
 		    "%s-----------------\nStack Trace:\n%s",
 		     asctime(gmtime(&timet)), OSName,
 			 IRCDTOTALVERSION,
 		     serveropts, extraflags ? extraflags : "", tainted ? "3" : "",
 		     buildid, me.name, memStats.ullAvailPhys/1048576, memStats.ullTotalPhys/1048576,
 		     memStats.ullAvailVirtual/1048576, memStats.ullTotalVirtual/1048576,
 		     GetException(e->ExceptionRecord->ExceptionCode), backupbuf,
 		     GetRegisters(e->ContextRecord), StackTrace(e));
 
 	sprintf(text, "UnrealIRCd has encountered a fatal error. Debugging information has been dumped to %s.", file);
 	fclose(fd);
 
 #ifndef NOMINIDUMP
 	hDll = LoadLibrary("DBGHELP.DLL");
 	if (hDll)
 	{
 		MINIDUMPWRITEDUMP pDump = (MINIDUMPWRITEDUMP)GetProcAddress(hDll, "MiniDumpWriteDump");
 		if (pDump)
 		{
 			MINIDUMP_EXCEPTION_INFORMATION ExInfo;
 			sprintf(minidumpf, "unrealircd.%d.mdmp", getpid());
 			hDump = CreateFile(minidumpf, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 			if (hDump != INVALID_HANDLE_VALUE)
 			{
 				ExInfo.ThreadId = GetCurrentThreadId();
 				ExInfo.ExceptionPointers = e;
 				ExInfo.ClientPointers = 0;
 
 				if (pDump(GetCurrentProcess(), GetCurrentProcessId(), hDump, MiniDumpWithIndirectlyReferencedMemory, &ExInfo, NULL, NULL))
 				{
 					sprintf(text, "UnrealIRCd has encountered a fatal error. Debugging information has been dumped to %s and %s.", file, minidumpf);
 				}
 				CloseHandle(hDump);
 			}
 			sprintf(minidumpf, "unrealircd.%d.full.mdmp", getpid());
 			hDump = CreateFile(minidumpf, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 			if (hDump != INVALID_HANDLE_VALUE)
 			{
 				ExInfo.ThreadId = GetCurrentThreadId();
 				ExInfo.ExceptionPointers = e;
 				ExInfo.ClientPointers = 0;
 
 				pDump(GetCurrentProcess(), GetCurrentProcessId(), hDump, MiniDumpWithPrivateReadWriteMemory, &ExInfo, NULL, NULL);
 				CloseHandle(hDump);
 			}
 		}
 	}
 #endif
 	
 	if (!IsService)
 	{
 		MessageBox(NULL, text, "Fatal Error", MB_OK);
 		StartCrashReporter();
 	}
 	else 
 	{
 		FILE *fd = fopen("logs\\service.log", "a");
 
 		if (fd)
 		{
 			fprintf(fd, "UnrealIRCd has encountered a fatal error. Debugging information "
 					"has been dumped to unrealircd.%d.core, please file a bug and upload "
 					"this file to https://bugs.unrealircd.org/.", getpid());
 			fclose(fd);
 		}
 	}
 	CleanUp();
 	return EXCEPTION_EXECUTE_HANDLER;
 }
 
 void GotSigAbort(int signal)
 {
 	/* I just want to call ExceptionFilter() but it requires an argument which we don't have...
 	 * So just crash, which is rather silly but produces at least a crash report.
 	 * Feel free to improve this!
 	 */
 	char *crash = NULL;
 	*crash = 'X';
 }
 
 /* Initializes the exception handler */
 void InitDebug(void) 
 {
 	SetUnhandledExceptionFilter(&ExceptionFilter);
 	_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 	signal(SIGABRT, GotSigAbort);
 }
 
 

© 2023 acidvegas, inc • generated with stagit