modules/rostests/apitests/ntdll/NtLoadUnloadKey.c

   1 /*
   2  * PROJECT:         ReactOS API Tests
   3  * LICENSE:         GPLv2+ - See COPYING in the top level directory
   4  * PURPOSE:         Test for NtLoadKey and NtUnloadKey
   5  * PROGRAMMERS:     Hermes Belusca-Maito (hermes.belusca@sfr.fr)
   6  */
   7
   8 #include "precomp.h"
   9
  10 /* See xdk/cmtypes.h */
  11 #define REG_CREATED_NEW_KEY     1
  12 #define REG_OPENED_EXISTING_KEY 2
  13
  14 #define REG_FORCE_UNLOAD        1
  15
  16 #if 1
  17
  18     #define NDEBUG
  19     #include <debug.h>
  20
  21 #else
  22
  23     #define DPRINT(fmt, ...)  printf("(%s:%d) " fmt, __FILE__, __LINE__, ##__VA_ARGS__);
  24     #define DPRINT1(fmt, ...) printf("(%s:%d) " fmt, __FILE__, __LINE__, ##__VA_ARGS__);
  25
  26 #endif
  27
  28 static NTSTATUS (NTAPI *pNtUnloadKey2)(POBJECT_ATTRIBUTES, ULONG);
  29
  30 static BOOLEAN
  31 RetrieveCurrentModuleNTDirectory(
  32     OUT PUNICODE_STRING NtPath)
  33 {
  34     WCHAR ModulePath[MAX_PATH];
  35     PWSTR PathSep;
  36
  37     /* Retrieve the current path where the test is running */
  38     GetModuleFileNameW(NULL, ModulePath, _countof(ModulePath));
  39     PathSep = wcsrchr(ModulePath, L'\\');
  40     if (!PathSep)
  41         PathSep = ModulePath + wcslen(ModulePath);
  42     *PathSep = UNICODE_NULL;
  43
  44     /* Convert the path to NT format and work with it for now on */
  45     return RtlDosPathNameToNtPathName_U(ModulePath, NtPath, NULL, NULL);
  46 }
  47
  48 static NTSTATUS
  49 CreateRegKey(
  50     OUT PHANDLE KeyHandle,
  51     IN HANDLE RootKey OPTIONAL,
  52     IN PUNICODE_STRING KeyName,
  53     IN ULONG CreateOptions,
  54     OUT PULONG Disposition OPTIONAL)
  55 {
  56     OBJECT_ATTRIBUTES ObjectAttributes;
  57
  58     InitializeObjectAttributes(&ObjectAttributes,
  59                                KeyName,
  60                                OBJ_CASE_INSENSITIVE,
  61                                RootKey,
  62                                NULL);
  63     return NtCreateKey(KeyHandle,
  64                        KEY_ALL_ACCESS,
  65                        &ObjectAttributes,
  66                        0,
  67                        NULL,
  68                        CreateOptions,
  69                        Disposition);
  70 }
  71
  72 static NTSTATUS
  73 CreateProtoHive(
  74     OUT PHANDLE KeyHandle)
  75 {
  76     NTSTATUS Status;
  77     UNICODE_STRING KeyName;
  78
  79     RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\SYSTEM\\$$$PROTO.HIV");
  80     Status = CreateRegKey(KeyHandle,
  81                           NULL,
  82                           &KeyName,
  83                           REG_OPTION_NON_VOLATILE,
  84                           NULL);
  85     if (!NT_SUCCESS(Status))
  86         return Status;
  87
  88     NtFlushKey(KeyHandle);
  89     return Status;
  90 }
  91
  92 static VOID
  93 DestroyProtoHive(
  94     IN HANDLE KeyHandle)
  95 {
  96     NtDeleteKey(KeyHandle);
  97     NtClose(KeyHandle);
  98 }
  99
 100 static NTSTATUS
 101 OpenDirectoryByHandleOrPath(
 102     OUT PHANDLE RootPathHandle,
 103     IN HANDLE RootDirectory OPTIONAL,
 104     IN PUNICODE_STRING RootPath OPTIONAL)
 105 {
 106     NTSTATUS Status;
 107     OBJECT_ATTRIBUTES ObjectAttributes;
 108     IO_STATUS_BLOCK IoStatusBlock;
 109
 110     *RootPathHandle = NULL;
 111
 112     /*
 113      * RootDirectory and RootPath cannot be either both NULL
 114      * or both non-NULL, when being specified.
 115      */
 116     if ((!RootDirectory && !RootPath) ||
 117         ( RootDirectory &&  RootPath))
 118     {
 119         return STATUS_INVALID_PARAMETER;
 120     }
 121
 122     if (!RootDirectory && RootPath)
 123     {
 124         /* Open the root directory path */
 125         InitializeObjectAttributes(&ObjectAttributes,
 126                                    RootPath,
 127                                    OBJ_CASE_INSENSITIVE,
 128                                    NULL,
 129                                    NULL);
 130         Status = NtOpenFile(RootPathHandle,
 131                             // FILE_TRAVERSE is needed to be able to use the handle as RootDirectory for future InitializeObjectAttributes calls.
 132                             FILE_LIST_DIRECTORY | FILE_ADD_FILE /* | FILE_ADD_SUBDIRECTORY */ | FILE_TRAVERSE | SYNCHRONIZE,
 133                             &ObjectAttributes,
 134                             &IoStatusBlock,
 135                             FILE_SHARE_READ | FILE_SHARE_WRITE,
 136                             FILE_SYNCHRONOUS_IO_NONALERT | FILE_DIRECTORY_FILE /* | FILE_OPEN_FOR_BACKUP_INTENT */);
 137         if (!NT_SUCCESS(Status))
 138         {
 139             DPRINT1("NtOpenFile(%wZ) failed, Status 0x%08lx\n", RootPath, Status);
 140             return Status;
 141         }
 142
 143         /* Mark the handle as being opened locally */
 144         *RootPathHandle = (HANDLE)((ULONG_PTR)*RootPathHandle | 1);
 145     }
 146     else if (RootDirectory && !RootPath)
 147     {
 148         *RootPathHandle = RootDirectory;
 149     }
 150     // No other cases possible
 151
 152     return STATUS_SUCCESS;
 153 }
 154
 155 /*
 156  * Should be called under privileges
 157  */
 158 static NTSTATUS
 159 CreateRegistryFile(
 160     IN HANDLE RootDirectory OPTIONAL,
 161     IN PUNICODE_STRING RootPath OPTIONAL,
 162     IN PCWSTR RegistryKey,
 163     IN HANDLE ProtoKeyHandle)
 164 {
 165     NTSTATUS Status;
 166     HANDLE RootPathHandle, FileHandle;
 167     UNICODE_STRING FileName;
 168     OBJECT_ATTRIBUTES ObjectAttributes;
 169     IO_STATUS_BLOCK IoStatusBlock;
 170
 171     /* Open the root directory */
 172     Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
 173     if (!NT_SUCCESS(Status))
 174     {
 175         DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
 176         return Status;
 177     }
 178
 179     /* Create the file */
 180     RtlInitUnicodeString(&FileName, RegistryKey);
 181     InitializeObjectAttributes(&ObjectAttributes,
 182                                &FileName,
 183                                OBJ_CASE_INSENSITIVE,
 184                                (HANDLE)((ULONG_PTR)RootPathHandle & ~1), // Remove the opened-locally flag
 185                                NULL);
 186     Status = NtCreateFile(&FileHandle,
 187                           FILE_GENERIC_WRITE /* | DELETE */,
 188                           &ObjectAttributes,
 189                           &IoStatusBlock,
 190                           NULL,
 191                           FILE_ATTRIBUTE_NORMAL /* | FILE_FLAG_DELETE_ON_CLOSE */,
 192                           0,
 193                           FILE_OVERWRITE_IF,
 194                           FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE,
 195                           NULL,
 196                           0);
 197     if (!NT_SUCCESS(Status))
 198     {
 199         DPRINT1("NtCreateFile(%wZ) failed, Status 0x%08lx\n", &FileName, Status);
 200         goto Cleanup;
 201     }
 202
 203     /* Save the selected hive into the file */
 204     Status = NtSaveKeyEx(ProtoKeyHandle, FileHandle, REG_LATEST_FORMAT);
 205     if (!NT_SUCCESS(Status))
 206     {
 207         DPRINT1("NtSaveKeyEx(%wZ) failed, Status 0x%08lx\n", &FileName, Status);
 208     }
 209
 210     /* Close the file, the root directory (if opened locally), and return */
 211     NtClose(FileHandle);
 212 Cleanup:
 213     if ((ULONG_PTR)RootPathHandle & 1) NtClose((HANDLE)((ULONG_PTR)RootPathHandle & ~1));
 214     return Status;
 215 }
 216
 217 /*
 218  * Should be called under privileges
 219  */
 220 static NTSTATUS
 221 MyDeleteFile(
 222     IN HANDLE RootDirectory OPTIONAL,
 223     IN PUNICODE_STRING RootPath OPTIONAL,
 224     IN PCWSTR FileName,
 225     IN BOOLEAN ForceDelete) // ForceDelete can be used to delete read-only files
 226 {
 227     NTSTATUS Status;
 228     HANDLE RootPathHandle;
 229     UNICODE_STRING NtPath;
 230     OBJECT_ATTRIBUTES ObjectAttributes;
 231     IO_STATUS_BLOCK IoStatusBlock;
 232     HANDLE FileHandle;
 233     FILE_DISPOSITION_INFORMATION FileDispInfo;
 234     BOOLEAN RetryOnce = FALSE;
 235
 236     /* Open the root directory */
 237     Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
 238     if (!NT_SUCCESS(Status))
 239     {
 240         DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
 241         return Status;
 242     }
 243
 244     /* Open the directory name that was passed in */
 245     RtlInitUnicodeString(&NtPath, FileName);
 246     InitializeObjectAttributes(&ObjectAttributes,
 247                                &NtPath,
 248                                OBJ_CASE_INSENSITIVE,
 249                                RootPathHandle,
 250                                NULL);
 251
 252 Retry: /* We go back there once if RetryOnce == TRUE */
 253     Status = NtOpenFile(&FileHandle,
 254                         DELETE | FILE_READ_ATTRIBUTES |
 255                         (RetryOnce ? FILE_WRITE_ATTRIBUTES : 0),
 256                         &ObjectAttributes,
 257                         &IoStatusBlock,
 258                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 259                         FILE_NON_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT);
 260     if (!NT_SUCCESS(Status))
 261     {
 262         DPRINT1("NtOpenFile failed with Status 0x%08lx\n", Status);
 263         return Status;
 264     }
 265
 266     if (RetryOnce)
 267     {
 268         FILE_BASIC_INFORMATION FileInformation;
 269
 270         Status = NtQueryInformationFile(FileHandle,
 271                                         &IoStatusBlock,
 272                                         &FileInformation,
 273                                         sizeof(FILE_BASIC_INFORMATION),
 274                                         FileBasicInformation);
 275         if (!NT_SUCCESS(Status))
 276         {
 277             DPRINT1("NtQueryInformationFile failed with Status 0x%08lx\n", Status);
 278             NtClose(FileHandle);
 279             return Status;
 280         }
 281
 282         FileInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
 283         Status = NtSetInformationFile(FileHandle,
 284                                       &IoStatusBlock,
 285                                       &FileInformation,
 286                                       sizeof(FILE_BASIC_INFORMATION),
 287                                       FileBasicInformation);
 288         NtClose(FileHandle);
 289         if (!NT_SUCCESS(Status))
 290         {
 291             DPRINT1("NtSetInformationFile failed with Status 0x%08lx\n", Status);
 292             return Status;
 293         }
 294     }
 295
 296     /* Ask for the file to be deleted */
 297     FileDispInfo.DeleteFile = TRUE;
 298     Status = NtSetInformationFile(FileHandle,
 299                                   &IoStatusBlock,
 300                                   &FileDispInfo,
 301                                   sizeof(FILE_DISPOSITION_INFORMATION),
 302                                   FileDispositionInformation);
 303     NtClose(FileHandle);
 304
 305     if (!NT_SUCCESS(Status))
 306         DPRINT1("Deletion of file '%S' failed, Status 0x%08lx\n", FileName, Status);
 307
 308     // FIXME: Check the precise value of Status!
 309     if (!NT_SUCCESS(Status) && ForceDelete && !RetryOnce)
 310     {
 311         /* Retry once */
 312         RetryOnce = TRUE;
 313         goto Retry;
 314     }
 315
 316     /* Return result to the caller */
 317     return Status;
 318 }
 319
 320 /*
 321  * Should be called under privileges
 322  */
 323 static NTSTATUS
 324 ConnectRegistry(
 325     IN HANDLE RootKey OPTIONAL,
 326     IN PCWSTR RegMountPoint,
 327     IN HANDLE RootDirectory OPTIONAL,
 328     IN PUNICODE_STRING RootPath OPTIONAL,
 329     IN PCWSTR RegistryKey)
 330 {
 331     NTSTATUS Status;
 332     HANDLE RootPathHandle;
 333     UNICODE_STRING KeyName, FileName;
 334     OBJECT_ATTRIBUTES KeyObjectAttributes;
 335     OBJECT_ATTRIBUTES FileObjectAttributes;
 336
 337     /* Open the root directory */
 338     Status = OpenDirectoryByHandleOrPath(&RootPathHandle, RootDirectory, RootPath);
 339     if (!NT_SUCCESS(Status))
 340     {
 341         DPRINT1("OpenDirectoryByHandleOrPath failed, Status 0x%08lx\n", Status);
 342         return Status;
 343     }
 344
 345     RtlInitUnicodeString(&KeyName, RegMountPoint);
 346     InitializeObjectAttributes(&KeyObjectAttributes,
 347                                &KeyName,
 348                                OBJ_CASE_INSENSITIVE,
 349                                RootKey,
 350                                NULL);
 351
 352     RtlInitUnicodeString(&FileName, RegistryKey);
 353     InitializeObjectAttributes(&FileObjectAttributes,
 354                                &FileName,
 355                                OBJ_CASE_INSENSITIVE,
 356                                (HANDLE)((ULONG_PTR)RootPathHandle & ~1), // Remove the opened-locally flag
 357                                NULL);
 358
 359     /* Mount the registry hive in the registry namespace */
 360     Status = NtLoadKey(&KeyObjectAttributes, &FileObjectAttributes);
 361
 362     /* Close the root directory (if opened locally), and return */
 363     if ((ULONG_PTR)RootPathHandle & 1) NtClose((HANDLE)((ULONG_PTR)RootPathHandle & ~1));
 364     return Status;
 365 }
 366
 367 /*
 368  * Should be called under privileges
 369  */
 370 static NTSTATUS
 371 DisconnectRegistry(
 372     IN HANDLE RootKey OPTIONAL,
 373     IN PCWSTR RegMountPoint,
 374     IN ULONG Flags)
 375 {
 376     UNICODE_STRING KeyName;
 377     OBJECT_ATTRIBUTES ObjectAttributes;
 378
 379     RtlInitUnicodeString(&KeyName, RegMountPoint);
 380     InitializeObjectAttributes(&ObjectAttributes,
 381                                &KeyName,
 382                                OBJ_CASE_INSENSITIVE,
 383                                RootKey,
 384                                NULL);
 385     if (!pNtUnloadKey2)
 386     {
 387         win_skip("NtUnloadKey2 unavailable, using NtUnloadKey. Flags %lu\n", Flags);
 388         return NtUnloadKey(&ObjectAttributes);
 389     }
 390     return pNtUnloadKey2(&ObjectAttributes, Flags);
 391 }
 392
 393
 394 START_TEST(NtLoadUnloadKey)
 395 {
 396     typedef struct _HIVE_LIST_ENTRY
 397     {
 398         PCWSTR HiveName;
 399         PCWSTR RegMountPoint;
 400     } HIVE_LIST_ENTRY;
 401
 402     static const HIVE_LIST_ENTRY RegistryHives[] =
 403     {
 404         { L"TestHive1", L"\\Registry\\Machine\\TestHive1" },
 405         { L"TestHive2", L"\\Registry\\Machine\\TestHive2" },
 406     };
 407
 408     NTSTATUS Status;
 409     UNICODE_STRING NtTestPath;
 410     UNICODE_STRING KeyName;
 411     HANDLE KeyHandle;
 412     ULONG Disposition;
 413     UINT i;
 414     BOOLEAN PrivilegeSet[2] = {FALSE, FALSE};
 415     WCHAR PathBuffer[MAX_PATH];
 416
 417     pNtUnloadKey2 = (PVOID)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtUnloadKey2");
 418
 419     /* Retrieve our current directory */
 420     RetrieveCurrentModuleNTDirectory(&NtTestPath);
 421
 422     /* Acquire restore privilege */
 423     Status = RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, TRUE, FALSE, &PrivilegeSet[0]);
 424     if (!NT_SUCCESS(Status))
 425     {
 426         skip("RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE) failed (Status 0x%08lx)\n", Status);
 427         /* Exit prematurely here.... */
 428         // goto Cleanup;
 429         RtlFreeUnicodeString(&NtTestPath);
 430         return;
 431     }
 432
 433     /* Acquire backup privilege */
 434     Status = RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE, TRUE, FALSE, &PrivilegeSet[1]);
 435     if (!NT_SUCCESS(Status))
 436     {
 437         skip("RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE) failed (Status 0x%08lx)\n", Status);
 438         RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, PrivilegeSet[0], FALSE, &PrivilegeSet[0]);
 439         /* Exit prematurely here.... */
 440         // goto Cleanup;
 441         RtlFreeUnicodeString(&NtTestPath);
 442         return;
 443     }
 444
 445     /* Create the template proto-hive */
 446     Status = CreateProtoHive(&KeyHandle);
 447     if (!NT_SUCCESS(Status))
 448     {
 449         skip("CreateProtoHive() failed to create the proto-hive; Status 0x%08lx\n", Status);
 450         goto Cleanup;
 451     }
 452
 453     /* Create two registry hive files from it */
 454     for (i = 0; i < _countof(RegistryHives); ++i)
 455     {
 456         Status = CreateRegistryFile(NULL, &NtTestPath,
 457                                     RegistryHives[i].HiveName,
 458                                     KeyHandle);
 459         if (!NT_SUCCESS(Status))
 460         {
 461             DPRINT1("CreateRegistryFile(%S) failed, Status 0x%08lx\n", RegistryHives[i].HiveName, Status);
 462             /* Exit prematurely here.... */
 463             break;
 464         }
 465     }
 466
 467     /* That is now done, remove the proto-hive */
 468     DestroyProtoHive(KeyHandle);
 469
 470     /* Exit prematurely here if we failed */
 471     if (!NT_SUCCESS(Status))
 472         goto Cleanup;
 473
 474
 475 /***********************************************************************************************/
 476
 477
 478     /* Now, mount the first hive */
 479     Status = ConnectRegistry(NULL, RegistryHives[0].RegMountPoint,
 480                              NULL, &NtTestPath,
 481                              RegistryHives[0].HiveName);
 482     if (!NT_SUCCESS(Status))
 483     {
 484         DPRINT1("ConnectRegistry('%wZ\\%S', '%S') failed, Status 0x%08lx\n",
 485                 &NtTestPath, RegistryHives[0].HiveName, RegistryHives[0].RegMountPoint, Status);
 486     }
 487
 488     /* Create or open a key inside the mounted hive */
 489     StringCchPrintfW(PathBuffer, _countof(PathBuffer), L"%s\\%s", RegistryHives[0].RegMountPoint, L"MyKey_1");
 490     RtlInitUnicodeString(&KeyName, PathBuffer);
 491
 492     KeyHandle = NULL;
 493     Status = CreateRegKey(&KeyHandle,
 494                           NULL,
 495                           &KeyName,
 496                           REG_OPTION_NON_VOLATILE,
 497                           &Disposition);
 498     if (!NT_SUCCESS(Status))
 499     {
 500         DPRINT1("CreateRegKey(%wZ) failed (Status %lx)\n", &KeyName, Status);
 501     }
 502     else
 503     {
 504         DPRINT1("CreateRegKey(%wZ) succeeded to %s the key (Status %lx)\n",
 505                 &KeyName,
 506                 Disposition == REG_CREATED_NEW_KEY ? "create" : /* REG_OPENED_EXISTING_KEY */ "open",
 507                 Status);
 508     }
 509
 510     /* The key handle must be valid here */
 511     Status = NtFlushKey(KeyHandle);
 512     ok_ntstatus(Status, STATUS_SUCCESS);
 513
 514     /* Attempt to unmount the hive, with the handle key still opened */
 515     Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, 0); // Same as NtUnloadKey(&ObjectAttributes);
 516     DPRINT1("Unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
 517     ok_ntstatus(Status, STATUS_CANNOT_DELETE);
 518
 519     /* The key handle should still be valid here */
 520     Status = NtFlushKey(KeyHandle);
 521     ok_ntstatus(Status, STATUS_SUCCESS);
 522
 523 #if 0 // Currently, leads to memory corruption !!!!!
 524
 525     /* Force-unmount the hive, with the handle key still opened */
 526     Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, REG_FORCE_UNLOAD);
 527     DPRINT1("Force-unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
 528     ok_hex(Status, STATUS_SUCCESS);
 529
 530     /* The key handle should not be valid anymore */
 531     Status = NtFlushKey(KeyHandle);
 532     if (Status != STATUS_KEY_DELETED    /* Win2k3 */ &&
 533         Status != STATUS_HIVE_UNLOADED  /* Win7+  */)
 534     {
 535         ok_ntstatus(Status, STATUS_KEY_DELETED);
 536     }
 537
 538 #endif
 539
 540     /* The key handle should not be valid anymore */
 541     Status = NtDeleteKey(KeyHandle);
 542     ok_ntstatus(Status, STATUS_SUCCESS);
 543
 544     /* Close by principle the handle, but should this fail? */
 545     Status = NtClose(KeyHandle);
 546     ok_ntstatus(Status, STATUS_SUCCESS);
 547
 548
 549 /***********************************************************************************************/
 550
 551
 552     /* Now, mount the first hive, again */
 553     Status = ConnectRegistry(NULL, RegistryHives[0].RegMountPoint,
 554                              NULL, &NtTestPath,
 555                              RegistryHives[0].HiveName);
 556     if (!NT_SUCCESS(Status))
 557     {
 558         DPRINT1("ConnectRegistry('%wZ\\%S', '%S') failed, Status 0x%08lx\n",
 559                 &NtTestPath, RegistryHives[0].HiveName, RegistryHives[0].RegMountPoint, Status);
 560     }
 561
 562     /* Create or open a key inside the mounted hive */
 563     StringCchPrintfW(PathBuffer, _countof(PathBuffer), L"%s\\%s", RegistryHives[0].RegMountPoint, L"MyKey_2");
 564     RtlInitUnicodeString(&KeyName, PathBuffer);
 565
 566     KeyHandle = NULL;
 567     Status = CreateRegKey(&KeyHandle,
 568                           NULL,
 569                           &KeyName,
 570                           REG_OPTION_NON_VOLATILE,
 571                           &Disposition);
 572     if (!NT_SUCCESS(Status))
 573     {
 574         DPRINT1("CreateRegKey(%wZ) failed (Status %lx)\n", &KeyName, Status);
 575     }
 576     else
 577     {
 578         DPRINT1("CreateRegKey(%wZ) succeeded to %s the key (Status %lx)\n",
 579                 &KeyName,
 580                 Disposition == REG_CREATED_NEW_KEY ? "create" : /* REG_OPENED_EXISTING_KEY */ "open",
 581                 Status);
 582     }
 583
 584     /* The key handle must be valid here */
 585     Status = NtFlushKey(KeyHandle);
 586     ok_ntstatus(Status, STATUS_SUCCESS);
 587
 588     /* Delete the key, this should succeed */
 589     Status = NtDeleteKey(KeyHandle);
 590     ok_ntstatus(Status, STATUS_SUCCESS);
 591
 592     /* Close the handle, this should succeed */
 593     Status = NtClose(KeyHandle);
 594     ok_ntstatus(Status, STATUS_SUCCESS);
 595
 596     /* Attempt to unmount the hive (no forcing), this should succeed */
 597     Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, 0); // Same as NtUnloadKey(&ObjectAttributes);
 598     DPRINT1("Unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
 599     ok_ntstatus(Status, STATUS_SUCCESS);
 600
 601     /* Force-unmount the hive (it is already unmounted), this should fail */
 602     Status = DisconnectRegistry(NULL, RegistryHives[0].RegMountPoint, REG_FORCE_UNLOAD);
 603     DPRINT1("Force-unmounting '%S' %s\n", RegistryHives[0].RegMountPoint, NT_SUCCESS(Status) ? "succeeded" : "failed");
 604     ok_hex(Status, STATUS_INVALID_PARAMETER);
 605
 606 #if 0
 607     /* Close by principle the handle, but should this fail? */
 608     Status = NtClose(KeyHandle);
 609     ok_ntstatus(Status, STATUS_SUCCESS);
 610 #endif
 611
 612
 613 /***********************************************************************************************/
 614
 615
 616 Cleanup:
 617
 618     /* Destroy the hive files */
 619     for (i = 0; i < _countof(RegistryHives); ++i)
 620     {
 621         Status = MyDeleteFile(NULL, &NtTestPath,
 622                               RegistryHives[i].HiveName, TRUE);
 623         if (!NT_SUCCESS(Status))
 624             DPRINT1("MyDeleteFile(%S) failed, Status 0x%08lx\n", RegistryHives[i].HiveName, Status);
 625     }
 626
 627     /* Remove restore and backup privileges */
 628     RtlAdjustPrivilege(SE_BACKUP_PRIVILEGE, PrivilegeSet[1], FALSE, &PrivilegeSet[1]);
 629     RtlAdjustPrivilege(SE_RESTORE_PRIVILEGE, PrivilegeSet[0], FALSE, &PrivilegeSet[0]);
 630
 631     RtlFreeUnicodeString(&NtTestPath);
 632 }