windows-xp/Source/XPSP1/NT/net/mcast/pgm/sys/connect.c

/*++

Copyright (c) 2000-2000  Microsoft Corporation

Module Name:

    Connect.c

Abstract:

    This module implements Connect handling routines
    for the PGM Transport

Author:

    Mohammad Shabbir Alam (MAlam)   3-30-2000

Revision History:

--*/


#include "precomp.h"
#include <tcpinfo.h>    // for AO_OPTION_xxx, TCPSocketOption


//*******************  Pageable Routine Declarations ****************
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, PgmCreateConnection)
#endif
//*******************  Pageable Routine Declarations ****************


//----------------------------------------------------------------------------

NTSTATUS
PgmCreateConnection(
    IN  tPGM_DEVICE                 *pPgmDevice,
    IN  PIRP                        pIrp,
    IN  PIO_STACK_LOCATION          pIrpSp,
    IN  PFILE_FULL_EA_INFORMATION   TargetEA
    )
/*++

Routine Description:

    This routine is called to create a connection context for the client
    At this time, we do not knwo which address which connection will
    be associated with, nor do we know whether it will be a sender
    or a receiver.

Arguments:

    IN  pPgmDevice  -- Pgm's Device object context
    IN  pIrp        -- Client's request Irp
    IN  pIrpSp      -- current request's stack pointer
    IN  TargetEA    -- contains the client's Connect context

Return Value:

    NTSTATUS - Final status of the set event operation

--*/
{
    NTSTATUS                    status;
    CONNECTION_CONTEXT          ConnectionContext;
    tCOMMON_SESSION_CONTEXT     *pSession = NULL;

    PAGED_CODE();

    if (TargetEA->EaValueLength < sizeof(CONNECTION_CONTEXT))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmCreateConnection",
            "(BufferLength=%d < Min=%d)\n", TargetEA->EaValueLength, sizeof(CONNECTION_CONTEXT));
        return (STATUS_INVALID_ADDRESS_COMPONENT);
    }

    if (!(pSession = PgmAllocMem (sizeof(tCOMMON_SESSION_CONTEXT), PGM_TAG('0'))))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmCreateConnection", 
            "STATUS_INSUFFICIENT_RESOURCES, Requested <%d> bytes\n", sizeof(tCOMMON_SESSION_CONTEXT));
        return (STATUS_INSUFFICIENT_RESOURCES);
    }
    PgmZeroMemory (pSession, sizeof (tCOMMON_SESSION_CONTEXT));

    InitializeListHead (&pSession->Linkage);
    PgmInitLock (pSession, SESSION_LOCK);
    pSession->Verify = PGM_VERIFY_SESSION_UNASSOCIATED;
    PGM_REFERENCE_SESSION_UNASSOCIATED (pSession, REF_SESSION_CREATE, TRUE);
    pSession->Process = (PEPROCESS) PsGetCurrentProcess();

    // the connection context value is stored in the string just after the
    // name "connectionContext", and it is most likely unaligned, so just
    // copy it out.( 4 bytes of copying ).
    PgmCopyMemory (&pSession->ClientSessionContext,
                   (CONNECTION_CONTEXT) &TargetEA->EaName[TargetEA->EaNameLength+1],
                   sizeof (CONNECTION_CONTEXT));

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmCreateConnection",
        "pSession=<%x>, ConnectionContext=<%x>\n",
            pSession, * ((PVOID UNALIGNED *) &TargetEA->EaName[TargetEA->EaNameLength+1]));

    // link on to list of open connections for this device so that we
    // know how many open connections there are at any time (if we need to know)
    // This linkage is only in place until the client does an associate, then
    // the connection is unlinked from here and linked to the client ConnectHead.
    //
    PgmInterlockedInsertTailList (&PgmDynamicConfig.ConnectionsCreated, &pSession->Linkage,&PgmDynamicConfig);

    pIrpSp->FileObject->FsContext = pSession;
    pIrpSp->FileObject->FsContext2 = (PVOID) TDI_CONNECTION_FILE;

    return (STATUS_SUCCESS);
}



//----------------------------------------------------------------------------

VOID
PgmCleanupSession(
    IN  tCOMMON_SESSION_CONTEXT *pSession,
    IN  PVOID                   Unused1,
    IN  PVOID                   Unused2
    )
/*++

Routine Description:

    This routine performs the cleanup operation for a session
    handle once the RefCount goes to 0.  It is called after a
    cleanup has been requested on this handle
    This routine has to be called at Passive Irql since we will
    need to do some file/section handle manipulation here.

Arguments:

    IN  pSession    -- the session object to be cleaned up

Return Value:

    NONE

--*/
{
    PIRP            pIrpCleanup;
    PGMLockHandle   OldIrq;

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmCleanupSession",
        "Cleanup Session=<%x>\n", pSession);

    if ((pSession->SessionFlags & PGM_SESSION_FLAG_SENDER) &&
        (pSession->pSender->SendDataBufferMapping))
    {
        PgmUnmapAndCloseDataFile (pSession);
        pSession->pSender->SendDataBufferMapping = NULL;
    }

    PgmLock (pSession, OldIrq);
    pSession->Process = NULL;           // To remember that we have cleanedup

    if (pIrpCleanup = pSession->pIrpCleanup)
    {
        pSession->pIrpCleanup = NULL;
        PgmUnlock (pSession, OldIrq);
        PgmIoComplete (pIrpCleanup, STATUS_SUCCESS, 0);
    }
    else
    {
        PgmUnlock (pSession, OldIrq);
    }
}


