cmcallhighlevel.c

基于h323协议的软phone

                        if (!fta)
                        {

                            if (qAddress.port <= 0)
                            {
                                if (eta)
                                    qAddress.port = 2517;
                                else
                                    qAddress.port = 1720;
                            }

                            if (!eta)
                                cmCallSetParam((HCALL)hsCall,cmParamDestinationIpAddress,0, sizeof(cmTransportAddress),(char*)&qAddress);
                            else
                                cmCallSetParam((HCALL)hsCall,cmParamDestinationAnnexEAddress,0, sizeof(cmTransportAddress),(char*)&qAddress);
                        }
                        else
                        {
                            if (qAddress.port <= 0)
                                qAddress.port = 1720;
                        }

                        if (!eta)
                            cmCallSetParam((HCALL)hsCall,cmParamDestCallSignalAddress,0, sizeof(cmTransportAddress),(char*)&qAddress);
                    }
                }
                else
                {
                    namedID=RV_FALSE;
                }
            }

            if (namedID)
                numPtr=nextPtr;
        }

        /* Deal with extra call info (used for calls that need 2 numbers) */
        i=-1;
        while(numPtr)
        {
            cmAlias alias;

            alias.string=numPtr;
            numPtr=(RvChar*) strchr(numPtr,';');
            if (numPtr)
            {
                *numPtr=0;
                numPtr++;
            }
            alias.type=cmAliasTypeE164;
            alias.length=(RvUint16)strlen(alias.string);
            cmCallSetParam((HCALL)hsCall,(i<0)?cmParamCalledPartyNumber:cmParamDestExtraCallInfo,(i<0)?0:i,
                sizeof(cmAlias),(char*)&alias);
            i++;
        }
    }

    /*Set annexE type*/

    {
        cmAnnexEUsageMode annexE=cmTransNoAnnexE;
        if (wasTA && wasETA && firstETA)  annexE=cmTransPreferedAnnexE;
        else
        if (wasTA && wasETA && !firstETA) annexE=cmTransPreferedTPKT;
        else
        if (wasETA && !wasTA) annexE=cmTransUseAnnexE;

        cmCallSetParam((HCALL)hsCall,cmParamAnnexE,0,annexE,NULL);
    }


    /* Set other parameters - rate, display, userUser */
    cmCallSetParam(hsCall,cmParamRequestedRate,0,(RvInt32)maxRate,0);
    if (display)
        cmCallSetParam(hsCall,cmParamDisplay,0,0,display);
    if (userUser)
        cmCallSetParam(hsCall,cmParamUserUser,0,userUserSize,userUser);

    /* Make sure we dial */
    ret = cmCallDial(hsCall);

    cmiAPIExit(hApp, "cmCallMake=%d", ret);
    return ret;
}

/*-----------------------------------------------------------------------------------------
 * alias2str
 *
 * convert from cmAlias to string with the alias (with the appropriate prefix of the alias)
 *
 * Input:  alias - alias struct.
 *         len   - length of str (how much space was allocated).
 * Output: str   - string with alias. must be allocated before calling the function.
 *
 * Return: the length of the string that was copied to str.
 *-----------------------------------------------------------------------------------------*/
int alias2str(
    IN  cmAlias alias,
    OUT char * str,
    IN  int len)
{
    switch(alias.type)
    {
    case(cmAliasTypeE164):
        {
            if (strncmp("EXT:",str,4))
            {
                if(len>(alias.length+4))
                {
                    RvSprintf(str,"TEL:%s",alias.string);
                    return 4+alias.length;
                }
            }
            else    /* if str begins with "EXT:", it is e164 because of EXT and not TEL, */
                /* then don't write the "TEL:", only the name and return only length */
            {
                if(len>alias.length)
                    RvSprintf(str,"%s",alias.string);
                return alias.length;
            }
            return 0;
        }
    case(cmAliasTypeH323ID):
        {
            char nameId[128];
            utlBmp2Chr(nameId,(RvUint8* )alias.string, (int)alias.length);
            if(len>((alias.length/2)+5))
            {
                RvSprintf(str,"NAME:%s",nameId);
                return 5+(alias.length/2);
            }
            return 0;
        }
    case(cmAliasTypeURLID):
        {
            if(len>(alias.length+4))
            {
                RvSprintf(str,"URL:%s",alias.string);
                return 4+alias.length;
            }
            return 0;
        }
    case(cmAliasTypeEMailID):
        {
            if(len>(alias.length+6))
            {
                RvSprintf(str,"EMAIL:%s",alias.string);
                return 6+alias.length;
            }
            return 0;
        }
    case(cmAliasTypeTransportAddress):
        {
            if (len>25)
            {
                unsigned char * ip = (unsigned char *) &alias.transport.ip;
                int length=RvSprintf(str,"TA:%u.%u.%u.%u:%u",
                    (unsigned)ip[0],
                    (unsigned)ip[1],
                    (unsigned)ip[2],
                    (unsigned)ip[3],
                    alias.transport.port);
                return length;
            }
            return 0;
        }
    case(cmAliasTypePartyNumber):
        {
            if(len>(alias.length+7))
            {
                static char pnType[15][6] = { "PUU", "PUI", "PUN0", "PUNS", "PUS", "PUA", "D", "T", "PRU", "PRL2", "PRL1", "PRP", "PRL0", "PRA", "N" };
                RvSprintf(str,"PN:%s$%s",alias.string,pnType[alias.pnType]);
                return 6+alias.length;
            }
            return 0;
        }
    case(cmAliasTypeEndpointID):
    case(cmAliasTypeGatekeeperID):
        return RV_ERROR_UNKNOWN;
    }
    return 0;
}


