callmgr.c

驱动开发,经过测试可以直接编译后使用,编译使用DDK中的build工具

/*++

Copyright (c) 1990-1998  Microsoft Corporation, All Rights Reserved.

Module Name:

    callmgr.c

Abstract:

    This module contains the interface of the driver with the Call Manager.

Author:

    Anil Francis Thomas (10/98)

Environment:

    Kernel

Revision History:

--*/
#include "precomp.h"
#pragma hdrstop


#define MODULE_ID    MODULE_CALLMGR

VOID
AtmSmCoAfRegisterNotify(
    IN  NDIS_HANDLE                 ProtocolBindingContext,
    IN  PCO_ADDRESS_FAMILY          pAddressFamily
    )
/*++

Routine Description:

    This routine is called by NDIS when a Call manager registers its support
    for an Address Family over an adapter. If this is the Address Family we
    are interested in (UNI 3.1), then we register our SAP on this adapter.

Arguments:

    ProtocolBindingContext  - our context passed in NdisOpenAdapter, which is
                              a pointer to our Adapter structure.
    pAddressFamily          - points to a structure describing the 
                              Address Family registered by a Call Manager.

Return Value:

    None

--*/
{
    PATMSM_ADAPTER              pAdapt = (PATMSM_ADAPTER)
                                                ProtocolBindingContext;
    NDIS_STATUS                 Status;
    NDIS_CLIENT_CHARACTERISTICS Chars;

    TraceIn(AtmSmCoAfRegisterNotify);

    if(!AtmSmReferenceAdapter(pAdapt))
        return;

    if ((pAddressFamily->AddressFamily   == CO_ADDRESS_FAMILY_Q2931)   &&
        (pAddressFamily->MajorVersion    == 3)                         &&
        (pAddressFamily->MinorVersion    == 1)                         &&
        (pAdapt->NdisAfHandle           == NULL))
    {
        DbgInfo(("AfNotify: Adapter %X\n", pAdapt));

        //
        // We successfully opened the adapter. Now open the address-family
        //
        pAdapt->AddrFamily.AddressFamily = CO_ADDRESS_FAMILY_Q2931;
        pAdapt->AddrFamily.MajorVersion  = 3;
        pAdapt->AddrFamily.MinorVersion  = 1;

        NdisZeroMemory(&Chars, sizeof(NDIS_CLIENT_CHARACTERISTICS));
        Chars.MajorVersion = 5;
        Chars.MinorVersion = 0;
        Chars.ClCreateVcHandler         = AtmSmCreateVc;
        Chars.ClDeleteVcHandler         = AtmSmDeleteVc;
        Chars.ClRequestHandler          = AtmSmCoRequest;
        Chars.ClRequestCompleteHandler  = AtmSmCoRequestComplete;
        Chars.ClOpenAfCompleteHandler   = AtmSmOpenAfComplete;
        Chars.ClCloseAfCompleteHandler  = AtmSmCloseAfComplete;
        Chars.ClRegisterSapCompleteHandler   = AtmSmRegisterSapComplete;
        Chars.ClDeregisterSapCompleteHandler = AtmSmDeregisterSapComplete;
        Chars.ClMakeCallCompleteHandler      = AtmSmMakeCallComplete;
        Chars.ClModifyCallQoSCompleteHandler = NULL;
        Chars.ClCloseCallCompleteHandler = AtmSmCloseCallComplete;
        Chars.ClAddPartyCompleteHandler  = AtmSmAddPartyComplete;
        Chars.ClDropPartyCompleteHandler = AtmSmDropPartyComplete;
        Chars.ClIncomingCallHandler      = AtmSmIncomingCall;
        Chars.ClIncomingCallQoSChangeHandler = AtmSmIncomingCallQoSChange;
        Chars.ClIncomingCloseCallHandler = AtmSmIncomingCloseCall;
        Chars.ClIncomingDropPartyHandler = AtmSmIncomingDropParty;
        Chars.ClCallConnectedHandler     = AtmSmCallConnected;

        Status = NdisClOpenAddressFamily(pAdapt->NdisBindingHandle,
                                         &pAdapt->AddrFamily,
                                         pAdapt,  // Use this as the Af context
                                         &Chars,
                                         sizeof(NDIS_CLIENT_CHARACTERISTICS),
                                         &pAdapt->NdisAfHandle);
        if (NDIS_STATUS_PENDING != Status)
        {
            AtmSmOpenAfComplete(Status, pAdapt, pAdapt->NdisAfHandle);
        }

    } else {

        // Not UNI3.1, hence remove the reference we added above
        AtmSmDereferenceAdapter(pAdapt);
    }

    TraceOut(AtmSmCoAfRegisterNotify);
}


