Fix for NFAS when one of the d-channels are down

libs/freetdm/mod_freetdm/mod_freetdm.c

@@ -1917,10 +1917,8 @@ static FIO_SIGNAL_CB_FUNCTION(on_common_signal)
 				return FTDM_FAIL;
 			}
 			if (sigmsg->event_id == FTDM_SIGEVENT_ALARM_CLEAR) {
-				ftdm_log(FTDM_LOG_NOTICE, "Alarm cleared on channel %d:%d\n", spanid, chanid);
 				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-clear");
 			} else {
-				ftdm_log(FTDM_LOG_NOTICE, "Alarm raised on channel %d:%d\n", spanid, chanid);
 				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-trap");
 			}
 		}
@@ -2525,7 +2523,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
 		break;	
 	case FTDM_SIGEVENT_SIGSTATUS_CHANGED:
 		{	
-			ftdm_signaling_status_t sigstatus = sigmsg->ev_data.sigstatus.status;
+			ftdm_signaling_status_t sigstatus = sigmsg->ev_data.sigstatus.status;	
 			switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "%d:%d signalling changed to :%s\n",
 					spanid, chanid, ftdm_signaling_status2str(sigstatus));
 		}

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

@@ -281,8 +281,8 @@ ftdm_state_map_t sangoma_isdn_state_map = {
 static void ftdm_sangoma_isdn_process_phy_events(ftdm_span_t *span, ftdm_oob_event_t event)
 {
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
-	sngisdn_snd_event(signal_data->dchan, event);
-	
+	sngisdn_snd_event(signal_data, event);
+
 	switch (event) {
 		/* Check if the span woke up from power-saving mode */
 		case FTDM_OOB_ALARM_CLEAR:
@@ -354,7 +354,6 @@ static void *ftdm_sangoma_isdn_io_run(ftdm_thread_t *me, void *obj)
 	short *poll_events = ftdm_malloc(sizeof(short) * span->chan_count);
 
 	/* Initialize the d-channel */
-	ftdm_assert(((sngisdn_span_data_t*)span->signal_data)->dchan, "Span does not have a dchannel");
 	chaniter = ftdm_span_get_chan_iterator(span, NULL);
 	if (!chaniter) {
 		ftdm_log(FTDM_LOG_CRIT, "Failed to allocate channel iterator for span %s!\n", span->name);
@@ -1039,21 +1038,11 @@ static ftdm_status_t ftdm_sangoma_isdn_dtmf(ftdm_channel_t *ftdmchan, const char
 	return FTDM_SUCCESS;
 }
 
-static ftdm_status_t ftdm_sangoma_isdn_start(ftdm_span_t *span)
+static ftdm_status_t ftdm_sangoma_isdn_perform_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);
-	
-	ftdm_channel_set_feature(((sngisdn_span_data_t*)span->signal_data)->dchan, FTDM_CHANNEL_FEATURE_IO_STATS);
-	ftdm_channel_open_chan(((sngisdn_span_data_t*)span->signal_data)->dchan);
-	ftdm_sangoma_isdn_dchan_set_queue_size(((sngisdn_span_data_t*)span->signal_data)->dchan);	
-
-	if (sngisdn_stack_start(span) != FTDM_SUCCESS) {
-		ftdm_log(FTDM_LOG_CRIT, "Failed to start span %s\n", span->name);
-		return FTDM_FAIL;
-	}
-
+	ftdm_log(FTDM_LOG_DEBUG, "Actually starting span:%s\n", span->name);
 	/* clear the monitor thread stop flag */
 	ftdm_clear_flag(span, FTDM_SPAN_STOP_THREAD);
 	ftdm_clear_flag(span, FTDM_SPAN_IN_THREAD);
@@ -1085,12 +1074,64 @@ static ftdm_status_t ftdm_sangoma_isdn_start(ftdm_span_t *span)
 	if (signal_data->restart_timeout) {
 		ftdm_log(FTDM_LOG_DEBUG, "%s:Scheduling Restart timeout\n", signal_data->ftdm_span->name);
 		ftdm_sched_timer(signal_data->sched, "restart_timeout", signal_data->restart_timeout,
-							sngisdn_restart_timeout, (void*) signal_data, &signal_data->timers[SNGISDN_SPAN_TIMER_RESTART]);
+						sngisdn_restart_timeout, (void*) signal_data, &signal_data->timers[SNGISDN_SPAN_TIMER_RESTART]);
 	}
+
 	ftdm_log(FTDM_LOG_DEBUG,"Finished starting span %s\n", span->name);
 	return FTDM_SUCCESS;
 }
 
+
+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 (signal_data->dchan) {
+		ftdm_channel_set_feature(signal_data->dchan, FTDM_CHANNEL_FEATURE_IO_STATS);
+		ftdm_channel_open_chan(signal_data->dchan);
+		ftdm_sangoma_isdn_dchan_set_queue_size(signal_data->dchan);
+	}
+
+	if (signal_data->nfas.trunk) {
+		if (signal_data->nfas.trunk->num_spans == signal_data->nfas.trunk->num_spans_configured) {
+			int i;
+			ftdm_log(FTDM_LOG_DEBUG, "Starting span for all spans within trunkgroup:%s\n", signal_data->nfas.trunk->name);
+
+			sngisdn_stack_start(signal_data->nfas.trunk->dchan->ftdm_span);
+			ftdm_sangoma_isdn_perform_start(signal_data->nfas.trunk->dchan->ftdm_span);
+
+			if (signal_data->nfas.trunk->backup) {
+				sngisdn_stack_start(signal_data->nfas.trunk->backup->ftdm_span);
+				ftdm_sangoma_isdn_perform_start(signal_data->nfas.trunk->backup->ftdm_span);
+			}
+			
+			for (i = 0; i < signal_data->nfas.trunk->num_spans; i++) {
+				if (signal_data->nfas.trunk->spans[i] &&
+					signal_data->nfas.trunk->spans[i]->nfas.sigchan == SNGISDN_NFAS_DCHAN_NONE) {
+					sngisdn_stack_start(signal_data->nfas.trunk->spans[i]->ftdm_span);
+					ftdm_sangoma_isdn_perform_start(signal_data->nfas.trunk->spans[i]->ftdm_span);
+				}
+			}
+
+			return FTDM_SUCCESS;
+		} else {
+			ftdm_log(FTDM_LOG_DEBUG, "Delaying span start until all spans within trunkgroup are started: %s\n", signal_data->nfas.trunk->name);
+			return FTDM_SUCCESS;
+		}
+	}
+
+	if (sngisdn_stack_start(span) != FTDM_SUCCESS) {
+		ftdm_log(FTDM_LOG_CRIT, "Failed to start span %s\n", span->name);
+		return FTDM_FAIL;
+	}
+
+	ftdm_sangoma_isdn_perform_start(span);
+	
+	return FTDM_SUCCESS;
+}
+
 static ftdm_status_t ftdm_sangoma_isdn_stop(ftdm_span_t *span)
 {	
 	ftdm_iterator_t *chaniter = NULL;
@@ -1138,13 +1179,13 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_isdn_span_config)
 	ftdm_iterator_t *chaniter = NULL;
 	ftdm_iterator_t *curr = NULL;
 
