windows-server-2003/base/fs/rdr2/rdbss/smb.mrx/smbcedb.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    smbcedb.c

Abstract:

    This module implements all functions related to accessing the SMB connection engine
    database

Revision History:

    Balan Sethu Raman     [SethuR]    6-March-1995

Notes:

    The construction of server, net root and session entries involve a certain
    amount of network traffic. Therefore, all these entities are constructed
    using a two phase protocol

    This continuation context is that of the RDBSS during construction of
    srv call and net root entries. For the session entries it is an SMB exchange
    that needs to be resumed.

    Two of the three primary data structures in the SMB mini redirector, i.e.,
    SMBCEDB_SERVER_ENTRY, SMBCEDB_SESSION_ENTRY and SMBCEDB_NET_ROOT_ENTRY  have
    directcounterparts in the RDBSS (MRX_SRV_CALL, MRX_V_NET_ROOT and MRX_NET_ROOT)
    constitute the core of the SMB mini redirector connection engine. There exists
    a one to one mapping between the SERVER_ENTRY and the MRX_SRV_CALL, as well
    as NET_ROOT_ENTRY and MRX_NET_ROOT.

    The SMBCEDB_SESSION_ENTRY does not have a direct mapping to a wrapper data
    structue, It is a part of SMBCE_V_NET_ROOT_CONTEXT which is the data
    structure associated with a MRX_V_NET_ROOT instance.

    More than one tree connect to a server can use the same session on a USER level
    security share. Consequently mapping rules need to be established to manage this
    relationship. The SMB mini redirector implements the following rules ...

         1) The first session with explicitly specified credentials will be
         treated as the default session for all subsequent requests to any given
         server unless credentials are explicitly specified for the new session.

         2) If no session with explicitly specified credentials exist then a
         session with the same logon id. is choosen.

         3) If no session with the same logon id. exists a new session is created.

    These rules are liable to change as we experiment with rules for establishing
    sessions with differing credentials to a given server. The problem is not with
    creating/manipulating these sessions but providing an adequate set of
    fallback rules for emulating the behaviour of the old redirector.

    These rules are implemented in SmbCeFindOrConstructSessionEntry.

--*/

#include "precomp.h"
#pragma hdrstop

#include "exsessup.h"
#include "secext.h"
#include "csc.h"

#ifdef  ALLOC_PRAGMA
#pragma alloc_text(PAGE, SmbCeUpdateSrvCall)
#pragma alloc_text(PAGE, SmbCeTearDownServerEntry)
#pragma alloc_text(PAGE, SmbCeGetUserNameAndDomainName)
#pragma alloc_text(PAGE, SmbCeTearDownSessionEntry)
#pragma alloc_text(PAGE, SmbCeTearDownNetRootEntry)
#pragma alloc_text(PAGE, SmbCeUpdateNetRoot)
#pragma alloc_text(PAGE, SmbCeDbInit)
#endif

extern BOOLEAN MRxSmbSecuritySignaturesRequired;
extern BOOLEAN MRxSmbSecuritySignaturesEnabled;
extern BOOLEAN MRxSmbExtendedSignaturesEnabled;
extern BOOLEAN MRxSmbExtendedSignaturesRequired;
extern BOOLEAN Win9xSessionRestriction;

RXDT_DefineCategory(SMBCEDB);
#define Dbg        (DEBUG_TRACE_SMBCEDB)

// The flag mask to control reference count tracing.

ULONG MRxSmbReferenceTracingValue = 0;

PSMBCEDB_SERVER_ENTRY
SmbCeFindServerEntry(
    PUNICODE_STRING     pServerName,
    SMBCEDB_SERVER_TYPE ServerType,
    PRX_CONNECTION_ID   RxConnectionId )
/*++

Routine Description:

    This routine searches the list of server entries and locates a matching
    entry

Arguments:

    pServerName - the name of the server

    ServerType  - the server type

    RxConnectionId - Used to control whether this will be multiplexed or not

Notes:

    The SmbCeResource must be held on entry and its ownership state will remain
    unchanged on exit

--*/
{
    PSMBCEDB_SERVER_ENTRY pServerEntry;
    RX_CONNECTION_ID LocalId;

    ASSERT(SmbCeIsResourceOwned());

    if( !RxConnectionId )
    {
        RtlZeroMemory( &LocalId, sizeof(RX_CONNECTION_ID) );
        RxConnectionId = &LocalId;
    }


    pServerEntry = SmbCeGetFirstServerEntry();
    while (pServerEntry != NULL) {
        if ((RtlCompareUnicodeString(
                    pServerName,
                    &pServerEntry->Name,
                    TRUE) == 0)) {
            // Check the connection ID
            if( RxEqualConnectionId( RxConnectionId, &pServerEntry->ConnectionId ) )
            {
                SmbCeReferenceServerEntry(pServerEntry);
                break;
            }
            else
            {
                pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
            }
        } else {
            pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
        }
    }

    return pServerEntry;
}

PSMBCEDB_SERVER_ENTRY
SmbCeFindServerEntryNoId(
    PUNICODE_STRING     pServerName,
    SMBCEDB_SERVER_TYPE ServerType)
/*++

Routine Description:

    This routine searches the list of server entries and locates a matching
    entry and ignores the ConnectionId

Arguments:

    pServerName - the name of the server

    ServerType  - the server type

Notes:

    The SmbCeResource must be held on entry and its ownership state will remain
    unchanged on exit

--*/
{
    PSMBCEDB_SERVER_ENTRY pServerEntry;
    RX_CONNECTION_ID LocalId;

    ASSERT(SmbCeIsResourceOwned());

    RtlZeroMemory( &LocalId, sizeof(RX_CONNECTION_ID) );

    pServerEntry = SmbCeGetFirstServerEntry();
    while (pServerEntry != NULL) {
        if ((RtlCompareUnicodeString(
                    pServerName,
                    &pServerEntry->Name,
                    TRUE) == 0)) {
            if( RxEqualConnectionId( &LocalId, &pServerEntry->ConnectionId ) )
            {
                SmbCeReferenceServerEntry(pServerEntry);
                break;
            }
            else
            {
                pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
            }
        } else {
            pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
        }
    }

    return pServerEntry;
}


PSMBCEDB_SERVER_ENTRY
SmbCeFindDfsServerEntry(
    PUNICODE_STRING     pServerName,
    SMBCEDB_SERVER_TYPE ServerType)
/*++

Routine Description:

    This routine searches the list of server entries and locates a matching
    entry

Arguments:

    pServerName - the name of the server

    ServerType  - the server type

Notes:

    The SmbCeResource must be held on entry and its ownership state will remain
    unchanged on exit

--*/
{
    PSMBCEDB_SERVER_ENTRY pServerEntry;

    ASSERT(SmbCeIsResourceOwned());

    pServerEntry = SmbCeGetFirstServerEntry();
    while (pServerEntry != NULL) {
        if ((RtlCompareUnicodeString(
                    pServerName,
                    &pServerEntry->DfsRootName,
                    TRUE) == 0)) {
            SmbCeReferenceServerEntry(pServerEntry);
            break;
        } else {
            pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
        }
    }

    return pServerEntry;
}

NTSTATUS
SmbCeFindOrConstructServerEntry(
    PUNICODE_STRING       pServerName,
    SMBCEDB_SERVER_TYPE   ServerType,
    PSMBCEDB_SERVER_ENTRY *pServerEntryPtr,
    PBOOLEAN              pNewServerEntry,
    PRX_CONNECTION_ID     RxConnectionId )
