kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-04-13 07:45:26 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' of git.freeswitch.org:freeswitch

Browse Source
This commit is contained in:
Brian West 2010-04-28 09:19:07 -05:00
commit a5a24d4142
16 changed files with 409 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
conf/autoload_configs/switch.conf.xml
View File

@ -72,6 +72,8 @@
<param name="mailer-app" value="sendmail"/>
<param name="mailer-app-args" value="-t"/>
<param name="dump-cores" value="yes"/>
<!-- enable verbose-channel-events to dump every detail about a channel on every event -->
<!--<param name="verbose-channel-events" value="no"/>-->
<!--RTP port range -->
<!--<param name="rtp-start-port" value="16384"/>-->
<!--<param name="rtp-end-port" value="32768"/>-->

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

@ -25,6 +25,7 @@
*
* Anthony Minessale II <anthmct@yahoo.com>
* Moises Silva <moy@sangoma.com>
* David Yat Sin <dyatsin@sangoma.com>
*
*
* mod_freetdm.c -- FreeTDM Endpoint Module
@ -1950,6 +1951,14 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A");
}
}
break;
case FTDM_SIGEVENT_SIGSTATUS_CHANGED:
{
ftdm_signaling_status_t *sigstatus = (ftdm_signaling_status_t*)(sigmsg->raw_data);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%d:%d signalling changed to :%s\n",
sigmsg->channel->span_id, sigmsg->channel->chan_id, ftdm_signaling_status2str(*sigstatus));
}
break;
default:
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled msg type %d for channel %d:%d\n",
@ -2983,15 +2992,19 @@ static switch_status_t load_config(void)
void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream)
{
ftdm_signaling_status_t sigstatus = FTDM_SIG_STATE_DOWN;
if (chan_id > span->chan_count) {
return;
}
ftdm_channel_get_sig_status(span->channels[chan_id], &sigstatus);
stream->write_function(stream,
"span_id: %u\n"
"chan_id: %u\n"
"physical_span_id: %u\n"
"physical_chan_id: %u\n"
"physical_status: %s\n"
"signaling_status: %s\n"
"type: %s\n"
"state: %s\n"
"last_state: %s\n"
@ -3009,6 +3022,8 @@ void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stre
span->channels[chan_id]->chan_id,
span->channels[chan_id]->physical_span_id,
span->channels[chan_id]->physical_chan_id,
(span->channels[chan_id]->alarm_flags) ? "DOWN" : "UP",
ftdm_signaling_status2str(sigstatus),
ftdm_chan_type2str(span->channels[chan_id]->type),
ftdm_channel_state2str(span->channels[chan_id]->state),
ftdm_channel_state2str(span->channels[chan_id]->last_state),
@ -3027,16 +3042,19 @@ void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stre
void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream)
{
ftdm_signaling_status_t sigstatus = FTDM_SIG_STATE_DOWN;
if (chan_id > span->chan_count) {
return;
}
ftdm_channel_get_sig_status(span->channels[chan_id], &sigstatus);
stream->write_function(stream,
" <channel>\n"
" <span-id>%u</span-id>\n"
" <chan-id>%u</chan-id>>\n"
" <physical-span-id>%u</physical-span-id>\n"
" <physical-chan-id>%u</physical-chan-id>\n"
" <physical-status>%s</physical-status>\n"
" <signaling-status>%s</signaling-status>\n"
" <type>%s</type>\n"
" <state>%s</state>\n"
" <last-state>%s</last-state>\n"
@ -3055,6 +3073,8 @@ void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *
span->channels[chan_id]->chan_id,
span->channels[chan_id]->physical_span_id,
span->channels[chan_id]->physical_chan_id,
(span->channels[chan_id]->alarm_flags) ? "DOWN" : "UP",
ftdm_signaling_status2str(sigstatus),
ftdm_chan_type2str(span->channels[chan_id]->type),
ftdm_channel_state2str(span->channels[chan_id]->state),
ftdm_channel_state2str(span->channels[chan_id]->last_state),
@ -3168,7 +3188,7 @@ SWITCH_STANDARD_API(ft_function)
stream->write_function(stream,
"+OK\n"
"span: %u (%s)\n"
"type: %s\n"
"type: %s\n"
"signaling_status: %s\n"
"chan_count: %u\n"
"dialplan: %s\n"

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

@ -143,6 +143,8 @@ FTDM_STR2ENUM(ftdm_str2ftdm_chan_type, ftdm_chan_type2str, ftdm_chan_type_t, CHA
FTDM_ENUM_NAMES(SIGNALING_STATUS_NAMES, SIGSTATUS_STRINGS)
FTDM_STR2ENUM(ftdm_str2ftdm_signaling_status, ftdm_signaling_status2str, ftdm_signaling_status_t, SIGNALING_STATUS_NAMES, FTDM_SIG_STATE_INVALID)
static ftdm_status_t ftdm_group_add_channels(ftdm_span_t* span, int currindex, const char* name);
static const char *cut_path(const char *in)
{
const char *p, *ret = in;
@ -775,7 +777,7 @@ FT_DECLARE(ftdm_status_t) ftdm_span_add_channel(ftdm_span_t *span, ftdm_socket_t
i++;
}
ftdm_set_flag(new_chan, FTDM_CHANNEL_CONFIGURED | FTDM_CHANNEL_READY);
ftdm_set_flag(new_chan, FTDM_CHANNEL_CONFIGURED | FTDM_CHANNEL_READY);
*chan = new_chan;
return FTDM_SUCCESS;
}
@ -1279,9 +1281,10 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_group(uint32_t group_id, ftdm_dir
if (!(check = group->channels[i])) {
status = FTDM_FAIL;
break;
}
}
if (ftdm_test_flag(check, FTDM_CHANNEL_READY) &&
if (ftdm_test_flag(check, FTDM_CHANNEL_READY) &&
ftdm_test_flag(check, FTDM_CHANNEL_SIG_UP) &&
!ftdm_test_flag(check, FTDM_CHANNEL_INUSE) &&
!ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) &&
!ftdm_test_flag(check, FTDM_CHANNEL_IN_ALARM) &&
@ -1401,7 +1404,8 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_span(uint32_t span_id, ftdm_direc
break;
}
if (ftdm_test_flag(check, FTDM_CHANNEL_READY) &&
if (ftdm_test_flag(check, FTDM_CHANNEL_READY) &&
ftdm_test_flag(check, FTDM_CHANNEL_SIG_UP) &&
!ftdm_test_flag(check, FTDM_CHANNEL_INUSE) &&
!ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) &&
!ftdm_test_flag(check, FTDM_CHANNEL_IN_ALARM) &&
@ -2851,26 +2855,79 @@ FT_DECLARE(char *) ftdm_api_execute(const char *type, const char *cmd)
return rval;
}
static void ftdm_set_channels_gains(ftdm_span_t *span, int currindex, float rxgain, float txgain)
static ftdm_status_t ftdm_set_channels_gains(ftdm_span_t *span, int currindex, float rxgain, float txgain)
{
unsigned chan_index = 0;
if (!span->chan_count) {
return;
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to set gains because span has no channels\n");
return FTDM_FAIL;
}
for (chan_index = currindex+1; chan_index <= span->chan_count; chan_index++) {
if (!FTDM_IS_VOICE_CHANNEL(span->channels[chan_index])) {
continue;
}
ftdm_channel_command(span->channels[chan_index], FTDM_COMMAND_SET_RX_GAIN, &rxgain);
ftdm_channel_command(span->channels[chan_index], FTDM_COMMAND_SET_TX_GAIN, &txgain);
if (ftdm_channel_command(span->channels[chan_index], FTDM_COMMAND_SET_RX_GAIN, &rxgain) != FTDM_SUCCESS) {
return FTDM_FAIL;
}
if (ftdm_channel_command(span->channels[chan_index], FTDM_COMMAND_SET_TX_GAIN, &txgain) != FTDM_SUCCESS) {
return FTDM_FAIL;
}
}
return FTDM_SUCCESS;
}
static ftdm_status_t ftdm_set_channels_alarms(ftdm_span_t *span, int currindex) {
unsigned chan_index = 0;
if (!span->chan_count) {
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to set alarms because span has no channels\n");
return FTDM_FAIL;
}
if (!span->fio->get_alarms) {
ftdm_log(FTDM_LOG_WARNING, "%d: Span does not support alarms\n", span->span_id);
return FTDM_SUCCESS;
}
for (chan_index = currindex+1; chan_index <= span->chan_count; chan_index++) {
/* fio->get_alarms will update ftdm_chan->alarm_flags */
if (span->fio->get_alarms(span->channels[chan_index]) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "%d:%d: Failed to get alarms\n", span->channels[chan_index]->physical_span_id, span->channels[chan_index]->physical_chan_id);
return FTDM_FAIL;
}
}
return FTDM_SUCCESS;
}
FT_DECLARE(ftdm_status_t) ftdm_configure_span_channels(ftdm_span_t *span, const char* str, ftdm_channel_config_t *chan_config, unsigned *configured)
{
int currindex = span->chan_count;
*configured = 0;
*configured = span->fio->configure_span(span, str, chan_config->type, chan_config->name, chan_config->number);
if (!*configured) {
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to configure span", span->span_id);
return FTDM_FAIL;
}
if (ftdm_group_add_channels(span, currindex, chan_config->group_name) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to add channels to group %s\n", span->span_id, chan_config->group_name);
return FTDM_FAIL;
}
if (ftdm_set_channels_alarms(span, currindex) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to set channel alarms\n", span->span_id);
return FTDM_FAIL;
}
if (ftdm_set_channels_gains(span, currindex, chan_config->rxgain, chan_config->txgain) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "%d:Failed to set channel gains\n", span->span_id);
return FTDM_FAIL;
}
return FTDM_SUCCESS;
}
static ftdm_status_t ftdm_group_add_channels(const char* name, ftdm_span_t* span, int currindex);
static ftdm_status_t load_config(void)
{
char cfg_name[] = "freetdm.conf";
@ -2878,17 +2935,15 @@ static ftdm_status_t load_config(void)
char *var, *val;
int catno = -1;
int intparam = 0;
int currindex = 0;
ftdm_span_t *span = NULL;
unsigned configured = 0, d = 0;
char name[80] = "";
char number[25] = "";
char group_name[80] = "default";
ftdm_io_interface_t *fio = NULL;
ftdm_analog_start_type_t tmp;
float rxgain = 0.0;
float txgain = 0.0;
ftdm_size_t len = 0;
ftdm_channel_config_t chan_config;
memset(&chan_config, 0, sizeof(chan_config));
sprintf(chan_config.group_name,"default");
if (!ftdm_config_open_file(&cfg, cfg_name)) {
return FTDM_FAIL;
@ -2967,15 +3022,15 @@ static ftdm_status_t load_config(void)
ftdm_log(FTDM_LOG_DEBUG, "setting trunk type to '%s'\n", ftdm_trunk_type2str(span->trunk_type));
} else if (!strcasecmp(var, "name")) {
if (!strcasecmp(val, "undef")) {
*name = '\0';
chan_config.name[0] = '\0';
} else {
ftdm_copy_string(name, val, sizeof(name));
ftdm_copy_string(chan_config.name, val, FTDM_MAX_NAME_STR_SZ);
}
} else if (!strcasecmp(var, "number")) {
if (!strcasecmp(val, "undef")) {
*number = '\0';
chan_config.number[0] = '\0';
} else {
ftdm_copy_string(number, val, sizeof(number));
ftdm_copy_string(chan_config.number, val, FTDM_MAX_NUMBER_STR_SZ);
}
} else if (!strcasecmp(var, "analog-start-type")) {
if (span->trunk_type == FTDM_TRUNK_FXS || span->trunk_type == FTDM_TRUNK_FXO || span->trunk_type == FTDM_TRUNK_EM) {
@ -2993,10 +3048,11 @@ static ftdm_status_t load_config(void)
ftdm_analog_start_type2str(span->start_type));
}
if (span->trunk_type == FTDM_TRUNK_FXO) {
currindex = span->chan_count;
configured += fio->configure_span(span, val, FTDM_CHAN_TYPE_FXO, name, number);
ftdm_set_channels_gains(span, currindex, rxgain, txgain);
ftdm_group_add_channels(group_name, span, currindex);
unsigned chans_configured = 0;
chan_config.type = FTDM_CHAN_TYPE_FXO;
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
} else {
ftdm_log(FTDM_LOG_WARNING, "Cannot add FXO channels to an FXS trunk!\n");
}
@ -3007,10 +3063,11 @@ static ftdm_status_t load_config(void)
ftdm_analog_start_type2str(span->start_type));
}
if (span->trunk_type == FTDM_TRUNK_FXS) {
currindex = span->chan_count;
configured += fio->configure_span(span, val, FTDM_CHAN_TYPE_FXS, name, number);
ftdm_set_channels_gains(span, currindex, rxgain, txgain);
ftdm_group_add_channels(group_name, span, currindex);
unsigned chans_configured = 0;
chan_config.type = FTDM_CHAN_TYPE_FXS;
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
} else {
ftdm_log(FTDM_LOG_WARNING, "Cannot add FXS channels to an FXO trunk!\n");
}
@ -3021,56 +3078,62 @@ static ftdm_status_t load_config(void)
ftdm_analog_start_type2str(span->start_type));
}
if (span->trunk_type == FTDM_TRUNK_EM) {
currindex = span->chan_count;
configured += fio->configure_span(span, val, FTDM_CHAN_TYPE_EM, name, number);
ftdm_set_channels_gains(span, currindex, rxgain, txgain);
ftdm_group_add_channels(group_name, span, currindex);
unsigned chans_configured = 0;
chan_config.type = FTDM_CHAN_TYPE_EM;
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
} else {
ftdm_log(FTDM_LOG_WARNING, "Cannot add EM channels to a non-EM trunk!\n");
}
} else if (!strcasecmp(var, "b-channel")) {
currindex = span->chan_count;
configured += fio->configure_span(span, val, FTDM_CHAN_TYPE_B, name, number);
ftdm_set_channels_gains(span, currindex, rxgain, txgain);
ftdm_group_add_channels(group_name, span, currindex);
unsigned chans_configured = 0;
chan_config.type = FTDM_CHAN_TYPE_B;
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
} else if (!strcasecmp(var, "d-channel")) {
if (d) {
ftdm_log(FTDM_LOG_WARNING, "ignoring extra d-channel\n");
} else {
ftdm_chan_type_t qtype;
unsigned chans_configured = 0;
if (!strncasecmp(val, "lapd:", 5)) {
qtype = FTDM_CHAN_TYPE_DQ931;
chan_config.type = FTDM_CHAN_TYPE_DQ931;
val += 5;
} else {
qtype = FTDM_CHAN_TYPE_DQ921;
chan_config.type = FTDM_CHAN_TYPE_DQ921;
}
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
configured += fio->configure_span(span, val, qtype, name, number);
d++;
}
} else if (!strcasecmp(var, "cas-channel")) {
currindex = span->chan_count;
configured += fio->configure_span(span, val, FTDM_CHAN_TYPE_CAS, name, number);
ftdm_set_channels_gains(span, currindex, rxgain, txgain);
ftdm_group_add_channels(group_name, span, currindex);
unsigned chans_configured = 0;
chan_config.type = FTDM_CHAN_TYPE_CAS;
if (ftdm_configure_span_channels(span, val, &chan_config, &chans_configured) == FTDM_SUCCESS) {
configured += chans_configured;
}
} else if (!strcasecmp(var, "dtmf_hangup")) {
span->dtmf_hangup = ftdm_strdup(val);
span->dtmf_hangup_len = strlen(val);
} else if (!strcasecmp(var, "txgain")) {
if (sscanf(val, "%f", &txgain) != 1) {
if (sscanf(val, "%f", &(chan_config.txgain)) != 1) {
ftdm_log(FTDM_LOG_ERROR, "invalid txgain: '%s'\n", val);
}
} else if (!strcasecmp(var, "rxgain")) {
if (sscanf(val, "%f", &rxgain) != 1) {
if (sscanf(val, "%f", &(chan_config.rxgain)) != 1) {
ftdm_log(FTDM_LOG_ERROR, "invalid rxgain: '%s'\n", val);
}
} else if (!strcasecmp(var, "group")) {
len = strlen(val);
if (len >= sizeof(group_name)) {
len = sizeof(group_name) - 1;
if (len >= FTDM_MAX_NAME_STR_SZ) {
len = FTDM_MAX_NAME_STR_SZ - 1;
ftdm_log(FTDM_LOG_WARNING, "Truncating group name %s to %zd length\n", val, len);
}
memcpy(group_name, val, len);
group_name[len] = '\0';
memcpy(chan_config.group_name, val, len);
chan_config.group_name[len] = '\0';
} else {
ftdm_log(FTDM_LOG_ERROR, "unknown span variable '%s'\n", var);
}
@ -3527,7 +3590,7 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_remove_from_group(ftdm_group_t* group, ft
return FTDM_FAIL;
}
static ftdm_status_t ftdm_group_add_channels(const char* name, ftdm_span_t* span, int currindex)
static ftdm_status_t ftdm_group_add_channels(ftdm_span_t* span, int currindex, const char* name)
{
unsigned chan_index = 0;
@ -3639,19 +3702,24 @@ FT_DECLARE(ftdm_status_t) ftdm_group_create(ftdm_group_t **group, const char *na
FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg)
{
ftdm_status_t status = FTDM_FAIL;
if (span->signal_cb) {
if (sigmsg->channel) {
ftdm_mutex_lock(sigmsg->channel->mutex);
}
status = span->signal_cb(sigmsg);
if (sigmsg->channel) {
ftdm_mutex_unlock(sigmsg->channel->mutex);
}
if (sigmsg->channel) {
ftdm_mutex_lock(sigmsg->channel->mutex);
}
if (sigmsg->event_id == FTDM_SIGEVENT_SIGSTATUS_CHANGED) {
if (*((ftdm_signaling_status_t*)(sigmsg->raw_data)) == FTDM_SIG_STATE_UP) {
ftdm_set_flag(sigmsg->channel, FTDM_CHANNEL_SIG_UP);
} else {
ftdm_clear_flag(sigmsg->channel, FTDM_CHANNEL_SIG_UP);
}
}
if (span->signal_cb) {
status = span->signal_cb(sigmsg);
}
if (sigmsg->channel) {
ftdm_mutex_unlock(sigmsg->channel->mutex);
}
return status;
}

29
libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c
View File

@ -84,6 +84,32 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxs_outgoing_call)
return FTDM_SUCCESS;
}
/**
* \brief Returns the signalling status on a channel
* \param ftdmchan Channel to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(analog_get_channel_sig_status)
{
*status = FTDM_SIG_STATE_UP;
return FTDM_SUCCESS;
}
/**
* \brief Returns the signalling status on a span
* \param span Span to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_SPAN_GET_SIG_STATUS_FUNCTION(analog_get_span_sig_status)
{
*status = FTDM_SIG_STATE_UP;
return FTDM_SUCCESS;
}
/**
* \brief Starts an analog span thread (monitor)
* \param span Span to monitor
@ -181,6 +207,9 @@ static FIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_configure_span)
span->signal_type = FTDM_SIGTYPE_ANALOG;
span->signal_data = analog_data;
span->outgoing_call = span->trunk_type == FTDM_TRUNK_FXS ? analog_fxs_outgoing_call : analog_fxo_outgoing_call;
span->get_channel_sig_status = analog_get_channel_sig_status;
span->get_span_sig_status = analog_get_span_sig_status;
ftdm_span_load_tones(span, tonemap);
return FTDM_SUCCESS;

28
libs/freetdm/src/ftmod/ftmod_analog_em/ftmod_analog_em.c
View File

@ -82,6 +82,32 @@ static ftdm_status_t ftdm_analog_em_start(ftdm_span_t *span)
return ftdm_thread_create_detached(ftdm_analog_em_run, span);
}
/**
* \brief Returns the signalling status on a channel
* \param ftdmchan Channel to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(analog_em_get_channel_sig_status)
{
*status = FTDM_SIG_STATE_UP;
return FTDM_SUCCESS;
}
/**
* \brief Returns the signalling status on a span
* \param span Span to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_SPAN_GET_SIG_STATUS_FUNCTION(analog_em_get_span_sig_status)
{
*status = FTDM_SIG_STATE_UP;
return FTDM_SUCCESS;
}
/**
* \brief Initialises an EM span from configuration variables
* \param span Span to configure
@ -149,6 +175,8 @@ static FIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_em_configure_span)
span->signal_type = FTDM_SIGTYPE_ANALOG;
span->signal_data = analog_data;
span->outgoing_call = analog_em_outgoing_call;
span->get_channel_sig_status = analog_em_get_channel_sig_status;
span->get_span_sig_status = analog_em_get_span_sig_status;
ftdm_span_load_tones(span, tonemap);
return FTDM_SUCCESS;

79
libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c
View File

@ -43,6 +43,43 @@ static FIO_IO_UNLOAD_FUNCTION(ftdm_libpri_unload)
return FTDM_SUCCESS;
}
/**
* \brief Returns the signalling status on a channel
* \param ftdmchan Channel to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(isdn_get_channel_sig_status)
{
*status = FTDM_SIG_STATE_DOWN;
ftdm_libpri_data_t *isdn_data = ftdmchan->span->signal_data;
if (ftdm_test_flag(&(isdn_data->spri), LPWRAP_PRI_READY)) {
*status = FTDM_SIG_STATE_UP;
}
return FTDM_SUCCESS;
}
/**
* \brief Returns the signalling status on a span
* \param span Span to get status on
* \param status Pointer to set signalling status
* \return Success or failure
*/
static FIO_SPAN_GET_SIG_STATUS_FUNCTION(isdn_get_span_sig_status)
{
*status = FTDM_SIG_STATE_DOWN;
ftdm_libpri_data_t *isdn_data = span->signal_data;
if (ftdm_test_flag(&(isdn_data->spri), LPWRAP_PRI_READY)) {
*status = FTDM_SIG_STATE_UP;
}
return FTDM_SUCCESS;
}
/**
* \brief Starts a libpri channel (outgoing call)
* \param ftdmchan Channel to initiate call on
@ -937,13 +974,27 @@ static int on_restart(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_eve
*/
static int on_dchan_up(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent)
{
if (!ftdm_test_flag(spri, LPWRAP_PRI_READY)) {
ftdm_signaling_status_t status = FTDM_SIG_STATE_UP;
ftdm_channel_t *ftdmchan = NULL;
ftdm_sigmsg_t sig;
int i;
ftdm_log(FTDM_LOG_INFO, "Span %d D-Chan UP!\n", spri->span->span_id);
ftdm_set_flag(spri, LPWRAP_PRI_READY);
ftdm_set_state_all(spri->span, FTDM_CHANNEL_STATE_RESTART);
}
ftdm_log(FTDM_LOG_NOTICE, "%d:Signaling link status changed to %s\n", spri->span->span_id, ftdm_signaling_status2str(status));
for(i=1; i <= spri->span->chan_count; i++) {
ftdmchan = spri->span->channels[i];
memset(&sig, 0, sizeof(sig));
sig.chan_id = ftdmchan->chan_id;
sig.span_id = ftdmchan->span_id;
sig.channel = ftdmchan;
sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
sig.raw_data = &status;
ftdm_span_send_signal(spri->span, &sig);
}
}
return 0;
}
@ -955,13 +1006,28 @@ static int on_dchan_up(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_ev
* \return 0
*/
static int on_dchan_down(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent)
{
{
if (ftdm_test_flag(spri, LPWRAP_PRI_READY)) {
ftdm_signaling_status_t status = FTDM_SIG_STATE_DOWN;
ftdm_channel_t *ftdmchan = NULL;
ftdm_sigmsg_t sig;
int i;
ftdm_log(FTDM_LOG_INFO, "Span %d D-Chan DOWN!\n", spri->span->span_id);
ftdm_clear_flag(spri, LPWRAP_PRI_READY);
ftdm_set_state_all(spri->span, FTDM_CHANNEL_STATE_RESTART);
ftdm_log(FTDM_LOG_NOTICE, "%d:Signaling link status changed to %s\n", spri->span->span_id, ftdm_signaling_status2str(status));
for(i=1; i <= spri->span->chan_count; i++) {
ftdmchan = spri->span->channels[i];
memset(&sig, 0, sizeof(sig));
sig.chan_id = ftdmchan->chan_id;
sig.span_id = ftdmchan->span_id;
sig.channel = ftdmchan;
sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
sig.raw_data = &status;
ftdm_span_send_signal(spri->span, &sig);
}
}
return 0;
@ -1329,6 +1395,9 @@ static FIO_SIG_CONFIGURE_FUNCTION(ftdm_libpri_configure_span)
span->signal_type = FTDM_SIGTYPE_ISDN;
span->outgoing_call = isdn_outgoing_call;
span->get_channel_sig_status = isdn_get_channel_sig_status;
span->get_span_sig_status = isdn_get_span_sig_status;
if ((isdn_data->opts & FTMOD_LIBPRI_OPT_SUGGEST_CHANNEL)) {
span->channel_request = isdn_channel_request;
ftdm_set_flag(span, FTDM_SPAN_SUGGEST_CHAN_ID);

2
libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.c
View File

@ -182,7 +182,7 @@ int lpwrap_init_pri(struct lpwrap_pri *spri, ftdm_span_t *span, ftdm_channel_t *
size_t buflen = sizeof(buf), len = 0;
pri_set_debug(spri->pri, debug);
ret = 0;
ftdm_set_flag(spri, LPWRAP_PRI_READY);
ftdm_channel_write(spri->dchan, buf, buflen, &len);
} else {
fprintf(stderr, "Unable to create PRI\n");

17
libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c
View File

@ -2122,6 +2122,7 @@ static FIO_SIG_UNLOAD_FUNCTION(ftdm_sangoma_boost_destroy)
static ftdm_status_t ftdm_sangoma_boost_start(ftdm_span_t *span)
{
int err;
ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data;
ftdm_set_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING);
err=ftdm_thread_create_detached(ftdm_sangoma_boost_run, span);
@ -2140,23 +2141,23 @@ static ftdm_status_t ftdm_sangoma_boost_start(ftdm_span_t *span)
static ftdm_status_t ftdm_sangoma_boost_stop(ftdm_span_t *span)
{
int cnt = 10;
ftdm_status_t status = FTDM_SUCCESS;
ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data;
if (sangoma_boost_data->sigmod) {
/* FIXME: we should make sure the span thread is stopped (use pthread_kill or freetdm thread kill function) */
/* I think stopping the span before destroying the queue makes sense
otherwise may be boost events would still arrive when the queue is already destroyed! */
status = sangoma_boost_data->sigmod->stop_span(span);
ftdm_queue_enqueue(sangoma_boost_data->boost_queue, NULL);
}
while (ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING)) {
ftdm_log(FTDM_LOG_DEBUG, "Waiting for boost thread\n");
ftdm_sleep(100);
}
if (sangoma_boost_data->sigmod) {
while(ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING) && cnt-- > 0) {
ftdm_log(FTDM_LOG_DEBUG, "Waiting for boost thread\n");
ftdm_sleep(500);
}
ftdm_queue_destroy(&sangoma_boost_data->boost_queue);
return status;
}
return status;
}

15
libs/freetdm/src/include/freetdm.h
View File

@ -198,6 +198,9 @@ extern "C" {
#define FTDM_MAX_CHANNELS_GROUP 1024
#define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE
#define FTDM_MAX_NAME_STR_SZ 80
#define FTDM_MAX_NUMBER_STR_SZ 20
#define GOTO_STATUS(label,st) status = st; goto label ;
#define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1)
@ -611,6 +614,15 @@ struct ftdm_channel {
float txgain;
};
struct ftdm_channel_config {
char name[FTDM_MAX_NAME_STR_SZ];
char number[FTDM_MAX_NUMBER_STR_SZ];
char group_name[FTDM_MAX_NAME_STR_SZ];
ftdm_chan_type_t type;
float rxgain;
float txgain;
};
struct ftdm_sigmsg {
ftdm_signal_event_t event_id;
@ -831,6 +843,9 @@ FT_DECLARE(ftdm_status_t) ftdm_conf_node_create(const char *name, ftdm_conf_node
FT_DECLARE(ftdm_status_t) ftdm_conf_node_add_param(ftdm_conf_node_t *node, const char *param, const char *val);
FT_DECLARE(ftdm_status_t) ftdm_conf_node_destroy(ftdm_conf_node_t *node);
FT_DECLARE(ftdm_status_t) ftdm_configure_span_channels(ftdm_span_t *span, const char *str, ftdm_channel_config_t *chan_config, unsigned *configured);
FIO_CODEC_FUNCTION(fio_slin2ulaw);
FIO_CODEC_FUNCTION(fio_ulaw2slin);
FIO_CODEC_FUNCTION(fio_slin2alaw);

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

@ -416,6 +416,7 @@ typedef enum {
FTDM_CHANNEL_USE_RX_GAIN = (1 << 25),
FTDM_CHANNEL_USE_TX_GAIN = (1 << 26),
FTDM_CHANNEL_IN_ALARM = (1 << 27),
FTDM_CHANNEL_SIG_UP = (1 << 28),
} ftdm_channel_flag_t;
#if defined(__cplusplus) && defined(WIN32)
// fix C2676
@ -467,6 +468,7 @@ typedef struct ftdm_conf_parameter_s {
} ftdm_conf_parameter_t;
typedef struct ftdm_channel ftdm_channel_t;
typedef struct ftdm_channel_config ftdm_channel_config_t;
typedef struct ftdm_event ftdm_event_t;
typedef struct ftdm_sigmsg ftdm_sigmsg_t;
typedef struct ftdm_span ftdm_span_t;

6
src/include/switch_types.h
View File

@ -248,7 +248,8 @@ typedef enum {
SCF_EARLY_HANGUP = (1 << 7),
SCF_CALIBRATE_CLOCK = (1 << 8),
SCF_USE_HEAVY_TIMING = (1 << 9),
SCF_USE_CLOCK_RT = (1 << 10)
SCF_USE_CLOCK_RT = (1 << 10),
SCF_VERBOSE_EVENTS = (1 << 11)
} switch_core_flag_enum_t;
typedef uint32_t switch_core_flag_t;
@ -1494,7 +1495,8 @@ typedef enum {
SCSC_CALIBRATE_CLOCK,
SCSC_SAVE_HISTORY,
SCSC_CRASH,
SCSC_MIN_IDLE_CPU
SCSC_MIN_IDLE_CPU,
SCSC_VERBOSE_EVENTS
} switch_session_ctl_t;
typedef enum {

10
src/mod/applications/mod_commands/mod_commands.c
View File

@ -1500,6 +1500,16 @@ SWITCH_STANDARD_API(ctl_function)
} else if (!strcasecmp(argv[0], "crash")) {
switch_core_session_ctl(SCSC_CRASH, NULL);
stream->write_function(stream, "+OK\n");
} else if (!strcasecmp(argv[0], "verbose_events")) {
arg = -1;
if (argv[1]) {
arg = switch_true(argv[1]);
}
switch_core_session_ctl(SCSC_VERBOSE_EVENTS, &arg);
stream->write_function(stream, "+OK verbose_events is %s \n", arg ? "on" : "off");
} else if (!strcasecmp(argv[0], "save_history")) {
switch_core_session_ctl(SCSC_SAVE_HISTORY, NULL);
stream->write_function(stream, "+OK\n");

27
src/mod/asr_tts/mod_unimrcp/mod_unimrcp.c
View File

@ -263,8 +263,7 @@ static switch_status_t audio_queue_destroy(audio_queue_t *queue);
* SPEECH_CHANNEL : speech functions common to recognizer and synthesizer
*/
/* how long to wait for UniMRCP to process requests */
#define SPEECH_CHANNEL_TIMEOUT_USEC (30 * 1000000)
#define SPEECH_CHANNEL_TIMEOUT_USEC (5 * 1000000)
/**
* Type of MRCP channel
@ -836,7 +835,7 @@ static switch_status_t speech_channel_destroy(speech_channel_t *schannel)
while (schannel->state != SPEECH_CHANNEL_CLOSED) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT && !warned) {
warned = 1;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) MRCP session has not terminated after %d ms\n", schannel->name, SPEECH_CHANNEL_TIMEOUT_USEC / (1000));
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) MRCP session has not terminated after %d ms\n", schannel->name, SPEECH_CHANNEL_TIMEOUT_USEC / (1000));
}
}
}
@ -907,6 +906,7 @@ static switch_status_t speech_channel_open(speech_channel_t *schannel, profile_t
switch_status_t status = SWITCH_STATUS_SUCCESS;
mpf_termination_t *termination = NULL;
mrcp_resource_type_e resource_type;
int warned = 0;
switch_mutex_lock(schannel->mutex);
@ -954,9 +954,11 @@ static switch_status_t speech_channel_open(speech_channel_t *schannel, profile_t
}
/* wait for channel to be ready */
warned = 0;
while (schannel->state == SPEECH_CHANNEL_CLOSED) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT) {
break;
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT && !warned) {
warned = 1;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) MRCP session has not opened after %d ms\n", schannel->name, SPEECH_CHANNEL_TIMEOUT_USEC / (1000));
}
}
if (schannel->state == SPEECH_CHANNEL_READY) {
@ -967,9 +969,11 @@ static switch_status_t speech_channel_open(speech_channel_t *schannel, profile_t
status = SWITCH_STATUS_FALSE;
} else if (schannel->state == SPEECH_CHANNEL_ERROR) {
/* Wait for session to be cleaned up */
warned = 0;
while (schannel->state == SPEECH_CHANNEL_ERROR) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT) {
break;
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT && !warned) {
warned = 1;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) MRCP session has not cleaned up after %d ms\n", schannel->name, SPEECH_CHANNEL_TIMEOUT_USEC / (1000));
}
}
if (schannel->state != SPEECH_CHANNEL_CLOSED) {
@ -1046,9 +1050,10 @@ static switch_status_t synth_channel_speak(speech_channel_t *schannel, const cha
status = SWITCH_STATUS_FALSE;
goto done;
}
/* wait for IN PROGRESS */
/* wait for IN-PROGRESS */
while (schannel->state == SPEECH_CHANNEL_READY) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) Timed out waiting for SPEAK IN-PROGRESS\n", schannel->name);
break;
}
}
@ -1297,7 +1302,7 @@ static switch_status_t speech_channel_stop(speech_channel_t *schannel)
}
if (schannel->state == SPEECH_CHANNEL_PROCESSING) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "(%s) Timed out waiting for session to close. Continuing.\n", schannel->name);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "(%s) Timed out waiting for STOP to COMPLETE. Continuing.\n", schannel->name);
schannel->state = SPEECH_CHANNEL_ERROR;
status = SWITCH_STATUS_FALSE;
goto done;
@ -2134,9 +2139,10 @@ static switch_status_t recog_channel_start(speech_channel_t *schannel, const cha
status = SWITCH_STATUS_FALSE;
goto done;
}
/* wait for IN PROGRESS */
/* wait for IN-PROGRESS */
while (schannel->state == SPEECH_CHANNEL_READY) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) Timed out waiting for RECOGNIZE IN-PROGRESS\n", schannel->name);
break;
}
}
@ -2214,6 +2220,7 @@ static switch_status_t recog_channel_load_grammar(speech_channel_t *schannel, co
}
while (schannel->state == SPEECH_CHANNEL_PROCESSING) {
if (switch_thread_cond_timedwait(schannel->cond, schannel->mutex, SPEECH_CHANNEL_TIMEOUT_USEC) == SWITCH_STATUS_TIMEOUT) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "(%s) Timed out waiting for DEFINE-GRAMMAR to COMPLETE\n", schannel->name);
break;
}
}

