Merge branch 'master' of git@git.sangoma.com:smg_freeswitch

libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c

@@ -1325,7 +1325,7 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
 				}
 				Q931ReleaseCRV(&isdn_data->q931, gen->CRV);
 			}
-			ftdm_channel_done(ftdmchan);
+			ftdm_channel_close(&ftdmchan);
 		}
 		break;
 	case FTDM_CHANNEL_STATE_PROGRESS:

libs/freetdm/src/ftmod/ftmod_pritap/ftmod_pritap.c

@@ -280,12 +280,12 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
 
 	switch (ftdmchan->state) {
 	case FTDM_CHANNEL_STATE_DOWN:
-		{
-			ftdm_channel_done(ftdmchan);			
+		{			
 			ftdmchan->call_data = NULL;
+			ftdm_channel_close(&ftdmchan);
 
-			ftdm_channel_done(peerchan);
 			peerchan->call_data = NULL;
+			ftdm_channel_close(&peerchan);
 		}
 		break;
 

libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c

@@ -255,7 +255,7 @@ static void ftdm_r2_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling
 	sig.span_id = ftdmchan->span_id;
 	sig.channel = ftdmchan;
 	sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-	sig.sigstatus = status;
+	sig.ev_data.sigstatus.status = status;
 	if (ftdm_span_send_signal(ftdmchan->span, &sig) != FTDM_SUCCESS) {
 		ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "Failed to change channel status to %s\n", ftdm_signaling_status2str(status));
 	}

libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c

@@ -839,7 +839,7 @@ static void handle_call_released(ftdm_span_t *span, sangomabc_connection_t *mcon
 	if ((ftdmchan = find_ftdmchan(span, event, 1))) {
 		ftdm_log(FTDM_LOG_DEBUG, "Releasing completely chan s%dc%d\n", BOOST_EVENT_SPAN(mcon->sigmod, event), 
 				BOOST_EVENT_CHAN(mcon->sigmod, event));
-		ftdm_channel_done(ftdmchan);
+		ftdm_channel_close(&ftdmchan);
 	} else {
 		ftdm_log(FTDM_LOG_CRIT, "Odd, We could not find chan: s%dc%d to release the call completely!!\n", 
 				BOOST_EVENT_SPAN(mcon->sigmod, event), BOOST_EVENT_CHAN(mcon->sigmod, event));
@@ -1105,8 +1105,9 @@ static void handle_call_loop_start(ftdm_span_t *span, sangomabc_connection_t *mc
 
 	ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_IN_LOOP, res);
 	if (res != FTDM_SUCCESS) {
+		ftdm_channel_t *toclose = ftdmchan;
 		ftdm_log(FTDM_LOG_CRIT, "yay, could not set the state of the channel to IN_LOOP, loop will fail\n");
-		ftdm_channel_done(ftdmchan);
+		ftdm_channel_close(&toclose);
 		return;
 	}
 	ftdm_log(FTDM_LOG_DEBUG, "%d:%d starting loop\n", ftdmchan->span_id, ftdmchan->chan_id);
@@ -1426,11 +1427,12 @@ static __inline__ ftdm_status_t state_advance(ftdm_channel_t *ftdmchan)
 			ftdmchan->sflags = 0;
 			memset(ftdmchan->call_data, 0, sizeof(sangoma_boost_call_t));
 			if (sangoma_boost_data->sigmod && call_stopped_ack_sent) {
-				/* we dont want to call ftdm_channel_done just yet until call released is received */
+				/* we dont want to call ftdm_channel_close just yet until call released is received */
 				ftdm_log(FTDM_LOG_DEBUG, "Waiting for call release confirmation before declaring chan %d:%d as available \n", 
 						ftdmchan->span_id, ftdmchan->chan_id);
 			} else {
-				ftdm_channel_done(ftdmchan);
+				ftdm_channel_t *toclose = ftdmchan;
+				ftdm_channel_close(&toclose);
 			}
 		}
 		break;

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.c

@@ -65,7 +65,13 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 		ZSD_INBOUND,
 		ZSM_UNACCEPTABLE,
 		{FTDM_ANY_STATE, FTDM_END},
-		{FTDM_CHANNEL_STATE_RESTART, FTDM_CHANNEL_STATE_SUSPENDED, FTDM_END}
+		{FTDM_CHANNEL_STATE_RESET, FTDM_CHANNEL_STATE_RESTART, FTDM_END}
+	},
+	{
+		ZSD_INBOUND,
+		ZSM_UNACCEPTABLE,
+		{FTDM_CHANNEL_STATE_RESET, FTDM_END},
+		{FTDM_CHANNEL_STATE_DOWN, FTDM_END}
 	},
 	{
 		ZSD_INBOUND,
@@ -170,7 +176,13 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 		ZSD_OUTBOUND,
 		ZSM_UNACCEPTABLE,
 		{FTDM_ANY_STATE, FTDM_END},
-		{FTDM_CHANNEL_STATE_RESTART, FTDM_CHANNEL_STATE_SUSPENDED, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}
+		{FTDM_CHANNEL_STATE_RESET, FTDM_CHANNEL_STATE_RESTART, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}
+	},
+	{
+		ZSD_OUTBOUND,
+		ZSM_UNACCEPTABLE,
+		{FTDM_CHANNEL_STATE_RESET, FTDM_END},
+		{FTDM_CHANNEL_STATE_DOWN, FTDM_END}
 	},
 	{
 		ZSD_OUTBOUND,
@@ -203,7 +215,7 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 		ZSM_UNACCEPTABLE,
 		{FTDM_CHANNEL_STATE_DIALING, FTDM_END},
 		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP,
-		 FTDM_CHANNEL_STATE_PROCEED, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP,
+		 FTDM_CHANNEL_STATE_PROCEED, FTDM_CHANNEL_STATE_RINGING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP,
 		 FTDM_CHANNEL_STATE_DOWN, FTDM_END}
 	},
 	{
@@ -211,14 +223,20 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 		ZSM_UNACCEPTABLE,
 		{FTDM_CHANNEL_STATE_PROCEED, FTDM_END},
 		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP,
-		 FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END},
-		},
+		 FTDM_CHANNEL_STATE_RINGING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END},
+	},
 	{
 		ZSD_OUTBOUND,
 		ZSM_UNACCEPTABLE,
 		{FTDM_CHANNEL_STATE_PROGRESS, FTDM_END},
 		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END},
 	},
+	{
+		ZSD_OUTBOUND,
+		ZSM_UNACCEPTABLE,
+		{FTDM_CHANNEL_STATE_RINGING, FTDM_END},
+		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END},
+	},
 	{
 		ZSD_OUTBOUND,
 		ZSM_UNACCEPTABLE,
@@ -680,8 +698,17 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 		break;
 	case FTDM_CHANNEL_STATE_RINGING:
 		{
-			ftdm_sngisdn_progind_t prog_ind = {SNGISDN_PROGIND_LOC_USER, SNGISDN_PROGIND_DESCR_NETE_ISDN};
-			sngisdn_snd_alert(ftdmchan, prog_ind);
+			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
+				/* OUTBOUND...so we were told by the line of this so notify the user */
+				sigev.event_id = FTDM_SIGEVENT_RINGING;
+				ftdm_span_send_signal(ftdmchan->span, &sigev);
+				if (sngisdn_test_flag(sngisdn_info, FLAG_MEDIA_READY)) {
+					ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
+				}
+			} else {
+				ftdm_sngisdn_progind_t prog_ind = {SNGISDN_PROGIND_LOC_USER, SNGISDN_PROGIND_DESCR_NETE_ISDN};
+				sngisdn_snd_alert(ftdmchan, prog_ind);
+			}
 		}
 		break;
 	case FTDM_CHANNEL_STATE_PROGRESS:
@@ -692,12 +719,9 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 				sigev.event_id = FTDM_SIGEVENT_PROGRESS;
 				ftdm_span_send_signal(ftdmchan->span, &sigev);
 			} else {
-				/* If we already sent a PROCEED before, do not send a PROGRESS as there is nothing to indicate to the remote switch */
-				if (ftdmchan->last_state != FTDM_CHANNEL_STATE_PROCEED) {
-					/* Send a progress message, indicating: Call is not end-to-end ISDN, further call progress may be available */
-					ftdm_sngisdn_progind_t prog_ind = {SNGISDN_PROGIND_LOC_USER, SNGISDN_PROGIND_DESCR_NETE_ISDN};
-					sngisdn_snd_progress(ftdmchan, prog_ind);
-				}
+				/* Send a progress message, indicating: Call is not end-to-end ISDN, further call progress may be available */
+				ftdm_sngisdn_progind_t prog_ind = {SNGISDN_PROGIND_LOC_USER, SNGISDN_PROGIND_DESCR_NETE_ISDN};
+				sngisdn_snd_progress(ftdmchan, prog_ind);				
 			}
 		}
 		break;
