h245table.c

基于h323协议的软phone

    case h245LogChannelsMediaControlGuaranteedDelivery:
        mibdata->type=asnInt;
        mibdata->valueSize=0;
        if (!mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsMediaControlGuaranteedDelivery,
                    &mibdata->valueSize,mibdata->value))
                mibdata->valueSize = bool2truth(mibdata->valueSize);
                    break;
    case h245LogChannelsSilenceSuppression:
        mibdata->type=asnInt;
        mibdata->valueSize=0;
        if (!mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsSilenceSuppression,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize = bool2truth(mibdata->valueSize);
                    break;
    case h245LogChannelsDestination:
        mibdata->type=asnMibOctetString;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsDestination,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize=0;
                    break;
    case h245LogChannelsSrcTerminalLabel:
        mibdata->type=asnMibOctetString;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsSrcTerminalLabel,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize=0;
                    break;

    case h245LogChannelsMediaChannel:
        {
            cmTransportAddress media;
            int length;
            mibdata->type=asnAddressString;
            if (!mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsMediaChannel,
                    &length,(RvUint8 *)&media))
            {
                    transportAddress2String(&media,mibdata->value);
                    mibdata->valueSize=6;

            }
            else
                mibdata->valueSize=0;
            break;

        }
    case h245LogChannelsMediaControlChannel:
        {
            cmTransportAddress mediaControl;
            int length;
            mibdata->type=asnAddressString;
            if (!mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsMediaControlChannel,
                    &length,(RvUint8 *)&mediaControl))
            {

                    transportAddress2String(&mediaControl,mibdata->value);
                    mibdata->valueSize=6;

            }
            else
                mibdata->valueSize=0;
            break;

        }
    case h245LogChannelsDynamicRTPPayloadType:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsDynamicRTPPayloadType,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize=0;
                    break;

    case h245LogChannelsH261aVideoPacketization:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsH261aVideoPacketization,
                    &mibdata->valueSize,mibdata->value))
                    mibdata->valueSize=0;
                    break;
    case h245LogChannelsRTPPayloadType:
        mibdata->type=asnInt;
        if (mibGetChannelParameters(((logH225ChanElT *)data)->hsChan,enumh245LogChannelsRTPPayloadType,
                    &mibdata->valueSize,mibdata->value))
                    break;
    case h245LogChannelsRTPPayloadDescriptor:
    case h245LogChannelsTransportCapability:
    case h245LogChannelsRedundancyEncoding:
    default:
        return notImplemented;
    }
    return 0;
}

RvUint8 * tableLCH225GetIndex(RAElement   data)
{
    return ((logH225ChanElT *)data)->key;
}

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



tableT *lcH225TableConstruct(int nElements)
{
    return tableConstruct(nElements,H245_LC_H225_KEY_SIZE,sizeof(logH225ChanElT),tableLCH225Get,hsChanH225Compare,tableLCH225GetIndex);

}


/*********************************************************************************
 * h341InstAddControl -  add info from all the Control and Capabilities Tables
 * Parameters
 * hSnmp - handle to Snmp
 * hsCall - handle to the call
 *********************************************************************************/
h341ErrorT h341InstAddControl(h341InstanceHandle hSnmp,HCALL hsCall)
{
    int  res,entry,isTunn;
    cmTransportAddress trSrc,trDest;
    controlElT data;
    mibDataT mibData;
    capabilityElT elIn;
    capabilityElT elOut;
    RvUint8 * index;
	int ifIndex = ((h341InstanceHandleT *)hSnmp)->ifIndex;
	/*
	 * Is the info about a call already written in the control table?
	 */
    index = tableFindIndex(((h341InstanceHandleT *)hSnmp)->ControlTable,(void *) hsCall);
    if (index!=NULL)
    {
        res = cmCallGetH245Address(hsCall,&trSrc,&trDest,&isTunn);
        if (res<0)
            return (h341ErrorT)invalidCall;
        transportAddress2Index(&trSrc,data.key);
        transportAddress2Index(&trDest,&data.key[10]);
        if(!memcpy(index,data.key,sizeof(data.key)))
            return (h341ErrorT)0;
        tableUpdateIndex(((h341InstanceHandleT *)hSnmp)->ControlTable,index,data.key,H245_CONTROL_KEY_SIZE);
        return (h341ErrorT)0;
    }
    res = cmCallGetH245Address(hsCall,&trSrc,&trDest,&isTunn);
    if (res<0)
        return (h341ErrorT)invalidCall;
    data.hsCall=hsCall;
    transportAddress2Index(&trSrc,data.key);
    transportAddress2Index(&trDest,&data.key[10]);

    res = tableAdd( ((h341InstanceHandleT *)hSnmp)->ControlTable,(RAElement)&data,&entry);

    if (!res)
    {

        mibData.valueSize=entry;
        tableSetDefault(((h341InstanceHandleT *)hSnmp)->ControlTable,entry,h245ControlChannelIndex,
                    &mibData,tableCtrlSetDefault);

        buildCapExchangeCapabilityTableIndex(ifIndex, entry, INCOMMING, (RvUint8 *)&elIn.key);
        buildCapExchangeCapabilityTableIndex(ifIndex, entry, OUTGOING, (RvUint8 *)&elOut.key);

            elIn.hsCall=hsCall;
            elOut.hsCall=hsCall;
            tableAdd( ((h341InstanceHandleT *)hSnmp)->CapTable,(RAElement)&elIn,&entry);
            tableAdd( ((h341InstanceHandleT *)hSnmp)->CapTable,(RAElement)&elOut,&entry);
    }
    return (h341ErrorT)res;

}