/*++

Routine Description:

    This routine searches the list of server entries and locates a matching
    entry or constructs a new one with the given name

Arguments:

    pServerName - the name of the server

    ServerType  - the type of server

    pServerEntryPtr - placeholder for the server entry

    pNewServerEntry - set to TRUE if it is a newly created server entry

Notes:

    The SmbCeResource must be held on entry and its ownership state will remain
    unchanged on exit

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;

    BOOLEAN               fNewServerEntry = FALSE;

    PSMBCEDB_SERVER_ENTRY pServerEntry;
    RX_CONNECTION_ID      LocalId;

    ASSERT(SmbCeIsResourceOwned());

    if( !RxConnectionId )
    {
        RtlZeroMemory( &LocalId, sizeof(RX_CONNECTION_ID) );
        RxConnectionId = &LocalId;
    }

    pServerEntry = SmbCeFindServerEntry(
                       pServerName,
                       ServerType,
                       RxConnectionId);

    if (pServerEntry == NULL) {
        // Create a server instance, initialize its state, add it to the list

        pServerEntry = (PSMBCEDB_SERVER_ENTRY)SmbMmAllocateObject(SMBCEDB_OT_SERVER);

        if (pServerEntry != NULL) {
            pServerEntry->Name.Buffer = RxAllocatePoolWithTag(
                                             NonPagedPool,
                                             pServerName->Length,
                                             MRXSMB_SERVER_POOLTAG);

            if (pServerEntry->Name.Buffer == NULL) {
                SmbMmFreeObject(pServerEntry);
                pServerEntry = NULL;
            }
        }

        if (pServerEntry != NULL) {
            fNewServerEntry = TRUE;

            pServerEntry->Name.Length = pServerName->Length;
            pServerEntry->Name.MaximumLength = pServerEntry->Name.Length;
            RtlCopyMemory(
                pServerEntry->Name.Buffer,
                pServerName->Buffer,
                pServerEntry->Name.Length);

            SmbCeUpdateServerEntryState(
                pServerEntry,
                SMBCEDB_CONSTRUCTION_IN_PROGRESS);

            SmbCeSetServerType(
                pServerEntry,
                ServerType);

            pServerEntry->PreferredTransport = NULL;

            SmbCeReferenceServerEntry(pServerEntry);
            SmbCeAddServerEntry(pServerEntry);

            pServerEntry->Server.IsRemoteBootServer = FALSE;
            if (MRxSmbBootedRemotely &&
                (MRxSmbRemoteBootShare.Length > pServerEntry->Name.Length)) {
                UNICODE_STRING RemoteBootServer;

                RemoteBootServer.Length = pServerEntry->Name.Length;
                RemoteBootServer.MaximumLength = pServerEntry->Name.MaximumLength;
                RemoteBootServer.Buffer = MRxSmbRemoteBootShare.Buffer;

                if (RtlEqualUnicodeString(
                    &pServerEntry->Name,
                    &RemoteBootServer,
                    TRUE)) {
                    pServerEntry->Server.IsRemoteBootServer = TRUE;
                }
            }

            pServerEntry->Server.IsFakeDfsServerForOfflineUse = FALSE;
            pServerEntry->Server.IsPinnedOffline = FALSE;
            pServerEntry->Server.SecurityMode = SECURITY_MODE_USER_LEVEL;

            RtlCopyMemory( &pServerEntry->ConnectionId, RxConnectionId, sizeof(RX_CONNECTION_ID) );

            if (SmbCeContext.ServersWithExtendedSessTimeout.Length != 0) {
                PWSTR          pSmbMRxServers = (PWSTR)SmbCeContext.ServersWithExtendedSessTimeout.Buffer;
                UNICODE_STRING SmbMRxServer, TargetServer;

                TargetServer.Length = pServerEntry->Name.Length - sizeof(WCHAR);
                TargetServer.MaximumLength = pServerEntry->Name.MaximumLength;
                TargetServer.Buffer = &pServerEntry->Name.Buffer[1];

                while (*pSmbMRxServers) {
                    SmbMRxServer.Length = wcslen(pSmbMRxServers) * sizeof(WCHAR);

                    if (SmbMRxServer.Length == TargetServer.Length) {
                        SmbMRxServer.MaximumLength = SmbMRxServer.Length;
                        SmbMRxServer.Buffer = pSmbMRxServers;

                        if (RtlCompareUnicodeString(
                               &SmbMRxServer,
                               &TargetServer,
                               TRUE) == 0) {
                            pServerEntry->Server.ExtendedSessTimeout = TRUE;
                            //DbgPrint("Extended SessTimeout %wZ\n",&pServerEntry->Name);
                            break;
                        }
                    }

                    pSmbMRxServers += (SmbMRxServer.Length / sizeof(WCHAR) + 1);
                }
            }

            SmbCeLog(("NewSrvEntry %lx %wZ\n",pServerEntry,&pServerEntry->Name));
            SmbLog(LOG,
                   SmbCeFindOrConstructServerEntry_1,
                   LOGPTR(pServerEntry)
                   LOGUSTR(pServerEntry->Name));
        } else {
            RxDbgTrace(0, Dbg, ("SmbCeOpenServer : Server Entry Allocation failed\n"));
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    } else {
        if (pServerEntry->PreferredTransport != NULL) {
            // reset the preferred transport created by previous owner
            SmbCeDereferenceTransport(pServerEntry->PreferredTransport);
            pServerEntry->PreferredTransport = NULL;
        }

        SmbCeLog(("CachedSrvEntry %lx %wZ\n",pServerEntry,&pServerEntry->Name));
        SmbLog(LOG,
               SmbCeFindOrConstructServerEntry_2,
               LOGPTR(pServerEntry)
               LOGUSTR(pServerEntry->Name));
    }

    *pServerEntryPtr = pServerEntry;
    *pNewServerEntry = fNewServerEntry;

    return Status;
}

VOID
SmbCeCompleteSrvCallConstruction(
    PMRX_SRVCALL_CALLBACK_CONTEXT  pCallbackContext)
/*++

Routine Description:

    This routine comlpletes the srvcall construtcion routine by invoking
    the callback routine to the wrapper.

Arguments:

    pCallbackContext   - the RDBSS context

Notes:

--*/
{
    PMRX_SRVCALLDOWN_STRUCTURE SrvCalldownStructure;
    PMRX_SRV_CALL              pSrvCall;
    PSMBCEDB_SERVER_ENTRY      pServerEntry;
    BOOLEAN                    MustSucceed = FALSE;
    NTSTATUS                   Status;

    PAGED_CODE();

    SrvCalldownStructure =
        (PMRX_SRVCALLDOWN_STRUCTURE)(pCallbackContext->SrvCalldownStructure);

    pSrvCall = SrvCalldownStructure->SrvCall;
    pServerEntry = (PSMBCEDB_SERVER_ENTRY)pCallbackContext->RecommunicateContext;

    if (pServerEntry != NULL) {
        if (!NT_SUCCESS(pCallbackContext->Status)) {
            if (pServerEntry->Server.IsRemoteBootServer ||
                pCallbackContext->Status == STATUS_RETRY) {
                MustSucceed = TRUE;
            }

            SmbCeDereferenceServerEntry(pServerEntry);
        } else {
            if (SmbCeGetServerType(pServerEntry) == SMBCEDB_MAILSLOT_SERVER) {
                pServerEntry->Header.State = SMBCEDB_ACTIVE;
            }
        }
    } else {
        if (pCallbackContext->Status == STATUS_SUCCESS) {
            pCallbackContext->Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }

    if (MustSucceed) {
        //DbgPrint("Build ServerEntry %X try again.\n",pCallbackContext->Status);

        // in case it is the remote boot server, if the server entry cannot be created for some
        // reason, i.e. transport is not ready and the cache is not filled, we need to create the
        // server entry again until it succeeds.
        Status = RxDispatchToWorkerThread(
                     MRxSmbDeviceObject,
                     CriticalWorkQueue,
                     SmbCeCreateSrvCall,
                     pCallbackContext);
    } else {
        SrvCalldownStructure->CallBack(pCallbackContext);
    }
}

NTSTATUS
SmbCeInitializeServerEntry(
    PMRX_SRV_CALL                 pSrvCall,
    PMRX_SRVCALL_CALLBACK_CONTEXT pCallbackContext,
    BOOLEAN                       fDeferNetworkInitialization)
/*++

Routine Description:

    This routine opens/creates a server entry in the connection engine database

Arguments:

    pSrvCall           - the SrvCall instance

    pCallbackContext   - the RDBSS context

Return Value:

    STATUS_SUCCESS - the server call construction has been finalized.

    Other Status codes correspond to error situations.

Notes:

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;

    PSMBCEDB_SERVER_ENTRY pServerEntry = NULL;
    BOOLEAN               MailSlotCreate = FALSE;
    PSMBCE_TRANSPORT      PreferredTransport = NULL;
    BOOLEAN               fNewServerEntry = FALSE;
    SMBCEDB_SERVER_TYPE   ServerType = SMBCEDB_FILE_SERVER;
    UNICODE_STRING        TransportName;
    RX_CONNECTION_ID      sRxConnectionId;

//   RxProfile(SmbCe,SmbCeOpenServer);

    ASSERT(pSrvCall->Context == NULL);
    TransportName = pCallbackContext->SrvCalldownStructure->RxContext->Create.TransportName;

    Status = MRxSmbGetConnectionId( pCallbackContext->SrvCalldownStructure->RxContext, &sRxConnectionId );
    if( !NT_SUCCESS(Status) )
    {
        DbgPrint( "MRXSMB: GetConnectionId failed.\n" );
        ASSERT(FALSE);
        RtlZeroMemory( &sRxConnectionId, sizeof(RX_CONNECTION_ID) );
    }

    if (TransportName.Length > 0) {
        if ((PreferredTransport=SmbCeFindTransport(&TransportName)) == NULL) {
            ASSERT(pCallbackContext->RecommunicateContext == NULL);
            Status = STATUS_NETWORK_UNREACHABLE;
            goto FINALLY;
        }
    }

    MailSlotCreate = BooleanFlagOn(
                        pCallbackContext->SrvCalldownStructure->RxContext->Flags,
                        RX_CONTEXT_FLAG_CREATE_MAILSLOT);

    if (MailSlotCreate) {
        fDeferNetworkInitialization = FALSE;
        ServerType = SMBCEDB_MAILSLOT_SERVER;
    }

    SmbCeAcquireResource();

    Status = SmbCeFindOrConstructServerEntry(
                 pSrvCall->pSrvCallName,
                 ServerType,
                 &pServerEntry,
                 &fNewServerEntry,
                 &sRxConnectionId);

    SmbCeReleaseResource();

    pCallbackContext->RecommunicateContext = pServerEntry;

    if (Status == STATUS_SUCCESS) {

        ASSERT(pServerEntry != NULL);

        InterlockedExchangePointer(
            &pServerEntry->pRdbssSrvCall,
            pSrvCall);

        Status = SmbCeUpdateSrvCall(pServerEntry);

        if(!SmbCeIsServerInDisconnectedMode(pServerEntry)) {
            if (Status == STATUS_SUCCESS) {
                if (PreferredTransport != NULL) {
                    // Transfer the ownership of the preferred transport to the
                    // server entry.
                    pServerEntry->PreferredTransport = PreferredTransport;
                    PreferredTransport = NULL;
                } else {
                    pServerEntry->PreferredTransport = NULL;
                }

                if (fNewServerEntry) {
                    pServerEntry->Header.State = SMBCEDB_INVALID;
                    // Initialize the mailslot server parameters.
                    pServerEntry->Server.Dialect = LANMAN21_DIALECT;
                    //  MaximumBufferSize will be set based on negotiate response
                    pServerEntry->Server.MaximumBufferSize = 0xffff;

                    Status = CscInitializeServerEntryDfsRoot(
                                 pCallbackContext->SrvCalldownStructure->RxContext,
                                 pServerEntry);
                }

                if (Status == STATUS_SUCCESS) {
                    if (!fDeferNetworkInitialization &&
                        !MailSlotCreate) {
                        Status = SmbCeInitializeServerTransport(
                                     pServerEntry,
                                     SmbCeCompleteSrvCallConstruction,
                                     pCallbackContext);
                    } else {
                        Status = SmbCeInitializeServerMailSlotTransport(
                                     pServerEntry,
                                     SmbCeCompleteSrvCallConstruction,
                                     pCallbackContext);
                    }
                }
            }
        }
    }

FINALLY:
    if (Status != STATUS_PENDING) {
        pCallbackContext->Status = Status;
        SmbCeCompleteSrvCallConstruction(pCallbackContext);
    }

    if (PreferredTransport != NULL) {
        SmbCeDereferenceTransport(PreferredTransport);
    }

    return STATUS_PENDING;
}


NTSTATUS
SmbCeUpdateSrvCall(
    PSMBCEDB_SERVER_ENTRY pServerEntry)
/*++

Routine Description:

    This routine initializes the wrapper data structure corresponding to a
    given server entry.

Arguments:

    pServerEntry  - the server entry

Return Value:

    STATUS_SUCCESS if successful

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;

    PMRX_SRV_CALL pSrvCall = pServerEntry->pRdbssSrvCall;

    PAGED_CODE();

    if (pSrvCall != NULL) {
        // Copy the domain name into the server entry
        Status = RxSetSrvCallDomainName(
                     pSrvCall,
                     &pServerEntry->DomainName);

        // Initialize the SrvCall flags based upon the capabilities of the remote
        // server. The only flags that the SMB mini redirector updates are the
        // SRVCALL_FLAG_DFS_AWARE and SRVCALL_FLAG_LWIO_AWARE

        if (pServerEntry->Server.Capabilities & CAP_DFS) {
            SetFlag(
                pSrvCall->Flags,
                SRVCALL_FLAG_DFS_AWARE_SERVER);
        }

        if (pServerEntry->Server.Capabilities & LWIO_CAPABILITY) {
            SetFlag(
                pSrvCall->Flags,
                SRVCALL_FLAG_LWIO_AWARE_SERVER);
        }

        if (pServerEntry->Server.IsLoopBack) {
            SetFlag(
                pSrvCall->Flags,
                SRVCALL_FLAG_LOOPBACK_SERVER);
        }
    }

    return Status;
}

BOOLEAN
SmbCeAreServerEntriesAliased(
    PSMBCEDB_SERVER_ENTRY pServerEntry1,
    PSMBCEDB_SERVER_ENTRY pServerEntry2)
/*++

Routine Description:

    This routine is used to determine if two server entries are aliased. For uplevel
    servers (NT5 or greater) the server GUID can be used to determine if the two
    server entries are aliased. For downlevel servers it is determined by checking if
    they have the same IP address.

Arguments:

    pServerEntry1  - the first server entry

    pServerEntry2  - the second server entry

Return Value:

    TRUE if the two server entries are aliased and FALSE otherwise

Notes:

    There are two interesting points to note ...

    1) a server entry cannot be an alias of itself. The first test in the implementation.
    This semantic makes checking a server entry against a collection of entries easy.

    2) the mechanism that we have for detecting aliases is not complete. There are cases
    (downlevel) when the two server entries are aliases of each other but we will conclude
    otherwise. This is because there is no foolproof way of establishing the absence of
    aliasing. The algorithm that is currently implemented detects the most important case
    of aliasing, i.e., DNS names and NETBIOS names to the same server on TCP.

--*/
{
    BOOLEAN ServerEntriesAliased = FALSE;

    if (pServerEntry1 != pServerEntry2) {
        if (BooleanFlagOn(
                pServerEntry1->Server.DialectFlags,
                DF_EXTENDED_SECURITY) &&
            BooleanFlagOn(
                pServerEntry2->Server.DialectFlags,
                DF_EXTENDED_SECURITY)) {
            if (RtlEqualMemory(
                    &pServerEntry1->Server.NtServer.ServerGuid,
                    &pServerEntry2->Server.NtServer.ServerGuid,
                    sizeof(GUID))) {
                ServerEntriesAliased = TRUE;
            }

        } else {
            if ((pServerEntry1->Server.IpAddress == pServerEntry2->Server.IpAddress) &&
                (pServerEntry1->Server.IpAddress != 0)) {
                ServerEntriesAliased = TRUE;
            }
        }
    }

    return ServerEntriesAliased;
}

VOID
SmbCeCompleteServerEntryInitialization(
    PSMBCEDB_SERVER_ENTRY pServerEntry,
    NTSTATUS              Status)
/*++

Routine Description:

    This routine is invoked in the context of a worker thread to finalize the
    construction of a server entry

Arguments:

    pServerEntry  - the server entry to be finalized

    ServerState   - the final state of the server

--*/
{
    NTSTATUS                ServerStatus;

    SMBCEDB_OBJECT_STATE    PreviousState;
    SMBCEDB_REQUESTS        ReconnectRequests;
    PSMBCEDB_REQUEST_ENTRY  pRequestEntry;

    KIRQL                   SavedIrql;

    RxDbgTrace( 0, Dbg, ("Server Entry Finalization\n"));
    ASSERT(pServerEntry->Header.ObjectType == SMBCEDB_OT_SERVER);

    InitializeListHead(&ReconnectRequests.ListHead);

    // Acquire the SMBCE resource
    SmbCeAcquireResource();
    SmbCeAcquireSpinLock();

    // The server status could have changed because of the transport disconnects
    // from the time the admin exchange was completed to the time the server
    // entry initialization complete routine is called. Update the state
    // accordingly.

    PreviousState = pServerEntry->Header.State;

    if (PreviousState == SMBCEDB_CONSTRUCTION_IN_PROGRESS) {
        pServerEntry->ServerStatus = Status;

        if (Status == STATUS_SUCCESS) {
            pServerEntry->Header.State = SMBCEDB_ACTIVE;
        } else {
            pServerEntry->Header.State = SMBCEDB_INVALID;
        }
    }

    ServerStatus = pServerEntry->ServerStatus;

    pServerEntry->NegotiateInProgress = FALSE;

    // Weed out all the reconnect requests so that they can be resumed
    pRequestEntry = SmbCeGetFirstRequestEntry(&pServerEntry->OutstandingRequests);
    while (pRequestEntry != NULL) {
        if (pRequestEntry->GenericRequest.Type == RECONNECT_REQUEST) {
            PSMBCEDB_REQUEST_ENTRY pTempRequestEntry;

            pTempRequestEntry = pRequestEntry;
            pRequestEntry = SmbCeGetNextRequestEntry(
                                &pServerEntry->OutstandingRequests,
                                pRequestEntry);

            SmbCeRemoveRequestEntryLite(
                &pServerEntry->OutstandingRequests,
                pTempRequestEntry);

            SmbCeAddRequestEntryLite(
                &ReconnectRequests,
                pTempRequestEntry);
        } else {
            pRequestEntry = SmbCeGetNextRequestEntry(
                                &pServerEntry->OutstandingRequests,
                                pRequestEntry);
        }
    }

    pServerEntry->Server.NumberOfVNetRootContextsForScavenging = 0;
    pServerEntry->Server.AliasedServers = FALSE;
    if ((Status == STATUS_SUCCESS) && (ServerStatus == STATUS_SUCCESS)) {
        // Walk through the list of currently active servers to establish the
        // session numbering. This traversal is required because of server
        // name aliasing that occurs when the different name formats are used
        // to access the server, i.e., dotted IP address, DNS name, NETBIOS name.
        // The disambiguation between different servers is done in one of two
        // ways. For uplevel servers ( NT5.0 or later ) the Server GUID is used.
        // For downlevel servers ( NT 4.0 or before ) the IP address is used
        // to distinguish the two. Note that there is one case that is not
        // covered by the current solution, the connection using a NETBIOS
        // name is established over some transport other than NetBt and this
        // is followed by establishing a connection establishment using the
        // DNS name over NetBt. In such cases this numbering scheme fails. In
        // some ways there is no complete solution for this once we start using
        // *SMBSERVER names as opposed to the NETBIOS name for connection
        // establishment with dotted IP address.

        PSMBCEDB_SERVER_ENTRY pTempServerEntry;

        pTempServerEntry = SmbCeGetFirstServerEntry();

        while (pTempServerEntry != NULL) {
            if (pTempServerEntry->Header.State == SMBCEDB_ACTIVE) {
                if (SmbCeAreServerEntriesAliased(
                        pServerEntry,
                        pTempServerEntry)) {
                    pServerEntry->Server.AliasedServers = TRUE;
                    pTempServerEntry->Server.AliasedServers = TRUE;
                }
            }

            pTempServerEntry = SmbCeGetNextServerEntry(pTempServerEntry);
        }
    }

    SmbCeReleaseSpinLock();

    if ((Status == STATUS_SUCCESS) &&
        (ServerStatus == STATUS_SUCCESS) &&
        (PreviousState == SMBCEDB_CONSTRUCTION_IN_PROGRESS)) {
        PSMBCEDB_SESSION_ENTRY pSessionEntry;
        SESSION_TYPE           SessionType;

        InterlockedIncrement(&pServerEntry->Server.Version);
        pServerEntry->Server.NumberOfSrvOpens = 0;

        ASSERT(pServerEntry->pMidAtlas == NULL);

        // Initialize the MID Atlas
        pServerEntry->pMidAtlas = FsRtlCreateMidAtlas(
                                       pServerEntry->Server.MaximumRequests,
                                       pServerEntry->Server.MaximumRequests);

        if (pServerEntry->pMidAtlas == NULL) {
            pServerEntry->ServerStatus = RX_MAP_STATUS(INSUFFICIENT_RESOURCES);
        }

        if (MRxSmbSecuritySignaturesEnabled &&
            pServerEntry->Server.SecuritySignaturesEnabled) {
            pServerEntry->SecuritySignaturesEnabled = TRUE;
        } else {
            pServerEntry->SecuritySignaturesEnabled = FALSE;
        }

        // The sessions that have been created but whose initialization has been
        // deferred will have the session types set incorrectly. This is because
        // there is no previous knowledge of the session type required for deferred
        // servers.

        if (pServerEntry->Server.DialectFlags & DF_EXTENDED_SECURITY) {
            SessionType = EXTENDED_NT_SESSION;
        } else {
            SessionType = LANMAN_SESSION;
        }

        pSessionEntry =  SmbCeGetFirstSessionEntry(pServerEntry);
        while (pSessionEntry != NULL) {
            if (!FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION)) {
                pSessionEntry->Session.Type = SessionType;
            } else {
                pSessionEntry->Session.Type = LANMAN_SESSION;
            }
            pSessionEntry = SmbCeGetNextSessionEntry(
                                pServerEntry,
                                pSessionEntry);
        }

        MRxSmbCheckForLoopBack(pServerEntry);
    }

    // Release the resource for the server entry
    SmbCeReleaseResource();

    // Resume all the outstanding reconnect requests that were held up because an earlier
    // reconnect request was under way.
    // Iterate over the list of pending requests and resume all of them
    SmbCeResumeOutstandingRequests(&ReconnectRequests,ServerStatus);
}


VOID
SmbCepDereferenceServerEntry(
    PSMBCEDB_SERVER_ENTRY pServerEntry)
/*++

Routine Description:

    This routine dereferences a server entry instance

Arguments:

    pServerEntry - the server entry to be dereferenced

--*/
{
    if (pServerEntry != NULL) {
        BOOLEAN fTearDownEntry = FALSE;
        LONG    FinalRefCount;

        ASSERT((pServerEntry->Header.ObjectType == SMBCEDB_OT_SERVER) &&
               (pServerEntry->Header.SwizzleCount > 0));

        SmbCeAcquireResource();
        SmbCeAcquireSpinLock();

    /* if this is a work item request then clear the flag */
    /* WorkerRoutine is set to NULL just before work items are called */
    if((pServerEntry->WorkQueueItemForDisconnect.WorkerRoutine == NULL) &&
       pServerEntry->DisconnectWorkItemOutstanding == TRUE) {
        pServerEntry->DisconnectWorkItemOutstanding = FALSE;
    }

        FinalRefCount = InterlockedDecrement(&pServerEntry->Header.SwizzleCount);

        fTearDownEntry = (FinalRefCount == 0);

        if (fTearDownEntry) {
            // This is to ensure that the routines for traversing the server
            // entry list, i.e., probing servers do not colide with the teardown.

            if (pServerEntry->Header.SwizzleCount == 0) {
                pServerEntry->Header.State = SMBCEDB_MARKED_FOR_DELETION;

                SmbCeRemoveServerEntryLite(pServerEntry);

                if (SmbCeGetFirstServerEntry() == NULL &&
                    SmbCeStartStopContext.pServerEntryTearDownEvent != NULL) {
                    KeSetEvent(SmbCeStartStopContext.pServerEntryTearDownEvent,0,FALSE);
                }
            } else {
                fTearDownEntry = FALSE;
            }
        }

        SmbCeReleaseSpinLock();
        SmbCeReleaseResource();

        if (fTearDownEntry) {
            if (IoGetCurrentProcess() == RxGetRDBSSProcess()) {
                SmbCeTearDownServerEntry(pServerEntry);
            } else {
                InitializeListHead(&pServerEntry->WorkQueueItem.List);

                RxPostToWorkerThread(
                    MRxSmbDeviceObject,
                    CriticalWorkQueue,
                    &pServerEntry->WorkQueueItem,
                    SmbCeTearDownServerEntry,
                    pServerEntry);
            }
        }
    }
}

VOID
SmbCeTearDownServerEntry(
    PSMBCEDB_SERVER_ENTRY pServerEntry)
