static ftdm_status_t handle_set_function_trace(ftdm_stream_handle_t *stream, int on, int level);
static ftdm_status_t handle_set_message_trace(ftdm_stream_handle_t *stream, int on, int level);
-static ftdm_status_t handle_set_blocks(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
-static ftdm_status_t handle_set_unblks(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
static ftdm_status_t handle_set_inhibit(ftdm_stream_handle_t *stream, char *name);
static ftdm_status_t handle_set_uninhibit(ftdm_stream_handle_t *stream, char *name);
static ftdm_status_t handle_tx_rsc(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
static ftdm_status_t handle_tx_grs(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
+static ftdm_status_t handle_tx_blo(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
+static ftdm_status_t handle_tx_ubl(ftdm_stream_handle_t *stream, int span, int chan, int verbose);
+
+static ftdm_status_t handle_tx_cgb(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
+static ftdm_status_t handle_tx_cgu(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose);
+
+
static ftdm_status_t handle_status_link(ftdm_stream_handle_t *stream, char *name);
static ftdm_status_t handle_status_linkset(ftdm_stream_handle_t *stream, char *name);
/**********************************************************************/
}
/**************************************************************************/
- } else if (!strcasecmp(argv[c], "block")) {
+ } else if (!strcasecmp(argv[c], "inhibit")) {
+ /**************************************************************************/
+ if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+ c++;
+
+ if (!strcasecmp(argv[c], "link")) {
+ /**********************************************************************/
+ if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
+ c++;
+
+ handle_set_inhibit(stream, argv[c]);
+ /**********************************************************************/
+ } else {
+ /**********************************************************************/
+ stream->write_function(stream, "Unknown \"block\" command\n");
+ goto handle_cli_error;
+ /**********************************************************************/
+ }
+ /**************************************************************************/
+ } else if (!strcasecmp(argv[c], "uninhibit")) {
+ /**************************************************************************/
+ if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+ c++;
+
+ if (!strcasecmp(argv[c], "link")) {
+ /**********************************************************************/
+ if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
+ c++;
+
+ handle_set_uninhibit(stream, argv[c]);
+ /**********************************************************************/
+ } else {
+ /**********************************************************************/
+ stream->write_function(stream, "Unknown \"unblock\" command\n");
+ goto handle_cli_error;
+ /**********************************************************************/
+ }
+ /**************************************************************************/
+ } else if (!strcasecmp(argv[c], "blo")) {
/**************************************************************************/
if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
c++;
if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
- handle_set_blocks(stream, span, chan, verbose);
+ handle_tx_blo(stream, span, chan, verbose);
/**********************************************************************/
- } else if (!strcasecmp(argv[c], "link")) {
+ } else {
/**********************************************************************/
- if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
- c++;
-
- handle_set_inhibit(stream, argv[c]);
+ stream->write_function(stream, "Unknown \"block\" command\n");
+ goto handle_cli_error;
+ /**********************************************************************/
+ }
+ /**************************************************************************/
+ } else if (!strcasecmp(argv[c], "ubl")) {
+ /**************************************************************************/
+ if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+ c++;
+
+ if (!strcasecmp(argv[c], "span")) {
+ /**********************************************************************/
+ if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
+
+ if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+
+ handle_tx_ubl(stream, span, chan, verbose);
/**********************************************************************/
} else {
/**********************************************************************/
- stream->write_function(stream, "Unknown \"block\" command\n");
+ stream->write_function(stream, "Unknown \"ubl\" command\n");
goto handle_cli_error;
/**********************************************************************/
- }
+ }
/**************************************************************************/
- } else if (!strcasecmp(argv[c], "unblock")) {
+ } else if (!strcasecmp(argv[c], "cgb")) {
/**************************************************************************/
if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
c++;
if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+ c = c + 4;
- handle_set_unblks(stream, span, chan, verbose);
+ if (check_arg_count(argc, 7)) goto handle_cli_error_argc;
+
+ if (!strcasecmp(argv[c], "range")) {
+ /******************************************************************/
+ c++;
+ range = atoi(argv[c]);
+ /******************************************************************/
+ } else {
+ /******************************************************************/
+ stream->write_function(stream, "Unknown \"cgb range\" command\n");
+ goto handle_cli_error;
+ /******************************************************************/
+ }
+
+ handle_tx_cgb(stream, span, chan, range, verbose);
/**********************************************************************/
- } else if (!strcasecmp(argv[c], "link")) {
+ } else {
/**********************************************************************/
- if (check_arg_count(argc, 3)) goto handle_cli_error_argc;
- c++;
-
- handle_set_uninhibit(stream, argv[c]);
+ stream->write_function(stream, "Unknown \"cgb\" command\n");
+ goto handle_cli_error;
+ /**********************************************************************/
+ }
+ /**************************************************************************/
+ } else if (!strcasecmp(argv[c], "cgu")) {
+ /**************************************************************************/
+ if (check_arg_count(argc, 2)) goto handle_cli_error_argc;
+ c++;
+
+ if (!strcasecmp(argv[c], "span")) {
+ /**********************************************************************/
+ if (check_arg_count(argc, 5)) goto handle_cli_error_argc;
+
+ if (extract_span_chan(argv, c, &span, &chan)) goto handle_cli_error_span_chan;
+ c = c + 4;
+
+ if (check_arg_count(argc, 7)) goto handle_cli_error_argc;
+
+ if (!strcasecmp(argv[c], "range")) {
+ /******************************************************************/
+ c++;
+ range = atoi(argv[c]);
+ /******************************************************************/
+ } else {
+ /******************************************************************/
+ stream->write_function(stream, "Unknown \"cgu range\" command\n");
+ goto handle_cli_error;
+ /******************************************************************/
+ }
+
+ handle_tx_cgu(stream, span, chan, range, verbose);
/**********************************************************************/
} else {
/**********************************************************************/
- stream->write_function(stream, "Unknown \"unblock\" command\n");
+ stream->write_function(stream, "Unknown \"cgu\" command\n");
goto handle_cli_error;
/**********************************************************************/
}
stream->write_function(stream, "ftdm ss7 show inreset span X chan Y\n");
stream->write_function(stream, "\n");
stream->write_function(stream, "Ftmod_sangoma_ss7 circuit control:\n");
- stream->write_function(stream, "ftdm ss7 block span X chan Y\n");
- stream->write_function(stream, "ftdm ss7 unblk span X chan Y\n");
+ stream->write_function(stream, "ftdm ss7 blo span X chan Y\n");
+ stream->write_function(stream, "ftdm ss7 ubl span X chan Y\n");
stream->write_function(stream, "ftdm ss7 rsc span X chan Y\n");
stream->write_function(stream, "ftdm ss7 grs span X chan Y range Z\n");
+ stream->write_function(stream, "\n");
+ stream->write_function(stream, "Ftmod_sangoma_ss7 link control:\n");
+ stream->write_function(stream, "ftdm ss7 inhibit link X\n");
+ stream->write_function(stream, "ftdm ss7 uninhibit link X\n");
+
stream->write_function(stream, "\n");
return FTDM_SUCCESS;
return FTDM_SUCCESS;
}
/******************************************************************************/
-static ftdm_status_t handle_set_blocks(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
+static ftdm_status_t handle_tx_blo(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
{
int x;
sngss7_chan_data_t *ss7_info;
}
/******************************************************************************/
-static ftdm_status_t handle_set_unblks(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
+static ftdm_status_t handle_tx_ubl(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
{
int x;
sngss7_chan_data_t *ss7_info;
/******************************************************************************/
static ftdm_status_t handle_tx_rsc(ftdm_stream_handle_t *stream, int span, int chan, int verbose)
{
- int x;
- sngss7_chan_data_t *ss7_info;
- ftdm_channel_t *ftdmchan;
- int lspan;
- int lchan;
+ int x;
+ sngss7_chan_data_t *sngss7_info;
+ ftdm_channel_t *ftdmchan;
+ int lspan;
+ int lchan;
x=1;
while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
- ss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
- ftdmchan = ss7_info->ftdmchan;
+ sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+ ftdmchan = sngss7_info->ftdmchan;
/* if span == 0 then all spans should be printed */
if (span == 0) {
}
if ((ftdmchan->physical_span_id == lspan) && (ftdmchan->physical_chan_id == lchan)) {
- /* now that we have the right channel...put a lock on it so no-one else can use it */
+ /* lock the channel */
ftdm_mutex_lock(ftdmchan->mutex);
- /* check if there is a pending state change|give it a bit to clear */
- if (check_for_state_change(ftdmchan)) {
- SS7_ERROR("Failed to wait for pending state change on CIC = %d\n", ss7_info->circuit->cic);
- SS7_ASSERT;
- } else {
- /* throw the ckt block flag */
- sngss7_set_flag(ss7_info, FLAG_RESET_TX);
+ /* throw the reset flag */
+ sngss7_set_flag(sngss7_info, FLAG_RESET_TX);
- /* set the channel to suspended state */
+ switch (ftdmchan->state) {
+ /**************************************************************************/
+ case FTDM_CHANNEL_STATE_RESTART:
+ /* go to idle so that we can redo the restart state*/
+ ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
+ break;
+ /**************************************************************************/
+ default:
+ /* set the state of the channel to restart...the rest is done by the chan monitor */
ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
+ break;
+ /**************************************************************************/
}
-
+
/* unlock the channel again before we exit */
ftdm_mutex_unlock(ftdmchan->mutex);
-
} /* if ( span and chan) */
- } /* if ( cic != 0) */
+ } /* if ( cic == voice) */
/* go the next circuit */
x++;
return FTDM_SUCCESS;
}
+/******************************************************************************/
+static ftdm_status_t handle_tx_cgb(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose)
+{
+ int x;
+ sngss7_chan_data_t *sngss7_info;
+ ftdm_channel_t *ftdmchan;
+ ftdm_channel_t *main_chan = NULL;
+ sngss7_span_data_t *sngss7_span;
+ int byte = 0;
+ int bit = 0;
+
+ if (range > 31) {
+ stream->write_function(stream, "Invalid range value %d", range);
+ return FTDM_SUCCESS;
+ }
+
+ x=1;
+ while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
+ if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
+
+ /* extract the channel and span info for this circuit */
+ sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+ ftdmchan = sngss7_info->ftdmchan;
+ sngss7_span = ftdmchan->span->mod_data;
+
+ /* check if this circuit is part of the block */
+ if ((ftdmchan->physical_span_id == span) &&
+ ((ftdmchan->physical_chan_id >= chan) && (ftdmchan->physical_chan_id < (chan+range)))) {
+
+ /* now that we have the right channel...put a lock on it so no-one else can use it */
+ ftdm_mutex_lock(ftdmchan->mutex);
+
+ /* throw the grp maint. block flag */
+ sngss7_set_flag(sngss7_info, FLAG_GRP_MN_BLOCK_TX);
+
+ /* if this is the first channel in the range */
+ if (ftdmchan->physical_chan_id == chan) {
+ /* attach the cgb information */
+ main_chan = ftdmchan;
+ sngss7_span->tx_cgb.circuit = sngss7_info->circuit->id;
+ sngss7_span->tx_cgb.range = range-1;
+ sngss7_span->tx_cgb.type = 0; /* maintenace block */
+ } /* if (ftdmchan->physical_chan_id == chan) */
+
+ /* update the status field */
+ sngss7_span->tx_cgb.status[byte] = (sngss7_span->tx_cgb.status[byte] | (1 << bit));
+
+ /* update the bit and byte counter*/
+ bit ++;
+ if (bit == 8) {
+ byte++;
+ bit = 0;
+ }
+
+ /* unlock the channel again before we exit */
+ ftdm_mutex_unlock(ftdmchan->mutex);
+ } /* if ( span and chan) */
+ } /* if ( cic == voice) */
+ /* go the next circuit */
+ x++;
+ } /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
+
+ /* send the circuit group block */
+ ft_to_sngss7_cgb(main_chan);
+
+
+ return FTDM_SUCCESS;
+}
+
+/******************************************************************************/
+static ftdm_status_t handle_tx_cgu(ftdm_stream_handle_t *stream, int span, int chan, int range, int verbose)
+{
+ int x;
+ sngss7_chan_data_t *sngss7_info;
+ ftdm_channel_t *ftdmchan;
+ ftdm_channel_t *main_chan = NULL;
+ sngss7_span_data_t *sngss7_span;
+ int byte = 0;
+ int bit = 0;
+
+ if (range > 31) {
+ stream->write_function(stream, "Invalid range value %d", range);
+ return FTDM_SUCCESS;
+ }
+
+ x=1;
+ while (g_ftdm_sngss7_data.cfg.isupCkt[x].id != 0) {
+ if (g_ftdm_sngss7_data.cfg.isupCkt[x].type == VOICE) {
+
+ /* extract the channel and span info for this circuit */
+ sngss7_info = (sngss7_chan_data_t *)g_ftdm_sngss7_data.cfg.isupCkt[x].obj;
+ ftdmchan = sngss7_info->ftdmchan;
+ sngss7_span = ftdmchan->span->mod_data;
+
+ /* check if this circuit is part of the block */
+ if ((ftdmchan->physical_span_id == span) &&
+ ((ftdmchan->physical_chan_id >= chan) && (ftdmchan->physical_chan_id < (chan+range)))) {
+
+ /* now that we have the right channel...put a lock on it so no-one else can use it */
+ ftdm_mutex_lock(ftdmchan->mutex);
+
+ /* throw the grp maint. block flag */
+ sngss7_clear_flag(sngss7_info, FLAG_GRP_MN_BLOCK_TX);
+
+ /* if this is the first channel in the range */
+ if (ftdmchan->physical_chan_id == chan) {
+ /* attach the cgb information */
+ main_chan = ftdmchan;
+ sngss7_span->tx_cgu.circuit = sngss7_info->circuit->id;
+ sngss7_span->tx_cgu.range = range-1;
+ sngss7_span->tx_cgu.type = 0; /* maintenace block */
+ } /* if (ftdmchan->physical_chan_id == chan) */
+
+ /* update the status field */
+ sngss7_span->tx_cgu.status[byte] = (sngss7_span->tx_cgu.status[byte] | (1 << bit));
+
+ /* update the bit and byte counter*/
+ bit ++;
+ if (bit == 8) {
+ byte++;
+ bit = 0;
+ }
+
+ /* unlock the channel again before we exit */
+ ftdm_mutex_unlock(ftdmchan->mutex);
+ } /* if ( span and chan) */
+ } /* if ( cic == voice) */
+ /* go the next circuit */
+ x++;
+ } /* while (g_ftdm_sngss7_data.cfg.isupCkt[x]id != 0) */
+
+ /* send the circuit group block */
+ ft_to_sngss7_cgu(main_chan);
+
+
+ return FTDM_SUCCESS;
+}
+
/******************************************************************************/
static ftdm_status_t extract_span_chan(char *argv[10], int pos, int *span, int *chan)
{
void ft_to_sngss7_gra(ftdm_channel_t * ftdmchan);
void ft_to_sngss7_grs(ftdm_channel_t * ftdmchan);
+void ft_to_sngss7_cgb(ftdm_channel_t * ftdmchan);
+void ft_to_sngss7_cgu(ftdm_channel_t * ftdmchan);
+
void ft_to_sngss7_cgba(ftdm_channel_t * ftdmchan);
void ft_to_sngss7_cgua(ftdm_channel_t * ftdmchan);
/******************************************************************************/
(g_ftdm_sngss7_data.cfg.isupIntf[sngss7_info->circuit->infId].switchType == LSI_SW_ANS92) ||
(g_ftdm_sngss7_data.cfg.isupIntf[sngss7_info->circuit->infId].switchType == LSI_SW_ANS95)) {
+ /* include only if we're running ANSI */
+ iam.fwdCallInd.transCallNInd.pres = PRSNT_NODEF;
+ iam.fwdCallInd.transCallNInd.val = 0x0;
+
iam.usrServInfoA.eh.pres = PRSNT_NODEF;
iam.usrServInfoA.infoTranCap.pres = PRSNT_NODEF;
SS7_FUNC_TRACE_EXIT (__FUNCTION__);
return;
}
+
+/******************************************************************************/
+void ft_to_sngss7_cgb(ftdm_channel_t * ftdmchan)
+{
+ SS7_FUNC_TRACE_ENTER (__FUNCTION__);
+
+ sngss7_span_data_t *sngss7_span = ftdmchan->span->mod_data;
+ sngss7_chan_data_t *sngss7_info = ftdmchan->call_data;
+ SiStaEvnt cgb;
+ int x = 0;
+
+
+ memset (&cgb, 0x0, sizeof(cgb));
+
+ /* fill in the circuit group supervisory message */
+ cgb.cgsmti.eh.pres = PRSNT_NODEF;
+ cgb.cgsmti.typeInd.pres = PRSNT_NODEF;
+ cgb.cgsmti.typeInd.val = sngss7_span->tx_cgb.type;
+
+ /* fill in the range */
+ cgb.rangStat.eh.pres = PRSNT_NODEF;
+ cgb.rangStat.range.pres = PRSNT_NODEF;
+ cgb.rangStat.range.val = sngss7_span->tx_cgb.range;
+
+ /* fill in the status */
+ cgb.rangStat.status.pres = PRSNT_NODEF;
+ cgb.rangStat.status.len = ((sngss7_span->tx_cgb.range + 1) >> 3) + (((sngss7_span->tx_cgb.range + 1) & 0x07) ? 1 : 0);
+ for(x = 0; x < cgb.rangStat.status.len; x++){
+ cgb.rangStat.status.val[x] = sngss7_span->tx_cgb.status[x];
+ }
+
+ sng_cc_sta_request (1,
+ 0,
+ 0,
+ sngss7_span->tx_cgb.circuit,
+ 0,
+ SIT_STA_CGBREQ,
+ &cgb);
+
+ SS7_INFO_CHAN(ftdmchan, "Tx CGB (%d:%d)\n",
+ sngss7_info->circuit->cic,
+ (sngss7_info->circuit->cic + sngss7_span->tx_cgb.range));
+
+ /* clean out the saved data */
+ memset(&sngss7_span->tx_cgb, 0x0, sizeof(sngss7_group_data_t));
+
+ SS7_FUNC_TRACE_EXIT (__FUNCTION__);
+ return;
+}
+
+/******************************************************************************/
+void ft_to_sngss7_cgu(ftdm_channel_t * ftdmchan)
+{
+ SS7_FUNC_TRACE_ENTER (__FUNCTION__);
+
+ sngss7_span_data_t *sngss7_span = ftdmchan->span->mod_data;
+ sngss7_chan_data_t *sngss7_info = ftdmchan->call_data;
+ SiStaEvnt cgu;
+ int x = 0;
+
+
+ memset (&cgu, 0x0, sizeof(cgu));
+
+ /* fill in the circuit group supervisory message */
+ cgu.cgsmti.eh.pres = PRSNT_NODEF;
+ cgu.cgsmti.typeInd.pres = PRSNT_NODEF;
+ cgu.cgsmti.typeInd.val = sngss7_span->tx_cgu.type;
+
+ /* fill in the range */
+ cgu.rangStat.eh.pres = PRSNT_NODEF;
+ cgu.rangStat.range.pres = PRSNT_NODEF;
+ cgu.rangStat.range.val = sngss7_span->tx_cgu.range;
+
+ /* fill in the status */
+ cgu.rangStat.status.pres = PRSNT_NODEF;
+ cgu.rangStat.status.len = ((sngss7_span->tx_cgu.range + 1) >> 3) + (((sngss7_span->tx_cgu.range + 1) & 0x07) ? 1 : 0);
+ for(x = 0; x < cgu.rangStat.status.len; x++){
+ cgu.rangStat.status.val[x] = sngss7_span->tx_cgu.status[x];
+ }
+
+ sng_cc_sta_request (1,
+ 0,
+ 0,
+ sngss7_span->tx_cgu.circuit,
+ 0,
+ SIT_STA_CGUREQ,
+ &cgu);
+
+ SS7_INFO_CHAN(ftdmchan, "Tx CGU (%d:%d)\n",
+ sngss7_info->circuit->cic,
+ (sngss7_info->circuit->cic + sngss7_span->tx_cgu.range));
+
+ /* clean out the saved data */
+ memset(&sngss7_span->tx_cgu, 0x0, sizeof(sngss7_group_data_t));
+
+ SS7_FUNC_TRACE_EXIT (__FUNCTION__);
+ return;
+}
+
+
/******************************************************************************/
/* For Emacs:
* Local Variables:
projects / thirdparty / freeswitch.git / commitdiff
