cmctrlcap.c

基于h323协议的软phone

        {
            cmiAPIExit(hApp, "cmCallCapabilitiesBuild: [-1].");

            /* 2004.11.03, added. make sure we unlock the mutex */
            emaUnlock((EMAElement)hsCall);
			
            return rootId;
        }

        capSetBuildFromStruct(hVal, ((cmElem*)hApp)->h245Conf, rootId, capSet);
        capDescBuildFromStruct(hVal, rootId, capDesc);
        emaUnlock((EMAElement)hsCall);
    }

    cmiAPIExit(hApp, "cmCallCapabilitiesBuild: [%d].", rootId);
    return rootId;
}


RVAPI int RVCALLCONV
cmCallCapabilitiesSend(
               IN   HCALL           hsCall,
               IN   cmCapStruct*    capSet[],
               IN   cmCapStruct***  capDesc[])
{
    int rootId=-1;
    HAPP hApp=(HAPP)emaGetInstance((EMAElement)hsCall);
    if (!hApp || !hsCall || !capSet || !capDesc) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmCallCapabilitiesSend: hsCall=0x%p, capSet=0x%p, capDesc=0x%p.", hsCall, capSet, capDesc);

    if (emaLock((EMAElement)hsCall))
    {
        if ((rootId = cmCallCapabilitiesBuild(hsCall, capSet, capDesc)) <0)
        {
        /*2004.11.3 add emaUnlock*/
            emaUnlock((EMAElement)hsCall);	
            cmiAPIExit(hApp, "cmCallCapabilitiesSend: [-1].");
            return RV_ERROR_UNKNOWN;
        }

        cmCallSendCapability(hsCall, rootId);
        pvtDelete(((cmElem *)hApp)->hVal, rootId);
        emaUnlock((EMAElement)hsCall);
    }
    cmiAPIExit(hApp, "cmCallCapabilitiesSend: [1].");
    return RV_TRUE;
}



RVAPI int RVCALLCONV /* remote terminal capability set node id, or RV_ERROR_UNKNOWN */
cmCallGetRemoteCapabilities(
                /* Get latest remote terminal capability message */
                IN  HCALL       hsCall
                )
{
    int termCapId=-1;
    HAPP hApp=(HAPP)emaGetInstance((EMAElement)hsCall);
    H245Control* ctrl=(H245Control*)cmiGetControl(hsCall);

    if (!hsCall || !hApp) return RV_ERROR_UNKNOWN;
    cmiAPIEnter(hApp, "cmCallGetRemoteCapabilities: hsCall=0x%p.", hsCall);
    if (emaLock((EMAElement)hsCall))
    {
        if (ctrl->eState != ctrlNotInitialized)
            termCapId=ctrl->inCap.termNodeId;
        emaUnlock((EMAElement)hsCall);
    }

    cmiAPIExit(hApp, "cmCallGetRemoteCapabilities: [%d].", termCapId);
    return termCapId;
}




RVAPI int RVCALLCONV
cmCallGetLocalCapabilities(
               /* translate local caps (from CESE_OUT machine) to application structures.
                  Usage:
                   cmCapStruct capA[capSetASize];
                   cmCapStruct *capSetA[capSetASize];
                   void* capDescA[capDescASize];
                   cmCapStruct** capSet;
                   cmCapStruct**** capDesc;
                   int i;

                   for (i=0; i<capSetASize; i++) capSetA[i] = capA+i;
                   cmCallGetLocalCapabilities(hsCall,
                                              capSetA, capSetASize,
                                              capDescA, capDescASize,
                              &capSet, &capDesc);
                              */

               IN      HCALL        hsCall,
               IN      cmCapStruct*         capSetA[], /* user allocated */
               IN      int                  capSetASize,
               IN      void*                capDescA[], /* user allocated */
               IN      int                  capDescASize,
               OUT     cmCapStruct**        capSet[],
               OUT     cmCapStruct****      capDesc[]
               )
{
    int capId=-1, i;
    H245Control* ctrl=(H245Control*)cmiGetControl(hsCall);
    HAPP hApp=(HAPP)emaGetInstance((EMAElement)hsCall);
    HPVT hVal;
    int ret = RV_TRUE;

    if (!hsCall || !hApp) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmCallGetLocalCapabilities: hsCall=0x%p, capSetA=0x%p, capSetASize=%d, capDescA=0x%p, capDescASize=%d, capSet=0x%p, capDesc=0x%p.",
          hsCall, capSetA, capSetASize, capDescA, capDescASize, capSet, capDesc);

    hVal = ((cmElem *)hApp)->hVal;

    if ((ctrl->eState != ctrlNotInitialized) && (ctrl->outCap.termNodeId >= 0))
    {
        capId = ctrl->outCap.termNodeId;
    }
    else
    {
        capId = pvtGetChild2(hVal,((cmElem*)hApp)->h245Conf,__h245(capabilities),__h245(terminalCapabilitySet));
    }

    /* Some validity checks */
    if ((capId < 0) || (capSetASize < 1) || (capDescASize < 1))
        ret = RV_ERROR_UNKNOWN;

    if (ret >= 0)
    {
        if (capSetA == NULL)
            ret = RV_TRUE;
        else
        {
            /* We should probably start building the capabilities */
            if (emaLock((EMAElement)hsCall))
            {
                capSetBuild(hVal, capId, capSetSize, capSetA);
                if (capSet)
                    *capSet = capSetA;

                if (capDescA != NULL)
                {
                    for (i = 0; i < capDescASize; i++)
                        capDescA[i] = capDescA-1;

                    if (capDescBuild(hVal, capId, capSetA, capDescASize, capDescA) <0)
                    {
                        RvLogError(&((cmElem*)hApp)->logERR, (&((cmElem*)hApp)->logERR,
                            "cmcGetLocalCaps:capDescBuild failed."));
                        ret = RV_ERROR_UNKNOWN;
                    }
                    else
                    {
                        if (capDesc)
                            *capDesc = (cmCapStruct****)capDescA;
                    }
                }

                emaUnlock((EMAElement)hsCall);
            }
        }
    }

    cmiAPIExit(hApp, "cmCallGetLocalCapabilities: [%d].", ret);
    return ret;
}