/*++

Routine Description:

    This routine tears down a server entry instance

Arguments:

    pServerEntry - the server entry to be dereferenced

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;
    PAGED_CODE();

    SmbCeLog(("TearSrvEntry %lx %wZ\n",pServerEntry,&pServerEntry->Name));
    SmbLog(LOG,
           SmbCeTearDownServerEntry,
           LOGPTR(pServerEntry)
           LOGUSTR(pServerEntry->Name));
    ASSERT(pServerEntry->Header.State == SMBCEDB_MARKED_FOR_DELETION);

    if (pServerEntry->pMidAtlas != NULL) {
        FsRtlDestroyMidAtlas(pServerEntry->pMidAtlas,NULL);
        pServerEntry->pMidAtlas = NULL;
    }

    if (pServerEntry->pTransport != NULL ||
        pServerEntry->pMailSlotTransport != NULL) {
        Status = SmbCeUninitializeServerTransport(pServerEntry,NULL,NULL);
        ASSERT(Status == STATUS_SUCCESS);
    }

    if (pServerEntry->Server.NtServer.pSecurityBlob != NULL) {
        RxFreePool(pServerEntry->Server.NtServer.pSecurityBlob);
    }

    if (pServerEntry->Name.Buffer != NULL) {
        RxFreePool(pServerEntry->Name.Buffer);
    }

    if (pServerEntry->DomainName.Buffer != NULL) {
        RxFreePool(pServerEntry->DomainName.Buffer);
    }

    if (pServerEntry->DfsRootName.Buffer != NULL) {
        RxFreePool(pServerEntry->DfsRootName.Buffer);
    }

    if (pServerEntry->DnsName.Buffer != NULL) {
        RxFreePool(pServerEntry->DnsName.Buffer);
    }

    if (pServerEntry->PreferredTransport != NULL) {
        SmbCeDereferenceTransport(pServerEntry->PreferredTransport);
    }

    SmbMmFreeObject(pServerEntry);
}

NTSTATUS
SmbCeFindOrConstructSessionEntry(
    PMRX_V_NET_ROOT         pVNetRoot,
    PSMBCEDB_SESSION_ENTRY *pSessionEntryPtr)
/*++

Routine Description:

    This routine opens/creates a session for a given user in the connection engine database

Arguments:

    pVNetRoot - the RDBSS Virtual net root instance

Return Value:

    STATUS_SUCCESS - if successful

    Other Status codes correspond to error situations.

Notes:

    This routine assumes that the necesary concurreny control mechanism has already
    been taken.

    On Entry the connection engine resource must have been acquired exclusive and
    ownership remains invariant on exit.

    In case of UPN, we should pass a NULL string instead of NULL as domain name.

--*/
{
    NTSTATUS                Status = STATUS_SUCCESS;
    PSMBCEDB_SERVER_ENTRY   pServerEntry  = NULL;
    PSMBCEDB_SESSION_ENTRY  pSessionEntry = NULL;
    BOOLEAN                 fSessionEntryFound = FALSE;
    PUNICODE_STRING         UserName;
    PUNICODE_STRING         Password;
    PUNICODE_STRING         UserDomainName;
    DWORD                   SessionType;
    LUID                    AnonymousLogonID = ANONYMOUS_LOGON_LUID;

#define SessionTypeDefault      1
#define SessionTypeUser         2
#define SessionTypeNull         3
#define SessionTypeRemoteBoot   4

    ASSERT(SmbCeIsResourceOwned());

    UserName = pVNetRoot->pUserName;
    Password = pVNetRoot->pPassword;
    UserDomainName = pVNetRoot->pUserDomainName;

    //
    // If this is a remote boot client, and we're connecting to the boot share,
    // we always use the machine account, not the user account. This is
    // necessary in order to get security (ACL checking) to behave correctly.
    //

    SessionType = SessionTypeDefault;

    if ( MRxSmbBootedRemotely ) {

        //DbgPrint( "FindOrConstructSessionEntry: root %wZ\n", pVNetRoot->pNetRoot->pNetRootName );
        //DbgBreakPoint();
        if ( RtlCompareUnicodeString(
                 pVNetRoot->pNetRoot->pNetRootName,
                 &MRxSmbRemoteBootShare,
                 TRUE
                 ) == 0 ) {
            SessionType = SessionTypeRemoteBoot;
            //DbgPrint( "  Original user/password/domain: %wZ/%wZ/%wZ\n", UserName, Password, UserDomainName );
            UserName = &MRxSmbRemoteBootMachineName;
            Password = &MRxSmbRemoteBootMachinePassword;
            UserDomainName = &MRxSmbRemoteBootMachineDomain;
            //DbgPrint( "  Machine user/password/domain: %wZ/%wZ/%wZ\n", UserName, Password, UserDomainName );
        }
    }

    if (SessionType != SessionTypeRemoteBoot) {
        if ((UserName != NULL)       &&
            (UserName->Length == 0)  &&
            (Password != NULL)       &&
            (Password->Length == 0)  &&
            (UserDomainName != NULL) &&
            (UserDomainName->Length == 0)) {
            SessionType = SessionTypeNull;
        } else if ((UserName != NULL) ||
                   ((Password != NULL) &&
                    (Password->Length > 0))) {
            SessionType = SessionTypeUser;
        }
    }

    *pSessionEntryPtr = NULL;

    // Reference the server handle
    pServerEntry = SmbCeReferenceAssociatedServerEntry(pVNetRoot->pNetRoot->pSrvCall);
    if (pServerEntry != NULL) {
        if (SessionType != SessionTypeUser &&
            pServerEntry->Server.SecurityMode != SECURITY_MODE_SHARE_LEVEL) {

            SmbCeAcquireSpinLock();
            // Rule No. 1
            // 1) The first session with explicitly specified credentials will be treated as the
            // default session for all subsequent requests to any given server.
            if (SessionType == SessionTypeDefault) {
                pSessionEntry = SmbCeGetDefaultSessionEntry(
                                    pServerEntry,
                                    pVNetRoot->SessionId,
                                    &pVNetRoot->LogonId);

                while (pSessionEntry != NULL &&
                       FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_MARKED_FOR_DELETION)) {

                    SmbCeRemoveDefaultSessionEntry(pSessionEntry);

                    pSessionEntry = SmbCeGetDefaultSessionEntry(
                                        pServerEntry,
                                        pVNetRoot->SessionId,
                                        &pVNetRoot->LogonId);
                }
            }

            if (pSessionEntry == NULL) {
                // Enumerate the sessions to detect if a session satisfying rule 2 exists

                pSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
                while (pSessionEntry != NULL) {
                    if (!FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_MARKED_FOR_DELETION)) {
                        if (SessionType == SessionTypeDefault) {
                            //
                            // Rule No. 2
                            // 2) If no session with explicitly specified credentials exist then a
                            // session with the same logon id. is choosen.
                            //

                            if (RtlEqualLuid(
                                    &pSessionEntry->Session.LogonId,
                                    &pVNetRoot->LogonId)) {
                                break;
                            }
                        } else if (SessionType == SessionTypeNull) {
                            if (FlagOn(
                                    pSessionEntry->Session.Flags,
                                    SMBCE_SESSION_FLAGS_NULL_CREDENTIALS)) {
                                break;
                            }
                        } else {
                            ASSERT(SessionType == SessionTypeRemoteBoot);
                            if (FlagOn(
                                    pSessionEntry->Session.Flags,
                                    SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION)) {
                                break;
                            }
                        }
                    }

                    pSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pSessionEntry);
                }
            }

            if (pSessionEntry != NULL) {
                SmbCeReferenceSessionEntry(pSessionEntry);
            }

            SmbCeReleaseSpinLock();
        } else {
            BOOLEAN SessionEntryFound = FALSE;

            SmbCeAcquireSpinLock();
            pSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
            if (pSessionEntry != NULL) {
                SmbCeReferenceSessionEntry(pSessionEntry);
            }
            SmbCeReleaseSpinLock();

            while ((pSessionEntry != NULL) && !SessionEntryFound) {
                if (!FlagOn(pSessionEntry->Session.Flags,
                        SMBCE_SESSION_FLAGS_NULL_CREDENTIALS |
                        SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION |
                        SMBCE_SESSION_FLAGS_MARKED_FOR_DELETION)) {
                    PSecurityUserData pSecurityData = NULL;

                    if (pServerEntry->Server.SecurityMode != SECURITY_MODE_SHARE_LEVEL) {
                        for (;;) {
                            PSMBCE_SESSION  pSession = &pSessionEntry->Session;
                            PUNICODE_STRING TempUserName,TempUserDomainName;

                            // For each existing session check to determine if the credentials
                            // supplied match the credentials used to construct the session.
                            if( pSession->SessionId != pVNetRoot->SessionId ) {
                                break;
                            }

                            if (!RtlEqualLuid(
                                    &pSessionEntry->Session.LogonId,
                                    &pVNetRoot->LogonId)) {
                                break;
                            }

                            TempUserName       = pSession->pUserName;
                            TempUserDomainName = pSession->pUserDomainName;

                            if (TempUserName == NULL ||
                                TempUserDomainName == NULL) {
                                Status = GetSecurityUserInfo(
                                             &pVNetRoot->LogonId,
                                             UNDERSTANDS_LONG_NAMES,
                                             &pSecurityData);

                                if (NT_SUCCESS(Status)) {
                                    if (TempUserName == NULL) {
                                        TempUserName = &(pSecurityData->UserName);
                                    }

                                    if (TempUserDomainName == NULL) {
                                        TempUserDomainName = &(pSecurityData->LogonDomainName);
                                    }
                                } else {
                                    break;
                                }
                            }

                            if (UserName != NULL &&
                                !RtlEqualUnicodeString(UserName,TempUserName,TRUE)) {
                                Status = STATUS_NETWORK_CREDENTIAL_CONFLICT;
                                break;
                            }

                            if (UserDomainName != NULL &&
                                !RtlEqualUnicodeString(UserDomainName,TempUserDomainName,TRUE)) {
                                Status = STATUS_NETWORK_CREDENTIAL_CONFLICT;
                                break;
                            }

                            if ((Password != NULL) &&
                                (pSession->pPassword != NULL)) {
                                if (!RtlEqualUnicodeString(
                                        Password,
                                        pSession->pPassword,
                                        FALSE)) {
                                    Status = STATUS_NETWORK_CREDENTIAL_CONFLICT;
                                    break;
                                }
                            }

                            SessionEntryFound = TRUE;

                            // We use existing session if either the stored or new password is NULL.
                            // Later, a new security API will be created for verify the password
                            // based on the logon ID.

                            // An entry that matches the credentials supplied has been found. use it.
                            break;
                        }

                        //ASSERT(Status != STATUS_NETWORK_CREDENTIAL_CONFLICT);

                        if (pSecurityData != NULL) {
                            LsaFreeReturnBuffer(pSecurityData);
                            pSecurityData = NULL;
                        }
                    } else {
                        if (RtlEqualLuid(
                                &pSessionEntry->Session.LogonId,
                                &pVNetRoot->LogonId)) {
                            // For share level security, each share will have a different session
                            if (pSessionEntry->pNetRootName != NULL) {
                                if (RtlEqualUnicodeString(
                                        pVNetRoot->pNetRoot->pNetRootName,
                                        pSessionEntry->pNetRootName,
                                        FALSE)) {
                                    SessionEntryFound = TRUE;
                                }
                            }
                        }
                    }
                }

                if (!SessionEntryFound) {
                    if (Status == STATUS_SUCCESS) {
                        PSMBCEDB_SESSION_ENTRY pNextSessionEntry;

                        SmbCeAcquireSpinLock();
                        pNextSessionEntry = SmbCeGetNextSessionEntry(
                                                pServerEntry,
                                                pSessionEntry);
                        if (pNextSessionEntry != NULL) {
                            SmbCeReferenceSessionEntry(pNextSessionEntry);
                        }
                        SmbCeReleaseSpinLock();

                        SmbCeDereferenceSessionEntry(pSessionEntry);
                        pSessionEntry = pNextSessionEntry;
                    } else {
                        // An error situation was encountered. Terminate the iteration.
                        // Typically a set of conflicting credentials have been presented
                        SmbCeDereferenceSessionEntry(pSessionEntry);
                        pSessionEntry = NULL;
                    }
                } else {
                    if (RtlEqualLuid(&pSessionEntry->Session.LogonId,&AnonymousLogonID) &&
                        (Password != NULL || UserName != NULL || UserDomainName != NULL)) {
                        Status = STATUS_NETWORK_CREDENTIAL_CONFLICT;
                    }
                }
            }
        }

        if (Win9xSessionRestriction &&
            (pSessionEntry == NULL) &&
            (Status == STATUS_SUCCESS) &&
            FlagOn(pServerEntry->Server.DialectFlags,DF_W95)) {
            PSMBCEDB_SESSION_ENTRY  TempSessionEntry;

            TempSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
            while (TempSessionEntry != NULL) {
                if (!FlagOn(TempSessionEntry->Session.Flags,
                           SMBCE_SESSION_FLAGS_NULL_CREDENTIALS)) {
                    Status = STATUS_LOGIN_WKSTA_RESTRICTION;
                    break;
                }

                TempSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,TempSessionEntry);
            }
        }

        if ((pSessionEntry == NULL) && (Status == STATUS_SUCCESS)) {
            // Rule No. 3
            // 3) If no session with the same logon id. exists a new session is created.
            //
            // Allocate a new session entry

            // This is the point at which a many to mapping between session entries and
            // V_NET_ROOT's in the RDBSS is being established. From this point it is
            // true that the session entry can outlive the associated V_NET_ROOT entry.
            // Therefore copies of the parameters used in the session setup need be made.

            PSMBCE_SESSION  pSession = &pSessionEntry->Session;
            PUNICODE_STRING pPassword,pUserName,pUserDomainName,pNetRootName;

            if (Password != NULL) {
                pPassword = (PUNICODE_STRING)
                            RxAllocatePoolWithTag(
                                NonPagedPool,
                                sizeof(UNICODE_STRING) + Password->Length,
                                MRXSMB_SESSION_POOLTAG);
                if (pPassword != NULL) {
                    pPassword->Buffer = (PWCHAR)((PCHAR)pPassword + sizeof(UNICODE_STRING));
                    pPassword->Length = Password->Length;
                    pPassword->MaximumLength = pPassword->Length;
                    RtlCopyMemory(
                        pPassword->Buffer,
                        Password->Buffer,
                        pPassword->Length);
                } else {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            } else {
                pPassword = NULL;
            }

            if ((UserName != NULL) &&
                (Status == RX_MAP_STATUS(SUCCESS))) {
                pUserName = (PUNICODE_STRING)
                            RxAllocatePoolWithTag(
                                NonPagedPool,
                                sizeof(UNICODE_STRING) + UserName->Length,
                                MRXSMB_SESSION_POOLTAG);
                if (pUserName != NULL) {
                    pUserName->Buffer = (PWCHAR)((PCHAR)pUserName + sizeof(UNICODE_STRING));
                    pUserName->Length = UserName->Length;
                    pUserName->MaximumLength = pUserName->Length;
                    RtlCopyMemory(
                        pUserName->Buffer,
                        UserName->Buffer,
                        pUserName->Length);
                } else {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            } else {
                pUserName = NULL;
            }

            if ((UserDomainName != NULL) &&
                (Status == RX_MAP_STATUS(SUCCESS))) {
                pUserDomainName = (PUNICODE_STRING)
                                  RxAllocatePoolWithTag(
                                      NonPagedPool,
                                      sizeof(UNICODE_STRING) + UserDomainName->Length + sizeof(WCHAR),
                                      MRXSMB_SESSION_POOLTAG);

                if (pUserDomainName != NULL) {
                    pUserDomainName->Buffer = (PWCHAR)((PCHAR)pUserDomainName + sizeof(UNICODE_STRING));
                    pUserDomainName->Length = UserDomainName->Length;
                    pUserDomainName->MaximumLength = pUserDomainName->Length;

                    // in case of UPN name, domain name will be a NULL string
                    *pUserDomainName->Buffer = 0;

                    if (UserDomainName->Length > 0) {
                        RtlCopyMemory(
                            pUserDomainName->Buffer,
                            UserDomainName->Buffer,
                            pUserDomainName->Length);
                    }
                } else {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            } else {
                pUserDomainName = NULL;
            }


            if (pServerEntry->Server.SecurityMode == SECURITY_MODE_SHARE_LEVEL) {
                pNetRootName = (PUNICODE_STRING)RxAllocatePoolWithTag(
                                          NonPagedPool,
                                          sizeof(UNICODE_STRING) +
                                          pVNetRoot->pNetRoot->pNetRootName->Length,
                                          MRXSMB_SESSION_POOLTAG);

                if (pNetRootName != NULL) {
                    pNetRootName->Buffer = (PWCHAR)((PCHAR)pNetRootName + sizeof(UNICODE_STRING));
                    pNetRootName->Length = pVNetRoot->pNetRoot->pNetRootName->Length;
                    pNetRootName->MaximumLength = pNetRootName->Length;

                    if (pNetRootName->Length > 0) {
                        RtlCopyMemory(
                            pNetRootName->Buffer,
                            pVNetRoot->pNetRoot->pNetRootName->Buffer,
                            pNetRootName->Length);
                    }
                } else {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            } else {
                pNetRootName = NULL;
            }

            if (Status == STATUS_SUCCESS) {
                pSessionEntry = SmbMmAllocateSessionEntry(
                                    pServerEntry,
                                    (BOOLEAN)(SessionType == SessionTypeRemoteBoot));
                if (pSessionEntry != NULL) {
                    PSMBCE_SESSION pSession = & pSessionEntry->Session;

                    SmbCeLog(("NewSessEntry %lx\n",pSessionEntry));
                    SmbLog(LOG,
                           SmbCeFindOrConstructSessionEntry_1,
                           LOGPTR(pSessionEntry));

                    pSessionEntry->Header.State = SMBCEDB_INVALID;
                    pSessionEntry->pServerEntry = pServerEntry;
                    pSessionEntry->pNetRootName = pNetRootName;

                    if (pServerEntry->Server.SecurityMode == SECURITY_MODE_SHARE_LEVEL) {
                        pSessionEntry->Session.UserId = (SMB_USER_ID)SMBCE_SHARE_LEVEL_SERVER_USERID;
                    }

                    pSession->Flags           = 0;
                    if ( SessionType == SessionTypeRemoteBoot ) {
                        pSession->Flags = SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION;
                    }

                    if ( SessionType == SessionTypeNull ) {
                        pSession->Flags |= SMBCE_SESSION_FLAGS_NULL_CREDENTIALS;
                    }

                    pSession->LogonId         = pVNetRoot->LogonId;
                    pSession->pUserName       = pUserName;
                    pSession->pPassword       = pPassword;
                    pSession->pUserDomainName = pUserDomainName;
                    pSession->SessionId       = pVNetRoot->SessionId;

                    SmbCeReferenceSessionEntry(pSessionEntry);
                    SmbCeAddSessionEntry(pServerEntry,pSessionEntry);
                } else {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            }

            if (Status != STATUS_SUCCESS) {
                if (pUserName != NULL) {
                    RxFreePool(pUserName);
                }

                if (pPassword != NULL) {
                    RxFreePool(pPassword);
                }

                if (pUserDomainName != NULL) {
                    RxFreePool(pUserDomainName);
                }

                if (pNetRootName != NULL) {
                    RxFreePool(pNetRootName);
                }
            }
        } else {
            if (Status == STATUS_SUCCESS) {
                SmbCeLog(("CachedSessEntry %lx\n",pSessionEntry));
                SmbLog(LOG,
                       SmbCeFindOrConstructSessionEntry_2,
                       LOGPTR(pSessionEntry));
            }
        }

        if (Status == STATUS_SUCCESS) {
            *pSessionEntryPtr = pSessionEntry;
        }

        SmbCeDereferenceServerEntry(pServerEntry);
    } else {
        Status = STATUS_INVALID_PARAMETER;
    }

    return Status;
}



VOID
SmbCeCompleteSessionEntryInitialization(
    PVOID    pContext,
    NTSTATUS Status,
    BOOLEAN  SecuritySignatureReturned)
/*++

Routine Description:

    This routine is invoked in the context of a worker thread to finalize the
    construction of a session entry

Arguments:

    pContext  - the session entry to be activated

Notes:

    PRE_CONDITION: The session entry must have been referenced to ensure that
    even it has been finalized it will not be deleted.

--*/
{
    PSMBCEDB_SESSION_ENTRY pSessionEntry = (PSMBCEDB_SESSION_ENTRY)pContext;
    PSMBCE_SESSION         pSession = &pSessionEntry->Session;
    PSMBCEDB_SERVER_ENTRY  pServerEntry = pSessionEntry->pServerEntry;
    PSMBCEDB_REQUEST_ENTRY pRequestEntry;
    SMBCEDB_REQUESTS       Requests;
    SMBCEDB_REQUESTS       SecuritySignatureSyncRequests;

    RxDbgTrace( 0, Dbg, ("Session Entry Finalization\n"));
    ASSERT(pSessionEntry->Header.ObjectType == SMBCEDB_OT_SESSION);

    // Acquire the SMBCE resource
    SmbCeAcquireResource();

    // reset the constructor exchange field since the construction is complete
    pSessionEntry->pExchange = NULL;

    //
    SmbCeUnblockSerializedSessionSetupRequests(pSessionEntry);

    // Create a temporary copy of the list that can be traversed after releasing the
    // resource.
    SmbCeTransferRequests(&Requests,&pSessionEntry->Requests);
    SmbCeTransferRequests(&SecuritySignatureSyncRequests,&pServerEntry->SecuritySignatureSyncRequests);
    pServerEntry->ExtSessionSetupInProgress = FALSE;

    if (Status == STATUS_SUCCESS) {
        SmbCeUpdateSessionEntryState(
            pSessionEntry,
            SMBCEDB_ACTIVE);

        if ((pSession->pPassword != NULL || pSession->pUserName != NULL) &&
            !BooleanFlagOn(pSession->Flags,SMBCE_SESSION_FLAGS_NULL_CREDENTIALS)) {
            if (pSessionEntry->DefaultSessionLink.Flink == NULL ) {
                ASSERT( pSessionEntry->DefaultSessionLink.Blink == NULL );
                InsertHeadList(&pServerEntry->Sessions.DefaultSessionList,
                               &pSessionEntry->DefaultSessionLink );
            }
        }

        if (SecuritySignatureReturned &&
            pServerEntry->SecuritySignaturesEnabled == TRUE &&
            pServerEntry->SecuritySignaturesActive == FALSE) {

            if (pSession->Type == EXTENDED_NT_SESSION) {
                SmbInitializeSmbSecuritySignature(&pServerEntry->Server,
                                                  NULL,
                                                  pSession->UserSessionKey,
                                                  pSession->SessionKeyLength);

                if( MRxSmbExtendedSignaturesEnabled )
                {
                    pSession->SessionKeyState = SmbSessionKeyAuthenticating;
                    ClearFlag( pSession->Flags, SMBCE_SESSION_FLAGS_SESSION_KEY_HASHED );
                }
                else
                {
                    pSession->SessionKeyState = SmbSessionKeyAvailible;
                }

                //DbgPrint("MRXSMB: Security Signature is active to W2K server %wZ\n", &pServerEntry->Name);
            } else {
                //DbgPrint("MRXSMB: Security Signature is active to NT4 server %wZ\n", &pServerEntry->Name);
                pSession->SessionKeyState = SmbSessionKeyAvailible;
            }

            // turn on the security signature on the client side
            pServerEntry->SecuritySignaturesActive = TRUE;
            pServerEntry->Server.SmbSecuritySignatureIndex = 2;
        }
        else
        {
            pSession->SessionKeyState = SmbSessionKeyAvailible;
        }
    } else {
        SmbCeUpdateSessionEntryState(
            pSessionEntry,
            SMBCEDB_INVALID);
    }

    pSessionEntry->SessionRecoverInProgress = FALSE;
    pSessionEntry->SessionRecoveryInitiated = FALSE;
    
    RxLog( ( "Completed session initialization %lx",pSessionEntry ) );

    // Release the resource for the session entry
    SmbCeReleaseResource();

    if (!IsListEmpty(&Requests.ListHead)) {
        // Iterate over the list of pending requests and resume all of them
        SmbCeResumeOutstandingRequests(&Requests,Status);
    }

    if (!IsListEmpty(&SecuritySignatureSyncRequests.ListHead)) {
        SmbCeResumeOutstandingRequests(&SecuritySignatureSyncRequests,STATUS_SUCCESS);
    }

    SmbCeDereferenceSessionEntry(pSessionEntry);
}

NTSTATUS
SmbCeGetUserNameAndDomainName(
    PSMBCEDB_SESSION_ENTRY  pSessionEntry,
    PUNICODE_STRING         pUserName,
    PUNICODE_STRING         pUserDomainName)
/*++

Routine Description:

    This routine returns the user name and domain name associated with a session
    in a caller allocated buffer.

Arguments:

    pSessionEntry - the session entry to be dereferenced

    pUserName     - the User name

    pUserDomainName - the user domain name

Return Value:

    STATUS_SUCCESS if successful

--*/
{
    NTSTATUS Status;

    PSMBCE_SESSION  pSession;
    PUNICODE_STRING pSessionUserName,pSessionDomainName;

    PSecurityUserData   pSecurityData;

    PAGED_CODE();

    ASSERT(pSessionEntry != NULL);
    pSession = &pSessionEntry->Session;

    if ((pUserName == NULL) ||
        (pUserDomainName == NULL) ||
        (pUserName->MaximumLength < (UNLEN * sizeof(WCHAR))) ||
        (pUserDomainName->MaximumLength < (DNLEN * sizeof(WCHAR)))) {
        return STATUS_INVALID_PARAMETER;
    }

    Status          = STATUS_SUCCESS;
    pSecurityData   = NULL;

    pSessionUserName   = pSession->pUserName;
    pSessionDomainName = pSession->pUserDomainName;

    try {
        if (pSessionUserName == NULL ||
            pSessionDomainName == NULL) {
            Status = GetSecurityUserInfo(
                         &pSession->LogonId,
                         UNDERSTANDS_LONG_NAMES,
                         &pSecurityData);

            if (NT_SUCCESS(Status)) {
                if (pSessionUserName == NULL) {
                    pSessionUserName   = &(pSecurityData->UserName);
                }

                if (pSessionDomainName == NULL) {
                    pSessionDomainName = &(pSecurityData->LogonDomainName);
                }
            }
        }

        if (NT_SUCCESS(Status)) {
            if (pSessionUserName->Length > pUserName->MaximumLength ||
                pSessionDomainName->Length > pUserDomainName->MaximumLength) {
                Status = STATUS_BUFFER_OVERFLOW;
            }

            pUserName->Length = pSessionUserName->Length;
            RtlCopyMemory(
                pUserName->Buffer,
                pSessionUserName->Buffer,
                pUserName->Length);

            pUserDomainName->Length = pSessionDomainName->Length;
            if (pUserDomainName->Length > 0) {
                RtlCopyMemory(
                    pUserDomainName->Buffer,
                    pSessionDomainName->Buffer,
                    pUserDomainName->Length);
            }
        }
    } finally {
        if (pSecurityData != NULL) {
            LsaFreeReturnBuffer(pSecurityData);
        }
    }

    return Status;
}

VOID
SmbCepDereferenceSessionEntry(
    PSMBCEDB_SESSION_ENTRY pSessionEntry)
/*++

Routine Description:

    This routine dereferences a session entry instance

Arguments:

    pSessionEntry - the session entry to be dereferenced

--*/
{
    if (pSessionEntry != NULL) {
        BOOLEAN fTearDownEntry;
        BOOLEAN fLogOffRequired;

        LONG    FinalRefCount;

        PSMBCEDB_SERVER_ENTRY pServerEntry;

        ASSERT((pSessionEntry->Header.ObjectType == SMBCEDB_OT_SESSION) &&
               (pSessionEntry->Header.SwizzleCount > 0));

        pServerEntry = pSessionEntry->pServerEntry;

        SmbCeAcquireResource();

        FinalRefCount = InterlockedDecrement(&pSessionEntry->Header.SwizzleCount);

        fTearDownEntry = (FinalRefCount == 0);

        if (fTearDownEntry) {
            // A logoff smb needs to be sent if the user id associated with
            // the session is not zero. Note that we cannot rely on the state
            // of the session to indicate this since extended session setups
            // cna be terminated midway through the construction

            SmbCeReferenceServerEntry(pServerEntry);

            if (pSessionEntry->Header.SwizzleCount == 0) {
                if (!FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_LOGGED_OFF)) {
                    SmbCeRemoveSessionEntry(pServerEntry,pSessionEntry);
                }

                SmbCeRemoveDefaultSessionEntry(pSessionEntry);

                if ((pSessionEntry->Session.UserId != (SMB_USER_ID)(SMBCE_SHARE_LEVEL_SERVER_USERID)) &&
                    (pSessionEntry->Session.UserId != 0) &&
                    (pSessionEntry->Header.State == SMBCEDB_ACTIVE) &&
                    !FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_LOGGED_OFF)) {
                    SmbCeReferenceServerEntry(pServerEntry);
                    SmbCeReferenceSessionEntry(pSessionEntry);

                    fLogOffRequired = TRUE;
                } else {
                    fLogOffRequired = FALSE;
                }

                pSessionEntry->Header.State = SMBCEDB_MARKED_FOR_DELETION;
                pSessionEntry->Session.Flags |= SMBCE_SESSION_FLAGS_LOGGED_OFF;
                fTearDownEntry = TRUE;
            } else {
                fTearDownEntry = FALSE;
            }

            SmbCeDereferenceServerEntry(pServerEntry);
        }

        SmbCeReleaseResource();

        if (fTearDownEntry) {
            if (fLogOffRequired) {
                SmbCeLogOff(pServerEntry,pSessionEntry);
                SmbCeDereferenceServerEntry(pServerEntry);
            } else {
                SmbCeTearDownSessionEntry(pSessionEntry);
            }
        }
    }
}

NTSTATUS
MRxSmbLogonSessionTerminationHandler(
    PLUID pLogonId)
/*++

Routine Description:

    This routine issues a log off command to the server on all the sessions
    for the given logon id.

Arguments:

    pLogonId - the logon id of the logon session that was terminated

--*/
{
#if 0
    PSMBCEDB_SERVER_ENTRY  pServerEntry,pNextServerEntry;
    PSMBCEDB_SESSION_ENTRY pSessionEntry,pNextSessionEntry;

    SmbCeAcquireResource();

    pServerEntry = SmbCeGetFirstServerEntry();

    while (pServerEntry != NULL) {
        ASSERT(SmbCeIsResourceOwned());

        SmbCeReferenceServerEntry(pServerEntry);

        pSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
        while (pSessionEntry != NULL) {
            if (RtlEqualLuid(
                    &pSessionEntry->Session.LogonId,
                    pLogonId)) {
                if ((pSessionEntry->Session.UserId != (SMB_USER_ID)(SMBCE_SHARE_LEVEL_SERVER_USERID)) &&
                    (pSessionEntry->Session.UserId != 0) &&
                    !FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_LOGGED_OFF)) {

                    SmbCeRemoveSessionEntry(pServerEntry,pSessionEntry);
                    SmbCeRemoveDefaultSessionEntry(pSessionEntry);

                    pSessionEntry->Header.State = SMBCEDB_MARKED_FOR_DELETION;
                    pSessionEntry->Session.Flags |= SMBCE_SESSION_FLAGS_LOGGED_OFF;

                    SmbCeReferenceSessionEntry(pSessionEntry);

                    SmbCeReleaseResource();

                    if (pSessionEntry->Header.State == SMBCEDB_ACTIVE) {
                        SmbCeLogOff(pServerEntry,pSessionEntry);
                    } else {
                        SmbCeDereferenceSessionEntry(pSessionEntry);
                    }

                    SmbCeAcquireResource();

                    pNextSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pSessionEntry);

                    SmbCeDereferenceSessionEntry(pSessionEntry);

                    pSessionEntry = pNextSessionEntry;
                }
            } else {
                pSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pSessionEntry);
            }
        }

        pNextServerEntry = SmbCeGetNextServerEntry(pServerEntry);

        SmbCeDereferenceServerEntry(pServerEntry);

        pServerEntry = pNextServerEntry;
    }

    SmbCeReleaseResource();
