freetdm:ftmod_sangoma_isdn changes

	Minor fixes to glare testing, add check for INBAND TONES available in ALERT msgs
	Fix for handling T310 expiring
	Minor fixes to glare testing
	Fixed handling for Progress with cause
	Support for facility timeout

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

@@ -189,7 +189,8 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 		ZSD_OUTBOUND,
 		ZSM_UNACCEPTABLE,
 		{FTDM_CHANNEL_STATE_DIALING, FTDM_END},
-		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_DOWN, FTDM_END}
+		{FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS,
+		 FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_CHANNEL_STATE_DOWN, FTDM_END}
 	},
 	{
 		ZSD_OUTBOUND,
@@ -558,6 +559,9 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 				/* We are hangup local call because there was a glare, we are waiting for a
 				RELEASE on this call, before we can process the saved call */
 				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Waiting for RELEASE on hungup glared call\n");
+			} else if (sngisdn_test_flag(sngisdn_info, FLAG_SEND_DISC)) {
+				/* Remote side sent a PROGRESS message, but cause indicates disconnect or T310 expired*/
+				sngisdn_snd_disconnect(ftdmchan);
 			} else {
 				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Hanging up call upon local request!\n");
 
@@ -568,16 +572,15 @@ static void ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdmchan)
 				if (ftdmchan->last_state == FTDM_CHANNEL_STATE_RING ||
 					ftdmchan->last_state == FTDM_CHANNEL_STATE_DIALING) {
 
+					sngisdn_set_flag(sngisdn_info, FLAG_LOCAL_ABORT);
+					sngisdn_snd_release(ftdmchan, 0);
+
 					if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SIG_UP)) {
 						sng_isdn_set_avail_rate(ftdmchan->span, SNGISDN_AVAIL_DOWN);
 					}
-
-					sngisdn_set_flag(sngisdn_info, FLAG_LOCAL_ABORT);
-					sngisdn_snd_release(ftdmchan, 0);
 				} else {
 					sngisdn_snd_disconnect(ftdmchan);
 				}
-				
 			}
 
 			/* now go to the HANGUP complete state */

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

@@ -68,6 +68,7 @@ typedef enum {
 	FLAG_GLARE              = (1 << 6),
 	FLAG_DELAYED_REL        = (1 << 7),
 	FLAG_SENT_PROCEED       = (1 << 8),
+	FLAG_SEND_DISC  		= (1 << 9),
 } sngisdn_flag_t;
 
 
@@ -127,6 +128,13 @@ typedef enum {
 	SNGISDN_EVENT_RST_IND,
 } ftdm_sngisdn_event_id_t;
 
+/* Only timers that can be cancelled are listed here */
+#define SNGISDN_NUM_TIMERS 1
+/* Increase NUM_TIMERS as number of ftdm_sngisdn_timer_t increases */
+typedef enum {
+	SNGISDN_TIMER_FACILITY = 0,
+} ftdm_sngisdn_timer_t;
+
 typedef struct sngisdn_glare_data {
 	int16_t		suId;
     uint32_t	suInstId;
@@ -148,6 +156,7 @@ typedef struct sngisdn_chan_data {
 
 	uint8_t                 globalFlg;
 	sngisdn_glare_data_t	glare;
+	ftdm_timer_t 			*timers[SNGISDN_NUM_TIMERS];
 } sngisdn_chan_data_t;
 
 /* Span specific data */
@@ -165,6 +174,7 @@ typedef struct sngisdn_span_data {
 	uint8_t			overlap_dial;
 	uint8_t			setup_arb;
 	uint8_t			facility;
+	int8_t			facility_timeout;
 	ftdm_sched_t	*sched;
 	ftdm_queue_t 	*event_queue;
 } sngisdn_span_data_t;
@@ -223,8 +233,8 @@ typedef struct sngisdn_cc {
 	ftdm_trunk_type_t	trunktype;
 	uint32_t			last_suInstId;	
 	ftdm_mutex_t		*mutex;
-	sngisdn_chan_data_t	*active_spInstIds[MAX_INSTID];
-	sngisdn_chan_data_t	*active_suInstIds[MAX_INSTID];
+	sngisdn_chan_data_t	*active_spInstIds[MAX_INSTID+1];
+	sngisdn_chan_data_t	*active_suInstIds[MAX_INSTID+1];
 }sngisdn_cc_t;
 
 /* Global sngisdn data */
@@ -349,6 +359,7 @@ void sngisdn_set_span_sig_status(ftdm_span_t *ftdmspan, ftdm_signaling_status_t
 void sngisdn_delayed_release(void* p_sngisdn_info);
 void sngisdn_delayed_connect(void* p_sngisdn_info);
 void sngisdn_delayed_disconnect(void* p_sngisdn_info);
+void sngisdn_facility_timeout(void* p_sngisdn_info);
 
 /* Stack management functions */
 ftdm_status_t sng_isdn_stack_cfg(ftdm_span_t *span);

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

@@ -249,6 +249,11 @@ ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_
 			ftdm_span_set_bearer_capability(val, &span->default_caller_data.bearer_capability);
 		} else if (!strcasecmp(var, "outbound-bearer_layer1")) {
 			ftdm_span_set_bearer_layer1(val, &span->default_caller_data.bearer_layer1);
+		} else if (!strcasecmp(var, "facility-timeout")) {
+			signal_data->facility_timeout = atoi(val);
+			if (signal_data->facility_timeout < 0) {
+				signal_data->facility_timeout = 0;
+			}
 		} 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_stack_hndl.c

@@ -82,7 +82,6 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 
 			/* If this is a glared call that was previously saved, we moved
 			all the info to the current call, so clear the glared saved data */
-
 			if (sngisdn_info->glare.spInstId == spInstId) {
 				clear_call_glare_data(sngisdn_info);
 			}			
@@ -106,6 +105,7 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 				ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_CANCEL);
 				break;
 			}
