windows-xp/Source/XPSP1/NT/base/fs/mup/logroot.c

//+----------------------------------------------------------------------------
//
//  Copyright (C) 1992, Microsoft Corporation.
//
//  File:       logroot.c
//
//  Contents:   This module implements the logical root handling functions.
//
//  Functions:  DfsInitializeLogicalRoot -
//              DfsDeleteLogicalRoot -
//              DfspLogRootNameToPath -
//
//  History:    14-June-1994    SudK    Created (Most stuff moved from Dsinit.c)
//
//-----------------------------------------------------------------------------


#include "dfsprocs.h"
#include "creds.h"
#include "dnr.h"
#include "fcbsup.h"

#include <stdio.h>

#define Dbg     DEBUG_TRACE_LOGROOT

NTSTATUS
DfsDefineDosDevice(
    IN WCHAR Device,
    IN PUNICODE_STRING Target);

NTSTATUS
DfsUndefineDosDevice(
    IN WCHAR Device);

#ifdef ALLOC_PRAGMA

#pragma alloc_text( PAGE, DfsFindLogicalRoot )
#pragma alloc_text( PAGE, DfsInitializeLogicalRoot )
#pragma alloc_text( PAGE, DfsDeleteLogicalRoot )
#pragma alloc_text( PAGE, DfspLogRootNameToPath )
#pragma alloc_text( PAGE, DfsGetResourceFromVcb )
#pragma alloc_text( PAGE, DfsGetResourceFromDevlessRoot )
#pragma alloc_text( PAGE, DfsLogicalRootExists )

#endif

#ifdef TERMSRV

//
// Maximum character string length of a session Id (decimal)
//

#define SESSIONID_MAX_LEN 10

//
// Maximum characters string length of a session ID [10] (decimal) or
// logon ID [16] (hex, base 16)
//
#define ID_MAX_LEN 16

#endif // TERMSRV

//
// Global that denotes whether LUID device maps are enabled
//  TRUE  - LUID device maps are enabled
//  FALSE - LUID device maps are not enabled
//      Defined in nt\base\fs\mup\dfsinit.c
//
extern BOOL DfsLUIDDeviceMapsEnabled;


//+-------------------------------------------------------------------------
//
//  Function:   DfsFindLogicalRoot, local
//
//  Synopsis:   DfsFindLogicalRoot takes as input a DS path name in
//              the standard form (root:\file\path\name), looks up
//              the DFS_VCB associated with the logical root, and returns
//              a string pointing to beyond the logical root part
//              of the input string.
//
//  Arguments:  [PrefixPath] -- Input path name
//              [Vcb] -- Returns DFS_VCB which corresponds to logical root
//                      in PrefixPath
//              [RemainingPath] -- Returns with portion of PrefixPath
//                      after the logical root name and colon
//
//  Returns:    NTSTATUS:
//                      STATUS_SUCCESS if Vcb found
//                      STATUS_OBJECT_PATH_SYNTAX_BAD - no logical root name
//                      STATUS_NO_SUCH_DEVICE - logical root name not found
//
//--------------------------------------------------------------------------


#ifdef TERMSRV

NTSTATUS
DfsFindLogicalRoot(
    IN PUNICODE_STRING PrefixPath,
    IN ULONG SessionID,
    IN PLUID LogonID,
    OUT PDFS_VCB *Vcb,
    OUT PUNICODE_STRING RemainingPath
    )

#else // TERMSRV

NTSTATUS
DfsFindLogicalRoot(
    IN PUNICODE_STRING PrefixPath,
    IN PLUID LogonID,
    OUT PDFS_VCB *Vcb,
    OUT PUNICODE_STRING RemainingPath
    )

#endif // TERMSRV
{
    PLIST_ENTRY Link;
    unsigned int i;
    NTSTATUS    Status = STATUS_SUCCESS;
    NETRESOURCE testnt;

    DfsDbgTrace(+1, Dbg, "DfsFindLogicalRoot...\n", 0);

    *RemainingPath = *PrefixPath;

    for (i = 0; i < RemainingPath->Length/sizeof(WCHAR); i++) {
        if ((RemainingPath->Buffer[i] == (WCHAR)':') ||
            (RemainingPath->Buffer[i] == UNICODE_PATH_SEP))
            break;
    }

    if ((i*sizeof(WCHAR) >= RemainingPath->Length) ||
        (RemainingPath->Buffer[i] == UNICODE_PATH_SEP)) {
        Status = STATUS_OBJECT_PATH_SYNTAX_BAD;
        DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
        return(Status);
    }

    RemainingPath->Length = (USHORT)(i * sizeof (WCHAR));

    //
    // Search for the logical root in all known DFS_VCBs
    //

    ExAcquireResourceSharedLite(&DfsData.Resource, TRUE);
    for ( Link = DfsData.VcbQueue.Flink;
          Link != &DfsData.VcbQueue;
          Link = Link->Flink ) {

        *Vcb = CONTAINING_RECORD( Link, DFS_VCB, VcbLinks );

#ifdef TERMSRV
        if ((SessionID == INVALID_SESSIONID) ||
            (SessionID == (*Vcb)->SessionID)) {
#endif
	    if ( RtlEqualLuid(LogonID, &(*Vcb)->LogonID) ) {
		if (RtlEqualString( (PSTRING)&(*Vcb)->LogicalRoot,
				   (PSTRING)RemainingPath, (BOOLEAN)TRUE) ) {
		    break;
		}
	    }
#ifdef TERMSRV
        }
#endif // TERMSRV
    }
    if (Link == &DfsData.VcbQueue) {
        Status = STATUS_NO_SUCH_DEVICE;
        ExReleaseResourceLite(&DfsData.Resource);
        DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
        return(Status);
    }

    //
    // Adjust remaining path to point beyond the logical root name
    //

    RemainingPath->Buffer = (WCHAR*)((char*) (RemainingPath->Buffer) +
                                     RemainingPath->Length + sizeof (WCHAR) );
    RemainingPath->Length = PrefixPath->Length -
                                    (RemainingPath->Length + sizeof (WCHAR));

    if (RemainingPath->Length <= 0 ||
        RemainingPath->Buffer[0] != UNICODE_PATH_SEP) {
        Status = STATUS_OBJECT_PATH_SYNTAX_BAD;
        ExReleaseResourceLite(&DfsData.Resource);
        DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
        return(Status);
    }

    ExReleaseResourceLite(&DfsData.Resource);
    DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
    return(Status);
}

