mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3599 lines
105 KiB
3599 lines
105 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1999 - 2000
|
|
//
|
|
// File: moduleinfo.cpp
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
// ModuleInfo.cpp: implementation of the CModuleInfo class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef NO_STRICT
|
|
#ifndef STRICT
|
|
#define STRICT 1
|
|
#endif
|
|
#endif /* NO_STRICT */
|
|
|
|
#include <WINDOWS.H>
|
|
#include <STDIO.H>
|
|
#include <TCHAR.H>
|
|
|
|
#include <time.h>
|
|
#include "ModuleInfo.h"
|
|
#include "Globals.h"
|
|
#include "ProgramOptions.h"
|
|
#include "SymbolVerification.h"
|
|
#include "FileData.h"
|
|
#include "UtilityFunctions.h"
|
|
#include "DmpFile.h"
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
CModuleInfo::CModuleInfo()
|
|
{
|
|
m_dwRefCount = 1;
|
|
m_dwCurrentReadPosition = 0;
|
|
|
|
m_lpInputFile = NULL;
|
|
m_lpOutputFile = NULL;
|
|
m_lpDmpFile = NULL;
|
|
|
|
// File version information
|
|
m_fPEImageFileVersionInfo = false;
|
|
m_tszPEImageFileVersionDescription = NULL;
|
|
m_tszPEImageFileVersionCompanyName = NULL;
|
|
|
|
m_tszPEImageFileVersionString = NULL;
|
|
m_dwPEImageFileVersionMS = 0;
|
|
m_dwPEImageFileVersionLS = 0;
|
|
|
|
m_tszPEImageProductVersionString = NULL;
|
|
m_dwPEImageProductVersionMS = 0;
|
|
m_dwPEImageProductVersionLS = 0;
|
|
|
|
// PE Image Properties
|
|
m_tszPEImageModuleName = NULL; // Module name (eg. notepad.exe)
|
|
m_tszPEImageModuleFileSystemPath = NULL; // Full path to module (eg. C:\winnt\system32\notepad.exe)
|
|
m_dwPEImageFileSize = 0;
|
|
m_ftPEImageFileTimeDateStamp.dwLowDateTime = 0;
|
|
m_ftPEImageFileTimeDateStamp.dwHighDateTime = 0;
|
|
m_dwPEImageCheckSum = 0;
|
|
m_dwPEImageTimeDateStamp = 0;
|
|
m_dwPEImageSizeOfImage = 0;
|
|
m_enumPEImageType = PEImageTypeUnknown; // We need to track what ImageType we have (PE32/PE64/???)
|
|
m_dw64BaseAddress = 0;
|
|
|
|
m_wPEImageMachineArchitecture = 0;
|
|
m_wCharacteristics = 0; // These are the PE image characteristics
|
|
|
|
// PE Image has a reference to DBG file
|
|
m_enumPEImageSymbolStatus = SYMBOLS_NO; // Assume there are no symbols for this module
|
|
m_tszPEImageDebugDirectoryDBGPath = NULL; // Path to DBG (found in PE Image)
|
|
|
|
// PE Image has internal symbols
|
|
m_dwPEImageDebugDirectoryCoffSize = 0;
|
|
m_dwPEImageDebugDirectoryFPOSize = 0;
|
|
m_dwPEImageDebugDirectoryCVSize = 0;
|
|
m_dwPEImageDebugDirectoryOMAPtoSRCSize = 0;
|
|
m_dwPEImageDebugDirectoryOMAPfromSRCSize = 0;
|
|
|
|
// PE Image has a reference to PDB file...
|
|
m_tszPEImageDebugDirectoryPDBPath = NULL;
|
|
m_dwPEImageDebugDirectoryPDBFormatSpecifier = 0;
|
|
m_dwPEImageDebugDirectoryPDBSignature = 0; // PDB Signature (unique (across PDB instances) signature)
|
|
m_dwPEImageDebugDirectoryPDBAge = 0; // PDB Age (Number of times this instance has been updated)
|
|
m_tszPEImageDebugDirectoryPDBGuid = NULL;
|
|
|
|
// DBG Symbol information
|
|
m_enumDBGModuleStatus = SYMBOL_NOT_FOUND; // Status of the DBG file
|
|
m_tszDBGModuleFileSystemPath = NULL; // Path to the DBG file (after searching)
|
|
m_dwDBGTimeDateStamp = 0;
|
|
m_dwDBGCheckSum = 0;
|
|
m_dwDBGSizeOfImage = 0;
|
|
m_dwDBGImageDebugDirectoryCoffSize = 0;
|
|
m_dwDBGImageDebugDirectoryFPOSize = 0;
|
|
m_dwDBGImageDebugDirectoryCVSize = 0;
|
|
m_dwDBGImageDebugDirectoryOMAPtoSRCSize = 0;
|
|
m_dwDBGImageDebugDirectoryOMAPfromSRCSize = 0;
|
|
|
|
// DBG File has a reference to a PDB file...
|
|
m_tszDBGDebugDirectoryPDBPath = NULL;
|
|
m_dwDBGDebugDirectoryPDBFormatSpecifier = 0; // NB10, RSDS, etc...
|
|
m_dwDBGDebugDirectoryPDBAge = 0;
|
|
m_dwDBGDebugDirectoryPDBSignature = 0;
|
|
m_tszDBGDebugDirectoryPDBGuid = NULL;
|
|
|
|
// PDB File Information
|
|
m_enumPDBModuleStatus = SYMBOL_NOT_FOUND; // Status of the PDB file
|
|
m_tszPDBModuleFileSystemPath = NULL; // Path to the PDB file (after searching)
|
|
m_dwPDBFormatSpecifier = 0;
|
|
m_dwPDBSignature = 0;
|
|
m_dwPDBAge = 0;
|
|
m_tszPDBGuid = NULL;
|
|
m_dwPDBTotalBytesOfLineInformation = 0;
|
|
m_dwPDBTotalBytesOfSymbolInformation = 0;
|
|
m_dwPDBTotalSymbolTypesRange = 0;
|
|
}
|
|
|
|
CModuleInfo::~CModuleInfo()
|
|
{
|
|
// Let's cleanup a bit...
|
|
if (m_tszPEImageFileVersionDescription)
|
|
delete [] m_tszPEImageFileVersionDescription;
|
|
|
|
if (m_tszPEImageFileVersionCompanyName)
|
|
delete [] m_tszPEImageFileVersionCompanyName;
|
|
|
|
if (m_tszPEImageFileVersionString)
|
|
delete [] m_tszPEImageFileVersionString;
|
|
|
|
if (m_tszPEImageProductVersionString)
|
|
delete [] m_tszPEImageProductVersionString;
|
|
|
|
if (m_tszPEImageModuleName)
|
|
delete [] m_tszPEImageModuleName;
|
|
|
|
if (m_tszPEImageModuleFileSystemPath)
|
|
delete [] m_tszPEImageModuleFileSystemPath;
|
|
|
|
if (m_tszPEImageDebugDirectoryDBGPath)
|
|
delete [] m_tszPEImageDebugDirectoryDBGPath;
|
|
|
|
if (m_tszPEImageDebugDirectoryPDBPath)
|
|
delete [] m_tszPEImageDebugDirectoryPDBPath;
|
|
|
|
if (m_tszPEImageDebugDirectoryPDBGuid)
|
|
delete [] m_tszPEImageDebugDirectoryPDBGuid;
|
|
|
|
if (m_tszDBGModuleFileSystemPath)
|
|
delete [] m_tszDBGModuleFileSystemPath;
|
|
|
|
if (m_tszDBGDebugDirectoryPDBPath)
|
|
delete [] m_tszDBGDebugDirectoryPDBPath;
|
|
|
|
if (m_tszDBGDebugDirectoryPDBGuid)
|
|
delete [] m_tszDBGDebugDirectoryPDBGuid;
|
|
|
|
if (m_tszPDBModuleFileSystemPath)
|
|
delete [] m_tszPDBModuleFileSystemPath;
|
|
|
|
if (m_tszPDBGuid)
|
|
delete [] m_tszPDBGuid;
|
|
}
|
|
|
|
//bool CModuleInfo::Initialize(CProgramOptions * lpProgramOptions, CFileData * lpInputFile, CFileData * lpOutputFile)
|
|
bool CModuleInfo::Initialize(CFileData * lpInputFile, CFileData * lpOutputFile, CDmpFile * lpDmpFile)
|
|
{
|
|
// Let's save off the Program Options so we don't have to pass it to every method...
|
|
m_lpInputFile = lpInputFile;
|
|
m_lpOutputFile = lpOutputFile;
|
|
m_lpDmpFile = lpDmpFile;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::GetModuleInfo(LPTSTR tszModulePath, bool fDmpFile, DWORD64 dw64ModAddress, bool fGetDataFromCSVFile)
|
|
{
|
|
bool fReturn = true;
|
|
|
|
if (fGetDataFromCSVFile)
|
|
{
|
|
fReturn = GetModuleInfoFromCSVFile(tszModulePath);
|
|
} else
|
|
{
|
|
fReturn = GetModuleInfoFromPEImage(tszModulePath, fDmpFile, dw64ModAddress);
|
|
}
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
LPTSTR CModuleInfo::GetModulePath()
|
|
{
|
|
return m_tszPEImageModuleFileSystemPath;
|
|
}
|
|
|
|
bool CModuleInfo::OutputData(LPTSTR tszProcessName, DWORD iProcessID, unsigned int dwModuleNumber)
|
|
{
|
|
// Output to STDOUT?
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::QuietMode))
|
|
{
|
|
if (!OutputDataToStdout(dwModuleNumber))
|
|
return false;
|
|
}
|
|
|
|
// Output to file?
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::OutputCSVFileMode))
|
|
{
|
|
// Try and output to file...
|
|
if (!OutputDataToFile(tszProcessName, iProcessID))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::fCheckPDBSignature(bool fDmpFile, HANDLE hModuleHandle, OMFSignature *pSig, PDB_INFO *ppdb)
|
|
{
|
|
if (!DoRead(fDmpFile, hModuleHandle, pSig, sizeof(*pSig)))
|
|
return false;
|
|
|
|
if ( (pSig->Signature[0] != 'N') ||
|
|
(pSig->Signature[1] != 'B') ||
|
|
(!isdigit(pSig->Signature[2])) ||
|
|
(!isdigit(pSig->Signature[3])))
|
|
|
|
{
|
|
//
|
|
// If this is a DMP file (fDmpFile), odds are good that this was not compiled with
|
|
// a linker 6.20 or higher (which marks the PDB path in the PE image such
|
|
// that it gets mapped into the virtual address space (and will be in the user.dmp
|
|
// file).
|
|
//
|
|
|
|
return false;
|
|
}
|
|
|
|
// This switch statement is reminiscent of some windbg code...don't shoot me
|
|
// (I modified it slightly since the NB signature isn't super important to me)...
|
|
switch (*(LONG UNALIGNED *)(pSig->Signature))
|
|
{
|
|
case sigNB10: // OMF Signature, and hopefully some PDB INFO
|
|
{
|
|
if (!DoRead(fDmpFile, hModuleHandle, ppdb, sizeof(PDB_INFO)))
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Before returning true (since we have some form of NB## symbols), we'll save this...
|
|
/*
|
|
#ifdef _UNICODE
|
|
// Source is in ANSI, dest is in _UNICODE... need to convert...
|
|
MultiByteToWideChar(CP_ACP,
|
|
MB_PRECOMPOSED,
|
|
pSig->Signature,
|
|
4,
|
|
m_tszPEImageDebugDirectoryNBInfo,
|
|
4);
|
|
#else
|
|
// Copy the ANSI string over...
|
|
strncpy(m_tszPEImageDebugDirectoryNBInfo, pSig->Signature, 4);
|
|
#endif
|
|
|
|
m_tszPEImageDebugDirectoryNBInfo[4] = '\0';
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::VerifySymbols(CSymbolVerification * lpSymbolVerification)
|
|
{
|
|
bool fReturn = false;
|
|
|
|
if (!m_tszPEImageModuleName)
|
|
goto cleanup;
|
|
|
|
// Find/Verify a DBG file...
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_DBG)
|
|
{
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPath) )
|
|
{
|
|
fReturn = GetDBGModuleFileUsingSymbolPath(g_lpProgramOptions->GetSymbolPath());
|
|
}
|
|
|
|
// Do we want to try an alternate method to find symbols?
|
|
if ( m_enumDBGModuleStatus != SYMBOL_MATCH )
|
|
{
|
|
// Try SQL server next...
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSQLServer) )
|
|
{
|
|
fReturn = GetDBGModuleFileUsingSQLServer(lpSymbolVerification);
|
|
}
|
|
// Try SQL2 server next ... mjl 12/14/99
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSQLServer2) )
|
|
{
|
|
fReturn = GetDBGModuleFileUsingSQLServer2(lpSymbolVerification);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Note, it is possible that the m_enumPEImageSymbolStatus will have changed from SYMBOLS_DBG
|
|
// to SYMBOLS_DBG_AND_PDB after the DBG file is found above...
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) ||
|
|
(m_enumPEImageSymbolStatus == SYMBOLS_PDB) )
|
|
{
|
|
// This gets populated with the PDB filename (obtained from the DBG or PE Image)
|
|
// if (m_tszDebugDirectoryPDBPath)
|
|
if (GetDebugDirectoryPDBPath())
|
|
{
|
|
if (!lpSymbolVerification)
|
|
{
|
|
m_enumPDBModuleStatus = SYMBOL_NO_HELPER_DLL;
|
|
goto cleanup;
|
|
}
|
|
|
|
fReturn = GetPDBModuleFileUsingSymbolPath();
|
|
|
|
// Do we want to try an alternate method to find symbols?
|
|
if ( m_enumPDBModuleStatus != SYMBOL_MATCH )
|
|
{
|
|
// Search for PDB in SQL2 if enabled - mjl 12/14/99
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSQLServer2) )
|
|
{
|
|
fReturn = GetPDBModuleFileUsingSQLServer2(lpSymbolVerification);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
bool CModuleInfo::GetDBGModuleFileUsingSymbolPath(LPTSTR tszSymbolPath)
|
|
{
|
|
HANDLE hModuleHandle = INVALID_HANDLE_VALUE;
|
|
TCHAR tszDebugModulePath[_MAX_PATH+1];
|
|
TCHAR tszDrive[_MAX_DRIVE];
|
|
TCHAR tszDir[_MAX_DIR];
|
|
TCHAR tszExtModuleName[_MAX_EXT];
|
|
TCHAR tszDBGModuleName[_MAX_FNAME];
|
|
TCHAR tszSymbolPathWithModulePathPrepended[_MAX_PATH+_MAX_PATH+1];
|
|
TCHAR tszPEImageModuleName[_MAX_FNAME+_MAX_EXT+1];
|
|
|
|
bool fDebugSearchPaths = g_lpProgramOptions->fDebugSearchPaths();
|
|
|
|
// We have two options on the name of the DBG file...
|
|
//
|
|
// We compose the name of the DBG file we're searching for and pass that as the
|
|
// first parameter (we could grab that which is in the MISC section but the
|
|
// debuggers do not tend to do that...
|
|
//
|
|
// or
|
|
//
|
|
// We actually grab the MISC section and pull the name from there...
|
|
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeUsingDBGInMISCSection))
|
|
{
|
|
// We search for this PE Image by it's actual name...
|
|
_tcscpy(tszPEImageModuleName, m_tszPEImageModuleName);
|
|
|
|
// Compose the DBG filename from the PE Image Name
|
|
_tsplitpath(m_tszPEImageModuleName, NULL, NULL, tszDBGModuleName, NULL);
|
|
_tcscat(tszDBGModuleName, TEXT(".DBG"));
|
|
|
|
} else
|
|
{
|
|
// If we're told to grab the DBG name from the MISC section... and there isn't one...
|
|
// bail!
|
|
if (!m_tszPEImageDebugDirectoryDBGPath)
|
|
goto cleanup;
|
|
|
|
// Okay, the user wants us to look in the MISC section of the Debug Directories
|
|
// to figure out the DBG file location... though the FindDebugInfoFileEx() takes
|
|
// as an argument the name of the DBG file... if you provide the PE Image name
|
|
// instead, it performs a search that is more "broad"...
|
|
|
|
// Split the DBG file info found in the MISC section into components...
|
|
_tsplitpath(m_tszPEImageDebugDirectoryDBGPath, NULL, NULL, tszDBGModuleName, tszExtModuleName);
|
|
|
|
// Save the module name found here...
|
|
_tcscpy(tszPEImageModuleName, tszDBGModuleName);
|
|
|
|
// Append the DBG extension back on...
|
|
_tcscat(tszDBGModuleName, tszExtModuleName);
|
|
|
|
// Grab the extension of the PE Image and add it to end of our DBG module name..
|
|
_tsplitpath(m_tszPEImageModuleName, NULL, NULL, NULL, tszExtModuleName);
|
|
_tcscat(tszPEImageModuleName, tszExtModuleName);
|
|
}
|
|
|
|
// _tcsupr(tszDBGModuleName);
|
|
|
|
tszSymbolPathWithModulePathPrepended[0] = '\0'; // Fast way to empty this string ;)
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("DBG Search - Looking for [%s] Using Symbol Path...\n"), tszDBGModuleName);
|
|
};
|
|
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::BuildSymbolTreeMode) )
|
|
{
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("DBG Search - SEARCH in Symbol Tree We're Building!\n"));
|
|
};
|
|
|
|
// When we are constructing a build symbol tree... we should first
|
|
// search there to see if our symbol is already present...
|
|
hModuleHandle = CUtilityFunctions::FindDebugInfoFileEx(tszPEImageModuleName, g_lpProgramOptions->GetSymbolTreeToBuild(), tszDebugModulePath, VerifyDBGFile, this);
|
|
|
|
// Close handle if one is returned...
|
|
if (hModuleHandle != NULL)
|
|
{
|
|
CloseHandle(hModuleHandle);
|
|
}
|
|
|
|
// Hey, if we found it, we're done...
|
|
if (GetDBGSymbolModuleStatus() == SYMBOL_MATCH)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
// Okay, we're not building a symbol tree... or we didn't find our symbol match in
|
|
// the symbol tree... keep looking...
|
|
|
|
// Well... let's search the SymbolPath provided for the DBG file...
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathRecursion))
|
|
{
|
|
// Do we use recursion???
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("DBG Search - SEARCH Symbol path with recursion!\n"));
|
|
// ISSUE-2000/07/24-GREGWI: Does FindDebugInfoFileEx2 support SYMSRV?
|
|
};
|
|
|
|
hModuleHandle = CUtilityFunctions::FindDebugInfoFileEx2(tszDBGModuleName, tszSymbolPath, VerifyDBGFile, this);
|
|
|
|
} else
|
|
{
|
|
// Only do this if we're doing the standard file search mechanism...
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly))
|
|
{
|
|
// Don't do this block here if VerifySymbolsModeWithSymbolPathOnly option has been set...
|
|
|
|
// Hmm... Windbg changed behavior and now prepends the module path to the
|
|
// front of the symbolpath before called FindDebugInfoFileEx()...
|
|
_tsplitpath(m_tszPEImageModuleFileSystemPath, tszDrive, tszDir, NULL, NULL);
|
|
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, tszDrive);
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, tszDir);
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, TEXT(";"));
|
|
}
|
|
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, tszSymbolPath);
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("DBG Search - SEARCH Symbol path!\n"));
|
|
};
|
|
|
|
// Do we do the standard thing?
|
|
hModuleHandle = CUtilityFunctions::FindDebugInfoFileEx(tszPEImageModuleName, tszSymbolPathWithModulePathPrepended, tszDebugModulePath, VerifyDBGFile, this);
|
|
}
|
|
|
|
cleanup:
|
|
// If we have a hModuleHandle... free it now..
|
|
if (hModuleHandle != NULL)
|
|
{
|
|
CloseHandle(hModuleHandle);
|
|
}
|
|
|
|
// We found the following path
|
|
if (m_tszDBGModuleFileSystemPath)
|
|
{
|
|
// Okay, let's clean up any "strangeness" added by FindDebugInfoFileEx()
|
|
// If a symbol is found in the same directory as the module, it will be
|
|
// returned with an extra \.\ combination (which is superfluous normally)...
|
|
LPTSTR tszLocationOfExtraJunk = _tcsstr(m_tszDBGModuleFileSystemPath, TEXT("\\.\\"));
|
|
|
|
if ( tszLocationOfExtraJunk )
|
|
{
|
|
// Remember where we were...
|
|
LPTSTR tszPreviousLocation = tszLocationOfExtraJunk;
|
|
|
|
// Skip the junk...
|
|
tszLocationOfExtraJunk = CharNext(tszLocationOfExtraJunk); // '\\'
|
|
tszLocationOfExtraJunk = CharNext(tszLocationOfExtraJunk); // '.'
|
|
|
|
// While we have data... copy to the old location...
|
|
while (*tszLocationOfExtraJunk)
|
|
{
|
|
*tszPreviousLocation = *tszLocationOfExtraJunk;
|
|
tszLocationOfExtraJunk = CharNext(tszLocationOfExtraJunk);
|
|
tszPreviousLocation = CharNext(tszPreviousLocation);
|
|
}
|
|
|
|
// Null terminate the module path...
|
|
*tszPreviousLocation = '\0';
|
|
}
|
|
|
|
}
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
if (GetDBGSymbolModuleStatus() == SYMBOL_MATCH)
|
|
{
|
|
_tprintf(TEXT("DBG Search - Debug Module Found at [%s]\n\n"), m_tszDBGModuleFileSystemPath);
|
|
} else
|
|
{
|
|
_tprintf(TEXT("DBG Search - Debug Module Not Found.\n\n"));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::GetDBGModuleFileUsingSQLServer(CSymbolVerification * lpSymbolVerification)
|
|
{
|
|
// Do we need to initialize the SQL Server Connection?
|
|
if (!lpSymbolVerification->SQLServerConnectionInitialized() &&
|
|
!lpSymbolVerification->SQLServerConnectionAttempted())
|
|
{
|
|
if (!lpSymbolVerification->InitializeSQLServerConnection( g_lpProgramOptions->GetSQLServerName() ) )
|
|
return false;
|
|
}
|
|
|
|
// Let's only use the SQL Server if it was initialized properly...
|
|
if ( lpSymbolVerification->SQLServerConnectionInitialized() )
|
|
{
|
|
if (!lpSymbolVerification->SearchForDBGFileUsingSQLServer(m_tszPEImageModuleName, m_dwPEImageTimeDateStamp, this))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// begin SQL2 - mjl 12/14/99
|
|
bool CModuleInfo::GetDBGModuleFileUsingSQLServer2(CSymbolVerification * lpSymbolVerification)
|
|
{
|
|
// Do we need to initialize the SQL Server Connection?
|
|
if (!lpSymbolVerification->SQLServerConnectionInitialized2() &&
|
|
!lpSymbolVerification->SQLServerConnectionAttempted2())
|
|
{
|
|
if (!lpSymbolVerification->InitializeSQLServerConnection2( g_lpProgramOptions->GetSQLServerName2() ) )
|
|
return false;
|
|
}
|
|
|
|
// Let's only use the SQL Server if it was initialized properly...
|
|
if ( lpSymbolVerification->SQLServerConnectionInitialized2() )
|
|
{
|
|
if (!lpSymbolVerification->SearchForDBGFileUsingSQLServer2(m_tszPEImageModuleName, m_dwPEImageTimeDateStamp, this))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::GetPDBModuleFileUsingSQLServer2(CSymbolVerification * lpSymbolVerification)
|
|
{
|
|
// Do we need to initialize the SQL Server Connection?
|
|
if (!lpSymbolVerification->SQLServerConnectionInitialized2() &&
|
|
!lpSymbolVerification->SQLServerConnectionAttempted2())
|
|
{
|
|
if (!lpSymbolVerification->InitializeSQLServerConnection2( g_lpProgramOptions->GetSQLServerName2() ) )
|
|
return false;
|
|
}
|
|
|
|
// Let's only use the SQL Server if it was initialized properly...
|
|
if ( lpSymbolVerification->SQLServerConnectionInitialized2() )
|
|
{
|
|
if (!lpSymbolVerification->SearchForPDBFileUsingSQLServer2(m_tszPEImageModuleName, m_dwPEImageDebugDirectoryPDBSignature, this))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
// end SQL2 - mjl 12/14/99
|
|
|
|
bool CModuleInfo::fValidDBGCheckSum()
|
|
{
|
|
if (m_enumDBGModuleStatus == SYMBOL_MATCH)
|
|
return true;
|
|
|
|
if ((g_lpProgramOptions->GetVerificationLevel() == 1) && fValidDBGTimeDateStamp())
|
|
return true;
|
|
|
|
if (m_enumDBGModuleStatus == SYMBOL_POSSIBLE_MISMATCH)
|
|
return (m_dwPEImageCheckSum == m_dwDBGCheckSum);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CModuleInfo::fValidDBGTimeDateStamp()
|
|
{
|
|
return ( (m_enumDBGModuleStatus == SYMBOL_POSSIBLE_MISMATCH) ||
|
|
(m_enumDBGModuleStatus == SYMBOL_MATCH) )
|
|
? (m_dwPEImageTimeDateStamp == m_dwDBGTimeDateStamp ) : false;
|
|
}
|
|
|
|
bool CModuleInfo::GetPDBModuleFileUsingSymbolPath()
|
|
{
|
|
enum {
|
|
niNil = 0,
|
|
PDB_MAX_PATH = 260,
|
|
cbErrMax = 1024,
|
|
};
|
|
|
|
HANDLE hModuleHandle = NULL;
|
|
TCHAR tszSymbolPathWithModulePathPrepended[_MAX_PATH+_MAX_PATH+1];
|
|
bool fSuccess = false;
|
|
TCHAR tszRefPath[_MAX_PATH];
|
|
TCHAR tszImageExt[_MAX_EXT] = {0}; // In case there is no extension we need to null terminate now...
|
|
char szPDBOut[cbErrMax];
|
|
TCHAR tszPDBModuleName[_MAX_FNAME];
|
|
LPTSTR pcEndOfPath = NULL;
|
|
tszPDBModuleName[0] = '\0';
|
|
tszSymbolPathWithModulePathPrepended[0] = '\0';
|
|
bool fDebugSearchPaths = g_lpProgramOptions->fDebugSearchPaths();
|
|
|
|
_tsplitpath(m_tszPEImageModuleFileSystemPath, NULL, NULL, NULL, tszImageExt);
|
|
|
|
// Copy the symbol name we're searching for from the Debug Directories
|
|
//LPTSTR lptszPointerToPDBName = _tcsrchr(m_tszDebugDirectoryPDBPath, '\\');
|
|
LPTSTR lptszPointerToPDBName = _tcsrchr(GetDebugDirectoryPDBPath(), '\\');
|
|
|
|
// If we don't find a \ char, then go ahead and copy the PDBPath directly...
|
|
if (lptszPointerToPDBName == NULL)
|
|
{
|
|
//_tcscpy(tszPDBModuleName, m_tszDebugDirectoryPDBPath);
|
|
_tcscpy(tszPDBModuleName, GetDebugDirectoryPDBPath());
|
|
} else
|
|
{
|
|
// Advance past the \ char...
|
|
lptszPointerToPDBName = CharNext(lptszPointerToPDBName);
|
|
_tcscpy(tszPDBModuleName, lptszPointerToPDBName);
|
|
}
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
//_tprintf(TEXT("PDB Search - Looking for [%s] Using Symbol Path...\n"), g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : m_tszDebugDirectoryPDBPath);
|
|
_tprintf(TEXT("PDB Search - Looking for [%s] Using Symbol Path...\n"), g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : GetDebugDirectoryPDBPath());
|
|
};
|
|
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::BuildSymbolTreeMode) )
|
|
{
|
|
// When we are constructing a build symbol tree... we should first
|
|
// search there to see if our symbol is already present...
|
|
|
|
// Do we do the standard thing?
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - SEARCH in Symbol Tree We're Building!\n"));
|
|
};
|
|
|
|
//fSuccess = LocatePdb(g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : m_tszDebugDirectoryPDBPath,
|
|
fSuccess = LocatePdb(g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : GetDebugDirectoryPDBPath(),
|
|
m_dwPEImageDebugDirectoryPDBAge,
|
|
m_dwPEImageDebugDirectoryPDBSignature,
|
|
g_lpProgramOptions->GetSymbolTreeToBuild(),
|
|
&tszImageExt[1],
|
|
false);
|
|
|
|
// Hey, if we found it, we're done...
|
|
if (fSuccess)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly))
|
|
{
|
|
// Hey, we better have one or the other...
|
|
if (!m_tszDBGModuleFileSystemPath && !m_tszPEImageModuleFileSystemPath)
|
|
goto cleanup;
|
|
|
|
// figure out the home directory of the EXE/DLL or DBG file - pass that along to
|
|
// OpenValidate this will direct to dbi to search for it in that directory.
|
|
_tfullpath(tszRefPath, m_tszDBGModuleFileSystemPath ? m_tszDBGModuleFileSystemPath : m_tszPEImageModuleFileSystemPath, sizeof(tszRefPath)/sizeof(TCHAR));
|
|
pcEndOfPath = _tcsrchr(tszRefPath, '\\');
|
|
*pcEndOfPath = '\0'; // null terminate it
|
|
*szPDBOut = '\0';
|
|
|
|
if (_MAX_PATH+_MAX_PATH+1 < (_tcsclen(tszRefPath) + _tcsclen(g_lpProgramOptions->GetSymbolPath())+2))
|
|
goto cleanup; // Buffer isn't big enough... sigh...
|
|
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, tszRefPath);
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, TEXT(";"));
|
|
}
|
|
|
|
_tcscat(tszSymbolPathWithModulePathPrepended, g_lpProgramOptions->GetSymbolPath());
|
|
|
|
// Well... let's search the SymbolPath provided for the PDB file...
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathRecursion))
|
|
{
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - SEARCH Symbol path with recursion!\n"));
|
|
// ISSUE-2000/07/24-GREGWI: Does FindDebugInfoFileEx2 support SYMSRV?
|
|
};
|
|
|
|
// Do we use recursion???
|
|
// ISSUE-2000/07/24-GREGWI - Are we passing the right first arg? Is this supported?
|
|
hModuleHandle = CUtilityFunctions::FindDebugInfoFileEx2(tszPDBModuleName, tszSymbolPathWithModulePathPrepended, VerifyPDBFile, this);
|
|
|
|
if (hModuleHandle != NULL)
|
|
{
|
|
CloseHandle(hModuleHandle);
|
|
}
|
|
|
|
fSuccess = false;
|
|
} else
|
|
{
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - SEARCH Symbol path!\n"));
|
|
};
|
|
|
|
// Search for the PDB file the old fashioned way...
|
|
|
|
// fSuccess = LocatePdb(g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : m_tszDebugDirectoryPDBPath,
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_PDB)
|
|
{
|
|
fSuccess = LocatePdb(g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : GetDebugDirectoryPDBPath(),
|
|
m_dwPEImageDebugDirectoryPDBAge,
|
|
m_dwPEImageDebugDirectoryPDBSignature,
|
|
tszSymbolPathWithModulePathPrepended,
|
|
&tszImageExt[1],
|
|
false);
|
|
} else
|
|
{
|
|
fSuccess = LocatePdb(g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly) ? tszPDBModuleName : GetDebugDirectoryPDBPath(),
|
|
m_dwDBGDebugDirectoryPDBAge,
|
|
m_dwDBGDebugDirectoryPDBSignature,
|
|
tszSymbolPathWithModulePathPrepended,
|
|
&tszImageExt[1],
|
|
false);
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
if (GetPDBSymbolModuleStatus() == SYMBOL_MATCH)
|
|
{
|
|
_tprintf(TEXT("PDB Search - Debug Module Found at [%s]\n\n"), m_tszPDBModuleFileSystemPath);
|
|
} else
|
|
{
|
|
_tprintf(TEXT("PDB Search - Debug Module Not Found.\n\n"));
|
|
}
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
BOOL CModuleInfo::VerifyPDBFile(HANDLE hFileHandle, LPTSTR tszFileName, PVOID CallerData)
|
|
{
|
|
PDB * lpPdb = NULL;
|
|
EC ec = 0;
|
|
char szError[cbErrMax] = "";
|
|
bool fPdbModuleFound = false;
|
|
char szFileName[_MAX_FNAME+1];
|
|
hFileHandle = INVALID_HANDLE_VALUE;
|
|
|
|
// Let's grab the data passed to us...
|
|
CModuleInfo * lpModuleInfo = (CModuleInfo *) CallerData; // mjl
|
|
|
|
CUtilityFunctions::CopyTSTRStringToAnsi(tszFileName, szFileName, _MAX_FNAME+1);
|
|
|
|
PDBOpenValidate(szFileName, NULL, pdbRead, lpModuleInfo->m_dwPEImageDebugDirectoryPDBSignature, lpModuleInfo->m_dwPEImageDebugDirectoryPDBAge, &ec, szError, &lpPdb);
|
|
|
|
// Based on the return code, the path may be saved, and the PDB Module Status
|
|
// updated...
|
|
fPdbModuleFound = lpModuleInfo->HandlePDBOpenValidateReturn(lpPdb, tszFileName, ec);
|
|
|
|
if (lpPdb)
|
|
{
|
|
PDBClose(lpPdb);
|
|
lpPdb = NULL;
|
|
}
|
|
|
|
return fPdbModuleFound ? (ec == EC_OK) : FALSE;
|
|
}
|
|
|
|
bool
|
|
CModuleInfo::LocatePdb(
|
|
LPTSTR tszPDB,
|
|
ULONG PdbAge,
|
|
ULONG PdbSignature,
|
|
LPTSTR tszSymbolPath,
|
|
LPTSTR tszImageExt,
|
|
bool fImagePathPassed
|
|
)
|
|
{
|
|
PDB *lpPdb = NULL;
|
|
EC ec = 0;
|
|
char szError[cbErrMax] = "";
|
|
TCHAR tszPDBSansPath[_MAX_FNAME];
|
|
TCHAR tszPDBExt[_MAX_EXT];
|
|
TCHAR tszPDBLocal[_MAX_PATH];
|
|
char szPDBLocal[_MAX_PATH];
|
|
LPTSTR ptszSemiColon;
|
|
DWORD pass;
|
|
BOOL symsrv = TRUE;
|
|
TCHAR tszPDBName[_MAX_PATH];
|
|
bool fDebugSearchPaths = g_lpProgramOptions->fDebugSearchPaths();
|
|
|
|
// We're pessimistic initially...
|
|
m_enumPDBModuleStatus = SYMBOL_NOT_FOUND;
|
|
bool fPdbModuleFound = false;
|
|
|
|
// szSymbolPath is a semicolon delimited path (reference path first)
|
|
|
|
_tcscpy(tszPDBLocal, tszPDB);
|
|
_tsplitpath(tszPDBLocal, NULL, NULL, tszPDBSansPath, tszPDBExt);
|
|
|
|
do {
|
|
ptszSemiColon = _tcschr(tszSymbolPath, ';');
|
|
|
|
if (ptszSemiColon) {
|
|
*ptszSemiColon = '\0';
|
|
}
|
|
|
|
if (fImagePathPassed) {
|
|
pass = 2;
|
|
fImagePathPassed = 0;
|
|
} else {
|
|
pass = 0;
|
|
}
|
|
|
|
if (tszSymbolPath) {
|
|
do_again:
|
|
if (!_tcsnicmp(tszSymbolPath, TEXT("SYMSRV*"), 7)) {
|
|
|
|
*tszPDBLocal = 0;
|
|
_stprintf(tszPDBName, TEXT("%s%s"), tszPDBSansPath, TEXT(".pdb"));
|
|
|
|
if (symsrv) {
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - SYMSRV [%s,0x%x,0x%x]\n"),
|
|
tszSymbolPath,
|
|
PdbSignature,
|
|
PdbAge);
|
|
}
|
|
|
|
CUtilityFunctions::GetSymbolFileFromServer(tszSymbolPath,
|
|
tszPDBName,
|
|
PdbSignature,
|
|
PdbAge,
|
|
0,
|
|
tszPDBLocal);
|
|
symsrv = FALSE;
|
|
}
|
|
|
|
} else {
|
|
|
|
_tcscpy(tszPDBLocal, tszSymbolPath);
|
|
CUtilityFunctions::EnsureTrailingBackslash(tszPDBLocal);
|
|
|
|
// search order is ...
|
|
//
|
|
// %dir%\symbols\%ext%\%file%
|
|
// %dir%\%ext%\%file%
|
|
// %dir%\%file%
|
|
|
|
switch (pass)
|
|
{
|
|
case 0:
|
|
_tcscat(tszPDBLocal, TEXT("symbols"));
|
|
CUtilityFunctions::EnsureTrailingBackslash(tszPDBLocal);
|
|
// pass through
|
|
case 1:
|
|
_tcscat(tszPDBLocal, tszImageExt);
|
|
// pass through
|
|
default:
|
|
CUtilityFunctions::EnsureTrailingBackslash(tszPDBLocal);
|
|
break;
|
|
}
|
|
|
|
_tcscat(tszPDBLocal, tszPDBSansPath);
|
|
_tcscat(tszPDBLocal, tszPDBExt);
|
|
}
|
|
|
|
// Okay... at this point we may have a path to a PDB file to examine...
|
|
// If so, then issue the PDBOpenValidate() and attempt to verify it...
|
|
if (*tszPDBLocal)
|
|
{
|
|
CUtilityFunctions::CopyTSTRStringToAnsi(tszPDBLocal, szPDBLocal, _MAX_PATH);
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - Search here [%s]\n"), tszPDBLocal);
|
|
}
|
|
|
|
PDBOpenValidate(szPDBLocal, NULL, "r", PdbSignature, PdbAge, &ec, szError, &lpPdb);
|
|
|
|
if (lpPdb)
|
|
{
|
|
fPdbModuleFound = true;
|
|
}
|
|
|
|
// Based on the return code, the path may be saved, and the PDB Module Status
|
|
// updated...
|
|
if ( !HandlePDBOpenValidateReturn(lpPdb, tszPDBLocal, ec) )
|
|
goto cleanup;
|
|
|
|
if (fPdbModuleFound)
|
|
{
|
|
PDBClose(lpPdb);
|
|
lpPdb = NULL;
|
|
break;
|
|
} else
|
|
{
|
|
if (pass < 2)
|
|
{
|
|
pass++;
|
|
goto do_again;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we found a semicolon before... then restore the semi... and move just beyond it...
|
|
// Enable our symsrv searching again...
|
|
if (ptszSemiColon) {
|
|
*ptszSemiColon = ';';
|
|
ptszSemiColon++;
|
|
symsrv = TRUE;
|
|
}
|
|
|
|
// Reset the tszSymbolPath to the new location...
|
|
tszSymbolPath = ptszSemiColon;
|
|
|
|
} while (ptszSemiColon);
|
|
|
|
// Only try this last check if we're not bound to our Symbol Path Only
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsModeWithSymbolPathOnly))
|
|
{
|
|
// Okay... if pdb is still not found... then try the tszPDB location...
|
|
if (!lpPdb)
|
|
{
|
|
// ISSUE-2000/07/24-GREGWI: Is it required to copy the tszPDB string here?
|
|
_tcscpy(tszPDBLocal, tszPDB);
|
|
CUtilityFunctions::CopyTSTRStringToAnsi(tszPDBLocal, szPDBLocal, _MAX_PATH);
|
|
|
|
if (fDebugSearchPaths)
|
|
{
|
|
_tprintf(TEXT("PDB Search - Search here [%s]\n"), tszPDBLocal);
|
|
}
|
|
|
|
PDBOpenValidate(szPDBLocal, NULL, "r", PdbSignature, PdbAge, &ec, szError, &lpPdb);
|
|
|
|
if ( !HandlePDBOpenValidateReturn(lpPdb, tszPDBLocal, ec) )
|
|
goto cleanup;
|
|
|
|
if (lpPdb)
|
|
{
|
|
fPdbModuleFound = true;
|
|
PDBClose(lpPdb);
|
|
lpPdb = NULL;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
return fPdbModuleFound;
|
|
}
|
|
|
|
BOOL CModuleInfo::VerifyDBGFile(HANDLE hFileHandle, LPTSTR tszFileName, PVOID CallerData)
|
|
{
|
|
CModuleInfo * lpModuleInfo = (CModuleInfo * )CallerData;
|
|
WORD wMagic; // Read to identify a DBG file...
|
|
bool fPerfectMatch = false; // Assume we don't have a good DBG match...
|
|
|
|
// DBG Image Locals
|
|
IMAGE_SEPARATE_DEBUG_HEADER ImageSeparateDebugHeader;
|
|
|
|
// Start at the top of the image...
|
|
lpModuleInfo->SetReadPointer(false, hFileHandle, 0, FILE_BEGIN);
|
|
|
|
// Read in a signature word... is this a DBG file?
|
|
if ( !lpModuleInfo->DoRead(false, hFileHandle, &wMagic, sizeof(wMagic) ) )
|
|
goto cleanup;
|
|
|
|
// No sense in going further since we're expecting a DBG image file...
|
|
if (wMagic != IMAGE_SEPARATE_DEBUG_SIGNATURE)
|
|
goto cleanup;
|
|
|
|
// Start at the top of the image...
|
|
lpModuleInfo->SetReadPointer(false, hFileHandle, 0, FILE_BEGIN);
|
|
|
|
// Read in the full Separate Debug Header
|
|
if ( !lpModuleInfo->DoRead(false, hFileHandle, &ImageSeparateDebugHeader, sizeof(ImageSeparateDebugHeader) ) )
|
|
goto cleanup;
|
|
|
|
//
|
|
// We have a more stringent requirement for matching the checksum if the verification level is set...
|
|
//
|
|
if ( (lpModuleInfo->m_dwPEImageTimeDateStamp == ImageSeparateDebugHeader.TimeDateStamp ) &&
|
|
(lpModuleInfo->m_dwPEImageSizeOfImage == ImageSeparateDebugHeader.SizeOfImage ) )
|
|
{
|
|
if (g_lpProgramOptions->GetVerificationLevel() == 2)
|
|
{
|
|
if (lpModuleInfo->m_dwPEImageCheckSum == ImageSeparateDebugHeader.CheckSum)
|
|
fPerfectMatch = true;
|
|
} else
|
|
{
|
|
fPerfectMatch = true;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We're going to perform some action below unless this is not a perfect match
|
|
// and we've already picked up a "bad" DBG file reference...
|
|
//
|
|
if (!fPerfectMatch && lpModuleInfo->m_tszDBGModuleFileSystemPath)
|
|
goto cleanup;
|
|
|
|
//
|
|
// Take action based on our results...
|
|
// 1. If we have a perfect match... save our stuff!
|
|
// 2. If we don't already have a DBG, go ahead and save (even if wrong)
|
|
//
|
|
|
|
// Save off the checksum/linker information...
|
|
lpModuleInfo->m_dwDBGTimeDateStamp = ImageSeparateDebugHeader.TimeDateStamp;
|
|
lpModuleInfo->m_dwDBGCheckSum = ImageSeparateDebugHeader.CheckSum;
|
|
lpModuleInfo->m_dwDBGSizeOfImage = ImageSeparateDebugHeader.SizeOfImage;
|
|
|
|
// If we already had a path to a wrong DBG file, delete it...
|
|
if (lpModuleInfo->m_tszDBGModuleFileSystemPath)
|
|
{
|
|
delete [] lpModuleInfo->m_tszDBGModuleFileSystemPath;
|
|
lpModuleInfo->m_tszDBGModuleFileSystemPath = NULL;
|
|
}
|
|
|
|
// Save the Module Path now that we know we have a match...
|
|
// Okay, let's save off the path to the DBG file...
|
|
lpModuleInfo->m_tszDBGModuleFileSystemPath = (LPTSTR)CUtilityFunctions::CopyString(tszFileName);
|
|
|
|
// Delete any PDB reference we may have found in our last DBG file (if any)...
|
|
if (lpModuleInfo->m_tszDBGDebugDirectoryPDBPath)
|
|
{
|
|
delete [] lpModuleInfo->m_tszDBGDebugDirectoryPDBPath;
|
|
lpModuleInfo->m_tszDBGDebugDirectoryPDBPath = NULL;
|
|
}
|
|
|
|
//
|
|
// At this point, we only continue on if we've made a perfect "hit"
|
|
//
|
|
if (!fPerfectMatch)
|
|
{
|
|
// Not a perfect symbol.. record the status and exit...
|
|
lpModuleInfo->m_enumDBGModuleStatus = SYMBOL_POSSIBLE_MISMATCH;
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
// Good symbol.. record this...
|
|
lpModuleInfo->m_enumDBGModuleStatus = SYMBOL_MATCH;
|
|
|
|
// Now that we're done verifying the module... do we save the symbol in
|
|
// our tree?
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::BuildSymbolTreeMode) )
|
|
{
|
|
// Yup...
|
|
CUtilityFunctions::CopySymbolFileToSymbolTree(lpModuleInfo->m_tszPEImageModuleName, &lpModuleInfo->m_tszDBGModuleFileSystemPath, g_lpProgramOptions->GetSymbolTreeToBuild());
|
|
}
|
|
|
|
//
|
|
// Okay, now with a good symbol let's extract the goods...
|
|
//
|
|
|
|
// If there's no debug info, we can't continue further.
|
|
if (ImageSeparateDebugHeader.DebugDirectorySize == 0)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
// Okay, we need to advance by the IMAGE_SECTION_HEADER...
|
|
lpModuleInfo->SetReadPointer(false, hFileHandle, (ImageSeparateDebugHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)), FILE_CURRENT);
|
|
|
|
// Skip over the exported names.
|
|
if (ImageSeparateDebugHeader.ExportedNamesSize)
|
|
{
|
|
lpModuleInfo->SetReadPointer(false, hFileHandle, ImageSeparateDebugHeader.ExportedNamesSize, FILE_CURRENT);
|
|
}
|
|
|
|
if (!lpModuleInfo->ProcessDebugDirectory(false, false, hFileHandle, ImageSeparateDebugHeader.DebugDirectorySize, lpModuleInfo->GetReadPointer()))
|
|
goto cleanup;
|
|
|
|
cleanup:
|
|
|
|
return (fPerfectMatch ? TRUE : FALSE);
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToFile(LPTSTR tszProcessName, DWORD iProcessID)
|
|
{
|
|
|
|
LPTSTR tszString = NULL;
|
|
|
|
bool fReturn = false;
|
|
|
|
// We remove the first three columns if -E was specified...
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
// Let's skip the first column to make room for the tag in the first column...
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Process Name
|
|
//
|
|
if (tszProcessName)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(tszProcessName, true))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// BUG 524 - GREGWI - CheckSym - Unable to read CSV file generated on Windows 2000 Machine
|
|
// (I changed the code to emit the PID no matter what it's value, I was special casing 0)
|
|
//
|
|
// Process ID
|
|
//
|
|
// ISSUE-2000/07/24-GREGWI: Put conditional write back in (only emit if this is PROCESSES collection
|
|
// ISSUE-2000/07/24-GREGWI: we don't want to see 0 as the PID for any other collection....
|
|
if (tszProcessName)
|
|
{
|
|
// Let's only emit the PID if there is a process name...
|
|
if (!m_lpOutputFile->WriteDWORD(iProcessID))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
// if -E is specified, we only spit out if the module has a problem
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode) )
|
|
{
|
|
|
|
switch (m_enumPEImageSymbolStatus)
|
|
{
|
|
case SYMBOLS_DBG:
|
|
if ( m_enumDBGModuleStatus == SYMBOL_MATCH)
|
|
{
|
|
// Don't print this out.. it matches...
|
|
fReturn = true;
|
|
goto cleanup;
|
|
}
|
|
break;
|
|
|
|
case SYMBOLS_DBG_AND_PDB:
|
|
if ( m_enumDBGModuleStatus == SYMBOL_MATCH &&
|
|
m_enumPDBModuleStatus == SYMBOL_MATCH )
|
|
{
|
|
// Don't print this out.. it matches...
|
|
fReturn = true;
|
|
goto cleanup;
|
|
}
|
|
|
|
break;
|
|
|
|
case SYMBOLS_PDB:
|
|
if ( m_enumPDBModuleStatus == SYMBOL_MATCH)
|
|
{
|
|
// Don't print this out.. it matches...
|
|
fReturn = true;
|
|
goto cleanup;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Module Path
|
|
//
|
|
if (m_tszPEImageModuleFileSystemPath)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageModuleFileSystemPath, true))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Symbol Status
|
|
//
|
|
if (m_enumPEImageSymbolStatus != SYMBOL_INFORMATION_UNKNOWN)
|
|
{
|
|
tszString = SymbolInformationString(m_enumPEImageSymbolStatus);
|
|
|
|
if (tszString)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(tszString))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
// We remove this column if -E is specified
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
//
|
|
// Checksum
|
|
//
|
|
if ( m_enumPEImageSymbolStatus != SYMBOL_INFORMATION_UNKNOWN )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageCheckSum))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Time/Date Stamp
|
|
//
|
|
if ( m_enumPEImageSymbolStatus != SYMBOL_INFORMATION_UNKNOWN )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageTimeDateStamp))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
//
|
|
// Time/Date String
|
|
//
|
|
// If -E is specified we'll use version2 of the output format...
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
if ( m_enumPEImageSymbolStatus != SYMBOL_INFORMATION_UNKNOWN )
|
|
{
|
|
if (!m_lpOutputFile->WriteTimeDateString(m_dwPEImageTimeDateStamp))
|
|
goto cleanup;
|
|
}
|
|
} else
|
|
{
|
|
if (!m_lpOutputFile->WriteTimeDateString2(m_dwPEImageTimeDateStamp))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
// We remove these columns if -E is specified
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
//
|
|
// Size Of Image (internal PE value) - used for SYMSRV support
|
|
//
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageSizeOfImage))
|
|
goto cleanup;
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// DBG Pointer
|
|
//
|
|
if ( m_enumPEImageSymbolStatus == SYMBOLS_DBG ||
|
|
m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB )
|
|
{
|
|
// Output the Path
|
|
if (m_tszPEImageDebugDirectoryDBGPath)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageDebugDirectoryDBGPath, true))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// PDB Pointer
|
|
//
|
|
if ( m_enumPEImageSymbolStatus == SYMBOLS_PDB )
|
|
{
|
|
// Output the Path
|
|
if (GetDebugDirectoryPDBPath())
|
|
{
|
|
if (!m_lpOutputFile->WriteString(GetDebugDirectoryPDBPath(), true))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// PDB Signature
|
|
//
|
|
if ( m_enumPEImageSymbolStatus == SYMBOLS_PDB )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageDebugDirectoryPDBSignature))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// PDB Age
|
|
//
|
|
if ( m_enumPEImageSymbolStatus == SYMBOLS_PDB )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageDebugDirectoryPDBAge))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
//
|
|
// Product Version
|
|
//
|
|
// We remove these columns if -E is specified
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
if (m_fPEImageFileVersionInfo && m_tszPEImageProductVersionString)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageProductVersionString))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// File Version
|
|
//
|
|
if (m_fPEImageFileVersionInfo && m_tszPEImageFileVersionString)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageFileVersionString))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Company Name
|
|
//
|
|
if (m_fPEImageFileVersionInfo && m_tszPEImageFileVersionCompanyName)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageFileVersionCompanyName, true))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// File Description
|
|
//
|
|
if (m_fPEImageFileVersionInfo && m_tszPEImageFileVersionDescription)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPEImageFileVersionDescription, true))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
// We remove these columns if -E is specified
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
//
|
|
// File Size (in bytes)
|
|
//
|
|
if ( m_dwPEImageFileSize )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_dwPEImageFileSize))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
// File Date High Word
|
|
if ( m_ftPEImageFileTimeDateStamp.dwLowDateTime ||
|
|
m_ftPEImageFileTimeDateStamp.dwHighDateTime )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_ftPEImageFileTimeDateStamp.dwHighDateTime))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
// File Date Low Word
|
|
if ( m_ftPEImageFileTimeDateStamp.dwLowDateTime ||
|
|
m_ftPEImageFileTimeDateStamp.dwHighDateTime )
|
|
{
|
|
if (!m_lpOutputFile->WriteDWORD(m_ftPEImageFileTimeDateStamp.dwLowDateTime))
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
// File Date String
|
|
if ( m_ftPEImageFileTimeDateStamp.dwLowDateTime ||
|
|
m_ftPEImageFileTimeDateStamp.dwHighDateTime )
|
|
{
|
|
// If -E is specified we'll use version2 of the output format...
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::ExceptionMonitorMode))
|
|
{
|
|
if (!m_lpOutputFile->WriteFileTimeString(m_ftPEImageFileTimeDateStamp))
|
|
goto cleanup;
|
|
} else
|
|
{
|
|
if (!m_lpOutputFile->WriteFileTimeString2(m_ftPEImageFileTimeDateStamp))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsMode))
|
|
{
|
|
//
|
|
// Local DBG Status
|
|
//
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG) || (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) )
|
|
{
|
|
|
|
tszString = SymbolModuleStatusString(m_enumDBGModuleStatus);
|
|
|
|
if (tszString)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(tszString))
|
|
goto cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Local DBG
|
|
//
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG) || (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) )
|
|
{
|
|
if (m_tszDBGModuleFileSystemPath)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszDBGModuleFileSystemPath, true))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Local PDB Status
|
|
//
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) || (m_enumPEImageSymbolStatus == SYMBOLS_PDB) )
|
|
{
|
|
tszString = SymbolModuleStatusString(m_enumPDBModuleStatus);
|
|
|
|
if (tszString)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(tszString))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!m_lpOutputFile->WriteString(TEXT(",")))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Local PDB
|
|
//
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) || (m_enumPEImageSymbolStatus == SYMBOLS_PDB) )
|
|
{
|
|
if (m_tszPDBModuleFileSystemPath)
|
|
{
|
|
if (!m_lpOutputFile->WriteString(m_tszPDBModuleFileSystemPath, true))
|
|
goto cleanup;
|
|
}
|
|
}
|
|
}
|
|
// Write the carriage-return line-feed at the end of the line...
|
|
if (!m_lpOutputFile->WriteString(TEXT("\r\n")))
|
|
goto cleanup;
|
|
|
|
fReturn = true; // Success
|
|
|
|
cleanup:
|
|
|
|
if (!fReturn)
|
|
{
|
|
_tprintf(TEXT("Error: Failure writing module data!\n"));
|
|
m_lpOutputFile->PrintLastError();
|
|
}
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToStdout(DWORD dwModuleNumber)
|
|
{
|
|
//
|
|
// Do we output this module?
|
|
//
|
|
if (!OutputDataToStdoutThisModule())
|
|
return false;
|
|
|
|
//
|
|
// First, Output Module Info
|
|
//
|
|
OutputDataToStdoutModuleInfo(dwModuleNumber);
|
|
|
|
bool fPrintCarriageReturn = false;
|
|
|
|
//
|
|
// Second, if we were to collect symbol info, but NOT verify... dump out what we
|
|
// discovered about the symbol info...
|
|
//
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::OutputSymbolInformationMode) &&
|
|
!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsMode))
|
|
{
|
|
fPrintCarriageReturn = true;
|
|
|
|
switch (m_enumPEImageSymbolStatus)
|
|
{
|
|
case SYMBOL_INFORMATION_UNKNOWN:
|
|
_tprintf(TEXT(" Module symbol information was not collected!\n"));
|
|
break;
|
|
|
|
case SYMBOLS_NO:
|
|
_tprintf(TEXT(" Module has NO symbols!\n"));
|
|
break;
|
|
|
|
case SYMBOLS_LOCAL:
|
|
//
|
|
// This module has ONLY local symbols...
|
|
//
|
|
_tprintf(TEXT(" Module has internal symbols only! %s\n"), SourceEnabledPEImage());
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
break;
|
|
|
|
case SYMBOLS_DBG:
|
|
|
|
//
|
|
// This module may have Internal Symbols but has a DBG file...
|
|
//
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
|
|
//
|
|
// Output the DBG Symbol Information
|
|
//
|
|
OutputDataToStdoutDbgSymbolInfo(m_tszPEImageDebugDirectoryDBGPath, m_dwPEImageTimeDateStamp, m_dwPEImageCheckSum, m_dwPEImageSizeOfImage);
|
|
|
|
//
|
|
// Output the DBG Internal Symbol Information
|
|
//
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwDBGImageDebugDirectoryCoffSize, m_dwDBGImageDebugDirectoryFPOSize, m_dwDBGImageDebugDirectoryCVSize, m_dwDBGImageDebugDirectoryOMAPtoSRCSize, m_dwDBGImageDebugDirectoryOMAPfromSRCSize);
|
|
break;
|
|
|
|
case SYMBOLS_PDB:
|
|
//
|
|
// Output any internal symbols (that should be "splitsym'ed out")
|
|
//
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
|
|
//
|
|
// In this case, we have a PE Image with a PDB file...
|
|
//
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPEImageDebugDirectoryPDBFormatSpecifier, m_tszPEImageDebugDirectoryPDBPath, m_dwPEImageDebugDirectoryPDBSignature, m_tszPEImageDebugDirectoryPDBGuid, m_dwPEImageDebugDirectoryPDBAge);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Third, if we were to verify symbol info, display the results...
|
|
//
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsMode))
|
|
{
|
|
fPrintCarriageReturn = true;
|
|
|
|
switch (m_enumPEImageSymbolStatus)
|
|
{
|
|
case SYMBOL_INFORMATION_UNKNOWN:
|
|
_tprintf(TEXT(" Module symbol information was not collected!\n"));
|
|
break;
|
|
|
|
case SYMBOLS_NO:
|
|
_tprintf(TEXT(" Module has NO symbols\n"));
|
|
break;
|
|
|
|
case SYMBOLS_LOCAL:
|
|
_tprintf(TEXT(" Module has internal symbols only! %s\n"), SourceEnabledPEImage());
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
break;
|
|
|
|
case SYMBOLS_DBG:
|
|
case SYMBOLS_DBG_AND_PDB:
|
|
switch (m_enumDBGModuleStatus)
|
|
{
|
|
case SYMBOL_MATCH:
|
|
|
|
// Did they want the debug/symbol info for the PE image itself?
|
|
if(g_lpProgramOptions->GetMode(CProgramOptions::OutputSymbolInformationMode))
|
|
{
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
}
|
|
|
|
if(m_tszDBGModuleFileSystemPath )
|
|
{
|
|
_tprintf(TEXT(" DBG File = %s [VERIFIED] %s\n"), m_tszDBGModuleFileSystemPath, SourceEnabledDBGImage());
|
|
}
|
|
|
|
if(g_lpProgramOptions->GetMode(CProgramOptions::OutputSymbolInformationMode))
|
|
{
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwDBGImageDebugDirectoryCoffSize, m_dwDBGImageDebugDirectoryFPOSize, m_dwDBGImageDebugDirectoryCVSize, m_dwDBGImageDebugDirectoryOMAPtoSRCSize, m_dwDBGImageDebugDirectoryOMAPfromSRCSize);
|
|
}
|
|
break;
|
|
|
|
case SYMBOL_NOT_FOUND:
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
OutputDataToStdoutDbgSymbolInfo(m_tszPEImageDebugDirectoryDBGPath, m_dwPEImageTimeDateStamp, m_dwPEImageCheckSum, m_dwPEImageSizeOfImage);
|
|
_tprintf(TEXT(" DBG File NOT FOUND!\n"));
|
|
break; // If we didn't find the DBG file... we don't bother with the PDB...
|
|
|
|
case SYMBOL_POSSIBLE_MISMATCH:
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
|
|
OutputDataToStdoutDbgSymbolInfo(m_tszPEImageDebugDirectoryDBGPath, m_dwPEImageTimeDateStamp, m_dwPEImageCheckSum, m_dwPEImageSizeOfImage);
|
|
OutputDataToStdoutDbgSymbolInfo(m_tszDBGModuleFileSystemPath, m_dwDBGTimeDateStamp, m_dwDBGCheckSum, m_dwDBGSizeOfImage, TEXT("DISCREPANCY"), m_dwPEImageTimeDateStamp, m_dwPEImageCheckSum, m_dwPEImageSizeOfImage);
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwDBGImageDebugDirectoryCoffSize, m_dwDBGImageDebugDirectoryFPOSize, m_dwDBGImageDebugDirectoryCVSize, m_dwDBGImageDebugDirectoryOMAPtoSRCSize, m_dwDBGImageDebugDirectoryOMAPfromSRCSize);
|
|
break;
|
|
};
|
|
|
|
//
|
|
// Intentional fall through to SYMBOLS_PDB (we might have one)
|
|
//
|
|
|
|
case SYMBOLS_PDB:
|
|
|
|
// These two cases should have a PDB file... if we can find it...
|
|
//
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) ||
|
|
(m_enumPEImageSymbolStatus == SYMBOLS_PDB) )
|
|
{
|
|
//
|
|
// If we have a DebugDirectoryPDBPath... then display the goods...
|
|
//
|
|
if (GetDebugDirectoryPDBPath())
|
|
{
|
|
switch(m_enumPDBModuleStatus)
|
|
{
|
|
case SYMBOL_NOT_FOUND:
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
|
|
// Output PDB info as appropriate
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_PDB)
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPEImageDebugDirectoryPDBFormatSpecifier, m_tszPEImageDebugDirectoryPDBPath, m_dwPEImageDebugDirectoryPDBSignature, m_tszPEImageDebugDirectoryPDBGuid, m_dwPEImageDebugDirectoryPDBAge);
|
|
}
|
|
else
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwDBGDebugDirectoryPDBFormatSpecifier, m_tszDBGDebugDirectoryPDBPath, m_dwDBGDebugDirectoryPDBSignature, m_tszDBGDebugDirectoryPDBGuid, m_dwDBGDebugDirectoryPDBAge);
|
|
}
|
|
|
|
_tprintf(TEXT(" NO PDB FILE FOUND!!\n"));
|
|
break;
|
|
|
|
case SYMBOL_MATCH:
|
|
// Did they want the debug/symbol info for the PE image itself?
|
|
if(m_tszPDBModuleFileSystemPath )
|
|
_tprintf(TEXT(" PDB File = %s [VERIFIED] %s\n"), m_tszPDBModuleFileSystemPath, SourceEnabledPDB());
|
|
|
|
// BUGBUG: Testing...
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::OutputSymbolInformationMode))
|
|
{
|
|
if (m_dwPDBTotalBytesOfLineInformation)
|
|
_tprintf(TEXT(" Module PDB Bytes of Lines = 0x%x\n"), m_dwPDBTotalBytesOfLineInformation);
|
|
|
|
if (m_dwPDBTotalBytesOfSymbolInformation)
|
|
_tprintf(TEXT(" Module PDB Bytes of Symbols = 0x%x\n"), m_dwPDBTotalBytesOfSymbolInformation);
|
|
|
|
if (m_dwPDBTotalSymbolTypesRange)
|
|
_tprintf(TEXT(" Module PDB Symbol Types Range = 0x%x\n"), m_dwPDBTotalSymbolTypesRange);
|
|
}
|
|
|
|
break;
|
|
|
|
case SYMBOL_POSSIBLE_MISMATCH:
|
|
if(m_tszPDBModuleFileSystemPath )
|
|
{
|
|
// Output PDB info as appropriate
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_PDB)
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPEImageDebugDirectoryPDBFormatSpecifier, m_tszPEImageDebugDirectoryPDBPath, m_dwPEImageDebugDirectoryPDBSignature, m_tszPEImageDebugDirectoryPDBGuid, m_dwPEImageDebugDirectoryPDBAge);
|
|
}
|
|
else
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwDBGDebugDirectoryPDBFormatSpecifier, m_tszDBGDebugDirectoryPDBPath, m_dwDBGDebugDirectoryPDBSignature, m_tszDBGDebugDirectoryPDBGuid, m_dwDBGDebugDirectoryPDBAge);
|
|
}
|
|
|
|
//
|
|
// Output the PDB data itself...
|
|
//
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPDBFormatSpecifier, m_tszPDBModuleFileSystemPath, m_dwPDBSignature, m_tszPDBGuid, m_dwPDBAge, TEXT("DISCREPANCY"));
|
|
}
|
|
break;
|
|
|
|
case SYMBOL_INVALID_FORMAT:
|
|
if(m_tszPDBModuleFileSystemPath )
|
|
{
|
|
// Output PDB info as appropriate
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_PDB)
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPEImageDebugDirectoryPDBFormatSpecifier, m_tszPEImageDebugDirectoryPDBPath, m_dwPEImageDebugDirectoryPDBSignature, m_tszPEImageDebugDirectoryPDBGuid, m_dwPEImageDebugDirectoryPDBAge);
|
|
}
|
|
else
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwDBGDebugDirectoryPDBFormatSpecifier, m_tszDBGDebugDirectoryPDBPath, m_dwDBGDebugDirectoryPDBSignature, m_tszDBGDebugDirectoryPDBGuid, m_dwDBGDebugDirectoryPDBAge);
|
|
}
|
|
|
|
_tprintf(TEXT(" PDB File = %s [INVALID_FORMAT]\n"), m_tszPDBModuleFileSystemPath );
|
|
}
|
|
break;
|
|
|
|
case SYMBOL_NO_HELPER_DLL:
|
|
if(m_tszPDBModuleFileSystemPath )
|
|
{
|
|
// Output PDB info as appropriate
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_PDB)
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwPEImageDebugDirectoryPDBFormatSpecifier, m_tszPEImageDebugDirectoryPDBPath, m_dwPEImageDebugDirectoryPDBSignature, m_tszPEImageDebugDirectoryPDBGuid, m_dwPEImageDebugDirectoryPDBAge);
|
|
}
|
|
else
|
|
{
|
|
OutputDataToStdoutPdbSymbolInfo(m_dwDBGDebugDirectoryPDBFormatSpecifier, m_tszDBGDebugDirectoryPDBPath, m_dwDBGDebugDirectoryPDBSignature, m_tszDBGDebugDirectoryPDBGuid, m_dwDBGDebugDirectoryPDBAge);
|
|
}
|
|
|
|
_tprintf(TEXT(" PDB File = %s [Unable to Validate]\n"), m_tszPDBModuleFileSystemPath );
|
|
}
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
OutputDataToStdoutInternalSymbolInfo(m_dwPEImageDebugDirectoryCoffSize, m_dwPEImageDebugDirectoryFPOSize, m_dwPEImageDebugDirectoryCVSize, m_dwPEImageDebugDirectoryOMAPtoSRCSize, m_dwPEImageDebugDirectoryOMAPfromSRCSize);
|
|
OutputDataToStdoutDbgSymbolInfo(m_tszPEImageDebugDirectoryDBGPath, m_dwPEImageTimeDateStamp, m_dwPEImageCheckSum, m_dwPEImageSizeOfImage);
|
|
_tprintf(TEXT(" Module has PDB File\n"));
|
|
_tprintf(TEXT(" Module Pointer to PDB = [UNKNOWN] (Could not find in PE Image)\n"));
|
|
};
|
|
};
|
|
}
|
|
}
|
|
|
|
// Should we tack an extra carriage-return?
|
|
if ( fPrintCarriageReturn )
|
|
_tprintf(TEXT("\n"));
|
|
|
|
return true;
|
|
}
|
|
|
|
LPTSTR CModuleInfo::SymbolModuleStatusString(enum SymbolModuleStatus enumModuleStatus)
|
|
{
|
|
LPTSTR tszStringPointer = NULL;
|
|
|
|
// Output the Symbol Information for the PE module
|
|
switch (enumModuleStatus)
|
|
{
|
|
case SYMBOL_NOT_FOUND:
|
|
tszStringPointer = TEXT("SYMBOL_NOT_FOUND");
|
|
break;
|
|
|
|
case SYMBOL_MATCH:
|
|
tszStringPointer = TEXT("SYMBOL_MATCH");
|
|
break;
|
|
|
|
case SYMBOL_POSSIBLE_MISMATCH:
|
|
tszStringPointer = TEXT("SYMBOL_POSSIBLE_MISMATCH");
|
|
break;
|
|
|
|
case SYMBOL_INVALID_FORMAT:
|
|
tszStringPointer = TEXT("SYMBOL_INVALID_FORMAT");
|
|
break;
|
|
|
|
case SYMBOL_NO_HELPER_DLL:
|
|
tszStringPointer = TEXT("SYMBOL_NO_HELPER_DLL");
|
|
break;
|
|
|
|
default:
|
|
tszStringPointer = NULL;
|
|
}
|
|
|
|
return tszStringPointer;
|
|
}
|
|
|
|
LPTSTR CModuleInfo::SymbolInformationString(enum SymbolInformationForPEImage enumSymbolInformationForPEImage)
|
|
{
|
|
LPTSTR tszStringPointer = NULL;
|
|
|
|
// Ouput the Symbol Information for the PE module
|
|
switch (enumSymbolInformationForPEImage)
|
|
{
|
|
case SYMBOL_INFORMATION_UNKNOWN:
|
|
tszStringPointer = TEXT("SYMBOL_INFORMATION_UNKNOWN");
|
|
break;
|
|
|
|
case SYMBOLS_NO:
|
|
tszStringPointer = TEXT("SYMBOLS_NO");
|
|
break;
|
|
|
|
case SYMBOLS_LOCAL:
|
|
tszStringPointer = TEXT("SYMBOLS_LOCAL");
|
|
break;
|
|
|
|
case SYMBOLS_DBG:
|
|
tszStringPointer = TEXT("SYMBOLS_DBG");
|
|
break;
|
|
|
|
case SYMBOLS_DBG_AND_PDB:
|
|
tszStringPointer = TEXT("SYMBOLS_DBG_AND_PDB");
|
|
break;
|
|
|
|
case SYMBOLS_PDB:
|
|
tszStringPointer = TEXT("SYMBOLS_PDB");
|
|
break;
|
|
|
|
default:
|
|
tszStringPointer = NULL;
|
|
}
|
|
|
|
return tszStringPointer;
|
|
}
|
|
|
|
bool CModuleInfo::GetModuleInfoFromPEImage(LPTSTR tszModulePath, const bool fDmpFile, const DWORD64 dw64ModAddress)
|
|
{
|
|
HANDLE hModuleHandle = INVALID_HANDLE_VALUE;
|
|
bool fReturn = false;
|
|
|
|
// PE File Version
|
|
TCHAR tszFileName[_MAX_FNAME];
|
|
TCHAR tszFileExtension[_MAX_EXT];
|
|
DWORD dwVersionInfoSize = 0;
|
|
DWORD dwHandle = 0;
|
|
LPBYTE lpBuffer = NULL;
|
|
VS_FIXEDFILEINFO * lpFixedFileInfo = NULL;
|
|
DWORD * pdwLang = NULL;
|
|
unsigned int cbLang = 0;
|
|
unsigned int uint = 0;
|
|
TCHAR achName[256];
|
|
LPTSTR psz = NULL;
|
|
|
|
// PE Image Locals
|
|
IMAGE_DOS_HEADER ImageDosHeader;
|
|
DWORD dwMagic;
|
|
IMAGE_FILE_HEADER ImageFileHeader;
|
|
IMAGE_DATA_DIRECTORY DebugImageDataDirectory;
|
|
IMAGE_OPTIONAL_HEADER64 ImageOptionalHeader64;
|
|
PIMAGE_OPTIONAL_HEADER32 lpImageOptionalHeader32 = NULL;
|
|
PIMAGE_SECTION_HEADER lpImageSectionHeader = NULL;
|
|
ULONG OffsetImageDebugDirectory;
|
|
|
|
|
|
unsigned long ul;
|
|
// bool fDBGSymbolStrippedFromImage = false;
|
|
bool fCodeViewSectionFound = false;
|
|
// unsigned long NumDebugDirs;
|
|
|
|
// Save the base address so that all DmpFile reads become relative to this...
|
|
m_dw64BaseAddress = dw64ModAddress;
|
|
|
|
// We don't know anything about symbols yet... (we may not when we exit if the user
|
|
// didn't ask us to look...)
|
|
m_enumPEImageSymbolStatus = SYMBOL_INFORMATION_UNKNOWN;
|
|
|
|
if (!fDmpFile)
|
|
{
|
|
// Copy the Module Name to the ModuleInfo Object...
|
|
_tsplitpath(m_tszPEImageModuleFileSystemPath, NULL, NULL, tszFileName, tszFileExtension);
|
|
|
|
if (tszFileName && tszFileExtension)
|
|
{
|
|
// Compose the module name...
|
|
m_tszPEImageModuleName = new TCHAR[_tcsclen(tszFileName)+_tcsclen(tszFileExtension)+1];
|
|
|
|
if (!m_tszPEImageModuleName)
|
|
goto cleanup;
|
|
|
|
_tcscpy(m_tszPEImageModuleName, tszFileName);
|
|
_tcscat(m_tszPEImageModuleName, tszFileExtension);
|
|
}
|
|
|
|
// Let's open the file... we use this for both Version Info and Symbol Info
|
|
// gathering...
|
|
hModuleHandle = CreateFile( tszModulePath,
|
|
GENERIC_READ ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
0);
|
|
|
|
if (hModuleHandle == INVALID_HANDLE_VALUE)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
// Did the user request version information?
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::CollectVersionInfoMode) && !fDmpFile)
|
|
{
|
|
|
|
// Now, get CheckSum, TimeDateStamp, and other Image properties...
|
|
BY_HANDLE_FILE_INFORMATION lpFileInformation;
|
|
|
|
if ( GetFileInformationByHandle(hModuleHandle, &lpFileInformation) )
|
|
{
|
|
// Get the file size...
|
|
m_dwPEImageFileSize = lpFileInformation.nFileSizeLow;
|
|
|
|
m_ftPEImageFileTimeDateStamp = lpFileInformation.ftLastWriteTime;
|
|
}
|
|
|
|
// First, is there any FileVersionInfo at all?
|
|
dwVersionInfoSize = GetFileVersionInfoSize(m_tszPEImageModuleFileSystemPath, &dwHandle);
|
|
|
|
if (dwVersionInfoSize != 0)
|
|
{
|
|
// Allocate a buffer to read into...
|
|
lpBuffer = new BYTE[dwVersionInfoSize];
|
|
|
|
if (lpBuffer)
|
|
{
|
|
// Okay... query to get this version info...
|
|
if (GetFileVersionInfo(m_tszPEImageModuleFileSystemPath, dwHandle, dwVersionInfoSize, lpBuffer))
|
|
{
|
|
// Well, we returned the buffer...
|
|
m_fPEImageFileVersionInfo = true;
|
|
|
|
// Get the VS_FIXEDFILEINFO structure which carries version info...
|
|
if (VerQueryValue(lpBuffer, TEXT("\\"), (LPVOID *)&lpFixedFileInfo, &uint))
|
|
{
|
|
m_dwPEImageFileVersionMS = lpFixedFileInfo->dwFileVersionMS;
|
|
m_dwPEImageFileVersionLS = lpFixedFileInfo->dwFileVersionLS;
|
|
|
|
m_dwPEImageProductVersionMS = lpFixedFileInfo->dwProductVersionMS;
|
|
m_dwPEImageProductVersionLS = lpFixedFileInfo->dwProductVersionLS;
|
|
|
|
// Okay, before we go allocating a version string... let's ensure
|
|
// we actually have a version number worth reporting...
|
|
if ( m_dwPEImageFileVersionMS || m_dwPEImageFileVersionLS )
|
|
{
|
|
m_tszPEImageFileVersionString = new TCHAR[1+5+1+5+1+5+1+5+1+1]; // Format will be (#.#:#.#) where each # is a word
|
|
|
|
if (m_tszPEImageFileVersionString) // Okay, blitz the data into place...
|
|
_stprintf( m_tszPEImageFileVersionString, TEXT("(%d.%d:%d.%d)"), HIWORD(m_dwPEImageFileVersionMS), LOWORD(m_dwPEImageFileVersionMS), HIWORD(m_dwPEImageFileVersionLS), LOWORD(m_dwPEImageFileVersionLS) );
|
|
}
|
|
|
|
// Okay, before we go allocating a version string... let's ensure
|
|
// we actually have a version number worth reporting...
|
|
if ( m_dwPEImageProductVersionMS || m_dwPEImageProductVersionLS )
|
|
{
|
|
m_tszPEImageProductVersionString = new TCHAR[1+5+1+5+1+5+1+5+1+1]; // Format will be (#.#:#.#) where each # is a word
|
|
|
|
if (m_tszPEImageProductVersionString) // Okay, blitz the data into place...
|
|
_stprintf( m_tszPEImageProductVersionString, TEXT("(%d.%d:%d.%d)"), HIWORD(m_dwPEImageFileVersionMS), LOWORD(m_dwPEImageFileVersionMS), HIWORD(m_dwPEImageProductVersionLS), LOWORD(m_dwPEImageProductVersionLS) );
|
|
}
|
|
|
|
}
|
|
|
|
// Get the language and codepage information for the CompanyName and
|
|
// FileDescription string table resources...
|
|
if (VerQueryValue(lpBuffer, TEXT("\\VarFileInfo\\Translation"), (LPVOID *)&pdwLang, &cbLang))
|
|
{
|
|
_stprintf(achName,TEXT("\\StringFileInfo\\%04x%04x\\CompanyName"),
|
|
LOWORD(*pdwLang),
|
|
HIWORD(*pdwLang));
|
|
|
|
if (VerQueryValue(lpBuffer, achName, (LPVOID *)&psz, &uint))
|
|
{
|
|
// Cool, we have a Company Name...
|
|
if (psz && *psz)
|
|
{
|
|
m_tszPEImageFileVersionCompanyName = new TCHAR[_tcslen(psz)+1];
|
|
|
|
if (m_tszPEImageFileVersionCompanyName)
|
|
_tcscpy(m_tszPEImageFileVersionCompanyName, psz);
|
|
}
|
|
|
|
}
|
|
|
|
_stprintf(achName,TEXT("\\StringFileInfo\\%04x%04x\\FileDescription"),
|
|
LOWORD(*pdwLang),
|
|
HIWORD(*pdwLang));
|
|
|
|
if (VerQueryValue(lpBuffer, achName, (LPVOID *)&psz, &uint))
|
|
{
|
|
// Cool, we have a Company Name...
|
|
if (psz && *psz)
|
|
{
|
|
m_tszPEImageFileVersionDescription = new TCHAR[_tcslen(psz)+1];
|
|
if (m_tszPEImageFileVersionDescription)
|
|
_tcscpy(m_tszPEImageFileVersionDescription, psz);
|
|
}
|
|
|
|
}
|
|
|
|
// If we still don't have a proper file version... just try
|
|
// and grab the FileVersion string and hope it's good...
|
|
if ( !m_dwPEImageFileVersionMS && !m_dwPEImageFileVersionLS )
|
|
{
|
|
_stprintf(achName,TEXT("\\StringFileInfo\\%04x%04x\\FileVersion"),
|
|
LOWORD(*pdwLang),
|
|
HIWORD(*pdwLang));
|
|
|
|
if (VerQueryValue(lpBuffer, achName, (LPVOID *)&psz, &uint))
|
|
{
|
|
// Cool, we have a FileVersion String...
|
|
if (psz && *psz)
|
|
{
|
|
m_tszPEImageFileVersionString = new TCHAR[_tcslen(psz)+1];
|
|
if (m_tszPEImageFileVersionString)
|
|
_tcscpy(m_tszPEImageFileVersionString, psz);
|
|
}
|
|
}
|
|
}
|
|
// If we still don't have a proper file version... just try
|
|
// and grab the ProductVersion string and hope it's good...
|
|
if ( !m_dwPEImageProductVersionMS && !m_dwPEImageProductVersionLS )
|
|
{
|
|
_stprintf(achName,TEXT("\\StringFileInfo\\%04x%04x\\ProductVersion"),
|
|
LOWORD(*pdwLang),
|
|
HIWORD(*pdwLang));
|
|
|
|
if (VerQueryValue(lpBuffer, achName, (LPVOID *)&psz, &uint))
|
|
{
|
|
// Cool, we have a FileVersion String...
|
|
if (psz && *psz)
|
|
{
|
|
m_tszPEImageProductVersionString = new TCHAR[_tcslen(psz)+1];
|
|
if (m_tszPEImageProductVersionString)
|
|
_tcscpy(m_tszPEImageProductVersionString, psz);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the user chose not to collect or verify symbol information, then bail out of here...
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::OutputSymbolInformationMode) &&
|
|
!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsMode))
|
|
{
|
|
fReturn = true;
|
|
goto cleanup;
|
|
}
|
|
|
|
// Start at the top of the image...
|
|
SetReadPointer(fDmpFile, hModuleHandle, 0, FILE_BEGIN);
|
|
|
|
// Read in a dos exe header
|
|
if ( !DoRead(fDmpFile, hModuleHandle, &ImageDosHeader, sizeof(ImageDosHeader) ) )
|
|
goto cleanup;
|
|
|
|
if (ImageDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
|
|
{ // No sense in going further since we're expecting a PE image file...
|
|
goto cleanup;
|
|
}
|
|
|
|
if (ImageDosHeader.e_lfanew == 0)
|
|
{ // This is a DOS program... very odd...
|
|
goto cleanup;
|
|
}
|
|
|
|
// Great, we have a valid DOS_SIGNATURE... now read in the NT_SIGNATURE?!
|
|
SetReadPointer(fDmpFile, hModuleHandle, ImageDosHeader.e_lfanew, FILE_BEGIN);
|
|
|
|
// Read in a DWORD to see if this is an image worth looking at...
|
|
if ( !DoRead(fDmpFile, hModuleHandle, &dwMagic, sizeof(DWORD)) )
|
|
goto cleanup;
|
|
|
|
// Probe to see if this is a valid image... we only handle NT images (PE/PE64)
|
|
if (dwMagic != IMAGE_NT_SIGNATURE)
|
|
goto cleanup;
|
|
|
|
// Now read the ImageFileHeader...
|
|
if ( !DoRead(fDmpFile, hModuleHandle, &ImageFileHeader, sizeof(IMAGE_FILE_HEADER)) )
|
|
goto cleanup;
|
|
|
|
// Okay, we have a PE Image!!!!
|
|
|
|
// Save the Time Date Stamp
|
|
m_dwPEImageTimeDateStamp = ImageFileHeader.TimeDateStamp;
|
|
|
|
// Save the Machine Architecture
|
|
m_wPEImageMachineArchitecture = ImageFileHeader.Machine;
|
|
|
|
// Save the PE Image Characteristics
|
|
m_wCharacteristics = ImageFileHeader.Characteristics;
|
|
|
|
// The OptionalHeader is necessary to get the SizeOfImage and to find the DebugDirectoryInfo.
|
|
if (ImageFileHeader.SizeOfOptionalHeader == 0)
|
|
goto cleanup;
|
|
|
|
// Now... the size of the Optional Header is DIFFERENT between PE32 and PE64...
|
|
// The only items we need from the option header are:
|
|
//
|
|
// ULONG CheckSum
|
|
// ULONG SizeOfImage
|
|
// IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG]
|
|
//
|
|
// We'll read as a PE64 (since it's larger) and cast to PE32 if required...
|
|
if ( !DoRead(fDmpFile, hModuleHandle, &ImageOptionalHeader64, sizeof(IMAGE_OPTIONAL_HEADER64)) )
|
|
goto cleanup;
|
|
|
|
switch (ImageOptionalHeader64.Magic)
|
|
{
|
|
case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
|
|
|
|
m_enumPEImageType = PE32;
|
|
|
|
lpImageOptionalHeader32 = (PIMAGE_OPTIONAL_HEADER32)&ImageOptionalHeader64;
|
|
|
|
// Save the Checksum info (though it's not very relavent to identifying symbols)
|
|
m_dwPEImageCheckSum = lpImageOptionalHeader32->CheckSum;
|
|
|
|
// Save the SizeOfImage info...
|
|
m_dwPEImageSizeOfImage = lpImageOptionalHeader32->SizeOfImage;
|
|
|
|
// Get the preferred load address (but only if we don't already have one)
|
|
if (m_dw64BaseAddress != 0)
|
|
{
|
|
m_dw64BaseAddress = lpImageOptionalHeader32->ImageBase;
|
|
}
|
|
|
|
DebugImageDataDirectory.Size = lpImageOptionalHeader32->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
|
|
DebugImageDataDirectory.VirtualAddress = lpImageOptionalHeader32->DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;
|
|
|
|
break;
|
|
|
|
case IMAGE_NT_OPTIONAL_HDR64_MAGIC:
|
|
|
|
m_enumPEImageType = PE64;
|
|
|
|
// Save the Checksum info (though it's not very relavent to identifying symbols)
|
|
m_dwPEImageCheckSum = ImageOptionalHeader64.CheckSum;
|
|
|
|
// Save the SizeOfImage info...
|
|
m_dwPEImageSizeOfImage = ImageOptionalHeader64.SizeOfImage;
|
|
|
|
// Get the preferred load address (but only if we don't already have one)
|
|
if (m_dw64BaseAddress != 0)
|
|
{
|
|
m_dw64BaseAddress = ImageOptionalHeader64.ImageBase;
|
|
}
|
|
|
|
DebugImageDataDirectory.Size = ImageOptionalHeader64.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].Size;
|
|
DebugImageDataDirectory.VirtualAddress = ImageOptionalHeader64.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;
|
|
|
|
break;
|
|
|
|
default:
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
// Let's quickly look to see if there is even a Debug Directory in the PE image!
|
|
if (DebugImageDataDirectory.Size == 0)
|
|
{
|
|
m_enumPEImageSymbolStatus = SYMBOLS_NO;
|
|
fReturn = true;
|
|
goto cleanup; // No Debug Directory found...
|
|
}
|
|
|
|
// Now, go ahead and allocate the storage...
|
|
lpImageSectionHeader = (PIMAGE_SECTION_HEADER) new IMAGE_SECTION_HEADER[ImageFileHeader.NumberOfSections];
|
|
|
|
if (lpImageSectionHeader == NULL)
|
|
goto cleanup;
|
|
|
|
// Set the pointer to the start of the Section Headers... (we may need to back up if we read
|
|
// PE64 Optional Headers and this is a PE32 image...
|
|
if (m_enumPEImageType == PE32)
|
|
{
|
|
SetReadPointer(fDmpFile, hModuleHandle, (LONG)(sizeof(IMAGE_OPTIONAL_HEADER32)-sizeof(IMAGE_OPTIONAL_HEADER64)), FILE_CURRENT);
|
|
}
|
|
|
|
// Read in the Section Headers...
|
|
if (!DoRead(fDmpFile, hModuleHandle, lpImageSectionHeader, (ImageFileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER))))
|
|
goto cleanup;
|
|
|
|
// Let's walk through these Section Headers...
|
|
|
|
// For PE images, walk the section headers looking for the
|
|
// one that's got the debug directory.
|
|
for (ul=0; ul < ImageFileHeader.NumberOfSections; ul++) {
|
|
|
|
// If the virtual address for the Debug Entry falls into this section header, then we've found it!
|
|
if ( DebugImageDataDirectory.VirtualAddress >= lpImageSectionHeader[ul].VirtualAddress &&
|
|
DebugImageDataDirectory.VirtualAddress < lpImageSectionHeader[ul].VirtualAddress + lpImageSectionHeader[ul].SizeOfRawData )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Assuming we haven't exhausted the list of section headers, we should have the debug directory now.
|
|
if (ul >= ImageFileHeader.NumberOfSections)
|
|
{
|
|
m_enumPEImageSymbolStatus = SYMBOLS_NO;
|
|
fReturn = true;
|
|
goto cleanup; // No Debug Directory found...
|
|
}
|
|
|
|
// For a DmpFile, the address is based on the Section Header's Virtual Address, not PointerToRawData
|
|
if (fDmpFile)
|
|
{
|
|
OffsetImageDebugDirectory = ((DebugImageDataDirectory.VirtualAddress - lpImageSectionHeader[ul].VirtualAddress) + lpImageSectionHeader[ul].VirtualAddress);
|
|
|
|
} else
|
|
{
|
|
OffsetImageDebugDirectory = ((DebugImageDataDirectory.VirtualAddress - lpImageSectionHeader[ul].VirtualAddress) + lpImageSectionHeader[ul].PointerToRawData);
|
|
}
|
|
|
|
// NumDebugDirs = DebugImageDataDirectory.Size / sizeof(IMAGE_DEBUG_DIRECTORY);
|
|
|
|
if (!ProcessDebugDirectory(true, fDmpFile, hModuleHandle, DebugImageDataDirectory.Size, OffsetImageDebugDirectory))
|
|
goto cleanup;
|
|
|
|
fReturn = true;
|
|
|
|
// fDBGSymbolStrippedFromImage = (ImageFileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) == IMAGE_FILE_DEBUG_STRIPPED;
|
|
// fIMAGE_FILE_LOCAL_SYMS_STRIPPED = (ImageFileHeader.Characteristics & IMAGE_FILE_LOCAL_SYMS_STRIPPED) == IMAGE_FILE_LOCAL_SYMS_STRIPPED;
|
|
|
|
/**
|
|
**
|
|
** What type of symbols were found to be present...
|
|
**
|
|
** NO SYMBOLS
|
|
** =============
|
|
** No Debug Directory
|
|
** NO Debug information stripped
|
|
** Symbols stripped
|
|
**
|
|
** LOCAL SYMBOLS
|
|
** =============
|
|
** Debug Directory
|
|
** NO Debug information stripped
|
|
** NO Symbols stripped
|
|
**
|
|
** PDB SYMBOL
|
|
** =============
|
|
** Debug Directory
|
|
** NO Debug information stripped
|
|
** Symbols stripped
|
|
**
|
|
** DBG SYMBOL
|
|
** =============
|
|
** Debug Directory (assumed)
|
|
** BOTH - YES/NO Debug information stripped
|
|
** NO Symbols stripped
|
|
**
|
|
**/
|
|
|
|
if ((ImageFileHeader.Characteristics & IMAGE_FILE_DEBUG_STRIPPED) == IMAGE_FILE_DEBUG_STRIPPED)
|
|
{ // Debug Information Stripped! (A DBG file is assumed)
|
|
m_enumPEImageSymbolStatus = SYMBOLS_DBG;
|
|
} else
|
|
{
|
|
// Debug Information NOT stripped! (Either a PDB exists, or symbols are local, or both...)
|
|
if ( ( m_tszPEImageDebugDirectoryPDBPath) || (fDmpFile && fCodeViewSectionFound) )
|
|
{ // If we find PDB data, a PDB file is assumed...
|
|
// Starting with LINK.EXE 6.2 and higher, we'll find PDB data in USER.DMP files....
|
|
m_enumPEImageSymbolStatus = SYMBOLS_PDB;
|
|
} else
|
|
{ // Symbols NOT stripped (Symbols appear to be local to the PE Image)
|
|
m_enumPEImageSymbolStatus = SYMBOLS_LOCAL;
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if (hModuleHandle != INVALID_HANDLE_VALUE)
|
|
CloseHandle(hModuleHandle);
|
|
|
|
if (lpImageSectionHeader)
|
|
delete [] lpImageSectionHeader;
|
|
|
|
return fReturn;
|
|
|
|
}
|
|
|
|
bool CModuleInfo::GetModuleInfoFromCSVFile(LPTSTR tszModulePath)
|
|
{
|
|
TCHAR tszFileName[_MAX_FNAME];
|
|
TCHAR tszFileExtension[_MAX_EXT];
|
|
|
|
// Copy the Module Name to the ModuleInfo Object...
|
|
_tsplitpath(tszModulePath, NULL, NULL, tszFileName, tszFileExtension);
|
|
|
|
if (tszFileName && tszFileExtension)
|
|
{
|
|
// Compose the module name...
|
|
m_tszPEImageModuleName = new TCHAR[_tcsclen(tszFileName)+_tcsclen(tszFileExtension)+1];
|
|
|
|
if (!m_tszPEImageModuleName)
|
|
return false;
|
|
|
|
_tcscpy(m_tszPEImageModuleName, tszFileName);
|
|
_tcscat(m_tszPEImageModuleName, tszFileExtension);
|
|
}
|
|
|
|
// Get the symbol status
|
|
enum {BUFFER_SIZE = 32};
|
|
char szSymbolStatus[BUFFER_SIZE];
|
|
|
|
m_lpInputFile->ReadString(szSymbolStatus, BUFFER_SIZE);
|
|
|
|
// Get the enum value for this string...
|
|
m_enumPEImageSymbolStatus = SymbolInformation(szSymbolStatus);
|
|
|
|
// Reset the symbol status if it is DBG/PDB (that may have
|
|
// applied on the other machine where the data was captured,
|
|
// but on this machine we'll have to find the DBG file
|
|
// first, then see if a PDB file exists...
|
|
if (m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB)
|
|
m_enumPEImageSymbolStatus = SYMBOLS_DBG;
|
|
|
|
m_lpInputFile->ReadDWORD(&m_dwPEImageCheckSum);
|
|
|
|
m_lpInputFile->ReadDWORD((LPDWORD)&m_dwPEImageTimeDateStamp);
|
|
|
|
// Skip the time/date string...
|
|
m_lpInputFile->ReadString();
|
|
|
|
m_lpInputFile->ReadDWORD(&m_dwPEImageSizeOfImage);
|
|
|
|
char szBuffer[_MAX_PATH+1];
|
|
|
|
DWORD dwStringLength;
|
|
|
|
// Read in the DBG Module Path
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good path... allocate space for it...
|
|
|
|
m_tszPEImageDebugDirectoryDBGPath = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if (!m_tszPEImageDebugDirectoryDBGPath)
|
|
return false;
|
|
}
|
|
|
|
// Read in the PDB Module Path
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good path... allocate space for it...
|
|
m_tszPEImageDebugDirectoryPDBPath = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if (!m_tszPEImageDebugDirectoryPDBPath)
|
|
return false; // Failure allocating...
|
|
}
|
|
|
|
m_lpInputFile->ReadDWORD(&m_dwPEImageDebugDirectoryPDBSignature);
|
|
|
|
m_lpInputFile->ReadDWORD(&m_dwPEImageDebugDirectoryPDBAge);
|
|
|
|
// Read in the Product Version String
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good version... allocate space for it...
|
|
m_tszPEImageProductVersionString = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if (!m_tszPEImageProductVersionString )
|
|
return false; // Failure allocating...
|
|
}
|
|
|
|
// Read in the File Version String
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good version... allocate space for it...
|
|
m_tszPEImageFileVersionString = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if (!m_tszPEImageFileVersionString )
|
|
return false; // Failure allocating...
|
|
}
|
|
|
|
// Read in the File Version Company String
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good version... allocate space for it...
|
|
m_tszPEImageFileVersionCompanyName = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if ( !m_tszPEImageFileVersionCompanyName )
|
|
return false; // Failure allocating...
|
|
}
|
|
|
|
// Read in the File Version Description String
|
|
dwStringLength = m_lpInputFile->ReadString(szBuffer, _MAX_PATH+1);
|
|
|
|
if (dwStringLength)
|
|
{
|
|
// Okay, if we found a good version... allocate space for it...
|
|
m_tszPEImageFileVersionDescription = CUtilityFunctions::CopyAnsiStringToTSTR(szBuffer);
|
|
|
|
if ( !m_tszPEImageFileVersionDescription )
|
|
return false; // Failure allocating...
|
|
}
|
|
|
|
m_lpInputFile->ReadDWORD(&m_dwPEImageFileSize);
|
|
|
|
m_lpInputFile->ReadDWORD(&m_ftPEImageFileTimeDateStamp.dwHighDateTime);
|
|
|
|
m_lpInputFile->ReadDWORD(&m_ftPEImageFileTimeDateStamp.dwLowDateTime);
|
|
|
|
// Okay... read to the start of the next line...
|
|
m_lpInputFile->ReadFileLine();
|
|
|
|
return true;
|
|
}
|
|
|
|
// This function is for ANSI strings explicitly because we only need to map these from
|
|
// ANSI strings read from a file, to an enum...
|
|
CModuleInfo::SymbolInformationForPEImage CModuleInfo::SymbolInformation(LPSTR szSymbolInformationString)
|
|
{
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOLS_DBG"))
|
|
return SYMBOLS_DBG;
|
|
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOLS_PDB"))
|
|
return SYMBOLS_PDB;
|
|
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOLS_DBG_AND_PDB"))
|
|
return SYMBOLS_DBG_AND_PDB;
|
|
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOLS_NO"))
|
|
return SYMBOLS_NO;
|
|
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOLS_LOCAL"))
|
|
return SYMBOLS_LOCAL;
|
|
|
|
if (0 == _stricmp(szSymbolInformationString, "SYMBOL_INFORMATION_UNKNOWN"))
|
|
return SYMBOL_INFORMATION_UNKNOWN;
|
|
|
|
return SYMBOL_INFORMATION_UNKNOWN;
|
|
}
|
|
|
|
bool CModuleInfo::OutputFileTime(FILETIME ftFileTime, LPTSTR tszFileTime, int iFileTimeBufferSize)
|
|
{
|
|
|
|
// Thu Oct 08 15:37:22 1998
|
|
|
|
FILETIME ftLocalFileTime;
|
|
SYSTEMTIME lpSystemTime;
|
|
int cch = 0, cch2 = 0;
|
|
|
|
// Let's convert this to a local file time first...
|
|
if (!FileTimeToLocalFileTime(&ftFileTime, &ftLocalFileTime))
|
|
return false;
|
|
|
|
FileTimeToSystemTime( &ftLocalFileTime, &lpSystemTime );
|
|
|
|
cch = GetDateFormat( LOCALE_USER_DEFAULT,
|
|
0,
|
|
&lpSystemTime,
|
|
TEXT("ddd MMM dd"),
|
|
tszFileTime,
|
|
iFileTimeBufferSize );
|
|
|
|
if (!cch)
|
|
return false;
|
|
|
|
// Let's keep going...
|
|
tszFileTime[cch-1] = TEXT(' ');
|
|
|
|
//
|
|
// Get time and format to characters
|
|
//
|
|
cch2 = GetTimeFormat( LOCALE_USER_DEFAULT,
|
|
NULL,
|
|
&lpSystemTime,
|
|
TEXT("HH':'mm':'ss"),
|
|
tszFileTime + cch,
|
|
iFileTimeBufferSize - cch );
|
|
|
|
// Let's keep going... we have to tack on the year...
|
|
tszFileTime[cch + cch2 - 1] = TEXT(' ');
|
|
|
|
GetDateFormat( LOCALE_USER_DEFAULT,
|
|
0,
|
|
&lpSystemTime,
|
|
TEXT("yyyy"),
|
|
tszFileTime + cch + cch2,
|
|
iFileTimeBufferSize - cch - cch2);
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::SetModulePath(LPTSTR tszModulePath)
|
|
{
|
|
// Copy the Module Path to the ModuleInfo Object...
|
|
if (!tszModulePath) {
|
|
return false;
|
|
}
|
|
|
|
if (m_tszPEImageModuleFileSystemPath)
|
|
delete [] m_tszPEImageModuleFileSystemPath;
|
|
|
|
m_tszPEImageModuleFileSystemPath = new TCHAR[(_tcsclen(tszModulePath)+1)];
|
|
|
|
if (!m_tszPEImageModuleFileSystemPath)
|
|
return false;
|
|
|
|
_tcscpy(m_tszPEImageModuleFileSystemPath, tszModulePath);
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::HandlePDBOpenValidateReturn(PDB * lpPdb, LPTSTR tszPDBLocal, EC ec)
|
|
{
|
|
char szPDBLocal[_MAX_PATH+1];
|
|
|
|
// What we do now is based on the return from PDBOpenValidate()
|
|
switch (ec)
|
|
{
|
|
case EC_NOT_FOUND:
|
|
break; // Not here, go back for more...
|
|
|
|
case EC_OK:
|
|
// Yee haa... save the data for sure...
|
|
m_enumPDBModuleStatus = SYMBOL_MATCH;
|
|
|
|
// On a perfect match, these must be equal...
|
|
m_dwPDBSignature = m_dwPEImageDebugDirectoryPDBSignature;
|
|
m_dwPDBAge = m_dwPEImageDebugDirectoryPDBAge;
|
|
|
|
// We're saving this... delete an existing one if found...
|
|
if (m_tszPDBModuleFileSystemPath)
|
|
{
|
|
delete [] m_tszPDBModuleFileSystemPath;
|
|
m_tszPDBModuleFileSystemPath = NULL;
|
|
}
|
|
|
|
m_tszPDBModuleFileSystemPath = CUtilityFunctions::CopyString(tszPDBLocal);
|
|
|
|
_tcscpy(m_tszPDBModuleFileSystemPath, tszPDBLocal);
|
|
|
|
if (!m_tszPDBModuleFileSystemPath)
|
|
return false;
|
|
|
|
// Now that we're done verifying the module... do we save the symbol in
|
|
// our tree?
|
|
if ( g_lpProgramOptions->GetMode(CProgramOptions::BuildSymbolTreeMode) )
|
|
{
|
|
// Yup...
|
|
CUtilityFunctions::CopySymbolFileToSymbolTree(m_tszPEImageModuleName, &m_tszPDBModuleFileSystemPath, g_lpProgramOptions->GetSymbolTreeToBuild());
|
|
}
|
|
|
|
//
|
|
// Is there any Private Information (Source Enabled?)
|
|
//
|
|
if (!ProcessPDBSourceInfo(lpPdb))
|
|
return false;
|
|
|
|
break;
|
|
|
|
case EC_FORMAT:
|
|
// This deserves an error of its own...
|
|
m_enumPDBModuleStatus = SYMBOL_INVALID_FORMAT;
|
|
|
|
// We'll only save this if we don't already have one...
|
|
if (m_tszPDBModuleFileSystemPath == NULL)
|
|
{
|
|
m_tszPDBModuleFileSystemPath = CUtilityFunctions::CopyString(tszPDBLocal);
|
|
|
|
if (!m_tszPDBModuleFileSystemPath)
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case EC_INVALID_SIG:
|
|
case EC_INVALID_AGE:
|
|
// We'll save the location only for interests sake (and only if we
|
|
// don't have a PDB path already...
|
|
|
|
// Maybe we need to be more granular?
|
|
m_enumPDBModuleStatus = SYMBOL_POSSIBLE_MISMATCH;
|
|
|
|
// We'll only save this if we don't already have one...
|
|
if (m_tszPDBModuleFileSystemPath == NULL)
|
|
{
|
|
m_tszPDBModuleFileSystemPath = CUtilityFunctions::CopyString(tszPDBLocal);
|
|
|
|
if (!m_tszPDBModuleFileSystemPath)
|
|
return false;
|
|
}
|
|
|
|
// Okay, we know that we had a bad match, but we don't know why... let's
|
|
// go ahead and figure it out...
|
|
EC ec;
|
|
char szError[cbErrMax];
|
|
PDB *pPdb;
|
|
|
|
CUtilityFunctions::CopyTSTRStringToAnsi(tszPDBLocal, szPDBLocal, _MAX_PATH+1);
|
|
|
|
if ( PDBOpen(szPDBLocal,
|
|
pdbRead,
|
|
m_dwPEImageDebugDirectoryPDBSignature,
|
|
&ec,
|
|
szError,
|
|
&pPdb) )
|
|
{
|
|
// We opened it...
|
|
|
|
// Get the goods...
|
|
m_dwPDBFormatSpecifier = sigNB10; // TEMPORARY ASSUMPTION!!!
|
|
m_dwPDBSignature = PDBQuerySignature(pPdb);
|
|
m_dwPDBAge = PDBQueryAge(pPdb);
|
|
|
|
PDBClose(pPdb);
|
|
}
|
|
break;
|
|
|
|
case EC_USAGE:
|
|
|
|
m_enumPDBModuleStatus = SYMBOL_NO_HELPER_DLL;
|
|
|
|
// We'll only save this if we don't already have one...
|
|
if (m_tszPDBModuleFileSystemPath == NULL)
|
|
{
|
|
m_tszPDBModuleFileSystemPath = CUtilityFunctions::CopyString(tszPDBLocal);
|
|
|
|
if (!m_tszPDBModuleFileSystemPath)
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
ULONG CModuleInfo::SetReadPointer(bool fDmpFile, HANDLE hModuleHandle, LONG cbOffset, int iFrom)
|
|
{
|
|
if (fDmpFile)
|
|
{
|
|
switch( iFrom )
|
|
{
|
|
case FILE_BEGIN:
|
|
m_dwCurrentReadPosition = cbOffset;
|
|
break;
|
|
|
|
case FILE_CURRENT:
|
|
m_dwCurrentReadPosition += cbOffset;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
m_dwCurrentReadPosition = SetFilePointer(hModuleHandle, cbOffset, NULL, iFrom);
|
|
}
|
|
|
|
return m_dwCurrentReadPosition;
|
|
}
|
|
|
|
bool CModuleInfo::DoRead(bool fDmpFile, HANDLE hModuleHandle, LPVOID lpBuffer, DWORD cbNumberOfBytesToRead)
|
|
{
|
|
DWORD cbActuallyRead;
|
|
bool fReturn = false;
|
|
|
|
if (fDmpFile)
|
|
{
|
|
if (m_lpDmpFile)
|
|
{
|
|
HRESULT Hr;
|
|
|
|
if (FAILED(Hr = m_lpDmpFile->m_pIDebugDataSpaces->ReadVirtual(m_dw64BaseAddress+(DWORD64)m_dwCurrentReadPosition,
|
|
lpBuffer,
|
|
cbNumberOfBytesToRead,
|
|
&cbActuallyRead)))
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
if (cbActuallyRead != cbNumberOfBytesToRead)
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
} else
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
m_dwCurrentReadPosition += cbActuallyRead;
|
|
|
|
} else if ( (ReadFile(hModuleHandle, lpBuffer, cbNumberOfBytesToRead, &cbActuallyRead, NULL) == 0) ||
|
|
(cbNumberOfBytesToRead != cbActuallyRead) )
|
|
{
|
|
goto exit;
|
|
}
|
|
|
|
fReturn = true;
|
|
|
|
exit:
|
|
return fReturn;
|
|
}
|
|
|
|
bool CModuleInfo::SetDebugDirectoryDBGPath(LPTSTR tszNewDebugDirectoryDBGPath)
|
|
{
|
|
if (m_tszPEImageDebugDirectoryDBGPath)
|
|
delete [] m_tszPEImageDebugDirectoryDBGPath;
|
|
|
|
m_tszPEImageDebugDirectoryDBGPath = CUtilityFunctions::CopyString(tszNewDebugDirectoryDBGPath);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::SetPEDebugDirectoryPDBPath(LPTSTR tszNewDebugDirectoryPDBPath)
|
|
{
|
|
if (m_tszPEImageDebugDirectoryPDBPath)
|
|
delete [] m_tszPEImageDebugDirectoryPDBPath;
|
|
|
|
m_tszPEImageDebugDirectoryPDBPath = CUtilityFunctions::CopyString(tszNewDebugDirectoryPDBPath);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::SetPEImageModulePath(LPTSTR tszNewPEImageModulePath)
|
|
{
|
|
if (m_tszPEImageModuleFileSystemPath)
|
|
delete [] m_tszPEImageModuleFileSystemPath;
|
|
|
|
m_tszPEImageModuleFileSystemPath = CUtilityFunctions::CopyString(tszNewPEImageModulePath);
|
|
|
|
_tcsupr(m_tszPEImageModuleFileSystemPath);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::SetPEImageModuleName(LPTSTR tszNewModuleName)
|
|
{
|
|
if (m_tszPEImageModuleName)
|
|
delete [] m_tszPEImageModuleName;
|
|
|
|
m_tszPEImageModuleName = CUtilityFunctions::CopyString(tszNewModuleName);
|
|
|
|
_tcsupr(m_tszPEImageModuleName);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// Evaluate whether we've found the symbolic information for this module
|
|
// that the user is looking for.
|
|
bool CModuleInfo::GoodSymbolNotFound()
|
|
{
|
|
bool fBadSymbol = true;
|
|
|
|
// Well, we evaluate success based on the type of symbol we're looking for
|
|
// and whether it was successfully found.
|
|
switch (GetPESymbolInformation())
|
|
{
|
|
// This is bad... consider this fatal...
|
|
case SYMBOL_INFORMATION_UNKNOWN:
|
|
break;
|
|
|
|
// Is this bad? I think so... but if you inherit a module as an import should you
|
|
// be punished for the ills of another? Hmm.... For now we'll say it's okay...
|
|
case SYMBOLS_NO:
|
|
fBadSymbol = false;
|
|
break;
|
|
|
|
// While this is wasteful, we have symbolic info... so that's cool
|
|
case SYMBOLS_LOCAL:
|
|
fBadSymbol = false;
|
|
break;
|
|
|
|
case SYMBOLS_DBG:
|
|
fBadSymbol = SYMBOL_MATCH == GetDBGSymbolModuleStatus();
|
|
break;
|
|
|
|
case SYMBOLS_DBG_AND_PDB:
|
|
fBadSymbol = (SYMBOL_MATCH == GetDBGSymbolModuleStatus()) &&
|
|
(SYMBOL_MATCH == GetPDBSymbolModuleStatus());
|
|
break;
|
|
|
|
case SYMBOLS_PDB:
|
|
fBadSymbol = SYMBOL_MATCH == GetPDBSymbolModuleStatus();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return fBadSymbol;
|
|
}
|
|
|
|
//
|
|
// Process the DebugDirectory data for a PE image (or a DBG file)
|
|
//
|
|
bool CModuleInfo::ProcessDebugDirectory(const bool fPEImage, const bool fDmpFile, const HANDLE hModuleHandle, unsigned int iDebugDirectorySize, ULONG OffsetImageDebugDirectory)
|
|
{
|
|
unsigned int iNumberOfDebugDirectoryEntries = iDebugDirectorySize / sizeof(IMAGE_DEBUG_DIRECTORY);
|
|
|
|
//
|
|
// Let's loop through the debug directories and collect the relavent info...
|
|
//
|
|
while (iNumberOfDebugDirectoryEntries--)
|
|
{
|
|
IMAGE_DEBUG_DIRECTORY ImageDebugDirectory;
|
|
|
|
// Set the pointer to the DebugDirectories entry
|
|
SetReadPointer(fDmpFile, hModuleHandle, OffsetImageDebugDirectory, FILE_BEGIN);
|
|
|
|
// Read the DebugDirectoryImage
|
|
if (!DoRead(fDmpFile, hModuleHandle, &ImageDebugDirectory, sizeof(IMAGE_DEBUG_DIRECTORY)))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Processing of the Debug Directory is dependent on the type
|
|
//
|
|
switch (ImageDebugDirectory.Type)
|
|
{
|
|
//
|
|
// This is our preferred debug format as it offers full source level debugging (typically)
|
|
//
|
|
case IMAGE_DEBUG_TYPE_CODEVIEW:
|
|
ProcessDebugTypeCVDirectoryEntry(fPEImage, fDmpFile, hModuleHandle, &ImageDebugDirectory);
|
|
break;
|
|
|
|
//
|
|
// COFF symbols are okay... CV is better :)
|
|
//
|
|
case IMAGE_DEBUG_TYPE_COFF:
|
|
ProcessDebugTypeCoffDirectoryEntry(fPEImage, &ImageDebugDirectory);
|
|
break;
|
|
|
|
//
|
|
// MISC implies that a DBG file is created...
|
|
//
|
|
case IMAGE_DEBUG_TYPE_MISC:
|
|
ProcessDebugTypeMiscDirectoryEntry(fPEImage, fDmpFile, hModuleHandle, &ImageDebugDirectory);
|
|
break;
|
|
|
|
//
|
|
// FPO info is important for working with functions with FPO
|
|
//
|
|
case IMAGE_DEBUG_TYPE_FPO:
|
|
ProcessDebugTypeFPODirectoryEntry(fPEImage, &ImageDebugDirectory);
|
|
break;
|
|
|
|
case IMAGE_DEBUG_TYPE_OMAP_TO_SRC:
|
|
case IMAGE_DEBUG_TYPE_OMAP_FROM_SRC:
|
|
ProcessDebugTypeOMAPDirectoryEntry(fPEImage, &ImageDebugDirectory);
|
|
break;
|
|
|
|
case IMAGE_DEBUG_TYPE_UNKNOWN:
|
|
case IMAGE_DEBUG_TYPE_EXCEPTION:
|
|
case IMAGE_DEBUG_TYPE_FIXUP:
|
|
case IMAGE_DEBUG_TYPE_BORLAND:
|
|
case IMAGE_DEBUG_TYPE_RESERVED10:
|
|
case IMAGE_DEBUG_TYPE_CLSID:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
OffsetImageDebugDirectory += sizeof(IMAGE_DEBUG_DIRECTORY);
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CModuleInfo::ProcessDebugTypeMiscDirectoryEntry(const bool fPEImage, const bool fDmpFile, const HANDLE hModuleHandle, const PIMAGE_DEBUG_DIRECTORY lpImageDebugDirectory)
|
|
{
|
|
bool fReturnValue = false;
|
|
PIMAGE_DEBUG_MISC lpImageDebugMisc = NULL, lpCurrentImageDebugMiscPointer = NULL;
|
|
ULONG OffsetImageDebugDirectory = NULL;
|
|
unsigned long ulSizeOfMiscDirectoryEntry = lpImageDebugDirectory->SizeOfData;
|
|
|
|
//
|
|
// DBG files tend to store the EXE name here... not too useful for now...
|
|
//
|
|
if (!fPEImage)
|
|
{
|
|
fReturnValue = true;
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Allocate storage for the MISC data...
|
|
//
|
|
lpImageDebugMisc = (PIMAGE_DEBUG_MISC) new BYTE[ulSizeOfMiscDirectoryEntry];
|
|
|
|
if (lpImageDebugMisc == NULL)
|
|
goto cleanup;
|
|
|
|
// Calculate the location/size so we can load it.
|
|
if (fDmpFile)
|
|
{
|
|
OffsetImageDebugDirectory = lpImageDebugDirectory->AddressOfRawData;
|
|
} else
|
|
{
|
|
OffsetImageDebugDirectory = lpImageDebugDirectory->PointerToRawData;
|
|
}
|
|
|
|
// Advance to the location of the Debug Info
|
|
SetReadPointer(fDmpFile, hModuleHandle, OffsetImageDebugDirectory, FILE_BEGIN);
|
|
|
|
// Read the data...
|
|
if (!DoRead(fDmpFile, hModuleHandle, lpImageDebugMisc, ulSizeOfMiscDirectoryEntry))
|
|
goto cleanup;
|
|
|
|
// Set our pointer to the start of our data...
|
|
lpCurrentImageDebugMiscPointer = lpImageDebugMisc;
|
|
|
|
//
|
|
// The logic of this routine will skip past bad sections of the MISC datastream...
|
|
//
|
|
while(ulSizeOfMiscDirectoryEntry > 0)
|
|
{
|
|
//
|
|
// Hopefully we have a string here...
|
|
//
|
|
if (lpCurrentImageDebugMiscPointer->DataType == IMAGE_DEBUG_MISC_EXENAME)
|
|
{
|
|
LPSTR lpszExeName;
|
|
|
|
lpszExeName = (LPSTR)&lpCurrentImageDebugMiscPointer->Data[ 0 ];
|
|
|
|
// Save off the DBG Path...
|
|
if (m_tszPEImageDebugDirectoryDBGPath)
|
|
delete [] m_tszPEImageDebugDirectoryDBGPath;
|
|
|
|
if (lpCurrentImageDebugMiscPointer->Unicode)
|
|
{
|
|
// Is this a Unicode string?
|
|
m_tszPEImageDebugDirectoryDBGPath = CUtilityFunctions::CopyUnicodeStringToTSTR((LPWSTR)lpszExeName);
|
|
} else
|
|
{
|
|
// Is this an ANSI string?
|
|
m_tszPEImageDebugDirectoryDBGPath = CUtilityFunctions::CopyAnsiStringToTSTR(lpszExeName);
|
|
}
|
|
|
|
if (!m_tszPEImageDebugDirectoryDBGPath)
|
|
goto cleanup;
|
|
|
|
break;
|
|
|
|
|
|
} else
|
|
{
|
|
// Beware of corrupt images
|
|
if (lpCurrentImageDebugMiscPointer->Length == 0)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Decrement the ulSizeOfMiscDirectoryEntry by the length of this "stuff"
|
|
ulSizeOfMiscDirectoryEntry -= lpCurrentImageDebugMiscPointer->Length;
|
|
|
|
// If our new value exceeds the SizeOfData we need to bail...
|
|
if (ulSizeOfMiscDirectoryEntry > lpImageDebugDirectory->SizeOfData)
|
|
{
|
|
ulSizeOfMiscDirectoryEntry = 0; // Avoid AV on bad exe
|
|
break;
|
|
}
|
|
|
|
lpCurrentImageDebugMiscPointer = (PIMAGE_DEBUG_MISC) (lpCurrentImageDebugMiscPointer + lpCurrentImageDebugMiscPointer->Length);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fReturnValue = true;
|
|
|
|
cleanup:
|
|
|
|
if (lpImageDebugMisc)
|
|
{
|
|
delete [] lpImageDebugMisc;
|
|
lpImageDebugMisc = NULL;
|
|
}
|
|
|
|
return fReturnValue;
|
|
}
|
|
|
|
bool CModuleInfo::ProcessDebugTypeCoffDirectoryEntry(const bool fPEImage, const PIMAGE_DEBUG_DIRECTORY lpImageDebugDirectory)
|
|
{
|
|
//
|
|
// The only thing we really care about is the size right now...
|
|
//
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryCoffSize = lpImageDebugDirectory->SizeOfData;
|
|
} else
|
|
{
|
|
m_dwDBGImageDebugDirectoryCoffSize = lpImageDebugDirectory->SizeOfData;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::ProcessDebugTypeFPODirectoryEntry(const bool fPEImage, const PIMAGE_DEBUG_DIRECTORY lpImageDebugDirectory)
|
|
{
|
|
//
|
|
// The only thing we really care about is the size right now...
|
|
//
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryFPOSize = lpImageDebugDirectory->SizeOfData;
|
|
} else
|
|
{
|
|
m_dwDBGImageDebugDirectoryFPOSize = lpImageDebugDirectory->SizeOfData;
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool CModuleInfo::ProcessDebugTypeCVDirectoryEntry(const bool fPEImage, const bool fDmpFile, const HANDLE hModuleHandle, const PIMAGE_DEBUG_DIRECTORY lpImageDebugDirectory)
|
|
{
|
|
bool fReturnValue = false;
|
|
ULONG OffsetImageDebugDirectory;
|
|
DWORD dwCVFormatSpecifier;
|
|
char szPdb[_MAX_PATH * 3]; // Must this be so large?
|
|
|
|
// Calculate the location/size so we can load it.
|
|
if (fDmpFile)
|
|
{
|
|
OffsetImageDebugDirectory = lpImageDebugDirectory->AddressOfRawData;
|
|
} else
|
|
{
|
|
OffsetImageDebugDirectory = lpImageDebugDirectory->PointerToRawData;
|
|
}
|
|
|
|
// Advance to the location of the Debug Info
|
|
SetReadPointer(fDmpFile, hModuleHandle, OffsetImageDebugDirectory, FILE_BEGIN);
|
|
|
|
// Read the data...
|
|
if (!DoRead(fDmpFile, hModuleHandle, &dwCVFormatSpecifier, sizeof(DWORD)))
|
|
goto cleanup;
|
|
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryPDBFormatSpecifier = dwCVFormatSpecifier;
|
|
} else
|
|
{
|
|
m_dwDBGDebugDirectoryPDBFormatSpecifier = dwCVFormatSpecifier;
|
|
}
|
|
|
|
switch (dwCVFormatSpecifier)
|
|
{
|
|
case sigNB09:
|
|
case sigNB11:
|
|
//
|
|
// The only thing we really care about is the size right now...
|
|
//
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryCVSize = lpImageDebugDirectory->SizeOfData;
|
|
} else
|
|
{
|
|
m_dwDBGImageDebugDirectoryCVSize = lpImageDebugDirectory->SizeOfData;
|
|
}
|
|
break;
|
|
|
|
case sigNB10:
|
|
|
|
NB10I nb10i;
|
|
|
|
// Read the data...
|
|
if (!DoRead(fDmpFile, hModuleHandle, &nb10i.off, sizeof(NB10I) - sizeof(DWORD)))
|
|
goto cleanup;
|
|
|
|
if (fPEImage)
|
|
{
|
|
// Save away the PDB Signature...
|
|
m_dwPEImageDebugDirectoryPDBSignature = nb10i.sig;
|
|
|
|
// Save away the PDB Age...
|
|
m_dwPEImageDebugDirectoryPDBAge = nb10i.age;
|
|
} else
|
|
{
|
|
// Save away the PDB Signature...
|
|
m_dwDBGDebugDirectoryPDBSignature = nb10i.sig;
|
|
|
|
// Save away the PDB Age...
|
|
m_dwDBGDebugDirectoryPDBAge = nb10i.age;
|
|
}
|
|
|
|
// Read the data...
|
|
if (!DoRead(fDmpFile, hModuleHandle, szPdb, (lpImageDebugDirectory->SizeOfData) - sizeof(NB10I)))
|
|
goto cleanup;
|
|
|
|
if (szPdb[0] != '\0')
|
|
{
|
|
// Save the data (as appropriate)
|
|
if (fPEImage)
|
|
{
|
|
// Copy the PDB path away...
|
|
m_tszPEImageDebugDirectoryPDBPath = CUtilityFunctions::CopyAnsiStringToTSTR(szPdb);
|
|
|
|
if (!m_tszPEImageDebugDirectoryPDBPath)
|
|
goto cleanup;
|
|
} else
|
|
{
|
|
// Copy the PDB path away...
|
|
m_tszDBGDebugDirectoryPDBPath = CUtilityFunctions::CopyAnsiStringToTSTR(szPdb);
|
|
|
|
if (!m_tszDBGDebugDirectoryPDBPath)
|
|
goto cleanup;
|
|
|
|
// We now know that we have a DBG/PDB combination...
|
|
m_enumPEImageSymbolStatus = SYMBOLS_DBG_AND_PDB;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case sigRSDS:
|
|
|
|
RSDSI rsdsi;
|
|
|
|
// Read the RSDSI structure (except for the rsds DWORD at the beginning).
|
|
if (!DoRead(fDmpFile, hModuleHandle, &rsdsi.guidSig, sizeof(RSDSI) - sizeof(DWORD)))
|
|
goto cleanup;
|
|
|
|
wchar_t wszGuid[39];
|
|
|
|
StringFromGUID2(rsdsi.guidSig, wszGuid, sizeof(wszGuid)/sizeof(wchar_t));
|
|
|
|
if (fPEImage)
|
|
{
|
|
// Save away the PDB Age...
|
|
m_dwPEImageDebugDirectoryPDBAge = rsdsi.age;
|
|
|
|
// Copy the GUID...
|
|
m_tszPEImageDebugDirectoryPDBGuid = CUtilityFunctions::CopyUnicodeStringToTSTR(wszGuid);
|
|
} else
|
|
{
|
|
// Save away the PDB Age...
|
|
m_dwDBGDebugDirectoryPDBAge = rsdsi.age;
|
|
|
|
// Copy the GUID...
|
|
m_tszDBGDebugDirectoryPDBGuid = CUtilityFunctions::CopyUnicodeStringToTSTR(wszGuid);
|
|
}
|
|
|
|
// Now, read in the PDB path... apparently it's in UTF8 format...
|
|
if (!DoRead(fDmpFile, hModuleHandle, szPdb, (lpImageDebugDirectory->SizeOfData) - sizeof(RSDSI)))
|
|
goto cleanup;
|
|
|
|
if (szPdb[0] != '\0')
|
|
{
|
|
// Save the data (as appropriate)
|
|
if (fPEImage)
|
|
{
|
|
wchar_t wszPdb[_MAX_PATH];
|
|
CUtilityFunctions::UTF8ToUnicode(szPdb, wszPdb, sizeof(wszPdb));
|
|
|
|
// Copy the PDB path away...
|
|
m_tszPEImageDebugDirectoryPDBPath = CUtilityFunctions::CopyUnicodeStringToTSTR(wszPdb);
|
|
|
|
if (!m_tszPEImageDebugDirectoryPDBPath)
|
|
goto cleanup;
|
|
} else
|
|
{
|
|
wchar_t wszPdb[_MAX_PATH];
|
|
CUtilityFunctions::UTF8ToUnicode(szPdb, wszPdb, sizeof(wszPdb));
|
|
|
|
// Copy the PDB path away...
|
|
m_tszDBGDebugDirectoryPDBPath = CUtilityFunctions::CopyUnicodeStringToTSTR(wszPdb);
|
|
|
|
if (!m_tszDBGDebugDirectoryPDBPath)
|
|
goto cleanup;
|
|
}
|
|
}
|
|
break;
|
|
|
|
// Unknown CV format...
|
|
default:
|
|
break;
|
|
}
|
|
|
|
fReturnValue = true;
|
|
|
|
cleanup:
|
|
|
|
return fReturnValue;
|
|
}
|
|
|
|
bool CModuleInfo::ProcessDebugTypeOMAPDirectoryEntry(const bool fPEImage, const PIMAGE_DEBUG_DIRECTORY lpImageDebugDirectory)
|
|
{
|
|
DWORD dwSize = lpImageDebugDirectory->SizeOfData;
|
|
|
|
//
|
|
// The only thing we really care about is the size right now...
|
|
//
|
|
switch (lpImageDebugDirectory->Type)
|
|
{
|
|
case IMAGE_DEBUG_TYPE_OMAP_TO_SRC:
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryOMAPtoSRCSize = dwSize;
|
|
} else
|
|
{
|
|
m_dwDBGImageDebugDirectoryOMAPtoSRCSize = dwSize;
|
|
}
|
|
|
|
break;
|
|
|
|
case IMAGE_DEBUG_TYPE_OMAP_FROM_SRC:
|
|
if (fPEImage)
|
|
{
|
|
m_dwPEImageDebugDirectoryOMAPfromSRCSize = dwSize;
|
|
} else
|
|
{
|
|
m_dwDBGImageDebugDirectoryOMAPfromSRCSize = dwSize;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToStdoutInternalSymbolInfo(DWORD dwCoffSize, DWORD dwFPOSize, DWORD dwCVSize, DWORD dwOMAPtoSRC, DWORD dwOMAPfromSRC)
|
|
{
|
|
// _tprintf(TEXT(" Module has internal symbols.\n"));
|
|
|
|
if (dwCoffSize)
|
|
{
|
|
_tprintf(TEXT(" Internal COFF Symbols - Size 0x%08x bytes\n"), dwCoffSize);
|
|
}
|
|
|
|
if (dwFPOSize)
|
|
{
|
|
_tprintf(TEXT(" Internal FPO Symbols - Size 0x%08x bytes\n"), dwFPOSize);
|
|
}
|
|
|
|
if (dwCVSize)
|
|
{
|
|
_tprintf(TEXT(" Internal CV Symbols - Size 0x%08x bytes\n"), dwCVSize);
|
|
}
|
|
|
|
if (dwOMAPtoSRC)
|
|
{
|
|
_tprintf(TEXT(" Internal -> SRC Symbols - Size 0x%08x bytes\n"), dwOMAPtoSRC);
|
|
}
|
|
|
|
if (dwOMAPfromSRC)
|
|
{
|
|
_tprintf(TEXT(" Internal SRC -> Symbols - Size 0x%08x bytes\n"), dwOMAPfromSRC);
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// Dump DBG information
|
|
//
|
|
bool CModuleInfo::OutputDataToStdoutDbgSymbolInfo(LPCTSTR tszModulePointerToDbg, DWORD dwTimeDateStamp, DWORD dwChecksum, DWORD dwSizeOfImage, LPCTSTR tszDbgComment, DWORD dwExpectedTimeDateStamp, DWORD dwExpectedChecksum, DWORD dwExpectedSizeOfImage)
|
|
{
|
|
if (!tszDbgComment)
|
|
{
|
|
// Dump out the pointer to the DBG file from the PE Image
|
|
if (tszModulePointerToDbg)
|
|
{
|
|
_tprintf(TEXT(" Module Pointer to DBG = [%s]\n"), tszModulePointerToDbg);
|
|
} else
|
|
{
|
|
_tprintf(TEXT(" Module had DBG File stripped from it.\n"));
|
|
}
|
|
|
|
time_t time = dwTimeDateStamp;
|
|
_tprintf(TEXT(" Module TimeDateStamp = 0x%08x - %s"), dwTimeDateStamp, _tctime(&time));
|
|
_tprintf(TEXT(" Module Checksum = 0x%08x\n"), dwChecksum);
|
|
_tprintf(TEXT(" Module SizeOfImage = 0x%08x\n"), dwSizeOfImage);
|
|
|
|
} else
|
|
{
|
|
TCHAR tszBuffer[2*_MAX_PATH]; // This should be large enough ;)
|
|
size_t tszStringLength;
|
|
|
|
// Is this discrepancy stuff...
|
|
if (tszModulePointerToDbg)
|
|
{
|
|
_tprintf(TEXT(" DBG File = [%s] [%s]\n"), tszModulePointerToDbg, tszDbgComment);
|
|
}
|
|
|
|
time_t time = dwTimeDateStamp;
|
|
_stprintf(tszBuffer, TEXT(" DBG TimeDateStamp = 0x%08x - %s"), dwTimeDateStamp, _tctime(&time));
|
|
|
|
// If our TimeDateStamps don't match... we have some fixup to do...
|
|
if (dwTimeDateStamp != dwExpectedTimeDateStamp)
|
|
{
|
|
tszStringLength = _tcslen(tszBuffer);
|
|
if (tszBuffer[tszStringLength-1] == '\n')
|
|
tszBuffer[tszStringLength-1] = '\0';
|
|
}
|
|
|
|
_tprintf(tszBuffer);
|
|
|
|
// If our TimeDateStamps don't match... we have some fixup to do...
|
|
if (dwTimeDateStamp != dwExpectedTimeDateStamp)
|
|
{
|
|
_tprintf(TEXT(" [%s]!\n"), (dwTimeDateStamp > dwExpectedTimeDateStamp) ? TEXT("NEWER") : TEXT("OLDER"));
|
|
}
|
|
|
|
_tprintf(TEXT(" DBG Checksum = 0x%08x [%s]\n"), dwChecksum, ( (dwChecksum == dwExpectedChecksum) ? TEXT("MATCHED"):TEXT("UNMATCHED")) );
|
|
_tprintf(TEXT(" DBG SizeOfImage = 0x%08x [%s]\n"), dwSizeOfImage, ( ( dwSizeOfImage == dwExpectedSizeOfImage) ? TEXT("MATCHED"):TEXT("UNMATCHED")) );
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToStdoutPdbSymbolInfo(DWORD dwPDBFormatSpecifier, LPTSTR tszModulePointerToPDB, DWORD dwPDBSignature, LPTSTR tszPDBGuid, DWORD dwPDBAge, LPCTSTR tszPdbComment)
|
|
{
|
|
|
|
if (tszModulePointerToPDB)
|
|
{
|
|
if (!tszPdbComment)
|
|
{
|
|
_tprintf(TEXT(" Module Pointer to PDB = [%s]\n"), tszModulePointerToPDB);
|
|
} else
|
|
{
|
|
_tprintf(TEXT(" PDB File = [%s] [%s]\n"), tszModulePointerToPDB, tszPdbComment);
|
|
}
|
|
switch (dwPDBFormatSpecifier)
|
|
{
|
|
case sigNB10:
|
|
_tprintf(TEXT(" Module PDB Signature = 0x%x\n"), dwPDBSignature);
|
|
break;
|
|
|
|
case sigRSDS:
|
|
_tprintf(TEXT(" Module PDB Guid = %s\n"), tszPDBGuid);
|
|
break;
|
|
|
|
default:
|
|
_tprintf(TEXT(" UNKNOWN PDB Format!\n"));
|
|
break;
|
|
}
|
|
|
|
_tprintf(TEXT(" Module PDB Age = 0x%x\n"), dwPDBAge);
|
|
} else
|
|
{
|
|
_tprintf(TEXT(" Module has PDB File\n"));
|
|
_tprintf(TEXT(" Module Pointer to PDB = [UNKNOWN] (Could not find in PE Image)\n"));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToStdoutModuleInfo(DWORD dwModuleNumber)
|
|
{
|
|
_tprintf(TEXT("Module[%3d] [%s] %s\n"), dwModuleNumber, m_tszPEImageModuleFileSystemPath, (m_dwPEImageDebugDirectoryCVSize ? TEXT("(Source Enabled)") : TEXT("")));
|
|
|
|
// LPTSTR lpMachineArchitecture;
|
|
//
|
|
// switch(m_wPEImageMachineArchitecture)
|
|
// {
|
|
// case IMAGE_FILE_MACHINE_I386:
|
|
// lpMachineArchitecture = TEXT("Binary Image for Intel Machines");
|
|
// break;
|
|
//
|
|
// case IMAGE_FILE_MACHINE_ALPHA64:
|
|
// lpMachineArchitecture = TEXT("Binary Image for Alpha Machines");
|
|
// break;
|
|
//
|
|
// default:
|
|
// lpMachineArchitecture = TEXT("Binary Image for Unknown Machine Architecture");
|
|
// }
|
|
//
|
|
// if (m_wPEImageMachineArchitecture) _tprintf(TEXT(" %s\n"), lpMachineArchitecture);
|
|
|
|
//
|
|
// First, let's output version information if requested
|
|
//
|
|
if (g_lpProgramOptions->GetMode(CProgramOptions::CollectVersionInfoMode) )
|
|
{
|
|
// Version Information
|
|
if (m_tszPEImageFileVersionCompanyName) _tprintf(TEXT(" Company Name: %s\n"), m_tszPEImageFileVersionCompanyName);
|
|
if (m_tszPEImageFileVersionDescription) _tprintf(TEXT(" File Description: %s\n"), m_tszPEImageFileVersionDescription);
|
|
if (m_tszPEImageProductVersionString) _tprintf(TEXT(" Product Version: %s\n"), m_tszPEImageProductVersionString);
|
|
if (m_tszPEImageFileVersionString) _tprintf(TEXT(" File Version: %s\n"), m_tszPEImageFileVersionString);
|
|
if (m_dwPEImageFileSize) _tprintf(TEXT(" File Size (bytes): %d\n"), m_dwPEImageFileSize);
|
|
|
|
if ( m_ftPEImageFileTimeDateStamp.dwHighDateTime || m_ftPEImageFileTimeDateStamp.dwLowDateTime)
|
|
{
|
|
enum { FILETIME_BUFFERSIZE = 128 };
|
|
TCHAR tszFileTime[FILETIME_BUFFERSIZE];
|
|
|
|
if (OutputFileTime(m_ftPEImageFileTimeDateStamp, tszFileTime, FILETIME_BUFFERSIZE))
|
|
_tprintf(TEXT(" File Date: %s\n"), tszFileTime);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CModuleInfo::OutputDataToStdoutThisModule()
|
|
{
|
|
//
|
|
// If we're not doing "Discrepancies Only" then we output this module unconditionally...
|
|
//
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::OutputDiscrepanciesOnly))
|
|
return true;
|
|
|
|
//
|
|
// If we're not in verification mode, then we output everything...
|
|
//
|
|
if (!g_lpProgramOptions->GetMode(CProgramOptions::VerifySymbolsMode))
|
|
return true;
|
|
|
|
//
|
|
// This is "Discrepancy Only" mode, so check for discrepancies...
|
|
//
|
|
bool fAnyDiscrepancies = false;
|
|
|
|
// Hey, if they only want to dump out modules with discrepancies... check to see
|
|
// if this qualifies...
|
|
switch (m_enumPEImageSymbolStatus)
|
|
{
|
|
// Consider these normal status codes...
|
|
case SYMBOLS_DBG:
|
|
case SYMBOLS_DBG_AND_PDB:
|
|
case SYMBOLS_PDB:
|
|
case SYMBOLS_LOCAL:
|
|
break;
|
|
|
|
// Anything else is worth reporting...
|
|
default:
|
|
fAnyDiscrepancies = true;
|
|
}
|
|
|
|
// If we don't have a discrepancy yet... let's look further...
|
|
if (!fAnyDiscrepancies)
|
|
{
|
|
// Is there a DBG file?
|
|
if ( (m_enumPEImageSymbolStatus == SYMBOLS_DBG) ||
|
|
(m_enumPEImageSymbolStatus == SYMBOLS_DBG_AND_PDB) )
|
|
{
|
|
// Does it match?
|
|
if ( m_enumDBGModuleStatus != SYMBOL_MATCH )
|
|
fAnyDiscrepancies = true;
|
|
}
|
|
|
|
// Is there a PDB file?
|
|
if ( GetDebugDirectoryPDBPath() )
|
|
{
|
|
if (m_enumPDBModuleStatus != SYMBOL_MATCH )
|
|
fAnyDiscrepancies = true;
|
|
}
|
|
}
|
|
|
|
return fAnyDiscrepancies;
|
|
}
|
|
|
|
bool CModuleInfo::ProcessPDBSourceInfo(PDB *lpPdb)
|
|
{
|
|
bool fReturnValue = false;
|
|
DBI* lpDbi = NULL;
|
|
|
|
// Module variables...
|
|
Mod * lpMod = NULL;
|
|
Mod * lpPrevMod = NULL;
|
|
long cb;
|
|
|
|
// Type variables...
|
|
TPI * lpTpi = NULL;
|
|
TI tiMin;
|
|
TI tiMac;
|
|
|
|
// Summary variables
|
|
m_dwPDBTotalBytesOfLineInformation = 0;
|
|
m_dwPDBTotalBytesOfSymbolInformation = 0;
|
|
m_dwPDBTotalSymbolTypesRange = 0;
|
|
|
|
if (!PDBOpenDBI(lpPdb, pdbRead, NULL, &lpDbi))
|
|
goto cleanup;
|
|
|
|
//
|
|
// Enumerate through the modules in the Dbi interface we opened...
|
|
//
|
|
while (DBIQueryNextMod(lpDbi, lpMod, &lpMod) && lpMod)
|
|
{
|
|
// If we had a Module Previously... close it...
|
|
if (lpPrevMod)
|
|
{
|
|
ModClose(lpPrevMod);
|
|
lpPrevMod = NULL;
|
|
}
|
|
|
|
// Check that Source line info is removed
|
|
ModQueryLines(lpMod, NULL, &cb);
|
|
|
|
// If we have lines... add these to our total...
|
|
m_dwPDBTotalBytesOfLineInformation+= cb;
|
|
|
|
// Check that local symbols are removed
|
|
ModQuerySymbols(lpMod, NULL, &cb);
|
|
|
|
// If we have symbols for this module... add these to our total...
|
|
m_dwPDBTotalBytesOfSymbolInformation+= cb;
|
|
|
|
// Save the current module (so we can close it if needed)...
|
|
lpPrevMod = lpMod;
|
|
}
|
|
|
|
//
|
|
// Attempt to open the Tpi Interface
|
|
//
|
|
PDBOpenTpi(lpPdb, pdbRead, &lpTpi);
|
|
|
|
// If we
|
|
if(lpTpi)
|
|
{
|
|
// Find the Min and Max Index...
|
|
tiMin = TypesQueryTiMinEx(lpTpi);
|
|
tiMac = TypesQueryTiMacEx(lpTpi);
|
|
|
|
if (tiMin < tiMac)
|
|
{
|
|
m_dwPDBTotalSymbolTypesRange = tiMac - tiMin;
|
|
}
|
|
|
|
}
|
|
|
|
fReturnValue = true;
|
|
|
|
cleanup:
|
|
if (lpTpi)
|
|
{
|
|
TypesClose(lpTpi);
|
|
lpTpi = NULL;
|
|
}
|
|
|
|
if (lpMod)
|
|
{
|
|
ModClose(lpMod);
|
|
lpMod = NULL;
|
|
}
|
|
|
|
if (lpPrevMod)
|
|
{
|
|
ModClose(lpPrevMod);
|
|
lpPrevMod = NULL;
|
|
}
|
|
|
|
if (lpDbi)
|
|
{
|
|
DBIClose(lpDbi);
|
|
}
|
|
|
|
return fReturnValue;
|
|
}
|