+
 			/* Fill in call information */
 			cpy_calling_num_from_stack(&ftdmchan->caller_data, &conEvnt->cgPtyNmb);
 			cpy_called_num_from_stack(&ftdmchan->caller_data, &conEvnt->cdPtyNmb);
@@ -142,6 +142,10 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 					if (ret_val == 1) {
 						ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Expecting Caller name in FACILITY\n");
 						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_GET_CALLERID);
+						/* Launch timer in case we never get a FACILITY msg */
+						if (signal_data->facility_timeout) {
+							ftdm_sched_timer(signal_data->sched, "facility_timeout", signal_data->facility_timeout, sngisdn_facility_timeout, (void*) sngisdn_info, &sngisdn_info->timers[SNGISDN_TIMER_FACILITY]);
+						}
 						break;
 					} else if (ret_val == 0) {
 						strcpy(ftdmchan->caller_data.cid_name, retrieved_str);
@@ -289,6 +293,8 @@ void sngisdn_process_cnst_ind (sngisdn_event_data_t *sngisdn_event)
 	sngisdn_chan_data_t *sngisdn_info = sngisdn_event->sngisdn_info;
 	ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
 	
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
+	
 	CnStEvnt *cnStEvnt = &sngisdn_event->event.cnStEvnt;
 
 	ftdm_assert(!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE), "State change flag pending\n");
