RtlRegistry.c File Reference

#include <kmt_test.h>

Include dependency graph for RtlRegistry.c:

Go to the source code of this file.

Classes
struct	EXPECTED_VALUE
struct	EXPECTED_VALUES

Macros
#define	KMT_EMULATE_KERNEL
#define	RTL_NUMBER_OF(x)   (sizeof(x) / sizeof(x[0]))
#define	CONST_STR_AND_LEN(d)   { (d), sizeof(d) }
#define	CSAL   CONST_STR_AND_LEN
#define	NO_AUTO_LEN   1
#define	NO_DEFAULT   2
#define	AUTO_DIFFERS   4
#define	DEFAULT_DIFFERS   8
#define	DO_QUERY(ExpectedArray, ExpectedCount)

Typedefs
typedef struct EXPECTED_VALUE *	PEXPECTED_VALUE
typedef struct EXPECTED_VALUES *	PEXPECTED_VALUES

Functions
static NTSTATUS NTAPI	QueryRoutine (_In_ PWSTR ValueName, _In_ ULONG ValueType, _In_ PVOID ValueData, _In_ ULONG ValueLength, _In_ PVOID Context, _In_ PVOID EntryContext)
static VOID	TestRtlQueryRegistryValues (_In_ HANDLE KeyHandle)
	START_TEST (RtlRegistry)

Macro Definition Documentation

AUTO_DIFFERS

#define AUTO_DIFFERS   4

CONST_STR_AND_LEN

#define CONST_STR_AND_LEN

(

d

)

{ (d), sizeof(d) }

CSAL

#define CSAL   CONST_STR_AND_LEN

DEFAULT_DIFFERS

#define DEFAULT_DIFFERS   8

DO_QUERY

#define DO_QUERY	(		ExpectedArray,
			ExpectedCount
	)

Value:

do                       \
    {                                                                   \
        ULONG _i;                                                       \
        ULONG _ExpectedCount = (ExpectedCount);                         \
        for (_i = 0; _i < _ExpectedCount; _i++)                         \
        {                                                               \
            Expected.Values[_i].ValueName = ValueName.Buffer;           \
            Expected.Values[_i].ValueType = REG_SZ;                     \
            Expected.Values[_i].ValueData = (ExpectedArray)[_i].Str;    \
            Expected.Values[_i].ValueLength = (ExpectedArray)[_i].Len;  \
        }                                                               \
        Expected.CurrentIndex = 0;                                      \
        Expected.Count = _ExpectedCount;                                \
        if (_ExpectedCount == 1)                                        \
            QueryTable[0].EntryContext = &Expected.Values[0];           \
        else                                                            \
            QueryTable[0].EntryContext = NULL;                          \
        Status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,            \
                                        (PCWSTR)KeyHandle,              \
                                        QueryTable,                     \
                                        &Expected,                      \
                                        NULL);                          \
        ok_eq_hex(Status, STATUS_SUCCESS);                              \
        ok_eq_ulong(Expected.CurrentIndex, Expected.Count);             \
    } while(0)

KMT_EMULATE_KERNEL

#define KMT_EMULATE_KERNEL

Definition at line 8 of file RtlRegistry.c.

NO_AUTO_LEN

#define NO_AUTO_LEN   1

NO_DEFAULT

#define NO_DEFAULT   2

RTL_NUMBER_OF

#define RTL_NUMBER_OF

(

x

)

(sizeof(x) / sizeof(x[0]))

Definition at line 12 of file RtlRegistry.c.

Typedef Documentation

PEXPECTED_VALUE

typedef struct EXPECTED_VALUE * PEXPECTED_VALUE

PEXPECTED_VALUES

typedef struct EXPECTED_VALUES * PEXPECTED_VALUES

Function Documentation

QueryRoutine()

static NTSTATUS NTAPI QueryRoutine ( _In_ PWSTR  ValueName, _In_ ULONG  ValueType, _In_ PVOID  ValueData, _In_ ULONG  ValueLength, _In_ PVOID  Context, _In_ PVOID  EntryContext  )

static

Definition at line 34 of file RtlRegistry.c.

