From df76709e95241e7971e380e99f66853838902397 Mon Sep 17 00:00:00 2001 From: kapil Date: Thu, 17 May 2012 16:14:05 +0530 Subject: [PATCH] Adding code to bring up MEGACO stack --- src/mod/endpoints/mod_megaco/Makefile | 10 +- src/mod/endpoints/mod_megaco/megaco.c | 13 +- src/mod/endpoints/mod_megaco/megaco_stack.c | 964 ++++++++++++++++++ .../{megaco_cfg.h => megaco_stack.h} | 39 +- src/mod/endpoints/mod_megaco/megaco_xml.c | 1 + src/mod/endpoints/mod_megaco/mod_megaco.c | 15 +- src/mod/endpoints/mod_megaco/mod_megaco.h | 2 +- 7 files changed, 1031 insertions(+), 13 deletions(-) create mode 100644 src/mod/endpoints/mod_megaco/megaco_stack.c rename src/mod/endpoints/mod_megaco/{megaco_cfg.h => megaco_stack.h} (71%) diff --git a/src/mod/endpoints/mod_megaco/Makefile b/src/mod/endpoints/mod_megaco/Makefile index 29349edca1..4564a420e9 100644 --- a/src/mod/endpoints/mod_megaco/Makefile +++ b/src/mod/endpoints/mod_megaco/Makefile @@ -1,4 +1,12 @@ +ifndef ARCH + ARCH=$(shell uname -m) +endif + +ifeq ($(ARCH),x86_64) + LOCAL_CFLAGS+=-DBIT_64 -DALIGN_64BIT +endif + BASE=../../../.. -LOCAL_OBJS=megaco.o megaco_cfg.o +LOCAL_OBJS=megaco.o megaco_stack.o megaco_xml.o LOCAL_LDFLAGS=-lsng_megaco include $(BASE)/build/modmake.rules diff --git a/src/mod/endpoints/mod_megaco/megaco.c b/src/mod/endpoints/mod_megaco/megaco.c index 20024ace87..84bf70963b 100644 --- a/src/mod/endpoints/mod_megaco/megaco.c +++ b/src/mod/endpoints/mod_megaco/megaco.c @@ -96,7 +96,12 @@ static switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t r } } - status = SWITCH_STATUS_SUCCESS; + + /* configure the MEGACO stack */ + status = sng_mgco_cfg(profile->name); + + /* we should break from here , profile name should be unique */ + break; } done: @@ -131,6 +136,12 @@ switch_status_t megaco_profile_start(const char *profilename) goto fail; } + /* start MEGACP stack */ + if(SWITCH_STATUS_FALSE == sng_mgco_start(profilename)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error starting MEGACO Stack for profile %s\n", profile->name); + goto fail; + } + switch_core_hash_insert_wrlock(megaco_globals.profile_hash, profile->name, profile, megaco_globals.profile_rwlock); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Started profile: %s\n", profile->name); diff --git a/src/mod/endpoints/mod_megaco/megaco_stack.c b/src/mod/endpoints/mod_megaco/megaco_stack.c new file mode 100644 index 0000000000..4ba2cd05f6 --- /dev/null +++ b/src/mod/endpoints/mod_megaco/megaco_stack.c @@ -0,0 +1,964 @@ +/* +* Copyright (c) 2012, Sangoma Technologies +* Kapil Gupta +* All rights reserved. +* +* +*/ + +/* INCLUDES *******************************************************************/ +#include "mod_megaco.h" +/******************************************************************************/ + +/* DEFINES ********************************************************************/ + +/* FUNCTION PROTOTYPES ********************************************************/ +int mgco_mg_gen_config(void); +int mgco_mu_gen_config(void); +int mgco_tucl_gen_config(void); +int mgco_mu_ssap_config(int idx); +int mgco_mg_tsap_config(int idx); +int mgco_mg_enble_debug(void); +int mgco_mg_ssap_config(int idx); +int mgco_mg_peer_config(int idx); +int mgco_mg_tpt_server_config(int idx); +int mgco_tucl_sap_config(int idx); + +int mgco_mg_tsap_bind_cntrl(int idx); +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); + +switch_status_t sng_mgco_stack_gen_cfg(); + +/******************************************************************************/ + +/* FUNCTIONS ******************************************************************/ + +switch_status_t sng_mgco_init(sng_isup_event_interface_t* event) +{ + uint32_t major, minor, build; + + switch_assert(event); + + /* initalize sng_mg library */ + sng_isup_init_gen(event); + + /* print the version of the library being used */ + sng_isup_version(&major, &minor, &build); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Loaded LibSng-MEGACO %d.%d.%d\n", major, minor, build); + + /* start up the stack manager */ + if (sng_isup_init_sm()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Failed to start Stack Manager\n"); + return SWITCH_STATUS_FALSE; + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Started Stack Manager!\n"); + } + + if (sng_isup_init_tucl()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"Failed to start TUCL\n"); + return SWITCH_STATUS_FALSE; + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Started TUCL!\n"); + } + + if (sng_isup_init_mg()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"Failed to start MG\n"); + return SWITCH_STATUS_FALSE; + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Started MG!\n"); + } + + if (sng_isup_init_mu()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"Failed to start MU\n"); + return SWITCH_STATUS_FALSE; + } else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"Started MU!\n"); + } + + + /* gen config for all the layers of megaco */ + return sng_mgco_stack_gen_cfg(); +} + +/*****************************************************************************************************************/ +switch_status_t sng_mgco_stack_shutdown() +{ + /* free MEGACO Application */ + sng_isup_free_mu(); + + /* free MEGACO */ + sng_isup_free_mg(); + + /* free TUCL */ + sng_isup_free_tucl(); + + /* free SM */ + sng_isup_free_sm(); + + /* free gen */ + sng_isup_free_gen(); + + return SWITCH_STATUS_SUCCESS; +} + +/*****************************************************************************************************************/ +switch_status_t sng_mgco_stack_gen_cfg() +{ + if(mgco_mg_gen_config()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"MG Gen Config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"MG Gen Config SUCCESS \n"); + } + + if(mgco_mu_gen_config()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"MU(MG-Application) Gen Config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,"MU(MG-Application) Gen Config SUCCESS \n"); + } + + if(mgco_tucl_gen_config()) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," TUCL Gen Config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," TUCL Gen Config SUCCESS \n"); + } + + return SWITCH_STATUS_SUCCESS; +} + + +/*****************************************************************************************************************/ + +switch_status_t sng_mgco_cfg(const char* profilename) +{ + int idx = 0x00; + + 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," Starting MG configuration for idx[%d] against profilename[%s]\n", idx, profilename); + + if(mgco_tucl_sap_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," mgco_tucl_sap_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," mgco_tucl_sap_config SUCCESS \n"); + } + + + if(mgco_mu_ssap_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," mgco_mu_ssap_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," mgco_mu_ssap_config SUCCESS \n"); + } + + + if(mgco_mg_tsap_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," mgco_mg_tsap_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," mgco_mg_tsap_config SUCCESS \n"); + } + + if(mgco_mg_ssap_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_ssap_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_ssap_config SUCCESS \n"); + } + + if(mgco_mg_peer_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_peer_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_peer_config SUCCESS \n"); + } + + if(mgco_mg_tpt_server_config(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_tpt_server_config FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tpt_server_config SUCCESS \n"); + } + + return SWITCH_STATUS_SUCCESS; +} + +/*****************************************************************************************************************/ + +switch_status_t sng_mgco_start(const char* profilename) +{ + int idx = 0x00; + + 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," Starting MG stack for idx[%d] against profilename[%s]\n", idx, profilename); + + if(mgco_mu_ssap_cntrl(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mu_ssap_cntrl FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mu_ssap_cntrl SUCCESS \n"); + } + + if(mgco_mg_tsap_bind_cntrl(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_tsap_bind_cntrl FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tsap_bind_cntrl SUCCESS \n"); + } + + if(mgco_mg_ssap_cntrl(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_ssap_cntrl FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_ssap_cntrl SUCCESS \n"); + } + + if(mgco_mg_tsap_enable_cntrl(idx)) { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, " mgco_mg_tsap_enable_cntrl FAILED \n"); + return SWITCH_STATUS_FALSE; + } + else { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tsap_enable_cntrl SUCCESS \n"); + } + + return SWITCH_STATUS_SUCCESS; +} + +/*****************************************************************************************************************/ +int mgco_mg_tsap_bind_cntrl(int idx) +{ + MgMngmt mgMngmt; + Pst pst; /* Post for layer manager */ + MgCntrl *cntrl; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + + cntrl = &(mgMngmt.t.cntrl); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*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 = STTSAP; + + cntrl->action = ABND_ENA; + cntrl->subAction = SAELMNT; + cntrl->spId = GET_TPT_ID(idx); + + return(sng_cntrl_mg(&pst, &mgMngmt)); +} + +/*****************************************************************************************************************/ + +int mgco_mg_tsap_enable_cntrl(int idx) +{ + MgMngmt mgMngmt; + Pst pst; /* Post for layer manager */ + MgCntrl *cntrl; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + + cntrl = &(mgMngmt.t.cntrl); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*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 = STTSAP; + + cntrl->action = AENA; + cntrl->subAction = SAELMNT; + cntrl->spId = GET_TPT_ID(idx); + + return(sng_cntrl_mg(&pst, &mgMngmt)); +} + +/*****************************************************************************************************************/ + +int mgco_mg_tpt_server(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 = AENA; + cntrl->subAction = SAELMNT; + cntrl->spId = (SpId)0x01; + + return(sng_cntrl_mg(&pst, &mgMngmt)); +} + +/*****************************************************************************************************************/ + +int mgco_mu_ssap_cntrl(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 = ABND_ENA; + cntrl->subAction = SAELMNT; + + return(sng_cntrl_mu(&pst, &mgMngmt)); +} + +/*****************************************************************************************************************/ + +int mgco_mg_ssap_cntrl(int idx) +{ + MgMngmt mgMngmt; + Pst pst; /* Post for layer manager */ + MgCntrl *cntrl; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + + cntrl = &(mgMngmt.t.cntrl); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*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; + + cntrl->action = AENA; + cntrl->subAction = SAELMNT; + cntrl->spId = (SpId)1; + + return(sng_cntrl_mg(&pst, &mgMngmt)); +} +/******************************************************************************/ + +int mgco_mg_enble_debug() +{ + MgMngmt mgMngmt; + Pst pst; /* Post for layer manager */ + MgCntrl* cntrl; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + cntrl = &mgMngmt.t.cntrl; + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTHI; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STGEN; + + cntrl->action = AENA; + cntrl->subAction = SADBG; + cntrl->s.dbg.genDbgMask = 0xfffffdff; + + return(sng_cntrl_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ +int mgco_tucl_gen_config(void) +{ + HiMngmt cfg; + Pst pst; + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTHI; + + /* clear the configuration structure */ + memset(&cfg, 0, sizeof(cfg)); + + /* fill in the post structure */ + set_dest_sm_pst(&cfg.t.cfg.s.hiGen.lmPst); + /*fill in the specific fields of the header */ + cfg.hdr.msgType = TCFG; + cfg.hdr.entId.ent = ENTHI; + cfg.hdr.entId.inst = S_INST; + cfg.hdr.elmId.elmnt = STGEN; + + cfg.t.cfg.s.hiGen.numSaps = HI_MAX_SAPS; /* number of SAPs */ + cfg.t.cfg.s.hiGen.numCons = HI_MAX_NUM_OF_CON; /* maximum num of connections */ + cfg.t.cfg.s.hiGen.numFdsPerSet = HI_MAX_NUM_OF_FD_PER_SET; /* maximum num of fds to use per set */ + cfg.t.cfg.s.hiGen.numFdBins = HI_MAX_NUM_OF_FD_HASH_BINS; /* for fd hash lists */ + cfg.t.cfg.s.hiGen.numClToAccept = HI_MAX_NUM_OF_CLIENT_TO_ACCEPT; /* clients to accept simultaneously */ + cfg.t.cfg.s.hiGen.permTsk = TRUE; /* schedule as perm task or timer */ + cfg.t.cfg.s.hiGen.schdTmrVal = HI_MAX_SCHED_TMR_VALUE; /* if !permTsk - probably ignored */ + cfg.t.cfg.s.hiGen.selTimeout = HI_MAX_SELECT_TIMEOUT_VALUE; /* select() timeout */ + + /* number of raw/UDP messages to read in one iteration */ + cfg.t.cfg.s.hiGen.numRawMsgsToRead = HI_MAX_RAW_MSG_TO_READ; + cfg.t.cfg.s.hiGen.numUdpMsgsToRead = HI_MAX_UDP_MSG_TO_READ; + + /* thresholds for congestion on the memory pool */ + cfg.t.cfg.s.hiGen.poolStrtThr = HI_MEM_POOL_START_THRESHOLD; + cfg.t.cfg.s.hiGen.poolDropThr = HI_MEM_POOL_DROP_THRESHOLD; + cfg.t.cfg.s.hiGen.poolStopThr = HI_MEM_POOL_STOP_THRESHOLD; + + cfg.t.cfg.s.hiGen.timeRes = SI_PERIOD; /* time resolution */ + +#ifdef HI_SPECIFY_GENSOCK_ADDR + cfg.t.cfg.s.hiGen.ipv4GenSockAddr.address = CM_INET_INADDR_ANY; + cfg.t.cfg.s.hiGen.ipv4GenSockAddr.port = 0; /* DAVIDY - why 0? */ +#ifdef IPV6_SUPPORTED + cfg.t.cfg.s.hiGen.ipv6GenSockAddr.address = CM_INET_INADDR6_ANY; + cfg.t.cfg.s.hiGen.ipv4GenSockAddr.port = 0; +#endif +#endif + + return(sng_cfg_tucl(&pst, &cfg)); +} + +/******************************************************************************/ + +int mgco_tucl_sap_config(int idx) +{ + HiMngmt cfg; + Pst pst; + HiSapCfg *pCfg; + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTHI; + + /* clear the configuration structure */ + memset(&cfg, 0, sizeof(cfg)); + + /* fill in the post structure */ + set_dest_sm_pst(&cfg.t.cfg.s.hiGen.lmPst); + /*fill in the specific fields of the header */ + cfg.hdr.msgType = TCFG; + cfg.hdr.entId.ent = ENTHI; + cfg.hdr.entId.inst = S_INST; + cfg.hdr.elmId.elmnt = STTSAP; + + pCfg = &cfg.t.cfg.s.hiSap; + + pCfg->spId = GET_TPT_ID(idx); + pCfg->uiSel = 0x00; /*loosley coupled */ + pCfg->flcEnb = TRUE; + pCfg->txqCongStrtLim = HI_SAP_TXN_QUEUE_CONG_START_LIMIT; + pCfg->txqCongDropLim = HI_SAP_TXN_QUEUE_CONG_DROP_LIMIT; + pCfg->txqCongStopLim = HI_SAP_TXN_QUEUE_CONG_STOP_LIMIT; + pCfg->numBins = 10; + + pCfg->uiMemId.region = S_REG; + pCfg->uiMemId.pool = S_POOL; + pCfg->uiPrior = PRIOR0; + pCfg->uiRoute = RTESPEC; + + return(sng_cfg_tucl(&pst, &cfg)); +} + +/******************************************************************************/ + +int mgco_mg_gen_config(void) +{ + MgMngmt mgMngmt; + MgGenCfg *cfg; + Pst pst; /* Post for layer manager */ + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + cfg = &(mgMngmt.t.cfg.c.genCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /* fill in the post structure */ + set_dest_sm_pst(&mgMngmt.t.cfg.c.genCfg.lmPst); + /*fill in the specific fields of the header */ + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTMG; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STGEN; + + + /*----------- Fill General Configuration Parameters ---------*/ + cfg->maxSSaps = (U16)MG_MAX_SSAPS; + cfg->maxTSaps = (U32)MG_MAX_TSAPS; + cfg->maxServers = (U16)MG_MAX_SERVERS; + cfg->maxConn = (U32)10; + cfg->maxTxn = (U16)MG_MAX_OUTSTANDING_TRANSACTIONS; + cfg->maxPeer = (U32)MG_MAX_PEER; + cfg->resThUpper = (Status)7; + cfg->resThLower = (Status)3; +#if (defined(GCP_MGCP) || defined(TDS_ROLL_UPGRADE_SUPPORT)) + cfg->timeResTTL = (Ticks)10000; +#endif + + cfg->timeRes = (Ticks)10; + cfg->reCfg.rspAckEnb = MG_LMG_GET_RSPACK_MGCO; + cfg->numBlks = (U32)MG_NUM_BLK; + cfg->maxBlkSize = (Size)MG_MAXBLKSIZE; + cfg->numBinsTxnIdHl = (U16)149; + cfg->numBinsNameHl = (U16)149; + cfg->entType = LMG_ENT_GW; + cfg->numBinsTptSrvrHl = (U16)149; + cfg->indicateRetx = TRUE; /* Assume environment to be lossy */ + cfg->resOrder = LMG_RES_IPV4; /* IPV4 only */ + +#ifdef CM_ABNF_MT_LIB + cfg->firstInst = 1; + cfg->edEncTmr.enb = FALSE; + cfg->edEncTmr.val = (U16)50; + cfg->edDecTmr.enb = TRUE; + cfg->edDecTmr.val = (U16)50; + cfg->noEDInst = 1; +#endif /* CM_ABNF_MT_LIB */ + +#ifdef GCP_CH + cfg->numBinsPeerCmdHl = 20; + cfg->numBinsTransReqHl = 50; + cfg->numBinsTransIndRspCmdHl = 50; +#endif /* GCP_CH */ + +#ifdef GCP_MG + cfg->maxMgCmdTimeOut.enb =TRUE; + cfg->maxMgCmdTimeOut.val =20; +#endif /* GCP_MG */ + +#ifdef GCP_MG + cfg->maxMgCmdTimeOut.enb =TRUE; + cfg->maxMgCmdTimeOut.val =20; +#endif /* GCP_MG */ + +#ifdef GCP_MGC + cfg->maxMgcCmdTimeOut.enb =TRUE; + cfg->maxMgcCmdTimeOut.val =20; +#endif /* GCP_MG */ + +#if (defined(GCP_MGCO) && (defined GCP_VER_2_1)) + cfg->reCfg.segRspTmr.enb = TRUE; + cfg->reCfg.segRspTmr.val = (U16)50; + cfg->reCfg.segRspAckTmr.enb = TRUE; + cfg->reCfg.segRspAckTmr.val = (U16)25; +#endif + +#ifdef GCP_PKG_MGCO_ROOT + cfg->limit.pres.pres = PRSNT_NODEF; + cfg->limit.mgcOriginatedPendingLimit = 20000; + cfg->limit.mgOriginatedPendingLimit = 20000; +#endif /* GCP_PKG_MGCO_ROOT */ + + return(sng_cfg_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ + +int mgco_mu_gen_config(void) +{ + MuMngmt mgmt; + MuGenCfg *cfg; + Pst pst; /* Post for layer manager */ + + memset(&mgmt, 0, sizeof(mgmt)); + cfg = &(mgmt.t.cfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMU; + + /*fill in the specific fields of the header */ + mgmt.hdr.msgType = TCFG; + mgmt.hdr.entId.ent = ENTMU; + mgmt.hdr.entId.inst = S_INST; + mgmt.hdr.elmId.elmnt = STGEN; + + return(sng_cfg_mu(&pst, &mgmt)); +} + +/******************************************************************************/ + +int mgco_mu_ssap_config(int idx) +{ + MuMngmt mgmt; + MuSAP_t *cfg; + Pst pst; /* Post for layer manager */ + + memset(&mgmt, 0, sizeof(mgmt)); + cfg = &(mgmt.t.sapCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMU; + + /*fill in the specific fields of the header */ + mgmt.hdr.msgType = TCFG; + mgmt.hdr.entId.ent = ENTMU; + mgmt.hdr.entId.inst = S_INST; + mgmt.hdr.elmId.elmnt = STSSAP; + + /* fill lower layer i.e. MG PST */ + cfg->ssapId = GET_MU_SAP_ID(idx); /* SSAP ID */ + cfg->spId = GET_MU_SAP_ID(idx); /* SSAP ID */ + + cfg->mem.region = S_REG; + cfg->mem.pool = S_POOL; + cfg->dstProcId = SFndProcId(); + cfg->dstEnt = ENTMG; + cfg->dstInst = S_INST; + cfg->dstPrior = PRIOR0; + cfg->dstRoute = RTESPEC; + cfg->selector = 0x00; /* Loosely coupled */ + + return(sng_cfg_mu(&pst, &mgmt)); +} + +/******************************************************************************/ + +int mgco_mg_ssap_config(int idx) +{ + MgMngmt mgMngmt; + MgSSAPCfg *pCfg; + Pst pst; /* Post for layer manager */ + CmInetIpAddr ipAddr; + int len = 0x00; + sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx]; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + pCfg = &(mgMngmt.t.cfg.c.sSAPCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*fill in the specific fields of the header */ + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTMG; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STSSAP; + + /* FILL SAP config */ + + pCfg->sSAPId = mgCfg->id; /* SSAP ID */ + pCfg->sel = 0x00 ; /* Loosely coupled */ + pCfg->memId.region = S_REG; + pCfg->memId.pool = S_POOL; + pCfg->prior = PRIOR0; + pCfg->route = RTESPEC; + + pCfg->protocol = mgCfg->protocol_type; + + pCfg->startTxnNum = 50; + pCfg->endTxnNum = 60; + + pCfg->initReg = TRUE; + pCfg->mwdTimer = (U16)10; + + pCfg->minMgcoVersion = LMG_VER_PROF_MGCO_H248_1_0; + pCfg->maxMgcoVersion = LMG_VER_PROF_MGCO_H248_3_0; + + pCfg->userInfo.pres.pres = PRSNT_NODEF; + pCfg->userInfo.id.pres = NOTPRSNT; + pCfg->userInfo.mid.pres = PRSNT_NODEF; + pCfg->userInfo.dname.namePres.pres = PRSNT_NODEF; + + pCfg->userInfo.mid.len = (U8)strlen((char*)mgCfg->mid); + strncpy((char*)pCfg->userInfo.mid.val, (char*)mgCfg->mid, MAX_MID_LEN); + + len = (U32)strlen((char*)mgCfg->my_domain); + memcpy( (U8*)(pCfg->userInfo.dname.name), + (CONSTANT U8*)(mgCfg->my_domain), len ); + pCfg->userInfo.dname.name[len] = '\0'; + + pCfg->userInfo.dname.netAddr.type = CM_TPTADDR_IPV4; + memset(&ipAddr,'\0',sizeof(ipAddr)); + if(ROK == cmInetAddr((S8*)mgCfg->my_ipaddr,&ipAddr)) + { + pCfg->userInfo.dname.netAddr.u.ipv4NetAddr = ntohl(ipAddr); + } + + pCfg->reCfg.initRetxTmr.enb = TRUE; + pCfg->reCfg.initRetxTmr.val = MG_INIT_RTT; + pCfg->reCfg.provRspTmr.enb = TRUE; + pCfg->reCfg.provRspTmr.val = (U16)50; /* In timer resolution */ + pCfg->reCfg.provRspDelay = 2; + pCfg->reCfg.atMostOnceTmr.enb = TRUE; + pCfg->reCfg.atMostOnceTmr.val = (U16)30; + + return(sng_cfg_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ + +int mgco_mg_tsap_config(int idx) +{ + MgMngmt mgMngmt; + /* local variables */ + MgTSAPCfg *cfg; + Pst pst; /* Post for layer manager */ + sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx]; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + cfg = &(mgMngmt.t.cfg.c.tSAPCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*fill in the specific fields of the header */ + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTMG; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STTSAP; + + /* FILL TSAP config */ + cfg->tSAPId = mgCfg->id; + cfg->spId = GET_TPT_ID(idx); + cfg->provType = GET_TPT_TYPE(idx); + + /* FILL TUCL Information */ + cfg->memId.region = S_REG; + cfg->memId.pool = S_POOL; + cfg->dstProcId = SFndProcId(); + cfg->dstEnt = ENTHI; + cfg->dstInst = S_INST; + cfg->dstPrior = PRIOR0; + cfg->dstRoute = RTESPEC; + cfg->dstSel = 0x00; /* Loosely coupled */ + cfg->bndTmrCfg.enb = TRUE; + cfg->bndTmrCfg.val = 5; /* 5 seconds */ + + + /* Disable DNS as of now */ + cfg->reCfg.idleTmr.enb = FALSE; + cfg->reCfg.dnsCfg.dnsAccess = LMG_DNS_DISABLED; + cfg->reCfg.dnsCfg.dnsAddr.type = CM_TPTADDR_IPV4; + cfg->reCfg.dnsCfg.dnsAddr.u.ipv4TptAddr.port = (U16)53; + cfg->reCfg.dnsCfg.dnsAddr.u.ipv4TptAddr.address = (CmInetIpAddr)MG_DNS_IP; + + cfg->reCfg.dnsCfg.dnsRslvTmr.enb = FALSE; + cfg->reCfg.dnsCfg.dnsRslvTmr.val = 60; /* 60 sec */ + cfg->reCfg.dnsCfg.maxRetxCnt = 4; + + cfg->reCfg.tMax = 1000; + cfg->reCfg.tptParam.type = CM_TPTPARAM_SOCK; + cfg->reCfg.tptParam.u.sockParam.listenQSize = 5; + cfg->reCfg.tptParam.u.sockParam.numOpts = 0; + + + return(sng_cfg_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ + +int mgco_mg_peer_config(int idx) +{ + MgMngmt mgMngmt; + MgGcpEntCfg *cfg; + Pst pst; /* Post for layer manager */ + U32 peerIdx = 0; + CmInetIpAddr ipAddr = 0; + sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx]; + sng_mg_peer_t* mgPeer = &megaco_globals.g_mg_cfg.mgPeer.peers[mgCfg->peer_id]; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + cfg = &(mgMngmt.t.cfg.c.mgGcpEntCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*fill in the specific fields of the header */ + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTMG; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STGCPENT; + + cfg->numPeer = megaco_globals.g_mg_cfg.mgPeer.total_peer; + cfg->peerCfg[peerIdx].sSAPId = mgCfg->id; /* SSAP ID */; + cfg->peerCfg[peerIdx].port = mgPeer->port; + cfg->peerCfg[peerIdx].tsapId = GET_TPT_ID(idx); + + cfg->peerCfg[peerIdx].mtuSize = MG_MAX_MTU_SIZE; + + + cfg->peerCfg[peerIdx].peerAddrTbl.count = 1; + cfg->peerCfg[peerIdx].peerAddrTbl.netAddr[0].type = + CM_NETADDR_IPV4; + + if(ROK == cmInetAddr((S8*)&mgPeer->ipaddr[0],&ipAddr)) + { + cfg->peerCfg[peerIdx].peerAddrTbl.netAddr[0].u.ipv4NetAddr = ntohl(ipAddr); + } + else + { + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "cmInetAddr failed \n"); + cfg->peerCfg[peerIdx].peerAddrTbl.count = 0; + } + +#ifdef GCP_MG + cfg->peerCfg[peerIdx].transportType = GET_TPT_TYPE(idx); + cfg->peerCfg[peerIdx].encodingScheme = GET_ENCODING_TYPE(idx); + cfg->peerCfg[peerIdx].mgcPriority = 0; + cfg->peerCfg[peerIdx].useAHScheme = FALSE; + cfg->peerCfg[peerIdx].mid.pres = PRSNT_NODEF; + cfg->peerCfg[peerIdx].mid.len = strlen((char*)mgPeer->mid); + cmMemcpy((U8 *)cfg->peerCfg[peerIdx].mid.val, + (CONSTANT U8*)(char*)mgPeer->mid, + cfg->peerCfg[peerIdx].mid.len); + +#endif /* GCP_MG */ + + return(sng_cfg_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ + +int mgco_mg_tpt_server_config(int idx) +{ + MgMngmt mgMngmt; + MgTptSrvrCfg *cfg; + Pst pst; /* Post for layer manager */ + CmInetIpAddr ipAddr = 0; + sng_mg_cfg_t* mgCfg = &megaco_globals.g_mg_cfg.mgCfg[idx]; + int srvIdx = 0; + + memset(&mgMngmt, 0, sizeof(mgMngmt)); + cfg = &(mgMngmt.t.cfg.c.tptSrvrCfg); + + /* initalize the post structure */ + smPstInit(&pst); + + /* insert the destination Entity */ + pst.dstEnt = ENTMG; + + /*fill in the specific fields of the header */ + mgMngmt.hdr.msgType = TCFG; + mgMngmt.hdr.entId.ent = ENTMG; + mgMngmt.hdr.entId.inst = S_INST; + mgMngmt.hdr.elmId.elmnt = STSERVER; + + cfg->count = 1; + cfg->srvr[srvIdx].isDefault = TRUE; + cfg->srvr[srvIdx].sSAPId = mgCfg->id; + cfg->srvr[srvIdx].tSAPId = GET_TPT_ID(idx); + cfg->srvr[srvIdx].protocol = mgCfg->protocol_type; + cfg->srvr[srvIdx].transportType = GET_TPT_TYPE(idx); + cfg->srvr[srvIdx].encodingScheme = GET_ENCODING_TYPE(idx); + + cfg->srvr[srvIdx].tptParam.type = CM_TPTPARAM_SOCK; + cfg->srvr[srvIdx].tptParam.u.sockParam.listenQSize = 5; + cfg->srvr[srvIdx].tptParam.u.sockParam.numOpts = 0; + cfg->srvr[srvIdx].lclTptAddr.type = CM_TPTADDR_IPV4; + cfg->srvr[srvIdx].lclTptAddr.u.ipv4TptAddr.port = mgCfg->port; + if(ROK == cmInetAddr((S8*)mgCfg->my_ipaddr, &ipAddr)) + { + cfg->srvr[srvIdx].lclTptAddr.u.ipv4TptAddr.address = ntohl(ipAddr); + } + + return(sng_cfg_mg(&pst, &mgMngmt)); +} + +/******************************************************************************/ diff --git a/src/mod/endpoints/mod_megaco/megaco_cfg.h b/src/mod/endpoints/mod_megaco/megaco_stack.h similarity index 71% rename from src/mod/endpoints/mod_megaco/megaco_cfg.h rename to src/mod/endpoints/mod_megaco/megaco_stack.h index 54bf310b29..24cf6e26ca 100644 --- a/src/mod/endpoints/mod_megaco/megaco_cfg.h +++ b/src/mod/endpoints/mod_megaco/megaco_stack.h @@ -51,12 +51,21 @@ typedef enum{ SNG_MG_MEGACO, }sng_mg_protocol_types_e; +#define PRNT_PROTOCOL_TYPE(_val)\ + ((_val == SNG_MG_MGCP)?"SNG_MG_MGCP":\ + (_val == SNG_MG_MEGACO)?"SNG_MG_MEGACO":\ + "SNG_MG_NONE") + typedef enum{ SNG_MG_ENCODING_NONE, - SNG_MG_ENCODING_TEXT, SNG_MG_ENCODING_BINARY, + SNG_MG_ENCODING_TEXT, }sng_mg_encoding_types_e; +#define PRNT_ENCODING_TYPE(_val)\ + ((_val == SNG_MG_ENCODING_TEXT)?"SNG_MG_ENCODING_TEXT":\ + (_val == SNG_MG_ENCODING_BINARY)?"SNG_MG_ENCODING_BINARY":\ + "SNG_MG_ENCODING_NONE") /* each profile is corresponds to each MG Instance */ @@ -95,4 +104,32 @@ void handle_mgco_audit_cfm(Pst *pst, SuId suId, MgMgtAudit* audit, Reason reason void handle_mg_alarm(Pst *pst, MgMngmt *sta); 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_stack_shutdown(void); + +/*****************************************************************************************************/ + +#define GET_MG_CFG_IDX(_profilename, _idx){\ + for(idx=0; idx < MAX_MG_PROFILES; idx++){\ + /* id zero is not acceptable */\ + if(megaco_globals.g_mg_cfg.mgCfg[idx].id){\ + if (strcmp(megaco_globals.g_mg_cfg.mgCfg[idx].name, profilename)) {\ + continue;\ + } else{\ + break;\ + }\ + }\ + }\ +} + +#define GET_TPT_ID(_id) megaco_globals.g_mg_cfg.mgTptProf[megaco_globals.g_mg_cfg.mgCfg[_id].transport_prof_id].id +#define GET_MU_SAP_ID(_id) megaco_globals.g_mg_cfg.mgCfg[_id].id + +#define GET_TPT_TYPE(_id) megaco_globals.g_mg_cfg.mgTptProf[megaco_globals.g_mg_cfg.mgCfg[_id].transport_prof_id].transport_type + +#define GET_ENCODING_TYPE(_id) megaco_globals.g_mg_cfg.mgPeer.peers[megaco_globals.g_mg_cfg.mgCfg[_id].peer_id].encoding_type + #endif /* _MEGACO_CFG_H_ */ diff --git a/src/mod/endpoints/mod_megaco/megaco_xml.c b/src/mod/endpoints/mod_megaco/megaco_xml.c index 506cc3b29e..e7addf5875 100644 --- a/src/mod/endpoints/mod_megaco/megaco_xml.c +++ b/src/mod/endpoints/mod_megaco/megaco_xml.c @@ -214,6 +214,7 @@ switch_status_t sng_parse_mg_peer_profile(switch_xml_t mg_peer_profile) } } + megaco_globals.g_mg_cfg.mgPeer.total_peer++; return SWITCH_STATUS_SUCCESS; } /***********************************************************************************************************/ diff --git a/src/mod/endpoints/mod_megaco/mod_megaco.c b/src/mod/endpoints/mod_megaco/mod_megaco.c index bda8e53ec0..332392c59a 100644 --- a/src/mod/endpoints/mod_megaco/mod_megaco.c +++ b/src/mod/endpoints/mod_megaco/mod_megaco.c @@ -123,25 +123,22 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_megaco_load) sng_event.mg.sng_mgco_cmd_ind = handle_mgco_cmd_ind; sng_event.mg.sng_mgco_txn_sta_ind = handle_mgco_txn_sta_ind; sng_event.mg.sng_mgco_sta_ind = handle_mgco_sta_ind; - sng_event.mg.sng_mgco_cntrl_cfm = handle_mgco_cntrl_cfm; - sng_event.mg.sng_mgco_audit_cfm = handle_mgco_audit_cfm; - + sng_event.mg.sng_mgco_cntrl_cfm = handle_mgco_cntrl_cfm; + sng_event.mg.sng_mgco_audit_cfm = handle_mgco_audit_cfm; /* Alarm CB */ sng_event.sm.sng_mg_alarm = handle_mg_alarm; sng_event.sm.sng_tucl_alarm = handle_tucl_alarm; - /* Log */ sng_event.sm.sng_log = handle_sng_log; - /* initalize sng_mg library */ - sng_isup_init_gen(&sng_event); - - return SWITCH_STATUS_SUCCESS; + /* initualize MEGACO stack */ + return sng_mgco_init(&sng_event); } SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_megaco_shutdown) { - /* TODO: Kapil: Insert stack global shutdown code here */ + sng_mgco_stack_shutdown(); + return SWITCH_STATUS_SUCCESS; } diff --git a/src/mod/endpoints/mod_megaco/mod_megaco.h b/src/mod/endpoints/mod_megaco/mod_megaco.h index 3efa48e3bc..7c21610639 100644 --- a/src/mod/endpoints/mod_megaco/mod_megaco.h +++ b/src/mod/endpoints/mod_megaco/mod_megaco.h @@ -11,7 +11,7 @@ #define MOD_MEGACO_H #include -#include "megaco_cfg.h" +#include "megaco_stack.h" struct megaco_globals { switch_memory_pool_t *pool;