8
src/switch_caller.c
View File

@ -271,6 +271,14 @@ SWITCH_DECLARE(void) switch_caller_profile_event_set_data(switch_caller_profile_
switch_snprintf(header_name, sizeof(header_name), "%s-Caller-ID-Number", prefix);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->caller_id_number);
}
if (!zstr(caller_profile->callee_id_name)) {
switch_snprintf(header_name, sizeof(header_name), "%s-Callee-ID-Name", prefix);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->callee_id_name);
}
if (!zstr(caller_profile->callee_id_number)) {
switch_snprintf(header_name, sizeof(header_name), "%s-Callee-ID-Number", prefix);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->callee_id_number);
}
if (!zstr(caller_profile->network_addr)) {
switch_snprintf(header_name, sizeof(header_name), "%s-Network-Addr", prefix);
switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header_name, caller_profile->network_addr);

6
src/switch_channel.c
View File

@ -1677,11 +1677,13 @@ SWITCH_DECLARE(void) switch_channel_event_set_basic_data(switch_channel_t *chann
SWITCH_DECLARE(void) switch_channel_event_set_extended_data(switch_channel_t *channel, switch_event_t *event)
{
switch_event_header_t *hi;
int x;
int x, global_verbos_events = 0;
switch_mutex_lock(channel->profile_mutex);
if (switch_channel_test_flag(channel, CF_VERBOSE_EVENTS) ||
switch_core_session_ctl(SCSC_VERBOSE_EVENTS, &global_verbos_events);
if (global_verbos_events || switch_channel_test_flag(channel, CF_VERBOSE_EVENTS) ||
event->event_id == SWITCH_EVENT_CHANNEL_CREATE ||
event->event_id == SWITCH_EVENT_CHANNEL_ORIGINATE ||
event->event_id == SWITCH_EVENT_CHANNEL_UUID ||

77
src/switch_core.c
View File

@ -1448,6 +1448,13 @@ static void switch_load_core_config(const char *file)
switch_time_set_matrix(switch_true(var));
} else if (!strcasecmp(var, "max-sessions") && !zstr(val)) {
switch_core_session_limit(atoi(val));
} else if (!strcasecmp(var, "verbose-channel-events") && !zstr(val)) {
int v = switch_true(val);
if (v) {
switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
} else {
switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
}
} else if (!strcasecmp(var, "min-idle-cpu") && !zstr(val)) {
switch_core_min_idle_cpu(atof(val));
} else if (!strcasecmp(var, "tipping-point") && !zstr(val)) {
@ -1639,12 +1646,29 @@ SWITCH_DECLARE(uint32_t) switch_core_debug_level(void)
SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *val)
{
int *intval = (int *) val;
int oldintval = 0, newintval = 0;
if (intval) {
oldintval = *intval;
}
if (switch_test_flag((&runtime), SCF_SHUTTING_DOWN)) {
return -1;
}
switch (cmd) {
case SCSC_VERBOSE_EVENTS:
if (intval) {
if (oldintval > -1) {
if (oldintval) {
switch_set_flag((&runtime), SCF_VERBOSE_EVENTS);
} else {
switch_clear_flag((&runtime), SCF_VERBOSE_EVENTS);
}
}
newintval = switch_test_flag((&runtime), SCF_VERBOSE_EVENTS);
}
break;
case SCSC_CALIBRATE_CLOCK:
switch_time_calibrate_clock();
break;
@ -1656,10 +1680,10 @@ SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *
break;
case SCSC_SYNC_CLOCK:
switch_time_sync();
*intval = 0;
newintval = 0;
break;
case SCSC_PAUSE_INBOUND:
if (*intval) {
if (oldintval) {
switch_set_flag((&runtime), SCF_NO_NEW_SESSIONS);
} else {
switch_clear_flag((&runtime), SCF_NO_NEW_SESSIONS);
@ -1710,7 +1734,7 @@ SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *
win_shutdown();
#endif
if (*intval) {
if (oldintval) {
switch_set_flag((&runtime), SCF_RESTART);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
} else {
@ -1732,7 +1756,7 @@ SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *
win_shutdown();
#endif
if (*intval) {
if (oldintval) {
switch_set_flag((&runtime), SCF_RESTART);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Restarting\n");
} else {
@ -1744,62 +1768,69 @@ SWITCH_DECLARE(int32_t) switch_core_session_ctl(switch_session_ctl_t cmd, void *
runtime.running = 0;
break;
case SCSC_CHECK_RUNNING:
*intval = runtime.running;
newintval = runtime.running;
break;
case SCSC_LOGLEVEL:
if (*intval > -1) {
runtime.hard_log_level = *intval;
if (oldintval > -1) {
runtime.hard_log_level = oldintval;
}
if (runtime.hard_log_level > SWITCH_LOG_DEBUG) {
runtime.hard_log_level = SWITCH_LOG_DEBUG;
}
*intval = runtime.hard_log_level;
newintval = runtime.hard_log_level;
break;
case SCSC_DEBUG_LEVEL:
if (*intval > -1) {
if (*intval > 10)
*intval = 10;
runtime.debug_level = *intval;
if (oldintval > -1) {
if (oldintval > 10)
newintval = 10;
runtime.debug_level = oldintval;
}
*intval = runtime.debug_level;
newintval = runtime.debug_level;
break;
case SCSC_MIN_IDLE_CPU:
{
double *dval = (double *) val;
*dval = switch_core_min_idle_cpu(*dval);
if (dval) {
*dval = switch_core_min_idle_cpu(*dval);
}
intval = NULL;
}
break;
case SCSC_MAX_SESSIONS:
*intval = switch_core_session_limit(*intval);
newintval = switch_core_session_limit(oldintval);
break;
case SCSC_LAST_SPS:
*intval = runtime.sps_last;
newintval = runtime.sps_last;
break;
case SCSC_MAX_DTMF_DURATION:
*intval = switch_core_max_dtmf_duration(*intval);
newintval = switch_core_max_dtmf_duration(oldintval);
break;
case SCSC_MIN_DTMF_DURATION:
*intval = switch_core_min_dtmf_duration(*intval);
newintval = switch_core_min_dtmf_duration(oldintval);
break;
case SCSC_DEFAULT_DTMF_DURATION:
*intval = switch_core_default_dtmf_duration(*intval);
newintval = switch_core_default_dtmf_duration(oldintval);
break;
case SCSC_SPS:
switch_mutex_lock(runtime.throttle_mutex);
if (*intval > 0) {
runtime.sps_total = *intval;
if (oldintval > 0) {
runtime.sps_total = oldintval;
}
*intval = runtime.sps_total;
newintval = runtime.sps_total;
switch_mutex_unlock(runtime.throttle_mutex);
break;
case SCSC_RECLAIM:
switch_core_memory_reclaim_all();
*intval = 0;
newintval = 0;
break;
}
if (intval) {
*intval = newintval;
}
return 0;
}