kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix conflict

This commit is contained in:
Mathieu Rene 2012-06-21 10:40:57 -04:00
parent 79702bc0d2 97d89de3fc
commit 294ab3880f
9 changed files with 343 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -5069,7 +5069,8 @@ static ftdm_cli_entry_t ftdm_cli_options[] =
/* Fake handlers as they are handled within freetdm library,
* we should provide a way inside freetdm to query for completions from signaling modules */
{ "core state", "[!]<state_name>", "", NULL },
{ "core flag", "[!]<flag_value>", "", NULL },
{ "core flag", "[!]<flag-int-value|flag-name> [<span_id|span_name>] [<chan_id>]", "", NULL },
{ "core spanflag", "[!]<flag-int-value|flag-name> [<span_id|span_name>]", "", NULL },
{ "core calls", "", "", NULL },
};

267
libs/freetdm/src/ftdm_io.c
View File

@ -63,12 +63,78 @@ struct tm *localtime_r(const time_t *clock, struct tm *result);
ftdm_time_t time_last_throttle_log = 0;
ftdm_time_t time_current_throttle_log = 0;
typedef struct val_str {
const char *str;
unsigned long long val;
} val_str_t;
static val_str_t channel_flag_strs[] = {
{ "configured" , FTDM_CHANNEL_CONFIGURED},
{ "ready", FTDM_CHANNEL_READY},
{ "open", FTDM_CHANNEL_OPEN},
{ "dtmf-detect", FTDM_CHANNEL_DTMF_DETECT},
{ "suppress-dtmf", FTDM_CHANNEL_SUPRESS_DTMF},
{ "transcode", FTDM_CHANNEL_TRANSCODE},
{ "buffer", FTDM_CHANNEL_BUFFER},
{ "in-thread", FTDM_CHANNEL_INTHREAD},
{ "wink", FTDM_CHANNEL_WINK},
{ "flash", FTDM_CHANNEL_FLASH},
{ "state-change", FTDM_CHANNEL_STATE_CHANGE},
{ "hold", FTDM_CHANNEL_HOLD},
{ "in-use", FTDM_CHANNEL_INUSE},
{ "off-hook", FTDM_CHANNEL_OFFHOOK},
{ "ringing", FTDM_CHANNEL_RINGING},
{ "progress-detect", FTDM_CHANNEL_PROGRESS_DETECT},
{ "callerid-detect", FTDM_CHANNEL_CALLERID_DETECT},
{ "outbound", FTDM_CHANNEL_OUTBOUND},
{ "suspended", FTDM_CHANNEL_SUSPENDED},
{ "3-way", FTDM_CHANNEL_3WAY},
{ "progress", FTDM_CHANNEL_PROGRESS},
{ "media", FTDM_CHANNEL_MEDIA},
{ "answered", FTDM_CHANNEL_ANSWERED},
{ "mute", FTDM_CHANNEL_MUTE},
{ "use-rx-gain", FTDM_CHANNEL_USE_RX_GAIN},
{ "use-tx-gain", FTDM_CHANNEL_USE_TX_GAIN},
{ "in-alarm", FTDM_CHANNEL_IN_ALARM},
{ "sig-up", FTDM_CHANNEL_SIG_UP},
{ "user-hangup", FTDM_CHANNEL_USER_HANGUP},
{ "rx-disabled", FTDM_CHANNEL_RX_DISABLED},
{ "tx-disabled", FTDM_CHANNEL_TX_DISABLED},
{ "call-started", FTDM_CHANNEL_CALL_STARTED},
{ "non-block", FTDM_CHANNEL_NONBLOCK},
{ "ind-ack-pending", FTDM_CHANNEL_IND_ACK_PENDING},
{ "blocking", FTDM_CHANNEL_BLOCKING},
{ "media", FTDM_CHANNEL_DIGITAL_MEDIA},
{ "native-sigbridge", FTDM_CHANNEL_NATIVE_SIGBRIDGE},
{ "invalid", FTDM_CHANNEL_MAX_FLAG},
};
static val_str_t span_flag_strs[] = {
{ "configured", FTDM_SPAN_CONFIGURED},
{ "started", FTDM_SPAN_STARTED},
{ "state-change", FTDM_SPAN_STATE_CHANGE},
{ "suspended", FTDM_SPAN_SUSPENDED},
{ "in-thread", FTDM_SPAN_IN_THREAD},
{ "stop-thread", FTDM_SPAN_STOP_THREAD},
{ "use-chan-queue", FTDM_SPAN_USE_CHAN_QUEUE},
{ "suggest-chan-id", FTDM_SPAN_SUGGEST_CHAN_ID},
{ "use-av-rate", FTDM_SPAN_USE_AV_RATE},
{ "power-saving", FTDM_SPAN_PWR_SAVING},
{ "signals-queue", FTDM_SPAN_USE_SIGNALS_QUEUE},
{ "proceed-state", FTDM_SPAN_USE_PROCEED_STATE},
{ "skip-state", FTDM_SPAN_USE_SKIP_STATES},
{ "non-stoppable", FTDM_SPAN_NON_STOPPABLE},
{ "use-transfer", FTDM_SPAN_USE_TRANSFER},
};
static ftdm_status_t ftdm_call_set_call_id(ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data);
static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data);
static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan);
static ftdm_status_t ftdm_channel_sig_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg);
static const char *channel_val2str(unsigned long long flag);
static unsigned long long channel_str2val(const char *flag_name);
static const char *ftdm_val2str(unsigned long long val, val_str_t *val_str_table, ftdm_size_t array_size, const char *default_str);
static unsigned long long ftdm_str2val(const char *str, val_str_t *val_str_table, ftdm_size_t array_size, unsigned long long default_val);
static int time_is_init = 0;
@ -4370,28 +4436,28 @@ static void print_channels_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *in
stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s) ON \n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval, channel_val2str(flagval));
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
mycount++;
} else {
stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s) OFF \n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval, channel_val2str(flagval));
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
}
} else if (!not) {
} else {
if (ftdm_test_flag(fchan, flag)) {
stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s) ON\n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval, channel_val2str(flagval));
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
mycount++;
} else {
stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s) OFF \n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval, channel_val2str(flagval));
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
}
}
}
@ -4412,16 +4478,16 @@ static void print_channels_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *in
for (curr = citer ; curr; curr = ftdm_iterator_next(curr)) {
fchan = ftdm_iterator_current(curr);
if (not && !ftdm_test_flag(fchan, flag)) {
stream->write_function(stream, "[s%dc%d][%d:%d] has not flag %d\n",
stream->write_function(stream, "[s%dc%d][%d:%d] flag !%d(!%s)\n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval);
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
mycount++;
} else if (!not && ftdm_test_flag(fchan, flag)) {
stream->write_function(stream, "[s%dc%d][%d:%d] has flag %d\n",
stream->write_function(stream, "[s%dc%d][%d:%d] flag %d(%s)\n",
fchan->span_id, fchan->chan_id,
fchan->physical_span_id, fchan->physical_chan_id,
flagval);
flagval, ftdm_val2str(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), "invalid"));
mycount++;
}
}
@ -4433,6 +4499,68 @@ end:
ftdm_mutex_unlock(globals.mutex);
}
static void print_spans_by_flag(ftdm_stream_handle_t *stream, ftdm_span_t *inspan, int32_t flagval, int not, int *count)
{
ftdm_hash_iterator_t *i = NULL;
ftdm_span_t *span;
const void *key = NULL;
void *val = NULL;
uint32_t flag = (1 << flagval);
int mycount = 0;
*count = 0;
ftdm_mutex_lock(globals.mutex);
if (inspan) {
if (not) {
if (!ftdm_test_flag(inspan, flag)) {
stream->write_function(stream, "[s%d] flag !%d(!%s) ON \n",
inspan->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
mycount++;
} else {
stream->write_function(stream, "[s%d] flag !%d(!%s) OFF \n",
inspan->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
}
} else {
if (ftdm_test_flag(inspan, flag)) {
stream->write_function(stream, "[s%d] flag %d(%s) ON \n",
inspan->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
mycount++;
} else {
stream->write_function(stream, "[s%d] flag %d(%s) OFF \n",
inspan->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
}
}
} else {
for (i = hashtable_first(globals.span_hash); i; i = hashtable_next(i)) {
hashtable_this(i, &key, NULL, &val);
if (!key || !val) {
break;
}
span = val;
if (not && !ftdm_test_flag(span, flag)) {
stream->write_function(stream, "[s%d] flag !%d(!%s)\n",
span->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
mycount++;
} else if (!not && ftdm_test_flag(span, flag)) {
stream->write_function(stream, "[s%d] flag %d(%s)\n",
span->span_id,
flagval, ftdm_val2str(flag, span_flag_strs, ftdm_array_len(span_flag_strs), "invalid"));
mycount++;
}
}
}
*count = mycount;
ftdm_mutex_unlock(globals.mutex);
}
static void print_channels_by_state(ftdm_stream_handle_t *stream, ftdm_channel_state_t state, int not, int *count)
{
ftdm_hash_iterator_t *i = NULL;
@ -4483,83 +4611,47 @@ static void print_core_usage(ftdm_stream_handle_t *stream)
"--------------------------------------------------------------------------------\n"
"ftdm core state [!]<state-name> - List all channels in or not in the given state\n"
"ftdm core flag [!]<flag-int-value|flag-name> [<span_id|span_name>] [<chan_id>] - List all channels with the given flag value set\n"
"ftdm core spanflag [!]<flag-int-value|flag-name> [<span_id|span_name>] - List all spans with the given span flag value set\n"
"ftdm core calls - List all known calls to the FreeTDM core\n"
"--------------------------------------------------------------------------------\n");
}
typedef struct channel_flags_str {
const char *name;
unsigned long long channel_flag;
} channel_flag_str_t;
static channel_flag_str_t channel_flag_strs[] = {
{ "configured" , FTDM_CHANNEL_CONFIGURED},
{ "ready", FTDM_CHANNEL_READY},
{ "open", FTDM_CHANNEL_OPEN},
{ "dtmf-detect", FTDM_CHANNEL_DTMF_DETECT},
{ "suppress-dtmf", FTDM_CHANNEL_SUPRESS_DTMF},
{ "transcode", FTDM_CHANNEL_TRANSCODE},
{ "buffer", FTDM_CHANNEL_BUFFER},
{ "in-thread", FTDM_CHANNEL_INTHREAD},
{ "wink", FTDM_CHANNEL_WINK},
{ "flash", FTDM_CHANNEL_FLASH},
{ "state-change", FTDM_CHANNEL_STATE_CHANGE},
{ "hold", FTDM_CHANNEL_HOLD},
{ "in-use", FTDM_CHANNEL_INUSE},
{ "off-hook", FTDM_CHANNEL_OFFHOOK},
{ "ringing", FTDM_CHANNEL_RINGING},
{ "progress-detect", FTDM_CHANNEL_PROGRESS_DETECT},
{ "callerid-detect", FTDM_CHANNEL_CALLERID_DETECT},
{ "outbound", FTDM_CHANNEL_OUTBOUND},
{ "suspended", FTDM_CHANNEL_SUSPENDED},
{ "3-way", FTDM_CHANNEL_3WAY},
{ "progress", FTDM_CHANNEL_PROGRESS},
{ "media", FTDM_CHANNEL_MEDIA},
{ "answered", FTDM_CHANNEL_ANSWERED},
{ "mute", FTDM_CHANNEL_MUTE},
{ "use-rx-gain", FTDM_CHANNEL_USE_RX_GAIN},
{ "use-tx-gain", FTDM_CHANNEL_USE_TX_GAIN},
{ "in-alarm", FTDM_CHANNEL_IN_ALARM},
{ "sig-up", FTDM_CHANNEL_SIG_UP},
{ "user-hangup", FTDM_CHANNEL_USER_HANGUP},
{ "rx-disabled", FTDM_CHANNEL_RX_DISABLED},
{ "tx-disabled", FTDM_CHANNEL_TX_DISABLED},
{ "call-started", FTDM_CHANNEL_CALL_STARTED},
{ "non-block", FTDM_CHANNEL_NONBLOCK},
{ "ind-ack-pending", FTDM_CHANNEL_IND_ACK_PENDING},
{ "blocking", FTDM_CHANNEL_BLOCKING},
{ "media", FTDM_CHANNEL_DIGITAL_MEDIA},
{ "native-sigbridge", FTDM_CHANNEL_NATIVE_SIGBRIDGE},
{ "invalid", FTDM_CHANNEL_MAX_FLAG},
};
static unsigned long long channel_str2val(const char *flag_name)
static unsigned long long ftdm_str2val(const char *str, val_str_t *val_str_table, ftdm_size_t array_size, unsigned long long default_val)
{
int i;
for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
if (!strcasecmp(channel_flag_strs[i].name, flag_name)) {
return channel_flag_strs[i].channel_flag;
for (i = 0; i < array_size; i++) {
if (!strcasecmp(val_str_table[i].str, str)) {
return val_str_table[i].val;
}
}
return FTDM_CHANNEL_MAX_FLAG;
return default_val;
}
static const char *channel_val2str(unsigned long long flag)
static const char *ftdm_val2str(unsigned long long val, val_str_t *val_str_table, ftdm_size_t array_size, const char *default_str)
{
int i;
for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
if (channel_flag_strs[i].channel_flag == flag) {
return channel_flag_strs[i].name;
for (i = 0; i < array_size; i++) {
if (val_str_table[i].val == val) {
return val_str_table[i].str;
}
}
return "invalid";
return default_str;
}
static void print_channel_flag_values(ftdm_stream_handle_t *stream)
{
int i;
for (i = 0; i < ftdm_array_len(channel_flag_strs); i++) {
stream->write_function(stream, "%s\n", channel_flag_strs[i].name);
stream->write_function(stream, "%s\n", channel_flag_strs[i].str);
}
}
static void print_span_flag_values(ftdm_stream_handle_t *stream)
{
int i;
for (i = 0; i < ftdm_array_len(span_flag_strs); i++) {
stream->write_function(stream, "%s\n", span_flag_strs[i].str);
}
}
@ -4631,12 +4723,13 @@ static char *handle_core_command(const char *cmd)
}
if (isalpha(flag[0])) {
flagval = channel_str2val(flag);
flagval = ftdm_str2val(flag, channel_flag_strs, ftdm_array_len(channel_flag_strs), FTDM_CHANNEL_MAX_FLAG);
if (flagval == FTDM_CHANNEL_MAX_FLAG) {
stream.write_function(&stream, "\nInvalid channel flag value. Possible channel flags\n");
print_channel_flag_values(&stream);
goto done;
}
flagval = flagval >> 1;
} else {
flagval = atoi(flag);
}
@ -4661,6 +4754,44 @@ static char *handle_core_command(const char *cmd)
print_channels_by_flag(&stream, fspan, chan_id, flagval, not, &count);
stream.write_function(&stream, "\nTotal channels %s %d: %d\n", not ? "without flag" : "with flag", flagval, count);
} else if (!strcasecmp(argv[0], "spanflag")) {
if (argc < 2) {
stream.write_function(&stream, "core spanflag command requires an argument\n");
print_core_usage(&stream);
goto done;
}
flag = argv[1];
if (argv[1][0] == '!') {
not = 1;
flag++;
}
if (isalpha(flag[0])) {
flagval = ftdm_str2val(flag, span_flag_strs, ftdm_array_len(span_flag_strs), FTDM_SPAN_MAX_FLAG);
if (flagval == FTDM_SPAN_MAX_FLAG) {
stream.write_function(&stream, "\nInvalid span flag value. Possible span flags\n");
print_span_flag_values(&stream);
goto done;
}
flagval = flagval >> 1;
} else {
flagval = atoi(flag);
}
/* Specific span specified */
if (argv[2]) {
ftdm_span_find_by_name(argv[2], &fspan);
if (!fspan) {
stream.write_function(&stream, "-ERR span:%s not found\n", argv[2]);
goto done;
}
}
print_spans_by_flag(&stream, fspan, flagval, not, &count);
if (!fspan) {
stream.write_function(&stream, "\nTotal spans %s %d: %d\n", not ? "without flag" : "with flag", flagval, count);
}
} else if (!strcasecmp(argv[0], "calls")) {
ftdm_mutex_lock(globals.call_id_mutex);
current_call_id = globals.last_call_id;

27
libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c
View File

@ -1460,6 +1460,33 @@ static ftdm_status_t handle_show_status(ftdm_stream_handle_t *stream, int span,
x++;
} /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
/* Look spans that are being used by M2UA SG links */
for (x = 1; x < ftdm_array_len(g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif); x++) {
if (g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].id) {
if (g_ftdm_sngss7_data.cfg.mtp2Link[g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].mtp2LnkNmb].id) {
uint32_t mtp1_id = g_ftdm_sngss7_data.cfg.mtp2Link[g_ftdm_sngss7_data.cfg.g_m2ua_cfg.nif[x].mtp2LnkNmb].id;
if (g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].id) {
if (g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span == span) {
if (chan) {
if (chan == g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan) {
stream->write_function(stream, "span=%2d|chan=%2d|cic=%4d|SIGNALING LINK\n",
g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span,
g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan,
0);
}
} else {
stream->write_function(stream, "span=%2d|chan=%2d|cic=%4d|SIGNALING LINK\n",
g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].span,
g_ftdm_sngss7_data.cfg.mtp1Link[mtp1_id].chan,
0);
}
}
}
}
}
}
return FTDM_SUCCESS;
}