@@ -780,7 +804,7 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 					sngisdn_snd_release(ftdmchan, 0);
 
 					if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SIG_UP)) {
-						sngisdn_set_avail_rate(ftdmchan->span, SNGISDN_AVAIL_DOWN);
+						sngisdn_set_span_avail_rate(ftdmchan->span, SNGISDN_AVAIL_DOWN);
 					}
 				} else {
 					sngisdn_snd_disconnect(ftdmchan);
@@ -838,6 +862,11 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 			/* IMPLEMENT ME */
 		}
 		break;
+	case FTDM_CHANNEL_STATE_RESET:
+		{
+			sngisdn_snd_restart(ftdmchan);
+		}
+		break;
 	default:
 		{
 			ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "unsupported sngisdn_rcvd state %s\n", ftdm_channel_state2str(ftdmchan->state));
@@ -862,10 +891,6 @@ static FIO_CHANNEL_SEND_MSG_FUNCTION(ftdm_sangoma_isdn_send_msg)
 	ftdm_status_t status = FTDM_FAIL;
 
 	switch (sigmsg->event_id) {
-		case FTDM_SIGEVENT_RESTART:
-			/* TODO: Send a channel restart here */
-			/* Implement me */
-			break;
 		case FTDM_SIGEVENT_FACILITY:
 			sngisdn_snd_fac_req(ftdmchan);
 			break;
@@ -951,7 +976,8 @@ static FIO_SPAN_SET_SIG_STATUS_FUNCTION(ftdm_sangoma_isdn_set_span_sig_status)
 }
 
 static ftdm_status_t ftdm_sangoma_isdn_start(ftdm_span_t *span)
-{	
+{
+	sngisdn_span_data_t *signal_data = span->signal_data;
 	ftdm_log(FTDM_LOG_INFO,"Starting span %s:%u.\n",span->name,span->span_id);
 	if (sngisdn_stack_start(span) != FTDM_SUCCESS) {
 		ftdm_log(FTDM_LOG_CRIT, "Failed to start span %s\n", span->name);
@@ -961,6 +987,14 @@ static ftdm_status_t ftdm_sangoma_isdn_start(ftdm_span_t *span)
 	ftdm_clear_flag(span, FTDM_SPAN_STOP_THREAD);
 	ftdm_clear_flag(span, FTDM_SPAN_IN_THREAD);
 
+	if (signal_data->raw_trace_q921 == SNGISDN_OPT_TRUE) {
+		sngisdn_activate_trace(span, SNGISDN_TRACE_Q921);
+	}
+	
+	if (signal_data->raw_trace_q931 == SNGISDN_OPT_TRUE) {
+		sngisdn_activate_trace(span, SNGISDN_TRACE_Q931);
+	}
+
 	/*start the span monitor thread*/
 	if (ftdm_thread_create_detached(ftdm_sangoma_isdn_run, span) != FTDM_SUCCESS) {
 		ftdm_log(FTDM_LOG_CRIT,"Failed to start Sangoma ISDN Span Monitor Thread!\n");
@@ -1072,7 +1106,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_isdn_span_config)
 	if (span->trunk_type == FTDM_TRUNK_BRI_PTMP ||
 		span->trunk_type == FTDM_TRUNK_BRI) {
 		
-		sngisdn_set_avail_rate(span, SNGISDN_AVAIL_PWR_SAVING);
+		sngisdn_set_span_avail_rate(span, SNGISDN_AVAIL_PWR_SAVING);
 	}
 
 	/* Initialize scheduling context */
@@ -1167,6 +1201,7 @@ static FIO_API_FUNCTION(ftdm_sangoma_isdn_api)
 		goto done;
 	}
 
+	/* TODO: Move functions to table + function pointers */
 	if (!strcasecmp(argv[0], "trace")) {
 		char *trace_opt;
 		
@@ -1184,6 +1219,7 @@ static FIO_API_FUNCTION(ftdm_sangoma_isdn_api)
 			stream->write_function(stream, "-ERR failed to find span by name %s\n", argv[2]);
 			goto done;
 		}
+		
 		if (!strcasecmp(trace_opt, "q921")) {
 			sngisdn_activate_trace(span, SNGISDN_TRACE_Q921);
 		} else if (!strcasecmp(trace_opt, "q931")) {
@@ -1192,7 +1228,7 @@ static FIO_API_FUNCTION(ftdm_sangoma_isdn_api)
 			sngisdn_activate_trace(span, SNGISDN_TRACE_DISABLE);
 		} else {
 			stream->write_function(stream, "-ERR invalid trace option <q921|q931> <span name>\n");
-		}	
+		}
 	}
 	if (!strcasecmp(argv[0], "l1_stats")) {
 		ftdm_span_t *span;
@@ -1210,7 +1246,7 @@ static FIO_API_FUNCTION(ftdm_sangoma_isdn_api)
 		}
 		sngisdn_print_phy_stats(stream, span);
 	}
-
+	
 	if (!strcasecmp(argv[0], "show_spans")) {
 		ftdm_span_t *span = NULL;
 		if (argc == 2) {

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.h

@@ -101,9 +101,11 @@ typedef enum {
 	FLAG_GLARE              = (1 << 6),
 	FLAG_DELAYED_REL        = (1 << 7),
 	FLAG_SENT_PROCEED       = (1 << 8),
-	FLAG_SEND_DISC  		= (1 << 9),
+	FLAG_SEND_DISC  		= (1 << 9),	
 	/* Used for BRI only, flag is set after we request line CONNECTED */
-	FLAG_ACTIVATING			= (1 << 10), 
+	FLAG_ACTIVATING			= (1 << 10),
+	/* Used when we receive an ALERT msg + inband tones ready */
+	FLAG_MEDIA_READY		= (1 << 11),
 } sngisdn_flag_t;
 
 
@@ -259,6 +261,8 @@ typedef struct sngisdn_span_data {
 	int8_t			facility_timeout;
 	uint8_t			num_local_numbers;
 	uint8_t 		ignore_cause_value;
+	uint8_t			raw_trace_q931;
+	uint8_t			raw_trace_q921;
 	uint8_t			timer_t3;
 	uint8_t			restart_opt;
 	char*			local_numbers[SNGISDN_NUM_LOCAL_NUMBERS];
@@ -352,8 +356,11 @@ void clear_call_glare_data(sngisdn_chan_data_t *sngisdn_info);
 ftdm_status_t get_ftdmchan_by_suInstId(int16_t cc_id, uint32_t suInstId, sngisdn_chan_data_t **sngisdn_data);
 ftdm_status_t get_ftdmchan_by_spInstId(int16_t cc_id, uint32_t spInstId, sngisdn_chan_data_t **sngisdn_data);
 
+ftdm_status_t sngisdn_set_span_avail_rate(ftdm_span_t *span, sngisdn_avail_t avail);
+ftdm_status_t sngisdn_set_chan_avail_rate(ftdm_channel_t *chan, sngisdn_avail_t avail);
+void sngisdn_set_span_sig_status(ftdm_span_t *ftdmspan, ftdm_signaling_status_t status);
+void sngisdn_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status);
 
-ftdm_status_t sngisdn_set_avail_rate(ftdm_span_t *span, sngisdn_avail_t avail);
 ftdm_status_t sngisdn_activate_trace(ftdm_span_t *span, sngisdn_tracetype_t trace_opt);
 
 
@@ -374,6 +381,7 @@ void sngisdn_snd_con_complete(ftdm_channel_t *ftdmchan);
 void sngisdn_snd_fac_req(ftdm_channel_t *ftdmchan);
 void sngisdn_snd_info_req(ftdm_channel_t *ftdmchan);
 void sngisdn_snd_status_enq(ftdm_channel_t *ftdmchan);
+void sngisdn_snd_restart(ftdm_channel_t *ftdmchan);
 void sngisdn_snd_data(ftdm_channel_t *dchan, uint8_t *data, ftdm_size_t len);
 void sngisdn_snd_event(ftdm_channel_t *dchan, ftdm_oob_event_t event);
 
@@ -421,8 +429,11 @@ void sngisdn_process_rst_ind (sngisdn_event_data_t *sngisdn_event);
 void sngisdn_rcv_phy_ind(SuId suId, Reason reason);
 void sngisdn_rcv_q921_ind(BdMngmt *status);
 
-void sngisdn_trace_q921(char* str, uint8_t* data, uint32_t data_len);
-void sngisdn_trace_q931(char* str, uint8_t* data, uint32_t data_len);
+void sngisdn_trace_interpreted_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len);
+void sngisdn_trace_interpreted_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len);
+void sngisdn_trace_raw_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len);
+void sngisdn_trace_raw_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len);
+
 void get_memory_info(void);
 
 ftdm_status_t sng_isdn_activate_trace(ftdm_span_t *span, sngisdn_tracetype_t trace_opt);
