layer.c File Reference

#include "windef.h"
#include "winbase.h"
#include "strsafe.h"
#include <ntndk.h>
#include "apphelp.h"

Include dependency graph for layer.c:

Go to the source code of this file.

Classes
struct	SDB_TMP_STR

Macros
#define	WIN32_NO_STATUS
#define	GPLK_USER   1
#define	GPLK_MACHINE   2
#define	MAX_LAYER_LENGTH   256
#define	LAYER_APPLY_TO_SYSTEM_EXES   1
#define	LAYER_UNK_FLAG2   2
#define	REG_SZ   1
#define	APPCOMPAT_LAYER_KEY   L"\\Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers"
#define	REGISTRY_MACHINE   L"\\Registry\\Machine"
#define	SPACE_ONLY   L" "
#define	DISALLOWED_LAYER_CHARS   L" #!"
#define	LAYER_SEPARATORS   L" \t"
#define	SIGN_MEDIA_FMT   L"SIGN.MEDIA=%X %s"

Typedefs
typedef struct SDB_TMP_STR	SDB_TMP_STR
typedef struct SDB_TMP_STR *	PSDB_TMP_STR

Functions
void	SdbpInitTempStr (PSDB_TMP_STR String)
void	SdbpFreeTempStr (PSDB_TMP_STR String)
void	SdbpResizeTempStr (PSDB_TMP_STR String, WORD newLength)
BOOL	SdbpGetLongPathName (PCWSTR wszPath, PSDB_TMP_STR Result)
BOOL	SdbpIsPathOnRemovableMedia (PCWSTR Path)
BOOL	SdbpBuildSignMediaId (PSDB_TMP_STR LongPath)
BOOL	SdbpResolvePath (PSDB_TMP_STR LongPath, PCWSTR wszPath)
ACCESS_MASK	Wow64QueryFlag (void)
NTSTATUS	SdbpOpenKey (PUNICODE_STRING FullPath, BOOL bMachine, ACCESS_MASK Access, PHANDLE KeyHandle)
BOOL	SdbpGetPermLayersInternal (PUNICODE_STRING FullPath, PWSTR pwszLayers, PDWORD pdwBytes, BOOL bMachine)
BOOL	SdbDeletePermLayerKeys (PCWSTR wszPath, BOOL bMachine)
BOOL	SdbpMatchLayer (PCWSTR start, PCWSTR end, PCWSTR compare)
BOOL	SdbpAppendLayer (PWSTR target, DWORD len, PCWSTR layer, PCWSTR end)
BOOL WINAPI	AllowPermLayer (PCWSTR Path)
BOOL WINAPI	SdbGetPermLayerKeys (PCWSTR wszPath, PWSTR pwszLayers, PDWORD pdwBytes, DWORD dwFlags)
BOOL WINAPI	SdbSetPermLayerKeys (PCWSTR wszPath, PCWSTR wszLayers, BOOL bMachine)
BOOL WINAPI	SetPermLayerState (PCWSTR wszPath, PCWSTR wszLayer, DWORD dwFlags, BOOL bMachine, BOOL bEnable)

Variables
static ACCESS_MASK	g_QueryFlag = 0xffffffff

Macro Definition Documentation

APPCOMPAT_LAYER_KEY

#define APPCOMPAT_LAYER_KEY   L"\\Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags\\Layers"

Definition at line 34 of file layer.c.

DISALLOWED_LAYER_CHARS

#define DISALLOWED_LAYER_CHARS   L" #!"

Definition at line 37 of file layer.c.

GPLK_MACHINE

#define GPLK_MACHINE   2

Definition at line 16 of file layer.c.

GPLK_USER

#define GPLK_USER   1

Definition at line 15 of file layer.c.

LAYER_APPLY_TO_SYSTEM_EXES

#define LAYER_APPLY_TO_SYSTEM_EXES   1

Definition at line 18 of file layer.c.

LAYER_SEPARATORS

#define LAYER_SEPARATORS   L" \t"

Definition at line 38 of file layer.c.

LAYER_UNK_FLAG2

#define LAYER_UNK_FLAG2   2

Definition at line 19 of file layer.c.

MAX_LAYER_LENGTH

#define MAX_LAYER_LENGTH   256

Definition at line 17 of file layer.c.

REG_SZ

#define REG_SZ   1

Definition at line 22 of file layer.c.

REGISTRY_MACHINE

#define REGISTRY_MACHINE   L"\\Registry\\Machine"

