cmutils.c

基于h323协议的软phone

/***********************************************************************
        Copyright (c) 2002 RADVISION Ltd.
************************************************************************
NOTICE:
This document contains information that is confidential and proprietary
to RADVISION Ltd.. No part of this document may be reproduced in any
form whatsoever without written prior approval by RADVISION Ltd..

RADVISION Ltd. reserve the right to revise this publication and make
changes without obligation to notify any person of such revisions or
changes.
***********************************************************************/

#include "rvinternal.h"
#include "prnutils.h"
#include "msg.h"
#include "pvaltreeStackApi.h"
#include "cm.h"
#include "cmintr.h"
#include "cmutils.h"
#include "q931asn1.h"
#include "oidutils.h"
#include "h245.h"

#ifdef __cplusplus
extern "C" {
#endif


static RvUint32      timesTlsInitialized = 0;
static RvUint32      rvEncoderTlsIndex;


typedef struct
{
    RvUint32    bufferSize;
    RvUint8*    buffer;
} cmThreadCoderLocalStorage;



int setNonStandard(
        IN  HPVT  hVal,
        IN  int   nodeId,
        IN  cmNonStandard*nonStandard
)
{
    int tmp,ret;
    tmp=nonStandard->t35CountryCode;
    if ((ret=pvtBuildByPath(hVal,nodeId,"t35CountryCode",tmp,NULL))<0)
        return ret;
    tmp=nonStandard->t35Extension;
    if ((ret=pvtBuildByPath(hVal,nodeId,"t35Extension",tmp,NULL))<0)
        return ret;
    tmp=nonStandard->manufacturerCode;
    if ((ret=pvtBuildByPath(hVal,nodeId,"manufacturerCode",tmp,NULL))<0)
        return ret;
    return 0;
}


int getNonStandard(
        IN  HPVT  hVal,
        IN  int   nodeId,
        OUT cmNonStandard*nonStandard
)
{
    RvInt32 tmp;
    pvtGetByPath(hVal,nodeId,"t35CountryCode",NULL,&tmp,NULL);
    nonStandard->t35CountryCode=(RvUint8)tmp;
    pvtGetByPath(hVal,nodeId,"t35Extension",NULL,&tmp,NULL);
    nonStandard->t35Extension=(RvUint8)tmp;
    pvtGetByPath(hVal,nodeId,"manufacturerCode",NULL,&tmp,NULL);
    nonStandard->manufacturerCode=(RvUint16)tmp;
    return 0;
}

int setNonStandardParam(
        IN  HPVT  hVal,
        IN  int   vNodeId,
        IN  cmNonStandardParam*nonStandard
)
{
    if (!nonStandard)
        return RV_ERROR_UNKNOWN;
    return cmNonStandardParameterCreate(hVal,vNodeId,
                 &nonStandard->info,
                 nonStandard->data,
                 nonStandard->length);




}


int getNonStandardParam(
        IN  HPVT  hVal,
        IN  int   vNodeId,
        OUT cmNonStandardParam*nonStandard
)
{
    return cmNonStandardParameterGet(hVal,vNodeId,
                    &nonStandard->info,
                    nonStandard->data,
                    &nonStandard->length);
}


RvInt32 getEnumNameId(
          IN    fieldNames* enumFieldNames,
          IN    int     enumFieldNamesSize,
          IN    unsigned    enumValue)
{
    return ((enumValue<enumFieldNamesSize/sizeof(fieldNames))?
        enumFieldNames[enumValue].nameId:LAST_TOKEN);
}

int getEnumValueByNameId(
            IN  fieldNames* enumFieldNames,
            IN  RvInt32     nameId)
{
    int i=0;
    while(enumFieldNames[i].nameId != LAST_TOKEN)
        if (enumFieldNames[i++].nameId==nameId) return i-1;
    return RV_ERROR_UNKNOWN;
}



int aliasToVt(
          IN  HPVT    hVal,
          IN  cmAlias*alias,
          IN  int     nodeId)
{
    /* We can't use _q931() macros here since this function can be used for H450 ASN.1, which
       has different values for those fieldIDs. */
    int ret = 0;

    switch(alias->type)
    {
    case   cmAliasTypeE164          :
    {   int iLen = alias->length;
        ret=pvtBuildByPath(hVal,nodeId,"e164",iLen,alias->string);
    }
    break;
    case   cmAliasTypeH323ID        :
    {   int iLen = alias->length;
        ret=pvtBuildByPath(hVal,nodeId,"h323-ID",iLen,alias->string);
    }
    break;
    case   cmAliasTypeEndpointID        :
    case   cmAliasTypeGatekeeperID      :
    {
        int iLen = alias->length;
        pvtSet(hVal, nodeId, -1, iLen, alias->string);
    }
    break;
    case   cmAliasTypeURLID         :
    {
        int iLen = alias->length;
        ret = pvtBuildByPath(hVal, nodeId, "url-ID", iLen, alias->string);
    }
    break;
    case   cmAliasTypeEMailID       :
    {
        int iLen = alias->length;
        ret = pvtBuildByPath(hVal, nodeId, "email-ID", iLen, alias->string);
    }
    break;
    case   cmAliasTypeTransportAddress  :
    {
        ret = pvtBuildByPath(hVal, nodeId, "transportID", 0, NULL);
        if (ret >= 0)
            ret = cmTAToVt(hVal, ret, &(alias->transport));
    }
    break;
    case   cmAliasTypePartyNumber       :
    {
        int iLen;
        char *t=NULL,*v=NULL;
        int newNode=pvtBuildByPath(hVal,nodeId,"partyNumber",0,NULL);
        if (newNode<0)
        return newNode;
        switch (alias->pnType)
        {
        case cmPartyNumberPublicUnknown         :
            t=(char*)"publicNumber.publicTypeOfNumber.unknown";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberPublicInternationalNumber :
            t=(char*)"publicNumber.publicTypeOfNumber.internationalNumber";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberPublicNationalNumber      :
            t=(char*)"publicNumber.publicTypeOfNumber.nationalNumber";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberPublicNetworkSpecificNumber   :
            t=(char*)"publicNumber.publicTypeOfNumber.networkSpecificNumber";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberPublicSubscriberNumber    :
            t=(char*)"publicNumber.publicTypeOfNumber.subscriberNumber";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberPublicAbbreviatedNumber   :
            t=(char*)"publicNumber.publicTypeOfNumber.abbreviatedNumber";
            v=(char*)"publicNumber.publicNumberDigits";
        break;
        case cmPartyNumberDataPartyNumber       :
            t=NULL;
            v=(char*)"dataPartyNumber";
        break;
        case cmPartyNumberTelexPartyNumber      :
            t=NULL;
            v=(char*)"telexPartyNumber";
        break;
        case cmPartyNumberPrivateUnknown        :
            t=(char*)"privateNumber.privateTypeOfNumber.unknown";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberPrivateLevel2RegionalNumber   :
            t=(char*)"privateNumber.privateTypeOfNumber.level2RegionalNumber";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberPrivateLevel1RegionalNumber   :
            t=(char*)"privateNumber.privateTypeOfNumber.level1RegionalNumber";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberPrivatePISNSpecificNumber :
            t=(char*)"privateNumber.privateTypeOfNumber.pISNSpecificNumber";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberPrivateLocalNumber        :
            t=(char*)"privateNumber.privateTypeOfNumber.localNumber";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberPrivateAbbreviatedNumber  :
            t=(char*)"privateNumber.privateTypeOfNumber.abbreviatedNumber";
            v=(char*)"privateNumber.privateNumberDigits";
        break;
        case cmPartyNumberNationalStandardPartyNumber   :
            t=NULL;
            v=(char*)"nationalStandardPartyNumber";
        break;
        }

        if (t)
        {
            ret = pvtBuildByPath(hVal,newNode,t,0,NULL);
            if (ret<0)
                return ret;
        }
        iLen = alias->length;
        ret = pvtBuildByPath(hVal,newNode,v,iLen,alias->string);
    }
    break;
    }

    return ret;
}

typedef enum
{
    cmNTPublicNumber,
    cmNTDataPartyNumber,
    cmNTTelexPartyNumber,
    cmNTPrivateNumber,
    cmNTNationalStandardPartyNumber
} cmNT;


int vtToAlias(IN  HPVT      hVal,
              IN  cmAlias*  alias,
              IN  int       nodeId)
{
    /* We can't use _q931() macros here since this function can be used for H450 ASN.1, which
       has different values for those fieldIDs. */
    int chNodeId;
    int tmpNodeId;
    chNodeId=pvtChild(hVal,nodeId);

    alias->type=(cmAliasType)(pvtGetSyntaxIndex(hVal,chNodeId)+cmAliasTypeE164-1);
    if (alias->type < cmAliasTypeE164) return RV_ERROR_OUTOFRANGE;
    if (alias->type>=cmAliasTypeEndpointID) alias->type=(cmAliasType)(2 + alias->type);
    if (alias->type >= cmAliasTypeLast) return RV_ERROR_OUTOFRANGE;
    if (alias->type==cmAliasTypeTransportAddress)
    {
        return cmVtToTA(hVal, chNodeId, &(alias->transport));
    }
    if (alias->type==cmAliasTypePartyNumber)
    {
        chNodeId=pvtChild(hVal,chNodeId);
        switch(pvtGetSyntaxIndex(hVal,chNodeId)-1)
        {
        case cmNTPublicNumber       :
            {
                /* ASN.1:
                    PublicPartyNumber ::= SEQUENCE
                    {
                        publicTypeOfNumber  PublicTypeOfNumber,
                        publicNumberDigits  NumberDigits
                    }
                */
                tmpNodeId = pvtChild(hVal, chNodeId); /* "publicTypeOfNumber" */
                chNodeId = pvtBrother(hVal, tmpNodeId); /* "publicNumberDigits" */
                tmpNodeId = pvtChild(hVal, tmpNodeId); /* "publicTypeOfNumber.*" */
                alias->pnType=(cmPartyNumberType)(pvtGetSyntaxIndex(hVal,tmpNodeId)+cmPartyNumberPublicUnknown-1);
            }
            break;
        case cmNTDataPartyNumber        :
            alias->pnType=cmPartyNumberDataPartyNumber;
            break;
        case cmNTTelexPartyNumber       :
            alias->pnType=cmPartyNumberTelexPartyNumber;
            break;
        case cmNTPrivateNumber      :
            {
                /* ASN.1:
                    PrivatePartyNumber ::= SEQUENCE
                    {
                        privateTypeOfNumber PrivateTypeOfNumber,
                        privateNumberDigits NumberDigits
                    }
                */
                tmpNodeId = pvtChild(hVal, chNodeId); /* "privateTypeOfNumber" */
                chNodeId = pvtBrother(hVal, tmpNodeId); /* privateNumberDigits */
                tmpNodeId = pvtChild(hVal, tmpNodeId); /* "privateTypeOfNumber.*" */
                alias->pnType=(cmPartyNumberType)(pvtGetSyntaxIndex(hVal,tmpNodeId)+cmPartyNumberPrivateUnknown-1);
            }
            break;
        case cmNTNationalStandardPartyNumber:
            alias->pnType=cmPartyNumberNationalStandardPartyNumber;
            break;
        default:
            return RV_ERROR_OUTOFRANGE;
        }
    }

    if (chNodeId < 0)
        return chNodeId;

    {
        RvBool isString;
        int length;
        pvtGet(hVal,chNodeId,NULL,NULL,&length,&isString);

        /* We don't always have the length of the alias, so we just take it from the