2
libs/freetdm/src/include/private/ftdm_types.h
View File

@ -197,6 +197,8 @@ typedef enum {
FTDM_SPAN_NON_STOPPABLE = (1 << 13),
/* If this flag is set, then this span supports TRANSFER state */
FTDM_SPAN_USE_TRANSFER = (1 << 14),
/* This is the last flag, no more flags bigger than this */
FTDM_SPAN_MAX_FLAG = (1 << 15),
} ftdm_span_flag_t;
/*! \brief Channel supported features */

47
src/mod/endpoints/mod_media_gateway/media_gateway_cli.c
View File

@ -138,6 +138,7 @@ done:
switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, megaco_profile_t* mg_cfg)
{
int idx = 0x00;
int peerIdx = 0x00;
int len = 0x00;
MgMngmt cfm;
char* xmlhdr = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
@ -152,22 +153,23 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
memset((U8 *)&cfm, 0, sizeof(cfm));
memset((char *)&prntBuf, 0, sizeof(prntBuf));
mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
if(!mg_peer){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[0],mg_cfg->name);
return SWITCH_STATUS_FALSE;
}
idx = mg_cfg->idx;
len = len + sprintf(&prntBuf[0] + len,"%s\n",xmlhdr);
len = len + sprintf(&prntBuf[0] + len,"<mg_peer>\n");
len = len + sprintf(&prntBuf[0] + len,"<name>%s</name>\n",mg_cfg->peer_list[0]);
len = len + sprintf(&prntBuf[0] + len,"<mg_peers>\n");
/* TODO - as of now supporting only one peer .. need to add logic to iterate through all the peers associated with this profile..*/
for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
if(!mg_peer){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[peerIdx],mg_cfg->name);
return SWITCH_STATUS_FALSE;
}
len = len + sprintf(&prntBuf[0] + len,"<mg_peer>\n");
len = len + sprintf(&prntBuf[0] + len,"<name>%s</name>\n",mg_peer->name);
/* send request to MEGACO Trillium stack to get peer information*/
sng_mgco_mg_get_status(STGCPENT, &cfm, mg_cfg, mg_peer);
@ -179,6 +181,9 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
len = len + sprintf(prntBuf+len, "<peer_state>%s</peer_state>\n",PRNT_MG_PEER_STATE(cfm.t.ssta.s.mgPeerSta.peerState));
len = len + sprintf(&prntBuf[0] + len,"</mg_peer>\n");
}
len = len + sprintf(&prntBuf[0] + len,"</mg_peers>\n");
stream->write_function(stream, "\n%s\n",&prntBuf[0]);
@ -190,6 +195,7 @@ switch_status_t megaco_profile_peer_xmlstatus(switch_stream_handle_t *stream, me
switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_profile_t* mg_cfg)
{
int idx = 0x00;
int peerIdx = 0x00;
int len = 0x00;
MgMngmt cfm;
char* xmlhdr = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>";
@ -204,12 +210,6 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
memset((U8 *)&cfm, 0, sizeof(cfm));
memset((char *)&prntBuf, 0, sizeof(prntBuf));
mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
if(!mg_peer){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[0],mg_cfg->name);
return SWITCH_STATUS_FALSE;
}
idx = mg_cfg->idx;
@ -221,9 +221,17 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
/****************************************************************************************************************/
/* Print Peer Information ***************************************************************************************/
/* TODO - as of now supporting only one peer .. need to add logic to iterate through all the peers associated with this profile..*/
len = len + sprintf(&prntBuf[0] + len,"<mg_peers>\n");
for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
if(!mg_peer){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," No MG peer configuration found for peername[%s] against profilename[%s]\n",mg_cfg->peer_list[peerIdx],mg_cfg->name);
return SWITCH_STATUS_FALSE;
}
len = len + sprintf(&prntBuf[0] + len,"<mg_peer name=%s>\n",mg_peer->name);
/* send request to MEGACO Trillium stack to get peer information*/
@ -232,6 +240,7 @@ switch_status_t megaco_profile_xmlstatus(switch_stream_handle_t *stream, megaco_
get_peer_xml_buffer(&prntBuf[0] + len, &cfm.t.ssta.s.mgPeerSta);
len = len + sprintf(&prntBuf[0] + len,"</mg_peer>\n");
}
len = len + sprintf(&prntBuf[0] + len,"</mg_peers>\n");

