hsdb.c File Reference

#include "windows.h"
#include "ntndk.h"
#include "strsafe.h"
#include "apphelp.h"
#include "compat_undoc.h"

Include dependency graph for hsdb.c:

Go to the source code of this file.

Classes
struct	_ShimData

Macros
#define	WIN32_NO_STATUS
#define	MAX_LAYER_LENGTH   256
#define	GPLK_USER   1
#define	GPLK_MACHINE   2
#define	SHIMDATA_MAGIC   0xAC0DEDAB
#define	REACTOS_COMPATVERSION_IGNOREMANIFEST   0xffffffff

Typedefs
typedef struct _ShimData	ShimData

Functions
	C_ASSERT (SHIMDATA_MAGIC==REACTOS_SHIMDATA_MAGIC)
	C_ASSERT (sizeof(ShimData)==sizeof(ReactOS_ShimData))
	C_ASSERT (offsetof(ShimData, dwMagic)==offsetof(ReactOS_ShimData, dwMagic))
	C_ASSERT (offsetof(ShimData, dwRosProcessCompatVersion)==offsetof(ReactOS_ShimData, dwRosProcessCompatVersion))
static BOOL WINAPI	SdbpFileExists (LPCWSTR path)
static BOOL	SdbpMatchFileAttributes (PDB pdb, TAGID matching_file, PATTRINFO attribs, DWORD attr_count)
static BOOL WINAPI	SdbpMatchExe (PDB pdb, TAGID exe, const WCHAR *dir, PATTRINFO main_attribs, DWORD main_attr_count)
static void	SdbpAddDatabaseGuid (PDB pdb, PSDBQUERYRESULT result)
static BOOL	SdbpAddSingleLayerMatch (TAGREF layer, PSDBQUERYRESULT result)
static BOOL	SdbpAddNamedLayerMatch (HSDB hsdb, PCWSTR layerName, PSDBQUERYRESULT result)
static void	SdbpAddExeLayers (HSDB hsdb, PDB pdb, TAGID tagExe, PSDBQUERYRESULT result)
static void	SdbpAddExeMatch (HSDB hsdb, PDB pdb, TAGID tagExe, PSDBQUERYRESULT result)
static ULONG	SdbpAddLayerMatches (HSDB hsdb, PWSTR pwszLayers, DWORD pdwBytes, PSDBQUERYRESULT result)
static BOOL	SdbpPropagateEnvLayers (HSDB hsdb, LPWSTR Environment, PSDBQUERYRESULT Result)
HSDB WINAPI	SdbInitDatabase (DWORD flags, LPCWSTR path)
void WINAPI	SdbReleaseDatabase (HSDB hsdb)
BOOL WINAPI	SdbGetMatchingExe (HSDB hsdb, LPCWSTR path, LPCWSTR module_name, LPCWSTR env, DWORD flags, PSDBQUERYRESULT result)
HRESULT WINAPI	SdbGetAppPatchDir (HSDB hsdb, LPWSTR path, DWORD size)
BOOL WINAPI	SdbTagRefToTagID (HSDB hsdb, TAGREF trWhich, PDB *ppdb, TAGID *ptiWhich)
BOOL WINAPI	SdbTagIDToTagRef (HSDB hsdb, PDB pdb, TAGID tiWhich, TAGREF *ptrWhich)
BOOL WINAPI	SdbPackAppCompatData (HSDB hsdb, PSDBQUERYRESULT pQueryResult, PVOID *ppData, DWORD *pdwSize)
BOOL WINAPI	SdbUnpackAppCompatData (HSDB hsdb, LPCWSTR pszImageName, PVOID pData, PSDBQUERYRESULT pQueryResult)
DWORD WINAPI	SdbGetAppCompatDataSize (ShimData *pData)
DWORD WINAPI	SdbQueryDataEx (HSDB hsdb, TAGREF trWhich, LPCWSTR lpszDataName, LPDWORD lpdwDataType, LPVOID lpBuffer, LPDWORD lpcbBufferSize, TAGREF *ptrData)
DWORD WINAPI	SdbQueryData (HSDB hsdb, TAGREF trWhich, LPCWSTR lpszDataName, LPDWORD lpdwDataType, LPVOID lpBuffer, LPDWORD lpcbBufferSize)

Macro Definition Documentation

GPLK_MACHINE

#define GPLK_MACHINE   2

Definition at line 19 of file hsdb.c.

GPLK_USER

#define GPLK_USER   1

Definition at line 18 of file hsdb.c.

MAX_LAYER_LENGTH

#define MAX_LAYER_LENGTH   256

Definition at line 17 of file hsdb.c.

REACTOS_COMPATVERSION_IGNOREMANIFEST

#define REACTOS_COMPATVERSION_IGNOREMANIFEST   0xffffffff

Definition at line 36 of file hsdb.c.

SHIMDATA_MAGIC

