Merge branch 'netborder'

Conflicts:
	libs/freetdm/mod_freetdm/mod_freetdm.c
	libs/freetdm/src/ftdm_io.c
	libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2_io_mf_lib.h
	libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c
	libs/freetdm/src/include/freetdm.h
	libs/freetdm/src/include/private/ftdm_core.h

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

@@ -285,10 +285,7 @@ static FIO_SPAN_GET_SIG_STATUS_FUNCTION(isdn_get_span_sig_status)
  */
 static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call)
 {
-	ftdm_status_t status = FTDM_SUCCESS;
-	ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND);
-	ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING);
-	return status;
+	return FTDM_SUCCESS;
 }
 
 /**
@@ -300,7 +297,14 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call)
 #ifdef __TODO__
 static FIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request)
 {
+#if 1 /* FIXME caller_data.raw_data does not exist anymore, see docs/variables.txt for more info */
+	Q931mes_Generic empty_gen;
+	Q931mes_Generic *gen = &empty_gen;
+	
+	memset(&empty_gen, 0, sizeof(empty_gen)) ;
+#else
 	Q931mes_Generic *gen = (Q931mes_Generic *) caller_data->raw_data;
+#endif
 	Q931ie_BearerCap BearerCap;
 	Q931ie_ChanID ChanID = { 0 };
 	Q931ie_CallingNum CallingNum;
@@ -1095,12 +1099,16 @@ static L3INT ftdm_isdn_931_34(void *pvt, struct Q931_Call *call, Q931mes_Generic
 #ifdef __TODO_OR_REMOVE__
 						ftdmchan->caller_data.CRV = gen->CRV;
 #endif
+#if 0 /* FIXME */
 						if (cplen > sizeof(caller_data->raw_data)) {
 							cplen = sizeof(caller_data->raw_data);
 						}
+#endif
 						gen->CRVFlag = !(gen->CRVFlag);
+#if 0 /* FIXME */						
 						memcpy(caller_data->raw_data, msg, cplen);
 						caller_data->raw_data_len = cplen;
+#endif
 						fail = 0;
 					}
 				}
@@ -1298,12 +1306,20 @@ static int ftdm_isdn_921_21(void *pvt, L2UCHAR *msg, L2INT mlen)
 
 static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
 {
-	Q931mes_Generic *gen = (Q931mes_Generic *) ftdmchan->caller_data.raw_data;
 	ftdm_isdn_data_t *isdn_data = ftdmchan->span->signal_data;
 	ftdm_span_t *span = ftdm_channel_get_span(ftdmchan);
 	ftdm_sigmsg_t sig;
 	ftdm_status_t status;
 
+#if 1 /* FIXME caller_data.raw_data does not exist anymore, see docs/variables.txt for more info */
+	Q931mes_Generic empty_gen;
+	Q931mes_Generic *gen = &empty_gen;
+	
+	memset(&empty_gen, 0, sizeof(empty_gen)) ;
+#else
+	Q931mes_Generic *gen = (Q931mes_Generic *) ftdmchan->caller_data.raw_data;
+#endif
+
 	ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n",
 			ftdm_channel_get_span_id(ftdmchan),
 			ftdm_channel_get_id(ftdmchan),
@@ -1431,7 +1447,9 @@ static __inline__ void state_advance(ftdm_channel_t *ftdmchan)
 				gen->MesType = Q931mes_CONNECT;
 				gen->BearerCap = 0;
 				gen->CRVFlag = 1;	/* inbound call */
+#if 0 /* FIXME */
 				Q931Rx43(&isdn_data->q931, gen, ftdmchan->caller_data.raw_data_len);
+#endif
 			}
 		}
 		break;

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

@@ -93,10 +93,7 @@ static FIO_SPAN_GET_SIG_STATUS_FUNCTION(isdn_get_span_sig_status)
  */
 static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call)
 {
-	ftdm_status_t status = FTDM_SUCCESS;
-	ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND);
-	ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING);
-	return status;
+	return FTDM_SUCCESS;
 }
 
 /**

libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.2008.vcproj

@@ -185,6 +185,10 @@
 				RelativePath=".\ftmod_r2.c"
 				>
 			</File>
+			<File
+				RelativePath=".\ftmod_r2_io_mf_lib.c"
+				>
+			</File>
 		</Filter>
 	</Files>
 	<Globals>

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

@@ -47,8 +47,10 @@
 #endif
 #include <stdio.h>
 #include <openr2.h>
-#include "freetdm.h"
-#include "private/ftdm_core.h"
+#include <freetdm.h>
+#include <private/ftdm_core.h>
+
+#include "ftmod_r2_io_mf_lib.h" // ftdm_r2_get_native_channel_mf_generation_iface
 
 /* when the user stops a span, we clear FTDM_R2_SPAN_STARTED, so that the signaling thread
  * knows it must stop, and we wait for FTDM_R2_RUNNING to be clear, which tells us the
@@ -105,6 +107,7 @@ typedef struct ft_r2_conf_s {
 	int charge_calls;
 	int forced_release;
 	int allow_collect_calls;
+	int use_channel_native_mf_generation;
 } ft_r2_conf_t;
 
 /* r2 configuration stored in span->signal_data */
@@ -286,9 +289,6 @@ static ftdm_call_cause_t ftdm_r2_cause_to_ftdm_cause(ftdm_channel_t *fchan, open
 	case OR2_CAUSE_UNSPECIFIED:
 		return FTDM_CAUSE_NORMAL_UNSPECIFIED;
 
-	case OR2_CAUSE_COLLECT_CALL_REJECTED:
-		return FTDM_CAUSE_CALL_REJECTED;
-
 	case OR2_CAUSE_FORCED_RELEASE:
 		return FTDM_CAUSE_NORMAL_CLEARING;
 
@@ -471,12 +471,9 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(r2_outgoing_call)
 		return FTDM_FAIL;
 	}
 
