Merge remote branch 'fsorig/master'

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

libs/freetdm/src/ftdm_io.c

@@ -2806,7 +2806,7 @@ static ftdm_status_t ftdmchan_activate_dtmf_buffer(ftdm_channel_t *ftdmchan)
 static ftdm_status_t ftdm_insert_dtmf_pause(ftdm_channel_t *ftdmchan, ftdm_size_t pausems)
 {
 	void *data = NULL;
-	unsigned int datalen = pausems * sizeof(uint16_t);
+	ftdm_size_t datalen = pausems * sizeof(uint16_t);
 
 	data = ftdm_malloc(datalen);
 	ftdm_assert(data, "Failed to allocate memory\n");
@@ -3800,7 +3800,6 @@ FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint
 
 FT_DECLARE(ftdm_status_t) ftdm_channel_process_media(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
 {
-	ftdm_status_t status = FTDM_FAIL;
 	fio_codec_t codec_func = NULL;
 	ftdm_size_t max = *datalen;
 
@@ -3822,11 +3821,10 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_process_media(ftdm_channel_t *ftdmchan, v
 		}
 
 		if (codec_func) {
-			status = codec_func(data, max, datalen);
+			codec_func(data, max, datalen);
 		} else {
 			snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!");
 			ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "no codec function to perform transcoding from %d to %d\n", ftdmchan->native_codec, ftdmchan->effective_codec);
-			status = FTDM_FAIL;
 		}
 	}
 
@@ -3861,7 +3859,6 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_process_media(ftdm_channel_t *ftdmchan, v
 				} else {
 					snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!");
 					ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "invalid effective codec %d\n", ftdmchan->effective_codec);
-					status = FTDM_FAIL;
 					goto done;
 				}
 			}

libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c

@@ -401,7 +401,7 @@ static void analog_dial(ftdm_channel_t *ftdmchan, uint32_t *state_counter, uint3
 			ftdmchan->needed_tones[FTDM_TONEMAP_FAIL1] = 1;
 			ftdmchan->needed_tones[FTDM_TONEMAP_FAIL2] = 1;
 			ftdmchan->needed_tones[FTDM_TONEMAP_FAIL3] = 1;
-			*dial_timeout = ((ftdmchan->dtmf_on + ftdmchan->dtmf_off) * strlen(ftdmchan->caller_data.dnis.digits)) + 2000;
+			*dial_timeout = (uint32_t)((ftdmchan->dtmf_on + ftdmchan->dtmf_off) * strlen(ftdmchan->caller_data.dnis.digits)) + 2000;
 		}
 	}
 }
@@ -932,6 +932,7 @@ static void *ftdm_analog_channel_run(ftdm_thread_t *me, void *obj)
 	ftdm_channel_lock(closed_chan);
 
 	if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) {
+		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Going onhook");
 		ftdm_channel_command(ftdmchan, FTDM_COMMAND_ONHOOK, NULL);
 	}
 

libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c

@@ -34,6 +34,10 @@
 #include "private/ftdm_core.h"
 #include "ftmod_libpri.h"
 