//+-------------------------------------------------------------------------
//
//  Function:   DfsInitializeLogicalRoot, public
//
//  Synopsis:   Allocate and initialize storage for a logical root.
//              This includes creating a device object and DFS_VCB for it.
//
//  Effects:    A logical root device object is created.  A corresponding
//              DFS_VCB is also created and linked into the list of known
//              DFS_VCBs.
//
//  Arguments:  [Name] --   name of logical root.
//              [Prefix] -- Prefix to be prepended to file names opened
//                          via the logical root being created before
//                          they can be resolved in the DFS name space.
//              [Credentials] -- The credentials to use when accessing files
//                          via this logical root.
//              [VcbFlags] -- To be OR'd into the VcbState field of the
//                          DFS_VCB of the newly created logical root device.
//
//  Requires:   DfsData must first be set up. Also an EXCLUSIVE LOCK on
//              DfsData.Resource must be acquired.
//
//  Returns:    NTSTATUS - STATUS_SUCCESS unless there is some problem.
//
//  History:    25 Jan 1992 alanw   created
//
//--------------------------------------------------------------------------

#ifdef TERMSRV

NTSTATUS
DfsInitializeLogicalRoot(
    IN LPCWSTR Name,
    IN PUNICODE_STRING  Prefix OPTIONAL,
    IN PDFS_CREDENTIALS Credentials OPTIONAL,
    IN USHORT VcbFlags,
    IN ULONG SessionID,
    IN PLUID LogonID
    )

#else // TERMSRV

NTSTATUS
DfsInitializeLogicalRoot(
    IN LPCWSTR        Name,
    IN PUNICODE_STRING  Prefix OPTIONAL,
    IN PDFS_CREDENTIALS Credentials OPTIONAL,
    IN USHORT       VcbFlags,
    IN PLUID LogonID
    )


#endif // TERMSRV
{
    UNICODE_STRING UnicodeString = DfsData.LogRootDevName;
    UNICODE_STRING LogRootPrefix;
    UNICODE_STRING RootName, RemainingPath;
    UNICODE_STRING LogicalRoot;

#ifdef TERMSRV

    //
    // The SessionID suffix is :SessionID where SessionID is 10 digits max.
    //

    UNICODE_STRING DeviceString;
    WCHAR DeviceBuffer[MAX_LOGICAL_ROOT_LEN + ID_MAX_LEN + sizeof(WCHAR)];
    UNICODE_STRING IDString;
    WCHAR IDBuffer[ID_MAX_LEN + 1];   // +1 for UNICODE_NULL

#endif // TERMSRV

    WCHAR          *TmpBuf;
    PDFS_VCB       Vcb;
    WCHAR          RootBuffer[MAX_LOGICAL_ROOT_LEN];
    PDFS_PKT_ENTRY pktEntry = NULL;

    LPCWSTR pstr = Name;
    PWSTR pdst;
    PLOGICAL_ROOT_DEVICE_OBJECT DeviceObject = NULL;
    NTSTATUS Status;

    DfsDbgTrace(0, Dbg, "DfsInitializeLogicalRoot -> %ws\n", Name);
    DfsDbgTrace(0, Dbg, "DfsInitializeLogicalRoot -> %wZ\n", Prefix);

    //
    // First, see if a logical root by the given name already exists
    //

    ASSERT(ARGUMENT_PRESENT(Name));
    RootName.Buffer = RootBuffer;
    RootName.MaximumLength = sizeof(RootBuffer);
    Status = DfspLogRootNameToPath(Name, &RootName);
    if (!NT_SUCCESS(Status)) {
        return(Status);
    }

#ifdef TERMSRV
    Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
#else
    Status = DfsFindLogicalRoot(&RootName, &Vcb, LogonID, &RemainingPath);
#endif

    ASSERT(Status != STATUS_OBJECT_PATH_SYNTAX_BAD);
    if (Status != STATUS_NO_SUCH_DEVICE) {
        return(STATUS_OBJECT_NAME_COLLISION);
    }

#ifdef TERMSRV

    //
    // For multiuser,
    // If LUID device maps are enabled,
    // then we add the LogonID to the devicename - e.g.
    // net use f: to a DFS share for logon ID 0x000000000003a3f0 will create
    // a symbolic link with the following format:
    // \??\f: -> \Device\WinDfs\f:000000000003a3f0
    //
    // If LUID device maps are not enabled,
    // then we add the SessionID to the devicename - e.g.
    // net use f: to a DFS share for session ID 3 will create a symbolic link
    // \DosDevices\f::3 -> \device\WinDfs\f:3
    // In the VCB we store the SessionID for matching purposes.
    // Both the symbolic link and the object name shall contain the SessionID
    // in the name. However, in deviceObject->Vcb.LogicalRoot.Buffer, the
    // name does not contain the SessionID. To find a matching VCB, both the name
    // and SessionID must match.
    //

    DeviceString.Buffer = DeviceBuffer;
    DeviceString.MaximumLength = sizeof(DeviceBuffer);
    DeviceString.Length = 0;

    //
    // Build the UnicodeString without the SessionID or LogonID
    //

    RtlAppendUnicodeToString(&UnicodeString, (LPWSTR)Name);


    if( SessionID != INVALID_SESSIONID) {

        if( (DfsLUIDDeviceMapsEnabled == TRUE) &&
            (LogonID != NULL) &&
            (sizeof(*LogonID) == sizeof(LUID)) ) {
            //
            // Build the DeviceString with the LogonID
            //
            _snwprintf( IDBuffer,
                        sizeof(IDBuffer)/sizeof(WCHAR),
                        L"%08x%08x",
                        LogonID->HighPart,
                        LogonID->LowPart );

            RtlInitUnicodeString( &IDString, IDBuffer );
        }
        else {
            //
            // Build the DeviceString with the SessionID
            //
            IDString.Buffer = IDBuffer;
            IDString.MaximumLength = sizeof(IDBuffer);
            IDString.Length = 0;

            RtlIntegerToUnicodeString(SessionID, 10, &IDString);
        }
        
        RtlCopyUnicodeString(&DeviceString, &DfsData.LogRootDevName);
        RtlAppendUnicodeToString(&DeviceString, (LPWSTR)Name);
        RtlAppendUnicodeToString(&DeviceString,L":");
        RtlAppendUnicodeStringToString(&DeviceString, &IDString);
        DeviceString.MaximumLength = DeviceString.Length;

        //
        // Next, try to setup the Dos Device link
        //

        if (Prefix) {
            Status = DfsDefineDosDevice( Name[0], &DeviceString );
            if (!NT_SUCCESS(Status)) {
                return( Status );
            }
        }
    }
    else {

        ASSERT( Prefix == FALSE );
    }

#else // TERMSRV

    //
    // DfsData.LogRootDevName is initialized to be L"\Device\WinDfs\"
    // Here, we tack on the name of the Logical root we are creating
    // to the above string, so that the string becomes, for example,
    // L"\Device\WinDfs\Root". Note that at this point, we are scribbling
    // into the buffer belonging to DfsData.LogRootDevName, but this
    // should be ok, since we are not changing the Length field of that
    // Unicode string! BTW, we need a string of this form to create the
    // device object.
    //

    pdst = &UnicodeString.Buffer[UnicodeString.Length/sizeof (WCHAR)];
    while (*pstr != UNICODE_NULL) {
        *pdst++ = *pstr++;
        UnicodeString.Length += sizeof (WCHAR);
    }

    //
    // Next, try to setup the Dos Device link
    //
    if (Prefix) {
        Status = DfsDefineDosDevice( Name[0], &UnicodeString );
        if (!NT_SUCCESS(Status)) {
            return( Status );
        }
    }

#endif // TERMSRV

    //
    // Before we initialize the Vcb, we need to allocate space for the
    // Prefix. PagedPool should be fine here. We need to reallocate because
    // we will store this permanently in the DFS_VCB.
    //

    LogRootPrefix.Buffer = NULL;

    if (Prefix && Prefix->Length > 0) {
        LogRootPrefix.Length = Prefix->Length;
        LogRootPrefix.MaximumLength = LogRootPrefix.Length + sizeof(WCHAR);
        LogRootPrefix.Buffer = ExAllocatePoolWithTag(
                                    PagedPool,
                                    LogRootPrefix.MaximumLength,
                                    ' puM');

        if (LogRootPrefix.Buffer != NULL) {
            RtlMoveMemory(LogRootPrefix.Buffer,
                          Prefix->Buffer,
                          Prefix->MaximumLength);

            LogRootPrefix.Buffer[Prefix->Length/sizeof(WCHAR)] = UNICODE_NULL;

        } else {

            //
            // Couldn't allocate memory! Ok to return with error code, since
            // we haven't changed the state of the IO subsystem yet.
            //

            if (Prefix) {
                NTSTATUS DeleteStatus;

                DeleteStatus = DfsUndefineDosDevice( Name[0] );

                ASSERT(NT_SUCCESS(DeleteStatus));
            }

            return(STATUS_INSUFFICIENT_RESOURCES);
        }
    } else {
        RtlInitUnicodeString(&LogRootPrefix, NULL);
    }

    //
    //  Save the logical root name for the DFS_VCB structure. Remember, above
    //  we had UnicodeString to be of the form L"\Device\WinDfs\org". Now,
    //  we copy UnicodeString, then adjust the buffer and length fields so that
    //  the Buffer points to the beginning of the L"org"; Then, we allocate
    //  space for LogicalRootBuffer, and copy the name to it!
    //

    LogicalRoot = UnicodeString;

    LogicalRoot.Buffer = &LogicalRoot.Buffer[ DfsData.LogRootDevName.Length/sizeof (WCHAR) ];
    LogicalRoot.Length -= DfsData.LogRootDevName.Length;
    LogicalRoot.MaximumLength -= DfsData.LogRootDevName.Length;

    //
    // Now dup the buffer that LogicalRoot uses
    //

    TmpBuf = ExAllocatePoolWithTag( PagedPool,
                                    LogicalRoot.Length,
                                    ' puM');

    if (TmpBuf == NULL) {

        //
        // Couldn't allocate memory! Ok to return with error code, since
        // we still haven't changed the state of the IO subsystem yet.
        //

        if (LogRootPrefix.Buffer != NULL) {

            ExFreePool(LogRootPrefix.Buffer);

        }

        if (Prefix) {
            NTSTATUS DeleteStatus;

            DeleteStatus = DfsUndefineDosDevice( Name[0] );

            ASSERT(NT_SUCCESS(DeleteStatus));
        }

        return(STATUS_INSUFFICIENT_RESOURCES);

    } else {

        RtlMoveMemory( TmpBuf,
                       LogicalRoot.Buffer,
                       LogicalRoot.Length );

        LogicalRoot.Buffer = TmpBuf;

    }

    //
    //  Create the device object for the logical root.
    //

#ifdef TERMSRV

    Status = IoCreateDevice( DfsData.DriverObject,
                 sizeof( LOGICAL_ROOT_DEVICE_OBJECT ) -
                    sizeof( DEVICE_OBJECT ),
                 (SessionID != INVALID_SESSIONID) ?
                    &DeviceString : &UnicodeString,
                 FILE_DEVICE_DFS,
                 FILE_REMOTE_DEVICE,
                 FALSE,
                 (PDEVICE_OBJECT *) &DeviceObject );

#else // TERMSRV

    Status = IoCreateDevice( DfsData.DriverObject,
                 sizeof( LOGICAL_ROOT_DEVICE_OBJECT ) -
                 sizeof( DEVICE_OBJECT ),
                 &UnicodeString,
                 FILE_DEVICE_DFS,
                 FILE_REMOTE_DEVICE,
                 FALSE,
                 (PDEVICE_OBJECT *) &DeviceObject );

#endif // TERMSRV

    if ( !NT_SUCCESS( Status ) ) {
        if (LogRootPrefix.Buffer) {
            ExFreePool(LogRootPrefix.Buffer);
            ExFreePool(LogicalRoot.Buffer);
        }
        if (Prefix) {
            NTSTATUS DeleteStatus;

            DeleteStatus = DfsUndefineDosDevice( Name[0] );

            ASSERT(NT_SUCCESS(DeleteStatus));
        }
        return Status;
    }

    //
    // Pin the pkt entry in the cache by incrementing the Usecount
    //

    if (LogRootPrefix.Buffer != NULL && LogRootPrefix.Length > 0) {

        UNICODE_STRING prefix = LogRootPrefix;
        USHORT i, j;

        //
        // We want to work with the \server\share part of the prefix only,
        // so count up to 3 backslashes, then stop.
        //

        for (i = j = 0; i < prefix.Length/sizeof(WCHAR) && j < 3; i++) {

            if (prefix.Buffer[i] == UNICODE_PATH_SEP) {

                j++;

            }

        }

        prefix.Length = (j >= 3) ? (i-1) * sizeof(WCHAR) : i * sizeof(WCHAR);

        pktEntry = PktLookupEntryByPrefix(&DfsData.Pkt,
                                            &prefix,
                                            &RemainingPath);

        if (pktEntry != NULL && RemainingPath.Length == 0) {

            InterlockedIncrement(&pktEntry->UseCount);

        }
	else {
	  pktEntry = NULL;
	}
    }

    DeviceObject->DeviceObject.StackSize = 5;

    DfsInitializeVcb ( NULL,
               &DeviceObject->Vcb,
               &LogRootPrefix,
               Credentials,
               (PDEVICE_OBJECT)DeviceObject );

    DeviceObject->Vcb.VcbState |= VcbFlags;

#ifdef TERMSRV
    DeviceObject->Vcb.SessionID = SessionID;
#endif
    DeviceObject->Vcb.pktEntry = pktEntry;

    RtlCopyLuid(&DeviceObject->Vcb.LogonID, LogonID);

    //
    // Above we preallocated the buffer we need here.  So just use it.
    //

    DeviceObject->Vcb.LogicalRoot = LogicalRoot;

    //
    //  This is not documented anywhere, but calling IoCreateDevice has set
    //  the DO_DEVICE_INITIALIZING flag in DeviceObject->Flags. Normally,
    //  device objects are created only at driver init time, and IoLoadDriver
    //  will clear this bit for all device objects created at init time.
    //  Since in Dfs, we need to create and delete devices on the fly (ie,
    //  via FsCtl), we need to manually clear this bit.
    //

    DeviceObject->DeviceObject.Flags &= ~DO_DEVICE_INITIALIZING;

    return STATUS_SUCCESS;
}