@@ -302,19 +308,49 @@ void sngisdn_process_cnst_ind (sngisdn_event_data_t *sngisdn_event)
 															suId, suInstId, spInstId, ces);
 	
 	switch(evntType) {
+		case MI_PROGRESS:
+			if (signal_data->switchtype == SNGISDN_SWITCH_NI2 &&
+						 cnStEvnt->causeDgn[0].eh.pres && cnStEvnt->causeDgn[0].causeVal.pres) {
+
+				switch(cnStEvnt->causeDgn[0].causeVal.val) {
+					case 17:	/* User Busy */
+					case 18:	/* No User responding */
+					case 19:	/* User alerting, no answer */
+					case 21:	/* Call rejected, the called party does not with to accept this call */
+					case 27:	/* Destination out of order */
+					case 31:	/* Normal, unspecified */
+					case 34:	/* Circuit/Channel congestion */
+					case 41:	/* Temporary failure */
+					case 42:	/* Switching equipment is experiencing a period of high traffic */
+					case 47:	/* Resource unavailable */
+					case 58:	/* Bearer Capability not available */
+					case 63:	/* Service or option not available */
+					case 65:	/* Bearer Cap not implemented, not supported */
+					case 79:	/* Service or option not implemented, unspecified */
+						ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Cause requires disconnect (cause:%d)\n", cnStEvnt->causeDgn[0].causeVal.val);
+						ftdmchan->caller_data.hangup_cause = cnStEvnt->causeDgn[0].causeVal.val;
+						
+						sngisdn_set_flag(sngisdn_info, FLAG_SEND_DISC);
+						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
+						goto sngisdn_process_cnst_ind_end;
+				}
+			}
+			/* fall-through */
 		case MI_ALERTING:
 		case MI_CALLPROC:
-		case MI_PROGRESS:
+		
 			switch(ftdmchan->state) {
 				case FTDM_CHANNEL_STATE_DIALING:					
-					if (evntType == MI_PROGRESS) {
+					if (evntType == MI_PROGRESS ||
+						(cnStEvnt->progInd.eh.pres && cnStEvnt->progInd.progDesc.val == IN_PD_IBAVAIL)) {
 						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
 					} else {
 						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
 					}
 					break;
 				case FTDM_CHANNEL_STATE_PROGRESS:
-					if (evntType == MI_PROGRESS) {
+					if (evntType == MI_PROGRESS ||
+						(cnStEvnt->progInd.eh.pres && cnStEvnt->progInd.progDesc.val == IN_PD_IBAVAIL)) {
 						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
 					}
 					break;
@@ -371,6 +407,7 @@ void sngisdn_process_cnst_ind (sngisdn_event_data_t *sngisdn_event)
 			break;
 	}
 
+sngisdn_process_cnst_ind_end:
 	ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
 	return;
 }
@@ -638,12 +675,14 @@ void sngisdn_process_flc_ind (sngisdn_event_data_t *sngisdn_event)
 void sngisdn_process_fac_ind (sngisdn_event_data_t *sngisdn_event)
 {
 	ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
+
 	int16_t suId = sngisdn_event->suId;
 	uint32_t suInstId = sngisdn_event->suInstId;
 	uint32_t spInstId = sngisdn_event->spInstId;
 
 	sngisdn_chan_data_t *sngisdn_info = sngisdn_event->sngisdn_info;
 	ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
 
 	FacEvnt *facEvnt = &sngisdn_event->event.facEvnt;
 
@@ -659,10 +698,16 @@ void sngisdn_process_fac_ind (sngisdn_event_data_t *sngisdn_event)
 				if (sng_isdn_retrieve_facility_caller_name(facility_str, facEvnt->facElmt.facStr.len, retrieved_str) != FTDM_SUCCESS) {
 					ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Failed to retrieve Caller Name from Facility IE\n");
 				}
+				/* Cancel facility timeout */
+				ftdm_sched_cancel_timer(signal_data->sched, &sngisdn_info->timers[SNGISDN_TIMER_FACILITY]);
 			}
 
 			ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_RING);
 			break;
+		case FTDM_CHANNEL_STATE_RING:
+			/* We received the caller ID Name in FACILITY, but its too late, facility-timeout already occurred */
+			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "FACILITY received, but we already proceeded with call\n");
+			break;
 		default:
 			/* We do not support other FACILITY types for now, so do nothing */
 			break;
@@ -794,6 +839,14 @@ void sngisdn_process_sta_cfm (sngisdn_event_data_t *sngisdn_event)
 					break;
 			case 3:
 				switch (ftdmchan->state) {
+					case FTDM_CHANNEL_STATE_PROGRESS:
+						/* T310 timer has expired */
+						ftdmchan->caller_data.hangup_cause = staEvnt->causeDgn[0].causeVal.val;
+						ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "T310 Timer expired, hanging up call\n");
+						sngisdn_set_flag(sngisdn_info, FLAG_SEND_DISC);
+						ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
+
+						break;
 					case FTDM_CHANNEL_STATE_UP:
 						/* Remote side is still waiting for our CONNECT message */
 						if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {

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

@@ -74,7 +74,9 @@ void __inline__ clear_call_glare_data(sngisdn_chan_data_t *sngisdn_info)
 										sngisdn_info->suInstId, sngisdn_info->spInstId);
 
 	ftdm_mutex_lock(g_sngisdn_data.ccs[sngisdn_info->glare.suId].mutex);	
+	if (sngisdn_info->glare.spInstId != sngisdn_info->spInstId) {
 		g_sngisdn_data.ccs[sngisdn_info->glare.suId].active_spInstIds[sngisdn_info->glare.spInstId]=NULL;
+	}
 	g_sngisdn_data.ccs[sngisdn_info->glare.suId].active_suInstIds[sngisdn_info->glare.suInstId]=NULL;
 	ftdm_mutex_unlock(g_sngisdn_data.ccs[sngisdn_info->glare.suId].mutex);
 
@@ -427,6 +429,24 @@ void sngisdn_delayed_disconnect(void* p_sngisdn_info)
 	return;
 }
 
+void sngisdn_facility_timeout(void* p_sngisdn_info)
+{
+	sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;
+	ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;	
+
+	ftdm_mutex_lock(ftdmchan->mutex);
+	if (ftdmchan->state == FTDM_CHANNEL_STATE_GET_CALLERID) {
+		ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Facility timeout reached proceeding with call (suId:%d suInstId:%u spInstId:%u)\n",
+					  signal_data->cc_id, sngisdn_info->spInstId, sngisdn_info->suInstId);
+		
+		ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_RING);
+	}
+	
+	ftdm_mutex_unlock(ftdmchan->mutex);
+	return;
+}
+
 ftdm_status_t sngisdn_check_free_ids(void)
 {
 	unsigned i;