#endif
    return STATUS_SUCCESS;
}

VOID
SmbCeTearDownSessionEntry(
    PSMBCEDB_SESSION_ENTRY pSessionEntry)
/*++

Routine Description:

    This routine tears down a session entry instance

Arguments:

    pSessionEntry - the session entry to be dereferenced

--*/
{
    PAGED_CODE();

    ASSERT((pSessionEntry->Header.SwizzleCount == 0) &&
           (pSessionEntry->Header.State == SMBCEDB_MARKED_FOR_DELETION));

    ASSERT(IsListEmpty(&pSessionEntry->SerializationList));

    SmbCeLog(("TearSessEntry %lx\n",pSessionEntry));
    SmbLog(LOG,
           SmbCeTearDownSessionEntry,
           LOGPTR(pSessionEntry));

    if (pSessionEntry->Session.pUserName != NULL) {
        RxFreePool(pSessionEntry->Session.pUserName);
    }

    if (pSessionEntry->Session.pPassword != NULL) {
        RtlSecureZeroMemory(pSessionEntry->Session.pPassword->Buffer,pSessionEntry->Session.pPassword->Length);
        RxFreePool(pSessionEntry->Session.pPassword);
    }

    if (pSessionEntry->Session.pUserDomainName != NULL) {
        RxFreePool(pSessionEntry->Session.pUserDomainName);
    }

    if (pSessionEntry->Session.TargetInfoMarshalled != NULL) {
        RxFreePool(pSessionEntry->Session.TargetInfoMarshalled);
    }

    if (pSessionEntry->pNetRootName != NULL) {
        RxFreePool(pSessionEntry->pNetRootName);
    }

    UninitializeSecurityContextsForSession(&pSessionEntry->Session);

    SmbMmFreeSessionEntry(pSessionEntry);
}

