path: root/private/ntos/tdi/st/send.c

/*++

Copyright (c) 1989-1993  Microsoft Corporation

Module Name:

    send.c

Abstract:

    This module contains code which performs the following TDI services:

        o   TdiSend
        o   TdiSendDatagram

Environment:

    Kernel mode

Revision History:

--*/

#include "st.h"


NTSTATUS
StTdiSend(
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine performs the TdiSend request for the transport provider.

Arguments:

    Irp - Pointer to the I/O Request Packet for this request.

Return Value:

    NTSTATUS - status of operation.

--*/

{
    KIRQL oldirql, cancelirql;
    NTSTATUS status;
    PTP_CONNECTION connection;
    PMDL SendBuffer;
    ULONG SendBufferLength;
    PIO_STACK_LOCATION irpSp;
    PTDI_REQUEST_KERNEL_SEND parameters;
    PIRP TempIrp;

    //
    // Determine which connection this send belongs on.
    //

    irpSp = IoGetCurrentIrpStackLocation (Irp);
    connection  = irpSp->FileObject->FsContext;

    //
    // Check that this is really a connection.
    //

    if ((connection->Size != sizeof (TP_CONNECTION)) ||
        (connection->Type != ST_CONNECTION_SIGNATURE)) {
        return STATUS_INVALID_CONNECTION;
    }

    //
    // Now map the data in to SVA space.
    //

    parameters = (PTDI_REQUEST_KERNEL_SEND)(&irpSp->Parameters);
    SendBuffer = Irp->MdlAddress;
    SendBufferLength = parameters->SendLength;

    //
    // Interpret send options.
    //

    //
    // Now we have a reference on the connection object.  Queue up this
    // send to the connection object.
    //


    // This reference is removed by TdiDestroyRequest

    StReferenceConnection("TdiSend", connection);

    IRP_CONNECTION(irpSp) = connection;
    IRP_REFCOUNT(irpSp) = 1;

    IoAcquireCancelSpinLock(&cancelirql);
    ACQUIRE_SPIN_LOCK (&connection->SpinLock,&oldirql);

    if ((connection->Flags & CONNECTION_FLAGS_STOPPING) != 0) {
        RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql);
        IoReleaseCancelSpinLock(cancelirql);
        StCompleteSendIrp(
            Irp,
            connection->Status,
            0);
        status = STATUS_PENDING;
    } else {

        StReferenceConnection ("Verify Temp Use", connection);

        //
        // Insert onto the send queue, and make the IRP
        // cancellable.
        //

        InsertTailList (&connection->SendQueue,&Irp->Tail.Overlay.ListEntry);


        //
        // If this IRP has been cancelled, then call the
        // cancel routine.
        //

        if (Irp->Cancel) {
            RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql);
            Irp->CancelIrql = cancelirql;
            StCancelSend((PDEVICE_OBJECT)(connection->Provider), Irp);
            StDereferenceConnection ("IRP cancelled", connection);   // release lookup hold.
            return STATUS_PENDING;
        }

        Irp->CancelRoutine = StCancelSend;

        //
        // If this connection is waiting for an EOR to appear because a non-EOR
        // send failed at some point in the past, fail this send. Clear the
        // flag that causes this if this request has the EOR set.
        //
        // BUGBUG: Should the FailSend status be clearer here?
        //

        if ((connection->Flags & CONNECTION_FLAGS_FAILING_TO_EOR) != 0) {

            RELEASE_SPIN_LOCK (&connection->SpinLock,oldirql);
            IoReleaseCancelSpinLock(cancelirql);

            //
            // BUGBUG: Should we save status from real failure?
            //

            FailSend (connection, STATUS_LINK_FAILED, TRUE);

            if ( (parameters->SendFlags & TDI_SEND_PARTIAL) == 0) {
                connection->Flags &= ~CONNECTION_FLAGS_FAILING_TO_EOR;
            }

            StDereferenceConnection ("Failing to EOR", connection);   // release lookup hold.
            return STATUS_PENDING;
        }


        //
        // If the send state is either IDLE or W_EOR, then we should
        // begin packetizing this send.  Otherwise, some other event
        // will cause it to be packetized.
        //

        //
        // NOTE: If we call StartPacketizingConnection, we make
        // sure that it is the last operation we do on this
        // connection. This allows us to "hand off" the reference
        // we have to that function, which converts it into
        // a reference for being on the packetize queue.
        //

        switch (connection->SendState) {

        case CONNECTION_SENDSTATE_IDLE:

            InitializeSend (connection);   // sets state to PACKETIZE

            //
            // If we can, packetize right now.
            //

            if ((!(connection->Flags & CONNECTION_FLAGS_PACKETIZE)) &&
                (!(connection->Flags & CONNECTION_FLAGS_STOPPING))) {

                connection->Flags |= CONNECTION_FLAGS_PACKETIZE;

                RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql);
                IoReleaseCancelSpinLock(cancelirql);

                PacketizeSend (connection);

            } else {

                RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql);
                IoReleaseCancelSpinLock(cancelirql);

                StDereferenceConnection ("Stopping or already packetizing", connection);   // release lookup hold.

            }

            break;

        case CONNECTION_SENDSTATE_W_EOR:
            connection->SendState = CONNECTION_SENDSTATE_PACKETIZE;

            //
            // Adjust the send variables on the connection so that
            // they correctly point to this new send.  We can't call
            // InitializeSend to do that, because we need to keep
            // track of the other outstanding sends on this connection
            // which have been sent but are a part of this message.
            //

            TempIrp = CONTAINING_RECORD(
                connection->SendQueue.Flink,
                IRP,
                Tail.Overlay.ListEntry);

            connection->sp.CurrentSendIrp = TempIrp;
            connection->sp.CurrentSendMdl = TempIrp->MdlAddress;
            connection->sp.SendByteOffset = 0;
            connection->CurrentSendLength +=
                IRP_SEND_LENGTH(IoGetCurrentIrpStackLocation(TempIrp));

            StartPacketizingConnection (connection, TRUE, oldirql, cancelirql);
            break;

        default:

            //
            // The connection is in another state (such as
            // W_ACK or W_LINK), we just need to make sure
            // to call InitializeSend if the new one is
            // the first one on the list.
            //

            //
            // BUGBUG: Currently InitializeSend sets SendState,
            // we should fix this.
            //

            if (connection->SendQueue.Flink == &Irp->Tail.Overlay.ListEntry) {
                ULONG SavedSendState;
                SavedSendState = connection->SendState;
                InitializeSend (connection);
                connection->SendState = SavedSendState;
            }
            RELEASE_SPIN_LOCK (&connection->SpinLock, oldirql);
            IoReleaseCancelSpinLock(cancelirql);

            StDereferenceConnection("temp TdiSend", connection);

        }

    }

    status = STATUS_PENDING;


    return status;
} /* TdiSend */


