obdir.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for obdir.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
BOOLEAN NTAPI	ObpInsertEntryDirectory (IN POBJECT_DIRECTORY Parent, IN POBP_LOOKUP_CONTEXT Context, IN POBJECT_HEADER ObjectHeader)
POBJECT_DIRECTORY NTAPI	ObpGetShadowDirectory (IN POBJECT_DIRECTORY Directory)
PVOID NTAPI	ObpLookupEntryDirectory (IN POBJECT_DIRECTORY Directory, IN PUNICODE_STRING Name, IN ULONG Attributes, IN BOOLEAN SearchShadow, IN POBP_LOOKUP_CONTEXT Context)
BOOLEAN NTAPI	ObpDeleteEntryDirectory (POBP_LOOKUP_CONTEXT Context)
NTSTATUS NTAPI	NtOpenDirectoryObject (OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)
NTSTATUS NTAPI	NtQueryDirectoryObject (IN HANDLE DirectoryHandle, OUT PVOID Buffer, IN ULONG BufferLength, IN BOOLEAN ReturnSingleEntry, IN BOOLEAN RestartScan, IN OUT PULONG Context, OUT PULONG ReturnLength OPTIONAL)
NTSTATUS NTAPI	NtCreateDirectoryObject (OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes)

Variables
POBJECT_TYPE	ObpDirectoryObjectType = NULL

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 17 of file obdir.c.

Function Documentation

NtCreateDirectoryObject()

NTSTATUS NTAPI NtCreateDirectoryObject	(	OUT PHANDLE	DirectoryHandle,
		IN ACCESS_MASK	DesiredAccess,
		IN POBJECT_ATTRIBUTES	ObjectAttributes
	)

Definition at line 765 of file obdir.c.