Definition at line 35 of file layer.c.

SIGN_MEDIA_FMT

#define SIGN_MEDIA_FMT   L"SIGN.MEDIA=%X %s"

Definition at line 39 of file layer.c.

SPACE_ONLY

#define SPACE_ONLY   L" "

Definition at line 36 of file layer.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 8 of file layer.c.

Typedef Documentation

PSDB_TMP_STR

typedef struct SDB_TMP_STR * PSDB_TMP_STR

SDB_TMP_STR

typedef struct SDB_TMP_STR SDB_TMP_STR

Function Documentation

AllowPermLayer()

BOOL WINAPI AllowPermLayer

(

PCWSTR

Path

)

Determine if we allow permission layers to apply on this file.

Parameters

[in]

Path

Full pathname of the file, only the drive part is used.

Returns

TRUE if we allow permission layer, FALSE if not.

Definition at line 320 of file layer.c.

{
    WCHAR tmp[] = { 'A',':','\\', 0 };
    ULONG type;
    if (!Path)
    {
        SHIM_ERR("Invalid argument\n");
        return FALSE;
    }
    switch (Path[1])
    {
    case L':':
        break;
    case L'\\':
        SHIM_INFO("\"%S\" is a network path.\n", Path);
        return FALSE;
    default:
        SHIM_INFO("\"%S\" not a full path we can operate on.\n", Path);
        return FALSE;
    }
    tmp[0] = Path[0];
    type = GetDriveTypeW(tmp);
    if (type == DRIVE_REMOTE)
    {
        /* The logging here indicates that it does not like a CDROM or removable media, but it only
            seems to bail out on a media that reports it is remote...
            I have included correct logging, I doubt anyone would parse the logging, so this shouldnt break anything. */
        SHIM_INFO("\"%S\" is on a remote drive.\n", Path);
        return FALSE;
    }
    return TRUE;
}

Referenced by CLayerUIPropPage::InitFile().

SdbDeletePermLayerKeys()

BOOL SdbDeletePermLayerKeys	(	PCWSTR	wszPath,
		BOOL	bMachine
	)

Definition at line 258 of file layer.c.

{
    UNICODE_STRING FullKey;
    SDB_TMP_STR LongPath;
    HANDLE KeyHandle;
    NTSTATUS Status;

    if (!SdbpResolvePath(&LongPath, wszPath))
        return FALSE;

    Status = SdbpOpenKey(&FullKey, bMachine, KEY_SET_VALUE, &KeyHandle);
    if (NT_SUCCESS(Status))
    {
        Status = NtDeleteValueKey(KeyHandle, &LongPath.Str);
        if (!NT_SUCCESS(Status))
        {
            SHIM_INFO("Failed to delete value from Key \"%wZ\" Status 0x%lx\n", &FullKey, Status);
            /* This is what we want, so if the key didnt exist, we should not fail :) */
            if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
                Status = STATUS_SUCCESS;
        }
        NtClose(KeyHandle);
        SdbFree(FullKey.Buffer);
    }
    SdbpFreeTempStr(&LongPath);
    return NT_SUCCESS(Status);
}

Referenced by SdbSetPermLayerKeys().

SdbGetPermLayerKeys()

BOOL WINAPI SdbGetPermLayerKeys	(	PCWSTR	wszPath,
		PWSTR	pwszLayers,
		PDWORD	pdwBytes,
		DWORD	dwFlags
	)

Read the layers specified for the application.

Parameters

[in]	wszPath	Full pathname of the file.
[out]	pwszLayers	On return, the layers set on the file.
	pdwBytes	The size of the pwszLayers buffer in bytes, and on return the size of the data written (in bytes)
[in]	dwFlags	The flags, [GPLK_USER | GPLK_MACHINE].

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 364 of file layer.c.

