able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/windows/appcompat/sdbapi/ntbaseplus.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4349 lines
119 KiB
C
Raw Blame History

/*++
Copyright (c) 1989-2000 Microsoft Corporation
Module Name:
ntbaseplus.c
Abstract:
This module implements low level primitives. They should never be
called by anything other than this module.
Author:
dmunsil created sometime in 1999
Revision History:
several people contributed (vadimb, clupu, ...)
kinshu - 01/10/2002 - Fixed a bug in the circular linked list
insertion and deletion routines(InsertLookup,
RemoveLookup)
--*/
#include "sdbp.h"
UNICODE_STRING g_ustrDatabasePath = RTL_CONSTANT_STRING(L"DatabasePath");
UNICODE_STRING g_ustrDatabaseType = RTL_CONSTANT_STRING(L"DatabaseType");
UNICODE_STRING g_ustrDatabaseDescription = RTL_CONSTANT_STRING(L"DatabaseDescription");
UNICODE_STRING g_ustrInstallTimeStamp = RTL_CONSTANT_STRING(L"DatabaseInstallTimeStamp");
UNICODE_STRING g_ustrDebugPipeName = RTL_CONSTANT_STRING(L"\\Device\\NamedPipe\\ShimViewer");
extern TCHAR g_szCompatLayer[];
//
// Global flag for wow64. On Win2k we zero this flag out
//
DWORD volatile g_dwWow64Key = (DWORD)-1;
typedef NTSTATUS
(SDBAPI* PFNEnsureBufferSize)(
IN ULONG Flags,
IN OUT PRTL_BUFFER Buffer,
IN SIZE_T Size);
PFNEnsureBufferSize volatile g_pfnEnsureBufferSize = NULL;
NTSTATUS
SDBAPI
SdbEnsureBufferSizeFunction(
IN ULONG Flags,
IN OUT PRTL_BUFFER Buffer,
IN SIZE_T Size);
//
// to work on win2k, we have to modify default buffer-manipulation macro
//
#undef RtlEnsureBufferSize
#define RtlEnsureBufferSize(Flags, Buff, NewSizeBytes) \
( ((Buff) != NULL && (NewSizeBytes) <= (Buff)->Size) \
? STATUS_SUCCESS \
: SdbEnsureBufferSizeFunction((Flags), (Buff), (NewSizeBytes)) \
)
//
// This routine was stolen from buffer.c in ntdll so that we can support downlevel platforms
//
NTSTATUS
SDBAPI
SdbpEnsureBufferSize(
IN ULONG Flags,
IN OUT PRTL_BUFFER Buffer,
IN SIZE_T Size
)
{
NTSTATUS Status = STATUS_SUCCESS;
PUCHAR Temp = NULL;
if ((Flags & ~(RTL_ENSURE_BUFFER_SIZE_NO_COPY)) != 0) {
Status = STATUS_INVALID_PARAMETER;
goto Exit;
}
if (Buffer == NULL) {
Status = STATUS_INVALID_PARAMETER;
goto Exit;
}
if (Size <= Buffer->Size) {
Status = STATUS_SUCCESS;
goto Exit;
}
//
// Size <= Buffer->StaticSize does not imply static allocation, it
// could be heap allocation that the client poked smaller.
//
if (Buffer->Buffer == Buffer->StaticBuffer && Size <= Buffer->StaticSize) {
Buffer->Size = Size;
Status = STATUS_SUCCESS;
goto Exit;
}
//
// The realloc case was messed up in Whistler, and got removed.
// Put it back in Blackcomb.
//
Temp = (PUCHAR)RtlAllocateHeap(RtlProcessHeap(), 0, (Size));
if (Temp == NULL) {
Status = STATUS_NO_MEMORY;
goto Exit;
}
if ((Flags & RTL_ENSURE_BUFFER_SIZE_NO_COPY) == 0) {
RtlCopyMemory(Temp, Buffer->Buffer, Buffer->Size);
}
if (RTLP_BUFFER_IS_HEAP_ALLOCATED(Buffer)) {
RtlFreeHeap(RtlProcessHeap(), 0, Buffer->Buffer);
Buffer->Buffer = NULL;
}
ASSERT(Temp != NULL);
Buffer->Buffer = Temp;
Buffer->Size = Size;
Status = STATUS_SUCCESS;
Exit:
return Status;
}
#define KEY_MACHINE TEXT("\\Registry\\Machine")
BOOL
SdbpBuildMachineKeyPath(
IN LPCWSTR pwszPath,
OUT PUNICODE_STRING pmachineKeyPath
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Given a path to the key it builds it up for HKEY_LOCAL_MACHINE
registry. The buffer used by pmachineKeyPath will have to be freed
using SdbFree!
--*/
{
BOOL bReturn = FALSE;
NTSTATUS Status;
UNICODE_STRING machineKey = {0};
RtlInitUnicodeString(&machineKey, KEY_MACHINE);
pmachineKeyPath->Length = 0;
pmachineKeyPath->MaximumLength = wcslen(pwszPath) * sizeof(*pwszPath) +
machineKey.Length +
sizeof(UNICODE_NULL);
pmachineKeyPath->Buffer = SdbAlloc(pmachineKeyPath->MaximumLength);
if (pmachineKeyPath->Buffer == NULL) {
DBGPRINT((sdlError,
"SdbpBuildUserKeyPath",
"Failed to allocate %d bytes for user key buffer.\n",
pmachineKeyPath->MaximumLength));
goto out;
}
RtlAppendUnicodeStringToString(pmachineKeyPath, &machineKey);
RtlAppendUnicodeToString(pmachineKeyPath, pwszPath);
bReturn = TRUE;
out:
return bReturn;
}
BOOL
SdbpBuildUserKeyPath(
IN LPCWSTR pwszPath,
OUT PUNICODE_STRING puserKeyPath
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Given a path to the key it builds it up for HKEY_CURRENT_USER
registry. The buffer used by puserKeyPath will have to be freed
using SdbFree!
--*/
{
BOOL bReturn = FALSE;
NTSTATUS Status;
UNICODE_STRING userKey = {0};
Status = RtlFormatCurrentUserKeyPath(&userKey);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpBuildUserKeyPath",
"Failed to format current user key path 0x%x\n",
Status));
goto out;
}
puserKeyPath->Length = 0;
puserKeyPath->MaximumLength = wcslen(pwszPath) * sizeof(*pwszPath) +
userKey.Length +
sizeof(UNICODE_NULL);
puserKeyPath->Buffer = SdbAlloc(puserKeyPath->MaximumLength);
if (puserKeyPath->Buffer == NULL) {
DBGPRINT((sdlError,
"SdbpBuildUserKeyPath",
"Failed to allocate %d bytes for user key buffer.\n",
puserKeyPath->MaximumLength));
goto out;
}
RtlAppendUnicodeStringToString(puserKeyPath, &userKey);
RtlAppendUnicodeToString(puserKeyPath, pwszPath);
bReturn = TRUE;
out:
RtlFreeUnicodeString(&userKey);
return bReturn;
}
/////////////////////////////////////////////////////////////////////////////////////////
//
// Custom SDB cache code
//
PUSERSDBLOOKUP
SdbpFindSDBLookupEntry(
IN PSDBCONTEXT pSdbContext, // sdb context for searches
IN LPCWSTR pwszItemName, // item name foo.exe for instance
IN BOOL bLayer // true if Layer
)
{
PUSERSDBLOOKUP pLookup = pSdbContext->pLookupHead;
if (pLookup == NULL) {
return NULL;
}
do {
if (!_wcsicmp(pLookup->pwszItemName, pwszItemName) && pLookup->bLayer == bLayer) {
return pLookup;
}
pLookup = pLookup->pNext;
} while (pLookup != pSdbContext->pLookupHead);
return NULL;
}
void
RemoveLookup(
PSDBCONTEXT pSdbContext,
PUSERSDBLOOKUP pLookup
)
{
assert(pLookup);
if (pLookup->pPrev == pLookup) {
//
// There is only one element
//
pSdbContext->pLookupHead = NULL;
SdbFree(pLookup);
return;
}
if (pSdbContext->pLookupHead == pLookup) {
//
// We are deleting the first element
//
pSdbContext->pLookupHead = pLookup->pNext;
}
pLookup->pPrev->pNext = pLookup->pNext;
pLookup->pNext->pPrev = pLookup->pPrev;
SdbFree(pLookup);
}
void
InsertLookup(
PSDBCONTEXT pSdbContext,
PUSERSDBLOOKUP pLookup
)
{
assert(pLookup);
if (pSdbContext->pLookupHead == NULL) {
pSdbContext->pLookupHead = pLookup;
pLookup->pPrev = pLookup;
pLookup->pNext = pLookup;
return;
}
pLookup->pNext = pSdbContext->pLookupHead;
pLookup->pPrev = pSdbContext->pLookupHead->pPrev;
//
// The pNext of the last element (pSdbContext->pLookupHead->pPrev) should point to the
// new element
//
pSdbContext->pLookupHead->pPrev->pNext = pLookup;
pSdbContext->pLookupHead->pPrev = pLookup;
pSdbContext->pLookupHead = pLookup;
}
PUSERSDBLOOKUP
SdbpCreateSDBLookupEntry(
IN PSDBCONTEXT pSdbContext,
IN DWORD dwCount,
IN LPCWSTR pwszItemName,
IN BOOL bLayer
)
{
DWORD dwSize;
PUSERSDBLOOKUP pLookup;
pLookup = SdbpFindSDBLookupEntry(pSdbContext, pwszItemName, bLayer);
if (pLookup != NULL) {
//
// cornel: If we already have it shouldn't we just return here ?
//
assert(pLookup->dwCount == dwCount);
RemoveLookup(pSdbContext, pLookup);
}
//
// One entry is already included. See the structure definition.
//
// The memory layout is:
//
// USERSDBLOOKUP
// (dwCount - 1) USERSDBLOOKUPENTRY structures
// the string that pLookup->pwszItemName points to
//
dwSize = sizeof(USERSDBLOOKUP) +
(wcslen(pwszItemName) + 1) * sizeof(WCHAR) +
(dwCount - 1) * sizeof(USERSDBLOOKUPENTRY); // one is already included
pLookup = (PUSERSDBLOOKUP)SdbAlloc(dwSize);
if (pLookup == NULL) {
DBGPRINT((sdlError,
"SdbpCreateSDBLookupEntry",
"Failed to allocate 0x%lx bytes for sdb lookup buffer\n",
dwSize));
return NULL;
}
pLookup->pwszItemName = (LPWSTR)((PBYTE)(pLookup + 1) +
(dwCount - 1) * sizeof(USERSDBLOOKUPENTRY));
pLookup->bLayer = bLayer;
pLookup->dwCount = dwCount;
wcscpy(pLookup->pwszItemName, pwszItemName);
InsertLookup(pSdbContext, pLookup);
return pLookup;
}
void
SdbpCleanupUserSDBCache(
IN PSDBCONTEXT pSdbContext
)
{
while (pSdbContext->pLookupHead) {
RemoveLookup(pSdbContext, pSdbContext->pLookupHead);
}
}
//
// We built the array of these in accordance with ValueName's corresponding to a
// list of custom databases we have -- and query existing values for this particular entry
// ValueBuffer shall be allocated to be of a maximum length considering the number
// of the entries that we have
//
typedef int (__cdecl* PFNQSORTCOMPARE)(const void* pElem1, const void* pElem2);
int __cdecl
SdbpUserSDBLookupCompareEntries(
LPCVOID pEntry1,
LPCVOID pEntry2
)
{
//
// last-installed goes first
//
PUSERSDBLOOKUPENTRY pLookupEntry1 = (PUSERSDBLOOKUPENTRY)pEntry1;
PUSERSDBLOOKUPENTRY pLookupEntry2 = (PUSERSDBLOOKUPENTRY)pEntry2;
if (pLookupEntry1->liTimeStamp.QuadPart < pLookupEntry2->liTimeStamp.QuadPart) {
return 1;
}
if (pLookupEntry1->liTimeStamp.QuadPart == pLookupEntry2->liTimeStamp.QuadPart) {
return 0;
}
return -1;
}
NTSTATUS
SDBAPI
SdbpFindCharInUnicodeString(
ULONG Flags,
PCUNICODE_STRING StringToSearch,
PCUNICODE_STRING CharSet,
USHORT* NonInclusivePrefixLength
)
{
LPCWSTR pch;
//
// Implement only the case when we move backwards
//
if (Flags != RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END) {
return STATUS_NOT_IMPLEMENTED;
}
pch = StringToSearch->Buffer + StringToSearch->Length / sizeof(WCHAR);
while (pch >= StringToSearch->Buffer) {
if (_tcschr(CharSet->Buffer, *pch)) {
//
// Got the char
//
if (NonInclusivePrefixLength) {
*NonInclusivePrefixLength = (USHORT)(pch - StringToSearch->Buffer) * sizeof(WCHAR);
}
return STATUS_SUCCESS;
}
pch--;
}
//
// We haven't found it. Return failure.
//
return STATUS_NOT_FOUND;
}
BOOL
SdbpEnumUserSdb(
IN PSDBCONTEXT pSdbContext,
IN LPCWSTR wszItemName, // file name of an exe or the layer name
IN BOOL bLayer,
OUT PUSERSDBLOOKUP* ppSdbLookup
)
{
//
// This is how we figure:
// path + \\layers\\ + MAX_PATH (for name)
//
WCHAR FullKeyBuffer[sizeof(APPCOMPAT_KEY_PATH_MACHINE_CUSTOM)/sizeof(WCHAR) + 8 + MAX_PATH];
OBJECT_ATTRIBUTES ObjectAttributes;
struct {
KEY_FULL_INFORMATION KeyFullInformation;
WCHAR Buffer[MAX_PATH];
} KeyInformationBuffer;
PKEY_FULL_INFORMATION pFullInfo = &KeyInformationBuffer.KeyFullInformation;
struct {
KEY_VALUE_FULL_INFORMATION KeyValueFullInformation;
BYTE Buffer[MAX_PATH * 2 * sizeof(WCHAR)];
} KeyValueInformationBuffer;
PKEY_VALUE_FULL_INFORMATION pValue = &KeyValueInformationBuffer.KeyValueFullInformation;
PBYTE pData;
PUSERSDBLOOKUPENTRY pEntry;
ULONG ResultLength;
ULONG KeyValueLength;
DWORD dwIndexValue = 0;
DWORD dwIndexEntries = 0;
ULONG nIndex;
NTSTATUS Status;
HANDLE KeyHandle = NULL;
UNICODE_STRING ustrDbGuid;
USHORT uPrefix = 0;
UNICODE_STRING ustrFullKey;
UNICODE_STRING ustrValue;
UNICODE_STRING ustrCharDot = RTL_CONSTANT_STRING(L".");
GUID guidDB;
PUSERSDBLOOKUP pLookup = NULL;
BOOL bSuccess = FALSE;
ULARGE_INTEGER liTimeStamp;
ustrFullKey.Length = 0;
ustrFullKey.Buffer = FullKeyBuffer;
ustrFullKey.MaximumLength = sizeof(FullKeyBuffer);
RtlAppendUnicodeToString(&ustrFullKey, APPCOMPAT_KEY_PATH_MACHINE_CUSTOM);
if (bLayer) {
RtlAppendUnicodeToString(&ustrFullKey, L"\\Layers\\");
} else {
RtlAppendUnicodeToString(&ustrFullKey, L"\\");
}
RtlAppendUnicodeToString(&ustrFullKey, wszItemName);
InitializeObjectAttributes(&ObjectAttributes,
&ustrFullKey,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle, GENERIC_READ|SdbpGetWow64Flag(), &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpEnumUserSdb",
"Failed to open key \"%s\" Status 0x%lx\n",
ustrFullKey.Buffer,
Status));
goto cleanup;
}
Status = NtQueryKey(KeyHandle,
KeyFullInformation,
&KeyInformationBuffer,
sizeof(KeyInformationBuffer),
&ResultLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpEnumUserSdb",
"Failed to query key \"%s\" Status 0x%lx\n",
ustrFullKey.Buffer,
Status));
goto cleanup;
}
if (pFullInfo->Values == 0) {
goto cleanup; // nothing to look at
}
//
// Create new lookup item
//
pLookup = SdbpCreateSDBLookupEntry(pSdbContext, pFullInfo->Values, wszItemName, bLayer);
if (pLookup == NULL) {
//
// Oops, can't have an entry -- can't do lookups
//
goto cleanup;
}
//
// Load all the values
//
for (dwIndexValue = 0; dwIndexValue < pFullInfo->Values; dwIndexValue++) {
Status = NtEnumerateValueKey(KeyHandle,
dwIndexValue,
KeyValueFullInformation,
&KeyValueInformationBuffer,
sizeof(KeyValueInformationBuffer),
&KeyValueLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpEnumUserSdb",
"Failed to enum value index 0x%lx Status 0x%lx\n",
dwIndexValue,
Status));
continue;
}
//
// Extract database guid
//
ustrDbGuid.Buffer = &pValue->Name[0];
ustrDbGuid.MaximumLength =
ustrDbGuid.Length = (USHORT)pValue->NameLength;
Status = SdbpFindCharInUnicodeString(RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END,
&ustrDbGuid,
&ustrCharDot,
&uPrefix);
if (NT_SUCCESS(Status)) {
ustrDbGuid.Length = uPrefix;
}
//
// Convert to guid
//
Status = RtlGUIDFromString(&ustrDbGuid, &guidDB);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning, "SdbpEnumUserSdb",
"Failed to convert db name \"%s\" to guid Status 0x%lx\n",
ustrDbGuid.Buffer, Status));
continue; // We have failed to convert, skip and do the next
}
//
// Data may not be aligned, we store here timestamp
//
pData = (PBYTE)pValue + pValue->DataOffset;
//
// Check out value type
//
switch (pValue->Type) {
case REG_BINARY:
//
// The value is likely a timestamp
//
if (pValue->DataLength < sizeof(liTimeStamp.QuadPart)) {
DBGPRINT((sdlError,
"SdbpEnumUserSdb",
"Data length (0x%lx) does not match timestamp length for index 0x%lx\n",
pValue->DataLength,
dwIndexValue));
liTimeStamp.QuadPart = 0;
} else {
RtlCopyMemory(&liTimeStamp.QuadPart, (LPCVOID)pData, sizeof(liTimeStamp.QuadPart));
}
break;
case REG_QWORD:
//
// Naturally supported type, not aligned though
//
liTimeStamp.QuadPart = *(PULONGLONG UNALIGNED)pData;
break;
case REG_SZ:
//
// Hack: in case we need to enforce a particular order on some odd entry -- we
// use this hack
//
liTimeStamp.QuadPart = 0;
if (pValue->DataLength > 0) {
ustrValue.Buffer = (WCHAR*)pData;
ustrValue.Length = (USHORT)pValue->DataLength - sizeof(UNICODE_NULL);
ustrValue.MaximumLength = (USHORT)pValue->DataLength;
Status = RtlUnicodeStringToInteger(&ustrValue, 0, &liTimeStamp.LowPart);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpEnumUserSdb",
"Bad value for \"%s\" -> \"%s\" for index 0x%lx\n",
pValue->Name,
(LPCWSTR)pData,
dwIndexValue));
}
}
break;
default:
//
// Error case
//
DBGPRINT((sdlError,
"SdbpEnumUserSdb",
"Bad value type 0x%lx for index 0x%lx\n",
pValue->Type,
dwIndexValue));
Status = STATUS_INVALID_PARAMETER; // bugbug
break;
}
//
// Check the status
//
if (!NT_SUCCESS(Status)) {
continue;
}
//
// Fill-in this entry
//
pEntry = &pLookup->rgEntries[dwIndexEntries];
++dwIndexEntries;
RtlCopyMemory(&pEntry->guidDB, &guidDB, sizeof(GUID));
pEntry->liTimeStamp.QuadPart = liTimeStamp.QuadPart;
}
//
// After this, we are basically ready to lookup entries in sdbs
//
pLookup->dwCount = dwIndexEntries; // adjust count based on actually filled-in entries
if (dwIndexEntries > 1) {
//
// Optimization: only sort if more than one entry.
//
qsort((void*)&pLookup->rgEntries[0],
(size_t)pLookup->dwCount,
(size_t)sizeof(USERSDBLOOKUPENTRY),
(PFNQSORTCOMPARE)SdbpUserSDBLookupCompareEntries);
}
if (ppSdbLookup) {
*ppSdbLookup = pLookup;
}
bSuccess = TRUE;
cleanup:
if (KeyHandle) {
NtClose(KeyHandle);
}
if (!bSuccess && pLookup != NULL) {
RemoveLookup(pSdbContext, pLookup);
}
return bSuccess;
}
BOOL
SdbGetNthUserSdb(
IN HSDB hSDB,
IN LPCWSTR wszItemName, // item name (foo.exe or layer name)
IN BOOL bLayer,
IN OUT LPDWORD pdwIndex, // (0-based)
OUT GUID* pGuidDB
)
{
PSDBCONTEXT pSdbContext = (PSDBCONTEXT)hSDB;
PUSERSDBLOOKUP pLookup = NULL;
BOOL bSuccess = FALSE;
DWORD nIndex = *pdwIndex;
//
// Context already may have a user sdb cache -- do not touch it
//
if (nIndex == 0) {
//
// The first call, we have to init our system
//
if (!SdbpEnumUserSdb(pSdbContext, wszItemName, bLayer, &pLookup)) {
goto cleanup; // no custom sdb will be accessible
}
} else {
pLookup = SdbpFindSDBLookupEntry(pSdbContext, wszItemName, bLayer);
}
if (pLookup == NULL || nIndex >= pLookup->dwCount) {
return FALSE;
}
RtlCopyMemory(pGuidDB, &pLookup->rgEntries[nIndex].guidDB, sizeof(*pGuidDB));
++nIndex;
bSuccess = TRUE;
*pdwIndex = nIndex;
cleanup:
return bSuccess;
}
#ifndef WIN32U_MODE
BOOL
SDBAPI
SdbpGetLongPathName(
IN LPCWSTR pwszPath,
OUT PRTL_UNICODE_STRING_BUFFER pBuffer
)
{
DWORD dwBufferSize;
NTSTATUS Status;
RtlSyncStringToBuffer(pBuffer);
dwBufferSize = GetLongPathNameW(pwszPath,
pBuffer->String.Buffer,
RTL_STRING_GET_MAX_LENGTH_CHARS(&pBuffer->String));
if (!dwBufferSize) {
DBGPRINT((sdlError,
"SdbpGetLongPathName",
"Failed to convert short path to long path error 0x%lx\n",
GetLastError()));
return FALSE;
}
if (dwBufferSize < RTL_STRING_GET_MAX_LENGTH_CHARS(&pBuffer->String)) {
goto Done;
}
Status = RtlEnsureUnicodeStringBufferSizeChars(pBuffer, dwBufferSize);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpGetLongPathName",
"Failed to obtain sufficient buffer for long path (0x%lx chars) status 0x%lx\n",
dwBufferSize,
Status));
return FALSE;
}
dwBufferSize = GetLongPathNameW(pwszPath,
pBuffer->String.Buffer,
RTL_STRING_GET_MAX_LENGTH_CHARS(&pBuffer->String));
if (!dwBufferSize || dwBufferSize > RTL_STRING_GET_MAX_LENGTH_CHARS(&pBuffer->String)) {
DBGPRINT((sdlError,
"SdbpGetLongPathName",
"Failed to convert short path to long path (0x%lx chars) error 0x%lx\n",
dwBufferSize,
GetLastError()));
return FALSE;
}
Done:
pBuffer->String.Length = (USHORT)dwBufferSize;
return TRUE;
}
void
SdbpGetPermLayersInternal(
IN PUNICODE_STRING pstrExePath,
OUT LPWSTR wszLayers, // output receives layers string if success
IN OUT LPDWORD pdwBytes, // pointer to the size of wszLayers buffer
IN BOOL bMachine
)
{
UNICODE_STRING strKeyPath = { 0 };
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE KeyHandle;
ULONG KeyValueBuffer[256];
ULONG KeyValueLength;
NTSTATUS Status;
DWORD dwBytes = *pdwBytes;
PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
*pdwBytes = 0;
if (bMachine) {
//
// Build the machine path
//
if (!SdbpBuildMachineKeyPath(APPCOMPAT_PERM_LAYER_PATH, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbpGetPermLayersInternal",
"Failed to format machine key path for \"%S\"\n",
APPCOMPAT_PERM_LAYER_PATH));
goto out;
}
} else {
if (!SdbpBuildUserKeyPath(APPCOMPAT_PERM_LAYER_PATH, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbpGetPermLayersInternal",
"Failed to format user key path for \"%S\"\n",
APPCOMPAT_PERM_LAYER_PATH));
goto out;
}
}
InitializeObjectAttributes(&ObjectAttributes,
&strKeyPath,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle, GENERIC_READ|SdbpGetWow64Flag(), &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlInfo,
"SdbpGetPermLayersInternal",
"Failed to open Key \"%S\" Status 0x%x\n",
strKeyPath.Buffer,
Status));
goto out;
}
KeyValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
Status = NtQueryValueKey(KeyHandle,
pstrExePath,
KeyValuePartialInformation,
KeyValueInformation,
sizeof(KeyValueBuffer),
&KeyValueLength);
NtClose(KeyHandle);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlInfo,
"SdbpGetPermLayersInternal",
"Failed to read value info from Key \"%S\" Status 0x%x\n",
strKeyPath.Buffer,
Status));
goto out;
}
//
// Check for the value type.
//
if (KeyValueInformation->Type != REG_SZ) {
DBGPRINT((sdlError,
"SdbpGetPermLayersInternal",
"Unexpected value type 0x%x for Key \"%S\".\n",
KeyValueInformation->Type,
strKeyPath.Buffer));
goto out;
}
if (wszLayers == NULL || KeyValueInformation->DataLength > dwBytes) {
DBGPRINT((sdlError,
"SdbpGetPermLayersInternal",
"Value length %d too long for key \"%S\".\n",
KeyValueInformation->DataLength,
strKeyPath.Buffer));
*pdwBytes = KeyValueInformation->DataLength;
goto out;
}
RtlMoveMemory(wszLayers, KeyValueInformation->Data, KeyValueInformation->DataLength);
*pdwBytes = KeyValueInformation->DataLength;
out:
if (strKeyPath.Buffer != NULL) {
SdbFree(strKeyPath.Buffer);
}
}
BOOL
SdbGetPermLayerKeys(
IN LPCWSTR pwszPath, // exe path
OUT LPWSTR pwszLayers, // output receives layers string if success
IN LPDWORD pdwBytes, // pointer to the size of wszLayers buffer
IN DWORD dwFlags // per machine, per user flags
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Retrieves layers string associated with a given exe.
wszLayers may be NULL. In that case pdwBytes will receive necessary
size if the size provided in pdwBytes is not sufficient. The function
will return TRUE and pdwBytes will contain the necessary size.
--*/
{
UNICODE_STRING ustrPath;
BOOL bRet = FALSE;
WCHAR wszSignPath[MAX_PATH];
LPCWSTR pwszNewPath;
UCHAR PathBuffer[MAX_PATH * 2];
DWORD dwBytesMachine, dwBytesUser;
RTL_UNICODE_STRING_BUFFER LongPath;
RtlInitUnicodeStringBuffer(&LongPath, PathBuffer, sizeof(PathBuffer));
if (!pwszPath || !pdwBytes) {
DBGPRINT((sdlError,
"SdbGetPermLayerKeys",
"NULL parameter passed for wszPath or pdwBytes.\n"));
goto out;
}
if (!SdbpGetLongPathName(pwszPath, &LongPath)) {
goto out;
}
pwszPath = LongPath.String.Buffer;
if (SdbpIsPathOnCdRom(pwszPath)) {
SdbpBuildSignature(pwszPath, wszSignPath);
pwszNewPath = wszSignPath;
} else {
pwszNewPath = pwszPath;
}
RtlInitUnicodeString(&ustrPath, pwszNewPath);
dwBytesMachine = 0;
dwBytesUser = 0;
if (dwFlags & GPLK_MACHINE) {
dwBytesMachine = *pdwBytes;
SdbpGetPermLayersInternal(&ustrPath, pwszLayers, &dwBytesMachine, TRUE);
}
if (dwFlags & GPLK_USER) {
if (dwBytesMachine != 0) {
if (pwszLayers != NULL) {
pwszLayers += (dwBytesMachine / sizeof(TCHAR) - 1);
*pwszLayers++ = TEXT(' ');
}
dwBytesMachine += sizeof(TCHAR);
}
if (pwszLayers != NULL) {
dwBytesUser = *pdwBytes - dwBytesMachine;
}
SdbpGetPermLayersInternal(&ustrPath, pwszLayers, &dwBytesUser, FALSE);
if (dwBytesUser == 0 && dwBytesMachine != 0) {
dwBytesMachine -= sizeof(TCHAR);
if (pwszLayers != NULL) {
*(--pwszLayers) = 0;
}
}
}
if (pwszLayers != NULL) {
if (*pdwBytes >= dwBytesMachine + dwBytesUser) {
bRet = TRUE;
}
} else {
bRet = TRUE;
}
*pdwBytes = dwBytesMachine + dwBytesUser;
if (*pdwBytes == 0) {
bRet = FALSE;
}
out:
RtlFreeUnicodeStringBuffer(&LongPath);
return bRet;
}
#else // WIN32U_MODE case, stub the perm layer api
BOOL
SdbGetPermLayerKeys(
IN LPCTSTR szPath,
OUT LPTSTR szLayers,
IN LPDWORD pdwBytes,
IN DWORD dwFlags
)
{
return FALSE;
}
#endif // WIN32U_MODE
HANDLE
SdbpCreateKeyPath(
LPCWSTR pwszPath,
BOOL bMachine
)
/*++
Return: The handle to the registry key created.
Desc: Given a path to the key relative to HKEY_CURRENT_USER open/create
the key returns the handle to the key or NULL on failure.
--*/
{
UNICODE_STRING strKeyPath = { 0 };
HANDLE KeyHandle = NULL;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
ULONG CreateDisposition;
if (bMachine) {
if (!SdbpBuildMachineKeyPath(pwszPath, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbCreateKeyPath",
"Failed to format machine key path for \"%s\"\n",
pwszPath));
goto out;
}
} else {
if (!SdbpBuildUserKeyPath(pwszPath, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbCreateKeyPath",
"Failed to format user key path for \"%s\"\n",
pwszPath));
goto out;
}
}
InitializeObjectAttributes(&ObjectAttributes,
&strKeyPath,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtCreateKey(&KeyHandle,
STANDARD_RIGHTS_WRITE |
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS |
KEY_SET_VALUE |
KEY_CREATE_SUB_KEY|
SdbpGetWow64Flag(),
&ObjectAttributes,
0,
NULL,
REG_OPTION_NON_VOLATILE,
&CreateDisposition);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbCreateKeyPath",
"NtCreateKey failed for \"%s\" Status 0x%x\n",
pwszPath,
Status));
KeyHandle = NULL;
goto out;
}
out:
if (strKeyPath.Buffer != NULL) {
SdbFree(strKeyPath.Buffer);
}
return KeyHandle;
}
#ifndef WIN32U_MODE
BOOL
SdbSetPermLayerKeys(
IN LPCWSTR wszPath, // application path
IN LPCWSTR wszLayers, // layers to associate with this application
IN BOOL bMachine // TRUE if the layers should be set per machine
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Associates wszLayers string with application wszPath.
--*/
{
UNICODE_STRING ustrPath;
NTSTATUS Status;
HANDLE KeyHandle;
BOOL bRet = FALSE;
WCHAR wszSignPath[MAX_PATH];
LPCWSTR pwszPath;
RTL_UNICODE_STRING_BUFFER LongPath;
UCHAR PathBuffer[MAX_PATH * 2];
if (!wszLayers || !wszLayers[0]) {
//
// They passed in an empty string -- delete the layer keys
//
return SdbDeletePermLayerKeys(wszPath, bMachine);
}
RtlInitUnicodeStringBuffer(&LongPath, PathBuffer, sizeof(PathBuffer));
if (!SdbpGetLongPathName(wszPath, &LongPath)) {
goto out;
}
wszPath = LongPath.String.Buffer;
if (SdbpIsPathOnCdRom(wszPath)) {
SdbpBuildSignature(wszPath, wszSignPath);
pwszPath = wszSignPath;
} else {
pwszPath = wszPath;
}
RtlInitUnicodeString(&ustrPath, pwszPath);
KeyHandle = SdbpCreateKeyPath(APPCOMPAT_KEY_PATH_NT, bMachine);
if (KeyHandle == NULL) {
DBGPRINT((sdlError,
"SdbSetPermLayerKeys",
"Failed to create user key path for \"%s\"\n",
APPCOMPAT_KEY_PATH_NT));
goto out;
}
NtClose(KeyHandle);
KeyHandle = SdbpCreateKeyPath(APPCOMPAT_PERM_LAYER_PATH, bMachine);
if (KeyHandle == NULL) {
DBGPRINT((sdlError,
"SdbSetPermLayerKeys",
"Failed to create user key path \"%s\"\n",
APPCOMPAT_PERM_LAYER_PATH));
goto out;
}
Status = NtSetValueKey(KeyHandle,
&ustrPath,
0,
REG_SZ,
(PVOID)wszLayers,
(wcslen(wszLayers) + 1) * sizeof(WCHAR));
NtClose(KeyHandle);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbSetPermLayerKeys",
"Failed NtSetValueKey status 0x%x\n",
Status));
goto out;
}
bRet = TRUE;
out:
RtlFreeUnicodeStringBuffer(&LongPath);
return bRet;
}
BOOL
SdbDeletePermLayerKeys(
IN LPCWSTR wszPath,
IN BOOL bMachine
)
/*++
Return: TRUE if success
Desc: This function is used to disable permanent layer storage entry
for the application.
--*/
{
UNICODE_STRING strKeyPath = { 0 };
UNICODE_STRING ustrPath;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE KeyHandle;
BOOL bRet = FALSE;
WCHAR wszSignPath[MAX_PATH];
LPCWSTR pwszPath;
PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
RTL_UNICODE_STRING_BUFFER LongPath;
UCHAR PathBuffer[MAX_PATH * 2];
RtlInitUnicodeStringBuffer(&LongPath, PathBuffer, sizeof(PathBuffer));
if (!SdbpGetLongPathName(wszPath, &LongPath)) {
goto out;
}
wszPath = LongPath.String.Buffer;
if (SdbpIsPathOnCdRom(wszPath)) {
SdbpBuildSignature(wszPath, wszSignPath);
pwszPath = wszSignPath;
} else {
pwszPath = wszPath;
}
RtlInitUnicodeString(&ustrPath, pwszPath);
if (bMachine) {
if (!SdbpBuildMachineKeyPath(APPCOMPAT_PERM_LAYER_PATH, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbDeletePermLayerKeys",
"Failed to format machine key path for \"%S\"\n",
APPCOMPAT_PERM_LAYER_PATH));
goto out;
}
} else {
if (!SdbpBuildUserKeyPath(APPCOMPAT_PERM_LAYER_PATH, &strKeyPath)) {
DBGPRINT((sdlError,
"SdbDeletePermLayerKeys",
"Failed to format user key path for \"%S\"\n",
APPCOMPAT_PERM_LAYER_PATH));
goto out;
}
}
InitializeObjectAttributes(&ObjectAttributes,
&strKeyPath,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle,
KEY_WRITE|SdbpGetWow64Flag(),
&ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlInfo,
"SdbDeletePermLayerKeys",
"Failed to open Key for \"%S\" Status 0x%x\n",
strKeyPath.Buffer,
Status));
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
bRet = TRUE;
}
goto out;
}
Status = NtDeleteValueKey(KeyHandle,
&ustrPath);
NtClose(KeyHandle);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlInfo,
"SdbDeletePermLayerKeys",
"Failed to delete value from Key \"%S\" Status 0x%x\n",
strKeyPath.Buffer,
Status));
if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
bRet = TRUE;
}
goto out;
}
bRet = TRUE;
out:
if (strKeyPath.Buffer != NULL) {
SdbFree(strKeyPath.Buffer);
}
RtlFreeUnicodeStringBuffer(&LongPath);
return bRet;
}
#endif // WIN32U_MODE
BOOL
SdbSetEntryFlags(
IN GUID* pGuidID,
IN DWORD dwFlags
)
/*++
Return: TRUE if success
Desc: This function is used to disable apphelp or shim entries.
--*/
{
UNICODE_STRING ustrExeID = { 0 };
NTSTATUS Status;
HANDLE KeyHandle;
BOOL bReturn = FALSE;
Status = GUID_TO_UNICODE_STRING(pGuidID, &ustrExeID);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbSetEntryFlags",
"Failed to convert GUID to string 0x%x\n",
Status));
goto out;
}
KeyHandle = SdbpCreateKeyPath(APPCOMPAT_KEY_PATH_NT, FALSE);
if (KeyHandle == NULL) {
DBGPRINT((sdlError,
"SdbSetEntryFlags",
"Failed to create user key path for \"%s\"\n",
APPCOMPAT_KEY_PATH_NT));
goto out;
}
Status = NtSetValueKey(KeyHandle,
&ustrExeID,
0,
REG_DWORD,
&dwFlags,
sizeof(DWORD));
NtClose(KeyHandle);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbSetEntryFlags",
"Failed NtSetValueKey status 0x%x\n",
Status));
goto out;
}
bReturn = TRUE;
out:
FREE_GUID_STRING(&ustrExeID);
return bReturn;
}
BOOL
SdbpGetLongFileName(
IN LPCWSTR szFullPath, // a full UNC or DOS path & filename, "c:\foo\mylong~1.ext"
OUT LPWSTR szLongFileName // the long filename portion "mylongfilename.ext"
)
/*++
Return: TRUE if successful, FALSE otherwise.
Desc: Retrieves the long filename (without the path) of a potentially
short full-path filename.
--*/
{
NTSTATUS status;
BOOL bSuccess = FALSE;
UNICODE_STRING FileName;
UNICODE_STRING PathName;
OBJECT_ATTRIBUTES ObjPathName;
IO_STATUS_BLOCK IoStatusBlock;
HANDLE hDirectoryHandle = NULL;
PFILE_BOTH_DIR_INFORMATION DirectoryInfo;
struct SEARCH_BUFFER {
FILE_BOTH_DIR_INFORMATION DirInfo;
WCHAR Names[MAX_PATH-1];
} Buffer;
PathName.Buffer = NULL;
if (!RtlDosPathNameToNtPathName_U(szFullPath,
&PathName,
&FileName.Buffer,
NULL)) {
PathName.Buffer = NULL;
DBGPRINT((sdlError,
"SdbpGetLongFileName",
"Failed to get NT path name for \"%s\"\n",
szFullPath));
goto out;
}
if (FileName.Buffer == NULL) {
DBGPRINT((sdlError,
"SdbpGetLongFileName",
"Filename buffer is NULL for \"%s\"\n",
szFullPath));
goto out;
}
FileName.Length = PathName.Length -
(USHORT)((ULONG_PTR)FileName.Buffer - (ULONG_PTR)PathName.Buffer);
FileName.MaximumLength = FileName.Length;
PathName.Length = (USHORT)((ULONG_PTR)FileName.Buffer - (ULONG_PTR)PathName.Buffer);
PathName.MaximumLength = PathName.Length;
InitializeObjectAttributes(&ObjPathName,
&PathName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = NtOpenFile(&hDirectoryHandle,
FILE_LIST_DIRECTORY | SYNCHRONIZE,
&ObjPathName,
&IoStatusBlock,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_DIRECTORY_FILE |
FILE_SYNCHRONOUS_IO_NONALERT |
FILE_OPEN_FOR_BACKUP_INTENT);
if (STATUS_SUCCESS != status) {
DBGPRINT((sdlError,
"SdbpGetLongFileName",
"Failed to open directory file. Status 0x%x\n",
status));
goto out;
}
DirectoryInfo = &(Buffer.DirInfo);
status = NtQueryDirectoryFile(hDirectoryHandle,
NULL,
NULL,
NULL,
&IoStatusBlock,
DirectoryInfo,
sizeof(Buffer),
FileBothDirectoryInformation,
TRUE,
&FileName,
FALSE);
if (STATUS_SUCCESS != status) {
DBGPRINT((sdlError,
"SdbpGetLongFileName",
"NtQueryDirectoryFile Failed 0x%x\n",
status));
goto out;
}
if (DirectoryInfo->FileNameLength > MAX_PATH - 2) {
DBGPRINT((sdlError,
"SdbpGetLongFileName",
"File name longer than MAX_PATH - 2\n"));
goto out;
}
wcsncpy(szLongFileName, DirectoryInfo->FileName,
DirectoryInfo->FileNameLength/sizeof(WCHAR));
szLongFileName[DirectoryInfo->FileNameLength / sizeof(WCHAR)] = L'\0';
bSuccess = TRUE;
out:
if (PathName.Buffer) {
RtlFreeHeap(RtlProcessHeap(), 0, PathName.Buffer);
}
if (hDirectoryHandle) {
NtClose(hDirectoryHandle);
}
return bSuccess;
}
void
SdbpGetWinDir(
OUT LPWSTR pwszDir
)
/*++
Return: void.
Desc: Retrieves the system windows directory.
--*/
{
wcscpy(pwszDir, USER_SHARED_DATA->NtSystemRoot);
}
void
SdbpGetAppPatchDir(
OUT LPWSTR szAppPatchPath
)
/*++
Return: void.
Desc: Retrieves the %windir%\AppPatch directory.
--*/
{
int nLen;
wcscpy(szAppPatchPath, USER_SHARED_DATA->NtSystemRoot);
nLen = wcslen(szAppPatchPath);
if (nLen > 0 && L'\\' == szAppPatchPath[nLen-1]) {
szAppPatchPath[nLen-1] = L'\0';
}
wcscat(szAppPatchPath, L"\\AppPatch");
}
void
SdbpGetCurrentTime(
OUT LPSYSTEMTIME lpTime
)
/*++
Return: void.
Desc: Retrieves the current local time.
--*/
{
LARGE_INTEGER LocalTime;
LARGE_INTEGER SystemTime;
LARGE_INTEGER Bias;
TIME_FIELDS TimeFields;
volatile KSYSTEM_TIME* pRealBias = &(USER_SHARED_DATA->TimeZoneBias);
//
// Read system time from shared region.
//
do {
SystemTime.HighPart = USER_SHARED_DATA->SystemTime.High1Time;
SystemTime.LowPart = USER_SHARED_DATA->SystemTime.LowPart;
} while (SystemTime.HighPart != USER_SHARED_DATA->SystemTime.High2Time);
//
// Read time zone bias from shared region.
// If it's terminal server session use client bias.
//
do {
Bias.HighPart = pRealBias->High1Time;
Bias.LowPart = pRealBias->LowPart;
} while (Bias.HighPart != pRealBias->High2Time);
LocalTime.QuadPart = SystemTime.QuadPart - Bias.QuadPart;
RtlTimeToTimeFields(&LocalTime, &TimeFields);
lpTime->wYear = TimeFields.Year;
lpTime->wMonth = TimeFields.Month;
lpTime->wDayOfWeek = TimeFields.Weekday;
lpTime->wDay = TimeFields.Day;
lpTime->wHour = TimeFields.Hour;
lpTime->wMinute = TimeFields.Minute;
lpTime->wSecond = TimeFields.Second;
lpTime->wMilliseconds = TimeFields.Milliseconds;
}
NTSTATUS
SdbpGetEnvVar(
IN LPCWSTR pEnvironment,
IN LPCWSTR pszVariableName,
OUT LPWSTR pszVariableValue,
OUT LPDWORD pdwBufferSize
)
/*++
Return:
Desc: Retrieves the value of the specified environment variable.
--*/
{
NTSTATUS Status = STATUS_VARIABLE_NOT_FOUND;
UNICODE_STRING ustrVariableName;
UNICODE_STRING ustrVariableValue;
DWORD dwBufferSize = 0;
if (pdwBufferSize && pszVariableValue) {
dwBufferSize = *pdwBufferSize;
}
RtlInitUnicodeString(&ustrVariableName, pszVariableName);
ustrVariableValue.Length = 0;
ustrVariableValue.MaximumLength = (USHORT)dwBufferSize * sizeof(WCHAR);
ustrVariableValue.Buffer = (WCHAR*)pszVariableValue;
Status = RtlQueryEnvironmentVariable_U((LPVOID)pEnvironment,
&ustrVariableName,
&ustrVariableValue);
if (pdwBufferSize) {
*pdwBufferSize = (DWORD)ustrVariableValue.Length / sizeof(WCHAR);
}
return Status;
}
BOOL
SdbpMapFile(
IN HANDLE hFile, // handle to the open file (this is done previously)
OUT PIMAGEFILEDATA pImageData
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Maps a file into memory.
--*/
{
NTSTATUS Status;
HANDLE hSection = NULL;
SIZE_T ViewSize = 0;
PVOID pBase = NULL;
IO_STATUS_BLOCK IoStatusBlock;
FILE_STANDARD_INFORMATION StandardInfo;
if (hFile == INVALID_HANDLE_VALUE) {
DBGPRINT((sdlError, "SdbpMapFile", "Invalid argument\n"));
return FALSE;
}
//
// Query the file's size.
//
Status = NtQueryInformationFile(hFile,
&IoStatusBlock,
&StandardInfo,
sizeof(StandardInfo),
FileStandardInformation);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpMapFile",
"NtQueryInformationFile (EOF) failed Status = 0x%x\n",
Status));
return FALSE;
}
//
// Create a view of the file.
//
Status = NtCreateSection(&hSection,
SECTION_MAP_READ,
NULL,
0,
PAGE_READONLY,
SEC_COMMIT,
hFile);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpMapFile",
"NtCreateSection failed Status 0x%x\n",
Status));
//
// Can't create section, thus no way to map the file.
//
return FALSE;
}
Status = NtMapViewOfSection(hSection,
NtCurrentProcess(),
&pBase,
0,
0,
NULL,
&ViewSize,
ViewUnmap,
0,
PAGE_READONLY);
if (!NT_SUCCESS(Status)) {
NtClose(hSection);
DBGPRINT((sdlError,
"SdbpMapFile",
"NtMapViewOfSection failed Status 0x%x\n",
Status));
return FALSE;
}
//
// We have made it. The file is mapped.
//
pImageData->hFile = hFile;
pImageData->hSection = hSection;
pImageData->pBase = pBase;
pImageData->ViewSize = ViewSize;
pImageData->FileSize = StandardInfo.EndOfFile.QuadPart;
return TRUE;
}
BOOL
SdbpUnmapFile(
IN PIMAGEFILEDATA pImageData
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Unmaps a file from memory.
--*/
{
NTSTATUS Status;
BOOL bReturn = TRUE;
if (pImageData->pBase != NULL) {
Status = NtUnmapViewOfSection(NtCurrentProcess(), pImageData->pBase);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpUnmapFile",
"NtUnmapViewOfSection failed Status 0x%x\n",
Status));
bReturn = FALSE;
}
pImageData->pBase = NULL;
}
if (pImageData->hSection) {
NtClose(pImageData->hSection);
pImageData->hSection = NULL;
}
pImageData->hFile = INVALID_HANDLE_VALUE; // hFile is not owned by us
return bReturn;
}
#ifndef _WIN64
void
SdbResetStackOverflow(
void
)
/*++
Return: void.
Desc: This function sets the guard page to its position before the
stack overflow.
This is a copy of the following CRT routine:
void _resetstkoflw(void) - Recovers from Stack Overflow
--*/
{
LPBYTE pStack, pGuard, pStackBase, pCommitBase;
MEMORY_BASIC_INFORMATION mbi;
SYSTEM_BASIC_INFORMATION BasicInfo;
SYSTEM_INFO si;
DWORD PageSize;
NTSTATUS Status;
SIZE_T ReturnLength;
DWORD OldProtect;
SIZE_T RegionSize;
//
// Use alloca() to get the current stack pointer
// the call below DOES NOT fail
//
__try {
pStack = _alloca(1);
} __except(GetExceptionCode() == EXCEPTION_STACK_OVERFLOW ?
EXCEPTION_EXECUTE_HANDLER:EXCEPTION_CONTINUE_SEARCH) {
pStack = (LPBYTE)&pStack; // hack: we just grab the address of our internal variable
}
//
// Find the base of the stack.
//
Status = NtQueryVirtualMemory(NtCurrentProcess(),
pStack,
MemoryBasicInformation,
&mbi,
sizeof(mbi),
&ReturnLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtQueryVirtualMemory failed on stack 0x%x Status 0x%x\n",
pStack,
Status));
return;
}
pStackBase = mbi.AllocationBase;
Status = NtQueryVirtualMemory(NtCurrentProcess(),
pStackBase,
MemoryBasicInformation,
&mbi,
sizeof(mbi),
&ReturnLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtQueryVirtualMemory failed on stack base 0x%x Status 0x%x\n",
pStackBase,
Status));
return;
}
if (mbi.State & MEM_RESERVE) {
pCommitBase = (LPBYTE)mbi.AllocationBase + mbi.RegionSize;
Status = NtQueryVirtualMemory(NtCurrentProcess(),
pCommitBase,
MemoryBasicInformation,
&mbi,
sizeof(mbi),
&ReturnLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtQueryVirtualMemory failed on stack commit base 0x%x Status 0x%x\n",
pCommitBase,
Status));
return;
}
} else {
pCommitBase = pStackBase;
}
//
// Find the page size.
//
Status = NtQuerySystemInformation(SystemBasicInformation,
&BasicInfo,
sizeof(BasicInfo),
NULL);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtQuerySystemInformation failed Status 0x%x\n",
Status));
return;
}
PageSize = BasicInfo.PageSize;
//
// Find the page just below where stack pointer currently points.
//
pGuard = (LPBYTE)(((DWORD_PTR)pStack & ~(DWORD_PTR)(PageSize -1)) - PageSize);
if (pGuard < pStackBase) {
//
// We can't save this.
//
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"Bad guard page 0x%x base 0x%x\n",
pGuard,
pStackBase));
return;
}
if (pGuard > pStackBase) {
RegionSize = pGuard - pStackBase;
Status = NtFreeVirtualMemory(NtCurrentProcess(),
&pStackBase,
&RegionSize,
MEM_DECOMMIT);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtFreeVirtualMemory on 0x%x failed Status 0x%x\n",
pStackBase,
Status));
}
}
Status = NtAllocateVirtualMemory(NtCurrentProcess(),
&pGuard,
0,
&PageSize,
MEM_COMMIT,
PAGE_READWRITE);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtAllocateVirtualMemory on 0x%x failed Status 0x%x\n",
pGuard,
Status));
return;
}
Status = NtProtectVirtualMemory(NtCurrentProcess(),
&pGuard,
&PageSize,
PAGE_READWRITE|PAGE_GUARD,
&OldProtect);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpResetStackOverflow",
"NtProtectVirtualMemory on 0x%x failed Status 0x%x\n",
pGuard,
Status));
}
}
#endif // _WIN64
BOOL
SdbpQueryFileDirectoryAttributes(
LPCWSTR FilePath,
PFILEDIRECTORYATTRIBUTES pFileDirectoryAttributes
)
/*++
Return: BUGBUG: ?
Desc: BUGBUG: ?
--*/
{
OBJECT_ATTRIBUTES DirObjectAttributes;
UNICODE_STRING FileName; // filename part
IO_STATUS_BLOCK IoStatusBlock;
HANDLE FileHandle = INVALID_HANDLE_VALUE;
UNICODE_STRING Path = { 0 }; // nt path name
struct tagDirectoryInformationBuffer { // directory information (see ntioapi)
FILE_DIRECTORY_INFORMATION DirInfo;
WCHAR name[MAX_PATH];
} DirectoryInformationBuf;
PFILE_DIRECTORY_INFORMATION pDirInfo = &DirectoryInformationBuf.DirInfo;
USHORT nPathLength;
int i;
NTSTATUS Status = STATUS_INVALID_PARAMETER;
BOOL bTranslationStatus;
RtlZeroMemory(pFileDirectoryAttributes, sizeof(*pFileDirectoryAttributes));
bTranslationStatus = RtlDosPathNameToNtPathName_U(FilePath,
&Path,
&FileName.Buffer,
NULL);
if (!bTranslationStatus) {
DBGPRINT((sdlError,
"SdbpGetFileDirectoryAttributes",
"RtlDosPathNameToNtPathName_U failed for \"%s\"\n",
FilePath));
assert(FALSE);
goto Fail;
}
if (FileName.Buffer == NULL) {
DBGPRINT((sdlError,
"SdbpGetFileDirectoryAttributes",
"RtlDosPathNameToNtPathName_U returned no filename for \"%s\"",
FilePath));
Status = STATUS_INVALID_PARAMETER;
goto Fail;
}
nPathLength = (USHORT)((ULONG_PTR)FileName.Buffer - (ULONG_PTR)Path.Buffer);
FileName.Length = Path.Length - nPathLength;
FileName.MaximumLength = FileName.Length;
//
// path length, adjust please -- chopping off trailing backslash
//
// BUGBUG: what am I suppose to understand from the above comment ?
//
Path.Length = nPathLength;
if (nPathLength > 2 * sizeof(WCHAR)) {
if (*(Path.Buffer + (nPathLength/sizeof(WCHAR)) - 2) != L':' &&
*(Path.Buffer + (nPathLength/sizeof(WCHAR)) - 1) == L'\\') {
Path.Length -= sizeof(WCHAR);
}
}
Path.MaximumLength = Path.Length;
InitializeObjectAttributes(&DirObjectAttributes,
&Path,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenFile(&FileHandle,
FILE_LIST_DIRECTORY | SYNCHRONIZE,
&DirObjectAttributes,
&IoStatusBlock,
FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_DIRECTORY_FILE|
FILE_SYNCHRONOUS_IO_NONALERT |
FILE_OPEN_FOR_BACKUP_INTENT);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpGetFileDirectoryAttributes",
"NtOpenFile Failed to open \"%s\", status 0x%x\n",
(int)Path.Length,
Path.Buffer,
Status));
goto Fail;
}
Status = NtQueryDirectoryFile(FileHandle,
NULL,
NULL,
NULL,
&IoStatusBlock,
pDirInfo,
sizeof(DirectoryInformationBuf),
FileDirectoryInformation,
TRUE,
&FileName,
FALSE);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpGetFileDirectoryAttributes",
"NtQueryDirectoryFile Failed to query \"%s\" for \"%s\" status 0x%x\n",
(int)Path.Length,
Path.Buffer,
(int)FileName.Length,
FileName.Buffer,
Status));
goto Fail;
}
pFileDirectoryAttributes->dwFlags |= FDA_FILESIZE;
pFileDirectoryAttributes->dwFileSizeHigh = pDirInfo->EndOfFile.HighPart;
pFileDirectoryAttributes->dwFileSizeLow = pDirInfo->EndOfFile.LowPart;
Fail:
if (Path.Buffer) {
RtlFreeHeap(RtlProcessHeap(), 0, Path.Buffer);
}
if (FileHandle != INVALID_HANDLE_VALUE) {
NtClose(FileHandle);
}
return NT_SUCCESS(Status);
}
LPWSTR
StringToUnicodeString(
IN LPCSTR pszSrc // pointer to the ANSI string to be converted
)
/*++
Return: A pointer to an allocated UNICODE string.
Desc: Converts an ANSI string to UNICODE.
--*/
{
NTSTATUS Status;
ANSI_STRING AnsiSrc;
UNICODE_STRING UnicodeDest = { 0 };
LPWSTR pwszUnicodeDest = NULL;
ULONG Length;
RtlInitString(&AnsiSrc, pszSrc);
Length = RtlAnsiStringToUnicodeSize(&AnsiSrc);
pwszUnicodeDest = (LPWSTR)SdbAlloc(Length);
if (pwszUnicodeDest == NULL) {
DBGPRINT((sdlWarning, "StringToUnicodeString", "Failed to allocate %d bytes.\n", Length));
return pwszUnicodeDest;
}
UnicodeDest.MaximumLength = (USHORT)Length;
UnicodeDest.Buffer = pwszUnicodeDest;
Status = RtlAnsiStringToUnicodeString(&UnicodeDest, &AnsiSrc, FALSE);
if (!NT_SUCCESS(Status)) {
SdbFree(pwszUnicodeDest);
pwszUnicodeDest = NULL;
DBGPRINT((sdlWarning,
"StringToUnicodeString",
"Failed to convert \"%s\" to UNICODE. Status 0x%x\n",
pszSrc,
Status));
}
return pwszUnicodeDest;
}
BOOL
SdbpGet16BitDescription(
OUT LPWSTR* ppszDescription,
IN PIMAGEFILEDATA pImageData
)
/*++
Return: TRUE on success, FALSE otherwise
Desc: This function retrieves 16-bit description from the
module identified by pImageData
--*/
{
BOOL bSuccess;
char szBuffer[256];
LPWSTR pwszDescription = NULL;
bSuccess = SdbpQuery16BitDescription(szBuffer, pImageData);
if (bSuccess) {
pwszDescription = StringToUnicodeString(szBuffer);
*ppszDescription = pwszDescription;
}
return (pwszDescription != NULL);
}
BOOL
SdbpGet16BitModuleName(
OUT LPWSTR* ppszModuleName,
IN PIMAGEFILEDATA pImageData
)
/*++
Return: TRUE on success, FALSE otherwise
Desc: Retrieves 16-bit module name from the image
identified by pImageData, then converts it to UNICODE
--*/
{
BOOL bSuccess;
char szBuffer[256]; // max possible length of a string is 256 (1-byte worth of length)
LPWSTR pwszModuleName = NULL;
bSuccess = SdbpQuery16BitModuleName(szBuffer, pImageData);
if (bSuccess) {
pwszModuleName = StringToUnicodeString(szBuffer);
*ppszModuleName = pwszModuleName;
}
return (pwszModuleName != NULL);
}
PVOID
SdbGetFileInfo(
IN HSDB hSDB,
IN LPCWSTR pwszFilePath,
IN HANDLE hFile, // OPTIONAL HANDLE to the file, not used here
IN LPVOID pImageBase,
IN DWORD dwImageSize, // ignored
IN BOOL bNoCache
)
/*++
Return: BUGBUG: ?
Desc: Create and link a new entry in a file attribute cache.
--*/
{
PSDBCONTEXT pContext = (PSDBCONTEXT)hSDB;
WCHAR* FullPath = NULL;
NTSTATUS Status;
PFILEINFO pFileInfo = NULL;
ULONG nBufferLength;
ULONG cch;
UNICODE_STRING FullPathU;
BOOL bFreeFullPath;
//
// Check hFile and/or pImageBase -- if these are supplied --
// we presume that the file exists and we do not touch it
//
if (hFile != INVALID_HANDLE_VALUE || pImageBase != NULL) {
FullPath = (LPWSTR)pwszFilePath; // we do not have to free it
cch = wcslen(FullPath) * sizeof(WCHAR);
nBufferLength = cch + sizeof(UNICODE_NULL);
bFreeFullPath = FALSE;
goto CreateFileInfo;
}
//
// See if we have info on this file. First we get the full path.
//
cch = RtlGetFullPathName_U(pwszFilePath,
0,
NULL,
NULL);
if (cch == 0) {
DBGPRINT((sdlError,
"SdbGetFileInfo",
"RtlGetFullPathName_U failed for \"%s\"\n",
pwszFilePath));
return pFileInfo;
}
//
// Now allocate that much.
//
nBufferLength = cch + sizeof(UNICODE_NULL);
STACK_ALLOC(FullPath, nBufferLength);
if (FullPath == NULL) {
DBGPRINT((sdlError,
"SdbGetFileInfo",
"Failed to allocate %d bytes for full path\n",
nBufferLength));
return pFileInfo;
}
bFreeFullPath = TRUE;
cch = RtlGetFullPathName_U(pwszFilePath,
nBufferLength,
FullPath,
NULL);
assert(cch <= nBufferLength);
if (cch > nBufferLength || cch == 0) {
DBGPRINT((sdlError,
"SdbGetFileInfo",
"RtlGetFullPathName_U failed for \"%s\"\n",
pwszFilePath));
goto Done;
}
CreateFileInfo:
if (!bNoCache) {
pFileInfo = FindFileInfo(pContext, FullPath);
}
if (pFileInfo == NULL) {
if (hFile != INVALID_HANDLE_VALUE || pImageBase != NULL ||
RtlDoesFileExists_U(FullPath)) {
//
// The path does exist. Create a record of this file path.
//
FullPathU.Buffer = FullPath;
FullPathU.Length = (USHORT)cch;
FullPathU.MaximumLength = (USHORT)nBufferLength;
pFileInfo = CreateFileInfo(pContext,
FullPathU.Buffer,
FullPathU.Length / sizeof(WCHAR),
hFile,
pImageBase,
dwImageSize,
bNoCache);
}
}
Done:
if (FullPath != NULL && bFreeFullPath) {
STACK_FREE(FullPath);
}
return (PVOID)pFileInfo;
}
static UNICODE_STRING g_ustrShimDbgLevelVar = RTL_CONSTANT_STRING(L"SHIM_DEBUG_LEVEL");
int
GetShimDbgLevel(
void
)
/*++
Return: The current debug level.
Desc: Checks the environment variable that controls the amount of
debug output.
--*/
{
UNICODE_STRING ShimDbgLevel;
INT iShimDebugLevel = 0;
NTSTATUS Status;
WCHAR Buffer[MAX_PATH];
ULONG ulValue;
ShimDbgLevel.Buffer = (PWCHAR)Buffer;
ShimDbgLevel.Length = 0;
ShimDbgLevel.MaximumLength = sizeof(Buffer);
Status = RtlQueryEnvironmentVariable_U(NULL,
&g_ustrShimDbgLevelVar,
&ShimDbgLevel);
if (NT_SUCCESS(Status)) {
//
// We have the debug level variable present. Parse it to see what
// is the value of this variable.
//
Status = RtlUnicodeStringToInteger(&ShimDbgLevel, 0, (PULONG)&ulValue);
if (NT_SUCCESS(Status)) {
iShimDebugLevel = (int)ulValue;
}
}
return iShimDebugLevel;
}
//
// Functions that deal with APPCOMPAT_EXE_DATA
//
//
// These two functions should be used when passing APPCOMPAT_EXE_DATA structure
// across the boundaries of CreateProcess. Before passing the struct it should
// be "denormalized"; after -- normalized.
//
#define APPCOMPAT_EXE_DATA_MAGIC 0xAC0DEDAB
BOOL
SdbPackAppCompatData(
IN HSDB hSDB,
IN PSDBQUERYRESULT pSdbQuery,
OUT PVOID* ppData, // app compat data package
OUT LPDWORD pdwSize // data size
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Packs the APPCOMPAT_EXE_DATA to be sent to the kernel in the context
of the process about to be started (and shimmed).
--*/
{
PSDBCONTEXT pSdbContext = (PSDBCONTEXT)hSDB;
DWORD cbData;
PAPPCOMPAT_EXE_DATA pData = NULL;
BOOL bReturn = FALSE;
BOOL bLocal;
assert(ppData != NULL);
assert(pdwSize != NULL);
if (pSdbQuery->atrExes[0] == TAGREF_NULL && pSdbQuery->atrLayers[0] == TAGREF_NULL) {
DBGPRINT((sdlError, "SdbPackAppCompatData", "Invalid arguments.\n"));
return FALSE;
}
cbData = sizeof(APPCOMPAT_EXE_DATA);
//
// Allocate memory. Use this form of allocation so we know that
// we can free it from CreateProcess.
//
pData = (PAPPCOMPAT_EXE_DATA)RtlAllocateHeap(RtlProcessHeap(),
HEAP_ZERO_MEMORY,
cbData);
if (pData == NULL) {
DBGPRINT((sdlError,
"SdbPackAppCompatData",
"Failed to allocate %d bytes.\n",
cbData));
return FALSE;
}
pData->cbSize = cbData;
pData->dwMagic = APPCOMPAT_EXE_DATA_MAGIC;
pData->dwFlags = pSdbQuery->dwFlags;
pData->trAppHelp = pSdbQuery->trAppHelp;
RtlCopyMemory(&pData->atrExes[0],
&pSdbQuery->atrExes[0],
sizeof(pSdbQuery->atrExes));
RtlCopyMemory(&pData->atrLayers[0],
&pSdbQuery->atrLayers[0],
sizeof(pSdbQuery->atrLayers));
wcscpy(pData->szShimEngine, L"ShimEng.dll");
//
// Store custom sdbs
//
pData->dwDatabaseMap = pSdbQuery->dwCustomSDBMap;
if (pData->dwDatabaseMap) {
RtlCopyMemory(&pData->rgGuidDB[0],
&pSdbQuery->rgGuidDB[0],
sizeof(pData->rgGuidDB));
}
DBGPRINT((sdlInfo|sdlLogPipe,
"SdbPackAppCompatData",
"\n\tdwFlags 0x%X\n"
"\tdwMagic 0x%X\n"
"\ttrExe 0x%X\n"
"\ttrLayer 0x%X\n",
hSDB,
pData->dwFlags,
pData->dwMagic,
pData->atrExes[0],
pData->atrLayers[0]));
//
// Dump all the relevant entries
//
if (SDBCONTEXT_IS_INSTRUMENTED(hSDB)) {
DWORD dwMask;
DWORD dwIndex;
WCHAR szGuid[64];
PDB pdb;
LPCWSTR pszDescription;
SDBDATABASEINFO DbInfo;
if (pSdbQuery->dwCustomSDBMap) {
DBGPRINT((sdlInfo|sdlLogPipe, "SdbPackAppcompatData", "Database List\n", hSDB));
for (dwIndex = 0; dwIndex < ARRAYSIZE(pSdbQuery->rgGuidDB); ++dwIndex) {
dwMask = (1UL << dwIndex);
if (!(pSdbQuery->dwCustomSDBMap & dwMask)) {
continue;
}
//
// Dump the guid
//
pszDescription = NULL;
pdb = SdbGetPDBFromGUID(hSDB, &pSdbQuery->rgGuidDB[dwIndex]);
if (pdb != NULL && SdbGetDatabaseInformation(pdb, &DbInfo)) {
pszDescription = DbInfo.pszDescription;
}
SdbGUIDToString(&pSdbQuery->rgGuidDB[dwIndex], szGuid);
DBGPRINT((sdlInfo|sdlLogPipe,
"SdbPackAppcompatData",
"0x%lx %s %s\n",
hSDB,
SDB_INDEX_TO_MASK(dwIndex),
szGuid,
(pszDescription ? pszDescription : L"")));
}
}
//
// Now dump all the matches
//
for (dwIndex = 0; dwIndex < ARRAYSIZE(pSdbQuery->atrExes); ++dwIndex) {
if (pSdbQuery->atrExes[dwIndex] == TAGREF_NULL) {
continue;
}
DBGPRINT((sdlInfo|sdlLogPipe,
"SdbPackAppcompatData",
"Exe 0x%.8lx\n",
hSDB,
pSdbQuery->atrExes[dwIndex]));
}
for (dwIndex = 0; dwIndex < ARRAYSIZE(pSdbQuery->atrLayers); ++dwIndex) {
if (pSdbQuery->atrLayers[dwIndex] == TAGREF_NULL) {
continue;
}
DBGPRINT((sdlInfo|sdlLogPipe,
"SdbPackAppcompatData",
"Layer 0x%.8lx\n",
hSDB,
pSdbQuery->atrLayers[dwIndex]));
}
}
*ppData = (PVOID)pData;
*pdwSize = cbData;
return TRUE;
}
BOOL
SdbUnpackAppCompatData(
IN HSDB hSDB,
IN LPCWSTR pwszExeName,
IN PVOID pAppCompatData,
OUT PSDBQUERYRESULT pSdbQuery
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Unpacks the APPCOMPAT_EXE_DATA to extract the TAGREFs to be used
for the EXE that just started. This function is called from
LdrpInitializeProcess (in ntdll).
--*/
{
PAPPCOMPAT_EXE_DATA pData = (PAPPCOMPAT_EXE_DATA)pAppCompatData;
PSDBCONTEXT pSdbContext = (PSDBCONTEXT)hSDB;
BOOL bLocal;
if (pData == NULL) {
DBGPRINT((sdlError, "SdbUnpackAppCompatData", "Invalid parameter\n"));
return FALSE;
}
if (pData->dwMagic != APPCOMPAT_EXE_DATA_MAGIC) {
DbgPrint("[SdbUnpackAppCompatData] Invalid magic 0x%x. Expected 0x%x\n",
pData->dwMagic,
APPCOMPAT_EXE_DATA_MAGIC);
return FALSE;
}
DBGPRINT((sdlInfo,
"SdbUnpackAppCompatData",
"Appcompat Data for \"%s\":\n"
"\tdwFlags 0x%X\n"
"\tdwMagic 0x%X\n"
"\ttrExe 0x%X\n"
"\ttrLayer 0x%X\n",
pwszExeName,
pData->dwFlags,
pData->dwMagic,
pData->atrExes[0],
pData->atrLayers[0]));
//
// We have no use for dwFlags so far.
//
//
// We should get rid of all the local sdbs in this context
//
if (pSdbContext->pdbLocal != NULL) {
SdbCloseLocalDatabase(hSDB);
}
RtlCopyMemory(&pSdbQuery->atrExes[0],
&pData->atrExes[0],
sizeof(pData->atrExes));
RtlCopyMemory(&pSdbQuery->atrLayers[0],
&pData->atrLayers[0],
sizeof(pData->atrLayers));
pSdbQuery->dwFlags = pData->dwFlags;
pSdbQuery->trAppHelp = pData->trAppHelp;
//
// See if we need to open local db
//
// We might need to be able to use local dbs --
// actual open on a local db will be performed by a tagref translation layer
//
if (pData->dwDatabaseMap) {
DWORD dwMask;
DWORD dwIndex;
PSDBENTRY pEntry;
DWORD dwCount = 2;
SdbpCleanupLocalDatabaseSupport(hSDB);
//
// Now introduce entries, one by one
//
for (dwIndex = 2; dwIndex < ARRAYSIZE(pSdbContext->rgSDB); ++dwIndex) {
dwMask = (1UL << dwIndex);
if (pData->dwDatabaseMap & dwMask) {
pEntry = SDBGETENTRY(hSDB, dwIndex);
pEntry->dwFlags = SDBENTRY_VALID_GUID;
pEntry->guidDB = pData->rgGuidDB[dwIndex];
dwCount = dwIndex;
}
}
pSdbContext->dwDatabaseMask |= (pData->dwDatabaseMap & SDB_CUSTOM_MASK);
}
return TRUE;
}
DWORD
SdbGetAppCompatDataSize(
IN PVOID pAppCompatData
)
/*++
Return: The size of the appcompat data.
Desc: Self explanatory.
--*/
{
PAPPCOMPAT_EXE_DATA pData = (PAPPCOMPAT_EXE_DATA)pAppCompatData;
if (pData == NULL) {
DBGPRINT((sdlError, "SdbGetAppCompatDataSize", "Invalid parameter\n"));
return 0;
}
if (pData->dwMagic != APPCOMPAT_EXE_DATA_MAGIC) {
DBGPRINT((sdlError,
"SdbGetAppCompatDataSize",
"Invalid magic 0x%x. Expected 0x%x\n",
pData->dwMagic,
APPCOMPAT_EXE_DATA_MAGIC));
return 0;
}
return pData->cbSize;
}
BOOL
SdbpWriteBitsToFile(
IN LPCTSTR pszFile,
IN PBYTE pBuffer,
IN DWORD dwSize
)
/*++
Return: TRUE on success, FALSE otherwise.
Desc: Self explanatory.
--*/
{
LPCWSTR pszFileU = (LPCWSTR)pszFile;
UNICODE_STRING strFilePath;
RTL_RELATIVE_NAME RelativeName;
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS status = STATUS_UNSUCCESSFUL;
HANDLE hFile = NULL;
IO_STATUS_BLOCK IoStatusBlock;
LARGE_INTEGER liOffset;
//
// Create the file.
//
RtlInitUnicodeString(&strFilePath, pszFileU);
if (!RtlDosPathNameToNtPathName_U(strFilePath.Buffer,
&strFilePath,
NULL,
&RelativeName)) {
DBGPRINT((sdlError,
"SdbpWriteBitsToFile",
"Failed to convert file name \"%s\" to NT path.\n",
pszFileU));
goto cleanup;
}
InitializeObjectAttributes(&ObjectAttributes,
&strFilePath,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = NtCreateFile(&hFile,
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE | FILE_READ_ATTRIBUTES,
&ObjectAttributes,
&IoStatusBlock,
0,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OVERWRITE_IF,
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
//
// RtlDosPathNameToNtPathName_U allocates memory for the
// unicode string. This is where we dump it.
//
RtlFreeUnicodeString(&strFilePath);
if (!NT_SUCCESS(status)) {
DBGPRINT((sdlError,
"SdbpWriteBitsToFile",
"Failed to create file \"%s\".\n",
pszFileU));
goto cleanup;
}
//
// ...and write the bits to disk
//
liOffset.LowPart = 0;
liOffset.HighPart = 0;
status = NtWriteFile(hFile,
NULL,
NULL,
NULL,
&IoStatusBlock,
(PVOID)pBuffer,
dwSize,
&liOffset,
NULL);
if (!NT_SUCCESS(status)) {
DBGPRINT((sdlError,
"SdbpWriteBitsToFile",
"Failed 0x%x to write file \"%s\" to disk.\n",
status,
pszFileU));
goto cleanup;
}
status = STATUS_SUCCESS;
cleanup:
if (hFile != NULL) {
NtClose(hFile);
}
return (status == STATUS_SUCCESS);
}
DWORD
SdbExpandEnvironmentStrings(
IN LPCWSTR lpSrc,
OUT LPWSTR lpDst,
IN DWORD nSize
)
{
NTSTATUS Status;
UNICODE_STRING Source;
UNICODE_STRING Destination;
ULONG Length;
DWORD iSize;
if (nSize > (MAXUSHORT >> 1) - 2) {
iSize = (MAXUSHORT >> 1) - 2;
} else {
iSize = nSize;
}
RtlInitUnicodeString(&Source, lpSrc);
Destination.Buffer = lpDst;
Destination.Length = 0;
Destination.MaximumLength = (USHORT)(iSize * sizeof( WCHAR ));
Length = 0;
Status = RtlExpandEnvironmentStrings_U(NULL,
&Source,
&Destination,
&Length);
if (NT_SUCCESS( Status ) || Status == STATUS_BUFFER_TOO_SMALL) {
return (Length / sizeof(WCHAR));
}
return 0;
}
BOOL
SDBAPI
SdbRegisterDatabaseEx(
IN LPCWSTR pszDatabasePath,
IN DWORD dwDatabaseType,
IN PULONGLONG pTimeStamp OPTIONAL
)
/*++
Registers any given database so that it is "known" to our database lookup apis
--*/
{
PSDBDATABASEINFO pDbInfo = NULL;
BOOL bReturn = FALSE;
UNICODE_STRING ustrPath;
UNICODE_STRING ustrFullPath = { 0 };
BOOL bFreeFullPath = FALSE;
BOOL bExpandSZ = FALSE;
UNICODE_STRING ustrKey;
UNICODE_STRING ustrFullKey;
UNICODE_STRING ustrDatabaseID = { 0 };
WCHAR wszFullKey[1024];
NTSTATUS Status;
HANDLE KeyHandleAppcompat = NULL;
HANDLE KeyHandle = NULL;
ULONG CreateDisposition;
ULONG PathLength = 0;
OBJECT_ATTRIBUTES ObjectAttributes;
FILETIME TimeStamp;
LARGE_INTEGER liTimeStamp;
KEY_WRITE_TIME_INFORMATION KeyWriteTimeInfo;
//
// See if we need to expand some strings...
//
if (_tcschr(pszDatabasePath, TEXT('%')) != NULL) {
bExpandSZ = TRUE;
RtlInitUnicodeString(&ustrPath, pszDatabasePath);
Status = RtlExpandEnvironmentStrings_U(NULL,
&ustrPath,
&ustrFullPath,
&PathLength);
if (Status != STATUS_BUFFER_TOO_SMALL) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to expand environment strings for \"%s\" Status 0x%lx\n",
pszDatabasePath,
Status));
return FALSE;
}
//
// Allocate the length we need
//
ustrFullPath.Buffer = (WCHAR*)SdbAlloc(PathLength);
if (ustrFullPath.Buffer == NULL) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to allocate 0x%lx bytes for the path buffer \"%s\"\n",
PathLength,
pszDatabasePath));
return FALSE;
}
ustrFullPath.MaximumLength = (USHORT)PathLength;
ustrFullPath.Length = 0;
bFreeFullPath = TRUE;
Status = RtlExpandEnvironmentStrings_U(NULL,
&ustrPath,
&ustrFullPath,
&PathLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to expand environment strings for \"%s\" Status 0x%lx\n",
pszDatabasePath,
Status));
goto HandleError;
}
} else {
RtlInitUnicodeString(&ustrFullPath, pszDatabasePath);
}
if (!SdbGetDatabaseInformationByName(ustrFullPath.Buffer, &pDbInfo)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Cannot obtain database information for \"%s\"\n",
pszDatabasePath));
goto HandleError;
}
if (!(pDbInfo->dwFlags & DBINFO_GUID_VALID)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Cannot register database with no id \"%s\"\n",
pszDatabasePath));
goto HandleError;
}
Status = GUID_TO_UNICODE_STRING(&pDbInfo->guidDB, &ustrDatabaseID);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Cannot convert guid to unicode string status 0x%lx\n",
Status));
goto HandleError;
}
//
// Now that we have database information - create entry
//
ustrFullKey.Length = 0;
ustrFullKey.MaximumLength = sizeof(wszFullKey);
ustrFullKey.Buffer = wszFullKey;
RtlAppendUnicodeToString(&ustrFullKey, APPCOMPAT_KEY_PATH_MACHINE_INSTALLEDSDB);
RtlAppendUnicodeToString(&ustrFullKey, L"\\");
RtlAppendUnicodeStringToString(&ustrFullKey, &ustrDatabaseID);
FREE_GUID_STRING(&ustrDatabaseID);
//
// All done, now create key - first make sure that appcompat key path machine exists...
//
RtlInitUnicodeString(&ustrKey, APPCOMPAT_KEY_PATH_MACHINE_INSTALLEDSDB);
InitializeObjectAttributes(&ObjectAttributes,
&ustrKey,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtCreateKey(&KeyHandleAppcompat,
STANDARD_RIGHTS_WRITE |
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS |
KEY_SET_VALUE |
KEY_CREATE_SUB_KEY|
SdbpGetWow64Flag(),
&ObjectAttributes,
0,
NULL,
REG_OPTION_NON_VOLATILE,
&CreateDisposition);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to create key \"%s\" status = 0x%lx\n",
ustrKey.Buffer,
Status));
goto HandleError;
}
InitializeObjectAttributes(&ObjectAttributes,
&ustrFullKey,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtCreateKey(&KeyHandle,
STANDARD_RIGHTS_WRITE |
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS |
KEY_SET_VALUE |
KEY_CREATE_SUB_KEY|
SdbpGetWow64Flag(),
&ObjectAttributes,
0,
NULL,
REG_OPTION_NON_VOLATILE,
&CreateDisposition);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to create key \"%s\" Status 0x%x\n",
ustrFullKey.Buffer,
Status));
goto HandleError;
}
//
// We have an open key, we shall set these values:
//
Status = NtSetValueKey(KeyHandle,
&g_ustrDatabasePath,
0,
bExpandSZ ? REG_EXPAND_SZ : REG_SZ,
(PVOID)pszDatabasePath,
(_tcslen(pszDatabasePath) + 1) * sizeof(*pszDatabasePath));
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to set value \"%s\" to \"%s\" Status 0x%lx\n",
g_ustrDatabasePath.Buffer,
pszDatabasePath,
Status));
goto HandleError;
}
Status = NtSetValueKey(KeyHandle,
&g_ustrDatabaseType,
0,
REG_DWORD,
(PVOID)&dwDatabaseType,
sizeof(dwDatabaseType));
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to set value \"%s\" to 0x%lx Status 0x%lx\n",
g_ustrDatabaseType.Buffer,
dwDatabaseType, Status));
goto HandleError;
}
if (pDbInfo->pszDescription != NULL) {
Status = NtSetValueKey(KeyHandle,
&g_ustrDatabaseDescription,
0,
REG_SZ,
(PVOID)pDbInfo->pszDescription,
(_tcslen(pDbInfo->pszDescription) + 1) * sizeof(WCHAR));
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to set value \"%s\" to 0x%lx Status 0x%lx\n",
g_ustrDatabaseDescription.Buffer,
pDbInfo->pszDescription,
Status));
goto HandleError;
}
}
//
// Finally, set the date/time stamp explicitly as a value
//
if (pTimeStamp == NULL) {
GetSystemTimeAsFileTime(&TimeStamp);
liTimeStamp.LowPart = TimeStamp.dwLowDateTime;
liTimeStamp.HighPart = TimeStamp.dwHighDateTime;
} else {
liTimeStamp.QuadPart = *pTimeStamp;
}
Status = NtSetValueKey(KeyHandle,
&g_ustrInstallTimeStamp,
0,
REG_QWORD,
(PVOID)&liTimeStamp.QuadPart,
sizeof(liTimeStamp.QuadPart));
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to set value \"%s\" Status 0x%lx\n",
g_ustrInstallTimeStamp.Buffer,
Status));
goto HandleError;
}
//
// Make the value we set into the timestamp MATCH the last write date/time stamp
// on the key itself (just to be consistent)
//
KeyWriteTimeInfo.LastWriteTime.QuadPart = liTimeStamp.QuadPart;
Status = NtSetInformationKey(KeyHandle,
KeyWriteTimeInformation,
&KeyWriteTimeInfo,
sizeof(KeyWriteTimeInfo));
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbRegisterDatabase",
"Failed to set last write time on key Status 0x%lx\n",
Status));
goto HandleError;
}
bReturn = TRUE;
HandleError:
if (pDbInfo != NULL) {
SdbFreeDatabaseInformation(pDbInfo);
}
if (bFreeFullPath && ustrFullPath.Buffer != NULL) {
SdbFree(ustrFullPath.Buffer);
}
if (KeyHandle != NULL) {
NtClose(KeyHandle);
}
if (KeyHandleAppcompat != NULL) {
NtClose(KeyHandleAppcompat);
}
return bReturn;
}
BOOL
SDBAPI
SdbRegisterDatabase(
IN LPCWSTR pszDatabasePath,
IN DWORD dwDatabaseType
)
{
return SdbRegisterDatabaseEx(pszDatabasePath, dwDatabaseType, NULL);
}
BOOL
SDBAPI
SdbUnregisterDatabase(
IN GUID* pguidDB
)
/*++
Unregisters a database so it's no longer available.
--*/
{
BOOL bReturn = FALSE;
UNICODE_STRING ustrFullPath = { 0 };
UNICODE_STRING ustrFullKey;
UNICODE_STRING ustrDatabaseID = { 0 };
WCHAR wszFullKey[1024];
NTSTATUS Status;
HANDLE KeyHandle = NULL;
OBJECT_ATTRIBUTES ObjectAttributes;
Status = GUID_TO_UNICODE_STRING(pguidDB, &ustrDatabaseID);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbUnregisterDatabase",
"Cannot convert guid to unicode string status 0x%lx\n",
Status));
goto HandleError;
}
//
// Now that we have database information - remove entry
//
ustrFullKey.Length = 0;
ustrFullKey.MaximumLength = sizeof(wszFullKey);
ustrFullKey.Buffer = wszFullKey;
RtlAppendUnicodeToString(&ustrFullKey, APPCOMPAT_KEY_PATH_MACHINE_INSTALLEDSDB);
RtlAppendUnicodeToString(&ustrFullKey, L"\\");
RtlAppendUnicodeStringToString(&ustrFullKey, &ustrDatabaseID);
FREE_GUID_STRING(&ustrDatabaseID);
//
// All done, now delete key
//
InitializeObjectAttributes(&ObjectAttributes,
&ustrFullKey,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle, DELETE|SdbpGetWow64Flag(), &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbUnregisterDatabase",
"Failed to open key \"%s\" Status 0x%x\n",
ustrFullKey.Buffer,
Status));
goto HandleError;
}
//
// We have an open key, now delete it
//
Status = NtDeleteKey(KeyHandle);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbUnregisterDatabase",
"Failed to delete key \"%s\" Status 0x%x\n",
ustrFullKey.Buffer,
Status));
goto HandleError;
}
bReturn = TRUE;
HandleError:
if (KeyHandle != NULL) {
NtClose(KeyHandle);
}
return bReturn;
}
BOOL
SdbpDoesFileExistNTPath(
LPCWSTR lpwszFileName
)
{
OBJECT_ATTRIBUTES Obja;
UNICODE_STRING NtFileName;
NTSTATUS Status;
BOOL ReturnValue = FALSE;
FILE_BASIC_INFORMATION BasicInfo;
RtlInitUnicodeString(&NtFileName, lpwszFileName);
InitializeObjectAttributes(&Obja,
&NtFileName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
//
// Query the file's attributes. Note that the file cannot simply be opened
// to determine whether or not it exists, as the NT LanMan redirector lies
// on NtOpenFile to a Lan Manager server because it does not actually open
// the file until an operation is performed on it. We don't care since net is not
// even involved -- we always check for LOCAL files
//
Status = NtQueryAttributesFile(&Obja, &BasicInfo);
if (!NT_SUCCESS(Status)) {
if (Status == STATUS_SHARING_VIOLATION || Status == STATUS_ACCESS_DENIED) {
ReturnValue = TRUE;
} else {
ReturnValue = FALSE;
}
} else {
ReturnValue = TRUE;
}
return ReturnValue;
}
BOOL
SDBAPI
SdbGetStandardDatabaseGUID(
IN DWORD dwDatabaseType,
OUT GUID* pGuidDB
)
{
GUID const * pguid = NULL;
if (!(dwDatabaseType & SDB_DATABASE_MAIN)) {
DBGPRINT((sdlError,
"SdbGetStandardDatabaseGUID",
"Cannot obtain database guid for databases other than main\n"));
return FALSE;
}
switch (dwDatabaseType & SDB_DATABASE_TYPE_MASK) {
case SDB_DATABASE_MAIN_DRIVERS:
pguid = &GUID_DRVMAIN_SDB;
break;
case SDB_DATABASE_MAIN_DETAILS:
pguid = &GUID_APPHELP_SDB;
break;
case SDB_DATABASE_MAIN_SP_DETAILS:
pguid = &GUID_APPHELP_SP_SDB;
break;
case SDB_DATABASE_MAIN_MSI:
pguid = &GUID_MSIMAIN_SDB;
break;
case SDB_DATABASE_MAIN_SHIM:
pguid = &GUID_SYSMAIN_SDB;
break;
}
if (pguid != NULL) {
if (pGuidDB != NULL) {
RtlCopyMemory(pGuidDB, pguid, sizeof(*pGuidDB));
}
return TRUE;
}
return FALSE;
}
DWORD
SdbpGetStandardDatabasePath(
IN DWORD dwDatabaseType,
IN DWORD dwFlags, // specify HID_DOS_PATHS for dos paths
OUT LPTSTR pszDatabasePath,
IN DWORD dwBufferSize // in tchars
)
{
TCHAR szAppPatch[MAX_PATH];
TCHAR szTemp[MAX_PATH];
LPCTSTR pszDatabase = NULL;
LPCTSTR pszDir = NULL;
LCID lcid;
int nLen;
if (dwFlags & HID_DOS_PATHS) {
SdbpGetAppPatchDir(szAppPatch);
} else {
_tcscpy(szAppPatch, TEXT("\\SystemRoot\\AppPatch"));
}
if (!(dwDatabaseType & SDB_DATABASE_MAIN)) { // cannot get it for non-main d
return 0;
}
pszDir = szAppPatch;
switch (dwDatabaseType & SDB_DATABASE_TYPE_MASK) {
case SDB_DATABASE_MAIN_DRIVERS:
pszDatabase = TEXT("drvmain.sdb");
break;
case SDB_DATABASE_MAIN_MSI:
pszDatabase = TEXT("msimain.sdb");
break;
case SDB_DATABASE_MAIN_SHIM:
pszDatabase = TEXT("sysmain.sdb");
break;
case SDB_DATABASE_MAIN_TEST:
pszDatabase = TEXT("systest.sdb");
break;
case SDB_DATABASE_MAIN_SP_DETAILS:
pszDatabase = TEXT("apph_sp.sdb");
break;
case SDB_DATABASE_MAIN_DETAILS:
//
// The code below is not operational on nt4 yet. It would prevent sdbapiu from
// working properly as GetUserDefaultUILanguage does not exist.
//
#ifndef WIN32U_MODE
lcid = GetUserDefaultUILanguage();
if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)) {
BOOL bFoundDB = FALSE;
TCHAR szTemp[MAX_PATH];
//
// When doing this, always remember which apppatch we are putting up here
// we need to form our own private apppatch
//
nLen = _sntprintf(szTemp,
CHARCOUNT(szTemp),
TEXT("%s\\MUI\\%04x\\apphelp.sdb"),
szAppPatch,
lcid);
if (nLen > 0) {
if (dwFlags & HID_DOS_PATHS) {
bFoundDB = RtlDoesFileExists_U(szTemp);
} else {
bFoundDB = SdbpDoesFileExistNTPath(szTemp);
}
}
if (bFoundDB) {
_sntprintf(szTemp, CHARCOUNT(szTemp), TEXT("MUI\\%04x\\apphelp.sdb"), lcid);
pszDatabase = szTemp;
}
}
#else
UNREFERENCED_PARAMETER(lcid);
#endif
if (pszDatabase == NULL) {
//
// Standard case
//
pszDatabase = TEXT("apphelp.sdb");
}
break;
}
if (pszDatabase == NULL) {
DBGPRINT((sdlError,
"SdbpGetStandardDatabasePath",
"Cannot get the path for database type 0x%lx\n",
dwDatabaseType));
return 0;
}
if (pszDatabasePath != NULL) {
nLen = _sntprintf(pszDatabasePath,
(int)dwBufferSize,
TEXT("%s\\%s"),
pszDir,
pszDatabase);
} else {
nLen = -1;
}
if (nLen < 0) {
if (pszDatabasePath != NULL) {
DBGPRINT((sdlError, "SdbpGetStandardDatabasePath", "Path is too long\n"));
}
//
// Calc expected length. One for term null char and one for "\\" ...
//
nLen = (pszDir == NULL ? 0 : _tclen(pszDir)) + _tcslen(pszDatabase) + 1 + 1;
}
return (DWORD)nLen;
}
DWORD
SDBAPI
SdbResolveDatabase(
IN GUID* pguidDB, // pointer to the database guid to resolve
OUT LPDWORD lpdwDatabaseType, // optional pointer to the database type
OUT LPTSTR pszDatabasePath, // optional pointer to the database path
IN DWORD dwBufferSize // size of the buffer pszDatabasePath
)
{
WCHAR wszFullKey[1024];
UNICODE_STRING ustrFullKey;
UNICODE_STRING ustrKey;
UNICODE_STRING ustrPath;
NTSTATUS Status;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE KeyHandle = NULL;
ULONG KeyValueBuffer[256];
ULONG KeyValueLength = 0;
BOOL bRet = FALSE;
ULONG PathValueLength = 0; // this is return result
DWORD dwDatabaseType = 0;
int i;
PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
static struct tagSTDGUIDSDB {
const GUID* pGuid;
DWORD dwDatabaseType;
} guidStd[] = {
{ &GUID_SYSMAIN_SDB, SDB_DATABASE_MAIN_SHIM },
{ &GUID_MSIMAIN_SDB, SDB_DATABASE_MAIN_MSI },
{ &GUID_DRVMAIN_SDB, SDB_DATABASE_MAIN_DRIVERS },
{ &GUID_APPHELP_SDB, SDB_DATABASE_MAIN_DETAILS },
{ &GUID_APPHELP_SP_SDB, SDB_DATABASE_MAIN_SP_DETAILS},
{ &GUID_SYSTEST_SDB, SDB_DATABASE_MAIN_TEST }
};
for (i = 0; i < ARRAYSIZE(guidStd); ++i) {
if (!memcmp(guidStd[i].pGuid, pguidDB, sizeof(GUID))) {
dwDatabaseType = guidStd[i].dwDatabaseType;
break;
}
}
if (i < ARRAYSIZE(guidStd)) {
DWORD dwLen;
dwLen = SdbpGetStandardDatabasePath(dwDatabaseType,
HID_DOS_PATHS,
pszDatabasePath,
dwBufferSize);
if (lpdwDatabaseType != NULL) {
*lpdwDatabaseType = dwDatabaseType;
}
return dwLen;
}
ustrFullKey.Buffer = wszFullKey;
ustrFullKey.MaximumLength = sizeof(wszFullKey);
ustrFullKey.Length = 0;
RtlAppendUnicodeToString(&ustrFullKey, APPCOMPAT_KEY_PATH_MACHINE_INSTALLEDSDB);
RtlAppendUnicodeToString(&ustrFullKey, L"\\");
Status = GUID_TO_UNICODE_STRING(pguidDB, &ustrKey);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbResolveDatabase",
"Failed to convert guid to string status 0x%lx\n",
Status));
goto HandleError; // 0 means error
}
RtlAppendUnicodeStringToString(&ustrFullKey, &ustrKey);
FREE_GUID_STRING(&ustrKey);
InitializeObjectAttributes(&ObjectAttributes,
&ustrFullKey,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
Status = NtOpenKey(&KeyHandle, GENERIC_READ|SdbpGetWow64Flag(), &ObjectAttributes);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbResolveDatabase",
"Failed to open Key \"%s\" Status 0x%lx\n",
ustrFullKey.Buffer,
Status));
goto HandleError;
}
//
// Now since we were able to open the key -- database was found, recover path and type
//
KeyValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION)KeyValueBuffer;
Status = NtQueryValueKey(KeyHandle,
&g_ustrDatabasePath,
KeyValuePartialInformation,
KeyValueInformation,
sizeof(KeyValueBuffer),
&KeyValueLength);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbResolveDatabase",
"Failed trying to query value \"%s\" Status 0x%lx\n",
g_ustrDatabasePath.Buffer,
Status));
goto HandleError;
}
switch (KeyValueInformation->Type) {
case REG_SZ:
PathValueLength = KeyValueInformation->DataLength;
if (pszDatabasePath == NULL || dwBufferSize * sizeof(WCHAR) < PathValueLength) {
DBGPRINT((sdlWarning,
"SdbResolveDatabase",
"Insufficient buffer for the database path\n"));
goto HandleError;
}
RtlMoveMemory(pszDatabasePath, KeyValueInformation->Data, PathValueLength);
break;
case REG_EXPAND_SZ:
ustrKey.Buffer = (PWSTR)&KeyValueInformation->Data;
ustrKey.Length = (USHORT)(KeyValueInformation->DataLength - sizeof(UNICODE_NULL));
ustrKey.MaximumLength = (USHORT)KeyValueInformation->DataLength;
ustrPath.Buffer = pszDatabasePath;
ustrPath.Length = 0;
ustrPath.MaximumLength = (USHORT)(dwBufferSize * sizeof(WCHAR));
Status = RtlExpandEnvironmentStrings_U(NULL, &ustrKey, &ustrPath, &PathValueLength);
if (Status == STATUS_BUFFER_TOO_SMALL) {
DBGPRINT((sdlWarning, "SdbResolveDatabase", "Insufficient buffer to expand path\n"));
goto HandleError;
}
if (!NT_SUCCESS(Status)) {
PathValueLength = 0;
}
break;
default:
DBGPRINT((sdlError,
"SdbResolveDatabase",
"Wrong key type 0x%lx\n",
KeyValueInformation->Type));
PathValueLength = 0;
goto HandleError;
break;
}
if (lpdwDatabaseType != NULL) {
//
// Query for the database type
//
Status = NtQueryValueKey(KeyHandle,
&g_ustrDatabaseType,
KeyValuePartialInformation,
KeyValueInformation,
sizeof(KeyValueBuffer),
&KeyValueLength);
if (NT_SUCCESS(Status)) {
if (KeyValueInformation->Type != REG_DWORD) {
//
// bummer, get out -- wrong type
//
DBGPRINT((sdlError,
"SdbResolveDatabase",
"Wrong database type - value type 0x%lx\n",
KeyValueInformation->Type));
PathValueLength = 0;
goto HandleError;
}
//
// Else, we get the value
//
RtlMoveMemory(lpdwDatabaseType, &KeyValueInformation->Data, sizeof(*lpdwDatabaseType));
} else {
*lpdwDatabaseType = 0; // we do not have any value then
}
}
HandleError:
if (KeyHandle != NULL) {
NtClose(KeyHandle);
}
return PathValueLength / sizeof(WCHAR);
}
LPTSTR
SDBAPI
SdbGetLayerName(
IN HSDB hSDB,
IN TAGREF trLayer
)
/*++
Return: BUGBUG
Desc: BUGBUG
--*/
{
PDB pdb;
TAGID tiLayer, tiName;
LPTSTR pwszName;
if (!SdbTagRefToTagID(hSDB, trLayer, &pdb, &tiLayer)) {
DBGPRINT((sdlError,
"SdbGetLayerName",
"Failed to get tag id from tag ref 0x%lx\n",
trLayer));
return NULL;
}
tiName = SdbFindFirstTag(pdb, tiLayer, TAG_NAME);
if (tiName == TAGID_NULL) {
DBGPRINT((sdlError,
"SdbGetLayerName",
"Failed to get the name tag id for 0x%lx\n",
tiName));
return NULL;
}
pwszName = SdbGetStringTagPtr(pdb, tiName);
if (pwszName == NULL) {
DBGPRINT((sdlError,
"SdbGetLayerName",
"Cannot read the name of the layer tag id 0x%lx\n",
tiName));
}
return pwszName;
}
/*++
SdbBuildComapatEnvVar
This function builds the environment variable necessary for
Compat Layer propagation
--*/
DWORD
SDBAPI
SdbBuildCompatEnvVariables(
IN HSDB hSDB,
IN SDBQUERYRESULT* psdbQuery,
IN DWORD dwFlags,
IN LPCWSTR pwszParentEnv OPTIONAL, // environment which contains vars
// that we shall inherit from
OUT LPWSTR pBuffer,
IN DWORD cbSize, // size of the buffer in tchars
OUT LPDWORD lpdwShimsCount OPTIONAL
)
{
int i;
TCHAR szFullEnvVar[MAX_PATH];
TAGREF trShimRef;
INT nCountLayers = 0;
DWORD dwSizeRequired;
//
// Count the DLLs that trLayer uses, and put together the environment variable
//
szFullEnvVar[0] = TEXT('\0');
//
// Make sure to propagate the flags.
//
if (!(dwFlags & SBCE_ADDITIVE)) {
_tcscat(szFullEnvVar, TEXT("!"));
}
if (dwFlags & SBCE_INCLUDESYSTEMEXES) {
_tcscat(szFullEnvVar, TEXT("#"));
}
for (i = 0; i < SDB_MAX_LAYERS && psdbQuery->atrLayers[i] != TAGREF_NULL; ++i) {
WCHAR* pszEnvVar;
//
// Get the environment var and tack it onto the full string
//
pszEnvVar = SdbGetLayerName(hSDB, psdbQuery->atrLayers[i]);
if (pszEnvVar) {
if (nCountLayers) {
_tcscat(szFullEnvVar, TEXT(" "));
}
++nCountLayers;
_tcscat(szFullEnvVar, pszEnvVar);
}
if (lpdwShimsCount != NULL) {
//
// Keep counting the dlls.
//
trShimRef = SdbFindFirstTagRef(hSDB, psdbQuery->atrLayers[i], TAG_SHIM_REF);
while (trShimRef != TAGREF_NULL) {
(*lpdwShimsCount)++;
trShimRef = SdbFindNextTagRef(hSDB, psdbQuery->atrLayers[i], trShimRef);
}
}
}
dwSizeRequired = _tcslen(szFullEnvVar) + _tcslen(g_szCompatLayer) + 3;
if (cbSize < dwSizeRequired || pBuffer == NULL) {
//
// need g_szCompatLayer + '=' + \0 + szFullEnvVar space in the buffer
//
return dwSizeRequired;
}
return (DWORD)_stprintf(pBuffer, TEXT("%s=%s%c"), g_szCompatLayer, szFullEnvVar, TEXT('\0'));
UNREFERENCED_PARAMETER(pwszParentEnv);
}
DWORD
SdbpGetProcessorArchitecture(
VOID
)
{
static DWORD dwProcessorArchitecture = PROCESSOR_ARCHITECTURE_UNKNOWN;
SYSTEM_PROCESSOR_INFORMATION ProcessorInfo;
NTSTATUS Status;
PVOID Wow64Info = NULL;
if (dwProcessorArchitecture != PROCESSOR_ARCHITECTURE_UNKNOWN) {
goto Cleanup;
}
Status = NtQuerySystemInformation(SystemProcessorInformation,
&ProcessorInfo,
sizeof(ProcessorInfo),
NULL);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlError,
"SdbpGetProcessorArchitecture",
"Failed to obtain system processor information 0x%lx\n",
Status));
goto Cleanup;
}
dwProcessorArchitecture = ProcessorInfo.ProcessorArchitecture;
#ifndef _WIN64
if (dwProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
//
// If we are not 64 bit native -- then we need to make sure this is not
// an emulation layer that we are running on
//
Status = NtQueryInformationProcess(NtCurrentProcess(),
ProcessWow64Information,
&Wow64Info,
sizeof(Wow64Info),
NULL);
if (NT_SUCCESS(Status) && Wow64Info != NULL) {
dwProcessorArchitecture = PROCESSOR_ARCHITECTURE_IA32_ON_WIN64;
}
}
#endif // _WIN64
Cleanup:
return dwProcessorArchitecture;
}
#define FULL_TABLETPC_KEY_PATH KEY_MACHINE TEXT("\\") TABLETPC_KEY_PATH
#define FULL_EHOME_KEY_PATH KEY_MACHINE TEXT("\\") EHOME_KEY_PATH
BOOL
SdbpIsOs(
DWORD dwOSSKU
)
{
BOOL bRet = FALSE;
UNICODE_STRING ustrKeyPath = {0};
UNICODE_STRING ustrValue;
NTSTATUS status;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE KeyHandle;
PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
ULONG KeyValueBuffer[64];
ULONG KeyValueLength;
if (dwOSSKU == OS_SKU_TAB) {
RtlInitUnicodeString(&ustrKeyPath, FULL_TABLETPC_KEY_PATH);
} else if (dwOSSKU == OS_SKU_MED) {
RtlInitUnicodeString(&ustrKeyPath, FULL_EHOME_KEY_PATH);
} else {
DBGPRINT((sdlWarning,
"SdbpIsOs",
"Specified unknown OS type 0x%lx",
dwOSSKU));
return FALSE;
}
InitializeObjectAttributes(
&ObjectAttributes,
&ustrKeyPath,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
status = NtOpenKey(
&KeyHandle,
KEY_QUERY_VALUE | SdbpGetWow64Flag(),
&ObjectAttributes);
if (!NT_SUCCESS(status)) {
DBGPRINT((sdlWarning,
"SdbpIsOs",
"Failed to open Key %s Status 0x%lx",
ustrKeyPath.Buffer,
status));
goto out;
}
KeyValueInformation = (PKEY_VALUE_PARTIAL_INFORMATION)&KeyValueBuffer;
RtlInitUnicodeString(&ustrValue, IS_OS_INSTALL_VALUE);
status = NtQueryValueKey(
KeyHandle,
&ustrValue,
KeyValuePartialInformation,
KeyValueInformation,
sizeof(KeyValueBuffer),
&KeyValueLength);
NtClose(KeyHandle);
if (!NT_SUCCESS(status)) {
DBGPRINT((sdlWarning,
"SdbpIsOs",
"Failed to read value info for value %s for key %s Status 0x%lx",
IS_OS_INSTALL_VALUE,
ustrKeyPath.Buffer,
status));
goto out;
}
if (KeyValueInformation->Type != REG_DWORD) {
DBGPRINT((sdlWarning,
"SdbpIsOs",
"Unexpected value type 0x%x for value %s under key %s",
KeyValueInformation->Type,
IS_OS_INSTALL_VALUE,
ustrKeyPath.Buffer));
goto out;
}
if (*(DWORD*)(&KeyValueInformation->Data[0]) != 0) {
bRet = TRUE;
}
DBGPRINT((sdlInfo|sdlLogPipe,
"SdbpIsOs",
"%s %s installed",
0,
(dwOSSKU == OS_SKU_TAB ? TEXT("TabletPC") : TEXT("eHome")),
(bRet ? TEXT("is") : TEXT("is not"))));
out:
return bRet;
}
void
SdbpGetOSSKU(
LPDWORD lpdwSKU,
LPDWORD lpdwSP
)
{
WORD wServicePackMajor;
WORD wSuiteMask;
WORD wProductType;
PPEB Peb = NtCurrentPeb();
wServicePackMajor = (Peb->OSCSDVersion >> 8) & 0xFF;
wSuiteMask = (USHORT)(USER_SHARED_DATA->SuiteMask & 0xffff);
*lpdwSP = 1 << wServicePackMajor;
wSuiteMask = wSuiteMask;
wProductType = USER_SHARED_DATA->NtProductType;
if (wProductType == VER_NT_WORKSTATION) {
if (wSuiteMask & VER_SUITE_PERSONAL) {
*lpdwSKU = OS_SKU_PER;
} else {
#if (_WIN32_WINNT >= 0x0501)
if (SdbpIsOs(OS_SKU_TAB)) {
*lpdwSKU = OS_SKU_TAB;
} else if (SdbpIsOs(OS_SKU_MED)) {
*lpdwSKU = OS_SKU_MED;
} else {
*lpdwSKU = OS_SKU_PRO;
}
#else
*lpdwSKU = OS_SKU_PRO;
#endif
}
return;
}
if (wSuiteMask & VER_SUITE_DATACENTER) {
*lpdwSKU = OS_SKU_DTC;
return;
}
if (wSuiteMask & VER_SUITE_ENTERPRISE) {
*lpdwSKU = OS_SKU_ADS;
return;
}
if (wSuiteMask & VER_SUITE_BLADE) {
*lpdwSKU = OS_SKU_BLA;
return;
}
*lpdwSKU = OS_SKU_SRV;
}
DWORD
SdbpGetWow64Flag(
VOID
)
{
if (g_dwWow64Key == (DWORD)-1) {
OSVERSIONINFOEXW osvi;
BOOL bSuccess;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOW);
#ifdef WIN32U_MODE
bSuccess = GetVersionExW((POSVERSIONINFOW)&osvi);
#else
bSuccess = NT_SUCCESS(RtlGetVersion((PRTL_OSVERSIONINFOW)&osvi));
#endif
if (bSuccess) {
//
// Straight win2k
//
if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) {
g_dwWow64Key = 0; // no flag since there is no wow64 on win2k
} else {
g_dwWow64Key = KEY_WOW64_64KEY;
}
} else {
DBGPRINT((sdlError, "SdbGetWow64Flag", "RtlGetVersion failed\n"));
//
// XP or higher.
//
g_dwWow64Key = KEY_WOW64_64KEY;
}
}
return g_dwWow64Key;
}
NTSTATUS
SDBAPI
SdbEnsureBufferSizeFunction(
IN ULONG Flags,
IN OUT PRTL_BUFFER Buffer,
IN SIZE_T Size
)
{
HMODULE hModNtdll;
if (g_pfnEnsureBufferSize == NULL) {
hModNtdll = GetModuleHandleW(L"ntdll.dll");
if (hModNtdll == NULL) {
DBGPRINT((sdlError,
"SdbEnsureBufferSizeFunction",
"Failed to retrieve ntdll.dll module handle, Error 0x%lx\n",
GetLastError()));
return STATUS_UNSUCCESSFUL;
}
g_pfnEnsureBufferSize = (PFNEnsureBufferSize)GetProcAddress(hModNtdll,
"RtlpEnsureBufferSize");
if (g_pfnEnsureBufferSize == NULL) {
DBGPRINT((sdlError,
"SdbEnsureBufferSizeFunction",
"RtlpEnsureBufferSize is not available, reverting to sdbapi\n"));
g_pfnEnsureBufferSize = SdbpEnsureBufferSize;
}
}
return g_pfnEnsureBufferSize(Flags, Buffer, Size);
}
HANDLE
SdbpOpenDebugPipe(
void
)
{
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status;
HANDLE hPipe = INVALID_HANDLE_VALUE;
IO_STATUS_BLOCK IoStatusBlock;
FILE_PIPE_INFORMATION FilePipeInfo;
InitializeObjectAttributes(&ObjectAttributes,
&g_ustrDebugPipeName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL);
IoStatusBlock.Status = 0;
IoStatusBlock.Information = 0;
//
// Open the named pipe
//
Status = NtCreateFile(&hPipe,
FILE_GENERIC_WRITE,
&ObjectAttributes,
&IoStatusBlock,
NULL,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN,
0,
NULL,
0);
if ((!NT_SUCCESS(Status) || INVALID_HANDLE_VALUE == hPipe)) {
if (Status != STATUS_OBJECT_NAME_NOT_FOUND) {
DBGPRINT((sdlWarning,
"SdbpOpenDebugPipe",
"Failed to create debug pipe, status 0x%lx\n",
Status));
}
return INVALID_HANDLE_VALUE;
}
//
// Change the mode of the named pipe to message mode
//
FilePipeInfo.ReadMode = FILE_PIPE_MESSAGE_MODE;
FilePipeInfo.CompletionMode = FILE_PIPE_QUEUE_OPERATION;
Status = NtSetInformationFile(hPipe,
&IoStatusBlock,
&FilePipeInfo,
sizeof(FilePipeInfo),
FilePipeInformation);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpOpenDebugPipe",
"Failed to set pipe mode, status 0x%lx\n",
Status));
NtClose(hPipe);
hPipe = INVALID_HANDLE_VALUE;
}
return hPipe;
}
BOOL
SdbpCloseDebugPipe(
IN HANDLE hPipe
)
{
if (hPipe != INVALID_HANDLE_VALUE) {
NtClose(hPipe);
}
return TRUE;
}
BOOL
SdbpWriteDebugPipe(
HSDB hSDB,
LPCSTR pszBuffer
)
{
DWORD dwBufferSize;
ANSI_STRING strMessage;
UNICODE_STRING ustrMessage;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
IO_STATUS_BLOCK IoStatusBlock;
LARGE_INTEGER liOffset = { 0 };
PSDBCONTEXT pSdbContext = (PSDBCONTEXT)hSDB;
HANDLE hPipe = INVALID_HANDLE_VALUE;
BOOL bClosePipe = FALSE;
PCHAR pchStart;
PCHAR pch;
PWCHAR pwch;
if (pSdbContext == NULL) {
hPipe = SdbpOpenDebugPipe();
bClosePipe = TRUE;
} else {
hPipe = pSdbContext->hPipe;
}
if (hPipe == INVALID_HANDLE_VALUE ||
pszBuffer == NULL) {
return FALSE;
}
//
// Preprocess the string to eliminate any \t \r \n
//
pchStart = (PCHAR)pszBuffer;
while (pchStart != NULL && *pchStart) {
//
// Skip over white space and any empty lines
//
pchStart += strspn(pchStart, " \t\r\n");
pch = strpbrk(pchStart, "\r\n");
if (pch == NULL) {
RtlInitAnsiString(&strMessage, pchStart);
pchStart = NULL;
} else {
//
// if it's a tab, nuke it by replacing it with ' '
//
strMessage.Buffer = pchStart;
strMessage.MaximumLength =
strMessage.Length = (USHORT)((DWORD_PTR)pch - (DWORD_PTR)pchStart); // size in bytes
//
// now adjust the pointer past \r\n
//
pchStart = pch + strspn(pch, "\r\n");
}
if (strMessage.Length == 0) {
continue;
}
Status = RtlAnsiStringToUnicodeString(&ustrMessage, &strMessage, TRUE);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpWriteDebugPipe",
"Failed to convert string to unicode status 0x%lx\n",
Status));
goto cleanup;
}
//
// Second line of defense against rogue chars in shimviewer.
// Search and replace all instances of '\t' with ' '
//
pwch = ustrMessage.Buffer;
while (pwch != NULL && *pwch) {
pwch = wcschr(pwch, L'\t');
if (pwch != NULL) {
*pwch++ = L' ';
}
}
IoStatusBlock.Status = 0;
IoStatusBlock.Information = 0;
Status = NtWriteFile(pSdbContext->hPipe,
NULL,
NULL,
NULL,
&IoStatusBlock,
(PVOID)ustrMessage.Buffer,
ustrMessage.Length,
&liOffset,
NULL);
RtlFreeUnicodeString(&ustrMessage);
if (!NT_SUCCESS(Status)) {
DBGPRINT((sdlWarning,
"SdbpWriteDebugPipe",
"Failed to write data to debug pipe, Status 0x%lx\n",
Status));
if (Status == STATUS_PIPE_BROKEN) {
bClosePipe = TRUE;
goto cleanup;
}
}
}
cleanup:
if (bClosePipe) {
SdbpCloseDebugPipe(hPipe);
hPipe = INVALID_HANDLE_VALUE;
}
//
// We do cleanup depending on the context
//
if (pSdbContext != NULL) {
pSdbContext->hPipe = hPipe; // so that we don't do it again in case of an error
}
return NT_SUCCESS(Status);
}
Reference in a new issue View git blame Copy permalink