{
    PEXPECTED_VALUES ExpectedValues = Context;
    PEXPECTED_VALUE Expected;
    SIZE_T EqualBytes;

    ok(ExpectedValues->CurrentIndex < ExpectedValues->Count,
       "Call number %lu, expected only %lu\n",
       ExpectedValues->CurrentIndex, ExpectedValues->Count);
    if (!skip(ExpectedValues->CurrentIndex < ExpectedValues->Count, "Out of bounds\n"))
    {
        Expected = &ExpectedValues->Values[ExpectedValues->CurrentIndex];
        if (EntryContext)
            ok_eq_pointer(EntryContext, Expected);
        ok_eq_wstr(ValueName, Expected->ValueName);
        ok_eq_ulong(ValueType, Expected->ValueType);
        ok_eq_ulong(ValueLength, Expected->ValueLength);
        EqualBytes = RtlCompareMemory(ValueData,
                                      Expected->ValueData,
                                      min(ValueLength, Expected->ValueLength));
        ok_eq_size(EqualBytes, Expected->ValueLength);
    }

    ExpectedValues->CurrentIndex++;
    return STATUS_SUCCESS;
}

Referenced by TestRtlQueryRegistryValues().

START_TEST()

START_TEST

(

RtlRegistry

)

Definition at line 198 of file RtlRegistry.c.

{
    NTSTATUS Status;
    UNICODE_STRING KeyName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE SoftwareHandle;
    HANDLE KeyHandle;

    RtlInitUnicodeString(&KeyName, L"\\Registry\\MACHINE\\Software");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&SoftwareHandle,
                       KEY_CREATE_SUB_KEY,
                       &ObjectAttributes);
    ok_eq_hex(Status, STATUS_SUCCESS);
    if (skip(NT_SUCCESS(Status) && SoftwareHandle != NULL, "No software key\n"))
        return;

    RtlInitUnicodeString(&KeyName, L"RtlRegistryKmtestKey");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               SoftwareHandle,
                               NULL);
    Status = ZwCreateKey(&KeyHandle,
                         KEY_QUERY_VALUE | KEY_SET_VALUE | DELETE,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
    ok_eq_hex(Status, STATUS_SUCCESS);

    if (!skip(NT_SUCCESS(Status) && KeyHandle != NULL, "No test key\n"))
    {
        TestRtlQueryRegistryValues(KeyHandle);

        Status = ZwDeleteKey(KeyHandle);
        ok_eq_hex(Status, STATUS_SUCCESS);
        Status = ZwClose(KeyHandle);
        ok_eq_hex(Status, STATUS_SUCCESS);
    }
}

TestRtlQueryRegistryValues()

static VOID TestRtlQueryRegistryValues ( _In_ HANDLE  KeyHandle )

static

Definition at line 69 of file RtlRegistry.c.

{
    NTSTATUS Status;
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"TestValue");
    RTL_QUERY_REGISTRY_TABLE QueryTable[] =
    {
        { QueryRoutine, 0, L"TestValue", NULL, REG_NONE, NULL, 0 },
        { NULL }
    };
    EXPECTED_VALUES Expected;
    typedef struct
    {
        PWSTR Str;
        ULONG Len;
    } STR_AND_LEN;
#define CONST_STR_AND_LEN(d) { (d), sizeof(d) }
#define CSAL CONST_STR_AND_LEN

#define NO_AUTO_LEN     1
#define NO_DEFAULT      2
#define AUTO_DIFFERS    4
#define DEFAULT_DIFFERS 8
    struct
    {
        STR_AND_LEN Value;
        ULONG ExpectedCount;
        STR_AND_LEN Expected[20];
        ULONG Flags;
        ULONG DefaultExpectedCount;
        STR_AND_LEN DefaultExpected[20];

    } Tests[] =
    {
        { { NULL, 0 },                      0, { { NULL, 0 } },                                     NO_AUTO_LEN | NO_DEFAULT },
        { CSAL(L""),                        0, { { NULL, 0 } },                                     NO_AUTO_LEN },
        { CSAL(L"\0"),                      1, { CSAL(L"") },
          AUTO_DIFFERS | DEFAULT_DIFFERS,   0, { { NULL, 0 } } },
        { CSAL(L"String"),                  1, { CSAL(L"String") },                                 NO_AUTO_LEN },
        { CSAL(L"String\0"),                1, { CSAL(L"String") }                                              },
        { CSAL(L"String1\0String2"),        2, { CSAL(L"String1"), CSAL(L"String2") },              NO_AUTO_LEN },
        { CSAL(L"String1\0String2\0"),      2, { CSAL(L"String1"), CSAL(L"String2") }                           },
        { CSAL(L"String1\0\0String3"),      3, { CSAL(L"String1"), CSAL(L""), CSAL(L"String3") },   NO_AUTO_LEN },
        { CSAL(L"String1\0\0String3\0"),    3, { CSAL(L"String1"), CSAL(L""), CSAL(L"String3") },
          AUTO_DIFFERS,                     1, { CSAL(L"String1") } },
    };