//+----------------------------------------------------------------------------
//
//  Function:   DfsDeleteLogicalRoot
//
//  Synopsis:   Removes a logical root if found and possible.
//
//  Arguments:  [Name] -- Name of the Logical Root
//              [fForce] -- Whether to Forcibly delete logical root inspite of
//                          open files.
//
//  Returns:    STATUS_SUCCESS -- If successfully deleted logical root
//
//              STATUS_NO_SUCH_DEVICE -- If there is no logical root to
//                      delete.
//
//              STATUS_DEVICE_BUSY -- If fForce is false and there are open
//                      files via this logical root.
//
//-----------------------------------------------------------------------------

#ifdef TERMSRV

NTSTATUS
DfsDeleteLogicalRoot(
    IN PWSTR Name,
    IN BOOLEAN fForce,
    IN ULONG SessionID,
    IN PLUID LogonID
)

#else // TERMSRV

NTSTATUS
DfsDeleteLogicalRoot(
    IN PWSTR Name,
    IN BOOLEAN fForce,
    IN PLUID LogonID
)

#endif // TERMSRV
{
    UNICODE_STRING RootName;
    UNICODE_STRING RemainingPath;
    WCHAR          RootBuffer[MAX_LOGICAL_ROOT_LEN + 2];
    PDFS_PKT_ENTRY PktEntry;
    PDFS_VCB       Vcb;
    NTSTATUS       Status;
    PLOGICAL_ROOT_DEVICE_OBJECT DeviceObject;
    BOOLEAN        pktLocked;
    PDFS_PKT_ENTRY pktEntry;

    //
    // The 2 extra spots are for holding :\ to form a path out of a
    // root name; ie, to go from root to a root:\ form.
    //
    DfsDbgTrace(0, Dbg, "DfsDeleteLogicalRoot -> %ws\n", Name);
    DfsDbgTrace(0, Dbg, "DfsDeleteLogicalRoot -> %s\n", fForce ? "TRUE":"FALSE");


    //
    // First see if the logical root even exists.
    //

    ASSERT(ARGUMENT_PRESENT(Name));

    RootName.Buffer = RootBuffer;
    RootName.MaximumLength = sizeof(RootBuffer);

    Status = DfspLogRootNameToPath(Name, &RootName);

    if (!NT_SUCCESS(Status))
        return(Status);

    //
    // Acquire Pkt and DfsData, wait till we do so.
    //

    PktAcquireExclusive(TRUE, &pktLocked);

    ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE);

#ifdef TERMSRV
    Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
#else // TERMSRV
    Status = DfsFindLogicalRoot(&RootName, LogonID, &Vcb, &RemainingPath);
#endif // TERMSRV

    if (!NT_SUCCESS(Status)) {

        goto Cleanup;
    }

    //
    // Check to see if there are open files via this volume.
    //

    if (!fForce &&
            ((Vcb->DirectAccessOpenCount != 0) ||
                (Vcb->OpenFileCount != 0))) {

        Status = STATUS_DEVICE_BUSY;

        goto Cleanup;

    }

    //
    // Delete the credentials used by this connection
    //

    if (Vcb->Credentials != NULL) {
       DfsDeleteCredentials( Vcb->Credentials );
    }

    //
    // Get rid of the Dos Device
    //

    DfsUndefineDosDevice( Name[0] );

    //
    // Dec ref count on pkt entry
    //
    if (Vcb->pktEntry != NULL) {
      InterlockedDecrement(&Vcb->pktEntry->UseCount);

      Vcb->pktEntry = NULL;
    }

    //
    // Now, get rid of the Device itself. This is a bit tricky, because there
    // might be files open on this device. So, we reference the device and
    // call ObMakeTemporaryObject. This causes the object to be removed from
    // the NT Object table, but, since atleast our reference is active,
    // prevents the object from being freed. Then, we insert this object into
    // our DeletedVcb list. The timer routine will periodically wake up and
    // see if all references to this device have been released, at which
    // point the device will be finally freed.
    //

    RemoveEntryList(&Vcb->VcbLinks);

    InsertTailList( &DfsData.DeletedVcbQueue, &Vcb->VcbLinks );

    DeviceObject = CONTAINING_RECORD( Vcb, LOGICAL_ROOT_DEVICE_OBJECT, Vcb);

    ObReferenceObjectByPointer( DeviceObject, 0, NULL, KernelMode );

    ObMakeTemporaryObject((PVOID) DeviceObject);

    DeviceObject->DeviceObject.Flags &= ~DO_DEVICE_HAS_NAME;

