938 lines
24 KiB
C
938 lines
24 KiB
C
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dbaccess.c
|
|
|
|
Abstract:
|
|
|
|
This module implements APIs to access the shim database.
|
|
|
|
Author:
|
|
|
|
dmunsil created sometime in 1999
|
|
|
|
Revision History:
|
|
|
|
several people contributed (vadimb, clupu, ...)
|
|
|
|
--*/
|
|
|
|
#include "sdbp.h"
|
|
|
|
#if defined(KERNEL_MODE) && defined(ALLOC_PRAGMA)
|
|
#pragma alloc_text(PAGE, SdbReleaseDatabase)
|
|
#pragma alloc_text(PAGE, SdbGetDatabaseVersion)
|
|
#pragma alloc_text(PAGE, SdbGetDatabaseInformation)
|
|
#pragma alloc_text(PAGE, SdbGetDatabaseID)
|
|
#pragma alloc_text(PAGE, SdbFreeDatabaseInformation)
|
|
#pragma alloc_text(PAGE, SdbGetDatabaseInformationByName)
|
|
#pragma alloc_text(PAGE, SdbpGetDatabaseDescriptionPtr)
|
|
#pragma alloc_text(PAGE, SdbpReadMappedData)
|
|
#pragma alloc_text(PAGE, SdbpGetMappedData)
|
|
#pragma alloc_text(PAGE, SdbOpenDatabase)
|
|
#pragma alloc_text(PAGE, SdbpOpenDatabaseInMemory)
|
|
#pragma alloc_text(PAGE, SdbCloseDatabaseRead)
|
|
#pragma alloc_text(PAGE, SdbpOpenAndMapDB)
|
|
#pragma alloc_text(PAGE, SdbpUnmapAndCloseDB)
|
|
#pragma alloc_text(PAGE, SdbGetTagFromTagID)
|
|
#pragma alloc_text(PAGE, SdbpGetNextTagId)
|
|
#pragma alloc_text(PAGE, SdbGetFirstChild)
|
|
#pragma alloc_text(PAGE, SdbGetNextChild)
|
|
#pragma alloc_text(PAGE, SdbpCreateSearchPathPartsFromPath)
|
|
#endif // KERNEL_MODE && ALLOC_PRAGMA
|
|
|
|
|
|
|
|
void
|
|
SdbReleaseDatabase(
|
|
IN HSDB hSDB // handle to the database channel
|
|
)
|
|
/*++
|
|
Return: void.
|
|
|
|
Desc: This API should be called in pair with SdbInitDatabase.
|
|
--*/
|
|
{
|
|
PSDBCONTEXT pContext = (PSDBCONTEXT)hSDB;
|
|
|
|
assert(pContext != NULL);
|
|
|
|
//
|
|
// Do everything under a try/except block so we don't screw the caller
|
|
// if the databases are corrupt.
|
|
//
|
|
__try {
|
|
|
|
#ifndef KERNEL_MODE
|
|
|
|
SdbpCleanupLocalDatabaseSupport(hSDB);
|
|
|
|
if (pContext->rgSDB[2].dwFlags & SDBENTRY_VALID_ENTRY) {
|
|
SdbCloseDatabaseRead(pContext->rgSDB[2].pdb);
|
|
}
|
|
|
|
#endif // KERNEL_MODE
|
|
|
|
if (pContext->pdbTest != NULL) {
|
|
SdbCloseDatabaseRead(pContext->pdbTest);
|
|
}
|
|
|
|
if (pContext->pdbMain != NULL) {
|
|
SdbCloseDatabaseRead(pContext->pdbMain);
|
|
}
|
|
|
|
//
|
|
// Cleanup attributes.
|
|
//
|
|
SdbpCleanupAttributeMgr(pContext);
|
|
|
|
#ifndef KERNEL_MODE
|
|
|
|
//
|
|
// Cleanup user sdb cache
|
|
//
|
|
SdbpCleanupUserSDBCache(pContext);
|
|
|
|
#endif // KERNEL_MODE
|
|
|
|
#if defined(NT_MODE) || defined(WIN32U_MODE)
|
|
if (SDBCONTEXT_IS_INSTRUMENTED(pContext)) {
|
|
SdbpCloseDebugPipe(SDBCONTEXT_GET_PIPE(pContext));
|
|
}
|
|
#endif
|
|
|
|
SdbFree(pContext);
|
|
|
|
} __except (SHIM_EXCEPT_HANDLER) {
|
|
;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SdbGetDatabaseVersion(
|
|
IN LPCTSTR pszFileName, // the file name
|
|
OUT LPDWORD lpdwMajor, // store the major version of the database
|
|
OUT LPDWORD lpdwMinor // store the minor version of the database
|
|
)
|
|
/*++
|
|
Return: void.
|
|
|
|
Desc: This API should be called in pair with SdbInitDatabase.
|
|
--*/
|
|
{
|
|
PDB pdb;
|
|
SDBDATABASEINFO DBInfo;
|
|
BOOL bSuccess;
|
|
|
|
pdb = SdbAlloc(sizeof(DB));
|
|
|
|
if (pdb == NULL) {
|
|
DBGPRINT((sdlError, "SdbGetDatabaseVersion", "Can't allocate DB structure.\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!SdbpOpenAndMapDB(pdb, pszFileName, DOS_PATH)) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseVersion",
|
|
"Failed to open the database \"%s\".\n",
|
|
pszFileName));
|
|
goto err1;
|
|
}
|
|
|
|
pdb->bWrite = FALSE;
|
|
pdb->dwSize = SdbpGetFileSize(pdb->hFile);
|
|
|
|
if (!SdbGetDatabaseInformation(pdb, &DBInfo)) {
|
|
DBGPRINT((sdlError, "SdbGetDatabaseVersion", "Can't read database information.\n"));
|
|
goto err2;
|
|
}
|
|
|
|
*lpdwMajor = DBInfo.dwVersionMajor;
|
|
*lpdwMinor = DBInfo.dwVersionMinor;
|
|
|
|
err2:
|
|
SdbpUnmapAndCloseDB(pdb);
|
|
|
|
err1:
|
|
SdbFree(pdb);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SDBAPI
|
|
SdbGetDatabaseInformation(
|
|
IN PDB pdb,
|
|
OUT PSDBDATABASEINFO pSdbInfo
|
|
)
|
|
{
|
|
DB_HEADER DBHeader;
|
|
BOOL bReturn = FALSE;
|
|
|
|
RtlZeroMemory(pSdbInfo, sizeof(*pSdbInfo));
|
|
|
|
if (!SdbpReadMappedData(pdb, 0, &DBHeader, sizeof(DB_HEADER))) {
|
|
DBGPRINT((sdlError, "SdbGetDatabaseInformation", "Can't read database header.\n"));
|
|
goto errHandle;
|
|
}
|
|
|
|
if (DBHeader.dwMagic != SHIMDB_MAGIC) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseInformation",
|
|
"Magic doesn't match. Magic: 0x%08X, Expected: 0x%08X.\n",
|
|
DBHeader.dwMagic,
|
|
(DWORD)SHIMDB_MAGIC));
|
|
goto errHandle;
|
|
}
|
|
|
|
pSdbInfo->dwVersionMajor = DBHeader.dwMajorVersion;
|
|
pSdbInfo->dwVersionMinor = DBHeader.dwMinorVersion;
|
|
|
|
//
|
|
// Id and description are optional
|
|
//
|
|
if (SdbGetDatabaseID(pdb, &pSdbInfo->guidDB)) {
|
|
pSdbInfo->dwFlags |= DBINFO_GUID_VALID;
|
|
}
|
|
|
|
//
|
|
// Now try to get valid description.
|
|
//
|
|
pSdbInfo->pszDescription = (LPTSTR)SdbpGetDatabaseDescriptionPtr(pdb);
|
|
|
|
bReturn = TRUE;
|
|
|
|
errHandle:
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
BOOL
|
|
SDBAPI
|
|
SdbGetDatabaseID(
|
|
IN PDB pdb,
|
|
OUT GUID* pguidDB
|
|
)
|
|
{
|
|
TAGID tiDatabase;
|
|
TAGID tiGuidID;
|
|
BOOL bReturn = FALSE;
|
|
|
|
if (!(pdb->dwFlags & DB_GUID_VALID)) {
|
|
tiDatabase = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
|
|
if (!tiDatabase) {
|
|
DBGPRINT((sdlError, "SdbGetDatabaseID", "Failed to get root tag\n"));
|
|
goto errHandle;
|
|
}
|
|
|
|
tiGuidID = SdbFindFirstTag(pdb, tiDatabase, TAG_DATABASE_ID);
|
|
if (!tiGuidID) {
|
|
DBGPRINT((sdlWarning, "SdbGetDatabaseID", "Failed to get the database id\n"));
|
|
goto errHandle;
|
|
}
|
|
|
|
if (!SdbReadBinaryTag(pdb, tiGuidID, (PBYTE)&pdb->guidDB, sizeof(GUID))) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseID",
|
|
"Failed to read database id 0x%lx\n",
|
|
tiGuidID));
|
|
goto errHandle;
|
|
}
|
|
|
|
pdb->dwFlags |= DB_GUID_VALID;
|
|
}
|
|
|
|
//
|
|
// If we are here, GUID retrieval was successful.
|
|
//
|
|
if (pdb->dwFlags & DB_GUID_VALID) {
|
|
RtlMoveMemory(pguidDB, &pdb->guidDB, sizeof(GUID));
|
|
bReturn = TRUE;
|
|
}
|
|
|
|
errHandle:
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
VOID
|
|
SDBAPI
|
|
SdbFreeDatabaseInformation(
|
|
IN PSDBDATABASEINFO pDBInfo
|
|
)
|
|
{
|
|
if (pDBInfo != NULL && (pDBInfo->dwFlags & DBINFO_SDBALLOC)) {
|
|
SdbFree(pDBInfo);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
SDBAPI
|
|
SdbGetDatabaseInformationByName(
|
|
IN LPCTSTR pszDatabase,
|
|
OUT PSDBDATABASEINFO* ppdbInfo
|
|
)
|
|
/*++
|
|
Return: TRUE on success, FALSE otherwise.
|
|
|
|
Desc: This function retrieves database information given the database name
|
|
the pointer to the SDBDATABASEINFO should be freed by the caller using
|
|
SdbFreeDatabaseInformation
|
|
--*/
|
|
{
|
|
PDB pdb = NULL;
|
|
DWORD dwDescriptionSize = 0;
|
|
PSDBDATABASEINFO pDbInfo = NULL;
|
|
BOOL bReturn = FALSE;
|
|
SDBDATABASEINFO DbInfo;
|
|
|
|
assert(ppdbInfo != NULL);
|
|
|
|
pdb = SdbOpenDatabase(pszDatabase, DOS_PATH);
|
|
if (pdb == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseInformationByName",
|
|
"Error opening database file \"%s\"\n",
|
|
pszDatabase));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Find the size of the database description
|
|
//
|
|
if (!SdbGetDatabaseInformation(pdb, &DbInfo)) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseInformationByName",
|
|
"Error Retrieving Database information for \"%s\"\n",
|
|
pszDatabase));
|
|
goto HandleError;
|
|
}
|
|
|
|
if (DbInfo.pszDescription != NULL) {
|
|
dwDescriptionSize = (_tcslen(DbInfo.pszDescription) + 1) * sizeof(TCHAR);
|
|
}
|
|
|
|
pDbInfo = (PSDBDATABASEINFO)SdbAlloc(sizeof(SDBDATABASEINFO) + dwDescriptionSize);
|
|
if (pDbInfo == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"SdbGetDatabaseInformationByName",
|
|
"Error allocating 0x%lx bytes for database information \"%s\"\n",
|
|
sizeof(SDBDATABASEINFO) + dwDescriptionSize,
|
|
pszDatabase));
|
|
goto HandleError;
|
|
}
|
|
|
|
RtlMoveMemory(pDbInfo, &DbInfo, sizeof(DbInfo));
|
|
|
|
pDbInfo->dwFlags |= DBINFO_SDBALLOC;
|
|
|
|
//
|
|
// Make it "self-contained"
|
|
//
|
|
if (DbInfo.pszDescription != NULL) {
|
|
pDbInfo->pszDescription = (LPTSTR)(pDbInfo + 1);
|
|
RtlMoveMemory(pDbInfo->pszDescription, DbInfo.pszDescription, dwDescriptionSize);
|
|
}
|
|
|
|
*ppdbInfo = pDbInfo;
|
|
bReturn = TRUE;
|
|
|
|
HandleError:
|
|
if (pdb != NULL) {
|
|
SdbCloseDatabaseRead(pdb);
|
|
}
|
|
|
|
if (!bReturn) {
|
|
if (pDbInfo != NULL) {
|
|
SdbFree(pDbInfo);
|
|
}
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
LPCTSTR
|
|
SdbpGetDatabaseDescriptionPtr(
|
|
IN PDB pdb
|
|
)
|
|
{
|
|
TAGID tiDatabase;
|
|
TAGID tiName;
|
|
LPCTSTR lpszDescription = NULL;
|
|
|
|
tiDatabase = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
|
|
|
|
if (!tiDatabase) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpGetDatabaseDescriptionPtr",
|
|
"Failed to get database tag, db is corrupt\n"));
|
|
goto errHandle;
|
|
}
|
|
|
|
tiName = SdbFindFirstTag(pdb, tiDatabase, TAG_NAME);
|
|
if (tiName) {
|
|
lpszDescription = SdbGetStringTagPtr(pdb, tiName);
|
|
}
|
|
|
|
errHandle:
|
|
return lpszDescription;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SdbpReadMappedData(
|
|
IN PDB pdb, // database handle
|
|
IN DWORD dwOffset, // offset in the database where the data is to be copied from
|
|
OUT PVOID pBuffer, // destination buffer
|
|
IN DWORD dwSize // the region size
|
|
)
|
|
/*++
|
|
Return: TRUE if successful, FALSE otherwise.
|
|
|
|
Desc: This function reads the data (dwSize bytes) from the database
|
|
starting at offset dwOffset into the buffer pBuffer provided
|
|
by the caller
|
|
--*/
|
|
{
|
|
|
|
if (pdb->dwSize < dwOffset + dwSize) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpReadMappedData",
|
|
"Attempt to read past the end of the database offset 0x%lx size 0x%lx (0x%lx)\n",
|
|
dwOffset,
|
|
dwSize,
|
|
pdb->dwSize));
|
|
return FALSE;
|
|
}
|
|
|
|
assert(pdb->pBase != NULL);
|
|
|
|
memcpy(pBuffer, (PBYTE)pdb->pBase + dwOffset, dwSize);
|
|
return TRUE;
|
|
}
|
|
|
|
PVOID
|
|
SdbpGetMappedData(
|
|
IN PDB pdb, // database handle
|
|
IN DWORD dwOffset // offset in the database
|
|
)
|
|
/*++
|
|
Return: The pointer to the data.
|
|
|
|
Desc: This function returns the pointer to data within the database at
|
|
offset dwOffset. It will return FALSE if dwOffset is invalid.
|
|
--*/
|
|
{
|
|
assert(pdb);
|
|
|
|
assert(pdb->pBase != NULL);
|
|
|
|
if (dwOffset >= pdb->dwSize) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpGetMappedData",
|
|
"Trying to read mapped data past the end of the database offset 0x%x size 0x%x\n",
|
|
dwOffset,
|
|
pdb->dwSize));
|
|
assert(FALSE);
|
|
return NULL;
|
|
}
|
|
|
|
return (PBYTE)pdb->pBase + dwOffset;
|
|
}
|
|
|
|
|
|
PDB
|
|
SdbOpenDatabase(
|
|
IN LPCTSTR szPath, // full path to the DB
|
|
IN PATH_TYPE eType // DOS_PATH for standard paths,
|
|
// NT_PATH for internal NT paths
|
|
)
|
|
/*++
|
|
Return: A pointer to the open DB, or NULL on failure.
|
|
|
|
Desc: Opens up a shim database file, checks version and magic numbers, and creates
|
|
a DB record that is passed back as a PDB. eType can be NT_PATH or DOS_PATH,
|
|
and tells whether we are using NTDLL internal paths, or the more familiar
|
|
DOS paths.
|
|
--*/
|
|
{
|
|
PDB pdb;
|
|
DB_HEADER DBHeader;
|
|
BOOL bSuccess;
|
|
|
|
pdb = SdbAlloc(sizeof(DB));
|
|
|
|
if (pdb == NULL) {
|
|
DBGPRINT((sdlError, "SdbOpenDatabase", "Can't allocate DB structure.\n"));
|
|
return NULL;
|
|
}
|
|
|
|
if (!SdbpOpenAndMapDB(pdb, szPath, eType)) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbOpenDatabase",
|
|
"Failed to open the database \"%s\".\n",
|
|
szPath));
|
|
goto err1;
|
|
}
|
|
|
|
pdb->bWrite = FALSE;
|
|
pdb->dwSize = SdbpGetFileSize(pdb->hFile);
|
|
|
|
//
|
|
// Check version and magic.
|
|
//
|
|
if (!SdbpReadMappedData(pdb, 0, &DBHeader, sizeof(DB_HEADER))) {
|
|
DBGPRINT((sdlError, "SdbOpenDatabase", "Can't read database header.\n"));
|
|
goto err2;
|
|
}
|
|
|
|
if (DBHeader.dwMagic != SHIMDB_MAGIC) {
|
|
DBGPRINT((sdlError, "SdbOpenDatbase", "Magic does not match 0x%lx\n", DBHeader.dwMagic));
|
|
goto err2;
|
|
}
|
|
|
|
if (DBHeader.dwMajorVersion == 1) {
|
|
DBGPRINT((sdlWarning, "SdbOpenDatabase", "Reading under hack from older database\n"));
|
|
pdb->bUnalignedRead = TRUE;
|
|
} else if (DBHeader.dwMajorVersion != SHIMDB_MAJOR_VERSION) {
|
|
|
|
DBGPRINT((sdlError, "SdbOpenDatabase",
|
|
"MajorVersion mismatch, MajorVersion 0x%lx Expected 0x%lx\n",
|
|
DBHeader.dwMajorVersion, (DWORD)SHIMDB_MAJOR_VERSION));
|
|
goto err2;
|
|
}
|
|
|
|
if (DBHeader.dwMagic != SHIMDB_MAGIC || DBHeader.dwMajorVersion != SHIMDB_MAJOR_VERSION) {
|
|
DBGPRINT((sdlError,
|
|
"SdbOpenDatabase",
|
|
"Magic or MajorVersion doesn't match."
|
|
"Magic: %08X, Expected: %08X; MajorVersion: %08X, Expected: %08X.\n",
|
|
DBHeader.dwMagic,
|
|
(DWORD)SHIMDB_MAGIC,
|
|
DBHeader.dwMajorVersion,
|
|
(DWORD)SHIMDB_MAJOR_VERSION));
|
|
goto err2;
|
|
}
|
|
|
|
return pdb;
|
|
|
|
err2:
|
|
SdbpUnmapAndCloseDB(pdb);
|
|
|
|
err1:
|
|
SdbFree(pdb);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PDB
|
|
SdbpOpenDatabaseInMemory(
|
|
IN LPVOID pImageDatabase, // Pointer to the image of the mapped database
|
|
IN DWORD dwSize // the size of the file in bytes
|
|
)
|
|
/*++
|
|
Return: BUGBUG: ?
|
|
|
|
Desc: BUGBUG: ?
|
|
--*/
|
|
{
|
|
PDB pdb = NULL;
|
|
DB_HEADER DBHeader;
|
|
|
|
pdb = SdbAlloc(sizeof(DB));
|
|
if (pdb == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpOpenDatabaseInMemory",
|
|
"Failed to allocate DB structure\n"));
|
|
return NULL;
|
|
}
|
|
|
|
pdb->bWrite = FALSE;
|
|
pdb->hFile = INVALID_HANDLE_VALUE;
|
|
pdb->pBase = pImageDatabase;
|
|
pdb->dwSize = dwSize;
|
|
pdb->dwFlags |= DB_IN_MEMORY;
|
|
|
|
if (!SdbpReadMappedData(pdb, 0, &DBHeader, sizeof(DB_HEADER))) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpOpenDatabaseInMemory",
|
|
"Can't read database header\n"));
|
|
goto ErrHandle;
|
|
}
|
|
|
|
if (DBHeader.dwMagic != SHIMDB_MAGIC || DBHeader.dwMajorVersion != SHIMDB_MAJOR_VERSION) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpOpenDatabaseInMemory",
|
|
"Magic or MajorVersion doesn't match."
|
|
"Magic: %08X, Expected: %08X; MajorVersion: %08X, Expected: %08X.\n",
|
|
DBHeader.dwMagic,
|
|
(DWORD)SHIMDB_MAGIC,
|
|
DBHeader.dwMajorVersion,
|
|
(DWORD)SHIMDB_MAJOR_VERSION));
|
|
goto ErrHandle;
|
|
}
|
|
|
|
return pdb;
|
|
|
|
ErrHandle:
|
|
if (pdb != NULL) {
|
|
SdbFree(pdb);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
void
|
|
SdbCloseDatabaseRead(
|
|
IN PDB pdb // handle to the DB to close
|
|
)
|
|
/*++
|
|
Return: void.
|
|
|
|
Desc: Closes a database that was opened for read access as it is the case
|
|
with the majority of our run-time code.
|
|
--*/
|
|
{
|
|
assert(pdb);
|
|
assert(!pdb->bWrite);
|
|
|
|
if (pdb->pBase != NULL) {
|
|
|
|
SdbpUnmapAndCloseDB(pdb);
|
|
|
|
CLEANUP_STRING_CACHE_READ(pdb);
|
|
|
|
SdbFree(pdb);
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SdbpOpenAndMapDB(
|
|
IN PDB pdb, // pdb to fill in with mapping handles and whatnot
|
|
IN LPCTSTR pszPath, // full path of file to open
|
|
IN PATH_TYPE eType // DOS_PATH for standard paths, NT_PATH for nt internal paths
|
|
)
|
|
/*++
|
|
Return: TRUE if successful, FALSE otherwise.
|
|
|
|
Desc: Opens a db file, maps it into memory, and sets up the global vars in the pdb.
|
|
--*/
|
|
{
|
|
NTSTATUS status;
|
|
IMAGEFILEDATA ImageData;
|
|
|
|
ImageData.dwFlags = 0;
|
|
|
|
if (!SdbpOpenAndMapFile(pszPath, &ImageData, eType)) {
|
|
DBGPRINT((sdlInfo, "SdbpOpenAndMapDB", "Failed to open file \"%s\"\n", pszPath));
|
|
return FALSE;
|
|
}
|
|
|
|
pdb->hFile = ImageData.hFile;
|
|
pdb->hSection = ImageData.hSection;
|
|
pdb->pBase = ImageData.pBase;
|
|
pdb->dwSize = (DWORD)ImageData.ViewSize;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SdbpUnmapAndCloseDB(
|
|
IN PDB pdb // pdb to close the files and mapping info
|
|
)
|
|
/*++
|
|
Return: TRUE if successful, FALSE otherwise.
|
|
|
|
Desc: Cleans up for the specified database.
|
|
--*/
|
|
{
|
|
BOOL bReturn;
|
|
IMAGEFILEDATA ImageData;
|
|
|
|
if (pdb->dwFlags & DB_IN_MEMORY) {
|
|
//
|
|
// database in memory
|
|
//
|
|
pdb->pBase = NULL;
|
|
pdb->dwSize = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
ImageData.dwFlags = 0;
|
|
ImageData.hFile = pdb->hFile;
|
|
ImageData.hSection = pdb->hSection;
|
|
ImageData.pBase = pdb->pBase;
|
|
|
|
bReturn = SdbpUnmapAndCloseFile(&ImageData);
|
|
|
|
//
|
|
// once we nuke the file -- reset values
|
|
//
|
|
if (bReturn) {
|
|
pdb->hFile = INVALID_HANDLE_VALUE;
|
|
pdb->hSection = NULL;
|
|
pdb->pBase = NULL;
|
|
}
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
TAG
|
|
SdbGetTagFromTagID(
|
|
IN PDB pdb, // DB to use
|
|
IN TAGID tiWhich // record to get the tag for
|
|
)
|
|
/*++
|
|
Return: Just the TAG (the word-sized header) of the record.
|
|
|
|
Desc: Returns just the TAG that a TAGID points to.
|
|
--*/
|
|
{
|
|
TAG tWhich = TAG_NULL;
|
|
|
|
assert(pdb && tiWhich);
|
|
|
|
if (!SdbpReadMappedData(pdb, (DWORD)tiWhich, &tWhich, sizeof(TAG))) {
|
|
DBGPRINT((sdlError, "SdbGetTagFromTagID", "Error reading data.\n"));
|
|
return TAG_NULL;
|
|
}
|
|
|
|
return tWhich;
|
|
}
|
|
|
|
|
|
TAGID
|
|
SdbpGetNextTagId(
|
|
IN PDB pdb, // DB to look in
|
|
IN TAGID tiWhich // tag to get the next sibling of
|
|
)
|
|
/*++
|
|
Return: The next tag after the one passed in, or one past end of file if no more.
|
|
|
|
Desc: Gets the TAGID of the next tag in the DB, or a virtual
|
|
TAGID that is one past the end of the file, which means
|
|
there are no more tags in the DB.
|
|
|
|
This is an internal function, and shouldn't be called by
|
|
external functions, as there's no clean way to tell you've
|
|
walked off the end of the file. Use tiGetNextChildTag instead.
|
|
--*/
|
|
{
|
|
//
|
|
// If the tag is an unfinished list tag, point to the end of the file.
|
|
//
|
|
if (GETTAGTYPE(SdbGetTagFromTagID(pdb, tiWhich)) == TAG_TYPE_LIST &&
|
|
SdbGetTagDataSize(pdb, tiWhich) == TAG_SIZE_UNFINISHED) {
|
|
|
|
DBGPRINT((sdlError, "SdbpGetNextTagId", "Reading from unfinished list.\n"));
|
|
return pdb->dwSize;
|
|
} else {
|
|
return (TAGID)(tiWhich + GETTAGDATAOFFSET(pdb, tiWhich));
|
|
}
|
|
}
|
|
|
|
TAGID
|
|
SdbGetFirstChild(
|
|
IN PDB pdb, // DB to use
|
|
IN TAGID tiParent // parent to look in
|
|
)
|
|
/*++
|
|
Return: The first child of tiParent, or TAGID_NULL if there are none.
|
|
|
|
Desc: Returns the first child of tiParent, which must point to a tag
|
|
of basic type LIST.
|
|
--*/
|
|
{
|
|
TAGID tiParentEnd;
|
|
TAGID tiReturn;
|
|
|
|
assert(pdb);
|
|
|
|
if (tiParent != TAGID_ROOT &&
|
|
GETTAGTYPE(SdbGetTagFromTagID(pdb, tiParent)) != TAG_TYPE_LIST) {
|
|
|
|
DBGPRINT((sdlError,
|
|
"SdbGetFirstChild",
|
|
"Trying to operate on non-list, non-root tag.\n"));
|
|
return TAGID_NULL;
|
|
}
|
|
|
|
if (tiParent == TAGID_ROOT) {
|
|
tiParentEnd = pdb->dwSize;
|
|
|
|
//
|
|
// Skip past the header.
|
|
//
|
|
tiReturn = sizeof(DB_HEADER);
|
|
|
|
} else {
|
|
tiParentEnd = SdbpGetNextTagId(pdb, tiParent);
|
|
|
|
//
|
|
// Just skip past the tag and size params.
|
|
//
|
|
tiReturn = tiParent + sizeof(TAG) + sizeof(DWORD);
|
|
}
|
|
|
|
|
|
if (tiReturn >= tiParentEnd) {
|
|
tiReturn = TAGID_NULL;
|
|
}
|
|
|
|
return tiReturn;
|
|
}
|
|
|
|
|
|
TAGID
|
|
SdbGetNextChild(
|
|
IN PDB pdb, // DB to use
|
|
IN TAGID tiParent, // parent to look in
|
|
IN TAGID tiPrev // previously found child
|
|
)
|
|
/*++
|
|
Return: The next child of tiParent, or TAGID_NULL if there are none.
|
|
|
|
Desc: Returns the next child of tiParent after tiPrev. tiParent must point
|
|
to a tag of basic type LIST.
|
|
--*/
|
|
{
|
|
TAGID tiParentEnd;
|
|
TAGID tiReturn;
|
|
|
|
assert(pdb && tiPrev);
|
|
|
|
if (tiParent != TAGID_ROOT &&
|
|
GETTAGTYPE(SdbGetTagFromTagID(pdb, tiParent)) != TAG_TYPE_LIST) {
|
|
|
|
DBGPRINT((sdlError,
|
|
"SdbGetNextChild",
|
|
"Trying to operate on non-list, non-root tag.\n"));
|
|
return TAGID_NULL;
|
|
}
|
|
|
|
if (tiParent == TAGID_ROOT) {
|
|
tiParentEnd = pdb->dwSize;
|
|
} else {
|
|
tiParentEnd = SdbpGetNextTagId(pdb, tiParent);
|
|
}
|
|
|
|
//
|
|
// Get the next tag.
|
|
//
|
|
tiReturn = SdbpGetNextTagId(pdb, tiPrev);
|
|
|
|
if (tiReturn >= tiParentEnd) {
|
|
tiReturn = TAGID_NULL;
|
|
}
|
|
|
|
return tiReturn;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SdbpCreateSearchPathPartsFromPath(
|
|
IN LPCTSTR pszPath,
|
|
OUT PSEARCHPATHPARTS* ppSearchPathParts
|
|
)
|
|
/*++
|
|
Return: Returns TRUE on success, FALSE on failure.
|
|
|
|
Desc: This function breaks down a search path (PROCESS_HISTORY) into
|
|
parts, with each part specifying a directory where the search
|
|
for a matching binary to take place. Directories are organized
|
|
in such a way that the last executed binary provides the first
|
|
search path.
|
|
--*/
|
|
{
|
|
|
|
LPCTSTR pszDir = pszPath;
|
|
LPCTSTR pszDirEnd = NULL;
|
|
ULONG nParts = 0;
|
|
ULONG i = 0;
|
|
PSEARCHPATHPARTS pSearchPathParts = NULL;
|
|
|
|
if (pszPath == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpCreateSearchPathPartsFromPath",
|
|
"Invalid argument.\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// We count search path parts by counting semicolons in the path string
|
|
// numberOfParts = numberOfSemicolons + 1
|
|
//
|
|
pszDir = pszPath;
|
|
|
|
if (*pszDir != 0) {
|
|
//
|
|
// At least one part there...
|
|
//
|
|
nParts++;
|
|
}
|
|
|
|
while ((pszDir = _tcschr(pszDir, _T(';'))) != NULL) {
|
|
pszDir++;
|
|
nParts++;
|
|
}
|
|
|
|
//
|
|
// nParts now has the number of parts in a search path.
|
|
//
|
|
pSearchPathParts = (PSEARCHPATHPARTS)SdbAlloc(sizeof(SEARCHPATHPARTS) +
|
|
sizeof(SEARCHPATHPART) * nParts);
|
|
|
|
if (pSearchPathParts == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"SdbpCreateSearchPathPartsFromPath",
|
|
"Failed to allocate %d bytes.\n",
|
|
sizeof(SEARCHPATHPARTS) + sizeof(SEARCHPATHPART) * nParts));
|
|
return FALSE;
|
|
}
|
|
|
|
pSearchPathParts->PartCount = nParts;
|
|
|
|
pszDir = pszPath + _tcslen(pszPath);
|
|
|
|
while (pszDir >= pszPath) {
|
|
if (*pszDir == _T('\\') && pszDirEnd == NULL) {
|
|
//
|
|
// Points to the backslash
|
|
//
|
|
pszDirEnd = pszDir;
|
|
}
|
|
|
|
if ((*pszDir == _T(';') || pszPath == pszDir) && pszDirEnd != NULL) {
|
|
//
|
|
// At this point we should have an end to the string,
|
|
// If not that means we are stepping from a recently found path
|
|
//
|
|
if (*pszDir == _T(';')) {
|
|
pszDir++;
|
|
}
|
|
|
|
pSearchPathParts->Parts[i].pszPart = pszDir;
|
|
pSearchPathParts->Parts[i].PartLength = (ULONG)(pszDirEnd - pszDir + 1);
|
|
|
|
i++;
|
|
|
|
pszDirEnd = NULL;
|
|
|
|
}
|
|
|
|
pszDir--;
|
|
}
|
|
|
|
*ppSearchPathParts = pSearchPathParts;
|
|
|
|
return TRUE;
|
|
}
|
|
|