+#ifndef MIN
+#define MIN(x,y)	(((x) < (y)) ? (x) : (y))
+#endif
+
 static void _ftdm_channel_set_state_force(ftdm_channel_t *chan, const ftdm_channel_state_t state)
 {
 	assert(chan);
@@ -476,7 +480,7 @@ static ftdm_state_map_t isdn_state_map = {
 			ZSD_INBOUND,
 			ZSM_UNACCEPTABLE,
 			{FTDM_CHANNEL_STATE_DOWN, FTDM_END},
-			{FTDM_CHANNEL_STATE_DIALTONE, FTDM_CHANNEL_STATE_RING, FTDM_END}
+			{FTDM_CHANNEL_STATE_DIALTONE, FTDM_CHANNEL_STATE_COLLECT, FTDM_CHANNEL_STATE_RING, FTDM_END}
 		},
 		{
 			ZSD_INBOUND,
@@ -484,6 +488,12 @@ static ftdm_state_map_t isdn_state_map = {
 			{FTDM_CHANNEL_STATE_DIALTONE, FTDM_END},
 			{FTDM_CHANNEL_STATE_RING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}
 		},
+		{
+			ZSD_INBOUND,
+			ZSM_UNACCEPTABLE,
+			{FTDM_CHANNEL_STATE_COLLECT, FTDM_END},
+			{FTDM_CHANNEL_STATE_RING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}
+		},
 		{
 			ZSD_INBOUND,
 			ZSM_UNACCEPTABLE,
@@ -656,6 +666,29 @@ static ftdm_status_t state_advance(ftdm_channel_t *chan)
 		}
 		break;
 
+	case FTDM_CHANNEL_STATE_COLLECT:	/* Overlap receive */
+		{
+			if (!ftdm_test_flag(chan, FTDM_CHANNEL_OUTBOUND)) {
+				if (!call) {
+					ftdm_log_chan_msg(chan, FTDM_LOG_ERROR, "No call handle\n");
+					ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_RESTART);
+				}
+				else if (pri_need_more_info(isdn_data->spri.pri, call, ftdm_channel_get_id(chan), 0)) {
+					ftdm_caller_data_t *caller_data = ftdm_channel_get_caller_data(chan);
+
+					ftdm_log_chan_msg(chan, FTDM_LOG_ERROR, "Failed to send INFORMATION request\n");
+
+					/* hangup call */
+					caller_data->hangup_cause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER;
+					ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_HANGUP);
+				}
+			} else {
+				ftdm_log_chan_msg(chan, FTDM_LOG_ERROR, "Overlap receiving on outbound call?\n");
+				ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_RESTART);
+			}
+		}
+		break;
+
 	case FTDM_CHANNEL_STATE_RING:
 		{
 			/*
@@ -837,11 +870,57 @@ static __inline__ void check_state(ftdm_span_t *span)
  */
 static int on_info(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent)
 {
-	ftdm_log(FTDM_LOG_DEBUG, "number is: %s\n", pevent->ring.callednum);
+	ftdm_span_t *span = spri->span;
+	ftdm_channel_t *chan = ftdm_span_get_channel(span, pevent->ring.channel);
+	ftdm_caller_data_t *caller_data = NULL;
 
-	if (strlen(pevent->ring.callednum) > 3) {
-		ftdm_log(FTDM_LOG_DEBUG, "final number is: %s\n", pevent->ring.callednum);
-		pri_answer(spri->pri, pevent->ring.call, 0, 1);
+	if (!chan) {
+		ftdm_log(FTDM_LOG_CRIT, "-- Info on channel %d:%d %s but it's not in use?\n", ftdm_span_get_id(span), pevent->ring.channel);
+		return 0;
+	}
+
+	caller_data = ftdm_channel_get_caller_data(chan);
+
+	switch (ftdm_channel_get_state(chan)) {
+	case FTDM_CHANNEL_STATE_COLLECT:	/* TE-mode overlap receiving */
+		ftdm_log_chan(chan, FTDM_LOG_DEBUG, "-- Incoming INFORMATION indication, current called number: '%s', number complete: %s\n",
+			pevent->ring.callednum, pevent->ring.complete ? "yes" : "no");
+
+		/* append digits to dnis */
+		if (!ftdm_strlen_zero(pevent->ring.callednum)) {
+			int digits = strlen(pevent->ring.callednum);
+			int offset = strlen(caller_data->dnis.digits);
+			int len    = MIN(sizeof(caller_data->dnis.digits) - 1 - offset, digits);	/* max. length without terminator */
+
+			if (len < digits) {
+				ftdm_log_chan(chan, FTDM_LOG_WARNING, "Length %d of digit string exceeds available space %d of DNIS, truncating!\n",
+					digits, len);
+			}
+
+			ftdm_copy_string(&caller_data->dnis.digits[offset], (char *)pevent->ring.callednum, len + 1);	/* max. length with terminator */
+			caller_data->dnis.digits[offset + len] = '\0';
+		}
+		if (pevent->ring.complete) {
+			ftdm_log_chan_msg(chan, FTDM_LOG_DEBUG, "Number complete indicated, moving channel to RING state\n");
+			/* notify switch */
+			ftdm_set_state(chan, FTDM_CHANNEL_STATE_RING);
+		}
+		break;
+	case FTDM_CHANNEL_STATE_DIALTONE:	/* NT-mode overlap receiving */
+		ftdm_log_chan(chan, FTDM_LOG_DEBUG, "-- Incoming INFORMATION indication, current called number: '%s'\n",
+			pevent->ring.callednum);
+
+		/* Need to add proper support for overlap receiving in NT-mode (requires FreeSWITCH + FreeTDM core support) */
+		if (strlen(pevent->ring.callednum) > 3) {
+			ftdm_log(FTDM_LOG_DEBUG, "final number is: %s\n", pevent->ring.callednum);
+			pri_answer(spri->pri, pevent->ring.call, 0, 1);
+		}
+		break;
+	default:
+		ftdm_log_chan(chan, FTDM_LOG_ERROR, "-- INFORMATION indication on channel %d:%d in invalid state '%s'\n",
+			ftdm_channel_get_span_id(chan),
+			ftdm_channel_get_id(chan),
+			ftdm_channel_get_state_str(chan));
 	}
 	return 0;
 }
@@ -878,7 +957,15 @@ static int on_hangup(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_even
 		pri_hangup(spri->pri, pevent->hangup.call, pevent->hangup.cause);
 
 		chan->caller_data.hangup_cause = pevent->hangup.cause;
-		ftdm_set_state(chan, FTDM_CHANNEL_STATE_TERMINATING);
+
+		switch (ftdm_channel_get_state(chan)) {
+		case FTDM_CHANNEL_STATE_DIALTONE:
+		case FTDM_CHANNEL_STATE_COLLECT:
+			ftdm_set_state(chan, FTDM_CHANNEL_STATE_HANGUP);
+			break;
+		default:
+			ftdm_set_state(chan, FTDM_CHANNEL_STATE_TERMINATING);
+		}
 		break;
 
 	case LPWRAP_PRI_EVENT_HANGUP_ACK:	/* */
@@ -1112,6 +1199,7 @@ out:
 static int on_ring(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent)
 {
 	ftdm_span_t *span = spri->span;
+	ftdm_libpri_data_t *isdn_data = span->signal_data;
 	ftdm_channel_t *chan = ftdm_span_get_channel(span, pevent->ring.channel);
 	ftdm_caller_data_t *caller_data = NULL;
 	int ret = 0;
@@ -1187,8 +1275,14 @@ static int on_ring(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event
 	/* hurr, this is valid as along as nobody releases the call */
 	chan->call_data = pevent->ring.call;
 
-	ftdm_set_state(chan, FTDM_CHANNEL_STATE_RING);
-
+	/* only go to RING state if we have the complete called number (indicated via pevent->complete flag) */
+	if (!pevent->ring.complete && (isdn_data->overlap & FTMOD_LIBPRI_OVERLAP_RECEIVE)) {
+		ftdm_log(FTDM_LOG_DEBUG, "RING event without complete indicator, waiting for more digits\n");
+		ftdm_set_state(chan, FTDM_CHANNEL_STATE_COLLECT);
+	} else {
+		ftdm_log(FTDM_LOG_DEBUG, "RING event with complete indicator (or overlap receive disabled)\n");
+		ftdm_set_state(chan, FTDM_CHANNEL_STATE_RING);
+	}
 done:
 	ftdm_channel_unlock(chan);
 	return ret;
@@ -1878,6 +1972,25 @@ static int parse_ton(const char *ton)
 	return PRI_UNKNOWN;
 }
 
+/**
+ * \brief Parse overlap string to value
+ * \param	val	String to parse
+ * \return	Overlap flags
+ */
+static int parse_overlap_dial(const char *val)
+{
+	if (!strcasecmp(val, "yes") || !strcasecmp(val, "both"))
+		return FTMOD_LIBPRI_OVERLAP_BOTH;
+	if (!strcasecmp(val, "incoming") || !strcasecmp(val, "receive"))
+		return FTMOD_LIBPRI_OVERLAP_RECEIVE;
+	if (!strcasecmp(val, "outgoing") || !strcasecmp(val, "send"))
+		return FTMOD_LIBPRI_OVERLAP_SEND;
+	if (!strcasecmp(val, "no"))
+		return FTMOD_LIBPRI_OVERLAP_NONE;
+
+	return -1;
+}
+
 /**
  * \brief Parses an option string to flags
  * \param in String to parse for configuration options
@@ -2034,6 +2147,12 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_libpri_configure_span)
 		else if (!strcasecmp(var, "l1") || !strcasecmp(var, "layer1")) {
 			isdn_data->layer1 = parse_layer1(val);
 		}
+		else if (!strcasecmp(var, "overlapdial")) {
+			if ((isdn_data->overlap = parse_overlap_dial(val)) == -1) {
+				ftdm_log(FTDM_LOG_ERROR, "Invalid overlap flag, ignoring parameter\n");
+				isdn_data->overlap = FTMOD_LIBPRI_OVERLAP_NONE;
+			}
+		}
 		else if (!strcasecmp(var, "debug")) {
 			if (parse_debug(val, &isdn_data->debug_mask) == -1) {
 				ftdm_log(FTDM_LOG_ERROR, "Invalid debug flag, ignoring parameter\n");

libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.h

@@ -51,6 +51,12 @@ typedef enum {
 	FTMOD_LIBPRI_RUNNING = (1 << 0)
 } ftdm_isdn_flag_t;
 
+typedef enum {
+	FTMOD_LIBPRI_OVERLAP_NONE    = 0,
+	FTMOD_LIBPRI_OVERLAP_RECEIVE = (1 << 0),
+	FTMOD_LIBPRI_OVERLAP_SEND    = (1 << 1)
+#define FTMOD_LIBPRI_OVERLAP_BOTH	(FTMOD_LIBPRI_OVERLAP_RECEIVE | FTMOD_LIBPRI_OVERLAP_SEND)
+} ftdm_isdn_overlap_t;
 
 struct ftdm_libpri_data {
 	ftdm_channel_t *dchan;
@@ -60,6 +66,7 @@ struct ftdm_libpri_data {
 
 	int mode;
 	int dialect;
+	int overlap;		/*!< Overlap dial flags */
 	unsigned int layer1;
 	unsigned int ton;
 

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

@@ -57,6 +57,7 @@ typedef struct pritap {
 	int32_t flags;
 	struct pri *pri;
 	int debug;
+	uint8_t mixaudio;
 	ftdm_channel_t *dchan;
 	ftdm_span_t *span;
 	ftdm_span_t *peerspan;
@@ -752,6 +753,7 @@ static ftdm_status_t ftdm_pritap_sig_read(ftdm_channel_t *ftdmchan, void *data,
 	ftdm_status_t status;
 	fio_codec_t codec_func;
 	ftdm_channel_t *peerchan = ftdmchan->call_data;
+	pritap_t *pritap = ftdmchan->span->signal_data;
 	int16_t chanbuf[size];
 	int16_t peerbuf[size];
 	int16_t mixedbuf[size];
@@ -762,6 +764,11 @@ static ftdm_status_t ftdm_pritap_sig_read(ftdm_channel_t *ftdmchan, void *data,
 		return FTDM_SUCCESS;
 	}
 
+	if (!pritap->mixaudio) {
+		/* No mixing requested */
+		return FTDM_SUCCESS;
+	}
+
 	if (ftdmchan->native_codec != peerchan->native_codec) {
 		ftdm_log_chan(ftdmchan, FTDM_LOG_CRIT, "Invalid peer channel with format %d, ours = %d\n", 
 				peerchan->native_codec, ftdmchan->native_codec);
@@ -829,6 +836,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_pritap_configure_span)
 	uint32_t i;
 	const char *var, *val;
 	const char *debug = NULL;
+	uint8_t mixaudio = 1;
 	ftdm_channel_t *dchan = NULL;
 	pritap_t *pritap = NULL;
 	ftdm_span_t *peerspan = NULL;
@@ -857,6 +865,8 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_pritap_configure_span)
 
 		if (!strcasecmp(var, "debug")) {
 			debug = val;
+		} else if (!strcasecmp(var, "mixaudio")) {
+			mixaudio = ftdm_true(val);
 		} else if (!strcasecmp(var, "peerspan")) {
 			if (ftdm_span_find_by_name(val, &peerspan) != FTDM_SUCCESS) {
 				ftdm_log(FTDM_LOG_ERROR, "Invalid tapping peer span %s\n", val);
@@ -880,6 +890,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_pritap_configure_span)
 	pritap->debug = parse_debug(debug);
 	pritap->dchan = dchan;
 	pritap->peerspan = peerspan;
+	pritap->mixaudio = mixaudio;
 
 	span->start = ftdm_pritap_start;
 	span->stop = ftdm_pritap_stop;

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

@@ -344,7 +344,6 @@ static void *ftdm_sangoma_isdn_io_run(ftdm_thread_t *me, void *obj)
 	uint8_t data[1000];
 	unsigned i = 0;
 	ftdm_status_t status = FTDM_SUCCESS;
-	ftdm_wait_flag_t wflags = FTDM_READ;
 	ftdm_span_t *span = (ftdm_span_t*) obj;
 	ftdm_size_t len = 0;
 	ftdm_channel_t *ftdmchan = NULL;
@@ -365,7 +364,6 @@ static void *ftdm_sangoma_isdn_io_run(ftdm_thread_t *me, void *obj)
 	while (ftdm_running() && !(ftdm_test_flag(span, FTDM_SPAN_STOP_THREAD))) {
 		len = 1000;
 		waitms = 1000;
-		wflags = FTDM_READ;
 		memset(poll_events, 0, sizeof(short)*span->chan_count);
 
 		poll_events[i] |= FTDM_EVENTS;

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

@@ -460,8 +460,7 @@ ftdm_status_t get_calling_num(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb);
 ftdm_status_t get_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb);
 ftdm_status_t get_called_num(ftdm_channel_t *ftdmchan, CdPtyNmb *cdPtyNmb);
 ftdm_status_t get_redir_num(ftdm_channel_t *ftdmchan, RedirNmb *redirNmb);
-ftdm_status_t get_calling_name_from_display(ftdm_channel_t *ftdmchan, Display *display);
-ftdm_status_t get_calling_name_from_usr_usr(ftdm_channel_t *ftdmchan, UsrUsr *usrUsr);
+ftdm_status_t get_calling_name(ftdm_channel_t *ftdmchan, ConEvnt *conEvnt);
 ftdm_status_t get_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad);
 ftdm_status_t get_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd);
 ftdm_status_t get_facility_ie(ftdm_channel_t *ftdmchan, FacilityStr *facilityStr);

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

@@ -134,11 +134,8 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 			get_calling_subaddr(ftdmchan, &conEvnt->cgPtySad);
 			get_prog_ind_ie(ftdmchan, &conEvnt->progInd);
 			get_facility_ie(ftdmchan, &conEvnt->facilityStr);			
+			get_calling_name(ftdmchan, conEvnt);
 			
-			if (get_calling_name_from_display(ftdmchan, &conEvnt->display) != FTDM_SUCCESS) {
-				get_calling_name_from_usr_usr(ftdmchan, &conEvnt->usrUsr);
-			}
-
 			ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Incoming call: Called No:[%s] Calling No:[%s]\n", ftdmchan->caller_data.dnis.digits, ftdmchan->caller_data.cid_num.digits);
 
 			if (conEvnt->bearCap[0].eh.pres) {

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

@@ -45,6 +45,9 @@ SNGISDN_STR2ENUM(ftdm_str2ftdm_sngisdn_progind_loc, ftdm_sngisdn_progind_loc2str
 
 static uint8_t get_trillium_val(ftdm2trillium_t *vals, uint8_t ftdm_val, uint8_t default_val);
 static uint8_t get_ftdm_val(ftdm2trillium_t *vals, uint8_t trillium_val, uint8_t default_val);
+ftdm_status_t get_calling_name_from_usr_usr(ftdm_channel_t *ftdmchan, UsrUsr *usrUsr);
+ftdm_status_t get_calling_name_from_display(ftdm_channel_t *ftdmchan, Display *display);
+ftdm_status_t get_calling_name_from_ntDisplay(ftdm_channel_t *ftdmchan, NtDisplay *display);
 
 extern ftdm_sngisdn_data_t	g_sngisdn_data;
 
@@ -355,6 +358,20 @@ ftdm_status_t get_calling_name_from_display(ftdm_channel_t *ftdmchan, Display *d
 	return FTDM_SUCCESS;
 }
 
+ftdm_status_t get_calling_name_from_ntDisplay(ftdm_channel_t *ftdmchan, NtDisplay *display)
+{
+	ftdm_caller_data_t *caller_data = &ftdmchan->caller_data;
+	if (display->eh.pres != PRSNT_NODEF) {
+		return FTDM_FAIL;
+	}
+	if (display->dispInfo.pres != PRSNT_NODEF) {
+		return FTDM_FAIL;
+	}
+	
+	ftdm_copy_string(caller_data->cid_name, (const char*)display->dispInfo.val, display->dispInfo.len+1);
+	return FTDM_SUCCESS;
+}
+
 ftdm_status_t get_calling_name_from_usr_usr(ftdm_channel_t *ftdmchan, UsrUsr *usrUsr)
 {
 	ftdm_caller_data_t *caller_data = &ftdmchan->caller_data;
@@ -374,6 +391,24 @@ ftdm_status_t get_calling_name_from_usr_usr(ftdm_channel_t *ftdmchan, UsrUsr *us
 	return FTDM_SUCCESS;
 }
 
+ftdm_status_t get_calling_name(ftdm_channel_t *ftdmchan, ConEvnt *conEvnt)
+{
+	ftdm_status_t status = FTDM_FAIL;
+	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
+	
+	if (signal_data->switchtype == SNGISDN_SWITCH_DMS100) {
+		status = get_calling_name_from_ntDisplay(ftdmchan, &conEvnt->ntDisplay[0]);
+	} else {
+		status = get_calling_name_from_display(ftdmchan, &conEvnt->display);
+
+	}
+	if (status != FTDM_SUCCESS) {
+		status = get_calling_name_from_usr_usr(ftdmchan, &conEvnt->usrUsr);
+	}
+	return status;
+}
+
+
 ftdm_status_t get_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad)
 {
 	char subaddress[100];
@@ -694,12 +729,22 @@ ftdm_status_t set_calling_name(ftdm_channel_t *ftdmchan, ConEvnt *conEvnt)
 			/* follow through */
 		case SNGISDN_SWITCH_5ESS:
 		case SNGISDN_SWITCH_4ESS:
-		case SNGISDN_SWITCH_DMS100:
-			conEvnt->display.eh.pres = PRSNT_NODEF;
 			conEvnt->display.dispInfo.pres = PRSNT_NODEF;
 			conEvnt->display.dispInfo.len = len;
 			memcpy(conEvnt->display.dispInfo.val, caller_data->cid_name, len);
 			break;
+		case SNGISDN_SWITCH_DMS100:
+			conEvnt->ntDisplay[0].eh.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].dispTypeNt.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].dispTypeNt.val = 0x01; /* Calling Party Name */
+			conEvnt->ntDisplay[0].assocInfo.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].assocInfo.val  = 0x03; /* Included */
+			conEvnt->ntDisplay[0].eh.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].eh.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].dispInfo.pres = PRSNT_NODEF;
+			conEvnt->ntDisplay[0].dispInfo.len = len;
+			memcpy(conEvnt->ntDisplay[0].dispInfo.val, caller_data->cid_name, len);
+			break;
 		case SNGISDN_SWITCH_QSIG:
 			/* It seems like QSIG does not support Caller ID Name */
 			break;

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

@@ -114,7 +114,7 @@ void sngisdn_trace_interpreted_q921(sngisdn_span_data_t *signal_data, ftdm_trace
 {
 	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 FRAME %s:\n%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
+	ftdm_log(FTDM_LOG_DEBUG, "[SNGISDN Q921] %s FRAME %s:\n%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
 	ftdm_safe_free(data_str);
 }
 
@@ -221,7 +221,7 @@ void sngisdn_trace_interpreted_q931(sngisdn_span_data_t *signal_data, ftdm_trace
 {
 	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:\n%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
+	ftdm_log(FTDM_LOG_DEBUG, "[SNGISDN Q931] %s FRAME %s:\n%s\n", signal_data->ftdm_span->name, ftdm_trace_dir2str(dir), data_str);
 	ftdm_safe_free(data_str);
 }
 
@@ -586,11 +586,20 @@ uint32_t sngisdn_decode_ie(char *str, uint32_t *str_len, uint8_t current_codeset
 			break;
 		case PROT_Q931_IE_DISPLAY:
 			{
-				uint8_t displayStrOct=2, j;
+				uint8_t j;
 				char displayStr[82];
+				uint8_t displayNtEnabled = 0;
+				uint8_t displayStrOct = 2;
+				uint8_t displayType = 0;
+				uint8_t assocInfo = 0;
+				
 				memset(displayStr, 0, sizeof(displayStr));
 				
 				if(get_bits(OCTET(3),8,8)) {
+					displayType = get_bits(OCTET(3),1,4);
+					assocInfo = get_bits(OCTET(3),5,7);
+
+					displayNtEnabled = 1;
 					displayStrOct++;
 				}
 				j = 0;	
@@ -601,8 +610,15 @@ uint32_t sngisdn_decode_ie(char *str, uint32_t *str_len, uint8_t current_codeset
 					displayStr[j++]=ia5[get_bits(OCTET(displayStrOct),1,4)][get_bits(OCTET(displayStrOct),5,8)];
 				}
 				displayStr[j]='\0';
-				*str_len+= sprintf(&str[*str_len], "%s(l:%d)\n",
-														displayStr, len);
+				if (displayNtEnabled) {
+					*str_len+= sprintf(&str[*str_len], "%s(l:%d) type:%s(%d) info:%s(%d)\n",
+												displayStr, len,
+												get_code_2_str(displayType, dcodQ931DisplayTypeTable), displayType,
+												get_code_2_str(assocInfo, dcodQ931AssocInfoTable), assocInfo);
+				} else {
+					*str_len+= sprintf(&str[*str_len], "%s(l:%d)\n",
+															displayStr, len);
+				}
 			}
 			break;
 		case PROT_Q931_IE_RESTART_IND:

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

@@ -578,5 +578,17 @@ struct code2str dcodQ931TypeOfSubaddressTable[] = {
 	{ -1,   "Invalid"},
 };
 
-#endif /* __FTMOD_SANGOMA_ISDN_TRACE_H__ */
+struct code2str dcodQ931DisplayTypeTable[] = {
+	{ 0x00, "Calling Party Name"},
+	{ 0x01, "Connected Party Name"},
+	{ 0x05, "Original Called Party Name"},
+	{ -1,   "Invalid"},
+};
 
+struct code2str dcodQ931AssocInfoTable[] = {
+	{ 0x00, "Requested"},
+	{ 0x03, "Included"},
+	{ -1,   "Invalid"},
+};
+
+#endif /* __FTMOD_SANGOMA_ISDN_TRACE_H__ */

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

@@ -29,6 +29,11 @@
  * LIABILITY|WHETHER IN CONTRACT|STRICT LIABILITY|OR TORT (INCLUDING
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE|EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contributors: 
+ *
+ * Ricardo Barroetaveña <rbarroetavena@anura.com.ar>
+ *
  */
 
 /* INCLUDE ********************************************************************/

libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.c

@@ -725,7 +725,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_OFFHOOK;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "OFFHOOK Failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "OFFHOOK Failed");
 				return FTDM_FAIL;
 			}
 			ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK);
@@ -735,7 +735,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_ONHOOK;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ONHOOK Failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "ONHOOK Failed");
 				return FTDM_FAIL;
 			}
 			ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK);
@@ -745,7 +745,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_FLASH;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "FLASH Failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "FLASH Failed");
 				return FTDM_FAIL;
 			}
 		}