@@ -453,6 +464,9 @@ ftdm_status_t set_redir_num(ftdm_channel_t *ftdmchan, RedirNmb *redirNmb);
 ftdm_status_t set_calling_name(ftdm_channel_t *ftdmchan, ConEvnt *conEvnt);
 ftdm_status_t set_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad);
 ftdm_status_t set_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd, ftdm_sngisdn_progind_t prog_ind);
+ftdm_status_t set_bear_cap_ie(ftdm_channel_t *ftdmchan, BearCap *bearCap);
+ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId);
+ftdm_status_t set_restart_ind_ie(ftdm_channel_t *ftdmchan, RstInd *rstInd);
 ftdm_status_t set_facility_ie(ftdm_channel_t *ftdmchan, FacilityStr *facilityStr);
 ftdm_status_t set_facility_ie_str(ftdm_channel_t *ftdmchan, uint8_t *data, uint8_t *data_len);
 
@@ -482,7 +496,6 @@ static __inline__ void sngisdn_set_flag(sngisdn_chan_data_t *sngisdn_info, sngis
 
 
 void handle_sng_log(uint8_t level, char *fmt,...);
-void sngisdn_set_span_sig_status(ftdm_span_t *ftdmspan, ftdm_signaling_status_t status);
 void sngisdn_delayed_setup(void* p_sngisdn_info);
 void sngisdn_delayed_release(void* p_sngisdn_info);
 void sngisdn_delayed_connect(void* p_sngisdn_info);

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_cfg.c

@@ -296,6 +296,10 @@ ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_
 			parse_yesno(var, val, &signal_data->facility_ie_decode);
 		} else if (!strcasecmp(var, "ignore-cause-value")) {
 			parse_yesno(var, val, &signal_data->ignore_cause_value);
+		} else if (!strcasecmp(var, "q931-raw-trace")) {
+			parse_yesno(var, val, &signal_data->raw_trace_q931);
+		} else if (!strcasecmp(var, "q921-raw-trace")) {
+			parse_yesno(var, val, &signal_data->raw_trace_q921);
 		} else {
 			ftdm_log(FTDM_LOG_WARNING, "Ignoring unknown parameter %s\n", ftdm_parameters[paramindex].var);
 		}

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_cntrl.c

@@ -47,7 +47,7 @@ void sngisdn_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status
 	sig.span_id = ftdmchan->span_id;
 	sig.channel = ftdmchan;
 	sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-	sig.sigstatus = status;
+	sig.ev_data.sigstatus.status = status;
 	ftdm_span_send_signal(ftdmchan->span, &sig);
 	return;
 }

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_hndl.c

@@ -33,7 +33,8 @@
  */
 
 #include "ftmod_sangoma_isdn.h"
-ftdm_status_t sngisdn_cause_val_requires_disconnect(ftdm_channel_t *ftdmchan, CauseDgn *causeDgn);
+static ftdm_status_t sngisdn_cause_val_requires_disconnect(ftdm_channel_t *ftdmchan, CauseDgn *causeDgn);
+static void sngisdn_process_restart_confirm(ftdm_channel_t *ftdmchan);
 
 /* Remote side transmit a SETUP */
 void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
@@ -232,6 +233,9 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 				ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
 			}
 			break;
+		case FTDM_CHANNEL_STATE_RESET:
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+			break;
 		default:
 			ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Processing SETUP in an invalid state (%s)\n", ftdm_channel_state2str(ftdmchan->state));
 			break;
@@ -274,6 +278,7 @@ void sngisdn_process_con_cfm (sngisdn_event_data_t *sngisdn_event)
 	if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
 		switch(ftdmchan->state) {
 			case FTDM_CHANNEL_STATE_PROCEED:
+			case FTDM_CHANNEL_STATE_RINGING:
 			case FTDM_CHANNEL_STATE_PROGRESS:
 			case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
 			case FTDM_CHANNEL_STATE_DIALING:
@@ -285,6 +290,9 @@ void sngisdn_process_con_cfm (sngisdn_event_data_t *sngisdn_event)
 			case FTDM_CHANNEL_STATE_HANGUP:
 				/* Race condition, we just hung up the call - ignore this message */
 				break;
+			case FTDM_CHANNEL_STATE_RESET:
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+				break;				
 			default:
 				ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Processing CONNECT/CONNECT ACK in an invalid state (%s)\n", ftdm_channel_state2str(ftdmchan->state));
 
@@ -301,6 +309,9 @@ void sngisdn_process_con_cfm (sngisdn_event_data_t *sngisdn_event)
 			case FTDM_CHANNEL_STATE_HANGUP_COMPLETE:
 				/* Race condition, We just hung up an incoming call right after we sent a CONNECT - ignore this message */
 				break;
+			case FTDM_CHANNEL_STATE_RESET:
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+				break;
 			default:
 				ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Processing CONNECT/CONNECT ACK in an invalid state (%s)\n", ftdm_channel_state2str(ftdmchan->state));
 				
@@ -354,27 +365,47 @@ void sngisdn_process_cnst_ind (sngisdn_event_data_t *sngisdn_event)
 				ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
 				goto sngisdn_process_cnst_ind_end;
 			}
-			
+
 			switch(ftdmchan->state) {
 				case FTDM_CHANNEL_STATE_DIALING:
 				case FTDM_CHANNEL_STATE_PROCEED:
-					if (cnStEvnt->progInd.eh.pres && cnStEvnt->progInd.progDesc.val == IN_PD_IBAVAIL) {
-						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
-					} else 	if (evntType == MI_CALLPROC) {
-						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROCEED);
-					} else {
-						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
-					}
-					break;
 				case FTDM_CHANNEL_STATE_PROGRESS:
+				case FTDM_CHANNEL_STATE_RINGING:
 					if (cnStEvnt->progInd.eh.pres && cnStEvnt->progInd.progDesc.val == IN_PD_IBAVAIL) {
-						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
+						sngisdn_set_flag(sngisdn_info, FLAG_MEDIA_READY);
+					}
+					switch (evntType) {
+						case MI_CALLPROC:
+							if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALING) {
+								ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROCEED);
+							}
+							break;
+						case MI_ALERTING:
+							if (ftdmchan->state == FTDM_CHANNEL_STATE_PROCEED) {
+								ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_RINGING);
+							}
+							break;
+						case MI_PROGRESS:
+							if (sngisdn_test_flag(sngisdn_info, FLAG_MEDIA_READY)) {
+								
+								ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
+							} else if (ftdmchan->state != FTDM_CHANNEL_STATE_PROGRESS) {
+																
+								ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
+							}
+							break;
+						default:
+							/* We should never reach this section !*/
+							ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Don't know how to handle this event %d\n", evntType);
 					}
 					break;
 				case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
 					/* We are already in progress media, we can't go to any higher state except up */
 					/* Do nothing */
 					break;
+				case FTDM_CHANNEL_STATE_RESET:
+					ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+					break;
 				default:
 					ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Processing ALERT/PROCEED/PROGRESS in an invalid state (%s)\n", ftdm_channel_state2str(ftdmchan->state));
 
@@ -414,6 +445,9 @@ void sngisdn_process_cnst_ind (sngisdn_event_data_t *sngisdn_event)
 					case FTDM_CHANNEL_STATE_UP:
 						ftdm_log_chan(ftdmchan, FTDM_LOG_WARNING, "Receiving more digits %s, but we already proceeded with call\n", cnStEvnt->cdPtyNmb.nmbDigits.val);
 						break;