{
    BOOL Result = FALSE;
    SDB_TMP_STR LongPath;
    DWORD dwBytes, dwTotal = 0;
    if (!wszPath || !pdwBytes)
    {
        SHIM_ERR("NULL parameter passed for wszPath or pdwBytes.\n");
        return FALSE;
    }

    if (!SdbpResolvePath(&LongPath, wszPath))
        return FALSE;
    dwBytes = *pdwBytes;
    if (dwFlags & GPLK_MACHINE)
    {
        if (SdbpGetPermLayersInternal(&LongPath.Str, pwszLayers, &dwBytes, TRUE))
        {
            Result = TRUE;
            dwTotal = dwBytes - sizeof(WCHAR); /* Compensate for the nullterm. */
            pwszLayers += dwTotal / sizeof(WCHAR);
            dwBytes = *pdwBytes - dwBytes;
            if (dwFlags & GPLK_USER)
            {
                *(pwszLayers++) = L' ';
                *pwszLayers = L'\0';
                dwBytes -= sizeof(WCHAR);
                dwTotal += sizeof(WCHAR);
            }
        }
    }
    if (dwFlags & GPLK_USER)
    {
        if (SdbpGetPermLayersInternal(&LongPath.Str, pwszLayers, &dwBytes, FALSE))
        {
            Result = TRUE;
            dwTotal += dwBytes - sizeof(WCHAR); /* Compensate for the nullterm. */
        }
        else if (dwTotal > 0 && pwszLayers[-1] == L' ')
        {
            pwszLayers[-1] = '\0';
            dwTotal -= sizeof(WCHAR);
        }
    }
    if (dwTotal)
        dwTotal += sizeof(WCHAR);
    *pdwBytes = dwTotal;
    SdbpFreeTempStr(&LongPath);
    return Result;
}

Referenced by GetLayerInfo(), SdbGetMatchingExe(), and SetPermLayerState().

SdbpAppendLayer()

BOOL SdbpAppendLayer	(	PWSTR	target,
		DWORD	len,
		PCWSTR	layer,
		PCWSTR	end
	)

Definition at line 295 of file layer.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    if (target[0])
        Status = StringCbCatW(target, len, SPACE_ONLY);

    if (NT_SUCCESS(Status))
    {
        if (end)
            Status = StringCbCatNW(target, len, layer, (end - layer) * sizeof(WCHAR));
        else
            Status = StringCbCatW(target, len, layer);
    }

    return NT_SUCCESS(Status);
}

Referenced by SetPermLayerState().

SdbpBuildSignMediaId()

BOOL SdbpBuildSignMediaId

(

PSDB_TMP_STR

LongPath

)

Definition at line 124 of file layer.c.

{
    SDB_TMP_STR Scratch;
    PWCHAR Ptr;

    SdbpInitTempStr(&Scratch);
    SdbpResizeTempStr(&Scratch, LongPath->Str.Length / sizeof(WCHAR) + 30);
    StringCbCopyNW(Scratch.Str.Buffer, Scratch.Str.MaximumLength, LongPath->Str.Buffer, LongPath->Str.Length);
    Ptr = wcsrchr(LongPath->Str.Buffer, '\\');
    if (Ptr)
    {
        HANDLE FindHandle;
        WIN32_FIND_DATAW FindData;
        Ptr[1] = '*';
        Ptr[2] = '\0';
        FindHandle = FindFirstFileW(LongPath->Str.Buffer, &FindData);
        if (FindHandle != INVALID_HANDLE_VALUE)
        {
            DWORD SignMedia = 0;
            do
            {
                if (!(FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && FindData.nFileSizeLow)
                    SignMedia = SignMedia << 1 ^ FindData.nFileSizeLow;
            } while (FindNextFileW(FindHandle, &FindData));

            FindClose(FindHandle);
            SdbpResizeTempStr(LongPath, (LongPath->Str.Length >> 1) + 20);
            StringCbPrintfW(LongPath->Str.Buffer, LongPath->Str.MaximumLength, SIGN_MEDIA_FMT, SignMedia, Scratch.Str.Buffer + 3);
            LongPath->Str.Length = (USHORT)SdbpStrlen(LongPath->Str.Buffer) * sizeof(WCHAR);
            SdbpFreeTempStr(&Scratch);
            return TRUE;
        }
    }
    SdbpFreeTempStr(&Scratch);
    SdbpFreeTempStr(LongPath);
    return FALSE;
}

Referenced by SdbpResolvePath().

SdbpFreeTempStr()

void SdbpFreeTempStr

(

PSDB_TMP_STR

String

)

Definition at line 56 of file layer.c.

{
    if (String->Str.Buffer != String->FixedBuffer)
    {
        SdbFree(String->Str.Buffer);
    }
}

Referenced by SdbDeletePermLayerKeys(), SdbGetPermLayerKeys(), SdbpBuildSignMediaId(), SdbpResizeTempStr(), SdbpResolvePath(), and SdbSetPermLayerKeys().

SdbpGetLongPathName()

BOOL SdbpGetLongPathName	(	PCWSTR	wszPath,
		PSDB_TMP_STR	Result
	)

Definition at line 75 of file layer.c.

{
    DWORD max = Result->Str.MaximumLength / 2;
    DWORD ret = GetLongPathNameW(wszPath, Result->Str.Buffer, max);
    if (ret)
    {
        if (ret >= max)
        {
            SdbpResizeTempStr(Result, ret);
            max = Result->Str.MaximumLength / 2;
            ret = GetLongPathNameW(wszPath, Result->Str.Buffer, max);
        }
        if (ret && ret < max)
        {
            Result->Str.Length = ret * 2;
            return TRUE;
        }
    }
    SHIM_ERR("Failed to convert short path to long path error 0x%lx\n", GetLastError());
    return FALSE;
}

Referenced by SdbpResolvePath().

SdbpGetPermLayersInternal()

BOOL SdbpGetPermLayersInternal	(	PUNICODE_STRING	FullPath,
		PWSTR	pwszLayers,
		PDWORD	pdwBytes,
		BOOL	bMachine
	)

Definition at line 230 of file layer.c.

{
    UNICODE_STRING FullKey;
    ULONG ValueBuffer[(MAX_LAYER_LENGTH * sizeof(WCHAR) + sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG) - 1) / sizeof(ULONG)];
    PKEY_VALUE_PARTIAL_INFORMATION PartialInfo = (PVOID)ValueBuffer;
    ULONG Length = 0;
    HANDLE KeyHandle;
    NTSTATUS Status;

    Status = SdbpOpenKey(&FullKey, bMachine, KEY_QUERY_VALUE, &KeyHandle);
    if (NT_SUCCESS(Status))
    {
        Status = NtQueryValueKey(KeyHandle, FullPath, KeyValuePartialInformation, PartialInfo, sizeof(ValueBuffer), &Length);
        if (NT_SUCCESS(Status))
        {
            StringCbCopyNW(pwszLayers, *pdwBytes, (PCWSTR)PartialInfo->Data, PartialInfo->DataLength);
            *pdwBytes = PartialInfo->DataLength;
        }
        else
        {
            SHIM_INFO("Failed to read value info from Key \"%wZ\" Status 0x%lx\n", &FullKey, Status);
        }
        NtClose(KeyHandle);
        SdbFree(FullKey.Buffer);
    }
    return NT_SUCCESS(Status);
}