Cleanup:

    ExReleaseResourceLite(&DfsData.Resource);

    PktRelease();

    return(Status);
}


//+----------------------------------------------------------------------------
//
//  Function:   DfspLogRootNameToPath
//
//  Synopsis:   Amazingly enough, all it does it takes a PWSTR, copies it into
//              a Unicode string's buffer, and appends a \ to the tail of the
//              buffer, thus making a path out of a Logical root name.
//
//  Arguments:  [Name] --   Name of logical root, like L"org"
//              [RootName] --   Destination for L"org\\"
//
//  Returns:    STATUS_BUFFER_OVERFLOW, STATUS_SUCCESS
//
//-----------------------------------------------------------------------------

NTSTATUS
DfspLogRootNameToPath(
    IN  LPCWSTR Name,
    OUT PUNICODE_STRING RootName
)
{
    unsigned short i, nMaxNameLen;

    //
    // The two extra spots are required to append a ":\" after the root name.
    //
    nMaxNameLen = (RootName->MaximumLength/sizeof(WCHAR)) - 2;

    //
    // Copy the name
    //
    for (i = 0; Name[i] != UNICODE_NULL && i < nMaxNameLen; i++) {
        RootName->Buffer[i] = Name[i];
    }

    //
    // Make sure entire name was copied before we ran out of space
    //
    if (Name[i] != UNICODE_NULL) {
        //
        // Someone sent in a name bigger than allowed.
        //
        return(STATUS_BUFFER_OVERFLOW);
    }

    //
    // Append the ":\" to form a path
    //
    RootName->Length = i * sizeof(WCHAR);
    return(RtlAppendUnicodeToString(RootName, L":\\"));
}

#define PackMem(buf, str, len, pulen) {                                 \
        ASSERT(*(pulen) >= (len));                                      \
        RtlMoveMemory((buf) + *(pulen) - (len), (str), (len));          \
        *(pulen) -= (len);                                              \
        }


//+----------------------------------------------------------------------------
//
//  Function:   DfsGetResourceFromVcb
//
//  Synopsis:   Given a DFS_VCB it constructs a NETRESOURCE struct into the buffer
//              passed in. At the same time it uses the end of the buffer to
//              fill in a string. If the buffer is insufficient in size the
//              required size is returned in "pulen". If everything succeeds
//              then the pulen arg is decremented to indicate remaining size
//              of buffer.
//
//  Arguments:  [Vcb] -- The source DFS_VCB
//              [ProviderName] -- Provider Name to stuff in the NETRESOURCE
//              [BufBegin] -- Start of actual buffer for computing offsets
//              [Buf] -- The NETRESOURCE structure to fill
//              [BufSize] -- On entry, size of buf. On return, contains
//                      remaining size of buf.
//
//  Returns:    [STATUS_SUCCESS] -- Operation completed successfully.
//              [STATUS_BUFFER_OVERFLOW] -- buf is not big enough.
//
//  Notes:      This routine fills in a NETRESOURCE structure starting at
//              Buf. The strings in the NETRESOURCE are filled in starting
//              from the *end* (ie, starting at Buf + *BufSize)
//
//-----------------------------------------------------------------------------


#if defined (_WIN64)
typedef struct  _DFS_NETRESOURCE32 {
    DWORD    dwScope;
    DWORD    dwType;
    DWORD    dwDisplayType;
    DWORD    dwUsage;
    ULONG    lpLocalName;
    ULONG    lpRemoteName;
    ULONG    lpComment ;
    ULONG    lpProvider;
}DFS_NETRESOURCE32, *PDFS_NETRESOURCE32;

#endif

NTSTATUS
DfsGetResourceFromVcb(
    PIRP        pIrp,
    PDFS_VCB    Vcb,
    PUNICODE_STRING ProviderName,
    PUCHAR      BufBegin,
    PUCHAR      Buf,
    PULONG      BufSize,
    PULONG      pResourceSize

)
{
    LPNETRESOURCE netResource = (LPNETRESOURCE) Buf;
    ULONG               sizeRequired = 0, ResourceSize;
    WCHAR               localDrive[ 3 ];
    ULONG32    CommentOffset, ProviderOffset, LocalNameOffset, RemoteNameOffset;

#if defined (_WIN64)
    if (IoIs32bitProcess(pIrp)) {
      ResourceSize = sizeof(DFS_NETRESOURCE32);
    }
    else
#endif
    ResourceSize = sizeof(NETRESOURCE);

    *pResourceSize = ResourceSize;

    sizeRequired = ResourceSize +
                    ProviderName->Length +
                        sizeof(UNICODE_NULL) +
                            3 * sizeof(WCHAR) +     // lpLocalName D: etc.
                                sizeof(UNICODE_PATH_SEP) +
                                    Vcb->LogRootPrefix.Length +
                                        sizeof(UNICODE_NULL);

    if (*BufSize < sizeRequired) {
        *BufSize = sizeRequired;
        return(STATUS_BUFFER_OVERFLOW);
    }

    //
    // Buffer is big enough, fill in the NETRESOURCE structure
    //

    Buf += ResourceSize;
    *BufSize -= ResourceSize;

    netResource->dwScope       = RESOURCE_CONNECTED;
    netResource->dwType        = RESOURCETYPE_DISK;
    netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
    netResource->dwUsage       = RESOURCEUSAGE_CONNECTABLE;

    CommentOffset = 0;
    //
    // Fill in the provider name
    //

    PackMem(Buf, L"", sizeof(L""), BufSize);
    PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
    ProviderOffset = (ULONG32)(Buf + *BufSize - BufBegin);

    //
    // Fill in the local name next
    //

    localDrive[0] = Vcb->LogicalRoot.Buffer[0];
    localDrive[1] = UNICODE_DRIVE_SEP;
    localDrive[2] = UNICODE_NULL;

    PackMem(Buf, localDrive, sizeof(localDrive), BufSize);
    LocalNameOffset =  (ULONG32)(Buf + *BufSize - BufBegin);

    //
    // Fill in the remote name last
    //

    PackMem(Buf, L"", sizeof(L""), BufSize);
    PackMem(Buf, Vcb->LogRootPrefix.Buffer, Vcb->LogRootPrefix.Length, BufSize);
    PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);
    RemoteNameOffset = (ULONG32)(Buf + *BufSize - BufBegin);