+					case FTDM_CHANNEL_STATE_RESET:
+						ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+						break;
 					default:
 						ftdm_log_chan(ftdmchan, FTDM_LOG_WARNING, "\n", suId, suInstId, spInstId);
 						break;
@@ -477,6 +511,9 @@ void sngisdn_process_disc_ind (sngisdn_event_data_t *sngisdn_event)
 			/* This is a race condition. We just sent a DISCONNECT, on this channel */
 			/* Do nothing */
 			break;
+		case FTDM_CHANNEL_STATE_RESET:
+			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+			break;
 		default:
 			ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Received DISCONNECT in an invalid state (%s)\n",
 						  ftdm_channel_state2str(ftdmchan->state));
@@ -531,7 +568,7 @@ void sngisdn_process_rel_ind (sngisdn_event_data_t *sngisdn_event)
 		case FTDM_CHANNEL_STATE_DIALING:
 			/* Remote side rejected our SETUP message on outbound call */
 			if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SIG_UP)) {
-				sngisdn_set_avail_rate(ftdmchan->span, SNGISDN_AVAIL_DOWN);
+				sngisdn_set_span_avail_rate(ftdmchan->span, SNGISDN_AVAIL_DOWN);
 			}
 			/* fall-through */
 		case FTDM_CHANNEL_STATE_PROCEED:
@@ -581,6 +618,9 @@ void sngisdn_process_rel_ind (sngisdn_event_data_t *sngisdn_event)
 				/* set abort flag so that we do not transmit another release complete on this channel once FS core is done */
 			}
 			break;
+		case FTDM_CHANNEL_STATE_RESET:
+			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Processing SETUP but channel in RESET state, ignoring\n");
+			break;
 		default:
 			ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Received RELEASE in an invalid state (%s)\n",
 							ftdm_channel_state2str(ftdmchan->state));
@@ -1050,18 +1090,91 @@ void sngisdn_process_srv_cfm (sngisdn_event_data_t *sngisdn_event)
 	return;
 }
 
+static void sngisdn_process_restart_confirm(ftdm_channel_t *ftdmchan)
+{
+	switch (ftdmchan->state) {
+		case FTDM_CHANNEL_STATE_RESET:
+			ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
+			break;
+		case FTDM_CHANNEL_STATE_DOWN:
+			/* Do nothing */
+			break;
+		default:
+			ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Received RESTART CFM in an invalid state (%s)\n",
+						  ftdm_channel_state2str(ftdmchan->state));
+	}
+
+	return;
+}
+
+
 void sngisdn_process_rst_cfm (sngisdn_event_data_t *sngisdn_event)
 {
 	int16_t suId = sngisdn_event->suId;
 	int16_t dChan = sngisdn_event->dChan;
 	uint8_t ces = sngisdn_event->ces;
 	uint8_t evntType = sngisdn_event->evntType;
-
-	ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
-
-	/* Function does not require any info from ssHlEvnt struct for now */
-	/*Rst *rstEvnt = &sngisdn_event->event.rstEvnt;*/
+	uint8_t chan_no = 0;
+	Rst *rstEvnt = &sngisdn_event->event.rstEvnt;
 	
+	sngisdn_span_data_t	*signal_data = g_sngisdn_data.dchans[dChan].spans[1];
+	if (!signal_data) {
+		ftdm_log(FTDM_LOG_CRIT, "Received RESTART on unconfigured span (suId:%d)\n", suId);
+		return;
+	}
+	
+	if (!rstEvnt->rstInd.eh.pres || !rstEvnt->rstInd.rstClass.pres) {
+		ftdm_log(FTDM_LOG_DEBUG, "Receved RESTART, but Restart Indicator IE not present\n");
+		return;
+	}
+		
+	switch(rstEvnt->rstInd.rstClass.val) {
+		case IN_CL_INDCHAN: /* Indicated b-channel */
+			if (rstEvnt->chanId.eh.pres) {
+				if (rstEvnt->chanId.intType.val == IN_IT_BASIC) {
+					if (rstEvnt->chanId.infoChanSel.pres == PRSNT_NODEF) {
+						chan_no = rstEvnt->chanId.infoChanSel.val;
+					}
+				} else if (rstEvnt->chanId.intType.val == IN_IT_OTHER) {
+					if (rstEvnt->chanId.chanNmbSlotMap.pres == PRSNT_NODEF) {
+						chan_no = rstEvnt->chanId.chanNmbSlotMap.val[0];
+					}
+				}
+			}
+			if (!chan_no) {
+				ftdm_log(FTDM_LOG_CRIT, "Failed to determine channel from RESTART\n");
+				return;
+			}
+			break;
+		case IN_CL_SNGINT: /* Single interface */
+		case IN_CL_ALLINT: /* All interfaces */
+			/* In case restart class indicates all interfaces, we will duplicate
+			this event on each span associated to this d-channel in sngisdn_rcv_rst_cfm,
+			so treat it as a single interface anyway */
+			break;
+		default:
+			ftdm_log(FTDM_LOG_CRIT, "Invalid restart indicator class:%d\n", rstEvnt->rstInd.rstClass.val);
+			return;
+	}
+
+	if (chan_no) { /* For a single channel */
+		if (chan_no > ftdm_span_get_chan_count(signal_data->ftdm_span)) {
+			ftdm_log(FTDM_LOG_CRIT, "Received RESTART on invalid channel:%d\n", chan_no);
+		} else {
+			ftdm_channel_t *ftdmchan = ftdm_span_get_channel(signal_data->ftdm_span, chan_no);
+			sngisdn_process_restart_confirm(ftdmchan);
+		}
+	} else { /* for all channels */
+		ftdm_iterator_t *chaniter = NULL;
+		ftdm_iterator_t *curr = NULL;
+
+		chaniter = ftdm_span_get_chan_iterator(signal_data->ftdm_span, NULL);
+		for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {
+			sngisdn_process_restart_confirm((ftdm_channel_t*)ftdm_iterator_current(curr));
+		}
+		ftdm_iterator_free(chaniter);
+	}
+
 	ftdm_log(FTDM_LOG_DEBUG, "Processing RESTART CFM (suId:%u dChan:%d ces:%d type:%d)\n", suId, dChan, ces, evntType);
 	ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
 	return;
@@ -1090,7 +1203,7 @@ void sngisdn_process_rst_ind (sngisdn_event_data_t *sngisdn_event)
 	return;
 }
 
