Skip to content

F
freeswitch
提交 d147dcd5 authored 作者: kapil's avatar kapil
浏览文件
操作

Merge branch 'nsg-4.3' of ssh://git.sangoma.com/smg_freeswitch into nsg-4.3

上级 117cbc1b 67373e78
隐藏空白字符变更
内嵌 并排
正在显示 包含 1180 行增加 和 17 行删除
src/mod/endpoints/mod_megaco/conf/megaco.conf.xml
浏览文件 @ d147dcd5
......@@ -5,8 +5,9 @@
<sng_mg_interface name="default">
<param name="id" value="1"/> <!-- /* equivalent to SSAP ID of MEGACO layer */-->
<param name="protocol" value="MEGACO"/> <!-- /* Protocol Type , Supported values are MEGACO/MGCP */ -->
<param name="version" value="3"/> <!-- /* Protocol Version , Supported values for MEGACO are 1/2/3 */ -->
<param name="transportProfileId" value="1"/> <!-- /* Link to transport layer configuration -->
<param name="localIp" value="192.168.1.100"/> <!-- /* Local node IP */ -->
<param name="localIp" value="192.168.1.101"/> <!-- /* Local node IP */ -->
<param name="port" value="2944" /> <!-- /* Port */ -->
<param name="myDomainName" value="mg.sangoma.com" /> <!--/* Local domain name */ -->
<param name="mid" value="<lab.sangoma.com>"/> <!-- /* Message Identifier (MID) of MEGACO message */ -->
......@@ -35,7 +36,7 @@
<sng_mg_peer_interface name="MG_PEER1">
<param name="id" value="1"/> <!-- /* Peer profile ID */-->
<param name="ip" value="192.168.1.101"/> <!-- /* Peer node IP */ -->
<param name="ip" value="192.168.1.100"/> <!-- /* Peer node IP */ -->
<param name="port" value="2944"/> <!--/* peer port */ -->
<param name="encodingScheme" value="TEXT"/> <!--/* H.248 Encoding scheme TEXT/BINARY */ -->
<param name="mid" value="<remote.mgc.com>" /> <!-- /* Message Identifier (MID) of remote MGC MEGACO message */-->
......
src/mod/endpoints/mod_megaco/megaco.c
浏览文件 @ d147dcd5
......@@ -45,7 +45,7 @@ static switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t r
goto done;
}
/* iterate through MG Interface list to build all MG profiles */
/* iterate through MG Interface list to build requested MG profile */
for (mg_interface = switch_xml_child(mg_interfaces, "sng_mg_interface"); mg_interface; mg_interface = mg_interface->next) {
const char *name = switch_xml_attr_soft(mg_interface, "name");
......@@ -161,9 +161,11 @@ switch_status_t megaco_profile_destroy(megaco_profile_t **profile)
switch_thread_rwlock_wrlock((*profile)->rwlock);
/* TODO: Kapil: Insert stack per-interface shutdown code here */
/* stop MEGACP stack */
if(SWITCH_STATUS_FALSE == sng_mgco_stop((*profile)->name)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error stopping MEGACO Stack for profile %s\n", (*profile)->name);
}
switch_thread_rwlock_unlock((*profile)->rwlock);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Stopped profile: %s\n", (*profile)->name);
......
src/mod/endpoints/mod_megaco/megaco_stack.c
浏览文件 @ d147dcd5
......@@ -29,9 +29,16 @@ int mgco_mg_tsap_enable_cntrl(int idx);
int mgco_mg_ssap_cntrl(int idx);
int mgco_mu_ssap_cntrl(int idx);
int mgco_mg_tpt_server(int idx);
int sng_mgco_tucl_shutdown();
int sng_mgco_mg_shutdown();
int sng_mgco_mg_ssap_stop(int sapId);
int sng_mgco_mg_tpt_server_stop(int idx);
int sng_mgco_mg_app_ssap_stop(int idx);
switch_status_t sng_mgco_stack_gen_cfg();
void get_peer_xml_buffer(char* prntBuf, MgPeerSta* cfm);
/******************************************************************************/
/* FUNCTIONS ******************************************************************/
......@@ -86,6 +93,12 @@ switch_status_t sng_mgco_init(sng_isup_event_interface_t* event)
/*****************************************************************************************************************/
switch_status_t sng_mgco_stack_shutdown()
{
/* shutdown MG */
sng_mgco_mg_shutdown();
/* shutdown TUCL */
sng_mgco_tucl_shutdown();
/* free MEGACO Application */
sng_isup_free_mu();
......@@ -258,6 +271,159 @@ switch_status_t sng_mgco_start(const char* profilename)
}
/*****************************************************************************************************************/
switch_status_t sng_mgco_stop(const char* profilename)
{
int idx = 0x00;
sng_mg_cfg_t* mgCfg = NULL;
switch_assert(profilename);
GET_MG_CFG_IDX(profilename, idx);
if(!idx || (idx == MAX_MG_PROFILES)){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG configuration found against profilename[%s]\n",profilename);
return SWITCH_STATUS_FALSE;
}
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," Stopping MG stack for idx[%d] against profilename[%s]\n", idx, profilename);
mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx];
/* MG STOP is as good as deleting that perticular mg(virtual mg instance) data from megaco stack */
/* currently we are not supporting enable/disable MG stack */
if(sng_mgco_mg_ssap_stop(mgCfg->id)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " sng_mgco_mg_ssap_stop FAILED \n");
return SWITCH_STATUS_FALSE;
}
else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " sng_mgco_mg_ssap_stop SUCCESS \n");
}
if(sng_mgco_mg_tpt_server_stop(idx)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " sng_mgco_mg_tpt_server_stop FAILED \n");
return SWITCH_STATUS_FALSE;
}
else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " sng_mgco_mg_tpt_server_stop SUCCESS \n");
}
if(sng_mgco_mg_app_ssap_stop(idx)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " sng_mgco_mg_app_ssap_stop FAILED \n");
return SWITCH_STATUS_FALSE;
}
else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " sng_mgco_mg_app_ssap_stop SUCCESS \n");
}
return SWITCH_STATUS_SUCCESS;
}
/*****************************************************************************************************************/
int sng_mgco_mg_app_ssap_stop(int idx)
{
MuMngmt mgMngmt;
Pst pst; /* Post for layer manager */
MuCntrl *cntrl;
memset(&mgMngmt, 0, sizeof(mgMngmt));
cntrl = &(mgMngmt.t.cntrl);
/* initalize the post structure */
smPstInit(&pst);
/* insert the destination Entity */
pst.dstEnt = ENTMU;
/*fill in the specific fields of the header */
mgMngmt.hdr.msgType = TCNTRL;
mgMngmt.hdr.entId.ent = ENTMG;
mgMngmt.hdr.entId.inst = S_INST;
mgMngmt.hdr.elmId.elmnt = STSSAP;
mgMngmt.hdr.elmId.elmntInst1 = GET_MU_SAP_ID(idx);
cntrl->action = ADEL;
cntrl->subAction = SAELMNT;
return(sng_cntrl_mu(&pst, &mgMngmt));
}
/*****************************************************************************************************************/
int sng_mgco_mg_ssap_stop(int sapId)
{
Pst pst;
MgMngmt cntrl;
memset((U8 *)&pst, 0, sizeof(Pst));
memset((U8 *)&cntrl, 0, sizeof(MgCntrl));
smPstInit(&pst);
pst.dstEnt = ENTMG;
/* prepare header */
cntrl.hdr.msgType = TCNTRL; /* message type */
cntrl.hdr.entId.ent = ENTMG; /* entity */
cntrl.hdr.entId.inst = 0; /* instance */
cntrl.hdr.elmId.elmnt = STSSAP; /* SSAP */
cntrl.hdr.elmId.elmntInst1 = sapId; /* sap id */
cntrl.hdr.response.selector = 0;
cntrl.hdr.response.prior = PRIOR0;
cntrl.hdr.response.route = RTESPEC;
cntrl.hdr.response.mem.region = S_REG;
cntrl.hdr.response.mem.pool = S_POOL;
cntrl.t.cntrl.action = ADEL;
cntrl.t.cntrl.subAction = SAELMNT;
cntrl.t.cntrl.spId = sapId;
return (sng_cntrl_mg (&pst, &cntrl));
}
/*****************************************************************************************************************/
int sng_mgco_mg_tpt_server_stop(int idx)
{
MgMngmt mgMngmt;
Pst pst; /* Post for layer manager */
MgCntrl *cntrl;
MgTptCntrl *tptCntrl = &mgMngmt.t.cntrl.s.tptCntrl;
CmInetIpAddr ipAddr = 0;
sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx];
cntrl = &(mgMngmt.t.cntrl);
memset(&mgMngmt, 0, sizeof(mgMngmt));
/* initalize the post structure */
smPstInit(&pst);
/* insert the destination Entity */
pst.dstEnt = ENTMG;
tptCntrl->transportType = GET_TPT_TYPE(idx);
tptCntrl->serverAddr.type = CM_INET_IPV4ADDR_TYPE;
tptCntrl->serverAddr.u.ipv4TptAddr.port = mgCfg->port;
if(ROK == cmInetAddr((S8*)mgCfg->my_ipaddr, &ipAddr))
{
tptCntrl->serverAddr.u.ipv4TptAddr.address = ntohl(ipAddr);
}
/*fill in the specific fields of the header */
mgMngmt.hdr.msgType = TCNTRL;
mgMngmt.hdr.entId.ent = ENTMG;
mgMngmt.hdr.entId.inst = S_INST;
mgMngmt.hdr.elmId.elmnt = STSERVER;
cntrl->action = ADEL;
cntrl->subAction = SAELMNT;
return(sng_cntrl_mg(&pst, &mgMngmt));
}
/*****************************************************************************************************************/
int mgco_mg_tsap_bind_cntrl(int idx)
{
MgMngmt mgMngmt;
......@@ -753,7 +919,21 @@ int mgco_mg_ssap_config(int idx)
pCfg->mwdTimer = (U16)10;
pCfg->minMgcoVersion = LMG_VER_PROF_MGCO_H248_1_0;
pCfg->maxMgcoVersion = LMG_VER_PROF_MGCO_H248_3_0;
switch(mgCfg->protocol_version)
{
case 1:
pCfg->maxMgcoVersion = LMG_VER_PROF_MGCO_H248_1_0;
break;
case 2:
pCfg->maxMgcoVersion = LMG_VER_PROF_MGCO_H248_2_0;
break;
case 3:
pCfg->maxMgcoVersion = LMG_VER_PROF_MGCO_H248_3_0;
break;
default:
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Protocol version[%d] \n",mgCfg->protocol_version);
return SWITCH_STATUS_FALSE;
}
pCfg->userInfo.pres.pres = PRSNT_NODEF;
pCfg->userInfo.id.pres = NOTPRSNT;
......@@ -962,3 +1142,957 @@ int mgco_mg_tpt_server_config(int idx)
}
/******************************************************************************/
int sng_mgco_tucl_shutdown()
{
Pst pst;
HiMngmt cntrl;
memset((U8 *)&pst, 0, sizeof(Pst));
memset((U8 *)&cntrl, 0, sizeof(HiMngmt));
smPstInit(&pst);
pst.dstEnt = ENTHI;
/* prepare header */
cntrl.hdr.msgType = TCNTRL; /* message type */
cntrl.hdr.entId.ent = ENTHI; /* entity */
cntrl.hdr.entId.inst = 0; /* instance */
cntrl.hdr.elmId.elmnt = STGEN; /* General */
cntrl.hdr.response.selector = 0;
cntrl.hdr.response.prior = PRIOR0;
cntrl.hdr.response.route = RTESPEC;
cntrl.hdr.response.mem.region = S_REG;
cntrl.hdr.response.mem.pool = S_POOL;
cntrl.t.cntrl.action = ASHUTDOWN;
return (sng_cntrl_tucl (&pst, &cntrl));
}
/******************************************************************************/
int sng_mgco_mg_shutdown()
{
Pst pst;
MgMngmt cntrl;
memset((U8 *)&pst, 0, sizeof(Pst));
memset((U8 *)&cntrl, 0, sizeof(MgCntrl));
smPstInit(&pst);
pst.dstEnt = ENTMG;
/* prepare header */
cntrl.hdr.msgType = TCNTRL; /* message type */
cntrl.hdr.entId.ent = ENTMG; /* entity */
cntrl.hdr.entId.inst = 0; /* instance */
cntrl.hdr.elmId.elmnt = STGEN; /* General */
cntrl.hdr.response.selector = 0;
cntrl.hdr.response.prior = PRIOR0;
cntrl.hdr.response.route = RTESPEC;
cntrl.hdr.response.mem.region = S_REG;
cntrl.hdr.response.mem.pool = S_POOL;
cntrl.t.cntrl.action = ASHUTDOWN;
cntrl.t.cntrl.subAction = SAELMNT;
return (sng_cntrl_mg (&pst, &cntrl));
}
/******************************************************************************/
void handle_mg_alarm(Pst *pst, MgMngmt *usta)
{
U16 ret;
int len = 0x00;
char prBuf[3048];
memset(&prBuf[0], 0, sizeof(prBuf));
len = len + sprintf(prBuf+len,"MG Status Indication: received with Category = %d, Event = %d, Cause = %d \n",
usta->t.usta.alarm.category, usta->t.usta.alarm.event,
usta->t.usta.alarm.cause);
len = len + sprintf(prBuf+len, "Category ( ");
switch (usta->t.usta.alarm.category)
{
case LCM_CATEGORY_PROTOCOL:
{
len = len + sprintf(prBuf+len, "protocol related ");
break;
}
case LCM_CATEGORY_INTERFACE:
{
len = len + sprintf(prBuf+len, "interface related ");
break;
}
case LCM_CATEGORY_INTERNAL:
{
len = len + sprintf(prBuf+len, "internal ");
break;
}
case LCM_CATEGORY_RESOURCE:
{
len = len + sprintf(prBuf+len, "system resources related ");
break;
}
case LCM_CATEGORY_PSF_FTHA:
{
len = len + sprintf(prBuf+len, "fault tolerance / high availability PSF related ");
break;
}
case LCM_CATEGORY_LYR_SPECIFIC:
{
len = len + sprintf(prBuf+len, "MGCP related ");
break;
}
default:
{
len = len + sprintf(prBuf+len, "unknown: %d", (int)(usta->t.usta.alarm.category));
break;
}
}
len = len + sprintf(prBuf+len, ") ");
len = len + sprintf(prBuf+len, " Event ( ");
switch (usta->t.usta.alarm.event)
{
case LMG_EVENT_TSAP_RECVRY_SUCCESS:
{
len = len + sprintf(prBuf+len, "TSAP recovery success");
break;
}
case LMG_EVENT_TSAP_RECVRY_FAILED:
{
len = len + sprintf(prBuf+len, "TSAP recovery failed");
break;
}
case LCM_EVENT_UI_INV_EVT:
{
len = len + sprintf(prBuf+len, "upper interface invalid event");
break;
}
case LCM_EVENT_LI_INV_EVT:
{
len = len + sprintf(prBuf+len, "lower interface invalid event");
break;
}
case LCM_EVENT_PI_INV_EVT:
{
len = len + sprintf(prBuf+len, "peer interface invalid event");
break;
}
case LCM_EVENT_INV_EVT:
{
len = len + sprintf(prBuf+len, "general invalid event");
break;
}
case LCM_EVENT_INV_STATE:
{
len = len + sprintf(prBuf+len, "invalid internal state");
break;
}
case LCM_EVENT_INV_TMR_EVT:
{
len = len + sprintf(prBuf+len, "invalid timer event");
break;
}
case LCM_EVENT_MI_INV_EVT:
{
len = len + sprintf(prBuf+len, "management interface invalid event");
break;
}
case LCM_EVENT_BND_FAIL:
{
len = len + sprintf(prBuf+len, "bind failure");
break;
}
case LCM_EVENT_NAK:
{
len = len + sprintf(prBuf+len, "destination nack");
break;
}
case LCM_EVENT_TIMEOUT:
{
len = len + sprintf(prBuf+len, "timeout");
break;
}
case LCM_EVENT_BND_OK:
{
len = len + sprintf(prBuf+len, "bind ok");
break;
}
case LCM_EVENT_SMEM_ALLOC_FAIL:
{
len = len + sprintf(prBuf+len, "static memory allocation failed");
break;
}
case LCM_EVENT_DMEM_ALLOC_FAIL:
{
len = len + sprintf(prBuf+len, "dynamic mmemory allocation failed");
break;
}
case LCM_EVENT_LYR_SPECIFIC:
{
len = len + sprintf(prBuf+len, "MGCP specific");
break;
}
default:
{
len = len + sprintf(prBuf+len, "unknown event %d", (int)(usta->t.usta.alarm.event));
break;
}
case LMG_EVENT_HIT_BNDCFM:
{
len = len + sprintf(prBuf+len, "HIT bind confirm");
break;
}
case LMG_EVENT_HIT_CONCFM:
{
len = len + sprintf(prBuf+len, "HIT connect confirm");
break;
}
case LMG_EVENT_HIT_DISCIND:
{
len = len + sprintf(prBuf+len, "HIT disconnect indication");
break;
}
case LMG_EVENT_HIT_UDATIND:
{
len = len + sprintf(prBuf+len, "HIT unit data indication");
break;
}
case LMG_EVENT_MGT_BNDREQ:
{
len = len + sprintf(prBuf+len, "MGT bind request");
break;
}
case LMG_EVENT_PEER_CFG_FAIL:
{
len = len + sprintf(prBuf+len, "Peer Configuration Failed");
break;
}
case LMG_EVENT_MGT_UBNDREQ:
{
len = len + sprintf(prBuf+len, "MGT unbind request");
break;
}
case LMG_EVENT_MGT_MGCPTXNREQ:
{
len = len + sprintf(prBuf+len, "MGT MGCP transaction request");
break;
}
case LMG_EVENT_MGT_MGCPTXNIND:
{
len = len + sprintf(prBuf+len, "MGT MGCP transaction indication");
break;
}
case LMG_EVENT_PEER_ENABLED:
{
len = len + sprintf(prBuf+len, "gateway enabled");
break;
}
case LMG_EVENT_PEER_DISCOVERED:
{
len = len + sprintf(prBuf+len, "gateway discovered , notified entity");
break;
}
case LMG_EVENT_PEER_REMOVED:
{
len = len + sprintf(prBuf+len, "gateway removed");
break;
}
case LMG_EVENT_RES_CONG_ON:
{
len = len + sprintf(prBuf+len, "resource congestion ON");
break;
}
case LMG_EVENT_RES_CONG_OFF:
{
len = len + sprintf(prBuf+len, "resource congestion OFF");
break;
}
case LMG_EVENT_TPTSRV:
{
len = len + sprintf(prBuf+len, "transport service");
break;
}
case LMG_EVENT_SSAP_ENABLED:
{
len = len + sprintf(prBuf+len, "SSAP enabled");
break;
}
case LMG_EVENT_NS_NOT_RESPONDING:
{
len = len + sprintf(prBuf+len, "name server not responding");
break;
}
case LMG_EVENT_TPT_FAILED:
{
len = len + sprintf(prBuf+len, "transport failure");
break;
}
}
len = len + sprintf(prBuf+len, " ) ");
len = len + sprintf(prBuf+len, " cause ( ");
switch (usta->t.usta.alarm.cause)
{
case LCM_CAUSE_UNKNOWN:
{
len = len + sprintf(prBuf+len, "unknown");
break;
}
case LCM_CAUSE_OUT_OF_RANGE:
{
len = len + sprintf(prBuf+len, "out of range");
break;
}
case LCM_CAUSE_INV_SAP:
{
len = len + sprintf(prBuf+len, "NULL/unknown sap");
break;
}
case LCM_CAUSE_INV_SPID:
{
len = len + sprintf(prBuf+len, "invalid service provider");
break;
}
case LCM_CAUSE_INV_SUID:
{
len = len + sprintf(prBuf+len, "invalid service user");
break;
}
case LCM_CAUSE_INV_NETWORK_MSG:
{
len = len + sprintf(prBuf+len, "invalid network message");
break;
}
case LCM_CAUSE_DECODE_ERR:
{
len = len + sprintf(prBuf+len, "message decoding problem");
break;
}
case LCM_CAUSE_USER_INITIATED:
{
len = len + sprintf(prBuf+len, "user initiated");
break;
}
case LCM_CAUSE_MGMT_INITIATED:
{
len = len + sprintf(prBuf+len, "management initiated");
break;
}
case LCM_CAUSE_INV_STATE: /* cause and event! */
{
len = len + sprintf(prBuf+len, "invalid state");
break;
}
case LCM_CAUSE_TMR_EXPIRED: /* cause and event! */
{
len = len + sprintf(prBuf+len, "timer expired");
break;
}
case LCM_CAUSE_INV_MSG_LENGTH:
{
len = len + sprintf(prBuf+len, "invalid message length");
break;
}
case LCM_CAUSE_PROT_NOT_ACTIVE:
{
len = len + sprintf(prBuf+len, "protocol layer not active");
break;
}
case LCM_CAUSE_INV_PAR_VAL:
{
len = len + sprintf(prBuf+len, "invalid parameter value");
break;
}
case LCM_CAUSE_NEG_CFM:
{
len = len + sprintf(prBuf+len, "negative confirmation");
break;
}
case LCM_CAUSE_MEM_ALLOC_FAIL:
{
len = len + sprintf(prBuf+len, "memory allocation failure");
break;
}
case LCM_CAUSE_HASH_FAIL:
{
len = len + sprintf(prBuf+len, "hashing failure");
break;
}
case LCM_CAUSE_LYR_SPECIFIC:
{
len = len + sprintf(prBuf+len, "MGCP specific");
break;
}
default:
{
len = len + sprintf(prBuf+len, "unknown %d", (int)(usta->t.usta.alarm.cause));
break;
}
case LMG_CAUSE_TPT_FAILURE: /* make up your mind - cause or event? */
{
len = len + sprintf(prBuf+len, "transport failure");
break;
}
case LMG_CAUSE_NS_NOT_RESPONDING:
{
len = len + sprintf(prBuf+len, "name server not responding");
break;
}
}
len = len + sprintf(prBuf+len, " ) ");
len = len + sprintf(prBuf+len, " Alarm parameters ( ");
ret = smmgGetAlarmInfoField(&usta->t.usta);
switch (ret)
{
case SMMG_UNKNOWNFIELD:
{
len = len + sprintf(prBuf+len, "invalid ");
break;
}
case SMMG_PEERINFO:
{
/*
* Invoke the new function for printing the MgPeerInfo &
* delete all print code here
*/
smmgPrntPeerInfo(&(usta->t.usta.alarmInfo.u.peerInfo));
break;
}
case SMMG_SAPID:
{
len = len + sprintf(prBuf+len, "SAP ID %d\n", (int)(usta->t.usta.alarmInfo.u.sapId));
break;
}
case SMMG_MEM:
{
len = len + sprintf(prBuf+len, "memory region %d pool %d\n",
(int)(usta->t.usta.alarmInfo.u.mem.region),
(int)(usta->t.usta.alarmInfo.u.mem.pool));
break;
}
case SMMG_SRVSTA:
{
smmgPrntSrvSta(&usta->t.usta.alarmInfo.u.srvSta);
break;
}
case SMMG_PEERSTA:
{
smmgPrntPeerSta(&usta->t.usta.alarmInfo.u.peerSta);
break;
}
case SMMG_SSAPSTA:
{
smmgPrntSsapSta(&usta->t.usta.alarmInfo.u.ssapSta);
break;
}
case SMMG_PARID:
{
len = len + sprintf(prBuf+len, "parameter type: ");
switch (usta->t.usta.alarmInfo.u.parId.parType)
{
case LMG_PAR_TPTADDR: len = len + sprintf(prBuf+len, "transport address"); break;
case LMG_PAR_MBUF: len = len + sprintf(prBuf+len, "message buffer"); break;
case LMG_PAR_CHOICE: len = len + sprintf(prBuf+len, "choice"); break;
case LMG_PAR_SPID: len = len + sprintf(prBuf+len, "spId"); break;
default: len = len + sprintf(prBuf+len, "unknown"); break;
}
len = len + sprintf(prBuf+len, ", value %d\n",
(int)(usta->t.usta.alarmInfo.u.parId.u.sapId));
break;
}
case SMMG_NOT_APPL:
{
len = len + sprintf(prBuf+len, "not applicable\n");
break;
}
/*TODO*/
}
len = len + sprintf(prBuf+len, " ) ");
len = len + sprintf(prBuf+len, " \n ");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%s \n", prBuf);
}
/*****************************************************************************************************************************/
void handle_tucl_alarm(Pst *pst, HiMngmt *sta)
{
/* To print the general information */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Recieved a status indication from TUCL layer \n\n");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " Category = %d , event = %d , cause = %d\n",
sta->t.usta.alarm.category,
sta->t.usta.alarm.event, sta->t.usta.alarm.cause);
switch(sta->t.usta.alarm.event)
{
case LCM_EVENT_INV_EVT:
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," [HI_USTA]: LCM_EVENT_INV_EVT with type (%d)\n\n",
sta->t.usta.info.type);
break;
}
case LHI_EVENT_BNDREQ:
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," [HI_USTA]: LHI_EVENT_BNDREQ with type (%d) spId (%d)\n\n",
sta->t.usta.info.type, sta->t.usta.info.spId);
break;
}
case LHI_EVENT_SERVOPENREQ:
case LHI_EVENT_DATREQ:
case LHI_EVENT_UDATREQ:
case LHI_EVENT_CONREQ:
case LHI_EVENT_DISCREQ:
#if(defined(HI_TLS) && defined(HI_TCP_TLS))
case LHI_EVENT_TLS_ESTREQ:
#endif
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," [HI_USTA]: partype (%d) type(%d)\n\n",
sta->t.usta.info.inf.parType, sta->t.usta.info.type);
break;
}
case LCM_EVENT_DMEM_ALLOC_FAIL:
case LCM_EVENT_SMEM_ALLOC_FAIL:
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " [HI_USTA]: MEM_ALLOC_FAIL with region(%d) pool (%d) type(%d)\n\n",
sta->t.usta.info.inf.mem.region, sta->t.usta.info.inf.mem.pool,
sta->t.usta.info.type);
break;
}
default:
break;
}
} /* handle_sng_tucl_alarm */
/******************************************************************************/
int sng_mgco_mg_get_status(int elemId, MgMngmt* cfm, int mg_cfg_idx)
{
Pst pst;
MgMngmt cntrl;
sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[mg_cfg_idx];
sng_mg_peer_t* mgPeer = &megaco_globals.g_mg_cfg.mgPeer.peers[mgCfg->peer_id];
CmInetIpAddr ipAddr = 0;
memset((U8 *)&pst, 0, sizeof(Pst));
memset((U8 *)&cntrl, 0, sizeof(MgCntrl));
smPstInit(&pst);
pst.dstEnt = ENTMG;
/* prepare header */
/*cntrl.hdr.msgType = TCNTRL; */ /* message type */
cntrl.hdr.entId.ent = ENTMG; /* entity */
cntrl.hdr.entId.inst = 0; /* instance */
cntrl.hdr.elmId.elmnt = elemId; /* General */
cntrl.hdr.response.selector = 0;
cntrl.hdr.response.prior = PRIOR0;
cntrl.hdr.response.route = RTESPEC;
cntrl.hdr.response.mem.region = S_REG;
cntrl.hdr.response.mem.pool = S_POOL;
switch(elemId)
{
case STGCPENT:
{
cntrl.t.ssta.s.mgPeerSta.peerId.pres = PRSNT_NODEF;
cntrl.t.ssta.s.mgPeerSta.peerId.val = mgCfg->peer_id;
cntrl.t.ssta.s.mgPeerSta.mid.pres = PRSNT_NODEF;
cntrl.t.ssta.s.mgPeerSta.mid.len = strlen((char*)mgPeer->mid);
cmMemcpy((U8 *)cntrl.t.ssta.s.mgPeerSta.mid.val,
(CONSTANT U8*)(char*)mgPeer->mid,
cntrl.t.ssta.s.mgPeerSta.mid.len);
break;
}
case STSSAP:
{
cntrl.t.ssta.s.mgSSAPSta.sapId = mgCfg->id;
break;
}
case STTSAP:
{
cntrl.t.ssta.s.mgTSAPSta.tSapId = GET_TPT_ID(mg_cfg_idx);
break;
}
case STSERVER:
{
cntrl.t.ssta.s.mgTptSrvSta.tptAddr.type = CM_INET_IPV4ADDR_TYPE;
cntrl.t.ssta.s.mgTptSrvSta.tptAddr.u.ipv4TptAddr.port = ntohl(ipAddr);
if(ROK == cmInetAddr((S8*)mgCfg->my_ipaddr, &ipAddr))
{
cntrl.t.ssta.s.mgTptSrvSta.tptAddr.u.ipv4TptAddr.address = ntohl(ipAddr);
}
break;
}
default:
break;
}
return (sng_sta_mg (&pst, &cntrl, cfm));
}
/******************************************************************************/
switch_status_t megaco_profile_status(switch_stream_handle_t *stream, const char* profilename)
{
int idx = 0x00;
int len = 0x00;
MgMngmt cfm;
char prntBuf[1024];
switch_assert(profilename);
memset((U8 *)&cfm, 0, sizeof(cfm));
memset((char *)&prntBuf, 0, sizeof(prntBuf));
GET_MG_CFG_IDX(profilename, idx);
if(!idx || (idx == MAX_MG_PROFILES)){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG configuration found against profilename[%s]\n",profilename);
return SWITCH_STATUS_FALSE;
}
/*stream->write_function(stream, "Collecting MG Profile[%s] status... \n",profilename);*/
/* Fetch data from Trillium MEGACO Stack *
* SystemId - Software version information *
* SSAP - MG SAP Information *
* TSAP - MG Transport SAP Information *
* Peer - MG Peer Information *
* TPT-Server - MG Transport Server information *
*/
#if 0
/* get System ID */
sng_mgco_mg_get_status(STSID, &cfm, idx);
stream->write_function(stream, "***********************************************\n");
stream->write_function(stream, "**** TRILLIUM MEGACO Software Information *****\n");
stream->write_function(stream, "Version = %d \n", cfm.t.ssta.s.systemId.mVer);
stream->write_function(stream, "Version Revision = %d \n", cfm.t.ssta.s.systemId.mRev);
stream->write_function(stream, "Branch Version = %d \n", cfm.t.ssta.s.systemId.bVer);
stream->write_function(stream, "Branch Revision = %d \n", cfm.t.ssta.s.systemId.bRev);
stream->write_function(stream, "Part Number = %d \n", cfm.t.ssta.s.systemId.ptNmb);
stream->write_function(stream, "***********************************************\n");
#endif
/* MG Peer Information */
sng_mgco_mg_get_status(STGCPENT, &cfm, idx);
smmgPrntPeerSta(&cfm.t.ssta.s.mgPeerSta);
/* MG Peer Information */
sng_mgco_mg_get_status(STSSAP, &cfm, idx);
smmgPrntSsapSta(&cfm.t.ssta.s.mgSSAPSta);
/* MG Transport SAP Information */
sng_mgco_mg_get_status(STTSAP, &cfm, idx);
len = len + sprintf(prntBuf+len,"***********************************************\n");
len = len + sprintf(prntBuf+len,"**********MG TRANSPORT SAP Information**********\n");
len = len + sprintf(prntBuf+len,"TSAP status:\n");
len = len + sprintf(prntBuf+len,"state = %d, number of listeners %u\n",
(int)(cfm.t.ssta.s.mgTSAPSta.state),
(unsigned int)(cfm.t.ssta.s.mgTSAPSta.numServers));
len = len + sprintf(prntBuf+len,"***********************************************\n");
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"%s\n",prntBuf);
/* MG Transport Server Information */
sng_mgco_mg_get_status(STSERVER, &cfm, idx);
smmgPrntSrvSta(&cfm.t.ssta.s.mgTptSrvSta);
return SWITCH_STATUS_SUCCESS;
}
/******************************************************************************/
switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, const char* profilename)
{
int idx = 0x00;
int len = 0x00;
MgMngmt cfm;
char* xmlhdr = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
char prntBuf[10024];
sng_mg_cfg_t* mgCfg = NULL;
sng_mg_peer_t* mgPeer = NULL;
int i = 0x00;
char *asciiAddr;
CmInetIpAddr ip;
switch_assert(profilename);
memset((U8 *)&cfm, 0, sizeof(cfm));
memset((char *)&prntBuf, 0, sizeof(prntBuf));
GET_MG_CFG_IDX(profilename, idx);
if(!idx || (idx == MAX_MG_PROFILES)){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG configuration found against profilename[%s]\n",profilename);
return SWITCH_STATUS_FALSE;
}
mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx];
mgPeer = &megaco_globals.g_mg_cfg.mgPeer.peers[mgCfg->peer_id];
len = len + sprintf(&prntBuf[0] + len,"%s\n",xmlhdr);
len = len + sprintf(&prntBuf[0] + len,"<mg_profile>\n");
len = len + sprintf(&prntBuf[0] + len,"<name>%s</name>\n",mgCfg->name);
len = len + sprintf(&prntBuf[0] + len,"<profile>%s</profile>\n",profilename);
/****************************************************************************************************************/
/* Print Peer Information ***************************************************************************************/
/* TODO - as of now supporting only one peer .. need to add logic to iterate through all the peers associated with this profile..*/
len = len + sprintf(&prntBuf[0] + len,"<mg_peers>\n");
len = len + sprintf(&prntBuf[0] + len,"<mg_peer name=%s>\n",mgPeer->name);
/* send request to MEGACO Trillium stack to get peer information*/
sng_mgco_mg_get_status(STGCPENT, &cfm, idx);
get_peer_xml_buffer(&prntBuf[0] + len, &cfm.t.ssta.s.mgPeerSta);
len = len + sprintf(&prntBuf[0] + len,"</mg_peer>\n");
len = len + sprintf(&prntBuf[0] + len,"</mg_peers>\n");
/****************************************************************************************************************/
/* Print MG SAP Information ***************************************************************************************/
len = len + sprintf(&prntBuf[0] + len,"<mg_sap>\n");
/* MG SAP Information */
sng_mgco_mg_get_status(STSSAP, &cfm, idx);
len = len + sprintf(prntBuf+len, "<state> %s </state>\n", PRNT_SAP_STATE((int)(cfm.t.ssta.s.mgSSAPSta.state)));
len = len + sprintf(prntBuf+len, "<num_of_peer> %u </num_of_peer>\n", (unsigned int)(cfm.t.ssta.s.mgSSAPSta.numAssocPeer));
len = len + sprintf(prntBuf+len, "<num_of_listeners> %u </num_of_listeners>\n", (unsigned int)(cfm.t.ssta.s.mgSSAPSta.numServers));
len = len + sprintf(&prntBuf[0] + len,"<mg_sap_peers>\n");
for (i = 0; i < cfm.t.ssta.s.mgSSAPSta.numAssocPeer; i++)
{
len = len + sprintf(&prntBuf[0] + len,"<mg_sap_peer>\n");
if(cfm.t.ssta.s.mgSSAPSta.peerInfo[i].dname.namePres.pres == PRSNT_NODEF)
{
len = len + sprintf(prntBuf+len, "<domain_name> %s </domain_name>\n", (char *)(cfm.t.ssta.s.mgSSAPSta.peerInfo[i].dname.name));
}
switch(cfm.t.ssta.s.mgSSAPSta.peerInfo[i].dname.netAddr.type)
{
case CM_NETADDR_IPV4:
{
ip = ntohl(cfm.t.ssta.s.mgSSAPSta.peerInfo[i].dname.netAddr.u.ipv4NetAddr);
cmInetNtoa(ip, &asciiAddr);
len = len + sprintf(prntBuf+len, "<ipv4_address>%s</ipv4_address>\n",asciiAddr);
break;
}
default:
len = len + sprintf(prntBuf+len, "<ip_address>invalid type </ip_address>\n");
break;
}
#ifdef GCP_MGCO
if (PRSNT_NODEF == cfm.t.ssta.s.mgSSAPSta.peerInfo[i].mid.pres)
{
len = len + sprintf(prntBuf+len, "<peer_mid> %s </peer_mid>\n", (char *)(cfm.t.ssta.s.mgSSAPSta.peerInfo[i].mid.val));
}
#endif /* GCP_MGCO */
len = len + sprintf(&prntBuf[0] + len,"</mg_sap_peer>\n");
}
len = len + sprintf(&prntBuf[0] + len,"</mg_sap_peers>\n");
len = len + sprintf(&prntBuf[0] + len,"</mg_sap>\n");
/****************************************************************************************************************/
/* Print MG Transport SAP Information ***************************************************************************************/
len = len + sprintf(&prntBuf[0] + len,"<mg_transport_sap>\n");
/* MG Transport SAP Information */
sng_mgco_mg_get_status(STTSAP, &cfm, idx);
len = len + sprintf(&prntBuf[0] + len,"<state> %s </state>\n", PRNT_SAP_STATE(cfm.t.ssta.s.mgTSAPSta.state));
len = len + sprintf(&prntBuf[0] + len,"<num_of_listeners> %u </num_of_listeners>\n", (unsigned int)(cfm.t.ssta.s.mgTSAPSta.numServers));
len = len + sprintf(&prntBuf[0] + len,"</mg_transport_sap>\n");
/****************************************************************************************************************/
/* Print MG Transport Server Information ***************************************************************************************/
if(sng_mgco_mg_get_status(STSERVER, &cfm, idx)){
len = len + sprintf(&prntBuf[0] + len,"<mg_transport_server> no established server found </mg_transport_server>\n");
}
else {
len = len + sprintf(&prntBuf[0] + len,"<mg_transport_server>\n");
len = len + sprintf(&prntBuf[0] + len,"<state> %s </state>\n", PRNT_SAP_STATE(cfm.t.ssta.s.mgTptSrvSta.state));
len = len + sprintf(prntBuf+len, "<transport_address>");
switch (cfm.t.ssta.s.mgTptSrvSta.tptAddr.type)
{
case CM_TPTADDR_NOTPRSNT:
{
len = len + sprintf(prntBuf+len, "none");
break;
}
case CM_TPTADDR_IPV4:
{
ip = ntohl(cfm.t.ssta.s.mgTptSrvSta.tptAddr.u.ipv4TptAddr.address);
cmInetNtoa(ip, &asciiAddr);
len = len + sprintf(prntBuf+len, "IPv4 IP address #%s, port %u",asciiAddr,
(unsigned int)(cfm.t.ssta.s.mgTptSrvSta.tptAddr.u.ipv4TptAddr.port));
break;
}
default:
len = len + sprintf(prntBuf+len, "unknown");
break;
}
len = len + sprintf(prntBuf+len, "</transport_address>\n");
len = len + sprintf(&prntBuf[0] + len,"</mg_transport_server>\n");
}
/****************************************************************************************************************/
len = len + sprintf(&prntBuf[0] + len,"</mg_profile>\n");
stream->write_function(stream, "\n%s\n",&prntBuf[0]);
return SWITCH_STATUS_SUCCESS;
}
/******************************************************************************/
void get_peer_xml_buffer(char* prntBuf, MgPeerSta* cfm)
{
int len = 0x00;
int i = 0x00;
char *asciiAddr;
CmInetIpAddr ip;
if(PRSNT_NODEF == cfm->namePres.pres)
{
len = len + sprintf(prntBuf+len, "<domain_name> %s </domain_name>\n", (char *)(cfm->name));
}
else
{
len = len + sprintf(prntBuf+len, "<domain_name> Not Present </domain_name>\n");
}
/*
* Print all IP addresses in the IP addr table
*/
for(i=0; i<cfm->peerAddrTbl.count; i++)
{
switch (cfm->peerAddrTbl.netAddr[i].type)
{
case CM_NETADDR_IPV4:
{
ip = ntohl(cfm->peerAddrTbl.netAddr[i].u.ipv4NetAddr);
cmInetNtoa(ip, &asciiAddr);
len = len + sprintf(prntBuf+len, "<ipv4_address>%s</ipv4_address>\n",asciiAddr);
break;
}
case CM_NETADDR_IPV6:
{
char ipv6_buf[128];
int len1= 0;
int j = 0;
memset(&ipv6_buf[0], 0, sizeof(ipv6_buf));
len1 = len1 + sprintf(ipv6_buf+len1, "IP V6 address : %2x", (unsigned int)
(cfm->peerAddrTbl.netAddr[i].u.ipv6NetAddr[0]));
for (j = 1; j < CM_IPV6ADDR_SIZE; j++)
{
len1 = len1 + sprintf(ipv6_buf+len1, ":%2x", (unsigned int)
(cfm->peerAddrTbl.netAddr[i].u.ipv6NetAddr[j]));
}
len1 = len1 + sprintf(ipv6_buf+len1, "\n");
len = len + sprintf(prntBuf+len, "<ipv6_address>%s</ipv6_address>\n", ipv6_buf);
break;
}
default:
{
len = len + sprintf(prntBuf+len, "<ip_address> Invalid address type[%d]</ip_address>\n", cfm->peerAddrTbl.netAddr[i].type);
break;
}
}
} /* End of for */
len = len + sprintf(prntBuf+len,"<num_of_pending_out_txn> %lu </num_of_pending_out_txn>\n",(unsigned long)(cfm->numPendOgTxn));
len = len + sprintf(prntBuf+len,"<num_of_pending_in_txn> %lu </num_of_pending_in_txn>\n",(unsigned long)(cfm->numPendIcTxn));
len = len + sprintf(prntBuf+len,"<round_trip_estimate_time> %lu </round_trip_estimate_time>\n",(unsigned long)(cfm->rttEstimate));
switch(cfm->protocol)
{
case LMG_PROTOCOL_MGCP:
len = len + sprintf(prntBuf+len,"<protocol_type> MGCP </protocol_type>\n");
break;
case LMG_PROTOCOL_MGCO:
len = len + sprintf(prntBuf+len,"<protocol_type> MEGACO </protocol_type>\n");
break;
case LMG_PROTOCOL_NONE:
len = len + sprintf(prntBuf+len,"<protocol_type> MGCP/MEGACO </protocol_type>\n");
break;
default:
len = len + sprintf(prntBuf+len,"<protocol_type> invalid </protocol_type>\n");
break;
}
switch(cfm->transportType)
{
case LMG_TPT_UDP:
len = len + sprintf(prntBuf+len, "<transport_type>UDP</transport_type>\n");
break;
case LMG_TPT_TCP:
len = len + sprintf(prntBuf+len, "<transport_type>TCP</transport_type>\n");
break;
case LMG_TPT_NONE:
len = len + sprintf(prntBuf+len, "<transport_type>UDP/TCP</transport_type>\n");
break;
default:
len = len + sprintf(prntBuf+len, "<transport_type>invalid</transport_type>\n");
break;
}
#ifdef GCP_MGCO
switch(cfm->encodingScheme)
{
case LMG_ENCODE_BIN:
len = len + sprintf(prntBuf+len, "<encoding_type>BINARY</encoding_type>\n");
break;
case LMG_ENCODE_TXT:
len = len + sprintf(prntBuf+len, "<encoding_type>TEXT</encoding_type>\n");
break;
case LMG_ENCODE_NONE:
len = len + sprintf(prntBuf+len, "<encoding_type>TEXT/BINARY</encoding_type>\n");
break;
default:
len = len + sprintf(prntBuf+len, "<encoding_type>invalid</encoding_type>\n");
break;
}
if(LMG_VER_PROF_MGCO_H248_1_0 == cfm->version){
len = len + sprintf(prntBuf+len, "<version>1.0</version> \n");
} else if(LMG_VER_PROF_MGCO_H248_2_0 == cfm->version){
len = len + sprintf(prntBuf+len, "<version>2.0</version> \n");
}else if(LMG_VER_PROF_MGCO_H248_3_0 == cfm->version){
len = len + sprintf(prntBuf+len, "<version>3.0</version> \n");
} else{
len = len + sprintf(prntBuf+len, "<version>invalid</version> \n");
}
#endif
}
src/mod/endpoints/mod_megaco/megaco_stack.h
浏览文件 @ d147dcd5
......@@ -76,6 +76,7 @@ typedef struct sng_mg_cfg{
uint8_t my_domain[MAX_DOMAIN_LEN]; /* local domain name */
uint8_t my_ipaddr[MAX_DOMAIN_LEN]; /* local domain name */
uint32_t port; /* port */
uint16_t protocol_version; /* Protocol supported version */
uint16_t peer_id; /* MGC Peer ID */
uint16_t transport_prof_id; /* Transport profile id ..this also will be the spId for MG SAP*/
uint16_t protocol_type; /* MEGACO/MGCP */
......@@ -83,6 +84,7 @@ typedef struct sng_mg_cfg{
typedef struct sng_mg_gbl_cfg{
int num_of_mg_profiles;
sng_mg_cfg_t mgCfg[MAX_MG_PROFILES + 1];
sng_mg_transport_profile_t mgTptProf[MG_MAX_PEERS+1]; /* transport profile */
sng_mg_peers_t mgPeer;
......@@ -108,7 +110,11 @@ void handle_tucl_alarm(Pst *pst, HiMngmt *sta);
switch_status_t sng_mgco_init(sng_isup_event_interface_t* event);
switch_status_t sng_mgco_cfg(const char* profilename);
switch_status_t sng_mgco_start(const char* profilename);
switch_status_t sng_mgco_stop(const char* profilename);
switch_status_t sng_mgco_stack_shutdown(void);
int sng_mgco_mg_get_status(int elemId, MgMngmt* cfm, int mg_cfg_idx);
switch_status_t megaco_profile_status(switch_stream_handle_t *stream, const char* profilename);
switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, const char* profilename);
/*****************************************************************************************************/
......
src/mod/endpoints/mod_megaco/megaco_xml.c
浏览文件 @ d147dcd5
......@@ -46,6 +46,17 @@ switch_status_t sng_parse_mg_profile(switch_xml_t mg_interface)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mg_interface protocol[%d] \n",
megaco_globals.g_mg_cfg.mgCfg[i].protocol_type);
/********************************************************************************************/
}else if(!strcasecmp(var, "version")){
/********************************************************************************************/
megaco_globals.g_mg_cfg.mgCfg[i].protocol_version = atoi(val);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mg_interface protocol version[%s] \n",val);
if((megaco_globals.g_mg_cfg.mgCfg[i].protocol_version < 1)
|| (megaco_globals.g_mg_cfg.mgCfg[i].protocol_version > 3))
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Protocol version[%s] , Supported values are [1/2/3] \n",val);
return SWITCH_STATUS_FALSE;
}
/********************************************************************************************/
}else if(!strcasecmp(var, "transportProfileId")){
/********************************************************************************************/
megaco_globals.g_mg_cfg.mgCfg[i].transport_prof_id = atoi(val);
......@@ -214,6 +225,8 @@ switch_status_t sng_parse_mg_peer_profile(switch_xml_t mg_peer_profile)
}
}
strcpy((char*)&megaco_globals.g_mg_cfg.mgPeer.peers[i].name[0], prof_name);
megaco_globals.g_mg_cfg.mgPeer.total_peer++;
return SWITCH_STATUS_SUCCESS;
}
......
src/mod/endpoints/mod_megaco/mod_megaco.c
浏览文件 @ d147dcd5
......@@ -16,7 +16,7 @@ SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_megaco_shutdown);
SWITCH_MODULE_DEFINITION(mod_megaco, mod_megaco_load, mod_megaco_shutdown, NULL);
#define MEGACO_FUNCTION_SYNTAX "profile [name] [start | stop]"
#define MEGACO_FUNCTION_SYNTAX "profile [name] [start | stop] [status] [xmlstatus]"
SWITCH_STANDARD_API(megaco_function)
{
int argc;
......@@ -56,7 +56,22 @@ SWITCH_STANDARD_API(megaco_function)
} else {
stream->write_function(stream, "-ERR No such profile\n");
}
}else if(!strcmp(argv[2], "status")) {
megaco_profile_t *profile = megaco_profile_locate(argv[1]);
if (profile) {
megaco_profile_status(stream, profile->name);
} else {
stream->write_function(stream, "-ERR No such profile\n");
}
}else if(!strcmp(argv[2], "xmlstatus")) {
megaco_profile_t *profile = megaco_profile_locate(argv[1]);
if (profile) {
megaco_profile_xmlstatus(stream, profile->name);
} else {
stream->write_function(stream, "-ERR No such profile\n");
}
}
}
goto done;
......@@ -115,6 +130,8 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_megaco_load)
switch_console_set_complete("add megaco profile ::megaco::list_profiles start");
switch_console_set_complete("add megaco profile ::megaco::list_profiles stop");
switch_console_set_complete("add megaco profile ::megaco::list_profiles status");
switch_console_set_complete("add megaco profile ::megaco::list_profiles xmlstatus");
switch_console_add_complete_func("::megaco::list_profiles", list_profiles);
......@@ -209,16 +226,6 @@ void handle_mgco_audit_cfm(Pst *pst, SuId suId, MgMgtAudit* audit, Reason reason
}
/*****************************************************************************************************************************/
void handle_mg_alarm(Pst *pst, MgMngmt *sta)
{
/*TODO*/
}
/*****************************************************************************************************************************/
void handle_tucl_alarm(Pst *pst, HiMngmt *sta)
{
/*TODO*/
}
/*****************************************************************************************************************************/
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论