#define SHIMDATA_MAGIC   0xAC0DEDAB

Definition at line 35 of file hsdb.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 10 of file hsdb.c.

Typedef Documentation

ShimData

typedef struct _ShimData ShimData

Function Documentation

C_ASSERT() [1/4]

C_ASSERT

(

offsetof(ShimData, dwMagic)

= =offsetof(ReactOS_ShimData, dwMagic)

)

C_ASSERT() [2/4]

C_ASSERT

(

offsetof(ShimData, dwRosProcessCompatVersion)

= =offsetof(ReactOS_ShimData, dwRosProcessCompatVersion)

)

C_ASSERT() [3/4]

C_ASSERT

(

SHIMDATA_MAGIC

= =REACTOS_SHIMDATA_MAGIC

)

C_ASSERT() [4/4]

C_ASSERT

(

sizeof(ShimData)

= =sizeof(ReactOS_ShimData)

)

SdbGetAppCompatDataSize()

DWORD WINAPI SdbGetAppCompatDataSize

(

ShimData *

pData

)

Definition at line 790 of file hsdb.c.

{
    if (!pData || pData->dwMagic != SHIMDATA_MAGIC)
        return 0;
 
    return pData->dwSize;
}

SdbGetAppPatchDir()

HRESULT WINAPI SdbGetAppPatchDir	(	HSDB	hsdb,
		LPWSTR	path,
		DWORD	size
	)

Retrieves AppPatch directory.

Parameters

[in]	pdb	Handle to the shim database.
[out]	path	Pointer to memory in which path shall be written.
[in]	size	Size of the buffer in characters.

Definition at line 592 of file hsdb.c.

{
    static WCHAR* default_dir = NULL;
    static CONST WCHAR szAppPatch[] = {'\\','A','p','p','P','a','t','c','h',0};
 
    /* In case function fails, path holds empty string */
    if (size > 0)
        *path = 0;
 
    if (!default_dir)
    {
        WCHAR* tmp;
        HRESULT hr = E_FAIL;
        UINT len = GetSystemWindowsDirectoryW(NULL, 0) + SdbpStrlen(szAppPatch);
        tmp = SdbAlloc((len + 1)* sizeof(WCHAR));
        if (tmp)
        {
            UINT r = GetSystemWindowsDirectoryW(tmp, len+1);
            if (r && r < len)
            {
                hr = StringCchCatW(tmp, len+1, szAppPatch);
                if (SUCCEEDED(hr))
                {
                    if (InterlockedCompareExchangePointer((void**)&default_dir, tmp, NULL) == NULL)
                        tmp = NULL;
                }
            }
            if (tmp)
                SdbFree(tmp);
        }
        if (!default_dir)
        {
            SHIM_ERR("Unable to obtain default AppPatch directory (0x%x)\n", hr);
            return hr;
        }
    }
 
    if (!hsdb)
    {
        return StringCchCopyW(path, size, default_dir);
    }
    else
    {
        SHIM_ERR("Unimplemented for hsdb != NULL\n");
        return E_NOTIMPL;
    }
}

Referenced by CLayerStringList::CLayerStringList(), SdbInitDatabase(), SeiInit(), and START_TEST().

SdbGetMatchingExe()

BOOL WINAPI SdbGetMatchingExe	(	HSDB	hsdb,
		LPCWSTR	path,
		LPCWSTR	module_name,
		LPCWSTR	env,
		DWORD	flags,
		PSDBQUERYRESULT	result
	)

Queries database for a specified exe If hsdb is NULL default database shall be loaded and searched.

Parameters

[in]	hsdb	Handle to the shim database.
[in]	path	Path to executable for which we query database.
[in]	module_name	Unused.
[in]	env	The environment block to use
[in]	flags	0 or SDBGMEF_IGNORE_ENVIRONMENT.
[out]	result	Pointer to structure in which query result shall be stored.

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 445 of file hsdb.c.

