void minidump_write(const char* file, const EXCEPTION_RECORD* rec)
{
HANDLE hFile;
MINIDUMP_EXCEPTION_INFORMATION mei;
EXCEPTION_POINTERS ep;
DWORD wine_opt;
hFile = CreateFile(file, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE) return;
if (rec)
{
mei.ThreadId = dbg_curr_thread->tid;
mei.ExceptionPointers = &ep;
ep.ExceptionRecord = (EXCEPTION_RECORD*)rec;
ep.ContextRecord = &dbg_context;
mei.ClientPointers = FALSE;
}
/* this is a wine specific options to return also ELF modules in the
* dumping
*/
SymSetOptions((wine_opt = SymGetOptions()) | 0x40000000);
MiniDumpWriteDump(dbg_curr_process->handle, dbg_curr_process->pid,
hFile, MiniDumpNormal/*|MiniDumpWithDataSegs*/,
rec ? &mei : NULL, NULL, NULL);
SymSetOptions(wine_opt);
CloseHandle(hFile);
}
int32 CrashHandler::DumpFile(MY_EXCEPTION_POINTERS* pExceptionPointers, const char* sAppName)
{
char szFileName[MAX_PATH];
uint32 dwBufferSize = MAX_PATH;
SYSTEMTIME stLocalTime;
::GetLocalTime(&stLocalTime);
sprintf( szFileName, "%s-%04d%02d%02d-%02d%02d%02d.dmp", sAppName,
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond);
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
ExpParam.ThreadId = ::GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = NULL;
HANDLE hDumpFile = ::CreateFile( szFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
MINIDUMP_TYPE mDumpValue = (MINIDUMP_TYPE)(
MiniDumpNormal |
MiniDumpWithIndirectlyReferencedMemory |
MiniDumpWithDataSegs |
MiniDumpWithFullMemory
);
bool bMiniDumpSucessful = MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, mDumpValue, &ExpParam, NULL, NULL);
::CloseHandle(hDumpFile);
return bMiniDumpSucessful;
}
int TVPWriteHWEDumpFile( EXCEPTION_POINTERS* pExceptionPointers ) {
BOOL bMiniDumpSuccessful;
WCHAR szPath[MAX_PATH];
WCHAR szFileName[MAX_PATH];
const wchar_t* szAppName = TVPKirikiri;
const wchar_t* szVersion = TVPGetVersionString().c_str();
TVPEnsureDataPathDirectory();
TJS_strcpy(szPath, TVPNativeDataPath.c_str());
SYSTEMTIME stLocalTime;
::GetLocalTime( &stLocalTime );
StringCchPrintf( szFileName, MAX_PATH, L"%s%s%s-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp",
szPath, szAppName, szVersion,
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,
GetCurrentProcessId(), GetCurrentThreadId());
HANDLE hDumpFile = ::CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
ExpParam.ThreadId = ::GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
bMiniDumpSuccessful = MiniDumpWriteDump( ::GetCurrentProcess(), ::GetCurrentProcessId(), hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
return EXCEPTION_EXECUTE_HANDLER;
}
//===========================================================
// Entry point where control comes on an unhandled exception
//===========================================================
LONG WINAPI WheatyExceptionReport::WheatyUnhandledExceptionFilter(
PEXCEPTION_POINTERS pExceptionInfo) {
TCHAR module_folder_name[MAX_PATH];
GetModuleFileName(0, module_folder_name, MAX_PATH);
TCHAR* pos = _tcsrchr(module_folder_name, '\\');
if (!pos)
return 0;
pos[0] = '\0';
++pos;
TCHAR crash_folder_path[MAX_PATH];
sprintf(crash_folder_path, "%s\\%s", module_folder_name, CrashFolder);
if (!CreateDirectory(crash_folder_path, NULL)) {
if (GetLastError() != ERROR_ALREADY_EXISTS)
return 0;
}
SYSTEMTIME systime;
GetLocalTime(&systime);
sprintf(m_szDumpFileName, "%s\\%s_%s_[%u-%u_%u-%u-%u].dmp",
crash_folder_path, _HASH, pos, systime.wDay, systime.wMonth,
systime.wHour, systime.wMinute, systime.wSecond);
sprintf(m_szLogFileName, "%s\\%s_%s_[%u-%u_%u-%u-%u].txt",
crash_folder_path, _HASH, pos, systime.wDay, systime.wMonth,
systime.wHour, systime.wMinute, systime.wSecond);
m_hDumpFile = CreateFile(m_szDumpFileName, GENERIC_WRITE, 0, 0, OPEN_ALWAYS,
FILE_FLAG_WRITE_THROUGH, 0);
m_hReportFile = CreateFile(m_szLogFileName, GENERIC_WRITE, 0, 0,
OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, 0);
if (m_hDumpFile) {
MINIDUMP_EXCEPTION_INFORMATION info;
info.ClientPointers = FALSE;
info.ExceptionPointers = pExceptionInfo;
info.ThreadId = GetCurrentThreadId();
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
m_hDumpFile, MiniDumpWithIndirectlyReferencedMemory, &info, 0,
0);
CloseHandle(m_hDumpFile);
}
if (m_hReportFile) {
SetFilePointer(m_hReportFile, 0, 0, FILE_END);
GenerateExceptionReport(pExceptionInfo);
CloseHandle(m_hReportFile);
m_hReportFile = 0;
}
if (m_previousFilter)
return m_previousFilter(pExceptionInfo);
else
return EXCEPTION_EXECUTE_HANDLER/*EXCEPTION_CONTINUE_SEARCH*/;
}
static LONG WINAPI ExceptionHandler(struct _EXCEPTION_POINTERS *excp)
{
printf("#### Unhandled exception caught: data @ %p\n", (void *)excp);
#if defined(_MSC_VER)
if (0 != excp)
{
char *miniDumpPathName = "minidumptest.dmp";
HANDLE currentProcessHandle = GetCurrentProcess();
DWORD processId = GetCurrentProcessId();
MINIDUMP_TYPE type = MiniDumpNormal;
HANDLE outputFileHandle = CreateFile(miniDumpPathName, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
exceptionInfo.ThreadId = GetCurrentThreadId();
exceptionInfo.ExceptionPointers = excp;
exceptionInfo.ClientPointers = FALSE;
if (INVALID_HANDLE_VALUE != outputFileHandle)
{
MiniDumpWriteDump(currentProcessHandle, processId, outputFileHandle, type, &exceptionInfo, 0, 0);
CloseHandle(outputFileHandle);
}
else
{
printf("Cannot create minidump file '%s'\n", miniDumpPathName);
}
}
#endif /* defined(_MSC_VER) */
return EXCEPTION_CONTINUE_SEARCH;
}
LONG WINAPI DebugTools::SelfUnhandledException(struct _EXCEPTION_POINTERS *ExceptionInfo)
{
wchar_t path[MAX_PATH];
::GetModuleFileNameW(nullptr,path,MAX_PATH);
wcscat_s(path,L".dmp");
HANDLE hDumpFile=CreateFileW(path,GENERIC_WRITE,0,nullptr,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,nullptr);
MINIDUMP_EXCEPTION_INFORMATION eInfo;
eInfo.ThreadId = GetCurrentThreadId();
eInfo.ExceptionPointers = ExceptionInfo;
eInfo.ClientPointers = FALSE;
MINIDUMP_CALLBACK_INFORMATION cbMiniDump;
cbMiniDump.CallbackRoutine = 0;
cbMiniDump.CallbackParam = 0;
MiniDumpWriteDump(
GetCurrentProcess(),
GetCurrentProcessId(),
hDumpFile,
MiniDumpNormal,
&eInfo,
nullptr,
&cbMiniDump);
CloseHandle(hDumpFile);
return EXCEPTION_EXECUTE_HANDLER;
}
long WINAPI ExceptionFilter(EXCEPTION_POINTERS * lParam)
{
//DateTime dateTime(GetCurDateTime());
char strFileName[64] = "leeloo_webserver.dmp";
//std::string stdstrDumpName = ConfigSingleton::Instance().GetItem(ICEARK_DUMPNAME_SYSTEM_CONFIG);
//if(stdstrDumpName.compare(ICEARK_BLANK_SYSTEM_CONFIG) == 0)
// stdstrDumpName = "iceark";
//std::string stdstrOutputpath = ConfigSingleton::Instance().GetItem(ICEARK_OUTPUTPATH_SYSTEM_CONFIG);
//if(stdstrOutputpath.compare(ICEARK_BLANK_SYSTEM_CONFIG) == 0)
// sprintf(strFileName, "dump_%s_%04d_%02d_%02d_%02d_%02d_%02d.dmp", stdstrDumpName.c_str(), dateTime.year(), dateTime.month(), dateTime.day(), dateTime.hour(), dateTime.minute(), dateTime.second());
//else
// sprintf(strFileName, "%sdump_%s_%04d_%02d_%02d_%02d_%02d_%02d.dmp", stdstrOutputpath.c_str(), stdstrDumpName.c_str(), dateTime.year(), dateTime.month(), dateTime.day(), dateTime.hour(), dateTime.minute(), dateTime.second());
//strFileName = "ztcache.dmp";
HANDLE hFile = ::CreateFile( strFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if( hFile != INVALID_HANDLE_VALUE)
{
MINIDUMP_EXCEPTION_INFORMATION einfo;
einfo.ThreadId = ::GetCurrentThreadId();
einfo.ExceptionPointers = lParam;
einfo.ClientPointers = FALSE;
MiniDumpWriteDump(::GetCurrentProcess(), ::GetCurrentProcessId(), hFile, MiniDumpNormal, &einfo, NULL, NULL);
CloseHandle(hFile);
}
return EXCEPTION_EXECUTE_HANDLER;
}
LONG WINAPI GenerateDump(EXCEPTION_POINTERS* pExceptionPointers)
{
BOOL bMiniDumpSuccessful;
CHAR szFileName[MAX_PATH];
CHAR* szAppName = (CHAR *)Name.c_str();
CHAR* szVersion = (CHAR *)Version.c_str();
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
SYSTEMTIME stLocalTime;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
GetLocalTime(&stLocalTime);
StringCchPrintfA(szFileName, MAX_PATH, "%s_%s-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp",
szAppName, szVersion, stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond, GetCurrentProcessId(), GetCurrentThreadId());
hDumpFile = CreateFileA(szFileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
return EXCEPTION_EXECUTE_HANDLER;
}
void CrashHandlerWindows::writeCrashDump(PEXCEPTION_POINTERS pointers) {
GetTempPath(boost::size(m_pCrashInfo->miniDumpTmpFile), m_pCrashInfo->miniDumpTmpFile);
WCHAR tick[24];
_ultow(GetTickCount(), tick, 10);
wcscat(m_pCrashInfo->miniDumpTmpFile, tick);
wcscat(m_pCrashInfo->miniDumpTmpFile, L"-arx-crash.dmp");
HANDLE file = CreateFileW(m_pCrashInfo->miniDumpTmpFile, GENERIC_READ | GENERIC_WRITE,
0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(file == INVALID_HANDLE_VALUE) {
return;
}
MINIDUMP_TYPE miniDumpType = (MINIDUMP_TYPE)(MiniDumpWithIndirectlyReferencedMemory
| MiniDumpScanMemory);
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
exceptionInfo.ThreadId = m_pCrashInfo->threadId;
exceptionInfo.ExceptionPointers = pointers;
exceptionInfo.ClientPointers = TRUE;
// Write the minidump
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), file, miniDumpType,
&exceptionInfo, NULL, NULL);
CloseHandle(file);
}
int GenerateDump(EXCEPTION_POINTERS *pExceptionPointers)
{
bool bMiniDumpSuccessful;
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
hDumpFile = CreateFile(p_filenames->MiniDumpFilename(),
GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ,
0, CREATE_ALWAYS, 0, 0);
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
MINIDUMP_TYPE mdt = (MINIDUMP_TYPE) (MiniDumpWithPrivateReadWriteMemory |
MiniDumpWithDataSegs |
MiniDumpWithHandleData |
MiniDumpWithFullMemoryInfo |
MiniDumpWithThreadInfo |
MiniDumpWithUnloadedModules);
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile,
mdt, &ExpParam, NULL, NULL);
return EXCEPTION_EXECUTE_HANDLER;
}
static void create_mini_dump(PEXCEPTION_POINTERS pep, LPCTSTR filename)
{
HANDLE file = CreateFile(filename, GENERIC_READ | GENERIC_WRITE,
0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (file && file != INVALID_HANDLE_VALUE)
{
MINIDUMP_EXCEPTION_INFORMATION mei;
mei.ThreadId = GetCurrentThreadId();
mei.ExceptionPointers = pep;
mei.ClientPointers = FALSE;
MINIDUMP_CALLBACK_INFORMATION mci;
mci.CallbackRoutine = (MINIDUMP_CALLBACK_ROUTINE)mini_dump_callback;
mci.CallbackParam = 0;
MINIDUMP_TYPE mdt = (MINIDUMP_TYPE)(MiniDumpWithPrivateReadWriteMemory |
MiniDumpWithDataSegs |
MiniDumpWithHandleData |
MiniDumpWithFullMemoryInfo |
MiniDumpWithThreadInfo |
MiniDumpWithUnloadedModules);
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
file, mdt, (pep != 0) ? &mei : 0, 0, &mci);
CloseHandle(file);
}
}
LONG WINAPI DetourUnhandledExceptionFilter(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
// 记录用户出错信息
if (NULL != ExceptionInfo)
{
WCHAR szDumpFile[MAX_PATH] = {0};
ExpandEnvironmentStringsW(L"%APPDATA%\\MoneyHub\\MoneyhubDmp.dmp", szDumpFile, MAX_PATH);
HANDLE hDumpFile = CreateFile(szDumpFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL ,NULL);
MINIDUMP_EXCEPTION_INFORMATION stMiniDumpExceptionInfo;
stMiniDumpExceptionInfo.ExceptionPointers = ExceptionInfo;
stMiniDumpExceptionInfo.ThreadId = GetCurrentThreadId();
stMiniDumpExceptionInfo.ClientPointers = TRUE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile,
MiniDumpNormal, &stMiniDumpExceptionInfo, NULL, NULL);
CloseHandle(hDumpFile);
DWORD dwAddr = (DWORD)ExceptionInfo->ExceptionRecord->ExceptionAddress;
CRecordProgram::GetInstance()->FeedbackError(MY_ERROR_PRO_CORE, ERR_UNHANDLE_EXCEPT,
CRecordProgram::GetInstance()->GetRecordInfo(L"UnhandledException Errorcode = %d, ErrAddress = %08x", ExceptionInfo->ExceptionRecord->ExceptionCode, dwAddr));
exit(0);
return 0;
}
return OldUnhandledExceptionFilter(ExceptionInfo);
}
void CrashHandlerWindows::writeCrashDump(PEXCEPTION_POINTERS pExceptionPointers) {
// Build the temporary path to store the minidump
CHAR* tempPathBuffer = m_pCrashInfo->miniDumpTmpFile;
GetTempPath(MAX_PATH, m_pCrashInfo->miniDumpTmpFile);
DWORD tick = GetTickCount();
char tickChar[24];
_ultoa(tick, tickChar, 10);
strcat(&tempPathBuffer[0], tickChar);
strcat(&tempPathBuffer[0], ".dmp");
// Create the minidump file
HANDLE hFile = CreateFile(tempPathBuffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile == INVALID_HANDLE_VALUE)
return;
MINIDUMP_TYPE miniDumpType = (MINIDUMP_TYPE)(MiniDumpWithIndirectlyReferencedMemory | MiniDumpScanMemory);
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
exceptionInfo.ThreadId = GetCurrentThreadId();
exceptionInfo.ExceptionPointers = pExceptionPointers;
exceptionInfo.ClientPointers = TRUE;
MINIDUMP_CALLBACK_INFORMATION callbackInfo;
callbackInfo.CallbackRoutine = miniDumpCallback;
callbackInfo.CallbackParam = 0;
// Write the minidump
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, miniDumpType, &exceptionInfo, NULL, NULL);
CloseHandle(hFile);
}
LONG WINAPI CMiniDumpHelp::ProcessMiniDump(__in PEXCEPTION_POINTERS pExceptionPointer)
{
MINIDUMP_EXCEPTION_INFORMATION MinidumpExceptionInformation;
std::wstring dump_filename = CMiniDumpHelp::GetDumpFilename();
MinidumpExceptionInformation.ThreadId = ::GetCurrentThreadId();
MinidumpExceptionInformation.ExceptionPointers = pExceptionPointer;
MinidumpExceptionInformation.ClientPointers = FALSE;
if (dump_filename.empty() == true)
{
::TerminateProcess(::GetCurrentProcess(), 0);
}
HANDLE hDumpFile = ::CreateFileW( dump_filename.c_str()
, GENERIC_WRITE
, FILE_SHARE_WRITE
, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL);
MiniDumpWriteDump( GetCurrentProcess()
, GetCurrentProcessId()
, hDumpFile
, MiniDumpNormal
, &MinidumpExceptionInformation
, NULL
, NULL);
::TerminateProcess(::GetCurrentProcess(), 0);
return 0;
}
int GenerateDump(EXCEPTION_POINTERS* pExceptionPointers)
{
BOOL bMiniDumpSuccessful;
TCHAR szPath[MAX_PATH];
TCHAR szFileName[MAX_PATH];
TCHAR* szAppName = "GameWorld";
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
SYSTEMTIME stLocalTime;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
GetLocalTime( &stLocalTime );
GetTempPath( dwBufferSize, szPath );
StringCchPrintf( szFileName, MAX_PATH, "%s%s", szPath, szAppName );
CreateDirectory( szFileName, NULL );
StringCchPrintf( szFileName, MAX_PATH, "Data\\Online\\%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp",
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,
GetCurrentProcessId(), GetCurrentThreadId());
hDumpFile = CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
return EXCEPTION_EXECUTE_HANDLER;
}
int generate_dump(EXCEPTION_POINTERS* pExceptionPointers)
{
// Add a hardcoded check to guarantee we only write a dump file of the first crash exception that is received.
// Sometimes a crash is so bad that writing the dump below causes another exception to occur, in which case
// this function would be recursively called, spawning tons of error dialogs to the user.
static bool dumpGenerated = false;
if (dumpGenerated)
{
printf("WARNING: Not generating another dump, one has been generated already!\n");
return 0;
}
dumpGenerated = true;
BOOL bMiniDumpSuccessful;
WCHAR szPath[MAX_PATH];
WCHAR szFileName[MAX_PATH];
// Can't use Application for application name and version,
// since it might have not been initialized yet, or it might have caused
// the exception in the first place
WCHAR* szAppName = L"realXtend";
WCHAR* szVersion = L"Tundra_v2.0";
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
SYSTEMTIME stLocalTime;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
GetLocalTime( &stLocalTime );
GetTempPathW( dwBufferSize, szPath );
StringCchPrintf( szFileName, MAX_PATH, L"%s%s", szPath, szAppName );
CreateDirectoryW( szFileName, 0 );
StringCchPrintf( szFileName, MAX_PATH, L"%s%s\\%s-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp",
szPath, szAppName, szVersion,
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,
GetCurrentProcessId(), GetCurrentThreadId());
hDumpFile = CreateFileW(szFileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpWithDataSegs, &ExpParam, 0, 0);
std::wstring message(L"Program ");
message += szAppName;
message += L" encountered an unexpected error.\n\nCrashdump was saved to location:\n";
message += szFileName;
if (bMiniDumpSuccessful)
Application::Message(L"Minidump generated!", message);
else
Application::Message(szAppName, L"Unexpected error was encountered while generating minidump!");
return EXCEPTION_EXECUTE_HANDLER;
}
LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
std::string str;
{
char buf[260];
memset(buf,0, sizeof(buf));
GetModuleFileName(NULL, buf, 259);
std::string s;
s = buf;
std::string::size_type pos = s.rfind("\\");
if (pos != std::string::npos)
{
s.substr(pos, std::string::npos);
}
str = s;
tm t;
time_t tt=time(NULL);
localtime_s(&t, &tt);
sprintf(buf, "_%04d_%02d_%02d_%02d_%02d_%02d", t.tm_year+1900, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec);
str += buf;
}
str += ".dmp";
HANDLE lhDumpFile = CreateFile(str.c_str(), GENERIC_WRITE, 0, NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL ,NULL);
MINIDUMP_EXCEPTION_INFORMATION loExceptionInfo;
loExceptionInfo.ExceptionPointers = ExceptionInfo;
loExceptionInfo.ThreadId = GetCurrentThreadId();
loExceptionInfo.ClientPointers = TRUE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),lhDumpFile, MiniDumpNormal, &loExceptionInfo, NULL, NULL);
CloseHandle(lhDumpFile);
return EXCEPTION_EXECUTE_HANDLER;
}
clsProcessDump::clsProcessDump(HANDLE processHandle, DWORD processID, QString filePath, QWidget *pParent)
{
QString dumpFilePath = QFileDialog::getSaveFileName(pParent,
"Please select a path to save the dump",
QString("DUMP_%1_%2.dmp").arg(filePath).arg(processID,6,10,QChar('0')),
"Dump files (*.dmp)",
NULL,
QFileDialog::DontUseNativeDialog);
if(dumpFilePath.length() <= 0) return;
HANDLE dumpFile = CreateFileW(dumpFilePath.toStdWString().c_str(), GENERIC_READ | GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(dumpFile != INVALID_HANDLE_VALUE)
{
MINIDUMP_TYPE dumpTyp = (MINIDUMP_TYPE)( MiniDumpWithFullMemoryInfo |
MiniDumpWithIndirectlyReferencedMemory |
MiniDumpWithFullMemory |
MiniDumpWithHandleData |
MiniDumpWithProcessThreadData |
MiniDumpWithThreadInfo |
MiniDumpWithUnloadedModules );
if(MiniDumpWriteDump(processHandle, processID, dumpFile, dumpTyp, NULL, NULL, NULL))
QMessageBox::information(pParent,"Nanomite","Process dump was successfull!",QMessageBox::Ok,QMessageBox::Ok);
CloseHandle(dumpFile);
return;
}
QMessageBox::critical(pParent,"Nanomite","Process dump has failed!",QMessageBox::Ok,QMessageBox::Ok);
}
int GenerateDump(EXCEPTION_POINTERS *pExceptionPointers)
{
bool bMiniDumpSuccessful;
char szFileName[MAX_PATH];
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
SYSTEMTIME stLocalTime;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
GetLocalTime(&stLocalTime);
sprintf_s(szFileName, MAX_PATH, "%s\\%s-%s-%04d%02d%02d-%02d%02d%02d-%ld-%ld.dmp", _startup_path,
"ManualMode", VERSION_TEXT, stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond, GetCurrentProcessId(),
GetCurrentThreadId());
hDumpFile = CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_WRITE|FILE_SHARE_READ,
0, CREATE_ALWAYS, 0, 0);
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
MINIDUMP_TYPE mdt = (MINIDUMP_TYPE) (MiniDumpWithPrivateReadWriteMemory |
MiniDumpWithDataSegs |
MiniDumpWithHandleData |
MiniDumpWithFullMemoryInfo |
MiniDumpWithThreadInfo |
MiniDumpWithUnloadedModules);
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hDumpFile,
mdt, &ExpParam, NULL, NULL);
return EXCEPTION_EXECUTE_HANDLER;
}
// Handler function that writes out a dump file
LONG WINAPI Handler(_EXCEPTION_POINTERS * exPointers)
{
HANDLE theFile = CreateFileA("myDumpFile.mdmp",
GENERIC_WRITE,
FILE_SHARE_WRITE,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (theFile != INVALID_HANDLE_VALUE)
{
_MINIDUMP_EXCEPTION_INFORMATION exInfo;
exInfo.ClientPointers = NULL;
exInfo.ThreadId = GetCurrentThreadId();
exInfo.ExceptionPointers = exPointers;
// Write The Minidump
MiniDumpWriteDump(GetCurrentProcess(),
GetCurrentProcessId(),
theFile,
MiniDumpNormal,
&exInfo,
NULL,
NULL);
MessageBoxA(0, "myDumpFile.mdmp", "MiniDump was saved",MB_OK);
}
return EXCEPTION_EXECUTE_HANDLER;
}
LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
// 先生成目录
easygame::Platform::createDirectorys(g_dumpPath.c_str());
// 输出minidump文件
string timestamp = getTimeStamp();
string strFilePrev = g_dumpPath;
strFilePrev += g_dumpName;
strFilePrev += "_";
strFilePrev += timestamp;
string strDumpFile = strFilePrev;
strDumpFile += ".dmp";
HANDLE lhDumpFile = CreateFile(strDumpFile.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL ,NULL);
MINIDUMP_EXCEPTION_INFORMATION loExceptionInfo;
loExceptionInfo.ExceptionPointers = ExceptionInfo;
loExceptionInfo.ThreadId = GetCurrentThreadId();
loExceptionInfo.ClientPointers = TRUE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),lhDumpFile, MiniDumpNormal, &loExceptionInfo, NULL, NULL);
CloseHandle(lhDumpFile);
// 日志文件
string strStackFile = strFilePrev;
strStackFile += ".txt";
FileStackWalker fsw(strStackFile.c_str());
fsw.ShowCallstack(GetCurrentThread(), ExceptionInfo->ContextRecord);
return EXCEPTION_EXECUTE_HANDLER;
}
static LONG WINAPI CreateMiniDump( EXCEPTION_POINTERS* pep )
{
r3dOutToLog("Creating minidump!!\n");
// Open the file
char miniDumpPath[1024];
if(CreateConfigPath(miniDumpPath))
{
strcat( miniDumpPath, "MiniDump.dmp" );
r3dOutToLog("Minidump path: %s\n", miniDumpPath);
HANDLE hFile = CreateFile( miniDumpPath, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if( ( hFile != NULL ) && ( hFile != INVALID_HANDLE_VALUE ) )
{
// Create the minidump
MINIDUMP_EXCEPTION_INFORMATION mdei;
mdei.ThreadId = GetCurrentThreadId();
mdei.ExceptionPointers = pep;
mdei.ClientPointers = FALSE;
MINIDUMP_CALLBACK_INFORMATION mci;
mci.CallbackRoutine = (MINIDUMP_CALLBACK_ROUTINE)MyMiniDumpCallback;
mci.CallbackParam = 0;
MINIDUMP_TYPE mdt = (MINIDUMP_TYPE)(MiniDumpWithIndirectlyReferencedMemory | MiniDumpScanMemory);
BOOL rv = MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(),
hFile, mdt, (pep != 0) ? &mdei : 0, 0, &mci );
if( !rv )
r3dOutToLog( "MiniDumpWriteDump failed. Error: %u \n", GetLastError() );
else
r3dOutToLog( "Minidump created.\n" );
// Close the file
CloseHandle( hFile );
}
else
{
r3dOutToLog( "CreateFile failed. Error: %u \n", GetLastError() );
}
r3dOutToLog("\n!!!Crash!!!\nPlease send '%s' to support@localhost\nThank you.", miniDumpPath);
// hide window, hopefully will work in fullscreen
ShowWindow(win::hWnd, SW_FORCEMINIMIZE);
// show message box to user
char tempStr[2048];
sprintf(tempStr, "Application crashed.\nPlease send '%s' and r3dLog.txt (in install folder of the game) to support@localhost along with description of what you were doing at the time of crash.\nThank you and sorry for inconvenience.", miniDumpPath);
MessageBox(0, tempStr, "Crash", MB_OK);
}
r3dCloseLogFile();
// call WINDOWS ERROR REPORTING, in case if user will not send us crashdump
LONG lRet = EXCEPTION_CONTINUE_SEARCH;
lRet = EXCEPTION_EXECUTE_HANDLER;
return lRet ;
}
long WINAPI Win32ExceptionHandler(struct _EXCEPTION_POINTERS *pExceptInfo)
{
char buf[512];
MINIDUMP_EXCEPTION_INFORMATION mdei;
MINIDUMP_USER_STREAM_INFORMATION mdusi;
MINIDUMP_USER_STREAM mdus;
bool minidump_created = false;
std::string dumpfile = porting::path_user + DIR_DELIM PROJECT_NAME ".dmp";
std::string version_str(PROJECT_NAME " ");
version_str += g_version_hash;
HANDLE hFile = CreateFileA(dumpfile.c_str(), GENERIC_WRITE,
FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
goto minidump_failed;
if (SetEndOfFile(hFile) == FALSE)
goto minidump_failed;
mdei.ClientPointers = NULL;
mdei.ExceptionPointers = pExceptInfo;
mdei.ThreadId = GetCurrentThreadId();
mdus.Type = CommentStreamA;
mdus.BufferSize = version_str.size();
mdus.Buffer = (PVOID)version_str.c_str();
mdusi.UserStreamArray = &mdus;
mdusi.UserStreamCount = 1;
if (MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile,
MiniDumpNormal, &mdei, &mdusi, NULL) == FALSE)
goto minidump_failed;
minidump_created = true;
minidump_failed:
CloseHandle(hFile);
DWORD excode = pExceptInfo->ExceptionRecord->ExceptionCode;
_snprintf(buf, sizeof(buf),
" >> === FATAL ERROR ===\n"
" >> %s (Exception 0x%08X) at 0x%p\n",
Win32ExceptionCodeToString(excode), excode,
pExceptInfo->ExceptionRecord->ExceptionAddress);
dstream << buf;
if (minidump_created)
dstream << " >> Saved dump to " << dumpfile << std::endl;
else
dstream << " >> Failed to save dump" << std::endl;
return EXCEPTION_EXECUTE_HANDLER;
}
void CreateMiniDump(HANDLE hDumpFile, PEXCEPTION_POINTERS exc_ptr)
{
MINIDUMP_EXCEPTION_INFORMATION exceptionInfo;
exceptionInfo.ThreadId = GetCurrentThreadId();
exceptionInfo.ExceptionPointers = exc_ptr;
exceptionInfo.ClientPointers = false;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpNormal, &exceptionInfo, NULL, NULL);
}
long ExceptionHandler::MiniDumpExceptionHandler(EXCEPTION_POINTERS* exceptionPointers /*= NULL*/)
{
std::clog << "Unhandled exception, generating minidump..." << std::endl;
SYSTEMTIME systemTime;
GetSystemTime(&systemTime);
// "theforgottenserver_DD-MM-YYYY_HH-MM-SS.mdmp"
char fileName[64] = {"\0"};
sprintf(fileName, "theforgottenserver_%02u-%02u-%04u_%02u-%02u-%02u.mdmp",
systemTime.wDay, systemTime.wMonth, systemTime.wYear,
systemTime.wHour, systemTime.wMinute, systemTime.wSecond);
// Create the dump file
HANDLE hFile = CreateFileA(fileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
// If we cannot create the file, then we cannot dump the memory
if(!hFile || hFile == INVALID_HANDLE_VALUE)
{
std::clog << "Cannot create dump file, error: " << GetLastError() << std::endl;
return EXCEPTION_CONTINUE_SEARCH;
}
// Collect the exception information
MINIDUMP_EXCEPTION_INFORMATION exceptionInformation;
exceptionInformation.ClientPointers = FALSE;
exceptionInformation.ExceptionPointers = exceptionPointers;
exceptionInformation.ThreadId = GetCurrentThreadId();
HANDLE hProcess = GetCurrentProcess();
DWORD processId = GetProcessId(hProcess);
MINIDUMP_TYPE flags = (MINIDUMP_TYPE)(MiniDumpWithIndirectlyReferencedMemory);
BOOL dumpResult = MiniDumpWriteDump(hProcess, processId, hFile, flags,
&exceptionInformation, NULL, NULL);
// Delete the dump file if we cannot generate the crash trace
if(!dumpResult)
{
std::clog << "Cannot generate minidump, error: " << GetLastError() << std::endl;
//Close file and delete it
CloseHandle(hFile);
DeleteFileA(fileName);
return EXCEPTION_CONTINUE_SEARCH;
}
CloseHandle(hFile);
return EXCEPTION_EXECUTE_HANDLER;
}
LONG CALLBACK clsCrashHandler::ErrorReporter(PEXCEPTION_POINTERS pExceptionPtrs)
{
// Windows RPC Exception, happens on OpenFile Dialog, seems to come only on > XP and can be ignored
// 0x406d1388 = SetThreadName Exception from cruntime, ignore!
// 0x40010006 = STRG + C from cruntime, ignore!
if(pExceptionPtrs->ExceptionRecord->ExceptionCode == 0x000006ba ||
pExceptionPtrs->ExceptionRecord->ExceptionCode == 0x406d1388 ||
pExceptionPtrs->ExceptionRecord->ExceptionCode == 0xE0000001 ||
pExceptionPtrs->ExceptionRecord->ExceptionCode == 0x40010006)
return EXCEPTION_EXECUTE_HANDLER;
PTCHAR szCrashDumpName = (PTCHAR)malloc(MAX_PATH * sizeof(TCHAR));
time_t tTime;
tm* timeInfo;
time(&tTime);
timeInfo = localtime(&tTime);
swprintf_s(szCrashDumpName,MAX_PATH,L"Nanomite_%d-%d_%d.%d_crash.dmp",
timeInfo->tm_mday,
timeInfo->tm_mon + 1,
timeInfo->tm_hour,
timeInfo->tm_min);
HANDLE hFile = CreateFile(szCrashDumpName, GENERIC_READ | GENERIC_WRITE, NULL,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
MINIDUMP_EXCEPTION_INFORMATION mdei;
mdei.ThreadId = GetCurrentThreadId();
mdei.ExceptionPointers = pExceptionPtrs;
mdei.ClientPointers = TRUE;
MINIDUMP_TYPE dumpTyp = (MINIDUMP_TYPE)(MiniDumpWithFullMemoryInfo |
MiniDumpWithHandleData |
MiniDumpWithThreadInfo |
MiniDumpWithUnloadedModules );
if(MiniDumpWriteDump(GetCurrentProcess(),GetCurrentProcessId(),hFile, dumpTyp, &mdei, NULL, NULL))
MessageBoxW(NULL,L"Please send the dumpfile to [email protected]",L"Nanomite crashed!",MB_OK);
else
MessageBoxW(NULL,L"Nanomite crashed and was unable to write a dumpfile!",L"Nanomite crashed!",MB_OK);
CloseHandle(hFile);
}
free(szCrashDumpName);
if(IsDebuggerPresent())
return EXCEPTION_EXECUTE_HANDLER;
else
return TerminateProcess(GetCurrentProcess(),1);
}
void NTServerManager::PacketProcessingThread()
{
// A ping of < 30ms should be acceptable.
std::chrono::milliseconds SleepDuration(30);
while (true)
{
std::this_thread::sleep_for(SleepDuration);
for (auto Iterator = Host_ServerAddresses.begin(); Iterator != Host_ServerAddresses.end(); ++Iterator)
{
try
{
Iterator->second->Internal_RunServerFrame();
}
catch (const std::exception &Exception)
{
DebugPrint("\n\n\n==========================================================");
DebugPrint("OpenNet error");
DebugPrint(Exception.what());
DebugPrint("\n=============================================\n");
DebugPrint("One of the local socket processes threw an unhandled exception.");
DebugPrint("The plugin may still work in offline mode but should be restarted.");
HANDLE hFile = INVALID_HANDLE_VALUE;
hFile = CreateFileA("OpenNetCrash.dmp", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
if(strstr(GetCommandLineA(), "-handledump"))
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpWithHandleData, NULL, NULL, NULL);
else
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, NULL, NULL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
CloseHandle(hFile);
}
}
}
}
}
LONG WINAPI CBMPApp::MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS* ExceptionInfo)
{
typedef BOOL (WINAPI * PMiniDumpWriteDump)(
__in HANDLE hProcess,
__in DWORD ProcessId,
__in HANDLE hFile,
__in MINIDUMP_TYPE DumpType,
__in_opt PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
__in_opt PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
__in_opt PMINIDUMP_CALLBACK_INFORMATION CallbackParam
);
PMiniDumpWriteDump MiniDumpWriteDump=NULL;
HMODULE hModule=LoadLibrary(_T("dbghelp.dll"));
if( hModule!=NULL)
{
MiniDumpWriteDump=(PMiniDumpWriteDump)GetProcAddress(hModule,"MiniDumpWriteDump");
if( MiniDumpWriteDump==NULL)
{
FreeLibrary(hModule);
hModule=NULL;
return EXCEPTION_CONTINUE_SEARCH;
}
}
CTime tm=CTime::GetCurrentTime();
CString strTm=tm.Format("%d-%H-%M-%S.dmp");
CString strFileName=CPathUtilEx::Instance()->GetImagePath()+strTm;
HANDLE lhDumpFile=CreateFile(strFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
if( INVALID_HANDLE_VALUE==lhDumpFile)
{
FreeLibrary(hModule);
hModule=NULL;
return EXCEPTION_CONTINUE_SEARCH;
}
MINIDUMP_EXCEPTION_INFORMATION loExceptionInfo;
loExceptionInfo.ExceptionPointers = ExceptionInfo;
loExceptionInfo.ThreadId = GetCurrentThreadId();
loExceptionInfo.ClientPointers = TRUE;
if( !MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),lhDumpFile,\
(MINIDUMP_TYPE)(MINIDUMP_TYPE)(MiniDumpNormal/*|MiniDumpWithDataSegs|MiniDumpWithFullMemory|MiniDumpWithHandleData*/),&loExceptionInfo, NULL, NULL))
{
//
}
CloseHandle(lhDumpFile);
FreeLibrary(hModule);
hModule=NULL;
return EXCEPTION_CONTINUE_SEARCH;
}
static void minidump2(PEXCEPTION_POINTERS xinfo) {
HANDLE hFile = CreateFile("memory.dmp", GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
MINIDUMP_EXCEPTION_INFORMATION mxinfo;
mxinfo.ThreadId = GetCurrentThreadId();
mxinfo.ExceptionPointers = xinfo;
mxinfo.ClientPointers = FALSE;
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile,
MiniDumpNormal, &mxinfo, NULL, NULL);
CloseHandle(hFile);
}
int GenerateDump(EXCEPTION_POINTERS *pExceptionPointers)
{
if(IsDebuggerPresent())
return EXCEPTION_CONTINUE_SEARCH;
SYSTEMTIME stLocalTime;
GetLocalTime(&stLocalTime);
char szPath[MAX_PATH];
GetTempPath(sizeof(szPath), szPath);
char *szAppName = plugInName;
StringCchCat(szPath, sizeof(szPath), szAppName);
CreateDirectory(szPath, NULL);
char szFileName[MAX_PATH];
StringCchPrintf(szFileName, MAX_PATH, "%04i%02i%02i-%02i%02i%02i.dmp",
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond);
char szFullFileName[MAX_PATH];
StringCchPrintf(szFullFileName, MAX_PATH, "%s\\%s", szPath, szFileName);
HANDLE hDumpFile = CreateFile(szFullFileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
BOOL bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
CloseHandle(hDumpFile);
char szMessage[1024*32];
StringCchPrintf(szMessage, sizeof(szMessage),
plugInName " has crashed. A crash dump has been created:\n\n"
"%s\n\n"
"The application will exit.", szFileName);
/* If we show a MessageBox in this thread, then it'll run the message pump for
* any other dialogs that might still be alive, which might do bad things at this
* point. Create a temporary thread, and show the message box from there. */
unsigned long iThreadID = 0;
HANDLE hThreadHandle = CreateThread(0, 0, CrashMessageBoxThread, szMessage, 0, &iThreadID);
WaitForSingleObject(hThreadHandle, INFINITE);
ShellExecute(NULL, "open", szPath, NULL, NULL, SW_SHOWDEFAULT);
return EXCEPTION_EXECUTE_HANDLER;
}