Referenced by SdbGetPermLayerKeys().

SdbpInitTempStr()

void SdbpInitTempStr

(

PSDB_TMP_STR

String

)

Definition at line 49 of file layer.c.

{
    String->Str.Buffer = String->FixedBuffer;
    String->Str.Length = 0;
    String->Str.MaximumLength = sizeof(String->FixedBuffer);
}

Referenced by SdbpBuildSignMediaId(), and SdbpResolvePath().

SdbpIsPathOnRemovableMedia()

BOOL SdbpIsPathOnRemovableMedia

(

PCWSTR

Path

)

Definition at line 97 of file layer.c.

{
    WCHAR tmp[] = { 'A',':','\\',0 };
    ULONG type;
    if (!Path || Path[0] == UNICODE_NULL)
    {
        SHIM_ERR("Invalid argument\n");
        return FALSE;
    }
    switch (Path[1])
    {
    case L':':
        break;
    case L'\\':
        SHIM_INFO("\"%S\" is a network path.\n", Path);
        return FALSE;
    default:
        SHIM_INFO("\"%S\" not a full path we can operate on.\n", Path);
        return FALSE;
    }
    tmp[0] = Path[0];
    type = GetDriveTypeW(tmp);

    return type == DRIVE_REMOVABLE || type == DRIVE_CDROM;
}

Referenced by SdbpResolvePath().

SdbpMatchLayer()

BOOL SdbpMatchLayer	(	PCWSTR	start,
		PCWSTR	end,
		PCWSTR	compare
	)

Definition at line 286 of file layer.c.

{
    size_t len;
    if (!end)
        return !wcsicmp(start, compare);
    len = end - start;
    return wcslen(compare) == len && !_wcsnicmp(start, compare, len);
}

Referenced by SetPermLayerState().

SdbpOpenKey()

NTSTATUS SdbpOpenKey	(	PUNICODE_STRING	FullPath,
		BOOL	bMachine,
		ACCESS_MASK	Access,
		PHANDLE	KeyHandle
	)

Definition at line 190 of file layer.c.