{
    POBJECT_DIRECTORY Directory;
    HANDLE NewHandle;
    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Check if we need to do any probing */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            /* Probe the return handle */
            ProbeForWriteHandle(DirectoryHandle);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Return the exception code */
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* Create the object */
    Status = ObCreateObject(PreviousMode,
                            ObpDirectoryObjectType,
                            ObjectAttributes,
                            PreviousMode,
                            NULL,
                            sizeof(OBJECT_DIRECTORY),
                            0,
                            0,
                            (PVOID*)&Directory);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Setup the object */
    RtlZeroMemory(Directory, sizeof(OBJECT_DIRECTORY));
    ExInitializePushLock(&Directory->Lock);
    Directory->SessionId = -1;
 
    /* Insert it into the handle table */
    Status = ObInsertObject((PVOID)Directory,
                            NULL,
                            DesiredAccess,
                            0,
                            NULL,
                            &NewHandle);
 
    /* Enter SEH to protect write */
    _SEH2_TRY
    {
        /* Return the handle back to the caller */
        *DirectoryHandle = NewHandle;
    }
    _SEH2_EXCEPT(ExSystemExceptionFilter())
    {
        /* Get the exception code */
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    /* Return status to caller */
    return Status;
}

Referenced by BaseInitializeStaticServerData(), CsrCreateSessionObjectDirectory(), CsrParseServerCommandLine(), ExpCreateSystemRootLink(), ExpInitializeCallbacks(), IopCreateRootDirectories(), NlsInit(), ObInitSystem(), ObpCreateDosDevicesDirectory(), SmpConfigureObjectDirectories(), SmpInitializeKnownDllsInternal(), and SmpLoadDataFromRegistry().

NtOpenDirectoryObject()

NTSTATUS NTAPI NtOpenDirectoryObject	(	OUT PHANDLE	DirectoryHandle,
		IN ACCESS_MASK	DesiredAccess,
		IN POBJECT_ATTRIBUTES	ObjectAttributes
	)

Definition at line 393 of file obdir.c.

{
    HANDLE Directory;
    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
    NTSTATUS Status;
    PAGED_CODE();
 
    /* Check if we need to do any probing */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            /* Probe the return handle */
            ProbeForWriteHandle(DirectoryHandle);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Return the exception code */
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
 
    /* Open the directory object */
    Status = ObOpenObjectByName(ObjectAttributes,
                                ObpDirectoryObjectType,
                                PreviousMode,
                                NULL,
                                DesiredAccess,
                                NULL,
                                &Directory);
    if (NT_SUCCESS(Status))
    {
        _SEH2_TRY
        {
            /* Write back the handle to the caller */
            *DirectoryHandle = Directory;
        }
        _SEH2_EXCEPT(ExSystemExceptionFilter())
        {
            /* Get the exception code */
            Status = _SEH2_GetExceptionCode();
        }
        _SEH2_END;
    }
 
    /* Return the status to the caller */
    return Status;
}

Referenced by BaseGetNamedObjectDirectory(), CreateWindowStationW(), GetLogicalDrives(), ListDirectory(), NtOpenObject(), OpenWindowStationW(), QueryDosDeviceW(), ResolveArcNameNtSymLink(), ScmCheckDriver(), ScmGetDriverStatus(), and SmpInitializeDosDevices().

NtQueryDirectoryObject()

NTSTATUS NTAPI NtQueryDirectoryObject	(	IN HANDLE	DirectoryHandle,
		OUT PVOID	Buffer,
		IN ULONG	BufferLength,
		IN BOOLEAN	ReturnSingleEntry,
		IN BOOLEAN	RestartScan,
		IN OUT PULONG	Context,
		OUT PULONG ReturnLength	OPTIONAL
	)

Definition at line 490 of file obdir.c.

{
    POBJECT_DIRECTORY Directory;
    KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
    ULONG SkipEntries = 0;
    NTSTATUS Status;
    PVOID LocalBuffer;
    POBJECT_DIRECTORY_INFORMATION DirectoryInfo;
    ULONG Length, TotalLength;
    ULONG Count, CurrentEntry;
    ULONG Hash;
    POBJECT_DIRECTORY_ENTRY Entry;
    POBJECT_HEADER ObjectHeader;
    POBJECT_HEADER_NAME_INFO ObjectNameInfo;
    UNICODE_STRING Name;
    PWSTR p;
    OBP_LOOKUP_CONTEXT LookupContext;
    PAGED_CODE();
 
    /* Initialize lookup */
    ObpInitializeLookupContext(&LookupContext);
 
    /* Check if we need to do any probing */
    if (PreviousMode != KernelMode)
    {
        _SEH2_TRY
        {
            /* Probe the buffer (assuming it will hold Unicode characters) */
            ProbeForWrite(Buffer, BufferLength, sizeof(WCHAR));
 
            /* Probe the context and copy it unless scan-restart was requested */
            ProbeForWriteUlong(Context);
            if (!RestartScan) SkipEntries = *Context;
 
            /* Probe the return length if the caller specified one */
            if (ReturnLength) ProbeForWriteUlong(ReturnLength);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            /* Return the exception code */
            _SEH2_YIELD(return _SEH2_GetExceptionCode());
        }
        _SEH2_END;
    }
    else if (!RestartScan)
    {
        /* This is kernel mode, save the context without probing, if needed */
        SkipEntries = *Context;
    }
 
    /* Allocate a buffer */
    LocalBuffer = ExAllocatePoolWithTag(PagedPool,
                                        sizeof(OBJECT_DIRECTORY_INFORMATION) +
                                        BufferLength,
                                        OB_NAME_TAG);
    if (!LocalBuffer) return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(LocalBuffer, BufferLength);
 
    /* Get a reference to directory */
    Status = ObReferenceObjectByHandle(DirectoryHandle,
                                       DIRECTORY_QUERY,
                                       ObpDirectoryObjectType,
                                       PreviousMode,
                                       (PVOID*)&Directory,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        /* Free the buffer and fail */
        ExFreePoolWithTag(LocalBuffer, OB_NAME_TAG);
        return Status;
    }
 
    /* Lock the directory in shared mode */
    ObpAcquireDirectoryLockShared(Directory, &LookupContext);
 
    /* Start at position 0 */
    DirectoryInfo = (POBJECT_DIRECTORY_INFORMATION)LocalBuffer;
    TotalLength = sizeof(OBJECT_DIRECTORY_INFORMATION);
 
    /* Start with 0 entries */
    Count = 0;
    CurrentEntry = 0;
 
    /* Set default status and start looping */
    Status = STATUS_NO_MORE_ENTRIES;
    for (Hash = 0; Hash < 37; Hash++)
    {
        /* Get this entry and loop all of them */
        Entry = Directory->HashBuckets[Hash];
        while (Entry)
        {
            /* Check if we should process this entry */
            if (SkipEntries == CurrentEntry++)
            {
                /* Get the header data */
                ObjectHeader = OBJECT_TO_OBJECT_HEADER(Entry->Object);
                ObjectNameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
 
                /* Get the object name */
                if (ObjectNameInfo)
                {
                    /* Use the one we have */
                    Name = ObjectNameInfo->Name;
                }
                else
                {
                    /* Otherwise, use an empty one */
                    RtlInitEmptyUnicodeString(&Name, NULL, 0);
                }
 
                /* Calculate the length for this entry */
                Length = sizeof(OBJECT_DIRECTORY_INFORMATION) +
                         Name.Length + sizeof(UNICODE_NULL) +
                         ObjectHeader->Type->Name.Length + sizeof(UNICODE_NULL);
 
                /* Make sure this entry won't overflow */
                if ((TotalLength + Length) > BufferLength)
                {
                    /* Check if the caller wanted only an entry */
                    if (ReturnSingleEntry)
                    {
                        /* Then we'll fail and ask for more buffer */
                        TotalLength += Length;
                        Status = STATUS_BUFFER_TOO_SMALL;
                    }
                    else
                    {
                        /* Otherwise, we'll say we're done for now */
                        Status = STATUS_MORE_ENTRIES;
                    }
 
                    /* Decrease the entry since we didn't process */
                    CurrentEntry--;
                    goto Quickie;
                }
 
                /* Now fill in the buffer */
                DirectoryInfo->Name.Length = Name.Length;
                DirectoryInfo->Name.MaximumLength = Name.Length +
                                                    sizeof(UNICODE_NULL);
                DirectoryInfo->Name.Buffer = Name.Buffer;
                DirectoryInfo->TypeName.Length = ObjectHeader->
                                                 Type->Name.Length;
                DirectoryInfo->TypeName.MaximumLength = ObjectHeader->
                                                        Type->Name.Length +
                                                        sizeof(UNICODE_NULL);
                DirectoryInfo->TypeName.Buffer = ObjectHeader->
                                                 Type->Name.Buffer;
 
                /* Set success */
                Status = STATUS_SUCCESS;
 
                /* Increase statistics */
                TotalLength += Length;
                DirectoryInfo++;
                Count++;
 
                /* If the caller only wanted an entry, bail out */
                if (ReturnSingleEntry) goto Quickie;
 
                /* Increase the key by one */
                SkipEntries++;
            }
 
            /* Move to the next directory */
            Entry = Entry->ChainLink;
        }
    }
 
Quickie:
    /* Make sure we got success */
    if (NT_SUCCESS(Status))
    {
        /* Clear the current pointer and set it */
        RtlZeroMemory(DirectoryInfo, sizeof(OBJECT_DIRECTORY_INFORMATION));
        DirectoryInfo++;
 
        /* Set the buffer here now and loop entries */
        p = (PWSTR)DirectoryInfo;
        DirectoryInfo = LocalBuffer;
        while (Count--)
        {
            /* Copy the name buffer */
            RtlCopyMemory(p,
                          DirectoryInfo->Name.Buffer,
                          DirectoryInfo->Name.Length);
 
            /* Now fixup the pointers */
            DirectoryInfo->Name.Buffer = (PVOID)((ULONG_PTR)Buffer +
                                                 ((ULONG_PTR)p -
                                                  (ULONG_PTR)LocalBuffer));
 
            /* Advance in buffer and NULL-terminate */
            p = (PVOID)((ULONG_PTR)p + DirectoryInfo->Name.Length);
            *p++ = UNICODE_NULL;
 
            /* Now copy the type name buffer */
            RtlCopyMemory(p,
                          DirectoryInfo->TypeName.Buffer,
                          DirectoryInfo->TypeName.Length);
 
            /* Now fixup the pointers */
            DirectoryInfo->TypeName.Buffer = (PVOID)((ULONG_PTR)Buffer +
                                                     ((ULONG_PTR)p -
                                                     (ULONG_PTR)LocalBuffer));
 
            /* Advance in buffer and NULL-terminate */
            p = (PVOID)((ULONG_PTR)p + DirectoryInfo->TypeName.Length);
            *p++ = UNICODE_NULL;
 
            /* Move to the next entry */
            DirectoryInfo++;
        }
 
        /* Set the key */
        *Context = CurrentEntry;
    }
 
    _SEH2_TRY
    {
        /* Copy the buffer */
        RtlCopyMemory(Buffer,
                      LocalBuffer,
                      (TotalLength <= BufferLength) ?
                      TotalLength : BufferLength);
 
        /* Check if the caller requested the return length and return it*/
        if (ReturnLength) *ReturnLength = TotalLength;
    }
    _SEH2_EXCEPT(ExSystemExceptionFilter())
    {
        /* Get the exception code */
        Status = _SEH2_GetExceptionCode();
    }
    _SEH2_END;
 
    /* Unlock the directory */
    ObpReleaseDirectoryLock(Directory, &LookupContext);
 
    /* Dereference the directory and free our buffer */
    ObDereferenceObject(Directory);
    ExFreePoolWithTag(LocalBuffer, OB_NAME_TAG);
 
    /* Return status to caller */
    return Status;
}

Referenced by CEnumNTDirectory::EnumerateNext(), GetLogicalDrives(), ListDirectory(), QueryDosDeviceW(), ScmCheckDriver(), ScmGetDriverStatus(), and SmpTranslateSystemPartitionInformation().

ObpDeleteEntryDirectory()

BOOLEAN NTAPI ObpDeleteEntryDirectory

(

POBP_LOOKUP_CONTEXT

Context

)

Definition at line 344 of file obdir.c.

{
    POBJECT_DIRECTORY Directory;
    POBJECT_DIRECTORY_ENTRY *AllocatedEntry;
    POBJECT_DIRECTORY_ENTRY CurrentEntry;
 
    /* Get the Directory */
    Directory = Context->Directory;
    if (!Directory) return FALSE;
 
    /* Get the Entry */
    AllocatedEntry = &Directory->HashBuckets[Context->HashIndex];
    CurrentEntry = *AllocatedEntry;
 
    /* Unlink the Entry */
    *AllocatedEntry = CurrentEntry->ChainLink;
    CurrentEntry->ChainLink = NULL;
 
    /* Free it */
    ExFreePoolWithTag(CurrentEntry, OB_DIR_TAG);
 
    /* Return */
    return TRUE;
}

ObpGetShadowDirectory()

POBJECT_DIRECTORY NTAPI ObpGetShadowDirectory

(

IN POBJECT_DIRECTORY

Directory

)

Definition at line 110 of file obdir.c.

{
    PDEVICE_MAP DeviceMap;
    POBJECT_DIRECTORY GlobalDosDirectory = NULL;
 
    /* Acquire the device map lock */
    KeAcquireGuardedMutex(&ObpDeviceMapLock);
 
    /* Get the global DOS directory if any */
    DeviceMap = Directory->DeviceMap;
    if (DeviceMap != NULL)
    {
        GlobalDosDirectory = DeviceMap->GlobalDosDevicesDirectory;
    }
 
    /* Release the devicemap lock */
    KeReleaseGuardedMutex(&ObpDeviceMapLock);
 
    return GlobalDosDirectory;
}

Referenced by ObpLookupEntryDirectory().

ObpInsertEntryDirectory()

BOOLEAN NTAPI ObpInsertEntryDirectory	(	IN POBJECT_DIRECTORY	Parent,
		IN POBP_LOOKUP_CONTEXT	Context,
		IN POBJECT_HEADER	ObjectHeader
	)

Definition at line 45 of file obdir.c.

{
    POBJECT_DIRECTORY_ENTRY *AllocatedEntry;
    POBJECT_DIRECTORY_ENTRY NewEntry;
    POBJECT_HEADER_NAME_INFO HeaderNameInfo;
 
    /* Make sure we have a name */
    ASSERT(ObjectHeader->NameInfoOffset != 0);
 
    /* Validate the context */
    if ((Context->Object) ||
        !(Context->DirectoryLocked) ||
        (Parent != Context->Directory))
    {
        /* Invalid context */
        DPRINT1("OB: ObpInsertEntryDirectory - invalid context %p %u\n",
                Context, Context->DirectoryLocked);
        ASSERT(FALSE);
        return FALSE;
    }
 
    /* Allocate a new Directory Entry */
    NewEntry = ExAllocatePoolWithTag(PagedPool,
                                     sizeof(OBJECT_DIRECTORY_ENTRY),
                                     OB_DIR_TAG);
    if (!NewEntry) return FALSE;
 
    /* Save the hash */
    NewEntry->HashValue = Context->HashValue;
 
    /* Get the Object Name Information */
    HeaderNameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
 
    /* Get the Allocated entry */
    AllocatedEntry = &Parent->HashBuckets[Context->HashIndex];
 
    /* Set it */
    NewEntry->ChainLink = *AllocatedEntry;
    *AllocatedEntry = NewEntry;
 
    /* Associate the Object */
    NewEntry->Object = &ObjectHeader->Body;
 
    /* Associate the Directory */
    HeaderNameInfo->Directory = Parent;
    return TRUE;
}

Referenced by ObCreateObjectType(), ObInitSystem(), and ObpLookupObjectName().

ObpLookupEntryDirectory()

PVOID NTAPI ObpLookupEntryDirectory	(	IN POBJECT_DIRECTORY	Directory,
		IN PUNICODE_STRING	Name,
		IN ULONG	Attributes,
		IN BOOLEAN	SearchShadow,
		IN POBP_LOOKUP_CONTEXT	Context
	)

Definition at line 158 of file obdir.c.

{
    BOOLEAN CaseInsensitive = FALSE;
    POBJECT_HEADER_NAME_INFO HeaderNameInfo;
    POBJECT_HEADER ObjectHeader;
    ULONG HashValue;
    ULONG HashIndex;
    LONG TotalChars;
    WCHAR CurrentChar;
    POBJECT_DIRECTORY_ENTRY *AllocatedEntry;
    POBJECT_DIRECTORY_ENTRY *LookupBucket;
    POBJECT_DIRECTORY_ENTRY CurrentEntry;
    PVOID FoundObject = NULL;
    PWSTR Buffer;
    POBJECT_DIRECTORY ShadowDirectory;
 
    PAGED_CODE();
 
    /* Check if we should search the shadow directory */
    if (ObpLUIDDeviceMapsEnabled == 0) SearchShadow = FALSE;
 
    /* Fail if we don't have a directory or name */
    if (!(Directory) || !(Name)) goto Quickie;
 
    /* Get name information */
    TotalChars = Name->Length / sizeof(WCHAR);
    Buffer = Name->Buffer;
 
    /* Set up case-sensitivity */
    if (Attributes & OBJ_CASE_INSENSITIVE) CaseInsensitive = TRUE;
 
    /* Fail if the name is empty */
    if (!(Buffer) || !(TotalChars)) goto Quickie;
 
    /* Create the Hash */
    for (HashValue = 0; TotalChars; TotalChars--)
    {
        /* Go to the next Character */
        CurrentChar = *Buffer++;
 
        /* Prepare the Hash */
        HashValue += (HashValue << 1) + (HashValue >> 1);
 
        /* Create the rest based on the name */
        if (CurrentChar < 'a') HashValue += CurrentChar;
        else if (CurrentChar > 'z') HashValue += RtlUpcaseUnicodeChar(CurrentChar);
        else HashValue += (CurrentChar - ('a'-'A'));
    }
 
    /* Merge it with our number of hash buckets */
    HashIndex = HashValue % 37;
 
    /* Save the result */
    Context->HashValue = HashValue;
    Context->HashIndex = (USHORT)HashIndex;
 
DoItAgain:
    /* Get the root entry and set it as our lookup bucket */
    AllocatedEntry = &Directory->HashBuckets[HashIndex];
    LookupBucket = AllocatedEntry;
 
    /* Check if the directory is already locked */
    if (!Context->DirectoryLocked)
    {
        /* Lock it */
        ObpAcquireDirectoryLockShared(Directory, Context);
    }
 
    /* Start looping */
    while ((CurrentEntry = *AllocatedEntry))
    {
        /* Do the hashes match? */
        if (CurrentEntry->HashValue == HashValue)
        {
            /* Make sure that it has a name */
            ObjectHeader = OBJECT_TO_OBJECT_HEADER(CurrentEntry->Object);
 
            /* Get the name information */
            ASSERT(ObjectHeader->NameInfoOffset != 0);
            HeaderNameInfo = OBJECT_HEADER_TO_NAME_INFO(ObjectHeader);
 
            /* Do the names match? */
            if ((Name->Length == HeaderNameInfo->Name.Length) &&
                (RtlEqualUnicodeString(Name, &HeaderNameInfo->Name, CaseInsensitive)))
            {
                break;
            }
        }
 
        /* Move to the next entry */
        AllocatedEntry = &CurrentEntry->ChainLink;
    }
 
    /* Check if we still have an entry */
    if (CurrentEntry)
    {
        /* Set this entry as the first, to speed up incoming insertion */
        if (AllocatedEntry != LookupBucket)
        {
            /* Check if the directory was locked or convert the lock */
            if ((Context->DirectoryLocked) ||
                (ExConvertPushLockSharedToExclusive(&Directory->Lock)))
            {
                /* Set the Current Entry */
                *AllocatedEntry = CurrentEntry->ChainLink;
 
                /* Link to the old Hash Entry */
                CurrentEntry->ChainLink = *LookupBucket;
 
                /* Set the new Hash Entry */
                *LookupBucket = CurrentEntry;
            }
        }
 
        /* Save the found object */
        FoundObject = CurrentEntry->Object;
        goto Quickie;
    }
    else
    {
        /* Check if the directory was locked */
        if (!Context->DirectoryLocked)
        {
            /* Release the lock */
            ObpReleaseDirectoryLock(Directory, Context);
        }
 
        /* Check if we should scan the shadow directory */
        if ((SearchShadow) && (Directory->DeviceMap))
        {
            ShadowDirectory = ObpGetShadowDirectory(Directory);
            /* A global DOS directory was found, loop it again */
            if (ShadowDirectory != NULL)
            {
                Directory = ShadowDirectory;
                goto DoItAgain;
            }
        }
    }
 
Quickie:
    /* Check if we inserted an object */
    if (FoundObject)
    {
        /* Get the object name information */
        ObjectHeader = OBJECT_TO_OBJECT_HEADER(FoundObject);
        ObpReferenceNameInfo(ObjectHeader);
 
        /* Reference the object being looked up */
        ObReferenceObject(FoundObject);
 
        /* Check if the directory was locked */
        if (!Context->DirectoryLocked)
        {
            /* Release the lock */
            ObpReleaseDirectoryLock(Directory, Context);
        }
    }
 
    /* Release any object previously looked up and replace it with the new one */
    ObpReleaseLookupContextObject(Context);
    Context->Object = FoundObject;
 
    /* Return the object we found */
    return FoundObject;
}

Referenced by ObCreateObjectType(), ObInitSystem(), ObpDeleteNameCheck(), ObpLookupObjectName(), and ObpProcessDosDeviceSymbolicLink().

Variable Documentation

ObpDirectoryObjectType

POBJECT_TYPE ObpDirectoryObjectType = NULL

Definition at line 20 of file obdir.c.

Referenced by NtCreateDirectoryObject(), NtOpenDirectoryObject(), and NtQueryDirectoryObject().