//----------------------------------------------------------------------------

VOID
PgmDereferenceSessionCommon(
    IN  tCOMMON_SESSION_CONTEXT *pSession,
    IN  ULONG                   SessionType,
    IN  ULONG                   RefContext
    )
/*++

Routine Description:

    This routine is called as a result of a dereference on a session object

Arguments:

    IN  pSession    -- the Session object
    IN  SessionType -- basically, whether it is PGM_VERIFY_SESSION_SEND
                        or PGM_VERIFY_SESSION_RECEIVE
    IN  RefContext  -- the context for which this session object was
                        referenced earlier

Return Value:

    NONE

--*/
{
    NTSTATUS                status;
    PGMLockHandle           OldIrq;
    PIRP                    pIrpCleanup;
    LIST_ENTRY              *pEntry;
    tNAK_FORWARD_DATA       *pNak;

    PgmLock (pSession, OldIrq);

    ASSERT (PGM_VERIFY_HANDLE2 (pSession, SessionType, PGM_VERIFY_SESSION_DOWN));
    ASSERT (pSession->RefCount);             // Check for too many derefs
    ASSERT (pSession->ReferenceContexts[RefContext]--);

    if (--pSession->RefCount)
    {
        PgmUnlock (pSession, OldIrq);
        return;
    }

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmDereferenceSessionCommon",
        "pSession=<%x> Derefenced out, pIrpCleanup=<%x>\n", pSession, pSession->pIrpCleanup);

    ASSERT (!pSession->pAssociatedAddress);

    pIrpCleanup = pSession->pIrpCleanup;
    //
    // Sonce we may have a lot of memory buffered up, we need
    // to free it at non-Dpc
    //
    PgmUnlock (pSession, OldIrq);
    if (pSession->pReceiver)
    {
        CleanupPendingNaks (pSession, (PVOID) FALSE, NULL);
    }

    //
    // Remove from the global list
    //
    PgmLock (&PgmDynamicConfig, OldIrq);
    RemoveEntryList (&pSession->Linkage);
    PgmUnlock (&PgmDynamicConfig, OldIrq);

    //
    // If we are currently at Dpc, we will have to close the handles
    // on a Delayed Worker thread!
    //
    if (PgmGetCurrentIrql())
    {
        status = PgmQueueForDelayedExecution (PgmCleanupSession, pSession, NULL, NULL, FALSE);
        if (!NT_SUCCESS (status))
        {
            //
            // Apparently we ran out of Resources!
            // Complete the cleanup Irp for now and hope that the Close
            // can complete the rest of the cleanup
            //
            PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmDereferenceSessionCommon",
                "OUT_OF_RSRC, cannot queue Worker request\n", pSession);

            if (pIrpCleanup)
            {
                pSession->pIrpCleanup = NULL;
                PgmIoComplete (pIrpCleanup, STATUS_SUCCESS, 0);
            }
        }
    }
    else
    {
        PgmCleanupSession (pSession, NULL, NULL);
    }
}


//----------------------------------------------------------------------------

NTSTATUS
PgmCleanupConnection(
    IN  tCOMMON_SESSION_CONTEXT *pSession,
    IN  PIRP                    pIrp
    )
/*++

Routine Description:

    This routine is called as a result of a close on the client's
    session handle.  If we are a sender, our main job here is to
    send the FIN immediately, otherwise if we are a receiver, we
    need to remove ourselves from the timer list

Arguments:

    IN  pSession    -- the Session object
    IN  pIrp        -- Client's request Irp

Return Value:

    NTSTATUS - Final status of the request (STATUS_PENDING)

--*/
{
    tCLIENT_SEND_REQUEST    *pSendContext;
    PGMLockHandle           OldIrq, OldIrq1;

    PgmLock (&PgmDynamicConfig, OldIrq);
    PgmLock (pSession, OldIrq1);

    ASSERT (PGM_VERIFY_HANDLE3 (pSession, PGM_VERIFY_SESSION_UNASSOCIATED,
                                          PGM_VERIFY_SESSION_SEND,
                                          PGM_VERIFY_SESSION_RECEIVE));
    pSession->Verify = PGM_VERIFY_SESSION_DOWN;

    //
    // If Connection is currently associated, we must let the Disassociate handle
    // Removing the connection from the list
    //
    if (pSession->pAssociatedAddress)
    {
        PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmCleanupConnection",
            "WARNING:  pSession=<%x : %x> was not disassociated from pAddress=<%x : %x> earlier\n",
                pSession, pSession->Verify,
                pSession->pAssociatedAddress, pSession->pAssociatedAddress->Verify);

        ASSERT (0);

        PgmUnlock (pSession, OldIrq1);
        PgmUnlock (&PgmDynamicConfig, OldIrq);

        PgmDisassociateAddress (pIrp, IoGetCurrentIrpStackLocation(pIrp));

        PgmLock (&PgmDynamicConfig, OldIrq);
        PgmLock (pSession, OldIrq1);
    }

    ASSERT (!pSession->pAssociatedAddress);

    //
    // Remove connection from either ConnectionsCreated list
    // or ConnectionsDisassociated list
    //
    RemoveEntryList (&pSession->Linkage);
    InsertTailList (&PgmDynamicConfig.CleanedUpConnections, &pSession->Linkage);

    PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "PgmCleanupConnection",
        "pSession=<%x>\n", pSession);

    pSession->pIrpCleanup = pIrp;
    if (pSession->SessionFlags & PGM_SESSION_ON_TIMER)
    {
        pSession->SessionFlags |= PGM_SESSION_TERMINATED_ABORT;
    }

    PgmUnlock (pSession, OldIrq1);
    PgmUnlock (&PgmDynamicConfig, OldIrq);

    PGM_DEREFERENCE_SESSION_UNASSOCIATED (pSession, REF_SESSION_CREATE);

    return (STATUS_PENDING);
}


//----------------------------------------------------------------------------

NTSTATUS
PgmCloseConnection(
    IN  PIRP                pIrp,
    IN  PIO_STACK_LOCATION  pIrpSp
    )
/*++

Routine Description:

    This routine is the final dispatch operation to be performed
    after the cleanup, which should result in the session object
    being completely destroyed -- our RefCount must have already
    been set to 0 when we completed the Cleanup request.

Arguments:

    IN  pIrp        -- Client's request Irp
    IN  pIrpSp      -- current request's stack pointer

Return Value:

    NTSTATUS - Final status of the operation (STATUS_SUCCESS)

--*/
{
    tCOMMON_SESSION_CONTEXT *pSession = (tCOMMON_SESSION_CONTEXT *) pIrpSp->FileObject->FsContext;

    PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "PgmCloseConnection",
        "pSession=<%x>\n", pSession);

    ASSERT (!pSession->pIrpCleanup);

    if (pSession->Process)
    {
        PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmCloseConnection",
            "WARNING!  pSession=<%x>, Not yet cleaned up -- Calling cleanup again ...\n", pSession);

        PgmCleanupSession (pSession, NULL, NULL);
    }

    pIrpSp->FileObject->FsContext = NULL;

    if (pSession->FECOptions)
    {
        DestroyFECContext (&pSession->FECContext);
    }

    if (pSession->pSender)
    {
        ExDeleteResourceLite (&pSession->pSender->Resource);  // Delete the resource

        if (pSession->pSender->DataFileName.Buffer)
        {
            PgmFreeMem (pSession->pSender->DataFileName.Buffer);
        }

        if (pSession->pSender->pProActiveParityContext)
        {
            PgmFreeMem (pSession->pSender->pProActiveParityContext);
        }

        if (pSession->pSender->MaxPayloadSize)
        {
            ExDeleteNPagedLookasideList (&pSession->pSender->SenderBufferLookaside);
            ExDeleteNPagedLookasideList (&pSession->pSender->SendContextLookaside);
        }
        PgmFreeMem (pSession->pSender);
    }
    else if (pSession->pReceiver)
    {
        if (pSession->pFECBuffer)
        {
            PgmFreeMem (pSession->pFECBuffer);
        }

        if (pSession->FECGroupSize)
        {
            ExDeleteNPagedLookasideList (&pSession->pReceiver->NonParityContextLookaside);

            if (pSession->FECOptions)
            {
                ExDeleteNPagedLookasideList (&pSession->pReceiver->ParityContextLookaside);
            }
        }

        PgmFreeMem (pSession->pReceiver);
    }

    PgmFreeMem (pSession);

    //
    // The final Dereference will complete the Irp!
    //
    return (STATUS_SUCCESS);
}


//----------------------------------------------------------------------------
NTSTATUS
PgmConnect(
    IN  tPGM_DEVICE                 *pPgmDevice,
    IN  PIRP                        pIrp,
    IN  PIO_STACK_LOCATION          pIrpSp
    )