-ftdm_status_t sngisdn_cause_val_requires_disconnect(ftdm_channel_t *ftdmchan, CauseDgn *causeDgn)
+static ftdm_status_t sngisdn_cause_val_requires_disconnect(ftdm_channel_t *ftdmchan, CauseDgn *causeDgn)
 {
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
 	

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_out.c

@@ -51,72 +51,6 @@ void sngisdn_snd_setup(ftdm_channel_t *ftdmchan)
 	ftdm_mutex_unlock(g_sngisdn_data.ccs[signal_data->cc_id].mutex);
 
 	memset(&conEvnt, 0, sizeof(conEvnt));
-
-	conEvnt.bearCap[0].eh.pres = PRSNT_NODEF;
-	conEvnt.bearCap[0].infoTranCap.pres = PRSNT_NODEF;
-	conEvnt.bearCap[0].infoTranCap.val = sngisdn_get_infoTranCap_from_user(ftdmchan->caller_data.bearer_capability);
-
-	conEvnt.bearCap[0].codeStand0.pres = PRSNT_NODEF;
-	conEvnt.bearCap[0].codeStand0.val = IN_CSTD_CCITT;
-	conEvnt.bearCap[0].infoTranRate0.pres = PRSNT_NODEF;
-	conEvnt.bearCap[0].infoTranRate0.val = IN_ITR_64KBIT;
-	conEvnt.bearCap[0].tranMode.pres = PRSNT_NODEF;
-	conEvnt.bearCap[0].tranMode.val = IN_TM_CIRCUIT;
-
-	conEvnt.chanId.eh.pres = PRSNT_NODEF;
-	conEvnt.chanId.prefExc.pres = PRSNT_NODEF;
-	conEvnt.chanId.prefExc.val = IN_PE_EXCLSVE;
-	conEvnt.chanId.dChanInd.pres = PRSNT_NODEF;
-	conEvnt.chanId.dChanInd.val = IN_DSI_NOTDCHAN;
-	conEvnt.chanId.intIdentPres.pres = PRSNT_NODEF;
-	conEvnt.chanId.intIdentPres.val = IN_IIP_IMPLICIT;
-	conEvnt.chanId.intIdent.pres = NOTPRSNT;
-
-	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
-		ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
-		/* Trillium stack rejests lyr1Ident on BRI, but Netbricks always sends it.
-		Check with Trillium if this ever causes calls to fail in the field */
-
-		/* BRI only params */
-		conEvnt.chanId.intType.pres = PRSNT_NODEF;
-		conEvnt.chanId.intType.val = IN_IT_BASIC;
-		conEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		conEvnt.chanId.infoChanSel.val = ftdmchan->physical_chan_id;
-	} else {
-		/* PRI only params */
-		conEvnt.bearCap[0].usrInfoLyr1Prot.pres = PRSNT_NODEF;
-		conEvnt.bearCap[0].usrInfoLyr1Prot.val = sngisdn_get_usrInfoLyr1Prot_from_user(ftdmchan->caller_data.bearer_layer1);
-		
-		if (signal_data->switchtype == SNGISDN_SWITCH_EUROISDN &&
-			conEvnt.bearCap[0].usrInfoLyr1Prot.val == IN_UIL1_G711ULAW) {
-			
-			/* We are bridging a call from T1 */
-			conEvnt.bearCap[0].usrInfoLyr1Prot.val = IN_UIL1_G711ALAW;
-			
-		} else if (conEvnt.bearCap[0].usrInfoLyr1Prot.val == IN_UIL1_G711ALAW) {
-			
-			/* We are bridging a call from E1 */
-			conEvnt.bearCap[0].usrInfoLyr1Prot.val = IN_UIL1_G711ULAW;
-		}
-		
-		conEvnt.bearCap[0].lyr1Ident.pres = PRSNT_NODEF;
-		conEvnt.bearCap[0].lyr1Ident.val = IN_L1_IDENT;
-
-		conEvnt.chanId.intType.pres = PRSNT_NODEF;
-		conEvnt.chanId.intType.val = IN_IT_OTHER;
-		conEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		conEvnt.chanId.infoChanSel.val = IN_ICS_B1CHAN;
-		conEvnt.chanId.chanMapType.pres = PRSNT_NODEF;
-		conEvnt.chanId.chanMapType.val = IN_CMT_BCHAN;
-		conEvnt.chanId.nmbMap.pres = PRSNT_NODEF;
-		conEvnt.chanId.nmbMap.val = IN_NM_CHNNMB;
-		conEvnt.chanId.codeStand1.pres = PRSNT_NODEF;
-		conEvnt.chanId.codeStand1.val = IN_CSTD_CCITT;
-		conEvnt.chanId.chanNmbSlotMap.pres = PRSNT_NODEF;
-		conEvnt.chanId.chanNmbSlotMap.len = 1;
-		conEvnt.chanId.chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
-	}
-
 	if (signal_data->switchtype == SNGISDN_SWITCH_EUROISDN) {
 		conEvnt.sndCmplt.eh.pres = PRSNT_NODEF;
 	}
@@ -126,6 +60,8 @@ void sngisdn_snd_setup(ftdm_channel_t *ftdmchan)
 	}
 	ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Outgoing call: Called No:[%s] Calling No:[%s]\n", ftdmchan->caller_data.dnis.digits, ftdmchan->caller_data.cid_num.digits);
 
+	set_chan_id_ie(ftdmchan, &conEvnt.chanId);
+	set_bear_cap_ie(ftdmchan, &conEvnt.bearCap[0]);
 	set_called_num(ftdmchan, &conEvnt.cdPtyNmb);
 	set_calling_num(ftdmchan, &conEvnt.cgPtyNmb);
 	set_calling_num2(ftdmchan, &conEvnt.cgPtyNmb2);
@@ -161,38 +97,7 @@ void sngisdn_snd_setup_ack(ftdm_channel_t *ftdmchan)
 	
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));	
 
-	cnStEvnt.chanId.eh.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.val = IN_PE_EXCLSVE;
-	cnStEvnt.chanId.dChanInd.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.dChanInd.val = IN_DSI_NOTDCHAN;
-	cnStEvnt.chanId.intIdentPres.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.intIdentPres.val = IN_IIP_IMPLICIT;
 
-	
-	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
-		ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
-
-		/* BRI only params */
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_BASIC;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = ftdmchan->physical_chan_id;
-	} else {
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_OTHER;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = IN_ICS_B1CHAN;
-		cnStEvnt.chanId.chanMapType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanMapType.val = IN_CMT_BCHAN;
-		cnStEvnt.chanId.nmbMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.nmbMap.val = IN_NM_CHNNMB;
-		cnStEvnt.chanId.codeStand1.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.codeStand1.val = IN_CSTD_CCITT;
-		cnStEvnt.chanId.chanNmbSlotMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanNmbSlotMap.len = 1;
-		cnStEvnt.chanId.chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
-	}
 
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending SETUP ACK (suId:%d suInstId:%u spInstId:%u dchan:%d ces:%d)\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, signal_data->dchan_id, sngisdn_info->ces);
 
@@ -221,38 +126,7 @@ void sngisdn_snd_con_complete(ftdm_channel_t *ftdmchan)
 	
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));
 	
-	cnStEvnt.chanId.eh.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.val = IN_PE_EXCLSVE;
-	cnStEvnt.chanId.dChanInd.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.dChanInd.val = IN_DSI_NOTDCHAN;
-	cnStEvnt.chanId.intIdentPres.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.intIdentPres.val = IN_IIP_IMPLICIT;
-	
-	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
-		ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
-
-		/* BRI only params */
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_BASIC;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = ftdmchan->physical_chan_id;
-	} else {
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_OTHER;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = IN_ICS_B1CHAN;
-		cnStEvnt.chanId.chanMapType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanMapType.val = IN_CMT_BCHAN;
-		cnStEvnt.chanId.nmbMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.nmbMap.val = IN_NM_CHNNMB;
-		cnStEvnt.chanId.codeStand1.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.codeStand1.val = IN_CSTD_CCITT;
-		cnStEvnt.chanId.chanNmbSlotMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanNmbSlotMap.len = 1;
-		cnStEvnt.chanId.chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
-	}
-
+	set_chan_id_ie(ftdmchan, &cnStEvnt.chanId);
 
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending CONNECT COMPL (suId:%d suInstId:%u spInstId:%u dchan:%d ces:%d)\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, signal_data->dchan_id, sngisdn_info->ces);
 
@@ -277,41 +151,11 @@ void sngisdn_snd_proceed(ftdm_channel_t *ftdmchan, ftdm_sngisdn_progind_t prog_i
 	}
 	
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));
-	
-	cnStEvnt.chanId.eh.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.val = IN_PE_EXCLSVE;
-	cnStEvnt.chanId.dChanInd.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.dChanInd.val = IN_DSI_NOTDCHAN;
-	cnStEvnt.chanId.intIdentPres.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.intIdentPres.val = IN_IIP_IMPLICIT;
-	
-	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
-		ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
-
-		/* BRI only params */
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_BASIC;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = ftdmchan->physical_chan_id;
-	} else {
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_OTHER;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = IN_ICS_B1CHAN;
-		cnStEvnt.chanId.chanMapType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanMapType.val = IN_CMT_BCHAN;
-		cnStEvnt.chanId.nmbMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.nmbMap.val = IN_NM_CHNNMB;
-		cnStEvnt.chanId.codeStand1.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.codeStand1.val = IN_CSTD_CCITT;
-		cnStEvnt.chanId.chanNmbSlotMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanNmbSlotMap.len = 1;
-		cnStEvnt.chanId.chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
-	}
 
+	set_chan_id_ie(ftdmchan, &cnStEvnt.chanId);
 	set_prog_ind_ie(ftdmchan, &cnStEvnt.progInd, prog_ind);
 	set_facility_ie(ftdmchan, &cnStEvnt.facilityStr);
