[MKHIVE]
[reactos.git] / 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 RegDeleteKey()
29 * - Implement RegEnumValue()
30 * - Implement RegQueryValueExA()
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);
88 return NULL;
89 }
90 Key->LinkedKey = NULL;
91 return Key;
92 }
93
94 static LONG
95 RegpOpenOrCreateKey(
96 IN HKEY hParentKey,
97 IN PCWSTR KeyName,
98 IN BOOL AllowCreation,
99 OUT PHKEY Key)
100 {
101 PWSTR LocalKeyName;
102 PWSTR End;
103 UNICODE_STRING KeyString;
104 NTSTATUS Status;
105 MEMKEY ParentKey;
106 MEMKEY CurrentKey;
107 PLIST_ENTRY Ptr;
108 PCM_KEY_NODE SubKeyCell;
109 HCELL_INDEX BlockOffset;
110
111 DPRINT("RegpCreateOpenKey('%S')\n", KeyName);
112
113 if (*KeyName == L'\\')
114 {
115 KeyName++;
116 ParentKey = RootKey;
117 }
118 else if (hParentKey == NULL)
119 {
120 ParentKey = RootKey;
121 }
122 else
123 {
124 ParentKey = HKEY_TO_MEMKEY(RootKey);
125 }
126
127 LocalKeyName = (PWSTR)KeyName;
128 for (;;)
129 {
130 End = (PWSTR) utf16_wcschr(LocalKeyName, '\\');
131 if (End)
132 {
133 KeyString.Buffer = LocalKeyName;
134 KeyString.Length = KeyString.MaximumLength =
135 (USHORT)((ULONG_PTR)End - (ULONG_PTR)LocalKeyName);
136 }
137 else
138 RtlInitUnicodeString(&KeyString, LocalKeyName);
139
140 /* Redirect from 'CurrentControlSet' to 'ControlSet001' */
141 if (!utf16_wcsncmp(LocalKeyName, L"CurrentControlSet", 17) &&
142 ParentKey->NameSize == 12 &&
143 !memcmp(ParentKey->Name, L"SYSTEM", 12))
144 RtlInitUnicodeString(&KeyString, L"ControlSet001");
145
146 /* Check subkey in memory structure */
147 Ptr = ParentKey->SubKeyList.Flink;
148 while (Ptr != &ParentKey->SubKeyList)
149 {
150 CurrentKey = CONTAINING_RECORD(Ptr, KEY, KeyList);
151 if (CurrentKey->NameSize == KeyString.Length
152 && memcmp(CurrentKey->Name, KeyString.Buffer, KeyString.Length) == 0)
153 {
154 goto nextsubkey;
155 }
156
157 Ptr = Ptr->Flink;
158 }
159
160 Status = CmiScanForSubKey(
161 ParentKey->RegistryHive,
162 ParentKey->KeyCell,
163 &KeyString,
164 OBJ_CASE_INSENSITIVE,
165 &SubKeyCell,
166 &BlockOffset);
167 if (AllowCreation && Status == STATUS_OBJECT_NAME_NOT_FOUND)
168 {
169 Status = CmiAddSubKey(
170 ParentKey->RegistryHive,
171 ParentKey->KeyCell,
172 ParentKey->KeyCellOffset,
173 &KeyString,
174 0,
175 &SubKeyCell,
176 &BlockOffset);
177 }
178 if (!NT_SUCCESS(Status))
179 return ERROR_UNSUCCESSFUL;
180
181 /* Now, SubKeyCell/BlockOffset are valid */
182 CurrentKey = CreateInMemoryStructure(
183 ParentKey->RegistryHive,
184 BlockOffset,
185 &KeyString);
186 if (!CurrentKey)
187 return ERROR_OUTOFMEMORY;
188
189 /* Add CurrentKey in ParentKey */
190 InsertTailList(&ParentKey->SubKeyList, &CurrentKey->KeyList);
191 ParentKey->SubKeyCount++;
192
193 nextsubkey:
194 ParentKey = CurrentKey;
195 if (End)
196 LocalKeyName = End + 1;
197 else
198 break;
199 }
200
201 *Key = MEMKEY_TO_HKEY(ParentKey);
202
203 return ERROR_SUCCESS;
204 }
205
206 LONG WINAPI
207 RegCreateKeyW(
208 IN HKEY hKey,
209 IN LPCWSTR lpSubKey,
210 OUT PHKEY phkResult)
211 {
212 return RegpOpenOrCreateKey(hKey, lpSubKey, TRUE, phkResult);
213 }
214
215 static PWSTR
216 MultiByteToWideChar(
217 IN PCSTR MultiByteString)
218 {
219 ANSI_STRING Source;
220 UNICODE_STRING Destination;
221 NTSTATUS Status;
222
223 RtlInitAnsiString(&Source, MultiByteString);
224 Status = RtlAnsiStringToUnicodeString(&Destination, &Source, TRUE);
225 if (!NT_SUCCESS(Status))
226 return NULL;
227 return Destination.Buffer;
228 }
229
230 LONG WINAPI
231 RegCreateKeyA(
232 IN HKEY hKey,
233 IN LPCSTR lpSubKey,
234 OUT PHKEY phkResult)
235 {
236 PWSTR lpSubKeyW;
237 LONG rc;
238
239 lpSubKeyW = MultiByteToWideChar(lpSubKey);
240 if (!lpSubKeyW)
241 return ERROR_OUTOFMEMORY;
242
243 rc = RegCreateKeyW(hKey, lpSubKeyW, phkResult);
244 free(lpSubKeyW);
245 return rc;
246 }
247
248 LONG WINAPI
249 RegDeleteKeyA(HKEY Key,
250 LPCSTR Name)
251 {
252 if (Name != NULL && strchr(Name, '\\') != NULL)
253 return(ERROR_INVALID_PARAMETER);
254
255 DPRINT1("FIXME!\n");
256
257 return(ERROR_SUCCESS);
258 }
259
260 LONG WINAPI
261 RegOpenKeyW(
262 IN HKEY hKey,
263 IN LPCWSTR lpSubKey,
264 OUT PHKEY phkResult)
265 {
266 return RegpOpenOrCreateKey(hKey, lpSubKey, FALSE, phkResult);
267 }
268
269 LONG WINAPI
270 RegOpenKeyA(
271 IN HKEY hKey,
272 IN LPCSTR lpSubKey,
273 OUT PHKEY phkResult)
274 {
275 PWSTR lpSubKeyW;
276 LONG rc;
277
278 lpSubKeyW = MultiByteToWideChar(lpSubKey);
279 if (!lpSubKeyW)
280 return ERROR_OUTOFMEMORY;
281
282 rc = RegOpenKeyW(hKey, lpSubKeyW, phkResult);
283 free(lpSubKeyW);
284 return rc;
285 }
286
287 static LONG
288 RegpOpenOrCreateValue(
289 IN HKEY hKey,
290 IN LPCWSTR ValueName,
291 IN BOOL AllowCreation,
292 OUT PCM_KEY_VALUE *ValueCell,
293 OUT PHCELL_INDEX ValueCellOffset)
294 {
295 MEMKEY ParentKey;
296 UNICODE_STRING ValueString;
297 NTSTATUS Status;
298
299 ParentKey = HKEY_TO_MEMKEY(hKey);
300 RtlInitUnicodeString(&ValueString, ValueName);
301
302 Status = CmiScanForValueKey(
303 ParentKey->RegistryHive,
304 ParentKey->KeyCell,
305 &ValueString,
306 ValueCell,
307 ValueCellOffset);
308 if (AllowCreation && Status == STATUS_OBJECT_NAME_NOT_FOUND)
309 {
310 Status = CmiAddValueKey(
311 ParentKey->RegistryHive,
312 ParentKey->KeyCell,
313 ParentKey->KeyCellOffset,
314 &ValueString,
315 ValueCell,
316 ValueCellOffset);
317 }
318 if (!NT_SUCCESS(Status))
319 return ERROR_UNSUCCESSFUL;
320 return ERROR_SUCCESS;
321 }
322
323 LONG WINAPI
324 RegSetValueExW(
325 IN HKEY hKey,
326 IN LPCWSTR lpValueName OPTIONAL,
327 IN ULONG Reserved,
328 IN ULONG dwType,
329 IN const UCHAR* lpData,
330 IN USHORT cbData)
331 {
332 MEMKEY Key, DestKey;
333 PHKEY phKey;
334 PCM_KEY_VALUE ValueCell;
335 HCELL_INDEX ValueCellOffset;
336 PVOID DataCell;
337 LONG DataCellSize;
338 NTSTATUS Status;
339
340 if (dwType == REG_LINK)
341 {
342 /* Special handling of registry links */
343 if (cbData != sizeof(PVOID))
344 return STATUS_INVALID_PARAMETER;
345 phKey = (PHKEY)lpData;
346 Key = HKEY_TO_MEMKEY(hKey);
347 DestKey = HKEY_TO_MEMKEY(*phKey);
348
349 /* Create the link in memory */
350 Key->DataType = REG_LINK;
351 Key->LinkedKey = DestKey;
352
353 /* Create the link in registry hive (if applicable) */
354 if (Key->RegistryHive != DestKey->RegistryHive)
355 return STATUS_SUCCESS;
356 DPRINT1("Save link to registry\n");
357 return STATUS_NOT_IMPLEMENTED;
358 }
359
360 if ((cbData & REG_DATA_SIZE_MASK) != cbData)
361 return STATUS_UNSUCCESSFUL;
362
363 Key = HKEY_TO_MEMKEY(hKey);
364
365 Status = RegpOpenOrCreateValue(hKey, lpValueName, TRUE, &ValueCell, &ValueCellOffset);
366 if (!NT_SUCCESS(Status))
367 return ERROR_UNSUCCESSFUL;
368
369 /* Get size of the allocated cellule (if any) */
370 if (!(ValueCell->DataLength & REG_DATA_IN_OFFSET) &&
371 (ValueCell->DataLength & REG_DATA_SIZE_MASK) != 0)
372 {
373 DataCell = HvGetCell(&Key->RegistryHive->Hive, ValueCell->Data);
374 if (!DataCell)
375 return ERROR_UNSUCCESSFUL;
376 DataCellSize = -HvGetCellSize(&Key->RegistryHive->Hive, DataCell);
377 }
378 else
379 {
380 DataCell = NULL;
381 DataCellSize = 0;
382 }
383
384 if (cbData <= sizeof(HCELL_INDEX))
385 {
386 /* If data size <= sizeof(HCELL_INDEX) then store data in the data offset */
387 DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
388 if (DataCell)
389 HvFreeCell(&Key->RegistryHive->Hive, ValueCell->Data);
390
391 RtlCopyMemory(&ValueCell->Data, lpData, cbData);
392 ValueCell->DataLength = (ULONG)(cbData | REG_DATA_IN_OFFSET);
393 ValueCell->Type = dwType;
394 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
395 }
396 else
397 {
398 if (cbData > (SIZE_T)DataCellSize)
399 {
400 /* New data size is larger than the current, destroy current
401 * data block and allocate a new one. */
402 HCELL_INDEX NewOffset;
403
404 DPRINT("ValueCell->DataLength %u\n", ValueCell->DataLength);
405
406 NewOffset = HvAllocateCell(&Key->RegistryHive->Hive, cbData, Stable, HCELL_NIL);
407 if (NewOffset == HCELL_NIL)
408 {
409 DPRINT("HvAllocateCell() failed with status 0x%08x\n", Status);
410 return ERROR_UNSUCCESSFUL;
411 }
412
413 if (DataCell)
414 HvFreeCell(&Key->RegistryHive->Hive, ValueCell->Data);
415
416 ValueCell->Data = NewOffset;
417 DataCell = (PVOID)HvGetCell(&Key->RegistryHive->Hive, NewOffset);
418 }
419
420 /* Copy new contents to cellule */
421 RtlCopyMemory(DataCell, lpData, cbData);
422 ValueCell->DataLength = (ULONG)(cbData & REG_DATA_SIZE_MASK);
423 ValueCell->Type = dwType;
424 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCell->Data, FALSE);
425 HvMarkCellDirty(&Key->RegistryHive->Hive, ValueCellOffset, FALSE);
426 }
427
428 HvMarkCellDirty(&Key->RegistryHive->Hive, Key->KeyCellOffset, FALSE);
429
430 DPRINT("Return status 0x%08x\n", Status);
431 return Status;
432 }
433
434 LONG WINAPI
435 RegSetValueExA(
436 IN HKEY hKey,
437 IN LPCSTR lpValueName OPTIONAL,
438 IN ULONG Reserved,
439 IN ULONG dwType,
440 IN const UCHAR* lpData,
441 IN ULONG cbData)
442 {
443 LPWSTR lpValueNameW = NULL;
444 const UCHAR* lpDataW;
445 USHORT cbDataW;
446 LONG rc = ERROR_SUCCESS;
447
448 DPRINT("RegSetValueA(%s)\n", lpValueName);
449 if (lpValueName)
450 {
451 lpValueNameW = MultiByteToWideChar(lpValueName);
452 if (!lpValueNameW)
453 return ERROR_OUTOFMEMORY;
454 }
455
456 if ((dwType == REG_SZ || dwType == REG_EXPAND_SZ || dwType == REG_MULTI_SZ)
457 && cbData != 0)
458 {
459 ANSI_STRING AnsiString;
460 UNICODE_STRING Data;
461
462 if (lpData[cbData - 1] != '\0')
463 cbData++;
464 RtlInitAnsiString(&AnsiString, NULL);
465 AnsiString.Buffer = (PSTR)lpData;
466 AnsiString.Length = (USHORT)cbData - 1;
467 AnsiString.MaximumLength = (USHORT)cbData;
468 RtlAnsiStringToUnicodeString (&Data, &AnsiString, TRUE);
469 lpDataW = (const UCHAR*)Data.Buffer;
470 cbDataW = Data.MaximumLength;
471 }
472 else
473 {
474 lpDataW = lpData;
475 cbDataW = (USHORT)cbData;
476 }
477
478 if (rc == ERROR_SUCCESS)
479 rc = RegSetValueExW(hKey, lpValueNameW, 0, dwType, lpDataW, cbDataW);
480 if (lpValueNameW)
481 free(lpValueNameW);
482 if (lpData != lpDataW)
483 free((PVOID)lpDataW);
484 return rc;
485 }
486
487 LONG WINAPI
488 RegQueryValueExW(
489 IN HKEY hKey,
490 IN LPCWSTR lpValueName,
491 IN PULONG lpReserved,
492 OUT PULONG lpType,
493 OUT PUCHAR lpData,
494 OUT PSIZE_T lpcbData)
495 {
496 //ParentKey = HKEY_TO_MEMKEY(RootKey);
497 PCM_KEY_VALUE ValueCell;
498 HCELL_INDEX ValueCellOffset;
499 LONG rc;
500
501 rc = RegpOpenOrCreateValue(
502 hKey,
503 lpValueName,
504 FALSE,
505 &ValueCell,
506 &ValueCellOffset);
507 if (rc != ERROR_SUCCESS)
508 return rc;
509
510 DPRINT1("RegQueryValueExW(%S) not implemented\n", lpValueName);
511 /* ValueCell and ValueCellOffset are valid */
512
513 return ERROR_UNSUCCESSFUL;
514 }
515
516 LONG WINAPI
517 RegQueryValueExA(
518 IN HKEY hKey,
519 IN LPCSTR lpValueName,
520 IN PULONG lpReserved,
521 OUT PULONG lpType,
522 OUT PUCHAR lpData,
523 OUT PSIZE_T lpcbData)
524 {
525 LPWSTR lpValueNameW = NULL;
526 LONG rc;
527
528 if (lpValueName)
529 {
530 lpValueNameW = MultiByteToWideChar(lpValueName);
531 if (!lpValueNameW)
532 return ERROR_OUTOFMEMORY;
533 }
534
535 rc = RegQueryValueExW(hKey, lpValueNameW, lpReserved, lpType, lpData, lpcbData);
536 if (lpValueNameW)
537 free(lpValueNameW);
538 return ERROR_UNSUCCESSFUL;
539 }
540
541 LONG WINAPI
542 RegDeleteValueW(
543 IN HKEY hKey,
544 IN LPCWSTR lpValueName OPTIONAL)
545 {
546 DPRINT1("RegDeleteValueW() unimplemented\n");
547 return ERROR_UNSUCCESSFUL;
548 }
549
550 LONG WINAPI
551 RegDeleteValueA(
552 IN HKEY hKey,
553 IN LPCSTR lpValueName OPTIONAL)
554 {
555 LPWSTR lpValueNameW;
556 LONG rc;
557
558 if (lpValueName)
559 {
560 lpValueNameW = MultiByteToWideChar(lpValueName);
561 if (!lpValueNameW)
562 return ERROR_OUTOFMEMORY;
563 rc = RegDeleteValueW(hKey, lpValueNameW);
564 free(lpValueNameW);
565 }
566 else
567 rc = RegDeleteValueW(hKey, NULL);
568 return rc;
569 }
570
571 static BOOL
572 ConnectRegistry(
573 IN HKEY RootKey,
574 IN PCMHIVE HiveToConnect,
575 IN LPCWSTR Path)
576 {
577 NTSTATUS Status;
578 MEMKEY NewKey;
579 LONG rc;
580
581 Status = CmiInitializeTempHive(HiveToConnect);
582 if (!NT_SUCCESS(Status))
583 {
584 DPRINT1("CmiInitializeTempHive() failed with status 0x%08x\n", Status);
585 return FALSE;
586 }
587
588 /* Create key */
589 rc = RegCreateKeyW(
590 RootKey,
591 Path,
592 (PHKEY)&NewKey);
593 if (rc != ERROR_SUCCESS)
594 return FALSE;
595
596 NewKey->RegistryHive = HiveToConnect;
597 NewKey->KeyCellOffset = HiveToConnect->Hive.BaseBlock->RootCell;
598 NewKey->KeyCell = (PCM_KEY_NODE)HvGetCell (&HiveToConnect->Hive, NewKey->KeyCellOffset);
599 return TRUE;
600 }
601
602 LIST_ENTRY CmiHiveListHead;
603
604 VOID
605 RegInitializeRegistry(VOID)
606 {
607 UNICODE_STRING RootKeyName = RTL_CONSTANT_STRING(L"\\");
608 NTSTATUS Status;
609 HKEY ControlSetKey;
610
611 InitializeListHead(&CmiHiveListHead);
612
613 Status = CmiInitializeTempHive(&RootHive);
614 if (!NT_SUCCESS(Status))
615 {
616 DPRINT1("CmiInitializeTempHive() failed with status 0x%08x\n", Status);
617 return;
618 }
619
620 RootKey = CreateInMemoryStructure(
621 &RootHive,
622 RootHive.Hive.BaseBlock->RootCell,
623 &RootKeyName);
624
625 /* Create DEFAULT key */
626 ConnectRegistry(
627 NULL,
628 &DefaultHive,
629 L"Registry\\User\\.DEFAULT");
630
631 /* Create SAM key */
632 ConnectRegistry(
633 NULL,
634 &SamHive,
635 L"Registry\\Machine\\SAM");
636
637 /* Create SECURITY key */
638 ConnectRegistry(
639 NULL,
640 &SecurityHive,
641 L"Registry\\Machine\\SECURITY");
642
643 /* Create SOFTWARE key */
644 ConnectRegistry(
645 NULL,
646 &SoftwareHive,
647 L"Registry\\Machine\\SOFTWARE");
648
649 /* Create SYSTEM key */
650 ConnectRegistry(
651 NULL,
652 &SystemHive,
653 L"Registry\\Machine\\SYSTEM");
654
655 /* Create 'ControlSet001' key */
656 RegCreateKeyW(
657 NULL,
658 L"Registry\\Machine\\SYSTEM\\ControlSet001",
659 &ControlSetKey);
660 }
661
662 /* EOF */