17
src/mod/endpoints/mod_media_gateway/media_gateway_stack.c
View File

@ -183,7 +183,6 @@ switch_status_t sng_mgco_cfg(megaco_profile_t* profile)
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO," mgco_mu_ssap_config SUCCESS \n");
}
if(mgco_mg_tsap_config(profile)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR," mgco_mg_tsap_config FAILED \n");
return SWITCH_STATUS_FALSE;
@ -256,7 +255,6 @@ switch_status_t sng_mgco_start(megaco_profile_t* profile )
else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, " mgco_mg_tsap_enable_cntrl SUCCESS \n");
}
//mgco_mg_enable_debug();
return SWITCH_STATUS_SUCCESS;
}
@ -784,6 +782,8 @@ int mgco_mg_gen_config(void)
cfg->noEDInst = 1;
#endif /* CM_ABNF_MT_LIB */
cfg->entType = LMG_ENT_GW;
#ifdef GCP_CH
cfg->numBinsPeerCmdHl = 20;
cfg->numBinsTransReqHl = 50;
@ -1002,7 +1002,7 @@ int mgco_mg_tsap_config(megaco_profile_t* profile)
/* FILL TSAP config */
cfg->tSAPId = profile->idx;
cfg->spId = profile->idx;
cfg->provType = mg_get_tpt_type(profile);
cfg->provType = LMG_PROV_TYPE_TUCL;
/* FILL TUCL Information */
cfg->memId.region = S_REG;
@ -1046,7 +1046,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
Pst pst; /* Post for layer manager */
U32 peerIdx = 0;
CmInetIpAddr ipAddr = 0;
mg_peer_profile_t* mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[0]);
mg_peer_profile_t* mg_peer = NULL;
memset(&mgMngmt, 0, sizeof(mgMngmt));
cfg = &(mgMngmt.t.cfg.c.mgGcpEntCfg);
@ -1064,13 +1064,16 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
mgMngmt.hdr.elmId.elmnt = STGCPENT;
cfg->numPeer = mg_cfg->total_peers;
for(peerIdx =0; peerIdx < mg_cfg->total_peers; peerIdx++){
mg_peer = megaco_peer_profile_locate(mg_cfg->peer_list[peerIdx]);
cfg->peerCfg[peerIdx].sSAPId = mg_cfg->idx; /* SSAP ID */;
cfg->peerCfg[peerIdx].port = atoi(mg_peer->port);
cfg->peerCfg[peerIdx].tsapId = mg_cfg->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;
@ -1088,7 +1091,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
#ifdef GCP_MG
cfg->peerCfg[peerIdx].transportType = mg_get_tpt_type_from_str(mg_peer->transport_type);
cfg->peerCfg[peerIdx].encodingScheme = mg_get_enc_type_from_str(mg_peer->encoding_type);
cfg->peerCfg[peerIdx].mgcPriority = 0;
cfg->peerCfg[peerIdx].mgcPriority = peerIdx;
cfg->peerCfg[peerIdx].useAHScheme = FALSE;
cfg->peerCfg[peerIdx].mid.pres = PRSNT_NODEF;
cfg->peerCfg[peerIdx].mid.len = strlen((char*)mg_peer->mid);
@ -1097,6 +1100,7 @@ int mgco_mg_peer_config(megaco_profile_t* mg_cfg)
cfg->peerCfg[peerIdx].mid.len);
#endif /* GCP_MG */
}
return(sng_cfg_mg(&pst, &mgMngmt));
}
@ -1306,7 +1310,6 @@ sng_mg_transport_types_e mg_get_tpt_type_from_str(char* tpt_type)
if(!strcasecmp(tpt_type, "UDP")){
return SNG_MG_TPT_UDP;
}else if(!strcasecmp(tpt_type,"TCP")){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "TCP Transport for H.248 Protocol Not Yet Supported \n");
return SNG_MG_TPT_TCP;
}else if(!strcasecmp(tpt_type,"STCP")){
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STCP Transport for H.248 Protocol Not Yet Supported \n");

6
src/mod/endpoints/mod_media_gateway/media_gateway_xml.c
View File

@ -78,11 +78,12 @@ switch_status_t config_profile(megaco_profile_t *profile, switch_bool_t reload)
goto done;
}
count = 0x00;
event = NULL;
for (mg_peer = switch_xml_child(mg_peers, "mg_peer"); mg_peer; mg_peer = mg_peer->next) {
const char *name = switch_xml_attr_soft(mg_peer, "name");
for(idx=0; idx<profile->total_peers; idx++){
count = 0x00;
event = NULL;
peer_profile = NULL;
if (!strcmp(name, profile->peer_list[idx])) {
/* peer profile */
peer_profile = switch_core_alloc(profile->pool, sizeof(*peer_profile));
@ -136,6 +137,7 @@ switch_status_t mg_config_cleanup(megaco_profile_t* profile)
static switch_xml_config_item_t *get_peer_instructions(mg_peer_profile_t *profile) {
switch_xml_config_item_t *dup;
switch_xml_config_item_t instructions[] = {
/* parameter name type reloadable pointer default value options structure */
SWITCH_CONFIG_ITEM("ip", SWITCH_CONFIG_STRING, CONFIG_RELOADABLE, &profile->ipaddr, "", &switch_config_string_strdup, "", "Peer IP"),

2
src/mod/endpoints/mod_media_gateway/mod_media_gateway.c
View File

@ -118,7 +118,7 @@ void handle_sng_log(uint8_t level, char *fmt, ...)
case SNG_LOGLEVEL_DEBUG: log_level = SWITCH_LOG_DEBUG; break;
case SNG_LOGLEVEL_INFO: log_level = SWITCH_LOG_INFO; break;
case SNG_LOGLEVEL_WARN: log_level = SWITCH_LOG_WARNING; break;
case SNG_LOGLEVEL_ERROR: log_level = SWITCH_LOG_DEBUG; break;
case SNG_LOGLEVEL_ERROR: log_level = SWITCH_LOG_ERROR; break;
case SNG_LOGLEVEL_CRIT: log_level = SWITCH_LOG_CRIT; break;
default: log_level = SWITCH_LOG_DEBUG; break;
};

41
src/mod/endpoints/mod_sofia/rtp.c
View File

@ -88,15 +88,19 @@ switch_io_routines_t crtp_io_routines = {
.send_dtmf = channel_send_dtmf
};
#if 0
SWITCH_STANDARD_API(test_function)
{
return SWITCH_STATUS_SUCCESS;
}
#endif
void crtp_init(switch_loadable_module_interface_t *module_interface)
{
switch_endpoint_interface_t *endpoint_interface;
#if 0 /* DAVIDY */
switch_api_interface_t *api_interface;
#endif
crtp.pool = module_interface->pool;
endpoint_interface = switch_loadable_module_create_interface(module_interface, SWITCH_ENDPOINT_INTERFACE);
endpoint_interface->interface_name = "rtp";
@ -128,12 +132,18 @@ typedef struct parsed_sdp_s {
static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_sdp, const char *codec_string)
{
switch_core_session_t const * session = tech_pvt->session;
int num_codecs;
const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS] = { 0 };
char *codec_order[SWITCH_MAX_CODECS] = { 0 };
int codec_order_last;
int num_codecs;
#if 0 /* DAVIDY */
switch_core_session_t const * session = tech_pvt->session;
#endif
const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS] = { 0 };
char *codec_order[SWITCH_MAX_CODECS] = { 0 };
#if 1 /* DAVIDY */
char *sdpbuf = NULL;
sdp_connection_t *connection = NULL;
sdp_printer_t *printer = NULL;
#endif
/* Load in the list of codecs we support. If we have a codec string we use our priorities first */
@ -151,24 +161,30 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
if (zstr(l_sdp)) {
/* Generate a local SDP here */
#if 0 /* DAVIDY */
const char *sdpbuf = switch_core_session_sprintf(session, "v=0\nIN IP4 %s\nm=audio %d RTP/AVP %d");
#endif
} else {
/* Parse the SDP and remove anything we cannot support, then validate it to make sure it contains at least one codec
* so that we reject invalid ones. */
#if 1
#if 0
uint8_t match = 0;
int first = 0, last = 0;
int ptime = 0, dptime = 0, maxptime = 0, dmaxptime = 0;
int sendonly = 0, recvonly = 0;
int greedy = 0, x = 0, skip = 0, mine = 0;
int got_crypto = 0, got_audio = 0, got_avp = 0, got_savp = 0, got_udptl = 0;
int greedy = 0, x = 0, skip = 0;
#endif
int ptime = 0, maxptime = 0;
int sdp_modified = 0;
int cur_codec = 0;
sdp_parser_t *parser = NULL;
#if 1 /* DAVIDY */
sdp_session_t *sdp;
#else
sdp_session_t *sdp, *lsdp;
#endif
sdp_media_t *m;
sdp_attribute_t *attr;
su_home_t *sdp_home;
@ -196,7 +212,6 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
}
}
sdp_connection_t *connection;
connection = sdp->sdp_connection;
if (m->m_connections) {
connection = m->m_connections;
@ -250,8 +265,10 @@ static switch_status_t setup_local_rtp(crtp_private_t *tech_pvt, const char *l_s
}
}
#if 0 /* DAVIDY */
char sdpbuf[2048] = "";
sdp_printer_t *printer = sdp_print(sdp_home, sdp, sdpbuf, sizeof(sdpbuf), 0);
#endif
printer = sdp_print(sdp_home, sdp, sdpbuf, sizeof(sdpbuf), 0);
switch_channel_set_variable(tech_pvt->channel, kLSDP, sdpbuf);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Setting local SDP: [%s]\n", sdpbuf);
sdp_printer_free(printer);
@ -485,8 +502,10 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
char name[128];
const char *dname = "PCMU";
uint32_t interval = 20;
crtp_private_t *tech_pvt;
crtp_private_t *tech_pvt = NULL;
#if 0
const char *r_sdp = switch_event_get_header(var_event, kRSDP);
#endif
const char *l_sdp = switch_event_get_header(var_event, kLSDP);
const char *codec_string = switch_event_get_header_nil(var_event, kCODECSTRING);