forget update de.rc
[reactos.git] / reactos / ntoskrnl / cm / regobj.c
1 /* $Id$
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/cm/regobj.c
6 * PURPOSE: Registry object manipulation routines.
7 *
8 * PROGRAMMERS: No programmer listed.
9 */
10
11 #include <ntoskrnl.h>
12 #define NDEBUG
13 #include <internal/debug.h>
14
15 #include "cm.h"
16
17 extern LIST_ENTRY CmiKeyObjectListHead;
18 extern ULONG CmiTimer;
19
20 static NTSTATUS
21 CmiGetLinkTarget(PREGISTRY_HIVE RegistryHive,
22 PKEY_CELL KeyCell,
23 PUNICODE_STRING TargetPath);
24
25 /* FUNCTONS *****************************************************************/
26
27 NTSTATUS STDCALL
28 CmiObjectParse(PVOID ParsedObject,
29 PVOID *NextObject,
30 PUNICODE_STRING FullPath,
31 PWSTR *Path,
32 ULONG Attributes)
33 {
34 BLOCK_OFFSET BlockOffset;
35 PKEY_OBJECT FoundObject;
36 PKEY_OBJECT ParsedKey;
37 PKEY_CELL SubKeyCell;
38 NTSTATUS Status;
39 PWSTR StartPtr;
40 PWSTR EndPtr;
41 ULONG Length;
42 UNICODE_STRING LinkPath;
43 UNICODE_STRING TargetPath;
44 UNICODE_STRING KeyName;
45
46 ParsedKey = ParsedObject;
47
48 VERIFY_KEY_OBJECT(ParsedKey);
49
50 *NextObject = NULL;
51
52 if ((*Path) == NULL)
53 {
54 DPRINT("*Path is NULL\n");
55 return STATUS_UNSUCCESSFUL;
56 }
57
58 DPRINT("Path '%S'\n", *Path);
59
60 /* Extract relevant path name */
61 StartPtr = *Path;
62 if (*StartPtr == L'\\')
63 StartPtr++;
64
65 EndPtr = wcschr(StartPtr, L'\\');
66 if (EndPtr != NULL)
67 Length = ((PCHAR)EndPtr - (PCHAR)StartPtr) / sizeof(WCHAR);
68 else
69 Length = wcslen(StartPtr);
70
71
72 KeyName.Length = Length * sizeof(WCHAR);
73 KeyName.MaximumLength = KeyName.Length + sizeof(WCHAR);
74 KeyName.Buffer = ExAllocatePool(NonPagedPool,
75 KeyName.MaximumLength);
76 RtlCopyMemory(KeyName.Buffer,
77 StartPtr,
78 KeyName.Length);
79 KeyName.Buffer[KeyName.Length / sizeof(WCHAR)] = 0;
80
81 /* Acquire hive lock */
82 KeEnterCriticalRegion();
83 ExAcquireResourceExclusiveLite(&CmiRegistryLock, TRUE);
84
85
86 Status = CmiScanKeyList(ParsedKey,
87 &KeyName,
88 Attributes,
89 &FoundObject);
90 if (!NT_SUCCESS(Status))
91 {
92 ExReleaseResourceLite(&CmiRegistryLock);
93 KeLeaveCriticalRegion();
94 RtlFreeUnicodeString(&KeyName);
95 return Status;
96 }
97 if (FoundObject == NULL)
98 {
99 Status = CmiScanForSubKey(ParsedKey->RegistryHive,
100 ParsedKey->KeyCell,
101 &SubKeyCell,
102 &BlockOffset,
103 &KeyName,
104 0,
105 Attributes);
106 if (!NT_SUCCESS(Status) || (SubKeyCell == NULL))
107 {
108 ExReleaseResourceLite(&CmiRegistryLock);
109 KeLeaveCriticalRegion();
110 RtlFreeUnicodeString(&KeyName);
111 return(STATUS_UNSUCCESSFUL);
112 }
113
114 if ((SubKeyCell->Flags & REG_KEY_LINK_CELL) &&
115 !((Attributes & OBJ_OPENLINK) && (EndPtr == NULL)))
116 {
117 RtlInitUnicodeString(&LinkPath, NULL);
118 Status = CmiGetLinkTarget(ParsedKey->RegistryHive,
119 SubKeyCell,
120 &LinkPath);
121 if (NT_SUCCESS(Status))
122 {
123 ExReleaseResourceLite(&CmiRegistryLock);
124 KeLeaveCriticalRegion();
125
126 DPRINT("LinkPath '%wZ'\n", &LinkPath);
127
128 /* build new FullPath for reparsing */
129 TargetPath.MaximumLength = LinkPath.MaximumLength;
130 if (EndPtr != NULL)
131 {
132 TargetPath.MaximumLength += (wcslen(EndPtr) * sizeof(WCHAR));
133 }
134 TargetPath.Length = TargetPath.MaximumLength - sizeof(WCHAR);
135 TargetPath.Buffer = ExAllocatePool(NonPagedPool,
136 TargetPath.MaximumLength);
137 wcscpy(TargetPath.Buffer, LinkPath.Buffer);
138 if (EndPtr != NULL)
139 {
140 wcscat(TargetPath.Buffer, EndPtr);
141 }
142
143 RtlFreeUnicodeString(FullPath);
144 RtlFreeUnicodeString(&LinkPath);
145 FullPath->Length = TargetPath.Length;
146 FullPath->MaximumLength = TargetPath.MaximumLength;
147 FullPath->Buffer = TargetPath.Buffer;
148
149 DPRINT("FullPath '%wZ'\n", FullPath);
150
151 /* reinitialize Path for reparsing */
152 *Path = FullPath->Buffer;
153
154 *NextObject = NULL;
155
156 RtlFreeUnicodeString(&KeyName);
157 return(STATUS_REPARSE);
158 }
159 }
160
161 /* Create new key object and put into linked list */
162 DPRINT("CmiObjectParse: %S\n", *Path);
163 Status = ObCreateObject(KernelMode,
164 CmiKeyType,
165 NULL,
166 KernelMode,
167 NULL,
168 sizeof(KEY_OBJECT),
169 0,
170 0,
171 (PVOID*)&FoundObject);
172 if (!NT_SUCCESS(Status))
173 {
174 ExReleaseResourceLite(&CmiRegistryLock);
175 KeLeaveCriticalRegion();
176 RtlFreeUnicodeString(&KeyName);
177 return(Status);
178 }
179 DPRINT("Inserting Key into Object Tree\n");
180 Status = ObInsertObject((PVOID)FoundObject,
181 NULL,
182 KEY_ALL_ACCESS,
183 0,
184 NULL,
185 NULL);
186 DPRINT("Status %x\n", Status);
187
188 /* Add the keep-alive reference */
189 ObReferenceObject(FoundObject);
190
191 FoundObject->Flags = 0;
192 FoundObject->KeyCell = SubKeyCell;
193 FoundObject->KeyCellOffset = BlockOffset;
194 FoundObject->RegistryHive = ParsedKey->RegistryHive;
195 InsertTailList(&CmiKeyObjectListHead, &FoundObject->ListEntry);
196 RtlpCreateUnicodeString(&FoundObject->Name,
197 KeyName.Buffer, NonPagedPool);
198 CmiAddKeyToList(ParsedKey, FoundObject);
199 DPRINT("Created object 0x%p\n", FoundObject);
200 }
201 else
202 {
203 if ((FoundObject->KeyCell->Flags & REG_KEY_LINK_CELL) &&
204 !((Attributes & OBJ_OPENLINK) && (EndPtr == NULL)))
205 {
206 DPRINT("Found link\n");
207
208 RtlInitUnicodeString(&LinkPath, NULL);
209 Status = CmiGetLinkTarget(FoundObject->RegistryHive,
210 FoundObject->KeyCell,
211 &LinkPath);
212 if (NT_SUCCESS(Status))
213 {
214 DPRINT("LinkPath '%wZ'\n", &LinkPath);
215
216 ExReleaseResourceLite(&CmiRegistryLock);
217 KeLeaveCriticalRegion();
218
219 ObDereferenceObject(FoundObject);
220
221 /* build new FullPath for reparsing */
222 TargetPath.MaximumLength = LinkPath.MaximumLength;
223 if (EndPtr != NULL)
224 {
225 TargetPath.MaximumLength += (wcslen(EndPtr) * sizeof(WCHAR));
226 }
227 TargetPath.Length = TargetPath.MaximumLength - sizeof(WCHAR);
228 TargetPath.Buffer = ExAllocatePool(NonPagedPool,
229 TargetPath.MaximumLength);
230 wcscpy(TargetPath.Buffer, LinkPath.Buffer);
231 if (EndPtr != NULL)
232 {
233 wcscat(TargetPath.Buffer, EndPtr);
234 }
235
236 RtlFreeUnicodeString(FullPath);
237 RtlFreeUnicodeString(&LinkPath);
238 FullPath->Length = TargetPath.Length;
239 FullPath->MaximumLength = TargetPath.MaximumLength;
240 FullPath->Buffer = TargetPath.Buffer;
241
242 DPRINT("FullPath '%wZ'\n", FullPath);
243
244 /* reinitialize Path for reparsing */
245 *Path = FullPath->Buffer;
246
247 *NextObject = NULL;
248
249 RtlFreeUnicodeString(&KeyName);
250 return(STATUS_REPARSE);
251 }
252 }
253 }
254
255 RemoveEntryList(&FoundObject->ListEntry);
256 InsertHeadList(&CmiKeyObjectListHead, &FoundObject->ListEntry);
257 FoundObject->TimeStamp = CmiTimer;
258
259 ExReleaseResourceLite(&CmiRegistryLock);
260 KeLeaveCriticalRegion();
261
262 DPRINT("CmiObjectParse: %s\n", FoundObject->Name);
263
264 *Path = EndPtr;
265
266 VERIFY_KEY_OBJECT(FoundObject);
267
268 *NextObject = FoundObject;
269
270 RtlFreeUnicodeString(&KeyName);
271
272 return(STATUS_SUCCESS);
273 }
274
275 VOID STDCALL
276 CmiObjectDelete(PVOID DeletedObject)
277 {
278 PKEY_OBJECT ParentKeyObject;
279 PKEY_OBJECT KeyObject;
280
281 DPRINT("Delete key object (%p)\n", DeletedObject);
282
283 KeyObject = (PKEY_OBJECT) DeletedObject;
284 ParentKeyObject = KeyObject->ParentKey;
285
286 ObReferenceObject (ParentKeyObject);
287
288 /* Acquire hive lock */
289 KeEnterCriticalRegion();
290 ExAcquireResourceExclusiveLite(&CmiRegistryLock, TRUE);
291
292 if (!NT_SUCCESS(CmiRemoveKeyFromList(KeyObject)))
293 {
294 DPRINT1("Key not found in parent list ???\n");
295 }
296
297 RemoveEntryList(&KeyObject->ListEntry);
298 RtlFreeUnicodeString(&KeyObject->Name);
299
300 if (KeyObject->Flags & KO_MARKED_FOR_DELETE)
301 {
302 DPRINT("delete really key\n");
303
304 CmiRemoveSubKey(KeyObject->RegistryHive,
305 ParentKeyObject,
306 KeyObject);
307
308 KeQuerySystemTime (&ParentKeyObject->KeyCell->LastWriteTime);
309 CmiMarkBlockDirty (ParentKeyObject->RegistryHive,
310 ParentKeyObject->KeyCellOffset);
311
312 if (!IsNoFileHive (KeyObject->RegistryHive) ||
313 !IsNoFileHive (ParentKeyObject->RegistryHive))
314 {
315 CmiSyncHives ();
316 }
317 }
318
319 ObDereferenceObject (ParentKeyObject);
320
321 ExReleaseResourceLite(&CmiRegistryLock);
322 KeLeaveCriticalRegion();
323
324 if (KeyObject->NumberOfSubKeys)
325 {
326 KEBUGCHECK(REGISTRY_ERROR);
327 }
328
329 if (KeyObject->SizeOfSubKeys)
330 {
331 ExFreePool(KeyObject->SubKeys);
332 }
333 }
334
335
336 static NTSTATUS
337 CmiQuerySecurityDescriptor(PKEY_OBJECT KeyObject,
338 SECURITY_INFORMATION SecurityInformation,
339 PISECURITY_DESCRIPTOR SecurityDescriptor,
340 PULONG BufferLength)
341 {
342 ULONG_PTR Current;
343 ULONG SidSize;
344 ULONG SdSize;
345 NTSTATUS Status;
346
347 DPRINT("CmiQuerySecurityDescriptor() called\n");
348
349 /*
350 * FIXME:
351 * This is a big hack!!
352 * We need to retrieve the security descriptor from the keys security cell!
353 */
354
355 if (SecurityInformation == 0)
356 {
357 return STATUS_ACCESS_DENIED;
358 }
359
360 SidSize = RtlLengthSid(SeWorldSid);
361 SdSize = sizeof(SECURITY_DESCRIPTOR) + (2 * SidSize);
362
363 if (*BufferLength < SdSize)
364 {
365 *BufferLength = SdSize;
366 return STATUS_BUFFER_TOO_SMALL;
367 }
368
369 *BufferLength = SdSize;
370
371 Status = RtlCreateSecurityDescriptor(SecurityDescriptor,
372 SECURITY_DESCRIPTOR_REVISION);
373 if (!NT_SUCCESS(Status))
374 {
375 return Status;
376 }
377
378 SecurityDescriptor->Control |= SE_SELF_RELATIVE;
379 Current = (ULONG_PTR)SecurityDescriptor + sizeof(SECURITY_DESCRIPTOR);
380
381 if (SecurityInformation & OWNER_SECURITY_INFORMATION)
382 {
383 RtlCopyMemory((PVOID)Current,
384 SeWorldSid,
385 SidSize);
386 SecurityDescriptor->Owner = (PSID)((ULONG_PTR)Current - (ULONG_PTR)SecurityDescriptor);
387 Current += SidSize;
388 }
389
390 if (SecurityInformation & GROUP_SECURITY_INFORMATION)
391 {
392 RtlCopyMemory((PVOID)Current,
393 SeWorldSid,
394 SidSize);
395 SecurityDescriptor->Group = (PSID)((ULONG_PTR)Current - (ULONG_PTR)SecurityDescriptor);
396 Current += SidSize;
397 }
398
399 if (SecurityInformation & DACL_SECURITY_INFORMATION)
400 {
401 SecurityDescriptor->Control |= SE_DACL_PRESENT;
402 }
403
404 if (SecurityInformation & SACL_SECURITY_INFORMATION)
405 {
406 SecurityDescriptor->Control |= SE_SACL_PRESENT;
407 }
408
409 return STATUS_SUCCESS;
410 }
411
412
413 static NTSTATUS
414 CmiAssignSecurityDescriptor(PKEY_OBJECT KeyObject,
415 PSECURITY_DESCRIPTOR SecurityDescriptor)
416 {
417 #if 0
418 PREGISTRY_HIVE Hive;
419
420 DPRINT1("CmiAssignSecurityDescriptor() callled\n");
421
422 DPRINT1("KeyObject %p\n", KeyObject);
423 DPRINT1("KeyObject->RegistryHive %p\n", KeyObject->RegistryHive);
424
425 Hive = KeyObject->RegistryHive;
426 if (Hive == NULL)
427 {
428 DPRINT1("Create new root security cell\n");
429 return STATUS_SUCCESS;
430 }
431
432 if (Hive->RootSecurityCell == NULL)
433 {
434 DPRINT1("Create new root security cell\n");
435
436 }
437 else
438 {
439 DPRINT1("Search for security cell\n");
440
441 }
442 #endif
443
444 return STATUS_SUCCESS;
445 }
446
447
448 NTSTATUS STDCALL
449 CmiObjectSecurity(PVOID ObjectBody,
450 SECURITY_OPERATION_CODE OperationCode,
451 SECURITY_INFORMATION SecurityInformation,
452 PSECURITY_DESCRIPTOR SecurityDescriptor,
453 PULONG BufferLength,
454 PSECURITY_DESCRIPTOR *OldSecurityDescriptor,
455 POOL_TYPE PoolType,
456 PGENERIC_MAPPING GenericMapping)
457 {
458 DPRINT("CmiObjectSecurity() called\n");
459
460 switch (OperationCode)
461 {
462 case SetSecurityDescriptor:
463 DPRINT("Set security descriptor\n");
464 return STATUS_SUCCESS;
465
466 case QuerySecurityDescriptor:
467 DPRINT("Query security descriptor\n");
468 return CmiQuerySecurityDescriptor((PKEY_OBJECT)ObjectBody,
469 SecurityInformation,
470 SecurityDescriptor,
471 BufferLength);
472
473 case DeleteSecurityDescriptor:
474 DPRINT("Delete security descriptor\n");
475 return STATUS_SUCCESS;
476
477 case AssignSecurityDescriptor:
478 DPRINT("Assign security descriptor\n");
479 return CmiAssignSecurityDescriptor((PKEY_OBJECT)ObjectBody,
480 SecurityDescriptor);
481 }
482
483 return STATUS_UNSUCCESSFUL;
484 }
485
486
487 NTSTATUS STDCALL
488 CmiObjectQueryName (PVOID ObjectBody,
489 POBJECT_NAME_INFORMATION ObjectNameInfo,
490 ULONG Length,
491 PULONG ReturnLength)
492 {
493 PKEY_OBJECT KeyObject;
494 NTSTATUS Status;
495
496 DPRINT ("CmiObjectQueryName() called\n");
497
498 KeyObject = (PKEY_OBJECT)ObjectBody;
499
500 if (KeyObject->ParentKey != KeyObject)
501 {
502 Status = ObQueryNameString (KeyObject->ParentKey,
503 ObjectNameInfo,
504 Length,
505 ReturnLength);
506 }
507 else
508 {
509 /* KeyObject is the root key */
510 Status = ObQueryNameString (HEADER_TO_OBJECT_NAME(BODY_TO_HEADER(KeyObject))->Directory,
511 ObjectNameInfo,
512 Length,
513 ReturnLength);
514 }
515
516 if (!NT_SUCCESS(Status) && Status != STATUS_INFO_LENGTH_MISMATCH)
517 {
518 return Status;
519 }
520 (*ReturnLength) += sizeof(WCHAR) + KeyObject->Name.Length;
521
522 if (Status == STATUS_INFO_LENGTH_MISMATCH || *ReturnLength > Length)
523 {
524 return STATUS_INFO_LENGTH_MISMATCH;
525 }
526
527 if (ObjectNameInfo->Name.Buffer == NULL)
528 {
529 ObjectNameInfo->Name.Buffer = (PWCHAR)(ObjectNameInfo + 1);
530 ObjectNameInfo->Name.Length = 0;
531 ObjectNameInfo->Name.MaximumLength = Length - sizeof(OBJECT_NAME_INFORMATION);
532 }
533
534
535 DPRINT ("Parent path: %wZ\n", ObjectNameInfo->Name);
536
537 Status = RtlAppendUnicodeToString (&ObjectNameInfo->Name,
538 L"\\");
539 if (!NT_SUCCESS (Status))
540 return Status;
541
542 Status = RtlAppendUnicodeStringToString (&ObjectNameInfo->Name,
543 &KeyObject->Name);
544 if (NT_SUCCESS (Status))
545 {
546 DPRINT ("Total path: %wZ\n", &ObjectNameInfo->Name);
547 }
548
549 return Status;
550 }
551
552
553 VOID
554 CmiAddKeyToList(PKEY_OBJECT ParentKey,
555 PKEY_OBJECT NewKey)
556 {
557
558 DPRINT("ParentKey %.08x\n", ParentKey);
559
560
561 if (ParentKey->SizeOfSubKeys <= ParentKey->NumberOfSubKeys)
562 {
563 PKEY_OBJECT *tmpSubKeys = ExAllocatePool(NonPagedPool,
564 (ParentKey->NumberOfSubKeys + 1) * sizeof(ULONG));
565
566 if (ParentKey->NumberOfSubKeys > 0)
567 {
568 RtlCopyMemory (tmpSubKeys,
569 ParentKey->SubKeys,
570 ParentKey->NumberOfSubKeys * sizeof(ULONG));
571 }
572
573 if (ParentKey->SubKeys)
574 ExFreePool(ParentKey->SubKeys);
575
576 ParentKey->SubKeys = tmpSubKeys;
577 ParentKey->SizeOfSubKeys = ParentKey->NumberOfSubKeys + 1;
578 }
579
580 /* FIXME: Please maintain the list in alphabetic order */
581 /* to allow a dichotomic search */
582 ParentKey->SubKeys[ParentKey->NumberOfSubKeys++] = NewKey;
583
584 DPRINT("Reference parent key: 0x%p\n", ParentKey);
585
586 ObReferenceObjectByPointer(ParentKey,
587 STANDARD_RIGHTS_REQUIRED,
588 NULL,
589 UserMode);
590 NewKey->ParentKey = ParentKey;
591 }
592
593
594 NTSTATUS
595 CmiRemoveKeyFromList(PKEY_OBJECT KeyToRemove)
596 {
597 PKEY_OBJECT ParentKey;
598 DWORD Index;
599
600 ParentKey = KeyToRemove->ParentKey;
601 /* FIXME: If list maintained in alphabetic order, use dichotomic search */
602 for (Index = 0; Index < ParentKey->NumberOfSubKeys; Index++)
603 {
604 if (ParentKey->SubKeys[Index] == KeyToRemove)
605 {
606 if (Index < ParentKey->NumberOfSubKeys-1)
607 RtlMoveMemory(&ParentKey->SubKeys[Index],
608 &ParentKey->SubKeys[Index + 1],
609 (ParentKey->NumberOfSubKeys - Index - 1) * sizeof(PKEY_OBJECT));
610 ParentKey->NumberOfSubKeys--;
611
612 DPRINT("Dereference parent key: 0x%x\n", ParentKey);
613
614 ObDereferenceObject(ParentKey);
615 return STATUS_SUCCESS;
616 }
617 }
618
619 return STATUS_UNSUCCESSFUL;
620 }
621
622
623 NTSTATUS
624 CmiScanKeyList(PKEY_OBJECT Parent,
625 PUNICODE_STRING KeyName,
626 ULONG Attributes,
627 PKEY_OBJECT* ReturnedObject)
628 {
629 PKEY_OBJECT CurKey;
630 ULONG Index;
631
632 DPRINT("Scanning key list for: %wZ (Parent: %wZ)\n",
633 KeyName, &Parent->Name);
634
635 /* FIXME: if list maintained in alphabetic order, use dichotomic search */
636 for (Index=0; Index < Parent->NumberOfSubKeys; Index++)
637 {
638 CurKey = Parent->SubKeys[Index];
639 if (Attributes & OBJ_CASE_INSENSITIVE)
640 {
641 if ((KeyName->Length == CurKey->Name.Length)
642 && (_wcsicmp(KeyName->Buffer, CurKey->Name.Buffer) == 0))
643 {
644 break;
645 }
646 }
647 else
648 {
649 if ((KeyName->Length == CurKey->Name.Length)
650 && (wcscmp(KeyName->Buffer, CurKey->Name.Buffer) == 0))
651 {
652 break;
653 }
654 }
655 }
656
657 if (Index < Parent->NumberOfSubKeys)
658 {
659 if (CurKey->Flags & KO_MARKED_FOR_DELETE)
660 {
661 *ReturnedObject = NULL;
662 return STATUS_UNSUCCESSFUL;
663 }
664 ObReferenceObject(CurKey);
665 *ReturnedObject = CurKey;
666 }
667 else
668 {
669 *ReturnedObject = NULL;
670 }
671 return STATUS_SUCCESS;
672 }
673
674
675 static NTSTATUS
676 CmiGetLinkTarget(PREGISTRY_HIVE RegistryHive,
677 PKEY_CELL KeyCell,
678 PUNICODE_STRING TargetPath)
679 {
680 UNICODE_STRING LinkName = RTL_CONSTANT_STRING(L"SymbolicLinkValue");
681 PVALUE_CELL ValueCell;
682 PDATA_CELL DataCell;
683 NTSTATUS Status;
684
685 DPRINT("CmiGetLinkTarget() called\n");
686
687 /* Get Value block of interest */
688 Status = CmiScanKeyForValue(RegistryHive,
689 KeyCell,
690 &LinkName,
691 &ValueCell,
692 NULL);
693 if (!NT_SUCCESS(Status))
694 {
695 DPRINT1("CmiScanKeyForValue() failed (Status %lx)\n", Status);
696 return(Status);
697 }
698
699 if (ValueCell->DataType != REG_LINK)
700 {
701 DPRINT1("Type != REG_LINK\n!");
702 return(STATUS_UNSUCCESSFUL);
703 }
704
705 if (TargetPath->Buffer == NULL && TargetPath->MaximumLength == 0)
706 {
707 TargetPath->Length = 0;
708 TargetPath->MaximumLength = ValueCell->DataSize + sizeof(WCHAR);
709 TargetPath->Buffer = ExAllocatePool(NonPagedPool,
710 TargetPath->MaximumLength);
711 }
712
713 TargetPath->Length = min(TargetPath->MaximumLength - sizeof(WCHAR),
714 (ULONG) ValueCell->DataSize);
715
716 if (ValueCell->DataSize > 0)
717 {
718 DataCell = CmiGetCell (RegistryHive, ValueCell->DataOffset, NULL);
719 RtlCopyMemory(TargetPath->Buffer,
720 DataCell->Data,
721 TargetPath->Length);
722 TargetPath->Buffer[TargetPath->Length / sizeof(WCHAR)] = 0;
723 }
724 else
725 {
726 RtlCopyMemory(TargetPath->Buffer,
727 &ValueCell->DataOffset,
728 TargetPath->Length);
729 TargetPath->Buffer[TargetPath->Length / sizeof(WCHAR)] = 0;
730 }
731
732 DPRINT("TargetPath '%wZ'\n", TargetPath);
733
734 return(STATUS_SUCCESS);
735 }
736
737 /* EOF */