{
    UNICODE_STRING BasePath;
    const WCHAR* LayersKey = APPCOMPAT_LAYER_KEY;
    OBJECT_ATTRIBUTES ObjectLayer = RTL_INIT_OBJECT_ATTRIBUTES(FullPath, OBJ_CASE_INSENSITIVE);
    NTSTATUS Status;
    FullPath->Buffer = NULL;
    FullPath->Length = FullPath->MaximumLength = 0;
    if (bMachine)
    {
        RtlInitUnicodeString(&BasePath, REGISTRY_MACHINE);
    }
    else
    {
        Status = RtlFormatCurrentUserKeyPath(&BasePath);
        if (!NT_SUCCESS(Status))
        {
            SHIM_ERR("Unable to acquire user registry key, Error: 0x%lx\n", Status);
            return Status;
        }
    }
    FullPath->MaximumLength = (USHORT)(BasePath.Length + SdbpStrsize(LayersKey));
    FullPath->Buffer = SdbAlloc(FullPath->MaximumLength);
    FullPath->Length = 0;
    RtlAppendUnicodeStringToString(FullPath, &BasePath);
    if (!bMachine)
        RtlFreeUnicodeString(&BasePath);
    RtlAppendUnicodeToString(FullPath, LayersKey);

    Status = NtOpenKey(KeyHandle, Access | Wow64QueryFlag(), &ObjectLayer);
    if (!NT_SUCCESS(Status))
    {
        SHIM_ERR("Unable to open Key  \"%wZ\" Status 0x%lx\n", FullPath, Status);
        SdbFree(FullPath->Buffer);
        FullPath->Buffer = NULL;
    }
    return Status;
}

Referenced by SdbDeletePermLayerKeys(), SdbpGetPermLayersInternal(), and SdbSetPermLayerKeys().

SdbpResizeTempStr()

void SdbpResizeTempStr	(	PSDB_TMP_STR	String,
		WORD	newLength
	)

Definition at line 64 of file layer.c.

{
    if (newLength > String->Str.MaximumLength)
    {
        SdbpFreeTempStr(String);
        String->Str.MaximumLength = newLength * sizeof(WCHAR);
        String->Str.Buffer = SdbAlloc(String->Str.MaximumLength);
        String->Str.Length = 0;
    }
}

Referenced by SdbpBuildSignMediaId(), and SdbpGetLongPathName().

SdbpResolvePath()

BOOL SdbpResolvePath	(	PSDB_TMP_STR	LongPath,
		PCWSTR	wszPath
	)

Definition at line 163 of file layer.c.

{
    SdbpInitTempStr(LongPath);
    if (!SdbpGetLongPathName(wszPath, LongPath))
    {
        SdbpFreeTempStr(LongPath);
        return FALSE;
    }
    if (SdbpIsPathOnRemovableMedia(LongPath->Str.Buffer))
    {
        return SdbpBuildSignMediaId(LongPath);
    }
    return TRUE;
}

Referenced by SdbDeletePermLayerKeys(), SdbGetPermLayerKeys(), and SdbSetPermLayerKeys().

SdbSetPermLayerKeys()

BOOL WINAPI SdbSetPermLayerKeys	(	PCWSTR	wszPath,
		PCWSTR	wszLayers,
		BOOL	bMachine
	)

Set or clear the Layer key.

Parameters

[in]	wszPath	Full pathname of the file.
[in]	wszLayers	The layers to add (space separated), or an empty string / NULL to remove all layers.
[in]	bMachine	TRUE to machine.

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 425 of file layer.c.

{
    UNICODE_STRING FullKey;
    SDB_TMP_STR LongPath;
    HANDLE KeyHandle;
    NTSTATUS Status;

    if (!wszLayers || *wszLayers == '\0')
        return SdbDeletePermLayerKeys(wszPath, bMachine);

    if (!SdbpResolvePath(&LongPath, wszPath))
        return FALSE;

    Status = SdbpOpenKey(&FullKey, bMachine, KEY_SET_VALUE, &KeyHandle);
    if (NT_SUCCESS(Status))
    {
        Status = NtSetValueKey(KeyHandle, &LongPath.Str, 0, REG_SZ, (PVOID)wszLayers, SdbpStrsize(wszLayers));
        if (!NT_SUCCESS(Status))
        {
            SHIM_INFO("Failed to write a value to Key \"%wZ\" Status 0x%lx\n", &FullKey, Status);
            if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
                Status = STATUS_SUCCESS;
        }
        NtClose(KeyHandle);
        SdbFree(FullKey.Buffer);
    }
    SdbpFreeTempStr(&LongPath);
    return NT_SUCCESS(Status);
}

