/*++                        

Copyright (c) 1995-1996  Microsoft Corporation

Module Name:

    pxcl.c

Abstract:

    The module contains the calls to the proxy client from NDIS.

Author:

   Richard Machin (RMachin)

Revision History:

    Who         When            What
    --------    --------        ----------------------------------------------
    RMachin     10-3-96         created
    TonyBe      02-21-99        re-work/re-write

Notes:

--*/
#include "precomp.h"

#define MODULE_NUMBER MODULE_CL
#define _FILENUMBER 'LCXP'


NDIS_STATUS
PxClCreateVc(
    IN NDIS_HANDLE ProtocolAfContext,
    IN NDIS_HANDLE NdisVcHandle,
    OUT PNDIS_HANDLE ProtocolVcContext
    )
{
    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
    PPX_CL_AF   pClAf;
    PPX_VC      pVc;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCreateVc: ClAf %p\n", ProtocolAfContext));

    pClAf = (PPX_CL_AF)ProtocolAfContext;

    NdisAcquireSpinLock(&pClAf->Lock);

    if (pClAf->State != PX_AF_OPENED) {
        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClCreateVc: Invalid AfState ClAf %p, State %x\n", 
             pClAf, pClAf->State));

        NdisReleaseSpinLock(&pClAf->Lock);

        return (NDIS_STATUS_FAILURE);
    }

    pVc = PxAllocateVc(pClAf);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClCreateVc: Error allocating memory\n"));

        NdisReleaseSpinLock(&pClAf->Lock);

        return (NDIS_STATUS_RESOURCES);
    }

    pVc->ClVcHandle = NdisVcHandle;

    NdisReleaseSpinLock(&pClAf->Lock);

    if (!InsertVcInTable(pVc)) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClCreateVc: failed to insert in vc table\n"));

        PxFreeVc(pVc);

        return (NDIS_STATUS_RESOURCES);
    }
   
    *ProtocolVcContext = (NDIS_HANDLE)pVc->hdCall;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCreateVc: Exit\n"));

    return(NDIS_STATUS_SUCCESS);
}


NDIS_STATUS
PxClDeleteVc(
    IN NDIS_HANDLE ProtocolVcContext
    )
{
    PPX_VC  pVc;

    NDIS_STATUS Status = NDIS_STATUS_SUCCESS;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClDeleteVc: Enter\n"));

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClDeleteVc: VcCtx invalid %x\n", ProtocolVcContext));

        return (NDIS_STATUS_FAILURE);
    }

    ASSERT(pVc->State == PX_VC_IDLE);

    //
    // Deref for ref applied when we allocated the Vc.
    // We do not need the full deref code as the ref
    // applied at entry will keep the vc around.
    //
    pVc->RefCount--;

    //
    // Deref for ref applied at entry when 
    // validating the vc
    //
    DEREF_VC(pVc);

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClDeleteVc: Exit, Status %x\n", Status));

    return (Status);
}


NDIS_STATUS
PxClRequest(
    IN  NDIS_HANDLE             ProtocolAfContext,
    IN  NDIS_HANDLE             ProtocolVcContext       OPTIONAL,
    IN  NDIS_HANDLE             ProtocolPartyContext    OPTIONAL,
    IN OUT PNDIS_REQUEST        NdisRequest
    )
