EMS/svc.ems
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
48e5b94f1f7b82c087b02f94f2873c6f2a026b77
svc.ems/plat/mgc/src/mgc.c
simonzhangsz 9930e4e58f init ems server code
2024-09-27 15:39:34 +08:00

4698 lines
159 KiB
C
Raw Blame History

/****************************************************************/
/* MGC Implementation Program */
/* Version 9.0.1 */
/* Designed By Ying Min */
/* Last Update: 2007-4-17 */
/****************************************************************/
#include "./include/mgc_pub.h"
#include "./include/mgc.h"
#include "./include/mgc_const.h"
#include "./include/mgc_def.h"
#include "./include/mgc_struct.h"
#include "./include/mgc_fsm.h"
#include "./include/mgc_debug.h"
#include "./include/mgc_sess_ctl.h"
#include "../../snmp/src/include/snmp.h"
#include "../../public/src/include/license_id.h"
int mgc_is_non_virtual_mg(BYTE mgType)
{
if ((mgType > MGC_MG_TYPE_INTERNAL) && (mgType < MGC_MG_TYPE_ANN))
{
return 1;
}
else
{
return 0;
}
}
int mgc_codec_to_payload(BYTE codec)
{
if (codec== MGC_VCTYPE_GSM)
return 3;
else if (codec == MGC_VCTYPE_GSM_EFR)
return 84;
else if (codec == MGC_VCTYPE_AMR_12_2)
return 71;
else if (codec== MGC_VCTYPE_G729B)
return 118;
else if (codec== MGC_VCTYPE_PCMU)
return 0;
else if(codec == MGC_VCTYPE_AMR_10_2)
return 70;
else if(codec == MGC_VCTYPE_AMR_7_95)
return 69;
else if(codec == MGC_VCTYPE_AMR_7_4)
return 68;
else if(codec == MGC_VCTYPE_AMR_6_7)
return 67;
else if(codec == MGC_VCTYPE_AMR_5_15)
return 65;
else if(codec == MGC_VCTYPE_AMR_5_9)
return 66;
else if(codec == MGC_VCTYPE_AMR_4_75)
return 64;
return 8;
}
int mgc_8ecp_update_mg_status(BYTE mgNo, BYTE status)
{
char tmpStr[128];
if (mgcMgInfo[mgNo].created == 0)
{
sprintf(tmpStr, "mgc_8ecp_update_mg_status: MG not created, mgNo = %d\n\r", mgNo);
mgc_log_err(tmpStr);
return -1;
}
mgcMgInfo[mgNo].stLast = status;
if (1 == mgcMgInfo[mgNo].mgAttr.e1cardNo)
{
if ((1 == status)
&& ((0 == mgc_e1card0_mgNo) || (0 == mgcMgInfo[mgc_e1card0_mgNo].stLast)))
{
mgc_8k_tone_card_silent = 1;
}
else
{
mgc_8k_tone_card_silent = 0;
}
}
else if (0 == mgcMgInfo[mgNo].mgAttr.e1cardNo)
{
if ((0 == status)
&& (0 != mgc_e1card1_mgNo) && (1 == mgcMgInfo[mgc_e1card1_mgNo].stLast))
{
mgc_8k_tone_card_silent = 1;
}
else
{
mgc_8k_tone_card_silent = 0;
}
}
return 0;
}
int mgc_8ecp_update_trk_status(BYTE mgNo, BYTE trkNo, BYTE status)
{
WORD portIndex;
char tmpStr[128];
if (mgcMgInfo[mgNo].created == 0)
{
sprintf(tmpStr, "mgc_8ecp_update_trk_status: MG not created, mgNo = %d\n\r", mgNo);
mgc_log_err(tmpStr);
return -1;
}
if (trkNo >= MGC_8ECP_MAX_TRK_PER_MG)
{
sprintf(tmpStr, "mgc_8ecp_update_trk_status: invalid trkNo, trkNo = %d\n\r", trkNo);
mgc_log_err(tmpStr);
return -1;
}
portIndex = mgcMgInfo[mgNo].portIndex[trkNo];
if (portIndex >= MGC_MAX_NUM_OF_PHY_PORT)
return -1;
mgcPhyPort[portIndex].stLast = status;
return 0;
}
int mgc_bind_8ecp()
{
sprintf(mgc8ecpSap.name, "MGC");
mgc8ecpSap.update_mg_status = mgc_8ecp_update_mg_status;
mgc8ecpSap.update_trk_status = mgc_8ecp_update_trk_status;
if ((mgc8ecpSapIndex = _8ecp_bind(&mgc8ecpSap)) < 0)
return -1;
return 0;
}
int mgc_find_mg_by_name(char *mgName, WORD localPort, DWORD ip)
{
WORD i;
char tmpStr[128];
BYTE usrType;
if (MGC_MG_NETWORK_PORT == localPort)
{
usrType = MGC_USER_TYPE_MG;
}
else
{
usrType = MGC_USER_TYPE_MGC;
}
for (i = 0; i < MGC_MAX_NUM_OF_MG; i++)
{
if (mgcMgInfo[i].created == 0)
continue;
if ((strcmp(mgcMgInfo[i].mgAttr.domain, mgName) == 0)
&& (mgcMgInfo[i].usrType == usrType))
return i;
}
sprintf(tmpStr, "mgc_find_mg_by_name: invalid mgName: %s, ip: %ld\n\r", mgName, ip);
mgc_log_err(tmpStr);
return -1;
}
int mgc_codec_str_to_api(char *codec)
{
if (strcmp(codec, "PCMA") == 0)
return MGC_VCTYPE_PCMA;
else if (strcmp(codec, "PCMU") == 0)
return MGC_VCTYPE_PCMU;
else if (strcmp(codec, "GSM") == 0)
return MGC_VCTYPE_GSM;
else if (strcmp(codec, "GSM-EFR") == 0)
return MGC_VCTYPE_GSM_EFR;
else if (strcmp(codec, "AMR") == 0)
return MGC_VCTYPE_AMR_12_2;
else if (strcmp(codec, "G729B") == 0)
return MGC_VCTYPE_G729B;
else if (strcmp(codec, "AMR_12_2") == 0)
return MGC_VCTYPE_AMR_12_2;
else if (strcmp(codec, "AMR_10_2") == 0)
return MGC_VCTYPE_AMR_10_2;
else if (strcmp(codec, "AMR_7_95") == 0)
return MGC_VCTYPE_AMR_7_95;
else if (strcmp(codec, "AMR_7_4") == 0)
return MGC_VCTYPE_AMR_7_4;
else if (strcmp(codec, "AMR_6_7") == 0)
return MGC_VCTYPE_AMR_6_7;
else if (strcmp(codec, "AMR_5_15") == 0)
return MGC_VCTYPE_AMR_5_15;
else if (strcmp(codec, "AMR_5_9") == 0)
return MGC_VCTYPE_AMR_5_9;
else if (strcmp(codec, "AMR_4_75") == 0)
return MGC_VCTYPE_AMR_4_75;
return MGC_VCTYPE_PCMA;
}
void mgc_connect_init(WORD connectIndex)
{
memset((BYTE *) &mgcConnectInfo[connectIndex], 0, sizeof(CONNECT_INFO));
mgcConnectInfo[connectIndex].port = 0xFFFF;
mgcConnectInfo[connectIndex].chlIndex = 0xFFFF;
mgcConnectInfo[connectIndex].aasChnl.mgNo = 0xFFFF;
mgcConnectInfo[connectIndex].aasChnl.portNo = 0xFF;
mgcConnectInfo[connectIndex].aasChnl.chlNo = 0xFFFF;
mgcConnectInfo[connectIndex].aasChnl.connectNo = 0xFFFF;
}
int mgc_assign_connect_to_chnl(CHNL chnl)
{
WORD portIndex;
WORD chnlIndex;
WORD connectIndex = mgc_select_connection;
CHNL_INFO *chnlInfo;
int i;
if (connectIndex >= MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_select_connection may be changed\n\r");
connectIndex = 0;
}
for (i = 0; i < MGC_MAX_NUM_OF_CON; i++)
{
if (1 == mgcConnectInfo[connectIndex].assigned)
{
if (++connectIndex >= MGC_MAX_NUM_OF_CON)
{
connectIndex = 0;
}
continue;
}
else
{
mgc_connect_init(connectIndex);
if ((MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[chnl.mgNo].mgAttr.mgType))
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}//add by Francis
else
{
portIndex = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
if (portIndex >= MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_log_err("mgc_assign_connect_to_chnl: phy portIndex out of range!\n\r");
return -1;
}
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + chnl.chlNo;
}
if (chnlIndex >= MGC_MAX_NUM_OF_CHNL)
{
mgc_log_err("mgc_assign_connect_to_chnl: chnlIndex out of range!\n\r");
return -1;
}
chnlInfo = &mgcChnl[chnlIndex];
if ((chnlInfo->connectIndex[chnl.connectNo] >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[chnlInfo->connectIndex[chnl.connectNo]].assigned != 1))
{
chnlInfo->connectIndex[chnl.connectNo] = connectIndex;
mgcConnectInfo[connectIndex].assigned = 1;
mgcConnectInfo[connectIndex].status = MGC_CONNECT_STATUS_IDLE;
mgcConnectInfo[connectIndex].chlIndex = chnlIndex;
mgc_select_connection = connectIndex + 1;
if (mgc_select_connection >= MGC_MAX_NUM_OF_CON)
{
mgc_select_connection = 0;
}
return connectIndex;
}
else
{
if ((chnlInfo->connectIndex[chnl.connectNo] < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[chnlInfo->connectIndex[chnl.connectNo]].assigned == 1))
{
mgc_log_err("mgc_assign_connect_to_chnl: one connect already created on chnl's connectNo\n\r");
return chnlInfo->connectIndex[chnl.connectNo];
}
return -1;
}
}
}
mgc_log_err("mgc_assign_connect_to_chnl: connect resource is not sufficient\n\r");
return -1;
}
int mgc_assign_connect(CHNL *chnl, WORD *chnlConnectIndex)
{
WORD portIndex;
WORD chnlIndex;
CHNL_INFO *chnlInfo;
WORD connectIndex = mgc_select_connection;
int i;
int j;
if (connectIndex >= MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_select_connection may be changed\n\r");
connectIndex = 0;
}
for (i = 0; i < MGC_MAX_NUM_OF_CON; i++)
{
if (1 == mgcConnectInfo[connectIndex].assigned)
{
if (++connectIndex >= MGC_MAX_NUM_OF_CON)
{
connectIndex = 0;
}
continue;
}
else
{
mgc_connect_init(connectIndex);
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl->mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl->mgNo].chnlStartIndex + chnl->chlNo;
}//add by Francis
else
{
portIndex = mgcMgInfo[chnl->mgNo].portIndex[chnl->portNo];
if (portIndex >= MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_log_err("mgc_assign_connect: phy portIndex out of range!\n\r");
return -1;
}
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + chnl->chlNo;
}
if (chnlIndex >= MGC_MAX_NUM_OF_CHNL)
{
mgc_log_err("mgc_assign_connect: chnlIndex out of range!\n\r");
return -1;
}
chnlInfo = &mgcChnl[chnlIndex];
for (j = 0; j < MGC_MAX_NUM_OF_CHNL_CON; j++)
{
if ((chnlInfo->connectIndex[j] < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[chnlInfo->connectIndex[j]].assigned == 1))
{
continue;
}
else
{
chnlInfo->connectIndex[j] = connectIndex;
*chnlConnectIndex = j;
chnl->connectNo = j;
mgcConnectInfo[connectIndex].assigned = 1;
mgcConnectInfo[connectIndex].status = MGC_CONNECT_STATUS_IDLE;
mgcConnectInfo[connectIndex].chlIndex = chnlIndex;
mgc_select_connection = connectIndex + 1;
if (mgc_select_connection >= MGC_MAX_NUM_OF_CON)
{
mgc_select_connection = 0;
}
return connectIndex;
}
}
mgc_log_err("mgc_assign_connect: chnl connect resource is not sufficient\n\r");
return -1;
}
}
mgc_log_err("mgc_assign_connect: connect resource is not sufficient\n\r");
return -1;
}
void mgc_remove_connect(WORD chnl)
{
int i;
for (i = 0; i < MGC_MAX_NUM_OF_CON; i++)
{
if ((mgcConnectInfo[i].assigned != 1)
|| (mgcConnectInfo[i].chlIndex != chnl))
{
continue;
}
else
{
mgc_connect_init(i);
}
}
}
int mgc_release_connect(CHNL *chnl)
{
WORD portIndex;
WORD chnlIndex;
WORD connectIndex;
CHNL_INFO *chnlInfo;
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl->mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl->mgNo].chnlStartIndex + chnl->chlNo;
chnlInfo = &mgcChnl[chnlIndex];
}//add by Francis
else
{
portIndex = mgcMgInfo[chnl->mgNo].portIndex[chnl->portNo];
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + chnl->chlNo;
chnlInfo = &mgcChnl[chnlIndex];
}
if (((connectIndex = chnlInfo->connectIndex[chnl->connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[connectIndex].chlIndex != chnlIndex))
{
mgc_log_err("mgc_release_connect: the chnl connectNo has no connection\n\r");
return -1;
}
else
{
mgc_connect_init(connectIndex);
if (chnlInfo->connectNum > 0)
{
chnlInfo->connectNum--;
}
else
{
chnlInfo->connectNum = 0;
}
}
return 0;
}
int mgc_find_connect_by_con_id(CHNL *Chnl, char *conId)
{
int i;
WORD portIndex;
WORD chnlIndex;
CHNL_INFO *chnlInfo;
WORD chnlConnectIndex;
WORD connectIndex;
if (MGC_MG_TYPE_ANN == mgcMgInfo[Chnl->mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[Chnl->mgNo].chnlStartIndex + Chnl->chlNo;
}//add by Francis
else
{
portIndex = mgcMgInfo[Chnl->mgNo].portIndex[Chnl->portNo];
if (portIndex >= MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_log_err("mgc_find_connect_by_con_id: portIndex out of range!\r\n");
return -1;
}
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + Chnl->chlNo;
}
if (chnlIndex >= MGC_MAX_NUM_OF_CHNL)
{
mgc_log_err("mgc_find_connect_by_con_id: chnlIndex out of range!\r\n");
return -1;
}
chnlInfo = &mgcChnl[chnlIndex];
if (mgcMgInfo[Chnl->mgNo].usrType == MGC_USER_TYPE_MG)
{
chnlConnectIndex = strtoll(conId, NULL, 16) >> 48;
if ((chnlConnectIndex >= MGC_MAX_NUM_OF_CHNL_CON)
|| (chnlInfo->connectIndex[chnlConnectIndex] >= MGC_MAX_NUM_OF_CON)
|| (strcmp(conId, mgcConnectInfo[chnlInfo->connectIndex[chnlConnectIndex]].mediaAttr.conId) != 0))
return -1;
else
return chnlConnectIndex;
}
else if (mgcMgInfo[Chnl->mgNo].usrType == MGC_USER_TYPE_MGC)
{
for (i = 0; i < MGC_MAX_NUM_OF_CHNL_CON; i++)
{
if ((connectIndex = chnlInfo->connectIndex[i]) >= MGC_MAX_NUM_OF_CON)
{
continue;
}
else
{
if ((0 == strcmp(conId, mgcConnectInfo[connectIndex].mediaAttr.conId))
&& (chnlIndex == mgcConnectInfo[connectIndex].chlIndex))
{
return i;
}
}
}
return -1;
}
else
return -1;
}
int mgc_extract_media_info(BYTE flag, BYTE cmd, MGCP_PARA *para, WORD port)//new replace
//int mgc_extract_media_info(BYTE flag, MGCP_PARA *para, CHNL *mgcfChnl)
{
WORD portIndex;
WORD chnlIndex;
CHNL_INFO *chnlInfo;
CHNL *mgcfChnl;
int connectIndex;
int chnlConnectIndex;//new replace
PORT_INFO *portInfo;
portInfo = &mgcPort[port];
mgcfChnl = &portInfo->mgcfChnl;//new replace
if (((MGC_MG_TYPE_ANN != mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType) && (mgcfChnl->portNo >= MGC_MAX_PHY_PORT_PER_MG))
|| (mgcfChnl->chlNo >= MGC_MAX_NUM_OF_CHNL))
return 0;
if ((MGC_MG_TYPE_ANN == mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType))
{
chnlIndex = mgcMgInfo[mgcfChnl->mgNo].chnlStartIndex + mgcfChnl->chlNo;
}//add by Francis
else
{
portIndex = mgcMgInfo[mgcfChnl->mgNo].portIndex[mgcfChnl->portNo];
if (portIndex >= MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_log_err("mgc_extract_media_info: phy portIndex out of range!\n\r");
return -1;
}
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + mgcfChnl->chlNo;
}
if (chnlIndex >= MGC_MAX_NUM_OF_CHNL)
{
mgc_log_err("mgc_extract_media_info: chnlIndex out of range!\n\r");
return -1;
}
chnlInfo = &mgcChnl[chnlIndex];
if (flag == MGCP_RESPONSE)
{
if ((MGC_MG_TYPE_ANN != mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType) && (MGCP_CMD_CRCX == cmd)
&& (((para->flag & MGCP_PARA_FLAG_I) != MGCP_PARA_FLAG_I) || ((para->flag & MGCP_PARA_FLAG_SDP) != MGCP_PARA_FLAG_SDP)))
{
mgc_log_err("mgc_extract_media_info: crcx response miss para!!\n\r");
return -4;
}
if (mgcfChnl->connectNo != mgcPort[port].mgcfOperSteps[mgcPort[port].mgcfOperStepIndex].chnlConnectIndex)
{
mgc_log_err("mgc_extract_media_info: connectNo is mismatch!\n\r");
return -1;
}
if((MGCP_CMD_AUEP != cmd) && (MGCP_CMD_RQNT != cmd) && (MGCP_CMD_RSIP != cmd))
{
connectIndex = chnlInfo->connectIndex[mgcPort[port].mgcfOperSteps[mgcPort[port].mgcfOperStepIndex].chnlConnectIndex];
}
if (connectIndex >= MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_extract_media_info: chnl's connection released\n\r");
return -1;
}
if ((para->flag & MGCP_PARA_FLAG_I) == MGCP_PARA_FLAG_I)
{
strcpy(mgcConnectInfo[connectIndex].mediaAttr.conId, para->i.conId);
}
if ((para->flag & MGCP_PARA_FLAG_O) == MGCP_PARA_FLAG_O)
{
chnlInfo->comMediaAttr.pkgEvent = (para->o.package << 8) | para->o.event;
if ((MGCP_CMD_AUEP != cmd) && (MGCP_CMD_RQNT != cmd))
mgcConnectInfo[connectIndex].mediaAttr.pkgEvent = (para->o.package << 8) | para->o.event;
}
}
else
{
if (MGCP_CMD_CRCX == cmd)
{
if ((MGC_MG_TYPE_ANN == mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType) && ((para->flag & MGCP_PARA_FLAG_SDP) != MGCP_PARA_FLAG_SDP))
{
mgc_log_err("mgc_extract_media_info: crcx command miss sdp!!\n\r");
return -2;
}
if ((connectIndex = mgc_assign_connect(mgcfChnl, &mgcPort[port].mgcfOperSteps[0].chnlConnectIndex)) < 0)
{
mgc_log_err("mgc_extract_media_info: assign connect failed\n\r");
return -3;
}
mgcPort[port].mgcfOperStepsNum = 1;
}
else if ((MGCP_CMD_MDCX == cmd) || (MGCP_CMD_DLCX == cmd))
{
if ((chnlConnectIndex = mgc_find_connect_by_con_id(mgcfChnl, para->i.conId)) < 0)
{
mgc_log_err("mgc_extract_media_info: find connect by id failed\n\r");
return -1;
}
mgcfChnl->connectNo = chnlConnectIndex;
connectIndex = chnlInfo->connectIndex[chnlConnectIndex];
}
else if((MGCP_CMD_NTFY == cmd)&&((para->flag & MGCP_PARA_FLAG_O) == MGCP_PARA_FLAG_O))
{
chnlInfo->comMediaAttr.pkgEvent = (para->o.package << 8) | para->o.event;
return 0;
}
/* else
{
if (0xFFFF == (connectIndex = chnlInfo->connectIndex[0]))
{
mgc_log_err("mgc_extract_media_info: chnl's 0 connection released\n\r");
return -1;
}
}
*/
if (connectIndex >= MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_extract_media_info: chnl's connection released\n\r");
return -1;
}
if ((para->flag & MGCP_PARA_FLAG_L) == MGCP_PARA_FLAG_L)
{
mgcConnectInfo[connectIndex].mediaAttr.ecDisable = para->l.ecDisable;
mgcConnectInfo[connectIndex].mediaAttr.ssDisable = para->l.ssDisable;
mgcConnectInfo[connectIndex].mediaAttr.ptime = para->l.p;
mgcConnectInfo[connectIndex].mediaAttr.vocoderType = mgc_codec_str_to_api(para->l.codec);
}
if ((para->flag & MGCP_PARA_FLAG_M) == MGCP_PARA_FLAG_M)
mgcConnectInfo[connectIndex].mediaAttr.conMode = para->m.mode;
if ((para->flag & MGCP_PARA_FLAG_C) == MGCP_PARA_FLAG_C)
strcpy(mgcConnectInfo[connectIndex].mediaAttr.callId, para->c.callId);
if ((para->flag & MGCP_PARA_FLAG_O) == MGCP_PARA_FLAG_O)
{
chnlInfo->comMediaAttr.pkgEvent = (para->o.package << 8) | para->o.event;
mgcConnectInfo[connectIndex].mediaAttr.pkgEvent = (para->o.package << 8) | para->o.event;
}
if ((para->flag & MGCP_PARA_FLAG_S) == MGCP_PARA_FLAG_S)
{
chnlInfo->comMediaAttr.pkgSignal = (para->s.pkg << 8) | para->s.signal;
mgcConnectInfo[connectIndex].mediaAttr.pkgSignal = (para->s.pkg << 8) | para->s.signal;
}
}
if ((para->flag & MGCP_PARA_FLAG_SDP) == MGCP_PARA_FLAG_SDP)
{
if (flag == MGCP_RESPONSE)
{
if ((portInfo->mgcfOperSteps[portInfo->mgcfOperStepIndex].flag & MGCP_PARA_FLAG_TFO) == MGCP_PARA_FLAG_TFO)
{
mgcConnectInfo[connectIndex].flag |= MGCP_PARA_FLAG_TFO;
memcpy(para->sdp.medias.medias, mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias, sizeof(PUB_SDP_MEDIA) * 8);
}
else
{
mgcConnectInfo[connectIndex].flag &= ~MGCP_PARA_FLAG_TFO;
}
}
/*
if (mgcMgInfo[mgcfChnl->mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN)
{
num = para->sdp.medias.medias[0].m.plNum;
for (i = 0; i < mgcMgInfo[mgcfChnl->mgNo].mgAttr.codecList.num; i++)
{
para->sdp.medias.medias[0].m.payloads[num + i] = mgc_codec_to_payload(mgcMgInfo[mgcfChnl->mgNo].mgAttr.codecList.codec[i]);
para->sdp.medias.medias[0].m.plNum++;
if (para->sdp.medias.medias[0].m.plNum >= 8)
break;
}
}*/
//memcpy((BYTE *) &chnlInfo->mediaAttr.sdp, (BYTE *) &para->sdp, sizeof(PUB_SDP_MSG));
memcpy((BYTE *) &mgcConnectInfo[connectIndex].mediaAttr.sdp, (BYTE *) &para->sdp, sizeof(PUB_SDP_MSG));
}
if ((MGCP_CMD_AUEP != cmd) && (MGCP_CMD_RQNT != cmd))
{
if ((mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].flag & PUB_SDP_FLAG_C) != PUB_SDP_FLAG_C)
//if ((chnlInfo->mediaAttr.sdp.medias.medias[0].flag & PUB_SDP_FLAG_C) != PUB_SDP_FLAG_C)
{
//memcpy(&chnlInfo->mediaAttr.sdp.medias.medias[0].c, &chnlInfo->mediaAttr.sdp.c, sizeof(PUB_SDP_C));
//chnlInfo->mediaAttr.sdp.medias.medias[0].flag |= PUB_SDP_FLAG_C;
memcpy(&mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].c, &mgcConnectInfo[connectIndex].mediaAttr.sdp.c, sizeof(PUB_SDP_C));
mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].flag |= PUB_SDP_FLAG_C;
}
/*
num = mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].attrs.num;
//num = chnlInfo->mediaAttr.sdp.medias.medias[0].attrs.num;
if (num < PUB_SDP_MAX_ATTR_NUM)
{
//chnlInfo->mediaAttr.sdp.medias.medias[0].attrs.attrs[num].aType = PUB_SDP_ATTR_TYPE_PTIME;
//sprintf(chnlInfo->mediaAttr.sdp.medias.medias[0].attrs.attrs[num].aValue, "%d", chnlInfo->mediaAttr.ptime);
//chnlInfo->mediaAttr.sdp.medias.medias[0].attrs.num++;
mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].attrs.attrs[num].aType = PUB_SDP_ATTR_TYPE_PTIME;
sprintf(mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].attrs.attrs[num].aValue, "%d", mgcConnectInfo[connectIndex].mediaAttr.ptime);
mgcConnectInfo[connectIndex].mediaAttr.sdp.medias.medias[0].attrs.num++;
}*/
}
return 0;
}
void mgc_port_init(WORD port)
{
memset((BYTE *) &mgcPort[port], 0, sizeof(PORT_INFO));
}
int mgc_get_port()
{
WORD i;
WORD port = mgcSelectPort;
if (port >= MGC_MAX_NUM_OF_PORT)
{
mgc_log_err("mgcSelectPort may be changed\n\r");
port = 0;
}
for (i = 0; i < MGC_MAX_NUM_OF_PORT; i++)
{
if (mgcPort[port].assigned != 0)
{
if (++port >= MGC_MAX_NUM_OF_PORT)
{
port = 0;
}
continue;
}
mgcPort[port].assigned = 1;
mgcSelectPort = port + 1;
if (mgcSelectPort >= MGC_MAX_NUM_OF_PORT)
{
mgcSelectPort = 0;
}
return port;
}
return -1;
}
int mgc_mgcp_ind(BYTE cmd, WORD *usrPort, WORD hdlPort, MGCP_PARA *para)
{
int ret;
int port;
int mgNo;
PORT_INFO *portInfo;
MGCP_SL *sl;
WORD portIndex = 0xFFFF, chnlIndex = 0xFFFF;
char tmpStr[128];
MG_ATTR *mgAttr;
WORD associPort;
if (para == NULL)
{
mgc_log_err("mgc_mgcp_ind: para is NULL\n\r");
return -1;
}
if ((para->flag & MGCP_PARA_FLAG_SL) != MGCP_PARA_FLAG_SL)
{
mgc_log_err("mgc_mgcp_ind: missing start line\n\r");
return -1;
}
sl = &para->sl;
if ((mgNo = mgc_find_mg_by_name(sl->mgName, para->localPort, para->ip)) < 0)
{
mgc_log_err("mgc_mgcp_ind: can't find the mgName\n\r");
return -1;
}
if ((mgcMgInfo[mgNo].portIndex[sl->trkNum] >= MGC_MAX_NUM_OF_PHY_PORT)
&& (cmd == MGCP_CMD_RSIP))
{
mgcMgcpPara.ip = mgcMgInfo[mgNo].mgAttr.ip;
if (mgcMgInfo[mgNo].usrType == MGC_USER_TYPE_MGC)
{
mgcMgcpPara.localPort = MGC_MGCP_MGC_PORT;
mgcMgcpPara.peerPort = MGC_MGCP_MG_PORT;
}
else
{
mgcMgcpPara.localPort = MGC_MGCP_MG_PORT;
mgcMgcpPara.peerPort = MGC_MGCP_MGC_PORT;
}
mgcMgcpPara.flag = 0;
mgcMgcpPara.sl.cmdRes = MGCP_RESPONSE;
mgcMgcpPara.flag |= MGCP_PARA_FLAG_SL;
MGCP_rsp(mgcMgcpSapIndex, cmd, 0xFFFF, hdlPort, 200, &mgcMgcpPara);
return 0;
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_mgcp_ind: can't allocate port\n\r");
return -1;
}
mgAttr = &mgcMgInfo[mgNo].mgAttr;
portInfo = &mgcPort[port];
portInfo->mgcfState = MGC_MGCF_STATE_INDICATION;
portInfo->llPort = hdlPort;
portInfo->llCmd = cmd;
if (mgcMgInfo[mgNo].usrType == MGC_USER_TYPE_MG)
portInfo->ip = para->ip;
portInfo->mgcfChnl.mgNo = mgNo;
portInfo->mgcfChnl.portNo = sl->trkNum;
portInfo->mgcfChnl.chlNo = sl->chlNum;
if ((MGCP_CMD_CRCX == cmd) || (MGCP_CMD_MDCX == cmd) || (MGCP_CMD_DLCX == cmd)||(MGCP_CMD_NTFY == cmd))
{
if ((ret = mgc_extract_media_info(MGCP_COMMAND, cmd, para, port)) < 0)
{
if (ret == -2)
{
mgc_log_err("mgc_mgcp_ind: crcx command to aas miss sdp!\n\r");
mgc_port_init(port);
return -1;
}
else if (ret == -3)
{
mgc_log_err("mgc_mgcp_ind: aas mg no connection resource!\n\r");
mgc_port_init(port);
return -1;
}
else
{
mgc_log_err("mgc_mgcp_ind: extract media info failed!\n\r");
mgc_port_init(port);
return -1;
}
}
}
*usrPort = port;
if (sl->trkNum < MGC_MAX_PHY_PORT_PER_MG)
{
portIndex = mgcMgInfo[mgNo].portIndex[sl->trkNum];
if ((portIndex < MGC_MAX_NUM_OF_PHY_PORT) &&
(sl->chlNum < mgcPhyPort[portIndex].chnlNum))
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + sl->chlNum;
}
else
{
chnlIndex = mgcMgInfo[mgNo].chnlStartIndex + sl->chlNum;
}
sprintf(tmpStr, "mgc_mgcp_ind: succeed, cmd = %d, usrPort = %d, hdlPort = %d, mgNo: %d, portNo: %d, chlNo: %d\n\r",
cmd, port, hdlPort, portInfo->mgcfChnl.mgNo, portInfo->mgcfChnl.portNo, portInfo->mgcfChnl.chlNo);
mgc_log_procedure(mgNo, portIndex, chnlIndex, tmpStr);
if ((mgcMgInfo[mgNo].usrType == MGC_USER_TYPE_MGC)
&& (cmd != MGCP_CMD_RSIP) && (cmd != MGCP_CMD_NTFY))
{
if ((portInfo->mgcfChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
|| (mgcChnl[chnlIndex].connectIndex[portInfo->mgcfChnl.connectNo] >= MGC_MAX_NUM_OF_CON))
{
mgc_log_err("mgc_mgcp_ind: connectNo >= MGC_MAX_NUM_OF_CHNL_CON\n\r");
mgc_port_init(port);
return -1;
}
associPort = mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[portInfo->mgcfChnl.connectNo]].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_CLEAR_AFTER_OPER;
mgc_log_err("mgc_mgcp_ind: DLCX recved from MG, Chnl clear remain connection operation !\n\r");
mgcMgcpPara.ip = mgcMgInfo[mgNo].mgAttr.ip;
mgcMgcpPara.localPort = MGC_MGCP_MGC_PORT;
mgcMgcpPara.peerPort = MGC_MGCP_MG_PORT;
mgcMgcpPara.flag = 0;
mgcMgcpPara.sl.cmdRes = MGCP_RESPONSE;
mgcMgcpPara.flag |= MGCP_PARA_FLAG_SL;
MGCP_rsp(mgcMgcpSapIndex, cmd, port, hdlPort, 250, &mgcMgcpPara);
// mgc_connect_init(mgcChnl[chnlIndex].connectIndex[portInfo->mgcfChnl.connectNo]);
mgc_port_init(port);
}
}
return 0;
}
int mgc_mgcp_cnf(BYTE cmd, WORD usrPort, WORD hdlPort, WORD retCode, MGCP_PARA *para)
{
char tmpStr[128];
if (usrPort >= MGC_MAX_NUM_OF_PORT)
{
sprintf(tmpStr, "mgc_mgcp_cnf, invalid usrPort = %d, hdlPort = %d, cmd = %d, retCode = %d\n\r", usrPort, hdlPort, cmd, retCode);
mgc_log_err(tmpStr);
return -1;
}
if (mgcPort[usrPort].llPort != hdlPort)
{
sprintf(tmpStr, "mgc_mgcp_cnf, mismatched llport = %d, hdlPort = %d, cmd = %d, retCode = %d\n\r", mgcPort[usrPort].llPort, hdlPort, cmd, retCode);
mgc_log_err(tmpStr);
return -1;
}
if (mgcPort[usrPort].mgcfOperSteps[mgcPort[usrPort].mgcfOperStepIndex].cmd != cmd)
{
sprintf(tmpStr, "mgc_mgcp_cnf, mismatched cmd = %d, hdlPort = %d, cmd = %d, retCode = %d\n\r",
mgcPort[usrPort].mgcfOperSteps[mgcPort[usrPort].mgcfOperStepIndex].cmd, hdlPort, cmd, retCode);
mgc_log_err(tmpStr);
return -1;
}
if (((MGCP_CMD_CRCX == cmd) && (retCode == 200)) || (MGCP_CMD_MDCX == cmd))
{
// mgc_extract_media_info(MGCP_RESPONSE, para, &mgcPort[usrPort].mgcfChnl);
if (mgc_extract_media_info(MGCP_RESPONSE, cmd, para, usrPort) < 0)//new replace
{
sprintf(tmpStr, "mgc_mgcp_cnf: extract_media fail cmd = %d, hdlPort = %d, retCode = %d\n\r", cmd, hdlPort, retCode);
mgc_log_err(tmpStr);
return -1;
}
}
mgcPort[usrPort].llCmd = retCode;
return 0;
}
int mgc_bind_mgcp()
{
sprintf(mgcMgcpSap.name, "MGC");
mgcMgcpSap.MGCP_ind = mgc_mgcp_ind;
mgcMgcpSap.MGCP_cnf = mgc_mgcp_cnf;
if ((mgcMgcpSapIndex = mgcp_bind(&mgcMgcpSap)) < 0)
return -1;
return 0;
}
void mgc_chnl_init(WORD chnl)
{
memset((BYTE *) &mgcChnl[chnl], 0, sizeof(CHNL_INFO));
memset((BYTE *) mgcChnl[chnl].connectIndex, 0xFFFF, sizeof(WORD)*MGC_MAX_NUM_OF_CHNL_CON);//new replace
mgcChnl[chnl].port = 0xFFFF;
mgcChnl[chnl].sapIndex = 0xFF;
}
int mgc_vc_name_init()
{
strcpy(vcName[MGC_VCTYPE_PCMA], "PCMA");
strcpy(vcName[MGC_VCTYPE_PCMU], "PCMU");
strcpy(vcName[MGC_VCTYPE_GSM], "GSM");
strcpy(vcName[MGC_VCTYPE_GSM_EFR], "GSM-EFR");
strcpy(vcName[MGC_VCTYPE_AMR_12_2], "AMR_12_2");
strcpy(vcName[MGC_VCTYPE_G729B], "G729B");
strcpy(vcName[MGC_VCTYPE_AMR_10_2], "AMR_10_2");
strcpy(vcName[MGC_VCTYPE_AMR_7_95], "AMR_7_95");
strcpy(vcName[MGC_VCTYPE_AMR_7_4], "AMR_7_4");
strcpy(vcName[MGC_VCTYPE_AMR_6_7], "AMR_6_7");
strcpy(vcName[MGC_VCTYPE_AMR_5_15], "AMR_5_15");
strcpy(vcName[MGC_VCTYPE_AMR_5_9], "AMR_5_9");
strcpy(vcName[MGC_VCTYPE_AMR_4_75], "AMR_4_75");
return 0;
}
int mgc_get_non_virtual_trk_status(WORD mgNo)
{
struct snmp_pdu mgcSnmpPdu;
struct snmp_addr mgcSnmpAddr;
struct var_list *mgcVarList;
BYTE i, j = 0;
MG_INFO *mgInfo;
mgInfo = &mgcMgInfo[mgNo];
mgcVarList = &mgcSnmpPdu.var[0];
mgcSnmpPdu.var_num = 0; //val list number
if (MGC_MG_TYPE_AudioCoder == mgInfo->mgAttr.mgType)
{
for (i = 0; i < MGC_MAX_PHY_PORT_PER_MG; i++)
{
if (mgInfo->portIndex[i] != 0xFFFF)
{
mgcVarList[j].oidlen = MGC_AC_LINE_STATUS_IDLEN;
MGC_AC_LINE_STATUS_OID[MGC_AC_LINE_STATUS_IDLEN - 1] = i;
memcpy(&mgcVarList[mgcSnmpPdu.var_num].oid[0], MGC_AC_LINE_STATUS_OID, MGC_AC_LINE_STATUS_IDLEN*4);
mgcVarList[mgcSnmpPdu.var_num].vartype = 0x04;//octet string
mgcVarList[mgcSnmpPdu.var_num].msglen = 0;
mgcSnmpPdu.var_num++;
j++;
}
}
}
else if (MGC_MG_TYPE_LGC_MG == mgInfo->mgAttr.mgType)
{
mgcVarList[0].oidlen = MGC_LGC_MG_STATUS_IDLEN;
memcpy(&mgcVarList[mgcSnmpPdu.var_num].oid[0], MGC_LGC_MG_STATUS_OID, MGC_LGC_MG_STATUS_IDLEN*4);
mgcVarList[mgcSnmpPdu.var_num].vartype = 0x04;//octet string
mgcVarList[mgcSnmpPdu.var_num].msglen = 0;
mgcSnmpPdu.var_num++;
}//revise by Francis 0822
mgInfo->requestId = (++mgInfo->requestId) & 0xFFFF;
if (mgInfo->requestId == 0)
mgInfo->requestId = 1;
mgcSnmpPdu.pdu_type = 0x00; //get
mgcSnmpPdu.request_id = (mgNo << 16) | mgInfo->requestId;
mgcSnmpAddr.local_port = 4968;
mgcSnmpAddr.remote_port = 161;
mgcSnmpAddr.broadcast = 0; //Not broadcast
mgcSnmpAddr.remote_ip = mgInfo->mgAttr.ip;
if (mgcSnmpPdu.var_num)
snmp_send(&mgcSnmpPdu,&mgcSnmpAddr);
return 1;
}
int mgc_get_snmp_msg()
{
struct snmp_pdu mgcSnmpPdu;
struct snmp_addr mgcSnmpAddr;
struct var_list *mgcVarList;
BYTE i, trkNo;
WORD mgNo, portIndex;
MG_INFO *mgInfo;
mgcSnmpAddr.local_port = 4968;
if (!snmp_receive(&mgcSnmpPdu, &mgcSnmpAddr))
return 0;
if (mgcSnmpPdu.error_index != 0)
return -1;
mgNo = mgcSnmpPdu.request_id >> 16;
mgInfo = &mgcMgInfo[mgNo];
if ((mgcSnmpPdu.request_id & 0xFFFF) != mgInfo->requestId)
return -1;
if (mgcSnmpPdu.var_num > MGC_MAX_PHY_PORT_PER_MG)
return -1;
mgcVarList = &mgcSnmpPdu.var[0];
for (i = 0; i < mgcSnmpPdu.var_num; i++)
{
trkNo = mgcVarList[i].oid[MGC_AC_LINE_STATUS_IDLEN - 1];
if (trkNo > (MGC_MAX_PHY_PORT_PER_MG - 1))
return -1;
if ((portIndex = mgInfo->portIndex[trkNo]) != 0xFFFF)
{
if (mgcVarList[i].msg[0] == 1)
{ // No Alarm
mgcPhyPort[portIndex].stLast = 1;//revise by Francis 0822
}
else
{ // Alarm
mgcPhyPort[portIndex].stLast = 0;//revise by Francis 0822
}
}
}
return 1;
}
void mgc_get_mg_trk_status(WORD mg, BYTE stage)
{
BYTE i;
WORD portIndex;
CHNL chnl = {0, 0, 0, 0};
// static BYTE stage = 0;
// stage++;
// for (mg = 0; mg < MGC_MAX_NUM_OF_MG; mg++)
// {
if ((mgcMgInfo[mg].created == 0) ||
((!mgc_is_non_virtual_mg(mgcMgInfo[mg].mgAttr.mgType)) &&
(mgcMgInfo[mg].mgAttr.mgType != MGC_MG_TYPE_ANN)))
return;
chnl.mgNo = mg;
chnl.chlNo = 1;
if ((mgcMgInfo[mg].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_MGCP)
&& (mgcMgInfo[mg].usrType == MGC_USER_TYPE_MGC))
{
if (mgcMgInfo[mg].mgAttr.mgType == MGC_MG_TYPE_ANN)//revise by Francis 0822
{
chnl.portNo = 0;
mgc_auep_chnl(0xFFFF, chnl);
}
else if (mgcMgInfo[mg].portNum > 0)
{
for (i = 0; i < MGC_MAX_PHY_PORT_PER_MG; i++)
{
if (mgcMgInfo[mg].portIndex[i] == 0xFFFF)
continue;
else
{
chnl.portNo = i;
mgc_auep_chnl(0xFFFF, chnl);
break;
}
}
}
if ((mgc_is_non_virtual_mg(mgcMgInfo[mg].mgAttr.mgType))
&& (mgcMgInfo[mg].portNum > 0))
{
if (MGC_MG_TYPE_SSW_CSS != mgcMgInfo[mg].mgAttr.mgType)
{
mgc_get_non_virtual_trk_status(mg);
}//revise by Francis 0822
}
}
if ((stage & 1) == 0)
{
mgcMgInfo[mg].status = mgcMgInfo[mg].stLast;
mgcMgInfo[mg].stLast = 0;
if (mgc_is_non_virtual_mg(mgcMgInfo[mg].mgAttr.mgType))//revise by Francis 0822
{
for (i = 0; i < MGC_MAX_PHY_PORT_PER_MG; i++)
{
portIndex = mgcMgInfo[mg].portIndex[i];
if (portIndex != 0xFFFF)
{
mgcPhyPort[portIndex].phyStatus = mgcPhyPort[portIndex].stLast;
mgcPhyPort[portIndex].stLast = 0;
}
}
}
}
// }
}
void mgc_t10s()
{
// static DWORD cntT10s = 0;
static DWORD cntT50ms = 0;
static BYTE stage[MGC_MAX_NUM_OF_MG] = {0};
WORD i;
if (++cntT50ms >= MGC_MGCF_TIMER_50MS)
{ // 50 mini seconds period
cntT50ms = 0;
mgc_get_snmp_msg();
mgc_mon();
}
for (i = 1; i < MGC_MAX_NUM_OF_MG; i++)
{
if (mgcMgInfo[i].created == 0)
continue;
if (++mgcMgInfo[i].auditTimer >= mgcMgInfo[i].mgAttr.auditTimer)
{
stage[i]++;
mgcMgInfo[i].auditTimer = 0;
mgc_get_mg_trk_status(i, stage[i]);
}
}
/* if (++cntT10s >= MGC_MGCF_TIMER_10S)
{ // 10 seconds period
cntT10s = 0;
mgc_get_mg_trk_status();
}
*/
}
int mgc_mg_init(WORD mgNo)
{
memset((BYTE *) &mgcMgInfo[mgNo], 0, sizeof(MG_INFO));
memset((BYTE *) &mgcMgInfo[mgNo].portIndex, 0xFFFF, sizeof(WORD) * MGC_MAX_PHY_PORT_PER_MG);
return 0;
}
void mgc_init(DWORD systemId, DWORD localIp, DWORD peerIp)
{
WORD i;
MG_ATTR tmpMgAttr;
MG_ATTR *mgAttr = &tmpMgAttr;
printf("MGC module init start!\n");
if (mgc_bind_8ecp() < 0)
printf("MGC module binds 8ECP fail!\n");
if (mgc_bind_mgcp() < 0)
printf("MGC module binds MGCP fail!\n");
memset((BYTE *) &mgcSap[0], 0, sizeof(MGC_SAP) * MGC_MAX_NUM_OF_SAP);
memset((BYTE *) &mgcPhyPort[0], 0, sizeof(PHY_PORT_INFO) * MGC_MAX_NUM_OF_PHY_PORT);
for (i = 0; i < MGC_MAX_NUM_OF_MG; i++)
mgc_mg_init(i);
for (i = 0; i < MGC_MAX_NUM_OF_PORT; i++)
mgc_port_init(i);
for (i = 0; i < MGC_MAX_NUM_OF_CHNL; i++)
mgc_chnl_init(i);
for (i = 0; i < MGC_MAX_NUM_OF_CON; i++)
mgc_connect_init(i);//new replace
mgc_sess_init();
mgc_vc_name_init();
memset(mgc_aas_mgNo, 0xFFFF, sizeof(WORD)*MGC_MAX_NUM_OF_AAS_MGC);
mgcSelectPort = 0;
mgc_select_connection = 0;
mgc_select_ass_mgc_mgNo = 0;
mgcMaxMgNo = MGC_MAX_NUM_OF_MG;
mgcMaxChlNo = MGC_MAX_NUM_OF_CHNL;
mgcMgCreated = 0;
mgcChlAssigned = 0;
memset(mgAttr, 0, sizeof(MG_ATTR));
mgAttr->mgType = MGC_MG_TYPE_INTERNAL;
mgAttr->ctrlType = MGC_MG_CTRL_TYPE_MGCP;
strcpy(mgAttr->domain, "InternalMG");
mgAttr->ip = 1;
mgc_create_MG(0, mgAttr);
mgc_8k_tone_card_silent = 0;
mgc_e1card0_mgNo = 0;
mgc_e1card1_mgNo = 0;
sysID = systemId;
localIP = localIp;
peerIP = peerIp;
strcpy(mgcAsciInBuf, "\0");
strcpy(mgcAsciOutBuf, "\0");
mgcMonitorFg = MGC_MONITOR_NONE;
mgc_debug_set();
printf("MGC module init complete!\n");
}
void mgc_timer()
{
WORD port;
for (port = 0; port < MGC_MAX_NUM_OF_PORT; port++)
{
if (mgcPort[port].assigned == 0)
continue;
mgc_fsm(port);
}
mgc_t10s();
}
int mgc_bind(MGC_SAP *sap)
{
BYTE sapIndex;
if (wxc2_get_license(LIC_MGC) <= 0)
{
mgc_log_err("mgc_bind: mgc module is not presented!\n\r");
return -1;
}
if ((sap == NULL) ||
(sap->mgc_cnf == NULL) ||
(sap->usrType > MGC_USER_TYPE_MG))
return -1;
for (sapIndex = 0; sapIndex < MGC_MAX_NUM_OF_SAP; sapIndex++)
{
if (mgcSap[sapIndex].mgc_cnf != NULL)
continue;
memcpy((BYTE *) &mgcSap[sapIndex], sap, sizeof(MGC_SAP));
return sapIndex;
}
return -1;
}
int mgc_unbind(MGC_SAP *sap, BYTE sapIndex)
{
if ((sap == NULL) || (sapIndex >= MGC_MAX_NUM_OF_SAP))
return -1;
if ((strcmp(sap->usrName, mgcSap[sapIndex].usrName) != 0) ||
(sap->usrType != mgcSap[sapIndex].usrType))
return -1;
memset((BYTE *) &mgcSap[sapIndex], 0, sizeof(MGC_SAP));
return 0;
}
int mgc_store_aas_mgc_mg(WORD mgNo)
{
int i;
for (i = 0; i < MGC_MAX_NUM_OF_AAS_MGC; i++)
{
if ((mgc_aas_mgNo[i] < MGC_MAX_NUM_OF_MG) && (mgc_aas_mgNo[i] > 0))
{
continue;
}
else
{
mgc_aas_mgNo[i] = mgNo;
return 0;
}
}
return -1;
}
int mgc_delet_aas_mgc_mg(WORD mgNo)
{
int i;
for (i = 0; i < MGC_MAX_NUM_OF_AAS_MGC; i++)
{
if ((mgc_aas_mgNo[i] > 0) && (mgc_aas_mgNo[i] != mgNo))
{
continue;
}
else
{
mgc_aas_mgNo[i] = 0;
return 0;
}
}
return -1;
}
int mgc_assign_chnl(BYTE sapIndex, WORD mgNo, BYTE portNo, BYTE chnlType)
{
WORD i, j;
WORD chnlStart, chnlEnd, chnlNum;
if (mgNo >= MGC_MAX_NUM_OF_MG)
{
return -1;
}
if (chnlType == MGC_MG_TYPE_ANN)
{
chnlStart = MGC_CHNL_START_ANN;
chnlEnd = MGC_CHNL_START_ANN + MGC_CHNL_NUM_ANN;
chnlNum = MGC_CHNL_NUM_ANN_PER_TYPE;
}
else if (chnlType == MGC_PHY_PORT_TYPE_ANALOG)
{
chnlStart = MGC_CHNL_START_AALN;
chnlEnd = MGC_CHNL_START_AALN + MGC_CHNL_NUM_AALN;
chnlNum = MGC_CHNL_NUM_AALN_PER_PORT;
}
else if(chnlType == MGC_MG_TYPE_INTERNAL)
{
chnlStart = MGC_CHNL_START_INTERNAL;
chnlEnd = MGC_CHNL_START_INTERNAL+ MGC_CHNL_NUM_INTERNAL;
chnlNum = MGC_CHNL_NUM_INTERNAL_PER_PORT;
}
else
{
chnlStart = MGC_CHNL_START_DS;
chnlEnd = MGC_CHNL_START_DS + MGC_CHNL_NUM_DS_TOTAL;
chnlNum = MGC_CHNL_NUM_DS_PER_PORT;
}
if ((mgcChlAssigned + chnlNum) > mgcMaxChlNo)
return -1;
for (i = chnlStart; i < chnlEnd; i += chnlNum)
{
if (mgcChnl[i].assigned == 1)
continue;
for (j = 0; j < chnlNum; j++)
{
mgcChnl[i + j].assigned = 1;
mgcChnl[i + j].mgNo = mgNo;
mgcChnl[i + j].portNo = portNo;
mgcChnl[i + j].port = 0xFFFF;
if (chnlType == MGC_MG_TYPE_ANN)
{
mgcChnl[i + j].sapIndex = sapIndex;
}
}
mgcChlAssigned += chnlNum;
return i;
}
return -1;
}
int mgc_remove_chnl(WORD chnlIndex, WORD chnlNum)
{
WORD i, port;
if ((chnlIndex>MGC_MAX_NUM_OF_CHNL) || ((chnlIndex+chnlNum)>MGC_MAX_NUM_OF_CHNL))
{
return -1;
}
for (i = 0; i < chnlNum; i++)
{
port = mgcChnl[chnlIndex + i].port;
if (port < MGC_MAX_NUM_OF_CHNL)
mgcPort[port].mngCmd = MGC_MNG_CMD_REMOVE_CHNL;
mgc_chnl_init(chnlIndex + i);
mgc_remove_connect(chnlIndex + i);
}
if (mgcChlAssigned > chnlNum)
mgcChlAssigned -= chnlNum;
else
mgcChlAssigned = 0;
return 0;
}
int mgc_assign_MG(BYTE sapIndex, WORD mgNo, MG_ATTR *mgAttr)
{
int chnlIndex;
BYTE cardNo;
if ((mgNo >= MGC_MAX_NUM_OF_MG) || (mgAttr == NULL) || (0 == strcmp(mgAttr->domain, ""))
|| (0 == mgAttr->ip))
{
return -1;
}
if (mgAttr->mgType == MGC_MG_TYPE_ANN)
{
if ((chnlIndex = mgc_assign_chnl(sapIndex, mgNo, 0xFF, MGC_MG_TYPE_ANN)) < 0)
return -1;
mgcMgInfo[mgNo].chnlNum = MGC_CHNL_NUM_ANN_PER_TYPE;
mgcMgInfo[mgNo].chnlStartIndex = chnlIndex;
}
if (mgAttr->mgType == MGC_MG_TYPE_INTERNAL)
{
if ((chnlIndex = mgc_assign_chnl(0xFF, mgNo, 0xFF, MGC_MG_TYPE_INTERNAL)) < 0)
return -1;
mgcMgInfo[mgNo].chnlNum = MGC_CHNL_NUM_INTERNAL_PER_PORT;
mgcMgInfo[mgNo].chnlStartIndex = chnlIndex;
}//add by Francis
if (MGC_MG_CTRL_TYPE_8ECP == mgAttr->ctrlType)
{
if ((cardNo = atoi(mgAttr->domain)) > 31)
{
mgc_log_err("mgc_create_MG: 8ecp domain out of range!\n\r");
return -1;
}
_8ecp_createMG(mgNo, mgAttr->ip, cardNo);
if (0 == cardNo)
{
mgc_e1card0_mgNo = mgNo;
}
else if (1 == cardNo)
{
mgc_e1card1_mgNo = mgNo;
}
}
mgcMgInfo[mgNo].created = 1;
memcpy((BYTE *) &mgcMgInfo[mgNo].mgAttr, (BYTE *) mgAttr, sizeof(MG_ATTR));
if (mgcMgInfo[mgNo].mgAttr.auditTimer == 0)
{
mgcMgInfo[mgNo].mgAttr.auditTimer = MGC_MGCF_TIMER_10S;
}
else
{
mgcMgInfo[mgNo].mgAttr.auditTimer = mgcMgInfo[mgNo].mgAttr.auditTimer * MGC_MGCF_TIMER_1S;
}
mgcMgInfo[mgNo].mgAttr.e1cardNo = cardNo;
mgcMgInfo[mgNo].portNum = 0;
memset((BYTE *) mgcMgInfo[mgNo].portIndex, 0xFFFF, sizeof(WORD) * MGC_MAX_PHY_PORT_PER_MG);
mgcMgCreated++;
return mgNo;
}
int mgc_create_MG(BYTE sapIndex, MG_ATTR *mgAttr)
{
WORD i;
int mgNo;
char tmpStr[128];
if ((mgAttr == NULL) || (sapIndex >= MGC_MAX_NUM_OF_SAP) || (0 == strcmp(mgAttr->domain, ""))
|| (0 == mgAttr->ip) || ((MGC_MG_CTRL_TYPE_8ECP != mgAttr->ctrlType) && (MGC_MG_CTRL_TYPE_MGCP != mgAttr->ctrlType)))
{
mgc_log_err("mgc_create_MG: invalid sapIndex or NULL mgAttr or No domain or No ip!\n\r");
return -1;
}
if ((mgcMgCreated + 1) > mgcMaxMgNo)
{
mgc_log_err("mgc_create_MG: license not enough!\n\r");
return -1;
}
for (i = 0; i < MGC_MAX_NUM_OF_MG; i++)
{
if (mgcMgInfo[i].created == 0)
{
continue;
}
if ((0 == strcmp(mgcMgInfo[i].mgAttr.domain, mgAttr->domain))
&& (mgcMgInfo[i].mgAttr.ip == mgAttr->ip) && (mgcMgInfo[i].usrType == mgcSap[sapIndex].usrType))
{
if (mgcMgInfo[i].sapIndex[sapIndex] == 0)
{
mgcMgInfo[i].sapIndex[sapIndex] = 1;
return i;
}
else
{
mgc_log_err("mgc_create_MG: duplicated MG and sapIndex!\n\r");
return -1;
}
}
}
if (mgAttr->mgType == MGC_MG_TYPE_INTERNAL)
{
if (0 == mgcMgInfo[0].created)
return mgc_assign_MG(0xFF, MGC_INTERNAL_VIRTUAL_MG, mgAttr);
else
return -1;
}
for (i = 1; i < MGC_MAX_NUM_OF_MG; i++)
{
if (mgcMgInfo[i].created == 1)
continue;
mgNo = mgc_assign_MG(sapIndex, i, mgAttr);
if (mgNo >= 0)
{
if ((mgcMonitorFg & MGC_MONITOR_ALL) == MGC_MONITOR_ALL)
{
sprintf(tmpStr, "mgc_create_MG: succeed, sapIndex = %d, mgNo = %d, mgDomain: %s\n\r", sapIndex, mgNo, mgAttr->domain);
mgc_asciout_proc(tmpStr);
mgcMgInfo[mgNo].monFlag = 1;
}
mgcMgInfo[mgNo].usrType = mgcSap[sapIndex].usrType;
if ((MGC_MG_TYPE_ANN == mgcMgInfo[mgNo].mgAttr.mgType)
&& (MGC_USER_TYPE_MGC == mgcMgInfo[mgNo].usrType))
{
if (mgc_store_aas_mgc_mg(mgNo) < 0)
{
mgc_log_err("mgc_assign_MG: no resource store AAS MGC MG!\n\r");
mgc_mg_init(mgNo);
return -1;
}
}
mgcMgInfo[mgNo].sapIndex[sapIndex] = 1;
return mgNo;
}
else
{
mgc_log_err("mgc_assign_MG: MG assign failed!\n\r");
return -1;
}
}
mgc_log_err("mgc_create_MG: MG resource not available!\n\r");
return -1;
}
int mgc_delete_MG(BYTE sapIndex, WORD mgNo)
{
BYTE i;
char tmpStr[128];
BYTE cardNo;
BYTE mgFlag = 0;
if ((sapIndex >= MGC_MAX_NUM_OF_SAP) ||
(mgNo >= MGC_MAX_NUM_OF_MG) || (0 == mgNo)
|| (0 == mgcMgInfo[mgNo].created))//add by Francis
{
mgc_log_err("mgc_delete_MG: invalid sapIndex or mgNo!\n\r");
return -1;
}
if (MGC_MG_CTRL_TYPE_8ECP == mgcMgInfo[mgNo].mgAttr.ctrlType)
{
cardNo = mgcMgInfo[mgNo].mgAttr.e1cardNo;
if (cardNo > 31)
{
mgc_log_err("mgc_delete_MG: invalid 8ecp cardNo!\n\r");
return -1;
}
_8ecp_deleteMG(mgNo, mgcMgInfo[mgNo].mgAttr.ip, cardNo);
if (0 == cardNo)
{
mgc_e1card0_mgNo = 0;
}
else if (1 == cardNo)
{
mgc_e1card1_mgNo = 0;
}
}
else
{
if ((MGC_MG_TYPE_ANN == mgcMgInfo[mgNo].mgAttr.mgType) && (mgcMgInfo[mgNo].chnlNum > 0))
{
mgc_delet_aas_mgc_mg(mgNo);
mgc_remove_chnl(mgcMgInfo[mgNo].chnlStartIndex, mgcMgInfo[mgNo].chnlNum);
}//add by Francis
else
{
for (i = 0; i < MGC_MAX_PHY_PORT_PER_MG; i++)
{
if (mgcMgInfo[mgNo].portIndex[i] < MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_delete_port(sapIndex, mgNo, i);
}
}
}
}
mgcMgInfo[mgNo].sapIndex[sapIndex] = 0;
for (i = 0; i < MGC_MAX_NUM_OF_SAP; i++)
{
if (mgcMgInfo[mgNo].sapIndex[i] == 1)
{
mgFlag = 1;
break;
}
}
if (mgFlag == 0)
{
mgc_mg_init(mgNo);
if (mgcMgCreated > 0)
mgcMgCreated--;
sprintf(tmpStr, "mgc_delete_MG: succeed, sapIndex = %d, mgNo = %d, mgDomain: %s\n\r", sapIndex, mgNo, mgcMgInfo[mgNo].mgAttr.domain);
mgc_asciout_proc(tmpStr);
return 0;
}
mgc_log_err("mgc_delete_MG: other users are using this mg!\n\r");
return 0;
}
int mgc_modify_MG(BYTE sapIndex, WORD mgNo, MG_ATTR *mgAttr)
{
char tmpStr[128];
BYTE cardNo;
if ((sapIndex >= MGC_MAX_NUM_OF_SAP) ||
(mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_modify_MG: invalid sapIndex or mgNo!\n\r");
return -1;
}
if (0 == mgcMgInfo[mgNo].created)
{
mgc_log_err("mgc_modify_MG: mg not create!\n\r");
return -1;
}
if (MGC_MG_CTRL_TYPE_8ECP == mgAttr->ctrlType)
{
if ((cardNo = atoi(mgAttr->domain)) > 31)
{
mgc_log_err("mgc_modify_MG: 8ecp domain out of range!\n\r");
return -1;
}
_8ecp_createMG(mgNo, mgAttr->ip, cardNo);
}
memcpy((BYTE *) &mgcMgInfo[mgNo].mgAttr, (BYTE *) mgAttr, sizeof(MG_ATTR));
sprintf(tmpStr, "mgc_modify_MG: succeed, sapIndex = %d, mgNo = %d, mgDomain: %s\n\r", sapIndex, mgNo, mgAttr->domain);
mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_add_port(BYTE sapIndex, WORD mgNo, BYTE portNo, BYTE portType)
{
WORD i;
int chnlIndex;
MG_INFO *mgInfo;
BYTE chnlNum;
WORD portIndex;
char tmpStr[128];
if ((sapIndex >= MGC_MAX_NUM_OF_SAP) ||
(mgNo >= MGC_MAX_NUM_OF_MG) ||
(portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(portType > MGC_PHY_PORT_TYPE_ANALOG))
{
mgc_log_err("mgc_add_port: invalid sapIndex, mgNo, portNo, or portType!\n\r");
return -1;
}
mgInfo = &mgcMgInfo[mgNo];
if (mgInfo->created != 1)
{
mgc_log_err("mgc_add_port: MG not created!\n\r");
return -1;
}
if ((mgInfo->portNum + 1) > mgInfo->mgAttr.maxPorts)
{
mgc_log_err("mgc_add_port: reached maxPorts of that MG!\n\r");
return -1;
}
portIndex = mgcMgInfo[mgNo].portIndex[portNo];
if ((portIndex < MGC_MAX_NUM_OF_PHY_PORT) &&
(mgcPhyPort[portIndex].created == 1))
{
mgc_log_err("mgc_add_port: port already created!\n\r");
return -1;
}
for (i = 0; i < MGC_MAX_NUM_OF_PHY_PORT; i++)
{
if (mgcPhyPort[i].created == 1)
continue;
if (mgInfo->mgAttr.ctrlType != MGC_MG_CTRL_TYPE_8ECP)
{
if (portType == MGC_PHY_PORT_TYPE_ANALOG)
chnlNum = MGC_CHNL_NUM_AALN_PER_PORT;
else
chnlNum = MGC_CHNL_NUM_DS_PER_PORT;
if ((chnlIndex = mgc_assign_chnl(sapIndex, mgNo, portNo, portType)) < 0)
{
mgc_log_err("mgc_add_port: insufficient channel resources!\n\r");
return -1;
}
mgcPhyPort[i].chnlNum = chnlNum;
mgcPhyPort[i].chnlStartIndex = chnlIndex;
}
mgcPhyPort[i].created = 1;
mgcPhyPort[i].mgNo = mgNo;
mgcPhyPort[i].portNo = portNo;
mgcPhyPort[i].portType = portType;
mgcPhyPort[i].sapIndex = sapIndex;
mgInfo->portIndex[portNo] = i;
mgInfo->portNum++;
if ((mgcMonitorFg & MGC_MONITOR_ALL) == MGC_MONITOR_ALL)
mgcPhyPort[i].monFlag = 1;
sprintf(tmpStr, "mgc_add_port: succeed, sapIndex = %d, mgNo = %d, portNo = %d, portType = %d, allocated portNo = %d\n\r", sapIndex, mgNo, portNo, portType, i);
mgc_log_procedure(mgNo, i, 0xFFFF, tmpStr);
return i;
}
mgc_log_err("mgc_add_port: insufficient port resource!\n\r");
return -1;
}
int mgc_delete_port(BYTE sapIndex, WORD mgNo, BYTE portNo)
{
WORD portIndex;
MG_INFO *mgInfo;
char tmpStr[128];
if ((sapIndex >= MGC_MAX_NUM_OF_SAP) ||
(mgNo >= MGC_MAX_NUM_OF_MG) ||
(portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_delete_port: invalid sapIndex, mgNo, portNo!\n\r");
return -1;
}
mgInfo = &mgcMgInfo[mgNo];
portIndex = mgInfo->portIndex[portNo];
if (mgcPhyPort[portIndex].sapIndex == sapIndex)
{
mgc_remove_chnl(mgcPhyPort[portIndex].chnlStartIndex, mgcPhyPort[portIndex].chnlNum);
memset((BYTE *) &mgcPhyPort[portIndex], 0, sizeof(PHY_PORT_INFO));
mgInfo->portIndex[portNo] = 0xFFFF;
mgInfo->portNum--;
sprintf(tmpStr, "mgc_delete_port: succeed, sapIndex = %d, mgNo = %d, portNo = %d\n\r", sapIndex, mgNo, portNo);
mgc_asciout_proc(tmpStr);
return 0;
}
else
{
mgc_log_err("mgc_delete_port: invalid sapIndex for the portNo!\n\r");
return -1;
}
}
int mgc_modify_port(BYTE sapIndex, WORD mgNo, BYTE portNo, BYTE portType)
{
WORD phyPort;
char tmpStr[128];
if ((sapIndex >= MGC_MAX_NUM_OF_SAP) ||
(mgNo >= MGC_MAX_NUM_OF_MG) ||
(!mgc_is_non_virtual_mg(mgcMgInfo[mgNo].mgAttr.mgType))||//add by Francis
(portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(portType > MGC_PHY_PORT_TYPE_ANALOG))
{
mgc_log_err("mgc_modify_port: invalid sapIndex, mgNo, portNo, or portType!\n\r");
return -1;
}
phyPort = mgcMgInfo[mgNo].portIndex[portNo];
if (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)
{
mgc_log_err("mgc_modify_port: invalid phyPort!\n\r");
return -1;
}
mgcPhyPort[phyPort].portType = portType;
sprintf(tmpStr, "mgc_modify_port: succeed, sapIndex = %d, mgNo = %d, portNo = %d, portType = %d\n\r", sapIndex, mgNo, portNo, portType);
mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_apply_aas_tone(CHNL *aasChnl, BYTE toneNo)
{
int i;
int j;
WORD chnlIndex;
WORD connectIndex;
for (i = 0; i < MGC_MAX_NUM_OF_AAS_MGC; i++)
{
if (mgc_select_ass_mgc_mgNo > 3)
{
mgc_select_ass_mgc_mgNo = 0;
}
if ((mgc_aas_mgNo[mgc_select_ass_mgc_mgNo] >= MGC_MAX_NUM_OF_MG)
|| (mgc_aas_mgNo[mgc_select_ass_mgc_mgNo] == 0)
|| (mgcMgInfo[mgc_aas_mgNo[mgc_select_ass_mgc_mgNo]].status != 1)
|| (mgcMgInfo[mgc_aas_mgNo[mgc_select_ass_mgc_mgNo]].mgAttr.ip != localIP))
{
mgc_select_ass_mgc_mgNo++;
continue;
}
else
{
chnlIndex = mgcMgInfo[mgc_aas_mgNo[mgc_select_ass_mgc_mgNo]].chnlStartIndex + toneNo;
for (j = 0; j < MGC_MAX_NUM_OF_CHNL_CON; j++)
{
if (((connectIndex = mgcChnl[chnlIndex].connectIndex[j]) < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[connectIndex].assigned == 1))
{
continue;
}
else
{
aasChnl->mgNo = mgc_aas_mgNo[mgc_select_ass_mgc_mgNo];
aasChnl->portNo = 0xFF;
aasChnl->chlNo = toneNo;
aasChnl->connectNo = j;
if (mgc_assign_connect_to_chnl(*aasChnl) < 0)
{
mgc_log_err("mgc_apply_aas_tone: assigned connect to chnl failed!\n\r");
return -1;
}
mgc_select_ass_mgc_mgNo++;
return 0;
}
}
}
}
return -1;
}
int mgc_match_codec_list(MGC_CODEC_LIST *dest, MGC_CODEC_LIST *aParty, MGC_CODEC_LIST *bParty)
{
BYTE i, j, num = 0;
MGC_CODEC_LIST *base, *highPri;
if (dest == NULL)
{
mgc_log_err("mgc_match_codec_list: dest == NULL!\n\r");
return -1;
}
dest->num = 0;
dest->priority = 0;
if (aParty->priority >= bParty->priority)
{
base = bParty;
highPri = aParty;
}
else
{
base = aParty;
highPri = bParty;
}
if (aParty->codec[0] == MGC_VCTYPE_G729B)
{
base = bParty;
highPri = aParty;
}
else if (bParty->codec[0] == MGC_VCTYPE_G729B)
{
base = aParty;
highPri = bParty;
}
if (base->num == 0)
{
if (highPri->num == 0)
{
mgc_log_err("mgc_match_codec_list: base->num == 0!\n\r");
return -1;
}
else
{
memcpy((BYTE *) dest, (BYTE *) highPri, sizeof(MGC_CODEC_LIST));
return 0;
}
}
if (highPri->num == 0)
{
memcpy((BYTE *) dest, (BYTE *) base, sizeof(MGC_CODEC_LIST));
return 0;
}
for (i = 0; i < highPri->num; i++)
{
for (j = 0; j < base->num; j++)
{
if (highPri->codec[i] == base->codec[j])
{
dest->codec[num++] = highPri->codec[i];
break;
}
}
}
if (num > 0)
{
dest->num = num;
dest->priority = highPri->priority;
return 0;
}
else
{
mgc_log_err("mgc_match_codec_list: can't match at all!\n\r");
return -1;
}
}
int mgc_crcx_chnl(WORD usrPort, CHNL chnl)
{
int port;
WORD chnlIndex, phyPort, associPort;
char tmpStr[256];
BYTE ptime;
int connectIndex;//new replace
WORD aasChnlIndex;
WORD aasConnectIndex;
CHNL aasChnl;
// return 0;
if (chnl.mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_crcx_chnl: invalid mgNo!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL)
{
mgc_log_err("mgc_crcx_chnl: MGC_MG_TYPE_INTERNAL!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
return 1;
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_crcx_chnl: invalid portNo!\n\r");
return -1;
}
if (chnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_crcx_chnl: invalid connectNo!\n\r");
return -1;
}
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_crcx_chnl: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if ((mgcChnl[chnlIndex].connectIndex[chnl.connectNo] < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].assigned == 1)
&& ((mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].status == MGC_CONNECT_STATUS_CREATED)
||(mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].status == MGC_CONNECT_STATUS_TONE)))//new replace
{
mgc_log_err("mgc_crcx_chnl: connection already created on this channel!\n\r");
return 0;
}
if ((mgcChnl[chnlIndex].connectIndex[chnl.connectNo] >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].assigned != 1))
{
if ((connectIndex = mgc_assign_connect_to_chnl(chnl)) < 0)
{
mgc_log_err("mgc_crcx_chnl: connect resource not available!\n\r");
return -1;
}//new replace
}
else
{
connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo];
}
associPort = mgcConnectInfo[connectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_crcx_chnl: chnl connection operation overwritten!\n\r");
}
aasChnl = mgcConnectInfo[connectIndex].aasChnl;
if ((aasChnl.mgNo < MGC_MAX_NUM_OF_MG) && (aasChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (aasChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
aasChnlIndex = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
if ((aasConnectIndex = mgcChnl[aasChnlIndex].connectIndex[aasChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[aasConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_crcx_chnl: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_crcx_chnl: chnl operation overwritten!\n\r");
}
if (mgcConnectInfo[connectIndex].codecList.num == 0)
// if (mgcChnl[chnlIndex].codecList.num == 0)
{
if (mgc_match_codec_list(&mgcConnectInfo[connectIndex].codecList, &mgcConnectInfo[connectIndex].codecList, &mgcMgInfo[chnl.mgNo].mgAttr.codecList) < 0)
//if (mgc_match_codec_list(&codecList, &mgcChnl[chnlIndex].codecList, &mgcMgInfo[chnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_crcx_chnl: mgcChnl[chnlIndex].codecList error!\n\n");
return -1;
}
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_crcx_chnl: port resource not available!\n\r");
return -1;
}
ptime = mgcMgInfo[chnl.mgNo].mgAttr.ptime;
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
mgcPort[port].mgcfOperSteps[0].localChnl = chnl;
mgcPort[port].mgcfOperSteps[0].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[0].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[0].media.vocoderType = mgcConnectInfo[connectIndex].codecList;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_CRCX;
mgcPort[port].mgcfOperId = MGC_OPER_ID_CRCX;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperSteps[0].chnlConnectIndex = chnl.connectNo;
sprintf(tmpStr, "mgc_crcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, chnlConnectNo = %d, connectIndex = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo, connectIndex);//new replace
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
int mgc_mdcx_chnl(WORD usrPort, CHNL chnl, MEDIA_PARA *mediaPara, BYTE sdFlag)
{
int port;
WORD chnlIndex, phyPort;
char tmpStr[256];
WORD connectIndex;//new replace
// return 0;
if (chnl.mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_mdcx_chnl: invalid mgNo!\n\r");
return -1;
}
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_mdcx_chnl: invalid portNo!\n\r");
return -1;
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[chnl.mgNo].mgAttr.mgType))
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_mdcx_chnl: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if ((connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo]) >= MGC_MAX_NUM_OF_CON);//new replace
{
mgc_log_err("mgc_mdcx_chnl: invalid connectNo!\n\r");
return -1;
}
if ((mediaPara->flag & MGC_MEDIA_PARA_FLAG_EC) == MGC_MEDIA_PARA_FLAG_EC)
//mgcChnl[chnlIndex].mediaAttr.ecDisable = mediaPara->ecDisable;
mgcConnectInfo[connectIndex].mediaAttr.ecDisable = mediaPara->ecDisable;
if ((mediaPara->flag & MGC_MEDIA_PARA_FLAG_SS) == MGC_MEDIA_PARA_FLAG_SS)
//mgcChnl[chnlIndex].mediaAttr.ssDisable = mediaPara->ssDisable;
mgcConnectInfo[connectIndex].mediaAttr.ssDisable = mediaPara->ssDisable;
if ((mediaPara->flag & MGC_MEDIA_PARA_FLAG_CM) == MGC_MEDIA_PARA_FLAG_CM)
//mgcChnl[chnlIndex].mediaAttr.conMode = mediaPara->conMode;
mgcConnectInfo[connectIndex].mediaAttr.conMode = mediaPara->conMode;
if ((mediaPara->flag & MGC_MEDIA_PARA_FLAG_PT) == MGC_MEDIA_PARA_FLAG_PT)
//mgcChnl[chnlIndex].mediaAttr.ptime = mediaPara->ptime;
mgcConnectInfo[connectIndex].mediaAttr.ptime = mediaPara->ptime;
if ((mediaPara->flag & MGC_MEDIA_PARA_FLAG_VT) == MGC_MEDIA_PARA_FLAG_VT)
{
//mgc_match_codec_list(&mgcChnl[chnlIndex].codecList, &mediaPara->vocoderType, &mgcMgInfo[chnl.mgNo].mgAttr.codecList);
mgc_match_codec_list(&mgcConnectInfo[connectIndex].codecList, &mediaPara->vocoderType, &mgcMgInfo[chnl.mgNo].mgAttr.codecList);
}
if (sdFlag == 0)
{
// sprintf(tmpStr, "mgc_mdcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, sdFlag = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, sdFlag);
sprintf(tmpStr, "mgc_mdcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, sdFlag = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo, sdFlag);//new replace
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
if ((mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].assigned != 1)
|| ((mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].status != MGC_CONNECT_STATUS_CREATED)&&((mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].status != MGC_CONNECT_STATUS_TONE))))//new replace
// if (mgcChnl[chnlIndex].status != MGC_CHNL_STATUS_CREATED)
{
mgc_log_err("mgc_mdcx_chnl: connection not created on this channel!\n\r");
return -1;
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_mdcx_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
mgcPort[port].mgcfOperSteps[0].localChnl = chnl;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_MDCX;
mgcPort[port].mgcfOperId = MGC_OPER_ID_MDCX;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperSteps[0].chnlConnectIndex = chnl.connectNo;
// sprintf(tmpStr, "mgc_mdcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, sdFlag = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, sdFlag);
sprintf(tmpStr, "mgc_mdcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, sdFlag = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo, sdFlag);
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
int mgc_recvonly_chnl(WORD usrPort, CHNL orgChnl, CHNL destChnl)
{
int port;
BYTE ptime;
WORD chnlIndexOrg, chnlIndexDst, phyPortOrg, phyPortDst;
char tmpStr[256];
int orgConnectIndex;
int destConnectIndex;
MGC_CODEC_LIST codecList;
if ((orgChnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(destChnl.mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_recvonly_chnl: invalid mgNo!\n\r");
return -1;
}
if ((orgChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(destChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_recvonly_chnl: invalid portNo!\n\r");
return -1;
}
if ((orgChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON) ||
(destChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON))
{
mgc_log_err("mgc_recvonly_chnl: invalid connectNo!\n\r");
return -1;
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
|| (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL))
{
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
}
if ((chnlIndexOrg >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortOrg >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_recvonly_chnl: invalid chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
if (((orgConnectIndex = mgcChnl[chnlIndexOrg].connectIndex[orgChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[orgConnectIndex].assigned != 1)
|| ((mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_TONE)))//new replace
{
mgc_log_err("mgc_recvonly_chnl: orgChnl connectionIndex invaild or connection not create!\n\r");
return -1;
}
if (mgcConnectInfo[orgConnectIndex].mediaAttr.conMode == MGCP_CON_MODE_RECVONLY)
{
sprintf(tmpStr, "mgc_recvonly_chnl: connection already in recvonly mode, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, orgConnectIndex, destChnl.mgNo, destChnl.portNo, destChnl.chlNo, destChnl.connectNo);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[destChnl.mgNo].mgAttr.mgType)
|| (mgcMgInfo[destChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL))
{
chnlIndexDst = mgcMgInfo[destChnl.mgNo].chnlStartIndex + destChnl.chlNo;
}
else
{
phyPortDst = mgcMgInfo[destChnl.mgNo].portIndex[destChnl.portNo];
chnlIndexDst = mgcPhyPort[phyPortDst].chnlStartIndex + destChnl.chlNo;
}
if (chnlIndexDst >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[destChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (phyPortDst >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_recvonly_chnl: invalid chnlIndex or phyPort of destChnl!\n\r");
return -1;
}
if (((destConnectIndex = mgcChnl[chnlIndexDst].connectIndex[destChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[destConnectIndex].assigned != 1)
|| ((mgcConnectInfo[destConnectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[destConnectIndex].status != MGC_CONNECT_STATUS_TONE)))//new replace
{
mgc_log_err("mgc_recvonly_chnl: destChnl connectionIndex invaild or connection not create!\n\r");
return -1;
}
if (mgcConnectInfo[orgConnectIndex].codecList.num == 0)
{
if (mgc_match_codec_list(&mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcMgInfo[orgChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_crcx_chnl: mgcChnl[chnlIndex].codecList error!\n\n");
return -1;
}
}
codecList = mgcConnectInfo[orgConnectIndex].codecList;
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_mdcx_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[0].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[0].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[0].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[0].remChnl = destChnl;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_MDCX;
mgcPort[port].mgcfOperSteps[0].media.vocoderType = codecList;
mgcPort[port].mgcfOperId = MGC_OPER_ID_MDCX;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
sprintf(tmpStr, "mgc_recvonly_chnl: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, orgConnectIndex, destChnl.mgNo, destChnl.portNo, destChnl.chlNo, destChnl.connectNo, destConnectIndex);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
int mgc_dlcx_chnl(WORD usrPort, CHNL chnl)
{
int port;
WORD chnlIndex, phyPort, associPort;
char tmpStr[256];
WORD orgChl, dstChl;
WORD connectIndex;
WORD aasChnlIndex;
WORD aasConnectIndex;
CHNL aasChnl;
// return 0;
if (chnl.mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_dlcx_chnl: invalid mgNo!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
{
orgChl = (mgcMgInfo[chnl.mgNo].mgAttr.e1cardNo * 8 + chnl.portNo) * 32 + chnl.chlNo;
dstChl = (mgc_8k_tone_card_silent * 8 + 7) * 32 + 31;
_8ecp_connect_chnl(orgChl, dstChl, 0); //ecDisable:0/1=enable/disable echo canceller
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
sprintf(tmpStr, "mgc_dlcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo);
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
if ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN)
&& (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_dlcx_chnl: invalid portNo!\n\r");
return -1;
}
if (chnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_dlcx_chnl: invalid connectNo!\n\r");
return -1;
}
if (chnl.chlNo >= MGC_MAX_NUM_OF_CHNL)
{
if (chnl.chlNo != MGCP_EP_NAME_CHNL_WILDCAST)
{
mgc_log_err("mgc_dlcx_chnl: invalid chnlIndex!\n\r");
return -1;
}
}
if (chnl.chlNo < MGC_MAX_NUM_OF_CHNL)
{
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_dlcx_chnl: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if ((connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo]) >= MGC_MAX_NUM_OF_CON)//new replace
{
mgc_log_err("mgc_dlcx_chnl: invalid connectIndex!\n\r");
return -1;
}
associPort = mgcConnectInfo[connectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_dlcx_chnl: chnl connection operation overwritten!\n\r");
}
aasChnl = mgcConnectInfo[connectIndex].aasChnl;
if ((aasChnl.mgNo < MGC_MAX_NUM_OF_MG) && (aasChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (aasChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
aasChnlIndex = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
if ((aasConnectIndex = mgcChnl[aasChnlIndex].connectIndex[aasChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[aasConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_dlcx_chnl: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_dlcx_chnl: chnl operation overwritten!\n\r");
}
if ((mgcConnectInfo[connectIndex].assigned != 1)
|| ((mgcConnectInfo[connectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[connectIndex].status != MGC_CONNECT_STATUS_TONE))) //new replace
{
mgc_log_err("mgc_dlcx_chnl: connection not created on this channel!\n\r");
return 0;
}
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_dlcx_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
mgcPort[port].mgcfOperSteps[0].localChnl = chnl;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_DLCX;
mgcPort[port].mgcfOperId = MGC_OPER_ID_DLCX;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperSteps[0].chnlConnectIndex = chnl.connectNo;
sprintf(tmpStr, "mgc_dlcx_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo);
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
MGC_SESS_REC *pSess;
pSess = mgc_sess_is_already_rec(chnl);
if(pSess != NULL)
mgc_sess_rec_init(pSess, pSess->id);
return 0;
}
int mgc_rqnt_chnl(WORD usrPort, CHNL chnl, EVENT *event, SIGNAL *signal)
{
int port;
WORD chnlIndex, phyPort;
char tmpStr[256];
if (chnl.mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_rqnt_chnl: invalid mgNo!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
return 1;
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_rqnt_chnl: invalid portNo!\n\r");
return -1;
}
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL) ||
((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_rqnt_chnl: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if ((mgcChnl[chnlIndex].port < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[mgcChnl[chnlIndex].port].assigned != 0))
{
mgc_log_err("mgc_rqnt_chnl: channel already engaged!\n\r");
return 0;
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_rqnt_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
mgcPort[port].mgcfOperSteps[0].localChnl = chnl;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_RQNT;
mgcPort[port].mgcfOperId = MGC_OPER_ID_RQNT;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperSteps[0].chnlConnectIndex = 0xFFFF;
if (event != NULL)
//mgcChnl[chnlIndex].mediaAttr.pkgEvent = (event->pkg << 8) | event->event;
mgcChnl[chnlIndex].comMediaAttr.pkgEvent = (event->pkg << 8) | event->event;
if (signal != NULL)
//mgcChnl[chnlIndex].mediaAttr.pkgSignal = (signal->pkg << 8) | signal->signal;
mgcChnl[chnlIndex].comMediaAttr.pkgSignal = (signal->pkg << 8) | signal->signal;
// sprintf(tmpStr, "mgc_rqnt_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo);
sprintf(tmpStr, "mgc_rqnt_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo);
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
int mgc_auep_chnl(WORD usrPort, CHNL chnl)
{
int port;
WORD chnlIndex, phyPort;
char tmpStr[256];
// return 0;
if (chnl.mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_auep_chnl: invalid mgNo!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
return 1;
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_auep_chnl: invalid portNo!\n\r");
return -1;
}
if (MGC_MG_TYPE_ANN == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_auep_chnl: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if (mgcChnl[chnlIndex].auepSt != MGC_CHNL_AUEP_IDLE)
{
mgc_log_err("mgc_auep_chnl: auep already in progress!\n\r");
return -1;
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_auep_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
mgcPort[port].mgcfOperStepsNum = 1;
mgcPort[port].mgcfOperSteps[0].localChnl = chnl;
mgcPort[port].mgcfOperSteps[0].cmd = MGCP_CMD_AUEP;
mgcPort[port].mgcfOperId = MGC_OPER_ID_AUEP;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperSteps[0].chnlConnectIndex = 0xFFFF;
mgcChnl[chnlIndex].auepSt = MGC_CHNL_AUEP_IN_PROGRESS;
// sprintf(tmpStr, "mgc_auep_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo);
sprintf(tmpStr, "mgc_auep_chnl: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d\n\r", usrPort, chnl.mgNo, chnl.portNo, chnl.chlNo, chnl.connectNo);
mgc_log_procedure(chnl.mgNo, phyPort, chnlIndex, tmpStr);
return 0;
}
int mgc_connect_chnl(WORD usrPort, CHNL orgChnl, CHNL destChnl, BYTE flag)
{
int port;
BYTE step = 0, ptime;
WORD orgChl, dstChl;
WORD chnlIndexOrg, chnlIndexDst, phyPortOrg, phyPortDst, associPort;
char tmpStr[256];
MGC_CODEC_LIST codecList;
int orgConnectIndex;
int destConnectIndex;
WORD aasChnlIndex;
WORD aasConnectIndex;
CHNL aasChnl;
CONNECT_INFO *pConnect;
if ((orgChnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(destChnl.mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_connect_chnl: invalid mgNo!\n\r");
return -1;
}
if ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType != mgcMgInfo[destChnl.mgNo].mgAttr.ctrlType)
&& ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP) || (mgcMgInfo[destChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)))
{
mgc_log_err("mgc_connect_chnl: mg ctrlType error!\n\r");
return -1;
}
if (mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
{
orgChl = (mgcMgInfo[orgChnl.mgNo].mgAttr.e1cardNo * 8 + orgChnl.portNo) * 32 + orgChnl.chlNo;
if ((flag & MGC_CONNECT_SILENT_TONE) == MGC_CONNECT_SILENT_TONE)
dstChl = (mgc_8k_tone_card_silent * 8 + 7) * 32 + 31;
else
dstChl = (mgcMgInfo[destChnl.mgNo].mgAttr.e1cardNo * 8 + destChnl.portNo) * 32 + destChnl.chlNo;
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
_8ecp_connect_chnl(orgChl, dstChl, mgcChnl[chnlIndexOrg].comMediaAttr.ecDisable); //ecDisable:0/1=enable/disable echo canceller
phyPortDst = mgcMgInfo[destChnl.mgNo].portIndex[destChnl.portNo];
chnlIndexDst = mgcPhyPort[phyPortDst].chnlStartIndex + destChnl.chlNo;
sprintf(tmpStr, "mgc_connect_chnl: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, destChnl.mgNo, destChnl.portNo, destChnl.chlNo);
if (mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr) < 0)
mgc_log_procedure(destChnl.mgNo, phyPortDst, chnlIndexDst, tmpStr);
return 0;
}
if ((orgChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(destChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_connect_chnl: invalid portNo!\n\r");
return -1;
}
if ((orgChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON) ||
(destChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON))
{
mgc_log_err("mgc_connect_chnl: invalid connectNo!\n\r");
return -1;
}
if (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL)
{
phyPortOrg = 0;
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
if (MGC_MG_TYPE_ANN == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
}
}
if ((chnlIndexOrg >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortOrg >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_chnl: invalid chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
if (((orgConnectIndex = mgcChnl[chnlIndexOrg].connectIndex[orgChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[orgConnectIndex].assigned != 1))//new replace
{
if ((orgConnectIndex = mgc_assign_connect_to_chnl(orgChnl)) < 0)
{
mgc_log_err("mgc_connect_chnl: assigned connect on orgChnl failed!\n\r");
return -1;
}
}
associPort = mgcConnectInfo[orgConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_chnl: orgChnl operation overwritten!\n\r");
}
aasChnl = mgcConnectInfo[orgConnectIndex].aasChnl;
if ((aasChnl.mgNo < MGC_MAX_NUM_OF_MG) && (aasChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (aasChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
aasChnlIndex = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
if ((aasConnectIndex = mgcChnl[aasChnlIndex].connectIndex[aasChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[aasConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_chnl: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndexOrg].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_chnl: orgChnl chnl operation overwritten!\n\r");
}
if (mgcMgInfo[destChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL)
{
phyPortDst = 0;
chnlIndexDst = mgcMgInfo[destChnl.mgNo].chnlStartIndex + destChnl.chlNo;
}
else
{
if (MGC_MG_TYPE_ANN == mgcMgInfo[destChnl.mgNo].mgAttr.mgType)
{
chnlIndexDst = mgcMgInfo[destChnl.mgNo].chnlStartIndex + destChnl.chlNo;
}
else
{
phyPortDst = mgcMgInfo[destChnl.mgNo].portIndex[destChnl.portNo];
chnlIndexDst = mgcPhyPort[phyPortDst].chnlStartIndex + destChnl.chlNo;
}
}
if (chnlIndexDst >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[destChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortDst >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_chnl: invalid chnlIndex or phyPort of destChnl!\n\r");
return -1;
}
if (((destConnectIndex = mgcChnl[chnlIndexDst].connectIndex[destChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[destConnectIndex].assigned != 1))//new replace
{
if ((destConnectIndex = mgc_assign_connect_to_chnl(destChnl)) < 0)
{
mgc_log_err("mgc_connect_chnl: assigned connect on destChnl failed!\n\r");
return -1;
}
}
if (mgcMgInfo[destChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL)
{
associPort = mgcConnectInfo[destConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_chnl: destChnl operation overwritten!\n\r");
}
associPort = mgcChnl[chnlIndexDst].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_chnl: destChnl chnl operation overwritten!\n\r");
}
}
if ((mgcConnectInfo[orgConnectIndex].codecList.num == 0)
&& (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcMgInfo[orgChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_chnl: mgcConnectInfo[orgConnectIndex].codecList error!\n\n");
return -1;
}
}
if ((mgcConnectInfo[destConnectIndex].codecList.num == 0)
&& (mgcMgInfo[destChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[destConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList, &mgcMgInfo[destChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_chnl: mgcConnectInfo[destConnectIndex].codecList error!\n\n");
return -1;
}
}
if (mgc_match_codec_list(&codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList) < 0)
{
mgc_log_err("mgc_connect_chnl: can't match codec!\n\n");
return -1;
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_connect_chnl: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
if (mgcMgInfo[orgChnl.mgNo].mgAttr.ptime >= mgcMgInfo[destChnl.mgNo].mgAttr.ptime)
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
else
ptime = mgcMgInfo[destChnl.mgNo].mgAttr.ptime;
if ((mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_TONE))
{
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_CRCX;
}
}
if ((mgcConnectInfo[destConnectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[destConnectIndex].status != MGC_CONNECT_STATUS_TONE))
{
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[destChnl.mgNo].mgAttr.mgType)
{
mgcPort[port].mgcfOperSteps[step].localChnl = destChnl;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = destChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_CRCX;
}
}
if ((MGC_MG_TYPE_IPBSS != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType) && (orgChnl.mgNo == destChnl.mgNo)
&& ((mgcConnectInfo[orgConnectIndex].flag & MGCP_PARA_FLAG_TFO) != MGCP_PARA_FLAG_TFO))
{
if ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_IPBSS)
&& (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType))
{
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = destChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = 0;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = mgcConnectInfo[orgConnectIndex].mediaAttr.conMode;
mgcPort[port].mgcfOperSteps[step].flag |= MGCP_PARA_FLAG_TFO;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
else if ((orgChnl.mgNo != destChnl.mgNo)
&& ((mgcConnectInfo[orgConnectIndex].flag & MGCP_PARA_FLAG_TFO) == MGCP_PARA_FLAG_TFO))
{
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = destChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = 0;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = mgcConnectInfo[orgConnectIndex].mediaAttr.conMode;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = destChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = 0;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = mgcConnectInfo[orgConnectIndex].mediaAttr.conMode;
if ((MGC_MG_TYPE_IPBSS != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType) && (orgChnl.mgNo == destChnl.mgNo))
{
mgcPort[port].mgcfOperSteps[step].flag |= MGCP_PARA_FLAG_TFO;
}
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[destChnl.mgNo].mgAttr.mgType)
{
mgcPort[port].mgcfOperSteps[step].localChnl = destChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = 0;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
if ((flag & MGC_CONNECT_SILENT_TONE) == MGC_CONNECT_SILENT_TONE)
{
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
}
else
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_SENDRECV;
if ((MGC_MG_TYPE_IPBSS != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType) && (orgChnl.mgNo == destChnl.mgNo))
{
mgcPort[port].mgcfOperSteps[step].flag |= MGCP_PARA_FLAG_TFO;
}
mgcPort[port].mgcfOperSteps[step].media.vocoderType = codecList;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = destChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
if(mgcMgInfo[destChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_AudioCoder)
{
mgcPort[port].mgcfOperSteps[step].localChnl = destChnl;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_RQNT;
mgcChnl[chnlIndexDst].comMediaAttr.pkgReq = (MGCP_PKG_D << 8)|(MGCP_D_SIG_WILD);
}
pConnect = &mgcConnectInfo[orgConnectIndex];
memset(&(pConnect->operRec) , 0 , sizeof(OPER_REC));
pConnect->operRec.operaId = MGC_OPER_ID_CONNECT_CHNL;
if (step == 0)
mgc_port_init(port);
else
{
mgcPort[port].mgcfOperId = MGC_OPER_ID_CONNECT_CHNL;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperStepsNum = step;
}
sprintf(tmpStr, "mgc_connect_chnl: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, step = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, orgConnectIndex, destChnl.mgNo, destChnl.portNo, destChnl.chlNo, destChnl.connectNo, destConnectIndex, step);
if (mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr) < 0)
mgc_log_procedure(destChnl.mgNo, phyPortDst, chnlIndexDst, tmpStr);
if(mgc_sess_rec_org_and_dst_chnl(orgChnl , destChnl) == FALSE)
return -1;
return 0;
}
int mgc_connect_dtmf(WORD usrPort, CHNL orgChnl, CHNL dstChnl, BYTE dtmfNo)
{
int port;
BYTE step = 0, ptime;
WORD orgChl, dstChl;
WORD chnlIndexOrg, phyPortOrg, associPort;
char tmpStr[256];
BYTE digit = 0;
int orgConnectIndex;
WORD aasChnlIndex;
WORD aasConnectIndex;
CHNL aasChnl;
// return 0;
if ((orgChnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(dstChnl.mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_connect_dtmf: invalid mgNo!\n\r");
return -1;
}
if (0 == dtmfNo)
{
digit = 10;
}
else
{
digit = dtmfNo;
}
if (mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
{
orgChl = (mgcMgInfo[orgChnl.mgNo].mgAttr.e1cardNo * 8 + orgChnl.portNo) * 32 + orgChnl.chlNo;
dstChl = (mgcMgInfo[dstChnl.mgNo].mgAttr.e1cardNo * 8 + dstChnl.portNo) * 32 + dstChnl.chlNo;
_8ecp_connect_dtmf(orgChl, dstChl, digit);
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
sprintf(tmpStr, "mgc_connect_dtmf: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, dtmfNo = %d\n\r", usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, dtmfNo);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
if (orgChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_connect_dtmf: invalid portNo!\n\r");
return -1;
}
if (orgChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_connect_dtmf: invalid connectNo!\n\r");
return -1;
}
if (MGC_MG_TYPE_ANN == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
}
if (chnlIndexOrg >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortOrg >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_dtmf: invalid chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
if (((orgConnectIndex = mgcChnl[chnlIndexOrg].connectIndex[orgChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[orgConnectIndex].assigned != 1))//new replace
{
if ((orgConnectIndex = mgc_assign_connect_to_chnl(orgChnl)) < 0)
{
mgc_log_err("mgc_connect_dtmf: assigned connect on orgChnl failed!\n\r");
return -1;
}
}
associPort = mgcConnectInfo[orgConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_dtmf: orgChnl connection operation overwritten!\n\r");
}
aasChnl = mgcConnectInfo[orgConnectIndex].aasChnl;
if ((aasChnl.mgNo < MGC_MAX_NUM_OF_MG) && (aasChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (aasChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
aasChnlIndex = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
if ((aasConnectIndex = mgcChnl[aasChnlIndex].connectIndex[aasChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[aasConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_dtmf: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndexOrg].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_dtmf: orgChnl chnl operation overwritten!\n\r");
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_connect_dtmf: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
if ((mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_TONE))
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_CRCX;
}
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = (MGCP_PKG_D << 8) | digit;
if(mgcMgInfo[orgChnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_AudioCoder)
{
mgcChnl[orgConnectIndex].comMediaAttr.pkgReq = (MGCP_PKG_D << 8)|(MGCP_D_SIG_WILD);
}
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_RQNT;
mgcPort[port].mgcfOperStepsNum = step;
mgcPort[port].mgcfOperId = MGC_OPER_ID_CONNECT_DTMF;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
sprintf(tmpStr, "mgc_connect_dtmf: succeed, usrPort = %d, mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, dtmfNo = %d\n\r", usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, dtmfNo);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
int mgc_connect_AAS(WORD usrPort, CHNL orgChnl, CHNL dstChnl, BYTE toneNo, WORD duration, WORD times)
{
int port;
BYTE step = 0, ptime;
WORD orgChl, dstChl;
WORD chnlIndexOrg, chnlIndexDst, phyPortOrg, phyPortDst, associPort;
char tmpStr[256];
CHNL aasChnl = {0xFFFF, 0, 0xFFFF, 0xFFFF};
int orgConnectIndex;
int destConnectIndex;
WORD aasConnectIndex;
WORD chnlIndexAAS;
MGC_CODEC_LIST codecList;
WORD orgAASChnlIndex;
WORD orgAASConnectIndex;
CHNL orgAASChnl;
CONNECT_INFO *pConnect;
BYTE tone;
if ((orgChnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(dstChnl.mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_connect_AAS: invalid mgNo!\n\r");
return -1;
}
if ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType != mgcMgInfo[dstChnl.mgNo].mgAttr.ctrlType)
&& ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP) || (mgcMgInfo[dstChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)))
{
mgc_log_err("mgc_connect_chnl: mg ctrlType error!\n\r");
return -1;
}
if (toneNo >= MGC_MAX_TONE_NO)
{
mgc_log_err("mgc_connect_AAS: invalid toneNo!\n\r");
return -1;
}
if (mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
{
orgChl = (mgcMgInfo[orgChnl.mgNo].mgAttr.e1cardNo * 8 + orgChnl.portNo) * 32 + orgChnl.chlNo;
if ((0 == dstChnl.mgNo) && (0 == dstChnl.portNo) && (0 == dstChnl.chlNo))
{
dstChl = (mgc_8k_tone_card_silent * 8 + 7) * 32 + 31;
}
else if ((1 == mgcMgInfo[dstChnl.mgNo].created)
&& (1 == mgcPhyPort[mgcMgInfo[dstChnl.mgNo].portIndex[dstChnl.portNo]].created))
{
dstChl = (mgcMgInfo[dstChnl.mgNo].mgAttr.e1cardNo * 8 + dstChnl.portNo) * 32 + dstChnl.chlNo;//need revise
}
else
{
mgc_log_err("mgc_connect_AAS: invalid 8ecp mgNo or portNo!\n\r");
return -1;
}
_8ecp_connect_tone(orgChl, dstChl, toneNo, duration);
sprintf(tmpStr, "mgc_connect_AAS: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
if ((orgChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(dstChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_connect_AAS: invalid portNo!\n\r");
return -1;
}
if ((orgChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON) ||
(dstChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON))
{
mgc_log_err("mgc_connect_AAS: invalid connectNo!\n\r");
return -1;
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType))
{
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
}
if (chnlIndexOrg >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortOrg >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_AAS: invalid chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
if (((orgConnectIndex = mgcChnl[chnlIndexOrg].connectIndex[orgChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[orgConnectIndex].assigned != 1))//new replace
{
if ((orgConnectIndex = mgc_assign_connect_to_chnl(orgChnl)) < 0)
{
mgc_log_err("mgc_connect_AAS: assigned connect on orgChnl failed!\n\r");
return -1;
}
}
associPort = mgcConnectInfo[orgConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_AAS: orgChnl connection operation overwritten!\n\r");
}
orgAASChnl = mgcConnectInfo[orgConnectIndex].aasChnl;
if ((orgAASChnl.mgNo < MGC_MAX_NUM_OF_MG) && (orgAASChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (orgAASChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
orgAASChnlIndex = mgcMgInfo[orgAASChnl.mgNo].chnlStartIndex + orgAASChnl.chlNo;
if ((orgAASConnectIndex = mgcChnl[orgAASChnlIndex].connectIndex[orgAASChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[orgAASConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_AAS: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndexOrg].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_AAS: orgChnl chnl operation overwritten!\n\r");
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[dstChnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[dstChnl.mgNo].mgAttr.mgType))
{
chnlIndexDst = mgcMgInfo[dstChnl.mgNo].chnlStartIndex + dstChnl.chlNo;
}
else
{
phyPortDst = mgcMgInfo[dstChnl.mgNo].portIndex[dstChnl.portNo];
chnlIndexDst = mgcPhyPort[phyPortDst].chnlStartIndex + dstChnl.chlNo;
}
if (chnlIndexDst >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortDst >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_AAS: invalid destChnl chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
destConnectIndex = mgcChnl[chnlIndexDst].connectIndex[dstChnl.connectNo];
if ((mgcConnectInfo[orgConnectIndex].codecList.num == 0)
&& (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcMgInfo[orgChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_AAS: mgcConnectInfo[orgConnectIndex].codecList error!\n\n");
return -1;
}
}
if ((destConnectIndex < MGC_MAX_NUM_OF_CON) && (mgcConnectInfo[destConnectIndex].codecList.num == 0)
&& (mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[destConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList, &mgcMgInfo[dstChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_AAS: mgcConnectInfo[dstConnectIndex].codecList error!\n\n");
return -1;
}
}
if (destConnectIndex < MGC_MAX_NUM_OF_CON)
{
if (mgc_match_codec_list(&codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList) < 0)
{
mgc_log_err("mgc_connect_AAS: orgConnect and dstConnect code negotiation fail!\n\n");
return -1;
}
}
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_connect_AAS: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
if (toneNo == MGC_HOLD_MUSIC)
{
if (mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_CREATED)
{
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_CRCX;
}
}
else
{
if (mgcConnectInfo[orgConnectIndex].mediaAttr.conMode >= MGCP_CON_MODE_SENDONLY)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = dstChnl;
if (destConnectIndex < MGC_MAX_NUM_OF_CON)
{
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[destConnectIndex].codecList;//orgConnectIndex
}
else
{
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
}
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
}
if (mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL)
{
if ((destConnectIndex < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[destConnectIndex].status == MGC_CONNECT_STATUS_CREATED))
{
if (mgcConnectInfo[destConnectIndex].mediaAttr.conMode >= MGCP_CON_MODE_SENDONLY)
{
ptime = mgcMgInfo[dstChnl.mgNo].mgAttr.ptime;
if ((mgcConnectInfo[destConnectIndex].flag & MGCP_PARA_FLAG_TFO) == MGCP_PARA_FLAG_TFO)
{
mgcPort[port].mgcfOperSteps[step].flag |= MGCP_PARA_FLAG_TFO;
}
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = dstChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = dstChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;//destConnectIndex
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
}
toneNo = times * 10 + (toneNo - 7);
if (mgc_apply_aas_tone(&aasChnl, toneNo) < 0)
{
mgc_log_err("mgc_connect_AAS: apply aas tone fail!\n\r");
mgc_port_init(port);
return -1;
}
else
{
if ((aasChnl.mgNo >= MGC_MAX_NUM_OF_MG) || (aasChnl.portNo != 0xFF)
|| (aasChnl.chlNo != toneNo) || (aasChnl.connectNo > MGC_MAX_NUM_OF_CON))
{
mgc_log_err("mgc_connect_AAS: apply aas mg fail!\n\r");
mgc_port_init(port);
return -1;
}
else
{
if ((mgcConnectInfo[orgConnectIndex].flag & MGCP_PARA_FLAG_TFO) == MGCP_PARA_FLAG_TFO)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
if (toneNo == 0)
{
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
}
else
{
mgcPort[port].mgcfOperSteps[step].media.conMode = mgcConnectInfo[orgConnectIndex].mediaAttr.conMode;;
}
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = dstChnl;
if (destConnectIndex < MGC_MAX_NUM_OF_CON)
{
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[destConnectIndex].codecList;//orgConnectIndex
}
else
{
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
}
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
chnlIndexAAS = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
aasConnectIndex = mgcChnl[chnlIndexAAS].connectIndex[aasChnl.connectNo];
ptime = mgcConnectInfo[orgConnectIndex].mediaAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_SENDONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].cmd = MGCP_CMD_CRCX;
// mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcMgInfo[orgChnl.mgNo].mgAttr.codecList;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcConnectInfo[orgConnectIndex].aasChnl = aasChnl;
memcpy((BYTE *) &mgcConnectInfo[aasConnectIndex].mediaAttr.sdp, (BYTE *) &mgcConnectInfo[orgConnectIndex].mediaAttr.sdp, sizeof(PUB_SDP_MSG));
if (MGC_MG_TYPE_INTERNAL == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
if (duration == 0)
{
mgcPort[port].mgcfOperSteps[step].delay = MGC_MGCF_TIMER_1H;
}
else
{
mgcPort[port].mgcfOperSteps[step].delay = duration * MGC_MGCF_TIMER_1S;
}
}
mgcPort[port].mgcfOperSteps[step++].chnlConnectIndex = aasChnl.connectNo;
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step].cmd = MGCP_CMD_MDCX;
if (duration == 0)
{
mgcPort[port].mgcfOperSteps[step++].delay = MGC_MGCF_TIMER_1H;
}
else
{
mgcPort[port].mgcfOperSteps[step++].delay = duration * MGC_MGCF_TIMER_1S;
}
}
mgcPort[port].mgcfOperSteps[step].localChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = aasChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_DLCX;
}
}
mgcPort[port].mgcfOperId = MGC_OPER_ID_CONNECT_AAS;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperStepsNum = step;
pConnect = &mgcConnectInfo[orgConnectIndex];
memset(&(pConnect->operRec) , 0 , sizeof(OPER_REC));
pConnect->operRec.operaId = MGC_OPER_ID_CONNECT_AAS;
pConnect->operRec.tone = tone;
pConnect->operRec.duration = duration;
pConnect->operRec.times = times;
sprintf(tmpStr, "mgc_connect_AAS: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, step = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, orgConnectIndex, dstChnl.mgNo, dstChnl.portNo, dstChnl.chlNo, dstChnl.connectNo, destConnectIndex, step);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
int mgc_connect_tone(WORD usrPort, CHNL orgChnl, CHNL dstChnl, BYTE toneNo, WORD duration)
{
int port;
BYTE step = 0, ptime;
WORD orgChl, dstChl;
WORD chnlIndexOrg, chnlIndexDst, phyPortOrg, phyPortDst, associPort;
char tmpStr[256];
CHNL aasChnl = {0xFFFF, 0, 0xFFFF, 0xFFFF};
int orgConnectIndex;
int destConnectIndex;
WORD aasConnectIndex;
WORD chnlIndexAAS;
MGC_CODEC_LIST codecList;
WORD orgAASChnlIndex;
WORD orgAASConnectIndex;
CHNL orgAASChnl;
CONNECT_INFO *pConnect;
BYTE tone;
if ((orgChnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(dstChnl.mgNo >= MGC_MAX_NUM_OF_MG))
{
mgc_log_err("mgc_connect_tone: invalid mgNo!\n\r");
return -1;
}
if ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType != mgcMgInfo[dstChnl.mgNo].mgAttr.ctrlType)
&& ((mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP) || (mgcMgInfo[dstChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)))
{
mgc_log_err("mgc_connect_chnl: mg ctrlType error!\n\r");
return -1;
}
if (toneNo >= MGC_MAX_TONE_NO)
{
mgc_log_err("mgc_connect_tone: invalid toneNo!\n\r");
return -1;
}
tone = toneNo;
if (mgcMgInfo[orgChnl.mgNo].mgAttr.ctrlType == MGC_MG_CTRL_TYPE_8ECP)
{
orgChl = (mgcMgInfo[orgChnl.mgNo].mgAttr.e1cardNo * 8 + orgChnl.portNo) * 32 + orgChnl.chlNo;
if ((0 == dstChnl.mgNo) && (0 == dstChnl.portNo) && (0 == dstChnl.chlNo))
{
dstChl = (mgc_8k_tone_card_silent * 8 + 7) * 32 + 31;
}
else if ((1 == mgcMgInfo[dstChnl.mgNo].created)
&& (1 == mgcPhyPort[mgcMgInfo[dstChnl.mgNo].portIndex[dstChnl.portNo]].created))
{
dstChl = (mgcMgInfo[dstChnl.mgNo].mgAttr.e1cardNo * 8 + dstChnl.portNo) * 32 + dstChnl.chlNo;//need revise
}
else
{
mgc_log_err("mgc_connect_tone: invalid 8ecp mgNo or portNo!\n\r");
return -1;
}
_8ecp_connect_tone(orgChl, dstChl, toneNo, duration);
sprintf(tmpStr, "mgc_connect_tone: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
if ((orgChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG) ||
(dstChnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_connect_tone: invalid portNo!\n\r");
return -1;
}
if ((orgChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON) ||
(dstChnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON))
{
mgc_log_err("mgc_connect_tone: invalid connectNo!\n\r");
return -1;
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType))
{
chnlIndexOrg = mgcMgInfo[orgChnl.mgNo].chnlStartIndex + orgChnl.chlNo;
}
else
{
phyPortOrg = mgcMgInfo[orgChnl.mgNo].portIndex[orgChnl.portNo];
chnlIndexOrg = mgcPhyPort[phyPortOrg].chnlStartIndex + orgChnl.chlNo;
}
if (chnlIndexOrg >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortOrg >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_tone: invalid chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
if (((orgConnectIndex = mgcChnl[chnlIndexOrg].connectIndex[orgChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
|| (mgcConnectInfo[orgConnectIndex].assigned != 1))//new replace
{
if ((orgConnectIndex = mgc_assign_connect_to_chnl(orgChnl)) < 0)
{
mgc_log_err("mgc_connect_tone: assigned connect on orgChnl failed!\n\r");
return -1;
}
}
associPort = mgcConnectInfo[orgConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_tone: orgChnl connection operation overwritten!\n\r");
}
orgAASChnl = mgcConnectInfo[orgConnectIndex].aasChnl;
if ((orgAASChnl.mgNo < MGC_MAX_NUM_OF_MG) && (orgAASChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (orgAASChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
orgAASChnlIndex = mgcMgInfo[orgAASChnl.mgNo].chnlStartIndex + orgAASChnl.chlNo;
if ((orgAASConnectIndex = mgcChnl[orgAASChnlIndex].connectIndex[orgAASChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[orgAASConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_tone: connection aasChnl operation overwritten!\n\r");
}
}
}
associPort = mgcChnl[chnlIndexOrg].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_connect_tone: orgChnl chnl operation overwritten!\n\r");
}
if ((MGC_MG_TYPE_ANN == mgcMgInfo[dstChnl.mgNo].mgAttr.mgType)
|| (MGC_MG_TYPE_INTERNAL == mgcMgInfo[dstChnl.mgNo].mgAttr.mgType))
{
chnlIndexDst = mgcMgInfo[dstChnl.mgNo].chnlStartIndex + dstChnl.chlNo;
}
else
{
phyPortDst = mgcMgInfo[dstChnl.mgNo].portIndex[dstChnl.portNo];
chnlIndexDst = mgcPhyPort[phyPortDst].chnlStartIndex + dstChnl.chlNo;
}
if (chnlIndexDst >= MGC_MAX_NUM_OF_CHNL
|| ((mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL) && (mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPortDst >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_connect_tone: invalid destChnl chnlIndex or phyPort of orgChnl!\n\r");
return -1;
}
destConnectIndex = mgcChnl[chnlIndexDst].connectIndex[dstChnl.connectNo];
if ((mgcConnectInfo[orgConnectIndex].codecList.num == 0)
&& (mgcMgInfo[orgChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcMgInfo[orgChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_tone: mgcConnectInfo[orgConnectIndex].codecList error!\n\n");
return -1;
}
}
if (destConnectIndex < MGC_MAX_NUM_OF_CON)
{
if ((mgcConnectInfo[destConnectIndex].codecList.num == 0)
&& (mgcMgInfo[dstChnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_INTERNAL))
{
if (mgc_match_codec_list(&mgcConnectInfo[destConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList, &mgcMgInfo[dstChnl.mgNo].mgAttr.codecList) < 0)
{
mgc_log_err("mgc_connect_tone: mgcConnectInfo[dstConnectIndex].codecList error!\n\n");
return -1;
}
}
if (mgc_match_codec_list(&codecList, &mgcConnectInfo[orgConnectIndex].codecList, &mgcConnectInfo[destConnectIndex].codecList) < 0)
{
mgc_log_err("mgc_connect_AAS: orgConnect and dstConnect code negotiation fail!\n\n");
return -1;
}
}
else
codecList = mgcConnectInfo[orgConnectIndex].codecList;
if ((port = mgc_get_port()) < 0)
{
mgc_log_err("mgc_connect_tone: port resource not available!\n\r");
return -1;
}
mgcPort[port].usrPort = usrPort;
if (mgcConnectInfo[orgConnectIndex].status != MGC_CONNECT_STATUS_CREATED)
{
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_CRCX;
}
}
else
{
if (mgcConnectInfo[orgConnectIndex].mediaAttr.conMode >= MGCP_CON_MODE_SENDONLY)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = dstChnl;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
if ((destConnectIndex < MGC_MAX_NUM_OF_CON)
&& (mgcConnectInfo[destConnectIndex].status == MGC_CONNECT_STATUS_CREATED))
{
if (mgcConnectInfo[destConnectIndex].mediaAttr.conMode >= MGCP_CON_MODE_SENDONLY)
{
ptime = mgcMgInfo[dstChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = dstChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = dstChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
}
if (mgcMgInfo[orgChnl.mgNo].mgAttr.toneCap == 1)
{
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].cmd = MGCP_CMD_RQNT;
mgcPort[port].mgcfOperSteps[step].pkgSignal = MGC_TONE_NO_TO_PKG_SIG[toneNo];
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
if (duration == 0)
{
mgcPort[port].mgcfOperSteps[step++].delay = MGC_MGCF_TIMER_1H;
}
else
{
mgcPort[port].mgcfOperSteps[step++].delay = duration * MGC_MGCF_TIMER_1S;
}
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].pkgSignal = 0;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_RQNT;
}
else
{
toneNo = toneNo - 7;
if (mgc_apply_aas_tone(&aasChnl, toneNo) < 0)
{
mgc_log_err("mgc_connect_tone: mg no toneCap and no AAS MG!\n\r");
mgc_port_init(port);
return -1;
}
else
{
if ((aasChnl.mgNo >= MGC_MAX_NUM_OF_MG) || (aasChnl.portNo != 0xFF)
|| (aasChnl.chlNo != toneNo) || (aasChnl.connectNo > MGC_MAX_NUM_OF_CON))
{
mgc_log_err("mgc_connect_tone: mg no toneCap and apply aas mg fault!\n\r");
mgc_port_init(port);
return -1;
}
else
{
if ((mgcConnectInfo[orgConnectIndex].flag & MGCP_PARA_FLAG_TFO) == MGCP_PARA_FLAG_TFO)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_RECVONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = dstChnl;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_MDCX;
}
chnlIndexAAS = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
aasConnectIndex = mgcChnl[chnlIndexAAS].connectIndex[aasChnl.connectNo];
ptime = mgcConnectInfo[orgConnectIndex].mediaAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = MGCP_CON_MODE_SENDONLY;
mgcPort[port].mgcfOperSteps[step].localChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].cmd = MGCP_CMD_CRCX;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcConnectInfo[orgConnectIndex].aasChnl = aasChnl;
memcpy((BYTE *) &mgcConnectInfo[aasConnectIndex].mediaAttr.sdp, (BYTE *) &mgcConnectInfo[orgConnectIndex].mediaAttr.sdp, sizeof(PUB_SDP_MSG));
if (MGC_MG_TYPE_INTERNAL == mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
if (duration == 0)
{
mgcPort[port].mgcfOperSteps[step].delay = MGC_MGCF_TIMER_1H;
}
else
{
mgcPort[port].mgcfOperSteps[step].delay = duration * MGC_MGCF_TIMER_1S;
}
}
mgcPort[port].mgcfOperSteps[step++].chnlConnectIndex = aasChnl.connectNo;
if (MGC_MG_TYPE_INTERNAL != mgcMgInfo[orgChnl.mgNo].mgAttr.mgType)
{
ptime = mgcMgInfo[orgChnl.mgNo].mgAttr.ptime;
mgcPort[port].mgcfOperSteps[step].media.ptime = ptime;
mgcPort[port].mgcfOperSteps[step].media.conMode = mgcConnectInfo[orgConnectIndex].mediaAttr.conMode;
mgcPort[port].mgcfOperSteps[step].localChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = orgChnl.connectNo;
mgcPort[port].mgcfOperSteps[step].media.vocoderType = mgcConnectInfo[orgConnectIndex].codecList;
mgcPort[port].mgcfOperSteps[step].cmd = MGCP_CMD_MDCX;
if (duration == 0)
{
mgcPort[port].mgcfOperSteps[step++].delay = MGC_MGCF_TIMER_1H;
}
else
{
mgcPort[port].mgcfOperSteps[step++].delay = duration * MGC_MGCF_TIMER_1S;
}
}
mgcPort[port].mgcfOperSteps[step].localChnl = aasChnl;
mgcPort[port].mgcfOperSteps[step].remChnl = orgChnl;
mgcPort[port].mgcfOperSteps[step].chnlConnectIndex = aasChnl.connectNo;
mgcPort[port].mgcfOperSteps[step++].cmd = MGCP_CMD_DLCX;
}
}
}
mgcPort[port].mgcfOperId = MGC_OPER_ID_CONNECT_TONE;
mgcPort[port].mgcfState = MGC_MGCF_STATE_REQUEST;
mgcPort[port].mgcfOperStepsNum = step;
pConnect = &mgcConnectInfo[orgConnectIndex];
memset(&(pConnect->operRec) , 0 , sizeof(OPER_REC));
pConnect->operRec.operaId = MGC_OPER_ID_CONNECT_TONE;
pConnect->operRec.tone = tone;
pConnect->operRec.duration = duration;
sprintf(tmpStr, "mgc_connect_tone: succeed, usrPort = %d, Org: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, Dest: mgNo = %d, portNo = %d, chnlNo = %d, connectNo = %d, connectIndex = %d, step = %d\n\r",
usrPort, orgChnl.mgNo, orgChnl.portNo, orgChnl.chlNo, orgChnl.connectNo, orgConnectIndex, dstChnl.mgNo, dstChnl.portNo, dstChnl.chlNo, dstChnl.connectNo, destConnectIndex, step);
mgc_log_procedure(orgChnl.mgNo, phyPortOrg, chnlIndexOrg, tmpStr);
return 0;
}
int mgc_query_mg_status(WORD mgNo)
{
if (mgNo >= MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_query_mg_status: invalid mgNo!\n\r");
return -1;
}
return mgcMgInfo[mgNo].status;
}
int mgc_query_port_status(WORD mgNo, BYTE portNo)
{
if ((mgNo >= MGC_MAX_NUM_OF_MG) ||
(portNo >= MGC_MAX_PHY_PORT_PER_MG) || (0 == mgcPhyPort[mgcMgInfo[mgNo].portIndex[portNo]].created))
{
mgc_log_err("mgc_query_port_status: invalid mgNo or portNo!\n\r");
return 0;
}
return mgcPhyPort[mgcMgInfo[mgNo].portIndex[portNo]].phyStatus;
}
int mgc_query_channel_status(CHNL chnl)
{
if ((chnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_query_channel_status: invalid mgNo or portNo!\n\r");
return -1;
}
return mgcChnl[mgcPhyPort[mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo]].chnlStartIndex + chnl.chlNo].status;
}
int mgc_create_virtual_chnl(WORD port, CHNL *chnl)
{
int chnlIndex;
char tmpStr[128];
chnl->mgNo = MGC_INTERNAL_VIRTUAL_MG;
chnl->portNo = 0;
if ((chnlIndex = mgc_assign_chnl(0xFF, MGC_INTERNAL_VIRTUAL_MG, 0xFF, MGC_MG_TYPE_INTERNAL)) < 0)
{
mgc_log_err("mgc_create_virtual_chnl: can't allocate virtual channel!\n\r");
return -1;
}
chnl->chlNo = chnlIndex - mgcMgInfo[chnl->mgNo].chnlStartIndex;
if (mgc_assign_connect_to_chnl(*chnl) < 0)
{
mgc_log_err("mgc_create_virtual_chnl: can't allocate connect!\n\r");
return -1;
}
sprintf(tmpStr, "mgc_create_virtual_chnl: succeed, usrPort = %d, assigned chnlIndex = %d\n\r", port, chnlIndex);
mgc_log_procedure(chnl->mgNo, 0xFFFF, chnlIndex, tmpStr);
// mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_release_virtual_chnl(WORD port, CHNL chnl)
{
WORD chnlIndex;
char tmpStr[128];
int connectIndex;
WORD associPort;
WORD aasChnlIndex;
WORD aasConnectIndex;
CHNL aasChnl;
if ((chnl.mgNo != MGC_INTERNAL_VIRTUAL_MG) ||
(chnl.portNo != 0))
{
mgc_log_err("mgc_release_virtual_chnl: invalid mgNo or portNo!\n\r");
return -1;
}
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
if ((connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
aasChnl = mgcConnectInfo[connectIndex].aasChnl;
if ((aasChnl.mgNo < MGC_MAX_NUM_OF_MG) && (aasChnl.chlNo < MGC_MAX_NUM_OF_CHNL)
&& (aasChnl.connectNo < MGC_MAX_NUM_OF_CHNL_CON))
{
aasChnlIndex = mgcMgInfo[aasChnl.mgNo].chnlStartIndex + aasChnl.chlNo;
if ((aasConnectIndex = mgcChnl[aasChnlIndex].connectIndex[aasChnl.connectNo]) < MGC_MAX_NUM_OF_CON)
{
associPort = mgcConnectInfo[aasConnectIndex].port;
if ((associPort < MGC_MAX_NUM_OF_PORT)
&& (mgcPort[associPort].assigned != 0))
{
mgcPort[associPort].mngCmd = MGC_MNG_CMD_OVERWRITE;
mgc_log_err("mgc_release_virtual_chnl: connection aasChnl operation overwritten!\n\r");
}
}
}
}
else
{
mgc_log_err("mgc_release_virtual_chnl: invalid connectIndex!\n\r");
}
mgc_remove_chnl(chnlIndex, MGC_CHNL_NUM_INTERNAL_PER_PORT);
sprintf(tmpStr, "mgc_release_virtual_chnl: succeed, usrPort = %d, chnlIndex = %d\n\r", port, chnlIndex);
mgc_log_procedure(chnl.mgNo, 0xFFFF, chnlIndex, tmpStr);
// mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_query_chnl_media(WORD port, CHNL chnl, PUB_SDP_MSG **mediaInfo, BYTE *mgPayloads, BYTE *mgPlNum)
{
WORD phyPort, chnlIndex;
WORD connectIndex;
int i;
char tmpStr[128];
if ((chnl.mgNo >= MGC_MAX_NUM_OF_MG) ||
(chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG))
{
mgc_log_err("mgc_query_chnl_media: invalid mgNo or portNo!\n\r");
return -1;
}
if (mgcMgInfo[chnl.mgNo].mgAttr.mgType == MGC_MG_TYPE_INTERNAL)
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
else
{
phyPort = mgcMgInfo[chnl.mgNo].portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
{
return -1;
}
if ((mgcConnectInfo[connectIndex].status != MGC_CONNECT_STATUS_CREATED)&&(mgcConnectInfo[connectIndex].status != MGC_CONNECT_STATUS_TONE))
// if (mgcChnl[chnlIndex].status != MGC_CHNL_STATUS_CREATED)
return -1;
*mediaInfo = &mgcConnectInfo[connectIndex].mediaAttr.sdp;
for (i = 0; i < mgcConnectInfo[connectIndex].codecList.num; i++)
{
mgPayloads[i] = mgc_codec_to_payload(mgcConnectInfo[connectIndex].codecList.codec[i]);
}
*mgPlNum = mgcConnectInfo[connectIndex].codecList.num;
// *mediaInfo = &mgcChnl[chnlIndex].mediaAttr.sdp;
sprintf(tmpStr, "mgc_query_chnl: rtpmap=%s\n\r", (*mediaInfo)->medias.medias[0].attrs.attrs[0].aValue);
mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_payload_to_codec(WORD payload, PUB_SDP_ATTRS attrs)
{
BYTE i = 0;
if (attrs.num > 0)
{
for (i = 0; i < attrs.num; i++)
{
if (attrs.attrs[i].aType != PUB_SDP_ATTR_TYPE_RTPMAP)
{
continue;
}
if (strtol(attrs.attrs[i].aValue, NULL, 10) == payload)
{
if (strstr(attrs.attrs[i].aValue, " GSM/") != NULL)
return MGC_VCTYPE_GSM;
else if (strstr(attrs.attrs[i].aValue, "GSM-EFR") != NULL)
return MGC_VCTYPE_GSM_EFR;
else if (strstr(attrs.attrs[i].aValue, "AMR") != NULL)
return MGC_VCTYPE_AMR_12_2;
else if (strstr(attrs.attrs[i].aValue, "G729B") != NULL)
return MGC_VCTYPE_G729B;
else if (strstr(attrs.attrs[i].aValue, "PCMU") != NULL)
return MGC_VCTYPE_PCMU;
else if (strstr(attrs.attrs[i].aValue, "AMR_12_2") != NULL)
return MGC_VCTYPE_AMR_12_2;
else if (strstr(attrs.attrs[i].aValue, "AMR_10_2") != NULL)
return MGC_VCTYPE_AMR_10_2;
else if (strstr(attrs.attrs[i].aValue, "AMR_7_95") != NULL)
return MGC_VCTYPE_AMR_7_95;
else if (strstr(attrs.attrs[i].aValue, "AMR_7_4") != NULL)
return MGC_VCTYPE_AMR_7_4;
else if (strstr(attrs.attrs[i].aValue, "AMR_6_7") != NULL)
return MGC_VCTYPE_AMR_6_7;
else if (strstr(attrs.attrs[i].aValue, "AMR_5_15") != NULL)
return MGC_VCTYPE_AMR_5_15;
else if (strstr(attrs.attrs[i].aValue, "AMR_5_9") != NULL)
return MGC_VCTYPE_AMR_5_9;
else if (strstr(attrs.attrs[i].aValue, "AMR_4_75") != NULL)
return MGC_VCTYPE_AMR_4_75;
else
return MGC_VCTYPE_PCMA;
}
}
}
if (i == attrs.num)
{
if (payload == 3)
return MGC_VCTYPE_GSM;
else if (payload == 84)
return MGC_VCTYPE_GSM_EFR;
else if (payload == 118)
return MGC_VCTYPE_G729B;
else if (payload == 0)
return MGC_VCTYPE_PCMU;
else if (payload == 71)
return MGC_VCTYPE_AMR_12_2;
else if (payload == 70)
return MGC_VCTYPE_AMR_10_2;
else if (payload == 69)
return MGC_VCTYPE_AMR_7_95;
else if (payload == 68)
return MGC_VCTYPE_AMR_7_4;
else if (payload == 67)
return MGC_VCTYPE_AMR_6_7;
else if (payload == 65)
return MGC_VCTYPE_AMR_5_15;
else if (payload == 66)
return MGC_VCTYPE_AMR_5_9;
else if (payload == 64)
return MGC_VCTYPE_AMR_4_75;
}
return MGC_VCTYPE_PCMA;
}
int mgc_update_chnl_media(WORD port, CHNL chnl, PUB_SDP_MSG *mediaInfo)
{
WORD chnlIndex;
BYTE i;
WORD connectIndex;
BYTE ptime;
char tmpStr[128];
if ((chnl.mgNo != MGC_INTERNAL_VIRTUAL_MG) ||
(chnl.portNo != 0))
{
mgc_log_err("mgc_update_chnl_media: invalid mgNo or portNo!\n\r");
return -1;
}
chnlIndex = mgcMgInfo[chnl.mgNo].chnlStartIndex + chnl.chlNo;
connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo];
if (connectIndex > MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_update_chnl_media: invalid chnl connectNo!\n\r");
return -1;
}
memcpy((BYTE *) &mgcConnectInfo[connectIndex].mediaAttr.sdp, mediaInfo, sizeof(PUB_SDP_MSG));
// memcpy((BYTE *) &mgcChnl[chnlIndex].mediaAttr.sdp, mediaInfo, sizeof(PUB_SDP_MSG));
mgcConnectInfo[connectIndex].codecList.num = mediaInfo->medias.medias[0].m.plNum;
for (i = 0; i < mgcConnectInfo[connectIndex].codecList.num; i++)
{
mgcConnectInfo[connectIndex].codecList.codec[i] = mgc_payload_to_codec(mediaInfo->medias.medias[0].m.payloads[i], mediaInfo->medias.medias[0].attrs);
}
mgcConnectInfo[connectIndex].codecList.priority = 256;
if (chnl.mgNo == MGC_MG_TYPE_INTERNAL)
{
mgcMgInfo[chnl.mgNo].mgAttr.codecList.num = mediaInfo->medias.medias[0].m.plNum;
for (i = 0; i < mgcConnectInfo[connectIndex].codecList.num; i++)
{
mgcMgInfo[chnl.mgNo].mgAttr.codecList.codec[i] = mgcConnectInfo[connectIndex].codecList.codec[i];
}
}
for (i = 0; i < mediaInfo->medias.medias[0].attrs.num; i++)
{
if (mediaInfo->medias.medias[0].attrs.attrs[i].aType == PUB_SDP_ATTR_TYPE_PTIME)
{
ptime = atoi(mediaInfo->medias.medias[0].attrs.attrs[0].aValue);
break;
}
}
if (i == mediaInfo->medias.medias[0].attrs.num)
ptime = 20;
mgcConnectInfo[connectIndex].mediaAttr.ptime = ptime;
if (MGC_MG_TYPE_INTERNAL == mgcMgInfo[chnl.mgNo].mgAttr.mgType)
{
// mgcChnl[chnl.chlNo].status = MGC_CHNL_STATUS_CREATED;
mgcConnectInfo[connectIndex].status = MGC_CONNECT_STATUS_CREATED;
}
// mgcChnl[chnlIndex].codecList.num = mediaInfo->medias.medias[0].m.plNum;
// for (i = 0; i < mgcChnl[chnlIndex].codecList.num; i++)
// mgcChnl[chnlIndex].codecList.codec[i] = mgc_payload_to_codec(mediaInfo->medias.medias[0].m.payloads[i]);
// mgcChnl[chnlIndex].codecList.priority = 1;
sprintf(tmpStr, "mgc_update_chnl_media: codec=%d, connectIndex=%d\n\r", mgcConnectInfo[connectIndex].codecList.codec[0], connectIndex);
mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_license_ctrl(WORD maxMgNum, WORD maxChnlNum)
{
char tmpStr[128];
if ((maxMgNum > MGC_MAX_NUM_OF_MG) ||
(maxChnlNum > MGC_MAX_NUM_OF_CHNL))
{
mgc_log_err("mgc_license_ctrl: invalid maxMgNum or maxChnlNum!\n\r");
return -1;
}
mgcMaxMgNo = maxMgNum;
mgcMaxChlNo = maxChnlNum;
sprintf(tmpStr, "mgc_license_ctrl: succeed, mgcMaxMgNo = %d, mgcMaxChlNo = %d\n\r", mgcMaxMgNo, mgcMaxChlNo);
mgc_asciout_proc(tmpStr);
return 0;
}
int mgc_rsp(BYTE cmd, WORD usrPort, WORD port, WORD retCode, MEDIA_ATTR *mediaAttr)
{
WORD portIndex;
WORD chnlIndex;
PORT_INFO *portInfo;
char tmpStr[128];
int connectIndex;
if ((port >= MGC_MAX_NUM_OF_PORT) ||
((cmd != MGCP_CMD_CRCX) && (mgcPort[port].usrPort != usrPort)) ||
(mgcPort[port].llCmd != cmd))
{
mgc_log_err("mgc_rsp: invalid port or cmd!\n\r");
return -1;
}
portInfo = &mgcPort[port];
if (MGC_MG_TYPE_ANN == mgcMgInfo[portInfo->mgcfChnl.mgNo].mgAttr.mgType)
{
chnlIndex = mgcMgInfo[portInfo->mgcfChnl.mgNo].chnlStartIndex + portInfo->mgcfChnl.chlNo;
}
else
{
portIndex = mgcMgInfo[portInfo->mgcfChnl.mgNo].portIndex[portInfo->mgcfChnl.portNo];
chnlIndex = mgcPhyPort[portIndex].chnlStartIndex + portInfo->mgcfChnl.chlNo;
}
if ((cmd == MGCP_CMD_CRCX) && (retCode == 200))
{
if ((connectIndex = mgcChnl[chnlIndex].connectIndex[portInfo->mgcfChnl.connectNo]) >= MGC_MAX_NUM_OF_CON)
{
mgc_log_err("mgc_rsp: CRCX invalid connectIndex!\n\r");
return -1;
}
sprintf(mgcConnectInfo[connectIndex].mediaAttr.conId, "%X%04X%lX", portInfo->mgcfChnl.connectNo, usrPort, time(NULL));
// memcpy((BYTE *) &mgcChnl[chnlIndex].mediaAttr.sdp, (BYTE *) mediaAttr, sizeof(PUB_SDP_MSG));
memcpy((BYTE *) &mgcConnectInfo[connectIndex].mediaAttr.sdp, (BYTE *) &mediaAttr->sdp, sizeof(PUB_SDP_MSG));
}
mgcPort[port].usrCmd = retCode;
sprintf(tmpStr, "mgc_rsp: succeed, usrPort = %d, port = %d, retCode = %d, cmd = %d\n\r", usrPort, port, retCode, cmd);
mgc_log_procedure(portInfo->mgcfChnl.mgNo, portIndex, chnlIndex, tmpStr);
return 0;
}
/*
Parameter
chnl: the chnl need to update codec
codecList: the codec up layer support
Result
failure: return -1
sucess : return 0~6 which is represent following codec
#define MGC_VCTYPE_PCMA 0
#define MGC_VCTYPE_PCMU 1
#define MGC_VCTYPE_GSM 2
#define MGC_VCTYPE_GSM_EFR 3
#define MGC_VCTYPE_AMR 4
#define MGC_VCTYPE_G729B 5
#define MGC_VCTYPE_AMR_7_4 6
*/
int mgc_chnl_codec_update(CHNL chnl , MGC_CODEC_LIST codecList)
{
MG_INFO *pMgInfo;
WORD chnlIndex, phyPort;
int connectIndex;
MGC_CODEC_LIST codecListMg;
MGC_CODEC_LIST codecListResult;
BYTE codec;
CONNECT_INFO *pConn = NULL;
int i,j;
if(chnl.mgNo > MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_chnl_codec_update: invalid mgNo!\n\r");
return -1;
}
pMgInfo = &mgcMgInfo[chnl.mgNo];
if(pMgInfo->mgAttr.ctrlType != MGC_MG_CTRL_TYPE_MGCP)
return -1;
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_chnl_codec_update: invalid portNo!\n\r");
return -1;
}
if (chnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_chnl_codec_update: invalid connectNo!\n\r");
return -1;
}
if ((MGC_MG_TYPE_ANN == pMgInfo->mgAttr.mgType)||(MGC_MG_TYPE_INTERNAL == pMgInfo->mgAttr.mgType))
{
chnlIndex = pMgInfo->chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = pMgInfo->portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
if ((chnlIndex >= MGC_MAX_NUM_OF_CHNL)
|| ((mgcMgInfo[chnl.mgNo].mgAttr.mgType != MGC_MG_TYPE_ANN) && (phyPort >= MGC_MAX_NUM_OF_PHY_PORT)))
{
mgc_log_err("mgc_chnl_codec_update: invalid chnlIndex or phyPort!\n\r");
return -1;
}
if((mgcChnl[chnlIndex].connectIndex[chnl.connectNo] >= MGC_MAX_NUM_OF_CON)||
((mgcConnectInfo[mgcChnl[chnlIndex].connectIndex[chnl.connectNo]].assigned != 1)))
{
connectIndex = mgc_assign_connect_to_chnl(chnl);
if(connectIndex < 0)
return -1;
}
else
{
connectIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo];
}
pConn = &mgcConnectInfo[connectIndex];
memset(&codecListResult , 0 , sizeof(MGC_CODEC_LIST));
memcpy(&codecListMg , &pMgInfo->mgAttr.codecList , sizeof(MGC_CODEC_LIST));
codecListMg.priority = codecList.priority + 1;
for(i=0 ; i<codecListMg.num ; i++)
{
codec = codecListMg.codec[i];
for(j=0 ; j<codecList.num ; j++)
{
switch(codec)
{
case MGC_VCTYPE_AMR_12_2:
case MGC_VCTYPE_AMR_10_2:
if(codecList.codec[j] == MGC_VCTYPE_AMR_12_2)
{
codecListResult.codec[codecListResult.num] = codec;
codecListResult.num++;
}
break;
case MGC_VCTYPE_AMR_7_95:
case MGC_VCTYPE_AMR_7_4:
case MGC_VCTYPE_AMR_6_7:
case MGC_VCTYPE_AMR_5_15:
case MGC_VCTYPE_AMR_5_9:
case MGC_VCTYPE_AMR_4_75:
if((codecList.codec[j] == MGC_VCTYPE_AMR_12_2)||(codecList.codec[j] == MGC_VCTYPE_AMR_7_95))
{
codecListResult.codec[codecListResult.num] = codec;
codecListResult.num++;
}
break;
default:
if(codecList.codec[j] == codec)
{
codecListResult.codec[codecListResult.num] = codec;
codecListResult.num++;
}
break;
}
}
}
if(codecListResult.num == 0)
return -1;
if(pMgInfo->mgAttr.mgType == MGC_MG_TYPE_IPBSS)
memcpy(&pConn->codecList , &codecListResult , sizeof(MGC_CODEC_LIST));
switch(codecListResult.codec[0])
{
case MGC_VCTYPE_AMR_12_2:
case MGC_VCTYPE_AMR_10_2:
return MGC_VCTYPE_AMR_12_2;
case MGC_VCTYPE_AMR_7_95:
case MGC_VCTYPE_AMR_7_4:
case MGC_VCTYPE_AMR_6_7:
case MGC_VCTYPE_AMR_5_15:
case MGC_VCTYPE_AMR_5_9:
case MGC_VCTYPE_AMR_4_75:
return MGC_VCTYPE_AMR_7_95;
default:
return codecListResult.codec[0];
}
return -1;
}
/*
Parameter
chnl: the chnl need to be queried
Result:
failure: return -1
success: return 0~3 which represent following status
#define MGC_CONNECT_STATUS_IDLE 0
#define MGC_CONNECT_STATUS_CREATING 1
#define MGC_CONNECT_STATUS_CREATED 2
#define MGC_CONNECT_STATUS_TONE 3
*/
int mgc_query_chnl_status(CHNL chnl)
{
MG_INFO *pMgInfo;
WORD chnlIndex, phyPort , connIndex;
if(chnl.mgNo > MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_query_chnl_status: invalid mgNo!\n\r");
return -1;
}
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_query_chnl_status: invalid portNo!\n\r");
return -1;
}
if (chnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_query_chnl_status: invalid connectNo!\n\r");
return -1;
}
pMgInfo = &mgcMgInfo[chnl.mgNo];
if ((MGC_MG_TYPE_ANN == pMgInfo->mgAttr.mgType)||(MGC_MG_TYPE_INTERNAL == pMgInfo->mgAttr.mgType))
{
chnlIndex = pMgInfo->chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = pMgInfo->portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
connIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo];
if(connIndex > MGC_MAX_NUM_OF_CON)
return -1;
return(mgcConnectInfo[connIndex].status);
}
OPER_REC *mgc_query_chnl_oper_rec(CHNL chnl)
{
MG_INFO *pMgInfo;
WORD chnlIndex, phyPort , connIndex;
if(chnl.mgNo > MGC_MAX_NUM_OF_MG)
{
mgc_log_err("mgc_query_chnl_status: invalid mgNo!\n\r");
return NULL;
}
if (chnl.portNo >= MGC_MAX_PHY_PORT_PER_MG)
{
mgc_log_err("mgc_query_chnl_status: invalid portNo!\n\r");
return NULL;
}
if (chnl.connectNo >= MGC_MAX_NUM_OF_CHNL_CON)
{
mgc_log_err("mgc_query_chnl_status: invalid connectNo!\n\r");
return NULL;
}
pMgInfo = &mgcMgInfo[chnl.mgNo];
if ((MGC_MG_TYPE_ANN == pMgInfo->mgAttr.mgType)||(MGC_MG_TYPE_INTERNAL == pMgInfo->mgAttr.mgType))
{
chnlIndex = pMgInfo->chnlStartIndex + chnl.chlNo;
}
else
{
phyPort = pMgInfo->portIndex[chnl.portNo];
chnlIndex = mgcPhyPort[phyPort].chnlStartIndex + chnl.chlNo;
}
connIndex = mgcChnl[chnlIndex].connectIndex[chnl.connectNo];
if(connIndex > MGC_MAX_NUM_OF_CON)
return NULL;
return &(mgcConnectInfo[connIndex].operRec);
}
Reference in New Issue View Git Blame Copy Permalink