Referenced by SetPermLayerState().

SetPermLayerState()

BOOL WINAPI SetPermLayerState	(	PCWSTR	wszPath,
		PCWSTR	wszLayer,
		DWORD	dwFlags,
		BOOL	bMachine,
		BOOL	bEnable
	)

Adds or removes a single layer entry.

Parameters

[in]	wszPath	Full pathname of the file.
[in]	wszLayer	The layer to add or remove.
[in]	dwFlags	Additional flags to add / remove [LAYER_APPLY_TO_SYSTEM_EXES | ???].
[in]	bMachine	When TRUE, the setting applies to all users, when FALSE only applies to the current user.
[in]	bEnable	TRUE to enable, FALSE to disable a layer / flag specified.

Returns

TRUE if it succeeds, FALSE if it fails.

Definition at line 467 of file layer.c.

{
    WCHAR fullLayer[MAX_LAYER_LENGTH] = { 0 };
    WCHAR newLayer[MAX_LAYER_LENGTH] = { 0 };
    DWORD dwBytes = sizeof(fullLayer), dwWriteFlags = 0;
    PWSTR start, p;

    if (!wszLayer)
    {
        SHIM_ERR("Invalid argument\n");
        return FALSE;
    }
    if (dwFlags & ~(LAYER_APPLY_TO_SYSTEM_EXES | LAYER_UNK_FLAG2))
    {
        SHIM_ERR("Invalid flags\n");
        return FALSE;
    }
    p = wcspbrk(wszLayer, DISALLOWED_LAYER_CHARS);
    if (p)
    {
        switch (*p)
        {
        case ' ':
            SHIM_ERR("Only one layer can be passed in at a time.\n");
            return FALSE;
        case '#':
        case '!':
            SHIM_ERR("Flags cannot be passed in with the layer name.\n");
            return FALSE;
        }
    }
    if (!SdbGetPermLayerKeys(wszPath, fullLayer, &dwBytes, bMachine ? GPLK_MACHINE : GPLK_USER))
    {
        fullLayer[0] = '\0';
        dwBytes = sizeof(fullLayer);
    }

    start = fullLayer;
    while (*start == '!' || *start == '#' || *start == ' ' || *start == '\t')
    {
        if (*start == '#')
            dwWriteFlags |= LAYER_APPLY_TO_SYSTEM_EXES;
        else if (*start == '!')
            dwWriteFlags |= LAYER_UNK_FLAG2;
        start++;
    }
    if (bEnable)
        dwWriteFlags |= dwFlags;
    else
        dwWriteFlags &= ~dwFlags;

    p = newLayer;
    if (dwWriteFlags & LAYER_UNK_FLAG2)
        *(p++) = '!';
    if (dwWriteFlags & LAYER_APPLY_TO_SYSTEM_EXES)
        *(p++) = '#';

    do
    {
        while (*start == ' ' || *start == '\t')
            ++start;

        if (*start == '\0')
            break;
        p = wcspbrk(start, LAYER_SEPARATORS);
        if (!SdbpMatchLayer(start, p, wszLayer))
        {
            SdbpAppendLayer(newLayer, sizeof(newLayer), start, p);
        }
        start = p + 1;
    } while (p);

    if (bEnable && wszLayer[0])
    {
        SdbpAppendLayer(newLayer, sizeof(newLayer), wszLayer, NULL);
    }

    return SdbSetPermLayerKeys(wszPath, newLayer, bMachine);
}

Referenced by CLayerUIPropPage::OnApply().

Wow64QueryFlag()

ACCESS_MASK Wow64QueryFlag

(

void

)

Definition at line 179 of file layer.c.

{
    if (g_QueryFlag == 0xffffffff)
    {
        ULONG_PTR wow64_ptr = 0;
        NTSTATUS Status = NtQueryInformationProcess(NtCurrentProcess(), ProcessWow64Information, &wow64_ptr, sizeof(wow64_ptr), NULL);
        g_QueryFlag = (NT_SUCCESS(Status) && wow64_ptr != 0) ? KEY_WOW64_64KEY : 0;
    }
    return g_QueryFlag;
}

Referenced by SdbpOpenKey(), SdbRegisterDatabaseEx(), and SdbUnregisterDatabase().

Variable Documentation

g_QueryFlag

ACCESS_MASK g_QueryFlag = 0xffffffff

static

Definition at line 178 of file layer.c.

Referenced by Wow64QueryFlag().