{

DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_LINE64)

PVOID Key; // internal

DWORD LineNumber; // line number in file

PCHAR FileName; // full filename

DWORD64 Address; // first instruction of line

{

DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)

DWORD64 BaseOfImage; // base load address of module

DWORD ImageSize; // virtual size of the loaded module

DWORD TimeDateStamp; // date/time stamp from pe header

DWORD CheckSum; // checksum from the pe header

DWORD NumSyms; // number of symbols in the symbol table

SYM_TYPE SymType; // type of symbols loaded

CHAR ModuleName[32]; // module name

CHAR ImageName[256]; // image name

CHAR LoadedImageName[256]; // symbol file name

{

DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_SYMBOL64)

DWORD64 Address; // virtual address including dll base address

DWORD Size; // estimated size of symbol, can be zero

DWORD Flags; // info about the symbols, see the SYMF defines

DWORD MaxNameLength; // maximum size of symbol name in 'Name'

CHAR Name[1]; // symbol name (null terminated string)

{

DWORD64 Offset;

WORD Segment;

ADDRESS_MODE Mode;

{

DWORD64 Thread;

DWORD ThCallbackStack;

DWORD ThCallbackBStore;

DWORD NextCallback;

DWORD FramePointer;

DWORD64 KiCallUserMode;

DWORD64 KeUserCallbackDispatcher;

DWORD64 SystemRangeStart;

DWORD64 Reserved[8];

{

ADDRESS64 AddrPC; // program counter

ADDRESS64 AddrReturn; // return address

ADDRESS64 AddrFrame; // frame pointer

ADDRESS64 AddrStack; // stack pointer

ADDRESS64 AddrBStore; // backing store pointer

PVOID FuncTableEntry; // pointer to pdata/fpo or NULL

DWORD64 Params[4]; // possible arguments to the function

BOOL Far; // WOW far call

BOOL Virtual; // is this a virtual frame?

DWORD64 Reserved[3];

KDHELP64 KdHelp;

{

if (nMaxDestSize <= 0)

return;

strncpy_s(szDest, nMaxDestSize, szSrc, _TRUNCATE);

// INFO: _TRUNCATE will ensure that it is null-terminated;

// but with older compilers (<1400) it uses "strncpy" and this does not!)

szDest[nMaxDestSize - 1] = 0;

{

StackWalkerInternal(StackWalker* parent, HANDLE hProcess)

{

m_parent = parent;

m_hDbhHelp = NULL;

pSC = NULL;

m_hProcess = hProcess;

m_szSymPath = NULL;

pSFTA = NULL;

pSGLFA = NULL;

pSGMB = NULL;

pSGMI = NULL;

pSGO = NULL;

pSGSFA = NULL;

pSI = NULL;

pSLM = NULL;

pSSO = NULL;

pSW = NULL;

pUDSN = NULL;

pSGSP = NULL;

}

~StackWalkerInternal()

{

if (pSC != NULL)

pSC(m_hProcess); // SymCleanup

if (m_hDbhHelp != NULL)

FreeLibrary(m_hDbhHelp);

m_hDbhHelp = NULL;

m_parent = NULL;

if (m_szSymPath != NULL)

free(m_szSymPath);

m_szSymPath = NULL;

}

BOOL Init(LPCSTR szSymPath)

{

if (m_parent == NULL)

return FALSE;

// Dynamically load the Entry-Points for dbghelp.dll:

// First try to load the newest one from

TCHAR szTemp[4096];

// But before we do this, we first check if the ".local" file exists

if (GetModuleFileName(NULL, szTemp, 4096) > 0)

{

_tcscat_s(szTemp, _T(".local"));

if (GetFileAttributes(szTemp) == INVALID_FILE_ATTRIBUTES)

{

// ".local" file does not exist, so we can try to load the dbghelp.dll from the "Debugging Tools for Windows"

// Ok, first try the new path according to the architecture:

#ifdef _M_IX86

if ((m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0))

{

_tcscat_s(szTemp, _T("\\Debugging Tools for Windows (x86)\\dbghelp.dll"));

// now check if the file exists:

if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)

{

m_hDbhHelp = LoadLibrary(szTemp);

}

}

#elif _M_X64

if ((m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0))

{

_tcscat_s(szTemp, _T("\\Debugging Tools for Windows (x64)\\dbghelp.dll"));

// now check if the file exists:

if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)

{

m_hDbhHelp = LoadLibrary(szTemp);

}

}

#elif _M_IA64

if ((m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0))

{

_tcscat_s(szTemp, _T("\\Debugging Tools for Windows (ia64)\\dbghelp.dll"));

// now check if the file exists:

if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)

{

m_hDbhHelp = LoadLibrary(szTemp);

}

}

#endif

// If still not found, try the old directories...

if ((m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0))

{

_tcscat_s(szTemp, _T("\\Debugging Tools for Windows\\dbghelp.dll"));

// now check if the file exists:

if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)

{

m_hDbhHelp = LoadLibrary(szTemp);

}

}

#if defined _M_X64 || defined _M_IA64

// Still not found? Then try to load the (old) 64-Bit version:

if ((m_hDbhHelp == NULL) && (GetEnvironmentVariable(_T("ProgramFiles"), szTemp, 4096) > 0))

{

_tcscat_s(szTemp, _T("\\Debugging Tools for Windows 64-Bit\\dbghelp.dll"));

if (GetFileAttributes(szTemp) != INVALID_FILE_ATTRIBUTES)

{

m_hDbhHelp = LoadLibrary(szTemp);

}

}

#endif

}

}

if (m_hDbhHelp == NULL) // if not already loaded, try to load a default-one

m_hDbhHelp = LoadLibrary(_T("dbghelp.dll"));

if (m_hDbhHelp == NULL)

return FALSE;

pSI = (tSI)GetProcAddress(m_hDbhHelp, "SymInitialize");

pSC = (tSC)GetProcAddress(m_hDbhHelp, "SymCleanup");

pSW = (tSW)GetProcAddress(m_hDbhHelp, "StackWalk64");

pSGO = (tSGO)GetProcAddress(m_hDbhHelp, "SymGetOptions");

pSSO = (tSSO)GetProcAddress(m_hDbhHelp, "SymSetOptions");

pSFTA = (tSFTA)GetProcAddress(m_hDbhHelp, "SymFunctionTableAccess64");

pSGLFA = (tSGLFA)GetProcAddress(m_hDbhHelp, "SymGetLineFromAddr64");

pSGMB = (tSGMB)GetProcAddress(m_hDbhHelp, "SymGetModuleBase64");

pSGMI = (tSGMI)GetProcAddress(m_hDbhHelp, "SymGetModuleInfo64");

pSGSFA = (tSGSFA)GetProcAddress(m_hDbhHelp, "SymGetSymFromAddr64");

pUDSN = (tUDSN)GetProcAddress(m_hDbhHelp, "UnDecorateSymbolName");

pSLM = (tSLM)GetProcAddress(m_hDbhHelp, "SymLoadModule64");

pSGSP = (tSGSP)GetProcAddress(m_hDbhHelp, "SymGetSearchPath");

if (pSC == NULL || pSFTA == NULL || pSGMB == NULL || pSGMI == NULL || pSGO == NULL ||

pSGSFA == NULL || pSI == NULL || pSSO == NULL || pSW == NULL || pUDSN == NULL ||

pSLM == NULL)

{

FreeLibrary(m_hDbhHelp);

m_hDbhHelp = NULL;

pSC = NULL;

return FALSE;

}

// SymInitialize

if (szSymPath != NULL)

m_szSymPath = _strdup(szSymPath);

if (this->pSI(m_hProcess, m_szSymPath, FALSE) == FALSE)

this->m_parent->OnDbgHelpErr("SymInitialize", GetLastError(), 0);

DWORD symOptions = this->pSGO(); // SymGetOptions

symOptions |= SYMOPT_LOAD_LINES;

symOptions |= SYMOPT_FAIL_CRITICAL_ERRORS;

//symOptions |= SYMOPT_NO_PROMPTS;

// SymSetOptions

symOptions = this->pSSO(symOptions);

char buf[StackWalker::STACKWALK_MAX_NAMELEN] = {0};

if (this->pSGSP != NULL)

{

if (this->pSGSP(m_hProcess, buf, StackWalker::STACKWALK_MAX_NAMELEN) == FALSE)

this->m_parent->OnDbgHelpErr("SymGetSearchPath", GetLastError(), 0);

}

char szUserName[1024] = {0};

DWORD dwSize = 1024;

GetUserNameA(szUserName, &dwSize);

this->m_parent->OnSymInit(buf, symOptions, szUserName);

return TRUE;

}

StackWalker* m_parent;

HMODULE m_hDbhHelp;

HANDLE m_hProcess;

LPSTR m_szSymPath;

#pragma pack(push, 8)

typedef struct IMAGEHLP_MODULE64_V3

{

DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)

DWORD64 BaseOfImage; // base load address of module

DWORD ImageSize; // virtual size of the loaded module

DWORD TimeDateStamp; // date/time stamp from pe header

DWORD CheckSum; // checksum from the pe header

DWORD NumSyms; // number of symbols in the symbol table

SYM_TYPE SymType; // type of symbols loaded

CHAR ModuleName[32]; // module name

CHAR ImageName[256]; // image name

CHAR LoadedImageName[256]; // symbol file name

// new elements: 07-Jun-2002

CHAR LoadedPdbName[256]; // pdb file name

DWORD CVSig; // Signature of the CV record in the debug directories

CHAR CVData[MAX_PATH * 3]; // Contents of the CV record

DWORD PdbSig; // Signature of PDB

GUID PdbSig70; // Signature of PDB (VC 7 and up)

DWORD PdbAge; // DBI age of pdb

BOOL PdbUnmatched; // loaded an unmatched pdb

BOOL DbgUnmatched; // loaded an unmatched dbg

BOOL LineNumbers; // we have line number information

BOOL GlobalSymbols; // we have internal symbol information

BOOL TypeInfo; // we have type information

// new elements: 17-Dec-2003

BOOL SourceIndexed; // pdb supports source server

BOOL Publics; // contains public symbols

};