/*++

Routine Description:

    This is called by an underlying cm/mp to send an ndisrequest to
    a client.  Since we might be proxying on behalf of multiple clients
    we need to broadcast this request on to all clients that have
    opened our address family for this adapter.  We are interested in
    OID_CO_AF_CLOSE so that we can cleanup our open on the Af and
    OID_GEN_CO_LINK_SPEED so that we can get changes in linkspeed
    on the adapter (and Vc if active).

Arguments:



Return Value:


--*/
{
    PPX_CL_AF       pClAf;
    PPX_CM_AF       pCmAf;
    PPX_ADAPTER     pAdapter;
    PPX_VC          pVc = NULL;
    NDIS_STATUS     Status;
    NDIS_HANDLE     VcHandle;

    //
    // The Vc returned here could be NULL as this
    // request might not be on vc.
    //
    GetVcFromCtx(ProtocolVcContext, &pVc);
    
    pClAf = (PPX_CL_AF)ProtocolAfContext;
    pAdapter = pClAf->Adapter;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClRequest: ClAf %p, Vc %p\n", pClAf, pVc));

    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);

    switch (NdisRequest->DATA.QUERY_INFORMATION.Oid) {
        case OID_CO_AF_CLOSE:
            {
            PPX_TAPI_PROVIDER   TapiProvider;

            NdisAcquireSpinLock(&pAdapter->Lock);

            RemoveEntryList(&pClAf->Linkage);

            InsertTailList(&pAdapter->ClAfClosingList, &pClAf->Linkage);

            NdisReleaseSpinLock(&pAdapter->Lock);

            //
            // We need to cleanup and close the open
            // on this af.  This would include tearing
            // down all active calls (Vc's), deregistering
            // all saps and closing the af.
            //
            NdisAcquireSpinLock(&pClAf->Lock);

            //
            // Mark the Af as closing...
            //
            pClAf->State = PX_AF_CLOSING;

            TapiProvider = pClAf->TapiProvider;

            NdisReleaseSpinLock(&pClAf->Lock);

            //
            // Take all tapi devices associated with
            // this address family offline
            //
            if (TapiProvider != NULL) {
                NdisAcquireSpinLock(&TapiProvider->Lock);

                MarkProviderOffline(TapiProvider);

                NdisReleaseSpinLock(&TapiProvider->Lock);
            }

            //
            // Build list of Vc's that need attention
            //
            NdisAcquireSpinLock(&pClAf->Lock);

            while (!IsListEmpty(&pClAf->VcList)) {
                PLIST_ENTRY         Entry;
                PPX_VC              pActiveVc;

                Entry = RemoveHeadList(&pClAf->VcList);

                InsertHeadList(&pClAf->VcClosingList, Entry);

                pActiveVc = CONTAINING_RECORD(Entry, PX_VC, ClAfLinkage);

                NdisReleaseSpinLock(&pClAf->Lock);

                NdisAcquireSpinLock(&pActiveVc->Lock);

                pActiveVc->CloseFlags |= PX_VC_CLOSE_AF;

                REF_VC(pActiveVc);

                PxVcCleanup(pActiveVc, 0);

                DEREF_VC_LOCKED(pActiveVc);

                NdisAcquireSpinLock(&pClAf->Lock);
            }

            //
            // Get rid of all of the saps
            //
            {
                PLIST_ENTRY pe;
                PPX_CL_SAP  pClSap;

                pe = pClAf->ClSapList.Flink;

                pClSap =
                    CONTAINING_RECORD(pe, PX_CL_SAP, Linkage);

                while ((PVOID)pClSap != (PVOID)&pClAf->ClSapList) {

                    if (InterlockedCompareExchange((PLONG)&pClSap->State,
                                                   PX_SAP_CLOSING,
                                                   PX_SAP_OPENED)) {

                        RemoveEntryList(&pClSap->Linkage);

                        InsertTailList(&pClAf->ClSapClosingList, &pClSap->Linkage);

                        NdisReleaseSpinLock(&pClAf->Lock);

                        ClearSapWithTapiLine(pClSap);

                        Status = NdisClDeregisterSap(pClSap->NdisSapHandle);

                        if (Status != NDIS_STATUS_PENDING) {
                            PxClDeregisterSapComplete(Status, pClSap);
                        }

                        NdisAcquireSpinLock(&pClAf->Lock);

                        pe = pClAf->ClSapList.Flink;

                        pClSap =
                            CONTAINING_RECORD(pe, PX_CL_SAP, Linkage);
                    } else {
                        pe = pClSap->Linkage.Flink;

                        pClSap =
                            CONTAINING_RECORD(pe, PX_CL_SAP, Linkage);
                    }
                }
            }

            DEREF_CL_AF_LOCKED(pClAf);

            //
            // Now broadcast this close to all of the clients
            // we have using this adapter/af.
            //
            NdisAcquireSpinLock(&pAdapter->Lock);

            while (!IsListEmpty(&pAdapter->CmAfList)) {
                PX_REQUEST  ProxyRequest;
                PPX_REQUEST pProxyRequest = &ProxyRequest;
                ULONG       Info = 0;
                PNDIS_REQUEST   NdisRequest;

                pCmAf = (PPX_CM_AF)RemoveHeadList(&pAdapter->CmAfList);

                InsertTailList(&pAdapter->CmAfClosingList, &pCmAf->Linkage);

                NdisReleaseSpinLock(&pAdapter->Lock);

                NdisAcquireSpinLock(&pCmAf->Lock);

                pCmAf->State = PX_AF_CLOSING;

                REF_CM_AF(pCmAf);

                NdisReleaseSpinLock(&pCmAf->Lock);

                NdisZeroMemory(pProxyRequest, sizeof(PX_REQUEST));

                NdisRequest = &pProxyRequest->NdisRequest;

                NdisRequest->RequestType =
                    NdisRequestSetInformation;
                NdisRequest->DATA.QUERY_INFORMATION.Oid =
                    OID_CO_AF_CLOSE;
                NdisRequest->DATA.QUERY_INFORMATION.InformationBuffer =
                    &Info;
                NdisRequest->DATA.QUERY_INFORMATION.InformationBufferLength =
                    sizeof(ULONG);

                PxInitBlockStruc(&pProxyRequest->Block);

                Status = NdisCoRequest(pAdapter->CmBindingHandle,
                                       pCmAf->NdisAfHandle,
                                       NULL,
                                       NULL,
                                       NdisRequest);

                if (Status == NDIS_STATUS_PENDING) {
                    Status = PxBlock(&pProxyRequest->Block);
                }

                DEREF_CM_AF(pCmAf);

                NdisAcquireSpinLock(&pAdapter->Lock);
            }

            NdisReleaseSpinLock(&pAdapter->Lock);

            }
            break;

        case OID_GEN_CO_LINK_SPEED:
            //
            // We need to record the new speed of
            // the vc.
            //
            break;

        default:
            //
            // Just pass it through
            //
            break;
    }

    VcHandle = (pVc != NULL) ? pVc->CmVcHandle : NULL;

    //
    // Now broadcast this request up to all of the Clients 
    // that have opend our af for this adapter.
    //
    NdisAcquireSpinLock(&pAdapter->Lock);

    pCmAf = (PPX_CM_AF)pAdapter->CmAfList.Flink;

    while ((PVOID)pCmAf != (PVOID)&pAdapter->CmAfList) {
        PPX_CM_AF   NextAf;
        PX_REQUEST  ProxyRequest;
        PPX_REQUEST pProxyRequest = &ProxyRequest;

        NextAf = 
            (PPX_CM_AF)pCmAf->Linkage.Flink;

        NdisAcquireSpinLock(&pCmAf->Lock);

        if (pCmAf->State != PX_AF_OPENED) {
            NdisReleaseSpinLock(&pCmAf->Lock);
            pCmAf = NextAf;
            continue;
        }

        REF_CM_AF(pCmAf);
        NdisReleaseSpinLock(&pCmAf->Lock);

        NdisZeroMemory(pProxyRequest, sizeof(PX_REQUEST));

        NdisMoveMemory(&pProxyRequest->NdisRequest, NdisRequest, sizeof(NDIS_REQUEST));

        NdisReleaseSpinLock(&pAdapter->Lock);

        PxInitBlockStruc(&pProxyRequest->Block);

        Status = NdisCoRequest(pAdapter->CmBindingHandle,
                               pCmAf->NdisAfHandle,
                               VcHandle,
                               NULL,
                               &pProxyRequest->NdisRequest);

        if (Status == NDIS_STATUS_PENDING) {
            PxBlock(&pProxyRequest->Block);
        }

        NdisAcquireSpinLock(&pAdapter->Lock);

        //
        // deref for the ref applied before we
        // propagated this request
        //
        DEREF_CM_AF(pCmAf);

        pCmAf = NextAf;
    }

    NdisReleaseSpinLock(&pAdapter->Lock);

    //
    // Remove ref applied when we attempted to
    // map the vcctx to a vcptr at entry.
    //
    DEREF_VC(pVc);

    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);

    return (NDIS_STATUS_SUCCESS);
}