PSMBCEDB_NET_ROOT_ENTRY
SmbCeFindNetRootEntry(
    PSMBCEDB_SERVER_ENTRY pServerEntry,
    PUNICODE_STRING pServerShare
    )
{
   PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry = NULL;

   ASSERT(SmbCeIsResourceOwned());

   pNetRootEntry = SmbCeGetFirstNetRootEntry(pServerEntry);

    while (pNetRootEntry != NULL) {
        if (RtlCompareUnicodeString(
                pServerShare,
                &pNetRootEntry->Name,
                TRUE) == 0) {
            break;
        }

        pNetRootEntry = SmbCeGetNextNetRootEntry(pServerEntry,pNetRootEntry);

    }

    return pNetRootEntry;
}

NTSTATUS
SmbCeFindOrConstructNetRootEntry(
    IN  PMRX_NET_ROOT pNetRoot,
    OUT PSMBCEDB_NET_ROOT_ENTRY *pNetRootEntryPtr)
/*++

Routine Description:

    This routine opens/creates a net root entry in the connection engine database

Arguments:

    pNetRoot -- the RDBSS net root instance

    pNetRootEntryPtr -- Initialized to the SMBCEDB_NET_ROOT_ENTRY instance if
                        successful

Return Value:

    STATUS_SUCCESS - the construction of the net root instance has been finalized

    Other Status codes correspond to error situations.

Notes:

    This routine assumes that the necesary concurreny control mechanism has already
    been taken.

    On Entry the connection engine resource must have been acquired exclusive and
    ownership remains invariant on exit.

--*/
{
    NTSTATUS Status = STATUS_SUCCESS;

    PSMBCEDB_SERVER_ENTRY   pServerEntry   = NULL;
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry  = NULL;
    PSMBCEDB_SESSION_ENTRY  pSessionEntry  = NULL;

    SMB_USER_ID UserId = 0;

    ASSERT(SmbCeIsResourceOwned());

    *pNetRootEntryPtr = NULL;

    pServerEntry = SmbCeReferenceAssociatedServerEntry(pNetRoot->pSrvCall);

    if (pServerEntry != NULL) {
        // Check if any of the SMBCEDB_NET_ROOT_ENTRY associated with the server
        // can be used. An existing entry is reusable if the names match

        pNetRootEntry = SmbCeGetFirstNetRootEntry(pServerEntry);
        while (pNetRootEntry != NULL) {
            if (RtlCompareUnicodeString(
                    pNetRoot->pNetRootName,
                    &pNetRootEntry->Name,
                    TRUE) == 0) {
                SmbCeLog(("CachedNREntry %lx\n",pNetRootEntry));
                SmbLog(LOG,
                       SmbCeFindOrConstructNetRootEntry_1,
                       LOGPTR(pNetRootEntry));
                break;
            }

            pNetRootEntry = SmbCeGetNextNetRootEntry(pServerEntry,pNetRootEntry);
        }

        if (pNetRootEntry != NULL) {
            SmbCeReferenceNetRootEntry(pNetRootEntry);
        } else {
            pNetRootEntry = (PSMBCEDB_NET_ROOT_ENTRY)SmbMmAllocateObject(SMBCEDB_OT_NETROOT);
            if (pNetRootEntry != NULL) {
                Status = MRxSmbCscInitializeNetRootEntry(pNetRootEntry);

                if (Status != STATUS_SUCCESS) {
                    SmbMmFreeObject(pNetRootEntry);
                } else {
                    pNetRootEntry->Name.Buffer = RxAllocatePoolWithTag(
                                                     PagedPool | POOL_COLD_ALLOCATION,
                                                     pNetRoot->pNetRootName->Length,
                                                     MRXSMB_NETROOT_POOLTAG);

                    if (pNetRootEntry->Name.Buffer != NULL) {
                        SmbCeLog(("NewNetREntry %lx\n",pNetRootEntry));
                        SmbLog(LOG,
                               SmbCeFindOrConstructNetRootEntry_2,
                               LOGPTR(pNetRootEntry));

                        pNetRootEntry->Name.Length = pNetRoot->pNetRootName->Length;
                        pNetRootEntry->Name.MaximumLength = pNetRootEntry->Name.Length;
                        RtlCopyMemory(
                            pNetRootEntry->Name.Buffer,
                            pNetRoot->pNetRootName->Buffer,
                            pNetRootEntry->Name.Length);

                        pNetRootEntry->pServerEntry = pServerEntry;
                        pNetRootEntry->NetRoot.UserId = UserId;
                        pNetRootEntry->NetRoot.NetRootType   = pNetRoot->Type;
                        InitializeListHead(&pNetRootEntry->NetRoot.ClusterSizeSerializationQueue);

                        pNetRootEntry->Header.State = SMBCEDB_ACTIVE;

                        // Init the NetRoot Name Caches.
                        //
                        // The get file attributes name cache tracks the file attributes response
                        // from the last GFA sent to the server for a given file.
                        // NB: There is no struct defined for the extension to the GFA name
                        // cache since the extension is only an SMBPSE_FILEINFO_BUNDLE.
                        //
                        RxNameCacheInitialize(
                            &pNetRootEntry->NameCacheCtlGFABasic,
                            sizeof(FILE_BASIC_INFORMATION),
                            NAME_CACHE_NETROOT_MAX_ENTRIES);

                        RxNameCacheInitialize(
                            &pNetRootEntry->NameCacheCtlGFAStandard,
                            sizeof(FILE_STANDARD_INFORMATION),
                            NAME_CACHE_NETROOT_MAX_ENTRIES);

                        RxNameCacheInitialize(
                            &pNetRootEntry->NameCacheCtlGFAInternal,
                            sizeof(FILE_INTERNAL_INFORMATION),
                            NAME_CACHE_NETROOT_MAX_ENTRIES);

                        //
                        // The file not found name cache just tracks opens on files where the
                        // response was file not found.
                        //
                        RxNameCacheInitialize(
                            &pNetRootEntry->NameCacheCtlFNF,
                            0,
                            NAME_CACHE_NETROOT_MAX_ENTRIES);


                        RxNameCacheInitialize(
                            &pNetRootEntry->NameCacheCtlPartialDir,
                            sizeof (FULL_DIR_CACHE),
                            NAME_CACHE_NETROOT_MAX_ENTRIES);

                        SmbCeReferenceNetRootEntry(pNetRootEntry);
                        SmbCeAddNetRootEntry(pServerEntry,pNetRootEntry);

                        if ( RtlCompareUnicodeString(
                                 pNetRoot->pNetRootName,
                                 &MRxSmbRemoteBootShare,
                                 TRUE
                                 ) == 0 ) {
                            pNetRootEntry->IsRemoteBoot = TRUE;
                        }
                    } else {
                        SmbMmFreeObject(pNetRootEntry);
                        Status = STATUS_INSUFFICIENT_RESOURCES;
                    }
                }
            } else {
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }

        if (Status == STATUS_SUCCESS) {
            ASSERT(pNetRootEntry != NULL);
            *pNetRootEntryPtr = pNetRootEntry;
        }
        SmbCeDereferenceServerEntry(pServerEntry);
    } else {
        Status = STATUS_INVALID_PARAMETER;
    }

    return Status;
}

VOID
SmbCepDereferenceNetRootEntry(
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry,
    PVOID                   FileName,
    ULONG                   FileLine)
/*++

Routine Description:

    This routine dereferences a net root entry instance

Arguments:

    pNetRootEntry - the NEt Root entry to be dereferenced

Notes:

    Disconnects are not required for mailslot servers. They need to be
    sent to File servers only.

--*/
{
    if (pNetRootEntry != NULL) {
        LONG    FinalRefCount;
        BOOLEAN fTearDownEntry;
        BOOLEAN fDisconnectRequired;

        ASSERT((pNetRootEntry->Header.ObjectType == SMBCEDB_OT_NETROOT) &&
               (pNetRootEntry->Header.SwizzleCount > 0));

        SmbCeAcquireResource();

        FinalRefCount = InterlockedDecrement(&pNetRootEntry->Header.SwizzleCount);

        fTearDownEntry = (FinalRefCount == 0);

        if (fTearDownEntry) {

            if (pNetRootEntry->Header.SwizzleCount == 0) {
                PSMBCEDB_SERVER_ENTRY   pServerEntry  = pNetRootEntry->pServerEntry;
                PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext = NULL;

                SmbCeRemoveNetRootEntryLite(pNetRootEntry->pServerEntry,pNetRootEntry);
                pNetRootEntry->Header.State = SMBCEDB_MARKED_FOR_DELETION;
                fTearDownEntry = TRUE;

                pVNetRootContext = SmbCeGetFirstVNetRootContext(&pServerEntry->VNetRootContexts);
                while (pVNetRootContext != NULL) {
                    ASSERT(pVNetRootContext->pNetRootEntry != pNetRootEntry);

                    pVNetRootContext = SmbCeGetNextVNetRootContext(
                                           &pServerEntry->VNetRootContexts,
                                           pVNetRootContext);
                }
            } else {
                fTearDownEntry = FALSE;
            }
        }

        SmbCeReleaseResource();

        if (fTearDownEntry) {
            SmbCeTearDownNetRootEntry(pNetRootEntry);
        }
    }
}

VOID
SmbCeTearDownNetRootEntry(
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry)
/*++

Routine Description:

    This routine tears down a net root entry instance

Arguments:

    pNetRootEntry - the NEt Root entry to be dereferenced

--*/
{
    PAGED_CODE();

    ASSERT((pNetRootEntry->Header.SwizzleCount == 0) &&
           (pNetRootEntry->Header.State == SMBCEDB_MARKED_FOR_DELETION));

    SmbCeLog(("TearNetREntry %lx\n",pNetRootEntry));
    SmbLog(LOG,
           SmbCeTearDownNetRootEntry,
           LOGPTR(pNetRootEntry));

    MRxSmbCscUninitializeNetRootEntry(pNetRootEntry);

    //
    // Free storage associated with all entries in the name caches.
    //
    RxNameCacheFinalize(&pNetRootEntry->NameCacheCtlGFABasic);
    RxNameCacheFinalize(&pNetRootEntry->NameCacheCtlGFAStandard);
    RxNameCacheFinalize(&pNetRootEntry->NameCacheCtlGFAInternal);
    RxNameCacheFinalize(&pNetRootEntry->NameCacheCtlFNF);
    RxNameCacheFinalize(&pNetRootEntry->NameCacheCtlPartialDir);

    if (pNetRootEntry->Name.Buffer != NULL) {
        RxFreePool(pNetRootEntry->Name.Buffer);
        pNetRootEntry->Name.Buffer = NULL;
    }

    if (pNetRootEntry->VolumeInfo != NULL) {
        RxFreePool(pNetRootEntry->VolumeInfo);
        pNetRootEntry->VolumeInfo = NULL;
    }

    SmbMmFreeObject(pNetRootEntry);
}


NTSTATUS
SmbCeUpdateNetRoot(
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry,
    PMRX_NET_ROOT           pNetRoot)
/*++

Routine Description:

    This routine initializes the wrapper data structure corresponding to a
    given net root entry.

Arguments:

    pNetRootEntry - the server entry

Return Value:

    STATUS_SUCCESS if successful

--*/
{
    PAGED_CODE();

    if (pNetRootEntry->NetRoot.NetRootType != NET_ROOT_WILD) {
        pNetRoot->Type = pNetRootEntry->NetRoot.NetRootType;
    }

    switch (pNetRoot->Type) {
    case NET_ROOT_DISK:
        {
            pNetRoot->DeviceType = RxDeviceType(DISK);

            RxInitializeNetRootThrottlingParameters(
                &pNetRoot->DiskParameters.LockThrottlingParameters,
                MRxSmbConfiguration.LockIncrement,
                MRxSmbConfiguration.MaximumLock);
        }
        break;

    case NET_ROOT_PIPE:
        {
            pNetRoot->DeviceType = RxDeviceType(NAMED_PIPE);

            RxInitializeNetRootThrottlingParameters(
                &pNetRoot->NamedPipeParameters.PipeReadThrottlingParameters,
                MRxSmbConfiguration.PipeIncrement,
                MRxSmbConfiguration.PipeMaximum);
        }
        break;
    case NET_ROOT_COMM:
        pNetRoot->DeviceType = RxDeviceType(SERIAL_PORT);
        break;
    case NET_ROOT_PRINT:
        pNetRoot->DeviceType = RxDeviceType(PRINTER);
        break;
    case NET_ROOT_MAILSLOT:
        pNetRoot->DeviceType = RxDeviceType(MAILSLOT);
        break;
    case NET_ROOT_WILD:
        break;
    default:
        ASSERT(!"Valid Net Root Type");
    }

    if (pNetRootEntry->NetRoot.DfsAware) {
        SetFlag(pNetRoot->Flags,NETROOT_FLAG_DFS_AWARE_NETROOT);
    } else {
        ClearFlag(pNetRoot->Flags,NETROOT_FLAG_DFS_AWARE_NETROOT);
    }

    return STATUS_SUCCESS;
}

NTSTATUS
SmbCeProbeServers(
    PVOID    pContext)
/*++

Routine Description:

    This routine probes all the remote servers on which no activity has been
    detected in the recent past.

Notes:

    The current implementation of walking through the list of all servers to
    initiate echo processing will not scale very well for gateway servers. A
    different mechanism needs to be implemented.


--*/
{
    LIST_ENTRY              DiscardedServersList;
    PSMBCEDB_SERVER_ENTRY   pServerEntry;

    PMRXSMB_ECHO_PROBE_SERVICE_CONTEXT pEchoProbeContext;
    PSMBCEDB_SERVER_ENTRY pPreviousServerEntry = NULL;

    pEchoProbeContext = (PMRXSMB_ECHO_PROBE_SERVICE_CONTEXT)pContext;

    InitializeListHead(&DiscardedServersList);

    SmbCeAcquireSpinLock();
    pServerEntry = SmbCeGetFirstServerEntry();

    while (pServerEntry != NULL) {
        BOOLEAN               TearDownTransport = FALSE;

        if ((SmbCeGetServerType(pServerEntry) == SMBCEDB_FILE_SERVER) &&
            ((pServerEntry->Header.State == SMBCEDB_ACTIVE) ||
             (pServerEntry->Header.State == SMBCEDB_CONSTRUCTION_IN_PROGRESS))) {

            // The additional reference is required to keep this server entry
            // as a place marker in the list of server entries.
            // This will be released on resumption of the processinf further
            // down in this routine
            InterlockedIncrement(&pServerEntry->Header.SwizzleCount);
            SmbCeReleaseSpinLock();

            if (pPreviousServerEntry != NULL) {
                SmbCeDereferenceServerEntry(pPreviousServerEntry);
            }

            // For loop back servers we forego the expired exchange detection
            // mechanism. Since the I/O is directed to the same machine this
            // indicates a problem with the local system.

            TearDownTransport = SmbCeDetectExpiredExchanges(pServerEntry);

            if (!TearDownTransport) {
                if ((pServerEntry->Server.SmbsReceivedSinceLastStrobe == 0) &&
                    (pServerEntry->pMidAtlas != NULL) &&
                    (pServerEntry->pMidAtlas->NumberOfMidsInUse > 0)) {
                    if (pServerEntry->Server.EchoProbeState == ECHO_PROBE_IDLE) {
                        NTSTATUS      Status;
                        LARGE_INTEGER CurrentTime,ExpiryTimeInTicks;

                        KeQueryTickCount( &CurrentTime );

                        ExpiryTimeInTicks.QuadPart = (1000 * 1000 * 10) / KeQueryTimeIncrement();

                        ExpiryTimeInTicks.QuadPart = MRxSmbConfiguration.SessionTimeoutInterval * ExpiryTimeInTicks.QuadPart;

                        pServerEntry->Server.EchoExpiryTime.QuadPart = CurrentTime.QuadPart +
                                                                ExpiryTimeInTicks.QuadPart;


                        InterlockedExchange(
                            &pServerEntry->Server.EchoProbeState,
                            ECHO_PROBE_AWAITING_RESPONSE);

                        Status = SmbCeSendEchoProbe(
                                     pServerEntry,
                                     pEchoProbeContext);

                        RxDbgTrace(0,Dbg,("Sending ECHO SMB %lx Status %lx\n",pServerEntry,Status));

                        TearDownTransport = ((Status != STATUS_SUCCESS) &&
                                             (Status != STATUS_PENDING));
                        if( TearDownTransport )
                        {
                            RxLogRetail(( "Echo failed %x (%x)\n", pServerEntry, Status ));
                        }
                    } else if (pServerEntry->Server.EchoProbeState == ECHO_PROBE_AWAITING_RESPONSE) {
                        // Compare the current time with the time at which the echo probe
                        // was sent. If the interval is greater than the response time then
                        // it can be deemed that the echo response is not forthcoming and
                        // the tear down can be initiated.
                        LARGE_INTEGER CurrentTime;

                        KeQueryTickCount( &CurrentTime );

                        if ((pServerEntry->Server.EchoExpiryTime.QuadPart != 0) &&
                            (pServerEntry->Server.EchoExpiryTime.QuadPart < CurrentTime.QuadPart)) {

                            RxLogRetail(( "Echo failed %x (timeout)\n", pServerEntry ));
                            TearDownTransport = TRUE;
                        }
                    }

                    if (TearDownTransport) {
                        RxLog(("Echo Problem for srvr%lx \n",pServerEntry));
                        SmbLog(LOG,
                               SmbCeProbeServers,
                               LOGPTR(pServerEntry)
                               LOGUSTR(pServerEntry->Name));
                    }
                } else {
                    InterlockedExchange(&pServerEntry->Server.SmbsReceivedSinceLastStrobe,0);
                }
            }

            if (TearDownTransport) {
                InterlockedIncrement(&MRxSmbStatistics.HungSessions);
                SmbCeTransportDisconnectIndicated(pServerEntry);
            }

            // reacquire the spin lock to traverse the list.
            SmbCeAcquireSpinLock();

            pPreviousServerEntry = pServerEntry;
            pServerEntry = SmbCeGetNextServerEntry(pPreviousServerEntry);
        } else {
            pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
        }
    }

    SmbCeReleaseSpinLock();

    if (pPreviousServerEntry != NULL) {
        SmbCeDereferenceServerEntry(pPreviousServerEntry);
    }

    return STATUS_SUCCESS;
}

VOID
SmbCeTransportDisconnectIndicated(
    PSMBCEDB_SERVER_ENTRY   pServerEntry)
/*++

Routine Description:

    This routine invalidates a server entry on notification from the underlying transport

Arguments:

    pServerEntry - the server entry to be dereferenced

Notes:

    The server entry and the associated net roots and sessions are marked as invalid. A
    reconnect is facilitated on other requests as and when required. In addition all
    pending requests are resumed with the appropriate error indication.

--*/
{
    NTSTATUS Status;
    BOOLEAN  ShouldResumeRequests = FALSE;
    PSMBCEDB_NET_ROOT_ENTRY   pNetRootEntry;
    PSMBCEDB_SESSION_ENTRY    pSessionEntry;
    PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;

    RxDbgTrace(0,
              Dbg,
              ("SmbCeDbTransportDisconnectIndicated for %lx -- Entry\n",pServerEntry));

    // Acquire the database resource (DPC Level)
    SmbCeAcquireSpinLock();

    if (!pServerEntry->ResumeRequestsInProgress) {
        ShouldResumeRequests = TRUE;
        pServerEntry->ResumeRequestsInProgress = TRUE;

        pServerEntry->ServerStatus = STATUS_CONNECTION_DISCONNECTED;
        pServerEntry->Header.State = SMBCEDB_DESTRUCTION_IN_PROGRESS;
        pServerEntry->SecuritySignaturesActive = FALSE;

        SmbCeReferenceServerEntry(pServerEntry);

        // Increment the associated version count so as to invalidate all existing Fids
        InterlockedIncrement(&pServerEntry->Server.Version);
    }

    // release the database resource (DPC Level)
    SmbCeReleaseSpinLock();

    SmbLog(LOG,
           SmbCeTransportDisconnectIndicated,
           LOGPTR(pServerEntry)
           LOGUSTR(pServerEntry->Name));

    if (ShouldResumeRequests) {
        InitializeListHead(&pServerEntry->WorkQueueItemForResume.List);

        RxPostToWorkerThread(
            MRxSmbDeviceObject,
            CriticalWorkQueue,
            &pServerEntry->WorkQueueItemForResume,
            SmbCeResumeAllOutstandingRequestsOnError,
            pServerEntry);
    }

    RxDbgTrace(0,
              Dbg,
              ("SmbCeTransportDisconnectIndicated -- Exit\n"));
}

VOID
SmbCeHandleTransportInvalidation(
    IN PSMBCE_TRANSPORT  pTransport)
/*++

Routine Description:

    This routine invalidates all servers using a particular transport. This is different from
    a disconnect indication in which one server is invalidated. In this case a transport is being
    removed/invalidated locally and all servers using that transport must be invalidated

Arguments:

    pTransport  - the transport being invalidated

--*/
{
    PSMBCEDB_SERVER_ENTRY pServerEntry;

    SmbCeAcquireSpinLock();

    pServerEntry = SmbCeGetFirstServerEntry();

    while (pServerEntry != NULL) {

        if ((pServerEntry->pTransport != NULL) &&
            (pServerEntry->pTransport->pTransport == pTransport)) {
            pServerEntry->Header.State = SMBCEDB_DESTRUCTION_IN_PROGRESS;

            // The invalidation needs to hold onto an extra reference to avoid
            // race conditions which could lead to premature destruction of
            // this server entry.
            SmbCeReferenceServerEntry(pServerEntry);
        }

        pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
    }

    SmbCeReleaseSpinLock();

    SmbCeAcquireResource();

    pServerEntry = SmbCeGetFirstServerEntry();

    while (pServerEntry != NULL) {
        PSMBCEDB_SERVER_ENTRY pPrevServerEntry;
        BOOLEAN               fDereferencePrevServerEntry = FALSE;

        if ((pServerEntry->pTransport != NULL) &&
            (pServerEntry->pTransport->pTransport == pTransport)) {
            SmbCeReleaseResource();

            SmbCeTransportDisconnectIndicated(pServerEntry);

            SmbCeReferenceServerEntry(pServerEntry);

            // the reference count of Server Entry will be taken away while the transport
            // is torn down, which prevents the server tranports being torn down again at
            // time the server entry being freed.
            SmbCeUninitializeServerTransport(pServerEntry,
                                             SmbCeCompleteUninitializeServerTransport,
                                             pServerEntry);

            SmbCeAcquireResource();

            if (pServerEntry->PreferredTransport != NULL) {
                SmbCeDereferenceTransport(pServerEntry->PreferredTransport);
                pServerEntry->PreferredTransport = NULL;
            }

            fDereferencePrevServerEntry = TRUE;
        }

        pPrevServerEntry = pServerEntry;
        pServerEntry = SmbCeGetNextServerEntry(pServerEntry);

        if (fDereferencePrevServerEntry) {
            SmbCeDereferenceServerEntry(pPrevServerEntry);
        }
    }

    SmbCeReleaseResource();
}

NTSTATUS
SmbCeHoldExchangeForSessionRecovery(
    IN PSMB_EXCHANGE pExchange, 
    PSMBCE_RELEASE_ROUTINE pRoutine
    )
/*++
Routine Description:

   This routine adds the exchange to a list which will resume when session recoovery
   completes..

Arguments:

    OrdinaryExchange

Return Value:

    NTSTATUS - The return status for the operation

Notes:

    IRQL < DISPATCH_LEVEL
    
    This routine takes an extra reference on the exchange so that it will not be finalized.
    When the exchange is 'released', the extra reference will be removed.
    (see SmbCeResumeOutstandingRequests)

--*/

{
    PSMBCEDB_SERVER_ENTRY   pServerEntry;
    PSMBCEDB_SESSION_ENTRY  pSessionEntry;    
    PSMBCEDB_REQUEST_ENTRY  pRequestEntry;
    SMBCEDB_REQUESTS        SecuritySignatureSyncRequests;
    
    NTSTATUS Status = STATUS_SUCCESS;
    
    pServerEntry  = SmbCeGetExchangeServerEntry(pExchange);
    pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
    
    InitializeListHead( &SecuritySignatureSyncRequests.ListHead );
    
    SmbCeAcquireResource();

    //
    // If we are recovering from an expired session, we add the request to a list hanging on the server.
    //
    if( pSessionEntry->SessionRecoveryInitiated ) {

        pRequestEntry = (PSMBCEDB_REQUEST_ENTRY)SmbMmAllocateObject(SMBCEDB_OT_REQUEST);

        if (pRequestEntry != NULL) {

            pRequestEntry->HoldRequest.Type = HOLD_REQUEST;
            pRequestEntry->HoldRequest.pExchange = pExchange;
            pRequestEntry->HoldRequest.ReleaseRoutine = pRoutine;

            SmbCeAddRequestEntry(&pServerEntry->SecuritySignatureSyncRequests,pRequestEntry);
            
            RxLog( ( "Held exchange %x", pExchange ) );

            Status = STATUS_PENDING;

        } else {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    } else {

        //
        // Release the resource and initiate session recovery.
        //
        pSessionEntry->SessionRecoveryInitiated = TRUE;

        SmbCeReleaseResource();

        Status = SmbCeReconnect( SmbCeGetExchangeVNetRoot( pExchange ) );
        
        ASSERT(Status != STATUS_PENDING);

        SmbCeAcquireResource();
        
        pSessionEntry->SessionRecoveryInitiated = FALSE;

        if( !NT_SUCCESS( Status ) ) {

            SmbCeTransferRequests(&SecuritySignatureSyncRequests,&pServerEntry->SecuritySignatureSyncRequests);
        }
    }

    SmbCeReleaseResource();

    //
    // If we were unable to reconnect successfully, we must make sure that any requests
    // added to the list are resumed.
    //
    if (!IsListEmpty(&SecuritySignatureSyncRequests.ListHead)) {
        SmbCeResumeOutstandingRequests(&SecuritySignatureSyncRequests,Status);
    }

    return Status;
}


VOID
SmbCeResumeOutstandingRequests(
    PSMBCEDB_REQUESTS pRequests,
    NTSTATUS          RequestStatus)
/*++

Routine Description:

    This routine resumes the outstanding requests with the appropriate status

Arguments:

    pRequests - the list of requests

    RequestStatus - the resumption status ..

Notes:

    As a side effect the list of requests is torn down.

--*/
{
    NTSTATUS               Status;
    PSMBCEDB_REQUEST_ENTRY pRequestEntry;
    PSMB_EXCHANGE          pExchange;
    // Resume all the outstanding reconnect requests that were held up because an earlier
    // reconnect request was under way.
    // Iterate over the list of pending requests and resume all of them

    pRequestEntry = SmbCeGetFirstRequestEntry(pRequests);

    while (pRequestEntry != NULL) {

        pExchange = pRequestEntry->GenericRequest.pExchange;

        switch(pRequestEntry->GenericRequest.Type) {
        
        case HOLD_REQUEST:

            RxLog( ( "Releasing held exchange %x", pExchange ) );
            pRequestEntry->HoldRequest.ReleaseRoutine( pExchange, pExchange->RxContext );
            break;
        
        default:

            RxDbgTrace(0, Dbg, ("Resuming outstanding reconnect request exchange %lx \n",pExchange));

            pExchange->Status = RequestStatus;
            SmbCeDecrementPendingLocalOperations(pExchange);

            // Resume the exchange.
            if (pRequestEntry->Request.pExchange->pSmbCeSynchronizationEvent == NULL) {

                if (RequestStatus == STATUS_SUCCESS) {
                    Status = SmbCeResumeExchange(pExchange);
                } else {
                    // Invoke the error handler
                    RxDbgTrace( 0, Dbg, ("Resuming exchange%lx with error\n",pRequestEntry->Request.pExchange));
                    SmbCeFinalizeExchange(pExchange);
                }
            } else {
                KeSetEvent(
                    pRequestEntry->Request.pExchange->pSmbCeSynchronizationEvent,
                    0,
                    FALSE);
            }

        }

        // Delete the request entry
        SmbCeRemoveRequestEntryLite(pRequests,pRequestEntry);

        // Tear down the continuation entry
        SmbCeTearDownRequestEntry(pRequestEntry);

        // Skip to the next one.
        pRequestEntry = SmbCeGetFirstRequestEntry(pRequests);
    }
}

VOID
SmbCeResumeAllOutstandingRequestsOnError(
    PSMBCEDB_SERVER_ENTRY pServerEntry)
/*++

Routine Description:

    This routine handles the resumption of all outstanding requests on an error

Arguments:

    pServerEntry  - the Server entry which is being classified as disconnected
Notes:

    This routine requires the caller to have obtained a reference on the corresponding
    server entry. This is required because invocation of this routine can be posted
    which implies that a reference is required to avoid premature destruction of
    the associated server entry.

--*/
{
    PSMBCEDB_NET_ROOT_ENTRY   pNetRootEntry;
    PSMBCEDB_SESSION_ENTRY    pSessionEntry;
    PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;

    SMBCEDB_REQUESTS       Requests;
    SMBCEDB_REQUESTS       MidRequests;
    SMBCEDB_REQUESTS       SecuritySignatureSyncRequests;

    PSMBCEDB_REQUEST_ENTRY pRequestEntry;
    PMID_ATLAS             pMidAtlas;
    PSMB_EXCHANGE          pNegotiateExchange = NULL;
    LIST_ENTRY             ExpiredExchanges;

    //DbgPrint("SmbCeResumeAllOutstandingRequestsOnError: Invoked \n");
    InitializeListHead(&ExpiredExchanges);
    InitializeListHead(&Requests.ListHead);

    SmbCeAcquireResource();
    SmbCeAcquireSpinLock();

    if (pServerEntry->Header.State != SMBCEDB_DESTRUCTION_IN_PROGRESS) {
        SmbCeReleaseSpinLock();
        SmbCeReleaseResource();

        SmbCeDereferenceServerEntry(pServerEntry);

        return;
    }

    if (pServerEntry->pNegotiateExchange != NULL) {
        if (pServerEntry->pNegotiateExchange->ReceivePendingOperations > 0) {
            pNegotiateExchange = SmbResetServerEntryNegotiateExchange(pServerEntry);
        }
    }

    // Create a temporary copy of the list that can be traversed after releasing the
    // resource.

    // Copy all the MID assignment requests pending.
    SmbCeTransferRequests(&MidRequests,&pServerEntry->MidAssignmentRequests);

    // Weed out all the reconnect requests so that they can be resumed
    pRequestEntry = SmbCeGetFirstRequestEntry(&pServerEntry->OutstandingRequests);
    while (pRequestEntry != NULL) {
        if (pRequestEntry->GenericRequest.Type == RECONNECT_REQUEST) {
            PSMBCEDB_REQUEST_ENTRY pTempRequestEntry;

            pTempRequestEntry = pRequestEntry;
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->OutstandingRequests,pRequestEntry);

            SmbCeRemoveRequestEntryLite(&pServerEntry->OutstandingRequests,pTempRequestEntry);
            SmbCeAddRequestEntryLite(&Requests,pTempRequestEntry);
        } else {
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->OutstandingRequests,pRequestEntry);
        }
    }

    // The exchanges that have valid MID's assigned to them fall into two categories
    // Those that have a ReceivePendingOperation count of > 0 and those that have
    // a ReceievePendingOperation count of zero. For all the exchanges that belong
    // to the first category the finalize ( quiescent state ) routine must be invoked
    // since no receives will be forthcoming. For those exchanges that are in the
    // second category it is sufficient to mark the MID as being invalid. The
    // finalization( quiescent state ) routine is going to be called on completion
    // of other opertaions in this case.

    pMidAtlas = pServerEntry->pMidAtlas;
    if (pMidAtlas != NULL) {
        PVOID  pContext;
        USHORT MidsProcessed = 0;
        USHORT NumberOfMidsInUse;
        USHORT MaximumNumberOfMids;
        USHORT NextMid = 0;

        MaximumNumberOfMids = FsRtlGetMaximumNumberOfMids(pMidAtlas);
        NumberOfMidsInUse = FsRtlGetNumberOfMidsInUse(pMidAtlas);

        while ((NumberOfMidsInUse > MidsProcessed) &&
               (NextMid < MaximumNumberOfMids)) {
            pContext = FsRtlMapMidToContext(pMidAtlas,NextMid);

            if (pContext != NULL) {
                PSMB_EXCHANGE pExchange = (PSMB_EXCHANGE)pContext;

                pExchange->SmbCeFlags &= ~SMBCE_EXCHANGE_MID_VALID;

                pExchange->Status      = STATUS_CONNECTION_DISCONNECTED;
                pExchange->SmbStatus   = STATUS_CONNECTION_DISCONNECTED;

                if ((pExchange->ReceivePendingOperations > 0) &&
                    ((pExchange->LocalPendingOperations > 0) ||
                    (pExchange->CopyDataPendingOperations > 0) ||
                    (pExchange->SendCompletePendingOperations > 0))) {
                    // There are other pending operations. By merely setting the
                    // pending receive operations to zero, the finalization of
                    // the exchange is ensured.
                    pExchange->ReceivePendingOperations = 0;
                }

                if (pExchange->ReceivePendingOperations ==  0) {
                    FsRtlMapAndDissociateMidFromContext(pMidAtlas,NextMid,&pContext);
                }

                MidsProcessed++;
            }

            NextMid++;
        }
    }

    // Transfer all the active exchanges to expired exchanges. This will prevent these
    // exchanges from being considered for time outs again.
    if (!IsListEmpty(&pServerEntry->ActiveExchanges)) {
        pServerEntry->ExpiredExchanges.Blink->Flink = pServerEntry->ActiveExchanges.Flink;
        pServerEntry->ActiveExchanges.Flink->Blink = pServerEntry->ExpiredExchanges.Blink;

        pServerEntry->ExpiredExchanges.Blink = pServerEntry->ActiveExchanges.Blink;
        pServerEntry->ActiveExchanges.Blink->Flink = &pServerEntry->ExpiredExchanges;

        InitializeListHead(&pServerEntry->ActiveExchanges);
    }

    // Splice together all the requests that are awaiting the completion of the
    // session/netroot construction.

    pSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
    while (pSessionEntry != NULL) {
        if (pSessionEntry->Header.State == SMBCEDB_ACTIVE) {
            pSessionEntry->Header.State = SMBCEDB_INVALID;
        }

        if (!IsListEmpty(&pSessionEntry->Requests.ListHead)) {
            Requests.ListHead.Blink->Flink = pSessionEntry->Requests.ListHead.Flink;
            pSessionEntry->Requests.ListHead.Flink->Blink = Requests.ListHead.Blink;

            Requests.ListHead.Blink = pSessionEntry->Requests.ListHead.Blink;
            pSessionEntry->Requests.ListHead.Blink->Flink = &Requests.ListHead;

            SmbCeInitializeRequests(&pSessionEntry->Requests);
        }

        pSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pSessionEntry);
    }

    pNetRootEntry = SmbCeGetFirstNetRootEntry(pServerEntry);
    while (pNetRootEntry != NULL) {
        if (pNetRootEntry->Header.State == SMBCEDB_ACTIVE) {
            pNetRootEntry->Header.State = SMBCEDB_INVALID;
        }

        if (!IsListEmpty(&pNetRootEntry->Requests.ListHead)) {
            Requests.ListHead.Blink->Flink = pNetRootEntry->Requests.ListHead.Flink;
            pNetRootEntry->Requests.ListHead.Flink->Blink = Requests.ListHead.Blink;

            Requests.ListHead.Blink = pNetRootEntry->Requests.ListHead.Blink;
            pNetRootEntry->Requests.ListHead.Blink->Flink = &Requests.ListHead;

            SmbCeInitializeRequests(&pNetRootEntry->Requests);
        }

        pNetRootEntry = SmbCeGetNextNetRootEntry(pServerEntry,pNetRootEntry);
    }

    pVNetRootContext = SmbCeGetFirstVNetRootContext(&pServerEntry->VNetRootContexts);
    while (pVNetRootContext != NULL) {
        pVNetRootContext->Header.State = SMBCEDB_INVALID;
        ClearFlag(
            pVNetRootContext->Flags,
            SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);

        pVNetRootContext->TreeId = 0;

        if (!IsListEmpty(&pVNetRootContext->Requests.ListHead)) {
            Requests.ListHead.Blink->Flink = pVNetRootContext->Requests.ListHead.Flink;
            pVNetRootContext->Requests.ListHead.Flink->Blink = Requests.ListHead.Blink;

            Requests.ListHead.Blink = pVNetRootContext->Requests.ListHead.Blink;
            pVNetRootContext->Requests.ListHead.Blink->Flink = &Requests.ListHead;

            SmbCeInitializeRequests(&pVNetRootContext->Requests);
        }

        pVNetRootContext = SmbCeGetNextVNetRootContext(
                               &pServerEntry->VNetRootContexts,
                               pVNetRootContext);
    }

    pVNetRootContext = SmbCeGetFirstVNetRootContext(&MRxSmbScavengerServiceContext.VNetRootContexts);
    while (pVNetRootContext != NULL &&
           pVNetRootContext->pServerEntry == pServerEntry) {
        // prevent the VNetRootContexts on the scavenger list from being reused
        pVNetRootContext->Header.State = SMBCEDB_INVALID;
        ClearFlag(
            pVNetRootContext->Flags,
            SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);

        pVNetRootContext->TreeId = 0;

        pVNetRootContext = SmbCeGetNextVNetRootContext(
                               &MRxSmbScavengerServiceContext.VNetRootContexts,
                               pVNetRootContext);
    }

    pServerEntry->pMidAtlas          = NULL;

    if (pServerEntry->NegotiateInProgress) {
        pServerEntry->Header.State = SMBCEDB_CONSTRUCTION_IN_PROGRESS;
    } else {
        pServerEntry->Header.State = SMBCEDB_INVALID;
    }

    pServerEntry->ResumeRequestsInProgress = FALSE;

    //
    // Remove all entries from the SecuritySignatureSyncRequests to a private list.
    //

    SmbCeTransferRequests(&SecuritySignatureSyncRequests,&pServerEntry->SecuritySignatureSyncRequests);

    SmbCeReleaseSpinLock();

    if (IoGetCurrentProcess() == RxGetRDBSSProcess()) {
        SmbCeInitiateDisconnect(pServerEntry);
    }

    SmbCeReleaseResource();

    //DbgPrint("SmbCeResumeAllOutstandingRequestsOnError: Processing outsanding request \n");
    SmbCeResumeOutstandingRequests(&Requests,STATUS_CONNECTION_DISCONNECTED);

    //DbgPrint("SmbCeResumeAllOutstandingRequestsOnError: Processing MID request \n");
    SmbCeResumeDiscardedMidAssignmentRequests(
        &MidRequests,
        STATUS_CONNECTION_DISCONNECTED);

    //
    // Resume all the security signature sync requests...
    //
    if (!IsListEmpty(&SecuritySignatureSyncRequests.ListHead)) {

        SmbCeResumeOutstandingRequests(&SecuritySignatureSyncRequests,STATUS_SUCCESS);
    }
    
    
    // Resume all the outstanding requests with the error indication
    // The FsRtlDestroyMidAtlas destroys the Mid atlas and at the same
    // time invokes the specified routine on each valid context.
    if (pMidAtlas != NULL) {
        FsRtlDestroyMidAtlas(pMidAtlas,SmbCeFinalizeExchangeOnDisconnect);
    }

    if (pNegotiateExchange != NULL) {
        pNegotiateExchange->Status    = STATUS_CONNECTION_DISCONNECTED;
        pNegotiateExchange->SmbStatus = STATUS_CONNECTION_DISCONNECTED;
        pNegotiateExchange->ReceivePendingOperations = 0;

        SmbCeDecrementPendingLocalOperationsAndFinalize(pNegotiateExchange);
    }

    // The remaining ECHO exchanges on the expired exchanges list in the server entry
    // needs to be finalized as well.

    SmbCeAcquireResource();
    SmbCeAcquireSpinLock();

    if (!IsListEmpty(&pServerEntry->ExpiredExchanges)) {
        PLIST_ENTRY pListEntry;
        PSMB_EXCHANGE pExchange;

        pListEntry = pServerEntry->ExpiredExchanges.Flink;

        while (pListEntry != &pServerEntry->ExpiredExchanges) {
            PLIST_ENTRY pNextListEntry = pListEntry->Flink;

            pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);
            if ((pExchange->Mid == SMBCE_ECHO_PROBE_MID) &&
                !FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED) &&
                ((pExchange->ReceivePendingOperations > 0) ||
                 (pExchange->LocalPendingOperations > 0) ||
                 (pExchange->CopyDataPendingOperations > 0) ||
                 (pExchange->SendCompletePendingOperations > 0))) {
                RemoveEntryList(&pExchange->ExchangeList);
                InsertTailList(&ExpiredExchanges,&pExchange->ExchangeList);
                InterlockedIncrement(&pExchange->LocalPendingOperations);
            }

            pListEntry = pNextListEntry;
        }
    }

    SmbCeReleaseSpinLock();
    SmbCeReleaseResource();

    while (!IsListEmpty(&ExpiredExchanges)) {
        PLIST_ENTRY   pListEntry;
        PSMB_EXCHANGE pExchange;

        pListEntry = ExpiredExchanges.Flink;
        RemoveHeadList(&ExpiredExchanges);

        pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);
        InitializeListHead(&pExchange->ExchangeList);

        RxLog(("Finalizing scavenged exchange %lx Type %ld\n",pExchange,pExchange->Type));
        SmbLog(LOG,
               SmbCeResumeAllOutstandingRequestsOnError,
               LOGPTR(pExchange)
               LOGUCHAR(pExchange->Type));
        pExchange->Status      = STATUS_CONNECTION_DISCONNECTED;
        pExchange->SmbStatus   = STATUS_CONNECTION_DISCONNECTED;
        pExchange->ReceivePendingOperations = 0;

        SmbCeDecrementPendingLocalOperationsAndFinalize(pExchange);
    }

    //DbgPrint("SmbCeResumeAllOutstandingRequestsOnError: Exit \n");
    SmbCeDereferenceServerEntry(pServerEntry);
}