/*++

Routine Description:

    This routine is called to setup a connection, but since we are
    doing PGM, there are no packets to be sent out.  What we will
    do here is to create the file + section map for buffering the
    data packets, and also finalize the settings based on the default
    + user -specified settings

Arguments:

    IN  pPgmDevice  -- Pgm's Device object context
    IN  pIrp        -- Client's request Irp
    IN  pIrpSp      -- current request's stack pointer

Return Value:

    NTSTATUS - Final status of the connect operation

--*/
{
    tIPADDRESS                  IpAddress, OutIfAddress;
    LIST_ENTRY                  *pEntry;
    LIST_ENTRY                  *pEntry2;
    tLOCAL_INTERFACE            *pLocalInterface = NULL;
    tADDRESS_ON_INTERFACE       *pLocalAddress = NULL;
    USHORT                      Port;
    PGMLockHandle               OldIrq;
    NTSTATUS                    status;
    ULONGLONG                   WindowAdvanceInMSecs;
    tADDRESS_CONTEXT            *pAddress = NULL;
    tSEND_SESSION               *pSend = (tSEND_SESSION *) pIrpSp->FileObject->FsContext;
    PTDI_REQUEST_KERNEL         pRequestKernel  = (PTDI_REQUEST_KERNEL) &pIrpSp->Parameters;
    ULONG                       Length, MCastTtl;

    //
    // Verify Minimum Buffer length!
    //
    if (!GetIpAddress (pRequestKernel->RequestConnectionInformation->RemoteAddress,
                       pRequestKernel->RequestConnectionInformation->RemoteAddressLength,
                       &IpAddress,
                       &Port))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmConnect",
            "pSend=<%x>, Invalid Dest address!\n", pSend);
        return (STATUS_INVALID_ADDRESS_COMPONENT);
    }

    PgmLock (&PgmDynamicConfig, OldIrq);
    //
    // Now, verify that the Connection handle is valid + associated!
    //
    if ((!PGM_VERIFY_HANDLE (pSend, PGM_VERIFY_SESSION_SEND)) ||
        (!(pAddress = pSend->pAssociatedAddress)) ||
        (!PGM_VERIFY_HANDLE (pAddress, PGM_VERIFY_ADDRESS)) ||
        (pAddress->Flags & PGM_ADDRESS_FLAG_INVALID_OUT_IF))
    {
        PgmUnlock (&PgmDynamicConfig, OldIrq);
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmConnect",
            "BAD Handle(s), pSend=<%x>, pAddress=<%x>\n", pSend, pAddress);

        return (STATUS_INVALID_HANDLE);
    }

    PGM_REFERENCE_ADDRESS (pAddress, REF_ADDRESS_CONNECT, FALSE);

    //
    // If an outgoing interface has not yet been specified by the
    // client, select one ourselves
    //
    if (!pAddress->SenderMCastOutIf)
    {
        status = STATUS_ADDRESS_NOT_ASSOCIATED;
        OutIfAddress = 0;

        pEntry = &PgmDynamicConfig.LocalInterfacesList;
        while ((pEntry = pEntry->Flink) != &PgmDynamicConfig.LocalInterfacesList)
        {
            pLocalInterface = CONTAINING_RECORD (pEntry, tLOCAL_INTERFACE, Linkage);
            pEntry2 = &pLocalInterface->Addresses;
            while ((pEntry2 = pEntry2->Flink) != &pLocalInterface->Addresses)
            {
                pLocalAddress = CONTAINING_RECORD (pEntry2, tADDRESS_ON_INTERFACE, Linkage);
                OutIfAddress = htonl (pLocalAddress->IpAddress);

                PgmUnlock (&PgmDynamicConfig, OldIrq);
                status = SetSenderMCastOutIf (pAddress, OutIfAddress);
                PgmLock (&PgmDynamicConfig, OldIrq);

                break;
            }

            if (OutIfAddress)
            {
                break;
            }
        }

        if (!NT_SUCCESS (status))
        {
            PgmUnlock (&PgmDynamicConfig, OldIrq);
            PGM_DEREFERENCE_ADDRESS (pAddress, REF_ADDRESS_CONNECT);

            PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmConnect",
                "Could not bind sender to <%x>!\n", OutIfAddress);

            return (STATUS_UNSUCCESSFUL);
        }
    }

    //
    // So, we found a valid address to send to
    //
    pSend->pSender->DestMCastIpAddress = ntohl (IpAddress);
    pSend->pSender->DestMCastPort = pAddress->SenderMCastPort = ntohs (Port);
    pSend->pSender->SenderMCastOutIf = pAddress->SenderMCastOutIf;

    //
    // Set the FEC Info (if applicable)
    //
    pSend->FECBlockSize = pAddress->FECBlockSize;
    pSend->FECGroupSize = pAddress->FECGroupSize;

    if (pAddress->FECOptions)
    {
        Length = sizeof(tBUILD_PARITY_CONTEXT) + pSend->FECGroupSize*sizeof(PUCHAR);
        if (!(pSend->pSender->pProActiveParityContext = (tBUILD_PARITY_CONTEXT *) PgmAllocMem (Length,PGM_TAG('0'))) ||
            (!NT_SUCCESS (status = CreateFECContext (&pSend->FECContext, pSend->FECGroupSize, pSend->FECBlockSize, FALSE))))
        {
            PgmUnlock (&PgmDynamicConfig, OldIrq);
            PGM_DEREFERENCE_ADDRESS (pAddress, REF_ADDRESS_CONNECT);

            PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmConnect",
                "CreateFECContext returned <%x>, pSend=<%x>, Dest IpAddress=<%x>, Port=<%x>\n",
                    status, pSend, IpAddress, Port);

            return (STATUS_INSUFFICIENT_RESOURCES);
        }

        pSend->FECOptions = pAddress->FECOptions;
        pSend->FECProActivePackets = pAddress->FECProActivePackets;
        pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_PARITY_PRM;
        pSend->pSender->LastVariableTGPacketSequenceNumber = -1;

        ASSERT (!(pSend->FECProActivePackets || pSend->FECProActivePackets) ||
                 ((pSend->FECGroupSize && pSend->FECBlockSize) &&
                  (pSend->FECGroupSize < pSend->FECBlockSize)));

        //
        // Now determine the MaxPayloadsize and buffer size
        // We will also need to adjust the buffer size to avoid alignment issues
        //
        Length = sizeof (tPACKET_OPTIONS) + pAddress->OutIfMTU + sizeof (tPOST_PACKET_FEC_CONTEXT);
        pSend->pSender->PacketBufferSize = (Length + sizeof (PVOID) - 1) & ~(sizeof (PVOID) - 1);
        pSend->pSender->MaxPayloadSize = pAddress->OutIfMTU - (PGM_MAX_FEC_DATA_HEADER_LENGTH + sizeof (USHORT));
    }
    else
    {
        Length = sizeof (tPACKET_OPTIONS) + pAddress->OutIfMTU;
        pSend->pSender->PacketBufferSize = (Length + sizeof (PVOID) - 1) & ~(sizeof (PVOID) - 1);
        pSend->pSender->MaxPayloadSize = pAddress->OutIfMTU - PGM_MAX_DATA_HEADER_LENGTH;
    }
    ASSERT (pSend->pSender->MaxPayloadSize);

    pSend->TSIPort = PgmDynamicConfig.SourcePort++;    // Set the Global Src Port + Global Src Id
    if (pSend->TSIPort == PgmDynamicConfig.SourcePort)
    {
        //
        // We don't want the local port and remote port to be the same
        // (especially for handling TSI settings on loopback case),
        // so pick a different port
        //
        pSend->TSIPort = PgmDynamicConfig.SourcePort++;
    }

    //
    // Now, initialize the Sender info
    //
    InitializeListHead (&pSend->pSender->PendingSends);
    InitializeListHead (&pSend->pSender->PendingPacketizedSends);
    InitializeListHead (&pSend->pSender->CompletedSendsInWindow);
    InitializeListHead (&pSend->pSender->PendingRDataRequests);
    InitializeListHead (&pSend->pSender->HandledRDataRequests);

    MCastTtl = pAddress->MCastPacketTtl;
    PgmUnlock (&PgmDynamicConfig, OldIrq);

    KeInitializeEvent (&pSend->pSender->SendEvent, SynchronizationEvent, FALSE);

    //
    // Now, set the MCast TTL
    //
    status = PgmSetTcpInfo (pAddress->FileHandle,
                            AO_OPTION_MCASTTTL,
                            &MCastTtl,
                            sizeof (ULONG));
    if (NT_SUCCESS (status))
    {
        //
        // Set the MCast TTL for the RouterAlert handle also
        //
        status = PgmSetTcpInfo (pAddress->RAlertFileHandle,
                                AO_OPTION_MCASTTTL,
                                &MCastTtl,
                                sizeof (ULONG));
    }

    if (NT_SUCCESS (status))
    {
        status = PgmCreateDataFileAndMapSection (pSend);
        if (!NT_SUCCESS (status))
        {
            PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmConnect",
                "PgmCreateDataFileAndMapSection returned <%x>, pSend=<%x>, Dest IpAddress=<%x>, Port=<%x>\n",
                    status, pSend, IpAddress, Port);
        }
    }
    else
    {
        PgmLog (PGM_LOG_ERROR, DBG_ADDRESS, "PgmConnect",
            "AO_OPTION_MCASTTTL returned <%x>\n", status);
    }

    if (!NT_SUCCESS (status))
    {
        pSend->pSender->MaxPayloadSize = 0;
        PGM_DEREFERENCE_ADDRESS (pAddress, REF_ADDRESS_CONNECT);

        return (status);
    }

    PgmLock (&PgmDynamicConfig, OldIrq);

    //
    // Set the appropriate data parameters for the timeout routine
    // If the Send rate is quite high, we may need to send more than
    // 1 packet per timeout, but typically it should be low enough to
    // require several timeouts
    // Rate of Kb/Sec == Rate of Bytes/MilliSecs
    //
    ASSERT (pAddress->RateKbitsPerSec &&
            (BASIC_TIMER_GRANULARITY_IN_MSECS > BITS_PER_BYTE));
    if (((pAddress->RateKbitsPerSec * BASIC_TIMER_GRANULARITY_IN_MSECS) / BITS_PER_BYTE) >=
        pSend->pSender->PacketBufferSize)
    {
        //
        // We have a high Send rate, so we need to increment our window every timeout
        // So, Bytes to be sent in (x) Millisecs = Rate of Bytes/Millisecs * (x)
        //
        pSend->pSender->SendTimeoutCount = 1;
    }
    else
    {
        //
        // We will set our Send timeout count based for a slow timer
        // -- enough for pAddress->OutIfMTU
        // So, Number of Timeouts of x millisecs before we can send pAddress->OutIfMTU:
        //  = Rate of Bytes/Millisecs * (x)
        //
        pSend->pSender->SendTimeoutCount = (pAddress->OutIfMTU +(pAddress->RateKbitsPerSec/BITS_PER_BYTE-1)) /
                                            ((pAddress->RateKbitsPerSec * BASIC_TIMER_GRANULARITY_IN_MSECS)/BITS_PER_BYTE);
        if (!pSend->pSender->SendTimeoutCount)
        {
            ASSERT (0);
            pSend->pSender->SendTimeoutCount = 1;
        }
    }
    pSend->pSender->IncrementBytesOnSendTimeout = (ULONG) (pAddress->RateKbitsPerSec *
                                                           pSend->pSender->SendTimeoutCount *
                                                           BASIC_TIMER_GRANULARITY_IN_MSECS) /
                                                           BITS_PER_BYTE;

    //
    // Now, set the values for the next timeout!
    //
    pSend->pSender->CurrentTimeoutCount = pSend->pSender->SendTimeoutCount;
    pSend->pSender->CurrentBytesSendable = pSend->pSender->IncrementBytesOnSendTimeout;

    //
    // Set the SPM timeouts
    //
    pSend->pSender->CurrentSPMTimeout = 0;
    pSend->pSender->AmbientSPMTimeout = AMBIENT_SPM_TIMEOUT_IN_MSECS / BASIC_TIMER_GRANULARITY_IN_MSECS;
    pSend->pSender->InitialHeartbeatSPMTimeout = INITIAL_HEARTBEAT_SPM_TIMEOUT_IN_MSECS / BASIC_TIMER_GRANULARITY_IN_MSECS;
    pSend->pSender->MaxHeartbeatSPMTimeout = MAX_HEARTBEAT_SPM_TIMEOUT_IN_MSECS / BASIC_TIMER_GRANULARITY_IN_MSECS;
    pSend->pSender->HeartbeatSPMTimeout = pSend->pSender->InitialHeartbeatSPMTimeout;

    //
    // Set the Increment window settings
    //
    // TimerTickCount, LastWindowAdvanceTime and LastTrailingEdgeTime should be 0
    WindowAdvanceInMSecs = (((ULONGLONG)pAddress->WindowSizeInMSecs) * pAddress->WindowAdvancePercentage)/100;
    pSend->pSender->WindowSizeTime = pAddress->WindowSizeInMSecs / BASIC_TIMER_GRANULARITY_IN_MSECS;
    pSend->pSender->WindowAdvanceDeltaTime = WindowAdvanceInMSecs / BASIC_TIMER_GRANULARITY_IN_MSECS;
    pSend->pSender->NextWindowAdvanceTime = pSend->pSender->WindowSizeTime + pSend->pSender->WindowAdvanceDeltaTime;

    // Set the RData linger time!
    pSend->pSender->RDataLingerTime = RDATA_LINGER_TIME_MSECS / BASIC_TIMER_GRANULARITY_IN_MSECS;

    //
    // Set the late Joiner settings
    //
    if (pAddress->LateJoinerPercentage)
    {
        pSend->pSender->LateJoinSequenceNumbers = (SEQ_TYPE) ((pSend->pSender->MaxPacketsInBuffer *
                                                               pAddress->LateJoinerPercentage) /
                                                              (2 * 100));

        pSend->pSender->DataOptions |= PGM_OPTION_FLAG_JOIN;
        pSend->pSender->DataOptionsLength += PGM_PACKET_OPT_JOIN_LENGTH;

        pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_JOIN;
    }

    // The timer will be started when the first send comes down
    pSend->SessionFlags |= (PGM_SESSION_FLAG_FIRST_PACKET | PGM_SESSION_FLAG_SENDER);

#if 0
    pSend->pSender->LeadingWindowOffset = pSend->pSender->TrailingWindowOffset =
                (pSend->pSender->MaxDataFileSize/(pSend->pSender->PacketBufferSize*2))*pSend->pSender->PacketBufferSize;
#endif
    pSend->pSender->LeadingWindowOffset = pSend->pSender->TrailingWindowOffset = 0;

    PgmUnlock (&PgmDynamicConfig, OldIrq);
    PGM_DEREFERENCE_ADDRESS (pAddress, REF_ADDRESS_CONNECT);

    ExInitializeNPagedLookasideList (&pSend->pSender->SenderBufferLookaside,
                                     NULL,
                                     NULL,
                                     0,
                                     pAddress->OutIfMTU + sizeof (tPOST_PACKET_FEC_CONTEXT),
                                     PGM_TAG('2'),
                                     SENDER_BUFFER_LOOKASIDE_DEPTH);

    ExInitializeNPagedLookasideList (&pSend->pSender->SendContextLookaside,
                                     NULL,
                                     NULL,
                                     0,
                                     sizeof (tCLIENT_SEND_REQUEST),
                                     PGM_TAG('2'),
                                     SEND_CONTEXT_LOOKASIDE_DEPTH);

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmConnect",
        "DestIP=<%x>, Rate=<%d>, WinBytes=<%d>, WinMS=<%d>, SendTC=<%d>, IncBytes=<%d>, CurrentBS=<%d>\n",
            (ULONG) IpAddress, (ULONG) pAddress->RateKbitsPerSec,
            (ULONG) pAddress->WindowSizeInBytes, (ULONG) pAddress->WindowSizeInMSecs,
            (ULONG) pSend->pSender->SendTimeoutCount, (ULONG) pSend->pSender->IncrementBytesOnSendTimeout,
            (ULONG) pSend->pSender->CurrentBytesSendable);

    return (STATUS_SUCCESS);
}


//----------------------------------------------------------------------------

VOID
PgmCancelDisconnectIrp(
    IN PDEVICE_OBJECT DeviceContext,
    IN PIRP pIrp
    )
/*++

Routine Description:

    This routine handles the cancelling of a Disconnect Irp. It must
    release the cancel spin lock before returning re: IoCancelIrp().

Arguments:


Return Value:

    None

--*/
{
    PIO_STACK_LOCATION      pIrpSp = IoGetCurrentIrpStackLocation (pIrp);
    tCOMMON_SESSION_CONTEXT *pSession = (tCOMMON_SESSION_CONTEXT *) pIrpSp->FileObject->FsContext;
    PGMLockHandle           OldIrq;
    PIRP                    pIrpToComplete;

    if (!PGM_VERIFY_HANDLE2 (pSession, PGM_VERIFY_SESSION_SEND, PGM_VERIFY_SESSION_RECEIVE))
    {
        IoReleaseCancelSpinLock (pIrp->CancelIrql);

        PgmLog (PGM_LOG_ERROR, (DBG_SEND | DBG_ADDRESS | DBG_CONNECT), "PgmCancelDisconnectIrp",
            "pIrp=<%x> pSession=<%x>, pAddress=<%x>\n", pIrp, pSession, pSession->pAssociatedAddress);
        return;
    }

    PgmLock (pSession, OldIrq);

    ASSERT (pIrp == pSession->pIrpDisconnect);
    if ((pIrpToComplete = pSession->pIrpDisconnect) &&
        (pIrpToComplete == pIrp))
    {
        pSession->pIrpDisconnect = NULL;
    }
    else
    {
        pIrpToComplete = NULL;
    }

    if (pSession->pSender)
    {
        pSession->pSender->DisconnectTimeInTicks = pSession->pSender->TimerTickCount;
    }

    //
    // If we have reached here, then the Irp must already
    // be in the process of being completed!
    //
    PgmUnlock (pSession, OldIrq);
    IoReleaseCancelSpinLock (pIrp->CancelIrql);

    PgmLog (PGM_LOG_INFORM_ALL_FUNCS, (DBG_SEND | DBG_ADDRESS | DBG_CONNECT), "PgmCancelDisconnectIrp",
        "pIrp=<%x> was CANCELled, pIrpTpComplete=<%x>\n", pIrp, pIrpToComplete);

    if (pIrpToComplete)
    {
        pIrp->IoStatus.Information = 0;
        pIrp->IoStatus.Status = STATUS_CANCELLED;
        IoCompleteRequest (pIrp, IO_NETWORK_INCREMENT);
    }
}


