|
|
/*++
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
NTSTATUSNpWriteDataQueue ( 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;}
|
