c188d7a53b988435f96c570334ce3ee25112c4ae
[reactos.git] / sdk / 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 /*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS hive maker
22 * FILE: tools/mkhive/registry.c
23 * PURPOSE: Registry code
24 * PROGRAMMERS: Hervé Poussineau
25 * Hermès Bélusca-Maïto
26 */
27
28 /* INCLUDES *****************************************************************/
29
30 #define NDEBUG
31 #include "mkhive.h"
32
33 /* DATA *********************************************************************/
34
35 typedef struct _REPARSE_POINT
36 {
37 LIST_ENTRY ListEntry;
38 PCMHIVE SourceHive;
39 HCELL_INDEX SourceKeyCellOffset;
40 PCMHIVE DestinationHive;
41 HCELL_INDEX DestinationKeyCellOffset;
42 } REPARSE_POINT, *PREPARSE_POINT;
43
44 typedef struct _MEMKEY
45 {
46 /* Information on hard disk structure */
47 HCELL_INDEX KeyCellOffset;
48 PCMHIVE RegistryHive;
49 } MEMKEY, *PMEMKEY;
50
51 #define HKEY_TO_MEMKEY(hKey) ((PMEMKEY)(hKey))
52 #define MEMKEY_TO_HKEY(memKey) ((HKEY)(memKey))
53
54 static CMHIVE RootHive;
55 static PMEMKEY RootKey;
56
57 static CMHIVE SystemHive; /* \Registry\Machine\SYSTEM */
58 static CMHIVE SoftwareHive; /* \Registry\Machine\SOFTWARE */
59 static CMHIVE DefaultHive; /* \Registry\User\.DEFAULT */
60 static CMHIVE SamHive; /* \Registry\Machine\SAM */
61 static CMHIVE SecurityHive; /* \Registry\Machine\SECURITY */
62 static CMHIVE BcdHive; /* \Registry\Machine\BCD00000000 */
63
64 //
65 // TODO: Write these values in a more human-readable form.
66 // See http://amnesia.gtisc.gatech.edu/~moyix/suzibandit.ltd.uk/MSc/Registry%20Structure%20-%20Appendices%20V4.pdf
67 // Appendix 12 "The Registry NT Security Descriptor" for more information.
68 //
69 // Those SECURITY_DESCRIPTORs were obtained by dumping the security block "sk"
70 // of registry hives created by setting their permissions to be the same as
71 // the ones of the BCD, SOFTWARE, or SYSTEM, SAM and .DEFAULT system hives.
72 // A cross-check was subsequently done with the system hives to verify that
73 // the security descriptors were the same.
74 //
75 static UCHAR BcdSecurity[] =
76 {
77 // SECURITY_DESCRIPTOR_RELATIVE
78 0x01, // Revision
79 0x00, // Sbz1
80 0x04, 0x94, // Control: SE_SELF_RELATIVE (0x8000) |
81 // SE_DACL_PROTECTED (0x1000) |
82 // SE_DACL_AUTO_INHERITED (0x0400) |
83 // SE_DACL_PRESENT (0x0004)
84 0x48, 0x00, 0x00, 0x00, // Owner
85 0x58, 0x00, 0x00, 0x00, // Group
86 0x00, 0x00, 0x00, 0x00, // Sacl (None)
87 0x14, 0x00, 0x00, 0x00, // Dacl
88
89 // DACL
90 0x02, // AclRevision
91 0x00, // Sbz1
92 0x34, 0x00, // AclSize
93 0x02, 0x00, // AceCount
94 0x00, 0x00, // Sbz2
95
96 // (1st ACE)
97 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
98 0x02, // AceFlags: CONTAINER_INHERIT_ACE
99 0x18, 0x00, // AceSize
100 0x19, 0x00, 0x06, 0x00, // ACCESS_MASK: "Write DAC" (0x00040000) |
101 // "Read Control" (0x00020000) |
102 // "Notify" (0x00000010) |
103 // "Enumerate Subkeys" (0x00000008) |
104 // "Query Value" (0x00000001)
105 // (SidStart: S-1-5-32-544 "Administrators")
106 0x01, 0x02, 0x00, 0x00,
107 0x00, 0x00, 0x00, 0x05,
108 0x20, 0x00, 0x00, 0x00,
109 0x20, 0x02, 0x00, 0x00,
110
111 // (2nd ACE)
112 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
113 0x02, // AceFlags: CONTAINER_INHERIT_ACE
114 0x14, 0x00, // AceSize
115 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
116 // (SidStart: S-1-5-18 "Local System")
117 0x01, 0x01, 0x00, 0x00,
118 0x00, 0x00, 0x00, 0x05,
119 0x12, 0x00, 0x00, 0x00,
120
121 // Owner SID (S-1-5-32-544 "Administrators")
122 0x01, 0x02, 0x00, 0x00,
123 0x00, 0x00, 0x00, 0x05,
124 0x20, 0x00, 0x00, 0x00,
125 0x20, 0x02, 0x00, 0x00,
126
127 // Group SID (S-1-5-21-domain-513 "Domain Users")
128 0x01, 0x05, 0x00, 0x00,
129 0x00, 0x00, 0x00, 0x05,
130 0x15, 0x00, 0x00, 0x00,
131 0xAC, 0xD0, 0x49, 0xCB,
132 0xE6, 0x52, 0x47, 0x9C,
133 0xE4, 0x31, 0xDB, 0x5C,
134 0x01, 0x02, 0x00, 0x00
135 };
136
137 static UCHAR SoftwareSecurity[] =
138 {
139 // SECURITY_DESCRIPTOR_RELATIVE
140 0x01, // Revision
141 0x00, // Sbz1
142 0x04, 0x94, // Control: SE_SELF_RELATIVE (0x8000) |
143 // SE_DACL_PROTECTED (0x1000) |
144 // SE_DACL_AUTO_INHERITED (0x0400) |
145 // SE_DACL_PRESENT (0x0004)
146 0xA0, 0x00, 0x00, 0x00, // Owner
147 0xB0, 0x00, 0x00, 0x00, // Group
148 0x00, 0x00, 0x00, 0x00, // Sacl (None)
149 0x14, 0x00, 0x00, 0x00, // Dacl
150
151 // DACL
152 0x02, // AclRevision
153 0x00, // Sbz1
154 0x8C, 0x00, // AclSize
155 0x06, 0x00, // AceCount
156 0x00, 0x00, // Sbz2
157
158 // (1st ACE)
159 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
160 0x02, // AceFlags: CONTAINER_INHERIT_ACE
161 0x18, 0x00, // AceSize
162 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
163 // (SidStart: S-1-5-32-544 "Administrators")
164 0x01, 0x02, 0x00, 0x00,
165 0x00, 0x00, 0x00, 0x05,
166 0x20, 0x00, 0x00, 0x00,
167 0x20, 0x02, 0x00, 0x00,
168
169 // (2nd ACE)
170 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
171 0x0A, // AceFlags: INHERIT_ONLY_ACE | CONTAINER_INHERIT_ACE
172 0x14, 0x00, // AceSize
173 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
174 // (SidStart: S-1-3-0 "Creator Owner")
175 0x01, 0x01, 0x00, 0x00,
176 0x00, 0x00, 0x00, 0x03,
177 0x00, 0x00, 0x00, 0x00,
178
179 // (3rd ACE)
180 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
181 0x02, // AceFlags: CONTAINER_INHERIT_ACE
182 0x14, 0x00, // AceSize
183 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
184 // (SidStart: S-1-5-18 "Local System")
185 0x01, 0x01, 0x00, 0x00,
186 0x00, 0x00, 0x00, 0x05,
187 0x12, 0x00, 0x00, 0x00,
188
189 // (4th ACE)
190 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
191 0x02, // AceFlags: CONTAINER_INHERIT_ACE
192 0x14, 0x00, // AceSize
193 0x1F, 0x00, 0x03, 0x00, // ACCESS_MASK: "Read Control" (0x00020000) |
194 // "Delete" (0x00010000) |
195 // "Notify" (0x00000010) |
196 // "Enumerate Subkeys" (0x00000008) |
197 // "Create Subkey" (0x00000004) |
198 // "Set Value" (0x00000002) |
199 // "Query Value" (0x00000001)
200 // (SidStart: S-1-5-13 "Terminal Server Users")
201 0x01, 0x01, 0x00, 0x00,
202 0x00, 0x00, 0x00, 0x05,
203 0x0D, 0x00, 0x00, 0x00,
204
205 // (5th ACE)
206 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
207 0x02, // AceFlags: CONTAINER_INHERIT_ACE
208 0x18, 0x00, // AceSize
209 0x19, 0x00, 0x02, 0x00, // ACCESS_MASK: "Read Control" (0x00020000) |
210 // "Notify" (0x00000010) |
211 // "Enumerate Subkeys" (0x00000008) |
212 // "Query Value" (0x00000001)
213 // (SidStart: S-1-5-32-545 "Users")
214 0x01, 0x02, 0x00, 0x00,
215 0x00, 0x00, 0x00, 0x05,
216 0x20, 0x00, 0x00, 0x00,
217 0x21, 0x02, 0x00, 0x00,
218
219 // (6th ACE)
220 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
221 0x02, // AceFlags: CONTAINER_INHERIT_ACE
222 0x18, 0x00, // AceSize
223 0x1F, 0x00, 0x03, 0x00, // ACCESS_MASK: "Read Control" (0x00020000) |
224 // "Delete" (0x00010000) |
225 // "Notify" (0x00000010) |
226 // "Enumerate Subkeys" (0x00000008) |
227 // "Create Subkey" (0x00000004) |
228 // "Set Value" (0x00000002) |
229 // "Query Value" (0x00000001)
230 // (SidStart: S-1-5-32-547 "Power Users")
231 0x01, 0x02, 0x00, 0x00,
232 0x00, 0x00, 0x00, 0x05,
233 0x20, 0x00, 0x00, 0x00,
234 0x23, 0x02, 0x00, 0x00,
235
236 // Owner SID (S-1-5-32-544 "Administrators")
237 0x01, 0x02, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x05,
239 0x20, 0x00, 0x00, 0x00,
240 0x20, 0x02, 0x00, 0x00,
241
242 // Group SID (S-1-5-21-domain-513 "Domain Users")
243 0x01, 0x05, 0x00, 0x00,
244 0x00, 0x00, 0x00, 0x05,
245 0x15, 0x00, 0x00, 0x00,
246 0xAC, 0xD0, 0x49, 0xCB,
247 0xE6, 0x52, 0x47, 0x9C,
248 0xE4, 0x31, 0xDB, 0x5C,
249 0x01, 0x02, 0x00, 0x00
250 };
251
252 // Same security for SYSTEM, SAM and .DEFAULT
253 static UCHAR SystemSecurity[] =
254 {
255 // SECURITY_DESCRIPTOR_RELATIVE
256 0x01, // Revision
257 0x00, // Sbz1
258 0x04, 0x94, // Control: SE_SELF_RELATIVE (0x8000) |
259 // SE_DACL_PROTECTED (0x1000) |
260 // SE_DACL_AUTO_INHERITED (0x0400) |
261 // SE_DACL_PRESENT (0x0004)
262 0x8C, 0x00, 0x00, 0x00, // Owner
263 0x9C, 0x00, 0x00, 0x00, // Group
264 0x00, 0x00, 0x00, 0x00, // Sacl (None)
265 0x14, 0x00, 0x00, 0x00, // Dacl
266
267 // DACL
268 0x02, // AclRevision
269 0x00, // Sbz1
270 0x78, 0x00, // AclSize
271 0x05, 0x00, // AceCount
272 0x00, 0x00, // Sbz2
273
274 // (1st ACE)
275 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
276 0x02, // AceFlags: CONTAINER_INHERIT_ACE
277 0x18, 0x00, // AceSize
278 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
279 // (SidStart: S-1-5-32-544 "Administrators")
280 0x01, 0x02, 0x00, 0x00,
281 0x00, 0x00, 0x00, 0x05,
282 0x20, 0x00, 0x00, 0x00,
283 0x20, 0x02, 0x00, 0x00,
284
285 // (2nd ACE)
286 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
287 0x0A, // AceFlags: INHERIT_ONLY_ACE | CONTAINER_INHERIT_ACE
288 0x14, 0x00, // AceSize
289 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
290 // (SidStart: S-1-3-0 "Creator Owner")
291 0x01, 0x01, 0x00, 0x00,
292 0x00, 0x00, 0x00, 0x03,
293 0x00, 0x00, 0x00, 0x00,
294
295 // (3rd ACE)
296 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
297 0x02, // AceFlags: CONTAINER_INHERIT_ACE
298 0x14, 0x00, // AceSize
299 0x3F, 0x00, 0x0F, 0x00, // ACCESS_MASK: "Full Control" (0x000F003F)
300 // (SidStart: S-1-5-18 "Local System")
301 0x01, 0x01, 0x00, 0x00,
302 0x00, 0x00, 0x00, 0x05,
303 0x12, 0x00, 0x00, 0x00,
304
305 // (4th ACE)
306 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
307 0x02, // AceFlags: CONTAINER_INHERIT_ACE
308 0x18, 0x00, // AceSize
309 0x19, 0x00, 0x02, 0x00, // ACCESS_MASK: "Read Control" (0x00020000) |
310 // "Notify" (0x00000010) |
311 // "Enumerate Subkeys" (0x00000008) |
312 // "Query Value" (0x00000001)
313 // (SidStart: S-1-5-32-545 "Users")
314 0x01, 0x02, 0x00, 0x00,
315 0x00, 0x00, 0x00, 0x05,
316 0x20, 0x00, 0x00, 0x00,
317 0x21, 0x02, 0x00, 0x00,
318
319 // (5th ACE)
320 0x00, // AceType : ACCESS_ALLOWED_ACE_TYPE
321 0x02, // AceFlags: CONTAINER_INHERIT_ACE
322 0x18, 0x00, // AceSize
323 0x19, 0x00, 0x02, 0x00, // ACCESS_MASK: "Read Control" (0x00020000) |
324 // "Notify" (0x00000010) |
325 // "Enumerate Subkeys" (0x00000008) |
326 // "Query Value" (0x00000001)
327 // (SidStart: S-1-5-32-547 "Power Users")
328 0x01, 0x02, 0x00, 0x00,
329 0x00, 0x00, 0x00, 0x05,
330 0x20, 0x00, 0x00, 0x00,
331 0x23, 0x02, 0x00, 0x00,
332
333 // Owner SID (S-1-5-32-544 "Administrators")
334 0x01, 0x02, 0x00, 0x00,
335 0x00, 0x00, 0x00, 0x05,
336 0x20, 0x00, 0x00, 0x00,
337 0x20, 0x02, 0x00, 0x00,
338
339 // Group SID (S-1-5-21-domain-513 "Domain Users")
340 0x01, 0x05, 0x00, 0x00,
341 0x00, 0x00, 0x00, 0x05,
342 0x15, 0x00, 0x00, 0x00,
343 0xAC, 0xD0, 0x49, 0xCB,
344 0xE6, 0x52, 0x47, 0x9C,
345 0xE4, 0x31, 0xDB, 0x5C,
346 0x01, 0x02, 0x00, 0x00
347 };
348
349 /* GLOBALS ******************************************************************/
350
351 HIVE_LIST_ENTRY RegistryHives[/*MAX_NUMBER_OF_REGISTRY_HIVES*/] =
352 {
353 /* Special Setup system registry hive */
354 // WARNING: Please *keep* it in first position!
355 { "SETUPREG", L"Registry\\Machine\\SYSTEM" , &SystemHive , SystemSecurity , sizeof(SystemSecurity) },
356
357 /* Regular registry hives */
358 { "SYSTEM" , L"Registry\\Machine\\SYSTEM" , &SystemHive , SystemSecurity , sizeof(SystemSecurity) },
359 { "SOFTWARE", L"Registry\\Machine\\SOFTWARE" , &SoftwareHive, SoftwareSecurity, sizeof(SoftwareSecurity) },
360 { "DEFAULT" , L"Registry\\User\\.DEFAULT" , &DefaultHive , SystemSecurity , sizeof(SystemSecurity) },
361 { "SAM" , L"Registry\\Machine\\SAM" , &SamHive , SystemSecurity , sizeof(SystemSecurity) },
362 { "SECURITY", L"Registry\\Machine\\SECURITY" , &SecurityHive, NULL , 0 },
363 { "BCD" , L"Registry\\Machine\\BCD00000000", &BcdHive , BcdSecurity , sizeof(BcdSecurity) },
364 };
365 C_ASSERT(_countof(RegistryHives) == MAX_NUMBER_OF_REGISTRY_HIVES);
366
367 /* FUNCTIONS ****************************************************************/
368
369 static PMEMKEY
370 CreateInMemoryStructure(
371 IN PCMHIVE RegistryHive,
372 IN HCELL_INDEX KeyCellOffset)
373 {
374 PMEMKEY Key;
375
376 Key = (PMEMKEY)malloc(sizeof(MEMKEY));
377 if (!Key)
378 return NULL;
379
380 Key->RegistryHive = RegistryHive;
381 Key->KeyCellOffset = KeyCellOffset;
382 return Key;
383 }
384
385 LIST_ENTRY CmiHiveListHead;
386 LIST_ENTRY CmiReparsePointsHead;
387
388 static LONG
389 RegpCreateOrOpenKey(
390 IN HKEY hParentKey,
391 IN PCWSTR KeyName,
392 IN BOOL AllowCreation,
393 IN BOOL Volatile,
394 OUT PHKEY Key)
395 {
396 NTSTATUS Status;
397 PWSTR LocalKeyName;
398 PWSTR End;
399 UNICODE_STRING KeyString;
400 PREPARSE_POINT CurrentReparsePoint;
401 PMEMKEY CurrentKey;
402 PCMHIVE ParentRegistryHive;
403 HCELL_INDEX ParentCellOffset;
404 PCM_KEY_NODE ParentKeyCell;
405 PLIST_ENTRY Ptr;
406 PCM_KEY_NODE SubKeyCell;
407 HCELL_INDEX BlockOffset;
408
409 DPRINT("RegpCreateOrOpenKey('%S')\n", KeyName);
410
411 if (*KeyName == OBJ_NAME_PATH_SEPARATOR)
412 {
413 KeyName++;
414 ParentRegistryHive = RootKey->RegistryHive;
415 ParentCellOffset = RootKey->KeyCellOffset;
416 }
417 else if (hParentKey == NULL)
418 {
419 ParentRegistryHive = RootKey->RegistryHive;
420 ParentCellOffset = RootKey->KeyCellOffset;
421 }
422 else
423 {
424 ParentRegistryHive = HKEY_TO_MEMKEY(hParentKey)->RegistryHive;
425 ParentCellOffset = HKEY_TO_MEMKEY(hParentKey)->KeyCellOffset;
426 }
427
428 LocalKeyName = (PWSTR)KeyName;
429 for (;;)
430 {
431 End = (PWSTR)strchrW(LocalKeyName, OBJ_NAME_PATH_SEPARATOR);
432 if (End)
433 {
434 KeyString.Buffer = LocalKeyName;
435 KeyString.Length = KeyString.MaximumLength =
436 (USHORT)((ULONG_PTR)End - (ULONG_PTR)LocalKeyName);
437 }
438 else
439 {
440 RtlInitUnicodeString(&KeyString, LocalKeyName);
441 if (KeyString.Length == 0)
442 {
443 /* Trailing path separator: we're done */
444 break;
445 }
446 }
447
448 ParentKeyCell = (PCM_KEY_NODE)HvGetCell(&ParentRegistryHive->Hive, ParentCellOffset);
449 if (!ParentKeyCell)
450 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
451
452 VERIFY_KEY_CELL(ParentKeyCell);
453
454 BlockOffset = CmpFindSubKeyByName(&ParentRegistryHive->Hive, ParentKeyCell, &KeyString);
455 if (BlockOffset != HCELL_NIL)
456 {
457 Status = STATUS_SUCCESS;
458
459 /* Search for a possible reparse point */
460 Ptr = CmiReparsePointsHead.Flink;
461 while (Ptr != &CmiReparsePointsHead)
462 {
463 CurrentReparsePoint = CONTAINING_RECORD(Ptr, REPARSE_POINT, ListEntry);
464 if (CurrentReparsePoint->SourceHive == ParentRegistryHive &&
465 CurrentReparsePoint->SourceKeyCellOffset == BlockOffset)
466 {
467 ParentRegistryHive = CurrentReparsePoint->DestinationHive;
468 BlockOffset = CurrentReparsePoint->DestinationKeyCellOffset;
469 break;
470 }
471 Ptr = Ptr->Flink;
472 }
473 }
474 else if (AllowCreation) // && (BlockOffset == HCELL_NIL)
475 {
476 Status = CmiAddSubKey(ParentRegistryHive,
477 ParentCellOffset,
478 &KeyString,
479 Volatile,
480 &BlockOffset);
481 }
482 else // if (BlockOffset == HCELL_NIL)
483 {
484 Status = STATUS_OBJECT_NAME_NOT_FOUND;
485 }
486
487 HvReleaseCell(&ParentRegistryHive->Hive, ParentCellOffset);
488
489 if (!NT_SUCCESS(Status))
490 {
491 DPRINT("RegpCreateOrOpenKey('%S'): Could not create or open subkey '%.*S', Status 0x%08x\n",
492 KeyName, (int)(KeyString.Length / sizeof(WCHAR)), KeyString.Buffer, Status);
493 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
494 }
495
496 ParentCellOffset = BlockOffset;
497 if (End)
498 LocalKeyName = End + 1;
499 else
500 break;
501 }
502
503 CurrentKey = CreateInMemoryStructure(ParentRegistryHive, ParentCellOffset);
504 if (!CurrentKey)
505 return ERROR_NOT_ENOUGH_MEMORY; // STATUS_NO_MEMORY;
506
507 *Key = MEMKEY_TO_HKEY(CurrentKey);
508
509 return ERROR_SUCCESS;
510 }
511
512 LONG WINAPI
513 RegCloseKey(
514 IN HKEY hKey)
515 {
516 PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
517
518 /* Free the object */
519 free(Key);
520
521 return ERROR_SUCCESS;
522 }
523
524 LONG WINAPI
525 RegCreateKeyW(
526 IN HKEY hKey,
527 IN LPCWSTR lpSubKey,
528 OUT PHKEY phkResult)
529 {
530 return RegpCreateOrOpenKey(hKey, lpSubKey, TRUE, FALSE, phkResult);
531 }
532
533 LONG WINAPI
534 RegCreateKeyExW(
535 IN HKEY hKey,
536 IN LPCWSTR lpSubKey,
537 IN DWORD Reserved,
538 IN LPWSTR lpClass OPTIONAL,
539 IN DWORD dwOptions,
540 IN REGSAM samDesired,
541 IN LPSECURITY_ATTRIBUTES lpSecurityAttributes OPTIONAL,
542 OUT PHKEY phkResult,
543 OUT LPDWORD lpdwDisposition OPTIONAL)
544 {
545 return RegpCreateOrOpenKey(hKey,
546 lpSubKey,
547 TRUE,
548 (dwOptions & REG_OPTION_VOLATILE) != 0,
549 phkResult);
550 }
551
552 LONG WINAPI
553 RegDeleteKeyW(
554 IN HKEY hKey,
555 IN LPCWSTR lpSubKey)
556 {
557 LONG rc;
558 NTSTATUS Status;
559 HKEY hTargetKey;
560 PMEMKEY Key; // ParentKey
561 PHHIVE Hive;
562 PCM_KEY_NODE KeyNode; // ParentNode
563 PCM_KEY_NODE Parent;
564 HCELL_INDEX ParentCell;
565
566 if (lpSubKey)
567 {
568 rc = RegOpenKeyW(hKey, lpSubKey, &hTargetKey);
569 if (rc != ERROR_SUCCESS)
570 return rc;
571 }
572 else
573 {
574 hTargetKey = hKey;
575 }
576
577 /* Don't allow deleting the root */
578 if (hTargetKey == RootKey)
579 {
580 /* Fail */
581 rc = ERROR_ACCESS_DENIED; // STATUS_CANNOT_DELETE;
582 goto Quit;
583 }
584
585 /* Get the hive and node */
586 Key = HKEY_TO_MEMKEY(hTargetKey);
587 Hive = &Key->RegistryHive->Hive;
588
589 /* Get the key node */
590 KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
591 if (!KeyNode)
592 {
593 rc = ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
594 goto Quit;
595 }
596
597 ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
598
599 /* Check if we don't have any children */
600 if (!(KeyNode->SubKeyCounts[Stable] + KeyNode->SubKeyCounts[Volatile]) &&
601 !(KeyNode->Flags & KEY_NO_DELETE))
602 {
603 /* Get the parent and free the cell */
604 ParentCell = KeyNode->Parent;
605 Status = CmpFreeKeyByCell(Hive, Key->KeyCellOffset, TRUE);
606 if (NT_SUCCESS(Status))
607 {
608 /* Get the parent node */
609 Parent = (PCM_KEY_NODE)HvGetCell(Hive, ParentCell);
610 if (Parent)
611 {
612 /* Make sure we're dirty */
613 ASSERT(HvIsCellDirty(Hive, ParentCell));
614
615 /* Update the write time */
616 KeQuerySystemTime(&Parent->LastWriteTime);
617
618 /* Release the cell */
619 HvReleaseCell(Hive, ParentCell);
620 }
621 }
622 else
623 {
624 /* Fail */
625 rc = ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
626 }
627 }
628 else
629 {
630 /* Fail */
631 rc = ERROR_ACCESS_DENIED; // STATUS_CANNOT_DELETE;
632 }
633
634 /* Release the cell */
635 HvReleaseCell(Hive, Key->KeyCellOffset);
636
637 Quit:
638 if (lpSubKey)
639 RegCloseKey(hTargetKey);
640
641 return rc;
642 }
643
644 LONG WINAPI
645 RegOpenKeyW(
646 IN HKEY hKey,
647 IN LPCWSTR lpSubKey,
648 OUT PHKEY phkResult)
649 {
650 return RegpCreateOrOpenKey(hKey, lpSubKey, FALSE, FALSE, phkResult);
651 }
652
653 LONG WINAPI
654 RegSetValueExW(
655 IN HKEY hKey,
656 IN LPCWSTR lpValueName OPTIONAL,
657 IN ULONG Reserved,
658 IN ULONG dwType,
659 IN const UCHAR* lpData,
660 IN ULONG cbData)
661 {
662 PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
663 PHHIVE Hive;
664 PCM_KEY_NODE KeyNode; // ParentNode
665 PCM_KEY_VALUE ValueCell;
666 ULONG ChildIndex;
667 HCELL_INDEX CellIndex;
668 UNICODE_STRING ValueNameString;
669
670 PVOID DataCell;
671 ULONG DataCellSize;
672 NTSTATUS Status;
673
674 if (dwType == REG_LINK)
675 {
676 PMEMKEY DestKey;
677
678 /* Special handling of registry links */
679 if (cbData != sizeof(PVOID))
680 return ERROR_INVALID_PARAMETER; // STATUS_INVALID_PARAMETER;
681
682 DestKey = HKEY_TO_MEMKEY(*(PHKEY)lpData);
683
684 // FIXME: Add additional checks for the validity of DestKey
685
686 /* Create the link in registry hive (if applicable) */
687 if (Key->RegistryHive != DestKey->RegistryHive)
688 return ERROR_SUCCESS;
689
690 DPRINT1("Save link to registry\n");
691 return ERROR_INVALID_FUNCTION; // STATUS_NOT_IMPLEMENTED;
692 }
693
694 if ((cbData & ~CM_KEY_VALUE_SPECIAL_SIZE) != cbData)
695 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
696
697 Hive = &Key->RegistryHive->Hive;
698
699 KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
700 if (!KeyNode)
701 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
702
703 ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
704
705 /* Mark the parent as dirty since we are going to create a new value in it */
706 HvMarkCellDirty(Hive, Key->KeyCellOffset, FALSE);
707
708 /* Initialize value name string */
709 RtlInitUnicodeString(&ValueNameString, lpValueName);
710 if (!CmpFindNameInList(Hive,
711 &KeyNode->ValueList,
712 &ValueNameString,
713 &ChildIndex,
714 &CellIndex))
715 {
716 /* Sanity check */
717 ASSERT(CellIndex == HCELL_NIL);
718 /* Fail */
719 Status = STATUS_INSUFFICIENT_RESOURCES;
720 }
721 if (CellIndex == HCELL_NIL)
722 {
723 /* The value doesn't exist, create a new one */
724 Status = CmiAddValueKey(Key->RegistryHive,
725 KeyNode,
726 ChildIndex,
727 &ValueNameString,
728 &ValueCell,
729 &CellIndex);
730 }
731 else
732 {
733 /* The value already exists, use it. Get the value cell. */
734 ValueCell = HvGetCell(&Key->RegistryHive->Hive, CellIndex);
735 ASSERT(ValueCell != NULL);
736 Status = STATUS_SUCCESS;
737 }
738
739 // /**/HvReleaseCell(Hive, CellIndex);/**/
740
741 if (!NT_SUCCESS(Status))
742 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
743
744 /* Get size of the allocated cell (if any) */
745 if (!(ValueCell->DataLength & CM_KEY_VALUE_SPECIAL_SIZE) &&
746 (ValueCell->DataLength & ~CM_KEY_VALUE_SPECIAL_SIZE) != 0)
747 {
748 DataCell = HvGetCell(Hive, ValueCell->Data);
749 if (!DataCell)
750 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
751
752 DataCellSize = (ULONG)(-HvGetCellSize(Hive, DataCell));
753 }
754 else
755 {
756 DataCell = NULL;
757 DataCellSize = 0;
758 }
759
760 if (cbData <= sizeof(HCELL_INDEX))
761 {
762 /* If data size <= sizeof(HCELL_INDEX) then store data in the data offset */
763 DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
764 if (DataCell)
765 HvFreeCell(Hive, ValueCell->Data);
766
767 RtlCopyMemory(&ValueCell->Data, lpData, cbData);
768 ValueCell->DataLength = (cbData | CM_KEY_VALUE_SPECIAL_SIZE);
769 ValueCell->Type = dwType;
770 }
771 else
772 {
773 if (cbData > DataCellSize)
774 {
775 /* New data size is larger than the current, destroy current
776 * data block and allocate a new one. */
777 HCELL_INDEX NewOffset;
778
779 DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
780
781 NewOffset = HvAllocateCell(Hive, cbData, Stable, HCELL_NIL);
782 if (NewOffset == HCELL_NIL)
783 {
784 DPRINT("HvAllocateCell() has failed!\n");
785 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
786 }
787
788 if (DataCell)
789 HvFreeCell(Hive, ValueCell->Data);
790
791 ValueCell->Data = NewOffset;
792 DataCell = (PVOID)HvGetCell(Hive, NewOffset);
793 }
794
795 /* Copy new contents to cell */
796 RtlCopyMemory(DataCell, lpData, cbData);
797 ValueCell->DataLength = (cbData & ~CM_KEY_VALUE_SPECIAL_SIZE);
798 ValueCell->Type = dwType;
799 HvMarkCellDirty(Hive, ValueCell->Data, FALSE);
800 }
801
802 HvMarkCellDirty(Hive, CellIndex, FALSE);
803
804 /* Check if the maximum value name length changed, update it if so */
805 if (KeyNode->MaxValueNameLen < ValueNameString.Length)
806 KeyNode->MaxValueNameLen = ValueNameString.Length;
807
808 /* Check if the maximum data length changed, update it if so */
809 if (KeyNode->MaxValueDataLen < cbData)
810 KeyNode->MaxValueDataLen = cbData;
811
812 /* Save the write time */
813 KeQuerySystemTime(&KeyNode->LastWriteTime);
814
815 return ERROR_SUCCESS;
816 }
817
818
819 // Synced with freeldr/ntldr/registry.c
820 static
821 VOID
822 RepGetValueData(
823 IN PHHIVE Hive,
824 IN PCM_KEY_VALUE ValueCell,
825 OUT PULONG Type OPTIONAL,
826 OUT PUCHAR Data OPTIONAL,
827 IN OUT PULONG DataSize OPTIONAL)
828 {
829 ULONG DataLength;
830 PVOID DataCell;
831
832 /* Does the caller want the type? */
833 if (Type != NULL)
834 *Type = ValueCell->Type;
835
836 /* Does the caller provide DataSize? */
837 if (DataSize != NULL)
838 {
839 // NOTE: CmpValueToData doesn't support big data (the function will
840 // bugcheck if so), FreeLdr is not supposed to read such data.
841 // If big data is needed, use instead CmpGetValueData.
842 // CmpGetValueData(Hive, ValueCell, DataSize, &DataCell, ...);
843 DataCell = CmpValueToData(Hive, ValueCell, &DataLength);
844
845 /* Does the caller want the data? */
846 if ((Data != NULL) && (*DataSize != 0))
847 {
848 RtlCopyMemory(Data,
849 DataCell,
850 min(*DataSize, DataLength));
851 }
852
853 /* Return the actual data length */
854 *DataSize = DataLength;
855 }
856 }
857
858 // Similar to RegQueryValue in freeldr/ntldr/registry.c
859 LONG WINAPI
860 RegQueryValueExW(
861 IN HKEY hKey,
862 IN LPCWSTR lpValueName,
863 IN PULONG lpReserved,
864 OUT PULONG lpType OPTIONAL,
865 OUT PUCHAR lpData OPTIONAL,
866 IN OUT PULONG lpcbData OPTIONAL)
867 {
868 PMEMKEY ParentKey = HKEY_TO_MEMKEY(hKey);
869 PHHIVE Hive = &ParentKey->RegistryHive->Hive;
870 PCM_KEY_NODE KeyNode;
871 PCM_KEY_VALUE ValueCell;
872 HCELL_INDEX CellIndex;
873 UNICODE_STRING ValueNameString;
874
875 KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, ParentKey->KeyCellOffset);
876 if (!KeyNode)
877 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
878
879 ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
880
881 /* Initialize value name string */
882 RtlInitUnicodeString(&ValueNameString, lpValueName);
883 CellIndex = CmpFindValueByName(Hive, KeyNode, &ValueNameString);
884 if (CellIndex == HCELL_NIL)
885 return ERROR_FILE_NOT_FOUND; // STATUS_OBJECT_NAME_NOT_FOUND;
886
887 /* Get the value cell */
888 ValueCell = HvGetCell(Hive, CellIndex);
889 ASSERT(ValueCell != NULL);
890
891 RepGetValueData(Hive, ValueCell, lpType, lpData, lpcbData);
892
893 HvReleaseCell(Hive, CellIndex);
894
895 return ERROR_SUCCESS;
896 }
897
898 LONG WINAPI
899 RegDeleteValueW(
900 IN HKEY hKey,
901 IN LPCWSTR lpValueName OPTIONAL)
902 {
903 LONG rc;
904 NTSTATUS Status;
905 PMEMKEY Key = HKEY_TO_MEMKEY(hKey); // ParentKey
906 PHHIVE Hive = &Key->RegistryHive->Hive;
907 PCM_KEY_NODE KeyNode; // ParentNode
908 PCM_KEY_VALUE ValueCell;
909 HCELL_INDEX CellIndex;
910 ULONG ChildIndex;
911 UNICODE_STRING ValueNameString;
912
913 KeyNode = (PCM_KEY_NODE)HvGetCell(Hive, Key->KeyCellOffset);
914 if (!KeyNode)
915 return ERROR_GEN_FAILURE; // STATUS_UNSUCCESSFUL;
916
917 ASSERT(KeyNode->Signature == CM_KEY_NODE_SIGNATURE);
918
919 /* Initialize value name string */
920 RtlInitUnicodeString(&ValueNameString, lpValueName);
921 if (!CmpFindNameInList(Hive,
922 &KeyNode->ValueList,
923 &ValueNameString,
924 &ChildIndex,
925 &CellIndex))
926 {
927 /* Sanity check */
928 ASSERT(CellIndex == HCELL_NIL);
929 }
930 if (CellIndex == HCELL_NIL)
931 {
932 rc = ERROR_FILE_NOT_FOUND; // STATUS_OBJECT_NAME_NOT_FOUND;
933 goto Quit;
934 }
935
936 /* We found the value, mark all relevant cells dirty */
937 HvMarkCellDirty(Hive, Key->KeyCellOffset, FALSE);
938 HvMarkCellDirty(Hive, KeyNode->ValueList.List, FALSE);
939 HvMarkCellDirty(Hive, CellIndex, FALSE);
940
941 /* Get the key value */
942 ValueCell = (PCM_KEY_VALUE)HvGetCell(Hive, CellIndex);
943 ASSERT(ValueCell);
944
945 /* Mark it and all related data as dirty */
946 if (!CmpMarkValueDataDirty(Hive, ValueCell))
947 {
948 /* Not enough log space, fail */
949 rc = ERROR_NO_LOG_SPACE; // STATUS_NO_LOG_SPACE;
950 goto Quit;
951 }
952
953 /* Sanity checks */
954 ASSERT(HvIsCellDirty(Hive, KeyNode->ValueList.List));
955 ASSERT(HvIsCellDirty(Hive, CellIndex));
956
957 /* Remove the value from the child list */
958 Status = CmpRemoveValueFromList(Hive, ChildIndex, &KeyNode->ValueList);
959 if (!NT_SUCCESS(Status))
960 {
961 /* Set known error */
962 rc = ERROR_NO_SYSTEM_RESOURCES; // STATUS_INSUFFICIENT_RESOURCES;
963 goto Quit;
964 }
965
966 /* Remove the value and its data itself */
967 if (!CmpFreeValue(Hive, CellIndex))
968 {
969 /* Failed to free the value, fail */
970 rc = ERROR_NO_SYSTEM_RESOURCES; // STATUS_INSUFFICIENT_RESOURCES;
971 goto Quit;
972 }
973
974 /* Set the last write time */
975 KeQuerySystemTime(&KeyNode->LastWriteTime);
976
977 /* Sanity check */
978 ASSERT(HvIsCellDirty(Hive, Key->KeyCellOffset));
979
980 /* Check if the value list is empty now */
981 if (!KeyNode->ValueList.Count)
982 {
983 /* Then clear key node data */
984 KeyNode->MaxValueNameLen = 0;
985 KeyNode->MaxValueDataLen = 0;
986 }
987
988 /* Change default Status to success */
989 rc = ERROR_SUCCESS;
990
991 Quit:
992 /* Check if we had a value */
993 if (ValueCell)
994 {
995 /* Release the child cell */
996 ASSERT(CellIndex != HCELL_NIL);
997 HvReleaseCell(Hive, CellIndex);
998 }
999
1000 /* Release the parent cell, if any */
1001 if (KeyNode)
1002 HvReleaseCell(Hive, Key->KeyCellOffset);
1003
1004 return rc;
1005 }
1006
1007
1008 static BOOL
1009 ConnectRegistry(
1010 IN HKEY RootKey,
1011 IN PCMHIVE HiveToConnect,
1012 IN PUCHAR SecurityDescriptor,
1013 IN ULONG SecurityDescriptorLength,
1014 IN PCWSTR Path)
1015 {
1016 NTSTATUS Status;
1017 LONG rc;
1018 PREPARSE_POINT ReparsePoint;
1019 PMEMKEY NewKey;
1020
1021 ReparsePoint = (PREPARSE_POINT)malloc(sizeof(*ReparsePoint));
1022 if (!ReparsePoint)
1023 return FALSE;
1024
1025 /*
1026 * Use a dummy root key name:
1027 * - On 2k/XP/2k3, this is "$$$PROTO.HIV"
1028 * - On Vista+, this is "CMI-CreateHive{guid}"
1029 * See https://github.com/libyal/winreg-kb/blob/master/documentation/Registry%20files.asciidoc
1030 * for more information.
1031 */
1032 Status = CmiInitializeHive(HiveToConnect, L"$$$PROTO.HIV");
1033 if (!NT_SUCCESS(Status))
1034 {
1035 DPRINT1("CmiInitializeHive() failed with status 0x%08x\n", Status);
1036 free(ReparsePoint);
1037 return FALSE;
1038 }
1039
1040 /*
1041 * Add security to the root key.
1042 * NOTE: One can implement this using the lpSecurityAttributes
1043 * parameter of RegCreateKeyExW.
1044 */
1045 Status = CmiCreateSecurityKey(&HiveToConnect->Hive,
1046 HiveToConnect->Hive.BaseBlock->RootCell,
1047 SecurityDescriptor, SecurityDescriptorLength);
1048 if (!NT_SUCCESS(Status))
1049 DPRINT1("Failed to add security for root key '%S'\n", Path);
1050
1051 /* Create the key */
1052 rc = RegCreateKeyExW(RootKey,
1053 Path,
1054 0,
1055 NULL,
1056 REG_OPTION_VOLATILE,
1057 0,
1058 NULL,
1059 (PHKEY)&NewKey,
1060 NULL);
1061 if (rc != ERROR_SUCCESS)
1062 {
1063 free(ReparsePoint);
1064 return FALSE;
1065 }
1066
1067 ReparsePoint->SourceHive = NewKey->RegistryHive;
1068 ReparsePoint->SourceKeyCellOffset = NewKey->KeyCellOffset;
1069 NewKey->RegistryHive = HiveToConnect;
1070 NewKey->KeyCellOffset = HiveToConnect->Hive.BaseBlock->RootCell;
1071 ReparsePoint->DestinationHive = NewKey->RegistryHive;
1072 ReparsePoint->DestinationKeyCellOffset = NewKey->KeyCellOffset;
1073 InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry);
1074
1075 return TRUE;
1076 }
1077
1078 static BOOL
1079 CreateSymLink(
1080 IN PCWSTR LinkKeyPath OPTIONAL,
1081 IN OUT PHKEY LinkKeyHandle OPTIONAL,
1082 // IN PCWSTR TargetKeyPath OPTIONAL,
1083 IN HKEY TargetKeyHandle)
1084 {
1085 LONG rc;
1086 PMEMKEY LinkKey, TargetKey;
1087 PREPARSE_POINT ReparsePoint;
1088
1089 ReparsePoint = (PREPARSE_POINT)malloc(sizeof(*ReparsePoint));
1090 if (!ReparsePoint)
1091 return FALSE;
1092
1093 if (LinkKeyPath && !(LinkKeyHandle && *LinkKeyHandle))
1094 {
1095 /* Create the link key */
1096 rc = RegCreateKeyExW(NULL,
1097 LinkKeyPath,
1098 0,
1099 NULL,
1100 REG_OPTION_VOLATILE,
1101 0,
1102 NULL,
1103 (PHKEY)&LinkKey,
1104 NULL);
1105 if (rc != ERROR_SUCCESS)
1106 {
1107 free(ReparsePoint);
1108 return FALSE;
1109 }
1110 }
1111 else if (LinkKeyHandle)
1112 {
1113 /* Use the user-provided link key handle */
1114 LinkKey = HKEY_TO_MEMKEY(*LinkKeyHandle);
1115 }
1116
1117 if (LinkKeyHandle)
1118 *LinkKeyHandle = MEMKEY_TO_HKEY(LinkKey);
1119
1120 TargetKey = HKEY_TO_MEMKEY(TargetKeyHandle);
1121
1122 ReparsePoint->SourceHive = LinkKey->RegistryHive;
1123 ReparsePoint->SourceKeyCellOffset = LinkKey->KeyCellOffset;
1124 ReparsePoint->DestinationHive = TargetKey->RegistryHive;
1125 ReparsePoint->DestinationKeyCellOffset = TargetKey->KeyCellOffset;
1126 InsertTailList(&CmiReparsePointsHead, &ReparsePoint->ListEntry);
1127
1128 return TRUE;
1129 }
1130
1131 VOID
1132 RegInitializeRegistry(
1133 IN PCSTR HiveList)
1134 {
1135 NTSTATUS Status;
1136 UINT i;
1137 HKEY ControlSetKey;
1138
1139 InitializeListHead(&CmiHiveListHead);
1140 InitializeListHead(&CmiReparsePointsHead);
1141
1142 Status = CmiInitializeHive(&RootHive, L"");
1143 if (!NT_SUCCESS(Status))
1144 {
1145 DPRINT1("CmiInitializeHive() failed with status 0x%08x\n", Status);
1146 return;
1147 }
1148
1149 RootKey = CreateInMemoryStructure(&RootHive,
1150 RootHive.Hive.BaseBlock->RootCell);
1151
1152 for (i = 0; i < _countof(RegistryHives); ++i)
1153 {
1154 /* Skip this registry hive if it's not in the list */
1155 if (!strstr(HiveList, RegistryHives[i].HiveName))
1156 continue;
1157
1158 /* Create the registry key */
1159 ConnectRegistry(NULL,
1160 RegistryHives[i].CmHive,
1161 RegistryHives[i].SecurityDescriptor,
1162 RegistryHives[i].SecurityDescriptorLength,
1163 RegistryHives[i].HiveRegistryPath);
1164
1165 /* If we happen to deal with the special setup registry hive, stop there */
1166 // if (strcmp(RegistryHives[i].HiveName, "SETUPREG") == 0)
1167 if (i == 0)
1168 break;
1169 }
1170
1171 /* Create the 'ControlSet001' key */
1172 RegCreateKeyW(NULL,
1173 L"Registry\\Machine\\SYSTEM\\ControlSet001",
1174 &ControlSetKey);
1175
1176 /* Create the 'CurrentControlSet' key as a symlink to 'ControlSet001' */
1177 CreateSymLink(L"Registry\\Machine\\SYSTEM\\CurrentControlSet",
1178 NULL, ControlSetKey);
1179
1180 RegCloseKey(ControlSetKey);
1181
1182 #if 0
1183 /* Link SECURITY to SAM */
1184 CmpLinkKeyToHive(L"\\Registry\\Machine\\Security\\SAM", L"\\Registry\\Machine\\SAM\\SAM");
1185 /* Link S-1-5-18 to .Default */
1186 CmpLinkKeyToHive(L"\\Registry\\User\\S-1-5-18", L"\\Registry\\User\\.Default");
1187 #endif
1188 }
1189
1190 VOID
1191 RegShutdownRegistry(VOID)
1192 {
1193 PLIST_ENTRY Entry;
1194 PREPARSE_POINT ReparsePoint;
1195
1196 /* Clean up the reparse points list */
1197 while (!IsListEmpty(&CmiReparsePointsHead))
1198 {
1199 Entry = RemoveHeadList(&CmiReparsePointsHead);
1200 ReparsePoint = CONTAINING_RECORD(Entry, REPARSE_POINT, ListEntry);
1201 free(ReparsePoint);
1202 }
1203
1204 /* FIXME: clean up the complete hive */
1205
1206 free(RootKey);
1207 }
1208
1209 /* EOF */