-	ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DIALING);
-
 	ftdm_channel_set_feature(ftdmchan, FTDM_CHANNEL_FEATURE_IO_STATS);
 	ftdm_channel_command(ftdmchan, FTDM_COMMAND_FLUSH_TX_BUFFERS, NULL);
 	ftdm_channel_command(ftdmchan, FTDM_COMMAND_FLUSH_RX_BUFFERS, NULL);
-
 	return FTDM_SUCCESS;
 }
 
@@ -673,13 +670,13 @@ static void ftdm_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, cons
 	ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan);
 	ftdm_r2_data_t *r2data = ftdmchan->span->signal_data;
 
-	ftdm_log_chan(ftdmchan, FTDM_LOG_NOTICE, "Call offered with ANI = %s, DNIS = %s, Category = %d, ANI restricted = %s\n", 
-			ani, dnis, category, ani_restricted ? "Yes" : "No");
+	ftdm_log_chan(ftdmchan, FTDM_LOG_NOTICE, "Call offered with ANI = %s, DNIS = %s, Category = %s, ANI restricted = %s\n", 
+			ani, dnis, openr2_proto_get_category_string(category), ani_restricted ? "Yes" : "No");
 
 	/* check if this is a collect call and if we should accept it */
 	if (!r2data->allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
 		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_NOTICE, "Rejecting collect call\n");
-		openr2_chan_disconnect_call(r2chan, OR2_CAUSE_COLLECT_CALL_REJECTED);
+		openr2_chan_disconnect_call(r2chan, OR2_CAUSE_UNALLOCATED_NUMBER);
 	} else {
 		ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_RING);
 	}
@@ -1447,7 +1444,8 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_r2_configure_span_signaling)
 		/* .double_answer */ -1,
 		/* .charge_calls */ -1,
 		/* .forced_release */ -1,
-		/* .allow_collect_calls */ -1
+		/* .allow_collect_calls */ -1,
+		/* .use_channel_native_mf_generation */ 0
 	};
 
 	ftdm_assert_return(sig_cb != NULL, FTDM_FAIL, "No signaling cb provided\n");
@@ -1566,6 +1564,9 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_r2_configure_span_signaling)
 		} else if (!strcasecmp(var, "max_dnis")) {
 			r2conf.max_dnis = atoi(val);
 			ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %s with max dnis = %d\n", span->name, r2conf.max_dnis);
+		} else if (!strcasecmp(var, "use_channel_native_mf_generation")) {
+			r2conf.use_channel_native_mf_generation = ftdm_true(val);
+			ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %s with \"use native channel MF generation\" = %d\n", span->name, r2conf.use_channel_native_mf_generation);
 		} else {
 			snprintf(span->last_error, sizeof(span->last_error), "Unknown R2 parameter [%s]", var);
 			return FTDM_FAIL;
@@ -1617,6 +1618,10 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_r2_configure_span_signaling)
 		openr2_context_configure_from_advanced_file(r2data->r2context, r2conf.advanced_protocol_file);
 	}
 
+	if(r2conf.use_channel_native_mf_generation) {
+		openr2_context_set_mflib_interface(r2data->r2context, ftdm_r2_get_native_channel_mf_generation_iface());
+	}
+
 	spanpvt->r2calls = create_hashtable(FTDM_MAX_CHANNELS_SPAN, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
 	if (!spanpvt->r2calls) {
 		snprintf(span->last_error, sizeof(span->last_error), "Cannot create channel calls hash for span.");
@@ -1634,13 +1639,29 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_r2_configure_span_signaling)
 			openr2_chan_enable_call_files(r2chan);
 		}
 
-		r2call = ftdm_malloc(sizeof(*r2call));
+		if (r2conf.use_channel_native_mf_generation) {
+			/* Allocate a new write handle per r2chan */
+			ftdm_r2_mf_write_handle_t *mf_write_handle = ftdm_calloc(1, sizeof(*mf_write_handle));
+			/* Associate to the FreeTDM channel */
+			mf_write_handle->ftdmchan = span->channels[i];
+			/* Make sure the FreeTDM channel supports MF the generation feature */
+			if (!ftdm_channel_test_feature(mf_write_handle->ftdmchan, FTDM_CHANNEL_FEATURE_MF_GENERATE)) {
+				ftdm_log_chan_msg(mf_write_handle->ftdmchan, FTDM_LOG_ERROR, 
+				"FreeTDM channel does not support native MF generation: "
+				"\"use_channel_native_mf_generation\" configuration parameter cannot"
+				" be used\n");
+				goto fail;
+			}
+			/* Associate the mf_write_handle to the openR2 channel */
+			openr2_chan_set_mflib_handles(r2chan, mf_write_handle, NULL);
+		}
+
+		r2call = ftdm_calloc(1, sizeof(*r2call));
 		if (!r2call) {
 			snprintf(span->last_error, sizeof(span->last_error), "Cannot create all R2 call data structures for the span.");
 			ftdm_safe_free(r2chan);
 			goto fail;
 		}
-		memset(r2call, 0, sizeof(*r2call));
 		openr2_chan_set_logging_func(r2chan, ftdm_r2_on_chan_log);
 		openr2_chan_set_client_data(r2chan, span->channels[i]);
 		r2call->r2chan = r2chan;
@@ -1651,6 +1672,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_r2_configure_span_signaling)
 	}
 	r2data->mf_dump_size = r2conf.mf_dump_size;
 	r2data->category = r2conf.category;
+	r2data->allow_collect_calls = r2conf.allow_collect_calls;
 	r2data->flags = 0;
 	spanpvt->r2context = r2data->r2context;
 