{
    BOOL ret = FALSE;
    TAGID database, iter, name;
    PATTRINFO attribs = NULL;
    DWORD attr_count;
    RTL_UNICODE_STRING_BUFFER DosApplicationName = { { 0 } };
    WCHAR DosPathBuffer[MAX_PATH];
    ULONG PathType = 0;
    LPWSTR file_name;
    WCHAR wszLayers[MAX_LAYER_LENGTH];
    DWORD dwSize;
    PDB pdb;
 
    /* Load default database if one is not specified */
    if (!hsdb)
    {
        /* To reproduce windows behaviour HID_DOS_PATHS needs
         * to be specified when loading default database */
        hsdb = SdbInitDatabase(HID_DOS_PATHS | SDB_DATABASE_MAIN_SHIM, NULL);
        if (hsdb)
            hsdb->auto_loaded = TRUE;
    }
 
    ZeroMemory(result, sizeof(*result));
 
    /* No database could be loaded */
    if (!hsdb || !path)
        return FALSE;
 
    /* We do not support multiple db's yet! */
    pdb = hsdb->pdb;
 
    RtlInitUnicodeString(&DosApplicationName.String, path);
    RtlInitBuffer(&DosApplicationName.ByteBuffer, (PUCHAR)DosPathBuffer, sizeof(DosPathBuffer));
    if (!NT_SUCCESS(RtlEnsureBufferSize(RTL_SKIP_BUFFER_COPY, &DosApplicationName.ByteBuffer, DosApplicationName.String.MaximumLength)))
    {
        SHIM_ERR("Failed to convert allocate buffer.\n");
        goto Cleanup;
    }
    /* Update the internal buffer to contain the string */
    memcpy(DosApplicationName.ByteBuffer.Buffer, path, DosApplicationName.String.MaximumLength);
    /* Make sure the string uses our internal buffer (we want to modify the buffer,
        and RtlNtPathNameToDosPathName does not always modify the String to point to the Buffer)! */
    DosApplicationName.String.Buffer = (PWSTR)DosApplicationName.ByteBuffer.Buffer;
 
    if (!NT_SUCCESS(RtlNtPathNameToDosPathName(0, &DosApplicationName, &PathType, NULL)))
    {
        SHIM_ERR("Failed to convert %S to DOS Path.\n", path);
        goto Cleanup;
    }
 
 
    /* Extract file name */
    file_name = wcsrchr(DosApplicationName.String.Buffer, '\\');
    if (!file_name)
    {
        SHIM_ERR("Failed to find Exe name in %wZ.\n", &DosApplicationName.String);
        goto Cleanup;
    }
 
    /* We will use the buffer for exe name and directory. */
    *(file_name++) = UNICODE_NULL;
 
    /* DATABASE is list TAG which contains all executables */
    database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
    if (database == TAGID_NULL)
    {
        goto Cleanup;
    }
 
    /*
     * Instead of brute-force searching the 'entire' DB, we should:
     * 1. Iterate over the Index TAG_EXE.TAG_WILDCARD_NAME
     * 2. Search the index TAG_EXE.TAG_NAME (fallback to SdbFindFirstNamedTag)
     * 3. Search the index TAG_EXE.TAG_16BIT_MODULE_NAME (fallback to SdbFindFirstNamedTag)
     */
 
 
    /* EXE is list TAG which contains data required to match executable */
    for (iter = SdbFindFirstTag(pdb, database, TAG_EXE); iter != TAGID_NULL; iter = SdbFindNextTag(pdb, database, iter))
    {
        name = SdbFindFirstTag(pdb, iter, TAG_NAME);
        LPWSTR foundName = SdbGetStringTagPtr(pdb, name);
        /* If this is a malformed DB, (no TAG_NAME), we should not crash. */
        if (!foundName)
            continue;
 
        /* We only support full wildcard names for now */
        BOOL isWildcard = foundName[0] == '*' && foundName[1] == UNICODE_NULL;
 
        /* Check if exe name matches */
        if (isWildcard || !_wcsicmp(foundName, file_name))
        {
            /* Get information about executable required to match it with database entry */
            if (!attribs)
            {
                if (!SdbGetFileAttributes(path, &attribs, &attr_count))
                    goto Cleanup;
            }
 
 
            /* We have a null terminator before the application name, so DosApplicationName only contains the path. */
            if (SdbpMatchExe(pdb, iter, DosApplicationName.String.Buffer, attribs, attr_count))
            {
                ret = TRUE;
                SdbpAddExeMatch(hsdb, pdb, iter, result);
            }
        }
    }
 
    /* Restore the full path. */
    *(--file_name) = L'\\';
 
    dwSize = sizeof(wszLayers);
    if (SdbGetPermLayerKeys(DosApplicationName.String.Buffer, wszLayers, &dwSize, GPLK_MACHINE | GPLK_USER))
    {
        SdbpAddLayerMatches(hsdb, wszLayers, dwSize, result);
        ret = TRUE;
    }
 
    if (!(flags & SDBGMEF_IGNORE_ENVIRONMENT))
    {
        if (SdbpPropagateEnvLayers(hsdb, (LPWSTR)env, result))
        {
            ret = TRUE;
            result->dwFlags |= SHIMREG_HAS_ENVIRONMENT;
        }
    }
 
Cleanup:
    RtlFreeBuffer(&DosApplicationName.ByteBuffer);
    if (attribs)
        SdbFreeFileAttributes(attribs);
    if (hsdb->auto_loaded)
        SdbReleaseDatabase(hsdb);
    return ret;
}

Referenced by ApphelpCheckRunAppEx().

SdbInitDatabase()

HSDB WINAPI SdbInitDatabase	(	DWORD	flags,
		LPCWSTR	path
	)

Opens specified shim database file. Handle returned by this function may only be used by functions which take HSDB param thus differing it from SdbOpenDatabase.

Parameters

