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.
330 lines
9.8 KiB
330 lines
9.8 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
WriteSup.c
|
|
|
|
Abstract:
|
|
|
|
This module implements the Write support routine. This is a common
|
|
write function that is called by write, unbuffered write, and transceive.
|
|
|
|
Author:
|
|
|
|
Gary Kimura [GaryKi] 21-Sep-1990
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "NpProcs.h"
|
|
|
|
//
|
|
// The debug trace level
|
|
//
|
|
|
|
#define Dbg (DEBUG_TRACE_WRITESUP)
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE, NpWriteDataQueue)
|
|
#endif
|
|
|
|
|
|
NTSTATUS
|
|
NpWriteDataQueue (
|
|
IN PDATA_QUEUE WriteQueue,
|
|
IN READ_MODE ReadMode,
|
|
IN PUCHAR WriteBuffer,
|
|
IN ULONG WriteLength,
|
|
IN NAMED_PIPE_TYPE PipeType,
|
|
OUT PULONG WriteRemaining,
|
|
IN PCCB Ccb,
|
|
IN NAMED_PIPE_END NamedPipeEnd,
|
|
IN PETHREAD UserThread,
|
|
IN PLIST_ENTRY DeferredList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This procedure writes data from the write buffer into read entries in
|
|
the write queue. It will also dequeue entries in the queue as necessary.
|
|
|
|
Arguments:
|
|
|
|
WriteQueue - Provides the write queue to process.
|
|
|
|
ReadMode - Supplies the read mode of read entries in the write queue.
|
|
|
|
WriteBuffer - Provides the buffer from which to read the data.
|
|
|
|
WriteLength - Provides the length, in bytes, of WriteBuffer.
|
|
|
|
PipeType - Indicates if type of pipe (i.e., message or byte stream).
|
|
|
|
WriteRemaining - Receives the number of bytes remaining to be transfered
|
|
that were not completed by this call. If the operation wrote
|
|
everything then is value is set to zero.
|
|
|
|
Ccb - Supplies the ccb for the operation
|
|
|
|
NamedPipeEnd - Supplies the end of the pipe doing the write
|
|
|
|
UserThread - Supplies the user thread
|
|
|
|
DeferredList - List of IRPs to be completed after we drop the locks
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if the operation wrote everything and FALSE otherwise.
|
|
Note that a zero byte message that hasn't been written will return
|
|
a function result of FALSE and WriteRemaining of zero.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS Result;
|
|
|
|
BOOLEAN WriteZeroMessage;
|
|
|
|
PDATA_ENTRY DataEntry;
|
|
|
|
PUCHAR ReadBuffer;
|
|
ULONG ReadLength;
|
|
|
|
ULONG AmountToCopy;
|
|
NTSTATUS Status;
|
|
PSECURITY_CLIENT_CONTEXT SecurityContext;
|
|
BOOLEAN DoneSecurity=FALSE;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
BOOLEAN FreeBuffer;
|
|
|
|
PIRP ReadIrp;
|
|
|
|
PAGED_CODE();
|
|
|
|
DebugTrace(+1, Dbg, "NpWriteDataQueue\n", 0);
|
|
DebugTrace( 0, Dbg, "WriteQueue = %08lx\n", WriteQueue);
|
|
DebugTrace( 0, Dbg, "WriteBuffer = %08lx\n", WriteBuffer);
|
|
DebugTrace( 0, Dbg, "WriteLength = %08lx\n", WriteLength);
|
|
DebugTrace( 0, Dbg, "PipeType = %08lx\n", PipeType);
|
|
DebugTrace( 0, Dbg, "Ccb = %08lx\n", Ccb);
|
|
DebugTrace( 0, Dbg, "NamedPipeEnd = %08lx\n", NamedPipeEnd);
|
|
DebugTrace( 0, Dbg, "UserThread = %08lx\n", UserThread);
|
|
|
|
//
|
|
// Determine if we are to write a zero byte message, and initialize
|
|
// WriteRemaining
|
|
//
|
|
|
|
*WriteRemaining = WriteLength;
|
|
|
|
if ((PipeType == FILE_PIPE_MESSAGE_TYPE) && (WriteLength == 0)) {
|
|
|
|
WriteZeroMessage = TRUE;
|
|
|
|
} else {
|
|
|
|
WriteZeroMessage = FALSE;
|
|
}
|
|
|
|
//
|
|
// Now while the write queue has some read entries in it and
|
|
// there is some remaining write data or this is a write zero message
|
|
// then we'll do the following main loop
|
|
//
|
|
|
|
for (DataEntry = NpGetNextRealDataQueueEntry( WriteQueue, DeferredList );
|
|
|
|
(NpIsDataQueueReaders(WriteQueue) &&
|
|
((*WriteRemaining > 0) || WriteZeroMessage));
|
|
|
|
DataEntry = NpGetNextRealDataQueueEntry( WriteQueue, DeferredList )) {
|
|
|
|
ReadLength = DataEntry->DataSize;
|
|
|
|
DebugTrace(0, Dbg, "Top of main loop...\n", 0);
|
|
DebugTrace(0, Dbg, "ReadBuffer = %08lx\n", ReadBuffer);
|
|
DebugTrace(0, Dbg, "ReadLength = %08lx\n", ReadLength);
|
|
DebugTrace(0, Dbg, "*WriteRemaining = %08lx\n", *WriteRemaining);
|
|
|
|
//
|
|
// Check if this is a ReadOverflow Operation and if so then also check
|
|
// that the read will succeed otherwise complete this read with
|
|
// buffer overflow and continue on.
|
|
//
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation( DataEntry->Irp );
|
|
|
|
if (IrpSp->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
|
|
IrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_PIPE_INTERNAL_READ_OVFLOW) {
|
|
|
|
if ((ReadLength < WriteLength) || WriteZeroMessage) {
|
|
|
|
ReadIrp = NpRemoveDataQueueEntry( WriteQueue, TRUE, DeferredList );
|
|
if (ReadIrp != NULL) {
|
|
NpDeferredCompleteRequest( ReadIrp, STATUS_BUFFER_OVERFLOW, DeferredList );
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
|
|
if (DataEntry->DataEntryType == Unbuffered) {
|
|
DataEntry->Irp->Overlay.AllocationSize.QuadPart = WriteQueue->BytesInQueue - WriteQueue->BytesInQueue;
|
|
}
|
|
|
|
|
|
//
|
|
// copy data from the write buffer at write offset to the
|
|
// read buffer at read offset by the mininum of write remaining
|
|
// or read remaining
|
|
//
|
|
|
|
AmountToCopy = (*WriteRemaining < ReadLength ? *WriteRemaining
|
|
: ReadLength);
|
|
|
|
if (DataEntry->DataEntryType != Unbuffered && AmountToCopy > 0) {
|
|
ReadBuffer = NpAllocateNonPagedPool (AmountToCopy, 'RFpN');
|
|
if (ReadBuffer == NULL) {
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
FreeBuffer = TRUE;
|
|
} else {
|
|
ReadBuffer = DataEntry->Irp->AssociatedIrp.SystemBuffer;
|
|
FreeBuffer = FALSE;
|
|
}
|
|
|
|
try {
|
|
|
|
RtlCopyMemory( ReadBuffer,
|
|
&WriteBuffer[ WriteLength - *WriteRemaining ],
|
|
AmountToCopy );
|
|
|
|
} except (EXCEPTION_EXECUTE_HANDLER) {
|
|
if (FreeBuffer) {
|
|
NpFreePool (ReadBuffer);
|
|
}
|
|
return GetExceptionCode ();
|
|
}
|
|
|
|
//
|
|
// Done update the security in the CCB multiple times. It won't change.
|
|
//
|
|
if (DoneSecurity == FALSE) {
|
|
DoneSecurity = TRUE;
|
|
//
|
|
// Now update the security fields in the nonpaged ccb
|
|
//
|
|
Status = NpGetClientSecurityContext (NamedPipeEnd,
|
|
Ccb,
|
|
UserThread,
|
|
&SecurityContext);
|
|
if (!NT_SUCCESS(Status)) {
|
|
if (FreeBuffer) {
|
|
NpFreePool (ReadBuffer);
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
if (SecurityContext != NULL) {
|
|
NpFreeClientSecurityContext (Ccb->SecurityClientContext);
|
|
Ccb->SecurityClientContext = SecurityContext;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now we've done with the read entry so remove it from the
|
|
// write queue, get its irp, and fill in the information field
|
|
// to be the bytes that we've transferred into the read buffer.
|
|
//
|
|
|
|
ReadIrp = NpRemoveDataQueueEntry( WriteQueue, TRUE, DeferredList );
|
|
if (ReadIrp == NULL) {
|
|
if (FreeBuffer) {
|
|
NpFreePool (ReadBuffer);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Update the Write remaining counts
|
|
//
|
|
|
|
*WriteRemaining -= AmountToCopy;
|
|
|
|
ReadIrp->IoStatus.Information = AmountToCopy;
|
|
if (FreeBuffer) {
|
|
ReadIrp->AssociatedIrp.SystemBuffer = ReadBuffer;
|
|
ReadIrp->Flags |= IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER | IRP_INPUT_OPERATION;
|
|
}
|
|
|
|
|
|
if (*WriteRemaining == 0) {
|
|
|
|
DebugTrace(0, Dbg, "Finished up the write remaining\n", 0);
|
|
|
|
//**** ASSERT( ReadIrp->IoStatus.Information != 0 );
|
|
|
|
NpDeferredCompleteRequest( ReadIrp, STATUS_SUCCESS, DeferredList );
|
|
|
|
WriteZeroMessage = FALSE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// There is still some space in the write buffer to be
|
|
// written out, but before we can handle that (in the
|
|
// following if statement) we need to finish the read.
|
|
// If the read is message mode then we've overflowed the
|
|
// buffer otherwise we completed successfully
|
|
//
|
|
|
|
if (ReadMode == FILE_PIPE_MESSAGE_MODE) {
|
|
|
|
DebugTrace(0, Dbg, "Read buffer Overflow\n", 0);
|
|
|
|
NpDeferredCompleteRequest( ReadIrp, STATUS_BUFFER_OVERFLOW, DeferredList );
|
|
|
|
} else {
|
|
|
|
DebugTrace(0, Dbg, "Read buffer byte stream done\n", 0);
|
|
|
|
//**** ASSERT( ReadIrp->IoStatus.Information != 0 );
|
|
|
|
NpDeferredCompleteRequest( ReadIrp, STATUS_SUCCESS, DeferredList );
|
|
}
|
|
}
|
|
}
|
|
|
|
DebugTrace(0, Dbg, "Finished loop...\n", 0);
|
|
DebugTrace(0, Dbg, "*WriteRemaining = %08lx\n", *WriteRemaining);
|
|
DebugTrace(0, Dbg, "WriteZeroMessage = %08lx\n", WriteZeroMessage);
|
|
|
|
//
|
|
// At this point we've finished off all of the read entries in the
|
|
// queue and we might still have something left to write. If that
|
|
// is the case then we'll set our result to FALSE otherwise we're
|
|
// done so we'll return TRUE.
|
|
//
|
|
|
|
if ((*WriteRemaining > 0) || (WriteZeroMessage)) {
|
|
|
|
ASSERT( !NpIsDataQueueReaders( WriteQueue ));
|
|
|
|
Result = STATUS_MORE_PROCESSING_REQUIRED;
|
|
|
|
} else {
|
|
|
|
|
|
Result = STATUS_SUCCESS;
|
|
}
|
|
|
|
DebugTrace(-1, Dbg, "NpWriteDataQueue -> %08lx\n", Result);
|
|
return Result;
|
|
}
|
|
|
|
|