VOID
PxClRequestComplete(
    IN NDIS_STATUS Status,
    IN NDIS_HANDLE ProtocolAfContext,
    IN NDIS_HANDLE ProtocolVcContext,       // Optional
    IN NDIS_HANDLE ProtocolPartyContext,    // Optional
    IN PNDIS_REQUEST NdisRequest
    )
{
    PPX_REQUEST     pProxyRequest;
    PPX_CL_AF       pClAf;
    PPX_VC          pVc = NULL;

    pClAf = (PPX_CL_AF)ProtocolAfContext;

    //
    // The Vc returned here could be NULL as this
    // request might not be on vc.
    //
    GetVcFromCtx(ProtocolVcContext, &pVc);

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClRequestComplete: ClAf %p, Vc %p, Oid: %x, Status %x\n", 
         pClAf, pVc, NdisRequest->DATA.QUERY_INFORMATION.Oid, Status));

    pProxyRequest = CONTAINING_RECORD(NdisRequest, PX_REQUEST, NdisRequest);

    if (pProxyRequest->Flags & PX_REQ_ASYNC) {
        pProxyRequest->Flags &= ~PX_REQ_ASYNC;
        PxFreeMem(pProxyRequest);
    } else {
        PxSignal(&pProxyRequest->Block, Status);
    }

    //
    // Remove ref applied when we attempted to
    // map the vcctx to a vcptr at entry.
    //
    DEREF_VC(pVc);
}