#if defined (_WIN64)
    if (IoIs32bitProcess(pIrp)) {
      PDFS_NETRESOURCE32 pNetResource32 = (PDFS_NETRESOURCE32)netResource;

      pNetResource32->lpComment = CommentOffset;
      pNetResource32->lpProvider = ProviderOffset;
      pNetResource32->lpLocalName = LocalNameOffset;
      pNetResource32->lpRemoteName = RemoteNameOffset;
    }
    else {
#endif

      netResource->lpComment = (LPWSTR)UIntToPtr( CommentOffset );
      netResource->lpProvider = (LPWSTR)UIntToPtr( ProviderOffset );
      netResource->lpLocalName = (LPWSTR)UIntToPtr( LocalNameOffset );
      netResource->lpRemoteName = (LPWSTR)UIntToPtr( RemoteNameOffset );
#if defined (_WIN64)
    }
#endif

    return(STATUS_SUCCESS);
}

//+----------------------------------------------------------------------------
//
//  Function:   DfsGetResourceFromDevlessRoot
//
//  Synopsis:   Builds a NETRESOURCE structure for a device-less connection.
//              The LPWSTR members of NETRESOURCE actually contain offsets
//              from the BufBegin parameter.
//
//  Arguments:  [Drt] -- The DevicelessRoot structure
//              [ProviderName] -- Provider Name to stuff in the NETRESOURCE
//              [BufBegin] -- Start of actual buffer for computing offsets
//              [Buf] -- The NETRESOURCE structure to fill
//              [BufSize] -- On entry, size of buf. On return, contains
//                      remaining size of buf.
//
//  Returns:    [STATUS_SUCCESS] -- Operation completed successfully.
//              [STATUS_BUFFER_OVERFLOW] -- buf is not big enough.
//
//  Notes:      This routine fills in a NETRESOURCE structure starting at
//              Buf. The strings in the NETRESOURCE are filled in starting
//              from the *end* (ie, starting at Buf + *BufSize)
//
//-----------------------------------------------------------------------------

NTSTATUS
DfsGetResourceFromDevlessRoot(
    PIRP        pIrp,
    PDFS_DEVLESS_ROOT pDrt,
    PUNICODE_STRING ProviderName,
    PUCHAR BufBegin,
    PUCHAR Buf,
    PULONG BufSize,
    PULONG pResourceSize)
{
    LPNETRESOURCE netResource = (LPNETRESOURCE) Buf;
    ULONG               sizeRequired = 0, ResourceSize;
    WCHAR               localDrive[ 3 ];
    ULONG32    CommentOffset, ProviderOffset, LocalNameOffset, RemoteNameOffset;
#if defined (_WIN64)
    if (IoIs32bitProcess(pIrp)) {
      ResourceSize = sizeof(DFS_NETRESOURCE32);
    }
    else
#endif
    ResourceSize = sizeof(NETRESOURCE);

    *pResourceSize = ResourceSize;

    sizeRequired = ResourceSize +
                    ProviderName->Length +
                        sizeof(UNICODE_NULL) +
                            2 * sizeof(UNICODE_PATH_SEP) +
				pDrt->DevlessPath.Length +
                                     sizeof(UNICODE_NULL);

    if (*BufSize < sizeRequired) {
        *BufSize = sizeRequired;
        return(STATUS_BUFFER_OVERFLOW);
    }

    //
    // Buffer is big enough, fill in the NETRESOURCE structure
    //

    Buf += ResourceSize;
    *BufSize -= ResourceSize;

    netResource->dwScope       = RESOURCE_CONNECTED;
    netResource->dwType        = RESOURCETYPE_DISK;
    netResource->dwDisplayType = RESOURCEDISPLAYTYPE_GENERIC;
    netResource->dwUsage       = RESOURCEUSAGE_CONNECTABLE;

    CommentOffset = 0;
    LocalNameOffset = 0;

    //
    // Fill in the provider name
    //

    PackMem(Buf, L"", sizeof(L""), BufSize);
    PackMem(Buf, ProviderName->Buffer, ProviderName->Length, BufSize);
    ProviderOffset = (ULONG32)(Buf + *BufSize - BufBegin);

    //
    // Fill in the remote name last
    //

    PackMem(Buf, L"", sizeof(L""), BufSize);
    PackMem(Buf, pDrt->DevlessPath.Buffer, pDrt->DevlessPath.Length, BufSize);

    PackMem(Buf, UNICODE_PATH_SEP_STR, sizeof(UNICODE_PATH_SEP), BufSize);

    RemoteNameOffset = (ULONG32)(Buf + *BufSize - BufBegin);

#if defined (_WIN64)
    if (IoIs32bitProcess(pIrp)) {
      PDFS_NETRESOURCE32 pNetResource32 = (PDFS_NETRESOURCE32)netResource;

      pNetResource32->lpComment = CommentOffset;
      pNetResource32->lpProvider = ProviderOffset;
      pNetResource32->lpLocalName = LocalNameOffset;
      pNetResource32->lpRemoteName = RemoteNameOffset;
    }
    else {
#endif

      netResource->lpComment = (LPWSTR)UIntToPtr( CommentOffset );
      netResource->lpProvider = (LPWSTR)UIntToPtr( ProviderOffset );
      netResource->lpLocalName = (LPWSTR)UIntToPtr( LocalNameOffset );
      netResource->lpRemoteName = (LPWSTR)UIntToPtr( RemoteNameOffset );
#if defined (_WIN64)
    }
#endif

    return(STATUS_SUCCESS);


}


#ifdef TERMSRV

BOOLEAN
DfsLogicalRootExists(
    IN PWSTR pwszName,
    IN ULONG SessionID,
    IN PLUID LogonID
    )

#else // TERMSRV

BOOLEAN
DfsLogicalRootExists(
    IN PWSTR pwszName,
    IN PLUID LogonID
    )

