/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    disconn.c

Abstract:

    This module contains the dispatch routines for AFD.

Author:

    David Treadwell (davidtr)    31-Mar-1992

Revision History:

--*/

#include "afdp.h"


#if ENABLE_ABORT_TIMER_HACK
//
// Hack-O-Rama. TDI has a fundamental flaw in that it is often impossible
// to determine exactly when a TDI protocol is "done" with a connection
// object. The biggest problem here is that AFD may get a suprious TDI
// indication *after* an abort request has completed. As a temporary work-
// around, whenever an abort request completes, we'll start a timer. AFD
// will defer further processing on the connection until that timer fires.
//

typedef struct _AFD_ABORT_TIMER_INFO {

    KDPC Dpc;
    KTIMER Timer;

} AFD_ABORT_TIMER_INFO, *PAFD_ABORT_TIMER_INFO;

VOID
AfdAbortTimerHack(
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    );
#endif  // ENABLE_ABORT_TIMER_HACK

NTSTATUS
AfdRestartAbort(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

VOID
AfdRestartAbortHelper(
    IN PAFD_CONNECTION Connection
    );

NTSTATUS
AfdRestartDisconnect(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    );

typedef struct _AFD_ABORT_CONTEXT {
    PAFD_CONNECTION Connection;
} AFD_ABORT_CONTEXT, *PAFD_ABORT_CONTEXT;

#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGEAFD, AfdPartialDisconnect )
#pragma alloc_text( PAGEAFD, AfdDisconnectEventHandler )
#pragma alloc_text( PAGEAFD, AfdBeginAbort )
#pragma alloc_text( PAGEAFD, AfdRestartAbort )
#pragma alloc_text( PAGEAFD, AfdRestartAbortHelper )
#pragma alloc_text( PAGEAFD, AfdBeginDisconnect )
#pragma alloc_text( PAGEAFD, AfdRestartDisconnect )
#if ENABLE_ABORT_TIMER_HACK
#pragma alloc_text( PAGEAFD, AfdAbortTimerHack )
#endif  // ENABLE_ABORT_TIMER_HACK
#endif


NTSTATUS
AfdPartialDisconnect(
    IN PIRP Irp,
    IN PIO_STACK_LOCATION IrpSp
    )
{
    NTSTATUS status;
    KIRQL oldIrql;
    PAFD_ENDPOINT endpoint;
    PAFD_CONNECTION connection;
    PAFD_PARTIAL_DISCONNECT_INFO disconnectInfo;

    Irp->IoStatus.Information = 0;

    endpoint = IrpSp->FileObject->FsContext;
    ASSERT( IS_AFD_ENDPOINT_TYPE( endpoint ) );
    disconnectInfo = Irp->AssociatedIrp.SystemBuffer;

    IF_DEBUG(CONNECT) {
        KdPrint(( "AfdPartialDisconnect: disconnecting endpoint %lx, "
                  "mode %lx, endp mode %lx\n",
                      endpoint, disconnectInfo->DisconnectMode,
                      endpoint->DisconnectMode ));
    }

    //
    // If this is a datagram endpoint, just remember how the endpoint
    // was shut down, don't actually do anything.  Note that it is legal
    // to do a shutdown() on an unconnected datagram socket, so the
    // test that the socket must be connected is after this case.
    //

    if ( IS_DGRAM_ENDPOINT(endpoint) ) {

        AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );

        if ( (disconnectInfo->DisconnectMode & AFD_ABORTIVE_DISCONNECT) != 0 ) {
            endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_RECEIVE;
            endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_SEND;
            endpoint->DisconnectMode |= AFD_ABORTIVE_DISCONNECT;
        }

        if ( (disconnectInfo->DisconnectMode & AFD_PARTIAL_DISCONNECT_RECEIVE) != 0 ) {
            endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_RECEIVE;
        }

        if ( (disconnectInfo->DisconnectMode & AFD_PARTIAL_DISCONNECT_SEND) != 0 ) {
            endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_SEND;
        }

        if ( (disconnectInfo->DisconnectMode & AFD_UNCONNECT_DATAGRAM) != 0 ) {
            if( endpoint->Common.Datagram.RemoteAddress != NULL ) {
                AFD_FREE_POOL(
                    endpoint->Common.Datagram.RemoteAddress,
                    AFD_REMOTE_ADDRESS_POOL_TAG
                    );
            }
            endpoint->Common.Datagram.RemoteAddress = NULL;
            endpoint->Common.Datagram.RemoteAddressLength = 0;
            endpoint->State = AfdEndpointStateBound;
        }

        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

        status = STATUS_SUCCESS;
        goto complete;
    }

    //
    // Make sure that the endpoint is in the correct state.
    //

    if ( endpoint->Type != AfdBlockTypeVcConnecting ||
             endpoint->State != AfdEndpointStateConnected ) {
        status = STATUS_INVALID_PARAMETER;
        goto complete;
    }

    connection = endpoint->Common.VcConnecting.Connection;
    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    //
    // If we're doing an abortive disconnect, remember that the receive
    // side is shut down and issue a disorderly release.
    //

    if ( (disconnectInfo->DisconnectMode & AFD_ABORTIVE_DISCONNECT) != 0 ) {

        IF_DEBUG(CONNECT) {
            KdPrint(( "AfdPartialDisconnect: abortively disconnecting endp %lx\n",
                          endpoint ));
        }

        status = AfdBeginAbort( connection );
        if ( status == STATUS_PENDING ) {
            status = STATUS_SUCCESS;
        }

        goto complete;
    }

    //
    // If the receive side of the connection is being shut down,
    // remember the fact in the endpoint.  If there is pending data on
    // the VC, do a disorderly release on the endpoint.  If the receive
    // side has already been shut down, do nothing.
    //

    if ( (disconnectInfo->DisconnectMode & AFD_PARTIAL_DISCONNECT_RECEIVE) != 0 &&
         (endpoint->DisconnectMode & AFD_PARTIAL_DISCONNECT_RECEIVE) == 0 ) {

        AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );

        //
        // Determine whether there is pending data.
        //

        if ( IS_DATA_ON_CONNECTION( connection ) ||
                 IS_EXPEDITED_DATA_ON_CONNECTION( connection ) ) {

            //
            // There is unreceived data.  Abort the connection.
            //

            IF_DEBUG(CONNECT) {
                KdPrint(( "AfdPartialDisconnect: unreceived data on endp %lx,"
                          "conn %lx, aborting.\n",
                              endpoint, connection ));
            }

            AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

            (VOID)AfdBeginAbort( connection );

            status = STATUS_SUCCESS;
            goto complete;

        } else {

            IF_DEBUG(CONNECT) {
                KdPrint(( "AfdPartialDisconnect: disconnecting recv for endp %lx\n",
                              endpoint ));
            }

            //
            // Remember that the receive side is shut down.  This will cause
            // the receive indication handlers to dump any data that
            // arrived.
            //
            // !!! This is a minor violation of RFC1122 4.2.2.13.  We
            //     should really do an abortive disconnect if data
            //     arrives after a receive shutdown.
            //

            endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_RECEIVE;

            AfdReleaseSpinLock( &AfdSpinLock, oldIrql );
        }
    }

    //
    // If the send side is being shut down, remember it in the endpoint
    // and pass the request on to the TDI provider for a graceful
    // disconnect.  If the send side is already shut down, do nothing here.
    //

    if ( (disconnectInfo->DisconnectMode & AFD_PARTIAL_DISCONNECT_SEND) != 0 &&
         (endpoint->DisconnectMode & AFD_PARTIAL_DISCONNECT_SEND) == 0 ) {

        status = AfdBeginDisconnect( endpoint, &disconnectInfo->Timeout, NULL );
        if ( !NT_SUCCESS(status) ) {
            goto complete;
        }
        if ( status == STATUS_PENDING ) {
            status = STATUS_SUCCESS;
        }
    }

    status = STATUS_SUCCESS;

complete:

    Irp->IoStatus.Status = status;
    IoCompleteRequest( Irp, AfdPriorityBoost );

    return status;

} // AfdPartialDisconnect


NTSTATUS
AfdDisconnectEventHandler(
    IN PVOID TdiEventContext,
    IN CONNECTION_CONTEXT ConnectionContext,
    IN int DisconnectDataLength,
    IN PVOID DisconnectData,
    IN int DisconnectInformationLength,
    IN PVOID DisconnectInformation,
    IN ULONG DisconnectFlags
    )
{
    PAFD_CONNECTION connection = ConnectionContext;
    PAFD_ENDPOINT endpoint;
    KIRQL oldIrql;
    NTSTATUS status;

    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    endpoint = connection->Endpoint;
    ASSERT( endpoint->Type == AfdBlockTypeVcConnecting ||
            endpoint->Type == AfdBlockTypeVcListening );

    IF_DEBUG(CONNECT) {
        KdPrint(( "AfdDisconnectEventHandler called for endpoint %lx, "
                  "connection %lx\n",
                      connection->Endpoint, connection ));
    }

    UPDATE_CONN( connection, DisconnectFlags );

    //
    // Reference the connection object so that it does not go away while
    // we're processing it inside this function.  Without this
    // reference, the user application could close the endpoint object,
    // the connection reference count could go to zero, and the
    // AfdDeleteConnectedReference call at the end of this function
    // could cause a crash if the AFD connection object has been
    // completely cleaned up.
    //

    REFERENCE_CONNECTION( connection );

    //
    // Set up in the connection the fact that the remote side has
    // disconnected or aborted.
    //

    if ( (DisconnectFlags & TDI_DISCONNECT_ABORT) != 0 ) {
        connection->AbortIndicated = TRUE;
        status = STATUS_REMOTE_DISCONNECT;
        AfdRecordAbortiveDisconnectIndications();
    } else {
        connection->DisconnectIndicated = TRUE;
        status = STATUS_SUCCESS;
        AfdRecordGracefulDisconnectIndications();
    }

    //
    // If this is a nonbufferring transport, complete any pended receives.
    //

    if ( !connection->TdiBufferring ) {

        AfdCompleteIrpList(
            &connection->VcReceiveIrpListHead,
            &endpoint->SpinLock,
            status,
            NULL
            );

        //
        // If this is an abort indication, complete all pended sends and
        // discard any bufferred receive data.
        //

        if ( connection->AbortIndicated ) {

            AfdCompleteIrpList(
                &connection->VcSendIrpListHead,
                &endpoint->SpinLock,
                status,
                NULL
                );

            AfdAcquireSpinLock( &endpoint->SpinLock, &oldIrql );

            connection->VcBufferredReceiveBytes = 0;
            connection->VcBufferredReceiveCount = 0;
            connection->VcBufferredExpeditedBytes = 0;
            connection->VcBufferredExpeditedCount = 0;
            connection->VcReceiveBytesInTransport = 0;
            connection->VcReceiveCountInTransport = 0;

            while ( !IsListEmpty( &connection->VcReceiveBufferListHead ) ) {

                PAFD_BUFFER afdBuffer;
                PLIST_ENTRY listEntry;

                listEntry = RemoveHeadList( &connection->VcReceiveBufferListHead );
                afdBuffer = CONTAINING_RECORD( listEntry, AFD_BUFFER, BufferListEntry );

                afdBuffer->ExpeditedData = FALSE;
                afdBuffer->DataOffset = 0;

                AfdReturnBuffer( afdBuffer );
            }

            AfdReleaseSpinLock( &endpoint->SpinLock, oldIrql );
        }
    }

    //
    // If we got disconnect data or options, save it.
    //

    if( ( DisconnectData != NULL && DisconnectDataLength > 0 ) ||
        ( DisconnectInformation != NULL && DisconnectInformationLength > 0 ) ) {

        AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );

        if( DisconnectData != NULL & DisconnectDataLength > 0 ) {

            status = AfdSaveReceivedConnectData(
                         &connection->ConnectDataBuffers,
                         IOCTL_AFD_SET_DISCONNECT_DATA,
                         DisconnectData,
                         DisconnectDataLength
                         );

            if( !NT_SUCCESS(status) ) {

                //
                // We hit an allocation failure, but press on regardless.
                //

                KdPrint((
                    "AfdSaveReceivedConnectData failed: %08lx\n",
                    status
                    ));

            }

        }

        if( DisconnectInformation != NULL & DisconnectInformationLength > 0 ) {

            status = AfdSaveReceivedConnectData(
                         &connection->ConnectDataBuffers,
                         IOCTL_AFD_SET_DISCONNECT_DATA,
                         DisconnectInformation,
                         DisconnectInformationLength
                         );

            if( !NT_SUCCESS(status) ) {

                //
                // We hit an allocation failure, but press on regardless.
                //

                KdPrint((
                    "AfdSaveReceivedConnectData failed: %08lx\n",
                    status
                    ));

            }

        }

        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

    }

    //
    // Call AfdIndicatePollEvent in case anyone is polling on this
    // connection getting disconnected or aborted.
    //

    if ( (DisconnectFlags & TDI_DISCONNECT_ABORT) != 0 ) {

        AfdIndicatePollEvent(
            endpoint,
            AFD_POLL_ABORT_BIT,
            STATUS_SUCCESS
            );

    } else {

        AfdIndicatePollEvent(
            endpoint,
            AFD_POLL_DISCONNECT_BIT,
            STATUS_SUCCESS
            );

    }

    //
    // Remove the connected reference on the connection object.  We must
    // do this AFTER setting up the flag which remembers the disconnect
    // type that occurred.  We must also do this AFTER we have finished
    // handling everything in the endpoint, since the endpoint structure
    // may no longer have any information about the connection object if
    // a transmit request with AFD_TF_REUSE_SOCKET happenned on it.
    //

    AfdDeleteConnectedReference( connection, FALSE );

    //
    // Dereference the connection from the reference added above.
    //

    DEREFERENCE_CONNECTION( connection );

    return STATUS_SUCCESS;

} // AfdDisconnectEventHandler


NTSTATUS
AfdBeginAbort(
    IN PAFD_CONNECTION Connection
    )
{
    PAFD_ENDPOINT endpoint = Connection->Endpoint;
    PIRP irp;
    PFILE_OBJECT fileObject;
    PDEVICE_OBJECT deviceObject;
    KIRQL oldIrql;

    IF_DEBUG(CONNECT) {
        KdPrint(( "AfdBeginAbort: aborting on endpoint %lx\n", endpoint ));
    }

    // Yet another hack to keep it from crashing
    // Reduce the timing window were this connection can be removed
    // from under us. (VadimE)
    
    REFERENCE_CONNECTION( Connection );

    //
    // Build an IRP to reset the connection.  First get the address
    // of the target device object.
    //

    ASSERT( Connection->Type == AfdBlockTypeConnection );
    fileObject = Connection->FileObject;
    ASSERT( fileObject != NULL );
    deviceObject = IoGetRelatedDeviceObject( fileObject );

    AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );

    //
    // If the endpoint has already been abortively disconnected,
    // or if has been gracefully disconnected and the transport
    // does not support orderly (i.e. two-phase) release, then just
    // succeed this request.
    //
    // Note that, since the abort completion routine (AfdRestartAbort)
    // will not be called, we must delete the connected reference
    // ourselves.
    //

    if ( (endpoint->DisconnectMode & AFD_ABORTIVE_DISCONNECT) != 0 ||
         Connection->AbortIndicated ||
         (Connection->DisconnectIndicated &&
             (endpoint->TransportInfo->ProviderInfo.ServiceFlags &
                  TDI_SERVICE_ORDERLY_RELEASE) == 0) ) {
        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );
        AfdDeleteConnectedReference( Connection, FALSE );
   
            // Accounts for the reference hack above (VadimE)
        DEREFERENCE_CONNECTION( Connection );
        return STATUS_SUCCESS;
    }

#if ENABLE_ABORT_TIMER_HACK

    //
    // Allocate a new abort timer if necessary.
    //

    if( Connection->AbortTimerInfo == NULL ) {

        Connection->AbortTimerInfo = AFD_ALLOCATE_POOL(
                                         NonPagedPoolMustSucceed,
                                         sizeof(AFD_ABORT_TIMER_INFO),
                                         AFD_ABORT_TIMER_HACK_POOL_TAG
                                         );

    }

    ASSERT( Connection->AbortTimerInfo != NULL );

#endif  // ENABLE_ABORT_TIMER_HACK

    //
    // Remember that the connection has been aborted.
    //

    if ( endpoint->Type != AfdBlockTypeVcListening ) {
        endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_RECEIVE;
        endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_SEND;
        endpoint->DisconnectMode |= AFD_ABORTIVE_DISCONNECT;
    }

    Connection->AbortIndicated = TRUE;

    //
    // Set the BytesTaken fields equal to the BytesIndicated fields so
    // that no more AFD_POLL_RECEIVE or AFD_POLL_RECEIVE_EXPEDITED
    // events get completed.
    //

    if ( endpoint->TdiBufferring ) {

        Connection->Common.Bufferring.ReceiveBytesTaken =
            Connection->Common.Bufferring.ReceiveBytesIndicated;
        Connection->Common.Bufferring.ReceiveExpeditedBytesTaken =
            Connection->Common.Bufferring.ReceiveExpeditedBytesIndicated;

        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

    } else if ( endpoint->Type != AfdBlockTypeVcListening ) {

        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

        //
        // Complete all of the connection's pended sends and receives.
        //

        AfdCompleteIrpList(
            &Connection->VcReceiveIrpListHead,
            &endpoint->SpinLock,
            STATUS_LOCAL_DISCONNECT,
            NULL
            );

        AfdCompleteIrpList(
            &Connection->VcSendIrpListHead,
            &endpoint->SpinLock,
            STATUS_LOCAL_DISCONNECT,
            NULL
            );

    } else {

        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );
    }

    //
    // Allocate an IRP.  The stack size is one higher than that of the
    // target device, to allow for the caller's completion routine.
    //

    irp = IoAllocateIrp( (CCHAR)(deviceObject->StackSize), FALSE );

    if ( irp == NULL ) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Initialize the IRP for an abortive disconnect.
    //

    irp->MdlAddress = NULL;

    irp->Flags = 0;
    irp->RequestorMode = KernelMode;
    irp->PendingReturned = FALSE;

    irp->UserIosb = NULL;
    irp->UserEvent = NULL;

    irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;

    irp->AssociatedIrp.SystemBuffer = NULL;
    irp->UserBuffer = NULL;

    irp->Tail.Overlay.Thread = PsGetCurrentThread();
    irp->Tail.Overlay.OriginalFileObject = fileObject;
    irp->Tail.Overlay.AuxiliaryBuffer = NULL;

    TdiBuildDisconnect(
        irp,
        deviceObject,
        fileObject,
        AfdRestartAbort,
        Connection,
        NULL,
        TDI_DISCONNECT_ABORT,
        NULL,
        NULL
        );

    //
    // Reference the connection object so that it does not go away
    // until the abort completes.
    //

    // REFERENCE_CONNECTION( Connection ); Done above (VadimE)

    AfdRecordAbortiveDisconnectsInitiated();

    //
    // Pass the request to the transport provider.
    //

    return IoCallDriver( deviceObject, irp );

} // AfdBeginAbort


#if ENABLE_ABORT_TIMER_HACK
NTSTATUS
AfdRestartAbort(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
{

    PAFD_CONNECTION connection;
    PAFD_ABORT_TIMER_INFO timerInfo;

    connection = Context;
    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    UPDATE_CONN( connection, Irp->IoStatus.Status );

    timerInfo = connection->AbortTimerInfo;
    ASSERT( timerInfo != NULL );

    IF_DEBUG(CONNECT) {

        KdPrint((
            "AfdRestartAbort: abort completed, status = %X, endpoint = %lx\n",
            Irp->IoStatus.Status,
            connection->Endpoint
            ));

    }

    //
    // Setup a timer so we know it's safe to free the connection.
    //

    KeInitializeDpc(
        &timerInfo->Dpc,
        AfdAbortTimerHack,
        connection
        );

    KeInitializeTimer(
        &timerInfo->Timer
        );

    KeSetTimer(
        &timerInfo->Timer,
        AfdAbortTimerTimeout,
        &timerInfo->Dpc
        );

    //
    // Free the IRP now since it is no longer needed.
    //

    IoFreeIrp( Irp );

    //
    // Return STATUS_MORE_PROCESSING_REQUIRED so that IoCompleteRequest
    // will stop working on the IRP.
    //

    return STATUS_MORE_PROCESSING_REQUIRED;

}   // AfdRestartAbort

VOID
AfdAbortTimerHack(
    IN PKDPC Dpc,
    IN PVOID DeferredContext,
    IN PVOID SystemArgument1,
    IN PVOID SystemArgument2
    )
{

    PAFD_CONNECTION connection;

    connection = DeferredContext;
    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    //
    // Let the helper do the dirty work.
    //

    AfdRestartAbortHelper( connection );

}   // AfdAbortTimerHack

#else   // !ENABLE_ABORT_TIMER_HACK


NTSTATUS
AfdRestartAbort(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
{

    PAFD_CONNECTION connection;

    connection = Context;
    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    IF_DEBUG(CONNECT) {

        KdPrint((
            "AfdRestartAbort: abort completed, status = %X, endpoint = %lx\n",
            Irp->IoStatus.Status,
            connection->Endpoint
            ));

    }

    //
    // Let the helper do the dirty work.
    //

    AfdRestartAbortHelper( connection );

    //
    // Free the IRP now since it is no longer needed.
    //

    IoFreeIrp( Irp );

    //
    // Return STATUS_MORE_PROCESSING_REQUIRED so that IoCompleteRequest
    // will stop working on the IRP.
    //

    return STATUS_MORE_PROCESSING_REQUIRED;

} // AfdRestartAbort

#endif  // ENABLE_ABORT_TIMER_HACK


VOID
AfdRestartAbortHelper(
    IN PAFD_CONNECTION Connection
    )
{

    PAFD_ENDPOINT endpoint;

    ASSERT( Connection != NULL );
    ASSERT( Connection->Type == AfdBlockTypeConnection );

    endpoint = Connection->Endpoint;

    UPDATE_CONN( Connection, 0 );
    AfdRecordAbortiveDisconnectsCompleted();

    //
    // Remember that the connection has been aborted, and indicate if
    // necessary.
    //

    if( endpoint->Type != AfdBlockTypeVcListening ) {

        AfdIndicatePollEvent(
            endpoint,
            AFD_POLL_ABORT_BIT,
            STATUS_SUCCESS
            );

    }

    if( !Connection->TdiBufferring ) {

        //
        // Complete all of the connection's pended sends and receives.
        //

        AfdCompleteIrpList(
            &Connection->VcReceiveIrpListHead,
            &endpoint->SpinLock,
            STATUS_LOCAL_DISCONNECT,
            NULL
            );

        AfdCompleteIrpList(
            &Connection->VcSendIrpListHead,
            &endpoint->SpinLock,
            STATUS_LOCAL_DISCONNECT,
            NULL
            );

    }

    //
    // Remove the connected reference from the connection, since we
    // know that the connection will not be active any longer.
    //

    AfdDeleteConnectedReference( Connection, FALSE );

    //
    // Dereference the AFD connection object.
    //

    DEREFERENCE_CONNECTION( Connection );

}   // AfdRestartAbortHelper


NTSTATUS
AfdBeginDisconnect(
    IN PAFD_ENDPOINT Endpoint,
    IN PLARGE_INTEGER Timeout OPTIONAL,
    OUT PIRP *DisconnectIrp OPTIONAL
    )
{
    PTDI_CONNECTION_INFORMATION requestConnectionInformation = NULL;
    PTDI_CONNECTION_INFORMATION returnConnectionInformation = NULL;
    PAFD_CONNECTION connection;
    KIRQL oldIrql;
    PFILE_OBJECT fileObject;
    PDEVICE_OBJECT deviceObject;
    PAFD_DISCONNECT_CONTEXT disconnectContext;
    PIRP irp;

    ASSERT( Endpoint->Type == AfdBlockTypeVcConnecting );

    connection = Endpoint->Common.VcConnecting.Connection;
    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    fileObject = connection->FileObject;
    ASSERT( fileObject != NULL );
    deviceObject = IoGetRelatedDeviceObject( fileObject );

    UPDATE_CONN( connection, 0 );

    if ( DisconnectIrp != NULL ) {
        *DisconnectIrp = NULL;
    }

    //
    // Allocate and initialize a disconnect IRP.
    //

    irp = IoAllocateIrp( (CCHAR)(deviceObject->StackSize), FALSE );
    if ( irp == NULL ) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    //
    // Initialize the IRP.
    //

    irp->MdlAddress = NULL;

    irp->Flags = 0;
    irp->RequestorMode = KernelMode;
    irp->PendingReturned = FALSE;

    irp->UserIosb = NULL;
    irp->UserEvent = NULL;

    irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;

    irp->AssociatedIrp.SystemBuffer = NULL;
    irp->UserBuffer = NULL;

    irp->Tail.Overlay.Thread = PsGetCurrentThread();
    irp->Tail.Overlay.OriginalFileObject = fileObject;
    irp->Tail.Overlay.AuxiliaryBuffer = NULL;

    //
    // If the endpoint has already been abortively disconnected,
    // just succeed this request.
    //

    AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );

    if ( (Endpoint->DisconnectMode & AFD_ABORTIVE_DISCONNECT) != 0 ||
             connection->AbortIndicated ) {
        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );
        IoFreeIrp( irp );
        return STATUS_SUCCESS;
    }

    //
    // If this connection has already been disconnected, just succeed.
    //

    if ( (Endpoint->DisconnectMode & AFD_PARTIAL_DISCONNECT_SEND) != 0 ) {
        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );
        IoFreeIrp( irp );
        return STATUS_SUCCESS;
    }

    //
    // Use the disconnect context space in the connection structure.
    //

    disconnectContext = &connection->DisconnectContext;

    disconnectContext->Endpoint = Endpoint;
    disconnectContext->Connection = connection;
    disconnectContext->TdiConnectionInformation = NULL;
    disconnectContext->Irp = irp;

    InsertHeadList(
        &AfdDisconnectListHead,
        &disconnectContext->DisconnectListEntry
        );

    //
    // Remember that the send side has been disconnected.
    //

    Endpoint->DisconnectMode |= AFD_PARTIAL_DISCONNECT_SEND;

    //
    // If there are disconnect data buffers, allocate request
    // and return connection information structures and copy over
    // pointers to the structures.
    //

    if ( connection->ConnectDataBuffers != NULL ) {

        requestConnectionInformation =
            AFD_ALLOCATE_POOL(
                NonPagedPool,
                sizeof(*requestConnectionInformation) +
                    sizeof(*returnConnectionInformation),
                AFD_CONNECT_DATA_POOL_TAG
                );

        if ( requestConnectionInformation != NULL ) {

            returnConnectionInformation =
                requestConnectionInformation + 1;

            requestConnectionInformation->UserData =
                connection->ConnectDataBuffers->SendDisconnectData.Buffer;
            requestConnectionInformation->UserDataLength =
                connection->ConnectDataBuffers->SendDisconnectData.BufferLength;
            requestConnectionInformation->Options =
                connection->ConnectDataBuffers->SendDisconnectOptions.Buffer;
            requestConnectionInformation->OptionsLength =
                connection->ConnectDataBuffers->SendDisconnectOptions.BufferLength;
            returnConnectionInformation->UserData =
                connection->ConnectDataBuffers->ReceiveDisconnectData.Buffer;
            returnConnectionInformation->UserDataLength =
                connection->ConnectDataBuffers->ReceiveDisconnectData.BufferLength;
            returnConnectionInformation->Options =
                connection->ConnectDataBuffers->ReceiveDisconnectOptions.Buffer;
            returnConnectionInformation->OptionsLength =
                connection->ConnectDataBuffers->ReceiveDisconnectOptions.BufferLength;
        }

        disconnectContext->TdiConnectionInformation =
            requestConnectionInformation;
    }

    //
    // Set up the timeout for the disconnect.
    //

    disconnectContext->Timeout = RtlConvertLongToLargeInteger( -1 );

    //
    // Build a disconnect Irp to pass to the TDI provider.
    //

    TdiBuildDisconnect(
        irp,
        connection->DeviceObject,
        connection->FileObject,
        AfdRestartDisconnect,
        disconnectContext,
        &disconnectContext->Timeout,
        TDI_DISCONNECT_RELEASE,
        requestConnectionInformation,
        returnConnectionInformation
        );

    IF_DEBUG(CONNECT) {
        KdPrint(( "AfdBeginDisconnect: disconnecting endpoint %lx\n",
                      Endpoint ));
    }

    //
    // Reference the endpoint and connection so the space stays
    // allocated until the disconnect completes.
    //

    REFERENCE_ENDPOINT( Endpoint );
    REFERENCE_CONNECTION( connection );

    //
    // If there are still outstanding sends and this is a nonbufferring
    // TDI transport which does not support orderly release, pend the
    // IRP until all the sends have completed.
    //

    if ( (Endpoint->TransportInfo->ProviderInfo.ServiceFlags &
             TDI_SERVICE_ORDERLY_RELEASE) == 0 &&
         !Endpoint->TdiBufferring && connection->VcBufferredSendCount != 0 ) {

        ASSERT( connection->VcDisconnectIrp == NULL );

        connection->VcDisconnectIrp = irp;
        connection->SpecialCondition = TRUE;
        AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

        return STATUS_PENDING;
    }

    AfdRecordGracefulDisconnectsInitiated();
    AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

    //
    // Pass the disconnect request on to the TDI provider.
    //

    if ( DisconnectIrp == NULL ) {
        return IoCallDriver( connection->DeviceObject, irp );
    } else {
        *DisconnectIrp = irp;
        return STATUS_SUCCESS;
    }

} // AfdBeginDisconnect


NTSTATUS
AfdRestartDisconnect(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID Context
    )
{
    PAFD_DISCONNECT_CONTEXT disconnectContext = Context;
    PAFD_ENDPOINT endpoint;
    PAFD_CONNECTION connection;
    KIRQL oldIrql;

    endpoint = disconnectContext->Endpoint;
    connection = disconnectContext->Connection;

    UPDATE_CONN( connection, 0 );
    AfdRecordGracefulDisconnectsCompleted();

    ASSERT( connection != NULL );
    ASSERT( connection->Type == AfdBlockTypeConnection );

    IF_DEBUG(CONNECT) {
        KdPrint(( "AfdRestartDisconnect: disconnect completed, status = %X, "
                  "endpoint = %lx\n", Irp->IoStatus.Status, endpoint ));
    }

    //
    // Free context structures.
    //

    if ( disconnectContext->TdiConnectionInformation != NULL ) {
        AFD_FREE_POOL(
            disconnectContext->TdiConnectionInformation,
            AFD_CONNECT_DATA_POOL_TAG
            );
    }

    //
    // Remove the request from the list of disconnect requests and
    // Dereference the connection and endpoint.  We must remove it from
    // the list before dereferencing the endpoint because when we do the
    // dereference AFD might get unloaded, and we cannot acquire a spin
    // lock after AFD gets unloaded.
    //

    AfdAcquireSpinLock( &AfdSpinLock, &oldIrql );
    RemoveEntryList( &disconnectContext->DisconnectListEntry );
    AfdReleaseSpinLock( &AfdSpinLock, oldIrql );

    DEREFERENCE_ENDPOINT( endpoint );
    DEREFERENCE_CONNECTION( connection );

    //
    // Free the IRP and return a status code so that the IO system will
    // stop working on the IRP.
    //

    IoFreeIrp( Irp );
    return STATUS_MORE_PROCESSING_REQUIRED;

} // AfdRestartDisconnect