VOID
PxClOpenAfComplete(
    IN NDIS_STATUS Status,
    IN NDIS_HANDLE ProtocolAfContext,
    IN NDIS_HANDLE NdisAfHandle
    )
{
    PPX_CL_AF   pClAf;

    pClAf = (PPX_CL_AF)ProtocolAfContext;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClOpenAfComplete: ClAf %p, Status %x\n", pClAf, Status));

    pClAf->NdisAfHandle = NdisAfHandle;

    PxSignal(&pClAf->Block, Status);
}

VOID
PxClCloseAfComplete(
    IN NDIS_STATUS  Status,
    IN NDIS_HANDLE  ProtocolAfContext
    )
{
    PPX_CL_AF   pClAf;
    PPX_ADAPTER pAdapter;
    PPX_TAPI_PROVIDER   TapiProvider;

    pClAf = (PPX_CL_AF)ProtocolAfContext;
    pAdapter = pClAf->Adapter;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCloseAfComplete: ClAf %p, Status %x\n", pClAf, Status));

    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);

    NdisAcquireSpinLock(&pAdapter->Lock);

    RemoveEntryList(&pClAf->Linkage);

    DEREF_ADAPTER_LOCKED(pAdapter);

    NdisAcquireSpinLock(&pClAf->Lock);

    pClAf->State = PX_AF_CLOSED;

    TapiProvider = pClAf->TapiProvider;
    pClAf->TapiProvider = NULL;

    NdisReleaseSpinLock(&pClAf->Lock);

    if (TapiProvider != NULL) {

        NdisAcquireSpinLock(&TapiProvider->Lock);

        MarkProviderOffline(TapiProvider);

        NdisReleaseSpinLock(&TapiProvider->Lock);
    }

    PxFreeClAf(pClAf);

    ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
}