/* delete pvt of remote capability to reduce memory*/
RVAPI
int RVCALLCONV cmFreeCapability(IN HCALL hsCall)
{
    H245Control* ctrl=(H245Control*)cmiGetControl(hsCall);
    HAPP hApp=(HAPP)emaGetInstance((EMAElement)hsCall);

    if (!hsCall || !hApp) return RV_ERROR_UNKNOWN;
    cmiAPIEnter(hApp, "cmFreeCapability: hsCall=0x%p.", hsCall);

    if (emaLock((EMAElement)hsCall))
    {
        if (ctrl->eState != ctrlNotInitialized)
        {
            HPVT hVal = ((cmElem *)hApp)->hVal;

            if (ctrl->outCap.termNodeId>=0)
            {
                pvtDelete(hVal,  ctrl->outCap.termNodeId);
                ctrl->outCap.termNodeId = RV_ERROR_UNKNOWN;
            }
            if (ctrl->inCap.termNodeId>=0)
            {
                pvtDelete(hVal,  ctrl->inCap.termNodeId);
                ctrl->inCap.termNodeId = RV_ERROR_UNKNOWN;
            }
        }
        emaUnlock((EMAElement)hsCall);
    }

    cmiAPIExit(hApp, "cmFreeCapability: [1].");
    return RV_TRUE;
}




/************************************************************************
 * tcsGetMibParams
 * purpose: Get parameters related to the MIB for a TCS object in the
 *          control
 * input  : ctrl            - Control object
 *          inDirection     - RV_TRUE if incoming TCS should be checked. RV_FALSE for outgoing
 * output : state           - Status of TCS
 *          rejectCause     - Reject cause of TCS.Reject
 * return : Non-negative value on success
 *          Negative value on failure
 * Any of the output parameters can be passed as NULL if not relevant to caller
 ************************************************************************/
int tcsGetMibParams(
    IN  H245Control*    ctrl,
    IN  RvBool          inDirection,
    OUT CapStatus*      status,
    OUT int*            rejectCause)
{
    if (status)
    {
        if (inDirection)
            *status = ctrl->eInCapStatus;
        else
            *status = ctrl->eOutCapStatus;
    }
    if (rejectCause)
    {
        if (inDirection)
            return RV_ERROR_UNKNOWN; /* We never send TCS.Reject */
        else
        {
            if (ctrl->eOutCapStatus == CapStatusRejected)
                *rejectCause = ctrl->outCap.rejectCause;
            else
                return RV_ERROR_UNKNOWN;
        }
    }

    return 0;
}


/************************************************************************
 * tcsGetMibProtocolId
 * purpose: Get the protocol identifier of the capabilities.
 * input  : ctrl            - Control object
 *          inDirection     - RV_TRUE if incoming TCS should be checked. RV_FALSE for outgoing
 * output : valueSize       - Size in bytes of the protocol identifier
 *          value           - The protocol identifier
 * return : Non-negative value on success
 *          Negative value on failure
 ************************************************************************/
int tcsGetMibProtocolId(
    IN  H245Control*    ctrl,
    IN  RvBool          inDirection,
    OUT int*            valueSize,
    OUT RvUint8*        value)
{
    if (inDirection)
    {
        if (ctrl->inCap.pIDLen < 0)
            return RV_ERROR_UNKNOWN;
        *valueSize = ctrl->inCap.pIDLen;
        memcpy(value, ctrl->inCap.pID, (RvSize_t)*valueSize);
    }
    else
    {
        cmElem *app = (cmElem *)emaGetInstance((EMAElement)cmiGetByControl((HCONTROL)ctrl));

        if (app != NULL)
        {
            *valueSize = app->h245protocolIDLen;
            memcpy(value, app->h245protocolID, (RvSize_t)*valueSize);
        }
    }
    return 0;
}



#ifdef __cplusplus
}
#endif