VOID
AtmSmOpenAfComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolAfContext,
    IN  NDIS_HANDLE             NdisAfHandle
    )
/*++

Routine Description:

    Completion processing for the OpenAf call.

Arguments:

    Status              Status of OpenAf
    ProtocolAfContext   Pointer to the pAdapt
    NdisAfHandle        Ndis Handle to refer to this Af

Return Value:


--*/
{
    PATMSM_ADAPTER  pAdapt= (PATMSM_ADAPTER)ProtocolAfContext;

    TraceIn(AtmSmOpenAfComplete);

    if (NDIS_STATUS_SUCCESS == Status){

        pAdapt->NdisAfHandle = NdisAfHandle;

        pAdapt->ulFlags |= ADAPT_AF_OPENED;

        //
        // Now register our SAP on this interface
        //
        Status = AtmSmRegisterSap(pAdapt);

    } else {

        DbgErr(("Opening of Address Family Failed! Status - 0x%X\n", Status));
    }

    if ((Status != NDIS_STATUS_SUCCESS) && 
                (Status != NDIS_STATUS_PENDING)){

        //
        // Close Address family  (This results in a dereference)
        //
        Status = NdisClCloseAddressFamily(pAdapt->NdisAfHandle);
        if (NDIS_STATUS_PENDING != Status){

            AtmSmCloseAfComplete(Status, pAdapt);
        }

        //
        // Close Adapter (This results in a dereference)
        //
        NdisCloseAdapter(&Status, pAdapt->NdisBindingHandle);
        if (NDIS_STATUS_PENDING != Status){

            AtmSmCloseAdapterComplete(pAdapt, Status);
        }

        // if synchronous - by now the adapter structure wll be freed
    }

    TraceOut(AtmSmOpenAfComplete);
}


NDIS_STATUS
AtmSmRegisterSap(
    IN  PATMSM_ADAPTER  pAdapt
    )
/*++

Routine Description:
    Register the Sap for receiving incoming calls. 

Arguments:

Return Value:

--*/
{
    ULONG           ulSize;
    NDIS_STATUS     Status;
    PATM_SAP        pAtmSap;
    PATM_ADDRESS    pAtmAddress;

    TraceIn(AtmSmRegisterSap);

    do
    {
        //
        // Allocate memory for registering the SAP, if doing it for the 
        // first time.
        //
        ulSize = sizeof(CO_SAP) + sizeof(ATM_SAP) + sizeof(ATM_ADDRESS);

        if (NULL == pAdapt->pSap){

            AtmSmAllocMem(&pAdapt->pSap, PCO_SAP, ulSize);

        }

        if (NULL == pAdapt->pSap){

            Status = NDIS_STATUS_RESOURCES;
            DbgErr(("Failed to allocate memory for Sap\n"));
            break;
        }

        NdisZeroMemory(pAdapt->pSap, ulSize);

        pAdapt->pSap->SapType    = SAP_TYPE_NSAP;
        pAdapt->pSap->SapLength  = sizeof(ATM_SAP) + sizeof(ATM_ADDRESS);

        pAtmSap     = (PATM_SAP)pAdapt->pSap->Sap;
        pAtmAddress = (PATM_ADDRESS)(pAtmSap->Addresses);

        //
        //  Fill in the ATM SAP with default values
        //
        NdisMoveMemory(&pAtmSap->Blli, &AtmSmDefaultBlli, sizeof(ATM_BLLI_IE));
        NdisMoveMemory(&pAtmSap->Bhli, &AtmSmDefaultBhli, sizeof(ATM_BHLI_IE));

        //
        //  ATM Address to "listen" on: Wild card everything except the SEL.
        //
        pAtmSap->NumberOfAddresses  = 1;
        pAtmAddress->AddressType    = SAP_FIELD_ANY_AESA_REST;
        pAtmAddress->NumberOfDigits = ATM_ADDRESS_LENGTH;
        pAtmAddress->Address[ATM_ADDRESS_LENGTH-1]  = pAdapt->SelByte;

        Status = NdisClRegisterSap(pAdapt->NdisAfHandle,
                                   pAdapt,
                                   pAdapt->pSap,
                                   &pAdapt->NdisSapHandle);

        if (Status != NDIS_STATUS_PENDING){

            AtmSmRegisterSapComplete(Status,
                                    pAdapt,
                                    pAdapt->pSap,
                                    pAdapt->NdisSapHandle);
        }
    } while (FALSE);

    if ((Status != NDIS_STATUS_SUCCESS) && 
                (Status != NDIS_STATUS_PENDING)){

        DbgErr(("Registering Sap Failed! Status - 0x%X\n", Status));

        // cleanup done after return
    }

    TraceOut(AtmSmRegisterSap);

    return Status;
}



