#include <kmt_test.h>

Include dependency graph for RtlRegistry.c:

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 )