You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1802 lines
67 KiB
1802 lines
67 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
write.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the mini redirector call down routines pertaining
|
|
to write of file system objects.
|
|
|
|
Author:
|
|
|
|
Joe Linn [JoeLinn] 7-March-1995
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
#pragma warning(error:4101) // Unreferenced local variable
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, MRxSmbWrite)
|
|
#pragma alloc_text(PAGE, MRxSmbWriteMailSlot)
|
|
#pragma alloc_text(PAGE, MRxSmbBuildWriteRequest)
|
|
#pragma alloc_text(PAGE, SmbPseExchangeStart_Write)
|
|
#pragma alloc_text(PAGE, MRxSmbFinishWrite)
|
|
#endif
|
|
|
|
#define MAX(a,b) ((a) > (b) ? (a) : (b))
|
|
|
|
//
|
|
// The local debug trace level
|
|
//
|
|
|
|
#define Dbg (DEBUG_TRACE_WRITE)
|
|
|
|
#ifndef FORCE_NO_NTWRITEANDX
|
|
#define MRxSmbForceNoNtWriteAndX FALSE
|
|
#else
|
|
BOOLEAN MRxSmbForceNoNtWriteAndX = TRUE;
|
|
#endif
|
|
|
|
#define WRITE_COPY_THRESHOLD 64
|
|
#define FORCECOPYMODE FALSE
|
|
|
|
#ifdef SETFORCECOPYMODE
|
|
#undef FORCECOPYMODE
|
|
#define FORCECOPYMODE MRxSmbForceCopyMode
|
|
ULONG MRxSmbForceCopyMode = TRUE;
|
|
#endif
|
|
|
|
extern ULONG MaxNumOfExchangesForPipelineReadWrite;
|
|
|
|
NTSTATUS
|
|
SmbPseExchangeStart_Write(
|
|
SMBPSE_ORDINARY_EXCHANGE_ARGUMENT_SIGNATURE
|
|
);
|
|
|
|
NTSTATUS
|
|
MRxSmbFindNextSectionForReadWrite(
|
|
SMBPSE_ORDINARY_EXCHANGE_ARGUMENT_SIGNATURE,
|
|
PULONG NumOfOutstandingExchanges
|
|
);
|
|
|
|
ULONG MRxSmbWriteSendOptions = 0;
|
|
|
|
NTSTATUS
|
|
MRxSmbDereferenceGlobalReadWrite (
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite
|
|
)
|
|
{
|
|
ULONG RefCount;
|
|
|
|
RefCount = InterlockedDecrement(&GlobalReadWrite->RefCount);
|
|
SmbCeLog(("Deref GRW %x %d\n",GlobalReadWrite,RefCount));
|
|
|
|
if (RefCount == 0) {
|
|
PRX_CONTEXT RxContext = GlobalReadWrite->RxContext;
|
|
PMRX_SRV_OPEN SrvOpen = RxContext->pRelevantSrvOpen;
|
|
|
|
// update shadow as appropriate
|
|
// We do this here to ensure the shadow is updated only once (at IRP completion)
|
|
IF_NOT_MRXSMB_CSC_ENABLED{
|
|
ASSERT(MRxSmbGetSrvOpenExtension(SrvOpen)->hfShadow == 0);
|
|
} else {
|
|
if (MRxSmbGetSrvOpenExtension(SrvOpen)->hfShadow != 0){
|
|
MRxSmbCscWriteEpilogue(RxContext,&RxContext->StoredStatus);
|
|
}
|
|
}
|
|
|
|
if (BooleanFlagOn(RxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION) &&
|
|
(GlobalReadWrite->SmbFcbHoldingState != SmbFcb_NotHeld)) {
|
|
MRxSmbCscReleaseSmbFcb(RxContext,&GlobalReadWrite->SmbFcbHoldingState);
|
|
}
|
|
|
|
RxContext->StoredStatus = GlobalReadWrite->CompletionStatus;
|
|
RxLowIoCompletion(RxContext);
|
|
|
|
if (!BooleanFlagOn(RxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION)) {
|
|
KeSetEvent(
|
|
GlobalReadWrite->CompletionEvent,
|
|
0,
|
|
FALSE);
|
|
}
|
|
|
|
RxFreePool(GlobalReadWrite);
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
MRxSmbWrite (
|
|
IN PRX_CONTEXT RxContext)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine opens a file across the network.
|
|
|
|
Arguments:
|
|
|
|
RxContext - the RDBSS context
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status = RX_MAP_STATUS(SUCCESS);
|
|
|
|
RxCaptureFcb;
|
|
RxCaptureFobx;
|
|
|
|
PMRX_SRV_OPEN SrvOpen;
|
|
PMRX_SMB_SRV_OPEN smbSrvOpen;
|
|
|
|
PSMB_PSE_ORDINARY_EXCHANGE OrdinaryExchange;
|
|
SMBFCB_HOLDING_STATE SmbFcbHoldingState = SmbFcb_NotHeld;
|
|
|
|
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
|
|
|
|
ULONG NumberOfSections;
|
|
ULONG NumOfOutstandingExchanges = 0;
|
|
ULONG MaximumBufferSizeThisIteration;
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite = NULL;
|
|
ULONG GlobalReadWriteAllocationSize;
|
|
PSMBCE_V_NET_ROOT_CONTEXT pVNetRootContext = NULL;
|
|
BOOLEAN EnablePipelineWrite = TRUE;
|
|
BOOLEAN MsgModePipeOperation = FALSE;
|
|
BOOLEAN ExchangePending = FALSE;
|
|
KEVENT CompletionEvent;
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
RxDbgTrace(+1, Dbg, ("MRxSmbWrite\n", 0 ));
|
|
|
|
// Pipe buffer cannot be bigger than MAX_PIPE_BUFFER_SIZE, otherwise the
|
|
// server has problems.
|
|
if (RxContext->pFcb->pNetRoot->Type == NET_ROOT_PIPE) {
|
|
if (RxContext->CurrentIrpSp->Parameters.Write.Length > MAX_PIPE_BUFFER_SIZE) {
|
|
return STATUS_INVALID_BUFFER_SIZE;
|
|
}
|
|
}
|
|
|
|
if ( NodeType(capFcb) == RDBSS_NTC_MAILSLOT ) {
|
|
// This is an attempt to write on a mailslot file which is handled
|
|
// differently.
|
|
|
|
Status = MRxSmbWriteMailSlot(RxContext);
|
|
|
|
RxDbgTrace(-1, Dbg, ("MRxSmbWrite: Mailslot write returned %lx\n",Status));
|
|
return Status;
|
|
}
|
|
|
|
// For CSC we go ahead and mark an FCB as having been written to.
|
|
// When CSC is turned ON, if this flag is set before we obtained
|
|
// shadow handles, then the data corresponding to the file is
|
|
// deemed stale and is truncated
|
|
|
|
if (NodeType(capFcb) == RDBSS_NTC_STORAGE_TYPE_FILE) {
|
|
PMRX_SMB_FCB smbFcb = MRxSmbGetFcbExtension(capFcb);
|
|
smbFcb->MFlags |= SMB_FCB_FLAG_WRITES_PERFORMED;
|
|
}
|
|
|
|
ASSERT( NodeType(capFobx->pSrvOpen) == RDBSS_NTC_SRVOPEN );
|
|
|
|
SrvOpen = capFobx->pSrvOpen;
|
|
smbSrvOpen = MRxSmbGetSrvOpenExtension(SrvOpen);
|
|
pVNetRootContext = (PSMBCE_V_NET_ROOT_CONTEXT)SrvOpen->pVNetRoot->Context;
|
|
|
|
if (smbSrvOpen->OplockLevel == SMB_OPLOCK_LEVEL_II &&
|
|
!BooleanFlagOn(LowIoContext->ParamsFor.ReadWrite.Flags,
|
|
LOWIO_READWRITEFLAG_PAGING_IO)) {
|
|
PMRX_SRV_CALL pSrvCall;
|
|
|
|
pSrvCall = SrvOpen->pVNetRoot->pNetRoot->pSrvCall;
|
|
|
|
RxIndicateChangeOfBufferingStateForSrvOpen(
|
|
pSrvCall,
|
|
SrvOpen,
|
|
MRxSmbMakeSrvOpenKey(pVNetRootContext->TreeId,smbSrvOpen->Fid),
|
|
ULongToPtr(SMB_OPLOCK_LEVEL_NONE));
|
|
SmbCeLog(("Breaking oplock to None in Write SO %lx\n",SrvOpen));
|
|
SmbLog(LOG,
|
|
MRxSmbWrite,
|
|
LOGPTR(SrvOpen));
|
|
}
|
|
|
|
IF_NOT_MRXSMB_CSC_ENABLED{
|
|
ASSERT(smbSrvOpen->hfShadow == 0);
|
|
} else {
|
|
if (smbSrvOpen->hfShadow != 0){
|
|
NTSTATUS ShadowReadNtStatus;
|
|
ShadowReadNtStatus = MRxSmbCscWritePrologue(
|
|
RxContext,
|
|
&SmbFcbHoldingState);
|
|
|
|
if (ShadowReadNtStatus != STATUS_MORE_PROCESSING_REQUIRED) {
|
|
RxDbgTrace(-1, Dbg, ("MRxSmbWrite shadow hit with status=%08lx\n", ShadowReadNtStatus ));
|
|
return(ShadowReadNtStatus);
|
|
} else {
|
|
RxDbgTrace(0, Dbg, ("MRxSmbWrite shadowmiss with status=%08lx\n", ShadowReadNtStatus ));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (capFcb->pNetRoot->Type == NET_ROOT_PIPE) {
|
|
EnablePipelineWrite = FALSE;
|
|
|
|
if (capFobx->PipeHandleInformation->ReadMode != FILE_PIPE_BYTE_STREAM_MODE) {
|
|
MsgModePipeOperation = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!FlagOn(pVNetRootContext->pServerEntry->Server.DialectFlags,DF_LARGE_WRITEX)) {
|
|
EnablePipelineWrite = FALSE;
|
|
}
|
|
|
|
MaximumBufferSizeThisIteration = pVNetRootContext->pNetRootEntry->NetRoot.MaximumWriteBufferSize;
|
|
|
|
if (MsgModePipeOperation) {
|
|
MaximumBufferSizeThisIteration -= 2;
|
|
}
|
|
|
|
NumberOfSections = LowIoContext->ParamsFor.ReadWrite.ByteCount / MaximumBufferSizeThisIteration;
|
|
|
|
if ( (LowIoContext->ParamsFor.ReadWrite.ByteCount % MaximumBufferSizeThisIteration) ||
|
|
(LowIoContext->ParamsFor.ReadWrite.ByteCount == 0) ) {
|
|
NumberOfSections ++;
|
|
}
|
|
|
|
GlobalReadWriteAllocationSize = sizeof(SMB_PSE_OE_READWRITE) +
|
|
NumberOfSections*sizeof(SMB_PSE_OE_READWRITE_STATE);
|
|
|
|
GlobalReadWrite = RxAllocatePoolWithTag(
|
|
NonPagedPool,
|
|
GlobalReadWriteAllocationSize,
|
|
MRXSMB_RW_POOLTAG);
|
|
|
|
if (GlobalReadWrite == NULL) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
RtlZeroMemory(GlobalReadWrite,GlobalReadWriteAllocationSize);
|
|
|
|
GlobalReadWrite->RxContext = RxContext;
|
|
GlobalReadWrite->MaximumBufferSize = MaximumBufferSizeThisIteration;
|
|
GlobalReadWrite->TotalNumOfSections = NumberOfSections;
|
|
|
|
if (!BooleanFlagOn(RxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION)) {
|
|
KeInitializeEvent(
|
|
&CompletionEvent,
|
|
SynchronizationEvent,
|
|
FALSE);
|
|
|
|
GlobalReadWrite->CompletionEvent = &CompletionEvent;
|
|
}
|
|
|
|
GlobalReadWrite->UserBufferBase = RxLowIoGetBufferAddress( RxContext );
|
|
GlobalReadWrite->ByteOffsetAsLI.QuadPart = LowIoContext->ParamsFor.ReadWrite.ByteOffset;
|
|
GlobalReadWrite->RemainingByteCount = LowIoContext->ParamsFor.ReadWrite.ByteCount;
|
|
|
|
if (GlobalReadWrite->ByteOffsetAsLI.QuadPart == -1 ) {
|
|
GlobalReadWrite->WriteToTheEnd = TRUE;
|
|
GlobalReadWrite->ByteOffsetAsLI.QuadPart = smbSrvOpen->FileInfo.Standard.EndOfFile.QuadPart;
|
|
}
|
|
|
|
if (LowIoContext->ParamsFor.ReadWrite.Buffer != NULL) {
|
|
GlobalReadWrite->UserBufferBase = RxLowIoGetBufferAddress( RxContext );
|
|
} else {
|
|
GlobalReadWrite->UserBufferBase = (PBYTE)1; //any nonzero value will do
|
|
}
|
|
|
|
GlobalReadWrite->CompressedReadOrWrite = FALSE;
|
|
|
|
#if 0
|
|
if (MRxSmbEnableCompression &&
|
|
(capFcb->Attributes & FILE_ATTRIBUTE_COMPRESSED) &&
|
|
(pVNetRootContext->pServerEntry->Server.Capabilities & COMPRESSED_DATA_CAPABILITY)) {
|
|
GlobalReadWrite->CompressedReadOrWrite = TRUE;
|
|
EnablePipelineWrite = FALSE;
|
|
}
|
|
#endif
|
|
|
|
GlobalReadWrite->ThisBufferOffset = 0;
|
|
|
|
GlobalReadWrite->PartialExchangeMdlInUse = FALSE;
|
|
GlobalReadWrite->PartialDataMdlInUse = FALSE;
|
|
GlobalReadWrite->pCompressedDataBuffer = NULL;
|
|
GlobalReadWrite->RefCount = 1;
|
|
GlobalReadWrite->SmbFcbHoldingState = SmbFcbHoldingState;
|
|
|
|
do {
|
|
Status = SmbPseCreateOrdinaryExchange(
|
|
RxContext,
|
|
capFobx->pSrvOpen->pVNetRoot,
|
|
SMBPSE_OE_FROM_WRITE,
|
|
SmbPseExchangeStart_Write,
|
|
&OrdinaryExchange);
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
GlobalReadWrite->CompletionStatus = Status;
|
|
RxDbgTrace(-1, Dbg, ("Couldn't get the smb buf!\n"));
|
|
break;
|
|
}
|
|
|
|
OrdinaryExchange->AsyncResumptionRoutine = SmbPseExchangeStart_Write;
|
|
OrdinaryExchange->GlobalReadWrite = GlobalReadWrite;
|
|
|
|
RtlCopyMemory(&OrdinaryExchange->ReadWrite,
|
|
GlobalReadWrite,
|
|
sizeof(SMB_PSE_OE_READWRITE));
|
|
|
|
if ((capFcb->pNetRoot->Type == NET_ROOT_PIPE) &&
|
|
(capFobx->PipeHandleInformation->ReadMode != FILE_PIPE_BYTE_STREAM_MODE) ) {
|
|
SetFlag(OrdinaryExchange->OpSpecificFlags,OE_RW_FLAG_MSGMODE_PIPE_OPERATION);
|
|
}
|
|
|
|
ExAcquireFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
Status = MRxSmbFindNextSectionForReadWrite(SMBPSE_ORDINARY_EXCHANGE_ARGUMENTS,
|
|
&NumOfOutstandingExchanges);
|
|
|
|
ExReleaseFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
if (Status == STATUS_MORE_PROCESSING_REQUIRED) {
|
|
ULONG RefCount;
|
|
|
|
RefCount = InterlockedIncrement(&GlobalReadWrite->RefCount);
|
|
|
|
SmbCeLog(("Ref GRW %x %d\n",GlobalReadWrite,RefCount));
|
|
SmbCeLog(("Pipeline Write %x %d %d\n",OrdinaryExchange,NumberOfSections,NumOfOutstandingExchanges));
|
|
|
|
Status = SmbPseInitiateOrdinaryExchange(OrdinaryExchange);
|
|
NumberOfSections --;
|
|
|
|
if ( Status != RX_MAP_STATUS(PENDING) ) {
|
|
ExAcquireFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
NumberOfSections ++;
|
|
|
|
GlobalReadWrite->SectionState[OrdinaryExchange->ReadWrite.CurrentSection] = SmbPseOEReadWriteIoStates_Initial;
|
|
SmbCeLog(("Section undo %d\n",OrdinaryExchange->ReadWrite.CurrentSection));
|
|
}
|
|
|
|
if (!OrdinaryExchange->ReadWrite.ReadWriteFinalized) {
|
|
MRxSmbDereferenceGlobalReadWrite(GlobalReadWrite);
|
|
NumOfOutstandingExchanges = InterlockedDecrement(&GlobalReadWrite->NumOfOutstandingOperations);
|
|
} else {
|
|
NumOfOutstandingExchanges --;
|
|
}
|
|
|
|
if ((Status == STATUS_TOO_MANY_COMMANDS) && (NumOfOutstandingExchanges > 0)) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
if ((Status != STATUS_SUCCESS) &&
|
|
(GlobalReadWrite->CompletionStatus == STATUS_SUCCESS)) {
|
|
GlobalReadWrite->CompletionStatus = Status;
|
|
}
|
|
|
|
ExReleaseFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
SmbPseFinalizeOrdinaryExchange(OrdinaryExchange);
|
|
}
|
|
else {
|
|
ExchangePending = TRUE;
|
|
}
|
|
|
|
if (NumOfOutstandingExchanges >= MaxNumOfExchangesForPipelineReadWrite) {
|
|
break;
|
|
}
|
|
} else {
|
|
SmbPseFinalizeOrdinaryExchange(OrdinaryExchange);
|
|
Status = STATUS_PENDING;
|
|
break;
|
|
}
|
|
} while ((Status == STATUS_RETRY) ||
|
|
EnablePipelineWrite &&
|
|
(NumberOfSections > 0) &&
|
|
(Status == STATUS_PENDING));
|
|
|
|
SmbCeLog(("Pipeline Write out %x %d\n",Status,NumberOfSections));
|
|
|
|
MRxSmbDereferenceGlobalReadWrite(GlobalReadWrite);
|
|
|
|
if (!BooleanFlagOn(RxContext->Flags,RX_CONTEXT_FLAG_ASYNC_OPERATION)) {
|
|
KeWaitForSingleObject(
|
|
&CompletionEvent,
|
|
Executive,
|
|
KernelMode,
|
|
FALSE,
|
|
NULL );
|
|
|
|
Status = RxContext->StoredStatus;
|
|
|
|
if (SmbFcbHoldingState != SmbFcb_NotHeld) {
|
|
MRxSmbCscReleaseSmbFcb(
|
|
RxContext,
|
|
&SmbFcbHoldingState);
|
|
}
|
|
} else {
|
|
Status = STATUS_PENDING;
|
|
}
|
|
|
|
RxDbgTrace(-1, Dbg, ("MRxSmbWrite exit with status=%08lx\n", Status ));
|
|
|
|
return(Status);
|
|
} // MRxSmbWrite
|
|
|
|
NTSTATUS
|
|
MRxSmbWriteMailSlot(
|
|
PRX_CONTEXT RxContext
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine processes a write smb for a mail slot.
|
|
|
|
Arguments:
|
|
|
|
RxContext - the RDBSS context
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status = RX_MAP_STATUS(SUCCESS);
|
|
|
|
RxCaptureFcb;
|
|
RxCaptureFobx;
|
|
|
|
PLOWIO_CONTEXT pLowIoContext = &RxContext->LowIoContext;
|
|
|
|
UNICODE_STRING TransactionName;
|
|
UNICODE_STRING MailSlotName;
|
|
PUNICODE_STRING FcbName = &(((PFCB)(capFcb))->FcbTableEntry.Path);
|
|
PUNICODE_STRING AlreadyPrefixedName = GET_ALREADY_PREFIXED_NAME_FROM_CONTEXT(RxContext);
|
|
|
|
PAGED_CODE();
|
|
|
|
if (AlreadyPrefixedName->Length > sizeof(WCHAR)) {
|
|
MailSlotName.Length = AlreadyPrefixedName->Length - sizeof(WCHAR);
|
|
} else {
|
|
MailSlotName.Length = 0;
|
|
}
|
|
|
|
MailSlotName.MaximumLength = MailSlotName.Length;
|
|
MailSlotName.Buffer = AlreadyPrefixedName->Buffer + 1;
|
|
|
|
TransactionName.Length = (USHORT)(s_MailSlotTransactionName.Length +
|
|
MailSlotName.Length);
|
|
TransactionName.MaximumLength = TransactionName.Length;
|
|
TransactionName.Buffer = (PWCHAR)RxAllocatePoolWithTag(
|
|
PagedPool,
|
|
TransactionName.Length,
|
|
MRXSMB_MAILSLOT_POOLTAG);
|
|
|
|
if (TransactionName.Buffer != NULL) {
|
|
USHORT Setup[3]; // Setup params for mailslot write transaction
|
|
USHORT OutputParam;
|
|
|
|
PBYTE pInputDataBuffer = NULL;
|
|
PBYTE pOutputDataBuffer = NULL;
|
|
|
|
ULONG InputDataBufferLength = 0;
|
|
ULONG OutputDataBufferLength = 0;
|
|
|
|
SMB_TRANSACTION_RESUMPTION_CONTEXT ResumptionContext;
|
|
SMB_TRANSACTION_OPTIONS TransactionOptions;
|
|
|
|
TransactionOptions = RxDefaultTransactionOptions;
|
|
|
|
pInputDataBuffer = RxLowIoGetBufferAddress( RxContext );
|
|
InputDataBufferLength= pLowIoContext->ParamsFor.ReadWrite.ByteCount;
|
|
|
|
RtlCopyMemory(
|
|
TransactionName.Buffer,
|
|
s_MailSlotTransactionName.Buffer,
|
|
s_MailSlotTransactionName.Length );
|
|
|
|
RtlCopyMemory(
|
|
(PBYTE)TransactionName.Buffer +
|
|
s_MailSlotTransactionName.Length,
|
|
MailSlotName.Buffer,
|
|
MailSlotName.Length );
|
|
|
|
RxDbgTrace(0, Dbg, ("MRxSmbWriteMailSlot: Mailslot transaction name %wZ\n",&TransactionName));
|
|
|
|
Setup[0] = TRANS_MAILSLOT_WRITE;
|
|
Setup[1] = 0; // Priority of write
|
|
Setup[2] = 2; // Unreliable request (Second class mailslot)
|
|
|
|
TransactionOptions.NtTransactFunction = 0; // TRANSACT2/TRANSACT.
|
|
TransactionOptions.pTransactionName = &TransactionName;
|
|
TransactionOptions.Flags = (SMB_TRANSACTION_NO_RESPONSE |
|
|
SMB_XACT_FLAGS_FID_NOT_NEEDED |
|
|
SMB_XACT_FLAGS_MAILSLOT_OPERATION);
|
|
TransactionOptions.TimeoutIntervalInMilliSeconds =
|
|
SMBCE_TRANSACTION_TIMEOUT_NOT_USED;
|
|
|
|
Status = SmbCeTransact(
|
|
RxContext, // RXContext for transaction
|
|
&TransactionOptions, // transaction options
|
|
Setup, // the setup buffer
|
|
sizeof(Setup), // setup buffer length
|
|
NULL, // the output setup buffer
|
|
0, // output setup buffer length
|
|
NULL, // Input Param Buffer
|
|
0, // Input param buffer length
|
|
&OutputParam, // Output param buffer
|
|
sizeof(OutputParam), // output param buffer length
|
|
pInputDataBuffer, // Input data buffer
|
|
InputDataBufferLength, // Input data buffer length
|
|
NULL, // output data buffer
|
|
0, // output data buffer length
|
|
&ResumptionContext // the resumption context
|
|
);
|
|
|
|
if ( RX_MAP_STATUS(SUCCESS) == Status ) {
|
|
RxContext->InformationToReturn += InputDataBufferLength;
|
|
}
|
|
|
|
RxFreePool( TransactionName.Buffer );
|
|
} else {
|
|
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
RxDbgTrace( 0, Dbg, ("MRxSmbMailSlotWrite: ...returning %lx\n",Status));
|
|
|
|
return Status;
|
|
} // MRxSmbWriteMailSlot
|
|
|
|
NTSTATUS
|
|
MRxSmbPrepareCompressedWriteRequest(
|
|
PSMB_PSE_ORDINARY_EXCHANGE OrdinaryExchange,
|
|
PBYTE *pWriteDataBufferPointer,
|
|
PMDL *pWriteDataMdlPointer)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine prepares the buffers for a compressed write request
|
|
|
|
Arguments:
|
|
|
|
pExchange - the exchange instance
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
Notes:
|
|
|
|
The write requests issued to an uplevel server for a file which is stored in
|
|
a compressed fashion on the server can be classified into two categories ..
|
|
|
|
1) ALIGNED WRITE REQUESTS
|
|
These requests begin at an offset in the file which is an integral
|
|
multiple of the compression chunk size. If the write length is either
|
|
an integral multiple of the number of chunks or the write is at the
|
|
end of the file then the data can be sent as a compressed write request.
|
|
|
|
2) UNALIGNED WRITE REQUESTS
|
|
These requests begin at offsets which are not an integral multiple of
|
|
the compression chunk size.
|
|
|
|
Any Write request submitted by the user can be decomposed into atmost two
|
|
UNALIGNED WRITE REQUESTS and 0 or more ALIGNED WRITE REQUESTS.
|
|
|
|
The RDR adopts a strategy of sending atmst 64K of compressed data alongwith
|
|
the COMPRESSED_DATA_INFO structure in a single write request to the server.
|
|
In the worst case this will involving writing the request 64k at a time
|
|
( no compression possible in the given data ) and in the best case we will
|
|
be able to write using a single request.
|
|
|
|
In addition to the write buffer supplied by the user we require two more
|
|
buffers to complete the write request using compressed data. The first
|
|
buffer is for holding the COMPRESSED_DATA_INFO structure and the second
|
|
buffer is for holding the compressed data. The buffer associated with the
|
|
exchange is used to hold the CDI while a separate buffer is allocated to store
|
|
the compressed data. The two MDL's allocated as part of the
|
|
SMB_PSE_OE_READWRITE is used as the MDLs for the compressed data buffer and
|
|
the COMPRESSED_DATA_INFO structure
|
|
|
|
--*/
|
|
{
|
|
#define COMPRESSED_DATA_BUFFER_SIZE (0x10000)
|
|
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
PSMBSTUFFER_BUFFER_STATE StufferState = &OrdinaryExchange->AssociatedStufferState;
|
|
PSMB_PSE_OE_READWRITE rw = &OrdinaryExchange->ReadWrite;
|
|
PSMBCE_NET_ROOT pNetRoot;
|
|
|
|
PCOMPRESSED_DATA_INFO pCompressedDataInfo;
|
|
PUCHAR pWriteDataBuffer;
|
|
ULONG WriteDataBufferLength,CompressedDataInfoLength;
|
|
ULONG CompressedDataLength;
|
|
USHORT NumberOfChunks;
|
|
|
|
*pWriteDataBufferPointer = NULL;
|
|
*pWriteDataMdlPointer = NULL;
|
|
|
|
pWriteDataBuffer = rw->UserBufferBase + rw->ThisBufferOffset;
|
|
|
|
pNetRoot = SmbCeGetExchangeNetRoot((PSMB_EXCHANGE)OrdinaryExchange);
|
|
|
|
rw->CompressedRequestInProgress = FALSE;
|
|
|
|
if (rw->RemainingByteCount < (2 * pNetRoot->ChunkSize)) {
|
|
WriteDataBufferLength = rw->RemainingByteCount;
|
|
} else if (rw->ByteOffsetAsLI.LowPart & (pNetRoot->ChunkSize - 1)) {
|
|
// The Write request is not aligned at a chunk size. Send the unaligned
|
|
// portion as an uncompressed write request
|
|
|
|
WriteDataBufferLength = pNetRoot->ChunkSize -
|
|
(
|
|
rw->ByteOffsetAsLI.LowPart &
|
|
(pNetRoot->ChunkSize - 1)
|
|
);
|
|
} else {
|
|
PUCHAR pCompressedDataBuffer,pWorkSpaceBuffer;
|
|
ULONG WorkSpaceBufferSize,WorkSpaceFragmentSize;
|
|
|
|
if (rw->pCompressedDataBuffer == NULL) {
|
|
rw->pCompressedDataBuffer = RxAllocatePoolWithTag(
|
|
NonPagedPool,
|
|
COMPRESSED_DATA_BUFFER_SIZE,
|
|
MRXSMB_RW_POOLTAG);
|
|
|
|
if (rw->pCompressedDataBuffer == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
pCompressedDataBuffer = rw->pCompressedDataBuffer;
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
Status = RtlGetCompressionWorkSpaceSize(
|
|
COMPRESSION_FORMAT_LZNT1,
|
|
&WorkSpaceBufferSize,
|
|
&WorkSpaceFragmentSize );
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
pWorkSpaceBuffer = RxAllocatePoolWithTag(
|
|
PagedPool,
|
|
WorkSpaceBufferSize,
|
|
MRXSMB_RW_POOLTAG);
|
|
|
|
if (pWorkSpaceBuffer == NULL) {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
COMPRESSED_DATA_INFO CompressedChunkInfo;
|
|
|
|
USHORT MaximumNumberOfChunks;
|
|
ULONG CompressedChunkInfoLength;
|
|
ULONG RequestByteCount;
|
|
|
|
RequestByteCount = rw->RemainingByteCount -
|
|
(rw->RemainingByteCount & (pNetRoot->ChunkSize - 1));
|
|
|
|
CompressedChunkInfoLength = sizeof(CompressedChunkInfo);
|
|
|
|
pCompressedDataInfo = (PCOMPRESSED_DATA_INFO)
|
|
ROUND_UP_POINTER(
|
|
(StufferState->BufferBase +
|
|
sizeof(SMB_HEADER) +
|
|
FIELD_OFFSET(REQ_NT_WRITE_ANDX,Buffer)),
|
|
ALIGN_QUAD);
|
|
|
|
CompressedDataInfoLength = (ULONG)(StufferState->BufferLimit -
|
|
(PBYTE)pCompressedDataInfo);
|
|
|
|
MaximumNumberOfChunks = (USHORT)(
|
|
(CompressedDataInfoLength -
|
|
FIELD_OFFSET(
|
|
COMPRESSED_DATA_INFO,
|
|
CompressedChunkSizes)) /
|
|
sizeof(ULONG));
|
|
|
|
if ((RequestByteCount / pNetRoot->ChunkSize) < MaximumNumberOfChunks) {
|
|
MaximumNumberOfChunks = (USHORT)(RequestByteCount /
|
|
pNetRoot->ChunkSize);
|
|
}
|
|
|
|
pCompressedDataInfo->CompressionFormatAndEngine =
|
|
pNetRoot->CompressionFormatAndEngine;
|
|
pCompressedDataInfo->ChunkShift =
|
|
pNetRoot->ChunkShift;
|
|
pCompressedDataInfo->CompressionUnitShift =
|
|
pNetRoot->CompressionUnitShift;
|
|
pCompressedDataInfo->ClusterShift =
|
|
pNetRoot->ClusterShift;
|
|
|
|
RtlCopyMemory(
|
|
&CompressedChunkInfo,
|
|
pCompressedDataInfo,
|
|
FIELD_OFFSET(
|
|
COMPRESSED_DATA_INFO,
|
|
NumberOfChunks)
|
|
);
|
|
|
|
NumberOfChunks = 0;
|
|
CompressedDataLength = 0;
|
|
|
|
for (;;) {
|
|
if ((COMPRESSED_DATA_BUFFER_SIZE - CompressedDataLength) <
|
|
pNetRoot->ChunkSize) {
|
|
if (CompressedDataLength == 0) {
|
|
Status = STATUS_SMB_USE_STANDARD;
|
|
}
|
|
break;
|
|
}
|
|
|
|
Status = RtlCompressChunks(
|
|
pWriteDataBuffer,
|
|
pNetRoot->ChunkSize,
|
|
pCompressedDataBuffer,
|
|
(COMPRESSED_DATA_BUFFER_SIZE - CompressedDataLength),
|
|
&CompressedChunkInfo,
|
|
CompressedChunkInfoLength,
|
|
pWorkSpaceBuffer);
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
break;
|
|
}
|
|
|
|
pCompressedDataBuffer += CompressedChunkInfo.CompressedChunkSizes[0];
|
|
CompressedDataLength += CompressedChunkInfo.CompressedChunkSizes[0];
|
|
|
|
pCompressedDataInfo->CompressedChunkSizes[NumberOfChunks] =
|
|
CompressedChunkInfo.CompressedChunkSizes[0];
|
|
|
|
pWriteDataBuffer += pNetRoot->ChunkSize;
|
|
|
|
if (++NumberOfChunks >= MaximumNumberOfChunks) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
if (CompressedDataLength > 0) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
rw->CompressedRequestInProgress = TRUE;
|
|
pWriteDataBuffer = rw->pCompressedDataBuffer;
|
|
WriteDataBufferLength = CompressedDataLength;
|
|
} else if (Status != STATUS_BUFFER_TOO_SMALL) {
|
|
DbgPrint("Failure compressing data -- Status %lx, Switching over to uncompressed\n",Status);
|
|
}
|
|
|
|
if (pWorkSpaceBuffer != NULL) {
|
|
RxFreePool(
|
|
pWorkSpaceBuffer);
|
|
}
|
|
} else {
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
}
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
rw->PartialDataMdlInUse = TRUE;
|
|
|
|
MmInitializeMdl(
|
|
&rw->PartialDataMdl,
|
|
pWriteDataBuffer,
|
|
WriteDataBufferLength);
|
|
|
|
MmBuildMdlForNonPagedPool( &rw->PartialDataMdl );
|
|
|
|
if (rw->CompressedRequestInProgress) {
|
|
rw->CompressedDataInfoLength = FIELD_OFFSET(
|
|
COMPRESSED_DATA_INFO,
|
|
CompressedChunkSizes) +
|
|
NumberOfChunks * sizeof(ULONG);
|
|
pCompressedDataInfo->NumberOfChunks = NumberOfChunks;
|
|
|
|
rw->PartialExchangeMdlInUse = TRUE;
|
|
|
|
MmInitializeMdl(
|
|
&rw->PartialExchangeMdl,
|
|
pCompressedDataInfo,
|
|
rw->CompressedDataInfoLength);
|
|
|
|
MmBuildMdlForNonPagedPool( &rw->PartialExchangeMdl );
|
|
|
|
rw->ThisByteCount = pCompressedDataInfo->NumberOfChunks *
|
|
pNetRoot->ChunkSize;
|
|
|
|
rw->PartialExchangeMdl.Next = &rw->PartialDataMdl;
|
|
|
|
*pWriteDataMdlPointer = &rw->PartialExchangeMdl;
|
|
} else {
|
|
rw->ThisByteCount = WriteDataBufferLength;
|
|
|
|
*pWriteDataMdlPointer = &rw->PartialDataMdl;
|
|
}
|
|
} else {
|
|
// If for whatever reason the compression fails switch over to an
|
|
// uncompressed write mode.
|
|
rw->CompressedReadOrWrite = FALSE;
|
|
}
|
|
|
|
ASSERT(
|
|
!rw->CompressedReadOrWrite ||
|
|
((*pWriteDataMdlPointer != NULL) && (*pWriteDataBufferPointer == NULL)));
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
MRxSmbBuildWriteRequest(
|
|
PSMB_PSE_ORDINARY_EXCHANGE OrdinaryExchange,
|
|
BOOLEAN IsPagingIo,
|
|
UCHAR WriteCommand,
|
|
ULONG ByteCount,
|
|
PLARGE_INTEGER ByteOffsetAsLI,
|
|
PBYTE Buffer,
|
|
PMDL BufferAsMdl)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the start routine for write.
|
|
|
|
Arguments:
|
|
|
|
pExchange - the exchange instance
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
PSMBSTUFFER_BUFFER_STATE StufferState = &OrdinaryExchange->AssociatedStufferState;
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite = OrdinaryExchange->GlobalReadWrite;
|
|
PRX_CONTEXT RxContext = StufferState->RxContext;
|
|
|
|
RxCaptureFcb;
|
|
RxCaptureFobx;
|
|
|
|
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
|
|
|
|
PNT_SMB_HEADER NtSmbHeader = (PNT_SMB_HEADER)(StufferState->BufferBase);
|
|
|
|
PMRX_SRV_OPEN SrvOpen = capFobx->pSrvOpen;
|
|
PMRX_SMB_SRV_OPEN smbSrvOpen = MRxSmbGetSrvOpenExtension(SrvOpen);
|
|
|
|
ULONG OffsetLow,OffsetHigh;
|
|
|
|
PSMB_PSE_OE_READWRITE rw = &OrdinaryExchange->ReadWrite;
|
|
|
|
USHORT WriteMode = 0;
|
|
ULONG DataLengthLow,DataLengthHigh;
|
|
ULONG BytesRemaining = 0;
|
|
BOOLEAN AddLengthBytes = FALSE;
|
|
ULONG WriteCommandSize;
|
|
|
|
PSMBCE_SERVER pServer = SmbCeGetExchangeServer((PSMB_EXCHANGE)OrdinaryExchange);
|
|
BOOLEAN UseNtVersion;
|
|
|
|
UseNtVersion = BooleanFlagOn(pServer->DialectFlags,DF_NT_SMBS) &&
|
|
!MRxSmbForceNoNtWriteAndX;
|
|
|
|
// The data length field in SMB is a USHORT, and hence the data length given
|
|
// needs to be split up into two parts -- DataLengthHigh and DataLengthLow
|
|
DataLengthLow = (ByteCount & 0xffff);
|
|
DataLengthHigh = ((ByteCount & 0xffff0000) >> 16);
|
|
|
|
OffsetLow = ByteOffsetAsLI->LowPart;
|
|
OffsetHigh = ByteOffsetAsLI->HighPart;
|
|
|
|
switch (WriteCommand) {
|
|
case SMB_COM_WRITE_ANDX:
|
|
WriteCommandSize = SMB_REQUEST_SIZE(NT_WRITE_ANDX);
|
|
break;
|
|
case SMB_COM_WRITE:
|
|
WriteCommandSize = SMB_REQUEST_SIZE(WRITE);
|
|
break;
|
|
case SMB_COM_WRITE_PRINT_FILE:
|
|
WriteCommandSize = SMB_REQUEST_SIZE(WRITE_PRINT_FILE);
|
|
break;
|
|
}
|
|
|
|
Status = MRxSmbStartSMBCommand(
|
|
StufferState,
|
|
SetInitialSMB_Never,
|
|
WriteCommand,
|
|
WriteCommandSize,
|
|
NO_EXTRA_DATA,
|
|
NO_SPECIAL_ALIGNMENT,
|
|
RESPONSE_HEADER_SIZE_NOT_SPECIFIED,
|
|
0,0,0,0 STUFFERTRACE(Dbg,'FC'));
|
|
|
|
MRxSmbDumpStufferState(
|
|
1000,
|
|
"SMB Write Request before stuffing",
|
|
StufferState);
|
|
|
|
switch (WriteCommand) {
|
|
case SMB_COM_WRITE_ANDX :
|
|
{
|
|
if ( UseNtVersion && IsPagingIo ) {
|
|
SmbPutAlignedUshort(
|
|
&NtSmbHeader->Flags2,
|
|
SmbGetAlignedUshort(&NtSmbHeader->Flags2)|SMB_FLAGS2_PAGING_IO );
|
|
}
|
|
|
|
// set the writemode correctly....mainly multismb pipe stuff but also
|
|
// writethru for diskfiles
|
|
if (FlagOn(
|
|
OrdinaryExchange->OpSpecificFlags,
|
|
OE_RW_FLAG_MSGMODE_PIPE_OPERATION) ) {
|
|
|
|
//DOWNLEVEL pinball has wants a different value here....see rdr1.
|
|
|
|
// We need to use the GlobalReadWrite structure here because the local one
|
|
// will always have RemainingByteCount == write length. Note that pipe writes
|
|
// will be broken if we do not disable pipeline writes on them..
|
|
BytesRemaining = GlobalReadWrite->RemainingByteCount;
|
|
|
|
// If this write takes more than one Smb then we must set WRITE_RAW.
|
|
// The first Smb of the series must have START_OF_MESSAGE.
|
|
if (!FlagOn(
|
|
OrdinaryExchange->OpSpecificFlags,
|
|
OE_RW_FLAG_SUBSEQUENT_OPERATION) ) {
|
|
if ( rw->ThisByteCount < BytesRemaining ) {
|
|
|
|
// First Smb in a multi SMB write.
|
|
// Add a USHORT at the start of data saying how large the
|
|
// write is.
|
|
|
|
AddLengthBytes = TRUE;
|
|
DataLengthLow += sizeof(USHORT);
|
|
ASSERT(DataLengthHigh == 0);
|
|
|
|
SetFlag(
|
|
OrdinaryExchange->OpSpecificFlags,
|
|
OE_RW_FLAG_REDUCE_RETURNCOUNT);
|
|
|
|
// Tell the server that the data has the length at the start.
|
|
WriteMode |= (SMB_WMODE_WRITE_RAW_NAMED_PIPE |
|
|
SMB_WMODE_START_OF_MESSAGE);
|
|
} else {
|
|
// All fits in one Smb
|
|
WriteMode |= SMB_WMODE_START_OF_MESSAGE;
|
|
}
|
|
} else {
|
|
// any subsequent pipewrites are obviously raw and not the first
|
|
WriteMode |= SMB_WMODE_WRITE_RAW_NAMED_PIPE;
|
|
}
|
|
} else {
|
|
// If the data is to be written in a compressed fashion turn on
|
|
// the compressed data bit in the header
|
|
if ((rw->CompressedReadOrWrite) &&
|
|
(rw->CompressedDataInfoLength > 0)) {
|
|
ASSERT(UseNtVersion);
|
|
|
|
SmbPutAlignedUshort(
|
|
&NtSmbHeader->Flags2,
|
|
SmbGetAlignedUshort(&NtSmbHeader->Flags2) | SMB_FLAGS2_COMPRESSED );
|
|
|
|
// The Remaining field in NT_WRITE_ANDX also doubles as the field
|
|
// in which the CDI length is sent to the server
|
|
BytesRemaining = rw->CompressedDataInfoLength;
|
|
}
|
|
|
|
|
|
//
|
|
// If the file object was opened in write through mode, set write
|
|
// through on the write operation.
|
|
if (FlagOn(RxContext->Flags,RX_CONTEXT_FLAG_WRITE_THROUGH)) {
|
|
WriteMode |= SMB_WMODE_WRITE_THROUGH;
|
|
}
|
|
}
|
|
|
|
MRxSmbStuffSMB (
|
|
StufferState,
|
|
"XwddwwwwQ",
|
|
// X UCHAR WordCount;
|
|
// UCHAR AndXCommand;
|
|
// UCHAR AndXReserved;
|
|
// _USHORT( AndXOffset );
|
|
smbSrvOpen->Fid, // w _USHORT( Fid );
|
|
OffsetLow, // d _ULONG( Offset );
|
|
-1, // d _ULONG( Timeout );
|
|
WriteMode, // w _USHORT( WriteMode );
|
|
BytesRemaining, // w _USHORT( Remaining );
|
|
DataLengthHigh, // w _USHORT( DataLengthHigh );
|
|
DataLengthLow, // w _USHORT( DataLength );
|
|
// Q _USHORT( DataOffset );
|
|
SMB_OFFSET_CHECK(WRITE_ANDX,DataOffset)
|
|
StufferCondition(UseNtVersion), "D",
|
|
SMB_OFFSET_CHECK(NT_WRITE_ANDX,OffsetHigh)
|
|
OffsetHigh, // D NTonly _ULONG( OffsetHigh );
|
|
//
|
|
STUFFER_CTL_NORMAL, "BS5",
|
|
// B _USHORT( ByteCount );
|
|
SMB_WCT_CHECK(((UseNtVersion)?14:12))
|
|
// UCHAR Buffer[1];
|
|
// S //UCHAR Pad[];
|
|
// 5 //UCHAR Data[];
|
|
StufferCondition(AddLengthBytes), "w", LowIoContext->ParamsFor.ReadWrite.ByteCount,
|
|
StufferCondition(Buffer!=NULL), "c!",
|
|
ByteCount,
|
|
Buffer, // c the actual data
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
|
|
case SMB_COM_WRITE :
|
|
{
|
|
MRxSmbStuffSMB (
|
|
StufferState,
|
|
"0wwdwByw",
|
|
// 0 UCHAR WordCount; // Count of parameter words = 5
|
|
smbSrvOpen->Fid, // w _USHORT( Fid ); // File handle
|
|
DataLengthLow, // w _USHORT( Count ); // Number of bytes to be written
|
|
OffsetLow, // d _ULONG( Offset ); // Offset in file to begin write
|
|
BytesRemaining, // w _USHORT( Remaining ); // Bytes remaining to satisfy request
|
|
SMB_WCT_CHECK(5) // B _USHORT( ByteCount ); // Count of data bytes
|
|
// //UCHAR Buffer[1]; // Buffer containing:
|
|
0x01, // y UCHAR BufferFormat; // 0x01 -- Data block
|
|
DataLengthLow, // w _USHORT( DataLength ); // Length of data
|
|
// ULONG Buffer[1]; // Data
|
|
StufferCondition(Buffer!=NULL), "c!",
|
|
ByteCount,
|
|
Buffer, // c the actual data
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
|
|
case SMB_COM_WRITE_PRINT_FILE:
|
|
{
|
|
MRxSmbStuffSMB (
|
|
StufferState,
|
|
"0wByw",
|
|
// 0 UCHAR WordCount; // Count of parameter words = 1
|
|
smbSrvOpen->Fid, // w _USHORT( Fid ); // File handle
|
|
SMB_WCT_CHECK(1) // B _USHORT( ByteCount ); // Count of data bytes; min = 4
|
|
// UCHAR Buffer[1]; // Buffer containing:
|
|
0x01, // y //UCHAR BufferFormat; // 0x01 -- Data block
|
|
DataLengthLow, // w //USHORT DataLength; // Length of data
|
|
// //UCHAR Data[]; // Data
|
|
StufferCondition(Buffer!=NULL), "c!",
|
|
ByteCount,
|
|
Buffer, // c the actual data
|
|
0
|
|
);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Status = STATUS_UNSUCCESSFUL ;
|
|
break;
|
|
}
|
|
|
|
if ( BufferAsMdl ) {
|
|
MRxSmbStuffAppendRawData( StufferState, BufferAsMdl );
|
|
MRxSmbStuffSetByteCount( StufferState );
|
|
}
|
|
|
|
MRxSmbDumpStufferState(
|
|
700,
|
|
"SMB Write Request after stuffing",
|
|
StufferState);
|
|
|
|
if (Status==STATUS_SUCCESS) {
|
|
InterlockedIncrement(&MRxSmbStatistics.SmallWriteSmbs);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
BOOLEAN DisableLargeWrites = 0;
|
|
|
|
NTSTATUS
|
|
SmbPseExchangeStart_Write (
|
|
SMBPSE_ORDINARY_EXCHANGE_ARGUMENT_SIGNATURE
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the start routine for write.
|
|
|
|
Arguments:
|
|
|
|
pExchange - the exchange instance
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
|
|
ULONG StartEntryCount;
|
|
|
|
PSMBSTUFFER_BUFFER_STATE StufferState = &OrdinaryExchange->AssociatedStufferState;
|
|
PSMB_PSE_OE_READWRITE rw = &OrdinaryExchange->ReadWrite;
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite = OrdinaryExchange->GlobalReadWrite;
|
|
ULONG NumOfOutstandingOperations;
|
|
|
|
PLOWIO_CONTEXT LowIoContext = &RxContext->LowIoContext;
|
|
PMDL OriginalDataMdl = LowIoContext->ParamsFor.ReadWrite.Buffer;
|
|
|
|
RxCaptureFcb;
|
|
RxCaptureFobx;
|
|
|
|
PMRX_SRV_OPEN SrvOpen = capFobx->pSrvOpen;
|
|
PMRX_SMB_SRV_OPEN smbSrvOpen = MRxSmbGetSrvOpenExtension(SrvOpen);
|
|
PMRX_SMB_FCB SmbFcb = MRxSmbGetFcbExtension(capFcb);
|
|
|
|
BOOLEAN SynchronousIo, IsPagingIo;
|
|
UCHAR WriteCommand;
|
|
|
|
PAGED_CODE();
|
|
RxDbgTrace(+1, Dbg, ("SmbPseExchangeStart_Write\n"));
|
|
|
|
ASSERT( OrdinaryExchange->Type == ORDINARY_EXCHANGE );
|
|
|
|
ASSERT(
|
|
(
|
|
(OriginalDataMdl!=NULL) &&
|
|
(
|
|
RxMdlIsLocked(OriginalDataMdl) ||
|
|
RxMdlSourceIsNonPaged(OriginalDataMdl)
|
|
)
|
|
) ||
|
|
(
|
|
(OriginalDataMdl==NULL) &&
|
|
(LowIoContext->ParamsFor.ReadWrite.ByteCount==0)
|
|
)
|
|
);
|
|
|
|
ASSERT((OrdinaryExchange->SmbCeFlags&SMBCE_EXCHANGE_ATTEMPT_RECONNECTS) == 0 );
|
|
|
|
OrdinaryExchange->StartEntryCount++;
|
|
StartEntryCount = OrdinaryExchange->StartEntryCount;
|
|
|
|
SynchronousIo = !BooleanFlagOn(
|
|
RxContext->Flags,
|
|
RX_CONTEXT_FLAG_ASYNC_OPERATION);
|
|
|
|
IsPagingIo = BooleanFlagOn(
|
|
LowIoContext->ParamsFor.ReadWrite.Flags,
|
|
LOWIO_READWRITEFLAG_PAGING_IO);
|
|
|
|
// Ensure that the Fid is validated
|
|
SetFlag(OrdinaryExchange->Flags,SMBPSE_OE_FLAG_VALIDATE_FID);
|
|
|
|
for (;;) {
|
|
PSMBCE_SERVER pServer;
|
|
PSMBCE_NET_ROOT pNetRoot;
|
|
|
|
pServer = SmbCeGetExchangeServer(OrdinaryExchange);
|
|
pNetRoot = SmbCeGetExchangeNetRoot(OrdinaryExchange);
|
|
|
|
switch (OrdinaryExchange->OpSpecificState) {
|
|
case SmbPseOEInnerIoStates_Initial:
|
|
{
|
|
OrdinaryExchange->OpSpecificState = SmbPseOEInnerIoStates_ReadyToSend;
|
|
MRxSmbSetInitialSMB( StufferState STUFFERTRACE(Dbg,'FC') );
|
|
}
|
|
//lack of break is intentional
|
|
|
|
case SmbPseOEInnerIoStates_ReadyToSend:
|
|
{
|
|
ULONG MaximumBufferSizeThisIteration;
|
|
PCHAR Buffer = NULL;
|
|
PMDL BufferAsMdl = NULL;
|
|
|
|
OrdinaryExchange->OpSpecificState = SmbPseOEInnerIoStates_OperationOutstanding;
|
|
OrdinaryExchange->SendOptions = MRxSmbWriteSendOptions;
|
|
|
|
if (FlagOn(pServer->DialectFlags,DF_LANMAN10) &&
|
|
FlagOn(pServer->DialectFlags,DF_LARGE_FILES) &&
|
|
(StufferState->RxContext->pFcb->pNetRoot->Type != NET_ROOT_PRINT)) {
|
|
WriteCommand = SMB_COM_WRITE_ANDX;
|
|
} else {
|
|
WriteCommand = SMB_COM_WRITE;
|
|
}
|
|
|
|
MaximumBufferSizeThisIteration = rw->MaximumBufferSize;
|
|
|
|
// There are four parameters pertaining to a write request
|
|
//
|
|
// 1. Write Length -- rw->ThisByteCount
|
|
// 2. Write Offset -- rw->ByteOffsetAsLI
|
|
// 3. Write Buffer -- Buffer
|
|
// 4. Write Buffer as a MDL -- BufferAsMdl
|
|
//
|
|
// All writes can be classified into one of the following
|
|
// categories ...
|
|
//
|
|
// 1. Extremely Small writes
|
|
// These are writes lesser than the COPY_THRESHOLD or
|
|
// we are in a debug mode that forces us to do only small
|
|
// writes.
|
|
//
|
|
// 2. Write requests against downlevel servers or non disk
|
|
// file write requests against up level servers.
|
|
// In all these cases we are constrained by the Server
|
|
// which limits the number of bytes to roughly 4k. This
|
|
// is based upon the Smb Buffer size returned during
|
|
// negotiation.
|
|
//
|
|
// 3. Write requests ( Uncompressed ) against uplevel (NT5+)
|
|
// servers
|
|
// These write requests can be arbitrarily large
|
|
//
|
|
// 4. Write requests (Compressed) against uplevel servers
|
|
// In these cases the server constrains us to send
|
|
// only 64k of compressed data with the added restriction
|
|
// that the compressed data info structure must be less
|
|
// than the SMB buffer size.
|
|
//
|
|
|
|
rw->CompressedDataInfoLength = 0;
|
|
|
|
if ((rw->RemainingByteCount < WRITE_COPY_THRESHOLD) ||
|
|
FORCECOPYMODE) {
|
|
if (FORCECOPYMODE &&
|
|
(rw->ThisByteCount > MaximumBufferSizeThisIteration) ) {
|
|
rw->ThisByteCount = MaximumBufferSizeThisIteration;
|
|
} else {
|
|
rw->ThisByteCount = rw->RemainingByteCount;
|
|
}
|
|
|
|
Buffer = rw->UserBufferBase + rw->ThisBufferOffset;
|
|
|
|
ASSERT( WRITE_COPY_THRESHOLD <= pNetRoot->MaximumWriteBufferSize );
|
|
} else {
|
|
if (rw->CompressedReadOrWrite) {
|
|
MRxSmbPrepareCompressedWriteRequest(
|
|
OrdinaryExchange,
|
|
&Buffer,
|
|
&BufferAsMdl);
|
|
}
|
|
|
|
if (!rw->CompressedReadOrWrite) {
|
|
rw->ThisByteCount = min(
|
|
rw->RemainingByteCount,
|
|
MaximumBufferSizeThisIteration);
|
|
|
|
if ((rw->ThisBufferOffset != 0) ||
|
|
(rw->ThisByteCount != OriginalDataMdl->ByteCount)) {
|
|
MmInitializeMdl(
|
|
&rw->PartialDataMdl,
|
|
0,
|
|
MAX_PARTIAL_DATA_MDL_BUFFER_SIZE);
|
|
|
|
IoBuildPartialMdl(
|
|
OriginalDataMdl,
|
|
&rw->PartialDataMdl,
|
|
(PCHAR)MmGetMdlVirtualAddress(OriginalDataMdl) +
|
|
rw->ThisBufferOffset,
|
|
rw->ThisByteCount );
|
|
|
|
BufferAsMdl = &rw->PartialDataMdl;
|
|
} else {
|
|
BufferAsMdl = OriginalDataMdl;
|
|
}
|
|
}
|
|
}
|
|
|
|
Status = MRxSmbBuildWriteRequest(
|
|
OrdinaryExchange,
|
|
IsPagingIo,
|
|
WriteCommand,
|
|
rw->ThisByteCount,
|
|
&rw->ByteOffsetAsLI,
|
|
Buffer,
|
|
BufferAsMdl);
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
RxDbgTrace(0, Dbg, ("bad write stuffer status........\n"));
|
|
goto FINALLY;
|
|
}
|
|
|
|
InterlockedIncrement(&MRxSmbStatistics.WriteSmbs);
|
|
|
|
Status = SmbPseOrdinaryExchange(
|
|
SMBPSE_ORDINARY_EXCHANGE_ARGUMENTS,
|
|
SMBPSE_OETYPE_WRITE );
|
|
|
|
if ( Status == STATUS_PENDING) {
|
|
goto FINALLY;
|
|
}
|
|
}
|
|
//lack of break is intentional
|
|
|
|
case SmbPseOEInnerIoStates_OperationOutstanding:
|
|
case SmbPseOEInnerIoStates_OperationCompleted:
|
|
{
|
|
NTSTATUS ExchangeStatus;
|
|
|
|
//
|
|
// If we are retrying the operation, then don't touch the SUBSEQUENT flag.
|
|
//
|
|
if( OrdinaryExchange->Status != STATUS_RETRY ) {
|
|
SetFlag( OrdinaryExchange->OpSpecificFlags,OE_RW_FLAG_SUBSEQUENT_OPERATION );
|
|
}
|
|
|
|
OrdinaryExchange->OpSpecificState = SmbPseOEInnerIoStates_ReadyToSend;
|
|
|
|
if (rw->PartialExchangeMdlInUse) {
|
|
MmPrepareMdlForReuse(
|
|
&rw->PartialExchangeMdl);
|
|
rw->PartialDataMdlInUse = FALSE;
|
|
}
|
|
|
|
if (rw->PartialDataMdlInUse) {
|
|
MmPrepareMdlForReuse(
|
|
&rw->PartialDataMdl);
|
|
rw->PartialDataMdlInUse = FALSE;
|
|
}
|
|
|
|
Status = OrdinaryExchange->Status;
|
|
ExchangeStatus = OrdinaryExchange->Status;
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
PSMBCE_SESSION pSession = SmbCeGetExchangeSession(OrdinaryExchange);
|
|
|
|
if (Status == STATUS_RETRY) {
|
|
SmbCeUninitializeExchangeTransport((PSMB_EXCHANGE)OrdinaryExchange);
|
|
Status = SmbCeReconnect(SmbCeGetExchangeVNetRoot(OrdinaryExchange));
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
OrdinaryExchange->Status = STATUS_SUCCESS;
|
|
OrdinaryExchange->SmbStatus = STATUS_SUCCESS;
|
|
Status = SmbCeInitializeExchangeTransport((PSMB_EXCHANGE)OrdinaryExchange);
|
|
ASSERT(Status == STATUS_SUCCESS);
|
|
|
|
if (Status != STATUS_SUCCESS) {
|
|
goto FINALLY;
|
|
}
|
|
} else {
|
|
goto FINALLY;
|
|
}
|
|
} else if (FlagOn(pSession->Flags,SMBCE_SESSION_FLAGS_REMOTE_BOOT_SESSION) &&
|
|
(smbSrvOpen->DeferredOpenContext != NULL) &&
|
|
(Status == STATUS_IO_TIMEOUT ||
|
|
Status == STATUS_BAD_NETWORK_PATH ||
|
|
Status == STATUS_NETWORK_UNREACHABLE ||
|
|
Status == STATUS_USER_SESSION_DELETED ||
|
|
Status == STATUS_REMOTE_NOT_LISTENING ||
|
|
Status == STATUS_CONNECTION_DISCONNECTED)) {
|
|
|
|
Status = SmbCeRemoteBootReconnect((PSMB_EXCHANGE)OrdinaryExchange,RxContext);
|
|
|
|
if (Status == STATUS_SUCCESS) {
|
|
// Resume the write from the previous offset.
|
|
|
|
OrdinaryExchange->SmbStatus = STATUS_SUCCESS;
|
|
SmbCeInitializeExchangeTransport((PSMB_EXCHANGE)OrdinaryExchange);
|
|
} else {
|
|
Status = STATUS_RETRY;
|
|
}
|
|
}
|
|
}
|
|
|
|
ExAcquireFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
if (ExchangeStatus == STATUS_SUCCESS) {
|
|
rw->RemainingByteCount -= rw->BytesReturned;
|
|
RxContext->InformationToReturn += rw->BytesReturned;
|
|
rw->ByteOffsetAsLI.QuadPart += rw->BytesReturned;
|
|
rw->ThisBufferOffset += rw->BytesReturned;
|
|
|
|
if (rw->WriteToTheEnd) {
|
|
smbSrvOpen->FileInfo.Standard.EndOfFile.QuadPart += rw->BytesReturned;
|
|
MRxSmbUpdateFileInfoCacheFileSize(RxContext, (PLARGE_INTEGER)(&smbSrvOpen->FileInfo.Standard.EndOfFile.QuadPart));
|
|
}
|
|
}
|
|
|
|
if ((Status != STATUS_SUCCESS) ||
|
|
(rw->RemainingByteCount ==0)) {
|
|
|
|
if (rw->RemainingByteCount == 0) {
|
|
RxDbgTrace(
|
|
0,
|
|
Dbg,
|
|
(
|
|
"OE %lx TBC %lx RBC %lx BR %lx TBO %lx\n",
|
|
OrdinaryExchange,rw->ThisByteCount,
|
|
rw->RemainingByteCount,
|
|
rw->BytesReturned,
|
|
rw->ThisBufferOffset )
|
|
);
|
|
|
|
RxDbgTrace(
|
|
0,
|
|
Dbg,
|
|
("Bytes written %lx\n",
|
|
RxContext->InformationToReturn)
|
|
);
|
|
|
|
if (rw->pCompressedDataBuffer != NULL) {
|
|
RxFreePool(rw->pCompressedDataBuffer);
|
|
rw->pCompressedDataBuffer = NULL;
|
|
}
|
|
}
|
|
|
|
if (rw->RemainingByteCount == 0 &&
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] == SmbPseOEReadWriteIoStates_OperationOutstanding) {
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] = SmbPseOEReadWriteIoStates_OperationCompleted;
|
|
SmbCeLog(("Section done %d\n",rw->CurrentSection));
|
|
} else {
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] = SmbPseOEReadWriteIoStates_Initial;
|
|
SmbCeLog(("Section undo %d\n",rw->CurrentSection));
|
|
}
|
|
|
|
if ((Status == STATUS_RETRY) ||
|
|
(Status == STATUS_SUCCESS) ||
|
|
(Status == STATUS_SMB_USE_STANDARD)) {
|
|
if (Status == STATUS_SMB_USE_STANDARD) {
|
|
GlobalReadWrite->CompletionStatus = STATUS_SMB_USE_STANDARD;
|
|
}
|
|
|
|
Status = MRxSmbFindNextSectionForReadWrite(SMBPSE_ORDINARY_EXCHANGE_ARGUMENTS,
|
|
&NumOfOutstandingOperations);
|
|
}
|
|
|
|
NumOfOutstandingOperations = InterlockedDecrement(&GlobalReadWrite->NumOfOutstandingOperations);
|
|
|
|
if (Status != STATUS_MORE_PROCESSING_REQUIRED) {
|
|
if ((Status == STATUS_TOO_MANY_COMMANDS) && (NumOfOutstandingOperations > 0)) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
if (Status != STATUS_SUCCESS &&
|
|
GlobalReadWrite->CompletionStatus == STATUS_SUCCESS) {
|
|
GlobalReadWrite->CompletionStatus = Status;
|
|
}
|
|
|
|
rw->ReadWriteFinalized = TRUE;
|
|
|
|
SmbCeLog(("Pipeline Write final %x %x %d\n",OrdinaryExchange,Status,NumOfOutstandingOperations));
|
|
}
|
|
|
|
ExReleaseFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
if (Status != STATUS_MORE_PROCESSING_REQUIRED) {
|
|
goto FINALLY;
|
|
}
|
|
} else {
|
|
ExReleaseFastMutex(&MRxSmbReadWriteMutex);
|
|
}
|
|
|
|
RxDbgTrace(
|
|
0,
|
|
Dbg,
|
|
( "Next Iteration OE %lx RBC %lx TBO %lx\n",
|
|
OrdinaryExchange,
|
|
rw->RemainingByteCount,
|
|
rw->ThisBufferOffset)
|
|
);
|
|
|
|
RxDbgTrace(
|
|
0,
|
|
Dbg,
|
|
("OE %lx TBC %lx, BR %lx\n",
|
|
OrdinaryExchange,
|
|
rw->ThisByteCount,
|
|
rw->BytesReturned));
|
|
|
|
MRxSmbSetInitialSMB(StufferState STUFFERTRACE(Dbg,0));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
FINALLY:
|
|
|
|
if (Status != STATUS_PENDING) {
|
|
BOOLEAN ReadWriteOutStanding = FALSE;
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite = OrdinaryExchange->GlobalReadWrite;
|
|
|
|
if (!rw->ReadWriteFinalized) {
|
|
ExAcquireFastMutex(&MRxSmbReadWriteMutex);
|
|
|
|
if (rw->RemainingByteCount == 0 &&
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] == SmbPseOEReadWriteIoStates_OperationOutstanding) {
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] = SmbPseOEReadWriteIoStates_OperationCompleted;
|
|
SmbCeLog(("Section done %d\n",rw->CurrentSection));
|
|
} else {
|
|
GlobalReadWrite->SectionState[rw->CurrentSection] = SmbPseOEReadWriteIoStates_Initial;
|
|
SmbCeLog(("Section undo %d\n",rw->CurrentSection));
|
|
}
|
|
|
|
NumOfOutstandingOperations = InterlockedDecrement(&GlobalReadWrite->NumOfOutstandingOperations);
|
|
|
|
if ((Status == STATUS_TOO_MANY_COMMANDS) && (NumOfOutstandingOperations > 0)) {
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
if (Status != STATUS_SUCCESS &&
|
|
GlobalReadWrite->CompletionStatus == STATUS_SUCCESS) {
|
|
GlobalReadWrite->CompletionStatus = Status;
|
|
}
|
|
|
|
rw->ReadWriteFinalized = TRUE;
|
|
|
|
SmbCeLog(("Pipeline Write final %x %x %d\n",OrdinaryExchange,Status,NumOfOutstandingOperations));
|
|
|
|
ExReleaseFastMutex(&MRxSmbReadWriteMutex);
|
|
}
|
|
|
|
SmbPseFinalizeOrdinaryExchange(OrdinaryExchange);
|
|
MRxSmbDereferenceGlobalReadWrite(GlobalReadWrite);
|
|
|
|
Status = STATUS_PENDING;
|
|
}
|
|
|
|
RxDbgTrace(-1, Dbg, ("SmbPseExchangeStart_Write exit w %08lx\n", Status ));
|
|
return Status;
|
|
|
|
} // SmbPseExchangeStart_Write
|
|
|
|
NTSTATUS
|
|
MRxSmbFinishWrite (
|
|
IN OUT PSMB_PSE_ORDINARY_EXCHANGE OrdinaryExchange,
|
|
IN PBYTE ResponseBuffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine actually gets the stuff out of the write response and finishes
|
|
the write. Everything you need is locked down... so we can finish in the
|
|
indication routine
|
|
|
|
Arguments:
|
|
|
|
OrdinaryExchange - the exchange instance
|
|
|
|
ResponseBuffer - the response
|
|
|
|
Return Value:
|
|
|
|
RXSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG BytesReturned = 0;
|
|
|
|
PAGED_CODE();
|
|
|
|
RxDbgTrace(+1, Dbg, ("MRxSmbFinishWrite\n"));
|
|
SmbPseOEAssertConsistentLinkageFromOE("MRxSmbFinishWrite:");
|
|
|
|
switch (OrdinaryExchange->LastSmbCommand) {
|
|
case SMB_COM_WRITE_ANDX:
|
|
{
|
|
PSMBCE_SERVER pServer;
|
|
PSMBCE_NET_ROOT pNetRoot;
|
|
PRESP_WRITE_ANDX Response = (PRESP_WRITE_ANDX)ResponseBuffer;
|
|
|
|
if (Response->WordCount != 6 ||
|
|
SmbGetUshort(&Response->ByteCount) != 0) {
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
}
|
|
|
|
pServer = SmbCeGetExchangeServer((PSMB_EXCHANGE)OrdinaryExchange);
|
|
pNetRoot = SmbCeGetExchangeNetRoot((PSMB_EXCHANGE)OrdinaryExchange);
|
|
|
|
BytesReturned = SmbGetUshort( &Response->Count );
|
|
|
|
if (FlagOn(pServer->DialectFlags,DF_LARGE_WRITEX)) {
|
|
ULONG BytesReturnedHigh;
|
|
|
|
BytesReturnedHigh = SmbGetUshort(&Response->CountHigh);
|
|
|
|
BytesReturned = (BytesReturnedHigh << 16) | BytesReturned;
|
|
}
|
|
|
|
if (pNetRoot->NetRootType != NET_ROOT_PIPE) {
|
|
if ((OrdinaryExchange->Status == STATUS_SUCCESS) &&
|
|
(OrdinaryExchange->ReadWrite.ThisByteCount > 2) &&
|
|
(BytesReturned == 0)) {
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
}
|
|
} else {
|
|
// Servers are not setting the bytes returned correctly for
|
|
// pipe writes. This enables us to gracefully handle responses
|
|
// from such servers
|
|
|
|
BytesReturned = OrdinaryExchange->ReadWrite.ThisByteCount;
|
|
}
|
|
|
|
//if we added 2 headerbytes then let's get rid of them......
|
|
if ( FlagOn(OrdinaryExchange->OpSpecificFlags,OE_RW_FLAG_REDUCE_RETURNCOUNT) ) {
|
|
// BytesReturned -= sizeof(USHORT);
|
|
ClearFlag(OrdinaryExchange->OpSpecificFlags,OE_RW_FLAG_REDUCE_RETURNCOUNT);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case SMB_COM_WRITE :
|
|
{
|
|
PRESP_WRITE Response = (PRESP_WRITE)ResponseBuffer;
|
|
|
|
if (Response->WordCount != 1 ||
|
|
SmbGetUshort(&Response->ByteCount) != 0) {
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
}
|
|
|
|
BytesReturned = SmbGetUshort( &Response->Count );
|
|
}
|
|
break;
|
|
|
|
case SMB_COM_WRITE_PRINT_FILE:
|
|
{
|
|
PRESP_WRITE_PRINT_FILE Response = (PRESP_WRITE_PRINT_FILE)ResponseBuffer;
|
|
|
|
if (Response->WordCount != 0) {
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
}
|
|
|
|
//the response does not tell how many bytes were taken! get the byte count from the exchange
|
|
BytesReturned = OrdinaryExchange->ReadWrite.ThisByteCount;
|
|
}
|
|
break;
|
|
|
|
default :
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
break;
|
|
}
|
|
|
|
RxDbgTrace(0, Dbg, ("-->BytesReturned=%08lx\n", BytesReturned));
|
|
|
|
OrdinaryExchange->ReadWrite.BytesReturned = BytesReturned;
|
|
|
|
if (Status == STATUS_SUCCESS &&
|
|
OrdinaryExchange->ReadWrite.ThisByteCount > 2 &&
|
|
BytesReturned > OrdinaryExchange->ReadWrite.ThisByteCount) {
|
|
Status = STATUS_INVALID_NETWORK_RESPONSE;
|
|
|
|
// For safety sake, don't leave the bogus BytesReturned in our buffers
|
|
OrdinaryExchange->ReadWrite.BytesReturned = OrdinaryExchange->ReadWrite.ThisByteCount;
|
|
}
|
|
|
|
// invalidate the name based file info cache since it is almost impossible
|
|
// to know the last write time of the file on the server.
|
|
MRxSmbInvalidateFileInfoCache(OrdinaryExchange->RxContext);
|
|
|
|
// Mark FullDir Cache, weak for bdi : Current Invalidate for correctness
|
|
MRxSmbInvalidateFullDirectoryCacheParent(OrdinaryExchange->RxContext, TRUE);
|
|
|
|
RxDbgTrace(-1, Dbg, ("MRxSmbFinishWrite returning %08lx\n", Status ));
|
|
|
|
return Status;
|
|
} // MRxSmbFinishWrite
|
|
|
|
NTSTATUS
|
|
MRxSmbFindNextSectionForReadWrite(
|
|
SMBPSE_ORDINARY_EXCHANGE_ARGUMENT_SIGNATURE,
|
|
PULONG NumOfOutstandingExchanges
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine find out the next section for the read/write operation and set up the
|
|
exchange readwrite struction accordingly.
|
|
|
|
Arguments:
|
|
|
|
RxContext - the RDBSS context
|
|
|
|
OrdinaryExchange - the exchange instance
|
|
|
|
Return Value:
|
|
|
|
RXSTATUS - The return status for the operation
|
|
|
|
--*/
|
|
{
|
|
RxCaptureFcb;
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG Section;
|
|
BOOLEAN SectionFound = FALSE;
|
|
PSMB_PSE_OE_READWRITE rw = &OrdinaryExchange->ReadWrite;
|
|
PSMB_PSE_OE_READWRITE GlobalReadWrite = OrdinaryExchange->GlobalReadWrite;
|
|
PSMBCE_SERVER pServer;
|
|
|
|
pServer = SmbCeGetExchangeServer(OrdinaryExchange);
|
|
*NumOfOutstandingExchanges = GlobalReadWrite->NumOfOutstandingOperations;
|
|
|
|
if ((GlobalReadWrite->CompletionStatus != STATUS_SUCCESS) &&
|
|
(GlobalReadWrite->CompletionStatus != STATUS_SMB_USE_STANDARD)) {
|
|
|
|
Status = GlobalReadWrite->CompletionStatus;
|
|
goto FINALLY;
|
|
}
|
|
|
|
if (GlobalReadWrite->CompletionStatus == STATUS_SMB_USE_STANDARD) {
|
|
RxContext->InformationToReturn = 0;
|
|
|
|
GlobalReadWrite->CompressedRequestInProgress = FALSE;
|
|
GlobalReadWrite->CompressedReadOrWrite = FALSE;
|
|
GlobalReadWrite->CompletionStatus = STATUS_SUCCESS;
|
|
OrdinaryExchange->Status = STATUS_SUCCESS;
|
|
|
|
for (Section=0;Section<GlobalReadWrite->TotalNumOfSections;Section++) {
|
|
switch (GlobalReadWrite->SectionState[Section]) {
|
|
case SmbPseOEReadWriteIoStates_OperationOutstanding:
|
|
GlobalReadWrite->SectionState[Section] = SmbPseOEReadWriteIoStates_OperationAbandoned;
|
|
break;
|
|
case SmbPseOEReadWriteIoStates_OperationCompleted:
|
|
GlobalReadWrite->SectionState[Section] = SmbPseOEReadWriteIoStates_Initial;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Section=0;Section<GlobalReadWrite->TotalNumOfSections;Section++) {
|
|
if (GlobalReadWrite->SectionState[Section] == SmbPseOEReadWriteIoStates_Initial) {
|
|
GlobalReadWrite->SectionState[Section] = SmbPseOEReadWriteIoStates_OperationOutstanding;
|
|
SectionFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (SectionFound) {
|
|
rw->ByteOffsetAsLI.QuadPart = GlobalReadWrite->ByteOffsetAsLI.QuadPart +
|
|
(ULONGLONG)GlobalReadWrite->MaximumBufferSize*Section;
|
|
|
|
if ((Section == GlobalReadWrite->TotalNumOfSections - 1) &&
|
|
(GlobalReadWrite->RemainingByteCount % GlobalReadWrite->MaximumBufferSize != 0)) {
|
|
rw->RemainingByteCount = GlobalReadWrite->RemainingByteCount % GlobalReadWrite->MaximumBufferSize;
|
|
} else if( GlobalReadWrite->RemainingByteCount != 0 ) {
|
|
rw->RemainingByteCount = GlobalReadWrite->MaximumBufferSize;
|
|
} else {
|
|
rw->RemainingByteCount = 0;
|
|
}
|
|
|
|
rw->ThisBufferOffset = GlobalReadWrite->MaximumBufferSize*Section;
|
|
|
|
rw->CurrentSection = Section;
|
|
|
|
*NumOfOutstandingExchanges = InterlockedIncrement(&GlobalReadWrite->NumOfOutstandingOperations);
|
|
Status = STATUS_MORE_PROCESSING_REQUIRED;
|
|
SmbCeLog(("Next section found %d %x\n",Section,OrdinaryExchange));
|
|
}
|
|
|
|
FINALLY:
|
|
|
|
return Status;
|
|
}
|
|
|