windows-server-2003/windows/appcompat/apphelp/check.c

/*++

    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);
}