typedef struct IMAGEHLP_MODULE64_V2

{

DWORD SizeOfStruct; // set to sizeof(IMAGEHLP_MODULE64)

DWORD64 BaseOfImage; // base load address of module

DWORD ImageSize; // virtual size of the loaded module

DWORD TimeDateStamp; // date/time stamp from pe header

DWORD CheckSum; // checksum from the pe header

DWORD NumSyms; // number of symbols in the symbol table

SYM_TYPE SymType; // type of symbols loaded

CHAR ModuleName[32]; // module name

CHAR ImageName[256]; // image name

CHAR LoadedImageName[256]; // symbol file name

};

#pragma pack(pop)

// SymCleanup()

typedef BOOL(__stdcall* tSC)(IN HANDLE hProcess);

tSC pSC;

// SymFunctionTableAccess64()

typedef PVOID(__stdcall* tSFTA)(HANDLE hProcess, DWORD64 AddrBase);

tSFTA pSFTA;

// SymGetLineFromAddr64()

typedef BOOL(__stdcall* tSGLFA)(IN HANDLE hProcess,

IN DWORD64 dwAddr,

OUT PDWORD pdwDisplacement,

OUT PIMAGEHLP_LINE64 Line);

tSGLFA pSGLFA;

// SymGetModuleBase64()