-	sngisdn_span_data_t *span_data;
+	sngisdn_span_data_t *signal_data;
 	
 	ftdm_log(FTDM_LOG_INFO, "Configuring ftmod_sangoma_isdn span = %s\n", span->name);	
 
-	span_data = ftdm_calloc(1, sizeof(sngisdn_span_data_t));
-	span_data->ftdm_span = span;
-	span->signal_data = span_data;
+	signal_data = ftdm_calloc(1, sizeof(sngisdn_span_data_t));
+	signal_data->ftdm_span = span;
+	span->signal_data = signal_data;
 	
 	chaniter = ftdm_span_get_chan_iterator(span, NULL);
 	for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {
@@ -1160,79 +1201,98 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_isdn_span_config)
 		return FTDM_FAIL;
 	}
 
-	if (sngisdn_stack_cfg(span) != FTDM_SUCCESS) {
+	if (signal_data->nfas.trunk) {
+		if (signal_data->nfas.trunk->num_spans == ++signal_data->nfas.trunk->num_spans_configured) {
+			int i;
+			ftdm_log(FTDM_LOG_DEBUG, "Starting stack configuration for all spans within trunkgroup:%s\n", signal_data->nfas.trunk->name);
+
+			sngisdn_stack_cfg(signal_data->nfas.trunk->dchan->ftdm_span);
+			if (signal_data->nfas.trunk->backup) {
+				sngisdn_stack_cfg(signal_data->nfas.trunk->backup->ftdm_span);
+			}
+			
+			for (i = 0; i < signal_data->nfas.trunk->num_spans; i++) {
+				if (signal_data->nfas.trunk->spans[i] &&
+					signal_data->nfas.trunk->spans[i]->nfas.sigchan == SNGISDN_NFAS_DCHAN_NONE) {
+					sngisdn_stack_cfg(signal_data->nfas.trunk->spans[i]->ftdm_span);
+				}
+			}
+		} else {
+			ftdm_log(FTDM_LOG_DEBUG, "Delaying span stack configuration until all spans within trunkgroup are started:%s\n", signal_data->nfas.trunk->name);
+		}
+	} else if (sngisdn_stack_cfg(span) != FTDM_SUCCESS) {
 		ftdm_log(FTDM_LOG_CRIT, "Sangoma ISDN Stack configuration failed\n");
 		return FTDM_FAIL;
 	}
 
-	if (span_data->cid_name_method == SNGISDN_CID_NAME_AUTO) {
-		switch (span_data->switchtype) {
+	if (signal_data->cid_name_method == SNGISDN_CID_NAME_AUTO) {
+		switch (signal_data->switchtype) {
 			case SNGISDN_SWITCH_EUROISDN:
 				if (FTDM_SPAN_IS_BRI(span)) {
-					span_data->cid_name_method = SNGISDN_CID_NAME_USR_USR_IE;
+					signal_data->cid_name_method = SNGISDN_CID_NAME_USR_USR_IE;
 				} else {
-					span_data->cid_name_method = SNGISDN_CID_NAME_DISPLAY_IE;
+					signal_data->cid_name_method = SNGISDN_CID_NAME_DISPLAY_IE;
 				}
 				break;
 			case SNGISDN_SWITCH_DMS100:
-				span_data->cid_name_method = SNGISDN_CID_NAME_DISPLAY_IE;
+				signal_data->cid_name_method = SNGISDN_CID_NAME_DISPLAY_IE;
 				break;
 			case SNGISDN_SWITCH_NI2:
 			case SNGISDN_SWITCH_5ESS:
 			case SNGISDN_SWITCH_4ESS:
-				span_data->cid_name_method = SNGISDN_CID_NAME_FACILITY_IE;
+				signal_data->cid_name_method = SNGISDN_CID_NAME_FACILITY_IE;
 				break;
 			default:
 				break;
 		}
 	}
 
-	if (span_data->send_cid_name == SNGISDN_OPT_DEFAULT) {
-		switch (span_data->switchtype) {
+	if (signal_data->send_cid_name == SNGISDN_OPT_DEFAULT) {
+		switch (signal_data->switchtype) {
 			case SNGISDN_SWITCH_EUROISDN:
 #ifdef SNGISDN_SUPPORT_CALLING_NAME_IN_FACILITY
 			case SNGISDN_SWITCH_NI2:
 			case SNGISDN_SWITCH_5ESS:
 			case SNGISDN_SWITCH_4ESS:
 #endif
-				if (span_data->signalling == SNGISDN_SIGNALING_NET) {
-					span_data->send_cid_name = SNGISDN_OPT_TRUE;
+				if (signal_data->signalling == SNGISDN_SIGNALING_NET) {
+					signal_data->send_cid_name = SNGISDN_OPT_TRUE;
 				} else {
-					span_data->send_cid_name = SNGISDN_OPT_FALSE;
+					signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 				}
 				break;
 			case SNGISDN_SWITCH_DMS100:
-				span_data->send_cid_name = SNGISDN_OPT_TRUE;
+				signal_data->send_cid_name = SNGISDN_OPT_TRUE;
 				break;
 #ifndef SNGISDN_SUPPORT_CALLING_NAME_IN_FACILITY
 			case SNGISDN_SWITCH_NI2:
 			case SNGISDN_SWITCH_5ESS:
 			case SNGISDN_SWITCH_4ESS:
-				span_data->send_cid_name = SNGISDN_OPT_FALSE;
+				signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 				break;
 #endif
 			default:
-				span_data->send_cid_name = SNGISDN_OPT_FALSE;
+				signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 				break;
 		}
-	} else if (span_data->send_cid_name == SNGISDN_OPT_TRUE) {
-		switch (span_data->switchtype) {
+	} else if (signal_data->send_cid_name == SNGISDN_OPT_TRUE) {
+		switch (signal_data->switchtype) {
 			case SNGISDN_SWITCH_NI2:
 			case SNGISDN_SWITCH_5ESS:
 			case SNGISDN_SWITCH_4ESS:
 #ifndef SNGISDN_SUPPORT_CALLING_NAME_IN_FACILITY
 				ftdm_log(FTDM_LOG_WARNING, "Sending Calling Name in Facility IE not supported, please update your libsng_isdn library\n");
-				span_data->send_cid_name = SNGISDN_OPT_FALSE;
+				signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 #endif
 				break;
 			case SNGISDN_SWITCH_INSNET: /* Don't know how to transmit caller ID name on INSNET */
 			case SNGISDN_SWITCH_QSIG: /* It seems like QSIG does not support Caller ID */
-				span_data->send_cid_name = SNGISDN_OPT_FALSE;
+				signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 				break;
 			case SNGISDN_SWITCH_EUROISDN:
 				break;
 			default:
-				span_data->send_cid_name = SNGISDN_OPT_FALSE;
+				signal_data->send_cid_name = SNGISDN_OPT_FALSE;
 				break;
 		}
 	}

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

@@ -58,7 +58,8 @@
 /* Theoretical limit for MAX_SPANS_PER_NFAS_LINK is 31,
    but set to 8 for now to save some memory */
 
-#define MAX_SPANS_PER_NFAS_LINK	  	8 
+#define MAX_SPANS_PER_NFAS_LINK	  	16
+#define MAX_NFAS_GROUPS				16
 #define NUM_E1_CHANNELS_PER_SPAN 	32
 #define NUM_T1_CHANNELS_PER_SPAN 	24
 #define NUM_BRI_CHANNELS_PER_SPAN	2
@@ -66,6 +67,9 @@
 #define SNGISDN_EVENT_POLL_RATE		100
 #define SNGISDN_NUM_LOCAL_NUMBERS	8
 #define SNGISDN_DCHAN_QUEUE_LEN		200
+#define MAX_NFAS_GROUP_NAME			50
+
+#define NSG
 
 #ifndef MI_NOTIFY
 #define MI_NOTIFY 0x14
@@ -242,16 +246,25 @@ typedef struct sngisdn_chan_data {
 	ftdm_size_t				raw_data_len;
 } sngisdn_chan_data_t;
 
+struct sngisdn_nfas_data;
+typedef struct sngisdn_nfas_data sngisdn_nfas_data_t;
+
+typedef enum {
+	SNGISDN_NFAS_DCHAN_NONE,
+	SNGISDN_NFAS_DCHAN_PRIMARY,
+	SNGISDN_NFAS_DCHAN_BACKUP,
+} sngisdn_nfas_sigchan_t;
+
 /* Span specific data */
 typedef struct sngisdn_span_data {
 	ftdm_span_t		*ftdm_span;
 	ftdm_channel_t	*dchan;
 	uint8_t			link_id;
 	uint8_t 		switchtype;
-	uint8_t			signalling;			/* SNGISDN_SIGNALING_CPE or SNGISDN_SIGNALING_NET */
+	uint8_t			signalling;		/* SNGISDN_SIGNALING_CPE or SNGISDN_SIGNALING_NET */
 	uint8_t 		cc_id;
-	uint8_t 		dchan_id;
-	uint8_t 		span_id;
+	ftdm_signaling_status_t		sigstatus;
+
 	uint8_t			tei;
 	uint8_t			min_digits;
 	uint8_t			trace_flags;		/* TODO change to bit map of sngisdn_tracetype_t */
@@ -274,7 +287,7 @@ typedef struct sngisdn_span_data {
 	uint8_t			restart_timeout;
 	uint8_t			force_sending_complete;
 	uint8_t			cid_name_method;
-	uint8_t			send_cid_name;
+	uint8_t			send_cid_name;	
 
 	int32_t			timer_t301;
 	int32_t			timer_t302;
@@ -292,11 +305,20 @@ typedef struct sngisdn_span_data {
 	int32_t			timer_t318;
 	int32_t			timer_t319;
 	int32_t			timer_t322;
-	
+
 	char*			local_numbers[SNGISDN_NUM_LOCAL_NUMBERS];
 	ftdm_timer_id_t timers[SNGISDN_NUM_SPAN_TIMERS];
 	ftdm_sched_t 	*sched;
 	ftdm_queue_t 	*event_queue;
+
+	struct nfas_info {
+		sngisdn_nfas_data_t *trunk;
+		sngisdn_nfas_sigchan_t sigchan;
+		uint8_t interface_id;
+	} nfas;
+
+	uint32_t num_chans;
+	sngisdn_chan_data_t *channels[NUM_E1_CHANNELS_PER_SPAN];
 } sngisdn_span_data_t;
 
 typedef struct sngisdn_event_data {
@@ -331,19 +353,18 @@ typedef struct sngisdn_event_data {
 	
 } sngisdn_event_data_t;
 
-/* dchan_data can have more than 1 span when running NFAS */
-typedef struct sngisdn_dchan_data {
-	uint8_t 			num_spans;
-	sngisdn_span_data_t	*spans[MAX_L1_LINKS+1];
-	uint16_t			num_chans;
-	/* worst case for number of channel is when using NFAS, and NFAS is only used on T1,
-		so we can use MAX_SPANS_PER_NFAS_LINK*NUM_T1_CHANNELS_PER_SPAN instead of
-		MAX_SPANS_PER_NFAS_LINK*NUM_E1_CHANNELS_PER_SPAN
-	*/
-	/* Never seen NFAS on E1 yet, so use NUM_T1_CHANNELS_PER_SPAN */
-	/* b-channels are arranged by physical id's not logical */
-	sngisdn_chan_data_t *channels[MAX_SPANS_PER_NFAS_LINK*NUM_T1_CHANNELS_PER_SPAN];
-}sngisdn_dchan_data_t;
+struct sngisdn_nfas_data {
+	char name[MAX_NFAS_GROUP_NAME];
+
+	char dchan_span_name[20];
+	sngisdn_span_data_t *dchan;	/* Span that contains primary d-channel */
+
+	char backup_span_name[20];
+	sngisdn_span_data_t *backup; /* Span that contains backup d-channel */
+	uint8_t num_spans;			/* Number of spans within this NFAS */
+	uint8_t num_spans_configured;
+	sngisdn_span_data_t	*spans[MAX_SPANS_PER_NFAS_LINK+1]; //indexed by logical span id
+};
 
 typedef struct sngisdn_cc {
 	/* TODO: use flags instead of config_done and activation_done */
@@ -360,10 +381,10 @@ typedef struct sngisdn_cc {
 /* Global sngisdn data */
 typedef struct ftdm_sngisdn_data {
 	uint8_t	gen_config_done;
-	uint8_t num_cc;						/* 1 ent per switchtype */
-	struct sngisdn_cc ccs[MAX_VARIANTS+1];
-	uint8_t	num_dchan;
-	sngisdn_dchan_data_t dchans[MAX_L1_LINKS+1];
+	uint8_t num_cc;						/* 1 ent per switchtype */	
+	struct sngisdn_cc ccs[MAX_VARIANTS+1];	
+	uint8_t num_nfas;
+	sngisdn_nfas_data_t nfass[MAX_NFAS_GROUPS+1];
 	sngisdn_span_data_t *spans[MAX_L1_LINKS+1]; /* spans are indexed by link_id */
 
 #ifdef SANGOMA_ISDN_CHAN_ID_INVERT_BIT
@@ -424,7 +445,7 @@ 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);
+void sngisdn_snd_event(sngisdn_span_data_t *signal_data, ftdm_oob_event_t event);
 
 /* Inbound Call Control functions */
 void sngisdn_rcv_con_ind(int16_t suId, uint32_t suInstId, uint32_t spInstId, ConEvnt *conEvnt, int16_t dChan, uint8_t ces);
@@ -554,6 +575,7 @@ static __inline__ void sngisdn_set_flag(sngisdn_chan_data_t *sngisdn_info, sngis
 void handle_sng_log(uint8_t level, char *fmt,...);
 void sngisdn_delayed_setup(void* p_sngisdn_info);
 void sngisdn_delayed_release(void* p_sngisdn_info);
+void sngisdn_delayed_release_nfas(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);
@@ -565,6 +587,7 @@ ftdm_status_t sngisdn_stack_cfg(ftdm_span_t *span);
 ftdm_status_t sngisdn_stack_start(ftdm_span_t *span);
 ftdm_status_t sngisdn_stack_stop(ftdm_span_t *span);
 ftdm_status_t sngisdn_wake_up_phy(ftdm_span_t *span);
+sngisdn_span_data_t *sngisdn_dchan(sngisdn_span_data_t *signal_data);
 
 ftdm_status_t sngisdn_show_l1_stats(ftdm_stream_handle_t *stream, ftdm_span_t *span);
 ftdm_status_t sngisdn_show_spans(ftdm_stream_handle_t *stream);

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

@@ -37,6 +37,7 @@
 static ftdm_status_t parse_timer(const char* val, int32_t *target);
 static ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span);
 static ftdm_status_t parse_signalling(const char* signalling, ftdm_span_t *span);
+static ftdm_status_t parse_trunkgroup(const char *_trunkgroup);
 static ftdm_status_t add_local_number(const char* val, ftdm_span_t *span);
 static ftdm_status_t parse_yesno(const char* var, const char* val, uint8_t *target);
 static ftdm_status_t set_switchtype_defaults(ftdm_span_t *span);
@@ -81,7 +82,7 @@ static ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span
 	unsigned i;
 	ftdm_iterator_t *chaniter = NULL;
 	ftdm_iterator_t *curr = NULL;	
-	sngisdn_dchan_data_t *dchan_data;
+	//sngisdn_dchan_data_t *dchan_data;
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
 	
 	switch(span->trunk_type) {
@@ -133,13 +134,15 @@ static ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span
 			ftdm_log(FTDM_LOG_ERROR, "%s:Unsupported trunktype:%s\n", span->name, ftdm_trunk_type2str(span->trunk_type));
 			return FTDM_FAIL;
 	}
+
 	/* see if we have profile with this switch_type already */
-	for (i=1; i <= g_sngisdn_data.num_cc; i++) {
+	for (i = 1; i <= g_sngisdn_data.num_cc; i++) {
 		if (g_sngisdn_data.ccs[i].switchtype == signal_data->switchtype &&
 			g_sngisdn_data.ccs[i].trunktype == span->trunk_type) {
 			break;
 		}
 	}
+
 	/* need to create a new switch_type */
 	if (i > g_sngisdn_data.num_cc) {
 		g_sngisdn_data.num_cc++;
@@ -151,20 +154,9 @@ static ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span
 	/* add this span to its ent_cc */
 	signal_data->cc_id = i;
 
-	/* create a new dchan */ /* for NFAS - no-dchan on b-channels-only links */
-	g_sngisdn_data.num_dchan++;
-	signal_data->dchan_id = g_sngisdn_data.num_dchan;
-
-	dchan_data = &g_sngisdn_data.dchans[signal_data->dchan_id];
-	dchan_data->num_spans++;
-
-	signal_data->span_id = dchan_data->num_spans;
-	dchan_data->spans[signal_data->span_id] = signal_data;
-
 	g_sngisdn_data.spans[signal_data->link_id] = signal_data;
 	
-	ftdm_log(FTDM_LOG_DEBUG, "%s: cc_id:%d dchan_id:%d span_id:%d link_id:%d\n", span->name, signal_data->cc_id, signal_data->dchan_id, signal_data->span_id, signal_data->link_id);
-
+	ftdm_log(FTDM_LOG_DEBUG, "%s: cc_id:%d link_id:%d\n", span->name, signal_data->cc_id, signal_data->link_id);
 	
 	chaniter = ftdm_span_get_chan_iterator(span, NULL);
 	for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {
@@ -175,17 +167,16 @@ static ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span
 			signal_data->dchan = ftdmchan;
 		} else {
 			/* Add the channels to the span */
-			/* NFAS is not supported on E1, so span_id will always be 1 for E1 so this will work for E1 as well */
-			chan_id = ((signal_data->span_id-1)*NUM_T1_CHANNELS_PER_SPAN)+ftdmchan->physical_chan_id;
-			dchan_data->channels[chan_id] = (sngisdn_chan_data_t*)ftdmchan->call_data;
-			dchan_data->num_chans++;
+			chan_id = ftdmchan->physical_chan_id;
+			signal_data->channels[chan_id] = (sngisdn_chan_data_t*)ftdmchan->call_data;
+			signal_data->num_chans++;
 		}
 	}
 	ftdm_iterator_free(chaniter);
 	return FTDM_SUCCESS;
 }
 
-static ftdm_status_t parse_signalling(const char* signalling, ftdm_span_t *span)
+static ftdm_status_t parse_signalling(const char *signalling, ftdm_span_t *span)
 {
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
 	if (!strcasecmp(signalling, "net") ||
@@ -205,6 +196,146 @@ static ftdm_status_t parse_signalling(const char* signalling, ftdm_span_t *span)
 	return FTDM_SUCCESS;
 }
 
+static ftdm_status_t parse_spanmap(const char *_spanmap, ftdm_span_t *span)
+{
+	int i;
+	char *p, *name, *spanmap;
+	uint8_t logical_span_id = 0;
+	ftdm_status_t ret = FTDM_SUCCESS;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
+
+	spanmap = ftdm_strdup(_spanmap);
+
+	p = name = NULL;
+
+	i = 0;
+	for (p = strtok(spanmap, ","); p; p = strtok(NULL, ",")) {
+		while (*p == ' ') {
+			p++;
+		}
+		switch(i++) {
+			case 0:
+				name = ftdm_strdup(p);
+				break;
+			case 1:
+				logical_span_id = atoi(p);
+				break;
+		}
+	}
+
+	if (!name || logical_span_id < 0) {
+		ftdm_log(FTDM_LOG_ERROR, "Invalid spanmap syntax %s\n", _spanmap);
+		ret = FTDM_FAIL;
+		goto done;
+	}
+
+	for (i = 0; i < g_sngisdn_data.num_nfas; i++) {
+		if (!ftdm_strlen_zero(g_sngisdn_data.nfass[i].name) &&
+			!strcasecmp(g_sngisdn_data.nfass[i].name, name)) {
+
+			signal_data->nfas.trunk = &g_sngisdn_data.nfass[i];
+			break;
+		}
+	}
+
+	if (!signal_data->nfas.trunk) {
+		ftdm_log(FTDM_LOG_ERROR, "Could not find trunkgroup with name %s\n", name);
+		ret = FTDM_FAIL;
+		goto done;
+	}
+
+	if (signal_data->nfas.trunk->spans[logical_span_id]) {
+		ftdm_log(FTDM_LOG_ERROR, "trunkgroup:%s already had a span with logical span id:%d\n", name, logical_span_id);
+	} else {
+		signal_data->nfas.trunk->spans[logical_span_id] = signal_data;
+		signal_data->nfas.interface_id = logical_span_id;
+	}
+
+	if (!strcasecmp(signal_data->ftdm_span->name, signal_data->nfas.trunk->dchan_span_name)) {
+
+		signal_data->nfas.sigchan = SNGISDN_NFAS_DCHAN_PRIMARY;
+		signal_data->nfas.trunk->dchan = signal_data;
+	}
+
+	if (!strcasecmp(signal_data->ftdm_span->name, signal_data->nfas.trunk->backup_span_name)) {
+
+		signal_data->nfas.sigchan = SNGISDN_NFAS_DCHAN_BACKUP;
+		signal_data->nfas.trunk->backup = signal_data;
+	}
+
+done:
+	ftdm_safe_free(spanmap);
+	ftdm_safe_free(name);
+	return ret;
+}
+
+static ftdm_status_t parse_trunkgroup(const char *_trunkgroup)
+{
+	int i;
+	char *p, *name, *dchan_span, *backup_span, *trunkgroup;
+	uint8_t num_spans;
+	ftdm_status_t ret = FTDM_SUCCESS;
+
+	trunkgroup =  ftdm_strdup(_trunkgroup);
+
+	p = name = dchan_span = backup_span = NULL;
+
+	/* format: name, num_chans, dchan_span, [backup_span] */
+
+	i = 0;
+	for (p = strtok(trunkgroup, ","); p; p = strtok(NULL, ",")) {
+		while (*p == ' ') {
+			p++;
+		}
+		switch(i++) {
+			case 0:
+				name = ftdm_strdup(p);
+				break;
+			case 1:
+				num_spans = atoi(p);
+				break;
+			case 2:
+				dchan_span = ftdm_strdup(p);
+				break;
+			case 3:
+				backup_span = ftdm_strdup(p);
+		}
+	}
+
+	if (!name || !dchan_span || num_spans <= 0) {
+		ftdm_log(FTDM_LOG_ERROR, "Invalid parameters for trunkgroup:%s\n", _trunkgroup);
+		ret = FTDM_FAIL;
+		goto done;
+	}
+
+	for (i = 0; i < g_sngisdn_data.num_nfas; i++) {
+		if (!ftdm_strlen_zero(g_sngisdn_data.nfass[i].name) &&
+		    !strcasecmp(g_sngisdn_data.nfass[i].name, name)) {
+
+			/* We already configured this trunkgroup */
+			goto done;
+		}
+	}
+
+	/* Trunk group was not found, need to configure it */
+	strncpy(g_sngisdn_data.nfass[i].name, name, sizeof(g_sngisdn_data.nfass[i].name));
+	g_sngisdn_data.nfass[i].num_spans = num_spans;
+	strncpy(g_sngisdn_data.nfass[i].dchan_span_name, dchan_span, sizeof(g_sngisdn_data.nfass[i].dchan_span_name));
+
+	if (backup_span) {
+		strncpy(g_sngisdn_data.nfass[i].backup_span_name, backup_span, sizeof(g_sngisdn_data.nfass[i].backup_span_name));
+	}
+	
+
+	g_sngisdn_data.num_nfas++;
+done:
+	ftdm_safe_free(trunkgroup);
+	ftdm_safe_free(name);
+	ftdm_safe_free(dchan_span);
+	ftdm_safe_free(backup_span);
+	return FTDM_SUCCESS;
+}
+
 static ftdm_status_t parse_early_media(const char* opt, ftdm_span_t *span)
 {
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
@@ -314,6 +445,19 @@ ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_
 	/* Cannot set default bearer_layer1 yet, as we do not know the switchtype */
 	span->default_caller_data.bearer_layer1 = FTDM_INVALID_INT_PARM;
 
+	/* Find out if NFAS is enabled first */
+	for (paramindex = 0; ftdm_parameters[paramindex].var; paramindex++) {
+		ftdm_log(FTDM_LOG_DEBUG, "Sangoma ISDN key=value, %s=%s\n", ftdm_parameters[paramindex].var, ftdm_parameters[paramindex].val);
+		var = ftdm_parameters[paramindex].var;
+		val = ftdm_parameters[paramindex].val;
+
+		if (!strcasecmp(var, "trunkgroup")) {
+			if (parse_trunkgroup(val) != FTDM_SUCCESS) {
+				return FTDM_FAIL;
+			}
+		}
+	}
+
 	for (paramindex = 0; ftdm_parameters[paramindex].var; paramindex++) {
 		ftdm_log(FTDM_LOG_DEBUG, "Sangoma ISDN key=value, %s=%s\n", ftdm_parameters[paramindex].var, ftdm_parameters[paramindex].val);
 		var = ftdm_parameters[paramindex].var;
@@ -331,6 +475,10 @@ ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_
 			if (parse_signalling(val, span) != FTDM_SUCCESS) {
 				return FTDM_FAIL;
 			}
+		} else if (!strcasecmp(var, "spanmap")) {
+			if (parse_spanmap(val, span) != FTDM_SUCCESS) {
+				return FTDM_FAIL;
+			}
 		} else if (!strcasecmp(var, "tei")) {
 			uint8_t tei = atoi(val);
 			if (tei > 127) {
@@ -465,6 +613,8 @@ ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_
 			parse_timer(val, &signal_data->timer_t319);
 		} else if (!strcasecmp(var, "timer-t322")) {
 			parse_timer(val, &signal_data->timer_t322);
+		} else if (!strcasecmp(var, "trunkgroup")) {
+			/* Do nothing, we already parsed this parameter */
 		} 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

@@ -40,6 +40,8 @@ void sngisdn_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status
 void sngisdn_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
 {
 	ftdm_sigmsg_t sig;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)ftdmchan->span->signal_data;
+	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Signalling link status changed to %s\n", ftdm_signaling_status2str(status));
 
 	memset(&sig, 0, sizeof(sig));
@@ -52,7 +54,6 @@ void sngisdn_set_chan_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status
 
 	if (FTDM_SPAN_IS_BRI(ftdmchan->span)) {		
 		sngisdn_chan_data_t		*sngisdn_info = ftdmchan->call_data;
-		sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)ftdmchan->span->signal_data;
 		if (ftdm_test_flag(sngisdn_info, FLAG_ACTIVATING)) {
 			ftdm_clear_flag(sngisdn_info, FLAG_ACTIVATING);
 
@@ -67,6 +68,7 @@ void sngisdn_set_span_sig_status(ftdm_span_t *span, ftdm_signaling_status_t stat
 	ftdm_iterator_t *chaniter = NULL;
 	ftdm_iterator_t *curr = NULL;
 
+	((sngisdn_span_data_t*)span->signal_data)->sigstatus = status;
 
 	chaniter = ftdm_span_get_chan_iterator(span, NULL);
 	for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {

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

@@ -55,10 +55,12 @@ ftdm_status_t sngisdn_stack_start(ftdm_span_t *span)
 {
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
 
-	
-	if (sngisdn_cntrl_q921(span, ABND_ENA, NOTUSED) != FTDM_SUCCESS) {
-		ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack q921\n", span->name);
-		return FTDM_FAIL;
+	if (signal_data->dchan) {		
+		if (sngisdn_cntrl_q921(span, ABND_ENA, NOTUSED) != FTDM_SUCCESS) {
+			ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack q921\n", span->name);
+			return FTDM_FAIL;
+		}
+		ftdm_log(FTDM_LOG_DEBUG, "%s:Stack q921 activated\n", span->name);
 	}
 
 	/* Try to find an alternative for this */
@@ -67,8 +69,7 @@ ftdm_status_t sngisdn_stack_start(ftdm_span_t *span)
 	LdUiDatConReq when activated, and this requires the Mac SAP to be already
 	bound first */
 	ftdm_sleep(500); 
-	
-	ftdm_log(FTDM_LOG_DEBUG, "%s:Stack q921 activated\n", span->name);
+		
 	if (!g_sngisdn_data.ccs[signal_data->cc_id].activation_done) {
 		g_sngisdn_data.ccs[signal_data->cc_id].activation_done = 1;
 		if (sngisdn_activate_cc(span) != FTDM_SUCCESS) {
@@ -78,7 +79,6 @@ ftdm_status_t sngisdn_stack_start(ftdm_span_t *span)
 		ftdm_log(FTDM_LOG_DEBUG, "%s:Stack CC activated\n", span->name);
 	}
 
-	
 	if (sngisdn_cntrl_q931(span, ABND_ENA, SAELMNT) != FTDM_SUCCESS) {
 		ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack q931\n", span->name);
 		return FTDM_FAIL;
@@ -91,7 +91,11 @@ ftdm_status_t sngisdn_stack_start(ftdm_span_t *span)
 
 ftdm_status_t sngisdn_stack_stop(ftdm_span_t *span)
 {
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
 	/* Stop L1 first, so we do not receive any more frames */
+	if (!signal_data->dchan) {
+		return FTDM_SUCCESS;
+	}
 	if (sngisdn_deactivate_phy(span) != FTDM_SUCCESS) {
 		ftdm_log(FTDM_LOG_CRIT, "%s:Failed to deactivate stack phy\n", span->name);
 		return FTDM_FAIL;
@@ -147,7 +151,7 @@ ftdm_status_t sngisdn_deactivate_phy(ftdm_span_t *span)
 	cntrl.t.cntrl.action = AUBND_DIS;
 	cntrl.t.cntrl.subAction = SAELMNT;
 
-	cntrl.t.cntrl.sapId = signal_data->dchan_id;
+	cntrl.t.cntrl.sapId = signal_data->link_id;
 	
 	if (sng_isdn_phy_cntrl(&pst, &cntrl)) {
 		return FTDM_FAIL;
@@ -182,7 +186,7 @@ ftdm_status_t sngisdn_wake_up_phy(ftdm_span_t *span)
 	cntrl.t.cntrl.action = AENA;
 	cntrl.t.cntrl.subAction = SAELMNT;
 
-	cntrl.t.cntrl.sapId = signal_data->dchan_id;
+	cntrl.t.cntrl.sapId = signal_data->link_id;
 	
 	if (sng_isdn_phy_cntrl(&pst, &cntrl)) {
 		return FTDM_FAIL;
@@ -226,33 +230,34 @@ ftdm_status_t sngisdn_activate_cc(ftdm_span_t *span)
 
 ftdm_status_t sngisdn_activate_trace(ftdm_span_t *span, sngisdn_tracetype_t trace_opt)
 {
-	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
+	sngisdn_span_data_t *signal_data = sngisdn_dchan((sngisdn_span_data_t*)span->signal_data);
+
 	switch (trace_opt) {
 		case SNGISDN_TRACE_DISABLE:
 			if (sngisdn_test_trace_flag(signal_data, SNGISDN_TRACE_Q921)) {
-				ftdm_log(FTDM_LOG_INFO, "s%d Disabling q921 trace\n", signal_data->link_id);
+				ftdm_log(FTDM_LOG_INFO, "%s:Disabling q921 trace\n", signal_data->ftdm_span->name);
 				sngisdn_clear_trace_flag(signal_data, SNGISDN_TRACE_Q921);
 				
-				if (sngisdn_cntrl_q921(span, ADISIMM, SATRC) != FTDM_SUCCESS) {
-					ftdm_log(FTDM_LOG_ERROR, "s%d Failed to disable q921 trace\n", signal_data->link_id);
+				if (sngisdn_cntrl_q921(signal_data->ftdm_span, ADISIMM, SATRC) != FTDM_SUCCESS) {
+					ftdm_log(FTDM_LOG_INFO, "%s:Failed to disable q921 trace\n", signal_data->ftdm_span->name);
 				}
 			}
 			if (sngisdn_test_trace_flag(signal_data, SNGISDN_TRACE_Q931)) {
-				ftdm_log(FTDM_LOG_INFO, "s%d Disabling q931 trace\n", signal_data->link_id);
+				ftdm_log(FTDM_LOG_INFO, "%s:Disabling q921 trace\n", signal_data->ftdm_span->name);
 				sngisdn_clear_trace_flag(signal_data, SNGISDN_TRACE_Q931);
 
-				if (sngisdn_cntrl_q931(span, ADISIMM, SATRC) != FTDM_SUCCESS) {
-					ftdm_log(FTDM_LOG_ERROR, "s%d Failed to disable q931 trace\n", signal_data->link_id);
+				if (sngisdn_cntrl_q931(signal_data->ftdm_span, ADISIMM, SATRC) != FTDM_SUCCESS) {
+					ftdm_log(FTDM_LOG_INFO, "%s:Failed to disable q921 trace\n", signal_data->ftdm_span->name);
 				}
 			}
 			break;
 		case SNGISDN_TRACE_Q921:
 			if (!sngisdn_test_trace_flag(signal_data, SNGISDN_TRACE_Q921)) {
-				ftdm_log(FTDM_LOG_INFO, "s%d Enabling q921 trace\n", signal_data->link_id);
+				ftdm_log(FTDM_LOG_INFO, "%s:Enabling q921 trace\n", signal_data->ftdm_span->name);
 				sngisdn_set_trace_flag(signal_data, SNGISDN_TRACE_Q921);
 
-				if (sngisdn_cntrl_q921(span, AENA, SATRC) != FTDM_SUCCESS) {
-					ftdm_log(FTDM_LOG_ERROR, "s%d Failed to enable q921 trace\n", signal_data->link_id);
+				if (sngisdn_cntrl_q921(signal_data->ftdm_span, AENA, SATRC) != FTDM_SUCCESS) {
+					ftdm_log(FTDM_LOG_INFO, "%s:Failed to enable q921 trace\n", signal_data->ftdm_span->name);
 				}
 			}
 			break;
@@ -261,8 +266,8 @@ ftdm_status_t sngisdn_activate_trace(ftdm_span_t *span, sngisdn_tracetype_t trac
 				ftdm_log(FTDM_LOG_INFO, "s%d Enabling q931 trace\n", signal_data->link_id);
 				sngisdn_set_trace_flag(signal_data, SNGISDN_TRACE_Q931);
 				
-				if (sngisdn_cntrl_q931(span, AENA, SATRC) != FTDM_SUCCESS) {
-					ftdm_log(FTDM_LOG_ERROR, "s%d Failed to enable q931 trace\n", signal_data->link_id);
+				if (sngisdn_cntrl_q931(signal_data->ftdm_span, AENA, SATRC) != FTDM_SUCCESS) {
+					ftdm_log(FTDM_LOG_INFO, "%s:Failed to enable q931 trace\n", signal_data->ftdm_span->name);
 				}
 			}
 			break;
@@ -301,7 +306,7 @@ ftdm_status_t sngisdn_cntrl_q931(ftdm_span_t *span, uint8_t action, uint8_t suba
 		cntrl.t.cntrl.trcLen = -1; /* Trace the entire message buffer */
 	}
 
-	cntrl.t.cntrl.sapId = signal_data->dchan_id;
+	cntrl.t.cntrl.sapId = signal_data->link_id;
 	cntrl.t.cntrl.ces = 0;
 
 	if(sng_isdn_q931_cntrl(&pst, &cntrl)) {
@@ -342,11 +347,11 @@ ftdm_status_t sngisdn_cntrl_q921(ftdm_span_t *span, uint8_t action, uint8_t suba
 	cntrl.t.cntrl.subAction    = subaction;
 
 #if (SMBD_LMINT3 || BD_LMINT3)
-	cntrl.t.cntrl.lnkNmb       = signal_data->dchan_id;
+	cntrl.t.cntrl.lnkNmb       = signal_data->link_id;
 	cntrl.t.cntrl.sapi         = NOTUSED;
 	cntrl.t.cntrl.tei          = NOTUSED;
 #else /* _LMINT3 */
-	cntrl.hdr.elmId.elmntInst1 = signal_data->dchan_id;
+	cntrl.hdr.elmId.elmntInst1 = signal_data->link_id;
 	cntrl.hdr.elmId.elmntInst2 = NOTUSED;
 	cntrl.hdr.elmId.elmntInst3 = NOTUSED;
 #endif /* _LMINT3 */

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

@@ -58,6 +58,19 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 		
 	switch (ftdmchan->state) {
 		case FTDM_CHANNEL_STATE_DOWN: /* Proper state to receive a SETUP */
+			if (signal_data->nfas.trunk) {
+				ftdm_alarm_flag_t alarmflag = 0;
+
+				ftdm_channel_get_alarms(ftdmchan, &alarmflag);
+				if (alarmflag) {
+					ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "Received SETUP but channel has physical layer alarm - rejecting\n");
+					
+					ftdmchan->caller_data.hangup_cause = 0x2C; /* Channel requested not available */
+					ftdm_sched_timer(signal_data->sched, "delayed_release", 1, sngisdn_delayed_release, (void*) sngisdn_info, NULL);
+					break;
+				}
+			}
+
 			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE) ||
 				ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
 
@@ -1183,22 +1196,13 @@ void sngisdn_process_rst_cfm (sngisdn_event_data_t *sngisdn_event)
 	uint8_t chan_no = 0;
 	Rst *rstEvnt = &sngisdn_event->event.rstEvnt;	
 	
-	sngisdn_span_data_t	*signal_data = g_sngisdn_data.dchans[dChan].spans[1];
+	sngisdn_span_data_t	*signal_data = g_sngisdn_data.spans[dChan];
 	if (!signal_data) {
 		ftdm_log(FTDM_LOG_CRIT, "Received RESTART CFM on unconfigured span (suId:%d)\n", suId);
 		return;
 	}
 
-	ftdm_log(FTDM_LOG_DEBUG, "%s: Processing RESTART CFM (suId:%u dChan:%d ces:%d %s(%d))\n",
-									signal_data->ftdm_span->name,
-									suId, dChan, ces,
-									(evntType == IN_LNK_DWN)?"LNK_DOWN":
-									(evntType == IN_LNK_UP)?"LNK_UP":
-									(evntType == IN_INDCHAN)?"b-channel":
-									(evntType == IN_LNK_DWN_DM_RLS)?"NFAS service procedures":
-									(evntType == IN_SWCHD_BU_DCHAN)?"NFAS switchover to backup":"Unknown", evntType);
-
-	if (rstEvnt->rstInd.eh.pres == PRSNT_NODEF && rstEvnt->rstInd.rstClass.pres == PRSNT_NODEF) {			
+	if (rstEvnt->rstInd.eh.pres == PRSNT_NODEF && rstEvnt->rstInd.rstClass.pres == PRSNT_NODEF) {
 		switch(rstEvnt->rstInd.rstClass.val) {
 			case IN_CL_INDCHAN: /* Indicated b-channel */
 				if (rstEvnt->chanId.eh.pres) {
@@ -1211,6 +1215,16 @@ void sngisdn_process_rst_cfm (sngisdn_event_data_t *sngisdn_event)
 							chan_no = rstEvnt->chanId.chanNmbSlotMap.val[0];
 						}
 					}
+
+					if (signal_data->nfas.trunk) {
+						if (!rstEvnt->chanId.intIdent.pres) {
+							ftdm_log(FTDM_LOG_CRIT, "Failed to determine interface from RESTART\n");
+							return;
+						} else if (signal_data->nfas.interface_id != rstEvnt->chanId.intIdent.val) {
+							/* This RESTART is for another interface */
+							return;
+						}
+					}
 				}
 				if (!chan_no) {
 					ftdm_log(FTDM_LOG_CRIT, "Failed to determine channel from RESTART\n");
@@ -1273,10 +1287,7 @@ void sngisdn_process_rst_ind (sngisdn_event_data_t *sngisdn_event)
 
 	rstEvnt = &sngisdn_event->event.rstEvnt;
 
-	/* TODO: readjust this when NFAS is implemented as signal_data will not always be the first
-	 * span for that d-channel */
-
-	signal_data = g_sngisdn_data.dchans[dChan].spans[1];
+	signal_data = g_sngisdn_data.spans[dChan];
 
 	if (!signal_data) {
 		ftdm_log(FTDM_LOG_CRIT, "Received RESTART IND on unconfigured span (suId:%d)\n", suId);
@@ -1307,6 +1318,16 @@ void sngisdn_process_rst_ind (sngisdn_event_data_t *sngisdn_event)
 							chan_no = rstEvnt->chanId.chanNmbSlotMap.val[0];
 						}
 					}
+
+					if (signal_data->nfas.trunk) {
+						if (!rstEvnt->chanId.intIdent.pres) {
+							ftdm_log(FTDM_LOG_CRIT, "Failed to determine interface from RESTART\n");
+							return;
+						} else if (signal_data->nfas.interface_id != rstEvnt->chanId.intIdent.val) {
+							/* This RESTART is for another interface */
+							return;
+						}
+					}
 				}
 				if (!chan_no) {
 					ftdm_log(FTDM_LOG_CRIT, "Failed to determine channel from RESTART\n");
@@ -1315,7 +1336,7 @@ void sngisdn_process_rst_ind (sngisdn_event_data_t *sngisdn_event)
 				break;
 			case IN_CL_SNGINT: /* Single interface */
 			case IN_CL_ALLINT: /* All interfaces */
-				/* In case restart class indicates all interfaces, we will duplicate
+				/* In case restart class indicates all interfaces, we will duplicated
 						this event on each span associated to this d-channel in sngisdn_rcv_rst_cfm,
 						so treat it as a single interface anyway */
 				chan_no = 0;

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

@@ -1081,11 +1081,12 @@ ftdm_status_t set_cause_ie(ftdm_channel_t *ftdmchan, CauseDgn *causeDgn)
 
 ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId)
 {
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
 	sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)ftdmchan->call_data;
 	if (!ftdmchan) {
 		return FTDM_SUCCESS;
 	}
-
+	
 	ftdm_set_flag(sngisdn_info, FLAG_SENT_CHAN_ID);
 
 	chanId->eh.pres = PRSNT_NODEF;
@@ -1104,6 +1105,12 @@ ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId)
 		chanId->infoChanSel.pres = PRSNT_NODEF;
 		chanId->infoChanSel.val = ftdmchan->physical_chan_id;
 	} else {
+		if (signal_data->nfas.trunk) {
+			chanId->intIdentPres.val = IN_IIP_EXPLICIT;
+			chanId->intIdent.pres = PRSNT_NODEF;
+			chanId->intIdent.val = signal_data->nfas.interface_id;
+		}
+
 		chanId->intType.pres = PRSNT_NODEF;
 		chanId->intType.val = IN_IT_OTHER;
 		chanId->infoChanSel.pres = PRSNT_NODEF;
@@ -1118,6 +1125,7 @@ ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId)
 		chanId->chanNmbSlotMap.len = 1;
 		chanId->chanNmbSlotMap.val[0] = ftdmchan->physical_chan_id;
 	}
+	
 	return FTDM_SUCCESS;
 }
 
@@ -1237,6 +1245,23 @@ void sngisdn_delayed_setup(void *p_sngisdn_info)
 	return;
 }
 
+void sngisdn_delayed_release_nfas(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);
+	
+	ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending delayed RELEASE (suId:%d suInstId:%u spInstId:%u)\n",
+					signal_data->cc_id, sngisdn_info->spInstId, sngisdn_info->suInstId);
+
+	sngisdn_snd_release(ftdmchan, 0);
+
+	ftdm_mutex_unlock(ftdmchan->mutex);
+	return;
+}
+
 void sngisdn_delayed_release(void *p_sngisdn_info)
 {
 	sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;	
@@ -1433,7 +1458,7 @@ ftdm_status_t sngisdn_show_l1_stats(ftdm_stream_handle_t *stream, ftdm_span_t *s
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
 
 	memset(&sts, 0, sizeof(sts));
-	sng_isdn_phy_stats(signal_data->link_id , &sts);
+	sng_isdn_phy_stats(sngisdn_dchan(signal_data)->link_id , &sts);
 
 	stream->write_function(stream, "\n---------------------------------------------------------------------\n");
 	stream->write_function(stream, "   Span:%s", span->name);
@@ -1568,6 +1593,14 @@ void sngisdn_send_signal(sngisdn_chan_data_t *sngisdn_info, ftdm_signal_event_t
 	ftdm_span_send_signal(ftdmchan->span, &sigev);
 }
 
+sngisdn_span_data_t *sngisdn_dchan(sngisdn_span_data_t *signal_data)
+{
+	if (!signal_data->nfas.trunk) {
+		return signal_data;
+	}
+	return signal_data->nfas.trunk->dchan;
+}
+
 
 /* For Emacs:
  * Local Variables: