kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-03-13 12:40:17 +00:00
Code Issues Projects Releases Wiki Activity

adding m2ua stack config/control code

Browse Source
This commit is contained in:
kapil 2012-05-18 12:05:25 +05:30
parent 67c43a0759
commit 23ca7f8fed
11 changed files with 2560 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/freetdm/Makefile.am
View File

@ -213,6 +213,8 @@ ftmod_sangoma_ss7_la_SOURCES = \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_sta.c \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_sts.c \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_logger.c \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_m2ua_xml.c \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_m2ua.c \
$(SRC)/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_relay.c
ftmod_sangoma_ss7_la_CFLAGS = $(FTDM_CFLAGS) $(AM_CFLAGS) -D_GNU_SOURCE

100
libs/freetdm/mod_freetdm/mod_freetdm.c
View File

@ -55,6 +55,8 @@
/* How many consecutive IO errors before giving up */
#define FTDM_MAX_READ_WRITE_ERRORS 10
#define get_ss7_config_node(_cfg, _confname) _get_ss7_config_node(cfg, confname, "ISUP")
SWITCH_MODULE_LOAD_FUNCTION(mod_freetdm_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_freetdm_shutdown);
SWITCH_MODULE_DEFINITION(mod_freetdm, mod_freetdm_load, mod_freetdm_shutdown, NULL);
@ -2865,11 +2867,12 @@ static int add_config_list_nodes(switch_xml_t swnode, ftdm_conf_node_t *rootnode
return 0;
}
static ftdm_conf_node_t *get_ss7_config_node(switch_xml_t cfg, const char *confname)
static ftdm_conf_node_t *_get_ss7_config_node(switch_xml_t cfg, const char *confname, const char *operatingMode)
{
switch_xml_t signode, ss7configs, isup, gen, param;
ftdm_conf_node_t *rootnode, *list;
char *var, *val;
int is_isup = 0x00;
/* try to find the conf in the hash first */
rootnode = switch_core_hash_find(globals.ss7_configs, confname);
@ -2913,6 +2916,23 @@ static ftdm_conf_node_t *get_ss7_config_node(switch_xml_t cfg, const char *confn
return NULL;
}
/* operating mode , M2UA or ISUP */
if(operatingMode && ('\0' != operatingMode[0])) {
if(!strcasecmp(operatingMode, "ISUP")) {
is_isup = 0x01;
}
else if(!strcasecmp(operatingMode, "M2UA_SG")) {
is_isup = 0x00;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid operating Mode[%s] \n", operatingMode);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Operating mode not specified, default to ISUP \n");
is_isup = 0x01;
}
/* add sng_gen */
gen = switch_xml_child(isup, "sng_gen");
if (gen == NULL) {
@ -2954,11 +2974,14 @@ static ftdm_conf_node_t *get_ss7_config_node(switch_xml_t cfg, const char *confn
return NULL;
}
/* add mtp3 links */
if (add_config_list_nodes(isup, rootnode, "mtp3_links", "mtp3_link", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process mtp3_links for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
/* If ISUP is operating mode then only include mtp3_links/isup links */
if(is_isup) {
/* add mtp3 links */
if (add_config_list_nodes(isup, rootnode, "mtp3_links", "mtp3_link", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process mtp3_links for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
}
/* add mtp linksets */
@ -2975,18 +2998,53 @@ static ftdm_conf_node_t *get_ss7_config_node(switch_xml_t cfg, const char *confn
return NULL;
}
/* add isup interfaces */
if (add_config_list_nodes(isup, rootnode, "isup_interfaces", "isup_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process isup_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
if(is_isup) {
/* add isup interfaces */
if (add_config_list_nodes(isup, rootnode, "isup_interfaces", "isup_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process isup_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
/* add cc spans */
if (add_config_list_nodes(isup, rootnode, "cc_spans", "cc_span", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process cc_spans for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
}
else {
/* add sctp links */
if (add_config_list_nodes(isup, rootnode, "sng_sctp_interfaces", "sng_sctp_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process sng_sctp_interface for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
if (add_config_list_nodes(isup, rootnode, "sng_nif_interfaces", "sng_nif_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process sng_nif_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
if (add_config_list_nodes(isup, rootnode, "sng_m2ua_interfaces", "sng_m2ua_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process sng_m2ua_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
if (add_config_list_nodes(isup, rootnode, "sng_m2ua_peer_interfaces", "sng_m2ua_peer_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process sng_m2ua_peer_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
if (add_config_list_nodes(isup, rootnode, "sng_m2ua_cluster_interfaces", "sng_m2ua_cluster_interface", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process sng_m2ua_cluster_interfaces for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
/* add cc spans */
if (add_config_list_nodes(isup, rootnode, "cc_spans", "cc_span", NULL, NULL)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "failed to process cc_spans for sng_isup config %s\n", confname);
ftdm_conf_node_destroy(rootnode);
return NULL;
}
switch_core_hash_insert(globals.ss7_configs, confname, rootnode);
@ -3223,6 +3281,7 @@ static switch_status_t load_config(void)
char *id = (char *) switch_xml_attr(myspan, "id");
char *name = (char *) switch_xml_attr(myspan, "name");
char *configname = (char *) switch_xml_attr(myspan, "cfgprofile");
char *operatingMode = (char *) switch_xml_attr(myspan, "operating_mode");
ftdm_span_t *span = NULL;
uint32_t span_id = 0;
unsigned paramindex = 0;
@ -3256,7 +3315,7 @@ static switch_status_t load_config(void)
span_id = ftdm_span_get_id(span);
}
ss7confnode = get_ss7_config_node(cfg, configname);
ss7confnode = _get_ss7_config_node(cfg, configname, operatingMode);
if (!ss7confnode) {
CONFIG_ERROR("Error finding ss7config '%s' for FreeTDM span id: %s\n", configname, switch_str_nil(id));
continue;
@ -3264,6 +3323,11 @@ static switch_status_t load_config(void)
memset(spanparameters, 0, sizeof(spanparameters));
paramindex = 0;
if(operatingMode){
spanparameters[paramindex].var = "operatingMode";
spanparameters[paramindex].val = operatingMode;
paramindex++;
}
spanparameters[paramindex].var = "confnode";
spanparameters[paramindex].ptr = ss7confnode;
paramindex++;

166
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cfg.c
View File

@ -262,94 +262,103 @@ int ft_to_sngss7_cfg_all(void)
/* no configs above mtp2 for relay */
if (g_ftdm_sngss7_data.cfg.procId == 1) {
x = 1;
while (x < (MAX_MTP_LINKS)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtp3Link[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtp3Link[x].flags & SNGSS7_CONFIGURED))) {
while (x < (MAX_MTP_LINKS)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtp3Link[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtp3Link[x].flags & SNGSS7_CONFIGURED))) {
/* configure mtp3 */
if (ftmod_ss7_mtp3_dlsap_config(x)) {
SS7_CRITICAL("MTP3 DLSAP %d configuration FAILED!\n", x);
return 1;;
} else {
SS7_INFO("MTP3 DLSAP %d configuration DONE!\n", x);
/* configure mtp3 */
if (ftmod_ss7_mtp3_dlsap_config(x)) {
SS7_CRITICAL("MTP3 DLSAP %d configuration FAILED!\n", x);
return 1;;
} else {
SS7_INFO("MTP3 DLSAP %d configuration DONE!\n", x);
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtp3Link[x].flags |= SNGSS7_CONFIGURED;
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtp3Link[x].flags |= SNGSS7_CONFIGURED;
x++;
} /* while (x < (MAX_MTP_LINKS+1)) */
/* in M2UA_SG mode there will not be any MTP3 layer */
if(SNG_SS7_OPR_MODE_M2UA_SG != g_ftdm_operating_mode){
x = 1;
while (x < (MAX_NSAPS)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.nsap[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.nsap[x].flags & SNGSS7_CONFIGURED))) {
ret = ftmod_ss7_mtp3_nsap_config(x);
if (ret) {
SS7_CRITICAL("MTP3 NSAP %d configuration FAILED!(%s)\n", x, DECODE_LCM_REASON(ret));
return 1;
} else {
SS7_INFO("MTP3 NSAP %d configuration DONE!\n", x);
}
ret = ftmod_ss7_isup_nsap_config(x);
if (ret) {
SS7_CRITICAL("ISUP NSAP %d configuration FAILED!(%s)\n", x, DECODE_LCM_REASON(ret));
return 1;
} else {
SS7_INFO("ISUP NSAP %d configuration DONE!\n", x);
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.nsap[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
x++;
} /* while (x < (MAX_NSAPS)) */
}
x++;
} /* while (x < (MAX_MTP_LINKS+1)) */
x = 1;
while (x < (MAX_NSAPS)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.nsap[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.nsap[x].flags & SNGSS7_CONFIGURED))) {
/* in M2UA_SG mode there will not be any MTP3 layer */
if(SNG_SS7_OPR_MODE_M2UA_SG != g_ftdm_operating_mode){
x = 1;
while (x < (MAX_MTP_LINKSETS+1)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtpLinkSet[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags & SNGSS7_CONFIGURED))) {
ret = ftmod_ss7_mtp3_nsap_config(x);
if (ret) {
SS7_CRITICAL("MTP3 NSAP %d configuration FAILED!(%s)\n", x, DECODE_LCM_REASON(ret));
return 1;
} else {
SS7_INFO("MTP3 NSAP %d configuration DONE!\n", x);
}
if (ftmod_ss7_mtp3_linkset_config(x)) {
SS7_CRITICAL("MTP3 LINKSET %d configuration FAILED!\n", x);
return 1;
} else {
SS7_INFO("MTP3 LINKSET %d configuration DONE!\n", x);
}
ret = ftmod_ss7_isup_nsap_config(x);
if (ret) {
SS7_CRITICAL("ISUP NSAP %d configuration FAILED!(%s)\n", x, DECODE_LCM_REASON(ret));
return 1;
} else {
SS7_INFO("ISUP NSAP %d configuration DONE!\n", x);
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.nsap[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
x++;
} /* while (x < (MAX_NSAPS)) */
x++;
} /* while (x < (MAX_MTP_LINKSETS+1)) */
}
x = 1;
while (x < (MAX_MTP_LINKSETS+1)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtpLinkSet[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags & SNGSS7_CONFIGURED))) {
/* in M2UA_SG mode there will not be any MTP3 layer */
if(SNG_SS7_OPR_MODE_M2UA_SG != g_ftdm_operating_mode){
x = 1;
while (x < (MAX_MTP_ROUTES+1)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtpRoute[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpRoute[x].flags & SNGSS7_CONFIGURED))) {
if (ftmod_ss7_mtp3_linkset_config(x)) {
SS7_CRITICAL("MTP3 LINKSET %d configuration FAILED!\n", x);
return 1;
} else {
SS7_INFO("MTP3 LINKSET %d configuration DONE!\n", x);
}
if (ftmod_ss7_mtp3_route_config(x)) {
SS7_CRITICAL("MTP3 ROUTE %d configuration FAILED!\n", x);
return 1;
} else {
SS7_INFO("MTP3 ROUTE %d configuration DONE!\n",x);
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
x++;
} /* while (x < (MAX_MTP_LINKSETS+1)) */
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtpRoute[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
x = 1;
while (x < (MAX_MTP_ROUTES+1)) {
/* check if this link has been configured already */
if ((g_ftdm_sngss7_data.cfg.mtpRoute[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpRoute[x].flags & SNGSS7_CONFIGURED))) {
if (ftmod_ss7_mtp3_route_config(x)) {
SS7_CRITICAL("MTP3 ROUTE %d configuration FAILED!\n", x);
return 1;
} else {
SS7_INFO("MTP3 ROUTE %d configuration DONE!\n",x);
}
/* set the SNGSS7_CONFIGURED flag */
g_ftdm_sngss7_data.cfg.mtpRoute[x].flags |= SNGSS7_CONFIGURED;
} /* if !SNGSS7_CONFIGURED */
x++;
} /* while (x < (MAX_MTP_ROUTES+1)) */
x++;
} /* while (x < (MAX_MTP_ROUTES+1)) */
}
x = 1;
while (x < (MAX_ISAPS)) {
@ -441,6 +450,11 @@ int ft_to_sngss7_cfg_all(void)
} /* if !SNGSS7_CONFIGURED */
x++;
} /* while (x < (MAX_RELAY_CHANNELS)) */
if(SNG_SS7_OPR_MODE_M2UA_SG == g_ftdm_operating_mode){
return ftmod_ss7_m2ua_cfg();
}
return 0;
}

54
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cntrl.c
View File

@ -60,7 +60,7 @@ int ft_to_sngss7_activate_all(void)
while (x < (MAX_ISAPS)) {
/* check if this link has already been actived */
if ((g_ftdm_sngss7_data.cfg.isap[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.isap[x].flags & SNGSS7_ACTIVE))) {
(!(g_ftdm_sngss7_data.cfg.isap[x].flags & SNGSS7_ACTIVE))) {
if (ftmod_ss7_enable_isap(x)) {
SS7_CRITICAL("ISAP %d Enable: NOT OK\n", x);
@ -72,15 +72,16 @@ int ft_to_sngss7_activate_all(void)
/* set the SNGSS7_ACTIVE flag */
g_ftdm_sngss7_data.cfg.isap[x].flags |= SNGSS7_ACTIVE;
} /* if !SNGSS7_ACTIVE */
x++;
} /* while (x < (MAX_ISAPS)) */
if(SNG_SS7_OPR_MODE_M2UA_SG != g_ftdm_operating_mode){
x = 1;
while (x < (MAX_NSAPS)) {
/* check if this link has already been actived */
if ((g_ftdm_sngss7_data.cfg.nsap[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.nsap[x].flags & SNGSS7_ACTIVE))) {
(!(g_ftdm_sngss7_data.cfg.nsap[x].flags & SNGSS7_ACTIVE))) {
if (ftmod_ss7_enable_nsap(x)) {
SS7_CRITICAL("NSAP %d Enable: NOT OK\n", x);
@ -92,30 +93,35 @@ int ft_to_sngss7_activate_all(void)
/* set the SNGSS7_ACTIVE flag */
g_ftdm_sngss7_data.cfg.nsap[x].flags |= SNGSS7_ACTIVE;
} /* if !SNGSS7_ACTIVE */
x++;
} /* while (x < (MAX_NSAPS)) */
if (g_ftdm_sngss7_data.cfg.mtpRoute[1].id != 0) {
x = 1;
while (x < (MAX_MTP_LINKSETS+1)) {
/* check if this link has already been actived */
if ((g_ftdm_sngss7_data.cfg.mtpLinkSet[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags & SNGSS7_ACTIVE))) {
if (ftmod_ss7_enable_mtpLinkSet(x)) {
SS7_CRITICAL("LinkSet \"%s\" Enable: NOT OK\n", g_ftdm_sngss7_data.cfg.mtpLinkSet[x].name);
return 1;
} else {
SS7_INFO("LinkSet \"%s\" Enable: OK\n", g_ftdm_sngss7_data.cfg.mtpLinkSet[x].name);
}
/* set the SNGSS7_ACTIVE flag */
g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags |= SNGSS7_ACTIVE;
} /* if !SNGSS7_ACTIVE */
x++;
} /* while (x < (MAX_MTP_LINKSETS+1)) */
if (g_ftdm_sngss7_data.cfg.mtpRoute[1].id != 0) {
x = 1;
while (x < (MAX_MTP_LINKSETS+1)) {
/* check if this link has already been actived */
if ((g_ftdm_sngss7_data.cfg.mtpLinkSet[x].id != 0) &&
(!(g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags & SNGSS7_ACTIVE))) {
if (ftmod_ss7_enable_mtpLinkSet(x)) {
SS7_CRITICAL("LinkSet \"%s\" Enable: NOT OK\n", g_ftdm_sngss7_data.cfg.mtpLinkSet[x].name);
return 1;
} else {
SS7_INFO("LinkSet \"%s\" Enable: OK\n", g_ftdm_sngss7_data.cfg.mtpLinkSet[x].name);
}
/* set the SNGSS7_ACTIVE flag */
g_ftdm_sngss7_data.cfg.mtpLinkSet[x].flags |= SNGSS7_ACTIVE;
} /* if !SNGSS7_ACTIVE */
x++;
} /* while (x < (MAX_MTP_LINKSETS+1)) */
}
}
if(SNG_SS7_OPR_MODE_M2UA_SG == g_ftdm_operating_mode){
return ftmod_ss7_m2ua_start();
}
return 0;

30
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_logger.c
View File

@ -824,6 +824,36 @@ void handle_sng_relay_alarm(Pst *pst, RyMngmt *sta)
return;
}
/******************************************************************************/
void handle_sng_m2ua_alarm(Pst *pst, MwMgmt *sta)
{
ftdm_log(FTDM_LOG_ERROR," handle_sng_m2ua_alarm Not Yet Implement \n");
} /* handle_sng_m2ua_alarm */
/******************************************************************************/
void handle_sng_nif_alarm(Pst *pst, NwMgmt *sta)
{
ftdm_log(FTDM_LOG_ERROR," handle_sng_nif_alarm Not Yet Implement \n");
} /* handle_sng_nif_alarm */
/******************************************************************************/
void handle_sng_tucl_alarm(Pst *pst, HiMngmt *sta)
{
ftdm_log(FTDM_LOG_ERROR," handle_sng_tucl_alarm Not Yet Implement \n");
} /* handle_sng_tucl_alarm */
/******************************************************************************/
void handle_sng_sctp_alarm(Pst *pst, SbMgmt *sta)
{
ftdm_log(FTDM_LOG_ERROR," handle_sng_sctp_alarm Not Yet Implement \n");
} /* handle_sng_sctp_alarm */
/******************************************************************************/
/******************************************************************************/
/* For Emacs:
* Local Variables:

1335
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_m2ua.c Normal file
View File

File diff suppressed because it is too large Load Diff

125
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_m2ua.h Normal file
View File

@ -0,0 +1,125 @@
/*
* Copyright (c) 2012, Kapil Gupta <kgupta@sangoma.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* Contributors:
*
*/
/******************************************************************************/
#ifndef __FTMOD_SNG_SS7_M2UA_H__
#define __FTMOD_SNG_SS7_M2UA_H__
/******************************************************************************/
#include "private/ftdm_core.h"
#define MAX_NAME_LEN 25
typedef struct sng_nif_cfg{
char name[MAX_NAME_LEN];
uint32_t flags;
uint32_t id;
uint32_t m2uaLnkNmb;
uint32_t mtp2LnkNmb;
}sng_nif_cfg_t;
typedef enum{
SNG_M2UA_NODE_TYPE_SGP = 1, /* type SG */
SNG_M2UA_NODE_TYPE_ASP = 2, /* type ASP */
}sng_m2ua_node_types_e;
typedef struct sng_m2ua_cfg{
char name[MAX_NAME_LEN];
uint32_t flags;
uint32_t id; /* ID */
uint8_t nodeType; /*Node Type SG/ASP */
uint16_t sctpId; /* idx to sctp profile */
uint16_t peerdId; /* idx to m2ua_peer profile */
uint16_t clusterId; /* idx to m2ua_cluster profile */
}sng_m2ua_cfg_t;
typedef struct sng_m2ua_peer_cfg{
char name[MAX_NAME_LEN];
uint32_t flags;
uint32_t id; /* ID */
uint8_t aspIdFlag; /* Flag used to indicate whether include the ASP ID in the ASP UP message */
uint16_t selfAspId; /* Self ASP ID. ASP identifier for this ASP node if the aspIdFlag is TRUE. */
uint32_t numDestAddr; /* Number of destination address defined */
uint16_t sctpId; /* idx to sctp profile */
uint32_t destAddrList[SCT_MAX_NET_ADDRS+1]; /* Destination adddress list */
uint16_t locOutStrms; /*Number of outgoing streams supported by this association*/
}sng_m2ua_peer_cfg_t;
typedef enum{
SNG_M2UA_LOAD_SHARE_ALGO_RR = 0x1, /* Round Robin Mode*/
SNG_M2UA_LOAD_SHARE_ALGO_LS = 0x2, /* Link Specified */
SNG_M2UA_LOAD_SHARE_ALGO_CS = 0x3, /* Customer Specified */
}sng_m2ua_load_share_algo_types_e;
/* Possible values of Traffic mode */
typedef enum{
SNG_M2UA_TRF_MODE_OVERRIDE = 0x1, /* Override Mode */
SNG_M2UA_TRF_MODE_LOADSHARE = 0x2, /* Loadshare Mode */
SNG_M2UA_TRF_MODE_BROADCAST = 0x3, /* Broadcast Mode */
SNG_M2UA_TRF_MODE_ANY = 0x0, /* ANY Mode */
}sng_m2ua_traffic_mode_types_e;
typedef struct sng_m2ua_cluster_cfg{
char name[MAX_NAME_LEN];
uint32_t flags;
uint32_t id; /* ID */
uint8_t trfMode; /* Traffic mode. This parameter defines the mode in which this m2ua cluster is supposed to work */
uint8_t loadShareAlgo; /* This parameter defines the M2UA load share algorithm which is used to distribute the traffic */
uint16_t numOfPeers; /* idx to m2ua_peer profile */
uint16_t peerIdLst[MW_MAX_NUM_OF_PEER]; /* idx to m2ua_peer profile */
}sng_m2ua_cluster_cfg_t;
typedef struct sng_m2ua_gbl_cfg{
sng_nif_cfg_t nif[MW_MAX_NUM_OF_INTF];
sng_m2ua_cfg_t m2ua[MW_MAX_NUM_OF_INTF];
sng_m2ua_peer_cfg_t m2ua_peer[MW_MAX_NUM_OF_PEER];
sng_m2ua_cluster_cfg_t m2ua_clus[MW_MAX_NUM_OF_CLUSTER];
}sng_m2ua_gbl_cfg_t;
/* m2ua xml parsing APIs */
int ftmod_ss7_parse_nif_interfaces(ftdm_conf_node_t *nif_interfaces);
int ftmod_ss7_parse_m2ua_interfaces(ftdm_conf_node_t *m2ua_interfaces);
int ftmod_ss7_parse_m2ua_peer_interfaces(ftdm_conf_node_t *m2ua_peer_interfaces);
int ftmod_ss7_parse_m2ua_clust_interfaces(ftdm_conf_node_t *m2ua_clust_interfaces);
ftdm_status_t ftmod_m3ua_parse_sctp_links(ftdm_conf_node_t *node);
uint32_t iptoul(const char *ip);
int ftmod_ss7_m2ua_start(void);
ftdm_status_t ftmod_ss7_m2ua_cfg(void);
#endif /*__FTMOD_SNG_SS7_M2UA_H__*/

671
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_m2ua_xml.c Normal file
View File

@ -0,0 +1,671 @@
/*
* Copyright (c) 2012, Kapil Gupta <kgupta@sangoma.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* Contributors:
*
*
*/
/* INCLUDE ********************************************************************/
#include "ftmod_sangoma_ss7_main.h"
/******************************************************************************/
/* DEFINES ********************************************************************/
/******************************************************************************/
static int ftmod_ss7_parse_nif_interface(ftdm_conf_node_t *nif_interface);
static int ftmod_ss7_parse_m2ua_interface(ftdm_conf_node_t *m2ua_interface);
static int ftmod_ss7_parse_m2ua_peer_interface(ftdm_conf_node_t *m2ua_peer_interface);
static int ftmod_ss7_parse_m2ua_clust_interface(ftdm_conf_node_t *m2ua_clust_interface);
static int ftmod_ss7_fill_in_nif_interface(sng_nif_cfg_t *nif_iface);
static int ftmod_ss7_fill_in_m2ua_interface(sng_m2ua_cfg_t *m2ua_iface);
static int ftmod_ss7_fill_in_m2ua_peer_interface(sng_m2ua_peer_cfg_t *m2ua_peer_face);
static int ftmod_ss7_fill_in_m2ua_clust_interface(sng_m2ua_cluster_cfg_t *m2ua_cluster_face);
static ftdm_status_t ftmod_m3ua_parse_sctp_link(ftdm_conf_node_t *node);
/******************************************************************************/
int ftmod_ss7_parse_nif_interfaces(ftdm_conf_node_t *nif_interfaces)
{
ftdm_conf_node_t *nif_interface = NULL;
/* confirm that we are looking at sng_nif_interfaces */
if (strcasecmp(nif_interfaces->name, "sng_nif_interfaces")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"sng_nif_interfaces\"!\n",nif_interfaces->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"nif_interfaces\"...\n");
}
/* extract the isup_interfaces */
nif_interface = nif_interfaces->child;
while (nif_interface != NULL) {
/* parse the found mtp_route */
if (ftmod_ss7_parse_nif_interface(nif_interface)) {
SS7_ERROR("Failed to parse \"nif_interface\"\n");
return FTDM_FAIL;
}
/* go to the next nif_interface */
nif_interface = nif_interface->next;
}
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_parse_nif_interface(ftdm_conf_node_t *nif_interface)
{
sng_nif_cfg_t sng_nif;
ftdm_conf_parameter_t *parm = nif_interface->parameters;
int num_parms = nif_interface->n_parameters;
int i;
/* initalize the nif intf and isap structure */
memset(&sng_nif, 0x0, sizeof(sng_nif));
/* confirm that we are looking at an nif_interface */
if (strcasecmp(nif_interface->name, "sng_nif_interface")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"nif_interface\"!\n",nif_interface->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"nif_interface\"...\n");
}
for (i = 0; i < num_parms; i++) {
/**************************************************************************/
/* try to match the parameter to what we expect */
if (!strcasecmp(parm->var, "name")) {
/**********************************************************************/
strcpy((char *)sng_nif.name, parm->val);
SS7_DEBUG("Found an nif_interface named = %s\n", sng_nif.name);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "id")) {
/**********************************************************************/
sng_nif.id = atoi(parm->val);
SS7_DEBUG("Found an nif id = %d\n", sng_nif.id);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "m2uaLnkNmb")) {
/**********************************************************************/
sng_nif.m2uaLnkNmb = atoi(parm->val);
SS7_DEBUG("Found an nif m2uaLnkNmb = %d\n", sng_nif.m2uaLnkNmb);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "mtp2LnkNmb")) {
/**********************************************************************/
sng_nif.mtp2LnkNmb=atoi(parm->val);
SS7_DEBUG("Found an nif mtp2LnkNmb = %d\n", sng_nif.mtp2LnkNmb);
/**********************************************************************/
} else {
/**********************************************************************/
SS7_ERROR("Found an invalid parameter %s!\n", parm->var);
return FTDM_FAIL;
/**********************************************************************/
}
/* move to the next parameter */
parm = parm + 1;
/**************************************************************************/
} /* for (i = 0; i < num_parms; i++) */
/* default the interface to paused state */
sngss7_set_flag(&sng_nif, SNGSS7_PAUSED);
/* fill in the nif interface */
ftmod_ss7_fill_in_nif_interface(&sng_nif);
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_fill_in_nif_interface(sng_nif_cfg_t *nif_iface)
{
int i = nif_iface->id;
strncpy((char *)g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[i].name, (char *)nif_iface->name, MAX_NAME_LEN-1);
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[i].id = nif_iface->id;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[i].m2uaLnkNmb = nif_iface->m2uaLnkNmb;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[i].mtp2LnkNmb = nif_iface->mtp2LnkNmb;
return 0;
}
/******************************************************************************/
int ftmod_ss7_parse_m2ua_interfaces(ftdm_conf_node_t *m2ua_interfaces)
{
ftdm_conf_node_t *m2ua_interface = NULL;
/* confirm that we are looking at sng_m2ua_interfaces */
if (strcasecmp(m2ua_interfaces->name, "sng_m2ua_interfaces")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_nif_interfaces\"!\n",m2ua_interfaces->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_interfaces\"...\n");
}
/* extract the isup_interfaces */
m2ua_interface = m2ua_interfaces->child;
while (m2ua_interface != NULL) {
/* parse the found mtp_route */
if (ftmod_ss7_parse_m2ua_interface(m2ua_interface)) {
SS7_ERROR("Failed to parse \"m2ua_interface\"\n");
return FTDM_FAIL;
}
/* go to the next m2ua_interface */
m2ua_interface = m2ua_interface->next;
}
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_parse_m2ua_interface(ftdm_conf_node_t *m2ua_interface)
{
sng_m2ua_cfg_t sng_m2ua;
ftdm_conf_parameter_t *parm = m2ua_interface->parameters;
int num_parms = m2ua_interface->n_parameters;
int i;
/* initalize the m2ua intf */
memset(&sng_m2ua, 0x0, sizeof(sng_m2ua));
/* confirm that we are looking at an nif_interface */
if (strcasecmp(m2ua_interface->name, "sng_m2ua_interface")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_interface\"!\n",m2ua_interface->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_interface\"...\n");
}
for (i = 0; i < num_parms; i++) {
/**************************************************************************/
/* try to match the parameter to what we expect */
if (!strcasecmp(parm->var, "name")) {
/**********************************************************************/
strcpy((char *)sng_m2ua.name, parm->val);
SS7_DEBUG("Found an m2ua_interface named = %s\n", sng_m2ua.name);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "id")) {
/**********************************************************************/
sng_m2ua.id = atoi(parm->val);
SS7_DEBUG("Found an m2ua id = %d\n", sng_m2ua.id);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "nodeType")) {
/**********************************************************************/
if(!strcasecmp(parm->val, "SGP")){
sng_m2ua.nodeType = SNG_M2UA_NODE_TYPE_SGP;
} else if(!strcasecmp(parm->val, "ASP")){
SS7_ERROR(" NodeType = ASP Not Supported Yet \n");
return FTDM_FAIL;
} else {
SS7_ERROR("Found an invalid NodeType Parameter Value[%s]\n", parm->val);
return FTDM_FAIL;
}
SS7_DEBUG("Found an nif nodeType = %d\n", sng_m2ua.nodeType);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "sctpId")) {
/**********************************************************************/
sng_m2ua.sctpId=atoi(parm->val);
SS7_DEBUG("Found an m2ua sctpId = %d\n", sng_m2ua.sctpId);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "peerdId")) {
/**********************************************************************/
sng_m2ua.peerdId=atoi(parm->val);
SS7_DEBUG("Found an m2ua peerdId = %d\n", sng_m2ua.peerdId);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "clusterId")) {
/**********************************************************************/
sng_m2ua.clusterId=atoi(parm->val);
SS7_DEBUG("Found an m2ua clusterId = %d\n", sng_m2ua.clusterId);
/**********************************************************************/
} else {
/**********************************************************************/
SS7_ERROR("Found an invalid parameter %s!\n", parm->var);
return FTDM_FAIL;
/**********************************************************************/
}
/* move to the next parameter */
parm = parm + 1;
/**************************************************************************/
} /* for (i = 0; i < num_parms; i++) */
/* default the interface to paused state */
sngss7_set_flag(&sng_m2ua, SNGSS7_PAUSED);
/* fill in the nif interface */
ftmod_ss7_fill_in_m2ua_interface(&sng_m2ua);
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_fill_in_m2ua_interface(sng_m2ua_cfg_t *m2ua_iface)
{
int i = m2ua_iface->id;
strncpy((char *)g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].name, (char *)m2ua_iface->name, MAX_NAME_LEN-1);
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].id = m2ua_iface->id;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].nodeType = m2ua_iface->nodeType;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].sctpId = m2ua_iface->sctpId;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].peerdId = m2ua_iface->peerdId;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua[i].clusterId = m2ua_iface->clusterId;
return 0;
}
/******************************************************************************/
int ftmod_ss7_parse_m2ua_peer_interfaces(ftdm_conf_node_t *m2ua_peer_interfaces)
{
ftdm_conf_node_t *m2ua_peer_interface = NULL;
/* confirm that we are looking at m2ua_peer_interfaces */
if (strcasecmp(m2ua_peer_interfaces->name, "sng_m2ua_peer_interfaces")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_peer_interfaces\"!\n",m2ua_peer_interfaces->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_peer_interfaces\"...\n");
}
/* extract the m2ua_peer_interfaces */
m2ua_peer_interface = m2ua_peer_interfaces->child;
while (m2ua_peer_interface != NULL) {
/* parse the found mtp_route */
if (ftmod_ss7_parse_m2ua_peer_interface(m2ua_peer_interface)) {
SS7_ERROR("Failed to parse \"m2ua_peer_interface\"\n");
return FTDM_FAIL;
}
/* go to the next m2ua_peer_interface */
m2ua_peer_interface = m2ua_peer_interface->next;
}
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_parse_m2ua_peer_interface(ftdm_conf_node_t *m2ua_peer_interface)
{
sng_m2ua_peer_cfg_t sng_m2ua_peer;
ftdm_conf_parameter_t *parm = m2ua_peer_interface->parameters;
int num_parms = m2ua_peer_interface->n_parameters;
int i;
/* initalize the m2ua intf */
memset(&sng_m2ua_peer, 0x0, sizeof(sng_m2ua_peer));
/* confirm that we are looking at an m2ua_peer_interface */
if (strcasecmp(m2ua_peer_interface->name, "sng_m2ua_peer_interface")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_peer_interface\"!\n",m2ua_peer_interface->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_peer_interface\"...\n");
}
for (i = 0; i < num_parms; i++) {
/**************************************************************************/
/* try to match the parameter to what we expect */
if (!strcasecmp(parm->var, "name")) {
/**********************************************************************/
strcpy((char *)sng_m2ua_peer.name, parm->val);
SS7_DEBUG("Found an sng_m2ua_peer named = %s\n", sng_m2ua_peer.name);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "id")) {
/**********************************************************************/
sng_m2ua_peer.id = atoi(parm->val);
SS7_DEBUG("Found an sng_m2ua_peer id = %d\n", sng_m2ua_peer.id);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "aspIdFlag")) {
/**********************************************************************/
if(!strcasecmp(parm->val, "TRUE")){
sng_m2ua_peer.aspIdFlag = 0x01;
} else if(!strcasecmp(parm->val, "FALSE")){
sng_m2ua_peer.aspIdFlag = 0x00;
} else {
SS7_ERROR("Found an invalid aspIdFlag Parameter Value[%s]\n", parm->val);
return FTDM_FAIL;
}
SS7_DEBUG("Found an sng_m2ua_peer aspIdFlag = %d\n", sng_m2ua_peer.aspIdFlag);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "selfAspId")) {
/**********************************************************************/
sng_m2ua_peer.selfAspId=atoi(parm->val);
SS7_DEBUG("Found an sng_m2ua_peer selfAspId = %d\n", sng_m2ua_peer.selfAspId);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "DestAddr")) {
/**********************************************************************/
if (sng_m2ua_peer.numDestAddr < SCT_MAX_NET_ADDRS) {
sng_m2ua_peer.destAddrList[sng_m2ua_peer.numDestAddr] = iptoul (parm->val);
sng_m2ua_peer.numDestAddr++;
SS7_DEBUG("sng_m2ua_peer - Parsing with dest IP Address = %s\n", parm->val);
} else {
SS7_ERROR("sng_m2ua_peer - too many dest address configured. dropping %s \n", parm->val);
}
/**********************************************************************/
} else if (!strcasecmp(parm->var, "locOutStrms")) {
/**********************************************************************/
sng_m2ua_peer.locOutStrms=atoi(parm->val);
SS7_DEBUG("Found an sng_m2ua_peer locOutStrms = %d\n", sng_m2ua_peer.locOutStrms);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "sctpId")) {
/**********************************************************************/
sng_m2ua_peer.sctpId=atoi(parm->val);
SS7_DEBUG("Found an sng_m2ua_peer sctpId = %d\n", sng_m2ua_peer.sctpId);
/**********************************************************************/
} else {
/**********************************************************************/
SS7_ERROR("Found an invalid parameter %s!\n", parm->var);
return FTDM_FAIL;
/**********************************************************************/
}
/* move to the next parameter */
parm = parm + 1;
/**************************************************************************/
} /* for (i = 0; i < num_parms; i++) */
/* default the interface to paused state */
sngss7_set_flag(&sng_m2ua_peer, SNGSS7_PAUSED);
/* fill in the sng_m2ua_peer interface */
ftmod_ss7_fill_in_m2ua_peer_interface(&sng_m2ua_peer);
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_fill_in_m2ua_peer_interface(sng_m2ua_peer_cfg_t *m2ua_peer_iface)
{
int k = 0x00;
int i = m2ua_peer_iface->id;
strncpy((char *)g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].name, (char *)m2ua_peer_iface->name, MAX_NAME_LEN-1);
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].id = m2ua_peer_iface->id;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].aspIdFlag = m2ua_peer_iface->aspIdFlag;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].selfAspId = m2ua_peer_iface->selfAspId;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].locOutStrms = m2ua_peer_iface->locOutStrms;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].numDestAddr = m2ua_peer_iface->numDestAddr;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].sctpId = m2ua_peer_iface->sctpId;
for (k=1; k<=m2ua_peer_iface->numDestAddr; k++) {
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].destAddrList[k] = m2ua_peer_iface->destAddrList[k];
}
return 0;
}
/******************************************************************************/
int ftmod_ss7_parse_m2ua_clust_interfaces(ftdm_conf_node_t *m2ua_cluster_interfaces)
{
ftdm_conf_node_t *m2ua_cluster_interface = NULL;
/* confirm that we are looking at m2ua_cluster_interfaces */
if (strcasecmp(m2ua_cluster_interfaces->name, "sng_m2ua_cluster_interfaces")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_cluster_interfaces\"!\n",m2ua_cluster_interfaces->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_cluster_interfaces\"...\n");
}
/* extract the m2ua_cluster_interfaces */
m2ua_cluster_interface = m2ua_cluster_interfaces->child;
while (m2ua_cluster_interface != NULL) {
/* parse the found m2ua_cluster_interface */
if (ftmod_ss7_parse_m2ua_clust_interface(m2ua_cluster_interface)) {
SS7_ERROR("Failed to parse \"m2ua_cluster_interface\"\n");
return FTDM_FAIL;
}
/* go to the next m2ua_cluster_interface */
m2ua_cluster_interface = m2ua_cluster_interface->next;
}
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_parse_m2ua_clust_interface(ftdm_conf_node_t *m2ua_cluster_interface)
{
sng_m2ua_cluster_cfg_t sng_m2ua_cluster;
ftdm_conf_parameter_t *parm = m2ua_cluster_interface->parameters;
int num_parms = m2ua_cluster_interface->n_parameters;
int i;
/* initalize the m2ua_cluster_interface */
memset(&sng_m2ua_cluster, 0x0, sizeof(sng_m2ua_cluster));
/* confirm that we are looking at an m2ua_cluster_interface */
if (strcasecmp(m2ua_cluster_interface->name, "sng_m2ua_cluster_interface")) {
SS7_ERROR("We're looking at \"%s\"...but we're supposed to be looking at \"m2ua_cluster_interface\"!\n",m2ua_cluster_interface->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("Parsing \"m2ua_cluster_interface\"...\n");
}
for (i = 0; i < num_parms; i++) {
/**************************************************************************/
/* try to match the parameter to what we expect */
if (!strcasecmp(parm->var, "name")) {
/**********************************************************************/
strcpy((char *)sng_m2ua_cluster.name, parm->val);
SS7_DEBUG("Found an sng_m2ua_cluster named = %s\n", sng_m2ua_cluster.name);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "id")) {
/**********************************************************************/
sng_m2ua_cluster.id = atoi(parm->val);
SS7_DEBUG("Found an sng_m2ua_cluster id = %d\n", sng_m2ua_cluster.id);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "trfMode")) {
/**********************************************************************/
if(!strcasecmp(parm->val, "LOADSHARE")){
sng_m2ua_cluster.trfMode = SNG_M2UA_TRF_MODE_LOADSHARE;
} else if(!strcasecmp(parm->val, "OVERRIDE")){
sng_m2ua_cluster.trfMode = SNG_M2UA_TRF_MODE_OVERRIDE;
} else if(!strcasecmp(parm->val, "BROADCAST")){
sng_m2ua_cluster.trfMode = SNG_M2UA_TRF_MODE_BROADCAST;
} else {
SS7_ERROR("Found an invalid trfMode Parameter Value[%s]..adding default one[ANY]\n", parm->val);
sng_m2ua_cluster.trfMode = SNG_M2UA_TRF_MODE_ANY;
}
SS7_DEBUG("Found an sng_m2ua_cluster.trfMode = %d\n", sng_m2ua_cluster.trfMode);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "loadShareAlgo")) {
/**********************************************************************/
if(!strcasecmp(parm->val, "Round_Robin")){
sng_m2ua_cluster.loadShareAlgo = SNG_M2UA_LOAD_SHARE_ALGO_RR;
} else if(!strcasecmp(parm->val, "Link_Specified")){
sng_m2ua_cluster.loadShareAlgo = SNG_M2UA_LOAD_SHARE_ALGO_LS;
} else if(!strcasecmp(parm->val, "Customer_Specified")){
sng_m2ua_cluster.loadShareAlgo = SNG_M2UA_LOAD_SHARE_ALGO_CS;
} else {
SS7_ERROR("Found an invalid loadShareAlgo Parameter Value[%s]\n", parm->val);
return FTDM_FAIL;
}
SS7_DEBUG("Found an sng_m2ua_cluster.loadShareAlgo = %d\n", sng_m2ua_cluster.loadShareAlgo);
/**********************************************************************/
} else if (!strcasecmp(parm->var, "peerId")) {
/**********************************************************************/
if(sng_m2ua_cluster.numOfPeers < MW_MAX_NUM_OF_PEER) {
sng_m2ua_cluster.peerIdLst[sng_m2ua_cluster.numOfPeers] = atoi(parm->val);
sng_m2ua_cluster.numOfPeers++;
SS7_DEBUG("Found an sng_m2ua_cluster peerId[%d], Total numOfPeers[%d] \n",
sng_m2ua_cluster.peerIdLst[sng_m2ua_cluster.numOfPeers],
sng_m2ua_cluster.numOfPeers);
}else{
SS7_ERROR("Peer List excedding max[%d] limit \n", MW_MAX_NUM_OF_PEER);
return FTDM_FAIL;
}
/**********************************************************************/
} else {
/**********************************************************************/
SS7_ERROR("Found an invalid parameter %s!\n", parm->var);
return FTDM_FAIL;
/**********************************************************************/
}
/* move to the next parameter */
parm = parm + 1;
/**************************************************************************/
} /* for (i = 0; i < num_parms; i++) */
/* default the interface to paused state */
sngss7_set_flag(&sng_m2ua_cluster, SNGSS7_PAUSED);
/* fill in the sng_m2ua_peer interface */
ftmod_ss7_fill_in_m2ua_clust_interface(&sng_m2ua_cluster);
return FTDM_SUCCESS;
}
/******************************************************************************/
static int ftmod_ss7_fill_in_m2ua_clust_interface(sng_m2ua_cluster_cfg_t *m2ua_cluster_iface)
{
int k = 0x00;
int i = m2ua_cluster_iface->id;
strncpy((char *)g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_peer[i].name, (char *)m2ua_cluster_iface->name, MAX_NAME_LEN-1);
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_clus[i].id = m2ua_cluster_iface->id;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_clus[i].trfMode = m2ua_cluster_iface->trfMode;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_clus[i].loadShareAlgo = m2ua_cluster_iface->loadShareAlgo;
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_clus[i].numOfPeers = m2ua_cluster_iface->numOfPeers;
for(k=0;k<m2ua_cluster_iface->numOfPeers;k++){
g_ftdm_sngss7_data.cfg.g_m2ua_cfg.m2ua_clus[i].peerIdLst[k] = m2ua_cluster_iface->peerIdLst[k];
}
return 0;
}
/******************************************************************************/
ftdm_status_t ftmod_m3ua_parse_sctp_links(ftdm_conf_node_t *node)
{
ftdm_conf_node_t *node_sctp_link = NULL;
if (!node)
return FTDM_FAIL;
if (strcasecmp(node->name, "sng_sctp_interfaces")) {
SS7_ERROR("SCTP - We're looking at <%s>...but we're supposed to be looking at <sng_sctp_interfaces>!\n", node->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("SCTP - Parsing <sng_sctp_interface> configurations\n");
}
for (node_sctp_link = node->child; node_sctp_link != NULL; node_sctp_link = node_sctp_link->next) {
if (ftmod_m3ua_parse_sctp_link(node_sctp_link) != FTDM_SUCCESS) {
SS7_ERROR("SCTP - Failed to parse <node_sctp_link>. \n");
return FTDM_FAIL;
}
}
return FTDM_SUCCESS;
}
/******************************************************************************/
static ftdm_status_t ftmod_m3ua_parse_sctp_link(ftdm_conf_node_t *node)
{
ftdm_conf_parameter_t *param = NULL;
int num_params = 0;
int i=0;
if (!node)
return FTDM_FAIL;
param = node->parameters;
num_params = node->n_parameters;
sng_sctp_link_t t_link;
memset (&t_link, 0, sizeof(sng_sctp_link_t));
if (strcasecmp(node->name, "sng_sctp_interface")) {
SS7_ERROR("SCTP - We're looking at <%s>...but we're supposed to be looking at <sng_sctp_interface>!\n", node->name);
return FTDM_FAIL;
} else {
SS7_DEBUG("SCTP - Parsing <sng_sctp_interface> configurations\n");
}
for (i=0; i<num_params; i++, param++) {
if (!strcasecmp(param->var, "name")) {
int n_strlen = strlen(param->val);
strncpy((char*)t_link.name, param->val, (n_strlen>MAX_NAME_LEN)?MAX_NAME_LEN:n_strlen);
SS7_DEBUG("SCTP - Parsing <sctp_link> with name = %s\n", param->val);
}
else if (!strcasecmp(param->var, "id")) {
t_link.id = atoi(param->val);
SS7_DEBUG("SCTP - Parsing <sctp_link> with id = %s\n", param->val);
}
else if (!strcasecmp(param->var, "srcAddr")) {
if (t_link.numSrcAddr < SCT_MAX_NET_ADDRS) {
t_link.srcAddrList[t_link.numSrcAddr+1] = iptoul (param->val);
t_link.numSrcAddr++;
SS7_DEBUG("SCTP - Parsing <sctp_link> with source IP Address = %s\n", param->val);
} else {
SS7_ERROR("SCTP - too many source address configured. dropping %s \n", param->val);
}
}
else {
SS7_ERROR("SCTP - Found an unknown parameter <%s>. Skipping it.\n", param->var);
}
}
g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].id = t_link.id;
g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].tuclId = t_link.id;
strncpy((char*)g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].name, t_link.name, strlen(t_link.name) );
g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].flags = 0;
g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].numSrcAddr = t_link.numSrcAddr;
for (i=1; i<=t_link.numSrcAddr; i++) {
g_ftdm_sngss7_data.cfg.sctpCfg.linkCfg[t_link.id].srcAddrList[i] = t_link.srcAddrList[i];
}
return FTDM_SUCCESS;
}
/******************************************************************************/

21
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.c
View File

@ -50,6 +50,7 @@
static sng_isup_event_interface_t sng_event;
static ftdm_io_interface_t g_ftdm_sngss7_interface;
ftdm_sngss7_data_t g_ftdm_sngss7_data;
ftdm_sngss7_opr_mode g_ftdm_operating_mode;
/******************************************************************************/
@ -355,6 +356,15 @@ static void *ftdm_sangoma_ss7_run(ftdm_thread_t * me, void *obj)
/* set IN_THREAD flag so that we know this thread is running */
ftdm_set_flag (ftdmspan, FTDM_SPAN_IN_THREAD);
if(SNG_SS7_OPR_MODE_M2UA_SG == g_ftdm_operating_mode){
ftdm_log (FTDM_LOG_INFO, "FreeTDM running as M2UA_SG mode, freetdm dont have to do anything \n");
while (ftdm_running () && !(ftdm_test_flag (ftdmspan, FTDM_SPAN_STOP_THREAD))) {
continue;
}
goto ftdm_sangoma_ss7_stop;
}
/* get an interrupt queue for this span for channel state changes */
if (ftdm_queue_get_interrupt (ftdmspan->pendingchans, &ftdm_sangoma_ss7_int[0]) != FTDM_SUCCESS) {
SS7_CRITICAL ("Failed to get a ftdm_interrupt for span = %d for channel state changes!\n", ftdmspan->span_id);
@ -497,10 +507,12 @@ static void *ftdm_sangoma_ss7_run(ftdm_thread_t * me, void *obj)
/**********************************************************************/
}
}
ftdm_sangoma_ss7_stop:
/* clear the IN_THREAD flag so that we know the thread is done */
ftdm_clear_flag (ftdmspan, FTDM_SPAN_IN_THREAD);
ftdm_log (FTDM_LOG_INFO,"ftmod_sangoma_ss7 monitor thread for span=%u stopping.\n",ftdmspan->span_id);
return NULL;
@ -2496,6 +2508,8 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_ss7_span_config)
/* set the flag to indicate that this span uses sig event queues */
ftdm_set_flag (span, FTDM_SPAN_USE_SIGNALS_QUEUE);
/* parse the configuration and apply to the global config structure */
if (ftmod_ss7_parse_xml(ftdm_parameters, span)) {
ftdm_log (FTDM_LOG_CRIT, "Failed to parse configuration!\n");
@ -2503,8 +2517,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_ss7_span_config)
return FTDM_FAIL;
}
/* configure libsngss7 */
if (ft_to_sngss7_cfg_all()) {
if (ft_to_sngss7_cfg_all()) { /* configure libsngss7 */
ftdm_log (FTDM_LOG_CRIT, "Failed to configure LibSngSS7!\n");
ftdm_sleep (100);
return FTDM_FAIL;
@ -2566,6 +2579,10 @@ static FIO_SIG_LOAD_FUNCTION(ftdm_sangoma_ss7_init)
sng_event.sm.sng_isup_alarm = handle_sng_isup_alarm;
sng_event.sm.sng_cc_alarm = handle_sng_cc_alarm;
sng_event.sm.sng_relay_alarm = handle_sng_relay_alarm;
sng_event.sm.sng_m2ua_alarm = handle_sng_m2ua_alarm;
sng_event.sm.sng_nif_alarm = handle_sng_nif_alarm;
sng_event.sm.sng_tucl_alarm = handle_sng_tucl_alarm;
sng_event.sm.sng_sctp_alarm = handle_sng_sctp_alarm;
/* initalize sng_ss7 library */
sng_isup_init_gen(&sng_event);

41
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.h
View File

@ -52,6 +52,7 @@
#include "private/ftdm_core.h"
#include "sng_ss7/sng_ss7.h"
#include "ftmod_sangoma_ss7_m2ua.h"
/******************************************************************************/
@ -60,6 +61,7 @@
#define MAX_CIC_LENGTH 5
#define MAX_CIC_MAP_LENGTH 1000
#define MAX_SCTP_LINK 100
#define SNGSS7_EVENT_QUEUE_SIZE 100
#define SNGSS7_PEER_CHANS_QUEUE_SIZE 100
@ -449,6 +451,29 @@ typedef struct sng_relay {
uint32_t procId;
} sng_relay_t;
/**********************************************
sctp structures and data definitions
**********************************************/
typedef struct sng_sctp_gen_cfg {
} sng_sctp_gen_cfg_t;
typedef struct sng_sctp_link {
char name[MAX_NAME_LEN];
uint32_t flags;
uint32_t id;
uint32_t tuclId;
uint32_t numSrcAddr;
uint32_t srcAddrList[SCT_MAX_NET_ADDRS+1];
} sng_sctp_link_t;
typedef struct sng_sctp_cfg {
sng_sctp_gen_cfg_t genCfg;
sng_sctp_link_t linkCfg[MAX_SCTP_LINK+1];
} sng_sctp_cfg_t;
typedef struct sng_ss7_cfg {
uint32_t spc;
uint32_t procId;
@ -468,6 +493,8 @@ typedef struct sng_ss7_cfg {
sng_isap_t isap[MAX_ISAPS+1];
sng_glare_resolution glareResolution;
uint32_t force_inr;
sng_m2ua_gbl_cfg_t g_m2ua_cfg;
sng_sctp_cfg_t sctpCfg;
} sng_ss7_cfg_t;
typedef struct ftdm_sngss7_data {
@ -480,6 +507,14 @@ typedef struct ftdm_sngss7_data {
fio_signal_cb_t sig_cb;
} ftdm_sngss7_data_t;
typedef enum{
SNG_SS7_OPR_MODE_NONE,
SNG_SS7_OPR_MODE_M2UA_SG,
SNG_SS7_OPR_MODE_ISUP,
}ftdm_sngss7_operating_modes_e;
typedef ftdm_sngss7_operating_modes_e ftdm_sngss7_opr_mode;
typedef struct sngss7_timer_data {
ftdm_timer_id_t hb_timer_id;
int beat;
@ -728,6 +763,7 @@ typedef enum {
/* GLOBALS ********************************************************************/
extern ftdm_sngss7_data_t g_ftdm_sngss7_data;
extern ftdm_sngss7_opr_mode g_ftdm_operating_mode;
extern sng_ssf_type_t sng_ssf_type_map[];
extern sng_switch_type_t sng_switch_type_map[];
extern sng_link_type_t sng_link_type_map[];
@ -750,6 +786,10 @@ void handle_sng_mtp3_alarm(Pst *pst, SnMngmt *sta);
void handle_sng_isup_alarm(Pst *pst, SiMngmt *sta);
void handle_sng_cc_alarm(Pst *pst, CcMngmt *sta);
void handle_sng_relay_alarm(Pst *pst, RyMngmt *sta);
void handle_sng_m2ua_alarm(Pst *pst, MwMgmt *sta);
void handle_sng_nif_alarm(Pst *pst, NwMgmt *sta);
void handle_sng_tucl_alarm(Pst *pst, HiMngmt *sta);
void handle_sng_sctp_alarm(Pst *pst, SbMgmt *sta);
/* in ftmod_sangoma_ss7_relay.c */
ftdm_status_t handle_relay_connect(RyMngmt *sta);
@ -974,6 +1014,7 @@ void handle_isup_t35(void *userdata);
void handle_isup_t10(void *userdata);
void handle_isup_t39(void *userdata);
/******************************************************************************/
/* MACROS *********************************************************************/

153
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_xml.c
View File

@ -220,11 +220,32 @@ int ftmod_ss7_parse_xml(ftdm_conf_parameter_t *ftdm_parameters, ftdm_span_t *spa
/* clean out the self route */
memset(&self_route, 0x0, sizeof(self_route));
var = ftdm_parameters[i].var;
val = ftdm_parameters[i].val;
printf("var[%s], val[%s]\n",var,val);
/* confirm that the first parameter is the "operatingMode" */
if(!strcasecmp(var, "operatingMode")){
/**********************************************************************/
if(!strcasecmp(val, "ISUP")) {
g_ftdm_operating_mode = SNG_SS7_OPR_MODE_ISUP;
}
else if(!strcasecmp(val, "M2UA_SG")) {
g_ftdm_operating_mode = SNG_SS7_OPR_MODE_M2UA_SG;
} else {
SS7_ERROR("Invalid operating Mode[%s] \n", val);
return FTDM_FAIL;
}
/**********************************************************************/
}
i++;
var = ftdm_parameters[i].var;
val = ftdm_parameters[i].val;
ptr = (ftdm_conf_node_t *)ftdm_parameters[i].ptr;
/* confirm that the first parameter is the "confnode" */
/* confirm that the 2nd parameter is the "confnode" */
if (!strcasecmp(var, "confnode")) {
/* parse the confnode and fill in the global libsng_ss7 config structure */
if (ftmod_ss7_parse_sng_isup(ptr)) {
@ -239,6 +260,7 @@ int ftmod_ss7_parse_xml(ftdm_conf_parameter_t *ftdm_parameters, ftdm_span_t *spa
}
i++;
while (ftdm_parameters[i].var != NULL) {
/**************************************************************************/
@ -269,10 +291,12 @@ int ftmod_ss7_parse_xml(ftdm_conf_parameter_t *ftdm_parameters, ftdm_span_t *spa
/* fill the pointer to span into isupCkt */
sngSpan.span = span;
/* setup the circuits structure */
if(ftmod_ss7_fill_in_circuits(&sngSpan)) {
SS7_ERROR("Failed to fill in circuits structure!\n");
goto ftmod_ss7_parse_xml_error;
if(SNG_SS7_OPR_MODE_ISUP == g_ftdm_operating_mode){
/* setup the circuits structure */
if(ftmod_ss7_fill_in_circuits(&sngSpan)) {
SS7_ERROR("Failed to fill in circuits structure!\n");
goto ftmod_ss7_parse_xml_error;
}
}
return FTDM_SUCCESS;
@ -294,6 +318,11 @@ static int ftmod_ss7_parse_sng_isup(ftdm_conf_node_t *sng_isup)
ftdm_conf_node_t *isup_interfaces = NULL;
ftdm_conf_node_t *cc_spans = NULL;
ftdm_conf_node_t *tmp_node = NULL;
ftdm_conf_node_t *nif_ifaces = NULL;
ftdm_conf_node_t *m2ua_ifaces = NULL;
ftdm_conf_node_t *m2ua_peer_ifaces = NULL;
ftdm_conf_node_t *m2ua_clust_ifaces = NULL;
ftdm_conf_node_t *sctp_ifaces = NULL;
/* confirm that we are looking at sng_isup */
if (strcasecmp(sng_isup->name, "sng_isup")) {
@ -399,12 +428,62 @@ static int ftmod_ss7_parse_sng_isup(ftdm_conf_node_t *sng_isup)
return FTDM_FAIL;
}
/**********************************************************************/
} else if (!strcasecmp(tmp_node->name, "sng_nif_interfaces")) {
/**********************************************************************/
if (nif_ifaces == NULL) {
nif_ifaces = tmp_node;
SS7_DEBUG("Found a \"sng_nif_interfaces\" section!\n");
} else {
SS7_ERROR("Found a second \"sng_nif_interfaces\" section\n!");
return FTDM_FAIL;
}
/**********************************************************************/
} else if (!strcasecmp(tmp_node->name, "sng_m2ua_interfaces")) {
/**********************************************************************/
if (m2ua_ifaces == NULL) {
m2ua_ifaces = tmp_node;
SS7_DEBUG("Found a \"sng_m2ua_interfaces\" section!\n");
} else {
SS7_ERROR("Found a second \"sng_m2ua_interfaces\" section\n!");
return FTDM_FAIL;
}
/**********************************************************************/
} else if (!strcasecmp(tmp_node->name, "sng_m2ua_peer_interfaces")) {
/**********************************************************************/
if (m2ua_peer_ifaces == NULL) {
m2ua_peer_ifaces = tmp_node;
SS7_DEBUG("Found a \"sng_m2ua_peer_interfaces\" section!\n");
} else {
SS7_ERROR("Found a second \"sng_m2ua_peer_interfaces\" section\n!");
return FTDM_FAIL;
}
/**********************************************************************/
} else if (!strcasecmp(tmp_node->name, "sng_m2ua_cluster_interfaces")) {
/**********************************************************************/
if (m2ua_clust_ifaces == NULL) {
m2ua_clust_ifaces = tmp_node;
SS7_DEBUG("Found a \"sng_m2ua_cluster_interfaces\" section!\n");
} else {
SS7_ERROR("Found a second \"sng_m2ua_peer_interfaces\" section\n!");
return FTDM_FAIL;
}
/**********************************************************************/
} else if (!strcasecmp(tmp_node->name, "sng_sctp_interfaces")) {
/**********************************************************************/
if (sctp_ifaces == NULL) {
sctp_ifaces = tmp_node;
SS7_DEBUG("Found a <sng_sctp_interfaces> section!\n");
} else {
SS7_ERROR("Found a second <sng_sctp_interfaces> section!\n");
return FTDM_FAIL;
}
/**********************************************************************/
} else {
/**********************************************************************/
SS7_ERROR("\tFound an unknown section \"%s\"!\n", tmp_node->name);
return FTDM_FAIL;
/**********************************************************************/
}
}
/* go to the next sibling */
tmp_node = tmp_node->next;
@ -431,11 +510,6 @@ static int ftmod_ss7_parse_sng_isup(ftdm_conf_node_t *sng_isup)
return FTDM_FAIL;
}
if (ftmod_ss7_parse_mtp3_links(mtp3_links)) {
SS7_ERROR("Failed to parse \"mtp3_links\"!\n");
return FTDM_FAIL;
}
if (ftmod_ss7_parse_mtp_linksets(mtp_linksets)) {
SS7_ERROR("Failed to parse \"mtp_linksets\"!\n");
return FTDM_FAIL;
@ -446,14 +520,57 @@ static int ftmod_ss7_parse_sng_isup(ftdm_conf_node_t *sng_isup)
return FTDM_FAIL;
}
if (ftmod_ss7_parse_isup_interfaces(isup_interfaces)) {
SS7_ERROR("Failed to parse \"isup_interfaces\"!\n");
return FTDM_FAIL;
}
switch(g_ftdm_operating_mode)
{
case SNG_SS7_OPR_MODE_ISUP:
{
if (mtp3_links && ftmod_ss7_parse_mtp3_links(mtp3_links)) {
SS7_ERROR("Failed to parse \"mtp3_links\"!\n");
return FTDM_FAIL;
}
if (isup_interfaces && ftmod_ss7_parse_isup_interfaces(isup_interfaces)) {
SS7_ERROR("Failed to parse \"isup_interfaces\"!\n");
return FTDM_FAIL;
}
if (cc_spans && ftmod_ss7_parse_cc_spans(cc_spans)) {
SS7_ERROR("Failed to parse \"cc_spans\"!\n");
return FTDM_FAIL;
}
break;
}
case SNG_SS7_OPR_MODE_M2UA_SG:
{
if (ftmod_m3ua_parse_sctp_links(sctp_ifaces) != FTDM_SUCCESS) {
SS7_ERROR("Failed to parse <sctp_links>!\n");
return FTDM_FAIL;
}
SS7_INFO("Finished ftmod_m3ua_parse_sctp_links!\n");
if (nif_ifaces && ftmod_ss7_parse_nif_interfaces(nif_ifaces)) {
SS7_ERROR("Failed to parse \"nif_ifaces\"!\n");
return FTDM_FAIL;
}
if (m2ua_ifaces && ftmod_ss7_parse_m2ua_interfaces(m2ua_ifaces)) {
SS7_ERROR("Failed to parse \"m2ua_ifaces\"!\n");
return FTDM_FAIL;
}
if (m2ua_peer_ifaces && ftmod_ss7_parse_m2ua_peer_interfaces(m2ua_peer_ifaces)) {
SS7_ERROR("Failed to parse \"m2ua_peer_ifaces\"!\n");
return FTDM_FAIL;
}
if (m2ua_clust_ifaces && ftmod_ss7_parse_m2ua_clust_interfaces(m2ua_clust_ifaces)) {
SS7_ERROR("Failed to parse \"m2ua_clust_ifaces\"!\n");
return FTDM_FAIL;
}
break;
}
default:
SS7_ERROR("Invalid operating mode[%d]\n",g_ftdm_operating_mode);
break;
if (ftmod_ss7_parse_cc_spans(cc_spans)) {
SS7_ERROR("Failed to parse \"cc_spans\"!\n");
return FTDM_FAIL;
}
return FTDM_SUCCESS;