VOID
PxClRegisterSapComplete(
    IN NDIS_STATUS  Status,
    IN NDIS_HANDLE  ProtocolSapContext,
    IN PCO_SAP      pSap,
    IN NDIS_HANDLE  NdisSapHandle
    )
{
    PPX_CL_SAP      pClSap;
    PPX_CL_AF       pClAf;
    PPX_TAPI_LINE   TapiLine;

    pClSap = (PPX_CL_SAP)ProtocolSapContext;
    pClAf = pClSap->ClAf;
    TapiLine = pClSap->TapiLine;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClRegisterSapComplete: ClSap %p, Status %x\n", pClSap, Status));


    if (Status != NDIS_STATUS_SUCCESS) {

        InterlockedExchange((PLONG)&pClSap->State, PX_SAP_CLOSED);

        NdisAcquireSpinLock(&pClAf->Lock);

        RemoveEntryList(&pClSap->Linkage);

        DEREF_CL_AF_LOCKED(pClAf);

        TapiLine->ClSap = NULL;

        PxFreeClSap(pClSap);

        return;
    }

    pClSap->NdisSapHandle = NdisSapHandle;

    NdisAcquireSpinLock(&pClAf->Lock);

    if (pClAf->State != PX_AF_OPENED) {
        //
        // the af is no longer open so we to deregister
        // this sap
        //

        NdisReleaseSpinLock(&pClAf->Lock);

        InterlockedExchange((PLONG)&pClSap->State, PX_SAP_CLOSING);

        Status = NdisClDeregisterSap(pClSap->NdisSapHandle);

        if (Status != NDIS_STATUS_PENDING) {
            PxClDeregisterSapComplete(Status, pClSap);
        }

        return;
    }

    NdisReleaseSpinLock(&pClAf->Lock);


    NdisAcquireSpinLock(&TapiLine->Lock);

    if (TapiLine->DevStatus->ulNumOpens == 0) {

        NdisReleaseSpinLock(&TapiLine->Lock);

        //
        // There are not any opens on the line so we
        // need to deregister the sap
        //
        InterlockedExchange((PLONG)&pClSap->State, PX_SAP_CLOSING);

        Status = NdisClDeregisterSap(pClSap->NdisSapHandle);

        if (Status != NDIS_STATUS_PENDING) {
            PxClDeregisterSapComplete(Status, pClSap);
        }

        return;
    }

    NdisReleaseSpinLock(&TapiLine->Lock);

    InterlockedExchange((PLONG)&pClSap->State, PX_SAP_OPENED);
}

VOID
PxClDeregisterSapComplete(
    IN NDIS_STATUS  Status,
    IN NDIS_HANDLE  ProtocolSapContext
    )
{
    PPX_CL_SAP  pClSap;
    PPX_CL_AF   pClAf;

    pClSap = (PPX_CL_SAP)ProtocolSapContext;
    pClAf = pClSap->ClAf;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClDeregisterSapComplete: ClSap %p, Status %x\n", pClSap, Status));

    NdisAcquireSpinLock(&pClAf->Lock);

    RemoveEntryList(&pClSap->Linkage);

    DEREF_CL_AF_LOCKED(pClAf);

    InterlockedExchange((PLONG)&pClSap->State, PX_SAP_CLOSED);

    PxFreeClSap(pClSap);
}