#define DO_QUERY(ExpectedArray, ExpectedCount) do                       \
    {                                                                   \
        ULONG _i;                                                       \
        ULONG _ExpectedCount = (ExpectedCount);                         \
        for (_i = 0; _i < _ExpectedCount; _i++)                         \
        {                                                               \
            Expected.Values[_i].ValueName = ValueName.Buffer;           \
            Expected.Values[_i].ValueType = REG_SZ;                     \
            Expected.Values[_i].ValueData = (ExpectedArray)[_i].Str;    \
            Expected.Values[_i].ValueLength = (ExpectedArray)[_i].Len;  \
        }                                                               \
        Expected.CurrentIndex = 0;                                      \
        Expected.Count = _ExpectedCount;                                \
        if (_ExpectedCount == 1)                                        \
            QueryTable[0].EntryContext = &Expected.Values[0];           \
        else                                                            \
            QueryTable[0].EntryContext = NULL;                          \
        Status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,            \
                                        (PCWSTR)KeyHandle,              \
                                        QueryTable,                     \
                                        &Expected,                      \
                                        NULL);                          \
        ok_eq_hex(Status, STATUS_SUCCESS);                              \
        ok_eq_ulong(Expected.CurrentIndex, Expected.Count);             \
    } while(0)

    ULONG TestCount = RTL_NUMBER_OF(Tests);
    ULONG i;

    for (i = 0; i < TestCount; i++)
    {
        trace("Set: %lu\n", i);
        Status = ZwSetValueKey(KeyHandle,
                               &ValueName,
                               0,
                               REG_MULTI_SZ,
                               Tests[i].Value.Str,
                               Tests[i].Value.Len);
        ok_eq_hex(Status, STATUS_SUCCESS);

        DO_QUERY(Tests[i].Expected, Tests[i].ExpectedCount);
    }

    /* Delete value to test default values */
    Status = ZwDeleteValueKey(KeyHandle, &ValueName);
    ok(Status == STATUS_SUCCESS || Status == STATUS_OBJECT_NAME_NOT_FOUND,
       "ZwDeleteValueKey returned %lx\n", Status);

    /* Default: REG_NONE */
    DO_QUERY((STR_AND_LEN *)NULL, 0);

    for (i = 0; i < TestCount; i++)
    {
        if (Tests[i].Flags & NO_DEFAULT)
            continue;
        trace("Default: %lu\n", i);
        QueryTable[0].DefaultType = REG_MULTI_SZ;
        QueryTable[0].DefaultData = Tests[i].Value.Str;
        QueryTable[0].DefaultLength = Tests[i].Value.Len;

        if (Tests[i].Flags & DEFAULT_DIFFERS)
            DO_QUERY(Tests[i].DefaultExpected, Tests[i].DefaultExpectedCount);
        else
            DO_QUERY(Tests[i].Expected, Tests[i].ExpectedCount);
    }

    for (i = 0; i < TestCount; i++)
    {
        if (Tests[i].Flags & NO_AUTO_LEN)
            continue;
        trace("Auto: %lu\n", i);
        QueryTable[0].DefaultType = REG_MULTI_SZ;
        QueryTable[0].DefaultData = Tests[i].Value.Str;
        QueryTable[0].DefaultLength = 0;

        if (Tests[i].Flags & AUTO_DIFFERS)
            DO_QUERY(Tests[i].DefaultExpected, Tests[i].DefaultExpectedCount);
        else
            DO_QUERY(Tests[i].Expected, Tests[i].ExpectedCount);
    }
}

Referenced by START_TEST().