mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 14:18:41 +00:00
637 lines
21 KiB
C
637 lines
21 KiB
C
/*
|
|
* PROJECT: ReactOS API Tests
|
|
* LICENSE: GPLv2+ - See COPYING in the top level directory
|
|
* PURPOSE: Test for NtLoadKey and NtUnloadKey
|
|
* PROGRAMMERS: Hermes Belusca-Maito (hermes.belusca@sfr.fr)
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <apitest.h>
|
|
#include <strsafe.h>
|
|
|
|
#define WIN32_NO_STATUS
|
|
#include <ndk/rtlfuncs.h>
|
|
#include <ndk/cmfuncs.h>
|
|
#include <ndk/cmtypes.h>
|
|
#include <ndk/iofuncs.h>
|
|
#include <ndk/obfuncs.h>
|
|
#include <ndk/setypes.h>
|
|
|
|
/* See xdk/cmtypes.h */
|
|
#define REG_CREATED_NEW_KEY 1
|
|
#define REG_OPENED_EXISTING_KEY 2
|
|
|
|
#define REG_FORCE_UNLOAD 1
|
|
|
|
#if 1
|
|
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
#else
|
|
|
|
#define DPRINT(fmt, ...) printf("(%s:%d) " fmt, __FILE__, __LINE__, ##__VA_ARGS__);
|
|
#define DPRINT1(fmt, ...) printf("(%s:%d) " fmt, __FILE__, __LINE__, ##__VA_ARGS__);
|
|
|
|
#endif
|
|
|
|
|
|
static BOOLEAN
|
|
RetrieveCurrentModuleNTDirectory(
|
|
OUT PUNICODE_STRING NtPath)
|
|
{
|
|
WCHAR ModulePath[MAX_PATH];
|
|
PWSTR PathSep;
|
|
|
|
/* Retrieve the current path where the test is running */
|
|
GetModuleFileNameW(NULL, ModulePath, _countof(ModulePath));
|
|
PathSep = wcsrchr(ModulePath, L'\\');
|
|
if (!PathSep)
|
|
PathSep = ModulePath + wcslen(ModulePath);
|
|
*PathSep = UNICODE_NULL;
|
|
|
|
/* Convert the path to NT format and work with it for now on */
|
|
return RtlDosPathNameToNtPathName_U(ModulePath, NtPath, NULL, NULL);
|
|
}
|
|
|
|
static NTSTATUS
|
|
CreateRegKey(
|
|
OUT PHANDLE KeyHandle,
|
|
IN HANDLE RootKey OPTIONAL,
|
|
IN PUNICODE_STRING KeyName,
|
|
IN ULONG CreateOptions,
|
|
OUT PULONG Disposition OPTIONAL)
|
|
{
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootKey,
|
|
NULL);
|
|
return NtCreateKey(KeyHandle,
|
|
KEY_ALL_ACCESS,
|
|
&ObjectAttributes,
|
|
0,
|
|
NULL,
|
|
CreateOptions,
|
|
Disposition);
|
|
}
|
|
|
|
static NTSTATUS
|
|
CreateProtoHive(
|
|
OUT PHANDLE KeyHandle)
|
|
{
|
|
NTSTATUS Status;
|
|
UNICODE_STRING KeyName;
|
|
|
|
RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\SYSTEM\\$$$PROTO.HIV");
|
|
Status = CreateRegKey(KeyHandle,
|
|
NULL,
|
|
&KeyName,
|
|
REG_OPTION_NON_VOLATILE,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
return Status;
|
|
|
|
NtFlushKey(KeyHandle);
|
|
return Status;
|
|
}
|
|
|
|
static VOID
|
|
DestroyProtoHive(
|
|
IN HANDLE KeyHandle)
|
|
{
|
|
NtDeleteKey(KeyHandle);
|
|
NtClose(KeyHandle);
|
|
}
|
|
|
|
static NTSTATUS
|
|
OpenDirectoryByHandleOrPath(
|
|
OUT PHANDLE RootPathHandle,
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PUNICODE_STRING RootPath OPTIONAL)
|
|
{
|
|
NTSTATUS Status;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
*RootPathHandle = NULL;
|
|
|
|
/*
|
|
* RootDirectory and RootPath cannot be either both NULL
|
|
* or both non-NULL, when being specified.
|
|
*/
|
|
if ((!RootDirectory && !RootPath) ||
|
|
( RootDirectory && RootPath))
|
|
{
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!RootDirectory && RootPath)
|
|
{
|
|
/* Open the root directory path */
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
RootPath,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
Status = NtOpenFile(RootPathHandle,
|
|
// FILE_TRAVERSE is needed to be able to use the handle as RootDirectory for future InitializeObjectAttributes calls.
|
|
FILE_LIST_DIRECTORY | FILE_ADD_FILE /* | FILE_ADD_SUBDIRECTORY */ | FILE_TRAVERSE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE /* | FILE_OPEN_FOR_BACKUP_INTENT */);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtOpenFile(%wZ) failed, Status 0x%08lx\n", RootPath, Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Mark the handle as being opened locally */
|
|
*RootPathHandle = (HANDLE)((ULONG_PTR)*RootPathHandle | 1);
|
|
}
|
|
else if (RootDirectory && !RootPath)
|
|
{
|
|
*RootPathHandle = RootDirectory;
|
|
}
|
|
// No other cases possible
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* Should be called under privileges
|
|
*/
|
|
static NTSTATUS
|
|
CreateRegistryFile(
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PUNICODE_STRING RootPath OPTIONAL,
|
|
IN PCWSTR RegistryKey,
|
|
IN HANDLE ProtoKeyHandle)
|
|
{
|
|
NTSTATUS Status;
|
|
HANDLE RootPathHandle, FileHandle;
|
|
UNICODE_STRING FileName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
/* Open the root directory */
|
|
Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Create the file */
|
|
RtlInitUnicodeString(&FileName, RegistryKey);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
(HANDLE)((ULONG_PTR)RootPathHandle & ~1), // Remove the opened-locally flag
|
|
NULL);
|
|
Status = NtCreateFile(&FileHandle,
|
|
FILE_GENERIC_WRITE /* | DELETE */,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL /* | FILE_FLAG_DELETE_ON_CLOSE */,
|
|
0,
|
|
FILE_OVERWRITE_IF,
|
|
FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE,
|
|
NULL,
|
|
0);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtCreateFile(%wZ) failed, Status 0x%08lx\n", &FileName, Status);
|
|
goto Cleanup;
|
|
}
|
|
|
|
/* Save the selected hive into the file */
|
|
Status = NtSaveKeyEx(ProtoKeyHandle, FileHandle, REG_LATEST_FORMAT);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtSaveKeyEx(%wZ) failed, Status 0x%08lx\n", &FileName, Status);
|
|
}
|
|
|
|
/* Close the file, the root directory (if opened locally), and return */
|
|
NtClose(FileHandle);
|
|
Cleanup:
|
|
if ((ULONG_PTR)RootPathHandle & 1) NtClose((HANDLE)((ULONG_PTR)RootPathHandle & ~1));
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* Should be called under privileges
|
|
*/
|
|
static NTSTATUS
|
|
MyDeleteFile(
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PUNICODE_STRING RootPath OPTIONAL,
|
|
IN PCWSTR FileName,
|
|
IN BOOLEAN ForceDelete) // ForceDelete can be used to delete read-only files
|
|
{
|
|
NTSTATUS Status;
|
|
HANDLE RootPathHandle;
|
|
UNICODE_STRING NtPath;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
HANDLE FileHandle;
|
|
FILE_DISPOSITION_INFORMATION FileDispInfo;
|
|
BOOLEAN RetryOnce = FALSE;
|
|
|
|
/* Open the root directory */
|
|
Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
/* Open the directory name that was passed in */
|
|
RtlInitUnicodeString(&NtPath, FileName);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&NtPath,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootPathHandle,
|
|
NULL);
|
|
|
|
Retry: /* We go back there once if RetryOnce == TRUE */
|
|
Status = NtOpenFile(&FileHandle,
|
|
DELETE | FILE_READ_ATTRIBUTES |
|
|
(RetryOnce ? FILE_WRITE_ATTRIBUTES : 0),
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
|
|
FILE_NON_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtOpenFile failed with Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
if (RetryOnce)
|
|
{
|
|
FILE_BASIC_INFORMATION FileInformation;
|
|
|
|
Status = NtQueryInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInformation,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtQueryInformationFile failed with Status 0x%08lx\n", Status);
|
|
NtClose(FileHandle);
|
|
return Status;
|
|
}
|
|
|
|
FileInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
|
|
Status = NtSetInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileInformation,
|
|
sizeof(FILE_BASIC_INFORMATION),
|
|
FileBasicInformation);
|
|
NtClose(FileHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("NtSetInformationFile failed with Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
}
|
|
|
|
/* Ask for the file to be deleted */
|
|
FileDispInfo.DeleteFile = TRUE;
|
|
Status = NtSetInformationFile(FileHandle,
|
|
&IoStatusBlock,
|
|
&FileDispInfo,
|
|
sizeof(FILE_DISPOSITION_INFORMATION),
|
|
FileDispositionInformation);
|
|
NtClose(FileHandle);
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
DPRINT1("Deletion of file '%S' failed, Status 0x%08lx\n", FileName, Status);
|
|
|
|
// FIXME: Check the precise value of Status!
|
|
if (!NT_SUCCESS(Status) && ForceDelete && !RetryOnce)
|
|
{
|
|
/* Retry once */
|
|
RetryOnce = TRUE;
|
|
goto Retry;
|
|
}
|
|
|
|
/* Return result to the caller */
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* Should be called under privileges
|
|
*/
|
|
static NTSTATUS
|
|
ConnectRegistry(
|
|
IN HANDLE RootKey OPTIONAL,
|
|
IN PCWSTR RegMountPoint,
|
|
IN HANDLE RootDirectory OPTIONAL,
|
|
IN PUNICODE_STRING RootPath OPTIONAL,
|
|
IN PCWSTR RegistryKey)
|
|
{
|
|
NTSTATUS Status;
|
|
HANDLE RootPathHandle;
|
|
UNICODE_STRING KeyName, FileName;
|
|
OBJECT_ATTRIBUTES KeyObjectAttributes;
|
|
OBJECT_ATTRIBUTES FileObjectAttributes;
|
|
|
|
/* Open the root directory */
|
|
Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
RtlInitUnicodeString(&KeyName, RegMountPoint);
|
|
InitializeObjectAttributes(&KeyObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootKey,
|
|
NULL);
|
|
|
|
RtlInitUnicodeString(&FileName, RegistryKey);
|
|
InitializeObjectAttributes(&FileObjectAttributes,
|
|
&FileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
(HANDLE)((ULONG_PTR)RootPathHandle & ~1), // Remove the opened-locally flag
|
|
NULL);
|
|
|
|
/* Mount the registry hive in the registry namespace */
|
|
Status = NtLoadKey(&KeyObjectAttributes, &FileObjectAttributes);
|
|
|
|
/* Close the root directory (if opened locally), and return */
|
|
if ((ULONG_PTR)RootPathHandle & 1) NtClose((HANDLE)((ULONG_PTR)RootPathHandle & ~1));
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* Should be called under privileges
|
|
*/
|
|
static NTSTATUS
|
|
DisconnectRegistry(
|
|
IN HANDLE RootKey OPTIONAL,
|
|
IN PCWSTR RegMountPoint,
|
|
IN ULONG Flags)
|
|
{
|
|
UNICODE_STRING KeyName;
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
|
|
RtlInitUnicodeString(&KeyName, RegMountPoint);
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&KeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
RootKey,
|
|
NULL);
|
|
// return NtUnloadKey(&ObjectAttributes);
|
|
return NtUnloadKey2(&ObjectAttributes, Flags);
|
|
}
|
|
|
|
|
|
START_TEST(NtLoadUnloadKey)
|
|
{
|
|
typedef struct _HIVE_LIST_ENTRY
|
|
{
|
|
PCWSTR HiveName;
|
|
PCWSTR RegMountPoint;
|
|
} HIVE_LIST_ENTRY, *PHIVE_LIST_ENTRY;
|
|
|
|
static const HIVE_LIST_ENTRY RegistryHives[] =
|
|
{
|
|
{ L"TestHive1", L"\\Registry\\Machine\\TestHive1" },
|
|
{ L"TestHive2", L"\\Registry\\Machine\\TestHive2" },
|
|
};
|
|
|
|
NTSTATUS Status;
|
|
UNICODE_STRING NtTestPath;
|
|
UNICODE_STRING KeyName;
|
|
HANDLE KeyHandle;
|
|
ULONG Disposition;
|
|
UINT i;
|
|
BOOLEAN PrivilegeSet[2] = {FALSE, FALSE};
|
|
WCHAR PathBuffer[MAX_PATH];
|
|
|
|
/* Retrieve our current directory */
|
|
RetrieveCurrentModuleNTDirectory(&NtTestPath);
|
|
|
|
/* Acquire restore privilege */
|
|
Status = RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, TRUE, FALSE, &PrivilegeSet[0]);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
skip("RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE) failed (Status 0x%08lx)\n", Status);
|
|
/* Exit prematurely here.... */
|
|
// goto Cleanup;
|
|
RtlFreeUnicodeString(&NtTestPath);
|
|
return;
|
|
}
|
|
|
|
/* Acquire backup privilege */
|
|
Status = RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE, TRUE, FALSE, &PrivilegeSet[1]);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
skip("RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE) failed (Status 0x%08lx)\n", Status);
|
|
RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, PrivilegeSet[0], FALSE, &PrivilegeSet[0]);
|
|
/* Exit prematurely here.... */
|
|
// goto Cleanup;
|
|
RtlFreeUnicodeString(&NtTestPath);
|
|
return;
|
|
}
|
|
|
|
/* Create the template proto-hive */
|
|
Status = CreateProtoHive(&KeyHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
skip("CreateProtoHive() failed to create the proto-hive; Status 0x%08lx\n", Status);
|
|
goto Cleanup;
|
|
}
|
|
|
|
/* Create two registry hive files from it */
|
|
for (i = 0; i < _countof(RegistryHives); ++i)
|
|
{
|
|
Status = CreateRegistryFile(NULL, &NtTestPath,
|
|
RegistryHives[i].HiveName,
|
|
KeyHandle);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("CreateRegistryFile(%S) failed, Status 0x%08lx\n", RegistryHives[i].HiveName, Status);
|
|
/* Exit prematurely here.... */
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* That is now done, remove the proto-hive */
|
|
DestroyProtoHive(KeyHandle);
|
|
|
|
/* Exit prematurely here if we failed */
|
|
if (!NT_SUCCESS(Status))
|
|
goto Cleanup;
|
|
|
|
|
|
/***********************************************************************************************/
|
|
|
|
|
|
/* Now, mount the first hive */
|
|
Status = ConnectRegistry(NULL, RegistryHives[0].RegMountPoint,
|
|
NULL, &NtTestPath,
|
|
RegistryHives[0].HiveName);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("ConnectRegistry('%wZ\\%S', '%S') failed, Status 0x%08lx\n",
|
|
&NtTestPath, RegistryHives[0].HiveName, RegistryHives[0].RegMountPoint, Status);
|
|
}
|
|
|
|
/* Create or open a key inside the mounted hive */
|
|
StringCchPrintfW(PathBuffer, _countof(PathBuffer), L"%s\\%s", RegistryHives[0].RegMountPoint, L"MyKey_1");
|
|
RtlInitUnicodeString(&KeyName, PathBuffer);
|
|
|
|
KeyHandle = NULL;
|
|
Status = CreateRegKey(&KeyHandle,
|
|
NULL,
|
|
&KeyName,
|
|
REG_OPTION_NON_VOLATILE,
|
|
&Disposition);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("CreateRegKey(%wZ) failed (Status %lx)\n", &KeyName, Status);
|
|
}
|
|
else
|
|
{
|
|
DPRINT1("CreateRegKey(%wZ) succeeded to %s the key (Status %lx)\n",
|
|
&KeyName,
|
|
Disposition == REG_CREATED_NEW_KEY ? "create" : /* REG_OPENED_EXISTING_KEY */ "open",
|
|
Status);
|
|
}
|
|
|
|
/* The key handle must be valid here */
|
|
Status = NtFlushKey(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Attempt to unmount the hive, with the handle key still opened */
|
|
Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, 0); // Same as NtUnloadKey(&ObjectAttributes);
|
|
DPRINT1("Unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
|
|
ok_ntstatus(Status, STATUS_CANNOT_DELETE);
|
|
|
|
/* The key handle should still be valid here */
|
|
Status = NtFlushKey(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
#if 0 // Currently, leads to memory corruption !!!!!
|
|
|
|
/* Force-unmount the hive, with the handle key still opened */
|
|
Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, REG_FORCE_UNLOAD);
|
|
DPRINT1("Force-unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
|
|
ok_hex(Status, STATUS_SUCCESS);
|
|
|
|
/* The key handle should not be valid anymore */
|
|
Status = NtFlushKey(KeyHandle);
|
|
if (Status != STATUS_KEY_DELETED /* Win2k3 */ &&
|
|
Status != STATUS_HIVE_UNLOADED /* Win7+ */)
|
|
{
|
|
ok_ntstatus(Status, STATUS_KEY_DELETED);
|
|
}
|
|
|
|
#endif
|
|
|
|
/* The key handle should not be valid anymore */
|
|
Status = NtDeleteKey(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Close by principle the handle, but should this fail? */
|
|
Status = NtClose(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
|
|
/***********************************************************************************************/
|
|
|
|
|
|
/* Now, mount the first hive, again */
|
|
Status = ConnectRegistry(NULL, RegistryHives[0].RegMountPoint,
|
|
NULL, &NtTestPath,
|
|
RegistryHives[0].HiveName);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("ConnectRegistry('%wZ\\%S', '%S') failed, Status 0x%08lx\n",
|
|
&NtTestPath, RegistryHives[0].HiveName, RegistryHives[0].RegMountPoint, Status);
|
|
}
|
|
|
|
/* Create or open a key inside the mounted hive */
|
|
StringCchPrintfW(PathBuffer, _countof(PathBuffer), L"%s\\%s", RegistryHives[0].RegMountPoint, L"MyKey_2");
|
|
RtlInitUnicodeString(&KeyName, PathBuffer);
|
|
|
|
KeyHandle = NULL;
|
|
Status = CreateRegKey(&KeyHandle,
|
|
NULL,
|
|
&KeyName,
|
|
REG_OPTION_NON_VOLATILE,
|
|
&Disposition);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT1("CreateRegKey(%wZ) failed (Status %lx)\n", &KeyName, Status);
|
|
}
|
|
else
|
|
{
|
|
DPRINT1("CreateRegKey(%wZ) succeeded to %s the key (Status %lx)\n",
|
|
&KeyName,
|
|
Disposition == REG_CREATED_NEW_KEY ? "create" : /* REG_OPENED_EXISTING_KEY */ "open",
|
|
Status);
|
|
}
|
|
|
|
/* The key handle must be valid here */
|
|
Status = NtFlushKey(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Delete the key, this should succeed */
|
|
Status = NtDeleteKey(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Close the handle, this should succeed */
|
|
Status = NtClose(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Attempt to unmount the hive (no forcing), this should succeed */
|
|
Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, 0); // Same as NtUnloadKey(&ObjectAttributes);
|
|
DPRINT1("Unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
|
|
/* Force-unmount the hive (it is already unmounted), this should fail */
|
|
Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, REG_FORCE_UNLOAD);
|
|
DPRINT1("Force-unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
|
|
ok_hex(Status, STATUS_INVALID_PARAMETER);
|
|
|
|
#if 0
|
|
/* Close by principle the handle, but should this fail? */
|
|
Status = NtClose(KeyHandle);
|
|
ok_ntstatus(Status, STATUS_SUCCESS);
|
|
#endif
|
|
|
|
|
|
/***********************************************************************************************/
|
|
|
|
|
|
Cleanup:
|
|
|
|
/* Destroy the hive files */
|
|
for (i = 0; i < _countof(RegistryHives); ++i)
|
|
{
|
|
Status = MyDeleteFile(NULL, &NtTestPath,
|
|
RegistryHives[i].HiveName, TRUE);
|
|
if (!NT_SUCCESS(Status))
|
|
DPRINT1("MyDeleteFile(%S) failed, Status 0x%08lx\n", RegistryHives[i].HiveName, Status);
|
|
}
|
|
|
|
/* Remove restore and backup privileges */
|
|
RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE, PrivilegeSet[1], FALSE, &PrivilegeSet[1]);
|
|
RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, PrivilegeSet[0], FALSE, &PrivilegeSet[0]);
|
|
|
|
RtlFreeUnicodeString(&NtTestPath);
|
|
}
|