@@ -2370,5 +2392,5 @@ EX_DECLARE_DATA ftdm_module_t ftdm_module = {
  * c-basic-offset:4
  * End:
  * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
  */

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

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2011 Sebastien Trottier
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * 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.
+ *
+ */
+
+#include <freetdm.h>
+#include <private/ftdm_core.h>
+
+#include <openr2.h>
+
+#include "ftmod_r2_io_mf_lib.h"
+
+/* Convert openr2 MF tone enum value to FreeTDM MF tone value 
+    1-15 bitwise OR FTDM_MF_DIRECTION_FORWARD/BACKWARD
+    0 (stop playing)
+   openr2_mf_tone_t defined in r2proto.h
+*/
+static int ftdm_r2_openr2_mf_tone_to_ftdm_mf_tone(openr2_mf_tone_t 
+    openr2_tone_value, int forward_signals) 
+{
+	int tone;
+
+	switch (openr2_tone_value) {
+	case 0: return 0;
+#define TONE_FROM_NAME(name) case OR2_MF_TONE_##name: tone = name; break;
+	TONE_FROM_NAME(1)
+	TONE_FROM_NAME(2)
+	TONE_FROM_NAME(3)
+	TONE_FROM_NAME(4)
+	TONE_FROM_NAME(5)
+	TONE_FROM_NAME(6)
+	TONE_FROM_NAME(7)
+	TONE_FROM_NAME(8)
+	TONE_FROM_NAME(9)
+	TONE_FROM_NAME(10)
+	TONE_FROM_NAME(11)
+	TONE_FROM_NAME(12)
+	TONE_FROM_NAME(13)
+	TONE_FROM_NAME(14)
+	TONE_FROM_NAME(15)
+#undef TONE_FROM_NAME
+	default:
+		ftdm_assert(0, "Invalid openr2_tone_value\n");
+		return -1;
+	}
+
+	/* Add flag corresponding to direction */
+	if (forward_signals) {
+		tone |= FTDM_MF_DIRECTION_FORWARD;
+	} else {
+		tone |= FTDM_MF_DIRECTION_BACKWARD;
+	}
+
+	return tone;
+}
+
+/* MF generation routines (using IO command of a FreeTDM channel)
+   write_init stores the direction of the MF to generate */
+static void *ftdm_r2_io_mf_write_init(ftdm_r2_mf_write_handle_t *handle, int forward_signals)
+{
+	ftdm_log_chan(handle->ftdmchan, FTDM_LOG_DEBUG, "ftdm_r2_io_mf_write_init, "
+	"forward = %d\n", forward_signals);
+
+	handle->fwd = forward_signals;
+	return handle;
+}
+
+static int ftdm_r2_io_mf_generate_tone(ftdm_r2_mf_write_handle_t *handle, int16_t buffer[], int samples)
+{
+	/* Our mf_want_generate implementation always return 0, so mf_generate_tone should never be called */
+	ftdm_assert(0, "ftdm_r2_io_mf_generate_tone not implemented\n");
+	return 0;
+}
+
+/* \brief mf_select_tone starts tone generation or stops current tone
+ * \return 0 on success, -1 on error 
+ */
+static int ftdm_r2_io_mf_select_tone(ftdm_r2_mf_write_handle_t *handle, char signal)
+{
+	int tone; /*  (0, 1-15) (0 meaning to stop playing) */
+
+	ftdm_log_chan(handle->ftdmchan, FTDM_LOG_DEBUG, "ftdm_r2_io_mf_select_tone, "
+			"signal = %c\n", signal);
+
+	if (-1 == (tone = ftdm_r2_openr2_mf_tone_to_ftdm_mf_tone(signal, handle->fwd))) {
+		return -1;
+	}
+
+	/* Start/stop playback directly here, as select tone is called each time a tone 
+	   is started or stopped (called if tone changes, but silence is tone 0, 
+	   triggering a tone change) */
+	if (tone > 0) {
+		ftdm_channel_command(handle->ftdmchan, FTDM_COMMAND_START_MF_PLAYBACK, &tone);
+	} else {
+		/* tone 0 means to stop current tone */
+		ftdm_channel_command(handle->ftdmchan, FTDM_COMMAND_STOP_MF_PLAYBACK, NULL);
+	}
+	return 0;
+}
+
+static int ftdm_r2_io_mf_want_generate(ftdm_r2_mf_write_handle_t *handle, int signal)
+{
+	/* Return 0, meaning mf_generate_tone doesn't need to be called */
+	return 0;
+}
+
+/* MF lib interface that generate MF tones via FreeTDM channel IO commands
+   MF detection using the default openr2 provider (r2engine) */
+static openr2_mflib_interface_t g_mf_ftdm_io_iface = {
+	/* .mf_read_init */ (openr2_mf_read_init_func)openr2_mf_rx_init,
+	/* .mf_write_init */ (openr2_mf_write_init_func)ftdm_r2_io_mf_write_init,
+	/* .mf_detect_tone */ (openr2_mf_detect_tone_func)openr2_mf_rx,
+	/* .mf_generate_tone */ (openr2_mf_generate_tone_func)ftdm_r2_io_mf_generate_tone,
+	/* .mf_select_tone */ (openr2_mf_select_tone_func)ftdm_r2_io_mf_select_tone,
+	/* .mf_want_generate */ (openr2_mf_want_generate_func)ftdm_r2_io_mf_want_generate,
+	/* .mf_read_dispose */ NULL,
+	/* .mf_write_dispose */ NULL
+};
+
+openr2_mflib_interface_t *ftdm_r2_get_native_channel_mf_generation_iface()
+{
+	return &g_mf_ftdm_io_iface;
+}
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4
+ */

libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2_io_mf_lib.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2011 Sebastien Trottier
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * 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.
+ *
+ */
+
+#ifndef _FTMOD_R2_IO_MFLIB_H_
+#define _FTMOD_R2_IO_MFLIB_H_ 
+
+#include <ftdm_declare.h>
+
+#include <openr2.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* MFC/R2 tone generator handle (mf_write_handle) */
+typedef struct {
+	/*! FTDM channel performing the MF generation */
+	ftdm_channel_t *ftdmchan;
+	/*! 1 if generating forward tones, otherwise generating reverse tones. */
+	int fwd;
+} ftdm_r2_mf_write_handle_t;
+
+/* MF lib interface that generate MF tones via FreeTDM channel IO commands
+   MF detection using the default openr2 provider (r2engine) */   
+openr2_mflib_interface_t *ftdm_r2_get_native_channel_mf_generation_iface(void);
+
+#if defined(__cplusplus)
+} /* endif extern "C" */
+#endif
+
+#endif /* endif defined _FTMOD_R2_IO_MFLIB_H_ */
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */

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

@@ -610,9 +610,6 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 	sigev.span_id = ftdmchan->span_id;
 	sigev.channel = ftdmchan;
 
-	/* Acknowledge the state change */
-	ftdm_channel_complete_state(ftdmchan);
-
 #ifdef FTDM_DEBUG_CHAN_MEMORY
 	if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALING) {
 		ftdm_assert(mprotect(ftdmchan, sizeof(*ftdmchan), PROT_READ) == 0, "Failed to mprotect");
@@ -649,8 +646,7 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 			ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending incoming call from %s to %s to FTDM core\n", ftdmchan->caller_data.ani.digits, ftdmchan->caller_data.dnis.digits);
 
 			/* we have enough information to inform FTDM of the call*/
-			sigev.event_id = FTDM_SIGEVENT_START;
-			ftdm_span_send_signal(ftdmchan->span, &sigev);
+			sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_START);
 		}
 		break;
 	case FTDM_CHANNEL_STATE_DIALING: /* outgoing call request */
@@ -674,8 +670,8 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 		{
 			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
 				/*OUTBOUND...so we were told by the line of this so noifiy the user*/
-				sigev.event_id = FTDM_SIGEVENT_PROCEED;
-				ftdm_span_send_signal(ftdmchan->span, &sigev);
+				sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_PROCEED);
+				
 				if (sngisdn_test_flag(sngisdn_info, FLAG_MEDIA_READY)) {
 					ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
 				}
@@ -694,8 +690,8 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 		{
 			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);
+				sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_RINGING);
+				
 				if (sngisdn_test_flag(sngisdn_info, FLAG_MEDIA_READY)) {
 					ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
 				}
@@ -710,8 +706,8 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 			/*check if the channel is inbound or outbound*/
 			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
 				/*OUTBOUND...so we were told by the line of this so noifiy the user*/
-				sigev.event_id = FTDM_SIGEVENT_PROGRESS;
-				ftdm_span_send_signal(ftdmchan->span, &sigev);
+				
+				sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_PROGRESS);
 			} else {
 				/* 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};
@@ -722,8 +718,7 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 	case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
 		{
 			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
-				sigev.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA;
-				ftdm_span_send_signal(ftdmchan->span, &sigev);
+				sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_PROGRESS_MEDIA);
 			} else {
 				/* Send a progress message, indicating: In-band information/pattern available */
 				ftdm_sngisdn_progind_t prog_ind = {SNGISDN_PROGIND_LOC_USER, SNGISDN_PROGIND_DESCR_IB_AVAIL};
@@ -736,8 +731,8 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 			/* check if the channel is inbound or outbound */
 			if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
 				/* OUTBOUND ... so we were told by the line that the other side answered */
-				sigev.event_id = FTDM_SIGEVENT_UP;
-				ftdm_span_send_signal(ftdmchan->span, &sigev);
+				
+				sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_UP);
 
 				if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP &&
 					((sngisdn_span_data_t*)ftdmchan->span->signal_data)->signalling == SNGISDN_SIGNALING_NET) {
@@ -763,8 +758,7 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 	case FTDM_CHANNEL_STATE_TERMINATING: /* call is hung up by the remote end */
 		{
 			/* this state is set when the line is hanging up */
-			sigev.event_id = FTDM_SIGEVENT_STOP;
-			ftdm_span_send_signal(ftdmchan->span, &sigev);
+			sngisdn_send_signal(sngisdn_info, FTDM_SIGEVENT_STOP);
 		}
 		break;
 	case FTDM_CHANNEL_STATE_HANGUP:	/* call is hung up locally */
@@ -878,7 +872,25 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 		}
 		break;
 	}
+
+	/* Acknowledge the state change */
+	ftdm_channel_complete_state(ftdmchan);
 	
+	/* If sngisdn_info->variables is not NULL, it means did not send any
+	* sigevent to the user, therefore we have to free that hashtable */
+	if (sngisdn_info->variables) {
+		hashtable_destroy(sngisdn_info->variables);
+		sngisdn_info->variables = NULL;
+	}
+
+	/* If sngisdn_info->raw_data is not NULL, it means did not send any
+	* sigevent to the user, therefore we have to free that raw data */
+	if (sngisdn_info->raw_data) {
+		ftdm_safe_free(sngisdn_info->raw_data);
+		sngisdn_info->raw_data = NULL;
+		sngisdn_info->raw_data_len = 0;
+	}
+
 	if (ftdmchan->state == initial_state) {
 		ftdm_assert(!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE), "state change flag is still set, but we did not change state\n");
 	}
@@ -890,20 +902,18 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 	return FTDM_SUCCESS;
 }
 
-static FIO_CHANNEL_SEND_MSG_FUNCTION(ftdm_sangoma_isdn_send_msg)
+static FIO_CHANNEL_INDICATE_FUNCTION(ftdm_sangoma_isdn_indicate)
 {
 	ftdm_status_t status = FTDM_FAIL;
 
-	switch (sigmsg->event_id) {
-		case FTDM_SIGEVENT_FACILITY:
+	switch (indication) {
+		case FTDM_CHANNEL_INDICATE_FACILITY:
 			sngisdn_snd_fac_req(ftdmchan);
 			status = FTDM_SUCCESS;
 			break;
 		default:
-			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Unsupported signalling msg requested\n");
-			status = FTDM_BREAK;
-	}
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+			status = FTDM_NOTIMPL;
+	}	
 	return status;
 }
 
@@ -911,34 +921,25 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(ftdm_sangoma_isdn_outgoing_call)
 {
 	sngisdn_chan_data_t  *sngisdn_info = ftdmchan->call_data;
 	ftdm_status_t status = FTDM_FAIL;	
-	
-	switch (ftdmchan->state) {
 
-		case FTDM_CHANNEL_STATE_DOWN:
-			{
-				if (sngisdn_test_flag(sngisdn_info, FLAG_GLARE)) {
-					/* A call came in after we called ftdm_channel_open_chan for this call, but before we got here */
-					ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Glare detected - aborting outgoing call\n");
+	if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN) {
+		if (sngisdn_test_flag(sngisdn_info, FLAG_GLARE)) {
+			/* A call came in after we called ftdm_channel_open_chan for this call, but before we got here */
+			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Glare detected - aborting outgoing call\n");
 
-					sngisdn_set_flag(sngisdn_info, FLAG_LOCAL_ABORT);
-					ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE);
+			sngisdn_set_flag(sngisdn_info, FLAG_LOCAL_ABORT);
+			ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE);
 
-					status = FTDM_BREAK;
-				} else {
-					ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_DIALING);
-					status = FTDM_SUCCESS;
-				}
-			}
-			break;
-		default:
-		{
-			/* the channel is already used...this can't be, end the request */
-			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Outgoing call requested channel in already in use\n");
 			status = FTDM_BREAK;
+		} else {
+			status = FTDM_SUCCESS;
 		}
-		break;
+	} else {
+		/* the channel is already used...this can't be, end the request */
+		ftdm_log_chan(ftdmchan, FTDM_LOG_WARNING, "Outgoing call requested channel in already in use (%s)\n", ftdm_channel_state2str(ftdmchan->state));
+		status = FTDM_BREAK;
 	}
-
+	
 	return status;
 }
 static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(ftdm_sangoma_isdn_get_chan_sig_status)
@@ -1090,7 +1091,7 @@ static FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_isdn_span_config)
 	span->stop = ftdm_sangoma_isdn_stop;
 	span->signal_type = FTDM_SIGTYPE_ISDN;
 	span->outgoing_call = ftdm_sangoma_isdn_outgoing_call;
-	span->send_msg = ftdm_sangoma_isdn_send_msg;
+	span->indicate = ftdm_sangoma_isdn_indicate;
 	span->channel_request = NULL;
 	span->signal_cb	= sig_cb;
 	span->get_channel_sig_status = ftdm_sangoma_isdn_get_chan_sig_status;

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

@@ -181,6 +181,15 @@ typedef struct sngisdn_chan_data {
 	uint8_t                 globalFlg;
 	sngisdn_glare_data_t	glare;
 	ftdm_timer_id_t 		timers[SNGISDN_NUM_TIMERS];
+
+	/* variables saved here will be sent to the user application
+	on next SIGEVENT_XXX */
+	ftdm_hash_t*			variables;
+
+	/* raw_data saved here will be sent to the user application
+	on next SIGEVENT_XXX */
+	void					*raw_data;
+	ftdm_size_t				raw_data_len;
 } sngisdn_chan_data_t;
 
 /* Span specific data */
@@ -416,6 +425,12 @@ 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);
 
+
+ftdm_status_t sngisdn_add_var(sngisdn_chan_data_t *sngisdn_info, const char* var, const char* val);
+ftdm_status_t sngisdn_add_raw_data(sngisdn_chan_data_t *sngisdn_info, uint8_t* data, ftdm_size_t data_len);
+ftdm_status_t sngisdn_clear_data(sngisdn_chan_data_t *sngisdn_info);
+void sngisdn_send_signal(sngisdn_chan_data_t *sngisdn_info, ftdm_signal_event_t event_id);
+				 
 uint8_t sngisdn_get_infoTranCap_from_user(ftdm_bearer_cap_t bearer_capability);
 uint8_t sngisdn_get_usrInfoLyr1Prot_from_user(ftdm_user_layer1_prot_t layer1_prot);
 ftdm_bearer_cap_t sngisdn_get_infoTranCap_from_stack(uint8_t bearer_capability);

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

@@ -160,7 +160,8 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 				}
 			}
 
-			/* this should be in get_facility_ie function, fix this later */
+#if 1
+			/* this section will not be needed once asn decoding function with key-value pairs is implemented */
 			if (signal_data->facility == SNGISDN_OPT_TRUE && conEvnt->facilityStr.eh.pres) {
 				/* Verify whether the Caller Name will come in a subsequent FACILITY message */
 				uint16_t ret_val;
@@ -187,6 +188,7 @@ void sngisdn_process_con_ind (sngisdn_event_data_t *sngisdn_event)
 					strcpy(ftdmchan->caller_data.cid_name, retrieved_str);
 				}
 			}
+#endif
 			
 			if (signal_data->overlap_dial == SNGISDN_OPT_TRUE && !conEvnt->sndCmplt.eh.pres) {
 				ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_COLLECT);

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

@@ -156,8 +156,6 @@ void sngisdn_snd_proceed(ftdm_channel_t *ftdmchan, ftdm_sngisdn_progind_t prog_i
 	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);
 
 	if(sng_isdn_con_status(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &cnStEvnt, MI_CALLPROC, signal_data->dchan_id, sngisdn_info->ces)) {
@@ -189,7 +187,6 @@ void sngisdn_snd_progress(ftdm_channel_t *ftdmchan, ftdm_sngisdn_progind_t prog_
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));	
 	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 PROGRESS (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);
 	if(sng_isdn_con_status(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId,&cnStEvnt, MI_PROGRESS, signal_data->dchan_id, sngisdn_info->ces)) {
@@ -216,7 +213,6 @@ void sngisdn_snd_alert(ftdm_channel_t *ftdmchan, ftdm_sngisdn_progind_t prog_ind
 
 	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 ALERT (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);
 
@@ -241,11 +237,10 @@ void sngisdn_snd_connect(ftdm_channel_t *ftdmchan)
 	}
 	
 	memset(&cnStEvnt, 0, sizeof(cnStEvnt));
-	
+
 	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 CONNECT (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);
 	if (sng_isdn_con_response(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &cnStEvnt, signal_data->dchan_id, sngisdn_info->ces)) {
@@ -272,14 +267,13 @@ void sngisdn_snd_fac_req(ftdm_channel_t *ftdmchan)
 		/* No point in sending a FACILITY message if there is no Facility IE to transmit */
 		return;
 	}
-	ftdm_call_clear_data(&ftdmchan->caller_data);
 	
 	facEvnt.facElmt.eh.pres = PRSNT_NODEF;
 	facEvnt.facElmt.facStr.pres = PRSNT_NODEF;
 	facEvnt.facElmt.facStr.val[0] = 0x1C;
 	facEvnt.facElmt.facStr.val[1] = (uint8_t)facEvnt.facElmt.facStr.len;
 	facEvnt.facElmt.facStr.len +=2; /* Need to include the size of identifier + len */
-	
+
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending FACILITY (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);
 
 	if (sng_isdn_facility_request(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &facEvnt, MI_FACIL, signal_data->dchan_id, sngisdn_info->ces)) {
@@ -306,7 +300,7 @@ void sngisdn_snd_info_req(ftdm_channel_t *ftdmchan)
 	//ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "Sending INFO REQ\n");
 
 
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+	
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending INFO REQ (suId:%d dchan:%d ces:%d)\n", signal_data->cc_id, signal_data->dchan_id, sngisdn_info->ces);
 
@@ -327,8 +321,6 @@ void sngisdn_snd_status_enq(ftdm_channel_t *ftdmchan)
 	//ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "Sending STATUS ENQ\n");
 
 	memset(&staEvnt, 0, sizeof(StaEvnt));
-
-	ftdm_call_clear_data(&ftdmchan->caller_data);
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending Status ENQ on suId:%d suInstId:%u spInstId:%d dchan:%d ces:%d\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, signal_data->dchan_id, sngisdn_info->ces);
 	if (sng_isdn_status_request(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &staEvnt, MI_STATENQ)) {
@@ -367,8 +359,7 @@ void sngisdn_snd_disconnect(ftdm_channel_t *ftdmchan)
 	discEvnt.causeDgn[0].recommend.pres = NOTPRSNT;
 	discEvnt.causeDgn[0].dgnVal.pres = NOTPRSNT;
 
-	set_facility_ie(ftdmchan, &discEvnt.facilityStr);
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+	set_facility_ie(ftdmchan, &discEvnt.facilityStr);	
 
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending DISCONNECT (suId:%d suInstId:%u spInstId:%u)\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId);
 	if (sng_isdn_disc_request(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &discEvnt)) {
@@ -416,7 +407,6 @@ void sngisdn_snd_release(ftdm_channel_t *ftdmchan, uint8_t glare)
 	}
 
 	set_facility_ie(ftdmchan, &relEvnt.facilityStr);
-	ftdm_call_clear_data(&ftdmchan->caller_data);
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending RELEASE/RELEASE COMPLETE (suId:%d suInstId:%u spInstId:%u)\n", signal_data->cc_id, suInstId, spInstId);
 

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

@@ -225,26 +225,26 @@ ftdm_status_t get_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	}
 
 	if (cgPtyNmb->screenInd.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.screen_ind", ftdm_screening2str(cgPtyNmb->screenInd.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.screen_ind", ftdm_screening2str(cgPtyNmb->screenInd.val));
 	}
 
 	if (cgPtyNmb->presInd0.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.presentation_ind", ftdm_presentation2str(cgPtyNmb->presInd0.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.presentation_ind", ftdm_presentation2str(cgPtyNmb->presInd0.val));
 	}
 
 	if (cgPtyNmb->nmbPlanId.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.npi", ftdm_npi2str(cgPtyNmb->nmbPlanId.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.npi", ftdm_npi2str(cgPtyNmb->nmbPlanId.val));
 	}
 		
 	if (cgPtyNmb->typeNmb1.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.ton", ftdm_ton2str(cgPtyNmb->typeNmb1.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.ton", ftdm_ton2str(cgPtyNmb->typeNmb1.val));
 	}
 	
 	if (cgPtyNmb->nmbDigits.pres == PRSNT_NODEF) {
 		char digits_string [32];
 		memcpy(digits_string, (const char*)cgPtyNmb->nmbDigits.val, cgPtyNmb->nmbDigits.len);
 		digits_string[cgPtyNmb->nmbDigits.len] = '\0';
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.digits", digits_string);
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.digits", digits_string);
 	}
 	memcpy(&caller_data->ani, &caller_data->cid_num, sizeof(caller_data->ani));
 	return FTDM_SUCCESS;
@@ -253,6 +253,7 @@ 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_caller_data_t *caller_data = &ftdmchan->caller_data;
+	
 	if (cdPtyNmb->eh.pres != PRSNT_NODEF) {
 		return FTDM_FAIL;
 	}
@@ -343,7 +344,7 @@ ftdm_status_t get_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad)
 		
 	memcpy(subaddress, (char*)cgPtySad->sadInfo.val, cgPtySad->sadInfo.len);
 	subaddress[cgPtySad->sadInfo.len] = '\0';
-	ftdm_call_add_var(&ftdmchan->caller_data, "isdn.calling_subaddr", subaddress);
+	sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.calling_subaddr", subaddress);
 	return FTDM_SUCCESS;
 }
 