RVAPI
int RVCALLCONV cmCallGetCallingPartyId(
                                     IN     HCALL       hsCall,
                                     OUT    char*       partyId,
                                     IN     int         len)
{
    cmTransportAddress tr;
    cmAlias alias;
    char number[257];
    HAPP hApp;
    int i;
    char delimiter[2];
    int error=RV_ERROR_UNKNOWN;

    if (hsCall == NULL) return RV_ERROR_NULLPTR;

    strcpy(delimiter, ",");
    hApp=cmGetAHandle((HPROTOCOL)hsCall);
    if (!hApp) return RV_ERROR_UNKNOWN;

    cmiAPIEnter(hApp, "cmCallGetCallingPartyId(hsCall=0x%p,partyId,len=%d)", hsCall, len);
    alias.string=number;
    delimiter[0]=cmGetDelimiter(hApp);

    if (len>=25)
    {
        partyId[0]=0;
        if (cmCallGetParam(hsCall,cmParamSrcCallSignalAddress,0,0,(char*)&tr) >= 0)
        {
            RvAddress addr;
            char* strPtr = partyId + 3;

            if (RvH323CmToCoreAddress(&tr, &addr) == RV_OK)
            {
                if (RvAddressGetString(&addr, strPtr, (RvSize_t)len-8) != NULL)
                    strcpy(partyId, "TA:");
                RvAddressDestruct(&addr);
            }
        }

        i=0;
        while(cmCallGetParam(hsCall,cmParamSourceAddress,i++,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((length) && ((len-length) > 1)) strcat(partyId,delimiter);
            alias.string[alias.length] = 0;
            if(alias2str(alias, &partyId[length+1], len-length-1)<=0)
            {
                /* remove the delimiter */
                partyId[length] = 0;
            }
        }
        if (cmCallGetParam(hsCall,cmParamCallingPartySubAddress,0,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((len-length-5-strlen(number)) > 0)
            {
                if (length) strcat(partyId,delimiter);
                strcat(partyId,"SUB:");
                strcat(partyId,number);
            }
        }
        if (cmCallGetParam(hsCall,cmParamCallingPartyNumber,0,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((len-length-1-strlen(number)) > 0)
            {
                if (length) strcat(partyId,delimiter);
                strcat(partyId,number);
            }
        }
        error=0;
    }

    cmiAPIExit(hApp, "cmCallGetCallingPartyId(partyId=%.100s)=%d", nprn(partyId), error);
    return error;
}


RVAPI
int RVCALLCONV cmCallGetCalledPartyId(
                                    IN      HCALL       hsCall,
                                    OUT     char*       partyId,
                                    IN      int         len)
{
    cmTransportAddress tr;
    cmAlias alias;
    char number[256];
    int i;
    char delimiter[2];
    int error=RV_ERROR_UNKNOWN;
    HAPP hApp;

    strcpy(delimiter, ",");
    if (!hsCall) return RV_ERROR_UNKNOWN;
    hApp=cmGetAHandle((HPROTOCOL)hsCall);
    if (!hApp) return RV_ERROR_UNKNOWN;
    cmiAPIEnter(hApp, "cmCallGetCalledPartyId(hsCall=0x%p,partyId,len=%d)", hsCall, len);
    alias.string=number;
    delimiter[0]=cmGetDelimiter(hApp);

    if (len>=25)
    {
        partyId[0]=0;
        if (cmCallGetParam(hsCall,cmParamDestCallSignalAddress,0,0,(char*)&tr) >= 0)
        {
            RvAddress addr;
            char* strPtr = partyId + 3;

            if (RvH323CmToCoreAddress(&tr, &addr) == RV_OK)
            {
                if (RvAddressGetString(&addr, strPtr, (RvSize_t)len-8) != NULL)
                    strcpy(partyId, "TA:");
                RvAddressDestruct(&addr);
            }
        }

        i=0;
        while(cmCallGetParam(hsCall,cmParamDestinationAddress,i++,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((length) && ((len-length) > 1)) strcat(partyId,delimiter);
            alias.string[alias.length] = 0;
            if(alias2str(alias, &partyId[length+1], len-length-1) <= 0)
            {
                /* remove the delimiter */
                partyId[length] = 0;
            }
        }
        if (cmCallGetParam(hsCall,cmParamCalledPartySubAddress,0,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((len-length-5-strlen(number)) > 0)
            {
                if (length) strcat(partyId,delimiter);
                strcat(partyId,"SUB:");
                strcat(partyId,number);
            }
        }
        if (cmCallGetParam(hsCall,cmParamExtension,0,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            
            if (alias.type==cmAliasTypeH323ID)
            {
                char str[128];
                int iLength = alias.length;
                utlBmp2Chr(str,(RvUint8*)number,iLength);
                strncpy(number,str,128);
                number[128] = 0;
            }
            
            if ((len-length-1-((alias.type==cmAliasTypeE164)?4:6)-strlen(number)) > 0)
            {
                if (length) strcat(partyId,delimiter);
                strcat(partyId,(alias.type==cmAliasTypeE164)?"EXT:":"EXTID:");
                strcat(partyId,number);
            }
        }
        if (cmCallGetParam(hsCall,cmParamCalledPartyNumber,0,0,(char *)&alias)>=0)
        {
            int length = strlen(partyId);
            if ((len-length-1-strlen(number)) > 0)
            {
                if (length) strcat(partyId,delimiter);
                strcat(partyId,number);
            }
            i=0;
            while (cmCallGetParam(hsCall,cmParamDestExtraCallInfo,i++,0,(char *)&alias)>=0)