/*********************************************************************************
 * h341InstDeleteControl -  delete info from all the Control and Capabilities Tables
 * Parameters
 * hSnmp - handle to Snmp
 * hsCall - handle to the call
 *********************************************************************************/
h341ErrorT     h341InstDeleteControl(h341InstanceHandle hSnmp,HCALL hsCall)
{

    RvUint8 * index;
    int entry,res;
    capabilityElT elIn;
    capabilityElT elOut;
    mibDataT mibData;
	int ifIndex = ((h341InstanceHandleT *)hSnmp)->ifIndex;
	/*
	 * Is there info about a call?
	 */
    index = tableFindIndex(((h341InstanceHandleT *)hSnmp)->ControlTable,(void *) hsCall);

    if (index!=NULL)
    {
       res = getByIndex (((h341InstanceHandleT *)hSnmp)->ControlTable ,index, H245_CONTROL_KEY_SIZE,
                h245ControlChannelIndex,&mibData);
        if(!res)
        {
            entry = mibData.valueSize;
			buildCapExchangeCapabilityTableIndex(ifIndex, 0, INCOMMING, elIn.key);
			buildCapExchangeCapabilityTableIndex(ifIndex, 0, OUTGOING,  elOut.key);

			/*
			 * Remove info from Capabilities (IN and OUT) tables
			 */
            tableDelete(((h341InstanceHandleT *)hSnmp)->CapTable,elIn.key,H245_CAPEXC_KEY_SIZE);
            tableDelete(((h341InstanceHandleT *)hSnmp)->CapTable,elOut.key,H245_CAPEXC_KEY_SIZE);
        }

		/*
		 * Remove info from control (calls) table
		 */
        tableDelete(((h341InstanceHandleT *)hSnmp)->ControlTable,index,H245_CONTROL_KEY_SIZE);
    }
    return (h341ErrorT)0;

}



h341ErrorT h341InstAddNewLogicalChannel(h341InstanceHandle hSnmp, HCHAN hsChan)
{

    int res=RV_TRUE,entry;
    RvUint32 temp;
    HCALL hsCall;
    /*cmTransportAddress trSrc,trDest;
    controlElT data;*/
    logChanElT logChan;
    logH225ChanElT h225logChan;
    mibDataT mibData;
    int lcn;
    RvUint8 * index;

    mibData.valueSize = 0;

    cmChannelGetCallHandles(hsChan,&hsCall,NULL);

/*
    res = cmCallGetH245Address(hsCall,&trSrc,&trDest,&temp);
    if (res<0)
        return invalidCall;
    data.hsCall=hsCall;
    transportAddress2Index(&trSrc,data.key);
    transportAddress2Index(&trDest,&data.key[10]);
*/
    index = tableFindIndex(((h341InstanceHandleT *)hSnmp)->ControlTable,(void *) hsCall);

    if (index!=NULL)

       res = getByIndex (((h341InstanceHandleT *)hSnmp)->ControlTable ,index, H245_CONTROL_KEY_SIZE,
                h245ControlChannelIndex,&mibData);


    if (!res)
    {

            memset(logChan.key,0,12);
            int2index( mibData.valueSize,logChan.key);
            lcn = cmChannelGetNumber(hsChan);
            int2index( lcn,&logChan.key[4]);
            cmChannelGetOrigin(hsChan,(int *)&temp);
            if (temp)
                logChan.key[11] = 2;
            else
                logChan.key[11] = 1;
            logChan.hsChan = hsChan;
            res = tableAdd( ((h341InstanceHandleT *)hSnmp)->LCTable,(RAElement)&logChan,&entry);
            mibData.valueSize=entry;
            if (!res)
            {
                tableSetDefault(((h341InstanceHandleT *)hSnmp)->LCTable,entry,h245LogChannelsIndex,
                    &mibData,tableLcSetDefault);
                int2index(entry,h225logChan.key);
                h225logChan.hsChan = hsChan;

                res =tableAdd( ((h341InstanceHandleT *)hSnmp)->LCH225Table,(RAElement)&h225logChan,&entry);
            }


    }

    return (h341ErrorT)res;
}

h341ErrorT     h341InstDeleteLogicalChannel(h341InstanceHandle hSnmp,HCHAN hsChan)
{
    RvUint8 * index;
    index = tableFindIndex(((h341InstanceHandleT *)hSnmp)->LCH225Table,(void *) hsChan);
    if (index!=NULL)
    {
        tableDelete(((h341InstanceHandleT *)hSnmp)->LCH225Table,index,H245_LC_H225_KEY_SIZE);
    }
    index = tableFindIndex(((h341InstanceHandleT *)hSnmp)->LCTable,(void *) hsChan);
    if (index!=NULL)
    {
        tableDelete(((h341InstanceHandleT *)hSnmp)->LCTable,index,H245_LC_KEY_SIZE);
    }
    return (h341ErrorT)0;
}

void  buildCapExchangeCapabilityTableIndex(int ifIndex, int entry, directionT direction, RvUint8  *key)
{
	int *pIfIndex = (int *)key;
	int *ph245ControlChannelIndex = (int *)(key + sizeof(int));
	int *pCapExchangeDirection = (int *)(key + 2*sizeof(int));

	memset(key, 0, H245_CAPEXC_KEY_SIZE );

	/* set ifIndex part */
	*pIfIndex = ifIndex;

	/* set h245ControlChannel index part */
	*ph245ControlChannelIndex = entry;

	/* set direction index part */
	if (direction==INCOMMING)
	  *pCapExchangeDirection=1;
	else if (direction==OUTGOING)
	  *pCapExchangeDirection=2;
}

#ifdef __cplusplus
}
#endif