VOID
AtmSmRegisterSapComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolSapContext,
    IN  PCO_SAP                 pSap,
    IN  NDIS_HANDLE             NdisSapHandle
    )
/*++

Routine Description:
    Called by NDIS or us when the Sap registration completes.

Arguments:


Return Value:


--*/
{
    PATMSM_ADAPTER  pAdapt = (PATMSM_ADAPTER)ProtocolSapContext;

    TraceIn(AtmSmRegisterSapComplete);

    ASSERT (pSap == pAdapt->pSap);

    if (NDIS_STATUS_SUCCESS != Status){

        DbgErr(("RegisterSapComplete failed (%x): Adapter %x\n",
                                                        Status, pAdapt));
        AtmSmFreeMem(pAdapt->pSap);
        pAdapt->pSap = NULL;

    } else {

        ACQUIRE_ADAPTER_GEN_LOCK(pAdapt);

        pAdapt->NdisSapHandle  = NdisSapHandle;
        pAdapt->ulFlags       |= ADAPT_SAP_REGISTERED;

        RELEASE_ADAPTER_GEN_LOCK(pAdapt);

    }

    TraceOut(AtmSmRegisterSapComplete);
}


VOID
AtmSmDeregisterSapComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolSapContext
    )
/*++

Routine Description:
    Called by NDIS or us when the Sap Deregistration completes.

Arguments:


Return Value:


--*/
{
    PATMSM_ADAPTER   pAdapt = (PATMSM_ADAPTER)ProtocolSapContext;

    TraceIn(AtmSmDeregisterSapComplete);

    pAdapt->ulFlags &= ~ADAPT_SAP_REGISTERED;

    pAdapt->NdisSapHandle = NULL;

    AtmSmFreeMem(pAdapt->pSap);

    pAdapt->pSap = NULL;

    TraceOut(AtmSmDeregisterSapComplete);
}


VOID
AtmSmCloseAfComplete(
    IN  NDIS_STATUS             Status,
    IN  NDIS_HANDLE             ProtocolAfContext
    )
/*++

Routine Description:
    Called by NDIS or us when closing of AF completes.

Arguments:


Return Value:


--*/
{
    PATMSM_ADAPTER   pAdapt = (PATMSM_ADAPTER)ProtocolAfContext;

    pAdapt->ulFlags &= ~ADAPT_AF_OPENED;

    pAdapt->NdisAfHandle = NULL;

    DbgInfo(("CloseAfComplete: pAdapt %x, Flags %x, Ref %x\n",
                    pAdapt, pAdapt->ulFlags, pAdapt->ulRefCount));

    //
    // Nothing much to do except dereference the pAdapt
    //
    AtmSmDereferenceAdapter(pAdapt);
}


NDIS_STATUS
AtmSmCreateVc(
    IN  NDIS_HANDLE             ProtocolAfContext,
    IN  NDIS_HANDLE             NdisVcHandle,