typedef DWORD64(__stdcall* tSGMB)(IN HANDLE hProcess, IN DWORD64 dwAddr);

tSGMB pSGMB;

// SymGetModuleInfo64()

typedef BOOL(__stdcall* tSGMI)(IN HANDLE hProcess,

IN DWORD64 dwAddr,

OUT IMAGEHLP_MODULE64_V3* ModuleInfo);

tSGMI pSGMI;

// SymGetOptions()

typedef DWORD(__stdcall* tSGO)(VOID);

tSGO pSGO;

// SymGetSymFromAddr64()

typedef BOOL(__stdcall* tSGSFA)(IN HANDLE hProcess,

IN DWORD64 dwAddr,

OUT PDWORD64 pdwDisplacement,

OUT PIMAGEHLP_SYMBOL64 Symbol);

tSGSFA pSGSFA;

// SymInitialize()

typedef BOOL(__stdcall* tSI)(IN HANDLE hProcess, IN PSTR UserSearchPath, IN BOOL fInvadeProcess);

tSI pSI;

// SymLoadModule64()

typedef DWORD64(__stdcall* tSLM)(IN HANDLE hProcess,

IN HANDLE hFile,

IN PSTR ImageName,

IN PSTR ModuleName,

IN DWORD64 BaseOfDll,

IN DWORD SizeOfDll);