VOID
SmbCeFinalizeAllExchangesForNetRoot(
    PMRX_NET_ROOT pNetRoot)
/*++

Routine Description:

    This routine handles the resumption of all outstanding requests on a forced
    finalization of a connection

Arguments:

    pNetRoot - the NetRoot which is being fianlized forcibly

Notes:

--*/
{
    PMRX_SRV_CALL         pSrvCall;
    PSMBCEDB_SERVER_ENTRY pServerEntry;

    SMBCEDB_REQUESTS       Requests;
    LIST_ENTRY             ExpiredExchanges;

    PSMB_EXCHANGE pExchange;
    PSMBCEDB_REQUEST_ENTRY pRequestEntry;
    PLIST_ENTRY            pListEntry;

    pSrvCall = pNetRoot->pSrvCall;

    pServerEntry = SmbCeGetAssociatedServerEntry(pSrvCall);

    InitializeListHead(&Requests.ListHead);
    InitializeListHead(&ExpiredExchanges);

    SmbCeAcquireSpinLock();

    // Walk through the list of active exchanges, and the pending requests to
    // weed out the exchanges for the given VNET_ROOT.

    pRequestEntry = SmbCeGetFirstRequestEntry(&pServerEntry->OutstandingRequests);
    while (pRequestEntry != NULL) {
        pExchange = pRequestEntry->GenericRequest.pExchange;

        if ((pRequestEntry->GenericRequest.Type == RECONNECT_REQUEST) &&
            (pExchange->SmbCeContext.pVNetRoot != NULL) &&
            (pExchange->SmbCeContext.pVNetRoot->pNetRoot == pNetRoot)) {
            PSMBCEDB_REQUEST_ENTRY pTempRequestEntry;

            pTempRequestEntry = pRequestEntry;
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->OutstandingRequests,pRequestEntry);

            SmbCeRemoveRequestEntryLite(&pServerEntry->OutstandingRequests,pTempRequestEntry);
            SmbCeAddRequestEntryLite(&Requests,pTempRequestEntry);
        } else {
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->OutstandingRequests,pRequestEntry);
        }
    }

    pRequestEntry = SmbCeGetFirstRequestEntry(&pServerEntry->MidAssignmentRequests);
    while (pRequestEntry != NULL) {
        pExchange = pRequestEntry->GenericRequest.pExchange;

        ASSERT(pRequestEntry->GenericRequest.Type == ACQUIRE_MID_REQUEST);

        if ((pRequestEntry->GenericRequest.Type == ACQUIRE_MID_REQUEST) &&
            (pExchange->SmbCeContext.pVNetRoot != NULL) &&
            (pExchange->SmbCeContext.pVNetRoot->pNetRoot == pNetRoot)) {

            PSMBCEDB_REQUEST_ENTRY pTempRequestEntry;

            pTempRequestEntry = pRequestEntry;
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->MidAssignmentRequests,pRequestEntry);

            SmbCeRemoveRequestEntryLite(&pServerEntry->MidAssignmentRequests,pTempRequestEntry);

            // Signal the waiter for resumption
            pTempRequestEntry->MidRequest.pResumptionContext->Status = STATUS_CONNECTION_DISCONNECTED;
            SmbCeResume(pTempRequestEntry->MidRequest.pResumptionContext);

            SmbCeTearDownRequestEntry(pTempRequestEntry);
        } else {
            pRequestEntry = SmbCeGetNextRequestEntry(&pServerEntry->MidAssignmentRequests,pRequestEntry);
        }
    }

    pListEntry = pServerEntry->ActiveExchanges.Flink;

    while (pListEntry != &pServerEntry->ActiveExchanges) {
        PLIST_ENTRY pNextListEntry = pListEntry->Flink;

        pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);

        if ((pExchange->SmbCeContext.pVNetRoot != NULL) &&
            (pExchange->SmbCeContext.pVNetRoot->pNetRoot == pNetRoot)) {


            if (!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED)) {
                if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_MID_VALID) {
                    NTSTATUS LocalStatus;

                    LocalStatus = SmbCepDiscardMidAssociatedWithExchange(
                                      pExchange);

                    ASSERT(LocalStatus == STATUS_SUCCESS);
                }

                if ((pExchange->ReceivePendingOperations > 0) ||
                    (pExchange->LocalPendingOperations > 0) ||
                    (pExchange->CopyDataPendingOperations > 0) ||
                    (pExchange->SendCompletePendingOperations > 0)) {

                    RemoveEntryList(&pExchange->ExchangeList);
                    InsertTailList(&ExpiredExchanges,&pExchange->ExchangeList);
                    InterlockedIncrement(&pExchange->LocalPendingOperations);
                }
            }
        }

        pListEntry = pNextListEntry;
    }

    SmbCeReleaseSpinLock();

    while (!IsListEmpty(&ExpiredExchanges)) {
        PLIST_ENTRY   pListEntry;
        PSMB_EXCHANGE pExchange;

        pListEntry = ExpiredExchanges.Flink;
        RemoveHeadList(&ExpiredExchanges);

        pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);
        InitializeListHead(&pExchange->ExchangeList);

        RxLog(("Finalizing scavenged exchange %lx Type %ld\n",pExchange,pExchange->Type));
        SmbLog(LOG,
               SmbCeFinalizeAllExchangesForNetRoot,
               LOGPTR(pExchange)
               LOGUCHAR(pExchange->Type));

        pExchange->Status      = STATUS_CONNECTION_DISCONNECTED;
        pExchange->SmbStatus   = STATUS_CONNECTION_DISCONNECTED;
        pExchange->ReceivePendingOperations = 0;
        SmbCeDecrementPendingLocalOperationsAndFinalize(pExchange);
    }

    SmbCeResumeOutstandingRequests(&Requests,STATUS_CONNECTION_DISCONNECTED);
}