+	
 	ftdm_call_clear_data(&ftdmchan->caller_data);
 
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending PROCEED (suId:%d suInstId:%u spInstId:%u dchan:%d ces:%d)\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, signal_data->dchan_id, sngisdn_info->ces);
@@ -397,39 +241,8 @@ void sngisdn_snd_connect(ftdm_channel_t *ftdmchan)
 	}
 	
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));
-
-	cnStEvnt.chanId.eh.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.prefExc.val = IN_PE_EXCLSVE;
-	cnStEvnt.chanId.dChanInd.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.dChanInd.val = IN_DSI_NOTDCHAN;
-	cnStEvnt.chanId.intIdentPres.pres = PRSNT_NODEF;
-	cnStEvnt.chanId.intIdentPres.val = IN_IIP_IMPLICIT;
 	
-	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
-		ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
-
-		/* BRI only params */
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_BASIC;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = ftdmchan->physical_chan_id;
-	} else {
-		cnStEvnt.chanId.intType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.intType.val = IN_IT_OTHER;
-		cnStEvnt.chanId.infoChanSel.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.infoChanSel.val = IN_ICS_B1CHAN;
-		cnStEvnt.chanId.chanMapType.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanMapType.val = IN_CMT_BCHAN;
-		cnStEvnt.chanId.nmbMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.nmbMap.val = IN_NM_CHNNMB;
-		cnStEvnt.chanId.codeStand1.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.codeStand1.val = IN_CSTD_CCITT;
-		cnStEvnt.chanId.chanNmbSlotMap.pres = PRSNT_NODEF;
-		cnStEvnt.chanId.chanNmbSlotMap.len = 1;
-		cnStEvnt.chanId.chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
-	}
-
+	set_chan_id_ie(ftdmchan, &cnStEvnt.chanId);
 	set_prog_ind_ie(ftdmchan, &cnStEvnt.progInd, prog_ind);
 	set_facility_ie(ftdmchan, &cnStEvnt.facilityStr);
 	ftdm_call_clear_data(&ftdmchan->caller_data);
@@ -563,6 +376,7 @@ void sngisdn_snd_disconnect(ftdm_channel_t *ftdmchan)
 	}
 	return;
 }
+
 void sngisdn_snd_release(ftdm_channel_t *ftdmchan, uint8_t glare)
 {
 	RelEvnt relEvnt;
@@ -618,6 +432,24 @@ void sngisdn_snd_release(ftdm_channel_t *ftdmchan, uint8_t glare)
 	return;
 }
 
+void sngisdn_snd_restart(ftdm_channel_t *ftdmchan)
+{
+	Rst rstEvnt;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
+
+	memset(&rstEvnt, 0, sizeof(rstEvnt));
+
+	set_chan_id_ie(ftdmchan, &rstEvnt.chanId);
+	set_restart_ind_ie(ftdmchan, &rstEvnt.rstInd);
+	
+	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending RESTART (suId:%d dchan:%d ces:%d)\n", signal_data->cc_id, signal_data->dchan_id, CES_MNGMNT);
+
+	if (sng_isdn_restart_request(signal_data->cc_id, &rstEvnt, signal_data->dchan_id, CES_MNGMNT, IN_SND_RST)) {
+		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_CRIT, "stack refused RESTART request\n");
+	}
+	return;
+}
+
 
 /* We received an incoming frame on the d-channel, send data to the stack */
 void sngisdn_snd_data(ftdm_channel_t *dchan, uint8_t *data, ftdm_size_t len)

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_rcv.c

@@ -34,9 +34,6 @@
 
 #include "ftmod_sangoma_isdn.h"
 
-#define MAX_DECODE_STR_LEN 2000
-
-
 void sngisdn_rcv_con_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, ConEvnt *conEvnt, int16_t dChan, uint8_t ces)
 {
 	uint8_t bchan_no = 0;
@@ -630,8 +627,9 @@ void sngisdn_rcv_rst_cfm (int16_t suId, Rst *rstEvnt, int16_t dChan, uint8_t ces
 
 	ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
 
+
 	ftdm_log(FTDM_LOG_INFO, "Received RESTART CFM (dChan:%d ces:%u type:%u)\n", dChan, ces, evntType);
-	
+
 	/* Enqueue the event to each span within the dChan */
 	for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) {
 		signal_data = g_sngisdn_data.dchans[dChan].spans[i];
@@ -725,14 +723,25 @@ void sngisdn_rcv_q931_ind(InMngmt *status)
 			ftdmspan = signal_data->ftdm_span;
 			
 			if (status->t.usta.alarm.event == LCM_EVENT_UP) {
+				uint32_t chan_no = status->t.usta.evntParm[2];
 				ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
 						 status->t.usta.suId,
 								DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
 								DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
 								DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
-				
-				sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_UP);
-				sngisdn_set_avail_rate(ftdmspan, SNGISDN_AVAIL_UP);
+
+				if (chan_no) {
+					ftdm_channel_t *ftdmchan = ftdm_span_get_channel(ftdmspan, chan_no);
+					if (ftdmchan) {
+						sngisdn_set_chan_sig_status(ftdmchan, FTDM_SIG_STATE_UP);
+						sngisdn_set_chan_avail_rate(ftdmchan, SNGISDN_AVAIL_UP);
+					} else {
+						ftdm_log(FTDM_LOG_CRIT, "stack alarm event on invalid channel :%d\n", chan_no);
+					}
+				} else {
+					sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_UP);
+					sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_UP);
+				}
 			} else {
 				ftdm_log(FTDM_LOG_WARNING, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
 						 		status->t.usta.suId,
@@ -741,7 +750,7 @@ void sngisdn_rcv_q931_ind(InMngmt *status)
 								DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
 				
 				sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_DOWN);
-				sngisdn_set_avail_rate(ftdmspan, SNGISDN_AVAIL_PWR_SAVING);
+				sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_PWR_SAVING);
 			}
 		}
 		break;
@@ -765,9 +774,6 @@ void sngisdn_rcv_cc_ind(CcMngmt *status)
     return;
 }
 
-#define Q931_TRC_EVENT(event) (event == TL3PKTTX)?"TX": \
-								(event == TL3PKTRX)?"RX":"UNKNOWN"
-
 void sngisdn_rcv_q931_trace(InMngmt *trc, Buffer *mBuf)
 {
 	MsgLen mlen;
@@ -776,13 +782,20 @@ void sngisdn_rcv_q931_trace(InMngmt *trc, Buffer *mBuf)
 	Buffer *tmp;
 	Data *cptr;
 	uint8_t data;
+	ftdm_trace_dir_t dir;
 	uint8_t tdata[1000];
-	char *data_str = ftdm_calloc(1,MAX_DECODE_STR_LEN); /* TODO Find a proper size */
-	
+	sngisdn_span_data_t	*signal_data = g_sngisdn_data.spans[trc->t.trc.suId];
+
 	ftdm_assert(mBuf != NULLP, "Received a Q931 trace with no buffer");
 	mlen = ((SsMsgInfo*)(mBuf->b_rptr))->len;
-
-	if (mlen != 0) {
+	
+	if (trc->t.trc.evnt == TL3PKTTX) {
+		dir = FTDM_TRACE_OUTGOING;
+	} else {
+		dir = FTDM_TRACE_INCOMING;
+	}
+	
+	if (mlen) {
 		tmp = mBuf->b_cont;
 		cptr = tmp->b_rptr;
 		data = *cptr++;
@@ -797,41 +810,40 @@ void sngisdn_rcv_q931_trace(InMngmt *trc, Buffer *mBuf)
 			}
 			data = *cptr++;
 		}
-
-		sngisdn_trace_q931(data_str, tdata, mlen);
-		ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q931] s%d FRAME %s:%s\n", trc->t.trc.suId, Q931_TRC_EVENT(trc->t.trc.evnt), data_str);
+		if (signal_data->raw_trace_q931 == SNGISDN_OPT_TRUE) {
+			sngisdn_trace_raw_q931(signal_data, dir, tdata, mlen);
+		} else {
+			sngisdn_trace_interpreted_q931(signal_data, dir, tdata, mlen);
+		}
 	}
-
-	ftdm_safe_free(data_str);
-	/* We do not need to free mBuf in this case because stack does it */
-	/* SPutMsg(mBuf); */
 	return;
 }
 
 