tSLM pSLM;

// SymSetOptions()

typedef DWORD(__stdcall* tSSO)(IN DWORD SymOptions);

tSSO pSSO;

// StackWalk64()

typedef BOOL(__stdcall* tSW)(DWORD MachineType,

HANDLE hProcess,

HANDLE hThread,

LPSTACKFRAME64 StackFrame,

PVOID ContextRecord,

PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,

PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,

PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,

PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);

tSW pSW;

// UnDecorateSymbolName()

typedef DWORD(__stdcall WINAPI* tUDSN)(PCSTR DecoratedName,

PSTR UnDecoratedName,

DWORD UndecoratedLength,

DWORD Flags);

tUDSN pUDSN;

typedef BOOL(__stdcall WINAPI* tSGSP)(HANDLE hProcess, PSTR SearchPath, DWORD SearchPathLength);

tSGSP pSGSP;

#define MAX_MODULE_NAME32 255

#define TH32CS_SNAPMODULE 0x00000008

#pragma pack(push, 8)

typedef struct tagMODULEENTRY32

{

DWORD dwSize;

DWORD th32ModuleID; // This module

DWORD th32ProcessID; // owning process

DWORD GlblcntUsage; // Global usage count on the module

DWORD ProccntUsage; // Module usage count in th32ProcessID's context

BYTE* modBaseAddr; // Base address of module in th32ProcessID's context

DWORD modBaseSize; // Size in bytes of module starting at modBaseAddr

HMODULE hModule; // The hModule of this module in th32ProcessID's context

char szModule[MAX_MODULE_NAME32 + 1];

char szExePath[MAX_PATH];

} MODULEENTRY32;

typedef MODULEENTRY32* PMODULEENTRY32;

typedef MODULEENTRY32* LPMODULEENTRY32;

#pragma pack(pop)

BOOL GetModuleListTH32(HANDLE hProcess, DWORD pid)

{

// CreateToolhelp32Snapshot()

typedef HANDLE(__stdcall * tCT32S)(DWORD dwFlags, DWORD th32ProcessID);

// Module32First()

typedef BOOL(__stdcall * tM32F)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);

// Module32Next()

typedef BOOL(__stdcall * tM32N)(HANDLE hSnapshot, LPMODULEENTRY32 lpme);

// try both dlls...

const TCHAR* dllname[] = {_T("kernel32.dll"), _T("tlhelp32.dll")};

HINSTANCE hToolhelp = NULL;

tCT32S pCT32S = NULL;

tM32F pM32F = NULL;

tM32N pM32N = NULL;

HANDLE hSnap;

MODULEENTRY32 me;

me.dwSize = sizeof(me);

BOOL keepGoing;

size_t i;

for (i = 0; i < (sizeof(dllname) / sizeof(dllname[0])); i++)

{

hToolhelp = LoadLibrary(dllname[i]);

if (hToolhelp == NULL)

continue;

pCT32S = (tCT32S)GetProcAddress(hToolhelp, "CreateToolhelp32Snapshot");

pM32F = (tM32F)GetProcAddress(hToolhelp, "Module32First");

pM32N = (tM32N)GetProcAddress(hToolhelp, "Module32Next");

if ((pCT32S != NULL) && (pM32F != NULL) && (pM32N != NULL))

break; // found the functions!

FreeLibrary(hToolhelp);

hToolhelp = NULL;

}

if (hToolhelp == NULL)

return FALSE;

hSnap = pCT32S(TH32CS_SNAPMODULE, pid);

if (hSnap == (HANDLE)-1)

{

FreeLibrary(hToolhelp);

return FALSE;

}

keepGoing = !!pM32F(hSnap, &me);

int cnt = 0;

while (keepGoing)

