transpcap.c

基于h323协议的软phone

/*
***********************************************************************************

NOTICE:
This document contains information that is proprietary to RADVISION LTD..
No part of this publication may be reproduced in any form whatsoever without
written prior approval by RADVISION LTD..

RADVISION LTD. reserves the right to revise this publication and make changes
without obligation to notify any person of such revisions or changes.

***********************************************************************************
*/


#include "rvinternal.h"
#include "pvaltree.h"
#include "rvh323timer.h"
#include "cm.h"
#include "cmictrl.h"
#include "cmintr.h"
#include "h245.h"
#include "cmdebprn.h"
#include "transpcap.h"

#ifdef __cplusplus
extern "C" {
#endif


int createTranspCapability( IN   HAPP            hApp,
                            IN  cmNonStandardIdentifier *identifier,
                            /* non standard param is optional may be equal NULL */
                                  IN  char *data,
                                  IN  int dataLength );/* in bytes */

int addQosCapability( IN     HAPP            hApp,
                      IN int capTransport,
                      IN cmRSVPParameters *rsvpParam,
                      IN cmATMParameters * atmParam,
                      IN cmNonStandardParam *nonStandard);

int addMediaChannelCap( IN   HAPP            hApp,
                        IN int capTransport,
                        IN  cmMediaChannelCapability * mediaCap
                       );




int buildQosCapability(IN HPVT hVal,
                       IN int qosId,
                       IN cmRSVPParameters *rsvpParam,
                       IN cmATMParameters * atmParam,
                       IN cmNonStandardParam *nonStandard)

{

    int nodeId=0,nonStandardId,rsvpId,atmId;

    if (nonStandard!=NULL)
    {
        nonStandardId=pvtAdd(hVal, qosId, __h245(nonStandard), 0, NULL,NULL);
        nodeId=cmNonStandardParameterCreate(hVal,nonStandardId,&nonStandard->info,nonStandard->data,nonStandard->length);
    }
    if (rsvpParam!=NULL)
    {
        rsvpId = pvtAdd(hVal, qosId, __h245(rsvpParameters), 0, NULL,NULL);
        switch (rsvpParam->cmQosMode)
        {
            case cmGuaranteedQOS:
                __pvtBuildByFieldIds(nodeId,hVal,rsvpId,
                                    {_h245(qosMode) _h245(guaranteedQOS) LAST_TOKEN},
                                    (RvInt32)rsvpParam->cmQosModeValue, NULL);
            break;
            case cmControlledLoad:
                __pvtBuildByFieldIds(nodeId,hVal,rsvpId,
                                    {_h245(qosMode) _h245(controlledLoad) LAST_TOKEN},
                                    (RvInt32)rsvpParam->cmQosModeValue, NULL);
            break;
            default: break;
        }
        if (rsvpParam->cmTokenRate)
            nodeId=pvtAdd(hVal,rsvpId,__h245(tokenRate),rsvpParam->cmTokenRate, NULL, NULL);
        if (rsvpParam->cmBucketSize)
            nodeId=pvtAdd(hVal,rsvpId,__h245(bucketSize),rsvpParam->cmBucketSize, NULL, NULL);
        if (rsvpParam->cmPeakRate)
            nodeId=pvtAdd(hVal,rsvpId,__h245(peakRate),rsvpParam->cmPeakRate, NULL, NULL);
        if (rsvpParam->cmMinPoliced)
            nodeId=pvtAdd(hVal,rsvpId,__h245(minPoliced),rsvpParam->cmMinPoliced, NULL, NULL);
        if (rsvpParam->cmMaxPktSize)
            nodeId=pvtAdd(hVal,rsvpId,__h245(maxPktSize),rsvpParam->cmMaxPktSize, NULL, NULL);

    }
    if (atmParam!=NULL)
    {
        int iMaxNTUSize = atmParam->cmMaxNTUSize;
        atmId = pvtAdd(hVal, qosId, __h245(atmParameters), 0, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(maxNTUSize),iMaxNTUSize, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(atmUBR), (RvInt32)atmParam->cmAtmUBR, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(atmrtVBR), (RvInt32)atmParam->cmAtmrtVBR, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(atmnrtVBR), (RvInt32)atmParam->cmAtmnrtVBR, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(atmABR), (RvInt32)atmParam->cmAtmABR, NULL, NULL);
        nodeId=pvtAdd(hVal,atmId,__h245(atmCBR), (RvInt32)atmParam->cmAtmCBR, NULL, NULL);
    }

    return nodeId;
}

int addQosCapability( IN     HAPP            hApp,
                      IN int capTransport,
                      IN cmRSVPParameters *rsvpParam,
                      IN cmATMParameters * atmParam,
                      IN cmNonStandardParam *nonStandard
                       /* in bytes */)
/*   all parameters are optional may be equal NULL */

{
    int nodeId,qosId=-1,ret=1;
    HPVT hVal;
    if (!hApp) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "addQosCapability: hApp=0x%p",hApp);
    hVal = ((cmElem *)hApp)->hVal;

    nodeId = pvtGetChild(hVal,capTransport,__h245(qOSCapabilities), NULL);
    /* check if node is already exist*/
    if (nodeId<0)
        nodeId  = pvtAdd(hVal, capTransport, __h245(qOSCapabilities), 0, NULL,NULL);
    qosId = pvtAdd(hVal, nodeId, -800, 0, NULL, NULL);

    ret=buildQosCapability(hVal,qosId,rsvpParam,atmParam,nonStandard);
    cmiAPIExit(hApp, "addQosCapability: [%d].", ret);

    if(ret<0)
        return ret;
    return qosId;

}
int getQosParameters(IN HPVT hVal,
                     IN int qosElemId,
                     INOUT  cmQosCapability * cmQOSCapability)
{
    int nonStandardId ,nodeId,rsvpId,qosModeId,atmId;
    RvInt32 castValue;
    cmNonStandardParam *nonStandard;
    cmRSVPParameters *rsvpParameters;
    cmATMParameters  *atmParameters;

    nonStandard=&cmQOSCapability->cmNonStandard;
    rsvpParameters=&cmQOSCapability->cmRsvpParameters;
    atmParameters=&cmQOSCapability->cmAtmParameters;
    cmQOSCapability->cmQosCapabilityParamUsed = 0;


    if (qosElemId >= 0)
    {
    nonStandardId = pvtGetChild(hVal, qosElemId, __h245(nonStandardData), NULL);
    if (nonStandardId>=0)
    {
        cmNonStandardParameterGet(hVal,nonStandardId,&nonStandard->info,
            nonStandard->data,&(nonStandard->length));
        cmQOSCapability->cmQosCapabilityParamUsed |= cmQosCapabilityNonStandard;
    }


    rsvpId = pvtGetChild(hVal, qosElemId, __h245(rsvpParameters),NULL);
    if (rsvpId>=0)
    {
        nodeId=pvtGetChild(hVal, rsvpId, __h245(tokenRate), NULL);
        if (nodeId>=0)
            pvtGet(hVal,nodeId,NULL,NULL,&rsvpParameters->cmTokenRate,NULL);
        else
            rsvpParameters->cmTokenRate=0;
        nodeId=pvtGetChild(hVal, rsvpId, __h245(bucketSize), NULL);
        if (nodeId>=0)
            pvtGet(hVal,nodeId,NULL,NULL,&rsvpParameters->cmBucketSize,NULL);
        else
            rsvpParameters->cmBucketSize=0;

        nodeId=pvtGetChild(hVal, rsvpId, __h245(peakRate), NULL);
        if (nodeId>=0)
            pvtGet(hVal,nodeId,NULL,NULL,&rsvpParameters->cmPeakRate,NULL);
        else
            rsvpParameters->cmPeakRate=0;

        nodeId=pvtGetChild(hVal, rsvpId, __h245(minPoliced), NULL);
        if (nodeId>=0)
            pvtGet(hVal,nodeId,NULL,NULL,&rsvpParameters->cmMinPoliced,NULL);
        else
            rsvpParameters->cmMinPoliced=0;

        nodeId=pvtGetChild(hVal, rsvpId, __h245(maxPktSize), NULL);
        if (nodeId>=0)
            pvtGet(hVal,nodeId,NULL,NULL,&rsvpParameters->cmMaxPktSize,NULL);
        else
            rsvpParameters->cmMaxPktSize=0;

        nodeId=pvtGetChild(hVal, rsvpId, __h245(qosMode), NULL);
        if (nodeId>=0)
        {
            qosModeId = pvtGetChild(hVal, nodeId, __h245(guaranteedQOS), NULL);
            if (qosModeId>=0)
            {
                rsvpParameters->cmQosMode=cmGuaranteedQOS;
                pvtGet(hVal,qosModeId,NULL,NULL,(RvInt32*)&rsvpParameters->cmQosModeValue,NULL);
            }
            else
            {
                qosModeId = pvtGetChild(hVal, nodeId, __h245(controlledLoad), NULL);
                rsvpParameters->cmQosMode=cmControlledLoad;
                pvtGet(hVal,qosModeId,NULL,NULL,(RvInt32*)&rsvpParameters->cmQosModeValue,NULL);
            }

        }
        else
            rsvpParameters->cmQosMode=cmNoneQos;

        cmQOSCapability->cmQosCapabilityParamUsed |= cmQosCapabilityRsvpParameters;

    }

    atmId = pvtGetChild(hVal, qosElemId, __h245(atmParameters), NULL);
    if (atmId>=0)
    {
        pvtGetChildByFieldId(hVal,atmId,__h245(maxNTUSize),&castValue ,NULL);
        atmParameters->cmMaxNTUSize=(RvUint16)castValue;
        pvtGetChildByFieldId(hVal,atmId,__h245(atmUBR),(RvInt32*)&atmParameters->cmAtmUBR,NULL);
        pvtGetChildByFieldId(hVal,atmId,__h245(atmrtVBR),(RvInt32*)&atmParameters->cmAtmrtVBR,NULL);
        pvtGetChildByFieldId(hVal,atmId,__h245(atmnrtVBR),(RvInt32*)&atmParameters->cmAtmnrtVBR,NULL);
        pvtGetChildByFieldId(hVal,atmId,__h245(atmABR),(RvInt32*)&atmParameters->cmAtmABR,NULL);
        pvtGetChildByFieldId(hVal,atmId,__h245(atmCBR),(RvInt32*)&atmParameters->cmAtmCBR,NULL);

        cmQOSCapability->cmQosCapabilityParamUsed |= cmQosCapabilityAtmParameters;
    }
}

return RV_TRUE;
}