@@ -358,21 +359,19 @@ ftdm_status_t get_facility_ie(ftdm_channel_t *ftdmchan, FacilityStr *facilityStr
 
 ftdm_status_t get_facility_ie_str(ftdm_channel_t *ftdmchan, uint8_t *data, uint8_t data_len)
 {
-	ftdm_caller_data_t *caller_data = &ftdmchan->caller_data;
 	sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
 	
 	if (signal_data->facility_ie_decode == SNGISDN_OPT_FALSE) {
-		/* size of facilityStr->facilityStr.len is a uint8_t so no need to check
-		for overflow here as facilityStr->facilityStr.len will always be smaller
-		than sizeof(caller_data->raw_data) */
+		/* Max size of Facility IE is 255 */
+		uint8_t my_data [255];
 		
-		memset(caller_data->raw_data, 0, sizeof(caller_data->raw_data));
 		/* Always include Facility IE identifier + len so this can be used as a sanity check by the user */
-		caller_data->raw_data[0] = SNGISDN_Q931_FACILITY_IE_ID;
-		caller_data->raw_data[1] = data_len;
-	
-		memcpy(&caller_data->raw_data[2], data, data_len);
-		caller_data->raw_data_len = data_len+2;
+		my_data[0] = SNGISDN_Q931_FACILITY_IE_ID;
+		my_data[1] = data_len;
+		memcpy(&my_data[2], data, data_len);
+
+		sngisdn_add_raw_data((sngisdn_chan_data_t*)ftdmchan->call_data, data, data_len+2);
+		
 		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Raw Facility IE copied available\n");
 	} else {
 		/* Call libsng_isdn to process facility IE's here */
@@ -382,7 +381,7 @@ ftdm_status_t get_facility_ie_str(ftdm_channel_t *ftdmchan, uint8_t *data, uint8
 
 ftdm_status_t get_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd)
 {
-	uint8_t val;	
+	uint8_t val;
 	if (!progInd->eh.pres) {
 		return FTDM_FAIL;
 	}
@@ -412,7 +411,7 @@ ftdm_status_t get_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd)
 				val = SNGISDN_PROGIND_DESCR_INVALID;
 				break;
 		}
-		ftdm_call_add_var(&ftdmchan->caller_data, "isdn.prog_ind.descr", ftdm_sngisdn_progind_descr2str(val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.prog_ind.descr", ftdm_sngisdn_progind_descr2str(val));
 	}
 	
 	if (progInd->location.pres) {
@@ -443,7 +442,7 @@ ftdm_status_t get_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd)
 				val = SNGISDN_PROGIND_LOC_INVALID;
 				break;
 		}
-		ftdm_call_add_var(&ftdmchan->caller_data, "isdn.prog_ind.loc", ftdm_sngisdn_progind_loc2str(val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.prog_ind.loc", ftdm_sngisdn_progind_loc2str(val));
 	}	
 	return FTDM_SUCCESS;
 }
@@ -493,7 +492,7 @@ ftdm_status_t set_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	uint8_t len,val;
 	ftdm_caller_data_t *caller_data = &ftdmchan->caller_data;
 	
-	string = ftdm_call_get_var(caller_data, "isdn.cg_pty2.digits");
+	string = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.cg_pty2.digits");
 	if ((string == NULL) || !(*string)) {
 		return FTDM_FAIL;
 	}
@@ -510,7 +509,7 @@ ftdm_status_t set_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	cgPtyNmb->screenInd.pres	= PRSNT_NODEF;
 
 	val = FTDM_SCREENING_INVALID;
-	string = ftdm_call_get_var(caller_data, "isdn.cg_pty2.screening_ind");
+	string = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.cg_pty2.screening_ind");
 	if ((string != NULL) && (*string)) {
 		val = ftdm_str2ftdm_screening(string);
 	}
@@ -527,7 +526,7 @@ ftdm_status_t set_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	cgPtyNmb->presInd0.pres = PRSNT_NODEF;
 	
 	val = FTDM_PRES_INVALID;
-	string = ftdm_call_get_var(caller_data, "isdn.cg_pty2.presentation_ind");
+	string = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.cg_pty2.presentation_ind");
 	if ((string != NULL) && (*string)) {
 		val = ftdm_str2ftdm_presentation(string);
 	}
@@ -542,7 +541,7 @@ ftdm_status_t set_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	cgPtyNmb->nmbPlanId.pres	= PRSNT_NODEF;
 	
 	val = FTDM_NPI_INVALID;
-	string = ftdm_call_get_var(caller_data, "isdn.cg_pty2.npi");
+	string = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.cg_pty2.npi");
 	if ((string != NULL) && (*string)) {
 		val = ftdm_str2ftdm_npi(string);
 	}
@@ -557,7 +556,7 @@ ftdm_status_t set_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 
 	/* Type of Number */
 	val = FTDM_TON_INVALID;
-	string = ftdm_call_get_var(caller_data, "isdn.cg_pty2.ton");
+	string = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.cg_pty2.ton");
 	if ((string != NULL) && (*string)) {
 		val = ftdm_str2ftdm_ton(string);
 	}
@@ -691,7 +690,7 @@ ftdm_status_t set_calling_name(ftdm_channel_t *ftdmchan, ConEvnt *conEvnt)
 ftdm_status_t set_calling_subaddr(ftdm_channel_t *ftdmchan, CgPtySad *cgPtySad)
 {
 	const char* clg_subaddr = NULL;
-	clg_subaddr = ftdm_call_get_var(&ftdmchan->caller_data, "isdn.calling_subaddr");
+	clg_subaddr = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.calling_subaddr");
 	if ((clg_subaddr != NULL) && (*clg_subaddr)) {
 		unsigned len = strlen (clg_subaddr);
 		cgPtySad->eh.pres = PRSNT_NODEF;
@@ -721,14 +720,19 @@ 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)
 {
-	int len;
-	ftdm_caller_data_t *caller_data = &ftdmchan->caller_data;
-	if (caller_data->raw_data_len > 0 && caller_data->raw_data[0] == SNGISDN_Q931_FACILITY_IE_ID) {
-		len = caller_data->raw_data[1];
-		memcpy(data, &caller_data->raw_data[2], len);
-		*data_len = len;
-		return FTDM_SUCCESS;
-	}	
+	ftdm_size_t len;
+	uint8_t *mydata;
+	void *vdata;
+
+	if (ftdm_usrmsg_get_raw_data(ftdmchan->usrmsg, &vdata, &len) == FTDM_SUCCESS) {
+		mydata = vdata;
+		if (len > 2 && mydata[0] == SNGISDN_Q931_FACILITY_IE_ID) {
+			len = mydata[1];
+			memcpy(data, &mydata[2], len);
+			*data_len = len;
+			return FTDM_SUCCESS;
+		}
+	}
 	return FTDM_FAIL;
 }
 
@@ -738,7 +742,7 @@ ftdm_status_t set_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd, ftdm_s
 	int descr = prog_ind.descr;
 	int loc = prog_ind.loc;
 	
-	str = ftdm_call_get_var(&ftdmchan->caller_data, "isdn.prog_ind.descr");
+	str = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.prog_ind.descr");
 	if (str && *str) {
 		/* User wants to override progress indicator */
 		descr = ftdm_str2ftdm_sngisdn_progind_descr(str);
@@ -749,7 +753,7 @@ ftdm_status_t set_prog_ind_ie(ftdm_channel_t *ftdmchan, ProgInd *progInd, ftdm_s
 		return FTDM_SUCCESS;
 	}
 
-	str = ftdm_call_get_var(&ftdmchan->caller_data, "isdn.prog_ind.loc");
+	str = ftdm_usrmsg_get_var(ftdmchan->usrmsg, "isdn.prog_ind.loc");
 	if (str && *str) {
 		loc = ftdm_str2ftdm_sngisdn_progind_loc(str);
 	}
@@ -869,7 +873,7 @@ ftdm_status_t set_chan_id_ie(ftdm_channel_t *ftdmchan, ChanId *chanId)
 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);
@@ -1202,6 +1206,74 @@ void sngisdn_print_spans(ftdm_stream_handle_t *stream)
 	return;
 }
 
+ftdm_status_t sngisdn_add_var(sngisdn_chan_data_t *sngisdn_info, const char* var, const char* val)
+{
+	char *t_name = 0, *t_val = 0;
+	if (!var || !val) {
+		return FTDM_FAIL;
+	}
+	if (!sngisdn_info->variables) {
+		/* initialize on first use */
+		sngisdn_info->variables = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
+		ftdm_assert_return(sngisdn_info->variables, FTDM_FAIL, "Failed to create hash table\n");
+	}
+	t_name = ftdm_strdup(var);
+	t_val = ftdm_strdup(val);
+	hashtable_insert(sngisdn_info->variables, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
+	return FTDM_SUCCESS;
+}
+
+ftdm_status_t sngisdn_add_raw_data(sngisdn_chan_data_t *sngisdn_info, uint8_t* data, ftdm_size_t data_len)
+{
+	ftdm_assert_return(!sngisdn_info->raw_data, FTDM_FAIL, "Overwriting existing raw data\n");
+	
+	sngisdn_info->raw_data = ftdm_calloc(1, data_len);
+	ftdm_assert_return(sngisdn_info->raw_data, FTDM_FAIL, "Failed to allocate raw data\n");
+
+	memcpy(sngisdn_info->raw_data, data, data_len);
+	sngisdn_info->raw_data_len = data_len;
+	return FTDM_SUCCESS;
+}
+
+void sngisdn_send_signal(sngisdn_chan_data_t *sngisdn_info, ftdm_signal_event_t event_id)
+{
+	ftdm_sigmsg_t sigev;
+	ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
+
+	memset(&sigev, 0, sizeof(sigev));
+
+	sigev.chan_id = ftdmchan->chan_id;
+	sigev.span_id = ftdmchan->span_id;
+	sigev.channel = ftdmchan;
+	sigev.event_id = event_id;
+
+	if (sngisdn_info->variables) {
+		/*
+		* variables now belongs to the ftdm core, and
+		* will be cleared after sigev is processed by user. Set
+		* local pointer to NULL so we do not attempt to
+		* destroy it */
+		sigev.variables = sngisdn_info->variables;
+		sngisdn_info->variables = NULL;
+	}
+
+	if (sngisdn_info->raw_data) {
+		/*
+		* raw_data now belongs to the ftdm core, and
+		* will be cleared after sigev is processed by user. Set
+		* local pointer to NULL so we do not attempt to
+		* destroy it */
+		
+		sigev.raw.data = sngisdn_info->raw_data;
+		sigev.raw.len = sngisdn_info->raw_data_len;
+		
+		sngisdn_info->raw_data = NULL;
+		sngisdn_info->raw_data_len = 0;
+	}
+	ftdm_span_send_signal(ftdmchan->span, &sigev);
+}
+
+
 /* For Emacs:
  * Local Variables:
  * mode:c

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

@@ -139,7 +139,6 @@ void sngisdn_trace_raw_q921(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t d
 	memcpy(raw_data, data, data_len);
 	sigev.raw.data = raw_data;
 	sigev.raw.len = data_len;
-	sigev.raw.autofree = 1;
 	ftdm_span_send_signal(signal_data->ftdm_span, &sigev);
 }
 
@@ -258,7 +257,6 @@ void sngisdn_trace_raw_q931(sngisdn_span_data_t *signal_data, ftdm_trace_dir_t d
 		memcpy(raw_data, data, data_len);
 		sigev.raw.data = raw_data;
 		sigev.raw.len = data_len;
-		sigev.raw.autofree = 1;
 		ftdm_span_send_signal(signal_data->ftdm_span, &sigev);
 	}
 }
@@ -841,7 +839,7 @@ static ftdm_status_t sngisdn_get_frame_info(uint8_t *data, uint32_t data_len, ft
 			uint32_t tmp_len = 0;
 			char tmp[1000];
 			print_hex_dump(tmp, &tmp_len, data, 0, data_len);			
-			ftdm_log(FTDM_LOG_WARNING, "Failed to determine b-channel on SETUP message\n%s\n", tmp);
+			ftdm_log(FTDM_LOG_DEBUG, "Failed to determine b-channel on SETUP message\n%s\n", tmp);
 		}
 	}
 

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

@@ -1272,9 +1272,8 @@ static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(ftdm_sangoma_ss7_outgoing_call)
 	switch (ftdmchan->state){
 	/**************************************************************************/
 	case FTDM_CHANNEL_STATE_DOWN:
-		/* inform the monitor thread that we want to make a call */
-		ftdm_set_state_locked (ftdmchan, FTDM_CHANNEL_STATE_DIALING);
-
+		/* inform the monitor thread that we want to make a call by returning FTDM_SUCCESS */
+	
 		/* unlock the channel */
 		ftdm_mutex_unlock (ftdmchan->mutex);