VOID
PxClMakeCallComplete(
    IN  NDIS_STATUS         Status,
    IN  NDIS_HANDLE         ProtocolVcContext,
    IN  NDIS_HANDLE         ProxyNdisPartyHandle OPTIONAL,
    IN  PCO_CALL_PARAMETERS pCallParameters
    )
{
    PPX_VC      pVc;
    PPX_CL_AF   pClAf;
    ULONG       ulCallState;
    ULONG       ulCallStateMode;
    BOOLEAN     TapiStateChange;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClMakeCallComplete: VcCtx %x, Status %x\n", ProtocolVcContext, Status));

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {
        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClMakeCallComplete: pVc invalid %x\n", ProtocolVcContext));

        return;
    }

    TapiStateChange = TRUE;

    NdisAcquireSpinLock(&pVc->Lock);

    ASSERT(pVc->Flags & PX_VC_OWNER);

    do {

        if (pVc->Flags & PX_VC_OUTCALL_ABORTED) {
            //
            // This call has been aborted while
            // in the PROCEEDING state.  This means
            // that the CloseCallComplete has run 
            // and did our cleanup so just get
            // out.
            //
            break;

        } else if (pVc->Flags & PX_VC_OUTCALL_ABORTING) {
            pVc->Flags &= ~PX_VC_OUTCALL_ABORTING;
            pVc->Flags |= PX_VC_OUTCALL_ABORTED;
        }


        ASSERT((pVc->State == PX_VC_DISCONNECTING) ||
               (pVc->State == PX_VC_PROCEEDING));

        if (Status == NDIS_STATUS_SUCCESS) {

            //
            // This means that we received a drop from tapi
            // while the ClMakeCall was pending.
            //
            if (pVc->State == PX_VC_DISCONNECTING) {
                //
                // We need to drop the call with the
                // call manager/miniport
                //
                pVc->Flags &= ~PX_VC_OUTCALL_ABORTED;
                PxCloseCallWithCm(pVc);

                TapiStateChange = FALSE;

            } else {

                ulCallState = LINECALLSTATE_CONNECTED;
                ulCallStateMode = 0;
                pVc->PrevState = pVc->State;
                pVc->State = PX_VC_CONNECTED;
            }

        } else {

            ulCallState = LINECALLSTATE_DISCONNECTED;
            ulCallStateMode =
                PxMapNdisStatusToTapiDisconnectMode(Status, TRUE);

            //
            // Remove the ref applied before we
            // call NdisClMakeCall.  We don't need
            // to do the full deref code here as the
            // ref applied when we mapped the vc will
            // keep the vc around!
            //
            pVc->RefCount--;

            pVc->PrevState = pVc->State;
            pVc->State = PX_VC_IDLE;
        }

        if (TapiStateChange == TRUE) {

            SendTapiCallState(pVc, 
                              ulCallState, 
                              ulCallStateMode, 
                              pVc->CallInfo->ulMediaMode);
        }

        if (pVc->Flags & PX_VC_DROP_PENDING){
            PxTapiCompleteDropIrps(pVc, Status);
        }

    } while (FALSE);

    //
    // Deref for ref applied when mapping the context.
    // This releases the Vc lock!
    //
    DEREF_VC_LOCKED(pVc);
}

VOID
PxClModifyCallQosComplete(
    IN NDIS_STATUS          Status,
    IN NDIS_HANDLE          ProtocolVcContext,
    IN PCO_CALL_PARAMETERS  CallParameters
    )
{

}


VOID
PxClCloseCallComplete(
    IN NDIS_STATUS  Status,
    IN NDIS_HANDLE  ProtocolVcContext,
    IN NDIS_HANDLE  ProtocolPartyContext OPTIONAL
    )
{
    PPX_VC      pVc;
    PPX_CL_AF   pClAf;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCloseCallComplete: VcCtx %x, Status %x\n", ProtocolVcContext, Status));

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClCloseCallComplete: pVc invalid %x\n", ProtocolVcContext));

        return;
    }

    NdisAcquireSpinLock(&pVc->Lock);

    do {

        //
        // The closecall did not take (atm does
        // not support receiving a closecall while
        // an outgoing call is proceeding).  We 
        // need to get out and cleanup later.
        //
        if (Status != NDIS_STATUS_SUCCESS) {
            pVc->Flags |= PX_VC_CLEANUP_CM;
            pVc->CloseFlags |= PX_VC_CM_CLOSE_FAIL;
            break;
        }

        pVc->CloseFlags |= PX_VC_CM_CLOSE_COMP;

        if (pVc->Flags & PX_VC_OUTCALL_ABORTED) {

            //
            // This call has been aborted while
            // in the PROCEEDING state.  This means
            // that the MakeCallComplete has run 
            // and did our cleanup so just get
            // out.
            //
            break;

        } else if (pVc->Flags & PX_VC_OUTCALL_ABORTING) {

            pVc->Flags &= ~PX_VC_OUTCALL_ABORTING;
            pVc->Flags |= PX_VC_OUTCALL_ABORTED;
        } else if (pVc->Flags & PX_VC_INCALL_ABORTING) {
            pVc->Flags &= ~PX_VC_INCALL_ABORTING;
            pVc->Flags |= PX_VC_INCALL_ABORTED;
        }

        pVc->PrevState = pVc->State;
        pVc->State = PX_VC_IDLE;

        pClAf = pVc->ClAf;

        SendTapiCallState(pVc, 
                          LINECALLSTATE_DISCONNECTED, 
                          0, 
                          pVc->CallInfo->ulMediaMode);

        if (pVc->Flags & PX_VC_DROP_PENDING) {
            PxTapiCompleteDropIrps(pVc, Status);
        }

        //
        // Remove the ref applied when this call
        // became connected with the call manager
        // (NdisClMakeCall/PxClIncomingCall).
        // We don't need to do the full deref code 
        // here as the ref applied when we mapped 
        // the vc will keep the vc around!
        //
        pVc->RefCount--;

    } while (FALSE);

    //
    // Deref for ref applied at entry when 
    // validating the vc
    //
    DEREF_VC_LOCKED(pVc);
}


VOID
PxClAddPartyComplete(
    IN NDIS_STATUS status,
    IN NDIS_HANDLE ProtocolPartyContext,
    IN NDIS_HANDLE NdisPartyHandle,
    IN PCO_CALL_PARAMETERS CallParameters
    )
{
    ASSERT(0);
}

VOID
PxClDropPartyComplete(
    IN NDIS_STATUS status,
    IN NDIS_HANDLE ProtocolPartyContext
    )
{
    ASSERT(0);
}

NDIS_STATUS
PxClIncomingCall(
    IN NDIS_HANDLE              ProtocolSapContext,
    IN NDIS_HANDLE              ProtocolVcContext,
    IN OUT PCO_CALL_PARAMETERS  pCallParams
    )
{
    PPX_VC      pVc;
    PPX_CL_SAP  pClSap;
    PPX_CL_AF   pClAf;
    NDIS_STATUS Status;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClIncomingCall: Sap %p VcCtx %x\n", 
         ProtocolSapContext, ProtocolVcContext));

    pClSap = (PPX_CL_SAP)ProtocolSapContext;

    if (pClSap->State != PX_SAP_OPENED) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClIncomingCall: Invalid SapState Sap %p State %x\n", 
             pClSap, pClSap->State));

        return (NDIS_STATUS_FAILURE);
    }

    pClAf = pClSap->ClAf;

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClIncomingCall: pVc invalid %x\n", ProtocolVcContext));

        return (NDIS_STATUS_FAILURE);
    }

    Status =
        (*pClAf->AfGetTapiCallParams)(pVc, pCallParams);

    if (Status != NDIS_STATUS_SUCCESS) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClIncomingCall: pVc invalid %x\n", ProtocolVcContext));

        return (Status);
    }

    NdisAcquireSpinLock(&pVc->Lock);

    // The algorithim for computing a unique "htCall" is to start
    // at the value 1, and perpetually increment by 2.  Keeping
    // the low bit set will allow the user-mode TAPI component
    // we talk to to distinguish between these incoming call handles
    // and outgoing call handles, the latter of which will always
    // have the low bit zero'd (since they're really pointers to heap).
    //
    // In <= NT 4.0, valid values used to range between 0x80000000
    // and 0xffffffff, as we relied on the fact that user-mode
    // addresses always had the low bit zero'd.  (Not a valid
    // assumption anymore!)
    //

    pVc->htCall = 
        InterlockedExchangeAdd((PLONG)&TspCB.htCall, 2);

    //
    // This ref is applied for the indication to
    // tapi of a new call.  The ref will be removed
    // when tapi closes the call in PxTapiCloseCall.
    //
    REF_VC(pVc);

    //
    // This ref is applied for the connection
    // between the proxy and the call manager.
    // The ref will be removed in either 
    // PxClCloseCallComplete or PxVcCleanup
    // in the case where the offered call is
    // dropped by the client.
    //
    REF_VC(pVc);

    SendTapiNewCall(pVc, 
                    pVc->hdCall, 
                    pVc->htCall, 
                    0);

    SendTapiCallState(pVc, 
                      LINECALLSTATE_OFFERING, 
                      0, 
                      pVc->CallInfo->ulMediaMode);

    pVc->PrevState = pVc->State;
    pVc->State = PX_VC_OFFERING;

    PxStartIncomingCallTimeout(pVc);

    //
    // Deref for ref applied at entry when 
    // validating the vc
    //
    DEREF_VC_LOCKED(pVc);

    return (NDIS_STATUS_PENDING);
}