VOID
SmbCeTearDownRequestEntry(
    PSMBCEDB_REQUEST_ENTRY  pRequestEntry)
/*++

Routine Description:

    This routine tears down a request entry

Arguments:

    pRequestEntry - the request entry to be torn down

Notes:

--*/
{
    SmbMmFreeObject(pRequestEntry);
}

//
// The connection engine database initializtion/tear down routines
//

extern NTSTATUS
SmbMmInit();

extern VOID
SmbMmTearDown();

KIRQL           s_SmbCeDbSpinLockSavedIrql;
KSPIN_LOCK      s_SmbCeDbSpinLock;
ERESOURCE       s_SmbCeDbResource;
ERESOURCE       s_SmbSecuritySignatureResource;
SMBCEDB_SERVERS s_DbServers;
BOOLEAN         s_SmbCeDbSpinLockAcquired;

NTSTATUS
SmbCeDbInit()
/*++

Routine Description:

    This routine initializes the SMBCe database

Notes:

--*/
{
    NTSTATUS Status;

    PAGED_CODE();

    // Initialize the lists associated with various database entities
    InitializeListHead(&s_DbServers.ListHead);

    // Initialize the resource associated with the database.
    KeInitializeSpinLock(&s_SmbCeDbSpinLock );
    ExInitializeResource(&s_SmbCeDbResource);
    ExInitializeResource(&s_SmbSecuritySignatureResource);
    s_SmbCeDbSpinLockAcquired = FALSE;

    MRxSmbInitializeSmbCe();

    // Initialize the memory management data structures.
    Status = SmbMmInit();

    return Status;
}

