NtGdiGetObject
[reactos.git] / reactos / ntoskrnl / ob / obname.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ob/namespce.c
5 * PURPOSE: Manages all functions related to the Object Manager name-
6 * space, such as finding objects or querying their names.
7 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
8 * Eric Kohl
9 * Thomas Weidenmueller (w3seek@reactos.org)
10 */
11
12 /* INCLUDES ******************************************************************/
13
14 #include <ntoskrnl.h>
15 #define NDEBUG
16 #include <debug.h>
17
18 BOOLEAN ObpCaseInsensitive = TRUE;
19 POBJECT_DIRECTORY NameSpaceRoot;
20 POBJECT_DIRECTORY ObpTypeDirectoryObject;
21
22 /* DOS Device Prefix \??\ and \?? */
23 ALIGNEDNAME ObpDosDevicesShortNamePrefix = {{L'\\',L'?',L'?',L'\\'}};
24 ALIGNEDNAME ObpDosDevicesShortNameRoot = {{L'\\',L'?',L'?',L'\0'}};
25 UNICODE_STRING ObpDosDevicesShortName =
26 {
27 sizeof(ObpDosDevicesShortNamePrefix),
28 sizeof(ObpDosDevicesShortNamePrefix),
29 (PWSTR)&ObpDosDevicesShortNamePrefix
30 };
31
32 /* PRIVATE FUNCTIONS *********************************************************/
33
34 NTSTATUS
35 NTAPI
36 ObpCreateDosDevicesDirectory(VOID)
37 {
38 OBJECT_ATTRIBUTES ObjectAttributes;
39 UNICODE_STRING Name, LinkName;
40 HANDLE Handle, SymHandle;
41 NTSTATUS Status;
42
43 /* Create the '\??' directory */
44 RtlInitUnicodeString(&Name, L"\\??");
45 InitializeObjectAttributes(&ObjectAttributes,
46 &Name,
47 OBJ_PERMANENT,
48 NULL,
49 NULL);
50 Status = NtCreateDirectoryObject(&Handle,
51 DIRECTORY_ALL_ACCESS,
52 &ObjectAttributes);
53 if (!NT_SUCCESS(Status)) return FALSE;
54
55 /* Initialize the GLOBALROOT path */
56 RtlInitUnicodeString(&LinkName, L"GLOBALROOT");
57 RtlInitUnicodeString(&Name, L"");
58 InitializeObjectAttributes(&ObjectAttributes,
59 &LinkName,
60 OBJ_PERMANENT,
61 Handle,
62 NULL);
63 Status = NtCreateSymbolicLinkObject(&SymHandle,
64 SYMBOLIC_LINK_ALL_ACCESS,
65 &ObjectAttributes,
66 &Name);
67 if (NT_SUCCESS(Status)) NtClose(SymHandle);
68
69 /* Link \??\Global to \?? */
70 RtlInitUnicodeString(&LinkName, L"Global");
71 RtlInitUnicodeString(&Name, L"\\??");
72 InitializeObjectAttributes(&ObjectAttributes,
73 &LinkName,
74 OBJ_PERMANENT,
75 Handle,
76 NULL);
77 Status = NtCreateSymbolicLinkObject(&SymHandle,
78 SYMBOLIC_LINK_ALL_ACCESS,
79 &ObjectAttributes,
80 &Name);
81 if (NT_SUCCESS(Status)) NtClose(SymHandle);
82
83 /* Close the directory handle */
84 NtClose(Handle);
85 if (!NT_SUCCESS(Status)) return Status;
86
87 /* Create link from '\DosDevices' to '\??' directory */
88 RtlCreateUnicodeString(&LinkName, L"\\DosDevices");
89 InitializeObjectAttributes(&ObjectAttributes,
90 &LinkName,
91 OBJ_PERMANENT,
92 NULL,
93 NULL);
94 Status = NtCreateSymbolicLinkObject(&SymHandle,
95 SYMBOLIC_LINK_ALL_ACCESS,
96 &ObjectAttributes,
97 &Name);
98 if (NT_SUCCESS(Status)) NtClose(SymHandle);
99
100 /* FIXME: Hack Hack! */
101 ObSystemDeviceMap = ExAllocatePoolWithTag(NonPagedPool,
102 sizeof(*ObSystemDeviceMap),
103 TAG('O', 'b', 'D', 'm'));
104 RtlZeroMemory(ObSystemDeviceMap, sizeof(*ObSystemDeviceMap));
105
106 /* Return status */
107 return Status;
108 }
109
110 VOID
111 NTAPI
112 ObDereferenceDeviceMap(IN PEPROCESS Process)
113 {
114 //KIRQL OldIrql;
115 PDEVICE_MAP DeviceMap = Process->DeviceMap;
116
117 /* FIXME: We don't use Process Devicemaps yet */
118 if (DeviceMap)
119 {
120 /* FIXME: Acquire the DeviceMap Spinlock */
121 // KeAcquireSpinLock(DeviceMap->Lock, &OldIrql);
122
123 /* Delete the device map link and dereference it */
124 Process->DeviceMap = NULL;
125 if (--DeviceMap->ReferenceCount)
126 {
127 /* Nobody is referencing it anymore, unlink the DOS directory */
128 DeviceMap->DosDevicesDirectory->DeviceMap = NULL;
129
130 /* FIXME: Release the DeviceMap Spinlock */
131 // KeReleasepinLock(DeviceMap->Lock, OldIrql);
132
133 /* Dereference the DOS Devices Directory and free the Device Map */
134 ObDereferenceObject(DeviceMap->DosDevicesDirectory);
135 ExFreePool(DeviceMap);
136 }
137 else
138 {
139 /* FIXME: Release the DeviceMap Spinlock */
140 // KeReleasepinLock(DeviceMap->Lock, OldIrql);
141 }
142 }
143 }
144
145 VOID
146 NTAPI
147 ObInheritDeviceMap(IN PEPROCESS Parent,
148 IN PEPROCESS Process)
149 {
150 /* FIXME: Devicemap Support */
151 }
152
153 /*++
154 * @name ObpDeleteNameCheck
155 *
156 * The ObpDeleteNameCheck routine checks if a named object should be
157 * removed from the object directory namespace.
158 *
159 * @param Object
160 * Pointer to the object to check for possible removal.
161 *
162 * @return None.
163 *
164 * @remarks An object is removed if the following 4 criteria are met:
165 * 1) The object has 0 handles open
166 * 2) The object is in the directory namespace and has a name
167 * 3) The object is not permanent
168 *
169 *--*/
170 VOID
171 NTAPI
172 ObpDeleteNameCheck(IN PVOID Object)
173 {
174 POBJECT_HEADER ObjectHeader;
175 OBP_LOOKUP_CONTEXT Context;
176 POBJECT_HEADER_NAME_INFO ObjectNameInfo;
177 POBJECT_TYPE ObjectType;
178 PVOID Directory = NULL;
179
180 /* Get object structures */
181 ObjectHeader = OBJECT_TO_OBJECT_HEADER(Object);
182 ObjectNameInfo = ObpAcquireNameInformation(ObjectHeader);
183 ObjectType = ObjectHeader->Type;
184
185 /*
186 * Check if the handle count is 0, if the object is named,
187 * and if the object isn't a permanent object.
188 */
189 if (!(ObjectHeader->HandleCount) &&
190 (ObjectNameInfo) &&
191 (ObjectNameInfo->Name.Length) &&
192 (ObjectNameInfo->Directory) &&
193 !(ObjectHeader->Flags & OB_FLAG_PERMANENT))
194 {
195 /* Setup a lookup context */
196 ObpInitializeDirectoryLookup(&Context);
197
198 /* Lock the directory */
199 ObpAcquireDirectoryLockExclusive(ObjectNameInfo->Directory, &Context);
200
201 /* Do the lookup */
202 Object = ObpLookupEntryDirectory(ObjectNameInfo->Directory,
203 &ObjectNameInfo->Name,
204 0,
205 FALSE,
206 &Context);
207 if (Object)
208 {
209 /* Lock the object type */
210 ObpEnterObjectTypeMutex(ObjectType);
211
212 /* Make sure we can still delete the object */
213 if (!(ObjectHeader->HandleCount) &&
214 !(ObjectHeader->Flags & OB_FLAG_PERMANENT))
215 {
216 /* First delete it from the directory */
217 ObpDeleteEntryDirectory(&Context);
218
219 /* Check if this is a symbolic link */
220 if (ObjectType == ObSymbolicLinkType)
221 {
222 /* Remove internal name */
223 ObpDeleteSymbolicLinkName(Object);
224 }
225
226 /* Check if the magic protection flag is set */
227 ObjectNameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
228 if ((ObjectNameInfo) &&
229 (ObjectNameInfo->QueryReferences & 0x40000000))
230 {
231 /* Remove protection flag */
232 InterlockedExchangeAdd((PLONG)&ObjectNameInfo->QueryReferences,
233 -0x40000000);
234 }
235
236 /* Get the directory */
237 Directory = ObjectNameInfo->Directory;
238 }
239
240 /* Release the lock */
241 ObpLeaveObjectTypeMutex(ObjectType);
242 }
243
244 /* Cleanup after lookup */
245 ObpCleanupDirectoryLookup(&Context);
246
247 /* Remove another query reference since we added one on top */
248 ObpReleaseNameInformation(ObjectNameInfo);
249
250 /* Check if we were inserted in a directory */
251 if (Directory)
252 {
253 /* We were, so first remove the extra reference we had added */
254 ObpReleaseNameInformation(ObjectNameInfo);
255
256 /* Now dereference the object as well */
257 ObDereferenceObject(Object);
258 }
259 }
260 else
261 {
262 /* Remove the reference we added */
263 ObpReleaseNameInformation(ObjectNameInfo);
264 }
265 }
266
267 NTSTATUS
268 NTAPI
269 ObpLookupObjectName(IN HANDLE RootHandle OPTIONAL,
270 IN PUNICODE_STRING ObjectName,
271 IN ULONG Attributes,
272 IN POBJECT_TYPE ObjectType,
273 IN KPROCESSOR_MODE AccessMode,
274 IN OUT PVOID ParseContext,
275 IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL,
276 IN PVOID InsertObject OPTIONAL,
277 IN OUT PACCESS_STATE AccessState,
278 OUT POBP_LOOKUP_CONTEXT LookupContext,
279 OUT PVOID *FoundObject)
280 {
281 PVOID Object;
282 POBJECT_HEADER ObjectHeader;
283 UNICODE_STRING ComponentName, RemainingName;
284 BOOLEAN Reparse = FALSE, SymLink = FALSE;
285 PDEVICE_MAP DeviceMap = NULL;
286 POBJECT_DIRECTORY Directory = NULL, ParentDirectory = NULL, RootDirectory;
287 POBJECT_DIRECTORY ReferencedDirectory = NULL, ReferencedParentDirectory = NULL;
288 KIRQL CalloutIrql;
289 OB_PARSE_METHOD ParseRoutine;
290 NTSTATUS Status;
291 KPROCESSOR_MODE AccessCheckMode;
292 PWCHAR NewName;
293 POBJECT_HEADER_NAME_INFO ObjectNameInfo;
294 ULONG MaxReparse = 30;
295 PAGED_CODE();
296 OBTRACE(OB_NAMESPACE_DEBUG,
297 "%s - Finding Object: %wZ. Expecting: %p\n",
298 __FUNCTION__,
299 ObjectName,
300 InsertObject);
301
302 /* Initialize starting state */
303 ObpInitializeDirectoryLookup(LookupContext);
304 *FoundObject = NULL;
305 Status = STATUS_SUCCESS;
306 Object = NULL;
307
308 /* Check if case-insensitivity is checked */
309 if (ObpCaseInsensitive)
310 {
311 /* Check if the object type requests this */
312 if (!(ObjectType) || (ObjectType->TypeInfo.CaseInsensitive))
313 {
314 /* Add the flag to disable case sensitivity */
315 Attributes |= OBJ_CASE_INSENSITIVE;
316 }
317 }
318
319 /* Check if this is a access checks are being forced */
320 AccessCheckMode = (Attributes & OBJ_FORCE_ACCESS_CHECK) ?
321 UserMode : AccessMode;
322
323 /* Check if we got a Root Directory */
324 if (RootHandle)
325 {
326 /* We did. Reference it */
327 Status = ObReferenceObjectByHandle(RootHandle,
328 0,
329 NULL,
330 AccessMode,
331 (PVOID*)&RootDirectory,
332 NULL);
333 if (!NT_SUCCESS(Status)) return Status;
334
335 /* Get the header */
336 ObjectHeader = OBJECT_TO_OBJECT_HEADER(RootDirectory);
337
338 /* The name cannot start with a separator, unless this is a file */
339 if ((ObjectName->Buffer) &&
340 (ObjectName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR) &&
341 (ObjectHeader->Type != IoFileObjectType))
342 {
343 /* The syntax is bad, so fail this request */
344 ObDereferenceObject(RootDirectory);
345 return STATUS_OBJECT_PATH_SYNTAX_BAD;
346 }
347
348 /* Don't parse a Directory */
349 if (ObjectHeader->Type != ObDirectoryType)
350 {
351 /* Make sure the Object Type has a parse routine */
352 ParseRoutine = ObjectHeader->Type->TypeInfo.ParseProcedure;
353 if (!ParseRoutine)
354 {
355 /* We can't parse a name if we don't have a parse routine */
356 ObDereferenceObject(RootDirectory);
357 return STATUS_INVALID_HANDLE;
358 }
359
360 /* Set default parse count */
361 MaxReparse = 30;
362
363 /* Now parse */
364 while (TRUE)
365 {
366 /* Start with the full name */
367 RemainingName = *ObjectName;
368
369 /* Call the Parse Procedure */
370 ObpCalloutStart(&CalloutIrql);
371 Status = ParseRoutine(RootDirectory,
372 ObjectType,
373 AccessState,
374 AccessCheckMode,
375 Attributes,
376 ObjectName,
377 &RemainingName,
378 ParseContext,
379 SecurityQos,
380 &Object);
381 ObpCalloutEnd(CalloutIrql, "Parse", ObjectHeader->Type, Object);
382
383 /* Check for success or failure, so not reparse */
384 if ((Status != STATUS_REPARSE) &&
385 (Status != STATUS_REPARSE_OBJECT))
386 {
387 /* Check for failure */
388 if (!NT_SUCCESS(Status))
389 {
390 /* Parse routine might not have cleared this, do it */
391 Object = NULL;
392 }
393 else if (!Object)
394 {
395 /* Modify status to reflect failure inside Ob */
396 Status = STATUS_OBJECT_NAME_NOT_FOUND;
397 }
398
399 /* We're done, return the status and object */
400 *FoundObject = Object;
401 ObDereferenceObject(RootDirectory);
402 return Status;
403 }
404 else if ((!ObjectName->Length) ||
405 (!ObjectName->Buffer) ||
406 (ObjectName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR))
407 {
408 /* Reparsed to the root directory, so start over */
409 ObDereferenceObject(RootDirectory);
410 RootDirectory = NameSpaceRoot;
411
412 /* Don't use this anymore, since we're starting at root */
413 RootHandle = NULL;
414 goto ParseFromRoot;
415 }
416 else if (--MaxReparse)
417 {
418 /* Try reparsing again */
419 continue;
420 }
421 else
422 {
423 /* Reparsed too many times */
424 ObDereferenceObject(RootDirectory);
425
426 /* Return the object and normalized status */
427 *FoundObject = Object;
428 if (!Object) Status = STATUS_OBJECT_NAME_NOT_FOUND;
429 return Status;
430 }
431 }
432 }
433 else if (!(ObjectName->Length) || !(ObjectName->Buffer))
434 {
435 /* Just return the Root Directory if we didn't get a name*/
436 Status = ObReferenceObjectByPointer(RootDirectory,
437 0,
438 ObjectType,
439 AccessMode);
440 if (NT_SUCCESS(Status)) Object = RootDirectory;
441
442 /* Remove the first reference we added and return the object */
443 ObDereferenceObject(RootDirectory);
444 *FoundObject = Object;
445 return Status;
446 }
447 }
448 else
449 {
450 /* We did not get a Root Directory, so use the root */
451 RootDirectory = NameSpaceRoot;
452
453 /* It must start with a path separator */
454 if (!(ObjectName->Length) ||
455 !(ObjectName->Buffer) ||
456 (ObjectName->Buffer[0] != OBJ_NAME_PATH_SEPARATOR))
457 {
458 /* This name is invalid, so fail */
459 return STATUS_OBJECT_PATH_SYNTAX_BAD;
460 }
461
462 /* Check if the name is only the path separator */
463 if (ObjectName->Length == sizeof(OBJ_NAME_PATH_SEPARATOR))
464 {
465 /* So the caller only wants the root directory; do we have one? */
466 if (!RootDirectory)
467 {
468 /* This must be the first time we're creating it... right? */
469 if (InsertObject)
470 {
471 /* Yes, so return it to ObInsert so that it can create it */
472 Status = ObReferenceObjectByPointer(InsertObject,
473 0,
474 ObjectType,
475 AccessMode);
476 if (NT_SUCCESS(Status)) *FoundObject = InsertObject;
477 return Status;
478 }
479 else
480 {
481 /* This should never really happen */
482 ASSERT(FALSE);
483 return STATUS_INVALID_PARAMETER;
484 }
485 }
486 else
487 {
488 /* We do have the root directory, so just return it */
489 Status = ObReferenceObjectByPointer(RootDirectory,
490 0,
491 ObjectType,
492 AccessMode);
493 if (NT_SUCCESS(Status)) *FoundObject = RootDirectory;
494 return Status;
495 }
496 }
497 else
498 {
499 ParseFromRoot:
500 /* Check if we have a device map */
501 if (DeviceMap)
502 {
503 /* Dereference it */
504 //ObfDereferenceDeviceMap(DeviceMap);
505 DeviceMap = NULL;
506 }
507
508 /* Check if this is a possible DOS name */
509 if (!((ULONG_PTR)(ObjectName->Buffer) & 7))
510 {
511 /*
512 * This could be one. Does it match the prefix?
513 * Note that as an optimization, the match is done as 64-bit
514 * compare since the prefix is "\??\" which is exactly 8 bytes.
515 *
516 * In the second branch, we test for "\??" which is also valid.
517 * This time, we use a 32-bit compare followed by a Unicode
518 * character compare (16-bit), since the sum is 6 bytes.
519 */
520 if ((ObjectName->Length >= ObpDosDevicesShortName.Length) &&
521 (*(PULONGLONG)(ObjectName->Buffer) ==
522 ObpDosDevicesShortNamePrefix.Alignment.QuadPart))
523 {
524 /* FIXME! */
525 }
526 else if ((ObjectName->Length == ObpDosDevicesShortName.Length -
527 sizeof(WCHAR)) &&
528 (*(PULONG)(ObjectName->Buffer) ==
529 ObpDosDevicesShortNameRoot.Alignment.LowPart) &&
530 (*((PWCHAR)(ObjectName->Buffer) + 2) ==
531 (WCHAR)(ObpDosDevicesShortNameRoot.Alignment.HighPart)))
532 {
533 /* FIXME! */
534 }
535 }
536 }
537 }
538
539 /* Check if we were reparsing a symbolic link */
540 if (!SymLink)
541 {
542 /* Allow reparse */
543 Reparse = TRUE;
544 MaxReparse = 30;
545 }
546
547 /* Reparse */
548 while (Reparse)
549 {
550 /* Get the name */
551 RemainingName = *ObjectName;
552
553 /* Disable reparsing again */
554 Reparse = FALSE;
555
556 /* Start parse loop */
557 while (TRUE)
558 {
559 /* Clear object */
560 Object = NULL;
561
562 /* Check if the name starts with a path separator */
563 if ((RemainingName.Length) &&
564 (RemainingName.Buffer[0] == OBJ_NAME_PATH_SEPARATOR))
565 {
566 /* Skip the path separator */
567 RemainingName.Buffer++;
568 RemainingName.Length -= sizeof(OBJ_NAME_PATH_SEPARATOR);
569 }
570
571 /* Find the next Part Name */
572 ComponentName = RemainingName;
573 while (RemainingName.Length)
574 {
575 /* Break if we found the \ ending */
576 if (RemainingName.Buffer[0] == OBJ_NAME_PATH_SEPARATOR) break;
577
578 /* Move on */
579 RemainingName.Buffer++;
580 RemainingName.Length -= sizeof(OBJ_NAME_PATH_SEPARATOR);
581 }
582
583 /* Get its size and make sure it's valid */
584 ComponentName.Length -= RemainingName.Length;
585 if (!ComponentName.Length)
586 {
587 /* Invalid size, fail */
588 Status = STATUS_OBJECT_NAME_INVALID;
589 break;
590 }
591
592 /* Check if we're in the root */
593 if (!Directory) Directory = RootDirectory;
594
595 /* Check if this is a user-mode call that needs to traverse */
596 if ((AccessCheckMode != KernelMode) &&
597 !(AccessState->Flags & TOKEN_HAS_TRAVERSE_PRIVILEGE))
598 {
599 /* We shouldn't have referenced a directory yet */
600 ASSERT(ReferencedDirectory == NULL);
601
602 /* Reference the directory */
603 ObReferenceObject(Directory);
604 ReferencedDirectory = Directory;
605
606 /* Check if we have a parent directory */
607 if (ParentDirectory)
608 {
609 /* Check for traverse access */
610 if (!ObpCheckTraverseAccess(ParentDirectory,
611 DIRECTORY_TRAVERSE,
612 AccessState,
613 FALSE,
614 AccessCheckMode,
615 &Status))
616 {
617 /* We don't have it, fail */
618 break;
619 }
620 }
621 }
622
623 /* Check if we don't have a remaining name yet */
624 if (!RemainingName.Length)
625 {
626 /* Check if we don't have a referenced directory yet */
627 if (!ReferencedDirectory)
628 {
629 /* Reference it */
630 ObReferenceObject(Directory);
631 ReferencedDirectory = Directory;
632 }
633
634 /* Check if we are inserting an object */
635 if (InsertObject)
636 {
637 /* Lock the directory */
638 ObpAcquireDirectoryLockExclusive(Directory, LookupContext);
639 }
640 }
641
642 /* Do the lookup */
643 Object = ObpLookupEntryDirectory(Directory,
644 &ComponentName,
645 Attributes,
646 InsertObject ? FALSE : TRUE,
647 LookupContext);
648 if (!Object)
649 {
650 /* We didn't find it... do we still have a path? */
651 if (RemainingName.Length)
652 {
653 /* Then tell the caller the path wasn't found */
654 Status = STATUS_OBJECT_PATH_NOT_FOUND;
655 break;
656 }
657 else if (!InsertObject)
658 {
659 /* Otherwise, we have a path, but the name isn't valid */
660 Status = STATUS_OBJECT_NAME_NOT_FOUND;
661 break;
662 }
663
664 /* Check create access for the object */
665 if (!ObCheckCreateObjectAccess(Directory,
666 ObjectType == ObDirectoryType ?
667 DIRECTORY_CREATE_SUBDIRECTORY :
668 DIRECTORY_CREATE_OBJECT,
669 AccessState,
670 &ComponentName,
671 FALSE,
672 AccessCheckMode,
673 &Status))
674 {
675 /* We don't have create access, fail */
676 break;
677 }
678
679 /* Get the object header */
680 ObjectHeader = OBJECT_TO_OBJECT_HEADER(InsertObject);
681
682 /* FIXME: Check if this is a Section Object or Sym Link */
683 /* FIXME: If it is, then check if this isn't session 0 */
684 /* FIXME: If it isn't, check for SeCreateGlobalPrivilege */
685 /* FIXME: If privilege isn't there, check for unsecure name */
686 /* FIXME: If it isn't a known unsecure name, then fail */
687
688 /* Create Object Name */
689 NewName = ExAllocatePoolWithTag(PagedPool,
690 ComponentName.Length,
691 OB_NAME_TAG);
692 if (!(NewName) ||
693 !(ObpInsertEntryDirectory(Directory,
694 LookupContext,
695 ObjectHeader)))
696 {
697 /* Either couldn't allocate the name, or insert failed */
698 if (NewName) ExFreePool(NewName);
699
700 /* Fail due to memory reasons */
701 Status = STATUS_INSUFFICIENT_RESOURCES;
702 break;
703 }
704
705 /* Reference newly to be inserted object */
706 ObReferenceObject(InsertObject);
707
708 /* Get the name information */
709 ObjectNameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
710
711 /* Reference the directory */
712 ObReferenceObject(Directory);
713
714 /* Copy the Name */
715 RtlCopyMemory(NewName,
716 ComponentName.Buffer,
717 ComponentName.Length);
718
719 /* Check if we had an old name */
720 if (ObjectNameInfo->Name.Buffer)
721 {
722 /* Free it */
723 ExFreePool(ObjectNameInfo->Name.Buffer);
724 }
725
726 /* Write new one */
727 ObjectNameInfo->Name.Buffer = NewName;
728 ObjectNameInfo->Name.Length = ComponentName.Length;
729 ObjectNameInfo->Name.MaximumLength = ComponentName.Length;
730
731 /* Return Status and the Expected Object */
732 Status = STATUS_SUCCESS;
733 Object = InsertObject;
734
735 /* Get out of here */
736 break;
737 }
738
739 ReparseObject:
740 /* We found it, so now get its header */
741 ObjectHeader = OBJECT_TO_OBJECT_HEADER(Object);
742
743 /*
744 * Check for a parse Procedure, but don't bother to parse for an insert
745 * unless it's a Symbolic Link, in which case we MUST parse
746 */
747 ParseRoutine = ObjectHeader->Type->TypeInfo.ParseProcedure;
748 if ((ParseRoutine) &&
749 (!(InsertObject) || (ParseRoutine == ObpParseSymbolicLink)))
750 {
751 /* Use the Root Directory next time */
752 Directory = NULL;
753
754 /* Increment the pointer count */
755 InterlockedExchangeAdd(&ObjectHeader->PointerCount, 1);
756
757 /* Cleanup from the first lookup */
758 ObpCleanupDirectoryLookup(LookupContext);
759
760 /* Check if we have a referenced directory */
761 if (ReferencedDirectory)
762 {
763 /* We do, dereference it */
764 ObDereferenceObject(ReferencedDirectory);
765 ReferencedDirectory = NULL;
766 }
767
768 /* Check if we have a referenced parent directory */
769 if (ReferencedParentDirectory)
770 {
771 /* We do, dereference it */
772 ObDereferenceObject(ReferencedParentDirectory);
773 ReferencedParentDirectory = NULL;
774 }
775
776 /* Call the Parse Procedure */
777 ObpCalloutStart(&CalloutIrql);
778 Status = ParseRoutine(Object,
779 ObjectType,
780 AccessState,
781 AccessCheckMode,
782 Attributes,
783 ObjectName,
784 &RemainingName,
785 ParseContext,
786 SecurityQos,
787 &Object);
788 ObpCalloutEnd(CalloutIrql, "Parse", ObjectHeader->Type, Object);
789
790 /* Remove our extra reference */
791 ObDereferenceObject(&ObjectHeader->Body);
792
793 /* Check if we have to reparse */
794 if ((Status == STATUS_REPARSE) ||
795 (Status == STATUS_REPARSE_OBJECT))
796 {
797 /* Reparse again */
798 Reparse = TRUE;
799
800 /* Start over from root if we got sent back there */
801 if ((Status == STATUS_REPARSE_OBJECT) ||
802 (ObjectName->Buffer[0] == OBJ_NAME_PATH_SEPARATOR))
803 {
804 /* Check if we got a root directory */
805 if (RootHandle)
806 {
807 /* Stop using it, because we have a new directory now */
808 ObDereferenceObject(RootDirectory);
809 RootHandle = NULL;
810 }
811
812 /* Start at Root */
813 ParentDirectory = NULL;
814 RootDirectory = NameSpaceRoot;
815
816 /* Check for reparse status */
817 if (Status == STATUS_REPARSE_OBJECT)
818 {
819 /* Don't reparse again */
820 Reparse = FALSE;
821
822 /* Did we actually get an object to which to reparse? */
823 if (!Object)
824 {
825 /* We didn't, so set a failure status */
826 Status = STATUS_OBJECT_NAME_NOT_FOUND;
827 }
828 else
829 {
830 /* We did, so we're free to parse the new object */
831 goto ReparseObject;
832 }
833 }
834 else
835 {
836 /* This is a symbolic link */
837 SymLink = TRUE;
838 goto ParseFromRoot;
839 }
840 }
841 else if (RootDirectory == NameSpaceRoot)
842 {
843 /* We got STATUS_REPARSE but are at the Root Directory */
844 Object = NULL;
845 Status = STATUS_OBJECT_NAME_NOT_FOUND;
846 Reparse = FALSE;
847 }
848 }
849 else if (!NT_SUCCESS(Status))
850 {
851 /* Total failure */
852 Object = NULL;
853 }
854 else if (!Object)
855 {
856 /* We didn't reparse but we didn't find the Object Either */
857 Status = STATUS_OBJECT_NAME_NOT_FOUND;
858 }
859
860 /* Break out of the loop */
861 break;
862 }
863 else
864 {
865 /* No parse routine...do we still have a remaining name? */
866 if (!RemainingName.Length)
867 {
868 /* Are we creating an object? */
869 if (!InsertObject)
870 {
871 /* Check if this is a user-mode call that needs to traverse */
872 if ((AccessCheckMode != KernelMode) &&
873 !(AccessState->Flags & TOKEN_HAS_TRAVERSE_PRIVILEGE))
874 {
875 /* Check if we can get it */
876 if (!ObpCheckTraverseAccess(Directory,
877 DIRECTORY_TRAVERSE,
878 AccessState,
879 FALSE,
880 AccessCheckMode,
881 &Status))
882 {
883 /* We don't have access, fail */
884 Object = NULL;
885 break;
886 }
887 }
888
889 /* Reference the Object */
890 Status = ObReferenceObjectByPointer(Object,
891 0,
892 ObjectType,
893 AccessMode);
894 if (!NT_SUCCESS(Status)) Object = NULL;
895 }
896
897 /* And get out of the reparse loop */
898 break;
899 }
900 else
901 {
902 /* We still have a name; check if this is a directory object */
903 if (ObjectHeader->Type == ObDirectoryType)
904 {
905 /* Check if we have a referenced parent directory */
906 if (ReferencedParentDirectory)
907 {
908 /* Dereference it */
909 ObDereferenceObject(ReferencedParentDirectory);
910 }
911
912 /* Restart the lookup from this directory */
913 ReferencedParentDirectory = ReferencedDirectory;
914 ParentDirectory = Directory;
915 Directory = Object;
916 ReferencedDirectory = NULL;
917 }
918 else
919 {
920 /* We still have a name, but no parse routine for it */
921 Status = STATUS_OBJECT_TYPE_MISMATCH;
922 Object = NULL;
923 break;
924 }
925 }
926 }
927 }
928 }
929
930 /* Check if we failed */
931 if (!NT_SUCCESS(Status))
932 {
933 /* Cleanup after lookup */
934 ObpCleanupDirectoryLookup(LookupContext);
935 }
936
937 /* Check if we have a device map and dereference it if so */
938 //if (DeviceMap) ObfDereferenceDeviceMap(DeviceMap);
939
940 /* Check if we have a referenced directory and dereference it if so */
941 if (ReferencedDirectory) ObDereferenceObject(ReferencedDirectory);
942
943 /* Check if we have a referenced parent directory */
944 if (ReferencedParentDirectory)
945 {
946 /* We do, dereference it */
947 ObDereferenceObject(ReferencedParentDirectory);
948 }
949
950 /* Set the found object and check if we got one */
951 *FoundObject = Object;
952 if (!Object)
953 {
954 /* Nothing was found. Did we reparse or get success? */
955 if ((Status == STATUS_REPARSE) || (NT_SUCCESS(Status)))
956 {
957 /* Set correct failure */
958 Status = STATUS_OBJECT_NAME_NOT_FOUND;
959 }
960 }
961
962 /* Check if we had a root directory */
963 if (RootHandle) ObDereferenceObject(RootDirectory);
964
965 /* Return status to caller */
966 OBTRACE(OB_NAMESPACE_DEBUG,
967 "%s - Found Object: %p. Expected: %p\n",
968 __FUNCTION__,
969 *FoundObject,
970 InsertObject);
971 return Status;
972 }
973
974 /* PUBLIC FUNCTIONS *********************************************************/
975
976 NTSTATUS
977 NTAPI
978 ObQueryNameString(IN PVOID Object,
979 OUT POBJECT_NAME_INFORMATION ObjectNameInfo,
980 IN ULONG Length,
981 OUT PULONG ReturnLength)
982 {
983 POBJECT_HEADER_NAME_INFO LocalInfo;
984 POBJECT_HEADER ObjectHeader;
985 POBJECT_DIRECTORY ParentDirectory;
986 ULONG NameSize;
987 PWCH ObjectName;
988 BOOLEAN ObjectIsNamed;
989
990 /* Get the Kernel Meta-Structures */
991 ObjectHeader = OBJECT_TO_OBJECT_HEADER(Object);
992 LocalInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
993
994 /* Check if a Query Name Procedure is available */
995 if (ObjectHeader->Type->TypeInfo.QueryNameProcedure)
996 {
997 /* Call the procedure */
998 ObjectIsNamed = ((LocalInfo) && (LocalInfo->Name.Length > 0));
999 return ObjectHeader->Type->TypeInfo.QueryNameProcedure(Object,
1000 ObjectIsNamed,
1001 ObjectNameInfo,
1002 Length,
1003 ReturnLength,
1004 KernelMode);
1005 }
1006
1007 /* Check if the object doesn't even have a name */
1008 if (!(LocalInfo) || !(LocalInfo->Name.Buffer))
1009 {
1010 /* We're returning the name structure */
1011 *ReturnLength = sizeof(OBJECT_NAME_INFORMATION);
1012
1013 /* Check if we were given enough space */
1014 if (*ReturnLength > Length) return STATUS_INFO_LENGTH_MISMATCH;
1015
1016 /* Return an empty buffer */
1017 RtlInitEmptyUnicodeString(&ObjectNameInfo->Name, NULL, 0);
1018 return STATUS_SUCCESS;
1019 }
1020
1021 /*
1022 * Find the size needed for the name. We won't do
1023 * this during the Name Creation loop because we want
1024 * to let the caller know that the buffer isn't big
1025 * enough right at the beginning, not work our way through
1026 * and find out at the end
1027 */
1028 if (Object == NameSpaceRoot)
1029 {
1030 /* Size of the '\' string */
1031 NameSize = sizeof(OBJ_NAME_PATH_SEPARATOR);
1032 }
1033 else
1034 {
1035 /* Get the Object Directory and add name of Object */
1036 ParentDirectory = LocalInfo->Directory;
1037 NameSize = sizeof(OBJ_NAME_PATH_SEPARATOR) + LocalInfo->Name.Length;
1038
1039 /* Loop inside the directory to get the top-most one (meaning root) */
1040 while ((ParentDirectory != NameSpaceRoot) && (ParentDirectory))
1041 {
1042 /* Get the Name Information */
1043 LocalInfo = OBJECT_HEADER_TO_NAME_INFO(
1044 OBJECT_TO_OBJECT_HEADER(ParentDirectory));
1045
1046 /* Add the size of the Directory Name */
1047 if (LocalInfo && LocalInfo->Directory)
1048 {
1049 /* Size of the '\' string + Directory Name */
1050 NameSize += sizeof(OBJ_NAME_PATH_SEPARATOR) +
1051 LocalInfo->Name.Length;
1052
1053 /* Move to next parent Directory */
1054 ParentDirectory = LocalInfo->Directory;
1055 }
1056 else
1057 {
1058 /* Directory with no name. We append "...\" */
1059 NameSize += sizeof(L"...") + sizeof(OBJ_NAME_PATH_SEPARATOR);
1060 break;
1061 }
1062 }
1063 }
1064
1065 /* Finally, add the name of the structure and the null char */
1066 *ReturnLength = NameSize +
1067 sizeof(OBJECT_NAME_INFORMATION) +
1068 sizeof(UNICODE_NULL);
1069
1070 /* Check if we were given enough space */
1071 if (*ReturnLength > Length) return STATUS_INFO_LENGTH_MISMATCH;
1072
1073 /*
1074 * Now we will actually create the name. We work backwards because
1075 * it's easier to start off from the Name we have and walk up the
1076 * parent directories. We use the same logic as Name Length calculation.
1077 */
1078 LocalInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
1079 ObjectName = (PWCH)((ULONG_PTR)ObjectNameInfo + *ReturnLength);
1080 *--ObjectName = UNICODE_NULL;
1081
1082 /* Check if the object is actually the Root directory */
1083 if (Object == NameSpaceRoot)
1084 {
1085 /* This is already the Root Directory, return "\\" */
1086 *--ObjectName = OBJ_NAME_PATH_SEPARATOR;
1087 ObjectNameInfo->Name.Length = (USHORT)NameSize;
1088 ObjectNameInfo->Name.MaximumLength = (USHORT)(NameSize +
1089 sizeof(UNICODE_NULL));
1090 ObjectNameInfo->Name.Buffer = ObjectName;
1091 return STATUS_SUCCESS;
1092 }
1093 else
1094 {
1095 /* Start by adding the Object's Name */
1096 ObjectName = (PWCH)((ULONG_PTR)ObjectName -
1097 LocalInfo->Name.Length);
1098 RtlCopyMemory(ObjectName,
1099 LocalInfo->Name.Buffer,
1100 LocalInfo->Name.Length);
1101
1102 /* Now parse the Parent directories until we reach the top */
1103 ParentDirectory = LocalInfo->Directory;
1104 while ((ParentDirectory != NameSpaceRoot) && (ParentDirectory))
1105 {
1106 /* Get the name information */
1107 LocalInfo = OBJECT_HEADER_TO_NAME_INFO(
1108 OBJECT_TO_OBJECT_HEADER(ParentDirectory));
1109
1110 /* Add the "\" */
1111 *(--ObjectName) = OBJ_NAME_PATH_SEPARATOR;
1112
1113 /* Add the Parent Directory's Name */
1114 if (LocalInfo && LocalInfo->Name.Buffer)
1115 {
1116 /* Add the name */
1117 ObjectName = (PWCH)((ULONG_PTR)ObjectName -
1118 LocalInfo->Name.Length);
1119 RtlCopyMemory(ObjectName,
1120 LocalInfo->Name.Buffer,
1121 LocalInfo->Name.Length);
1122
1123 /* Move to next parent */
1124 ParentDirectory = LocalInfo->Directory;
1125 }
1126 else
1127 {
1128 /* Directory without a name, we add "..." */
1129 ObjectName -= sizeof(L"...");
1130 ObjectName = L"...";
1131 break;
1132 }
1133 }
1134
1135 /* Add Root Directory Name */
1136 *(--ObjectName) = OBJ_NAME_PATH_SEPARATOR;
1137 ObjectNameInfo->Name.Length = (USHORT)NameSize;
1138 ObjectNameInfo->Name.MaximumLength = (USHORT)(NameSize +
1139 sizeof(UNICODE_NULL));
1140 ObjectNameInfo->Name.Buffer = ObjectName;
1141 }
1142
1143 /* Return success */
1144 return STATUS_SUCCESS;
1145 }
1146
1147 VOID
1148 NTAPI
1149 ObQueryDeviceMapInformation(IN PEPROCESS Process,
1150 IN PPROCESS_DEVICEMAP_INFORMATION DeviceMapInfo)
1151 {
1152 //KIRQL OldIrql ;
1153
1154 /*
1155 * FIXME: This is an ugly hack for now, to always return the System Device Map
1156 * instead of returning the Process Device Map. Not important yet since we don't use it
1157 */
1158
1159 /* FIXME: Acquire the DeviceMap Spinlock */
1160 // KeAcquireSpinLock(DeviceMap->Lock, &OldIrql);
1161
1162 /* Make a copy */
1163 DeviceMapInfo->Query.DriveMap = ObSystemDeviceMap->DriveMap;
1164 RtlCopyMemory(DeviceMapInfo->Query.DriveType,
1165 ObSystemDeviceMap->DriveType,
1166 sizeof(ObSystemDeviceMap->DriveType));
1167
1168 /* FIXME: Release the DeviceMap Spinlock */
1169 // KeReleasepinLock(DeviceMap->Lock, OldIrql);
1170 }
1171
1172 /* EOF */