VOID
PxClIncomingCallQosChange(
    IN NDIS_HANDLE          ProtocolVcContext,
    IN PCO_CALL_PARAMETERS  pCallParams
    )
{

}


VOID
PxClIncomingCloseCall(
    IN NDIS_STATUS  CloseStatus,
    IN NDIS_HANDLE  ProtocolVcContext,
    IN PVOID        CloseData OPTIONAL,
    IN UINT         Size OPTIONAL
    )
{
    PPX_VC      pVc;
    PPX_CL_AF   pClAf;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClIncomingCloseCall: VcCtx %x\n", ProtocolVcContext));

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClIncomingCloseCall: pVc invalid %x\n", ProtocolVcContext));

        return;
    }

    NdisAcquireSpinLock(&pVc->Lock);

    pVc->CloseFlags |= PX_VC_INCOMING_CLOSE;

    PxVcCleanup(pVc, PX_VC_CLEANUP_CM);

    //
    // remove the ref applied when we
    // mapped the ctx to the vc at entry
    //
    DEREF_VC_LOCKED(pVc);

}

VOID
PxClIncomingDropParty(
    IN NDIS_STATUS  DropStatus,
    IN NDIS_HANDLE  ProtocolPartyContext,
    IN PVOID        CloseData OPTIONAL,
    IN UINT         Size OPTIONAL
    )
{
    ASSERT(0);
}

VOID
PxClCallConnected(
    IN NDIS_HANDLE ProtocolVcContext
    )
{
    PPX_VC  pVc;

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCallConnected: VcCtx %x\n", ProtocolVcContext));

    GetVcFromCtx(ProtocolVcContext, &pVc);

    if (pVc == NULL) {

        PXDEBUGP(PXD_WARNING, PXM_CL,
            ("PxClCallConnected: pVc invalid %x\n", ProtocolVcContext));

        return;
    }

    NdisAcquireSpinLock(&pVc->Lock);

    PXDEBUGP(PXD_LOUD, PXM_CL,
        ("PxClCallConnected: pVc %p, State %x\n", pVc, pVc->State));

    if (pVc->State == PX_VC_CONNECTED) {

        SendTapiCallState(pVc, 
                          LINECALLSTATE_CONNECTED, 
                          0, 
                          pVc->CallInfo->ulMediaMode);
    }

    //
    // Deref for ref applied at entry when 
    // validating the vc
    //
    DEREF_VC_LOCKED(pVc);

    PXDEBUGP(PXD_LOUD, PXM_CL, ("PxClCallConnected: Exit\n"));
}