h245table.c

基于h323协议的软phone

#include "rvinternal.h"
#include "cm.h"
#include "mib.h"
#include "cmmib.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef enum
{ 
  INCOMMING,
  OUTGOING
} directionT;

#define H245_CONTROL_KEY_SIZE   20
#define H245_CAPEXC_KEY_SIZE    12
#define H245_LC_KEY_SIZE        12
#define H245_LC_H225_KEY_SIZE   4 

void int2index(int entry,RvUint8 * key);

void transportAddress2Index(cmTransportAddress *tr,RvUint8 * key);

void transportAddress2String(cmTransportAddress *tr,RvUint8 * key);
void buildCapExchangeCapabilityTableIndex(int ifIndex, int entry, directionT, RvUint8 * key);

int bool2truth(int value)
{
    if(value)
        return 1;
    else
        return 2;
}





typedef struct
{
    RvUint8 key[H245_CONTROL_KEY_SIZE];/*23];*/
    HCALL hsCall;
    int controlChannelIndex;
}controlElT;



RvBool controlCompare(RAElement element, void *param)
{
    return (((controlElT *)element)->hsCall == (HCALL)param);
}


int tableCtrlGet(RAElement  data,h341ParameterName name,mibDataT *mibdata)
{
    mibdata->type=asnError;
    switch (name)
    {
    case h245ControlChannelIndex:
        mibdata->valueSize = ((controlElT *)data)->controlChannelIndex;
        mibdata->type=asnInt;
        break;
    case h245ControlChannelSrcAddressTag:             /* fore next are not accessible*/
    case h245ControlChannelSrcTransporTAddress:
    case h245ControlChannelDesTAddressTag:
    case h245ControlChannelDestTransporTAddress:
        return checkNext;

    case h245ControlChannelMSDState:
        mibdata->type=asnInt;
        if (mibGetControlParameters(((controlElT *)data)->hsCall,0,
            enumh245ControlChannelMSDState,&mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
        break;
    case h245ControlChannelTerminalType:
        mibdata->type=asnInt;
        if (mibGetControlParameters(((controlElT *)data)->hsCall,0,
            enumh245ControlChannelTerminalType,&mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
        break;
    case h245ControlChannelNumberOfMSDRetries:
        mibdata->type=asnInt;
        if (mibGetControlParameters(((controlElT *)data)->hsCall,0,
            enumh245ControlChannelNumberOfMSDRetries,&mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
        break;
    case h245ControlChannelIsTunneling:
        mibdata->type=asnInt;
        if (mibGetControlParameters(((controlElT *)data)->hsCall,0,
            enumh245ControlChannelIsTunneling,&mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
        break;
    default:
        return notImplemented;
    }
    return 0;
}

 /****************************************************************
 *tableControlGetIndex - get an index of the Control Table
 *parameters : .
 *  Input    : data - element in the table     
 *****************************************************************/
RvUint8 * tableCtrlGetIndex(RAElement     data)
{
    return ((controlElT *)data)->key;
}


tableT *  contolTableConstruct(int nElements)
{
    return tableConstruct(nElements,H245_CONTROL_KEY_SIZE,sizeof(controlElT),tableCtrlGet,controlCompare,tableCtrlGetIndex);

}

int tableCtrlSetDefault(RAElement data,h341ParameterName name,mibDataT * mibData)
{
    if (name == h245ControlChannelIndex)
        ((controlElT *)data)->controlChannelIndex = mibData->valueSize;

    return 0;
}


typedef struct
{
    RvUint8 key[H245_CAPEXC_KEY_SIZE];
    HCALL hsCall;
}capabilityElT;


RvBool capabilityCompare(RAElement element, void *param)
{
    return (((capabilityElT *)element)->hsCall == (HCALL)param);
}


/*==========================================================================.
 * h245CapExchageCapabilityTableGet 
 * purpose : get parameter from h245CapExchageCapabilityTable
 *
 *---------------------------------------------------------------------------*/
int h245CapExchageCapabilityTableGet(RAElement   data,h341ParameterName name,mibDataT *mibdata)
{
    int directionIn=0;
    RvUint8 * key = ((capabilityElT *)data)->key;
    HCALL hsCall = ((capabilityElT *)data)->hsCall;


	/* key[0] - ifIndex
	   key[1] - h245ControlChannelIndex
	   key[2] - h245CapabilityExchangeDirection
     */ 
	switch (key[2])
    {
	case INCOMMING:
        directionIn = 1;
		break;
    case OUTGOING:
        directionIn = 0;
	}
    mibdata->type=asnError;

    switch(name)
    {

    case h245CapExchangeDirection: /* not accessible */
        return checkNext;
    case h245CapExchangeState:
        if (!mibGetControlParameters(hsCall, directionIn,enumh245CapExchangeState,
                                     &mibdata->valueSize,mibdata->value))
            mibdata->type=asnInt;
        break;

    case h245CapExchangeProtocolId:
        mibdata->type=asnMibOctetString;
        if (mibGetControlParameters(hsCall, directionIn,enumh245CapExchangeProtocolId,
                                     &mibdata->valueSize,mibdata->value))

            mibdata->valueSize=0;
        break;
    case h245CapExchangeRejectCause:
        mibdata->type=asnInt;
        if (mibGetControlParameters(hsCall, directionIn,enumh245CapExchangeRejectCause,
                                     &mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
        break;

    case h245CapExchangeMultiplexCapability:
    case h245CapExchangeCapability:
    case h245CapExchangeCapabilityDescriptors:

    default:
        return notImplemented;
    }
    return 0;
}

/*=========================================================
 *tableCapGetIndex - get an index of the Capability Table 
 *---------------------------------------------------------*/
RvUint8 * tableCapGetIndex(RAElement  data)
{
    return ((capabilityElT *)data)->key;
}


tableT *  capTableConstruct(int nElements)
{
	return tableConstruct(nElements, H245_CAPEXC_KEY_SIZE, sizeof(capabilityElT), h245CapExchageCapabilityTableGet,NULL, tableCapGetIndex);

}




typedef struct
{
    RvUint8 key[H245_LC_KEY_SIZE];/*23];*/
    HCHAN hsChan;
    int   lcIndex;
}logChanElT;

int tableLcSetDefault(RAElement data,h341ParameterName name,mibDataT * mibData)
{
    if (name == h245LogChannelsIndex)
        ((logChanElT *)data)->lcIndex = mibData->valueSize;
    return 0;
}

int tableLCGet(RAElement    data,h341ParameterName name,mibDataT *mibdata)
{
    mibdata->type=asnError;

    switch (name)
    {
    case h245LogChannelsChannelNumber:
    case h245LogChannelsChannelDirection:
        return checkNext;

    case h245LogChannelsIndex:
        mibdata->valueSize=((logChanElT *)data)->lcIndex;
        mibdata->type=asnInt;
        break;

    case h245LogChannelsChannelState:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logChanElT *)data)->hsChan,enumh245LogChannelsChannelState,
                                     &mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
            break;
    case h245LogChannelsMediaTableType:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logChanElT *)data)->hsChan,enumh245LogChannelsMediaTableType,
                                     &mibdata->valueSize,mibdata->value))
            mibdata->valueSize=0;
            break;

    default:
        return notImplemented;
    }
    return 0;
}


/*****************************************************************
 *tableLCIndex - get an index of the LogicalChannel Table
 *parameters : 
 *  Input    : data - element in the table     
 *****************************************************************/
RvUint8 *tableLCGetIndex(RAElement 	data)
{
	return ((logChanElT *)data)->key;
}



RvBool hsChanCompare(RAElement element, void *param)
{
    return (((logChanElT *)element)->hsChan == (HCHAN)param);
}

tableT *  lcTableConstruct(int nElements)
{
    return tableConstruct(nElements,H245_LC_KEY_SIZE,sizeof(logChanElT),tableLCGet,hsChanCompare,tableLCGetIndex);

}



typedef struct
{
    RvUint8 key[H245_LC_H225_KEY_SIZE];/*23];*/
    HCHAN hsChan;
}logH225ChanElT;


int tableLCH225Get(RAElement    data,h341ParameterName name,mibDataT *mibdata)
{
    mibdata->type=asnError;

    switch (name)
    {
    case h245LogChannelsSessionId:
        mibdata->valueSize=cmChannelSessionId(((logH225ChanElT *)data)->hsChan);
        mibdata->type=asnInt;
        break;
    case h245LogChannelsAssociateSessionId:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsAssociateSessionId,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize=0;
                    break;

    case h245LogChannelsMediaGuaranteedDelivery:
        mibdata->type=asnInt;
        if (!mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsMediaGuaranteedDelivery,
                    &mibdata->valueSize,mibdata->value))
            mibdata->valueSize = bool2truth(mibdata->valueSize);
        else
            mibdata->valueSize =0;
        break;