#endif // TERMSRV
{

    UNICODE_STRING RootName;
    UNICODE_STRING RemainingPath;
    WCHAR      RootBuffer[MAX_LOGICAL_ROOT_LEN + 2];
    PDFS_VCB       Vcb;
    NTSTATUS       Status;

    ASSERT(ARGUMENT_PRESENT(pwszName));
    RootName.Buffer = RootBuffer;
    RootName.MaximumLength = sizeof(RootBuffer);

    Status = DfspLogRootNameToPath(pwszName, &RootName);
    if (!NT_SUCCESS(Status)) {
        return(FALSE);
    }

#ifdef TERMSRV
    Status = DfsFindLogicalRoot(&RootName, SessionID, LogonID, &Vcb, &RemainingPath);
#else // TERMSRV
    Status = DfsFindLogicalRoot(&RootName, LogonId, &Vcb, &RemainingPath);
#endif // TERMSRV

    if (!NT_SUCCESS(Status)) {

        //
        // If this asserts, we need to fix the code above that creates the
        // Logical Root name, or fix DfsFindLogicalRoot.
        //
        ASSERT(Status != STATUS_OBJECT_PATH_SYNTAX_BAD);
        return(FALSE);
    }
    else        {
        return(TRUE);
    }

}

//+----------------------------------------------------------------------------
//
//  Function:   DfsDefineDosDevice
//
//  Synopsis:   Creates a dos device to a logical root
//
//  Arguments:
//
//  Returns:
//
//-----------------------------------------------------------------------------

NTSTATUS
DfsDefineDosDevice(
    IN WCHAR Device,
    IN PUNICODE_STRING Target)
{
    NTSTATUS status;
    HANDLE device;
    OBJECT_ATTRIBUTES ob;
    UNICODE_STRING deviceName;
    WCHAR Buf[25];

    wcscpy(Buf, L"\\??\\X:");
    RtlInitUnicodeString( &deviceName, Buf);
    deviceName.Buffer[ deviceName.Length/sizeof(WCHAR) - 2] = Device;

    InitializeObjectAttributes(
        &ob,
        &deviceName,
        OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
        NULL,
        NULL);

    status = ZwCreateSymbolicLinkObject(
                    &device,
                    SYMBOLIC_LINK_ALL_ACCESS,
                    &ob,
                    Target);

    if (NT_SUCCESS(status))
        ZwClose( device );

    return( status );

}

//+----------------------------------------------------------------------------
//
//  Function:   DfsUndefineDosDevice
//
//  Synopsis:   Undefines a dos device
//
//  Arguments:
//
//  Returns:
//
//-----------------------------------------------------------------------------

NTSTATUS
DfsUndefineDosDevice(
    IN WCHAR Device
    )
{

    NTSTATUS status;
    HANDLE device;
    OBJECT_ATTRIBUTES ob;
    UNICODE_STRING deviceName;
    WCHAR Buf[25];

    wcscpy(Buf, L"\\??\\X:");
    RtlInitUnicodeString( &deviceName, Buf);
    deviceName.Buffer[ deviceName.Length/sizeof(WCHAR) - 2] = Device;

    InitializeObjectAttributes(
        &ob,
        &deviceName,
        OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
        NULL,
        NULL);

    status = ZwOpenSymbolicLinkObject(
                &device,
                SYMBOLIC_LINK_QUERY | DELETE,
                &ob);

    if (NT_SUCCESS(status)) {

        status = ZwMakeTemporaryObject( device );

        ZwClose( device );

    }

    return( status );

}



//+-------------------------------------------------------------------------
//
//  Function:   DfsFindDevlessRoot, local
//
//  Synopsis:   DfsFindDevlessRoot takes as input a UNC name
//              looks up the DFS_DEVLESS_ROOT associated with the root,
//              and returns the DevlessRoot
//
//  Arguments:  [Path] -- Input path name
//              [Drt] -- Returns DFS_DEVLESS_ROOT which corresponds to
//                       the root for the Path
//
//  Returns:    NTSTATUS:
//                      STATUS_SUCCESS if Drt found
//                      STATUS_NO_SUCH_DEVICE - root name not found
//
//--------------------------------------------------------------------------


#ifdef TERMSRV

NTSTATUS
DfsFindDevlessRoot(
    IN PUNICODE_STRING Path,
    IN ULONG SessionID,
    IN PLUID LogonID,
    OUT PDFS_DEVLESS_ROOT *Drt
    )

#else // TERMSRV

NTSTATUS
DfsFindDevlessRoot(
    IN PUNICODE_STRING Path,
    IN PLUID LogonID,
    OUT PDFS_DEVLESS_ROOT *Drt,
    )

#endif // TERMSRV
{
    PLIST_ENTRY Link;
    NTSTATUS    Status = STATUS_SUCCESS;

    DfsDbgTrace(+1, Dbg, "DfsFindDevlessRoot...%wZ\n", Path);

    //
    // Search for the devless ROOT.
    //

    ExAcquireResourceSharedLite(&DfsData.Resource, TRUE);

    for ( Link = DfsData.DrtQueue.Flink;
          Link != &DfsData.DrtQueue;
          Link = Link->Flink ) {

        *Drt = CONTAINING_RECORD( Link, DFS_DEVLESS_ROOT, DrtLinks );

#ifdef TERMSRV
        if ((SessionID == INVALID_SESSIONID) ||
            (SessionID == (*Drt)->SessionID)) {
#endif
	    if ( RtlEqualLuid(LogonID, &(*Drt)->LogonID) ) {
		if (RtlEqualString( (PSTRING)&(*Drt)->DevlessPath,
				   (PSTRING)Path, (BOOLEAN)TRUE) ) {
		    break;
		}
	    }
#ifdef TERMSRV
        }
#endif // TERMSRV
    }
    if (Link == &DfsData.DrtQueue) {
        Status = STATUS_NO_SUCH_DEVICE;
        ExReleaseResourceLite(&DfsData.Resource);
        DfsDbgTrace(-1, Dbg, "DfsFindDevlessRoot -> %08lx\n", ULongToPtr(Status) );
        return(Status);
    }

    ExReleaseResourceLite(&DfsData.Resource);
    DfsDbgTrace(-1, Dbg, "DfsFindLogicalRoot -> %08lx\n", ULongToPtr(Status) );
    return(Status);
}

//+-------------------------------------------------------------------------
//
//  Function:   DfsInitializeDevlessRoot, public
//
//  Synopsis:   Allocate and initialize storage for a Deviceless root.
//
//  Effects:    A DFS_DEVLESS_ROOT structure is created.
//
//  Arguments:  [Name] -- Pathname that is the deviceless root.
//              [Credentials] -- The credentials to use when accessing files
//                          via this logical root.
//
//  Requires:   DfsData must first be set up. Also an EXCLUSIVE LOCK on
//              DfsData.Resource must be acquired.
//
//  Returns:    NTSTATUS - STATUS_SUCCESS unless there is some problem.
//
//--------------------------------------------------------------------------