//----------------------------------------------------------------------------

NTSTATUS
PgmDisconnect(
    IN  tPGM_DEVICE                 *pPgmDevice,
    IN  PIRP                        pIrp,
    IN  PIO_STACK_LOCATION          pIrpSp
    )
/*++

Routine Description:

    This routine is called by the client to disconnect a currently-active
    session

Arguments:

    IN  pPgmDevice  -- Pgm's Device object context
    IN  pIrp        -- Client's request Irp
    IN  pIrpSp      -- current request's stack pointer

Return Value:

    NTSTATUS - Final status of the disconnect operation

--*/
{
    LIST_ENTRY                      PendingIrpsList;
    PGMLockHandle                   OldIrq1, OldIrq2, OldIrq3;
    PIRP                            pIrpReceive;
    NTSTATUS                        Status;
    LARGE_INTEGER                   TimeoutInMSecs;
    LARGE_INTEGER                   *pTimeoutInMSecs;
    tADDRESS_CONTEXT                *pAddress = NULL;
    tCOMMON_SESSION_CONTEXT         *pSession = (tCOMMON_SESSION_CONTEXT *) pIrpSp->FileObject->FsContext;
    PTDI_REQUEST_KERNEL_DISCONNECT  pDisconnectRequest = (PTDI_REQUEST_KERNEL_CONNECT) &(pIrpSp->Parameters);

    PgmLock (&PgmDynamicConfig, OldIrq1);
    //
    // Now, verify that the Connection handle is valid + associated!
    //
    if ((!PGM_VERIFY_HANDLE2 (pSession, PGM_VERIFY_SESSION_SEND, PGM_VERIFY_SESSION_RECEIVE)) ||
        (!(pAddress = pSession->pAssociatedAddress)) ||
        (!PGM_VERIFY_HANDLE (pAddress, PGM_VERIFY_ADDRESS)))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmDisconnect",
            "BAD Handle(s), pSession=<%x>, pAddress=<%x>\n", pSession, pAddress);

        PgmUnlock (&PgmDynamicConfig, OldIrq1);
        return (STATUS_INVALID_HANDLE);
    }

    Status = STATUS_SUCCESS;
    InitializeListHead (&PendingIrpsList);
    TimeoutInMSecs.QuadPart = 0;

    IoAcquireCancelSpinLock (&OldIrq2);
    PgmLock (pSession, OldIrq3);

    if (pSession->pReceiver)
    {
        //
        // If we have any receive Irps pending, cancel them
        //
        RemovePendingIrps (pSession, &PendingIrpsList);
    }
    else if (pSession->pSender)
    {
        //
        // See if there is an abortive or graceful disconnect, and
        // also if there is a timeout specified.
        //
        if ((pDisconnectRequest->RequestFlags & TDI_DISCONNECT_ABORT) ||
            (pSession->SessionFlags & PGM_SESSION_FLAG_FIRST_PACKET))       // No packets sent yet!
        {
            pSession->pSender->DisconnectTimeInTicks = pSession->pSender->TimerTickCount;
        }
        else if (NT_SUCCESS (PgmCheckSetCancelRoutine (pIrp, PgmCancelDisconnectIrp, TRUE)))
        {
            if ((pTimeoutInMSecs = pDisconnectRequest->RequestSpecific) &&
                ((pTimeoutInMSecs->LowPart != -1) || (pTimeoutInMSecs->HighPart != -1)))   // Check Infinite
            {
                //
                // NT relative timeouts are negative. Negate first to get a
                // positive value to pass to the transport.
                //
                TimeoutInMSecs.QuadPart = -((*pTimeoutInMSecs).QuadPart);
                TimeoutInMSecs = PgmConvert100nsToMilliseconds (TimeoutInMSecs);

                pSession->pSender->DisconnectTimeInTicks = pSession->pSender->TimerTickCount +
                                                           TimeoutInMSecs.QuadPart /
                                                               BASIC_TIMER_GRANULARITY_IN_MSECS;
            }

            pSession->pIrpDisconnect = pIrp;
            Status = STATUS_PENDING;
        }
        else
        {
            Status = STATUS_CANCELLED;
        }
    }

    if (NT_SUCCESS (Status))
    {
        pSession->SessionFlags |= PGM_SESSION_CLIENT_DISCONNECTED;
    }

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmDisconnect",
        "pIrp=<%x>, pSession=<%x>, pAddress=<%x>, Timeout=<%x : %x>, %s\n",
            pIrp, pSession, pAddress, TimeoutInMSecs.QuadPart,
            (pDisconnectRequest->RequestFlags & TDI_DISCONNECT_ABORT ? "ABORTive" : "GRACEful"));

    PgmUnlock (pSession, OldIrq3);
    IoReleaseCancelSpinLock (OldIrq2);
    PgmUnlock (&PgmDynamicConfig, OldIrq1);

    while (!IsListEmpty (&PendingIrpsList))
    {
        pIrpReceive = CONTAINING_RECORD (PendingIrpsList.Flink, IRP, Tail.Overlay.ListEntry);
        RemoveEntryList (&pIrpReceive->Tail.Overlay.ListEntry);

        PgmCancelCancelRoutine (pIrpReceive);
        pIrpReceive->IoStatus.Status = STATUS_CANCELLED;
        IoCompleteRequest (pIrpReceive, IO_NETWORK_INCREMENT);
    }

    return (Status);
}