-#define Q921_TRC_EVENT(event) (event == TL2FRMRX)?"RX": \
-								(event == TL2FRMTX)?"TX": \
-								(event == TL2TMR)?"TMR EXPIRED":"UNKNOWN"
-
 void sngisdn_rcv_q921_trace(BdMngmt *trc, Buffer *mBuf)
 {
 	MsgLen mlen;
+	Buffer *tmp;	
 	MsgLen i;
 	int16_t j;
-	Buffer *tmp;
 	Data *cptr;
 	uint8_t data;
-	uint8_t tdata[16];
-	char *data_str = ftdm_calloc(1,200); /* TODO Find a proper size */
-	
+	ftdm_trace_dir_t dir;
+	uint8_t tdata[1000];
+	sngisdn_span_data_t	*signal_data = g_sngisdn_data.spans[trc->t.trc.lnkNmb];
 
 	if (trc->t.trc.evnt == TL2TMR) {
-		goto end_of_trace;
+		return;
 	}
 
+	if (trc->t.trc.evnt == TL2FRMTX) {
+		dir = FTDM_TRACE_OUTGOING;
+	} else {
+		dir = FTDM_TRACE_INCOMING;
+	}
+	
 	ftdm_assert(mBuf != NULLP, "Received a Q921 trace with no buffer");
 	mlen = ((SsMsgInfo*)(mBuf->b_rptr))->len;
-
 	if (mlen != 0) {
 		tmp = mBuf->b_cont;
 		cptr = tmp->b_rptr;
@@ -853,12 +865,12 @@ void sngisdn_rcv_q921_trace(BdMngmt *trc, Buffer *mBuf)
 			}
 
 		}
-		sngisdn_trace_q921(data_str, tdata, mlen);
-		ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q921] s%d FRAME %s:%s\n", trc->t.trc.lnkNmb, Q921_TRC_EVENT(trc->t.trc.evnt), data_str);
+		if (signal_data->raw_trace_q921 == SNGISDN_OPT_TRUE) {
+			sngisdn_trace_raw_q921(signal_data, dir, tdata, mlen);
+		} else {
+			sngisdn_trace_interpreted_q921(signal_data, dir, tdata, mlen);
+		}		
 	}
-end_of_trace:
-	ftdm_safe_free(data_str);
-	SPutMsg(mBuf);
 	return;
 }
 

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_support.c

@@ -136,19 +136,25 @@ ftdm_status_t get_ftdmchan_by_spInstId(int16_t cc_id, uint32_t spInstId, sngisdn
 	return FTDM_SUCCESS;
 }
 
-ftdm_status_t sngisdn_set_avail_rate(ftdm_span_t *span, sngisdn_avail_t avail)
+ftdm_status_t sngisdn_set_chan_avail_rate(ftdm_channel_t *chan, sngisdn_avail_t avail)
 {
-	if (span->trunk_type == FTDM_TRUNK_BRI ||
-		span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
+	if (FTDM_SPAN_IS_BRI(chan->span)) {
+		ftdm_log_chan(chan, FTDM_LOG_DEBUG, "Setting availability rate to:%d\n", avail);
+		chan->availability_rate = avail;
+	}
+	return FTDM_SUCCESS;
+}
 
+ftdm_status_t sngisdn_set_span_avail_rate(ftdm_span_t *span, sngisdn_avail_t avail)
+{
+	if (FTDM_SPAN_IS_BRI(span)) {
 		ftdm_iterator_t *chaniter = NULL;
 		ftdm_iterator_t *curr = NULL;
 
-
 		chaniter = ftdm_span_get_chan_iterator(span, NULL);
 		for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {
 			ftdm_log_chan(((ftdm_channel_t*)ftdm_iterator_current(curr)), FTDM_LOG_DEBUG, "Setting availability rate to:%d\n", avail);
-			((ftdm_channel_t*)ftdm_iterator_current(curr))->availability_rate = avail;
+			sngisdn_set_chan_avail_rate(((ftdm_channel_t*)ftdm_iterator_current(curr)), avail);
 		}
 		ftdm_iterator_free(chaniter);
 	}
@@ -676,7 +682,6 @@ ftdm_status_t set_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad)
 	return FTDM_SUCCESS;
 }
 
-
 ftdm_status_t set_facility_ie(ftdm_channel_t *ftdmchan, FacilityStr *facilityStr)
 {
 	ftdm_status_t status;
@@ -789,6 +794,93 @@ ftdm_status_t set_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd, ftdm_s
 	return FTDM_SUCCESS;
 }
 
+ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId)
+{
+	if (!ftdmchan) {
+		return FTDM_SUCCESS;
+	}
+	chanId->eh.pres = PRSNT_NODEF;
+	chanId->prefExc.pres = PRSNT_NODEF;
+	chanId->prefExc.val = IN_PE_EXCLSVE;
+	chanId->dChanInd.pres = PRSNT_NODEF;
+	chanId->dChanInd.val = IN_DSI_NOTDCHAN;
+	chanId->intIdentPres.pres = PRSNT_NODEF;
+	chanId->intIdentPres.val = IN_IIP_IMPLICIT;
+
+	if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
+		   ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
+
+		/* BRI only params */
+		chanId->intType.pres = PRSNT_NODEF;
+		chanId->intType.val = IN_IT_BASIC;
+		chanId->infoChanSel.pres = PRSNT_NODEF;
+		chanId->infoChanSel.val = ftdmchan->physical_chan_id;
+	} else {
+		chanId->intType.pres = PRSNT_NODEF;
+		chanId->intType.val = IN_IT_OTHER;
+		chanId->infoChanSel.pres = PRSNT_NODEF;
+		chanId->infoChanSel.val = IN_ICS_B1CHAN;
+		chanId->chanMapType.pres = PRSNT_NODEF;
+		chanId->chanMapType.val = IN_CMT_BCHAN;
+		chanId->nmbMap.pres = PRSNT_NODEF;
+		chanId->nmbMap.val = IN_NM_CHNNMB;
+		chanId->codeStand1.pres = PRSNT_NODEF;
+		chanId->codeStand1.val = IN_CSTD_CCITT;
+		chanId->chanNmbSlotMap.pres = PRSNT_NODEF;
+		chanId->chanNmbSlotMap.len = 1;
+		chanId->chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
+	}
+	return FTDM_SUCCESS;
+}
+
+ftdm_status_t set_bear_cap_ie(ftdm_channel_t *ftdmchan, BearCap *bearCap)
+{
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
+	
+	bearCap->eh.pres = PRSNT_NODEF;
+	bearCap->infoTranCap.pres = PRSNT_NODEF;
+	bearCap->infoTranCap.val = sngisdn_get_infoTranCap_from_user(ftdmchan->caller_data.bearer_capability);
+
+	bearCap->codeStand0.pres = PRSNT_NODEF;
+	bearCap->codeStand0.val = IN_CSTD_CCITT;
+	bearCap->infoTranRate0.pres = PRSNT_NODEF;
+	bearCap->infoTranRate0.val = IN_ITR_64KBIT;
+	bearCap->tranMode.pres = PRSNT_NODEF;
+	bearCap->tranMode.val = IN_TM_CIRCUIT;
+
+	if (!FTDM_SPAN_IS_BRI(ftdmchan->span)) {
+		/* Trillium stack rejests lyr1Ident on BRI, but Netbricks always sends it.
+		Check with Trillium if this ever causes calls to fail in the field */
+
+		/* PRI only params */
+		bearCap->usrInfoLyr1Prot.pres = PRSNT_NODEF;
+		bearCap->usrInfoLyr1Prot.val = sngisdn_get_usrInfoLyr1Prot_from_user(ftdmchan->caller_data.bearer_layer1);
+
+		if (signal_data->switchtype == SNGISDN_SWITCH_EUROISDN &&
+			bearCap->usrInfoLyr1Prot.val == IN_UIL1_G711ULAW) {
+
+			/* We are bridging a call from T1 */
+			bearCap->usrInfoLyr1Prot.val = IN_UIL1_G711ALAW;
+
+		} else if (bearCap->usrInfoLyr1Prot.val == IN_UIL1_G711ALAW) {
+
+			/* We are bridging a call from E1 */
+			bearCap->usrInfoLyr1Prot.val = IN_UIL1_G711ULAW;
+		}
+
+		bearCap->lyr1Ident.pres = PRSNT_NODEF;
+		bearCap->lyr1Ident.val = IN_L1_IDENT;
+	}
+	return FTDM_SUCCESS;
+}
+
+ftdm_status_t set_restart_ind_ie(ftdm_channel_t *ftdmchan, RstInd *rstInd)
+{
+	rstInd->eh.pres = PRSNT_NODEF;
+	rstInd->rstClass.pres = PRSNT_NODEF;
+	rstInd->rstClass.val = IN_CL_INDCHAN;
+	return FTDM_SUCCESS;
+}
 
 void sngisdn_t3_timeout(void* p_sngisdn_info)
 {

libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c

@@ -36,14 +36,15 @@
 #include "ftmod_sangoma_isdn_trace.h"
 
 #define OCTET(x) (ieData[x-1] & 0xFF)
+#define MAX_DECODE_STR_LEN 2000
 
 void print_hex_dump(char* str, uint32_t *str_len, uint8_t* data, uint32_t index_start, uint32_t index_end);
-void sngisdn_trace_q921(char* str, uint8_t* data, uint32_t data_len);
-void sngisdn_trace_q931(char* str, uint8_t* data, uint32_t data_len);
 uint32_t sngisdn_decode_ie(char *str, uint32_t *str_len, uint8_t current_codeset, uint8_t *data, uint16_t index_start);
 
 uint8_t get_bits(uint8_t octet, uint8_t bitLo, uint8_t bitHi);
 char* get_code_2_str(int code, struct code2str *pCodeTable);
+void sngisdn_decode_q921(char* str, uint8_t* data, uint32_t data_len);
+void sngisdn_decode_q931(char* str, uint8_t* data, uint32_t data_len);
 
 char* get_code_2_str(int code, struct code2str *pCodeTable)
 {
@@ -97,7 +98,42 @@ uint8_t get_bits(uint8_t octet, uint8_t bitLo, uint8_t bitHi)
 	return 0;
 }
 
-void sngisdn_trace_q921(char* str, uint8_t* data, uint32_t data_len)
+void sngisdn_trace_interpreted_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len)
+{
+	char *data_str = ftdm_calloc(1,200); /* TODO Find a proper size */
+ 	sngisdn_decode_q921(data_str, data, data_len);
+	ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q921] s%d FRAME %s:%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
+	ftdm_safe_free(data_str);
+}
+
+void sngisdn_trace_raw_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len)
+{
+	uint8_t 			*raw_data;
+	ftdm_sigmsg_t		sigev;
+	
+	memset(&sigev, 0, sizeof(sigev));
+
+	sigev.span_id = signal_data->ftdm_span->span_id;
+	sigev.chan_id = signal_data->dchan->chan_id;
+	sigev.channel = signal_data->dchan;
+	sigev.event_id = FTDM_SIGEVENT_TRACE_RAW;
+	
+	sigev.ev_data.logevent.dir = dir;
+	sigev.ev_data.logevent.level = 2;
+	
+	/* TODO: Map trace to call ID here */
+	sigev.call_id = 0;
+	
+	raw_data = ftdm_malloc(data_len);
+	ftdm_assert(raw_data, "Failed to malloc");
+	
+	memcpy(raw_data, data, data_len);
+	sigev.raw_data = raw_data;
+	sigev.raw_data_len = data_len;
+	ftdm_span_send_signal(signal_data->ftdm_span, &sigev);
+}
+
+void sngisdn_decode_q921(char* str, uint8_t* data, uint32_t data_len)
 {
 	int str_len;
 	uint32_t i;
@@ -169,7 +205,42 @@ void sngisdn_trace_q921(char* str, uint8_t* data, uint32_t data_len)
 	return;
 }
 
