able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/rdr2/rdbss/smb.mrx/smbxchng.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

3790 lines
128 KiB
C
Raw Blame History

/*++ BUILD Version: 0009 // Increment this if a change has global effect
Copyright (c) 1987-1993 Microsoft Corporation
Module Name:
smbcxchng.c
Abstract:
This is the include file that implements the SMB_*_EXCHANGE creation, deletion and
dispatch routines.
Author:
Balan Sethu Raman (SethuR) 06-Mar-95 Created
Notes:
The exchange engine supports two kinds of changes, timed and untimed exhanges.
The timed exchanges are distinguished by the SMBCE_EXCHANGE_TIMED_RECEIVE_OPERATION.
In addition all exchanges are finalized if the transport is not able to push out
the data within a specific period of time. This enables us to throttle back
traffic to a overloaded server. Currently this is a global constant for all exchanges
and is set to 300 seconds.
This time limit only comes into play only when a send complete operation is outstanding
The exchanges are put on a timed exchange list ( one for each type of exchange)
when it is initiated. When a network operation, i.e., tranceive/send/copydata is
initiated the corresponding expiry time in the exchange is updated by invoking the
routine SmbCeSetExpiryTime.
The echo probes are initiated is invoked through the context of a recurrent service
(recursvc.c/recursvc.h). Every time this service is invoked (SmbCeProbeServers) it
in turn invokes SmbCeDetectAndResumeExpiredExchanges. This routine detects those
exchanges for which the wait for a response has exceeded the time limit and marks
them for finalization.
The finalization is done by SmbCeScavengeTimedOutExchanges in the context of a worker
thread. Notice that due to the granularity mismatch we treat timeout intervals as
soft deadlines.
--*/
#include "precomp.h"
#pragma hdrstop
#include "exsessup.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, MRxSmbInitializeSmbCe)
#pragma alloc_text(PAGE, SmbCeSerializeSessionSetupRequests)
#pragma alloc_text(PAGE, SmbCeUnblockSerializedSessionSetupRequests)
#pragma alloc_text(PAGE, SmbCeUnblockSerializedSessionSetupRequests)
#pragma alloc_text(PAGE, SmbCeInitiateExchange)
#pragma alloc_text(PAGE, SmbCeInitiateAssociatedExchange)
#pragma alloc_text(PAGE, SmbCeExchangeAbort)
#pragma alloc_text(PAGE, SmbCeBuildSmbHeader)
#pragma alloc_text(PAGE, SmbCeResumeExchange)
#pragma alloc_text(PAGE, SmbCepInitializeExchange)
#pragma alloc_text(PAGE, SmbCeInitializeAssociatedExchange)
#pragma alloc_text(PAGE, SmbCeTransformExchange)
#pragma alloc_text(PAGE, SmbCePrepareExchangeForReuse)
#pragma alloc_text(PAGE, SmbCeDiscardExchange)
#pragma alloc_text(PAGE, SmbCeFinalizeExchangeWorkerThreadRoutine)
#pragma alloc_text(PAGE, SmbCeFinalizeExchangeOnDisconnect)
#pragma alloc_text(PAGE, SmbCeDetectExpiredExchanges)
#pragma alloc_text(PAGE, DefaultSmbExchangeIndError)
#pragma alloc_text(PAGE, DefaultSmbExchangeIndReceive)
#pragma alloc_text(PAGE, DefaultSmbExchangeIndSendCallback)
#endif
#define CANCEL_BUFFER_SIZE (sizeof(SMB_HEADER) + sizeof(REQ_NT_CANCEL))
ULONG SmbCeTraceExchangeReferenceCount = 0;
extern BOOLEAN MRxSmbSecuritySignaturesRequired;
extern BOOLEAN MRxSmbSecuritySignaturesEnabled;
RXDT_DefineCategory(SMBXCHNG);
#define Dbg (DEBUG_TRACE_SMBXCHNG)
// The exchange engine in the mini redirector requires to maintain enough state
// to ensure that all the active exchanges are completed correctly when a shut down
// occurs. Since the exchanges can be finalized by different threads, including
// posted completions the exchange engine on startup initializes an event upon startup
// which is subsequently used to signal the terminating condition.
//
// The count of active changes has to be tracked continously and the signalling
// of the event depends upon the number of active exchanges reaching the count of
// zero and the exchange engine being in a stopped state.
SMBCE_STARTSTOP_CONTEXT SmbCeStartStopContext;
NTSTATUS
MRxSmbInitializeSmbCe()
/*++
Routine Description:
This routine initializes the connection engine
Return Value:
NXSTATUS - The return status for the operation
Notes:
--*/
{
LONG i;
PAGED_CODE();
KeInitializeEvent(
&SmbCeStartStopContext.StopEvent,
NotificationEvent,
FALSE);
SmbCeStartStopContext.ActiveExchanges = 0;
SmbCeStartStopContext.State = SMBCE_STARTED;
SmbCeStartStopContext.pServerEntryTearDownEvent = NULL;
InitializeListHead(
&SmbCeStartStopContext.SessionSetupRequests);
return STATUS_SUCCESS;
}
NTSTATUS
MRxSmbTearDownSmbCe()
/*++
Routine Description:
This routine tears down the connection engine
Return Value:
NXSTATUS - The return status for the operation
Notes:
--*/
{
BOOLEAN fWait;
if (SmbCeStartStopContext.State == SMBCE_STARTED) {
SmbCeAcquireSpinLock();
SmbCeStartStopContext.State = SMBCE_STOPPED;
fWait = (SmbCeStartStopContext.ActiveExchanges > 0);
SmbCeReleaseSpinLock();
if (fWait) {
KeWaitForSingleObject(
&SmbCeStartStopContext.StopEvent,
Executive,
KernelMode,
FALSE,
NULL);
}
}
return STATUS_SUCCESS;
}
NTSTATUS
SmbCeIncrementActiveExchangeCount()
/*++
Routine Description:
This routine increments the active exchange count
Return Value:
NXSTATUS - The return status for the operation
Notes:
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
SmbCeAcquireSpinLock();
if (SmbCeStartStopContext.State != SMBCE_STARTED) {
Status = STATUS_UNSUCCESSFUL;
} else {
InterlockedIncrement(&SmbCeStartStopContext.ActiveExchanges);
}
SmbCeReleaseSpinLock();
return Status;
}
VOID
SmbCeDecrementActiveExchangeCount()
/*++
Routine Description:
This routine decrements the active exchange count
Return Value:
NXSTATUS - The return status for the operation
Notes:
--*/
{
LONG FinalRefCount;
ASSERT(SmbCeStartStopContext.ActiveExchanges > 0);
if (InterlockedDecrement(&SmbCeStartStopContext.ActiveExchanges) == 0) {
SmbCeAcquireSpinLock();
if (SmbCeStartStopContext.State == SMBCE_STOPPED) {
KeSetEvent(&SmbCeStartStopContext.StopEvent,0,FALSE);
}
SmbCeReleaseSpinLock();
}
}
NTSTATUS
SmbCeReferenceServer(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine initializes the server associated with an exchange.
Arguments:
pExchange - the exchange to be initialized.
Return Value:
RXSTATUS - The return status for the operation
Notes:
The initiation of an exchange proceeds in multiple steps. The first step involves
referencing the corresponding server,session and netroot entries. Subsequently the
exchange is placed in a SMB_EXCHANGE_START state and the exchange is dispatched to the
Start method. The act of referencing the session or the net root may suspend the exchange.
The session and net roots are aliased entities, i.e., there is more then one reference
to it. It is conceivable that the construction is in progress when a reference is made.
In such cases the exchange is suspended and resumed when the construction is complete.
On some transports a reconnect is possible without having to tear down an existing
connection, i.e. attempting to send a packet reestablishes the connection at the
lower level. Since this is not supported by all the transports ( with the exception
of TCP/IP) the reference server entry initiates this process by tearing down the
existing transport and reinitialising it.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
LONG CscState;
PSMBCEDB_SERVER_ENTRY pServerEntry;
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
ASSERT(SmbCeIsResourceOwned());
ASSERT(pExchange->SmbCeState == SMBCE_EXCHANGE_INITIALIZATION_START);
if (SmbCeGetServerType(pServerEntry) == SMBCEDB_MAILSLOT_SERVER &&
!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_MAILSLOT_OPERATION)) {
// if the serve entry was created for mailslot operation, and a non-maislot operation
// comes, the server entry needs to establish a VC transport. Therefore we invalidate
// the server entry and set it to FILE SERVER.
pServerEntry->Header.State = SMBCEDB_INVALID;
SmbCeSetServerType(pServerEntry,SMBCEDB_FILE_SERVER);
SetFlag(pExchange->SmbCeFlags,SMBCE_EXCHANGE_ATTEMPT_RECONNECTS);
}
if ((pExchange->SmbCeFlags & SMBCE_EXCHANGE_ATTEMPT_RECONNECTS) &&
(SmbCeGetServerType(pServerEntry) == SMBCEDB_FILE_SERVER)) {
CscState = InterlockedCompareExchange(
&pServerEntry->Server.CscState,
ServerCscShadowing,
ServerCscTransitioningToShadowing);
if (CscState == ServerCscTransitioningToShadowing) {
ASSERT(!pServerEntry->NegotiateInProgress);
pServerEntry->Header.State = SMBCEDB_INVALID;
}
}
if (pServerEntry->Header.State != SMBCEDB_ACTIVE) {
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_ATTEMPT_RECONNECTS) {
switch (pServerEntry->Header.State) {
case SMBCEDB_INVALID:
{
BOOLEAN ServerInDisconnectedModeBeforeInit;
SMBCEDB_OBJECT_STATE State;
ServerInDisconnectedModeBeforeInit = SmbCeIsServerInDisconnectedMode(
pServerEntry);
ASSERT(!pServerEntry->NegotiateInProgress);
pServerEntry->NegotiateInProgress = TRUE;
SmbCeUpdateServerEntryState(
pServerEntry,
SMBCEDB_CONSTRUCTION_IN_PROGRESS);
SmbCeReleaseResource();
// Initialize the transport associated with the server
Status = SmbCeInitializeServerTransport(pServerEntry,NULL,NULL);
if (Status == STATUS_SUCCESS) {
if (SmbCeIsServerInDisconnectedMode(pServerEntry)) {
if (!ServerInDisconnectedModeBeforeInit) {
// A transition has occurred from connected mode of
// operation to a disconnected mode. retry the
// operation
Status = STATUS_RETRY;
}
} else {
if (ServerInDisconnectedModeBeforeInit) {
DbgPrint("Transitioning SE %lx from DC to CO\n",pServerEntry);
}
}
}
if (Status == STATUS_SUCCESS) {
PSMBCEDB_SESSION_ENTRY pSessionEntry =
SmbCeGetExchangeSessionEntry(pExchange);
BOOLEAN RemoteBootSession;
if ((pSessionEntry != NULL) &&
(FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION) ||
MRxSmbUseKernelModeSecurity)) {
RemoteBootSession = TRUE;
} else {
RemoteBootSession = FALSE;
}
Status = SmbCeNegotiate(
pServerEntry,
pServerEntry->pRdbssSrvCall,
RemoteBootSession
);
}
SmbCeCompleteServerEntryInitialization(pServerEntry,Status);
if (Status != STATUS_SUCCESS) {
// Either the transport initialization failed or the NEGOTIATE
// SMB could not be sent ....
InterlockedIncrement(&MRxSmbStatistics.Reconnects);
}
SmbCeAcquireResource();
}
break;
case SMBCEDB_CONSTRUCTION_IN_PROGRESS :
{
PSMBCEDB_REQUEST_ENTRY pRequestEntry;
pRequestEntry = (PSMBCEDB_REQUEST_ENTRY)
SmbMmAllocateObject(SMBCEDB_OT_REQUEST);
if (pRequestEntry != NULL) {
// Enqueue the request entry.
pRequestEntry->ReconnectRequest.Type = RECONNECT_REQUEST;
pRequestEntry->ReconnectRequest.pExchange = pExchange;
SmbCeIncrementPendingLocalOperations(pExchange);
SmbCeAddRequestEntry(&pServerEntry->OutstandingRequests,pRequestEntry);
Status = STATUS_PENDING;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
break;
default :
Status = STATUS_CONNECTION_DISCONNECTED;
break;
}
} else {
Status = STATUS_CONNECTION_DISCONNECTED;
}
}
if ((Status == STATUS_SUCCESS) || (Status == STATUS_PENDING)) {
pExchange->SmbCeState = SMBCE_EXCHANGE_SERVER_INITIALIZED;
}
ASSERT(SmbCeIsResourceOwned());
return Status;
}
VOID
SmbCeSerializeSessionSetupRequests(
PSMBCEDB_SESSION_ENTRY pSessionEntry)
/*++
Routine Description:
This routine serializes the session setup requests to a server
Arguments:
pSessionEntry - the session entry.
Notes:
The session setup request with a VC number of zero has a special significance
for the server. It is the clue for the server to tear down any existing
data structures and rebuild ( client reboot ). When two aliased connections to
a server are established it is important to ensure that no connections with VC
number zero are outstanding while a non zero VC numbered session is sent. This
is because of the potential for out of order request processing that exists
on the server.
In order to garantee the sequence of session setup, we put the outstanding session
setup requests on a waiting list. If there is a new sesstion setup against the
aliased server, it will be held until the first session setup finished.
--*/
{
PSMBCEDB_SERVER_ENTRY pServerEntry;
BOOLEAN DelayedRequest = FALSE;
PAGED_CODE();
RemoveEntryList(&pSessionEntry->SerializationList);
InitializeListHead(&pSessionEntry->SerializationList);
pServerEntry = pSessionEntry->pServerEntry;
pSessionEntry->SessionVCNumber = 0;
if ((pServerEntry->Server.Dialect >= NTLANMAN_DIALECT) &&
(FlagOn(pServerEntry->Server.DialectFlags,DF_NT_STATUS))) {
PSMBCEDB_SESSION_ENTRY pTempSessionEntry;
pTempSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
while (pTempSessionEntry != NULL) {
if ((pTempSessionEntry != pSessionEntry) &&
(pTempSessionEntry->Header.State != SMBCEDB_INVALID) &&
(pTempSessionEntry->Header.State != SMBCEDB_MARKED_FOR_DELETION)) {
pSessionEntry->SessionVCNumber = 1;
break;
}
pTempSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pTempSessionEntry);
}
if (pServerEntry->Server.AliasedServers) {
PLIST_ENTRY pListEntry;
BOOLEAN DelaySessionSetupRequest = FALSE;
PSMBCEDB_SERVER_ENTRY pTempServerEntry;
// Figure out the VC number for aliased servers by walking
// through the list of server entries
pTempServerEntry = SmbCeGetFirstServerEntry();
while ((pTempServerEntry != NULL) &&
(pSessionEntry->SessionVCNumber == 0)) {
if (SmbCeAreServerEntriesAliased(pServerEntry,pTempServerEntry)) {
pTempSessionEntry = SmbCeGetFirstSessionEntry(pServerEntry);
while (pTempSessionEntry != NULL) {
if ((pTempSessionEntry->Header.State != SMBCEDB_INVALID) &&
(pTempSessionEntry->Header.State != SMBCEDB_MARKED_FOR_DELETION)) {
pSessionEntry->SessionVCNumber = 1;
break;
}
pTempSessionEntry = SmbCeGetNextSessionEntry(pServerEntry,pTempSessionEntry);
}
}
pTempServerEntry = SmbCeGetNextServerEntry(pTempServerEntry);
}
pListEntry = SmbCeStartStopContext.SessionSetupRequests.Flink;
while (pListEntry != &SmbCeStartStopContext.SessionSetupRequests) {
PSMBCEDB_SESSION_ENTRY pTempSessionEntry;
pTempSessionEntry = (PSMBCEDB_SESSION_ENTRY)
CONTAINING_RECORD(
pListEntry,
SMBCEDB_SESSION_ENTRY,
SerializationList);
pTempServerEntry = pTempSessionEntry->pServerEntry;
if (SmbCeAreServerEntriesAliased(pServerEntry,pTempServerEntry) &&
(pTempSessionEntry->SessionVCNumber == 0)) {
DelaySessionSetupRequest = TRUE;
break;
} else {
pListEntry = pListEntry->Flink;
}
}
if (DelaySessionSetupRequest) {
KEVENT Event;
KeInitializeEvent(
&Event,
NotificationEvent,
FALSE);
pSessionEntry->pSerializationEvent = &Event;
InsertTailList(
&SmbCeStartStopContext.SessionSetupRequests,
&pSessionEntry->SerializationList);
SmbCeReleaseResource();
KeWaitForSingleObject(
&Event,
Executive,
KernelMode,
FALSE,
NULL);
SmbCeAcquireResource();
pSessionEntry->pSerializationEvent = NULL;
DelayedRequest = TRUE;
}
}
} else {
pSessionEntry->SessionVCNumber = 0;
}
if (!DelayedRequest) {
InsertTailList(
&SmbCeStartStopContext.SessionSetupRequests,
&pSessionEntry->SerializationList);
}
}
VOID
SmbCeUnblockSerializedSessionSetupRequests(
PSMBCEDB_SESSION_ENTRY pSessionEntry)
/*++
Routine Description:
This routine unblocks non zero VC number session setup requests on completion
of zero VC number session setup requests
Arguments:
pSessionEntry - the session entry.
Notes:
The session setup request with a VC number of zero has a special significance
for the server. It is the cure for the server to tear down any existing
data structures and rebuild ( cliet reboot ). When two aliased connections to
a server are established it is important to ensure that no connections with VC
number zero are outstanding while a non zero VC numbered session is sent. This
is because of the potential for out of order request processing that exists
on the server.
--*/
{
PLIST_ENTRY pListEntry;
PAGED_CODE();
RemoveEntryList(&pSessionEntry->SerializationList);
InitializeListHead(&pSessionEntry->SerializationList);
pListEntry = SmbCeStartStopContext.SessionSetupRequests.Flink;
while (pListEntry != &SmbCeStartStopContext.SessionSetupRequests) {
PSMBCEDB_SESSION_ENTRY pTempSessionEntry;
pTempSessionEntry = (PSMBCEDB_SESSION_ENTRY)
CONTAINING_RECORD(
pListEntry,
SMBCEDB_SESSION_ENTRY,
SerializationList);
pListEntry = pListEntry->Flink;
if (SmbCeAreServerEntriesAliased(
pSessionEntry->pServerEntry,
pTempSessionEntry->pServerEntry)) {
RemoveEntryList(&pTempSessionEntry->SerializationList);
InitializeListHead(&pTempSessionEntry->SerializationList);
if (pTempSessionEntry->pSerializationEvent != NULL) {
KeSetEvent(
pTempSessionEntry->pSerializationEvent,
0,
FALSE);
}
}
}
}
NTSTATUS
SmbCeReferenceSession(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine initializes the session associated with an exchange.
Arguments:
pExchange - the exchange to be initialized.
Return Value:
RXSTATUS - The return status for the operation
Notes:
The initiation of an exchange proceeds in multiple steps. The first step involves
referencing the corresponding server,session and netroot entries. Subsequently the
exchange is placed in a SMB_EXCHANGE_START state and the exchange is dispatched to the
Start method. The act of referencing the session or the net root may suspend the exchange.
The session and net roots are aliased entities, i.e., there is more then one reference
to it. It is conceivable that the construction is in progress when a reference is made.
In such cases the exchange is suspended and resumed when the construction is complete.
--*/
{
NTSTATUS Status;
BOOLEAN fReestablishSession;
BOOLEAN UnInitializeSecurityContext = FALSE;
PMRX_V_NET_ROOT pVNetRoot;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PSMBCEDB_SESSION_ENTRY pSessionEntry;
pVNetRoot = SmbCeGetExchangeVNetRoot(pExchange);
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
fReestablishSession = (pSessionEntry->Header.State == SMBCEDB_RECOVER) |
BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_ATTEMPT_RECONNECTS);
for (;;) {
ASSERT(pServerEntry->Header.ObjectType == SMBCEDB_OT_SERVER);
ASSERT(pExchange->SmbCeState == SMBCE_EXCHANGE_SERVER_INITIALIZED);
ASSERT(SmbCeGetServerType(pServerEntry) == SMBCEDB_FILE_SERVER);
ASSERT(SmbCeIsResourceOwned());
Status = STATUS_USER_SESSION_DELETED;
if (pSessionEntry == NULL) {
break;
}
switch (pSessionEntry->Header.State) {
case SMBCEDB_ACTIVE:
Status = STATUS_SUCCESS;
break;
case SMBCEDB_INVALID:
if (!fReestablishSession) {
break;
}
pSessionEntry->Session.UserId = 0;
// fall thru ...
case SMBCEDB_RECOVER:
UnInitializeSecurityContext = TRUE;
if (pSessionEntry->Header.State == SMBCEDB_RECOVER) {
ASSERT(pSessionEntry->SessionRecoverInProgress == FALSE);
pSessionEntry->SessionRecoverInProgress = TRUE;
RxLog(("Mark Sess Rec %lx\n",pSessionEntry));
}
if (pSessionEntry->Session.Type == EXTENDED_NT_SESSION){
pSessionEntry->Header.State = SMBCEDB_START_CONSTRUCTION;
if (pExchange->Type != EXTENDED_SESSION_SETUP_EXCHANGE) {
break;
}
}
RxDbgTrace( 0, Dbg, ("SmbCeReferenceSession: Reestablishing session\n"));
// fall thru ...
case SMBCEDB_START_CONSTRUCTION:
if (pSessionEntry->Session.Type != EXTENDED_NT_SESSION ||
pExchange->Type == EXTENDED_SESSION_SETUP_EXCHANGE) {
RxDbgTrace( 0, Dbg, ("SmbCeReferenceSession: Reestablishing session\n"));
ASSERT(SmbCeGetServerType(pServerEntry) == SMBCEDB_FILE_SERVER);
pExchange->SmbCeFlags |= SMBCE_EXCHANGE_SESSION_CONSTRUCTOR;
pSessionEntry->pExchange = pExchange;
pSessionEntry->Header.State = SMBCEDB_CONSTRUCTION_IN_PROGRESS;
SmbCeSerializeSessionSetupRequests(
pSessionEntry);
Status = STATUS_SUCCESS;
if (pExchange->Type == EXTENDED_SESSION_SETUP_EXCHANGE) {
PSMB_EXTENDED_SESSION_SETUP_EXCHANGE pExtSSExchange;
pExtSSExchange = (PSMB_EXTENDED_SESSION_SETUP_EXCHANGE)pExchange;
pExtSSExchange->FirstSessionSetup = TRUE;
}
break;
}
// fall thru ...
case SMBCEDB_CONSTRUCTION_IN_PROGRESS:
if (fReestablishSession) {
// The construction of the session is already in progress ....
// Queue up the request to resume this exchange when the session
// construction is complete.
PSMBCEDB_REQUEST_ENTRY pRequestEntry;
ASSERT(SmbCeGetServerType(pServerEntry) == SMBCEDB_FILE_SERVER);
pRequestEntry = (PSMBCEDB_REQUEST_ENTRY)
SmbMmAllocateObject(SMBCEDB_OT_REQUEST);
if (pRequestEntry != NULL) {
pRequestEntry->Request.pExchange = pExchange;
SmbCeIncrementPendingLocalOperations(pExchange);
SmbCeAddRequestEntry(&pSessionEntry->Requests,pRequestEntry);
Status = STATUS_PENDING;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
fReestablishSession = FALSE;
}
break;
case SMBCEDB_MARKED_FOR_DELETION:
Status = STATUS_USER_SESSION_DELETED;
break;
default:
ASSERT(!"Valid Session State, SmbCe database corrupt");
Status = STATUS_USER_SESSION_DELETED;
}
if (fReestablishSession &&
(pSessionEntry->Session.Type == EXTENDED_NT_SESSION) &&
(pExchange->Type != EXTENDED_SESSION_SETUP_EXCHANGE) &&
(pSessionEntry->Header.State == SMBCEDB_START_CONSTRUCTION)) {
// Reestablishing a NT50 session cannot be compounded currently. Therefor
// this exchange is suspended till we can reestablish the session. Therefore
PSMB_EXCHANGE pSessionSetupExchange;
SMBCE_RESUMPTION_CONTEXT ExchangeResumptionContext;
RxDbgTrace(0 , Dbg, ("Reestablishing an Extended session %lx\n",pSessionEntry));
pSessionSetupExchange = SmbMmAllocateExchange(EXTENDED_SESSION_SETUP_EXCHANGE,NULL);
SmbCeReleaseResource();
ExchangeResumptionContext.SecuritySignatureReturned = FALSE;
if (pSessionSetupExchange != NULL) {
UninitializeSecurityContextsForSession(&pSessionEntry->Session);
SmbCeInitializeResumptionContext(&ExchangeResumptionContext);
Status = SmbCeInitializeExtendedSessionSetupExchange(
&pSessionSetupExchange,
pExchange->SmbCeContext.pVNetRoot);
if (Status == STATUS_SUCCESS) {
// Attempt to reconnect( In this case it amounts to establishing the
// connection/session)
pSessionSetupExchange->SmbCeFlags |= SMBCE_EXCHANGE_ATTEMPT_RECONNECTS;
pSessionSetupExchange->RxContext = pExchange->RxContext;
((PSMB_EXTENDED_SESSION_SETUP_EXCHANGE)pSessionSetupExchange)->pResumptionContext
= &ExchangeResumptionContext;
Status = SmbCeInitiateExchange(pSessionSetupExchange);
if (Status == STATUS_PENDING) {
SmbCeSuspend(&ExchangeResumptionContext);
Status = ExchangeResumptionContext.Status;
} else {
SmbCeDiscardExtendedSessionSetupExchange(
(PSMB_EXTENDED_SESSION_SETUP_EXCHANGE)pSessionSetupExchange);
}
} else {
SmbMmFreeExchange(pSessionSetupExchange);
}
RxDbgTrace(0, Dbg, ("Reestablishing a NT50 Session %lx returning STATUS %lx\n",pSessionEntry,Status));
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
SmbCeReferenceSessionEntry(pSessionEntry);
ASSERT(Status != STATUS_SUCCESS ||
pSessionEntry->Header.State == SMBCEDB_CONSTRUCTION_IN_PROGRESS);
pVNetRoot->ConstructionStatus = Status;
SmbCeCompleteSessionEntryInitialization(
pSessionEntry,
Status,
ExchangeResumptionContext.SecuritySignatureReturned);
SmbCeAcquireResource();
if (Status != STATUS_RETRY) {
break;
}
} else {
if (UnInitializeSecurityContext) {
SmbCeReleaseResource();
UninitializeSecurityContextsForSession(&pSessionEntry->Session);
SmbCeAcquireResource();
}
break;
}
}
if ((Status == STATUS_SUCCESS) || (Status == STATUS_PENDING)) {
pExchange->SmbCeState = SMBCE_EXCHANGE_SESSION_INITIALIZED;
}
ASSERT(SmbCeIsResourceOwned());
//ASSERT(Status != STATUS_USER_SESSION_DELETED);
return Status;
}
NTSTATUS
SmbCeReferenceNetRoot(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine initializes the net root associated with an exchange.
Arguments:
pExchange - the exchange to be initialized.
Return Value:
RXSTATUS - The return status for the operation
Notes:
The initiation of an exchange proceeds in multiple steps. The first step involves
referencing the corresponding server,session and netroot entries. Subsequently the
exchange is placed in a SMB_EXCHANGE_START state and the exchange is dispatched to the
Start method. The act of referencing the session or the net root may suspend the exchange.
The session and net roots are aliased entities, i.e., there is more then one reference
to it. It is conceivable that the construction is in progress when a reference is made.
In such cases the exchange is suspended and resumed when the construction is complete.
--*/
{
NTSTATUS Status;
BOOLEAN fReconnectNetRoot;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry;
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;
pVNetRootContext = SmbCeGetAssociatedVNetRootContext(pExchange->SmbCeContext.pVNetRoot);
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pNetRootEntry = SmbCeGetExchangeNetRootEntry(pExchange);
ASSERT(pExchange->SmbCeState == SMBCE_EXCHANGE_SESSION_INITIALIZED);
ASSERT(SmbCeIsResourceOwned());
Status = STATUS_CONNECTION_DISCONNECTED;
fReconnectNetRoot = BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_ATTEMPT_RECONNECTS);
switch (pVNetRootContext->Header.State) {
case SMBCEDB_ACTIVE:
ASSERT(pNetRootEntry->Header.ObjectType == SMBCEDB_OT_NETROOT);
ASSERT(pServerEntry->Header.ObjectType == SMBCEDB_OT_SERVER);
Status = STATUS_SUCCESS;
break;
case SMBCEDB_INVALID:
RxDbgTrace( 0, Dbg, ("SmbCeReferenceNetRoot: Reestablishing net root\n"));
if (!fReconnectNetRoot) {
break;
}
ClearFlag(
pVNetRootContext->Flags,
SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);
pVNetRootContext->TreeId = 0;
// fall thru
case SMBCEDB_START_CONSTRUCTION:
pExchange->SmbCeFlags |= SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR;
pVNetRootContext->pExchange = pExchange;
pVNetRootContext->Header.State = SMBCEDB_CONSTRUCTION_IN_PROGRESS;
Status = STATUS_SUCCESS;
break;
case SMBCEDB_CONSTRUCTION_IN_PROGRESS:
if (fReconnectNetRoot) {
// The construction of the net root is already in progress ....
// Queue up the request to resume this exchange when the session
// construction is complete.
PSMBCEDB_REQUEST_ENTRY pRequestEntry;
pRequestEntry = (PSMBCEDB_REQUEST_ENTRY)
SmbMmAllocateObject(SMBCEDB_OT_REQUEST);
if (pRequestEntry != NULL) {
pRequestEntry->Request.pExchange = pExchange;
SmbCeIncrementPendingLocalOperations(pExchange);
SmbCeAddRequestEntry(&pVNetRootContext->Requests,pRequestEntry);
Status = STATUS_PENDING;
} else {
Status = STATUS_INSUFFICIENT_RESOURCES;
}
}
break;
case SMBCEDB_MARKED_FOR_DELETION:
break;
default:
ASSERT(!"Valid NetRoot State, SmbCe database corrupt");
break;
}
if ((Status == STATUS_SUCCESS) || (Status == STATUS_PENDING)) {
pExchange->SmbCeState = SMBCE_EXCHANGE_NETROOT_INITIALIZED;
}
ASSERT(SmbCeIsResourceOwned());
return Status;
}
NTSTATUS
SmbCeInitiateExchange(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine inititaes a exchange.
Arguments:
pExchange - the exchange to be initiated.
Return Value:
RXSTATUS - The return status for the operation
Notes:
The initiation of an exchange proceeds in multiple steps. The first step involves
referencing the corresponding server,session and netroot entries. Subsequently the
exchange is placed in a SMB_EXCHANGE_START state and the exchange is dispatched to the
Start method. The act of referencing the session or the net root may suspend the exchange.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PSMBCEDB_SESSION_ENTRY pSessionEntry;
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry;
PKEVENT pSmbCeSynchronizationEvent;
PAGED_CODE();
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
pNetRootEntry = SmbCeGetExchangeNetRootEntry(pExchange);
ASSERT(pServerEntry != NULL);
ASSERT(!FlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE));
switch (SmbCeGetServerType(pServerEntry)) {
case SMBCEDB_FILE_SERVER:
// If this is a mailslot write, then don't abort......
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_MAILSLOT_OPERATION) {
break;
}
// Admin exchanges do not have these fields filled in. All the three
// entries must be valid for all other exchanges.
if ((pExchange->NodeTypeCode != SMB_EXCHANGE_NTC(ADMIN_EXCHANGE)) &&
((pNetRootEntry == NULL) ||
(pSessionEntry == NULL))) {
Status = STATUS_REQUEST_ABORTED;
break;
}
case SMBCEDB_MAILSLOT_SERVER:
break;
default:
// Prepare for aborting the request if either the server type is invalid
// or if the netroot entry or the session entry is invalid.
Status = STATUS_REQUEST_ABORTED;
}
if (Status != STATUS_SUCCESS) {
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange %lx Status %lx\n",pExchange,Status));
return Status;
}
pSmbCeSynchronizationEvent = pExchange->pSmbCeSynchronizationEvent;
if (pSmbCeSynchronizationEvent != NULL) {
KeInitializeEvent(
pSmbCeSynchronizationEvent,
SynchronizationEvent,
FALSE);
}
for (;;) {
SmbCeAcquireResource();
switch (pExchange->SmbCeState) {
case SMBCE_EXCHANGE_INITIALIZATION_START:
{
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange %lx State %lx\n",pExchange,pExchange->SmbCeState));
Status = SmbCeReferenceServer(pExchange);
if (Status != STATUS_SUCCESS) {
// this covers the case when the SERVER_ENTRY is under construction
// and RxStatus(PENDING) is returned.
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SmbCeReferenceServer returned %lx\n",Status));
break;
}
}
// fall through
case SMBCE_EXCHANGE_SERVER_INITIALIZED:
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_MAILSLOT_OPERATION) {
// Mailslot servers do not have any netroot/session associated with them.
pExchange->SmbCeState = SMBCE_EXCHANGE_INITIATED;
Status = STATUS_SUCCESS;
break;
} else {
if (pSessionEntry->SessionRecoverInProgress ||
pServerEntry->SecuritySignaturesEnabled &&
!pServerEntry->SecuritySignaturesActive) {
// if security signature is enabled and not yet turned on, exchange should wait for
// outstanding extended session setup to finish before resume in order to avoid index mismatch.
RxLog(("Sync for Sess %lx\n",pExchange));
Status = SmbCeSyncExchangeForSecuritySignature(pExchange);
}
if (Status == STATUS_SUCCESS) {
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange %lx State %lx\n",pExchange,pExchange->SmbCeState));
Status = SmbCeReferenceSession(pExchange);
if (!NT_SUCCESS(Status)) {
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SmbCeReferenceSession returned %lx\n",Status));
break;
} if ((Status == STATUS_PENDING) &&
!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR)) {
break;
}
} else {
break;
}
}
// fall through
case SMBCE_EXCHANGE_SESSION_INITIALIZED:
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange %lx State %lx\n",pExchange,pExchange->SmbCeState));
if (pExchange->Type != EXTENDED_SESSION_SETUP_EXCHANGE) {
Status = SmbCeReferenceNetRoot(pExchange);
if (!NT_SUCCESS(Status)) {
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SmbCeReferenceNetRoot returned %lx\n",Status));
break;
} else if ((Status == STATUS_PENDING) &&
!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR)) {
break;
}
}
// else fall through
case SMBCE_EXCHANGE_NETROOT_INITIALIZED:
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange %lx State %lx\n",pExchange,pExchange->SmbCeState));
if (pServerEntry->SecuritySignaturesEnabled &&
!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_MAILSLOT_OPERATION)) {
Status = SmbCeAllocateBufferForServerResponse(pExchange);
if (Status != STATUS_SUCCESS) {
// this covers the case when the buffer for server response cannot be allocated
// and RxStatus(PENDING) is returned.
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SmbCeAllocateBufferForServerResponse returned %lx\n",Status));
break;
}
}
// else fall throungh
case SMBCE_EXCHANGE_SECURITYBUFFER_INITIALIZED:
{
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry;
pNetRootEntry = SmbCeGetExchangeNetRootEntry(pExchange);
// Exchange should have timeout flag set unless this is a pipe operation
// or the SMBCE_ECXCHANGE_INDEFINITE_DELAY_IN_RESPONSE flag is set
if(((pNetRootEntry == NULL) || (pNetRootEntry->NetRoot.NetRootType != NET_ROOT_PIPE)) &&
!BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_INDEFINITE_DELAY_IN_RESPONSE)) {
pExchange->SmbCeFlags |= SMBCE_EXCHANGE_TIMED_RECEIVE_OPERATION;
}
pExchange->SmbCeState = SMBCE_EXCHANGE_INITIATED;
Status = STATUS_SUCCESS;
}
break;
default:
ASSERT(!"Valid State for a SMB exchange, exchange Initiation aborted");
break;
}
SmbCeReleaseResource();
if ((pSmbCeSynchronizationEvent != NULL) &&
(pExchange->SmbCeState != SMBCE_EXCHANGE_INITIATED) &&
(Status == STATUS_PENDING)) {
KeWaitForSingleObject(
pSmbCeSynchronizationEvent,
Executive,
KernelMode,
FALSE,
NULL );
ASSERT(pExchange->Status != RX_MAP_STATUS(PENDING));
Status = pExchange->Status;
if (Status != RX_MAP_STATUS(SUCCESS)) {
break;
}
} else {
break;
}
}
ASSERT((Status != STATUS_PENDING) ||
(pSmbCeSynchronizationEvent == NULL));
RxDbgTrace(0,Dbg,("Exchange (%lx) Type (%lx) State(%lx) Status %lx \n",pExchange,pExchange->Type,pExchange->SmbCeState,Status));
RxDbgTrace(0,Dbg,
("ServerEntry(%lx) SessionEntry(%lx) NetRootEntry(%lx) \n",
pServerEntry,
pSessionEntry,
pNetRootEntry));
// Note: Once the exchange has been initiated no further reference of the exchange
// can be done since the state of the exchange is non-deterministic, i.e., depends upon
// the scheduler.
if (Status == STATUS_SUCCESS) {
BOOLEAN ResourceReleased = FALSE;
// Start the exchange
ASSERT(pExchange->SmbCeState == SMBCE_EXCHANGE_INITIATED);
SmbCeAcquireResource();
if ((pServerEntry->Header.State == SMBCEDB_ACTIVE) ||
(pExchange->NodeTypeCode == SMB_EXCHANGE_NTC(ADMIN_EXCHANGE)) ||
(FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_MAILSLOT_OPERATION))) {
Status = SmbCeInitializeExchangeTransport(pExchange);
} else {
Status = STATUS_CONNECTION_DISCONNECTED;
}
if (Status == STATUS_SUCCESS) {
if (pExchange->RxContext != NULL) {
PMRXSMB_RX_CONTEXT pMRxSmbContext;
// Set up the cancellation routine ..
pMRxSmbContext = MRxSmbGetMinirdrContext(pExchange->RxContext);
pMRxSmbContext->pCancelContext = pExchange;
Status = RxSetMinirdrCancelRoutine(
pExchange->RxContext,
SmbCeCancelExchange);
}
if (Status == STATUS_SUCCESS) {
if (!IsListEmpty(&pExchange->ExchangeList)) {
RemoveEntryList(&pExchange->ExchangeList);
}
InsertTailList(
&pServerEntry->ActiveExchanges,
&pExchange->ExchangeList);
SmbCeReleaseResource();
ResourceReleased = TRUE;
pExchange->SmbStatus = STATUS_SUCCESS;
pExchange->ServerVersion = pServerEntry->Server.Version;
Status = SMB_EXCHANGE_DISPATCH(pExchange,Start,((PSMB_EXCHANGE)pExchange));
}
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SMB_EXCHANGE_DISPATCH(Start) returned %lx\n",Status));
}
if (!ResourceReleased) {
SmbCeReleaseResource();
}
} else if (Status != STATUS_PENDING) {
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: Exchange(%lx) Initiation failed %lx \n",pExchange,Status));
}
return Status;
}
NTSTATUS
SmbCeInitiateAssociatedExchange(
PSMB_EXCHANGE pExchange,
BOOLEAN EnableCompletionHandlerInMasterExchange)
/*++
Routine Description:
This routine inititaes an associated exchange.
Arguments:
pExchange - the exchange to be initiated.
Return Value:
NTSTATUS - The return status for the operation
Notes:
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PSMB_EXCHANGE pMasterExchange;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PAGED_CODE();
ASSERT(pExchange->SmbCeState == SMBCE_EXCHANGE_INITIATED);
ASSERT(FlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE));
pMasterExchange = pExchange->Associated.pMasterExchange;
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
ASSERT(pServerEntry != NULL);
// Note: Once the exchange has been initiated no further reference of the exchange
// can be done since the state of the exchange is non-deterministic, i.e., depends upon
// the scheduler.
Status = SmbCeInitializeExchangeTransport(pExchange);
SmbCeAcquireResource();
if (!IsListEmpty(&pExchange->ExchangeList)) {
RemoveEntryList(&pExchange->ExchangeList);
}
InsertTailList(
&pServerEntry->ActiveExchanges,
&pExchange->ExchangeList);
if (EnableCompletionHandlerInMasterExchange) {
ASSERT(!FlagOn(
pMasterExchange->SmbCeFlags,
SMBCE_ASSOCIATED_EXCHANGES_COMPLETION_HANDLER_ACTIVATED));
SetFlag(
pMasterExchange->SmbCeFlags,
SMBCE_ASSOCIATED_EXCHANGES_COMPLETION_HANDLER_ACTIVATED);
}
pExchange->SmbStatus = STATUS_SUCCESS;
pExchange->ServerVersion = pServerEntry->Server.Version;
SmbCeReleaseResource();
if (Status == STATUS_SUCCESS) {
Status = SMB_EXCHANGE_DISPATCH(pExchange,Start,((PSMB_EXCHANGE)pExchange));
RxDbgTrace( 0, Dbg, ("SmbCeInitiateExchange: SMB_EXCHANGE_DISPATCH(Start) returned %lx\n",Status));
} else {
SmbCeFinalizeExchange(pExchange);
Status = STATUS_PENDING;
}
return Status;
}
NTSTATUS
SmbCeExchangeAbort(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine aborts an exchange.
Arguments:
pExchange - the exchange to be aborted.
Return Value:
RXSTATUS - The return status for the operation
Notes:
--*/
{
PAGED_CODE();
RxDbgTrace( 0, Dbg, ("SmbCeExchangeAbort: Exchange %lx aborted\n",pExchange));
SmbCeDiscardExchange(pExchange);
return STATUS_SUCCESS;
}
NTSTATUS
SmbCeBuildSmbHeader(
IN OUT PSMB_EXCHANGE pExchange,
IN OUT PVOID pBuffer,
IN ULONG BufferLength,
OUT PULONG pBufferConsumed,
OUT PUCHAR pLastCommandInHeader,
OUT PUCHAR *pNextCommandPtr)
/*++
Routine Description:
This routine constructs the SMB header associated with any SMB sent as part of
an exchange.
Arguments:
pExchange - the exchange for which the SMB is to be constructed.
pBuffer - the buffer in whihc the SMB header is to be constructed
BufferLength - length of the buffer
pBufferConsumed - the buffer consumed
pLastCommandInHeader - the last command in header, SMB_COM_NO_ANDX_COMMAND if none
pNextCommandPtr - the ptr to the place in the buffer where the next command
code should be copied.
Return Value:
STATUS_SUCCESS - if the header construction was successful
Notes:
This routine is called to build the SMB header. This centralization allows us to
compound the SMB operation with other SMB's required for the maintenance of the
SMB connection engine data structures. It also provides us with a centralized facility
for profiling SMB's as well as a one place mechanism for filling in all the header
fields associated with a SMB.
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PSMB_HEADER pSmbHeader = (PSMB_HEADER)pBuffer;
PGENERIC_ANDX pSmbBuffer;
ULONG SmbBufferUnconsumed = BufferLength;
PUCHAR pSmbCommand;
PRX_CONTEXT RxContext;
UCHAR LastCommandInHeader = SMB_COM_NO_ANDX_COMMAND;
UCHAR Flags = SMB_FLAGS_CASE_INSENSITIVE | SMB_FLAGS_CANONICALIZED_PATHS;
USHORT Flags2 = 0;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PSMBCEDB_SESSION_ENTRY pSessionEntry;
PSMBCE_SERVER pServer;
PAGED_CODE();
if (BufferLength < sizeof(SMB_HEADER)) {
RxDbgTrace( 0, Dbg, ("SmbCeBuildSmbHeader: BufferLength too small %d\n",BufferLength));
ASSERT(!"Buffer too small");
return STATUS_BUFFER_TOO_SMALL;
}
SmbBufferUnconsumed = BufferLength - sizeof(SMB_HEADER);
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
pServer = SmbCeGetExchangeServer(pExchange);
RxContext = pExchange->RxContext;
if (pServer->Dialect == NTLANMAN_DIALECT) {
if (FlagOn(pServer->DialectFlags,DF_NT_SMBS)) {
Flags2 |= (SMB_FLAGS2_KNOWS_EAS | SMB_FLAGS2_EXTENDED_SECURITY);
if ((pSessionEntry != NULL) &&
(FlagOn(pSessionEntry->Session.Flags,SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION) ||
MRxSmbUseKernelModeSecurity)) {
Flags2 &= ~SMB_FLAGS2_EXTENDED_SECURITY;
}
}
if (FlagOn(pServer->DialectFlags,DF_NT_STATUS)) {
Flags2 |= SMB_FLAGS2_NT_STATUS;
}
if( RxContext &&
(RxContext->pFcb) &&
(RxContext->pFcb->FcbState & FCB_STATE_SPECIAL_PATH) )
{
Flags2 |= SMB_FLAGS2_REPARSE_PATH;
}
}
if (!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_MAILSLOT_OPERATION)) {
if (FlagOn(pServer->DialectFlags,DF_UNICODE)) {
Flags2 |= SMB_FLAGS2_UNICODE;
}
}
if (FlagOn(pServer->DialectFlags,DF_LONGNAME)) {
Flags2 |= SMB_FLAGS2_KNOWS_LONG_NAMES;
}
if (FlagOn(pServer->DialectFlags,DF_SUPPORTEA)) {
Flags2 |= SMB_FLAGS2_KNOWS_EAS;
}
if (MRxSmbSecuritySignaturesEnabled) {
Flags2 |= SMB_FLAGS2_SMB_SECURITY_SIGNATURE;
}
//DOWNLEVEL.NOTCORE flags for lanman10
RtlZeroMemory(pSmbHeader,sizeof(SMB_HEADER));
*((PULONG)&pSmbHeader->Protocol) = SMB_HEADER_PROTOCOL;
pSmbHeader->Flags = Flags;
pSmbHeader->Flags2 = Flags2;
pSmbHeader->Pid = MRXSMB_PROCESS_ID;
pSmbHeader->Uid = 0;
pSmbHeader->Tid = 0;
pSmbHeader->ErrorClass = 0;
pSmbHeader->Reserved = 0;
pSmbCommand = &pSmbHeader->Command;
SmbPutUshort(&pSmbHeader->Error,0);
switch (SmbCeGetServerType(pServerEntry)) {
case SMBCEDB_MAILSLOT_SERVER :
break;
case SMBCEDB_FILE_SERVER:
{
BOOLEAN fValidTid;
if (pSessionEntry != NULL) {
pSmbHeader->Uid = pSessionEntry->Session.UserId;
}
if (pExchange->SmbCeContext.pVNetRoot != NULL) {
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;
pVNetRootContext = SmbCeGetAssociatedVNetRootContext(
pExchange->SmbCeContext.pVNetRoot);
fValidTid = BooleanFlagOn(
pVNetRootContext->Flags,
SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);
pSmbHeader->Tid = pVNetRootContext->TreeId;
} else {
fValidTid = TRUE;
}
pSmbBuffer = (PGENERIC_ANDX)(pSmbHeader + 1);
if ((pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR) ||
(pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR)) {
// There is an oppurtunity to compound some SessionSetup/TreeConnect SMB with the
// given SMB command.
if ((pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR) &&
(pSessionEntry->Header.State == SMBCEDB_CONSTRUCTION_IN_PROGRESS)) {
if (( pServer->DialectFlags & DF_EXTENDNEGOT) ||
( pServer->DialectFlags & DF_NTNEGOTIATE)) {
RxDbgTrace( 0, Dbg, ("SmbCeBuildSmbHeader: Building Session setup And X\n"));
*pSmbCommand = SMB_COM_SESSION_SETUP_ANDX;
LastCommandInHeader = *pSmbCommand;
pSmbCommand = &pSmbBuffer->AndXCommand;
pSmbHeader->Tid = 0;
Status = SMBCE_SERVER_DIALECT_DISPATCH(
pServer,
BuildSessionSetup,
(pExchange,
pSmbBuffer,
&SmbBufferUnconsumed));
if (NT_SUCCESS(Status)) {
// Update the buffer for the construction of the following SMB.
SmbPutUshort(
&pSmbBuffer->AndXOffset,
(USHORT)(BufferLength - SmbBufferUnconsumed));
pSmbBuffer = (PGENERIC_ANDX)((PBYTE)pBuffer + BufferLength - SmbBufferUnconsumed);
if (pServerEntry->SecuritySignaturesEnabled &&
!pServerEntry->SecuritySignaturesActive) {
RtlCopyMemory(pSmbHeader->SecuritySignature,InitialSecuritySignature,SMB_SECURITY_SIGNATURE_LENGTH);
}
}
}
} else {
NOTHING; //no sess for share level AT LEAST NOT FOR CORE!!!
}
if (NT_SUCCESS(Status) &&
(pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR) &&
!fValidTid) {
BOOLEAN BuildingTreeConnectAndX = BooleanFlagOn(pServer->DialectFlags,DF_LANMAN10);
//CODE.IMPROVEMENT this is not wholly satisfactory....we have encapsulated which smb we're building
// in the dialect dispatch vector and yet we're setting the smb externally.
if (BuildingTreeConnectAndX) {
RxDbgTrace( 0, Dbg, ("SmbCeBuildSmbHeader: Building Tree Connect And X\n"));
*pSmbCommand = SMB_COM_TREE_CONNECT_ANDX;
LastCommandInHeader = *pSmbCommand;
} else {
RxDbgTrace( 0, Dbg, ("SmbCeBuildSmbHeader: Building Tree Connect No X\n"));
*pSmbCommand = SMB_COM_TREE_CONNECT;
LastCommandInHeader = *pSmbCommand;
}
Status = SMBCE_SERVER_DIALECT_DISPATCH(
pServer,
BuildTreeConnect,
(pExchange,
pSmbBuffer,
&SmbBufferUnconsumed));
if (NT_SUCCESS(Status)) {
// Update the buffer for the construction of the following SMB.
if (BuildingTreeConnectAndX) {
pSmbCommand = &pSmbBuffer->AndXCommand;
SmbPutUshort(&pSmbBuffer->AndXOffset,(USHORT)(BufferLength - SmbBufferUnconsumed));
} else {
pSmbCommand = NULL;
}
}
}
}
}
break;
default:
{
ASSERT(!"Valid Server Type");
Status = STATUS_INVALID_HANDLE;
}
break;
}
*pNextCommandPtr = pSmbCommand;
*pBufferConsumed = BufferLength - SmbBufferUnconsumed;
*pLastCommandInHeader = LastCommandInHeader;
RxDbgTrace( 0, Dbg, ("SmbCeBuildSmbHeader: Buffer Consumed %lx\n",*pBufferConsumed));
if (Status != STATUS_SUCCESS) {
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR) {
pExchange->SessionSetupStatus = Status;
}
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR) {
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;
pVNetRootContext = SmbCeGetExchangeVNetRootContext(pExchange);
SmbCeUpdateVNetRootContextState(
pVNetRootContext,
SMBCEDB_INVALID);
}
}
return Status;
}
typedef struct __Service_Name_Entry {
NET_ROOT_TYPE NetRootType;
USHORT NameLength;
PBYTE Name;
};
struct __Service_Name_Entry ServiceNameTable[] = {
{NET_ROOT_DISK,sizeof(SHARE_TYPE_NAME_DISK),SHARE_TYPE_NAME_DISK},
{NET_ROOT_PIPE,sizeof(SHARE_TYPE_NAME_PIPE),SHARE_TYPE_NAME_PIPE},
{NET_ROOT_PRINT,sizeof(SHARE_TYPE_NAME_PRINT),SHARE_TYPE_NAME_PRINT},
{NET_ROOT_COMM,sizeof(SHARE_TYPE_NAME_COMM),SHARE_TYPE_NAME_COMM} //COMM must be last
};
UNICODE_STRING FileSystem_NTFS_UNICODE = {8,8,L"NTFS"};
UNICODE_STRING FileSystem_FAT_UNICODE = {6,6,L"FAT"};
CHAR FileSystem_NTFS[] = "NTFS";
CHAR FileSystem_FAT[] = "FAT";
NTSTATUS
SmbCeParseSmbHeader(
PSMB_EXCHANGE pExchange,
PSMB_HEADER pSmbHeader,
PGENERIC_ANDX pCommandToProcess,
NTSTATUS *pSmbResponseStatus,
ULONG BytesAvailable,
ULONG BytesIndicated,
PULONG pBytesConsumed)
/*++
Routine Description:
This routine validates the SMB header associated with any SMB received as part of
an exchange.
Arguments:
pExchange - the exchange for which the SMB is to be constructed.
pSmbHeader - the header of the SMB received
pCommandToProcess - the SMB command to be processed after the header ( Can be NULL )
pSmbResponseStatus - the status in the SMB response header (Can be NULL)
BytesAvailable - the bytes available for processing but not necesarily indicated.
BytesIndicated - the length of the SMB buffer avcailable for perusal
pBytesConsumed - the buffer consumed
Return Value:
RXSTATUS - The return status for the operation
STATUS_MORE_PROCESSING_REQUIRED -- if a copy of the data needs to be done before
processing can be completed. This occurs because sufficient data was not
indicated to process the header.
STATUS_SUCCESS -- the header was processed succesfully. In such cases the GENERIC_ANDX
if not NULL will contain the offset from the start of the buffer and the command
to be processed.
STATUS_* -- They indicate an error which would normally lead to the abortion of the
exchange.
Notes:
This routine is called to parse the SMB header. This centralization allows us to
implement a one stop mechanism for updateing/validating the header fields as well as
resuming the exchanges waiting for the construction of session/net root entry
associated with this exchange
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
NTSTATUS SmbResponseStatus;
PBYTE pSmbBuffer = (PBYTE)pSmbHeader;
UCHAR SmbCommand;
BOOLEAN fUpdateVNetRootContext = FALSE;
SMBCEDB_OBJECT_STATE SessionState;
SMBCEDB_OBJECT_STATE NetRootState;
PMRX_V_NET_ROOT pVNetRoot;
PSMBCEDB_SERVER_ENTRY pServerEntry;
PSMBCEDB_SESSION_ENTRY pSessionEntry;
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry;
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;
pVNetRoot = SmbCeGetExchangeVNetRoot(pExchange);
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
pNetRootEntry = SmbCeGetExchangeNetRootEntry(pExchange);
pVNetRootContext = SmbCeGetExchangeVNetRootContext(pExchange);
// Return Immediately if bytes indicated is less then the size of a SMB header.
if (BytesIndicated < sizeof(SMB_HEADER)) {
*pBytesConsumed = BytesIndicated;
return STATUS_INVALID_NETWORK_RESPONSE;
}
SmbResponseStatus = GetSmbResponseNtStatus(pSmbHeader,pExchange);
if (!NT_SUCCESS(SmbResponseStatus)) {
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader::SMB Response Error %lx\n",SmbResponseStatus));
}
SmbCommand = pSmbHeader->Command;
*pBytesConsumed = sizeof(SMB_HEADER);
pSmbBuffer += *pBytesConsumed;
if (SmbResponseStatus == STATUS_NETWORK_SESSION_EXPIRED) {
// if the session has been timed out on the server, establish the session and retry the operation
SmbResponseStatus = STATUS_RETRY;
InterlockedCompareExchange(&(pSessionEntry->Header.State),
SMBCEDB_RECOVER,
SMBCEDB_ACTIVE);
//DbgPrint("Session timed out on request %x\n", SmbCommand);
}
// There are certain SMB's that effect the connection engine data structures as
// well as the exchange that has been suspended. These are the SMB's used for tree
// connect and session setup.
// In all the other cases no special action is required for the maintenance of the
// connection engine data structures. The Exchange that was suspended needs to be
// resumed.
if (SmbCommand == SMB_COM_SESSION_SETUP_ANDX) {
if (SmbResponseStatus != RX_MAP_STATUS(SUCCESS)) {
if ((FIELD_OFFSET(GENERIC_ANDX,AndXReserved) + *pBytesConsumed) <= BytesIndicated) {
PGENERIC_ANDX pGenericAndX = (PGENERIC_ANDX)pSmbBuffer;
if (pGenericAndX->WordCount == 0) {
Status = SmbResponseStatus;
}
pExchange->SessionSetupStatus = SmbResponseStatus;
}
// Note that the case wherein sufficient bytes are not indicated for the
// GENERIC_ANDX response is handled by the if statement below which
// imposes a more stringent test.
}
if ((Status == STATUS_SUCCESS) &&
(FIELD_OFFSET(RESP_SESSION_SETUP_ANDX,Buffer) + *pBytesConsumed) > BytesIndicated) {
Status = STATUS_MORE_PROCESSING_REQUIRED;
}
if (Status == STATUS_SUCCESS) {
PRESP_SESSION_SETUP_ANDX pSessionSetupResponse;
ULONG SessionSetupResponseLength,ByteCount;
RxDbgTrace( 0, Dbg, ("Processing Session Setup ANd X\n"));
pSessionSetupResponse = (PRESP_SESSION_SETUP_ANDX)(pSmbBuffer);
ByteCount = SmbGetUshort(&pSessionSetupResponse->ByteCount);
if (pSessionSetupResponse->WordCount == 3) {
SmbCommand = pSessionSetupResponse->AndXCommand;
if (SmbCommand == SMB_COM_NO_ANDX_COMMAND) {
SessionSetupResponseLength =
FIELD_OFFSET(RESP_SESSION_SETUP_ANDX,Buffer) + ByteCount;
Status = SmbResponseStatus;
} else {
SessionSetupResponseLength =
SmbGetUshort(&pSessionSetupResponse->AndXOffset) - *pBytesConsumed;
}
//if (ByteCount == 0) {
// //bytecount==0 and NTDIALECT means that this is really w95...change the flags
// PSMBCE_SERVER pServer = &pExchange->SmbCeContext.pServerEntry->Server;
// if (FlagOn(pServer->DialectFlags,DF_NTPROTOCOL)) {
// pServer->DialectFlags &= ~(DF_MIXEDCASEPW);
// pServer->DialectFlags |= DF_W95;
// }
//}
} else {
// NT session setup is handled by another routine.
Status = STATUS_INVALID_NETWORK_RESPONSE;
}
if (NT_SUCCESS(Status)) {
if (SessionSetupResponseLength + *pBytesConsumed <= BytesIndicated) {
*pBytesConsumed += SessionSetupResponseLength;
pSmbBuffer += SessionSetupResponseLength;
pSessionEntry->Session.UserId = pSmbHeader->Uid;
if (FlagOn(SmbGetUshort(&pSessionSetupResponse->Action), SMB_SETUP_USE_LANMAN_KEY)) {
pSessionEntry->Session.Flags |=
SMBCE_SESSION_FLAGS_LANMAN_SESSION_KEY_USED;
}
if (FlagOn(SmbGetUshort(&pSessionSetupResponse->Action), SMB_SETUP_GUEST)) {
pSessionEntry->Session.Flags |=
SMBCE_SESSION_FLAGS_GUEST_SESSION;
}
if (pServerEntry->SecuritySignaturesEnabled &&
!pServerEntry->SecuritySignaturesActive &&
RtlCompareMemory(pSmbHeader->SecuritySignature,
InitialSecuritySignature,
SMB_SECURITY_SIGNATURE_LENGTH) != SMB_SECURITY_SIGNATURE_LENGTH) {
pExchange->SecuritySignatureReturned = TRUE;
}
InterlockedIncrement(&MRxSmbStatistics.Sessions);
} else {
Status = STATUS_MORE_PROCESSING_REQUIRED;
}
} else {
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader::Session setup and X Response %lx\n",Status));
pExchange->SessionSetupStatus = Status;
InterlockedIncrement(&MRxSmbStatistics.FailedSessions);
if ((SmbCommand == SMB_COM_TREE_CONNECT_ANDX) ||
(SmbCommand == SMB_COM_TREE_CONNECT)) {
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader:: Tearing down a tree connection\n"));
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_INVALID;
}
}
}
}
if ((SmbCommand == SMB_COM_TREE_CONNECT_ANDX) &&
NT_SUCCESS(Status)) {
if (SmbResponseStatus != RX_MAP_STATUS(SUCCESS)) {
if ((FIELD_OFFSET(GENERIC_ANDX,AndXReserved) + *pBytesConsumed) <= BytesIndicated) {
PGENERIC_ANDX pGenericAndX = (PGENERIC_ANDX)pSmbBuffer;
if (pGenericAndX->WordCount == 0) {
Status = SmbResponseStatus;
}
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_INVALID;
}
// Note that the case wherein sufficient bytes are not indicated for the
// GENERIC_ANDX response is handled by the if statement below which
// imposes a more stringent test.
}
if ((Status == RX_MAP_STATUS(SUCCESS)) &&
(FIELD_OFFSET(RESP_21_TREE_CONNECT_ANDX,Buffer) + *pBytesConsumed) > BytesIndicated) {
Status = STATUS_MORE_PROCESSING_REQUIRED;
}
if (Status == RX_MAP_STATUS(SUCCESS)) {
USHORT ResponseWordCount;
ULONG TreeConnectResponseLength,TreeConnectByteCount,ServiceStringLength;
PUCHAR pShareTypeResponseString = NULL;
PRESP_21_TREE_CONNECT_ANDX p21TreeConnectAndXResponse;
PUCHAR NativeFileSystem = NULL;
p21TreeConnectAndXResponse = (PRESP_21_TREE_CONNECT_ANDX)(pSmbBuffer);
SmbCommand = p21TreeConnectAndXResponse->AndXCommand;
TreeConnectByteCount = 0;
RxDbgTrace( 0, Dbg, ("Processing Tree Connect and X\n"));
// case out based on the actual response length. Lanman 21 clients or NT clients
// have a longer response.....win95 negotiates NT dialect but uses a <lm21 response format
ResponseWordCount = p21TreeConnectAndXResponse->WordCount;
switch (ResponseWordCount) {
case 0:
Status = SmbResponseStatus;
break;
case 3:
case 7:
{
PRESP_EXTENDED_TREE_CONNECT_ANDX pExtendedTreeConnectAndXResponse;
if (ResponseWordCount == 7) {
pExtendedTreeConnectAndXResponse = (PRESP_EXTENDED_TREE_CONNECT_ANDX)(pSmbBuffer);
pNetRootEntry->MaximalAccessRights =
SmbGetUlong(
&pExtendedTreeConnectAndXResponse->MaximalShareAccessRights);
pNetRootEntry->GuestMaximalAccessRights =
SmbGetUlong(
&pExtendedTreeConnectAndXResponse->GuestMaximalShareAccessRights);
ASSERT(FIELD_OFFSET(RESP_EXTENDED_TREE_CONNECT_ANDX,AndXCommand)
==FIELD_OFFSET(RESP_21_TREE_CONNECT_ANDX,AndXCommand));
pShareTypeResponseString = (PUCHAR)&pExtendedTreeConnectAndXResponse->Buffer;
TreeConnectByteCount = SmbGetUshort(&pExtendedTreeConnectAndXResponse->ByteCount);
TreeConnectResponseLength =
FIELD_OFFSET(RESP_EXTENDED_TREE_CONNECT_ANDX,Buffer) + TreeConnectByteCount;
pNetRootEntry->NetRoot.ChunkShift = 0xC;
pNetRootEntry->NetRoot.ChunkSize =
(1 << pNetRootEntry->NetRoot.ChunkShift);
pNetRootEntry->NetRoot.ClusterShift = 0x9;
pNetRootEntry->NetRoot.CompressionUnitShift = 0xD;
pNetRootEntry->NetRoot.CompressionFormatAndEngine =
COMPRESSION_FORMAT_LZNT1;
NativeFileSystem = &pExtendedTreeConnectAndXResponse->Buffer[3];
} else {
pNetRootEntry->MaximalAccessRights = FILE_ALL_ACCESS;
pNetRootEntry->GuestMaximalAccessRights = 0;
pShareTypeResponseString = (PUCHAR)&p21TreeConnectAndXResponse->Buffer;
TreeConnectByteCount = SmbGetUshort(&p21TreeConnectAndXResponse->ByteCount);
TreeConnectResponseLength =
FIELD_OFFSET(RESP_21_TREE_CONNECT_ANDX,Buffer) + TreeConnectByteCount;
NativeFileSystem = &p21TreeConnectAndXResponse->Buffer[3];
}
pNetRootEntry->NetRoot.UpdateCscShareRights = TRUE;
// Parse and update the optional support bits returned by
// the server
if (pServerEntry->Server.Dialect >= NTLANMAN_DIALECT ) {
USHORT OptionalSupport;
PMRX_NET_ROOT pNetRoot = pVNetRoot->pNetRoot;
OptionalSupport = SmbGetUshort(
&p21TreeConnectAndXResponse->OptionalSupport);
if (FlagOn(OptionalSupport,SMB_SHARE_IS_IN_DFS)) {
pNetRootEntry->NetRoot.DfsAware = TRUE;
SetFlag(pNetRoot->Flags,NETROOT_FLAG_DFS_AWARE_NETROOT);
}
if (FlagOn(OptionalSupport,SMB_UNIQUE_FILE_NAME)) {
SetFlag(pNetRoot->Flags,NETROOT_FLAG_UNIQUE_FILE_NAME);
}
pNetRootEntry->NetRoot.CscFlags = (OptionalSupport & SMB_CSC_MASK);
switch (pNetRootEntry->NetRoot.CscFlags) {
case SMB_CSC_CACHE_AUTO_REINT:
case SMB_CSC_CACHE_VDO:
pNetRootEntry->NetRoot.CscEnabled = TRUE;
pNetRootEntry->NetRoot.CscShadowable = TRUE;
break;
case SMB_CSC_CACHE_MANUAL_REINT:
pNetRootEntry->NetRoot.CscEnabled = TRUE;
pNetRootEntry->NetRoot.CscShadowable = FALSE;
break;
case SMB_CSC_NO_CACHING:
pNetRootEntry->NetRoot.CscEnabled = FALSE;
pNetRootEntry->NetRoot.CscShadowable = FALSE;
}
}
if (SmbCommand == SMB_COM_NO_ANDX_COMMAND) {
Status = SmbResponseStatus;
} else {
TreeConnectResponseLength =
SmbGetUshort(&p21TreeConnectAndXResponse->AndXOffset) -
*pBytesConsumed;
}
}
break;
case 2:
{
PRESP_TREE_CONNECT_ANDX pTreeConnectAndXResponse;
pTreeConnectAndXResponse = (PRESP_TREE_CONNECT_ANDX)(pSmbBuffer);
ASSERT(FIELD_OFFSET(RESP_TREE_CONNECT_ANDX,AndXCommand)
==FIELD_OFFSET(RESP_21_TREE_CONNECT_ANDX,AndXCommand));
pShareTypeResponseString = (PUCHAR)&pTreeConnectAndXResponse->Buffer;
TreeConnectByteCount = SmbGetUshort(&pTreeConnectAndXResponse->ByteCount);
TreeConnectResponseLength =
FIELD_OFFSET(RESP_TREE_CONNECT_ANDX,Buffer) + TreeConnectByteCount;
if (SmbCommand == SMB_COM_NO_ANDX_COMMAND) {
Status = SmbResponseStatus;
} else {
TreeConnectResponseLength =
SmbGetUshort(&pTreeConnectAndXResponse->AndXOffset) -
*pBytesConsumed;
}
// win9x server, returns wordcount of 2 yet has the dialect of NTLANMAN
// which is a bug, but we will work around it.
if (pServerEntry->Server.Dialect >= NTLANMAN_DIALECT ) {
pNetRootEntry->NetRoot.UpdateCscShareRights = TRUE;
pNetRootEntry->MaximalAccessRights = FILE_ALL_ACCESS;
pNetRootEntry->GuestMaximalAccessRights = 0;
// make it look like a MANUAL_REINT guy
pNetRootEntry->NetRoot.CscEnabled = TRUE;
pNetRootEntry->NetRoot.CscShadowable = FALSE;
}
}
break;
default :
Status = STATUS_INVALID_NETWORK_RESPONSE;
}
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader::Tree connect and X Response %lx\n",Status));
if (NT_SUCCESS(Status)) {
PSMBCE_NET_ROOT psmbNetRoot = &(pNetRootEntry->NetRoot);
PSMBCE_SERVER psmbServer = &(pServerEntry->Server);
if (TreeConnectResponseLength + *pBytesConsumed <= BytesIndicated) {
*pBytesConsumed += TreeConnectResponseLength;
// Update the NetRoot fields based on the response.
SetFlag(
pVNetRootContext->Flags,
SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);
RtlCopyMemory(
&pVNetRootContext->TreeId,
&pSmbHeader->Tid,
sizeof(pSmbHeader->Tid));
{ struct __Service_Name_Entry *i;
for (i=ServiceNameTable;;i++) {
ServiceStringLength = i->NameLength;
if (TreeConnectByteCount >= ServiceStringLength) {
if (RtlCompareMemory(
pShareTypeResponseString,
i->Name,
ServiceStringLength)
== ServiceStringLength) {
psmbNetRoot->NetRootType = i->NetRootType;
if (FALSE) DbgPrint("FoundServiceStrng %s len %d type %d\n",i->Name,i->NameLength,i->NetRootType);
break;
}
}
if (i->NetRootType==NET_ROOT_COMM) {
ASSERT(!"Valid Share Type returned in TREE COnnect And X response");
psmbNetRoot->NetRootType = NET_ROOT_DISK;
ServiceStringLength = TreeConnectByteCount;
break;
}
}
}
if (psmbNetRoot->NetRootType == NET_ROOT_DISK) {
if (NativeFileSystem != NULL) {
if (BooleanFlagOn(pServerEntry->Server.DialectFlags,DF_UNICODE)) {
if (RtlCompareMemory(
NativeFileSystem,
FileSystem_NTFS_UNICODE.Buffer,
FileSystem_NTFS_UNICODE.Length)
== FileSystem_NTFS_UNICODE.Length) {
psmbNetRoot->NetRootFileSystem = NET_ROOT_FILESYSTEM_NTFS;
} else if (RtlCompareMemory(
NativeFileSystem,
FileSystem_FAT_UNICODE.Buffer,
FileSystem_FAT_UNICODE.Length)
== FileSystem_FAT_UNICODE.Length) {
psmbNetRoot->NetRootFileSystem = NET_ROOT_FILESYSTEM_FAT;
}
} else {
if (RtlCompareMemory(
NativeFileSystem,
FileSystem_NTFS,
4*sizeof(CHAR))
== 4*sizeof(CHAR)) {
psmbNetRoot->NetRootFileSystem = NET_ROOT_FILESYSTEM_NTFS;
} else if (RtlCompareMemory(
NativeFileSystem,
FileSystem_FAT,
3*sizeof(CHAR))
== 3*sizeof(CHAR)) {
psmbNetRoot->NetRootFileSystem = NET_ROOT_FILESYSTEM_FAT;
}
}
}
psmbNetRoot->MaximumReadBufferSize = psmbServer->MaximumDiskFileReadBufferSize;
psmbNetRoot->MaximumWriteBufferSize = psmbServer->MaximumDiskFileWriteBufferSize;
} else {
psmbNetRoot->MaximumWriteBufferSize = psmbServer->MaximumNonDiskFileWriteBufferSize;
psmbNetRoot->MaximumReadBufferSize = psmbServer->MaximumNonDiskFileReadBufferSize;
}
//if !(NT was negotiated) and bytecount>servicelength, we may have a NativeFs name
if (!FlagOn(psmbServer->DialectFlags,DF_NTNEGOTIATE)
&& (TreeConnectByteCount>ServiceStringLength)) {
PBYTE NativeFs = pShareTypeResponseString+ServiceStringLength;
if (*NativeFs != 0) {
ULONG i;
ULONG maxlenpersmb = TreeConnectByteCount-ServiceStringLength;
ULONG maxlenperarraysize = SMB_MAXIMUM_SUPPORTED_VOLUME_LABEL;
PCHAR p = (PCHAR)(&psmbNetRoot->FileSystemNameA[0]); //dont write into the 0th char
//DbgPrint("we may have one...\n");
for (i=1;;i++){
if (i==maxlenpersmb) {
break;
}
if (i==maxlenperarraysize) {
break;
}
if (NativeFs[i]==0) {
break;
}
}
//save away the name for processing later
RtlCopyMemory(p,NativeFs,i);
p[i] = 0;
//DbgPrint("NativeFs = %s (%d)\n",p,i);
psmbNetRoot->FileSystemNameALength = (UCHAR)i;
}
}
pSmbBuffer += TreeConnectResponseLength;
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_ACTIVE;
} else {
Status = STATUS_MORE_PROCESSING_REQUIRED;
}
} else {
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_INVALID;
}
}
}
if ((SmbCommand == SMB_COM_TREE_CONNECT) &&
NT_SUCCESS(Status)) {
PRESP_TREE_CONNECT pTreeConnectResponse;
ULONG TreeConnectResponseLength;
RxDbgTrace( 0, Dbg, ("Processing Tree Connect\n"));
pTreeConnectResponse = (PRESP_TREE_CONNECT)pSmbBuffer;
TreeConnectResponseLength = FIELD_OFFSET(RESP_TREE_CONNECT,Buffer);
SmbCommand = SMB_COM_NO_ANDX_COMMAND;
if (NT_SUCCESS(SmbResponseStatus)) {
PSMBCE_NET_ROOT psmbNetRoot = &(pNetRootEntry->NetRoot);
PSMBCE_SERVER psmbServer = &(pServerEntry->Server);
if (TreeConnectResponseLength + *pBytesConsumed <= BytesIndicated) {
// Update the NetRoot fields based on the response.
SetFlag(
pVNetRootContext->Flags,
SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);
RtlCopyMemory(
&pVNetRootContext->TreeId,
&pTreeConnectResponse->Tid,
sizeof(pTreeConnectResponse->Tid));
if (psmbServer->Dialect == PCNET1_DIALECT) {
psmbNetRoot->NetRootType = NET_ROOT_DISK;
}
else {
psmbNetRoot->NetRootType = NET_ROOT_WILD;
}
if (psmbServer->MaximumBufferSize == 0){
ULONG MaxBuf = SmbGetUshort(&pTreeConnectResponse->MaxBufferSize);
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader:: setting srvmaxbufsize %ld\n", MaxBuf));
psmbServer->MaximumBufferSize = MaxBuf;
//psmbServer->MaximumDiskFileReadBufferSize =
psmbNetRoot->MaximumWriteBufferSize =
psmbNetRoot->MaximumReadBufferSize =
MaxBuf -
QuadAlign(
sizeof(SMB_HEADER) +
FIELD_OFFSET(
RESP_READ,
Buffer[0]));
}
*pBytesConsumed += TreeConnectResponseLength;
pSmbBuffer += *pBytesConsumed;
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_ACTIVE;
//for CORE, this counts as a successful session setup as well!
pSessionEntry->Session.UserId = pSmbHeader->Uid;
} else {
Status = STATUS_MORE_PROCESSING_REQUIRED;
}
} else {
Status = SmbResponseStatus;
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_MARKED_FOR_DELETION;
}
RxDbgTrace( 0, Dbg, ("SmbCeParseSmbHeader::Tree connect Response %lx\n",Status));
}
if ((SmbResponseStatus == STATUS_USER_SESSION_DELETED) ||
(SmbResponseStatus == STATUS_NETWORK_NAME_DELETED)) {
ClearFlag(
pVNetRootContext->Flags,
SMBCE_V_NET_ROOT_CONTEXT_FLAG_VALID_TID);
InterlockedCompareExchange(
&(pVNetRootContext->Header.State),
SMBCEDB_INVALID,
SMBCEDB_ACTIVE);
InterlockedCompareExchange(
&(pSessionEntry->Header.State),
SMBCEDB_INVALID,
SMBCEDB_ACTIVE);
fUpdateVNetRootContext = TRUE;
NetRootState = SMBCEDB_INVALID;
}
// Initiate further action if the status of the exchange/conenction engine can be
// updated based on the data available.
if (fUpdateVNetRootContext) {
PMRX_NET_ROOT pNetRoot = pExchange->SmbCeContext.pVNetRoot->pNetRoot;
SmbCeUpdateVNetRootContextState(
pVNetRootContext,
NetRootState);
switch (NetRootState) {
case SMBCEDB_ACTIVE:
pNetRoot->MRxNetRootState = MRX_NET_ROOT_STATE_GOOD;
break;
case SMBCEDB_INVALID:
pNetRoot->MRxNetRootState = MRX_NET_ROOT_STATE_DISCONNECTED;
break;
case SMBCEDB_CONSTRUCTION_IN_PROGRESS:
pNetRoot->MRxNetRootState = MRX_NET_ROOT_STATE_RECONN;
break;
default:
pNetRoot->MRxNetRootState = MRX_NET_ROOT_STATE_ERROR;
break;
}
RxDbgTrace( 0, Dbg, ("Dispatching Net root Entry Finalization\n"));
}
if (!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR) &&
!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR)) {
if ((pSmbHeader->Uid != pSessionEntry->Session.UserId) ||
(pSmbHeader->Tid != pVNetRootContext->TreeId)) {
RxLog(("Srvr %lx Xchg %lx RUid %ld RTid %ld\n SUid %ld STid %ld\n",
pServerEntry,pExchange,
pSmbHeader->Uid,pSmbHeader->Tid,
pSessionEntry->Session.UserId,pVNetRootContext->TreeId));
SmbLogError(STATUS_UNSUCCESSFUL,
LOG,
SmbCeParseSmbHeader,
LOGPTR(pServerEntry)
LOGPTR(pExchange)
LOGXSHORT(pSmbHeader->Uid)
LOGXSHORT(pSmbHeader->Tid)
LOGXSHORT(pSessionEntry->Session.UserId)
LOGXSHORT(pVNetRootContext->TreeId));
}
}
pExchange->SmbStatus = SmbResponseStatus; //N.B. no spinlock!
if (Status == STATUS_MORE_PROCESSING_REQUIRED) {
*pBytesConsumed = 0;
} else if (!NT_SUCCESS(Status)) {
*pBytesConsumed = BytesAvailable;
} else {
if (pSmbResponseStatus != NULL) {
*pSmbResponseStatus = SmbResponseStatus;
}
if (pCommandToProcess != NULL) {
PGENERIC_ANDX pGenericAndX = (PGENERIC_ANDX)((PBYTE)pSmbHeader + *pBytesConsumed);
pCommandToProcess->AndXCommand = SmbCommand;
SmbPutUshort(&pCommandToProcess->AndXOffset, (USHORT)*pBytesConsumed);
if ((sizeof(GENERIC_ANDX) + *pBytesConsumed) <= BytesAvailable) {
pCommandToProcess->WordCount = pGenericAndX->WordCount;
} else {
pCommandToProcess->WordCount = 0;
}
}
}
return Status;
}
NTSTATUS
SmbCeResumeExchange(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine resumes an exchange that was suspended in the connection
engine
Arguments:
pExchange - the exchange Instance
Return Value:
The return status for the operation
--*/
{
NTSTATUS Status;
PAGED_CODE();
SmbCeIncrementPendingLocalOperations(pExchange);
// Initiate the exchange
Status = SmbCeInitiateExchange(pExchange);
SmbCeDecrementPendingLocalOperationsAndFinalize(pExchange);
return Status;
}
NTSTATUS
SmbCepInitializeExchange(
PSMB_EXCHANGE *pExchangePointer,
PRX_CONTEXT pRxContext,
PSMBCEDB_SERVER_ENTRY pServerEntry,
PMRX_V_NET_ROOT pVNetRoot,
SMB_EXCHANGE_TYPE Type,
PSMB_EXCHANGE_DISPATCH_VECTOR pDispatchVector)
/*++
Routine Description:
This routine initializes the given exchange instanece
Arguments:
pExchangePointer - the placeholder for the exchange instance. If it is NULL a new one
is allocated.
pRxContext - the associated RxContext
pServerEntry - the associated server entry
pVirtualNetRoot - the virtual net root
Type - the type of the exchange
pDispatchVector - the dispatch vector asscoiated with this instance.
Return Value:
RXSTATUS - The return status for the operation
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PSMB_EXCHANGE pExchange = NULL;
PAGED_CODE();
RxDbgTrace( 0, Dbg, ("SmbCeInitializeExchange: Invoked\n"));
if (*pExchangePointer == NULL) {
// Allocate a new exchange instance.
pExchange = SmbMmAllocateExchange(Type,NULL);
if (pExchange == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
*pExchangePointer = pExchange;
}
if ((Status = SmbCeIncrementActiveExchangeCount()) == STATUS_SUCCESS) {
PSMB_EXCHANGE LocalExchangePointer = *pExchangePointer;
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext;
LocalExchangePointer->CancellationStatus = SMBCE_EXCHANGE_NOT_CANCELLED;
LocalExchangePointer->RxContext = pRxContext;
if (Status == STATUS_SUCCESS) {
if (pVNetRoot != NULL) {
pVNetRootContext = SmbCeGetAssociatedVNetRootContext(pVNetRoot);
LocalExchangePointer->SmbCeContext.pVNetRoot = pVNetRoot;
pServerEntry = SmbCeGetAssociatedServerEntry(pVNetRoot->pNetRoot->pSrvCall);
} else {
ASSERT(pServerEntry != NULL);
pVNetRootContext = NULL;
}
if (pVNetRootContext != NULL) {
SmbCeReferenceVNetRootContext(pVNetRootContext);
LocalExchangePointer->SmbCeContext.pVNetRootContext =
pVNetRootContext;
LocalExchangePointer->SmbCeContext.pServerEntry =
pVNetRootContext->pServerEntry;
} else {
SmbCeReferenceServerEntry(pServerEntry);
LocalExchangePointer->SmbCeContext.pServerEntry =
pServerEntry;
LocalExchangePointer->SmbCeContext.pVNetRootContext = NULL;
}
LocalExchangePointer->SmbCeState = SMBCE_EXCHANGE_INITIALIZATION_START;
LocalExchangePointer->pDispatchVector = pDispatchVector;
LocalExchangePointer->SmbCeFlags &= (SMBCE_EXCHANGE_FLAGS_TO_PRESERVE);
LocalExchangePointer->SmbCeFlags |= (SMBCE_EXCHANGE_REUSE_MID | SMBCE_EXCHANGE_ATTEMPT_RECONNECTS);
}
if (Status != STATUS_SUCCESS) {
SmbCeDecrementActiveExchangeCount();
}
} else {
(*pExchangePointer)->SmbCeFlags |= SMBCE_EXCHANGE_SMBCE_STOPPED;
}
if ((Status == STATUS_SUCCESS) &&
(pRxContext != NULL)) {
PFOBX pFobx = (PFOBX)(pRxContext->pFobx);
PMRX_FCB pFcb = (pRxContext->pFcb);
PSMBCE_SESSION pSession = SmbCeGetExchangeSession(*pExchangePointer);
if ((pSession != NULL) &&
FlagOn(pSession->Flags,SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION) &&
(pRxContext->MajorFunction != IRP_MJ_CREATE) &&
(pRxContext->MajorFunction != IRP_MJ_CLOSE) &&
(pFobx != NULL) &&
(pFcb->pNetRoot != NULL) &&
(pFcb->pNetRoot->Type == NET_ROOT_DISK)) {
PMRX_SRV_OPEN SrvOpen = pFobx->pSrvOpen;
PMRX_SMB_SRV_OPEN smbSrvOpen = MRxSmbGetSrvOpenExtension(SrvOpen);
if ((smbSrvOpen != NULL) &&
(smbSrvOpen->Version != pServerEntry->Server.Version)) {
if (smbSrvOpen->DeferredOpenContext != NULL) {
Status = SmbCeRemoteBootReconnect(*pExchangePointer, pRxContext);
} else {
Status = STATUS_CONNECTION_DISCONNECTED;
pFcb->fShouldBeOrphaned = TRUE;
}
}
}
}
if (pRxContext != NULL &&
pRxContext->MajorFunction != IRP_MJ_CREATE &&
pRxContext->pFcb->Attributes & FILE_ATTRIBUTE_OFFLINE) {
(*pExchangePointer)->IsOffLineFile = TRUE;
}
if (!NT_SUCCESS(Status)) {
if (pExchange != NULL) {
SmbMmFreeExchange(pExchange);
*pExchangePointer = NULL;
}
}
return Status;
}
NTSTATUS
SmbCeInitializeAssociatedExchange(
PSMB_EXCHANGE *pAssociatedExchangePointer,
PSMB_EXCHANGE pMasterExchange,
SMB_EXCHANGE_TYPE Type,
PSMB_EXCHANGE_DISPATCH_VECTOR pDispatchVector)
/*++
Routine Description:
This routine initializes the given exchange instanece
Arguments:
pAssociatedExchangePointer - the placeholder for the exchange instance. If it is NULL a new one
is allocated.
pMasterExchange - the master exchange
Type - the type of the exchange
pDispatchVector - the dispatch vector asscoiated with this instance.
Return Value:
NTSTATUS - The return status for the operation
Notes:
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PAGED_CODE();
if ((pMasterExchange->SmbCeState == SMBCE_EXCHANGE_INITIATED) &&
!FlagOn(pMasterExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE)) {
Status = SmbCeInitializeExchange(
pAssociatedExchangePointer,
NULL,
pMasterExchange->SmbCeContext.pVNetRoot,
Type,
pDispatchVector);
if (Status == STATUS_SUCCESS) {
PSMB_EXCHANGE pAssociatedExchange;
pAssociatedExchange = *pAssociatedExchangePointer;
pAssociatedExchange->SmbCeState = SMBCE_EXCHANGE_INITIATED;
pAssociatedExchange->SmbCeFlags |= SMBCE_ASSOCIATED_EXCHANGE;
SmbCeIncrementPendingLocalOperations(pMasterExchange);
InterlockedIncrement(&pMasterExchange->Master.PendingAssociatedExchanges);
pAssociatedExchange->Associated.pMasterExchange = pMasterExchange;
InitializeListHead(&pAssociatedExchange->WorkQueueItem.List);
}
} else {
Status = STATUS_INVALID_PARAMETER;
}
return Status;
}
NTSTATUS
SmbCeTransformExchange(
PSMB_EXCHANGE pExchange,
SMB_EXCHANGE_TYPE NewType,
PSMB_EXCHANGE_DISPATCH_VECTOR pDispatchVector)
/*++
Routine Description:
This routine transforms an exchange instance of one kind to an exchange instance
of another kind ( A sophisticated form of casting )
Arguments:
pExchange - the exchange instance.
Type - the new type of the exchange
pDispatchVector - the dispatch vector asscoiated with this instance.
Return Value:
RXSTATUS - The return status for the operation
Notes:
As it is currently implemented no restrictions are imposed. Once the number of exchanges
have been established further restrictions will be imposed barring certain kinds of
transformations. The transformation merely switches the dispatch vector associated
with the exchange but the context is left intact.
--*/
{
PAGED_CODE();
pExchange->Type = (UCHAR)NewType;
pExchange->pDispatchVector = pDispatchVector;
return STATUS_SUCCESS;
}
NTSTATUS
SmbCeUpdateSessionEntryAndVNetRootContext(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine updates the session entry and/or vnetrootcontext if this exchange has
been marked as a constructor for a session and/or netroot.
Arguments:
pExchange - the exchange instance.
Return Value:
RXSTATUS - The return status for the operation
--*/
{
PMRX_V_NET_ROOT pVNetRoot = SmbCeGetExchangeVNetRoot(pExchange);
PSMBCEDB_SESSION_ENTRY pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext = SmbCeGetExchangeVNetRootContext(pExchange);
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_SESSION_CONSTRUCTOR) {
ASSERT(pSessionEntry != NULL);
RxDbgTrace( 0, Dbg, ("Dispatching Session Entry Finalization\n"));
SmbCeReferenceSessionEntry(pSessionEntry);
// ASSERT(pExchange->SessionSetupStatus != STATUS_SUCCESS ||
// pSessionEntry->Header.State == SMBCEDB_CONSTRUCTION_IN_PROGRESS);
pVNetRoot->ConstructionStatus = pExchange->SessionSetupStatus;
SmbCeCompleteSessionEntryInitialization(pSessionEntry,
pExchange->SessionSetupStatus,
pExchange->SecuritySignatureReturned);
pExchange->SmbCeFlags &= ~SMBCE_EXCHANGE_SESSION_CONSTRUCTOR;
}
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR) {
ASSERT(pVNetRootContext != NULL);
RxDbgTrace( 0, Dbg, ("Dispatching Net root Entry Finalization\n"));
SmbCeReferenceVNetRootContext(pVNetRootContext);
SmbCeCompleteVNetRootContextInitialization(pVNetRootContext);
pExchange->SmbCeFlags &= ~SMBCE_EXCHANGE_NETROOT_CONSTRUCTOR;
}
return STATUS_SUCCESS;
}
NTSTATUS
SmbCePrepareExchangeForReuse(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine transforms an exchange instance of one kind to an exchange instance
of another kind ( A sophisticated form of casting )
Arguments:
pExchange - the exchange instance.
Return Value:
RXSTATUS - The return status for the operation
--*/
{
PSMBCEDB_SERVER_ENTRY pServerEntry = NULL;
PSMBCEDB_SESSION_ENTRY pSessionEntry = NULL;
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry = NULL;
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext = NULL;
PAGED_CODE();
RxDbgTrace( 0, Dbg, ("SmbCePrepareExchangeForReuse: Invoked\n"));
if (!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_SMBCE_STOPPED)) {
pNetRootEntry = SmbCeGetExchangeNetRootEntry(pExchange);
pSessionEntry = SmbCeGetExchangeSessionEntry(pExchange);
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pVNetRootContext = SmbCeGetExchangeVNetRootContext(pExchange);
if (pServerEntry != NULL) {
// Disassociate the MID associated with the exchange
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_MID_VALID) {
SmbCeDissociateMidFromExchange(pServerEntry,pExchange);
}
// Tear down all the copy data requests associated with this exchange
SmbCePurgeBuffersAssociatedWithExchange(pServerEntry,pExchange);
// Uninitialize the transport associated with the exchange
SmbCeUninitializeExchangeTransport(pExchange);
}
// If this exchange has been marked as a constructor for either a
// session or netroot finalize the appropriate entries. ( mark
// them for deletion so that other exchanges can be resumed )
SmbCeUpdateSessionEntryAndVNetRootContext(pExchange);
if (pVNetRootContext != NULL) {
SmbCeDereferenceVNetRootContext(pVNetRootContext);
} else {
if (pServerEntry != NULL) {
SmbCeDereferenceServerEntry(pServerEntry);
}
}
}
SmbCeFreeBufferForServerResponse(pExchange);
if (FlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE)) {
PSMB_EXCHANGE pMasterExchange;
LONG AssociatedExchangeCount;
pMasterExchange = pExchange->Associated.pMasterExchange;
AssociatedExchangeCount = InterlockedDecrement(
&pMasterExchange->Master.PendingAssociatedExchanges);
if (FlagOn(
pMasterExchange->SmbCeFlags,
SMBCE_ASSOCIATED_EXCHANGES_COMPLETION_HANDLER_ACTIVATED) &&
(AssociatedExchangeCount == 0)){
NTSTATUS Status;
BOOLEAN PostRequest;
ClearFlag(
pMasterExchange->SmbCeFlags,
SMBCE_ASSOCIATED_EXCHANGES_COMPLETION_HANDLER_ACTIVATED);
Status = SMB_EXCHANGE_DISPATCH(
pMasterExchange,
AssociatedExchangesCompletionHandler,
(pMasterExchange,&PostRequest));
RxDbgTrace(0,Dbg,("Master Exchange %lx Assoc. Completion Status %lx\n",pMasterExchange,Status));
}
SmbCeDecrementPendingLocalOperationsAndFinalize(pMasterExchange);
}
return STATUS_SUCCESS;
}
VOID
SmbCeDiscardExchangeWorkerThreadRoutine(PVOID pExchange)
/*++
Routine Description:
This routine discards an exchange.
Arguments:
pExchange - the exchange to be discarded.
Return Value:
RXSTATUS - The return status for the operation
Notes:
Even though this is simple, it cannot be inlined since the destruction of an
exchange instance can be posted to a waorker thread.
--*/
{
PSMB_EXCHANGE pSmbExchange = pExchange;
PAGED_CODE();
RxDbgTrace( 0, Dbg, ("SmbCeDiscardExchange: Invoked\n"));
//RxLog((">>>Discard %lx",pSmbExchange));
// Destory the context
if (pSmbExchange->ReferenceCount == 0) {
SmbCeAcquireResource();
RemoveEntryList(&pSmbExchange->ExchangeList);
SmbCeReleaseResource();
SmbCePrepareExchangeForReuse(pSmbExchange);
SmbCeDecrementActiveExchangeCount();
// Discard the memory associated with the exchange
SmbMmFreeExchange(pSmbExchange);
} else {
RxDbgTrace(
0,
Dbg,
("SmbCeDiscardExchange: Exchange %lx not discarded %ld\n",
pSmbExchange,pSmbExchange->ReferenceCount)
);
}
}
VOID
SmbCeDiscardExchange(PVOID pExchange)
/*++
Routine Description:
This routine discards an exchange.
Arguments:
pExchange - the exchange to be discarded.
Notes:
The destruction of an exchange instance is posted to a worker thread in order to
avoid deadlock in transport.
--*/
{
PSMB_EXCHANGE pSmbExchange = pExchange;
PSMBCEDB_SERVER_ENTRY pServerEntry = SmbCeGetExchangeServerEntry(pSmbExchange);
// Disassociate the MID associated with the exchange
if (pSmbExchange->SmbCeFlags & SMBCE_EXCHANGE_MID_VALID) {
SmbCeDissociateMidFromExchange(pServerEntry,pSmbExchange);
}
RxPostToWorkerThread(
MRxSmbDeviceObject,
CriticalWorkQueue,
&((PSMB_EXCHANGE)pExchange)->WorkQueueItem,
SmbCeDiscardExchangeWorkerThreadRoutine,
(PSMB_EXCHANGE)pExchange);
}
NTSTATUS
SmbCeCancelExchange(
PRX_CONTEXT pRxContext)
/*++
Routine Description:
This routine initiates the cancellation of an exchange.
Arguments:
pRxContext - the RX_CONTEXT instance for which cancellation needs to be
initiated.
Return Value:
NTSTATUS - The return status for the operation
Notes:
The cancellation policy that has been implemented is a "best effort" policy.
Since the server has already committed resources to an operation at its end
the best that we can do within the scope of the SMB protocol is to initiate
a cancellation operation by sending the appropriate SMB_COM_NT_CANCEL command
Not all dialects of SMB support this command. For the downlevel dialects the
best that we can do is to ensure that the MID is not reused during the lifetime
of the connection. This will result in a gradual degradation of performance.
The difficulty in detecting the end of operations is that there are MIDS
--*/
{
NTSTATUS Status = STATUS_SUCCESS;
PSMB_EXCHANGE pExchange;
LIST_ENTRY CancelledExchanges;
PLIST_ENTRY pListEntry;
PMRXSMB_RX_CONTEXT pMRxSmbContext;
PSMBCEDB_NET_ROOT_ENTRY pNetRootEntry = SmbCeGetAssociatedNetRootEntry(pRxContext->pFcb->pNetRoot);
PSMBCEDB_SERVER_ENTRY pServerEntry = pNetRootEntry->pServerEntry;
SmbCeLog(("SmbCe Cancel %lx\n",pRxContext));
SmbLog(LOG,
SmbCeCancelExchange_1,
LOGPTR(pRxContext));
InitializeListHead(&CancelledExchanges);
SmbCeAcquireSpinLock();
pListEntry = pServerEntry->ActiveExchanges.Flink;
//
// With the pipeline write, multiple exchanges can be outstanding for a single RxContext.
// We need to walk through the active exchanges list to find and cancel all of them.
//
while (pListEntry != &pServerEntry->ActiveExchanges) {
PLIST_ENTRY pNextListEntry;
pNextListEntry = pListEntry->Flink;
pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);
pListEntry = pNextListEntry;
if (pExchange->RxContext == pRxContext) {
if (!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED)) {
if (pExchange->ReceivePendingOperations > 0) {
// This exchange is awaiting a response from the server. In all
// these cases a CANCEL command needs to be sent to the server
// This command can only be sent to NT servers. For non NT
// servers this exchange can be terminated with the detrimental
// side effect of reducing the maximum number of commands by 1.
InsertTailList(&CancelledExchanges,&pExchange->CancelledList);
InterlockedIncrement(&pExchange->LocalPendingOperations);
//DbgPrint("Exchange to be cancelled %x %x\n",pExchange,pRxContext);
if (!FlagOn(pServerEntry->Server.DialectFlags,DF_NT_SMBS)) {
if (pExchange->SmbCeFlags & SMBCE_EXCHANGE_MID_VALID) {
NTSTATUS LocalStatus;
LocalStatus = SmbCepDiscardMidAssociatedWithExchange(
pExchange);
ASSERT(LocalStatus == STATUS_SUCCESS);
}
}
} else {
InterlockedCompareExchange(
&pExchange->CancellationStatus,
SMBCE_EXCHANGE_CANCELLED,
SMBCE_EXCHANGE_NOT_CANCELLED);
}
}
}
}
SmbCeReleaseSpinLock();
pListEntry = CancelledExchanges.Flink;
while (pListEntry != &CancelledExchanges) {
PLIST_ENTRY pNextListEntry;
pNextListEntry = pListEntry->Flink;
pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,CancelledList);
RemoveEntryList(&pExchange->CancelledList);
pListEntry = pNextListEntry;
//DbgPrint("Exchange cancelled %x %x\n",pExchange,pRxContext);
SmbCeLog(("SmbCeCancel Initiate %lx\n",pExchange));
SmbLog(LOG,
SmbCeCancelExchange_2,
LOGPTR(pExchange));
if (FlagOn(pServerEntry->Server.DialectFlags,DF_NT_SMBS)) {
UCHAR LastCommandInHeader;
PUCHAR pCommand;
PSMB_HEADER pSmbHeader;
PNT_SMB_HEADER pNtSmbHeader;
BYTE SmbBuffer[TRANSPORT_HEADER_SIZE + CANCEL_BUFFER_SIZE];
PBYTE CancelRequestBuffer = SmbBuffer + TRANSPORT_HEADER_SIZE;
ULONG CancelRequestBufferSize = CANCEL_BUFFER_SIZE;
pSmbHeader = (PSMB_HEADER)CancelRequestBuffer;
pNtSmbHeader = (PNT_SMB_HEADER)pSmbHeader;
// Before issuing the cancel request ensure that if this exchange
// is set as a timed receive operation. This will ensure that if
// the cancel is delayed at the server we will initiate a tear down
// of the connection.
if (!FlagOn(
pExchange->SmbCeFlags,
SMBCE_EXCHANGE_TIMED_RECEIVE_OPERATION)) {
SmbCeAcquireResource();
SmbCeSetExpiryTime(pExchange);
pExchange->SmbCeFlags |= SMBCE_EXCHANGE_TIMED_RECEIVE_OPERATION;
SmbCeReleaseResource();
}
// Build the Cancel request and send it across to the server.
Status = SmbCeBuildSmbHeader(
pExchange,
CancelRequestBuffer,
CancelRequestBufferSize,
&CancelRequestBufferSize,
&LastCommandInHeader,
&pCommand);
ASSERT(LastCommandInHeader == SMB_COM_NO_ANDX_COMMAND);
if (Status == STATUS_SUCCESS) {
PREQ_NT_CANCEL pCancelRequest = (PREQ_NT_CANCEL)(&CancelRequestBuffer[sizeof(SMB_HEADER)]);
PMDL pCancelSmbMdl;
*pCommand = SMB_COM_NT_CANCEL;
SmbPutUshort(&pSmbHeader->Mid,pExchange->Mid);
if (BooleanFlagOn(
pExchange->SmbCeFlags,
SMBCE_EXCHANGE_FULL_PROCESSID_SPECIFIED)) {
ULONG ProcessId;
ProcessId = RxGetRequestorProcessId(pRxContext);
SmbPutUshort(&pNtSmbHeader->Pid, (USHORT)((ProcessId) & 0xFFFF));
SmbPutUshort(&pNtSmbHeader->PidHigh, (USHORT)((ProcessId) >> 16));
}
SmbPutUshort(&pCancelRequest->WordCount,0);
pCancelRequest->ByteCount = 0;
CancelRequestBufferSize = CANCEL_BUFFER_SIZE;
RxAllocateHeaderMdl(
CancelRequestBuffer,
CancelRequestBufferSize,
pCancelSmbMdl
);
if (pCancelSmbMdl != NULL) {
RxProbeAndLockHeaderPages(
pCancelSmbMdl,
KernelMode,
IoModifyAccess,
Status);
if (Status == STATUS_SUCCESS) {
Status = SmbCeSendToServer(
pServerEntry,
RXCE_SEND_SYNCHRONOUS,
pCancelSmbMdl,
CancelRequestBufferSize);
RxUnlockHeaderPages(pCancelSmbMdl);
}
IoFreeMdl(pCancelSmbMdl);
}
}
} else {
SmbCeFinalizeExchangeOnDisconnect(pExchange);
}
InterlockedCompareExchange(
&pExchange->CancellationStatus,
SMBCE_EXCHANGE_CANCELLED,
SMBCE_EXCHANGE_NOT_CANCELLED);
SmbCeDecrementPendingLocalOperationsAndFinalize(pExchange);
}
return Status;
}
NTSTATUS
SmbCeIncrementPendingOperations(
PSMB_EXCHANGE pExchange,
ULONG PendingOperationMask,
PVOID FileName,
ULONG FileLine)
/*++
Routine Description:
This routine increments the appropriate pending operation count
Arguments:
pExchange - the exchange to be finalized.
PendingOperationsMask -- the pending operations to be incremented
Return Value:
RxStatus(SUCCESS) if successful
--*/
{
NTSTATUS Status;
PSMBCEDB_SERVER_ENTRY pServerEntry;
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
SmbCeAcquireSpinLock();
if (!BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED)) {
if ((pServerEntry != NULL) &&
((pServerEntry->ServerStatus == STATUS_SUCCESS) ||
(pExchange->NodeTypeCode == SMB_EXCHANGE_NTC(ADMIN_EXCHANGE)) ||
FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_MAILSLOT_OPERATION))) {
if (PendingOperationMask & SMBCE_LOCAL_OPERATION) {
pExchange->LocalPendingOperations++;
}
if (PendingOperationMask & SMBCE_SEND_COMPLETE_OPERATION) {
pExchange->SendCompletePendingOperations++;
}
if (PendingOperationMask & SMBCE_COPY_DATA_OPERATION) {
pExchange->CopyDataPendingOperations++;
}
if (PendingOperationMask & SMBCE_RECEIVE_OPERATION) {
pExchange->ReceivePendingOperations++;
}
Status = STATUS_SUCCESS;
} else {
if ((PendingOperationMask & SMBCE_LOCAL_OPERATION) &&
(PendingOperationMask & ~SMBCE_LOCAL_OPERATION) == 0) {
pExchange->LocalPendingOperations++;
Status = STATUS_SUCCESS;
} else {
Status = STATUS_CONNECTION_DISCONNECTED;
}
}
} else {
Status = STATUS_UNSUCCESSFUL;
}
SmbCeReleaseSpinLock();
return Status;
}
VOID
SmbCeFinalizeExchangeWorkerThreadRoutine(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This is the worker thread exchange finalization routine.
Arguments:
pExchange - the exchange to be finalized.
--*/
{
BOOLEAN fPostFinalize;
NTSTATUS Status;
PAGED_CODE();
Status = SMB_EXCHANGE_DISPATCH(
pExchange,
Finalize,
(pExchange,&fPostFinalize));
ASSERT(!fPostFinalize && (Status == STATUS_SUCCESS));
}
VOID
SmbCepFinalizeExchange(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This is the common finalization routine used by both the routines below
Arguments:
pExchange - the exchange to be finalized.
--*/
{
BOOLEAN fAssociatedExchange;
ASSERT(FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED));
fAssociatedExchange = BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE);
if (fAssociatedExchange) {
PSMB_EXCHANGE pMasterExchange;
// The local operation will be decremented on resumption of
// the finalization routine
pMasterExchange = pExchange->Associated.pMasterExchange;
SmbCeIncrementPendingLocalOperations(pMasterExchange);
RxPostToWorkerThread(
MRxSmbDeviceObject,
CriticalWorkQueue,
&pExchange->WorkQueueItem,
SmbCepFinalizeAssociatedExchange,
pExchange);
} else {
NTSTATUS Status;
BOOLEAN fPostFinalize = FALSE;
PSMBCEDB_SERVER_ENTRY pServerEntry;
pServerEntry = SmbCeGetExchangeServerEntry(pExchange);
pExchange->ExpiryTime.QuadPart = 0;
if (!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_RETAIN_MID)) {
SmbCeDissociateMidFromExchange(
pServerEntry,
pExchange);
}
Status = SMB_EXCHANGE_DISPATCH(
pExchange,
Finalize,
(pExchange,&fPostFinalize));
if ((Status == STATUS_SUCCESS) &&
fPostFinalize) {
// Post the request to a worker thread so that the finalization can be completed
// at a lower IRQL.
RxPostToWorkerThread(
MRxSmbDeviceObject,
CriticalWorkQueue,
&pExchange->WorkQueueItem,
SmbCeFinalizeExchangeWorkerThreadRoutine,
pExchange);
}
}
}
#define SENTINEL_ENTRY ((PSINGLE_LIST_ENTRY)IntToPtr(0xffffffff))
VOID
SmbCepFinalizeAssociatedExchange(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This is the common finalization routine used by both the routines below
Arguments:
pExchange - the exchange to be finalized.
--*/
{
PSMB_EXCHANGE pMasterExchange;
PSMB_EXCHANGE pAssociatedExchange;
SINGLE_LIST_ENTRY AssociatedExchangeList;
ASSERT(FlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE));
pMasterExchange = pExchange->Associated.pMasterExchange;
ASSERT(pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next != NULL);
for (;;) {
BOOLEAN fAllAssociatedExchangesFinalized = FALSE;
SmbCeAcquireSpinLock();
if (pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next == SENTINEL_ENTRY) {
pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next = NULL;
fAllAssociatedExchangesFinalized = TRUE;
} else if (pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next == NULL) {
fAllAssociatedExchangesFinalized = TRUE;
} else {
AssociatedExchangeList.Next =
pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next;
pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next =
SENTINEL_ENTRY;
}
SmbCeReleaseSpinLock();
if (!fAllAssociatedExchangesFinalized) {
for (;;) {
PSINGLE_LIST_ENTRY pAssociatedExchangeEntry;
pAssociatedExchangeEntry = AssociatedExchangeList.Next;
if ((pAssociatedExchangeEntry != NULL) &&
(pAssociatedExchangeEntry != SENTINEL_ENTRY)) {
NTSTATUS Status;
BOOLEAN fPostFinalize = FALSE;
AssociatedExchangeList.Next = pAssociatedExchangeEntry->Next;
pAssociatedExchange = (PSMB_EXCHANGE)
CONTAINING_RECORD(
pAssociatedExchangeEntry,
SMB_EXCHANGE,
Associated.NextAssociatedExchange);
ASSERT(IsListEmpty(&pAssociatedExchange->WorkQueueItem.List));
Status = SMB_EXCHANGE_DISPATCH(
pAssociatedExchange,
Finalize,
(pAssociatedExchange,&fPostFinalize));
} else {
break;
}
};
} else {
break;
}
}
SmbCeDecrementPendingLocalOperationsAndFinalize(pMasterExchange);
}
BOOLEAN
SmbCeCanExchangeBeFinalized(
PSMB_EXCHANGE pExchange,
PSMBCE_EXCHANGE_STATUS pExchangeStatus)
/*++
Routine Description:
This routine determines if the exchange instance can be finalized.
Arguments:
pExchange - the exchange to be finalized.
pExchangeStatus - the finalization status
Return Value:
TRUE if the exchange can be finalized
Notes:
As a side effect it also sets the SMBCE_EXCHANGE_FINALIZED flag
The SmbCe spin lock must have been acquire on entry
--*/
{
BOOLEAN fFinalizeExchange = FALSE;
BOOLEAN fAssociatedExchange;
fAssociatedExchange = BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_ASSOCIATED_EXCHANGE);
if (!(pExchange->SmbCeFlags & SMBCE_EXCHANGE_FINALIZED)) {
if ((pExchange->ReceivePendingOperations == 0) &&
(pExchange->CopyDataPendingOperations == 0) &&
(pExchange->SendCompletePendingOperations == 0) &&
(pExchange->LocalPendingOperations == 0)) {
fFinalizeExchange = TRUE;
*pExchangeStatus = SmbCeExchangeFinalized;
pExchange->SmbCeFlags |= SMBCE_EXCHANGE_FINALIZED;
if (fAssociatedExchange) {
PSMB_EXCHANGE pMasterExchange = pExchange->Associated.pMasterExchange;
if (pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next != NULL) {
fFinalizeExchange = FALSE;
}
pExchange->Associated.NextAssociatedExchange.Next =
pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next;
pMasterExchange->Master.AssociatedExchangesToBeFinalized.Next =
&pExchange->Associated.NextAssociatedExchange;
}
} else {
*pExchangeStatus = SmbCeExchangeNotFinalized;
}
} else {
*pExchangeStatus = SmbCeExchangeAlreadyFinalized;
}
if (fFinalizeExchange &&
(pExchange->RxContext != NULL)) {
NTSTATUS Status;
PMRXSMB_RX_CONTEXT pMRxSmbContext;
pMRxSmbContext = MRxSmbGetMinirdrContext(pExchange->RxContext);
pMRxSmbContext->pCancelContext = NULL;
Status = RxSetMinirdrCancelRoutine(
pExchange->RxContext,
NULL);
}
return fFinalizeExchange;
}
SMBCE_EXCHANGE_STATUS
SmbCeFinalizeExchange(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine finalizes an exchange instance.
Arguments:
pExchange - the exchange to be finalized.
Return Value:
appropriate exchange status
Notes:
When an exchange is initiated and the start routine is invoked a number of
SMB's are sent. This routine is invoked when all processing pertaining to the
SMB's that have been sent has ceased.
This routine encapsulates all the idiosyncratic behaviour associated with the
transports.
--*/
{
BOOLEAN fFinalizeExchange = FALSE;
SMBCE_EXCHANGE_STATUS ExchangeStatus;
SmbCeAcquireSpinLock();
fFinalizeExchange = SmbCeCanExchangeBeFinalized(
pExchange,
&ExchangeStatus);
SmbCeReleaseSpinLock();
if (fFinalizeExchange) {
SmbCepFinalizeExchange(pExchange);
}
return ExchangeStatus;
}
NTSTATUS
SmbCeDecrementPendingOperations(
PSMB_EXCHANGE pExchange,
ULONG PendingOperationMask,
PVOID FileName,
ULONG FileLine)
/*++
Routine Description:
This routine decrements the corresponding pending operation count
and finalizes an exchange instance if required
Arguments:
pExchange - the exchange to be finalized.
PendingOperationsMask -- the pending operations to be decremented.
Return Value:
appropriate exchange status
Notes:
When an exchange is initiated and the start routine is invoked a number of
SMB's are sent. This routine is invoked when all processing pertaining to the
SMB's that have been sent has ceased.
This routine encapsulates all the idiosyncratic behaviour associated with the
transports.
--*/
{
SmbCeAcquireSpinLock();
ASSERT(!BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED));
if (PendingOperationMask & SMBCE_LOCAL_OPERATION) {
ASSERT(pExchange->LocalPendingOperations > 0);
pExchange->LocalPendingOperations--;
}
if (PendingOperationMask & SMBCE_SEND_COMPLETE_OPERATION) {
ASSERT(pExchange->SendCompletePendingOperations > 0);
pExchange->SendCompletePendingOperations--;
}
if (PendingOperationMask & SMBCE_COPY_DATA_OPERATION) {
ASSERT(pExchange->CopyDataPendingOperations > 0);
pExchange->CopyDataPendingOperations--;
}
if ((PendingOperationMask & SMBCE_RECEIVE_OPERATION) &&
(pExchange->ReceivePendingOperations > 0)) {
pExchange->ReceivePendingOperations--;
}
SmbCeReleaseSpinLock();
return STATUS_SUCCESS;
}
SMBCE_EXCHANGE_STATUS
SmbCeDecrementPendingOperationsAndFinalize(
PSMB_EXCHANGE pExchange,
ULONG PendingOperationMask,
PVOID FileName,
ULONG FileLine)
/*++
Routine Description:
This routine decrements the corresponding pending operation count
and finalizes an exchange instance if required
Arguments:
pExchange - the exchange to be finalized.
PendingOperationsMask -- the pending operations to be decremented.
Return Value:
appropriate exchange status
Notes:
When an exchange is initiated and the start routine is invoked a number of
SMB's are sent. This routine is invoked when all processing pertaining to the
SMB's that have been sent has ceased.
This routine encapsulates all the idiosyncratic behaviour associated with the
transports.
--*/
{
BOOLEAN fFinalizeExchange = FALSE;
SMBCE_EXCHANGE_STATUS ExchangeStatus;
SmbCeAcquireSpinLock();
ASSERT(!BooleanFlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED));
if (PendingOperationMask & SMBCE_LOCAL_OPERATION) {
ASSERT(pExchange->LocalPendingOperations > 0);
pExchange->LocalPendingOperations--;
}
if (PendingOperationMask & SMBCE_SEND_COMPLETE_OPERATION) {
ASSERT(pExchange->SendCompletePendingOperations > 0);
pExchange->SendCompletePendingOperations--;
}
if (PendingOperationMask & SMBCE_COPY_DATA_OPERATION) {
ASSERT(pExchange->CopyDataPendingOperations > 0);
pExchange->CopyDataPendingOperations--;
}
if ((PendingOperationMask & SMBCE_RECEIVE_OPERATION) &&
(pExchange->ReceivePendingOperations > 0)) {
pExchange->ReceivePendingOperations--;
}
fFinalizeExchange = SmbCeCanExchangeBeFinalized(
pExchange,
&ExchangeStatus);
SmbCeReleaseSpinLock();
if (fFinalizeExchange) {
SmbCepFinalizeExchange(pExchange);
}
return ExchangeStatus;
}
VOID
SmbCeFinalizeExchangeOnDisconnect(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine handles the finalization of an exchange instance during transport disconnects
Arguments:
pExchange - the exchange instance
--*/
{
PAGED_CODE();
if (pExchange != NULL) {
pExchange->Status = STATUS_CONNECTION_DISCONNECTED;
pExchange->SmbStatus = STATUS_CONNECTION_DISCONNECTED;
pExchange->ReceivePendingOperations = 0;
SmbCeFinalizeExchange(pExchange);
}
}
extern ULONG OffLineFileTimeoutInterval;
extern ULONG ExtendedSessTimeoutInterval;
VOID
SmbCeSetExpiryTime(
PSMB_EXCHANGE pExchange)
/*++
Routine Description:
This routine sets the expiry time for a timed exchange,
i.e., SMBCE_EXCHANGE_TIMED_OPERATION must be set
Arguments:
pExchange - the exchange instance.
Notes:
--*/
{
LARGE_INTEGER CurrentTime;
LARGE_INTEGER ExpiryTimeInTicks;
KeQueryTickCount( &CurrentTime );
ExpiryTimeInTicks.QuadPart = (1000 * 1000 * 10) / KeQueryTimeIncrement();
if (pExchange->IsOffLineFile) {
ExpiryTimeInTicks.QuadPart = OffLineFileTimeoutInterval * ExpiryTimeInTicks.QuadPart;
} else if (pExchange->SmbCeContext.pServerEntry->Server.ExtendedSessTimeout) {
ExpiryTimeInTicks.QuadPart = ExtendedSessTimeoutInterval * ExpiryTimeInTicks.QuadPart;
//DbgPrint("Set extended sesstimeout for %x %d\n",pExchange,ExtendedSessTimeoutInterval);
} else {
ExpiryTimeInTicks.QuadPart = MRxSmbConfiguration.SessionTimeoutInterval * ExpiryTimeInTicks.QuadPart;
}
pExchange->ExpiryTime.QuadPart = CurrentTime.QuadPart + ExpiryTimeInTicks.QuadPart;
}
BOOLEAN
SmbCeDetectExpiredExchanges(
PSMBCEDB_SERVER_ENTRY pServerEntry)
/*++
Routine Description:
This routine periodically walks the list of timed exchanges and chooses the
instances for finalization.
A timed exchange choosen by this routine will have waited for some network
response for the given time interval
Arguments:
pServerEntry -- the server entry for which this needs to be done
Notes:
--*/
{
BOOLEAN ExpiredExchangesDetected = FALSE;
PSMB_EXCHANGE pExchange;
PLIST_ENTRY pListHead;
PLIST_ENTRY pListEntry;
LARGE_INTEGER CurrentTime;
PAGED_CODE();
KeQueryTickCount( &CurrentTime );
SmbCeAcquireResource();
pListHead = &pServerEntry->ActiveExchanges;
pListEntry = pListHead->Flink;
while (pListEntry != pListHead) {
PLIST_ENTRY pNextListEntry;
pNextListEntry = pListEntry->Flink;
pExchange = (PSMB_EXCHANGE)CONTAINING_RECORD(pListEntry,SMB_EXCHANGE,ExchangeList);
// There are two kinds of exchanges that are candidates for
// time out finalization.
// (1) Any exchange which has a outstanding send complete
// operation which has not completed.
// (2) timed network operation exchanges which have a
// receive or copy data operation pending.
//
// In all such cases the associated server entry is marked
// for tear down and further processing is terminated.
//
if ((pExchange->SendCompletePendingOperations > 0) ||
(FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_TIMED_RECEIVE_OPERATION) &&
((pExchange->CopyDataPendingOperations > 0) ||
(pExchange->ReceivePendingOperations > 0)))) {
if ((pExchange->ExpiryTime.QuadPart != 0) &&
(pExchange->ExpiryTime.QuadPart < CurrentTime.QuadPart) &&
!FlagOn(pExchange->SmbCeFlags,SMBCE_EXCHANGE_FINALIZED)) {
RxLog(("Marking server for tear down %lx \n",pServerEntry));
SmbLogError(STATUS_UNSUCCESSFUL,
LOG,
SmbCeDetectExpiredExchanges,
LOGPTR(pExchange)
LOGPTR(pServerEntry)
LOGUSTR(pServerEntry->Name));
ExpiredExchangesDetected = TRUE;
RxLogRetail(("Exp Exch on %x (Com %x State %x)\n", pServerEntry, pExchange->SmbCommand, pExchange->SmbCeState ));
RxLogRetail(("Rcv %x Loc %x SnCo %x Copy %x\n", pExchange->ReceivePendingOperations, pExchange->LocalPendingOperations,
pExchange->SendCompletePendingOperations, pExchange->CopyDataPendingOperations ));
if( pExchange->Type == TRANSACT_EXCHANGE )
{
PSMB_TRANSACT_EXCHANGE pTransExchange = (PSMB_TRANSACT_EXCHANGE)pExchange;
PRX_CONTEXT RxContext = pTransExchange->RxContext;
RxLogRetail(("TrCmd %x NtTrans %x FID Flags %x Setup %x\n", pTransExchange->TransactSmbCommand,
pTransExchange->NtTransactFunction, pTransExchange->Flags, pTransExchange->SendSetupBufferSize ));
RxLogRetail(("Transact %x (%x,%x)\n", RxContext->ResumeRoutine, RxContext->MajorFunction, RxContext->MinorFunction ));
}
break;
}
}
pListEntry = pNextListEntry;
}
SmbCeReleaseResource();
return ExpiredExchangesDetected;
}
//
// Default handler implementation of exchange handler functions.
//
NTSTATUS
DefaultSmbExchangeIndError(
IN PSMB_EXCHANGE pExchange) // the SMB exchange instance
{
PAGED_CODE();
UNREFERENCED_PARAMETER(pExchange);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DefaultSmbExchangeIndReceive(
IN PSMB_EXCHANGE pExchange) // The exchange instance
{
PAGED_CODE();
UNREFERENCED_PARAMETER(pExchange);
return STATUS_NOT_IMPLEMENTED;
}
NTSTATUS
DefaultSmbExchangeIndSendCallback(
IN PSMB_EXCHANGE pExchange) // The exchange instance
{
PAGED_CODE();
UNREFERENCED_PARAMETER(pExchange);
return STATUS_NOT_IMPLEMENTED;
}
Reference in a new issue View git blame Copy permalink