{

this->LoadModule(hProcess, me.szExePath, me.szModule, (DWORD64)me.modBaseAddr,

me.modBaseSize);

cnt++;

keepGoing = !!pM32N(hSnap, &me);

}

CloseHandle(hSnap);

FreeLibrary(hToolhelp);

if (cnt <= 0)

return FALSE;

return TRUE;

} // GetModuleListTH32

// **************************************** PSAPI ************************

typedef struct _MODULEINFO

{

LPVOID lpBaseOfDll;

DWORD SizeOfImage;

LPVOID EntryPoint;

} MODULEINFO, *LPMODULEINFO;

BOOL GetModuleListPSAPI(HANDLE hProcess)

{

// EnumProcessModules()

typedef BOOL(__stdcall * tEPM)(HANDLE hProcess, HMODULE * lphModule, DWORD cb,

LPDWORD lpcbNeeded);

// GetModuleFileNameEx()

typedef DWORD(__stdcall * tGMFNE)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename,

DWORD nSize);

// GetModuleBaseName()

typedef DWORD(__stdcall * tGMBN)(HANDLE hProcess, HMODULE hModule, LPSTR lpFilename,

DWORD nSize);

// GetModuleInformation()

typedef BOOL(__stdcall * tGMI)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO pmi, DWORD nSize);

HINSTANCE hPsapi;

tEPM pEPM;

tGMFNE pGMFNE;

tGMBN pGMBN;

tGMI pGMI;

DWORD i;

//ModuleEntry e;

DWORD cbNeeded;

MODULEINFO mi;

HMODULE* hMods = 0;

char* tt = NULL;

char* tt2 = NULL;

const SIZE_T TTBUFLEN = 8096;

int cnt = 0;

hPsapi = LoadLibrary(_T("psapi.dll"));

if (hPsapi == NULL)

return FALSE;

pEPM = (tEPM)GetProcAddress(hPsapi, "EnumProcessModules");

pGMFNE = (tGMFNE)GetProcAddress(hPsapi, "GetModuleFileNameExA");

pGMBN = (tGMFNE)GetProcAddress(hPsapi, "GetModuleBaseNameA");

pGMI = (tGMI)GetProcAddress(hPsapi, "GetModuleInformation");

if ((pEPM == NULL) || (pGMFNE == NULL) || (pGMBN == NULL) || (pGMI == NULL))

{

// we couldn't find all functions

FreeLibrary(hPsapi);

return FALSE;

}

hMods = (HMODULE*)malloc(sizeof(HMODULE) * (TTBUFLEN / sizeof(HMODULE)));

tt = (char*)malloc(sizeof(char) * TTBUFLEN);

tt2 = (char*)malloc(sizeof(char) * TTBUFLEN);

if ((hMods == NULL) || (tt == NULL) || (tt2 == NULL))

goto cleanup;

if (!pEPM(hProcess, hMods, TTBUFLEN, &cbNeeded))

{

//_ftprintf(fLogFile, _T("%lu: EPM failed, GetLastError = %lu\n"), g_dwShowCount, gle );

goto cleanup;

}

if (cbNeeded > TTBUFLEN)

{

//_ftprintf(fLogFile, _T("%lu: More than %lu module handles. Huh?\n"), g_dwShowCount, lenof( hMods ) );

goto cleanup;

}

for (i = 0; i < cbNeeded / sizeof(hMods[0]); i++)

{

// base address, size

pGMI(hProcess, hMods[i], &mi, sizeof(mi));

// image file name

tt[0] = 0;

pGMFNE(hProcess, hMods[i], tt, TTBUFLEN);

// module name

tt2[0] = 0;

pGMBN(hProcess, hMods[i], tt2, TTBUFLEN);

DWORD dwRes = this->LoadModule(hProcess, tt, tt2, (DWORD64)mi.lpBaseOfDll, mi.SizeOfImage);

if (dwRes != ERROR_SUCCESS)

this->m_parent->OnDbgHelpErr("LoadModule", dwRes, 0);

cnt++;

}

cleanup:

if (hPsapi != NULL)

FreeLibrary(hPsapi);

if (tt2 != NULL)

free(tt2);

if (tt != NULL)

free(tt);

if (hMods != NULL)

