reactos/tools/mkhive/registry.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2006 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 /* COPYRIGHT:       See COPYING in the top level directory
  20  * PROJECT:         ReactOS hive maker
  21  * FILE:            tools/mkhive/registry.c
  22  * PURPOSE:         Registry code
  23  * PROGRAMMER:      Hervé Poussineau
  24  */
  25
  26 /*
  27  * TODO:
  28  *      - Implement RegDeleteKeyW()
  29  *      - Implement RegEnumValue()
  30  *      - Implement RegQueryValueExW()
  31  */
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdio.h>
  36
  37 #define NDEBUG
  38 #include "mkhive.h"
  39
  40 #define REG_DATA_SIZE_MASK                 0x7FFFFFFF
  41 #define REG_DATA_IN_OFFSET                 0x80000000
  42
  43 static CMHIVE RootHive;
  44 static MEMKEY RootKey;
  45 CMHIVE DefaultHive;  /* \Registry\User\.DEFAULT */
  46 CMHIVE SamHive;      /* \Registry\Machine\SAM */
  47 CMHIVE SecurityHive; /* \Registry\Machine\SECURITY */
  48 CMHIVE SoftwareHive; /* \Registry\Machine\SOFTWARE */
  49 CMHIVE SystemHive;   /* \Registry\Machine\SYSTEM */
  50
  51 static MEMKEY
  52 CreateInMemoryStructure(
  53         IN PCMHIVE RegistryHive,
  54         IN HCELL_INDEX KeyCellOffset,
  55         IN PCUNICODE_STRING KeyName)
  56 {
  57         MEMKEY Key;
  58
  59         Key = (MEMKEY) malloc (sizeof(KEY));
  60         if (!Key)
  61                 return NULL;
  62
  63         InitializeListHead (&Key->SubKeyList);
  64         InitializeListHead (&Key->ValueList);
  65         InitializeListHead (&Key->KeyList);
  66
  67         Key->SubKeyCount = 0;
  68         Key->ValueCount = 0;
  69
  70         Key->NameSize = KeyName->Length;
  71         /* FIXME: It's not enough to allocate this way, because later
  72                   this memory gets overwritten with bigger names */
  73         Key->Name = malloc (Key->NameSize);
  74         if (!Key->Name)
  75                 return NULL;
  76         memcpy(Key->Name, KeyName->Buffer, KeyName->Length);
  77
  78         Key->DataType = 0;
  79         Key->DataSize = 0;
  80         Key->Data = NULL;
  81
  82         Key->RegistryHive = RegistryHive;
  83         Key->KeyCellOffset = KeyCellOffset;
  84         Key->KeyCell = (PCM_KEY_NODE)HvGetCell (&RegistryHive->Hive, Key->KeyCellOffset);
  85         if (!Key->KeyCell)
  86         {
  87         free(Key->Name);
  88                 free(Key);
  89                 return NULL;
  90         }
  91         Key->KeyCell->SubKeyLists[Stable] = HCELL_NIL;
  92         Key->KeyCell->SubKeyLists[Volatile] = HCELL_NIL;
  93         Key->LinkedKey = NULL;
  94         return Key;
  95 }
  96
  97 static LONG
  98 RegpOpenOrCreateKey(
  99         IN HKEY hParentKey,
 100         IN PCWSTR KeyName,
 101         IN BOOL AllowCreation,
 102         OUT PHKEY Key)
 103 {
 104         PWSTR LocalKeyName;
 105         PWSTR End;
 106         UNICODE_STRING KeyString;
 107         NTSTATUS Status;
 108         MEMKEY ParentKey;
 109         MEMKEY CurrentKey;
 110         PLIST_ENTRY Ptr;
 111         PCM_KEY_NODE SubKeyCell;
 112         HCELL_INDEX BlockOffset;
 113
 114         DPRINT("RegpCreateOpenKey('%S')\n", KeyName);
 115
 116         if (*KeyName == L'\\')
 117         {
 118                 KeyName++;
 119                 ParentKey = RootKey;
 120         }
 121         else if (hParentKey == NULL)
 122         {
 123                 ParentKey = RootKey;
 124         }
 125         else
 126         {
 127                 ParentKey = HKEY_TO_MEMKEY(RootKey);
 128         }
 129
 130         LocalKeyName = (PWSTR)KeyName;
 131         for (;;)
 132         {
 133                 End = (PWSTR)strchrW(LocalKeyName, '\\');
 134                 if (End)
 135                 {
 136                         KeyString.Buffer = LocalKeyName;
 137                         KeyString.Length = KeyString.MaximumLength =
 138                                 (USHORT)((ULONG_PTR)End - (ULONG_PTR)LocalKeyName);
 139                 }
 140                 else
 141                 {
 142                         RtlInitUnicodeString(&KeyString, LocalKeyName);
 143                         if (KeyString.Length == 0)
 144                         {
 145                                 /* Trailing backslash char; we're done */
 146                                 break;
 147                         }
 148                 }
 149
 150                 /* Redirect from 'CurrentControlSet' to 'ControlSet001' */
 151                 if (!strncmpW(LocalKeyName, L"CurrentControlSet", 17) &&
 152                     ParentKey->NameSize == 12 &&
 153                     !memcmp(ParentKey->Name, L"SYSTEM", 12))
 154                         RtlInitUnicodeString(&KeyString, L"ControlSet001");
 155
 156                 /* Check subkey in memory structure */
 157                 Ptr = ParentKey->SubKeyList.Flink;
 158                 while (Ptr != &ParentKey->SubKeyList)
 159                 {
 160                         CurrentKey = CONTAINING_RECORD(Ptr, KEY, KeyList);
 161                         if (CurrentKey->NameSize == KeyString.Length
 162                          && memcmp(CurrentKey->Name, KeyString.Buffer, KeyString.Length) == 0)
 163                         {
 164                                 goto nextsubkey;
 165                         }
 166
 167                         Ptr = Ptr->Flink;
 168                 }
 169
 170                 Status = CmiScanForSubKey(
 171                         ParentKey->RegistryHive,
 172                         ParentKey->KeyCell,
 173                         &KeyString,
 174                         OBJ_CASE_INSENSITIVE,
 175                         &SubKeyCell,
 176                         &BlockOffset);
 177                 if (AllowCreation && Status == STATUS_OBJECT_NAME_NOT_FOUND)
 178                 {
 179                         Status = CmiAddSubKey(
 180                                 ParentKey->RegistryHive,
 181                                 ParentKey->KeyCell,
 182                                 ParentKey->KeyCellOffset,
 183                                 &KeyString,
 184                                 0,
 185                                 &SubKeyCell,
 186                                 &BlockOffset);
 187                 }
 188                 if (!NT_SUCCESS(Status))
 189                         return ERROR_UNSUCCESSFUL;
 190
 191                 /* Now, SubKeyCell/BlockOffset are valid */
 192                 CurrentKey = CreateInMemoryStructure(
 193                         ParentKey->RegistryHive,
 194                         BlockOffset,
 195                         &KeyString);
 196                 if (!CurrentKey)
 197                         return ERROR_OUTOFMEMORY;
 198
 199                 /* Add CurrentKey in ParentKey */
 200                 InsertTailList(&ParentKey->SubKeyList, &CurrentKey->KeyList);
 201                 ParentKey->SubKeyCount++;
 202
 203 nextsubkey:
 204                 ParentKey = CurrentKey;
 205                 if (End)
 206                         LocalKeyName = End + 1;
 207                 else
 208                         break;
 209         }
 210
 211         *Key = MEMKEY_TO_HKEY(ParentKey);
 212
 213         return ERROR_SUCCESS;
 214 }
 215
 216 LONG WINAPI
 217 RegCreateKeyW(
 218         IN HKEY hKey,
 219         IN LPCWSTR lpSubKey,
 220         OUT PHKEY phkResult)
 221 {
 222         return RegpOpenOrCreateKey(hKey, lpSubKey, TRUE, phkResult);
 223 }
 224
 225 static PWSTR
 226 MultiByteToWideChar(
 227         IN PCSTR MultiByteString)
 228 {
 229         ANSI_STRING Source;
 230         UNICODE_STRING Destination;
 231         NTSTATUS Status;
 232
 233         RtlInitAnsiString(&Source, MultiByteString);
 234         Status = RtlAnsiStringToUnicodeString(&Destination, &Source, TRUE);
 235         if (!NT_SUCCESS(Status))
 236                 return NULL;
 237         return Destination.Buffer;
 238 }
 239
 240 LONG WINAPI
 241 RegCreateKeyA(
 242         IN HKEY hKey,
 243         IN LPCSTR lpSubKey,
 244         OUT PHKEY phkResult)
 245 {
 246         PWSTR lpSubKeyW;
 247         LONG rc;
 248
 249         lpSubKeyW = MultiByteToWideChar(lpSubKey);
 250         if (!lpSubKeyW)
 251                 return ERROR_OUTOFMEMORY;
 252
 253         rc = RegCreateKeyW(hKey, lpSubKeyW, phkResult);
 254         free(lpSubKeyW);
 255         return rc;
 256 }
 257
 258 LONG WINAPI
 259 RegDeleteKeyW(
 260         IN HKEY hKey,
 261         IN LPCWSTR lpSubKey)
 262 {
 263         DPRINT1("FIXME: implement RegDeleteKeyW!\n");
 264         return ERROR_SUCCESS;
 265 }
 266
 267 LONG WINAPI
 268 RegDeleteKeyA(
 269         IN HKEY hKey,
 270         IN LPCSTR lpSubKey)
 271 {
 272         PWSTR lpSubKeyW = NULL;
 273         LONG rc;
 274
 275         if (lpSubKey != NULL && strchr(lpSubKey, '\\') != NULL)
 276                 return ERROR_INVALID_PARAMETER;
 277
 278         if (lpSubKey)
 279         {
 280                 lpSubKeyW = MultiByteToWideChar(lpSubKey);
 281                 if (!lpSubKeyW)
 282                         return ERROR_OUTOFMEMORY;
 283         }
 284
 285         rc = RegDeleteKeyW(hKey, lpSubKeyW);
 286
 287         if (lpSubKey)
 288                 free(lpSubKeyW);
 289
 290         return rc;
 291 }
 292
 293 LONG WINAPI
 294 RegOpenKeyW(
 295         IN HKEY hKey,
 296         IN LPCWSTR lpSubKey,
 297         OUT PHKEY phkResult)
 298 {
 299         return RegpOpenOrCreateKey(hKey, lpSubKey, FALSE, phkResult);
 300 }
 301
 302 LONG WINAPI
 303 RegOpenKeyA(
 304         IN HKEY hKey,
 305         IN LPCSTR lpSubKey,
 306         OUT PHKEY phkResult)
 307 {
 308         PWSTR lpSubKeyW;
 309         LONG rc;
 310
 311         lpSubKeyW = MultiByteToWideChar(lpSubKey);
 312         if (!lpSubKeyW)
 313                 return ERROR_OUTOFMEMORY;
 314
 315         rc = RegOpenKeyW(hKey, lpSubKeyW, phkResult);
 316         free(lpSubKeyW);
 317         return rc;
 318 }
 319
 320 static LONG
 321 RegpOpenOrCreateValue(
 322         IN HKEY hKey,
 323         IN LPCWSTR ValueName,
 324         IN BOOL AllowCreation,
 325         OUT PCM_KEY_VALUE *ValueCell,
 326         OUT PHCELL_INDEX ValueCellOffset)
 327 {
 328         MEMKEY ParentKey;
 329         UNICODE_STRING ValueString;
 330         NTSTATUS Status;
 331
 332         ParentKey = HKEY_TO_MEMKEY(hKey);
 333         RtlInitUnicodeString(&ValueString, ValueName);
 334
 335         Status = CmiScanForValueKey(
 336                 ParentKey->RegistryHive,
 337                 ParentKey->KeyCell,
 338                 &ValueString,
 339                 ValueCell,
 340                 ValueCellOffset);
 341         if (AllowCreation && Status == STATUS_OBJECT_NAME_NOT_FOUND)
 342         {
 343                 Status = CmiAddValueKey(
 344                         ParentKey->RegistryHive,
 345                         ParentKey->KeyCell,
 346                         ParentKey->KeyCellOffset,
 347                         &ValueString,
 348                         ValueCell,
 349                         ValueCellOffset);
 350         }
 351         if (!NT_SUCCESS(Status))
 352                 return ERROR_UNSUCCESSFUL;
 353         return ERROR_SUCCESS;
 354 }
 355
 356 LONG WINAPI
 357 RegSetValueExW(
 358         IN HKEY hKey,
 359         IN LPCWSTR lpValueName OPTIONAL,
 360         IN ULONG Reserved,
 361         IN ULONG dwType,
 362         IN const UCHAR* lpData,
 363         IN USHORT cbData)
 364 {
 365         MEMKEY Key, DestKey;
 366         PHKEY phKey;
 367         PCM_KEY_VALUE ValueCell;
 368         HCELL_INDEX ValueCellOffset;
 369         PVOID DataCell;
 370         LONG DataCellSize;
 371         NTSTATUS Status;
 372
 373         if (dwType == REG_LINK)
 374         {
 375                 /* Special handling of registry links */
 376                 if (cbData != sizeof(PVOID))
 377                         return STATUS_INVALID_PARAMETER;
 378                 phKey = (PHKEY)lpData;
 379                 Key = HKEY_TO_MEMKEY(hKey);
 380                 DestKey = HKEY_TO_MEMKEY(*phKey);
 381
 382                 /* Create the link in memory */
 383                 Key->DataType = REG_LINK;
 384                 Key->LinkedKey = DestKey;
 385
 386                 /* Create the link in registry hive (if applicable) */
 387                 if (Key->RegistryHive != DestKey->RegistryHive)
 388                         return STATUS_SUCCESS;
 389                 DPRINT1("Save link to registry\n");
 390                 return STATUS_NOT_IMPLEMENTED;
 391         }
 392
 393         if ((cbData & REG_DATA_SIZE_MASK) != cbData)
 394                 return STATUS_UNSUCCESSFUL;
 395
 396         Key = HKEY_TO_MEMKEY(hKey);
 397
 398         Status = RegpOpenOrCreateValue(hKey, lpValueName, TRUE, &ValueCell, &ValueCellOffset);
 399         if (!NT_SUCCESS(Status))
 400                 return ERROR_UNSUCCESSFUL;
 401
 402         /* Get size of the allocated cellule (if any) */
 403         if (!(ValueCell->DataLength & REG_DATA_IN_OFFSET) &&
 404                 (ValueCell->DataLength & REG_DATA_SIZE_MASK) != 0)
 405         {
 406                 DataCell = HvGetCell(&Key->RegistryHive->Hive, ValueCell->Data);
 407                 if (!DataCell)
 408                         return ERROR_UNSUCCESSFUL;
 409                 DataCellSize = -HvGetCellSize(&Key->RegistryHive->Hive, DataCell);
 410         }
 411         else
 412         {
 413                 DataCell = NULL;
 414                 DataCellSize = 0;
 415         }
 416
 417         if (cbData <= sizeof(HCELL_INDEX))
 418         {
 419                 /* If data size <= sizeof(HCELL_INDEX) then store data in the data offset */
 420                 DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
 421                 if (DataCell)
 422                         HvFreeCell(&Key->RegistryHive->Hive, ValueCell->Data);
 423
 424                 RtlCopyMemory(&ValueCell->Data, lpData, cbData);
 425                 ValueCell->DataLength = (ULONG)(cbData | REG_DATA_IN_OFFSET);
 426                 ValueCell->Type = dwType;
 427                 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
 428         }
 429         else
 430         {
 431                 if (cbData > (SIZE_T)DataCellSize)
 432                 {
 433                         /* New data size is larger than the current, destroy current
 434                          * data block and allocate a new one. */
 435                         HCELL_INDEX NewOffset;
 436
 437                         DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
 438
 439                         NewOffset = HvAllocateCell(&Key->RegistryHive->Hive, cbData, Stable, HCELL_NIL);
 440                         if (NewOffset == HCELL_NIL)
 441                         {
 442                                 DPRINT("HvAllocateCell() failed with status 0x%08x\n", Status);
 443                                 return ERROR_UNSUCCESSFUL;
 444                         }
 445
 446                         if (DataCell)
 447                                 HvFreeCell(&Key->RegistryHive->Hive, ValueCell->Data);
 448
 449                         ValueCell->Data = NewOffset;
 450                         DataCell = (PVOID)HvGetCell(&Key->RegistryHive->Hive, NewOffset);
 451                 }
 452
 453                 /* Copy new contents to cellule */
 454                 RtlCopyMemory(DataCell, lpData, cbData);
 455                 ValueCell->DataLength = (ULONG)(cbData & REG_DATA_SIZE_MASK);
 456                 ValueCell->Type = dwType;
 457                 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCell->Data, FALSE);
 458                 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
 459         }
 460
 461     if (cbData > Key->KeyCell->MaxValueDataLen)
 462         Key->KeyCell->MaxValueDataLen = cbData;
 463
 464         HvMarkCellDirty(&Key->RegistryHive->Hive, Key->KeyCellOffset, FALSE);
 465
 466         DPRINT("Return status 0x%08x\n", Status);
 467         return Status;
 468 }
 469
 470 LONG WINAPI
 471 RegSetValueExA(
 472         IN HKEY hKey,
 473         IN LPCSTR lpValueName OPTIONAL,
 474         IN ULONG Reserved,
 475         IN ULONG dwType,
 476         IN const UCHAR* lpData,
 477         IN ULONG cbData)
 478 {
 479         LPWSTR lpValueNameW = NULL;
 480         const UCHAR* lpDataW;
 481         USHORT cbDataW;
 482         LONG rc = ERROR_SUCCESS;
 483
 484         DPRINT("RegSetValueA(%s)\n", lpValueName);
 485         if (lpValueName)
 486         {
 487                 lpValueNameW = MultiByteToWideChar(lpValueName);
 488                 if (!lpValueNameW)
 489                         return ERROR_OUTOFMEMORY;
 490         }
 491
 492         if ((dwType == REG_SZ || dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ)
 493          && cbData != 0)
 494         {
 495                 ANSI_STRING AnsiString;
 496                 UNICODE_STRING Data;
 497
 498                 if (lpData[cbData - 1] != '\0')
 499                         cbData++;
 500                 RtlInitAnsiString(&AnsiString, NULL);
 501                 AnsiString.Buffer = (PSTR)lpData;
 502                 AnsiString.Length = (USHORT)cbData - 1;
 503                 AnsiString.MaximumLength = (USHORT)cbData;
 504                 RtlAnsiStringToUnicodeString (&Data, &AnsiString, TRUE);
 505                 lpDataW = (const UCHAR*)Data.Buffer;
 506                 cbDataW = Data.MaximumLength;
 507         }
 508         else
 509         {
 510                 lpDataW = lpData;
 511                 cbDataW = (USHORT)cbData;
 512         }
 513
 514         if (rc == ERROR_SUCCESS)
 515                 rc = RegSetValueExW(hKey, lpValueNameW, 0, dwType, lpDataW, cbDataW);
 516         if (lpValueNameW)
 517                 free(lpValueNameW);
 518         if (lpData != lpDataW)
 519                 free((PVOID)lpDataW);
 520         return rc;
 521 }
 522
 523 LONG WINAPI
 524 RegQueryValueExW(
 525         IN HKEY hKey,
 526         IN LPCWSTR lpValueName,
 527         IN PULONG lpReserved,
 528         OUT PULONG lpType,
 529         OUT PUCHAR lpData,
 530         OUT PSIZE_T lpcbData)
 531 {
 532         //ParentKey = HKEY_TO_MEMKEY(RootKey);
 533         PCM_KEY_VALUE ValueCell;
 534         HCELL_INDEX ValueCellOffset;
 535         LONG rc;
 536
 537         rc = RegpOpenOrCreateValue(
 538                         hKey,
 539                         lpValueName,
 540                         FALSE,
 541                         &ValueCell,
 542                         &ValueCellOffset);
 543         if (rc != ERROR_SUCCESS)
 544                 return rc;
 545
 546         DPRINT1("RegQueryValueExW(%S) not implemented\n", lpValueName);
 547         /* ValueCell and ValueCellOffset are valid */
 548
 549         return ERROR_UNSUCCESSFUL;
 550 }
 551
 552 LONG WINAPI
 553 RegQueryValueExA(
 554         IN HKEY hKey,
 555         IN LPCSTR lpValueName,
 556         IN PULONG lpReserved,
 557         OUT PULONG lpType,
 558         OUT PUCHAR lpData,
 559         OUT PSIZE_T lpcbData)
 560 {
 561         LPWSTR lpValueNameW = NULL;
 562         LONG rc;
 563
 564         if (lpValueName)
 565         {
 566                 lpValueNameW = MultiByteToWideChar(lpValueName);
 567                 if (!lpValueNameW)
 568                         return ERROR_OUTOFMEMORY;
 569         }
 570
 571         rc = RegQueryValueExW(hKey, lpValueNameW, lpReserved, lpType, lpData, lpcbData);
 572         if (lpValueNameW)
 573                 free(lpValueNameW);
 574         return rc;
 575 }
 576
 577 LONG WINAPI
 578 RegDeleteValueW(
 579         IN HKEY hKey,
 580         IN LPCWSTR lpValueName OPTIONAL)
 581 {
 582         DPRINT1("RegDeleteValueW() unimplemented\n");
 583         return ERROR_UNSUCCESSFUL;
 584 }
 585
 586 LONG WINAPI
 587 RegDeleteValueA(
 588         IN HKEY hKey,
 589         IN LPCSTR lpValueName OPTIONAL)
 590 {
 591         LPWSTR lpValueNameW;
 592         LONG rc;
 593
 594         if (lpValueName)
 595         {
 596                 lpValueNameW = MultiByteToWideChar(lpValueName);
 597                 if (!lpValueNameW)
 598                         return ERROR_OUTOFMEMORY;
 599                 rc = RegDeleteValueW(hKey, lpValueNameW);
 600                 free(lpValueNameW);
 601         }
 602         else
 603                 rc = RegDeleteValueW(hKey, NULL);
 604         return rc;
 605 }
 606
 607 static BOOL
 608 ConnectRegistry(
 609         IN HKEY RootKey,
 610         IN PCMHIVE HiveToConnect,
 611         IN LPCWSTR Path)
 612 {
 613         NTSTATUS Status;
 614         MEMKEY NewKey;
 615         LONG rc;
 616
 617         Status = CmiInitializeTempHive(HiveToConnect);
 618         if (!NT_SUCCESS(Status))
 619         {
 620                 DPRINT1("CmiInitializeTempHive() failed with status 0x%08x\n", Status);
 621                 return FALSE;
 622         }
 623
 624         /* Create key */
 625         rc = RegCreateKeyW(
 626                 RootKey,
 627                 Path,
 628                 (PHKEY)&NewKey);
 629         if (rc != ERROR_SUCCESS)
 630                 return FALSE;
 631
 632         NewKey->RegistryHive = HiveToConnect;
 633         NewKey->KeyCellOffset = HiveToConnect->Hive.BaseBlock->RootCell;
 634         NewKey->KeyCell = (PCM_KEY_NODE)HvGetCell (&HiveToConnect->Hive, NewKey->KeyCellOffset);
 635         return TRUE;
 636 }
 637
 638 LIST_ENTRY CmiHiveListHead;
 639
 640 VOID
 641 RegInitializeRegistry(VOID)
 642 {
 643         UNICODE_STRING RootKeyName = RTL_CONSTANT_STRING(L"\\");
 644         NTSTATUS Status;
 645         HKEY ControlSetKey;
 646
 647         InitializeListHead(&CmiHiveListHead);
 648
 649         Status = CmiInitializeTempHive(&RootHive);
 650         if (!NT_SUCCESS(Status))
 651         {
 652                 DPRINT1("CmiInitializeTempHive() failed with status 0x%08x\n", Status);
 653                 return;
 654         }
 655
 656         RootKey = CreateInMemoryStructure(
 657                 &RootHive,
 658                 RootHive.Hive.BaseBlock->RootCell,
 659                 &RootKeyName);
 660
 661         /* Create DEFAULT key */
 662         ConnectRegistry(
 663                 NULL,
 664                 &DefaultHive,
 665                 L"Registry\\User\\.DEFAULT");
 666
 667         /* Create SAM key */
 668         ConnectRegistry(
 669                 NULL,
 670                 &SamHive,
 671                 L"Registry\\Machine\\SAM");
 672
 673         /* Create SECURITY key */
 674         ConnectRegistry(
 675                 NULL,
 676                 &SecurityHive,
 677                 L"Registry\\Machine\\SECURITY");
 678
 679         /* Create SOFTWARE key */
 680         ConnectRegistry(
 681                 NULL,
 682                 &SoftwareHive,
 683                 L"Registry\\Machine\\SOFTWARE");
 684
 685         /* Create SYSTEM key */
 686         ConnectRegistry(
 687                 NULL,
 688                 &SystemHive,
 689                 L"Registry\\Machine\\SYSTEM");
 690
 691         /* Create 'ControlSet001' key */
 692         RegCreateKeyW(
 693                 NULL,
 694                 L"Registry\\Machine\\SYSTEM\\ControlSet001",
 695                 &ControlSetKey);
 696 }
 697
 698 VOID
 699 RegShutdownRegistry(VOID)
 700 {
 701         /* FIXME: clean up the complete hive */
 702
 703         free(RootKey->Name);
 704         free(RootKey);
 705 }
 706
 707 /* EOF */