///////////////////////////////////////////////////////////////////
//	INCLUDE
///////////////////////////////////////////////////////////////////

#include "STDAFX.H"
#include "MINIDUMPSET.H"
#include "MEMORYMAP.H"
#include "TIMESET.H"
#include "COMMONMACROS.H"
#include "BASESET.H"
#include "DEBUGUTIL.H"
#include "SAFESTRINGMACROS.H"



#include "../../Server/ServerCommon/rlkt_Revision.h"

#ifdef _DEBUG
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
#endif

///////////////////////////////////////////////////////////////////
//	IMPLEMENTATION
///////////////////////////////////////////////////////////////////


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::CMiniDumpSet
//*---------------------------------------------------------------
// DESC : »ý¼ºÀÚ
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CMiniDumpSet::CMiniDumpSet() : m_hDebugHelp(NULL), m_lpMapping(NULL), m_hMap(NULL), m_hFile(INVALID_HANDLE_VALUE), m_lpfnMiniDumpWriteDump(NULL), m_lpfnMiniDumpReadDumpStream(NULL),
	m_dwProcessTime(0), m_dwUserTime(0), m_dwKernelTime(0), m_uExceptionCode(0), m_uExceptionAddress(0)
{
	::memset(m_szUserMessage, 0, sizeof(m_szUserMessage));
	::memset(m_szFilePath, 0, sizeof(m_szFilePath));
	::memset(m_szFileName, 0, sizeof(m_szFileName));
	::memset(m_szModuleName, 0, sizeof(m_szModuleName));
	::memset(m_szProcessorArchitecture, 0, sizeof(m_szProcessorArchitecture));
	::memset(m_szWindowVersion, 0, sizeof(m_szWindowVersion));
	::memset(m_szExceptionDesc, 0, sizeof(m_szExceptionDesc));
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::~CMiniDumpSet
//*---------------------------------------------------------------
// DESC : ¼Ò¸êÀÚ
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
CMiniDumpSet::~CMiniDumpSet()
{
	Close();
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::Open
//*---------------------------------------------------------------
// DESC : °´Ã¼ÀÚ¿ø ÃʱâÈ­
// PARM : N/A
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CMiniDumpSet::Open()
{
	DN_ASSERT(!IsOpen(),	"Already Opened!");

	// DBGHELP.DLL 6.1.17.1 ÀÌÈÄ ¹öÁ¯À» »ç¿ëÇØ¾ß ÇÔ
	m_hDebugHelp = ::LoadLibrary(_T("dbghelp.dll"));
	if (!m_hDebugHelp) {
		DN_RETURN(::GetLastError());
	}

	m_lpfnMiniDumpWriteDump = (LPFN_MINIDUMPWRITEDUMP)::GetProcAddress(m_hDebugHelp, "MiniDumpWriteDump");
	if (!m_lpfnMiniDumpWriteDump) {
		DN_RETURN(::GetLastError());
	}
	m_lpfnMiniDumpReadDumpStream = (LPFN_MINIDUMPREADDUMPSTREAM)::GetProcAddress(m_hDebugHelp, "MiniDumpReadDumpStream");
	if (!m_lpfnMiniDumpReadDumpStream) {
		DN_RETURN(::GetLastError());
	}

	return NOERROR;	
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::Close
//*---------------------------------------------------------------
// DESC : °´Ã¼ÀÚ¿ø ÇØÁ¦
// PARM : N/A
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CMiniDumpSet::Close()
{
	if (m_hDebugHelp) {
		::FreeLibrary(m_hDebugHelp);
		m_hDebugHelp = NULL;
	}
	if (m_lpMapping) {
		::UnmapViewOfFile(m_lpMapping);
		m_lpMapping = NULL;
	}
	if (m_hMap) {
		::CloseHandle(m_hMap);
		m_hMap = NULL;
	}
	if (INVALID_HANDLE_VALUE != m_hFile) {
		::CloseHandle(m_hFile);
		m_hFile = INVALID_HANDLE_VALUE;
	}
	m_lpfnMiniDumpWriteDump = NULL;
	m_lpfnMiniDumpReadDumpStream = NULL;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::Read
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·Î¿¡ ÀÖ´Â ¹Ì´Ï´ýÇÁ ÆÄÀÏÀ» ¿­¾î¼­ Á¤º¸µéÀ» ÀоîµéÀÓ
// PARM :	1 . lpszFilePath - ¹Ì´Ï´ýÇÁ ÆÄÀÏ°æ·Î
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CMiniDumpSet::Read(LPCTSTR lpszFilePath)
{
	DN_STRING(lpszFilePath,	MAX_PATH);

	m_hFile = ::CreateFile( lpszFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if (INVALID_HANDLE_VALUE == m_hFile) {
		DN_RETURN(::GetLastError());
	}
	m_hMap = ::CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
	if (!m_hMap) {
		DN_RETURN(::GetLastError());
	}
	m_lpMapping = ::MapViewOfFile( m_hMap, FILE_MAP_READ, 0, 0, 0);
	if (!m_lpMapping) {
		DN_RETURN(::GetLastError());
	}

	DWORD dwRetVal = NOERROR;
	__try {
		if (!ReadMiscInfo()) {
			dwRetVal = HASERROR + 0;
			__leave;
		}
		if (!ReadMouleName()) {
			dwRetVal = HASERROR + 1;
			__leave;
		}
		if (!ReadSystemInfo()) {
			dwRetVal = HASERROR + 2;
			__leave;
		}
		if (!ReadException()) {
			dwRetVal = HASERROR + 3;
			__leave;
		}
		if (!ReadUserData()) {
			dwRetVal = HASERROR + 4;
			__leave;
		}
	}
	__finally {
		if (NOERROR != dwRetVal) {
			DWORD dwRetVal2 = ::GetLastError();
			if (NOERROR != dwRetVal) {
				dwRetVal = dwRetVal2;
			}
		}
	}

	return dwRetVal;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::Write
//*---------------------------------------------------------------
// DESC : ƯÁ¤ °æ·Î¿¡ ¹Ì´Ï´ýÇÁ ÆÄÀÏÀ» »ý¼º
// PARM :	1 . lpstExceptionPointers - EXCEPTION_POINTERS ±¸Á¶Ã¼ Æ÷ÀÎÅÍ
//			2 . pMiniDumpType - ¹Ì´Ï´ýÇÁ ±â·ÏÇüÅÂ
//			3 . lpszFilePath - ¹Ì´Ï´ýÇÁ ÆÄÀÏ ÀúÀå°æ·Î
// RETV : NOERROR - ¼º°ø / ±×¿Ü - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
DWORD CMiniDumpSet::Write(LPEXCEPTION_POINTERS lpstExceptionPointers, MINIDUMP_TYPE pMiniDumpType, LPCTSTR lpszFilePath)
{
	DN_READ(lpstExceptionPointers, sizeof(LPEXCEPTION_POINTERS));
	DN_STRING(lpszFilePath,	MAX_PATH);

	DWORD dwRetVal = NOERROR;

	CTimeSet CurTime;
	#pragma warning(disable:4995)
	::wsprintf(m_szFileName, _T("%s%s_dmp_%04d%02d%02d%02d%02d%02d%03d_%d.dmp"),
				lpszFilePath,
				CDebugUtil::GetProgramName(),
				CurTime.GetYear(), CurTime.GetMonth(), CurTime.GetDay(),
				CurTime.GetHour(), CurTime.GetMinute(),CurTime.GetSecond(),CurTime.GetMilliseconds(),atoi(revDragonNest)+1);
	#pragma warning(default:4995)
	MAKE_STRING(m_szFileName);

	HANDLE hFile = ::CreateFile(m_szFileName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	if (INVALID_HANDLE_VALUE != hFile) {
		// ±âÁ¸ÀÇ ³»¿ëÀÌ ÀÖ´Ù¸é »èÁ¦¸¦ ÇØ¾ß ÇÑ´Ù.
		//if (::SetEndOfFile(hFile))
		DN_VERIFY(::SetEndOfFile(hFile), TRUE,	"¹«½¼ ¿À·ùÁö?");
		{
			MINIDUMP_EXCEPTION_INFORMATION stExclpModuleList;
			stExclpModuleList.ThreadId = ::GetCurrentThreadId();
			stExclpModuleList.ExceptionPointers = lpstExceptionPointers;
			stExclpModuleList.ClientPointers = NULL;

			MINIDUMP_USER_STREAM_INFORMATION stUserMsgHead;
			MINIDUMP_USER_STREAM stUserMsgData;
			if (_T('\0') != m_szUserMessage[0]) {
				stUserMsgHead.UserStreamCount = 1;
				stUserMsgHead.UserStreamArray = &stUserMsgData;
#if defined(_UNICODE)
				stUserMsgData.Type = CommentStreamW;	// UNICODE
#else	// _UNICODE
				stUserMsgData.Type = CommentStreamA;	// MBCS
#endif	// _UNICODE
				stUserMsgData.BufferSize = static_cast<ULONG>(::lstrlen(m_szUserMessage))*sizeof(TCHAR);
				stUserMsgData.Buffer = const_cast<TCHAR*>(m_szUserMessage);
			}

			// »ç¿ëÀÚ¿ë ¸Þ¼¼Áö´Â Dump fileÀÇ Áß°£ºÎºÐ¿¡ À§Ä¡Çϴµ¥ Hexa Editor·Î ¿­¾î¼­ "dbghelp.pdb" ¸¦ ãÀ¸¸é ´ÙÀ½¿¡ À§Ä¡
			if (!m_lpfnMiniDumpWriteDump(::GetCurrentProcess(), ::GetCurrentProcessId(), hFile, pMiniDumpType, &stExclpModuleList, ((_T('\0') != m_szUserMessage[0])?(&stUserMsgHead):(NULL)), NULL)) {
				dwRetVal = ::GetLastError();
				DN_ASSERT(0, "error occured!");
			}
		}
		DN_VERIFY(::CloseHandle(hFile), TRUE, "@err, hr");
	}
	else {
		dwRetVal = ::GetLastError();
		DN_ASSERT(0, "Disk full?");
	}

	return(dwRetVal);
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::SetUserMessage
//*---------------------------------------------------------------
// DESC : ¹Ì´Ï´ýÇÁ¿¡ ³²°ÔµÉ »ç¿ëÀÚ ¸Þ½ÃÁö¸¦ ÁöÁ¤
// PARM :	1 . lpszUserMessage - »ç¿ëÀÚ ¸Þ½ÃÁö
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CMiniDumpSet::SetUserMessage(LPCTSTR lpszUserMessage)
{
	DN_ASSERT(NULL != lpszUserMessage,	"Invalid!");
	
	if (lpszUserMessage) {
		STRNCPY(m_szUserMessage, COUNT_OF(m_szUserMessage), lpszUserMessage);
	}
	else {
		::memset(m_szUserMessage, 0, sizeof(m_szUserMessage));
	}
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::GetExceptionCause
//*---------------------------------------------------------------
// DESC : ¿¹¿Ü ÄÚµå·Î ¿¹¿ÜÀÇ ¹ß»ý¿øÀÎÀ» ã¾Æ¼­ ¹Ýȯ
// PARM :	1 . dwExceptionCode - ¿¹¿Ü ÄÚµå
//			2 . lpszDesc - °á°ú¸¦ ¹Ýȯ¹ÞÀ» ¹öÆÛ Æ÷ÀÎÅÍ
//			3 . nDescSize - ¹öÆÛ Å©±â
// RETV : N/A
// PRGM : B4nFter
//*---------------------------------------------------------------
VOID CMiniDumpSet::GetExceptionCause(DWORD dwExceptionCode, LPTSTR lpszDesc, DWORD nDescSize)
{
	DN_WRITE(lpszDesc, nDescSize);
	UNUSED_ALWAYS(nDescSize);

#pragma warning(disable:4995 4996)
	switch(dwExceptionCode) {
	case EXCEPTION_ACCESS_VIOLATION:			::lstrcpy(lpszDesc, _T("EXCEPTION_ACCESS_VIOLATION"));			break;
	case EXCEPTION_DATATYPE_MISALIGNMENT:		::lstrcpy(lpszDesc, _T("EXCEPTION_DATATYPE_MISALIGNMENT"));		break;
	case EXCEPTION_BREAKPOINT:					::lstrcpy(lpszDesc, _T("EXCEPTION_BREAKPOINT"));				break;
	case EXCEPTION_SINGLE_STEP:					::lstrcpy(lpszDesc, _T("EXCEPTION_SINGLE_STEP"));				break;
	case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:		::lstrcpy(lpszDesc, _T("EXCEPTION_ARRAY_BOUNDS_EXCEEDED"));		break;
	case EXCEPTION_FLT_DENORMAL_OPERAND:		::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_DENORMAL_OPERAND"));		break;
	case EXCEPTION_FLT_DIVIDE_BY_ZERO:			::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_DIVIDE_BY_ZERO"));		break;
	case EXCEPTION_FLT_INEXACT_RESULT:			::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_INEXACT_RESULT"));		break;
	case EXCEPTION_FLT_INVALID_OPERATION:		::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_INVALID_OPERATION"));		break;
	case EXCEPTION_FLT_OVERFLOW:				::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_OVERFLOW"));				break;
	case EXCEPTION_FLT_STACK_CHECK:				::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_STACK_CHECK"));			break;
	case EXCEPTION_FLT_UNDERFLOW:				::lstrcpy(lpszDesc, _T("EXCEPTION_FLT_UNDERFLOW"));				break;
	case EXCEPTION_INT_DIVIDE_BY_ZERO:			::lstrcpy(lpszDesc, _T("EXCEPTION_INT_DIVIDE_BY_ZERO"));		break;
	case EXCEPTION_INT_OVERFLOW:				::lstrcpy(lpszDesc, _T("EXCEPTION_INT_OVERFLOW"));				break;
	case EXCEPTION_PRIV_INSTRUCTION:			::lstrcpy(lpszDesc, _T("EXCEPTION_PRIV_INSTRUCTION"));			break;
	case EXCEPTION_IN_PAGE_ERROR:				::lstrcpy(lpszDesc, _T("EXCEPTION_IN_PAGE_ERROR"));				break;
	case EXCEPTION_ILLEGAL_INSTRUCTION:			::lstrcpy(lpszDesc, _T("EXCEPTION_ILLEGAL_INSTRUCTION"));		break;
	case EXCEPTION_NONCONTINUABLE_EXCEPTION:	::lstrcpy(lpszDesc, _T("EXCEPTION_NONCONTINUABLE_EXCEPTION"));	break;
	case EXCEPTION_STACK_OVERFLOW:				::lstrcpy(lpszDesc, _T("EXCEPTION_STACK_OVERFLOW"));			break;
	case EXCEPTION_INVALID_DISPOSITION:			::lstrcpy(lpszDesc, _T("EXCEPTION_INVALID_DISPOSITION"));		break;
	case EXCEPTION_GUARD_PAGE:					::lstrcpy(lpszDesc, _T("EXCEPTION_GUARD_PAGE"));				break;
	case EXCEPTION_INVALID_HANDLE:				::lstrcpy(lpszDesc, _T("EXCEPTION_INVALID_HANDLE"));			break;
	case 0xE06D7363:							::lstrcpy(lpszDesc, _T("Microsoft C++ Exception"));				break;
	default:									::wsprintf(lpszDesc,_T("0x%08X"), dwExceptionCode);				break;
	}
#pragma warning(default:4995 4996)
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::GetDumpInfo
//*---------------------------------------------------------------
// DESC : MiniDumpReadDumpStream ·Î ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ ƯÁ¤ Á¤º¸¸¦ Äõ¸®Çϱâ À§ÇÑ ·¡ÇÎ ¸Þ¼­µå
// PARM :	1 . eInfoType - ƯÁ¤ Á¤º¸Å¸ÀÔ
// RETV : Äõ¸®°á°ú (Á¤º¸Å¸ÀÔ¿¡ µû¶ó ´Ù¸§)
// PRGM : B4nFter
//*---------------------------------------------------------------
LPVOID CMiniDumpSet::GetDumpInfo(ULONG eInfoType)
{
	DN_ASSERT(NULL != m_lpfnMiniDumpReadDumpStream,	"Invalid!");

	if (!m_lpMapping) {
		DN_RETURN(NULL);
	}

	ULONG uSize = 0;
	LPVOID lpStream = NULL;
	MINIDUMP_DIRECTORY* lpMiniDumpDirectory = NULL;
//	if (!m_lpfnMiniDumpReadDumpStream(m_lpMapping, eInfoType, &lpMiniDumpDirectory, &lpStream, &uSize)) {
	if (!::MiniDumpReadDumpStream(m_lpMapping, eInfoType, &lpMiniDumpDirectory, &lpStream, &uSize)) {
		return NULL;
	}
	return lpStream;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::ReadMiscInfo
//*---------------------------------------------------------------
// DESC : ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ ±âŸ Á¤º¸¸¦ ¾òÀ½
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CMiniDumpSet::ReadMiscInfo()
{
	MINIDUMP_MISC_INFO* lpMiscInfo = GetMiscInfo();
	if (!lpMiscInfo) {
		return FALSE;
	}
	if (lpMiscInfo->Flags1 & MINIDUMP_MISC1_PROCESS_TIMES) {
		m_dwProcessTime = lpMiscInfo->ProcessCreateTime;
		m_dwUserTime	= lpMiscInfo->ProcessUserTime;
		m_dwKernelTime	= lpMiscInfo->ProcessKernelTime;
	}
	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::ReadMouleName
//*---------------------------------------------------------------
// DESC : ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ ¸ðµâ ¸®½ºÆ® Á¤º¸¸¦ ¾òÀ½
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CMiniDumpSet::ReadMouleName()
{
	MINIDUMP_MODULE_LIST* lpModuleList = GetModuleList();
	MINIDUMP_MODULE* lpModule = NULL;
	MINIDUMP_STRING* lpszModuleString = NULL;

	if (!lpModuleList || lpModuleList->NumberOfModules <= 0) {
		return FALSE;
	}

	lpModule = &lpModuleList->Modules[0];
	lpszModuleString = (MINIDUMP_STRING*)((LPBYTE)m_lpMapping + lpModule->ModuleNameRva);

	USES_CONVERSION;

#pragma warning(disable:4996)
	STRNCPY(m_szModuleName, COUNT_OF(m_szModuleName), W2T(lpszModuleString->Buffer));
	MAKE_STRING(m_szModuleName);
#pragma warning(default:4996)

	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::ReadSystemInfo
//*---------------------------------------------------------------
// DESC : ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ ½Ã½ºÅÛ Á¤º¸¸¦ ¾òÀ½
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
#pragma warning(disable:4996)
BOOL CMiniDumpSet::ReadSystemInfo()
{
	// http://msdn2.microsoft.com/en-us/library/ms680396.aspx
	MINIDUMP_SYSTEM_INFO* lpSystemInfo = GetSystemInfo();
	if (!lpSystemInfo) {
		return FALSE;
	}

	TCHAR szTemp[128] = { _T('\0'), };
	LPCTSTR lpszSystemDesc = NULL;

	switch(lpSystemInfo->ProcessorArchitecture) {
	case PROCESSOR_ARCHITECTURE_INTEL:
		{
			 STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Intel "));
			 switch (lpSystemInfo->ProcessorLevel) {
			 case  3:
				 {
					 lpszSystemDesc = _T("80386");
				 }
				 break;
			 case  4:
				 {
					 lpszSystemDesc = _T("80486");
				 }
				 break;
			 case  5:
				 {
					 lpszSystemDesc = _T("Pentium");
				 }
				 break;
			 case  6:
				 {
					 lpszSystemDesc = _T("Pentium Pro/II or AMD Athlon");
				 }
				 break;
			 case 15:
				 {
					 lpszSystemDesc = _T("Pentium 4 or AMD Athlon64");
				 }
				 break;
			 default:
				 {
					 lpszSystemDesc = _T("Unknown");
				 }
				 break;
			 }

			 STRNCAT(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), lpszSystemDesc);

			 if (3 == lpSystemInfo->ProcessorLevel || 4 == lpSystemInfo->ProcessorLevel) {
				 if (HIWORD(lpSystemInfo->ProcessorRevision) == 0xFF) {
					 SNPRINTF(MODE_DBG_EX(szTemp, COUNT_OF(szTemp)), COUNT_OF(szTemp), 
						_T(" (%c%d)"), _T('A') + HIBYTE(LOWORD(lpSystemInfo->ProcessorRevision)), LOBYTE(LOWORD(lpSystemInfo->ProcessorRevision)));
				 }
				 else {
					 SNPRINTF(MODE_DBG_EX(szTemp, COUNT_OF(szTemp)), COUNT_OF(szTemp), 
						_T(" (%c%d)"), _T('A') + HIWORD(lpSystemInfo->ProcessorRevision), LOWORD(lpSystemInfo->ProcessorRevision));
				 }
			 }
			 else {
				 //Model xx, Stepping yy
				 SNPRINTF(MODE_DBG_EX(szTemp, COUNT_OF(szTemp)), COUNT_OF(szTemp), 
					_T(" (%d.%d)"), HIWORD(lpSystemInfo->ProcessorRevision),LOWORD(lpSystemInfo->ProcessorRevision));
			 }
			 MAKE_STRING(szTemp);
			 STRNCAT(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), szTemp);
		}
		break;
	case PROCESSOR_ARCHITECTURE_MIPS:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Mips"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_ALPHA:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Alpha"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_PPC:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("PowerPC"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_SHX:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("SHX"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_ARM:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("ARM"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_IA64:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Intel Itanium Processor Family "));
		}
		break;
	case PROCESSOR_ARCHITECTURE_ALPHA64:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Alpha64"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_MSIL:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Msil"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_AMD64:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("x64 (AMD or Intel)"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("IA32"));
		}
		break;
	case PROCESSOR_ARCHITECTURE_UNKNOWN:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Unknown"));
		}
		break;
	default:
		{
			STRNCPY(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), _T("Unknown"));
		}
		break;
	}

	lpszSystemDesc = NULL;
	switch (lpSystemInfo->MajorVersion)	{
	case 3:
		{
			switch (lpSystemInfo->MinorVersion)	{
			case 51: 
				{
					lpszSystemDesc = _T("NT 3.51");
				}
				break;
			default: 
				{
					lpszSystemDesc = _T("3-????");
				}
				break;
			}
		}
		break;
	case 4:
		{
			switch (lpSystemInfo->MinorVersion)	{
			case 0:
				{
					lpszSystemDesc = (VER_PLATFORM_WIN32_NT == lpSystemInfo->PlatformId) ? _T("NT 4.0") : _T("95");
				}
				break;
			case 10:
				{
					lpszSystemDesc = _T("98"); 
				}
				break;
			case 90:
				{
					lpszSystemDesc = _T("ME"); 
				}
				break;
			default:
				{
					lpszSystemDesc = _T("4-????"); 
				}
				break;
			}
		}
		break;
	case 5:
		{
			switch (lpSystemInfo->MinorVersion)	{
			case 0:
				{
					lpszSystemDesc = _T("2000"); 
				}
				break;
			case 1: 
				{
					lpszSystemDesc = _T("XP"); 
				}
				break;
			case 2:
				{
					lpszSystemDesc = _T("Server 2003"); 
				}
				break;
			default:
				{
					lpszSystemDesc = _T("5-????"); 
				}
				break;
			}
		}
		break;
	default:
		{
			lpszSystemDesc = _T("???"); 
		}
		break;
	}
	STRNCPY(m_szWindowVersion, COUNT_OF(m_szWindowVersion), lpszSystemDesc);
	
	SNPRINTF(MODE_DBG_EX(szTemp, COUNT_OF(szTemp)), COUNT_OF(szTemp), _T(" (%u)"), lpSystemInfo->BuildNumber);
	MAKE_STRING(szTemp);

	STRNCAT(m_szProcessorArchitecture, COUNT_OF(m_szProcessorArchitecture), szTemp);

	return TRUE;
}
#pragma warning(default:4996)


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::ReadException
//*---------------------------------------------------------------
// DESC : ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ ¿¹¿Ü°ü·Ã Á¤º¸¸¦ ¾òÀ½
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CMiniDumpSet::ReadException()
{
	MINIDUMP_EXCEPTION_STREAM* lpExceptionStream = GetException();
	if (!lpExceptionStream)	{
		return FALSE;
	}

	m_uExceptionAddress = lpExceptionStream->ExceptionRecord.ExceptionAddress;
	m_uExceptionCode = lpExceptionStream->ExceptionRecord.ExceptionCode;
	GetExceptionCause((DWORD)m_uExceptionCode, m_szExceptionDesc, MAX_PATH);

	return TRUE;
}


//*---------------------------------------------------------------
// TYPE : FUNCTION
// NAME : CMiniDumpSet::ReadUserData
//*---------------------------------------------------------------
// DESC : ¿­·ÁÁø ¹Ì´Ï´ýÇÁ ÆÄÀÏ¿¡¼­ »ç¿ëÀÚ µ¥ÀÌÅÍ Á¤º¸¸¦ ¾òÀ½
// PARM : N/A
// RETV : TRUE - ¼º°ø / FALSE - ½ÇÆÐ
// PRGM : B4nFter
//*---------------------------------------------------------------
BOOL CMiniDumpSet::ReadUserData()
{
	ULONG nSize = 0;
	LPVOID lpStream	= NULL;
	MINIDUMP_DIRECTORY* lpMiniDumpDirectory = NULL;

#if defined(_UNICODE)
	if (!::MiniDumpReadDumpStream(m_lpMapping, CommentStreamW, &lpMiniDumpDirectory, &lpStream, &nSize)) {
#else	// _UNICODE
	if (!::MiniDumpReadDumpStream(m_lpMapping, CommentStreamA, &lpMiniDumpDirectory, &lpStream, &nSize)) {
#endif	// _UNICODE
		// UserStream À» ÀÔ·ÂÇÏÁö ¾Ê¾ÒÀ» °æ¿ìµµ ¼º°ø
		return TRUE;
	}

	if (!lpStream || !nSize) {
		return FALSE;
	}

	if (IsBadStringPtr((LPCTSTR)lpStream, nSize/sizeof(TCHAR))) {
		return FALSE;
	}

	m_strUserString.Format(_T("%s"), lpStream);

	if (0 < m_strUserString.GetLength() && 0x0002 == m_strUserString.GetAt(m_strUserString.GetLength()-1)) {
		m_strUserString.SetAt(m_strUserString.GetLength()-1, _T('\0'));
	}

/*
	for (INT iCount = 1 ; iCount < 3 ; ++iCount)	{
		if (!::MiniDumpReadDumpStream(m_lpMapping, LastReservedStream + iCount, &lpMiniDumpDirectory, &lpStream, &nSize)) {
			// UserStreamÀ» ÀÔ·ÂÇÏÁö ¾Ê¾ÒÀ»°æ¿ìµµ ¼º°ø
			return TRUE;
		}
		else {
			if (!lpStream || !nSize) {
				return FALSE;
			}
//			if (IsBadStringPtrA((LPCSTR)lpStream, nSize)) {
			if (IsBadStringPtr((LPCTSTR)lpStream, nSize/sizeof(TCHAR))) {
				return FALSE;
			}
			TCHAR szString[1024] = { _T('\0'), };
#pragma warning(disable:4996)
			SNPRINTF(MODE_DBG_EX(szString, COUNT_OF(szString)), COUNT_OF(szString), _T("%s"), lpStream);
			MAKE_STRING(szString);
#pragma warning(default:4996)
			if (1 == iCount) {
				m_strSystemInfo = szString;
			}
			else {
				m_strUserString = szString;
			}
		}
	}
*/
	
	return TRUE;
}