RVAPI int RVCALLCONV
cmCreateTranspCapability( IN     HAPP            hApp,
                          IN cmNonStandardParam *nonStandard)
                            /* non standard param is optional may be equal NULL */
{
    int ret;
    if (!hApp) return RV_ERROR_UNKNOWN;
    cmiAPIEnter(hApp, "cmCreateTranspCapability: hApp=0x%p",hApp);

    if (nonStandard)
    {
        ret = createTranspCapability( hApp,&nonStandard->info,nonStandard->data,nonStandard->length);
        cmiAPIExit(hApp, "cmCreateTranspCapability: with nonStandard [%d]",ret);
    }
    else
    {
        ret = createTranspCapability( hApp,NULL,NULL,0);
        cmiAPIExit(hApp, "cmCreateTranspCapability: [%d]",ret);
    }
    return ret;
}

RVAPI int RVCALLCONV
cmAddQosCapability( IN   HAPP            hApp,
                      IN int capTransport,
                      IN  cmQosCapability *qosCapability)

{
    cmRSVPParameters *rsvpParam=NULL;
    cmATMParameters * atmParam=NULL;
    cmNonStandardParam *nonStandard=NULL;
    int result;

    if (!hApp) return RV_ERROR_UNKNOWN;
    cmiAPIEnter(hApp, "cmAddQosCapability: hApp=0x%p,TransportCapabilityId=%d",hApp,capTransport);

    if (qosCapability->cmQosCapabilityParamUsed & cmQosCapabilityNonStandard)
        nonStandard = &qosCapability->cmNonStandard;
    if (qosCapability->cmQosCapabilityParamUsed & cmQosCapabilityRsvpParameters)
        rsvpParam = &qosCapability->cmRsvpParameters;

    if (qosCapability->cmQosCapabilityParamUsed & cmQosCapabilityAtmParameters)