[in]	flags	Specifies type of path or predefined database.
[in]	path	Path to the shim database file.

Returns

Success: Handle to the opened shim database, NULL otherwise.

Definition at line 375 of file hsdb.c.

{
    static const WCHAR shim[] = {'\\','s','y','s','m','a','i','n','.','s','d','b',0};
    static const WCHAR msi[] = {'\\','m','s','i','m','a','i','n','.','s','d','b',0};
    static const WCHAR drivers[] = {'\\','d','r','v','m','a','i','n','.','s','d','b',0};
    LPCWSTR name;
    WCHAR buffer[128];
    HSDB hsdb;
 
    hsdb = SdbAlloc(sizeof(SDB));
    if (!hsdb)
        return NULL;
    hsdb->auto_loaded = 0;
 
    /* Check for predefined databases */
    if ((flags & HID_DATABASE_TYPE_MASK) && path == NULL)
    {
        switch (flags & HID_DATABASE_TYPE_MASK)
        {
            case SDB_DATABASE_MAIN_SHIM: name = shim; break;
            case SDB_DATABASE_MAIN_MSI: name = msi; break;
            case SDB_DATABASE_MAIN_DRIVERS: name = drivers; break;
            default:
                SdbReleaseDatabase(hsdb);
                return NULL;
        }
        SdbGetAppPatchDir(NULL, buffer, _countof(buffer));
        StringCchCatW(buffer, _countof(buffer), name);
        flags = HID_DOS_PATHS;
    }
 
    hsdb->pdb = SdbOpenDatabase(path ? path : buffer, (flags & 0xF) - 1);
 
    /* If database could not be loaded, a handle doesn't make sense either */
    if (!hsdb->pdb)
    {
        SdbReleaseDatabase(hsdb);
        return NULL;
    }
 
    return hsdb;
}

Referenced by ApphelpCheckRunAppEx(), SdbGetMatchingExe(), SdbPackAppCompatData(), and SeiGetShimData().

SdbPackAppCompatData()

BOOL WINAPI SdbPackAppCompatData	(	HSDB	hsdb,
		PSDBQUERYRESULT	pQueryResult,
		PVOID *	ppData,
		DWORD *	pdwSize
	)

Definition at line 700 of file hsdb.c.

{
    ShimData* pData;
    HRESULT hr;
    DWORD n;
    BOOL bCloseDatabase = FALSE;
 
    if (!pQueryResult || !ppData || !pdwSize)
    {
        SHIM_WARN("Invalid params: %p, %p, %p\n", pQueryResult, ppData, pdwSize);
        return FALSE;
    }
 
    pData = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ShimData));
    if (!pData)
    {
        SHIM_WARN("Unable to allocate %d bytes\n", sizeof(ShimData));
        return FALSE;
    }
 
    GetSystemWindowsDirectoryW(pData->szModule, _countof(pData->szModule));
    hr = StringCchCatW(pData->szModule, _countof(pData->szModule), L"\\system32\\apphelp.dll");
    if (!SUCCEEDED(hr))
    {
        SHIM_ERR("Unable to append module name (0x%x)\n", hr);
        RtlFreeHeap(RtlGetProcessHeap(), 0, pData);
        return FALSE;
    }
 
    pData->dwSize = sizeof(*pData);
    pData->dwMagic = SHIMDATA_MAGIC;
    pData->Query = *pQueryResult;
    pData->dwRosProcessCompatVersion = 0;
    pData->szLayer[0] = UNICODE_NULL;   /* TODO */
 
    SHIM_INFO("\ndwFlags    0x%x\ndwMagic    0x%x\ntrExe      0x%x\ntrLayer    0x%x\n",
              pData->Query.dwFlags, pData->dwMagic, pData->Query.atrExes[0], pData->Query.atrLayers[0]);
 
    /* Database List */
    /* 0x0 {GUID} NAME: Use to open HSDB */
    if (hsdb == NULL)
    {
        hsdb = SdbInitDatabase(HID_DOS_PATHS | SDB_DATABASE_MAIN_SHIM, NULL);
        bCloseDatabase = TRUE;
    }
 
    for (n = 0; n < pQueryResult->dwLayerCount; ++n)
    {
        DWORD dwValue = 0, dwType;
        DWORD dwValueSize = sizeof(dwValue);
        SHIM_INFO("Layer 0x%x\n", pQueryResult->atrLayers[n]);
 
        if (SdbQueryData(hsdb, pQueryResult->atrLayers[n], L"SHIMVERSIONNT", &dwType, &dwValue, &dwValueSize) == ERROR_SUCCESS &&
            dwType == REG_DWORD && dwValueSize == sizeof(dwValue))
        {
            if (dwValue != REACTOS_COMPATVERSION_IGNOREMANIFEST)
                dwValue = (dwValue % 100) | ((dwValue / 100) << 8);
            if (dwValue > pData->dwRosProcessCompatVersion)
                pData->dwRosProcessCompatVersion = dwValue;
        }
    }
 
    if (pData->dwRosProcessCompatVersion)
        SHIM_INFO("Setting ProcessCompatVersion 0x%x\n", pData->dwRosProcessCompatVersion);
 
    if (bCloseDatabase)
        SdbReleaseDatabase(hsdb);
 
    *ppData = pData;
    *pdwSize = pData->dwSize;
 
    return TRUE;
}

