You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2378 lines
72 KiB
2378 lines
72 KiB
/*++
|
|
|
|
Copyright (c) 1989-2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
check.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the main API that CreateProcess
|
|
calls to check if an EXE is shimmed or apphelpped.
|
|
|
|
Author:
|
|
|
|
vadimb created sometime in 2000
|
|
|
|
Revision History:
|
|
|
|
clupu cleanup 12/27/2000
|
|
andyseti added ApphelpCheckExe 03/29/2001
|
|
andyseti added ApphelpCheckInstallShieldPackage 06/28/2001
|
|
--*/
|
|
|
|
#include "apphelp.h"
|
|
#define STRSAFE_NO_CB_FUNCTIONS
|
|
#include <strsafe.h>
|
|
|
|
static const WCHAR ShimEngine_ModuleName[] = L"Shimeng.dll";
|
|
static const CHAR DynamicShimProcedureName[] = "SE_DynamicShim";
|
|
static const CHAR DynamicUnshimProcedureName[] = "SE_DynamicUnshim";
|
|
|
|
typedef BOOL (WINAPI *_pfn_SE_DynamicShim)(LPCWSTR , HSDB , SDBQUERYRESULT*, LPCSTR, LPDWORD);
|
|
typedef BOOL (WINAPI *_pfn_SE_DynamicUnshim)(DWORD);
|
|
|
|
typedef struct tagEXE_DYN_SHIM_INFO {
|
|
LIST_ENTRY entry;
|
|
LPWSTR pwszFullPath; // full path to the executable.
|
|
DWORD dwToken; // the dynamic shimming token associated with this exe.
|
|
} EXE_DYN_SHIM_INFO, *PEXE_DYN_SHIM_INFO;
|
|
|
|
LIST_ENTRY g_ExeDynShimInfoList;
|
|
|
|
BOOL
|
|
AddExeDynShimInfoToList(
|
|
IN LPCWSTR pwszFullPath,
|
|
IN DWORD dwToken
|
|
);
|
|
|
|
BOOL
|
|
RemoveExeDynShimInfoFromList(
|
|
IN LPCWSTR pwszFullPath
|
|
);
|
|
|
|
extern HINSTANCE ghInstance;
|
|
|
|
//
|
|
// Prototypes of internal functions
|
|
//
|
|
void
|
|
GetExeNTVDMData(
|
|
IN HSDB hSDB, // the SDB context
|
|
IN PSDBQUERYRESULT psdbQuery, // the EXEs and LAYERs that are active
|
|
OUT WCHAR* pszCompatLayer, // The new compat layer variable. with format:
|
|
// "Alpha Bravo Charlie"
|
|
OUT PNTVDM_FLAGS pFlags // The flags
|
|
);
|
|
|
|
|
|
//
|
|
// Appcompat Infrastructure disable-via-policy-flag
|
|
//
|
|
DWORD gdwInfrastructureFlags; // initialized to 0
|
|
|
|
#define APPCOMPAT_INFRA_DISABLED 0x00000001
|
|
#define APPCOMPAT_INFRA_VALID_FLAG 0x80000000
|
|
|
|
#define IsAppcompatInfrastructureDisabled() \
|
|
(!!( (gdwInfrastructureFlags & APPCOMPAT_INFRA_VALID_FLAG) ? \
|
|
(gdwInfrastructureFlags & APPCOMPAT_INFRA_DISABLED) : \
|
|
(CheckAppcompatInfrastructureFlags() & APPCOMPAT_INFRA_DISABLED)) )
|
|
|
|
|
|
DWORD
|
|
CheckAppcompatInfrastructureFlags(
|
|
VOID
|
|
);
|
|
|
|
|
|
#if DBG
|
|
|
|
BOOL
|
|
bDebugChum(
|
|
void
|
|
)
|
|
/*++
|
|
Return: TRUE on success, FALSE otherwise.
|
|
|
|
Desc: Checks an env var. If the var is present return TRUE.
|
|
--*/
|
|
{
|
|
UNICODE_STRING ustrDebugChum;
|
|
UNICODE_STRING ustrDebugChumVal = { 0 };
|
|
NTSTATUS Status;
|
|
|
|
RtlInitUnicodeString(&ustrDebugChum, L"DEBUG_OFFLINE_CONTENT");
|
|
|
|
Status = RtlQueryEnvironmentVariable_U(NULL,
|
|
&ustrDebugChum,
|
|
&ustrDebugChumVal);
|
|
|
|
if (Status == STATUS_BUFFER_TOO_SMALL) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#else // DBG
|
|
#define bDebugChum() TRUE
|
|
#endif // DBG
|
|
|
|
BOOL
|
|
GetExeID(
|
|
IN PDB pdb, // the pointer to the database
|
|
IN TAGID tiExe, // the TAGID of the EXE for which we need the ID
|
|
OUT GUID* pGuid // will receive the EXE's ID
|
|
)
|
|
/*++
|
|
Return: TRUE on success, FALSE otherwise.
|
|
|
|
Desc: Reads the EXE's ID from the database using the EXE's tag id.
|
|
--*/
|
|
{
|
|
TAGID tiExeID;
|
|
|
|
tiExeID = SdbFindFirstTag(pdb, tiExe, TAG_EXE_ID);
|
|
|
|
if (tiExeID == TAGID_NULL) {
|
|
DBGPRINT((sdlError, "GetExeID", "EXE tag 0x%x without an ID !\n", tiExe));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!SdbReadBinaryTag(pdb, tiExeID, (PBYTE)pGuid, sizeof(*pGuid))) {
|
|
DBGPRINT((sdlError, "GetExeID", "Cannot read the ID for EXE tag 0x%x.\n", tiExe));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
GetExeIDByTagRef(
|
|
IN HSDB hSDB, // handle to the database object
|
|
IN TAGREF trExe, // EXE tag ref
|
|
OUT GUID* pGuid // will receive the EXE's ID
|
|
)
|
|
/*++
|
|
Return: TRUE on success, FALSE otherwise.
|
|
|
|
Desc: Reads the EXE's ID from the database using the EXE's tag ref.
|
|
--*/
|
|
{
|
|
PDB pdb;
|
|
TAGID tiExe;
|
|
TAGID tiExeID;
|
|
|
|
if (!SdbTagRefToTagID(hSDB, trExe, &pdb, &tiExe)) {
|
|
DBGPRINT((sdlError,
|
|
"GetExeIDByTagRef",
|
|
"Failed to get the tag id from EXE tag ref 0x%x.\n",
|
|
tiExe));
|
|
return FALSE;
|
|
}
|
|
|
|
return GetExeID(pdb, tiExe, pGuid);
|
|
}
|
|
|
|
|
|
|
|
#define APPHELP_CLSID_REG_PATH L"\\Registry\\Machine\\Software\\Classes\\CLSID\\"
|
|
#define APPHELP_INPROCSERVER32 L"\\InProcServer32"
|
|
|
|
DWORD
|
|
ResolveCOMServer(
|
|
IN REFCLSID CLSID,
|
|
OUT LPWSTR lpPath,
|
|
OUT DWORD dwBufSize)
|
|
{
|
|
DWORD dwReqBufSize = 0;
|
|
UNICODE_STRING ustrKey = { 0 };
|
|
UNICODE_STRING ustrValueName = { 0 };
|
|
UNICODE_STRING ustrGuid = { 0 };
|
|
UNICODE_STRING ustrUnexpandedValue = { 0 };
|
|
UNICODE_STRING ustrValue = { 0 };
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
HANDLE KeyHandle = NULL;
|
|
PKEY_VALUE_FULL_INFORMATION pKeyValueInfo = NULL;
|
|
DWORD dwKeyValueInfoSize = 0;
|
|
DWORD dwKeyValueInfoReqSize = 0;
|
|
LPWSTR wszCLSIDRegFullPath = NULL;
|
|
DWORD dwCLSIDRegFullPathSize = 0;
|
|
WCHAR wszCLSID[41] = { 0 };
|
|
|
|
// Enough for path + CLSID in string form
|
|
dwCLSIDRegFullPathSize = wcslen(APPHELP_CLSID_REG_PATH) +
|
|
wcslen(APPHELP_INPROCSERVER32) + 64;
|
|
|
|
wszCLSIDRegFullPath = RtlAllocateHeap(
|
|
RtlProcessHeap(),
|
|
HEAP_ZERO_MEMORY,
|
|
dwCLSIDRegFullPathSize * sizeof(WCHAR));
|
|
|
|
if (wszCLSIDRegFullPath == NULL) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Memory allocation failure\n"));
|
|
goto Done;
|
|
}
|
|
|
|
StringCchCopyW(wszCLSIDRegFullPath, dwCLSIDRegFullPathSize, APPHELP_CLSID_REG_PATH);
|
|
|
|
Status = RtlStringFromGUID(CLSID, &ustrGuid);
|
|
if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Malformed CLSID\n"));
|
|
goto Done;
|
|
}
|
|
|
|
if (ustrGuid.Length/sizeof(WCHAR) > 40) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"CLSID more than 40 characters\n"));
|
|
goto Done;
|
|
}
|
|
|
|
RtlMoveMemory(wszCLSID,
|
|
ustrGuid.Buffer,
|
|
ustrGuid.Length);
|
|
|
|
wszCLSID[ustrGuid.Length/sizeof(WCHAR)] = L'\0';
|
|
|
|
StringCchCatW(wszCLSIDRegFullPath, dwCLSIDRegFullPathSize, wszCLSID);
|
|
StringCchCatW(wszCLSIDRegFullPath, dwCLSIDRegFullPathSize, APPHELP_INPROCSERVER32);
|
|
|
|
RtlInitUnicodeString(&ustrKey, wszCLSIDRegFullPath);
|
|
RtlInitUnicodeString(&ustrValueName, L"");
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&ustrKey,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
Status = NtOpenKey(&KeyHandle,
|
|
GENERIC_READ,
|
|
&ObjectAttributes);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Failed to open Key \"%s\" Status 0x%x\n",
|
|
wszCLSIDRegFullPath,
|
|
Status));
|
|
goto Done;
|
|
}
|
|
|
|
if (lpPath == NULL &&
|
|
dwBufSize != 0) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Bad parameters\n"));
|
|
goto Done;
|
|
}
|
|
|
|
pKeyValueInfo = RtlAllocateHeap(RtlProcessHeap(),
|
|
HEAP_ZERO_MEMORY,
|
|
dwBufSize * 2);
|
|
|
|
if (pKeyValueInfo == NULL) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Memory allocation failure\n"));
|
|
goto Done;
|
|
}
|
|
|
|
dwKeyValueInfoSize = dwBufSize * 2;
|
|
|
|
Status = NtQueryValueKey(KeyHandle,
|
|
&ustrValueName,
|
|
KeyValueFullInformation,
|
|
pKeyValueInfo,
|
|
dwKeyValueInfoSize,
|
|
&dwKeyValueInfoReqSize);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
|
|
if (Status == STATUS_BUFFER_TOO_SMALL) {
|
|
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pKeyValueInfo);
|
|
|
|
pKeyValueInfo = RtlAllocateHeap(RtlProcessHeap(),
|
|
HEAP_ZERO_MEMORY,
|
|
dwKeyValueInfoReqSize);
|
|
|
|
if (pKeyValueInfo == NULL) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Memory allocation failure\n"));
|
|
goto Done;
|
|
}
|
|
|
|
dwKeyValueInfoSize = dwKeyValueInfoReqSize;
|
|
|
|
Status = NtQueryValueKey(KeyHandle,
|
|
&ustrValueName,
|
|
KeyValueFullInformation,
|
|
pKeyValueInfo,
|
|
dwKeyValueInfoSize,
|
|
&dwKeyValueInfoReqSize);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Failed to retrieve default key value for \"%s\" Status 0x%x\n",
|
|
wszCLSIDRegFullPath,
|
|
Status));
|
|
goto Done;
|
|
}
|
|
|
|
} else {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Failed to retrieve default key value for \"%s\" Status 0x%x\n",
|
|
wszCLSIDRegFullPath,
|
|
Status));
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
if (pKeyValueInfo->Type == REG_SZ) {
|
|
dwReqBufSize = pKeyValueInfo->DataLength + (1 * sizeof(WCHAR));
|
|
|
|
if (dwBufSize >= dwReqBufSize) {
|
|
RtlMoveMemory(lpPath, ((PBYTE) pKeyValueInfo) + pKeyValueInfo->DataOffset, pKeyValueInfo->DataLength);
|
|
lpPath[pKeyValueInfo->DataLength / sizeof(WCHAR)] = '\0';
|
|
}
|
|
|
|
} else if (pKeyValueInfo->Type == REG_EXPAND_SZ) {
|
|
ustrUnexpandedValue.Buffer = (PWSTR) (((PBYTE) pKeyValueInfo) + pKeyValueInfo->DataOffset);
|
|
ustrUnexpandedValue.Length = (USHORT) pKeyValueInfo->DataLength;
|
|
ustrUnexpandedValue.MaximumLength = (USHORT) pKeyValueInfo->DataLength;
|
|
ustrValue.Buffer = lpPath;
|
|
ustrValue.Length = 0;
|
|
ustrValue.MaximumLength = (USHORT) dwBufSize;
|
|
Status = RtlExpandEnvironmentStrings_U(NULL,
|
|
&ustrUnexpandedValue,
|
|
&ustrValue,
|
|
&dwReqBufSize);
|
|
|
|
if (Status == STATUS_BUFFER_TOO_SMALL) {
|
|
goto Done;
|
|
} else if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"Failed to expand key value for \"%s\" Status 0x%x\n",
|
|
wszCLSIDRegFullPath,
|
|
Status));
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
DBGPRINT((sdlInfo,
|
|
"SdbResolveCOMServer",
|
|
"CLSID %s resolved to \"%s\"\n",
|
|
wszCLSID, lpPath));
|
|
|
|
Done:
|
|
|
|
if (KeyHandle != NULL) {
|
|
NtClose(KeyHandle);
|
|
}
|
|
|
|
if (wszCLSIDRegFullPath != NULL) {
|
|
RtlFreeHeap(RtlProcessHeap(), 0, wszCLSIDRegFullPath);
|
|
}
|
|
|
|
if (pKeyValueInfo != NULL) {
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pKeyValueInfo);
|
|
}
|
|
|
|
if (ustrGuid.Buffer != NULL) {
|
|
RtlFreeUnicodeString(&ustrGuid);
|
|
}
|
|
|
|
return dwReqBufSize;
|
|
}
|
|
|
|
VOID
|
|
ParseSdbQueryResult(
|
|
IN HSDB hSDB,
|
|
IN PSDBQUERYRESULT pQuery,
|
|
OUT TAGREF* ptrAppHelp, // apphelp tagref, optional
|
|
OUT PAPPHELP_DATA pApphelpData, // apphelp data, optional
|
|
OUT TAGREF* ptrSxsData // fusion tagref, optional
|
|
)
|
|
{
|
|
DWORD dwIndex;
|
|
BOOL bAppHelp = FALSE;
|
|
BOOL bFusionFix = FALSE;
|
|
TAGREF trExe;
|
|
TAGREF trAppHelp = TAGREF_NULL;
|
|
TAGREF trSxsData = TAGREF_NULL;
|
|
|
|
//
|
|
// scan matching exes; we extract fusion fix (the first one we find) and apphelp data,
|
|
// also the first one we find
|
|
//
|
|
|
|
for (dwIndex = 0; dwIndex < pQuery->dwExeCount; ++dwIndex) {
|
|
trExe = pQuery->atrExes[dwIndex];
|
|
if (ptrAppHelp != NULL && !bAppHelp) {
|
|
bAppHelp = SdbReadApphelpData(hSDB, trExe, pApphelpData);
|
|
if (bAppHelp) {
|
|
trAppHelp = trExe;
|
|
if (ptrSxsData == NULL || bFusionFix) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// see if we have sxs fix as well
|
|
if (ptrSxsData != NULL && !bFusionFix) {
|
|
bFusionFix = GetExeSxsData(hSDB, trExe, NULL, NULL);
|
|
if (bFusionFix) {
|
|
trSxsData = trExe;
|
|
}
|
|
if (bFusionFix && (ptrAppHelp == NULL || bAppHelp)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ptrAppHelp != NULL) {
|
|
*ptrAppHelp = trAppHelp;
|
|
}
|
|
|
|
if (ptrSxsData != NULL) {
|
|
*ptrSxsData = trSxsData;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
InternalCheckRunApp(
|
|
IN HANDLE hFile, // [Optional] Handle to an open file to check
|
|
IN LPCWSTR pwszPath, // path to the app in NT format
|
|
IN LPCWSTR pEnvironment, // pointer to the environment of the process that is
|
|
// being created or NULL.
|
|
IN USHORT uExeType, // executable's image type
|
|
IN OUT PDWORD pdwReason, // collection of flags hinting at why we were called
|
|
OUT PVOID* ppData, // this will contain the pointer to the allocated buffer
|
|
// containing the appcompat data.
|
|
OUT PDWORD pcbData, // if appcompat data is found, the size of the buffer
|
|
// is returned here.
|
|
OUT PVOID* ppSxsData, // out: Sxs data block from the compatibility database
|
|
OUT PDWORD pcbSxsData, // out: sxs data block size
|
|
OUT PDWORD pdwFusionFlags, // out: flags for sxs
|
|
IN BOOL bNTVDMMode, // Are we doing the special NTVDM stuff?
|
|
|
|
IN LPCWSTR szModuleName, // the module name (for NTVDM only)
|
|
|
|
OUT LPWSTR pszCompatLayer, // The new compat layer variable. with format:
|
|
// "__COMPAT_LAYER=Alpha Bravo Charlie"
|
|
OUT PNTVDM_FLAGS pFlags, // The flags
|
|
OUT PAPPHELP_INFO pAHInfo, // If there is apphelp to display, this will be filled
|
|
// in with non-null values
|
|
OUT HSDB* phSDB, // The handle to the database.
|
|
OUT PSDBQUERYRESULT pQueryResult // The query result.
|
|
)
|
|
/*++
|
|
Return: FALSE if the app should be blocked from running, TRUE otherwise.
|
|
|
|
Desc: This is the main API of apphelp.dll. It is called from CreateProcess
|
|
to retrieve application compatibility information for the current process.
|
|
|
|
This function does not check whether the appcompat infrastructure has been
|
|
disabled, (kernel32 checks that)
|
|
|
|
--*/
|
|
{
|
|
|
|
APPHELP_DATA ApphelpData;
|
|
BOOL bSuccess;
|
|
BOOL bRunApp = TRUE; // run by default
|
|
BOOL bAppHelp = FALSE;
|
|
WCHAR* pwszDosPath = NULL;
|
|
BOOL bBypassCache = FALSE; // this is set if cache bypass occured (as opposed to entry not being found
|
|
BOOL bGetSxsData = TRUE;
|
|
BOOL bFusionFix = FALSE;
|
|
HSDB hSDB = NULL;
|
|
SDBQUERYRESULT sdbQuery;
|
|
PSDBQUERYRESULT pSdbQuery = NULL;
|
|
NTSTATUS Status;
|
|
TAGREF trAppHelp = TAGREF_NULL;
|
|
TAGREF trFusionFix = TAGREF_NULL;
|
|
ULARGE_INTEGER uliFusionFlags = {0};
|
|
|
|
UNICODE_STRING ExePath;
|
|
RTL_UNICODE_STRING_BUFFER DosPathBuffer;
|
|
UCHAR BufferPath[MAX_PATH*2];
|
|
|
|
if (phSDB) {
|
|
*phSDB = NULL;
|
|
}
|
|
|
|
if (pQueryResult) {
|
|
pSdbQuery = pQueryResult;
|
|
} else {
|
|
pSdbQuery = &sdbQuery;
|
|
}
|
|
|
|
RtlZeroMemory(pSdbQuery, sizeof(sdbQuery));
|
|
RtlInitUnicodeStringBuffer(&DosPathBuffer, BufferPath, sizeof(BufferPath));
|
|
|
|
RtlInitUnicodeString(&ExePath, pwszPath);
|
|
|
|
Status = RtlAssignUnicodeStringBuffer(&DosPathBuffer, &ExePath);
|
|
if (NT_SUCCESS(Status)) {
|
|
Status = RtlNtPathNameToDosPathName(0, &DosPathBuffer, NULL, NULL);
|
|
}
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlError, "InternalCheckRunApp", "Failed to convert path \"%S\" to DOS.\n", pwszPath));
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// we have been successful, this is 0-terminated dos path
|
|
//
|
|
pwszDosPath = DosPathBuffer.String.Buffer;
|
|
|
|
//
|
|
// Cache lookup was bypassed by one reason or the other.
|
|
// We do not update cache after it had been bypassed.
|
|
//
|
|
if (pdwReason) {
|
|
bBypassCache = !!(*pdwReason & SHIM_CACHE_BYPASS);
|
|
} else {
|
|
bBypassCache = TRUE;
|
|
}
|
|
|
|
hSDB = SdbInitDatabaseEx(0, NULL, uExeType);
|
|
|
|
if (phSDB) {
|
|
*phSDB = hSDB;
|
|
}
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError,
|
|
"InternalCheckRunApp",
|
|
"Failed to initialize the database.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// We didn't find this EXE in the cache. Query the database
|
|
// to get all the info about this EXE.
|
|
//
|
|
SdbGetMatchingExe(hSDB, pwszDosPath, szModuleName, pEnvironment, 0, pSdbQuery);
|
|
|
|
if (pSdbQuery->dwFlags & SHIMREG_DISABLE_SXS) {
|
|
bGetSxsData = FALSE;
|
|
}
|
|
|
|
//
|
|
// get the flags for fusion.
|
|
//
|
|
SdbQueryFlagMask(hSDB, pSdbQuery, TAG_FLAG_MASK_FUSION, &uliFusionFlags.QuadPart, NULL);
|
|
|
|
if (pdwFusionFlags) {
|
|
*pdwFusionFlags = (DWORD)uliFusionFlags.QuadPart;
|
|
}
|
|
|
|
|
|
//
|
|
// find apphelp/and/or Fusion fix
|
|
//
|
|
ParseSdbQueryResult(hSDB,
|
|
pSdbQuery,
|
|
&trAppHelp,
|
|
&ApphelpData,
|
|
bGetSxsData ? &trFusionFix : NULL);
|
|
|
|
bAppHelp = (trAppHelp != TAGREF_NULL);
|
|
|
|
if (bAppHelp) {
|
|
|
|
//
|
|
// Check whether the disable bit is set (the dwFlags has been retrieved from the
|
|
// registry via the SdbReadApphelpData call)
|
|
//
|
|
if (!(pSdbQuery->dwFlags & SHIMREG_DISABLE_APPHELP)) {
|
|
|
|
BOOL bNoUI;
|
|
|
|
//
|
|
// See whether the user has checked "Don't show this anymore" box before.
|
|
//
|
|
bNoUI = ((pSdbQuery->dwFlags & SHIMREG_APPHELP_NOUI) != 0);
|
|
|
|
if (bNoUI) {
|
|
DBGPRINT((sdlInfo,
|
|
"InternalCheckRunApp",
|
|
"NoUI flag is set, apphelp UI disabled for this app.\n"));
|
|
}
|
|
|
|
//
|
|
// Depending on severity of the problem...
|
|
//
|
|
switch (ApphelpData.dwSeverity) {
|
|
case APPHELP_MINORPROBLEM:
|
|
case APPHELP_HARDBLOCK:
|
|
case APPHELP_NOBLOCK:
|
|
case APPHELP_REINSTALL:
|
|
|
|
//
|
|
// NTVDM needs the severity info.
|
|
//
|
|
|
|
if (pAHInfo) {
|
|
pAHInfo->dwSeverity = ApphelpData.dwSeverity;
|
|
}
|
|
|
|
if (bNoUI) {
|
|
bRunApp = (ApphelpData.dwSeverity != APPHELP_HARDBLOCK);
|
|
} else {
|
|
DWORD dwRet;
|
|
|
|
|
|
//
|
|
// We need to show apphelp -- pack up the info
|
|
// so we can hand it off to shimeng or ntvdm.
|
|
//
|
|
pSdbQuery->trAppHelp = trAppHelp;
|
|
|
|
if (pAHInfo) {
|
|
PDB pdb;
|
|
TAGID tiWhich;
|
|
|
|
if (SdbTagRefToTagID(hSDB, trAppHelp, &pdb, &tiWhich)) {
|
|
if (SdbGetDatabaseGUID(hSDB, pdb, &(pAHInfo->guidDB))) {
|
|
pAHInfo->tiExe = tiWhich;
|
|
}
|
|
}
|
|
}
|
|
|
|
bRunApp = TRUE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Some other case was found (e.g. VERSIONSUB which should be replaced
|
|
// by shims in most cases).
|
|
//
|
|
DBGPRINT((sdlWarning,
|
|
"InternalCheckRunApp",
|
|
"Unhandled severity flag 0x%x.\n",
|
|
ApphelpData.dwSeverity));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Apphelp verification is done. Check for shims if we should still run the app.
|
|
//
|
|
if (bRunApp) {
|
|
|
|
if (ppData &&
|
|
(pSdbQuery->atrExes[0] != TAGREF_NULL ||
|
|
pSdbQuery->atrLayers[0] != TAGREF_NULL ||
|
|
pSdbQuery->trAppHelp)) {
|
|
//
|
|
// There are shims for this EXE. Pack the appcompat data
|
|
// so it can be sent to ntdll in the context of the starting EXE.
|
|
//
|
|
SdbPackAppCompatData(hSDB, pSdbQuery, ppData, pcbData);
|
|
}
|
|
|
|
if (ppSxsData && bGetSxsData && trFusionFix != TAGREF_NULL) {
|
|
//
|
|
// See if we have Fusion data to report.
|
|
//
|
|
GetExeSxsData(hSDB, trFusionFix, ppSxsData, pcbSxsData);
|
|
bFusionFix = (ppSxsData != NULL && *ppSxsData != NULL);
|
|
}
|
|
|
|
if (bNTVDMMode) {
|
|
GetExeNTVDMData(hSDB, pSdbQuery, pszCompatLayer, pFlags);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Update the cache now.
|
|
//
|
|
if (!bBypassCache) {
|
|
//
|
|
// Do not update the cache if we got the EXE entry from a local database.
|
|
//
|
|
bBypassCache = (pSdbQuery->atrExes[0] != TAGREF_NULL &&
|
|
!SdbIsTagrefFromMainDB(pSdbQuery->atrExes[0]));
|
|
}
|
|
|
|
if (!bBypassCache) {
|
|
|
|
//
|
|
// We remove from cache only if we have some appcompat data
|
|
//
|
|
BOOL
|
|
bCleanApp = pSdbQuery->atrExes[0] == TAGREF_NULL &&
|
|
pSdbQuery->atrLayers[0] == TAGREF_NULL &&
|
|
!bAppHelp &&
|
|
pSdbQuery->dwFlags == 0 &&
|
|
!bFusionFix;
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE) {
|
|
*pdwReason |= SHIM_CACHE_ACTION;
|
|
if (bCleanApp) {
|
|
*pdwReason |= SHIM_CACHE_UPDATE;
|
|
}
|
|
}
|
|
}
|
|
|
|
Done:
|
|
|
|
RtlFreeUnicodeStringBuffer(&DosPathBuffer);
|
|
|
|
//
|
|
// NTVDM needs to have the database handle open.
|
|
//
|
|
if (!bNTVDMMode) {
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
}
|
|
|
|
return bRunApp;
|
|
}
|
|
|
|
|
|
BOOL
|
|
ApphelpQueryExe(
|
|
IN HSDB hSDB,
|
|
IN LPCWSTR pwszPath, // Unicode path to the executable (DOS_PATH)
|
|
IN BOOL bAppHelpIfNecessary, // Produce AppHelp dialog if necessary
|
|
IN DWORD dwGetMatchingExeFlags,
|
|
OUT SDBQUERYRESULT* pQueryResult // Shim Database Query Result
|
|
)
|
|
/*++
|
|
Return: FALSE if the app should be blocked from running, TRUE otherwise.
|
|
|
|
Desc: This function is similar with ApphelpCheckRunApp but without validating
|
|
cache and Layer flags and doesn't return application compatibility
|
|
information for given app name. It is intended to be called from
|
|
a shim / user mode to verify whether an executable is allowed to run or not.
|
|
|
|
--*/
|
|
{
|
|
BOOL bRunApp = TRUE; // run by default
|
|
DWORD dwDatabaseType = 0;
|
|
DWORD dwSeverity = 0;
|
|
TAGREF trAppHelp = TAGREF_NULL;
|
|
|
|
HAPPHELPINFOCONTEXT hApphelpInfoContext = NULL;
|
|
|
|
//
|
|
// Query the database to get all the info about this EXE.
|
|
// Note:
|
|
// This function is intended to be called from user mode.
|
|
// It doesn't require a call to ConvertToDosPath to string \??\ from the filepath.
|
|
//
|
|
DBGPRINT((sdlInfo,
|
|
"ApphelpCheckExe",
|
|
"Calling SdbGetMatchingExe for \"%s\"\n",
|
|
pwszPath));
|
|
|
|
SdbGetMatchingExe(hSDB, pwszPath, NULL, NULL, dwGetMatchingExeFlags, pQueryResult);
|
|
|
|
|
|
//
|
|
// get info out of the query
|
|
//
|
|
ParseSdbQueryResult(hSDB,
|
|
pQueryResult,
|
|
&trAppHelp,
|
|
NULL, // Apphelp Information api is used here
|
|
NULL); // no sxs fixes are needed
|
|
|
|
|
|
//
|
|
// The last EXE in the list is always the more specific one, and the one we want to
|
|
// use for checking IDs and flags and whatnot.
|
|
//
|
|
if (trAppHelp != TAGREF_NULL) {
|
|
//
|
|
// Read the apphelp data if available for this EXE.
|
|
//
|
|
if (SdbIsTagrefFromMainDB(trAppHelp)) {
|
|
dwDatabaseType |= SDB_DATABASE_MAIN;
|
|
}
|
|
|
|
hApphelpInfoContext = SdbOpenApphelpInformationByID(hSDB,
|
|
trAppHelp,
|
|
dwDatabaseType);
|
|
}
|
|
|
|
//
|
|
// Check whether the disable bit is set (the dwFlags has been retrieved from the
|
|
// registry via the SdbReadApphelpData call)
|
|
//
|
|
if (hApphelpInfoContext != NULL) {
|
|
if (!(pQueryResult->dwFlags & SHIMREG_DISABLE_APPHELP)) {
|
|
BOOL bNoUI;
|
|
|
|
//
|
|
// See whether the user has checked "Don't show this anymore" box before.
|
|
//
|
|
bNoUI = ((pQueryResult->dwFlags & SHIMREG_APPHELP_NOUI) != 0);
|
|
|
|
if (bNoUI) {
|
|
DBGPRINT((sdlInfo,
|
|
"ApphelpCheckExe",
|
|
"NoUI flag is set, apphelp UI disabled for this app.\n"));
|
|
}
|
|
|
|
|
|
SdbQueryApphelpInformation(hApphelpInfoContext,
|
|
ApphelpProblemSeverity,
|
|
&dwSeverity,
|
|
sizeof(dwSeverity));
|
|
|
|
if (!bAppHelpIfNecessary) {
|
|
bNoUI = TRUE;
|
|
}
|
|
|
|
//
|
|
// depending on severity of the problem...
|
|
//
|
|
switch (dwSeverity) {
|
|
case APPHELP_MINORPROBLEM:
|
|
case APPHELP_HARDBLOCK:
|
|
case APPHELP_NOBLOCK:
|
|
case APPHELP_REINSTALL:
|
|
bRunApp = (dwSeverity != APPHELP_HARDBLOCK);
|
|
|
|
if (!bNoUI) {
|
|
DWORD dwRet;
|
|
APPHELP_INFO AHInfo = { 0 };
|
|
|
|
SdbQueryApphelpInformation(hApphelpInfoContext,
|
|
ApphelpDatabaseGUID,
|
|
&AHInfo.guidDB,
|
|
sizeof(AHInfo.guidDB));
|
|
|
|
SdbQueryApphelpInformation(hApphelpInfoContext,
|
|
ApphelpExeTagID,
|
|
&AHInfo.tiExe,
|
|
sizeof(AHInfo.tiExe));
|
|
AHInfo.bOfflineContent = bDebugChum();
|
|
SdbShowApphelpDialog(&AHInfo,
|
|
NULL,
|
|
&bRunApp); // either we succeeded or bInstall package is treated
|
|
// the same way as No UI
|
|
}
|
|
break;
|
|
default:
|
|
//
|
|
// Some other case was found (e.g. VERSIONSUB which should be replaced
|
|
// by shims in most cases).
|
|
//
|
|
DBGPRINT((sdlWarning,
|
|
"ApphelpCheckExe",
|
|
"Unhandled severity flag 0x%x.\n",
|
|
dwSeverity));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Apphelp verification is done.
|
|
//
|
|
|
|
if (hApphelpInfoContext != NULL) {
|
|
SdbCloseApphelpInformation(hApphelpInfoContext);
|
|
}
|
|
|
|
return bRunApp;
|
|
}
|
|
|
|
|
|
/*++
|
|
// This code was used to check for include/exclude list in the database
|
|
// to eliminate confusion entries should ALWAYS provide the list
|
|
//
|
|
// CheckIncludeExcludeList
|
|
// returns: TRUE - database provides the list
|
|
// FALSE - no list is provided in the database
|
|
//
|
|
|
|
BOOL
|
|
CheckIncludeExcludeList(
|
|
IN HSDB hSDB,
|
|
IN SDBQUERYRESULT* pQueryResult
|
|
)
|
|
{
|
|
INT i;
|
|
TAGREF trExe;
|
|
TAGREF trFix;
|
|
TAGREF trInexclude;
|
|
|
|
for (i = 0; i < SDB_MAX_EXES && pQueryResult->atrExes[i] != TAGREF_NULL; ++i) {
|
|
trExe = pQueryResult->atrExes[i];
|
|
trFix = SdbFindFirstTagRef(hSDB, trExe, TAG_SHIM_REF);
|
|
while (trFix != TAGREF_NULL) {
|
|
trInexclude = SdbFindFirstTagRef(hSDB, trFix, TAG_INEXCLUDE);
|
|
if (trInexclude != TAGREF_NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
trFix = SdbFindNextTagRef(hSDB, trExe, trFix);
|
|
}
|
|
}
|
|
|
|
//
|
|
// layers have their own inclusion/exclusion scheme
|
|
//
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
AddExeDynShimInfoToList(
|
|
IN LPCWSTR pwszFullPath,
|
|
IN DWORD dwToken
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
PEXE_DYN_SHIM_INFO pDynShimInfo = NULL;
|
|
DWORD dwLen = 0;
|
|
static BOOL bInitialized = FALSE;
|
|
|
|
if (pwszFullPath == NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
RtlEnterCriticalSection(&g_csDynShimInfo);
|
|
|
|
if (!bInitialized) {
|
|
bInitialized = TRUE;
|
|
InitializeListHead(&g_ExeDynShimInfoList);
|
|
}
|
|
|
|
pDynShimInfo =
|
|
RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, sizeof (EXE_DYN_SHIM_INFO));
|
|
|
|
if (pDynShimInfo == NULL) {
|
|
DBGPRINT((sdlError,"AddExeDynShimInfoToList",
|
|
"Failed to allocate a new dynamic shim info entry for %s\n",
|
|
pwszFullPath));
|
|
goto Done;
|
|
}
|
|
|
|
dwLen = wcslen(pwszFullPath) + 1;
|
|
|
|
pDynShimInfo->pwszFullPath =
|
|
RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, dwLen * sizeof(WCHAR));
|
|
|
|
if (pDynShimInfo->pwszFullPath == NULL) {
|
|
DBGPRINT((sdlError,"AddExeDynShimInfoToList",
|
|
"Failed to allocate a new dynamic shim info entry for %s\n",
|
|
pwszFullPath));
|
|
goto Done;
|
|
}
|
|
|
|
StringCchCopyW(pDynShimInfo->pwszFullPath, dwLen, pwszFullPath);
|
|
pDynShimInfo->dwToken = dwToken;
|
|
|
|
InsertHeadList(&g_ExeDynShimInfoList, &pDynShimInfo->entry);
|
|
|
|
DBGPRINT((sdlInfo,"AddExeDynShimInfoToList",
|
|
"Added %s(token: %d) to the list\n",
|
|
pwszFullPath,
|
|
dwToken));
|
|
|
|
bResult = TRUE;
|
|
|
|
Done:
|
|
|
|
if (!bResult) {
|
|
if (pDynShimInfo) {
|
|
|
|
if (pDynShimInfo->pwszFullPath) {
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pDynShimInfo->pwszFullPath);
|
|
}
|
|
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pDynShimInfo);
|
|
}
|
|
}
|
|
|
|
RtlLeaveCriticalSection(&g_csDynShimInfo);
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
RemoveExeDynShimInfoFromList(
|
|
IN LPCWSTR pwszFullPath
|
|
)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
_pfn_SE_DynamicUnshim pfnDynamicUnshim = NULL;
|
|
HMODULE hmodShimEngine = 0;
|
|
PEXE_DYN_SHIM_INFO pDynShimInfo = NULL;
|
|
PLIST_ENTRY pEntry, pTempEntry;
|
|
PLIST_ENTRY pHead = &g_ExeDynShimInfoList;
|
|
|
|
if (pwszFullPath == NULL) {
|
|
return TRUE;
|
|
}
|
|
|
|
hmodShimEngine = LoadLibraryW(ShimEngine_ModuleName);
|
|
|
|
if (hmodShimEngine == NULL) {
|
|
DBGPRINT((sdlError,"RemoveExeDynShimInfoFromList",
|
|
"Failed to get ShimEngine module handle.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
pfnDynamicUnshim = (_pfn_SE_DynamicUnshim) GetProcAddress(hmodShimEngine, DynamicUnshimProcedureName);
|
|
|
|
if (NULL == pfnDynamicUnshim) {
|
|
DBGPRINT((sdlError,
|
|
"RemoveExeDynShimInfoFromList",
|
|
"Failed to get Dynamic Shim procedure address from ShimEngine module.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
RtlEnterCriticalSection(&g_csDynShimInfo);
|
|
|
|
pEntry = pHead->Flink;
|
|
|
|
while (pEntry != pHead) {
|
|
|
|
pDynShimInfo = CONTAINING_RECORD(pEntry, EXE_DYN_SHIM_INFO, entry);
|
|
|
|
if (_wcsicmp(pDynShimInfo->pwszFullPath, pwszFullPath) == 0) {
|
|
|
|
pTempEntry = pEntry->Flink;
|
|
RemoveEntryList(pEntry);
|
|
|
|
if (!(*pfnDynamicUnshim)(pDynShimInfo->dwToken)) {
|
|
DBGPRINT((sdlInfo,"RemoveExeDynShimInfoFromList",
|
|
"Unshimming %s(token: %d) failed\n",
|
|
pwszFullPath,
|
|
pDynShimInfo->dwToken));
|
|
|
|
bResult = FALSE;
|
|
break;
|
|
}
|
|
|
|
DBGPRINT((sdlInfo,"RemoveExeDynShimInfoFromList",
|
|
"Removed %s(token: %d) from the list\n",
|
|
pwszFullPath,
|
|
pDynShimInfo->dwToken));
|
|
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pDynShimInfo->pwszFullPath);
|
|
RtlFreeHeap(RtlProcessHeap(), 0, pDynShimInfo);
|
|
|
|
bResult = TRUE;
|
|
|
|
//
|
|
// We need to remove all the entries for this exe so keep going.
|
|
//
|
|
pEntry = pTempEntry;
|
|
} else {
|
|
pEntry = pEntry->Flink;
|
|
}
|
|
}
|
|
|
|
RtlLeaveCriticalSection(&g_csDynShimInfo);
|
|
|
|
Done:
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
ApphelpFixExe(
|
|
IN HSDB hSDB,
|
|
IN LPCWSTR pwszPath, // Unicode path to the executable (DOS_PATH)
|
|
IN SDBQUERYRESULT* pQueryResult, // QueryResult
|
|
IN BOOL bUseModuleName // if false, module name is not used for dynamic shimming
|
|
)
|
|
{
|
|
static _pfn_SE_DynamicShim pfnDynamicShim = NULL;
|
|
|
|
HMODULE hmodShimEngine = 0;
|
|
BOOL bResult = FALSE;
|
|
ANSI_STRING AnsiModuleName = { 0 };
|
|
UNICODE_STRING UnicodeModuleName;
|
|
NTSTATUS Status;
|
|
LPCSTR pszModuleName = NULL;
|
|
LPCWSTR pwszModuleName;
|
|
DWORD dwDynamicToken = 0;
|
|
|
|
//
|
|
// Do we need to do anything?
|
|
//
|
|
if (pQueryResult->atrExes[0] == TAGREF_NULL &&
|
|
pQueryResult->atrLayers[0] == TAGREF_NULL) {
|
|
//
|
|
// Nothing for the shim engine to do.
|
|
//
|
|
bResult = TRUE;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Load additional shims for this exe.
|
|
//
|
|
DBGPRINT((sdlInfo,"ApphelpFixExe", "Loading ShimEngine for \"%s\"\n", pwszPath));
|
|
|
|
hmodShimEngine = LoadLibraryW(ShimEngine_ModuleName);
|
|
|
|
if (hmodShimEngine == NULL) {
|
|
DBGPRINT((sdlError,"ApphelpFixExe", "Failed to get ShimEngine module handle.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
pfnDynamicShim = (_pfn_SE_DynamicShim) GetProcAddress(hmodShimEngine, DynamicShimProcedureName);
|
|
|
|
if (NULL == pfnDynamicShim) {
|
|
DBGPRINT((sdlError,
|
|
"ApphelpFixExe",
|
|
"Failed to get Dynamic Shim procedure address from ShimEngine module.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// check inclusion/exclusion list
|
|
//
|
|
if (pwszPath != NULL && bUseModuleName) {
|
|
//
|
|
// no inclusion/exclusion in the xml -- determine module name
|
|
//
|
|
pwszModuleName = wcsrchr(pwszPath, L'\\'); // last backslash please
|
|
|
|
if (pwszModuleName == NULL) {
|
|
pwszModuleName = pwszPath;
|
|
} else {
|
|
++pwszModuleName;
|
|
}
|
|
|
|
//
|
|
// convert to ansi
|
|
//
|
|
RtlInitUnicodeString(&UnicodeModuleName, pwszModuleName);
|
|
Status = RtlUnicodeStringToAnsiString(&AnsiModuleName,
|
|
&UnicodeModuleName,
|
|
TRUE);
|
|
if (!NT_SUCCESS(Status)) {
|
|
DBGPRINT((sdlError, "ApphelpFixExe",
|
|
"Failed to convert unicode string \"%s\" to ansi, Status 0x%lx.\n",
|
|
pwszModuleName, Status));
|
|
|
|
goto Done;
|
|
}
|
|
|
|
pszModuleName = AnsiModuleName.Buffer; // this will be allocated by RtlUnicodeStringToAnsiString
|
|
|
|
}
|
|
|
|
bResult = (*pfnDynamicShim)(pwszPath,
|
|
hSDB,
|
|
pQueryResult,
|
|
pszModuleName,
|
|
&dwDynamicToken);
|
|
if (FALSE == bResult) {
|
|
DBGPRINT((sdlError, "ApphelpFixExe", "Failed to call Dynamic Shim.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
if (pszModuleName == NULL) {
|
|
if (!AddExeDynShimInfoToList(pwszPath, dwDynamicToken)) {
|
|
DBGPRINT((sdlError, "ApphelpFixExe",
|
|
"Failed to add %s(token: %d) to the list\n",
|
|
pwszPath,
|
|
dwDynamicToken));
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
bResult = TRUE;
|
|
|
|
Done:
|
|
|
|
RtlFreeAnsiString(&AnsiModuleName); // this will do nothing if string is empty
|
|
return bResult;
|
|
}
|
|
|
|
BOOL
|
|
ApphelpCheckExe(
|
|
IN LPCWSTR pwszPath, // Unicode path to the executable (DOS_PATH)
|
|
IN BOOL bAppHelpIfNecessary, // Only present AppHelp this executable if TRUE
|
|
IN BOOL bShimIfNecessary, // Only load shim for this executable if TRUE
|
|
IN BOOL bUseModuleName // use module name when inclusion/exclusion list is not provided
|
|
)
|
|
/*++
|
|
Return: FALSE if the app should be blocked from running, TRUE otherwise.
|
|
|
|
Desc: If you are calling this API with the last parameter set to FALSE and it returns
|
|
TRUE, you'll have to call ApphelpReleaseExe when you are done running this exe.
|
|
|
|
--*/
|
|
{
|
|
BOOL bRunApp = TRUE;
|
|
SDBQUERYRESULT QueryResult;
|
|
HSDB hSDB;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
goto Done;
|
|
}
|
|
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
hSDB = SdbInitDatabaseEx(0, NULL, IMAGE_FILE_MACHINE_I386);
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckExe", "Failed to initialize database.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
bRunApp = ApphelpQueryExe(hSDB,
|
|
pwszPath,
|
|
bAppHelpIfNecessary,
|
|
SDBGMEF_IGNORE_ENVIRONMENT,
|
|
&QueryResult);
|
|
|
|
if (TRUE == bRunApp && TRUE == bShimIfNecessary) {
|
|
ApphelpFixExe(hSDB, pwszPath, &QueryResult, bUseModuleName);
|
|
}
|
|
|
|
SdbReleaseDatabase(hSDB);
|
|
|
|
Done:
|
|
|
|
return bRunApp;
|
|
}
|
|
|
|
BOOL
|
|
ApphelpReleaseExe(
|
|
IN LPCWSTR pwszPath // Unicode path to the executable (DOS_PATH)
|
|
)
|
|
{
|
|
return RemoveExeDynShimInfoFromList(pwszPath);
|
|
}
|
|
|
|
BOOL
|
|
ApphelpCheckIME(
|
|
IN LPCWSTR pwszPath // Unicode path to the exe
|
|
)
|
|
{
|
|
BOOL bRunApp = TRUE;
|
|
SDBQUERYRESULT QueryResult;
|
|
HSDB hSDB;
|
|
BOOL bCleanApp;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
return TRUE;
|
|
}
|
|
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
hSDB = SdbInitDatabase(0, NULL);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckIME", "Failed to initialize database.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
bRunApp = ApphelpQueryExe(hSDB,
|
|
pwszPath,
|
|
TRUE,
|
|
SDBGMEF_IGNORE_ENVIRONMENT,
|
|
&QueryResult);
|
|
|
|
if (TRUE == bRunApp) {
|
|
ApphelpFixExe(hSDB, pwszPath, &QueryResult, FALSE);
|
|
}
|
|
|
|
SdbReleaseDatabase(hSDB);
|
|
|
|
//
|
|
// see that it's in the cache if no fixes
|
|
//
|
|
bCleanApp = QueryResult.atrExes[0] == TAGREF_NULL &&
|
|
QueryResult.atrLayers[0] == TAGREF_NULL &&
|
|
QueryResult.trAppHelp == TAGREF_NULL &&
|
|
QueryResult.dwFlags == 0;
|
|
|
|
#ifndef WIN2K_NOCACHE
|
|
|
|
BaseUpdateAppcompatCache(pwszPath, INVALID_HANDLE_VALUE, !bCleanApp);
|
|
|
|
#endif
|
|
|
|
Done:
|
|
|
|
return bRunApp;
|
|
}
|
|
|
|
BOOL
|
|
ApphelpCheckShellObject(
|
|
IN REFCLSID ObjectCLSID,
|
|
IN BOOL bShimIfNecessary,
|
|
OUT ULONGLONG* pullFlags
|
|
)
|
|
/*++
|
|
Return: FALSE if the object should be blocked from instantiating, TRUE otherwise.
|
|
|
|
Desc: This is a helper function for Explorer and Internet Explorer that will
|
|
allow those applications to detect bad extension objects and either
|
|
block them from running or fix them.
|
|
|
|
pullFlags is filled with a 64-bit flag mask that can be used to turn
|
|
on 'hack' flags in Explorer/IE. These are pulled out of the App Compat
|
|
database.
|
|
|
|
If the database indicates that a shim should be used to fix the extension
|
|
and bShimIfNecessary is TRUE, this function will load SHIMENG.DLL and
|
|
apply the fix.
|
|
|
|
--*/
|
|
{
|
|
BOOL bGoodObject = TRUE;
|
|
LPWSTR szComServer = NULL;
|
|
LPWSTR szDLLName = NULL;
|
|
DWORD dwBufSize = 0;
|
|
DWORD dwReqBufSize = 0;
|
|
SDBQUERYRESULT QueryResult;
|
|
HSDB hSDB = NULL;
|
|
PVOID pModuleHandle = NULL;
|
|
UNICODE_STRING ustrDLLName = { 0 };
|
|
UNICODE_STRING ustrNtPath = { 0 };
|
|
NTSTATUS status;
|
|
HANDLE hDLL = INVALID_HANDLE_VALUE;
|
|
DWORD dwReason;
|
|
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (pullFlags != NULL) {
|
|
*pullFlags = 0;
|
|
}
|
|
|
|
szComServer = RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, MAX_PATH);
|
|
|
|
if (szComServer == NULL) {
|
|
DBGPRINT((sdlInfo,"ApphelpCheckShellObject", "Memory allocation error\n"));
|
|
goto Done;
|
|
}
|
|
|
|
dwBufSize = MAX_PATH;
|
|
|
|
//
|
|
// Turn the CLSID into a filename (ie, the DLL that serves the object)
|
|
//
|
|
dwReqBufSize = ResolveCOMServer(ObjectCLSID, szComServer, dwBufSize);
|
|
|
|
if (dwReqBufSize == 0) {
|
|
//
|
|
// CLSID could not be resolved to a DLL.
|
|
//
|
|
goto Done;
|
|
}
|
|
|
|
if (dwReqBufSize > dwBufSize) {
|
|
|
|
RtlFreeHeap(RtlProcessHeap(), 0, szComServer);
|
|
szComServer = RtlAllocateHeap(RtlProcessHeap(), HEAP_ZERO_MEMORY, dwReqBufSize);
|
|
|
|
if (szComServer == NULL) {
|
|
DBGPRINT((sdlInfo,"ApphelpCheckShellObject", "Memory allocation error\n"));
|
|
goto Done;
|
|
}
|
|
|
|
dwBufSize = dwReqBufSize;
|
|
|
|
dwReqBufSize = ResolveCOMServer(ObjectCLSID, szComServer, dwBufSize);
|
|
|
|
if (dwReqBufSize > dwBufSize || dwReqBufSize == 0) {
|
|
//
|
|
// What? Buffer size changed. This could happen if registration of an
|
|
// object took place between the time we first queried and the next time.
|
|
// Just being paranoid...
|
|
//
|
|
DBGPRINT((sdlInfo,"ApphelpCheckShellObject", "Memory allocation error\n"));
|
|
goto Done;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Determine DLL name (w/o path). Walk back to first backslash.
|
|
//
|
|
szDLLName = szComServer + dwReqBufSize/sizeof(WCHAR);
|
|
|
|
while (szDLLName >= szComServer) {
|
|
if (*szDLLName == L'\\') {
|
|
break;
|
|
}
|
|
|
|
szDLLName--;
|
|
}
|
|
|
|
szDLLName++;
|
|
|
|
//
|
|
// Check if this DLL is already loaded. If so, no need to try and do anything
|
|
// since it's really too late anyway.
|
|
//
|
|
RtlInitUnicodeString(&ustrDLLName, szDLLName);
|
|
|
|
status = LdrGetDllHandle(NULL,
|
|
NULL,
|
|
&ustrDLLName,
|
|
&pModuleHandle);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
//
|
|
// Already loaded.
|
|
//
|
|
goto Done;
|
|
}
|
|
|
|
if (!RtlDosPathNameToNtPathName_U(szComServer,
|
|
&ustrNtPath,
|
|
NULL,
|
|
NULL)) {
|
|
DBGPRINT((sdlError,
|
|
"ApphelpCheckShellObject",
|
|
"RtlDosPathNameToNtPathName_U failed, path \"%s\"\n",
|
|
szComServer));
|
|
goto Done;
|
|
}
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&ustrNtPath,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
status = NtCreateFile(&hDLL,
|
|
GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
0,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
FILE_SHARE_READ,
|
|
FILE_OPEN,
|
|
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DBGPRINT((sdlError,
|
|
"ApphelpCheckShellObject",
|
|
"SdbpOpenFile failed, path \"%s\"\n",
|
|
szComServer));
|
|
goto Done;
|
|
}
|
|
|
|
if (BaseCheckAppcompatCache(ustrNtPath.Buffer, hDLL, NULL, &dwReason)) {
|
|
//
|
|
// We have this in cache
|
|
//
|
|
goto Done;
|
|
}
|
|
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
hSDB = SdbInitDatabase(0, NULL);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckShellObject", "Failed to initialize database.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
bGoodObject = ApphelpQueryExe(hSDB,
|
|
szComServer,
|
|
FALSE,
|
|
SDBGMEF_IGNORE_ENVIRONMENT,
|
|
&QueryResult);
|
|
|
|
if (TRUE == bGoodObject && TRUE == bShimIfNecessary) {
|
|
ApphelpFixExe(hSDB, szComServer, &QueryResult, FALSE);
|
|
}
|
|
|
|
SdbQueryFlagMask(hSDB, &QueryResult, TAG_FLAG_MASK_SHELL, pullFlags, NULL);
|
|
|
|
//
|
|
// we might want to use Apphelp api for this -- but shell does pass the right
|
|
// thing to us (most likely)
|
|
//
|
|
BaseUpdateAppcompatCache(ustrNtPath.Buffer,
|
|
hDLL,
|
|
!(QueryResult.atrExes[0] == TAGREF_NULL &&
|
|
QueryResult.atrLayers[0] == TAGREF_NULL));
|
|
|
|
Done:
|
|
|
|
RtlFreeUnicodeString(&ustrNtPath);
|
|
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
|
|
if (hDLL != INVALID_HANDLE_VALUE) {
|
|
NtClose(hDLL);
|
|
}
|
|
|
|
if (szComServer != NULL) {
|
|
RtlFreeHeap(RtlProcessHeap(), 0, szComServer);
|
|
}
|
|
|
|
return bGoodObject;
|
|
}
|
|
|
|
BOOL
|
|
ApphelpGetNTVDMInfo(
|
|
IN LPCWSTR pwszPath, // path to the app in NT format
|
|
IN LPCWSTR pwszModule, // module name
|
|
IN LPCWSTR pEnvironment, // pointer to the environment of the task that is
|
|
// being created or NULL if we are to use the main NTVDM
|
|
// environment block.
|
|
OUT LPWSTR pszCompatLayer, // The new compat layer variable. with format:
|
|
// "Alpha Bravo Charlie" -- allow 256 chars for this.
|
|
OUT PNTVDM_FLAGS pFlags, // The flags
|
|
OUT PAPPHELP_INFO pAHInfo, // If there is apphelp to display, this will be filled
|
|
// in with non-null values
|
|
OUT HSDB* phSDB, // The handle to the database.
|
|
OUT PSDBQUERYRESULT pQueryResult // The query result.
|
|
)
|
|
/*++
|
|
Return: FALSE if the app should be blocked from running, TRUE otherwise.
|
|
|
|
Desc: This is essentially the equivalent of ApphelpCheckRunApp, but specific
|
|
to NTVDM.
|
|
--*/
|
|
{
|
|
DWORD dwReason = 0;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
return TRUE;
|
|
}
|
|
|
|
return InternalCheckRunApp(INVALID_HANDLE_VALUE, pwszPath, pEnvironment,
|
|
IMAGE_FILE_MACHINE_I386, &dwReason,
|
|
NULL, NULL, NULL, NULL, NULL, TRUE,
|
|
pwszModule, pszCompatLayer, pFlags, pAHInfo,
|
|
phSDB, pQueryResult);
|
|
}
|
|
|
|
void
|
|
GetExeNTVDMData(
|
|
IN HSDB hSDB, // the SDB context
|
|
IN PSDBQUERYRESULT psdbQuery, // the EXEs and LAYERs that are active
|
|
OUT WCHAR* pszCompatLayer, // The new compat layer variable. with format:
|
|
// "Alpha Bravo Charlie"
|
|
OUT PNTVDM_FLAGS pFlags // The flags
|
|
)
|
|
{
|
|
DWORD i;
|
|
ULARGE_INTEGER uliFlags;
|
|
LPVOID pFlagContext = NULL;
|
|
HRESULT hr;
|
|
|
|
ZeroMemory(pFlags, sizeof(NTVDM_FLAGS));
|
|
|
|
//
|
|
// Build the layer variable, and look for the two "special" layers
|
|
//
|
|
if (pszCompatLayer) {
|
|
pszCompatLayer[0] = 0;
|
|
|
|
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) {
|
|
//
|
|
// check for one of the two "special" layers
|
|
//
|
|
if (_wcsicmp(pszEnvVar, L"640X480") == 0) {
|
|
//
|
|
// set the 640x480 flag -- found in base\mvdm\inc\wowcmpat.h
|
|
//
|
|
// NOTE: we don't have this flag yet -- waiting on WOW guys
|
|
}
|
|
if (_wcsicmp(pszEnvVar, L"256COLOR") == 0) {
|
|
//
|
|
// set the 256 color flag -- found in base\mvdm\inc\wowcmpat.h
|
|
//
|
|
pFlags->dwWOWCompatFlagsEx |= 0x00000002;
|
|
}
|
|
|
|
hr = StringCchCatW(pszCompatLayer, COMPATLAYERMAXLEN, pszEnvVar);
|
|
if (hr == S_OK) {
|
|
hr = StringCchCatW(pszCompatLayer, COMPATLAYERMAXLEN, L" ");
|
|
}
|
|
|
|
if (hr == STRSAFE_E_INSUFFICIENT_BUFFER) {
|
|
DBGPRINT((sdlError, "GetExeNTVDMData", "pszCompatLayer not big enough.\n"));
|
|
|
|
//
|
|
// If the buffer is not big enough, we just set it to an empty string -
|
|
// we don't want to fill in incomplete data.
|
|
//
|
|
pszCompatLayer[0] = 0;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Look for compat flags
|
|
//
|
|
SdbQueryFlagMask(hSDB, psdbQuery, TAG_FLAGS_NTVDM1, &uliFlags.QuadPart, &pFlagContext);
|
|
pFlags->dwWOWCompatFlags |= uliFlags.LowPart;
|
|
pFlags->dwWOWCompatFlagsEx |= uliFlags.HighPart;
|
|
|
|
SdbQueryFlagMask(hSDB, psdbQuery, TAG_FLAGS_NTVDM2, &uliFlags.QuadPart, &pFlagContext);
|
|
pFlags->dwUserWOWCompatFlags |= uliFlags.LowPart;
|
|
pFlags->dwWOWCompatFlags2 |= uliFlags.HighPart;
|
|
|
|
SdbQueryFlagMask(hSDB, psdbQuery, TAG_FLAGS_NTVDM3, &uliFlags.QuadPart, &pFlagContext);
|
|
pFlags->dwWOWCompatFlagsFE |= uliFlags.LowPart;
|
|
// High Part is unused for now.
|
|
|
|
// now pack command line parameters
|
|
|
|
SdbpPackCmdLineInfo(pFlagContext, &pFlags->pFlagsInfo);
|
|
SdbpFreeFlagInfoList(pFlagContext);
|
|
}
|
|
|
|
|
|
BOOL
|
|
ApphelpCheckRunApp(
|
|
IN HANDLE hFile, // [Optional] Handle to an open file to check
|
|
IN WCHAR* pwszPath, // path to the app in NT format
|
|
IN WCHAR* pEnvironment, // pointer to the environment of the process that is
|
|
// being created or NULL.
|
|
IN USHORT uExeType, // executable's image type
|
|
IN PDWORD pdwReason, // collection of flags hinting at why we were called
|
|
OUT PVOID* ppData, // this will contain the pointer to the allocated buffer
|
|
// containing the appcompat data.
|
|
OUT PDWORD pcbData, // if appcompat data is found, the size of the buffer
|
|
// is returned here.
|
|
OUT PVOID* ppSxsData, // BUGBUG: describe
|
|
OUT PDWORD pcbSxsData, // BUGBUG: describe
|
|
OUT PDWORD pdwFusionFlags
|
|
)
|
|
/*++
|
|
Return: FALSE if the app should be blocked from running, TRUE otherwise.
|
|
|
|
Desc: This is the main API of apphelp.dll. It is called from CreateProcess
|
|
to retrieve application compatibility information for the current process.
|
|
--*/
|
|
{
|
|
return InternalCheckRunApp(hFile, pwszPath, pEnvironment, uExeType, pdwReason,
|
|
ppData, pcbData, ppSxsData, pcbSxsData,pdwFusionFlags,
|
|
FALSE, NULL, NULL, NULL, NULL, NULL, NULL);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// =============================================================================================
|
|
// InstallShield 7 Support
|
|
// =============================================================================================
|
|
//
|
|
BOOL
|
|
ApphelpCheckInstallShieldPackage(
|
|
IN REFCLSID PackageID,
|
|
IN LPCWSTR lpszPackageFullPath
|
|
)
|
|
{
|
|
BOOL bPackageGood = TRUE; // This return value MUST TRUE otherwise InstallShield7 will cancel its processes.
|
|
|
|
TAGREF trExe = TAGREF_NULL;
|
|
|
|
DWORD dwNumExes = 0;
|
|
DWORD dwDataType = 0;
|
|
DWORD dwSize = 0;
|
|
DWORD dwReturn = 0;
|
|
|
|
BOOL bMatchFound = FALSE;
|
|
NTSTATUS Status;
|
|
|
|
BOOL bAppHelpIfNecessary = FALSE;
|
|
BOOL bResult = TRUE;
|
|
|
|
WCHAR wszCLSID[41];
|
|
WCHAR wszPackageCode[41];
|
|
|
|
GUID guidPackageID;
|
|
GUID guidPackageCode;
|
|
|
|
HSDB hSDB = NULL;
|
|
SDBQUERYRESULT QueryResult;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
goto Done;
|
|
}
|
|
|
|
if (NULL == lpszPackageFullPath) {
|
|
DBGPRINT((sdlInfo,
|
|
"ApphelpCheckInstallShieldPackage",
|
|
"lpszPackageFullPath is NULL\n"));
|
|
goto Done;
|
|
}
|
|
|
|
SdbGUIDToString((GUID *)&PackageID, wszCLSID, CHARCOUNT(wszCLSID));
|
|
|
|
DBGPRINT((sdlWarning,
|
|
"ApphelpCheckInstallShieldPackage",
|
|
"InstallShield package detected. CLSID: %s FullPath: %s\n",
|
|
wszCLSID, lpszPackageFullPath));
|
|
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
hSDB = SdbInitDatabase(0, NULL);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckExe", "Failed to initialize database.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
bMatchFound = ApphelpQueryExe(hSDB,
|
|
lpszPackageFullPath,
|
|
bAppHelpIfNecessary,
|
|
SDBGMEF_IGNORE_ENVIRONMENT,
|
|
&QueryResult);
|
|
|
|
if (!bMatchFound)
|
|
{
|
|
DBGPRINT((sdlError, "ApphelpCheckInstallShieldPackage", "No match found.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
for (dwNumExes = 0; dwNumExes < SDB_MAX_EXES; ++dwNumExes)
|
|
{
|
|
if (TAGREF_NULL == QueryResult.atrExes[dwNumExes]) {
|
|
break;
|
|
}
|
|
trExe = QueryResult.atrExes[dwNumExes];
|
|
|
|
DBGPRINT((sdlInfo, "ApphelpCheckInstallShieldPackage", "Processing TAGREF atrExes[%d] = 0x%8x.\n", dwNumExes, trExe));
|
|
|
|
dwSize = sizeof(wszPackageCode);
|
|
*wszPackageCode = L'\0';
|
|
|
|
dwReturn = SdbQueryData( hSDB,
|
|
trExe,
|
|
L"PackageCode",
|
|
&dwDataType,
|
|
wszPackageCode,
|
|
&dwSize);
|
|
|
|
if (dwReturn == ERROR_SUCCESS)
|
|
{
|
|
DBGPRINT((sdlInfo, "ApphelpCheckInstallShieldPackage", "SdbQueryData returns dwSize = %d and dwDataType = %d.\n", dwSize, dwDataType));
|
|
|
|
if ((dwSize > 0) && (dwSize < sizeof(wszPackageCode)))
|
|
{
|
|
// we have some data
|
|
// check the type (should be string)
|
|
if (REG_SZ != dwDataType)
|
|
{
|
|
DBGPRINT((sdlError, "ApphelpCheckInstallShieldPackage", "SdbQueryData returns non STRING PackageCode data. Exiting.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
DBGPRINT((sdlInfo, "ApphelpCheckInstallShieldPackage", "Comparing PackageId = %s and PackageCode = %s.\n", wszCLSID, wszPackageCode));
|
|
|
|
// convert to guid
|
|
if (FALSE == SdbGUIDFromString(wszPackageCode, &guidPackageCode))
|
|
{
|
|
DBGPRINT((sdlError, "ApphelpCheckInstallShieldPackage", "Can not convert PackageCode to GUID. Exiting.\n"));
|
|
goto Done;
|
|
}
|
|
|
|
if (RtlEqualMemory(PackageID, &guidPackageCode, sizeof(guidPackageCode) ))
|
|
{
|
|
DBGPRINT((sdlWarning, "ApphelpCheckInstallShieldPackage",
|
|
"Found InstallShield package matched with PackageCode: %s.\n",
|
|
wszPackageCode));
|
|
|
|
if (TRUE != ApphelpFixExe(hSDB, lpszPackageFullPath, &QueryResult, FALSE))
|
|
{
|
|
DBGPRINT((sdlError, "ApphelpCheckInstallShieldPackage", "Can not load additional shim dynamically for this executable.\n"));
|
|
}
|
|
goto Done;
|
|
}
|
|
}
|
|
}
|
|
} // for
|
|
|
|
DBGPRINT((sdlError, "ApphelpCheckInstallShieldPackage", "No match found.\n"));
|
|
|
|
Done:
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
|
|
return bPackageGood;
|
|
}
|
|
|
|
|
|
//
|
|
// =============================================================================================
|
|
// MSI Support
|
|
// =============================================================================================
|
|
//
|
|
|
|
BOOL
|
|
SDBAPI
|
|
ApphelpCheckMsiPackage(
|
|
IN GUID* pguidDB, // database id
|
|
IN GUID* pguidID, // match id
|
|
IN DWORD dwFlags, // not used now, set to 0
|
|
IN BOOL bNoUI
|
|
)
|
|
{
|
|
WCHAR szDatabasePath[MAX_PATH];
|
|
DWORD dwDatabaseType = 0;
|
|
DWORD dwPackageFlags = 0;
|
|
DWORD dwLength;
|
|
BOOL bInstallPackage = TRUE;
|
|
HSDB hSDB = NULL;
|
|
TAGREF trPackage = TAGREF_NULL;
|
|
|
|
HAPPHELPINFOCONTEXT hApphelpInfoContext = NULL;
|
|
DWORD dwSeverity = 0;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
goto out;
|
|
}
|
|
|
|
hSDB = SdbInitDatabase(HID_NO_DATABASE, NULL);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to initialize database\n"));
|
|
goto out;
|
|
}
|
|
|
|
SdbSetImageType(hSDB, IMAGE_FILE_MSI);
|
|
|
|
//
|
|
// First, we need to resolve a db
|
|
//
|
|
dwLength = SdbResolveDatabase(hSDB,
|
|
pguidDB,
|
|
&dwDatabaseType,
|
|
szDatabasePath,
|
|
CHARCOUNT(szDatabasePath));
|
|
|
|
if (dwLength == 0 || dwLength > CHARCOUNT(szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to resolve database path\n"));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// open database
|
|
//
|
|
|
|
if (!SdbOpenLocalDatabase(hSDB, szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to open database \"%s\"\n", szDatabasePath));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// find the entry
|
|
//
|
|
trPackage = SdbFindMsiPackageByID(hSDB, pguidID);
|
|
if (trPackage == TAGREF_NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to find msi package by guid id\n"));
|
|
goto out;
|
|
}
|
|
|
|
hApphelpInfoContext = SdbOpenApphelpInformationByID(hSDB,
|
|
trPackage,
|
|
dwDatabaseType);
|
|
if (hApphelpInfoContext == NULL) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Apphelp information has not been found\n"));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// we have apphelp data, check to see if we have flags for this exe
|
|
//
|
|
|
|
if (!SdbGetEntryFlags(pguidID, &dwPackageFlags)) {
|
|
DBGPRINT((sdlWarning, "ApphelpCheckMsiPackage",
|
|
"No flags for trPackage 0x%x\n", trPackage));
|
|
dwPackageFlags = 0;
|
|
}
|
|
|
|
//
|
|
// Check whether the disable bit is set (the dwFlags has been retrieved from the
|
|
// registry via the SdbReadApphelpData call)
|
|
//
|
|
if (dwPackageFlags & SHIMREG_DISABLE_APPHELP) {
|
|
goto out;
|
|
}
|
|
|
|
|
|
bNoUI |= !!(dwPackageFlags & SHIMREG_APPHELP_NOUI);
|
|
if (bNoUI) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"NoUI flag is set, apphelp UI disabled for this app.\n"));
|
|
}
|
|
|
|
SdbQueryApphelpInformation(hApphelpInfoContext,
|
|
ApphelpProblemSeverity,
|
|
&dwSeverity,
|
|
sizeof(dwSeverity));
|
|
|
|
//
|
|
// depending on severity of the problem...
|
|
//
|
|
switch (dwSeverity) {
|
|
case APPHELP_MINORPROBLEM:
|
|
case APPHELP_HARDBLOCK:
|
|
case APPHELP_NOBLOCK:
|
|
case APPHELP_REINSTALL:
|
|
|
|
//
|
|
//
|
|
//
|
|
bInstallPackage = (APPHELP_HARDBLOCK != dwSeverity);
|
|
if (!bNoUI) {
|
|
DWORD dwRet;
|
|
APPHELP_INFO AHInfo = { 0 };
|
|
|
|
AHInfo.guidDB = *pguidDB;
|
|
AHInfo.bMSI = TRUE;
|
|
SdbQueryApphelpInformation(hApphelpInfoContext,
|
|
ApphelpExeTagID,
|
|
&AHInfo.tiExe,
|
|
sizeof(AHInfo.tiExe));
|
|
if (AHInfo.tiExe != TAGID_NULL) {
|
|
|
|
AHInfo.bOfflineContent = bDebugChum();
|
|
|
|
SdbShowApphelpDialog(&AHInfo, NULL, &bInstallPackage);
|
|
// either we succeeded or bInstall package is treated
|
|
// the same way as No UI
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// Some other case was found (e.g. VERSIONSUB which should be replaced
|
|
// by shims in most cases).
|
|
//
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Unhandled severity flag 0x%x.\n", dwSeverity));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// at this point we know whether we want to install the package or not
|
|
//
|
|
|
|
|
|
out:
|
|
|
|
if (hApphelpInfoContext != NULL) {
|
|
SdbCloseApphelpInformation(hApphelpInfoContext);
|
|
}
|
|
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
|
|
|
|
return bInstallPackage;
|
|
}
|
|
|
|
BOOL
|
|
SDBAPI
|
|
ApphelpFixMsiPackage(
|
|
IN GUID* pguidDB,
|
|
IN GUID* pguidID,
|
|
IN LPCWSTR pszFileName,
|
|
IN LPCWSTR pszActionName,
|
|
IN DWORD dwFlags
|
|
)
|
|
{
|
|
WCHAR szDatabasePath[MAX_PATH];
|
|
DWORD dwDatabaseType = 0;
|
|
HSDB hSDB = NULL;
|
|
TAGREF trPackage = TAGREF_NULL;
|
|
TAGREF trAction = TAGREF_NULL;
|
|
SDBQUERYRESULT QueryResult;
|
|
BOOL bSuccess = FALSE;
|
|
DWORD dwLength;
|
|
TAGREF trLayer, trLayerRef;
|
|
DWORD dwLayers = 0;
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
bSuccess = TRUE;
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// open database. In this case we need to have the default database
|
|
// for this platform being opened, later on we modify the context
|
|
// Fixes will be looked up in a default main db though
|
|
//
|
|
|
|
hSDB = SdbInitDatabase(0, NULL);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to initialize database\n"));
|
|
goto out;
|
|
}
|
|
|
|
SdbSetImageType(hSDB, IMAGE_FILE_MSI);
|
|
|
|
//
|
|
// from this point on, all resolutions will be based on msi image type
|
|
// however all the fixes will come from the database that is standard for
|
|
// this platform
|
|
//
|
|
|
|
|
|
//
|
|
// First, we need to resolve a db
|
|
//
|
|
dwLength = SdbResolveDatabase(hSDB,
|
|
pguidDB,
|
|
&dwDatabaseType,
|
|
szDatabasePath,
|
|
CHARCOUNT(szDatabasePath));
|
|
|
|
if (dwLength == 0 || dwLength > CHARCOUNT(szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to resolve database path\n"));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// open database
|
|
//
|
|
|
|
if (!SdbOpenLocalDatabase(hSDB, szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to open database \"%s\"\n", szDatabasePath));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// find the entry
|
|
//
|
|
trPackage = SdbFindMsiPackageByID(hSDB, pguidID);
|
|
if (trPackage == TAGREF_NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to find msi package by guid id\n"));
|
|
goto out;
|
|
}
|
|
|
|
if (SdbGetEntryFlags(pguidID, &dwFlags) && (dwFlags & SHIMREG_DISABLE_SHIM)) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Shims for this package are disabled\n"));
|
|
|
|
goto out;
|
|
}
|
|
|
|
trAction = SdbFindCustomActionForPackage(hSDB, trPackage, pszActionName);
|
|
if (trAction == TAGREF_NULL) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Failed to find custom action \"%s\"\n", pszActionName));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// we have custom action on our hands which appears to have fixes
|
|
// attached to it, shim it!
|
|
//
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
QueryResult.guidID = *pguidID;
|
|
QueryResult.atrExes[0] = trAction;
|
|
|
|
//
|
|
// get all the layers for this entry
|
|
// also remember that tthe layers and shims alike might not be in the default
|
|
// database initialized in the beginning of this call
|
|
//
|
|
trLayerRef = SdbFindFirstTagRef(hSDB, trAction, TAG_LAYER);
|
|
while (trLayerRef != TAGREF_NULL && dwLayers < SDB_MAX_LAYERS) {
|
|
trLayer = SdbGetNamedLayer(hSDB, trLayerRef);
|
|
if (trLayer != TAGREF_NULL) {
|
|
QueryResult.atrLayers[dwLayers++] = trLayer;
|
|
}
|
|
trLayerRef = SdbFindNextTagRef(hSDB, trAction, trLayerRef);
|
|
}
|
|
|
|
|
|
//
|
|
// ready to shim
|
|
//
|
|
bSuccess = ApphelpFixExe(hSDB, pszFileName, &QueryResult, TRUE);
|
|
if (bSuccess) {
|
|
DBGPRINT((sdlInfo, "ApphelpFixMsiPackage",
|
|
"Custom action \"%s\" successfully shimmed file \"%s\"\n",
|
|
pszActionName, pszFileName));
|
|
}
|
|
|
|
out:
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
|
|
|
|
return(bSuccess);
|
|
}
|
|
|
|
BOOL
|
|
SDBAPI
|
|
ApphelpFixMsiPackageExe(
|
|
IN GUID* pguidDB,
|
|
IN GUID* pguidID,
|
|
IN LPCWSTR pszActionName,
|
|
IN OUT LPWSTR pwszEnv,
|
|
IN OUT LPDWORD pdwBufferSize
|
|
)
|
|
{
|
|
|
|
WCHAR szDatabasePath[MAX_PATH];
|
|
DWORD dwDatabaseType = 0;
|
|
HSDB hSDB = NULL;
|
|
TAGREF trPackage = TAGREF_NULL;
|
|
TAGREF trAction = TAGREF_NULL;
|
|
SDBQUERYRESULT QueryResult;
|
|
DWORD dwLength;
|
|
DWORD dwBufferSize;
|
|
BOOL bSuccess = FALSE;
|
|
DWORD dwFlags;
|
|
int i;
|
|
TAGREF trLayer;
|
|
|
|
if (pwszEnv != NULL) {
|
|
*pwszEnv = TEXT('\0');
|
|
}
|
|
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
goto out;
|
|
}
|
|
|
|
hSDB = SdbInitDatabaseEx(HID_NO_DATABASE, NULL, IMAGE_FILE_MSI);
|
|
|
|
if (hSDB == NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to initialize database\n"));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// First, we need to resolve a db
|
|
//
|
|
dwLength = SdbResolveDatabase(hSDB,
|
|
pguidDB,
|
|
&dwDatabaseType,
|
|
szDatabasePath,
|
|
CHARCOUNT(szDatabasePath));
|
|
|
|
if (dwLength == 0 || dwLength > CHARCOUNT(szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to resolve database path\n"));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// open database
|
|
//
|
|
|
|
if (!SdbOpenLocalDatabase(hSDB, szDatabasePath)) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to open database \"%s\"\n", szDatabasePath));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// find the entry
|
|
//
|
|
trPackage = SdbFindMsiPackageByID(hSDB, pguidID);
|
|
if (trPackage == TAGREF_NULL) {
|
|
DBGPRINT((sdlError, "ApphelpCheckMsiPackage",
|
|
"Failed to find msi package by guid id\n"));
|
|
goto out;
|
|
}
|
|
|
|
if (SdbGetEntryFlags(pguidID, &dwFlags) && (dwFlags & SHIMREG_DISABLE_SHIM)) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Shims for this package are disabled\n"));
|
|
|
|
goto out;
|
|
}
|
|
|
|
trAction = SdbFindCustomActionForPackage(hSDB, trPackage, pszActionName);
|
|
if (trAction == TAGREF_NULL) {
|
|
DBGPRINT((sdlInfo, "ApphelpCheckMsiPackage",
|
|
"Failed to find custom action \"%s\"\n", pszActionName));
|
|
goto out;
|
|
}
|
|
|
|
//
|
|
// now -- this action is an exe, do it right for him
|
|
//
|
|
RtlZeroMemory(&QueryResult, sizeof(QueryResult));
|
|
|
|
QueryResult.guidID = *pguidID;
|
|
|
|
for (i = 0; i < SDB_MAX_LAYERS; ++i) {
|
|
//
|
|
// check to see if we are doing the first layer, if so - call
|
|
// find first to obtain the layer, else find the next applicable layer
|
|
//
|
|
|
|
if (i == 0) {
|
|
trLayer = SdbFindFirstTagRef(hSDB, trAction, TAG_LAYER);
|
|
} else {
|
|
trLayer = SdbFindNextTagRef (hSDB, trAction, trLayer);
|
|
}
|
|
|
|
if (trLayer == TAGREF_NULL) {
|
|
break;
|
|
}
|
|
|
|
QueryResult.atrLayers[i] = trLayer;
|
|
}
|
|
|
|
dwLength = 0;
|
|
if (pdwBufferSize != NULL) {
|
|
dwLength = *pdwBufferSize;
|
|
}
|
|
|
|
//
|
|
// build compat layer
|
|
//
|
|
dwBufferSize = SdbBuildCompatEnvVariables(hSDB,
|
|
&QueryResult,
|
|
0,
|
|
NULL,
|
|
pwszEnv,
|
|
dwLength,
|
|
NULL);
|
|
|
|
if (pdwBufferSize != NULL) {
|
|
*pdwBufferSize = dwBufferSize;
|
|
}
|
|
|
|
bSuccess = TRUE;
|
|
|
|
out:
|
|
|
|
if (hSDB != NULL) {
|
|
SdbReleaseDatabase(hSDB);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
|
|
|
|
/*++
|
|
Function:
|
|
|
|
CheckAppcompatInfrastructureFlags
|
|
|
|
Description:
|
|
|
|
Checks various registry places for infrastructure global flags (just the disabled bit for now)
|
|
The flags are set into the global variable gdwInfrastructureFlags. Function is used via the macro
|
|
for perf reasons
|
|
|
|
Return:
|
|
global infrastructure flags
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
CheckAppcompatInfrastructureFlags(
|
|
VOID
|
|
)
|
|
{
|
|
gdwInfrastructureFlags = 0; // initialize just in case
|
|
|
|
if (BaseIsAppcompatInfrastructureDisabled()) {
|
|
gdwInfrastructureFlags |= APPCOMPAT_INFRA_DISABLED;
|
|
}
|
|
|
|
//
|
|
// make the bits valid
|
|
//
|
|
gdwInfrastructureFlags |= APPCOMPAT_INFRA_VALID_FLAG;
|
|
|
|
return gdwInfrastructureFlags;
|
|
}
|
|
|
|
/*++
|
|
Function:
|
|
|
|
SdbInitDatabaseExport
|
|
|
|
Description:
|
|
|
|
This is "exported" version of the function SdbInitDatabase
|
|
that checks for the "diabled" flag -- otherwise calls into SdbInitDatabase
|
|
|
|
Return:
|
|
|
|
see SdbInitDatabase
|
|
|
|
--*/
|
|
|
|
HSDB
|
|
SDBAPI
|
|
SdbInitDatabaseExport(
|
|
IN DWORD dwFlags, // flags that tell how the database should be
|
|
// initialized.
|
|
IN LPCWSTR pszDatabasePath // the OPTIONAL full path to the database to
|
|
// be used.
|
|
)
|
|
{
|
|
if (IsAppcompatInfrastructureDisabled()) {
|
|
return NULL;
|
|
}
|
|
|
|
return SdbInitDatabase(dwFlags, pszDatabasePath);
|
|
}
|
|
|
|
|