NTSTATUS
StTdiSendDatagram(
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine performs the TdiSendDatagram request for the transport
    provider.

Arguments:

    Irp - Pointer to the I/O Request Packet for this request.

Return Value:

    NTSTATUS - status of operation.

--*/

{
    NTSTATUS status;
    KIRQL oldirql;
    PTP_REQUEST tpRequest;
    PTP_ADDRESS_FILE addressFile;
    PTP_ADDRESS address;
    PMDL SendBuffer;
    ULONG SendBufferLength;
    PIO_STACK_LOCATION irpSp;
    PTDI_REQUEST_KERNEL_SENDDG parameters;
    LARGE_INTEGER timeout = {0,0};
    UINT MaxUserData;

    irpSp = IoGetCurrentIrpStackLocation (Irp);
    addressFile  = irpSp->FileObject->FsContext;

    status = StVerifyAddressObject (addressFile);
    if (!NT_SUCCESS (status)) {
        return status;
    }

    address = addressFile->Address;
    parameters = (PTDI_REQUEST_KERNEL_SENDDG)(&irpSp->Parameters);
    SendBuffer = Irp->MdlAddress;
    SendBufferLength = parameters->SendLength;

    //
    // Check that the length is short enough.
    //

    MacReturnMaxDataSize(
        &address->Provider->MacInfo,
        NULL,
        0,
        address->Provider->MaxSendPacketSize,
        &MaxUserData);

    if (SendBufferLength >
        (MaxUserData - sizeof(ST_HEADER))) {

        return STATUS_INVALID_PARAMETER;

    }

    //
    // We need a request object to keep track of this TDI request.
    // Attach this request to the address object.
    //

    status = StCreateRequest (
                 Irp,                           // IRP for this request.
                 address,                       // context.
                 REQUEST_FLAGS_ADDRESS,         // partial flags.
                 SendBuffer,                    // the data to be sent.
                 SendBufferLength,              // length of the data.
                 timeout,
                 &tpRequest);

    if (!NT_SUCCESS (status)) {
        StDereferenceAddress ("no send request", address);
        return status;                          // if we couldn't queue the request.
    }

    StReferenceAddress ("Send datagram", address);
    tpRequest->Owner = AddressType;

    ACQUIRE_SPIN_LOCK (&address->SpinLock,&oldirql);

    if ((address->Flags & ADDRESS_FLAGS_STOPPING) != 0) {
        RELEASE_SPIN_LOCK (&address->SpinLock,oldirql);
        StCompleteRequest (tpRequest, STATUS_NETWORK_NAME_DELETED, 0);
        return STATUS_PENDING;
    } else {
        InsertTailList (
            &address->SendDatagramQueue,
            &tpRequest->Linkage);
        RELEASE_SPIN_LOCK (&address->SpinLock,oldirql);
    }

    //
    // The request is queued.  Ship the next request at the head of the queue,
    // provided the completion handler is not active.  We serialize this so
    // that only one MDL and ST datagram header needs to be statically
    // allocated for reuse by all send datagram requests.
    //

    (VOID)StSendDatagramsOnAddress (address);

    StDereferenceAddress("tmp send datagram", address);

    return STATUS_PENDING;

} /* StTdiSendDatagram */