SdbpAddDatabaseGuid()

static void SdbpAddDatabaseGuid ( PDB  pdb, PSDBQUERYRESULT  result  )

static

Definition at line 189 of file hsdb.c.

{
    size_t n;
 
    for (n = 0; n < _countof(result->rgGuidDB); ++n)
    {
        if (!memcmp(&result->rgGuidDB[n], &pdb->database_id, sizeof(pdb->database_id)))
            return;
 
        if (result->dwCustomSDBMap & (1<<n))
            continue;
 
        memcpy(&result->rgGuidDB[n], &pdb->database_id, sizeof(result->rgGuidDB[n]));
        result->dwCustomSDBMap |= (1<<n);
        return;
    }
}

Referenced by SdbpAddExeMatch(), and SdbpAddNamedLayerMatch().

SdbpAddExeLayers()

static void SdbpAddExeLayers ( HSDB  hsdb, PDB  pdb, TAGID  tagExe, PSDBQUERYRESULT  result  )

static

Definition at line 253 of file hsdb.c.

{
    TAGID layer = SdbFindFirstTag(pdb, tagExe, TAG_LAYER);
 
    while (layer != TAGID_NULL)
    {
        TAGREF tr;
        TAGID layerIdTag = SdbFindFirstTag(pdb, layer, TAG_LAYER_TAGID);
        DWORD tagId = SdbReadDWORDTag(pdb, layerIdTag, TAGID_NULL);
 
        if (layerIdTag != TAGID_NULL &&
            tagId != TAGID_NULL &&
            SdbTagIDToTagRef(hsdb, pdb, tagId, &tr))
        {
            SdbpAddSingleLayerMatch(tr, result);
        }
        else
        {
            /* Try a name lookup */
            TAGID layerTag = SdbFindFirstTag(pdb, layer, TAG_NAME);
            if (layerTag != TAGID_NULL)
            {
                LPCWSTR layerName = SdbGetStringTagPtr(pdb, layerTag);
                if (layerName)
                {
                    SdbpAddNamedLayerMatch(hsdb, layerName, result);
                }
            }
        }
 
        layer = SdbFindNextTag(pdb, tagExe, layer);
    }
}

Referenced by SdbpAddExeMatch().

SdbpAddExeMatch()

static void SdbpAddExeMatch ( HSDB  hsdb, PDB  pdb, TAGID  tagExe, PSDBQUERYRESULT  result  )

static

Definition at line 288 of file hsdb.c.

{
    size_t n;
    TAGREF tr;
 
    if (!SdbTagIDToTagRef(hsdb, pdb, tagExe, &tr))
        return;
 
    for (n = 0; n < result->dwExeCount; ++n)
    {
        if (result->atrExes[n] == tr)
            return;
    }
 
    if (n >= _countof(result->atrExes))
        return;
 
    result->atrExes[n] = tr;
    result->dwExeCount++;
 
    SdbpAddExeLayers(hsdb, pdb, tagExe, result);
 
    SdbpAddDatabaseGuid(pdb, result);
}

Referenced by SdbGetMatchingExe().

SdbpAddLayerMatches()

static ULONG SdbpAddLayerMatches ( HSDB  hsdb, PWSTR  pwszLayers, DWORD  pdwBytes, PSDBQUERYRESULT  result  )

static

Definition at line 314 of file hsdb.c.

{
    PWSTR start = pwszLayers, p;
    ULONG Added = 0;
 
    const PWSTR end = pwszLayers + (pdwBytes / sizeof(WCHAR));
    while (start < end && (*start == L'!' || *start == L'#' || *start == L' ' || *start == L'\t'))
        start++;
 
    if (start == end)
        return 0;
 
    do
    {
        while (*start == L' ' || *start == L'\t')
            ++start;
 
        if (*start == UNICODE_NULL)
            break;
        p = wcspbrk(start, L" \t");
 
        if (p)
            *p = UNICODE_NULL;
 
        if (SdbpAddNamedLayerMatch(hsdb, start, result))
            Added++;
 
        start = p + 1;
    } while (start < end && p);
 
    return Added;
}

Referenced by SdbGetMatchingExe(), and SdbpPropagateEnvLayers().

SdbpAddNamedLayerMatch()

static BOOL SdbpAddNamedLayerMatch ( HSDB  hsdb, PCWSTR  layerName, PSDBQUERYRESULT  result  )

static

Definition at line 228 of file hsdb.c.