-void sngisdn_trace_q931(char* str, uint8_t* data, uint32_t data_len)
+
+void sngisdn_trace_interpreted_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len)
+{
+	char *data_str = ftdm_calloc(1,MAX_DECODE_STR_LEN); /* TODO Find a proper size */
+	sngisdn_decode_q931(data_str, data, data_len);
+	ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q931] %s FRAME %s:%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
+	ftdm_safe_free(data_str);
+}
+
+void sngisdn_trace_raw_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t dir, uint8_t *data, uint32_t data_len)
+{
+	uint8_t 			*raw_data;
+	ftdm_sigmsg_t		sigev;
+
+	memset(&sigev, 0, sizeof(sigev));
+
+	sigev.span_id = signal_data->ftdm_span->span_id;
+	sigev.chan_id = signal_data->dchan->chan_id;
+	sigev.channel = signal_data->dchan;
+	sigev.event_id = FTDM_SIGEVENT_TRACE_RAW;
+
+	sigev.ev_data.logevent.dir = dir;
+	sigev.ev_data.logevent.level = 3;
+	
+	/* TODO: Map trace to call ID here */
+	
+	raw_data = ftdm_malloc(data_len);
+	ftdm_assert(raw_data, "Failed to malloc");
+	
+	memcpy(raw_data, data, data_len);
+	sigev.raw_data = raw_data;
+	sigev.raw_data_len = data_len;
+	ftdm_span_send_signal(signal_data->ftdm_span, &sigev);
+}
+
+void sngisdn_decode_q931(char* str, uint8_t* data, uint32_t data_len)
 {
 	uint32_t str_len;
 	uint8_t	 prot_disc, callRefFlag;

libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_cli.c

@@ -1589,7 +1589,7 @@ static ftdm_status_t handle_tx_cgb(ftdm_stream_handle_t *stream, int span, int c
 				sigev.span_id = ftdmchan->span_id;
 				sigev.channel = ftdmchan;
 				sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-				sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+				sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 				ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 				/* if this is the first channel in the range */
@@ -1689,7 +1689,7 @@ static ftdm_status_t handle_tx_cgu(ftdm_stream_handle_t *stream, int span, int c
 				sigev.span_id = ftdmchan->span_id;
 				sigev.channel = ftdmchan;
 				sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-				sigev.sigstatus = FTDM_SIG_STATE_UP;
+				sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 				ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 				/* if this is the first channel in the range */

libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_handle.c

@@ -2004,7 +2004,7 @@ ftdm_status_t handle_cgb_req(uint32_t suInstId, uint32_t spInstId, uint32_t circ
 
 		/* bring the sig status down */
 		sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-		sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+		sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 		ftdm_span_send_signal(ftdmchan->span, &sigev);
 
 		/* unlock the channel again before we exit */
@@ -2135,7 +2135,7 @@ ftdm_status_t handle_cgu_req(uint32_t suInstId, uint32_t spInstId, uint32_t circ
 
 		/* bring the sig status down */
 		sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-		sigev.sigstatus = FTDM_SIG_STATE_UP;
+		sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 		ftdm_span_send_signal(ftdmchan->span, &sigev);
 	
 		/* unlock the channel again before we exit */

libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.c

@@ -841,7 +841,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 						SS7_DEBUG_CHAN(ftdmchan,"All reset flags cleared %s\n", "");
 						/* all flags are down so we can bring up the sig status */
 						sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-						sigev.sigstatus = FTDM_SIG_STATE_UP;
+						sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 						ftdm_span_send_signal (ftdmchan->span, &sigev);
 					} /* if (!ftdm_test_flag (ftdmchan, FTDM_CHANNEL_SIG_UP)) */
 				} /* if !blocked */
@@ -949,7 +949,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 		/* if the sig_status is up...bring it down */
 		if (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_SIG_UP)) {
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 			ftdm_span_send_signal (ftdmchan->span, &sigev);
 		}
 
@@ -1033,7 +1033,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 				/* bring the sig status back up */
 				sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-				sigev.sigstatus = FTDM_SIG_STATE_UP;
+				sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 				ftdm_span_send_signal(ftdmchan->span, &sigev);
 			}
 
@@ -1046,7 +1046,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the sig status down */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 			ftdm_span_send_signal(ftdmchan->span, &sigev);
 
 			/* go back to the last state */
@@ -1058,7 +1058,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the sig status down */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 			ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 			/* send a BLA */
@@ -1076,7 +1076,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the sig status up */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_UP;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 			ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 			/* send a uba */
@@ -1092,7 +1092,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the sig status down */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 			ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 			/* send a blo */
@@ -1110,7 +1110,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the sig status up */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_UP;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
 			ftdm_span_send_signal(ftdmchan->span, &sigev); 
 
 			/* send a ubl */
@@ -1149,7 +1149,7 @@ void ftdm_sangoma_ss7_process_state_change (ftdm_channel_t * ftdmchan)
 
 			/* bring the channel signaling status to down */
 			sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
-			sigev.sigstatus = FTDM_SIG_STATE_DOWN;
+			sigev.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
 			ftdm_span_send_signal (ftdmchan->span, &sigev);
 
 			/* remove any reset flags */