//----------------------------------------------------------------------------

NTSTATUS
PgmSetRcvBufferLength(
    IN  PIRP                pIrp,
    IN  PIO_STACK_LOCATION  pIrpSp
    )
/*++

Routine Description:

    This routine is called by the client by the client to set the receive buffer length
    Currently, we do not utilize this option meaningfully.

Arguments:

    IN  pIrp        -- Client's request Irp
    IN  pIrpSp      -- current request's stack pointer

Return Value:

    NTSTATUS - Final status of the operation

--*/
{
    NTSTATUS            status;
    tRECEIVE_SESSION    *pReceive = (tRECEIVE_SESSION *) pIrpSp->FileObject->FsContext;
    tPGM_MCAST_REQUEST  *pInputBuffer = (tPGM_MCAST_REQUEST *) pIrp->AssociatedIrp.SystemBuffer;

    PAGED_CODE();

    if (pIrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof (tPGM_MCAST_REQUEST))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmSetRcvBufferLength",
            "Invalid BufferLength, <%d> < <%d>\n",
                pIrpSp->Parameters.DeviceIoControl.InputBufferLength, sizeof (tPGM_MCAST_REQUEST));
        return (STATUS_INVALID_PARAMETER);
    }

    if (!PGM_VERIFY_HANDLE (pReceive, PGM_VERIFY_SESSION_RECEIVE))
    {
        PgmLog (PGM_LOG_ERROR, DBG_CONNECT, "PgmSetRcvBufferLength",
            "Invalid Handle <%x>\n", pReceive);
        return (STATUS_INVALID_HANDLE);
    }

    pReceive->pReceiver->RcvBufferLength = pInputBuffer->RcvBufferLength;

    PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "PgmSetRcvBufferLength",
        "RcvBufferLength=<%d>\n", pReceive->pReceiver->RcvBufferLength);

    //
    // ISSUE:  What else should we do here ?
    //

    return (STATUS_SUCCESS);
}


//----------------------------------------------------------------------------