{
    TAGID database, layer;
    TAGREF tr;
    PDB pdb = hsdb->pdb;
 
    database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
    if (database == TAGID_NULL)
        return FALSE;
 
    layer = SdbFindFirstNamedTag(pdb, database, TAG_LAYER, TAG_NAME, layerName);
    if (layer == TAGID_NULL)
        return FALSE;
 
    if (!SdbTagIDToTagRef(hsdb, pdb, layer, &tr))
        return FALSE;
 
    if (!SdbpAddSingleLayerMatch(tr, result))
        return FALSE;
 
    SdbpAddDatabaseGuid(pdb, result);
    return TRUE;
}

Referenced by SdbpAddExeLayers(), and SdbpAddLayerMatches().

SdbpAddSingleLayerMatch()

static BOOL SdbpAddSingleLayerMatch ( TAGREF  layer, PSDBQUERYRESULT  result  )

static

Definition at line 208 of file hsdb.c.

{
    size_t n;
 
    for (n = 0; n < result->dwLayerCount; ++n)
    {
        if (result->atrLayers[n] == layer)
            return FALSE;
    }
 
    if (n >= _countof(result->atrLayers))
        return FALSE;
 
    result->atrLayers[n] = layer;
    result->dwLayerCount++;
 
    return TRUE;
}

Referenced by SdbpAddExeLayers(), and SdbpAddNamedLayerMatch().

SdbpFileExists()

static BOOL WINAPI SdbpFileExists ( LPCWSTR  path )

static

Definition at line 46 of file hsdb.c.

{
    DWORD attr = GetFileAttributesW(path);
    return (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY));
}

Referenced by SdbpMatchExe().

SdbpMatchExe()

static BOOL WINAPI SdbpMatchExe ( PDB  pdb, TAGID  exe, const WCHAR *  dir, PATTRINFO  main_attribs, DWORD  main_attr_count  )

static

Definition at line 115 of file hsdb.c.

{
    RTL_UNICODE_STRING_BUFFER FullPathName = { { 0 } };
    WCHAR FullPathBuffer[MAX_PATH];
    UNICODE_STRING UnicodeDir;
    TAGID matching_file;
    PATTRINFO attribs = NULL;
    DWORD attr_count;
    BOOL IsMatch = FALSE;
 
    RtlInitUnicodeString(&UnicodeDir, dir);
    RtlInitBuffer(&FullPathName.ByteBuffer, (PUCHAR)FullPathBuffer, sizeof(FullPathBuffer));
 
    for (matching_file = SdbFindFirstTag(pdb, exe, TAG_MATCHING_FILE);
            matching_file != TAGID_NULL; matching_file = SdbFindNextTag(pdb, exe, matching_file))
    {
        TAGID tagName = SdbFindFirstTag(pdb, matching_file, TAG_NAME);
        UNICODE_STRING Name;
        USHORT Len;
 
        RtlInitUnicodeString(&Name, SdbGetStringTagPtr(pdb, tagName));
 
        if (!Name.Buffer)
            goto Cleanup;
 
        /* An '*' here means use the main executable' */
        if (!wcscmp(Name.Buffer, L"*"))
        {
            /* We already have these attributes, so we do not need to retrieve them */
            if (!SdbpMatchFileAttributes(pdb, matching_file, main_attribs, main_attr_count))
                goto Cleanup;
            continue;
        }
 
        /* Technically, one UNICODE_NULL and one path separator. */
        Len = UnicodeDir.Length + Name.Length + sizeof(UNICODE_NULL) + sizeof(UNICODE_NULL);
        if (!NT_SUCCESS(RtlEnsureBufferSize(RTL_SKIP_BUFFER_COPY, &FullPathName.ByteBuffer, Len)))
            goto Cleanup;
 
        if (Len > FullPathName.ByteBuffer.Size)
            goto Cleanup;
 
        RtlInitEmptyUnicodeString(&FullPathName.String, (PWCHAR)FullPathName.ByteBuffer.Buffer, FullPathName.ByteBuffer.Size);
 
        RtlCopyUnicodeString(&FullPathName.String, &UnicodeDir);
        RtlAppendUnicodeToString(&FullPathName.String, L"\\");
        RtlAppendUnicodeStringToString(&FullPathName.String, &Name);
 
        /* If the file does not exist, do not bother trying to read it's attributes */
        if (!SdbpFileExists(FullPathName.String.Buffer))
            goto Cleanup;
 
        /* Do we have some attributes from the previous iteration? */
        if (attribs)
            SdbFreeFileAttributes(attribs);
 
        if (!SdbGetFileAttributes(FullPathName.String.Buffer, &attribs, &attr_count))
            goto Cleanup;
 
        if (!SdbpMatchFileAttributes(pdb, matching_file, attribs, attr_count))
            goto Cleanup;
    }
 
    IsMatch = TRUE;
 
Cleanup:
    RtlFreeBuffer(&FullPathName.ByteBuffer);
    if (attribs)
        SdbFreeFileAttributes(attribs);
 
    return IsMatch;
}