free(hMods);

return cnt != 0;

} // GetModuleListPSAPI

DWORD LoadModule(HANDLE hProcess, LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size)

{

CHAR* szImg = _strdup(img);

CHAR* szMod = _strdup(mod);

DWORD result = ERROR_SUCCESS;

if ((szImg == NULL) || (szMod == NULL))

result = ERROR_NOT_ENOUGH_MEMORY;

else

{

if (pSLM(hProcess, 0, szImg, szMod, baseAddr, size) == 0)

result = GetLastError();

}

ULONGLONG fileVersion = 0;

if ((m_parent != NULL) && (szImg != NULL))

{

// try to retrieve the file-version:

if ((this->m_parent->m_options & StackWalker::RetrieveFileVersion) != 0)

{

VS_FIXEDFILEINFO* fInfo = NULL;

DWORD dwHandle{ 0 };

DWORD dwSize = GetFileVersionInfoSizeA(szImg, &dwHandle);

if (dwSize > 0)

{

LPVOID vData = malloc(dwSize);

if (vData != NULL)

{

if (GetFileVersionInfoA(szImg, dwHandle, dwSize, vData) != 0)

{

UINT len;

TCHAR szSubBlock[] = _T("\\");

if (VerQueryValue(vData, szSubBlock, (LPVOID*)&fInfo, &len) == 0)

fInfo = NULL;

else

{

fileVersion =

((ULONGLONG)fInfo->dwFileVersionLS) + ((ULONGLONG)fInfo->dwFileVersionMS << 32);

}

}

free(vData);

}

}

}

// Retrieve some additional-infos about the module

IMAGEHLP_MODULE64_V3 Module;

const char* szSymType = "-unknown-";

if (this->GetModuleInfo(hProcess, baseAddr, &Module) != FALSE)

{

switch (Module.SymType)

{

case SymNone:

szSymType = "-nosymbols-";

break;

case SymCoff: // 1

szSymType = "COFF";

break;

case SymCv: // 2

szSymType = "CV";

break;

case SymPdb: // 3

szSymType = "PDB";

break;

case SymExport: // 4

szSymType = "-exported-";

break;

case SymDeferred: // 5

szSymType = "-deferred-";

break;

case SymSym: // 6

szSymType = "SYM";

break;

case 7: // SymDia:

szSymType = "DIA";

break;

case 8: //SymVirtual:

szSymType = "Virtual";

break;

}

}

LPCSTR pdbName = Module.LoadedImageName;

if (Module.LoadedPdbName[0] != 0)

pdbName = Module.LoadedPdbName;

this->m_parent->OnLoadModule(img, mod, baseAddr, size, result, szSymType, pdbName,

fileVersion);

}

if (szImg != NULL)

free(szImg);

if (szMod != NULL)

free(szMod);

return result;

}

BOOL LoadModules(HANDLE hProcess, DWORD dwProcessId)

{

// first try toolhelp32

if (GetModuleListTH32(hProcess, dwProcessId))

return true;

// then try psapi

return GetModuleListPSAPI(hProcess);

}

BOOL GetModuleInfo(HANDLE hProcess, DWORD64 baseAddr, IMAGEHLP_MODULE64_V3* pModuleInfo)

{

memset(pModuleInfo, 0, sizeof(IMAGEHLP_MODULE64_V3));

if (this->pSGMI == NULL)

{

SetLastError(ERROR_DLL_INIT_FAILED);

return FALSE;

}

// First try to use the larger ModuleInfo-Structure

pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V3);

void* pData = malloc(

4096); // reserve enough memory, so the bug in v6.3.5.1 does not lead to memory-overwrites...

if (pData == NULL)

{

SetLastError(ERROR_NOT_ENOUGH_MEMORY);

return FALSE;

}

memcpy(pData, pModuleInfo, sizeof(IMAGEHLP_MODULE64_V3));

static bool s_useV3Version = true;

if (s_useV3Version)

{

if (this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE)

{

// only copy as much memory as is reserved...

memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V3));

pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V3);

free(pData);

return TRUE;

}

s_useV3Version = false; // to prevent unnecessary calls with the larger struct...

}

