/*++

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 and peek.

Author:

    Manny Weiser (mannyw)    15-Jan-1991

Revision History:

--*/

#include "mailslot.h"

//
// The debug trace level
//

#define Dbg                              (DEBUG_TRACE_READSUP)

#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGE, MsReadDataQueue )
#pragma alloc_text( PAGE, MsTimeoutRead )
#endif

IO_STATUS_BLOCK
MsReadDataQueue (
    IN PDATA_QUEUE ReadQueue,
    IN ENTRY_TYPE Operation,
    IN PUCHAR ReadBuffer,
    IN ULONG ReadLength,
    OUT PULONG MessageLength
    )

/*++

Routine Description:

    This function reads data from the read queue and fills up the
    read buffer.  It will also dequeue the data entry if this is not
    a peek operation.

    It will only be called if there is at least one message to read.

    *** This function must be called from within a try statement.

Arguments:

    ReadQueue - Provides the read queue to examine.  Its state must
        already be set to WriteEntries.

    Operation - Indicates the type of operation to perform.  If the
        operation is Peek, the write data entry is not dequeued.

    ReadBuffer - Supplies a buffer to receive the data

    ReadLength - Supplies the length, in bytes, of ReadBuffer.

    MessageLength - Returns the full size of the message, even if the
        read buffer is not large enough to contain the entire message.

Return Value:

    IO_STATUS_BLOCK - Indicates the result of the operation.

--*/

{
    IO_STATUS_BLOCK iosb;

    PLIST_ENTRY listEntry;
    PDATA_ENTRY dataEntry;
    PFCB fcb;

    PUCHAR writeBuffer;
    ULONG writeLength;

    ULONG amountRead;

    PAGED_CODE();
    DebugTrace(+1, Dbg, "MsReadDataQueue\n", 0);
    DebugTrace( 0, Dbg, "ReadQueue     = %08lx\n", (ULONG)ReadQueue);
    DebugTrace( 0, Dbg, "Operation     = %08lx\n", Operation);
    DebugTrace( 0, Dbg, "ReadBuffer    = %08lx\n", (ULONG)ReadBuffer);
    DebugTrace( 0, Dbg, "ReadLength    = %08lx\n", ReadLength);

    //
    // Read the first message out of the data queue.
    //

    iosb.Status = STATUS_SUCCESS;

    listEntry = MsGetNextDataQueueEntry( ReadQueue );
    ASSERT( listEntry != &ReadQueue->DataEntryList );

    dataEntry = CONTAINING_RECORD( listEntry, DATA_ENTRY, ListEntry );

    //
    // Calculate how much data is in this entry.
    //

    writeBuffer = dataEntry->DataPointer;
    writeLength = dataEntry->DataSize;

    DebugTrace(0, Dbg, "WriteBuffer    = %08lx\n", (ULONG)writeBuffer);
    DebugTrace(0, Dbg, "WriteLength    = %08lx\n", writeLength);

    //
    // Fail this operation, if it is a read and the buffer is not large
    // enough.
    //

    if ( (Operation != Peek) && (ReadLength < writeLength) ) {

        iosb.Information = 0;
        iosb.Status = STATUS_BUFFER_TOO_SMALL;

        return iosb;

    }

    //
    // Copy data from the write buffer at write offset to the
    // read buffer by the mininum of write remaining or read length
    //

    RtlMoveMemory( ReadBuffer,
                   writeBuffer,
                   writeLength );

    *MessageLength = dataEntry->DataSize;


    //
    // If write length is larger than read length, this must be an
    // overflowed peek.
    //

    if ( writeLength > ReadLength) {

        DebugTrace(0, Dbg, "Overflowed peek buffer\n", 0);

        iosb.Status = STATUS_BUFFER_OVERFLOW;

    } else {

        //
        // 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 (Operation != Peek) {

            PIRP writeIrp;

            if ((writeIrp = MsRemoveDataQueueEntry( ReadQueue,
                                                    dataEntry )) != NULL) {

                //
                // Update the last modification time.
                //

                fcb = CONTAINING_RECORD( ReadQueue, FCB, DataQueue );
                KeQuerySystemTime( &fcb->Specific.Fcb.LastModificationTime );

                MsCompleteRequest( writeIrp, STATUS_SUCCESS );
            }
        }

        DebugTrace(0, Dbg, "Successful mailslot read\n", 0);

        //
        // Indicate success.
        //

        iosb.Status = STATUS_SUCCESS;
    }

    amountRead = writeLength < ReadLength ? writeLength : ReadLength;

    DebugTrace(0, Dbg, "Amount read = %08lx\n", amountRead);

    iosb.Information = amountRead;
    DebugTrace(-1, Dbg, "MsReadDataQueue -> iosb.Status = %08lx\n", iosb.Status);
    return iosb;
}


VOID
MsTimeoutRead (
    IN PVOID Context
    )

/*++

Routine Description:

    This routine times out a read operation.  It gains exclusive
    access to the FCB, and searches the data queue of read operations.

    If the timed out read operation is not found, it is assumed that
    a write IRP completed the read after the time out DPC ran, but
    before this function could complete the read IRP.

Arguments:

    Context - a pointer to our WorkContext

Return Value:

    None.

--*/

{
    PDATA_QUEUE dataQueue;
    PLIST_ENTRY listEntry;
    PIRP queuedIrp;
    PDATA_ENTRY dataEntry;
    PWORK_CONTEXT workContext;
    PIRP irp;
    PFCB fcb;

    PAGED_CODE();

    //
    // Reference our local variables.
    //

    workContext = (PWORK_CONTEXT)Context;

    irp = workContext->Irp;
    fcb = workContext->Fcb;

    //
    // Acquire exclusive access to the FCB.  This must succeed.
    //

    MsAcquireExclusiveFcb( fcb );

    //
    // Walk the FCB's data queue, looking for this read IRP.
    //

    dataQueue = &fcb->DataQueue;

    for (listEntry = MsGetNextDataQueueEntry( dataQueue );
         listEntry != &dataQueue->DataEntryList;
         listEntry = listEntry->Flink ) {

         //
         // This is an outstanding read request from this FCB.
         // If it is the read request that has timed out, then
         // complete it with a timed out status.
         //

         dataEntry = CONTAINING_RECORD( listEntry, DATA_ENTRY, ListEntry );
         queuedIrp = dataEntry->Irp;

         if ( queuedIrp == irp ) {

             //
             // The timed out IRP is still queued.  Dequeue it and complete
             // it now.
             //

             MsRemoveDataQueueEntry( dataQueue, dataEntry );
             DebugTrace(0, Dbg, "Completing IRP %08lx\n", (ULONG)queuedIrp );

             MsCompleteRequest( queuedIrp, STATUS_IO_TIMEOUT );

             break;
         }

    }

    //
    // Free the work context structure.  Note that we have to free this
    // whenever this routine runs, even if the I/O request was cancelled,
    // because the canceller didn't free it.
    //

    ExFreePool( workContext );

    //
    // Release the FCB, and derefernce it.
    //

    MsReleaseFcb( fcb );
    MsDereferenceFcb( fcb );

}