Referenced by SdbGetMatchingExe().

SdbpMatchFileAttributes()

static BOOL SdbpMatchFileAttributes ( PDB  pdb, TAGID  matching_file, PATTRINFO  attribs, DWORD  attr_count  )

static

Definition at line 54 of file hsdb.c.

{
    TAGID child;
 
    for (child = SdbGetFirstChild(pdb, matching_file);
         child != TAGID_NULL; child = SdbGetNextChild(pdb, matching_file, child))
    {
        TAG tag = SdbGetTagFromTagID(pdb, child);
        DWORD n;
 
        /* Already handled! */
        if (tag == TAG_NAME)
            continue;
 
        if (tag == TAG_UPTO_BIN_FILE_VERSION ||
            tag == TAG_UPTO_BIN_PRODUCT_VERSION ||
            tag == TAG_UPTO_LINK_DATE)
        {
            SHIM_WARN("Unimplemented TAG_UPTO_XXXXX\n");
            continue;
        }
 
        for (n = 0; n < attr_count; ++n)
        {
            PATTRINFO attr = attribs + n;
            if (attr->flags == ATTRIBUTE_AVAILABLE && attr->type == tag)
            {
                DWORD dwval;
                WCHAR* lpval;
                QWORD qwval;
                switch (tag & TAG_TYPE_MASK)
                {
                case TAG_TYPE_DWORD:
                    dwval = SdbReadDWORDTag(pdb, child, 0);
                    if (dwval != attr->dwattr)
                        return FALSE;
                    break;
                case TAG_TYPE_STRINGREF:
                    lpval = SdbGetStringTagPtr(pdb, child);
                    if (!lpval || _wcsicmp(attr->lpattr, lpval))
                        return FALSE;
                    break;
                case TAG_TYPE_QWORD:
                    qwval = SdbReadQWORDTag(pdb, child, 0);
                    if (qwval != attr->qwattr)
                        return FALSE;
                    break;
                default:
                    SHIM_WARN("Unhandled type 0x%x MATCHING_FILE\n", (tag & TAG_TYPE_MASK));
                    return FALSE;
                }
            }
        }
        if (n == attr_count)
            SHIM_WARN("Unhandled tag %ws in MATCHING_FILE\n", SdbTagToString(tag));
    }
    return TRUE;
}

Referenced by SdbpMatchExe().

SdbpPropagateEnvLayers()

static BOOL SdbpPropagateEnvLayers ( HSDB  hsdb, LPWSTR  Environment, PSDBQUERYRESULT  Result  )

static

Definition at line 347 of file hsdb.c.

{
    static const UNICODE_STRING EnvKey = RTL_CONSTANT_STRING(L"__COMPAT_LAYER");
    UNICODE_STRING EnvValue;
    NTSTATUS Status;
    WCHAR Buffer[MAX_LAYER_LENGTH];
 
    RtlInitEmptyUnicodeString(&EnvValue, Buffer, sizeof(Buffer));
 
    Status = RtlQueryEnvironmentVariable_U(Environment, &EnvKey, &EnvValue);
 
    if (!NT_SUCCESS(Status))
        return FALSE;
 
    return SdbpAddLayerMatches(hsdb, Buffer, EnvValue.Length, Result) > 0;
}

Referenced by SdbGetMatchingExe().

SdbQueryData()

DWORD WINAPI SdbQueryData	(	HSDB	hsdb,
		TAGREF	trWhich,
		LPCWSTR	lpszDataName,
		LPDWORD	lpdwDataType,
		LPVOID	lpBuffer,
		LPDWORD	lpcbBufferSize
	)

Retrieve a Data entry

Parameters

[in]	hsdb	The multi-database.
[in]	trExe	The tagRef to start at
	[in,opt]	lpszDataName The name of the Data entry to find, or NULL to return all.
	[out,opt]	lpdwDataType Any of REG_SZ, REG_QWORD, REG_DWORD, ...
[out]	lpBuffer	The output buffer
	[in,out,opt]	lpcbBufferSize The size of lpBuffer in bytes

Returns

ERROR_SUCCESS

Definition at line 845 of file hsdb.c.

{
    return SdbQueryDataEx(hsdb, trWhich, lpszDataName, lpdwDataType, lpBuffer, lpcbBufferSize, NULL);
}

Referenced by SdbPackAppCompatData().

SdbQueryDataEx()

DWORD WINAPI SdbQueryDataEx	(	HSDB	hsdb,
		TAGREF	trWhich,
		LPCWSTR	lpszDataName,
		LPDWORD	lpdwDataType,
		LPVOID	lpBuffer,
		LPDWORD	lpcbBufferSize,
		TAGREF *	ptrData
	)

Retrieve a Data entry

Parameters

[in]	hsdb	The multi-database.
[in]	trExe	The tagRef to start at
	[in,opt]	lpszDataName The name of the Data entry to find, or NULL to return all.
	[out,opt]	lpdwDataType Any of REG_SZ, REG_QWORD, REG_DWORD, ...
[out]	lpBuffer	The output buffer
	[in,out,opt]	lpcbBufferSize The size of lpBuffer in bytes
	[out,opt]	ptrData The tagRef of the data

Returns

ERROR_SUCCESS

Definition at line 812 of file hsdb.c.

{
    PDB pdb;
    TAGID tiWhich, tiData;
    DWORD dwResult;
 
    if (!SdbTagRefToTagID(hsdb, trWhich, &pdb, &tiWhich))
    {
        SHIM_WARN("Unable to translate trWhich=0x%x\n", trWhich);
        return ERROR_NOT_FOUND;
    }
 
    dwResult = SdbQueryDataExTagID(pdb, tiWhich, lpszDataName, lpdwDataType, lpBuffer, lpcbBufferSize, &tiData);
 
    if (dwResult == ERROR_SUCCESS && ptrData)
        SdbTagIDToTagRef(hsdb, pdb, tiData, ptrData);
 
    return dwResult;
}

Referenced by SdbQueryData().

SdbReleaseDatabase()

void WINAPI SdbReleaseDatabase

(

HSDB

hsdb

)

Closes shim database opened by SdbInitDatabase.

Parameters

[in]

hsdb

Handle to the shim database.

Definition at line 423 of file hsdb.c.

{
    if (hsdb)
    {
        SdbCloseDatabase(hsdb->pdb);
        SdbFree(hsdb);
    }
}

Referenced by ApphelpCheckRunAppEx(), SdbGetMatchingExe(), SdbInitDatabase(), SdbPackAppCompatData(), SE_InstallBeforeInit(), and SeiGetShimData().

SdbTagIDToTagRef()

BOOL WINAPI SdbTagIDToTagRef	(	HSDB	hsdb,
		PDB	pdb,
		TAGID	tiWhich,
		TAGREF *	ptrWhich
	)

Translates the given trWhich to a specific database / tagid

Parameters

[in]	hsdb	Handle to the database.
[in]	pdb	The Shim database that tiWhich belongs to.
[in]	tiWhich	Path to executable for which we query database.
	[out,opt]	ptrWhich The tagid that tiWhich corresponds to.

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 682 of file hsdb.c.

{
    if (pdb != hsdb->pdb)
    {
        SHIM_ERR("Multiple shim databases not yet implemented!\n");
        if (ptrWhich)
            *ptrWhich = TAGREF_NULL;
        return FALSE;
    }
 
    if (ptrWhich)
        *ptrWhich = tiWhich & 0x0fffffff;
 
    return TRUE;
}

Referenced by SdbGetLayerTagRef(), SdbpAddExeLayers(), SdbpAddExeMatch(), SdbpAddNamedLayerMatch(), SdbQueryDataEx(), and SeiBuildShimRefArray().

SdbTagRefToTagID()

BOOL WINAPI SdbTagRefToTagID	(	HSDB	hsdb,
		TAGREF	trWhich,
		PDB *	ppdb,
		TAGID *	ptiWhich
	)

Translates the given trWhich to a specific database / tagid

Parameters

[in]	hsdb	Handle to the database.
[in]	trWhich	Tagref to find
	[out,opt]	ppdb The Shim database that trWhich belongs to.
	[out,opt]	ptiWhich The tagid that trWhich corresponds to.

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 651 of file hsdb.c.

{
    if (trWhich & 0xf0000000)
    {
        SHIM_ERR("Multiple shim databases not yet implemented!\n");
        if (ppdb)
            *ppdb = NULL;
        if (ptiWhich)
            *ptiWhich = TAG_NULL;
        return FALSE;
    }
 
    /* There seems to be no range checking on trWhich.. */
    if (ppdb)
        *ppdb = hsdb->pdb;
    if (ptiWhich)
        *ptiWhich = trWhich & 0x0fffffff;
 
    return TRUE;
}

Referenced by SdbQueryDataEx(), SeiBuildGlobalInclExclList(), SeiBuildShimRefArray(), and SeiInit().

SdbUnpackAppCompatData()

BOOL WINAPI SdbUnpackAppCompatData	(	HSDB	hsdb,
		LPCWSTR	pszImageName,
		PVOID	pData,
		PSDBQUERYRESULT	pQueryResult
	)

Definition at line 774 of file hsdb.c.

{
    ShimData* pShimData = pData;
 
    if (!pShimData || pShimData->dwMagic != SHIMDATA_MAGIC || pShimData->dwSize < sizeof(ShimData))
        return FALSE;
 
    if (!pQueryResult)
        return FALSE;
 
    /* szLayer? */
 
    *pQueryResult = pShimData->Query;
    return TRUE;
}

Referenced by SeiGetShimData().