1375 lines
40 KiB
C
1375 lines
40 KiB
C
/*
|
|
*********************************************************************************
|
|
* *
|
|
* NOTICE: *
|
|
* *
|
|
*********************************************************************************
|
|
* ++++++++++++++++++++++++++++++++++
|
|
* + +
|
|
* + +
|
|
* target -------> + recv endpoint <-------------->send enpoint + <--------------associator
|
|
* + | | +
|
|
* + | | +
|
|
* + | | +
|
|
* + +
|
|
* + tandem objec +
|
|
* ++++++++++++++++++++++++++++++++++
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*********************************************************************************
|
|
* <mgc_tandem_info.c>
|
|
* This file should provide rtp_proxy related object APIs
|
|
*
|
|
* Author Date
|
|
* ------ ------
|
|
* Sam Yao Aug 2008
|
|
*********************************************************************************/
|
|
|
|
|
|
#include "./include/mgc_tandem_info.h"
|
|
#include "./include/mgc_debug.h"
|
|
#include "./include/mgc_conn_info.h"
|
|
#include "./include/mgc_chnl_info.h"
|
|
#include "./include/mgc_phy_port.h"
|
|
#include "./include/mgc_mgcp.h"
|
|
#include "./include/mgc_mg_info.h"
|
|
#include "./include/mgc_port_info.h"
|
|
#include "./include/mgc_sur_info.h"
|
|
static MGC_TANDEM_INFO mgcTandem[MGC_MAX_NUM_OF_TANDEM];
|
|
static CONNECT_INFO mgcTandConn[MGC_MAX_NUM_OF_TANDEM_CONN];
|
|
static CHNL_INFO mgcTandChnl[MGC_MAX_NUM_OF_TANDEM_CHNL];
|
|
static PHY_PORT_INFO mgcTandPort[MGC_MAX_NUM_OF_RTP_PROXY_NUM];
|
|
|
|
|
|
extern MGC_SAP *mgc_sap_get_index_sap(int index);
|
|
|
|
MGC_TANDEM_STATUS mgc_tandem_info_get_status(MGC_TANDEM_INFO *pTandem)
|
|
{
|
|
if(pTandem == NULL)
|
|
return MGC_TANDEM_STATUS_UNDEF;
|
|
|
|
return pTandem->status;
|
|
}
|
|
|
|
void mgc_tandem_info_set_status(MGC_TANDEM_INFO *pTandem , MGC_TANDEM_STATUS status)
|
|
{
|
|
if((pTandem == NULL)||(status == MGC_TANDEM_STATUS_UNDEF))
|
|
return;
|
|
|
|
pTandem->status = status;
|
|
}
|
|
|
|
CONNECT_INFO *mgc_tandem_info_get_unattached_conn(void)
|
|
{
|
|
CONNECT_INFO *pConnect = NULL;
|
|
int i;
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_TANDEM_CONN ; i++)
|
|
{
|
|
pConnect = &mgcTandConn[i];
|
|
|
|
if(pConnect->pTandem != NULL)
|
|
continue;
|
|
|
|
return pConnect;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_conn_rec_tandem(CONNECT_INFO *pConnect , MGC_TANDEM_INFO *pTandem)
|
|
{
|
|
if((pConnect == NULL) || (pTandem == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem != NULL)
|
|
{
|
|
MGC_ERROR("conn[%d] already attached to tandem[%d]!" , pConnect->id, pConnect->pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
pConnect->pTandem = pTandem;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_unset_conn(MGC_TANDEM_INFO *pTandem , CONNECT_INFO *pConnect)
|
|
{
|
|
if((pTandem == NULL)||(pConnect == NULL))
|
|
return FALSE;
|
|
|
|
if(pTandem->pAconn == pConnect)
|
|
{
|
|
pTandem->pAconn = NULL;
|
|
MGC_DEBUG("tandem[%d] unset aor conn[%d]!" , pTandem->id, pConnect->id);
|
|
}
|
|
else if(pTandem->pTconn == pConnect)
|
|
{
|
|
pTandem->pTconn = NULL;
|
|
MGC_DEBUG("tandem[%d] unset tar conn[%d]!" , pTandem->id, pConnect->id);
|
|
}
|
|
else if(pTandem->pTxconn == pConnect)
|
|
{
|
|
pTandem->pTxconn = NULL;
|
|
MGC_WARN("tandem[%d] tx is removed!" , pTandem->id);
|
|
}
|
|
else if(pTandem->pRxconn == pConnect)
|
|
{
|
|
pTandem->pRxconn = NULL;
|
|
MGC_WARN("tandem[%d] rx is removed!" , pTandem->id);
|
|
}
|
|
else if(mgc_sur_info_remove_conn_to_list(&pTandem->list, pConnect) != FALSE)
|
|
{
|
|
MGC_DEBUG("tandem[%d] remove sur conn[%d]" , pTandem->id , pConnect->id);
|
|
}
|
|
pConnect->pTandem = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_set_conn(MGC_TANDEM_INFO *pTandem , CONNECT_INFO *pConnect, MGC_TANDEM_CONN_POS pos)
|
|
{
|
|
BOOL result = FALSE;
|
|
|
|
if((pTandem == NULL)||(pConnect== NULL)||(pos == MGC_TANDEM_CONN_POS_UNDEF))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem != NULL)
|
|
{
|
|
MGC_ERROR("conn[%d] already attached to tandem[%d]!" , pConnect->id, pConnect->pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
switch(pos)
|
|
{
|
|
case MGC_TANDEM_CONN_POS_TAR:
|
|
if(pTandem->pTconn != NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] already have target conn[%d]!" , pTandem->id, pTandem->pTconn->id);
|
|
break;
|
|
}
|
|
if(mgc_tandem_info_conn_rec_tandem(pConnect, pTandem) == TRUE)
|
|
{
|
|
pTandem->pTconn = pConnect;
|
|
result = TRUE;
|
|
MGC_DEBUG("tandem[%d] set tar conn[%d]", pTandem->id, pConnect->id);
|
|
}
|
|
mgc_tandem_info_set_status(pTandem, MGC_TANDEM_STATUS_USED);
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_TX:
|
|
if(pTandem->pTxconn != NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] already have tx conn[%d]!" , pTandem->id, pTandem->pTxconn->id);
|
|
break;
|
|
}
|
|
if(mgc_tandem_info_conn_rec_tandem(pConnect, pTandem) == TRUE)
|
|
{
|
|
pTandem->pTxconn = pConnect;
|
|
result = TRUE;
|
|
// MGC_DEBUG("tandem[%d] set tx conn[%d]", pTandem->id, pConnect->id);
|
|
}
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_RX:
|
|
if(pTandem->pRxconn != NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] already have rx conn[%d]!" , pTandem->id, pTandem->pRxconn->id);
|
|
break;
|
|
}
|
|
if(mgc_tandem_info_conn_rec_tandem(pConnect, pTandem) == TRUE)
|
|
{
|
|
pTandem->pRxconn = pConnect;
|
|
result = TRUE;
|
|
// MGC_DEBUG("tandem[%d] set rx conn[%d]", pTandem->id, pConnect->id);
|
|
}
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_AOR:
|
|
if(pTandem->pAconn != NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] already have associator conn[%d]!" , pTandem->id, pTandem->pAconn->id);
|
|
break;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_status(pTandem) == MGC_TANDEM_STATUS_IDLE)
|
|
{
|
|
MGC_ERROR("tandem[%d] should not set aorConn[%d] fisrt" , pTandem->id , pConnect->id);
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
if(mgc_tandem_info_conn_rec_tandem(pConnect, pTandem) == TRUE)
|
|
{
|
|
pTandem->pAconn = pConnect;
|
|
result = TRUE;
|
|
MGC_DEBUG("tandem[%d] set aor conn[%d]", pTandem->id, pConnect->id);
|
|
}
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_SUR:
|
|
MGC_DEBUG("try find conn[%d] in tandem[%d] list" , pConnect->id , pTandem->id);
|
|
if(mgc_sur_info_find_conn_in_list(&pTandem->list, pConnect) != NULL)
|
|
{
|
|
result = TRUE;
|
|
MGC_DEBUG("tandem[%d] already has sur conn[%d]" , pTandem->id , pConnect->id);
|
|
break;
|
|
}
|
|
if(mgc_tandem_info_conn_rec_tandem(pConnect, pTandem) == FALSE)
|
|
break;
|
|
if(mgc_sur_info_add_conn_to_list(&pTandem->list, pConnect) == TRUE)
|
|
{
|
|
result = TRUE;
|
|
MGC_DEBUG("tandem[%d] add sur conn[%d]" , pTandem->id , pConnect->id);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
return result;
|
|
}
|
|
|
|
pConnect->pTandem = pTandem;
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
|
|
MGC_TANDEM_CONN_POS mgc_tandem_info_get_conn_pos(MGC_TANDEM_INFO *pTandem , CONNECT_INFO *pConnect)
|
|
{
|
|
MGC_TANDEM_CONN_POS pos = MGC_TANDEM_CONN_POS_UNDEF;
|
|
|
|
|
|
if((pTandem == NULL) || (pConnect == NULL))
|
|
return MGC_TANDEM_CONN_POS_UNDEF;
|
|
|
|
if(pTandem->pTconn == pConnect)
|
|
{
|
|
pos = MGC_TANDEM_CONN_POS_TAR;
|
|
}
|
|
else if(pTandem->pTxconn == pConnect)
|
|
{
|
|
pos = MGC_TANDEM_CONN_POS_TX;
|
|
}
|
|
else if(pTandem->pRxconn == pConnect)
|
|
{
|
|
pos = MGC_TANDEM_CONN_POS_RX;
|
|
}
|
|
else if(pTandem->pAconn == pConnect)
|
|
{
|
|
pos = MGC_TANDEM_CONN_POS_AOR;
|
|
}
|
|
else if(mgc_sur_info_find_conn_in_list(&pTandem->list,pConnect) != NULL)
|
|
{
|
|
pos = MGC_TANDEM_CONN_POS_SUR;
|
|
}
|
|
|
|
if(pos != MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
if(pTandem != pConnect->pTandem)
|
|
{
|
|
MGC_ERROR(" conn[%d] do not bleong to tandem[%d]" , pConnect->id , pTandem->id);
|
|
pos = MGC_TANDEM_CONN_POS_UNDEF;
|
|
}
|
|
}
|
|
|
|
return pos;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_init(MGC_TANDEM_INFO *pTandem , int id)
|
|
{
|
|
CONNECT_INFO *pConn = NULL;
|
|
MGCP_PARA mgcpPara;
|
|
|
|
if(pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem->id = id;
|
|
pTandem->pTconn = NULL;
|
|
pTandem->pAconn = NULL;
|
|
|
|
if(pTandem->pRxconn != NULL)
|
|
{
|
|
if((mgc_connect_get_status(pTandem->pRxconn) == MGC_CONNECT_STATUS_CREATED)||(mgc_connect_get_status(pTandem->pRxconn) == MGC_CONNECT_STATUS_CREATE))
|
|
{
|
|
if(mgc_connect_dlcx_para_create(pTandem->pRxconn , &mgcpPara) == TRUE)
|
|
MGCP_req(mgc_mgcp_get_sap_index(), MGCP_CMD_DLCX , 0xFFFF , &mgcpPara);
|
|
}
|
|
mgc_tandem_info_unset_conn(pTandem,pTandem->pRxconn);
|
|
mgc_chnl_info_detach_connect(pTandem->pRxconn->pChnlInfo,pTandem->pRxconn);
|
|
mgc_connect_init(pTandem->pRxconn , pTandem->pRxconn->id);
|
|
}
|
|
|
|
if(pTandem->pTxconn != NULL)
|
|
{
|
|
if((mgc_connect_get_status(pTandem->pTxconn) == MGC_CONNECT_STATUS_CREATED)||(mgc_connect_get_status(pTandem->pTxconn) == MGC_CONNECT_STATUS_CREATE))
|
|
{
|
|
if(mgc_connect_dlcx_para_create(pTandem->pTxconn , &mgcpPara) == TRUE)
|
|
MGCP_req(mgc_mgcp_get_sap_index(), MGCP_CMD_DLCX , 0xFFFF , &mgcpPara);
|
|
}
|
|
mgc_tandem_info_unset_conn(pTandem,pTandem->pTxconn);
|
|
mgc_chnl_info_detach_connect(pTandem->pTxconn->pChnlInfo,pTandem->pTxconn);
|
|
mgc_connect_init(pTandem->pTxconn , pTandem->pTxconn->id);
|
|
}
|
|
|
|
pTandem->status = MGC_TANDEM_STATUS_UNDEF;
|
|
|
|
|
|
pConn = mgc_tandem_info_get_unattached_conn();
|
|
if(pConn == NULL)
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_set_conn(pTandem, pConn,MGC_TANDEM_CONN_POS_RX) == FALSE)
|
|
return FALSE;
|
|
|
|
pConn = mgc_tandem_info_get_unattached_conn();
|
|
if(pConn == NULL)
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_set_conn(pTandem, pConn,MGC_TANDEM_CONN_POS_TX) == FALSE)
|
|
return FALSE;
|
|
|
|
mgc_sur_info_clear_list(&pTandem->list);
|
|
mgc_tandem_info_set_status(pTandem,MGC_TANDEM_STATUS_IDLE);
|
|
sprintf(pTandem->escci , "%x%lx" , id , time(NULL));
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
MGC_TANDEM_INFO *mgc_tandem_info_get_tandem_by_id(DWORD id)
|
|
{
|
|
if(id >= MGC_MAX_NUM_OF_TANDEM)
|
|
return NULL;
|
|
|
|
return &mgcTandem[id];
|
|
}
|
|
|
|
MGC_TANDEM_INFO *mgc_tandem_info_get_idle_tandem(void)
|
|
{
|
|
int i;
|
|
static int index = 0;
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
MGC_TANDEM_INFO *pTandemTmp = NULL;
|
|
MG_INFO *pMgInfo = NULL;
|
|
|
|
i = index;
|
|
do
|
|
{
|
|
i++;
|
|
if(i == MGC_MAX_NUM_OF_TANDEM)
|
|
i = 0;
|
|
|
|
pTandem = &mgcTandem[i];
|
|
|
|
if(mgc_tandem_info_get_status(pTandem) != MGC_TANDEM_STATUS_IDLE)
|
|
continue;
|
|
|
|
if(pTandem->pRxconn == NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] lost rxConn" , pTandem->id);
|
|
continue;
|
|
}
|
|
|
|
if(pTandem->pTxconn == NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] lost txConn" , pTandem->id);
|
|
continue;
|
|
}
|
|
|
|
pMgInfo = mgc_connect_get_own_mg_info(pTandem->pRxconn);
|
|
if(pMgInfo == NULL)
|
|
continue;
|
|
|
|
if(pMgInfo != mgc_connect_get_own_mg_info(pTandem->pTxconn))
|
|
{
|
|
MGC_WARN("tandem[%d] txConn and rxConn is not on the same rtpproxy" , pTandem->id);
|
|
continue;
|
|
}
|
|
|
|
if(pMgInfo->enable == FALSE)
|
|
continue;
|
|
|
|
pTandemTmp = pTandem;
|
|
index = i;
|
|
break;
|
|
|
|
}while(i != index);
|
|
|
|
return pTandemTmp;
|
|
}
|
|
|
|
|
|
void mgc_tandem_info_setup(void)
|
|
{
|
|
int i;
|
|
CONNECT_INFO *pConn = NULL;
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
CHNL_INFO *pChnl = NULL;
|
|
PHY_PORT_INFO *pPhyPort = NULL;
|
|
|
|
for(i=0; i<MGC_MAX_NUM_OF_TANDEM_CONN; i++)
|
|
{
|
|
pConn = &mgcTandConn[i];
|
|
mgc_connect_init(pConn , i+MGC_TANDEM_CONN_STAR_ID);
|
|
}
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_TANDEM; i++)
|
|
{
|
|
pChnl = &mgcTandChnl[i];
|
|
mgc_chnl_info_init(pChnl , i+MGC_TANDEM_CHNL_STAR_ID);
|
|
}
|
|
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_RTP_PROXY_NUM ; i++)
|
|
{
|
|
pPhyPort = &mgcTandPort[i];
|
|
mgc_phy_port_init(pPhyPort,i+MGC_TANDEM_PHY_PORT_STAR_ID);
|
|
}
|
|
|
|
|
|
for(i=0; i<MGC_MAX_NUM_OF_TANDEM_CHNL; i++)
|
|
{
|
|
pTandem = &mgcTandem[i];
|
|
if(mgc_tandem_info_init(pTandem, i) == FALSE)
|
|
{
|
|
MGC_ERROR("tandem[%d] init failed!" , i);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
static PHY_PORT_INFO *mgc_tandem_info_get_unused_phy_port(void)
|
|
{
|
|
int i;
|
|
PHY_PORT_INFO *pPhyPort = NULL;
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_PHY_PORT ; i++)
|
|
{
|
|
pPhyPort = &mgcTandPort[i];
|
|
if((pPhyPort->chnlNum == 0)&&(pPhyPort->pMgInfo == NULL))
|
|
return pPhyPort;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static CONNECT_INFO *mgc_tandem_info_get_unsed_conn(void)
|
|
{
|
|
int i;
|
|
CONNECT_INFO *pConnect = NULL;
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_CON ; i++)
|
|
{
|
|
pConnect = &mgcTandConn[i];
|
|
|
|
if(pConnect->pChnlInfo != NULL)
|
|
continue;
|
|
|
|
return pConnect;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
static CHNL_INFO *mgc_tandem_info_get_unsed_chnl(void)
|
|
{
|
|
int i;
|
|
CHNL_INFO *pChnlInfo = NULL;
|
|
|
|
for(i=0 ; i<MGC_MAX_NUM_OF_CHNL ; i++)
|
|
{
|
|
pChnlInfo = &mgcTandChnl[i];
|
|
|
|
if(pChnlInfo->status != MGC_CHNL_INFO_STATUS_UNDEF)
|
|
continue;
|
|
|
|
return pChnlInfo;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static BOOL mgc_tandem_info_add_conn_to_chnl(CHNL_INFO *pChnlInfo)
|
|
{
|
|
int i;
|
|
CONNECT_INFO *pConn = NULL;
|
|
|
|
if(pChnlInfo == NULL)
|
|
return FALSE;
|
|
|
|
for(i=0 ; i<pChnlInfo->maxConnectNum ; i++)
|
|
{
|
|
pConn = mgc_tandem_info_get_unsed_conn();
|
|
if(pConn == NULL)
|
|
return FALSE;
|
|
|
|
if(mgc_chnl_info_attach_connect(pChnlInfo, pConn, i) == FALSE)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
static BOOL mgc_tandem_info_check_tandem_chnl_conn(CHNL_INFO *pChnlInfo)
|
|
{
|
|
int i;
|
|
BOOL result = FALSE;
|
|
CONNECT_INFO *pConn = NULL;
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if(pChnlInfo == NULL)
|
|
return FALSE;
|
|
|
|
/*get first attached connection's tandem*/
|
|
for(i=0; i<pChnlInfo->maxConnectNum ; i++)
|
|
{
|
|
pConn = pChnlInfo->pConnection[i];
|
|
|
|
if(pConn == NULL)
|
|
continue;
|
|
|
|
result = TRUE;
|
|
pTandem = pConn->pTandem;
|
|
break;
|
|
}
|
|
|
|
for(i=0; i<pChnlInfo->maxConnectNum ; i++)
|
|
{
|
|
pConn = pChnlInfo->pConnection[i];
|
|
|
|
if(pConn == NULL)
|
|
continue;
|
|
|
|
if(pTandem == pConn->pTandem)
|
|
continue;
|
|
|
|
result = FALSE;
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static BOOL mgc_tandem_info_add_chnl_to_port(PHY_PORT_INFO *pPhyPort)
|
|
{
|
|
int i;
|
|
CHNL_INFO *pChnlInfo = NULL;
|
|
|
|
if(pPhyPort == NULL)
|
|
return FALSE;
|
|
|
|
for(i=0 ; i<pPhyPort->chnlNum ; i++)
|
|
{
|
|
pChnlInfo = mgc_tandem_info_get_unsed_chnl();
|
|
if(pChnlInfo == NULL)
|
|
return FALSE;
|
|
|
|
pPhyPort->pChnlInfo[i] = pChnlInfo;
|
|
|
|
if(mgc_chnl_info_attach_to_phy_port(pChnlInfo , pPhyPort) == FALSE)
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_add_conn_to_chnl(pChnlInfo) == FALSE)
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_check_tandem_chnl_conn(pChnlInfo) == FALSE)
|
|
return FALSE;
|
|
|
|
mgc_chnl_info_status_set(pChnlInfo , MGC_CHNL_INFO_STATUS_IDLE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
static BOOL mgc_tandem_info_add_port(BYTE sapIndex, WORD mgNo, BYTE portNo, MGC_PHY_PORT_TYPE portType)
|
|
{
|
|
MG_INFO *pMgInfo = NULL;
|
|
MGC_SAP *pMgcSap = NULL;
|
|
PHY_PORT_INFO *pPhyPort = NULL;
|
|
|
|
pMgInfo = mgc_mg_info_get_index_mg(mgNo);
|
|
pMgcSap = mgc_sap_get_index_sap(sapIndex);
|
|
|
|
if((pMgcSap == NULL)||(pMgInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pMgInfo->created == FALSE)
|
|
return FALSE;
|
|
|
|
if(portType!= MGC_PHY_VIRTUAL_TYPE_TANDEM)
|
|
return FALSE;
|
|
|
|
if(pMgInfo->mgAttr.mgType != MGC_MG_TYPE_TANDEM)
|
|
return FALSE;
|
|
|
|
pPhyPort = mgc_tandem_info_get_unused_phy_port();
|
|
if(pPhyPort == NULL)
|
|
return FALSE;
|
|
|
|
pPhyPort->portType = portType;
|
|
pPhyPort->portNo = portNo;
|
|
pPhyPort->pMgcSap = pMgcSap;
|
|
pPhyPort->pMgInfo = pMgInfo;
|
|
|
|
switch(pMgInfo->mgAttr.ctrlType)
|
|
{
|
|
case MGC_MG_CTRL_TYPE_MGCP:
|
|
mgc_phy_port_set_chnl_num(pPhyPort , pPhyPort->portType);
|
|
break;
|
|
default:
|
|
mgc_phy_port_clear(pPhyPort);
|
|
MGC_ERROR("mgcMgInfo[%d] unsupport ctrl type %d" , pMgInfo->id , pMgInfo->mgAttr.ctrlType);
|
|
return FALSE;
|
|
}
|
|
|
|
if(mgc_tandem_info_add_chnl_to_port(pPhyPort) == FALSE)
|
|
{
|
|
mgc_phy_port_clear(pPhyPort);
|
|
return FALSE;
|
|
}
|
|
|
|
if(mgc_mg_info_attach_phy_port(pMgInfo , pPhyPort, pMgcSap)== FALSE)
|
|
{
|
|
mgc_phy_port_clear(pPhyPort);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
BOOL mgc_tandem_info_add_tandem_res(BYTE sapIndex, WORD mgNo)
|
|
{
|
|
MG_INFO *pMgInfo = NULL;
|
|
BOOL result = FALSE;
|
|
PHY_PORT_INFO *pPhyPort = NULL;
|
|
int i;
|
|
|
|
pMgInfo = mgc_mg_info_get_index_mg(mgNo);
|
|
|
|
if(pMgInfo == NULL)
|
|
return FALSE;
|
|
|
|
if(pMgInfo->mgAttr.mgType != MGC_MG_TYPE_TANDEM)
|
|
return FALSE;
|
|
|
|
pPhyPort = mgc_tandem_info_get_unused_phy_port();
|
|
if(pPhyPort == NULL)
|
|
return FALSE;
|
|
|
|
for(i=0 ; i< MGC_MAX_PHY_PORT_PER_MG ; i++)
|
|
{
|
|
if(pMgInfo->pPhyPort[i] != NULL)
|
|
continue;
|
|
result = TRUE;
|
|
break;
|
|
}
|
|
|
|
|
|
if(result == FALSE)
|
|
{
|
|
MGC_DEBUG("mg[%d] is full of phyport" , pMgInfo->id);
|
|
return FALSE;
|
|
}
|
|
|
|
if(mgc_tandem_info_add_port(sapIndex, mgNo, i , MGC_PHY_VIRTUAL_TYPE_TANDEM) == FALSE)
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_create_tandem(MGC_TANDEM_INFO *pTandem , PORT_INFO *pPortInfo)
|
|
{
|
|
if((pTandem == NULL) || (pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_connect_get_status(pTandem->pTxconn) == MGC_CONNECT_STATUS_IDLE)
|
|
mgc_connect_add_crcx_with_mode(pTandem->pTxconn, MGC_CON_MODE_SENDRECV ,pPortInfo);
|
|
|
|
if(mgc_connect_get_status(pTandem->pRxconn) == MGC_CONNECT_STATUS_IDLE)
|
|
mgc_connect_add_crcx_with_mode(pTandem->pRxconn, MGC_CON_MODE_RECVONLY,pPortInfo);
|
|
|
|
mgc_connect_add_nop(pTandem->pTxconn, pPortInfo);
|
|
mgc_tandem_info_set_status(pTandem, MGC_TANDEM_STATUS_USED);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_updadte_media(MGC_TANDEM_INFO *pTandem , PORT_INFO *pPortInfo)
|
|
{
|
|
CONNECT_INFO *pTarConn = NULL;
|
|
CONNECT_INFO *pSurConn = NULL;
|
|
MG_INFO *pTarMgInfo = NULL;
|
|
MGC_SUR_INFO_NODE *pNode = NULL;
|
|
BYTE ptime;
|
|
MGC_CODEC_LIST codeclist;
|
|
int i;
|
|
|
|
if((pTandem == NULL) ||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
pTarConn = pTandem->pTconn;
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pTarConn) != MGC_TANDEM_CONN_POS_TAR)
|
|
return FALSE;
|
|
|
|
pTarMgInfo = mgc_connect_get_own_mg_info(pTarConn);
|
|
if(pTarMgInfo == NULL)
|
|
return FALSE;
|
|
|
|
mgc_connect_codec_list_init(&codeclist);
|
|
ptime = 0;
|
|
if((mgc_connect_get_status(pTarConn) == MGC_CONNECT_STATUS_CREATED)||(mgc_connect_get_status(pTarConn) == MGC_CONNECT_STATUS_CREATE))
|
|
{
|
|
memcpy(&codeclist , &pTarConn->codecList , sizeof(MGC_CODEC_LIST));
|
|
ptime = pTarConn->mediaAttr.ptime;
|
|
}
|
|
else
|
|
{
|
|
memcpy(&codeclist , &pTarMgInfo->mgAttr.codecList , sizeof(MGC_CODEC_LIST));
|
|
ptime = pTarMgInfo->mgAttr.ptime;
|
|
}
|
|
|
|
if(pTandem->pRxconn == NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] lost RxConn" , pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
memcpy(&pTandem->pRxconn->codecList , &codeclist, sizeof(MGC_CODEC_LIST));
|
|
pTandem->pRxconn->mediaAttr.ptime = ptime;
|
|
|
|
if(pTandem->pTxconn == NULL)
|
|
{
|
|
MGC_ERROR("tandem[%d] lost TxConn" , pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
memcpy(&pTandem->pTxconn->codecList , &codeclist,sizeof(MGC_CODEC_LIST));
|
|
pTandem->pTxconn->mediaAttr.ptime = ptime;
|
|
|
|
for(i=0 ; i<pTandem->list.len ; i++)
|
|
{
|
|
pNode = mgc_sur_info_get_list_node(&pTandem->list , i);
|
|
if(pNode == NULL)
|
|
{
|
|
MGC_WARN("tandem[%d] sur_list lost node[%d]" , pTandem->id , i);
|
|
continue;
|
|
}
|
|
|
|
pSurConn = pNode->pConn;
|
|
if(pSurConn == NULL)
|
|
{
|
|
MGC_WARN("tandem[%d] sur_list node[%d] lost surConn " , pTandem->id , i);
|
|
continue;
|
|
}
|
|
|
|
memcpy(&pSurConn->codecList , &codeclist , sizeof(MGC_CODEC_LIST));
|
|
pSurConn->mediaAttr.ptime = ptime;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_create_tar_tandem(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
return FALSE;
|
|
|
|
mgc_tandem_info_create_tandem(pTandem, pPortInfo);
|
|
mgc_tandem_info_updadte_media(pTandem, pPortInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_stop_tar_send_to_tandem(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pConnect, pTandem->pTxconn, MGC_CON_MODE_RECVONLY, pPortInfo);
|
|
MGC_DEBUG("tarConn[%d] stop send stream to tandem[%d]" , pConnect->id , pTandem->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_stop_aor_send_to_tandem(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_AOR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pConnect, pTandem->pRxconn, MGC_CON_MODE_RECVONLY, pPortInfo);
|
|
MGC_DEBUG("AorConn[%d] stop send stream to tandem[%d]" , pConnect->id , pTandem->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
BOOL mgc_tandem_info_stop_tandem_send_to_tar(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pTandem->pTxconn, pConnect, MGC_CON_MODE_RECVONLY, pPortInfo);
|
|
MGC_DEBUG("tandem[%d] stop send stream to TarConn[%d]" , pTandem->id , pConnect->id);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_stop_tandem_send_to_aor(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_AOR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pTandem->pRxconn, pConnect, MGC_CON_MODE_RECVONLY, pPortInfo);
|
|
MGC_DEBUG("tandem[%d] stop send stream to AorConn[%d]" , pTandem->id , pConnect->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_start_tandem_send_to_tar(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pConnect, pTandem->pTxconn, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pTandem->pTxconn, pConnect, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
MGC_DEBUG("tandem[%d] start communication with tar conn[%d]" , pTandem->id , pConnect->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_start_tandem_send_to_aor(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return FALSE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_AOR)
|
|
return FALSE;
|
|
|
|
mgc_connect_add_mdcx(pConnect, pTandem->pRxconn, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pTandem->pRxconn, pConnect, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
MGC_DEBUG("tandem[%d] start communication with aor conn[%d]" , pTandem->id , pConnect->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_dettach_aor_related_tandem(CONNECT_INFO *pConnect, CONNECT_INFO *pPeerConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
if((pConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
if(mgc_tandem_info_stop_tandem_send_to_aor(pConnect, pPortInfo) == FALSE)
|
|
return FALSE;
|
|
|
|
mgc_tandem_info_unset_conn(pConnect->pTandem, pConnect);
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
if(mgc_tandem_info_stop_tandem_send_to_aor(pPeerConnect, pPortInfo) == FALSE)
|
|
return FALSE;
|
|
|
|
mgc_tandem_info_unset_conn(pPeerConnect->pTandem, pPeerConnect);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_connect_tandem_to_connection(CONNECT_INFO *pConnect, CONNECT_INFO *pPeerConnect, MGC_CON_MODE mode , PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
if((pConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
MGC_ERROR("conn[%d] is not a target!!" , pConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
if(pPeerConnect->pTandem)
|
|
{
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem,pPeerConnect) != MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
MGC_ERROR("conn[%d] should not be related to any tandem!" , pPeerConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
if(pConnect->pTandem != pPeerConnect->pTandem)
|
|
{
|
|
MGC_ERROR("conn[%d] and peerConn[%d] should not be called by %s!" , pConnect->id, pPeerConnect->id, __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
MGC_DEBUG("enter %s" , __FUNCTION__);
|
|
pTandem = pConnect->pTandem;
|
|
mgc_connect_add_mdcx(pTandem->pTxconn, pConnect, MGC_CON_MODE_SENDRECV , pPortInfo);
|
|
mgc_connect_add_mdcx(pTandem->pRxconn , pPeerConnect, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect,pTandem->pTxconn,mode, pPortInfo);
|
|
if(pPeerConnect->pTandem == NULL)
|
|
mgc_tandem_info_set_conn(pTandem, pPeerConnect, MGC_TANDEM_CONN_POS_AOR);
|
|
|
|
MGC_DEBUG("tandem[%d] connect to conn[%d]" , pTandem->id , pPeerConnect->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_connect_tandem_to_tandem(CONNECT_INFO *pConnect, CONNECT_INFO *pPeerConnect, MGC_CON_MODE mode , PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
MGC_TANDEM_INFO *pPeerTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
MGC_ERROR("conn[%d] is not a target!!" , pConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
MGC_ERROR("conn[%d] is not a target!!" , pPeerConnect->id);
|
|
return FALSE;
|
|
}
|
|
MGC_DEBUG("enter %s" , __FUNCTION__);
|
|
|
|
pTandem = pConnect->pTandem;
|
|
pPeerTandem = pPeerConnect->pTandem;
|
|
|
|
mgc_connect_add_mdcx(pTandem->pTxconn, pConnect, MGC_CON_MODE_SENDRECV , pPortInfo);
|
|
mgc_connect_add_mdcx(pTandem->pRxconn , pPeerTandem->pRxconn , MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pPeerTandem->pRxconn , pTandem->pRxconn , MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect,pTandem->pTxconn,mode, pPortInfo);
|
|
MGC_DEBUG("tandem[%d] connect to tandem[%d]" , pTandem->id , pPeerTandem->id);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL mgc_tandem_info_connect_connection_to_tandem(CONNECT_INFO *pConnect, CONNECT_INFO *pPeerConnect, MGC_CON_MODE mode , PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pPeerTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
MGC_DEBUG("enter %s" , __FUNCTION__);
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) != MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
MGC_ERROR("conn[%d] is not a target!!" , pPeerConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
if(pConnect->pTandem != NULL)
|
|
{
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem,pConnect) != MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
MGC_ERROR("conn[%d] should not be related to tandem[%d]!" , pConnect->id , pConnect->pTandem->id);
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
}
|
|
|
|
if(pConnect->pTandem != pPeerConnect->pTandem)
|
|
{
|
|
MGC_ERROR("conn[%d] and peerConn[%d] should not be called by %s!" , pConnect->id, pPeerConnect->id, __FUNCTION__);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
pPeerTandem = pPeerConnect->pTandem;
|
|
mgc_connect_add_mdcx(pPeerTandem->pRxconn, pConnect, MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pPeerTandem->pTxconn, pPeerConnect , MGC_CON_MODE_SENDRECV, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect, pPeerTandem->pRxconn , mode, pPortInfo);
|
|
if(pConnect->pTandem == NULL)
|
|
mgc_tandem_info_set_conn(pPeerTandem, pConnect, MGC_TANDEM_CONN_POS_AOR);
|
|
|
|
MGC_DEBUG("conn[%d] connect to tandem[%d]" , pConnect->id , pPeerTandem->id);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_connect(CONNECT_INFO *pConnect, CONNECT_INFO *pPeerConnect, MGC_CON_MODE mode , PORT_INFO *pPortInfo)
|
|
{
|
|
MG_INFO *pPeerMgInfo = NULL;
|
|
|
|
if((pConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
if(pConnect->pTandem->pAconn != pPeerConnect)
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect->pTandem->pAconn, pPortInfo);
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
mgc_tandem_info_connect_tandem_to_tandem(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem,pPeerConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
mgc_tandem_info_connect_tandem_to_connection(pConnect, pPeerConnect,mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
mgc_tandem_info_connect_tandem_to_connection(pConnect, pPeerConnect,mode, pPortInfo);
|
|
}
|
|
else
|
|
{
|
|
MGC_ERROR("peerConn[%d] is in illegal tandem[%d]!" , pPeerConnect->id, pPeerConnect->pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem,pPeerConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
if(pPeerConnect->pTandem != pConnect->pTandem)
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
|
|
if(pPeerConnect->pTandem->pAconn != pConnect)
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConnect->pTandem->pAconn, pPortInfo);
|
|
|
|
mgc_tandem_info_connect_connection_to_tandem(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConnect, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else
|
|
{
|
|
MGC_WARN("AorConn[%d] is not rec correct" , pConnect->id);
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_SUR)
|
|
{
|
|
mode = MGC_CON_MODE_SENDONLY;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) != MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
MGC_ERROR("surConn[%d] can't connect conn[%d]" , pConnect->id , pPeerConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConnect->pTandem->pAconn, pPortInfo);
|
|
mgc_tandem_info_connect_connection_to_tandem(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConnect, pPortInfo);
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_SUR)
|
|
{
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerConnect->pTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
pPeerMgInfo = mgc_connect_get_own_mg_info(pPeerConnect);
|
|
if(pPeerMgInfo == NULL)
|
|
return FALSE;
|
|
|
|
if((pPeerMgInfo->mgAttr.mgType == MGC_MG_TYPE_INTERNAL)&&(pPeerConnect->mediaAttr.conMode == MGC_CON_MODE_SENDONLY))
|
|
mode = MGC_CON_MODE_RECVONLY;
|
|
|
|
mgc_connect_add_mdcx(pConnect, pPeerConnect, mode, pPortInfo);
|
|
}
|
|
else
|
|
{
|
|
MGC_ERROR("conn[%d] can't connect conn[%d]" , pConnect->id , pPeerConnect->id);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
MGC_ERROR("Conn[%d] is in illegal tandem[%d]!" , pConnect->id, pConnect->pTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
BOOL mgc_tandem_info_add_crcx_aas(CONNECT_INFO *pAasConnect, CONNECT_INFO *pPeerConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
CONNECT_INFO *pPeerConn = NULL;
|
|
CONNECT_INFO *pConn = NULL;
|
|
MGC_TANDEM_INFO *pPeerTandem = NULL;
|
|
|
|
if((pAasConnect == NULL)||(pPeerConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
pPeerConn = pPeerConnect;
|
|
pConn = pAasConnect;
|
|
pPeerTandem = pPeerConnect->pTandem;
|
|
|
|
if(pConn->pTandem != NULL)
|
|
{
|
|
MGC_WARN("aasConn[%d] should not rec any tandem!" , pConn->id);
|
|
mgc_tandem_info_remove_connection_from_tandem(pConn, pPortInfo);
|
|
mgc_connect_add_dlcx(pConn, pPortInfo);
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pPeerTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
if(pPeerConnect->pTandem->pAconn != NULL)
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerTandem->pAconn, pPortInfo);
|
|
|
|
mgc_tandem_info_start_tandem_send_to_tar(pPeerConnect, pPortInfo);
|
|
pPeerConn = pPeerTandem->pRxconn;
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerTandem, pPeerConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
if(mgc_tandem_info_get_conn_pos(pPeerTandem, pPeerTandem->pTconn) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConnect, pPortInfo);
|
|
}
|
|
else
|
|
{
|
|
mgc_tandem_info_start_tandem_send_to_aor(pPeerConnect, pPortInfo);
|
|
pPeerConn = pPeerTandem->pTxconn;
|
|
}
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pPeerTandem, pPeerConnect) != MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
MGC_ERROR("peerConn[%d] is in illegal tandem[%d]!" , pPeerConnect->id, pPeerTandem->id);
|
|
return FALSE;
|
|
}
|
|
|
|
MGC_DEBUG("aasConn[%d] send tone to peerConn[%d]" , pConn->id , pPeerConn->id);
|
|
mgc_connect_add_crcx_aas(pConn, pPeerConn, pPortInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
BOOL mgc_tandem_info_add_mdcx_aas(CONNECT_INFO *pConnect, CONNECT_INFO *pAasConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
CONNECT_INFO *pPeerConn = NULL;
|
|
CONNECT_INFO *pConn = NULL;
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pAasConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
pPeerConn = pAasConnect;
|
|
pConn = pConnect;
|
|
pTandem = pConn->pTandem;
|
|
|
|
if(pPeerConn->pTandem != NULL)
|
|
{
|
|
MGC_WARN("aasConn[%d] should not related to any tandem" , pAasConnect->id);
|
|
mgc_tandem_info_remove_connection_from_tandem(pPeerConn, pPortInfo);
|
|
mgc_connect_add_dlcx(pConnect, pPortInfo);
|
|
return FALSE;
|
|
}
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
mgc_tandem_info_start_tandem_send_to_tar(pConnect, pPortInfo);
|
|
pConn = pTandem->pRxconn;
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
{
|
|
if(mgc_tandem_info_get_conn_pos(pTandem, pTandem->pTconn) == MGC_TANDEM_CONN_POS_TAR)
|
|
{
|
|
mgc_tandem_info_remove_connection_from_tandem(pConnect, pPortInfo);
|
|
}
|
|
else
|
|
{
|
|
mgc_tandem_info_start_tandem_send_to_aor(pConnect, pPortInfo);
|
|
pConn = pTandem->pTxconn;
|
|
}
|
|
}
|
|
else if(mgc_tandem_info_get_conn_pos(pTandem, pConnect) != MGC_TANDEM_CONN_POS_UNDEF)
|
|
{
|
|
MGC_ERROR("Conn[%d] is in illegal tandem[%d]!" , pConnect->id, pTandem->id);
|
|
return FALSE;
|
|
}
|
|
MGC_DEBUG("conn[%d] hear aasConn[%d] " , pConn->id , pPeerConn->id);
|
|
mgc_connect_add_mdcx_aas(pConn, pPeerConn, pPortInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
BOOL mgc_tandem_info_mdcx(CONNECT_INFO *pConnect , PORT_INFO *pPortInfo)
|
|
{
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_TAR)
|
|
mgc_connect_add_mdcx(pConnect, pConnect->pTandem->pTxconn, pConnect->mediaAttr.conMode, pPortInfo);
|
|
|
|
if(mgc_tandem_info_get_conn_pos(pConnect->pTandem, pConnect) == MGC_TANDEM_CONN_POS_AOR)
|
|
mgc_connect_add_mdcx(pConnect, pConnect->pTandem->pRxconn, pConnect->mediaAttr.conMode, pPortInfo);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_remove_connection_from_tandem(CONNECT_INFO *pConnect, PORT_INFO *pPortInfo)
|
|
{
|
|
MGC_TANDEM_INFO *pTandem = NULL;
|
|
|
|
if((pConnect == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
if(pConnect->pTandem == NULL)
|
|
return TRUE;
|
|
|
|
pTandem = pConnect->pTandem;
|
|
switch(mgc_tandem_info_get_conn_pos(pTandem, pConnect))
|
|
{
|
|
case MGC_TANDEM_CONN_POS_TAR:
|
|
mgc_tandem_info_stop_tandem_send_to_tar(pConnect, pPortInfo);
|
|
mgc_tandem_info_stop_tar_send_to_tandem(pConnect, pPortInfo);
|
|
mgc_tandem_info_unset_conn(pTandem, pConnect);
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_AOR:
|
|
mgc_tandem_info_stop_tandem_send_to_aor(pConnect, pPortInfo);
|
|
mgc_tandem_info_stop_aor_send_to_tandem(pConnect, pPortInfo);
|
|
mgc_tandem_info_unset_conn(pTandem, pConnect);
|
|
break;
|
|
case MGC_TANDEM_CONN_POS_TX:
|
|
case MGC_TANDEM_CONN_POS_RX:
|
|
MGC_ERROR("tandem[%d] is not allowed remove conn[%d]" , pTandem->id, pConnect->id);
|
|
break;
|
|
default:
|
|
MGC_ERROR("conn[%d] in illegal tandem[%d]", pConnect->id , pConnect->pTandem->id);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL mgc_tandem_info_clear(MGC_TANDEM_INFO *pTandem, PORT_INFO *pPortInfo)
|
|
{
|
|
CONNECT_INFO *pConnect = NULL;
|
|
MGC_SUR_INFO_NODE *pNode = NULL;
|
|
|
|
|
|
if((pTandem == NULL)||(pPortInfo == NULL))
|
|
return FALSE;
|
|
|
|
pNode = mgc_sur_info_get_list_tail(&pTandem->list);
|
|
while(pNode != NULL)
|
|
{
|
|
pConnect = pNode->pConn;
|
|
mgc_connect_add_dlcx(pConnect, pPortInfo);
|
|
mgc_tandem_info_unset_conn(pTandem, pConnect);
|
|
pNode = mgc_sur_info_get_list_tail(&pTandem->list);
|
|
}
|
|
|
|
mgc_connect_add_dlcx(pTandem->pRxconn, pPortInfo);
|
|
mgc_connect_add_dlcx(pTandem->pTxconn, pPortInfo);
|
|
mgc_tandem_info_unset_conn(pTandem, pTandem->pAconn);
|
|
mgc_tandem_info_unset_conn(pTandem, pTandem->pTconn);
|
|
mgc_tandem_info_set_status(pTandem, MGC_TANDEM_STATUS_IDLE);
|
|
return TRUE;
|
|
}
|
|
|