Leaked source code of windows server 2003
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.
 
 
 
 
 
 

311 lines
9.6 KiB

/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
ReadSup.c
Abstract:
This module implements the Read support routine. This is a common
read function that is called to do read, unbuffered read, peek, and
transceive.
Author:
Gary Kimura [GaryKi] 20-Sep-1990
Revision History:
--*/
#include "NpProcs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_READSUP)
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, NpReadDataQueue)
#endif
IO_STATUS_BLOCK
NpReadDataQueue (
IN PDATA_QUEUE ReadQueue,
IN BOOLEAN PeekOperation,
IN BOOLEAN ReadOverflowOperation,
IN PUCHAR ReadBuffer,
IN ULONG ReadLength,
IN READ_MODE ReadMode,
IN PCCB Ccb,
IN PLIST_ENTRY DeferredList
)
/*++
Routine Description:
This procedure reads data from the read queue and fills up the
read buffer. It will also dequeue the queue or leave it alone based
on an input parameter.
Arguments:
ReadQueue - Provides the read queue to examine. Its state must
already be set to WriteEntries.
PeekOperation - Indicates if the operation is to dequeue information
off of the queue as it is being read or leave the queue alone.
TRUE means to leave the queue alone.
ReadOverflowOperation - Indicates if this is a read overflow operation.
With read overflow we will not alter the named pipe if the data
will overflow the read buffer.
ReadBuffer - Supplies a buffer to receive the data
ReadLength - Supplies the length, in bytes, of ReadBuffer.
ReadMode - Indicates if the read operation is message mode or
byte stream mode.
NamedPipeEnd - Supplies the end of the named pipe doing the read
Ccb - Supplies the ccb for the pipe
DeferredList - List of IRP's to complete later after we drop locks
Return Value:
IO_STATUS_BLOCK - Indicates the result of the operation.
--*/
{
IO_STATUS_BLOCK Iosb= {0};
PDATA_ENTRY DataEntry;
ULONG ReadRemaining;
ULONG AmountRead;
PUCHAR WriteBuffer;
ULONG WriteLength;
ULONG WriteRemaining;
BOOLEAN StartStalled = FALSE;
ULONG AmountToCopy;
PAGED_CODE();
DebugTrace(+1, Dbg, "NpReadDataQueue\n", 0);
DebugTrace( 0, Dbg, "ReadQueue = %08lx\n", ReadQueue);
DebugTrace( 0, Dbg, "PeekOperation = %08lx\n", PeekOperation);
DebugTrace( 0, Dbg, "ReadOverflowOperation = %08lx\n", ReadOverflowOperation);
DebugTrace( 0, Dbg, "ReadBuffer = %08lx\n", ReadBuffer);
DebugTrace( 0, Dbg, "ReadLength = %08lx\n", ReadLength);
DebugTrace( 0, Dbg, "ReadMode = %08lx\n", ReadMode);
DebugTrace( 0, Dbg, "Ccb = %08lx\n", Ccb);
//
// If this is an overflow operation then we will force us to do peeks.
// Later when are determine that the opreation succeeded we will complete
// the write irp.
//
if (ReadOverflowOperation) {
PeekOperation = TRUE;
}
//
// Now for every real data entry we loop until either we run out
// of data entries or until the read buffer is full
//
ReadRemaining = ReadLength;
Iosb.Status = STATUS_SUCCESS;
Iosb.Information = 0;
AmountRead = 0;
for (DataEntry = (PeekOperation ? NpGetNextDataQueueEntry( ReadQueue, NULL )
: NpGetNextRealDataQueueEntry( ReadQueue, DeferredList ));
(DataEntry != (PDATA_ENTRY) &ReadQueue->Queue) && (ReadRemaining > 0);
DataEntry = (PeekOperation ? NpGetNextDataQueueEntry( ReadQueue, DataEntry )
: NpGetNextRealDataQueueEntry( ReadQueue, DeferredList ))) {
DebugTrace(0, Dbg, "Top of Loop\n", 0);
DebugTrace(0, Dbg, "ReadRemaining = %08lx\n", ReadRemaining);
//
// If this is a peek operation then make sure we got a real
// data entry and not a close or flush
//
if (!PeekOperation ||
(DataEntry->DataEntryType == Buffered) ||
(DataEntry->DataEntryType == Unbuffered)) {
//
// Calculate how much data is in this entry. The write
// remaining is based on whether this is the first entry
// in the queue or a later data entry
//
if (DataEntry->DataEntryType == Unbuffered) {
WriteBuffer = DataEntry->Irp->AssociatedIrp.SystemBuffer;
} else {
WriteBuffer = DataEntry->DataBuffer;
}
WriteLength = DataEntry->DataSize;
WriteRemaining = WriteLength;
if (DataEntry == NpGetNextDataQueueEntry( ReadQueue, NULL )) {
WriteRemaining -= ReadQueue->NextByteOffset;
}
DebugTrace(0, Dbg, "WriteBuffer = %08lx\n", WriteBuffer);
DebugTrace(0, Dbg, "WriteLength = %08lx\n", WriteLength);
DebugTrace(0, Dbg, "WriteRemaining = %08lx\n", WriteRemaining);
//
// 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 < ReadRemaining ? WriteRemaining
: ReadRemaining);
try {
RtlCopyMemory( &ReadBuffer[ ReadLength - ReadRemaining ],
&WriteBuffer[ WriteLength - WriteRemaining ],
AmountToCopy );
} except(EXCEPTION_EXECUTE_HANDLER) {
Iosb.Status = GetExceptionCode ();
goto exit_1;
}
//
// Update the Read and Write remaining counts, the total
// amount we've read and the next byte offset field in the
// read queue
//
ReadRemaining -= AmountToCopy;
WriteRemaining -= AmountToCopy;
AmountRead += AmountToCopy;
if (!PeekOperation) {
DataEntry->QuotaCharged -= AmountToCopy;
ReadQueue->QuotaUsed -= AmountToCopy;
ReadQueue->NextByteOffset += AmountToCopy;
StartStalled = TRUE;
}
//
// Now update the security fields in the ccb
//
NpCopyClientContext( Ccb, DataEntry );
//
// If the remaining write length is greater than zero
// then we've filled up the read buffer so we need to
// figure out if its an overflow error
//
if (WriteRemaining > 0 ||
(ReadOverflowOperation && (AmountRead == 0))) {
DebugTrace(0, Dbg, "Write remaining is > 0\n", 0);
if (ReadMode == FILE_PIPE_MESSAGE_MODE) {
DebugTrace(0, Dbg, "Overflow message mode read\n", 0);
//
// Set the status field and break out of the for-loop.
//
Iosb.Status = STATUS_BUFFER_OVERFLOW;
break;
}
} else {
DebugTrace(0, Dbg, "Remaining Write is zero\n", 0);
//
// The write entry is done so remove it from the read
// queue, if this is not a peek operation. This might
// also have an Irp that needs to be completed
//
if (!PeekOperation || ReadOverflowOperation) {
PIRP WriteIrp;
//
// For a read overflow operation we need to get the read data
// queue entry and remove it.
//
if (ReadOverflowOperation) {
PDATA_ENTRY TempDataEntry;
TempDataEntry = NpGetNextRealDataQueueEntry( ReadQueue, DeferredList );
ASSERT(TempDataEntry == DataEntry);
}
if ((WriteIrp = NpRemoveDataQueueEntry( ReadQueue, TRUE, DeferredList)) != NULL) {
WriteIrp->IoStatus.Information = WriteLength;
NpDeferredCompleteRequest( WriteIrp, STATUS_SUCCESS, DeferredList );
}
}
//
// And if we are doing message mode reads then we'll
// work on completing this irp without going back
// to the top of the loop
//
if (ReadMode == FILE_PIPE_MESSAGE_MODE) {
DebugTrace(0, Dbg, "Successful message mode read\n", 0);
//
// Set the status field and break out of the for-loop.
//
Iosb.Status = STATUS_SUCCESS;
break;
}
ASSERTMSG("Srv cannot use read overflow on a byte stream pipe ", !ReadOverflowOperation);
}
}
}
DebugTrace(0, Dbg, "End of loop, AmountRead = %08lx\n", AmountRead);
Iosb.Information = AmountRead;
exit_1:
if (StartStalled) {
NpCompleteStalledWrites (ReadQueue, DeferredList);
}
DebugTrace(-1, Dbg, "NpReadDataQueue -> Iosb.Status = %08lx\n", Iosb.Status);
return Iosb;
}