#ifdef TERMSRV

NTSTATUS
DfsInitializeDevlessRoot(
    IN PUNICODE_STRING  Name,
    IN PDFS_CREDENTIALS Credentials OPTIONAL,
    IN ULONG SessionID,
    IN PLUID LogonID
    )

#else // TERMSRV

NTSTATUS
DfsInitializeDevlessRoot(
    IN PUNICODE_STRING  Name,
    IN PDFS_CREDENTIALS Credentials OPTIONAL,
    IN PLUID LogonID
    )

#endif // TERMSRV
{

    PDFS_DEVLESS_ROOT Drt;
    PDFS_PKT_ENTRY pktEntry = NULL;
    UNICODE_STRING DevlessRootName;
    NTSTATUS Status;

    DfsDbgTrace(0, Dbg, "DfsInitializeDevlessRoot -> %wZ\n", Name);

#ifdef TERMSRV
    Status = DfsFindDevlessRoot(Name, SessionID, LogonID, &Drt);
#else
    Status = DfsFindDevlessRoot(Name, LogonID, &Drt);
#endif

    if (Status != STATUS_NO_SUCH_DEVICE) {
        //
        // this means we found a device. In the devless Root case, this means 
        // we dont have to do any more work. Just return a success response.
        // However, we still have the credentials which the caller assumes
        // we will be using. Get rid of it here and return success.
        //
        DfsDeleteCredentials(Credentials);
        return(STATUS_SUCCESS);
    }

    Drt = ExAllocatePoolWithTag( PagedPool,
				sizeof(DFS_DEVLESS_ROOT),
				' puM');
    if (Drt == NULL) {
	return(STATUS_INSUFFICIENT_RESOURCES);
    }

    //
    // Before we initialize the Drt, we need to allocate space for the
    // Prefix. PagedPool should be fine here. We need to reallocate because
    // we will store this permanently in the DFS_DEVLESS_ROOT.
    //

    DevlessRootName.Length = Name->Length;
    DevlessRootName.MaximumLength = DevlessRootName.Length + sizeof(WCHAR);
    DevlessRootName.Buffer = ExAllocatePoolWithTag(
                                    PagedPool,
                                    DevlessRootName.MaximumLength,
                                    ' puM');

    if (DevlessRootName.Buffer != NULL) {
            RtlMoveMemory(DevlessRootName.Buffer,
                          Name->Buffer,
                          Name->MaximumLength);
	    
            DevlessRootName.Buffer[Name->Length/sizeof(WCHAR)] = UNICODE_NULL;
    } else {
      ExFreePool(Drt);
      return(STATUS_INSUFFICIENT_RESOURCES);
    }

    //
    // Pin the pkt entry in the cache by incrementing the Usecount
    //

    if (DevlessRootName.Buffer != NULL && DevlessRootName.Length > 0) {

        UNICODE_STRING prefix = DevlessRootName;
        USHORT i, j;
        UNICODE_STRING RemainingPath;

        //
        // We want to work with the \server\share part of the prefix only,
        // so count up to 3 backslashes, then stop.
        //

        for (i = j = 0; i < prefix.Length/sizeof(WCHAR) && j < 3; i++) {
            if (prefix.Buffer[i] == UNICODE_PATH_SEP) {
                j++;
            }
        }

        prefix.Length = (j >= 3) ? (i-1) * sizeof(WCHAR) : i * sizeof(WCHAR);

        pktEntry = PktLookupEntryByPrefix(&DfsData.Pkt,
                                            &prefix,
                                            &RemainingPath);

        if (pktEntry != NULL && RemainingPath.Length == 0) {

            InterlockedIncrement(&pktEntry->UseCount);

        }
	else {
	  pktEntry = NULL;
	}

    }

    DfsInitializeDrt ( Drt,
		       &DevlessRootName,
		       Credentials);

#ifdef TERMSRV
    Drt->SessionID = SessionID;
#endif
    Drt->pktEntry = pktEntry;
    RtlCopyLuid(&Drt->LogonID, LogonID);

    return STATUS_SUCCESS;
}


//+----------------------------------------------------------------------------
//
//  Function:   DfsDeleteDevlessRoot
//
//  Synopsis:   Removes a Devless root if found and possible.
//
//  Arguments:  [Name] -- Name of the Logical Root
//
//  Returns:    STATUS_SUCCESS -- If successfully deleted logical root
//
//              STATUS_NO_SUCH_DEVICE -- If there is no logical root to
//                      delete.
//
//
//-----------------------------------------------------------------------------

#ifdef TERMSRV

NTSTATUS
DfsDeleteDevlessRoot(
    IN PUNICODE_STRING  Name,
    IN ULONG SessionID,
    IN PLUID LogonID
)

#else // TERMSRV

NTSTATUS
DfsDeleteDevlessRoot(
    IN PUNICODE_STRING  Name,
    IN PLUID LogonID
)

#endif // TERMSRV
{
    PDFS_PKT_ENTRY PktEntry;
    PDFS_DEVLESS_ROOT Drt;
    NTSTATUS       Status;
    BOOLEAN        pktLocked;
    PDFS_PKT_ENTRY pktEntry;

    DfsDbgTrace(0, Dbg, "DfsDeleteDevlessRoot -> %wZ\n", Name);

    //
    // Acquire Pkt and DfsData, wait till we do so.
    //

    PktAcquireExclusive(TRUE, &pktLocked);

    ExAcquireResourceExclusiveLite(&DfsData.Resource, TRUE);

#ifdef TERMSRV
    Status = DfsFindDevlessRoot(Name, SessionID, LogonID, &Drt);
#else // TERMSRV
    Status = DfsFindDevlessRoot(Name, LogonID, &Drt);
#endif // TERMSRV

    if (!NT_SUCCESS(Status)) {
        goto Cleanup;
    }

    //
    // Delete the credentials used by this connection
    //

    DfsDeleteCredentials( Drt->Credentials );

    if (Drt->pktEntry != NULL) {
         InterlockedDecrement(&Drt->pktEntry->UseCount);
 
	 Drt->pktEntry = NULL;
    }

    RemoveEntryList(&Drt->DrtLinks);

    if (Drt->DevlessPath.Buffer) {
	ExFreePool(Drt->DevlessPath.Buffer);
    }
    ExFreePool(Drt);

Cleanup:

    ExReleaseResourceLite(&DfsData.Resource);

    PktRelease();

    return(Status);
}