VOID
SmbCeDbTearDown()
/*++

Routine Description:

    This routine tears down the SMB connection engine database

Notes:

--*/
{
    // Walk through the list of servers and tear them down.
    PSMBCEDB_SERVER_ENTRY pServerEntry = NULL;
    KEVENT ServerEntryTearDownEvent;
    BOOLEAN NeedToWait = FALSE;

    KeInitializeEvent(
        &ServerEntryTearDownEvent,
        NotificationEvent,
        FALSE);

    SmbCeStartStopContext.pServerEntryTearDownEvent = &ServerEntryTearDownEvent;

    // The CSC code obtains references on all the servers that are operating in
    // disconnected mode. Force it to release the references since we are shutting
    // down.
    CscTransitionServerToOnline(0);

    SmbCeAcquireResource();
    SmbCeAcquireSpinLock();

    pServerEntry = SmbCeGetFirstServerEntry();

    if (pServerEntry != NULL) {
        SmbCeReferenceServerEntry(pServerEntry);
        NeedToWait = TRUE;
    }

    while (pServerEntry != NULL) {
        PSMBCEDB_SERVER_ENTRY pTempServerEntry;

        pTempServerEntry = pServerEntry;
        pServerEntry = SmbCeGetNextServerEntry(pServerEntry);

        if (pServerEntry != NULL) {
            SmbCeReferenceServerEntry(pServerEntry);
        }

        SmbCeReleaseSpinLock();
        SmbCeReleaseResource();

        pTempServerEntry->Header.State = SMBCEDB_DESTRUCTION_IN_PROGRESS;
        pTempServerEntry->ServerStatus = RX_MAP_STATUS(REDIRECTOR_PAUSED);
        SmbCeResumeAllOutstandingRequestsOnError(pTempServerEntry);

        SmbCeAcquireResource();
        SmbCeAcquireSpinLock();
    }

    SmbCeReleaseSpinLock();
    SmbCeReleaseResource();

    MRxSmbUninitializeTransport();
    MRxSmbTearDownSmbCe();

    if (NeedToWait) {
        KeWaitForSingleObject(
            &ServerEntryTearDownEvent,
            Executive,
            KernelMode,
            FALSE,
            NULL);
    }

    // Tear down the connection engine memory management data structures.
    SmbMmTearDown();
}

NTSTATUS
FindServerEntryFromCompleteUNCPath(
    USHORT  *lpuServerShareName,
    PSMBCEDB_SERVER_ENTRY *ppServerEntry
)
/*++

Routine Description:

    Given a UNC path of the form \\server\share, this routine looks up the redir
    in-memory data structures to locate such s SMBCEDB_SERVER_ENTRY for the server

Arguments:

    lpuServerShareName  \\server\share

    ppServerEntry      Contains the server entry if successful

Notes:

    The server entry is refcounted, hence the caller must dereference it after use by
    calling SmbCeDereferenceServerEntry

--*/
{

    UNICODE_STRING unistrServerName;
    USHORT  *lpuT = lpuServerShareName;
    DWORD   dwlenServerShare, dwlenServer=0;

    if ((*lpuT++ != (USHORT)'\\') || (*lpuT++ != (USHORT)'\\'))
    {
        return STATUS_INVALID_PARAMETER;
    }


    for (dwlenServerShare = 1; *lpuT; lpuT++, dwlenServerShare++)
    {
        if (*lpuT == (USHORT)'\\')
        {
            if (dwlenServer)
            {
                break;
            }
            else
            {
                dwlenServer = dwlenServerShare; // length of the \server part
            }
        }
    }

    unistrServerName.Length = unistrServerName.MaximumLength = (USHORT)(dwlenServer * sizeof(USHORT));
    unistrServerName.Buffer = lpuServerShareName+1;

    SmbCeAcquireResource();

    try
    {
        *ppServerEntry = SmbCeFindServerEntry(&unistrServerName, SMBCEDB_FILE_SERVER, NULL);

        if (!*ppServerEntry)
        {
            *ppServerEntry = SmbCeFindDfsServerEntry(&unistrServerName, SMBCEDB_FILE_SERVER);
        }
    }
    except(EXCEPTION_EXECUTE_HANDLER)
    {
        SmbCeReleaseResource();
        return STATUS_UNSUCCESSFUL;
    }

    SmbCeReleaseResource();

    if (*ppServerEntry)
    {
        return STATUS_SUCCESS;
    }

    return STATUS_UNSUCCESSFUL;
}

NTSTATUS
FindNetRootEntryFromCompleteUNCPath(
    USHORT  *lpuServerShareName,
    PSMBCEDB_NET_ROOT_ENTRY *ppNetRootEntry
)
/*++

Routine Description:

    Given a UNC path of the form \\server\share, this routine looks up the redir
    in-memory data structures to locate such a NETROOT

Arguments:

    lpuServerShareName  \\server\share

    ppNetRootEntry      Contains the netroot entry if successful.

Notes:

    The netroot entry is refcounted, hence the caller must dereference it after use by
    calling SmbCeDereferenceNetRootEntry

--*/
{

    PSMBCEDB_SERVER_ENTRY pServerEntry = NULL;
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry = NULL;
    UNICODE_STRING unistrServerName, unistrServerShare;
    USHORT  *lpuT = lpuServerShareName, *lpuDfsShare=NULL, *lpuSav;
    DWORD   dwlenServerShare, dwlenServer=0;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;

    if ((*lpuT++ != (USHORT)'\\') || (*lpuT++ != (USHORT)'\\'))
    {
        return STATUS_INVALID_PARAMETER;
    }

    for (dwlenServerShare = 1; *lpuT; lpuT++, dwlenServerShare++)
    {
        if (*lpuT == (USHORT)'\\')
        {
            if (dwlenServer)
            {
                break;
            }
            else
            {
                dwlenServer = dwlenServerShare; // length of the \server part
            }
        }
    }

    ASSERT((dwlenServerShare>dwlenServer));

    unistrServerName.Length = unistrServerName.MaximumLength = (USHORT)(dwlenServer * sizeof(USHORT));
    unistrServerName.Buffer = lpuServerShareName+1;

    unistrServerShare.Length = unistrServerShare.MaximumLength =  (USHORT)(dwlenServerShare * sizeof(USHORT));
    unistrServerShare.Buffer = lpuServerShareName+1;

    SmbCeAcquireResource();

    try
    {
        // lookup in standard places

        pServerEntry = SmbCeFindServerEntry(&unistrServerName, SMBCEDB_FILE_SERVER, NULL);
        if (pServerEntry)
        {
            pNetRootEntry = SmbCeFindNetRootEntry(pServerEntry, &unistrServerShare);
            SmbCeDereferenceServerEntry(pServerEntry);

            if (pNetRootEntry)
            {
                goto bailout;
            }
        }

        // now look to see if a DFS alternate has this share

        pServerEntry = SmbCeGetFirstServerEntry();

        while (pServerEntry != NULL) {

            DWORD   dwAllocationSize = 0;

            if ((RtlCompareUnicodeString(
                        &unistrServerName,
                        &pServerEntry->DfsRootName,
                        TRUE) == 0)) {

                dwAllocationSize =  pServerEntry->Name.MaximumLength+
                                    (dwlenServerShare-dwlenServer+2) * sizeof(USHORT);

                lpuDfsShare =  RxAllocatePoolWithTag(
                                    NonPagedPool,
                                    dwAllocationSize,
                                    MRXSMB_SESSION_POOLTAG);
                if (!lpuDfsShare)
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto bailout;
                }

                ASSERT(dwAllocationSize > pServerEntry->Name.MaximumLength);

                unistrServerShare.Length = (USHORT)(pServerEntry->Name.Length + (dwlenServerShare-dwlenServer) * sizeof(USHORT));
                unistrServerShare.MaximumLength = (USHORT)(pServerEntry->Name.MaximumLength+
                                                      (dwlenServerShare-dwlenServer+2) * sizeof(USHORT));

                memcpy(lpuDfsShare, pServerEntry->Name.Buffer, pServerEntry->Name.Length);
                memcpy(&lpuDfsShare[pServerEntry->Name.Length/sizeof(USHORT)],
                       &(unistrServerShare.Buffer[dwlenServer]),
                        (dwlenServerShare-dwlenServer) * sizeof(USHORT));

                lpuSav = unistrServerShare.Buffer;
                unistrServerShare.Buffer = lpuDfsShare;

                pNetRootEntry = SmbCeFindNetRootEntry(pServerEntry, &unistrServerShare);

                unistrServerShare.Buffer = lpuSav;

                RxFreePool(lpuDfsShare);

                // stop if we found it
                if (pNetRootEntry)
                {
                    break;
                }
            }

            pServerEntry = SmbCeGetNextServerEntry(pServerEntry);
        }

    }
    except(EXCEPTION_EXECUTE_HANDLER)
    {
        goto bailout;
    }

bailout:
    if (pNetRootEntry)
    {
        SmbCeReferenceNetRootEntry(pNetRootEntry);
        *ppNetRootEntry = pNetRootEntry;
        Status = STATUS_SUCCESS;
    }

    SmbCeReleaseResource();

    return Status;
}

NTSTATUS
MRxSmbCscCachingBitsFromCompleteUNCPath(
    PWSTR   lpServerShare,
    ULONG   *lpulBits
    )
/*++

Routine Description:

    Given a UNC path of the form \\server\share, this routine checks to see whether
    such a NETROOT exists, and if so, it gets the SMB flags for that entry

Arguments:

    lpuServerShareName  \\server\share

    lpulBits            SMB bits

Notes:

--*/
{
    PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry=NULL;
    NTSTATUS Status;

    if ((Status = FindNetRootEntryFromCompleteUNCPath(lpServerShare, &pNetRootEntry)) == STATUS_SUCCESS)
    {
        // convert these bits to those defined in csc\inc\shdcom.h
        *lpulBits = (pNetRootEntry->NetRoot.CscFlags << 4);

        SmbCeDereferenceNetRootEntry(pNetRootEntry);
    }

    return Status;
}

NTSTATUS
MRxSmbCscServerStateFromCompleteUNCPath(
    PWSTR   lpServerShare,
    BOOL    *lpfOnline,
    BOOL    *lpfPinnedOffline
    )
{
    PSMBCEDB_SERVER_ENTRY   pServerEntry = NULL;
    NTSTATUS Status;

    if ((Status = FindServerEntryFromCompleteUNCPath(lpServerShare, &pServerEntry)) == STATUS_SUCCESS)
    {
        *lpfOnline = (pServerEntry->Server.CscState == ServerCscShadowing);
        *lpfPinnedOffline = (pServerEntry->Server.IsPinnedOffline == TRUE);

        SmbCeDereferenceServerEntry(pServerEntry);
    }

    return Status;

}

NTSTATUS
MRxSmbCscIsLoopbackServer(
    PWSTR   lpServerShare,
    BOOL    *lpfIsLoopBack)
{
    PSMBCEDB_SERVER_ENTRY   pServerEntry = NULL;
    NTSTATUS Status;

    if ((Status = FindServerEntryFromCompleteUNCPath(lpServerShare, &pServerEntry)) == STATUS_SUCCESS)
    {
       *lpfIsLoopBack = pServerEntry->Server.IsLoopBack;

       SmbCeDereferenceServerEntry(pServerEntry);
    }

    return Status;

}

PSMBCEDB_SESSION_ENTRY
SmbCeGetDefaultSessionEntry(
    PSMBCEDB_SERVER_ENTRY pServerEntry,
    ULONG SessionId,
    PLUID pLogonId
    )
/*++

Routine Description:

    This routine returns the session entry from the default sessions list.

Arguments:

    pServerEntry - Server entry

    SessionId    - Hydra session Id.

    pLogonId     - the logon id.

Notes:

    This is called with the SmbCe spinlock held.

--*/
{
    PLIST_ENTRY pListEntry;
    PSMBCEDB_SESSION_ENTRY pSession;
    PSMBCEDB_SESSION_ENTRY pReturnSession = NULL;

    ASSERT( pServerEntry != NULL );

    pListEntry = pServerEntry->Sessions.DefaultSessionList.Flink;

    while( pListEntry != &pServerEntry->Sessions.DefaultSessionList ) {

        pSession = CONTAINING_RECORD( pListEntry, SMBCEDB_SESSION_ENTRY, DefaultSessionLink );

        if( pSession->Session.SessionId == SessionId ) {
            if (RtlEqualLuid(
                    &pSession->Session.LogonId,
                    pLogonId)) {
                pReturnSession = pSession;
                break;
            }
        }

        pListEntry = pListEntry->Flink;
    }

    return( pReturnSession );
}

VOID
SmbCeRemoveDefaultSessionEntry(
    PSMBCEDB_SESSION_ENTRY pDefaultSessionEntry
    )
/*++

Routine Description:

    This routine removes the session entry from the default sessions list.

Arguments:

    pServerEntry - Server entry

    SessionId    - Hydra session Id.

    pLogonId     - the logon id.

Notes:

    This is called with the SmbCe spinlock held.

--*/
{
    if( pDefaultSessionEntry &&
        pDefaultSessionEntry->DefaultSessionLink.Flink ) {

        RemoveEntryList( &pDefaultSessionEntry->DefaultSessionLink );

        pDefaultSessionEntry->DefaultSessionLink.Flink = NULL;
        pDefaultSessionEntry->DefaultSessionLink.Blink = NULL;
    }
}

VOID
MRxSmbTrackRefCount(
      PVOID   pInstance,
      PCHAR   FileName,
      ULONG   Line)
{
    LONG State = ((PSMBCE_OBJECT_HEADER)pInstance)->State;
    LONG RefCount = ((PSMBCE_OBJECT_HEADER)pInstance)->SwizzleCount;
    SMBCEDB_OBJECT_TYPE ObjectType = ((PSMBCE_OBJECT_HEADER)pInstance)->ObjectType;

    switch (ObjectType) {
    case SMBCEDB_OT_SERVER :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_SERVER_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("  Ref ServerEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("  Ref ServerEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(SERVER,MRxSmbRefServerEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_NETROOT :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_NETROOT_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("  Ref NetRootEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("  Ref NetRootEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(NETROOT,MRxSmbRefNetRootEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_SESSION :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_SESSION_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("  Ref SessionEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("  Ref SessionEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(SESSION,MRxSmbRefSessionEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_VNETROOTCONTEXT :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_VNETROOT_CONTEXT)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("  Ref VNetRootConext %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("  Ref VNetRootContext %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(VNETROOT,MRxSmbRefVNetRootContext,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;
    }
}

VOID
MRxSmbTrackDerefCount(
      PVOID   pInstance,
      PCHAR   FileName,
      ULONG   Line)
{
    LONG State = ((PSMBCE_OBJECT_HEADER)pInstance)->State;
    LONG RefCount = ((PSMBCE_OBJECT_HEADER)pInstance)->SwizzleCount;
    SMBCEDB_OBJECT_TYPE ObjectType = ((PSMBCE_OBJECT_HEADER)pInstance)->ObjectType;

    switch (ObjectType) {
    case SMBCEDB_OT_SERVER :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_SERVER_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("Deref ServerEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("Deref ServerEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(SERVER,MRxSmbDerefServerEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_NETROOT :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_NETROOT_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("Deref NetRootEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("Deref NetRootEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(NETROOT,MRxSmbDerefNetRootEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_SESSION :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_SESSION_ENTRY)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("Deref SessionEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("Deref SessionEntry %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(SESSION,MRxSmbDerefSessionEntry,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;

    case SMBCEDB_OT_VNETROOTCONTEXT :
        if (MRXSMB_REF_TRACING_ON(MRXSMB_REF_TRACE_VNETROOT_CONTEXT)) {
            if (MRxSmbReferenceTracingValue & MRXSMB_LOG_REF_TRACKING) {
                RxLog(("Deref VNetRootConext %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName));
            }

            if (MRxSmbReferenceTracingValue & MRXSMB_PRINT_REF_TRACKING) {
                DbgPrint("Deref VNetRootContext %lx %d %d %ld %s\n",pInstance,State,RefCount,Line,FileName);
            }
        }

        SmbLog(VNETROOT,MRxSmbDerefVNetRootContext,LOGPTR(pInstance)LOGULONG(State)LOGULONG(RefCount)LOGULONG(Line)LOGARSTR(FileName));
        break;
    }
}