// could not retrieve the bigger structure, try with the smaller one (as defined in VC7.1)...

pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2);

memcpy(pData, pModuleInfo, sizeof(IMAGEHLP_MODULE64_V2));

if (this->pSGMI(hProcess, baseAddr, (IMAGEHLP_MODULE64_V3*)pData) != FALSE)

{

// only copy as much memory as is reserved...

memcpy(pModuleInfo, pData, sizeof(IMAGEHLP_MODULE64_V2));

pModuleInfo->SizeOfStruct = sizeof(IMAGEHLP_MODULE64_V2);

free(pData);

return TRUE;

}

free(pData);

SetLastError(ERROR_DLL_INIT_FAILED);

return FALSE;

}

{

this->m_options = OptionsAll;

this->m_modulesLoaded = FALSE;

this->m_hProcess = hProcess;

this->m_sw = new StackWalkerInternal(this, this->m_hProcess);

this->m_dwProcessId = dwProcessId;

this->m_szSymPath = NULL;

this->m_MaxRecursionCount = 1000;

{

this->m_options = options;

this->m_modulesLoaded = FALSE;

this->m_hProcess = hProcess;

this->m_sw = new StackWalkerInternal(this, this->m_hProcess);

this->m_dwProcessId = dwProcessId;

if (szSymPath != NULL)

{

this->m_szSymPath = _strdup(szSymPath);

this->m_options |= SymBuildPath;

}

else

this->m_szSymPath = NULL;

this->m_MaxRecursionCount = 1000;

{

if (this->m_sw == NULL)

{

SetLastError(ERROR_DLL_INIT_FAILED);

return FALSE;

}

if (m_modulesLoaded != FALSE)

return TRUE;

// Build the sym-path:

char* szSymPath = NULL;

if ((this->m_options & SymBuildPath) != 0)

{

const size_t nSymPathLen = 4096;

szSymPath = (char*)malloc(nSymPathLen);

if (szSymPath == NULL)

{

SetLastError(ERROR_NOT_ENOUGH_MEMORY);

return FALSE;

}

szSymPath[0] = 0;

// Now first add the (optional) provided sympath:

if (this->m_szSymPath != NULL)

{

strcat_s(szSymPath, nSymPathLen, this->m_szSymPath);

strcat_s(szSymPath, nSymPathLen, ";");

}

strcat_s(szSymPath, nSymPathLen, ".;");

const size_t nTempLen = 1024;

char szTemp[nTempLen];

// Now add the current directory:

if (GetCurrentDirectoryA(nTempLen, szTemp) > 0)

{

szTemp[nTempLen - 1] = 0;

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

}

// Now add the path for the main-module:

if (GetModuleFileNameA(NULL, szTemp, nTempLen) > 0)

{

szTemp[nTempLen - 1] = 0;

for (char* p = (szTemp + strlen(szTemp) - 1); p >= szTemp; --p)

{

// locate the rightmost path separator

if ((*p == '\\') || (*p == '/') || (*p == ':'))

{

*p = 0;

break;

}

} // for (search for path separator...)

if (strlen(szTemp) > 0)

{

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

}

}

if (GetEnvironmentVariableA("_NT_SYMBOL_PATH", szTemp, nTempLen) > 0)

{

szTemp[nTempLen - 1] = 0;

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

}

if (GetEnvironmentVariableA("_NT_ALTERNATE_SYMBOL_PATH", szTemp, nTempLen) > 0)

{

szTemp[nTempLen - 1] = 0;

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

}

if (GetEnvironmentVariableA("SYSTEMROOT", szTemp, nTempLen) > 0)

{

szTemp[nTempLen - 1] = 0;

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

// also add the "system32"-directory:

strcat_s(szTemp, nTempLen, "\\system32");

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, ";");

}

if ((this->m_options & SymUseSymSrv) != 0)

{

if (GetEnvironmentVariableA("SYSTEMDRIVE", szTemp, nTempLen) > 0)

{

szTemp[nTempLen - 1] = 0;

strcat_s(szSymPath, nSymPathLen, "SRV*");

strcat_s(szSymPath, nSymPathLen, szTemp);

strcat_s(szSymPath, nSymPathLen, "\\websymbols");