@@ -754,7 +754,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_WINK;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "WINK Failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "WINK Failed");
 				return FTDM_FAIL;
 			}
 		}
@@ -763,7 +763,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_RING;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring Failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "RING Failed");
 				return FTDM_FAIL;
 			}
 			ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING);
@@ -773,7 +773,7 @@ static FIO_COMMAND_FUNCTION(zt_command)
 		{
 			int command = ZT_RINGOFF;
 			if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) {
-				snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring-off failed");
+				ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "Ring-off Failed");
 				return FTDM_FAIL;
 			}
 			ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING);

libs/freetdm/src/include/freetdm.h

@@ -48,7 +48,7 @@
 #define FTDM_MAX_CHANNELS_PHYSICAL_SPAN 32
 
 /*! \brief Max number of physical spans per logical span */
-#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32
+#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 128
 
 /*! \brief Max number of channels a logical span can contain */
 #define FTDM_MAX_CHANNELS_SPAN FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN
@@ -57,7 +57,7 @@
 #define FTDM_MAX_SPANS_INTERFACE 128
 
 /*! \brief Max number of channels per hunting group */
-#define FTDM_MAX_CHANNELS_GROUP 1024
+#define FTDM_MAX_CHANNELS_GROUP 2048
 
 /*! \brief Max number of groups */
 #define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE