diff --git a/libs/freetdm/Makefile.am b/libs/freetdm/Makefile.am
index 4b08dd3d3c..90b52320e0 100644
--- a/libs/freetdm/Makefile.am
+++ b/libs/freetdm/Makefile.am
@@ -76,6 +76,7 @@ libfreetdm_la_SOURCES = \
 	$(SRC)/ftdm_queue.c \
 	$(SRC)/ftdm_sched.c \
 	$(SRC)/ftdm_call_utils.c \
+	$(SRC)/ftdm_variables.c \
 	$(SRC)/ftdm_config.c \
 	$(SRC)/ftdm_callerid.c \
 	$(SRC)/fsk.c \
diff --git a/libs/freetdm/docs/variables.txt b/libs/freetdm/docs/variables.txt
new file mode 100644
index 0000000000..0beecd016c
--- /dev/null
+++ b/libs/freetdm/docs/variables.txt
@@ -0,0 +1,118 @@
+Using FreeTDM Variables
+
+1. User application sending variables or raw buffer to FreeTDM
+==============================================================
+
+The User can include a ftdm_usrmsg_t before sending an event to freetdm.
+
+example #1a - Making an outbound call:
+--------------------------------------
+
+To make an outbound call:
+	ftdm_usrmsg_t usrmsg;
+
+	/* Attach variable to usrmsg */
+	ftdm_usrmsg_add_var(&usrmsg, "isdn.prog_ind.descr", "inband-info-available");
+	
+	ftdm_channel_call_place_ex(ftdmchan, &usrmsg);
+
+example #1b - Adding a variable:
+--------------------------------
+When using ftmod_sangoma_isdn, user want to specify progress indicator inside PROCEED message.
+
+
+	ftdm_usrmsg_t usrmsg;
+
+	/* Attach variable to usrmsg */
+	ftdm_usrmsg_add_var(&usrmsg, "isdn.prog_ind.descr", "inband-info-available");
+	
+	/* Request FreeTDM to send a PROCEED msg */
+	ftdm_channel_call_indicate_ex(ftdmchan, FTDM_CHANNEL_INDICATE_PROCEED, &usrmsg);
+
+
+example #2 - Setting raw data:
+--------------------------------------------------------
+
+When using ftmod_sangoma_isdn, user wants to transmit a custom Facility IE, inside a FACILITY message.
+	
+	ftdm_usrmsg_t usrmsg;
+
+	uint8_t *my_facility_ie = ftdm_calloc(1, 200); /*memory has to be allocated using ftdm_calloc !! */
+	unsigned my_facility_ie_len = 0;
+
+	/* Fill my_facility_ie with custom data here */
+	my_facility_ie[my_facility_ie_len++] = 0x1C; /* Q.931 Facility IE ID */
+	my_facility_ie[my_facility_ie_len++] = 0x03; /* Length of facility IE */
+	my_facility_ie[my_facility_ie_len++] = 0x01;
+	my_facility_ie[my_facility_ie_len++] = 0x02;
+	my_facility_ie[my_facility_ie_len++] = 0x03;
+
+	ftdm_usrmsg_set_raw_data(&usrmsg, my_facility_ie, my_facility_ie_len);
+	
+	ftdm_channel_call_indicate(ftdmchan, FTDM_CHANNEL_INDICATE_FACILITY, &usrmsg);
+
+	/* FreeTDM will automatically free my_facility_ie */
+
+
+2. User application receiving variables and raw buffer from FreeTDM
+==================================================================
+
+example #1 - print all variables received from FreeTDM
+------------------------------------------------------
+
+	/* Inside event call-back function */
+	ftdm_iterator_t *iter = NULL;
+	ftdm_iterator_t *curr = NULL;
+	const char *var_name = NULL;
+	const char *var_value = NULL;
+
+	/* Read all variables attached to this event */
+	iter = ftdm_sigmsg_get_var_iterator(sigmsg, iter);
+	for (curr = iter ; curr; curr = ftdm_iterator_next(curr)) {
+		ftdm_get_current_var(curr, &var_name, &var_value);
+		fprintf("Call Variable: %s=%s\n", var_name, var_value);
+	}
+	ftdm_iterator_free(iter);	
+
+
+example #2 - accessing a specific variable
+------------------------------------------
+
+	/* Inside event call-back function */
+	char *string = NULL;
+	string = ftdm_sigmsg_get_var(sigmsg, "isdn.prog_ind.descr");
+	if (string && *string) {
+		fprintf("Progress indicator:%s\n", string);
+	}
+
+
+example #3a - accessing raw data
+-------------------------------
+
+	/* Inside event call-back function */
+	ftdm_size_t len;
+	uint8_t *mydata;
+	if (ftdm_sigmsg_get_raw_data(sigmsg, (void**)&mydata, &len) == FTDM_SUCCESS) {
+		/* raw data is available, do something with mydata here */
+	}
+	/* Once this function returns, raw data will be free'd inside FreeTDM */
+
+
+example #3b - accessing raw data
+-------------------------------
+
+	/* Inside event call-back function */
+	ftdm_size_t len;
+	uint8_t *mydata;
+	if (ftdm_sigmsg_get_raw_data_detached(sigmsg, (void**)&mydata, &len) == FTDM_SUCCESS) {
+		/* raw data is available, do something with mydata here */
+
+	}
+
+	:
+	:
+	:
+
+	/* User owns raw data and is responsible for free'ing it*/
+	ftdm_safe_free(mydata);
+
diff --git a/libs/freetdm/mod_freetdm/mod_freetdm.c b/libs/freetdm/mod_freetdm/mod_freetdm.c
index ef945cf629..f1675f2ff1 100755
--- a/libs/freetdm/mod_freetdm/mod_freetdm.c
+++ b/libs/freetdm/mod_freetdm/mod_freetdm.c
@@ -874,7 +874,7 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session,
 	default:
 		break;
 	}
-
+	
 	return SWITCH_STATUS_SUCCESS;
 }
 
@@ -1153,6 +1153,9 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 	const char *var;
 	const char *dest_num = NULL, *callerid_num = NULL;
 	ftdm_hunting_scheme_t hunting;
+	ftdm_usrmsg_t usrmsg;
+
+	memset(&usrmsg, 0, sizeof(ftdm_usrmsg_t));
 
 	if (!outbound_profile) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing caller profile\n");
@@ -1343,11 +1346,6 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 	if ((var = channel_get_variable(session, var_event, "freetdm_calling_party_category"))) {
 		ftdm_set_calling_party_category(var, (uint8_t *)&caller_data.cpc);
 	}
-
-	if ((var = channel_get_variable(session, var_event, "freetdm_custom_call_data"))) {
-		ftdm_set_string(caller_data.raw_data, var);
-		caller_data.raw_data_len = (uint32_t)strlen(var);
-	}
 	
 	if (!zstr(dest)) {
 		ftdm_set_string(caller_data.dnis.digits, dest);
@@ -1386,7 +1384,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 			char *v = h->name + FREETDM_VAR_PREFIX_LEN;
 			if (!zstr(v)) {
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Adding outbound freetdm variable %s=%s to channel %d:%d\n", v, h->value, span_id, chan_id);
-				ftdm_call_add_var(&caller_data, v, h->value);
+				ftdm_usrmsg_add_var(&usrmsg, v, h->value);
 			}
 		}
 	}
@@ -1414,7 +1412,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 		hunt_data.tech_pvt = tech_pvt;
 		caller_data.priv = &hunt_data;
 
-		if ((status = ftdm_call_place(&caller_data, &hunting)) != FTDM_SUCCESS) {
+		if ((status = ftdm_call_place_ex(&caller_data, &hunting, &usrmsg)) != FTDM_SUCCESS) {
 			if (tech_pvt->read_codec.implementation) {
 				switch_core_codec_destroy(&tech_pvt->read_codec);
 			}
@@ -1430,7 +1428,6 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi
 			}
             		goto fail;
 		}
-
 		ftdm_channel_init(caller_data.fchan);
 		
 		return SWITCH_CAUSE_SUCCESS;
@@ -1552,6 +1549,8 @@ ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session
 	switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", chanid);
 	switch_channel_set_variable_printf(channel, "freetdm_bearer_capability", "%d", channel_caller_data->bearer_capability);	
 	switch_channel_set_variable_printf(channel, "freetdm_bearer_layer1", "%d", channel_caller_data->bearer_layer1);
+	switch_channel_set_variable_printf(channel, "screening_ind", ftdm_screening2str(channel_caller_data->screen));
+	switch_channel_set_variable_printf(channel, "presentation_ind", ftdm_presentation2str(channel_caller_data->pres));
 	
 	if (globals.sip_headers) {
 		switch_channel_set_variable(channel, "sip_h_X-FreeTDM-SpanName", ftdm_channel_get_span_name(sigmsg->channel));
@@ -1577,28 +1576,17 @@ ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session
 		switch_channel_set_variable_printf(channel, "sip_h_X-FreeTDM-Screen", "%d", channel_caller_data->screen);
 		switch_channel_set_variable_printf(channel, "sip_h_X-FreeTDM-Presentation", "%d", channel_caller_data->pres);
 	}
-	if (channel_caller_data->raw_data_len) {
-		switch_channel_set_variable_printf(channel, "freetdm_custom_call_data", "%s", channel_caller_data->raw_data);
-	}
-	/* Add any channel variable to the dial plan */
-	iter = ftdm_channel_get_var_iterator(sigmsg->channel, NULL);
-	for (curr = iter ; curr; curr = ftdm_iterator_next(curr)) {
-		ftdm_channel_get_current_var(curr, &var_name, &var_value);
-		snprintf(name, sizeof(name), FREETDM_VAR_PREFIX "%s", var_name);
-		switch_channel_set_variable_printf(channel, name, "%s", var_value);
-	}	
 	
 	/* Add any call variable to the dial plan */
-	iter = ftdm_call_get_var_iterator(channel_caller_data, iter);
+	iter = ftdm_sigmsg_get_var_iterator(sigmsg, iter);
 	for (curr = iter ; curr; curr = ftdm_iterator_next(curr)) {
-		ftdm_call_get_current_var(curr, &var_name, &var_value);
+		ftdm_get_current_var(curr, &var_name, &var_value);
 		snprintf(name, sizeof(name), FREETDM_VAR_PREFIX "%s", var_name);
 		switch_channel_set_variable_printf(channel, name, "%s", var_value);
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Call Variable: %s=%s\n", name, var_value);
 	}
 	ftdm_iterator_free(iter);
 	
-
 	switch_channel_set_state(channel, CS_INIT);
 	if (switch_core_session_thread_launch(session) != SWITCH_STATUS_SUCCESS) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error spawning thread\n");
@@ -2149,8 +2137,6 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal)
     switch(sigmsg->event_id) {
     case FTDM_SIGEVENT_START:
 		{
-			ftdm_call_add_var(caller_data, "screening_ind", ftdm_screening2str(caller_data->screen));
-			ftdm_call_add_var(caller_data, "presentation_ind", ftdm_presentation2str(caller_data->pres));
 			return ftdm_channel_from_event(sigmsg, &session);
 		}
 		break;
diff --git a/libs/freetdm/msvc/freetdm.2008.vcproj b/libs/freetdm/msvc/freetdm.2008.vcproj
index c3a0d7ad08..46594bf38c 100644
--- a/libs/freetdm/msvc/freetdm.2008.vcproj
+++ b/libs/freetdm/msvc/freetdm.2008.vcproj
@@ -428,6 +428,10 @@
 				RelativePath="..\src\ftdm_call_utils.c"
 				>
 			</File>
+			<File
+				RelativePath="..\src\ftdm_variables.c"
+				>
+			</File>
 			<File
 				RelativePath="..\src\ftdm_callerid.c"
 				>
diff --git a/libs/freetdm/msvc/freetdm.2010.vcxproj b/libs/freetdm/msvc/freetdm.2010.vcxproj
index 7b95612031..bd0605060a 100644
--- a/libs/freetdm/msvc/freetdm.2010.vcxproj
+++ b/libs/freetdm/msvc/freetdm.2010.vcxproj
@@ -203,6 +203,7 @@
     <ClCompile Include="..\src\fsk.c" />
     <ClCompile Include="..\src\ftdm_buffer.c" />
     <ClCompile Include="..\src\ftdm_call_utils.c" />
+    <ClCompile Include="..\src\ftdm_variables.c" />
     <ClCompile Include="..\src\ftdm_callerid.c" />
     <ClCompile Include="..\src\ftdm_config.c" />
     <ClCompile Include="..\src\ftdm_cpu_monitor.c" />
diff --git a/libs/freetdm/msvc/freetdm.2010.vcxproj.filters b/libs/freetdm/msvc/freetdm.2010.vcxproj.filters
index e6dc40d372..9f15c9c737 100644
--- a/libs/freetdm/msvc/freetdm.2010.vcxproj.filters
+++ b/libs/freetdm/msvc/freetdm.2010.vcxproj.filters
@@ -85,6 +85,9 @@
     <ClCompile Include="..\src\ftdm_call_utils.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\ftdm_variables.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\src\ftdm_callerid.c">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -131,4 +134,4 @@
       <Filter>Source Files</Filter>
     </ClCompile>
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/libs/freetdm/src/ftdm_io.c b/libs/freetdm/src/ftdm_io.c
index 92559a43a5..947dff62e3 100644
--- a/libs/freetdm/src/ftdm_io.c
+++ b/libs/freetdm/src/ftdm_io.c
@@ -62,11 +62,11 @@ struct tm *localtime_r(const time_t *clock, struct tm *result);
 ftdm_time_t time_last_throttle_log = 0;
 ftdm_time_t time_current_throttle_log = 0;
 
-static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter);
 static ftdm_status_t ftdm_call_set_call_id(ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data);
 static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data);
-static ftdm_status_t ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan);
 static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan);
+static ftdm_status_t ftdm_channel_sig_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg);
+
 
 static int time_is_init = 0;
 
@@ -1900,10 +1900,9 @@ openchan:
 	ftdm_set_flag(check, FTDM_CHANNEL_INUSE);
 	ftdm_set_flag(check, FTDM_CHANNEL_OUTBOUND);
 	*ftdmchan = check;
-#if 1
+
 	/* we've got the channel, do not unlock it */
 	goto done;
-#endif
 
 unlockchan:
 	ftdm_mutex_unlock(check->mutex);
@@ -2064,25 +2063,25 @@ FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_done(const ftdm_channel_t *ftdmc
 	return condition;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status;
 	ftdm_channel_lock(ftdmchan);
 
 	ftdm_set_flag(ftdmchan, FTDM_CHANNEL_HOLD);
-	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALTONE, 0);
+	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALTONE, 0, usrmsg);
 	ftdm_channel_unlock(ftdmchan);
 
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_unhold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_unhold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status;
 
 	ftdm_channel_lock(ftdmchan);
 
-	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_UP, 0);
+	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_UP, 0, usrmsg);
 
 	ftdm_channel_unlock(ftdmchan);
 
@@ -2109,7 +2108,7 @@ FT_DECLARE(void) ftdm_ack_indication(ftdm_channel_t *fchan, ftdm_channel_indicat
 }
 
 /*! Answer call without locking the channel. The caller must have locked first */
-static ftdm_status_t _ftdm_channel_call_answer_nl(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+static ftdm_status_t _ftdm_channel_call_answer_nl(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 
@@ -2119,7 +2118,7 @@ static ftdm_status_t _ftdm_channel_call_answer_nl(const char *file, const char *
 		* use FTDM_SPAN_USE_SKIP_STATES for now while we update the sig modules */
 
 		if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) {
-			status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1);
+			status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1, usrmsg);
 			if (status != FTDM_SUCCESS) {
 				status = FTDM_ECANCELED;
 				goto done;
@@ -2134,7 +2133,7 @@ static ftdm_status_t _ftdm_channel_call_answer_nl(const char *file, const char *
 		}
 
 		if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS_MEDIA) {
-			status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, 1);
+			status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, 1, usrmsg);
 			if (status != FTDM_SUCCESS) {
 				status = FTDM_ECANCELED;
 				goto done;
@@ -2149,7 +2148,7 @@ static ftdm_status_t _ftdm_channel_call_answer_nl(const char *file, const char *
 		}
 	}
 
-	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_UP, 1);
+	status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_UP, 1, usrmsg);
 	if (status != FTDM_SUCCESS) {
 		status = FTDM_ECANCELED;
 		goto done;
@@ -2160,19 +2159,19 @@ done:
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_answer(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_answer(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status;
 
 	/* we leave the locking up to ftdm_channel_call_indicate, DO NOT lock here since ftdm_channel_call_indicate expects
 	 * the lock recursivity to be 1 */
-	status = _ftdm_channel_call_indicate(file, func, line, ftdmchan, FTDM_CHANNEL_INDICATE_ANSWER);
+	status = _ftdm_channel_call_indicate(file, func, line, ftdmchan, FTDM_CHANNEL_INDICATE_ANSWER, usrmsg);
 
 	return status;
 }
 
 /* lock must be acquired by the caller! */
-static ftdm_status_t _ftdm_channel_call_hangup_nl(const char *file, const char *func, int line, ftdm_channel_t *chan)
+static ftdm_status_t _ftdm_channel_call_hangup_nl(const char *file, const char *func, int line, ftdm_channel_t *chan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 	
@@ -2191,7 +2190,7 @@ static ftdm_status_t _ftdm_channel_call_hangup_nl(const char *file, const char *
 		if (ftdm_test_flag(chan, FTDM_CHANNEL_STATE_CHANGE)) {
 			ftdm_channel_cancel_state(file, func, line, chan);
 		}
-		status = ftdm_channel_set_state(file, func, line, chan, FTDM_CHANNEL_STATE_HANGUP, 1);
+		status = ftdm_channel_set_state(file, func, line, chan, FTDM_CHANNEL_STATE_HANGUP, 1, usrmsg);
 	} else {
 		/* the signaling stack did not touch the state, 
 		 * core is responsible from clearing flags and stuff, however, because ftmod_analog
@@ -2207,20 +2206,20 @@ static ftdm_status_t _ftdm_channel_call_hangup_nl(const char *file, const char *
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup_with_cause(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_call_cause_t cause)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup_with_cause(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_call_cause_t cause, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 	ftdm_channel_lock(ftdmchan);
 
 	ftdmchan->caller_data.hangup_cause = cause;
 	
-	status = _ftdm_channel_call_hangup_nl(file, func, line, ftdmchan);
+	status = _ftdm_channel_call_hangup_nl(file, func, line, ftdmchan, usrmsg);
 
 	ftdm_channel_unlock(ftdmchan);
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 
@@ -2228,7 +2227,7 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup(const char *file, const char
 	
 	ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING;
 
-	status = _ftdm_channel_call_hangup_nl(file, func, line, ftdmchan);
+	status = _ftdm_channel_call_hangup_nl(file, func, line, ftdmchan, usrmsg);
 
 	ftdm_channel_unlock(ftdmchan);
 	return status;
@@ -2288,7 +2287,7 @@ FT_DECLARE(uint32_t) ftdm_channel_get_ph_span_id(const ftdm_channel_t *ftdmchan)
  * someone *MUST* acknowledge the indication, either the signaling stack, this function or the core
  * at some later point
  * */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 
@@ -2331,10 +2330,10 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const ch
 	/* FIXME: ring and busy cannot be used with all signaling stacks 
 	 * (particularly isdn stacks I think, we should emulate or just move to hangup with busy cause) */
 	case FTDM_CHANNEL_INDICATE_RINGING:
-		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_RINGING, 1);
+		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_RINGING, 1, usrmsg);
 		break;
 	case FTDM_CHANNEL_INDICATE_BUSY:
-		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_BUSY, 1);
+		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_BUSY, 1, usrmsg);
 		break;
 	case FTDM_CHANNEL_INDICATE_PROCEED:
 		if (!ftdm_test_flag(ftdmchan->span, FTDM_SPAN_USE_PROCEED_STATE) ||
@@ -2342,15 +2341,15 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const ch
 			ftdm_ack_indication(ftdmchan, indication, status);
 			goto done;
 		}
-		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROCEED, 1);
+		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROCEED, 1, usrmsg);
 		break;
 	case FTDM_CHANNEL_INDICATE_PROGRESS:
-		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1);
+		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1, usrmsg);
 		break;
 	case FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA:
 		if (!ftdm_test_flag(ftdmchan->span, FTDM_SPAN_USE_SKIP_STATES)) {
 			if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) {
-				status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1);
+				status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS, 1, usrmsg);
 				if (status != FTDM_SUCCESS) {
 					goto done;
 				}
@@ -2362,14 +2361,14 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const ch
 				goto done;
 			}
 		}
-		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, 1);
+		status = ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, 1, usrmsg);
 		break;
 	case FTDM_CHANNEL_INDICATE_ANSWER:
-		status = _ftdm_channel_call_answer_nl(file, func, line, ftdmchan);
+		status = _ftdm_channel_call_answer_nl(file, func, line, ftdmchan, usrmsg);
 		break;
 	default:
-		ftdm_log(file, func, line, FTDM_LOG_LEVEL_WARNING, "Do not know how to indicate %d\n", indication);
-		status = FTDM_EINVAL;
+		/* See if signalling module can provide this indication */
+		status = ftdm_channel_sig_indicate(ftdmchan, indication, usrmsg);
 		break;
 	}
 
@@ -2379,38 +2378,19 @@ done:
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_send_msg(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)
-{
-	ftdm_status_t status = FTDM_FAIL;
-	ftdm_assert_return(ftdmchan != NULL, FTDM_FAIL, "null channel");
-#ifdef __WINDOWS__
-	UNREFERENCED_PARAMETER(file);
-	UNREFERENCED_PARAMETER(func);
-	UNREFERENCED_PARAMETER(line);
-#endif
-
-	ftdm_channel_lock(ftdmchan);
-	if (ftdmchan->span->send_msg) {
-		status = ftdmchan->span->send_msg(ftdmchan, sigmsg);
-	} else {
-		status = FTDM_NOTIMPL;
-		ftdm_log(FTDM_LOG_ERROR, "send_msg method not implemented in this span!\n");
-	}
-	ftdm_channel_unlock(ftdmchan);
-	return status;
-}
-
-FT_DECLARE(ftdm_status_t) _ftdm_channel_reset(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_reset(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_assert_return(ftdmchan != NULL, FTDM_FAIL, "null channel");
 
 	ftdm_channel_lock(ftdmchan);
-	ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_RESET, 1);
+	ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_RESET, 1, usrmsg);
 	ftdm_channel_unlock(ftdmchan);
 	return FTDM_SUCCESS;
 }
 
-static ftdm_status_t _ftdm_channel_call_place_nl(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+/* this function MUST be called with the channel lock held with lock recursivity of 1 exactly, 
+ * and the caller must be aware we might unlock the channel for a brief period of time and then lock it again */
+static ftdm_status_t _ftdm_channel_call_place_nl(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_FAIL;
 	
@@ -2450,13 +2430,24 @@ static ftdm_status_t _ftdm_channel_call_place_nl(const char *file, const char *f
 		goto done;
 	}
 
-	/* in case of success, *before* unlocking the channel, we must set the call started flag and the call id 
-	 * that is a guarantee that signaling modules expect from us */
 	ftdm_set_flag(ftdmchan, FTDM_CHANNEL_CALL_STARTED);
 	ftdm_call_set_call_id(ftdmchan, &ftdmchan->caller_data);
-	if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_NONBLOCK)) {
-		/* be aware this waiting unlocks the channel and locks it back when done */
-		ftdm_wait_for_flag_cleared(ftdmchan, FTDM_CHANNEL_STATE_CHANGE, 100);
+
+	/* if the signaling stack left the channel in state down on success, is expecting us to move to DIALING */
+	if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN) {
+		if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_NONBLOCK)) {
+			ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALING, 1, usrmsg);	
+		} else {
+			ftdm_channel_set_state(file, func, line, ftdmchan, FTDM_CHANNEL_STATE_DIALING, 0, usrmsg);	
+		}
+	} else if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE) &&
+		   !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_NONBLOCK)) {
+		
+		ftdm_channel_unlock(ftdmchan);
+
+		ftdm_interrupt_wait(ftdmchan->state_completed_interrupt, 500);
+
+		ftdm_channel_lock(ftdmchan);
 	}
 
 done:
@@ -2468,19 +2459,20 @@ done:
 	return status;
 }
 
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status;
 	ftdm_channel_lock(ftdmchan);
 
-	status = _ftdm_channel_call_place_nl(file, func, line, ftdmchan);
+	/* be aware that _ftdm_channl_call_place_nl can unlock/lock the channel quickly if working in blocking mode  */
+	status = _ftdm_channel_call_place_nl(file, func, line, ftdmchan, usrmsg);
 
 	ftdm_channel_unlock(ftdmchan);
 	return status;
 }
 
 FT_DECLARE(ftdm_status_t) _ftdm_call_place(const char *file, const char *func, int line, 
-		ftdm_caller_data_t *caller_data, ftdm_hunting_scheme_t *hunting)
+		   ftdm_caller_data_t *caller_data, ftdm_hunting_scheme_t *hunting, ftdm_usrmsg_t *usrmsg)
 {
 	ftdm_status_t status = FTDM_SUCCESS;
 	ftdm_channel_t *fchan = NULL;
@@ -2516,9 +2508,10 @@ FT_DECLARE(ftdm_status_t) _ftdm_call_place(const char *file, const char *func, i
 
 	ftdm_channel_set_caller_data(fchan, caller_data);
 
-	status = _ftdm_channel_call_place_nl(file, func, line, fchan);
+	/* be aware that _ftdm_channl_call_place_nl can unlock/lock the channel quickly if working in blocking mode  */
+	status = _ftdm_channel_call_place_nl(file, func, line, fchan, usrmsg);
 	if (status != FTDM_SUCCESS) {
-		_ftdm_channel_call_hangup_nl(file, func, line, fchan);
+		_ftdm_channel_call_hangup_nl(file, func, line, fchan, usrmsg);
 		goto done;
 	}
 
@@ -2606,6 +2599,29 @@ FT_DECLARE(ftdm_status_t) ftdm_span_get_sig_status(ftdm_span_t *span, ftdm_signa
 	}
 }
 
+static ftdm_status_t ftdm_channel_sig_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg)
+{
+	ftdm_status_t status = FTDM_FAIL;
+	if (ftdmchan->span->indicate) {
+		
+		ftdm_channel_save_usrmsg(ftdmchan, usrmsg);
+		
+		status = ftdmchan->span->indicate(ftdmchan, indication);
+		if (status == FTDM_NOTIMPL) {
+			ftdm_log(FTDM_LOG_WARNING, "Do not know how to indicate %s\n", ftdm_channel_indication2str(indication));
+		} else if (status != FTDM_SUCCESS) {
+			ftdm_log(FTDM_LOG_WARNING, "Failed to indicate %s\n", ftdm_channel_indication2str(indication));
+		} else { /* SUCCESS */
+			ftdm_ack_indication(ftdmchan, indication, FTDM_SUCCESS);
+		}
+		ftdm_usrmsg_free(&ftdmchan->usrmsg);
+	} else {
+		return FTDM_NOTIMPL;
+	}
+	return status;
+}
+
+
 /* this function must be called with the channel lock */
 static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan)
 {
@@ -2633,7 +2649,7 @@ static ftdm_status_t ftdm_channel_done(ftdm_channel_t *ftdmchan)
 	ftdm_buffer_destroy(&ftdmchan->pre_buffer);
 	ftdmchan->pre_buffer_size = 0;
 	ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex);
-	ftdm_channel_clear_vars(ftdmchan);
+	
 	if (ftdmchan->hangup_timer) {
 		ftdm_sched_cancel_timer(globals.timingsched, ftdmchan->hangup_timer);
 	}
@@ -3508,7 +3524,8 @@ skipdebug:
 			ftdmchan->dtmf_hangup_buf[ftdmchan->span->dtmf_hangup_len - 1] = *p;
 			if (!strcmp(ftdmchan->dtmf_hangup_buf, ftdmchan->span->dtmf_hangup)) {
 				ftdm_log(FTDM_LOG_DEBUG, "DTMF hangup detected.\n");
-				ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
+
+				ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, ftdmchan, FTDM_CHANNEL_STATE_HANGUP, 0, NULL);
 				break;
 			}
 		}
@@ -4032,166 +4049,7 @@ done:
 	return status;
 }
 
-FT_DECLARE(void) ftdm_call_clear_data(ftdm_caller_data_t *caller_data)
-{
-	ftdm_call_clear_vars(caller_data);
-	memset(&caller_data->raw_data, 0, sizeof(caller_data->raw_data));
-	caller_data->raw_data_len = 0;
-	return;
-}
-
-FT_DECLARE(ftdm_status_t) ftdm_call_clear_vars(ftdm_caller_data_t *caller_data)
-{
-	if (caller_data->variables) {
-		hashtable_destroy(caller_data->variables);
-	}
-	caller_data->variables = NULL;
-	return FTDM_SUCCESS;
-}
-
-FT_DECLARE(ftdm_status_t) ftdm_call_remove_var(ftdm_caller_data_t *caller_data, const char *var_name)
-{
-	if (caller_data->variables) {
-		hashtable_remove(caller_data->variables, (void *)var_name);
-	}
-	
-	return FTDM_SUCCESS;
-}
-
-
-FT_DECLARE(ftdm_status_t) ftdm_call_add_var(ftdm_caller_data_t *caller_data, const char *var_name, const char *value)
-{
-	char *t_name = 0, *t_val = 0;
-
-	if (!var_name || !value) {
-		return FTDM_FAIL;
-	}
-	
-	if (!caller_data->variables) {
-		/* initialize on first use */
-		caller_data->variables = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
-		ftdm_assert_return(caller_data->variables, FTDM_FAIL, "Failed to create hash table\n");
-	}
-	
-	t_name = ftdm_strdup(var_name);
-	t_val = ftdm_strdup(value);
-	hashtable_insert(caller_data->variables, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
-	return FTDM_SUCCESS;
-}
-
-FT_DECLARE(const char *) ftdm_call_get_var(ftdm_caller_data_t *caller_data, const char *var_name)
-{
-	const char *var = NULL;
-	
-	if (!caller_data->variables || !var_name) {
-		return NULL;
-	}
-
-	var = (const char *)hashtable_search(((struct hashtable*)caller_data->variables), (void *)var_name);
-	return var;
-}
-
-FT_DECLARE(ftdm_iterator_t *) ftdm_call_get_var_iterator(const ftdm_caller_data_t *caller_data, ftdm_iterator_t *iter)
-{
-	ftdm_hash_iterator_t *hashiter = NULL;
-	hashiter = caller_data->variables == NULL ? NULL : hashtable_first(caller_data->variables);
-	
-	if (hashiter == NULL) {
-		return NULL;
-	}
-	
-	if (!(iter = get_iterator(FTDM_ITERATOR_VARS, iter))) {
-		return NULL;
-	}
-	iter->pvt.hashiter = hashiter;
-	return iter;
-}
-
-FT_DECLARE(ftdm_status_t) ftdm_call_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val)
-{
-	const void *key = NULL;
-	void *val = NULL;
-
-	*var_name = NULL;
-	*var_val = NULL;
-
-	ftdm_assert_return(iter && (iter->type == FTDM_ITERATOR_VARS) && iter->pvt.hashiter, FTDM_FAIL, "Cannot get variable from invalid iterator!\n");
-
-	hashtable_this(iter->pvt.hashiter, &key, NULL, &val);
-
-	*var_name = key;
-	*var_val = val;
-
-	return FTDM_SUCCESS;
-}
-
-
-static ftdm_status_t ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan)
-{
-	ftdm_channel_lock(ftdmchan);
-
-	if (ftdmchan->variable_hash) {
-		hashtable_destroy(ftdmchan->variable_hash);
-	}
-	ftdmchan->variable_hash = NULL;
-
-	ftdm_channel_unlock(ftdmchan);
-	return FTDM_SUCCESS;
-}
-
-FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value)
-{
-	char *t_name = 0, *t_val = 0;
-
-	ftdm_status_t status = FTDM_FAIL;
-
-	if (!var_name || !value) {
-		return FTDM_FAIL;
-	}
-
-	ftdm_channel_lock(ftdmchan);
-
-	if (!ftdmchan->variable_hash) {
-		/* initialize on first use */
-		ftdmchan->variable_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
-		if (!ftdmchan->variable_hash) {
-			goto done;
-		}
-	}
-
-	t_name = ftdm_strdup(var_name);
-	t_val = ftdm_strdup(value);
-
-	hashtable_insert(ftdmchan->variable_hash, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
-
-	status = FTDM_SUCCESS;
-
-done:
-	ftdm_channel_unlock(ftdmchan);
-
-	return status;
-}
-
-
-FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name)
-{
-	const char *var = NULL;
-
-	ftdm_channel_lock(ftdmchan);
-
-	if (!ftdmchan->variable_hash || !var_name) {
-		goto done;
-	}
-	
-	var = (const char *)hashtable_search(ftdmchan->variable_hash, (void *)var_name);
-
-done:
-	ftdm_channel_unlock(ftdmchan);
-
-	return var;
-}
-
-static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter)
+FT_DECLARE(ftdm_iterator_t) *ftdm_get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter)
 {
 	int allocated = 0;
 	if (iter) {
@@ -4215,28 +4073,9 @@ static ftdm_iterator_t *get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t
 	return iter;
 }
 
-FT_DECLARE(ftdm_iterator_t *) ftdm_channel_get_var_iterator(const ftdm_channel_t *ftdmchan, ftdm_iterator_t *iter)
-{
-	ftdm_hash_iterator_t *hashiter = NULL;
-	ftdm_channel_lock(ftdmchan);
-	hashiter = ftdmchan->variable_hash == NULL ? NULL : hashtable_first(ftdmchan->variable_hash);
-	ftdm_channel_unlock(ftdmchan);
-
-
-	if (hashiter == NULL) {
-		return NULL;
-	}
-	
-	if (!(iter = get_iterator(FTDM_ITERATOR_VARS, iter))) {
-		return NULL;
-	}
-	iter->pvt.hashiter = hashiter;
-	return iter;
-}
-
 FT_DECLARE(ftdm_iterator_t *) ftdm_span_get_chan_iterator(const ftdm_span_t *span, ftdm_iterator_t *iter)
 {
-	if (!(iter = get_iterator(FTDM_ITERATOR_CHANS, iter))) {
+	if (!(iter = ftdm_get_iterator(FTDM_ITERATOR_CHANS, iter))) {
 		return NULL;
 	}
 	iter->pvt.chaniter.index = 1;
@@ -4244,24 +4083,6 @@ FT_DECLARE(ftdm_iterator_t *) ftdm_span_get_chan_iterator(const ftdm_span_t *spa
 	return iter;
 }
 
-FT_DECLARE(ftdm_status_t) ftdm_channel_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val)
-{
-	const void *key = NULL;
-	void *val = NULL;
-
-	*var_name = NULL;
-	*var_val = NULL;
-
-	ftdm_assert_return(iter && (iter->type == FTDM_ITERATOR_VARS) && iter->pvt.hashiter, FTDM_FAIL, "Cannot get variable from invalid iterator!\n");
-
-	hashtable_this(iter->pvt.hashiter, &key, NULL, &val);
-
-	*var_name = key;
-	*var_val = val;
-
-	return FTDM_SUCCESS;
-}
-
 FT_DECLARE(ftdm_iterator_t *) ftdm_iterator_next(ftdm_iterator_t *iter)
 {
 	ftdm_assert_return(iter && iter->type, NULL, "Invalid iterator\n");
@@ -5475,14 +5296,7 @@ FT_DECLARE(ftdm_status_t) ftdm_group_create(ftdm_group_t **group, const char *na
 static ftdm_status_t ftdm_span_trigger_signal(const ftdm_span_t *span, ftdm_sigmsg_t *sigmsg)
 {
 	ftdm_status_t status = span->signal_cb(sigmsg);
-	if (sigmsg->channel) {
-		ftdm_call_clear_data(&(sigmsg->channel->caller_data));
-	}
-	if (sigmsg->raw.autofree) {
-		ftdm_safe_free(sigmsg->raw.data);
-		sigmsg->raw.data = NULL;
-		sigmsg->raw.len = 0;
-	}
+	ftdm_sigmsg_free(&sigmsg);
 	return status;
 }
 
@@ -5505,7 +5319,6 @@ FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span)
 	ftdm_sigmsg_t *sigmsg = NULL;
 	while ((sigmsg = ftdm_queue_dequeue(span->pendingsignals))) {
 		ftdm_span_trigger_signal(span, sigmsg);
-		ftdm_safe_free(sigmsg);
 	}
 	return FTDM_SUCCESS;
 }
@@ -5518,7 +5331,7 @@ static void execute_safety_hangup(void *data)
 	fchan->hangup_timer = 0;
 	if (fchan->state == FTDM_CHANNEL_STATE_TERMINATING) {
 		ftdm_log_chan(fchan, FTDM_LOG_CRIT, "Forcing hangup since the user did not confirmed our hangup after %dms\n", FORCE_HANGUP_TIMER);
-		_ftdm_channel_call_hangup_nl(__FILE__, __FUNCTION__, __LINE__, fchan);
+		_ftdm_channel_call_hangup_nl(__FILE__, __FUNCTION__, __LINE__, fchan, NULL);
 	} else {
 		ftdm_log_chan(fchan, FTDM_LOG_CRIT, "Not performing safety hangup, channel state is %s\n", ftdm_channel_state2str(fchan->state));
 	}
@@ -6221,6 +6034,123 @@ static ftdm_status_t ftdm_call_clear_call_id(ftdm_caller_data_t *caller_data)
 	return FTDM_SUCCESS;
 }
 
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_get_raw_data(ftdm_sigmsg_t *sigmsg, void **data, ftdm_size_t *datalen)
+{
+	if (!sigmsg || !sigmsg->raw.len) {
+		return FTDM_FAIL;
+	}
+	
+	*data = sigmsg->raw.data;
+	*datalen = sigmsg->raw.len;
+	
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_get_raw_data_detached(ftdm_sigmsg_t *sigmsg, void **data, ftdm_size_t *datalen)
+{
+	if (!sigmsg || !sigmsg->raw.len) {
+		return FTDM_FAIL;
+	}
+	
+	*data = sigmsg->raw.data;
+	*datalen = sigmsg->raw.len;		
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_set_raw_data(ftdm_sigmsg_t *sigmsg, void *data, ftdm_size_t datalen)
+{
+	ftdm_assert_return(sigmsg, FTDM_FAIL, "Trying to set raw data on a NULL event\n");
+	ftdm_assert_return(!sigmsg->raw.len, FTDM_FAIL, "Overwriting existing raw data\n");
+	ftdm_assert_return(datalen, FTDM_FAIL, "Data length not set\n");
+
+	sigmsg->raw.data = data;
+	sigmsg->raw.len = datalen;
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_get_raw_data(ftdm_usrmsg_t *usrmsg, void **data, ftdm_size_t *datalen)
+{
+	if (!usrmsg || !usrmsg->raw.len) {
+		return FTDM_FAIL;
+	}
+	
+	*data = usrmsg->raw.data;
+	*datalen = usrmsg->raw.len;
+	
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_set_raw_data(ftdm_usrmsg_t *usrmsg, void *data, ftdm_size_t datalen)
+{
+	ftdm_assert_return(usrmsg, FTDM_FAIL, "Trying to set raw data on a NULL event\n");
+	ftdm_assert_return(!usrmsg->raw.len, FTDM_FAIL, "Overwriting existing raw data\n");
+	ftdm_assert_return(datalen, FTDM_FAIL, "Data length not set\n");
+
+	usrmsg->raw.data = data;
+	usrmsg->raw.len = datalen;
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_channel_save_usrmsg(ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg)
+{
+	ftdm_assert_return(!ftdmchan->usrmsg, FTDM_FAIL, "Info from previous event was not cleared\n");
+	if (usrmsg) {
+		/* Copy sigmsg from user to internal copy so user can set new variables without race condition */
+		ftdmchan->usrmsg = ftdm_calloc(1, sizeof(ftdm_usrmsg_t));
+		memcpy(ftdmchan->usrmsg, usrmsg, sizeof(ftdm_usrmsg_t));
+		
+		if (usrmsg->raw.data) {
+			usrmsg->raw.data = NULL;
+			usrmsg->raw.len = 0;
+		}
+		if (usrmsg->variables) {
+			usrmsg->variables = NULL;
+		}
+	}
+	return FTDM_SUCCESS;	
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_free(ftdm_sigmsg_t **sigmsg)
+{
+	if (!*sigmsg) {
+		return FTDM_SUCCESS;
+	}
+
+	if ((*sigmsg)->variables) {
+		hashtable_destroy((*sigmsg)->variables);
+		(*sigmsg)->variables = NULL;
+	}
+
+	if ((*sigmsg)->raw.data) {
+		ftdm_safe_free((*sigmsg)->raw.data);
+		(*sigmsg)->raw.data = NULL;
+		(*sigmsg)->raw.len = 0;
+	}
+
+	ftdm_safe_free(*sigmsg);
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_free(ftdm_usrmsg_t **usrmsg)
+{
+	if (!*usrmsg) {
+		return FTDM_SUCCESS;
+	}
+
+	if ((*usrmsg)->variables) {
+		hashtable_destroy((*usrmsg)->variables);
+		(*usrmsg)->variables = NULL;
+	}
+
+	if ((*usrmsg)->raw.data) {
+		ftdm_safe_free((*usrmsg)->raw.data);
+		(*usrmsg)->raw.data = NULL;
+		(*usrmsg)->raw.len = 0;
+	}
+
+	ftdm_safe_free(*usrmsg);
+	return FTDM_SUCCESS;
+}
 
 
 
diff --git a/libs/freetdm/src/ftdm_state.c b/libs/freetdm/src/ftdm_state.c
index de62c0f0e7..eea3a6a0c0 100644
--- a/libs/freetdm/src/ftdm_state.c
+++ b/libs/freetdm/src/ftdm_state.c
@@ -40,13 +40,15 @@ FTDM_STR2ENUM(ftdm_str2ftdm_channel_state, ftdm_channel_state2str, ftdm_channel_
 FTDM_ENUM_NAMES(CHANNEL_STATE_STATUS_NAMES, CHANNEL_STATE_STATUS_STRINGS)
 FTDM_STR2ENUM(ftdm_str2ftdm_state_status, ftdm_state_status2str, ftdm_state_status_t, CHANNEL_STATE_STATUS_NAMES, FTDM_STATE_STATUS_INVALID)
 
+static ftdm_status_t ftdm_core_set_state(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int waitrq);
+
 /* This function is only needed for boost and we should get rid of it at the next refactoring */
 FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *fchan)
 {
 	ftdm_channel_lock(fchan);
 
 	if (fchan->init_state != FTDM_CHANNEL_STATE_DOWN) {
-		ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, fchan, fchan->init_state, 1);
+		ftdm_core_set_state(__FILE__, __FUNCTION__, __LINE__, fchan, fchan->init_state, 1);
 		fchan->init_state = FTDM_CHANNEL_STATE_DOWN;
 	}
 
@@ -66,6 +68,8 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_complete_state(const char *file, const c
 		return FTDM_SUCCESS;
 	}
 
+	ftdm_usrmsg_free(&fchan->usrmsg);
+	
 	ftdm_clear_flag(fchan, FTDM_CHANNEL_STATE_CHANGE);
 
 	if (state == FTDM_CHANNEL_STATE_PROGRESS) {
@@ -121,7 +125,7 @@ FT_DECLARE(ftdm_status_t) _ftdm_set_state(const char *file, const char *func, in
 		   the current state */
 		_ftdm_channel_complete_state(file, func, line, fchan);
 	}
-	return ftdm_channel_set_state(file, func, line, fchan, state, 0);
+	return ftdm_core_set_state(file, func, line, fchan, state, 0);
 }
 
 static int ftdm_parse_state_map(ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, ftdm_state_map_t *state_map)
@@ -223,9 +227,20 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_cancel_state(const char *file, const char
 	return FTDM_SUCCESS;
 }
 
+
+FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int waitrq, ftdm_usrmsg_t *usrmsg)
+{
+	ftdm_channel_save_usrmsg(ftdmchan, usrmsg);
+	
+	if (ftdm_core_set_state(file, func, line, ftdmchan, state, waitrq) != FTDM_SUCCESS) {
+		ftdm_usrmsg_free(&ftdmchan->usrmsg);
+	}
+	return FTDM_SUCCESS;
+}
+
 /* this function MUST be called with the channel lock held. If waitrq == 1, the channel will be unlocked/locked (never call it with waitrq == 1 with an lock recursivity > 1) */
 #define DEFAULT_WAIT_TIME 1000
-FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int waitrq)
+static ftdm_status_t ftdm_core_set_state(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int waitrq)
 {
 	ftdm_status_t status;
 	int ok = 1;
@@ -513,7 +528,7 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_advance_states(ftdm_channel_t *fchan)
 			 * already completed implicitly by the state_processor() function via some internal
 			 * call to ftdm_set_state() */
 			fchan->state_status = FTDM_STATE_STATUS_PROCESSED;
-		}
+		}		
 	}
 
 	return FTDM_SUCCESS;
diff --git a/libs/freetdm/src/ftdm_variables.c b/libs/freetdm/src/ftdm_variables.c
new file mode 100644
index 0000000000..a2899c4ca9
--- /dev/null
+++ b/libs/freetdm/src/ftdm_variables.c
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2010, Sangoma Technologies
+ * David Yat Sin <dyatsin@sangoma.com>
+ * 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.
+ *
+ * Contributors: 
+ *
+ * Moises Silva <moy@sangoma.com>
+ *
+ */
+
+#include "private/ftdm_core.h"
+
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_add_var(ftdm_sigmsg_t *sigmsg, const char *var_name, const char *value)
+{
+	char *t_name = 0, *t_val = 0;
+
+	if (!sigmsg || !var_name || !value) {
+		return FTDM_FAIL;
+	}
+	
+	if (!sigmsg->variables) {
+		/* initialize on first use */
+		sigmsg->variables = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
+		ftdm_assert_return(sigmsg->variables, FTDM_FAIL, "Failed to create hash table\n");
+	}
+	
+	t_name = ftdm_strdup(var_name);
+	t_val = ftdm_strdup(value);
+	hashtable_insert(sigmsg->variables, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_remove_var(ftdm_sigmsg_t *sigmsg, const char *var_name)
+{
+	if (sigmsg && sigmsg->variables) {
+		hashtable_remove(sigmsg->variables, (void *)var_name);
+	}
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(const char *) ftdm_sigmsg_get_var(ftdm_sigmsg_t *sigmsg, const char *var_name)
+{
+	const char *var = NULL;
+	
+	if (!sigmsg || !sigmsg->variables || !var_name) {
+		return NULL;
+	}
+
+	var = (const char *)hashtable_search(((struct hashtable*)sigmsg->variables), (void *)var_name);
+	return var;
+}
+
+FT_DECLARE(ftdm_iterator_t *) ftdm_sigmsg_get_var_iterator(const ftdm_sigmsg_t *sigmsg, ftdm_iterator_t *iter)
+{
+	ftdm_hash_iterator_t *hashiter = NULL;
+	if (!sigmsg) {
+		return NULL;
+	}
+	
+	hashiter = sigmsg->variables == NULL ? NULL : hashtable_first(sigmsg->variables);
+	
+	if (hashiter == NULL) {
+		return NULL;
+	}
+	
+	if (!(iter = ftdm_get_iterator(FTDM_ITERATOR_VARS, iter))) {
+		return NULL;
+	}
+	iter->pvt.hashiter = hashiter;
+	return iter;
+}
+
+FT_DECLARE(ftdm_status_t) ftdm_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val)
+{
+	const void *key = NULL;
+	void *val = NULL;
+
+	*var_name = NULL;
+	*var_val = NULL;
+
+	ftdm_assert_return(iter && (iter->type == FTDM_ITERATOR_VARS) && iter->pvt.hashiter, FTDM_FAIL, "Cannot get variable from invalid iterator!\n");
+
+	hashtable_this(iter->pvt.hashiter, &key, NULL, &val);
+
+	*var_name = key;
+	*var_val = val;
+
+	return FTDM_SUCCESS;
+}
+
+
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_add_var(ftdm_usrmsg_t *usrmsg, const char *var_name, const char *value)
+{
+	char *t_name = 0, *t_val = 0;
+
+	if (!usrmsg || !var_name || !value) {
+		return FTDM_FAIL;
+	}
+	
+	if (!usrmsg->variables) {
+		/* initialize on first use */
+		usrmsg->variables = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys);
+		ftdm_assert_return(usrmsg->variables, FTDM_FAIL, "Failed to create hash table\n");
+	}
+	
+	t_name = ftdm_strdup(var_name);
+	t_val = ftdm_strdup(value);
+	hashtable_insert(usrmsg->variables, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE);
+	return FTDM_SUCCESS;
+}
+
+FT_DECLARE(const char *) ftdm_usrmsg_get_var(ftdm_usrmsg_t *usrmsg, const char *var_name)
+{
+	const char *var = NULL;
+	
+	if (!usrmsg || !usrmsg->variables || !var_name) {
+		return NULL;
+	}
+
+	var = (const char *)hashtable_search(((struct hashtable*)usrmsg->variables), (void *)var_name);
+	return var;
+}
diff --git a/libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c b/libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c
index 5b4ce7196a..a7b84ea5d8 100644
--- a/libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c
+++ b/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;
diff --git a/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c b/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c
index 2f9c70a48d..e051477346 100644
--- a/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c
+++ b/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;
 }
 
 /**
diff --git a/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c b/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c
index 4a817482e3..46eb92fede 100755
--- a/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c
+++ b/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c
@@ -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;
 }
 
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.c b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.c
index 608b0b6ac0..1437b45883 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.c
+++ b/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;
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.h b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.h
index 80dc73f0fa..79ca889d25 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.h
+++ b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn.h
@@ -179,6 +179,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 */
@@ -414,6 +423,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);
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_hndl.c b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_hndl.c
index bcc7d938b7..cfc5017a8d 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_hndl.c
+++ b/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);
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_out.c b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_out.c
index 4b27f21e1c..b56c95b10d 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_out.c
+++ b/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);
 
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_support.c b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_support.c
index 23fe08b983..85048bfbf0 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_support.c
+++ b/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,17 @@ 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;
+
+	if (ftdm_usrmsg_get_raw_data(ftdmchan->usrmsg, (void**)&mydata, &len) == FTDM_SUCCESS) {
+		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 +740,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 +751,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);
 	}
@@ -861,7 +863,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);
@@ -1194,6 +1196,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
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c b/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c
index e24e64b326..c2e9b5c3a1 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c
+++ b/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);
 	}
 }
diff --git a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.c b/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.c
index 48579ada85..976d43f3d6 100644
--- a/libs/freetdm/src/ftmod/ftmod_sangoma_ss7/ftmod_sangoma_ss7_main.c
+++ b/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);
 		
diff --git a/libs/freetdm/src/include/freetdm.h b/libs/freetdm/src/include/freetdm.h
index b1bcd46ae5..32b100319d 100755
--- a/libs/freetdm/src/include/freetdm.h
+++ b/libs/freetdm/src/include/freetdm.h
@@ -172,7 +172,7 @@ typedef enum {
 /*! \brief I/O channel type */
 typedef enum {
 	FTDM_CHAN_TYPE_B, /*!< Bearer channel */
-	FTDM_CHAN_TYPE_DQ921, /*< DQ921 channel (D-channel) */
+	FTDM_CHAN_TYPE_DQ921, /*!< DQ921 channel (D-channel) */
 	FTDM_CHAN_TYPE_DQ931, /*!< DQ931 channel */
 	FTDM_CHAN_TYPE_FXS, /*!< FXS analog channel */
 	FTDM_CHAN_TYPE_FXO, /*!< FXO analog channel */
@@ -214,6 +214,7 @@ typedef void *(*ftdm_queue_dequeue_func_t)(ftdm_queue_t *queue);
 typedef ftdm_status_t (*ftdm_queue_wait_func_t)(ftdm_queue_t *queue, int ms);
 typedef ftdm_status_t (*ftdm_queue_get_interrupt_func_t)(ftdm_queue_t *queue, ftdm_interrupt_t **interrupt);
 typedef ftdm_status_t (*ftdm_queue_destroy_func_t)(ftdm_queue_t **queue);
+
 typedef struct ftdm_queue_handler {
 	ftdm_queue_create_func_t create;
 	ftdm_queue_enqueue_func_t enqueue;
@@ -223,7 +224,6 @@ typedef struct ftdm_queue_handler {
 	ftdm_queue_destroy_func_t destroy;
 } ftdm_queue_handler_t;
 
-
 /*! \brief Type Of Number (TON) */
 typedef enum {
 	FTDM_TON_UNKNOWN = 0,
@@ -318,8 +318,6 @@ typedef struct {
 	uint8_t plan;
 } ftdm_number_t;
 
-typedef void * ftdm_variable_container_t; 
-
 /*! \brief Caller information */
 typedef struct ftdm_caller_data {
 	char cid_date[8]; /*!< Caller ID date */
@@ -333,21 +331,23 @@ typedef struct ftdm_caller_data {
 	uint8_t pres; /*!< Presentation*/
 	char collected[FTDM_DIGITS_LIMIT]; /*!< Collected digits so far */
 	int hangup_cause; /*!< Hangup cause */
-	char raw_data[1024]; /*!< Protocol specific raw caller data */
-	uint32_t raw_data_len; /*!< Raw data length */
 	/* these 2 are undocumented right now, only used by boost: */
 	/* bearer capability */
 	ftdm_bearer_cap_t bearer_capability;
 	/* user information layer 1 protocol */
 	ftdm_user_layer1_prot_t bearer_layer1;
 	ftdm_calling_party_category_t cpc; /*!< Calling party category */
-	ftdm_variable_container_t variables; /*!< Variables attached to this call */
-	/* We need call_id inside caller_data for the user to be able to retrieve 
+
+	ftdm_channel_t *fchan; /*!< FreeTDM channel associated (can be NULL) */
+
+	/*
+	 * We need call_id inside caller_data for the user to be able to retrieve
 	 * the call_id when ftdm_channel_call_place is called. This is the only time
 	 * that the user can use caller_data.call_id to obtain the call_id. The user
-	 * should use the call_id from sigmsg otherwise */
+	 * should use the call_id from sigmsg otherwise
+	 */
 	uint32_t call_id; /*!< Unique call ID for this call */
-	ftdm_channel_t *fchan; /*!< FreeTDM channel associated (can be NULL) */
+
 	void *priv; /*!< Private data for the FreeTDM user */
 } ftdm_caller_data_t;
 
@@ -533,9 +533,10 @@ typedef enum {
 	FTDM_CHANNEL_INDICATE_BUSY,
 	/* Using this indication is equivalent to call ftdm_channel_call_answer API */
 	FTDM_CHANNEL_INDICATE_ANSWER,
+	FTDM_CHANNEL_INDICATE_FACILITY,
 	FTDM_CHANNEL_INDICATE_INVALID,
 } ftdm_channel_indication_t;
-#define INDICATION_STRINGS "NONE", "RINGING", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "BUSY", "ANSWER", "INVALID"
+#define INDICATION_STRINGS "NONE", "RINGING", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "BUSY", "ANSWER", "FACILITY", "INVALID"
 
 /*! \brief Move from string to ftdm_channel_indication_t and viceversa */
 FTDM_STR2ENUM_P(ftdm_str2channel_indication, ftdm_channel_indication2str, ftdm_channel_indication_t)
@@ -547,7 +548,14 @@ typedef struct {
 	ftdm_status_t status;
 } ftdm_event_indication_completed_t;
 
-/*! \brief Generic signaling message */
+typedef void * ftdm_variable_container_t;
+
+typedef struct {
+	ftdm_size_t len;
+	void *data;
+} ftdm_raw_data_t;
+
+/*! \brief Generic signaling message received from the stack */
 struct ftdm_sigmsg {
 	ftdm_signal_event_t event_id; /*!< The type of message */
 	ftdm_channel_t *channel; /*!< Related channel */
@@ -555,17 +563,20 @@ struct ftdm_sigmsg {
 	uint32_t span_id; /*!< easy access to span_id */
 	uint32_t call_id; /*!< unique call id for this call */
 	void *call_priv; /*!< Private data for the FreeTDM user from ftdm_caller_data->priv */
+	ftdm_variable_container_t variables;
 	union {
 		ftdm_event_sigstatus_t sigstatus; /*!< valid if event_id is FTDM_SIGEVENT_SIGSTATUS_CHANGED */
 		ftdm_event_trace_t trace;	/*!< valid if event_id is FTDM_SIGEVENT_TRACE or FTDM_SIGEVENT_TRACE_RAW */
 		ftdm_event_collected_t collected; /*!< valid if event_id is FTDM_SIGEVENT_COLLECTED_DIGIT */
 		ftdm_event_indication_completed_t indication_completed; /*!< valid if the event_id is FTDM_SIGEVENT_INDICATION_COMPLETED */
 	} ev_data;
-	struct {
-		uint8_t autofree; /*!< Whether the freetdm core will free it after message delivery */
-		uint32_t len; /*!< Data len */
-		void *data; /*!< Signaling module specific data */
-	} raw;
+	ftdm_raw_data_t raw;
+};
+
+/*! \brief Generic user message sent to the stack */
+struct ftdm_usrmsg {
+	ftdm_variable_container_t variables;
+	ftdm_raw_data_t raw;
 };
 
 /*! \brief Crash policy 
@@ -701,7 +712,7 @@ struct ftdm_memory_handler {
  * You don't need these unless your implementing an I/O interface module (most users don't) */
 #define FIO_CHANNEL_REQUEST_ARGS (ftdm_span_t *span, uint32_t chan_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan)
 #define FIO_CHANNEL_OUTGOING_CALL_ARGS (ftdm_channel_t *ftdmchan)
-#define FIO_CHANNEL_SEND_MSG_ARGS (ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)
+#define FIO_CHANNEL_INDICATE_ARGS (ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication)
 #define FIO_CHANNEL_SET_SIG_STATUS_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
 #define FIO_CHANNEL_GET_SIG_STATUS_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)
 #define FIO_SPAN_SET_SIG_STATUS_ARGS (ftdm_span_t *span, ftdm_signaling_status_t status)
@@ -734,7 +745,7 @@ struct ftdm_memory_handler {
  * You don't need these unless your implementing an I/O interface module (most users don't) */
 typedef ftdm_status_t (*fio_channel_request_t) FIO_CHANNEL_REQUEST_ARGS ;
 typedef ftdm_status_t (*fio_channel_outgoing_call_t) FIO_CHANNEL_OUTGOING_CALL_ARGS ;
-typedef ftdm_status_t (*fio_channel_send_msg_t) FIO_CHANNEL_SEND_MSG_ARGS;
+typedef ftdm_status_t (*fio_channel_indicate_t) FIO_CHANNEL_INDICATE_ARGS;
 typedef ftdm_status_t (*fio_channel_set_sig_status_t) FIO_CHANNEL_SET_SIG_STATUS_ARGS;
 typedef ftdm_status_t (*fio_channel_get_sig_status_t) FIO_CHANNEL_GET_SIG_STATUS_ARGS;
 typedef ftdm_status_t (*fio_span_set_sig_status_t) FIO_SPAN_SET_SIG_STATUS_ARGS;
@@ -781,7 +792,7 @@ typedef ftdm_status_t (*fio_api_t) FIO_API_ARGS ;
  * You don't need these unless your implementing an I/O interface module (most users don't) */
 #define FIO_CHANNEL_REQUEST_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_REQUEST_ARGS
 #define FIO_CHANNEL_OUTGOING_CALL_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_OUTGOING_CALL_ARGS
-#define FIO_CHANNEL_SEND_MSG_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_SEND_MSG_ARGS
+#define FIO_CHANNEL_INDICATE_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_INDICATE_ARGS
 #define FIO_CHANNEL_SET_SIG_STATUS_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_SET_SIG_STATUS_ARGS
 #define FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_GET_SIG_STATUS_ARGS
 #define FIO_SPAN_SET_SIG_STATUS_FUNCTION(name) ftdm_status_t name FIO_SPAN_SET_SIG_STATUS_ARGS
@@ -879,23 +890,26 @@ FT_DECLARE(int) ftdm_channel_get_availability(ftdm_channel_t *ftdmchan);
  *        there is no guarantee of whether the event will arrive after or before your execution thread returns
  *        from ftdm_channel_call_answer 
  */
-#define ftdm_channel_call_answer(ftdmchan) _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_call_answer(ftdmchan) _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_call_answer_ex(ftdmchan, usrmsg) _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (usrmsg))
 
 /*! \brief Answer call recording the source code point where the it was called (see ftdm_channel_call_answer for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_answer(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_answer(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Place an outgoing call in the given channel 
  *  \deprecated This macro is deprecated since leaves the door open to glare issues, use ftdm_call_place instead
  */
-#define ftdm_channel_call_place(ftdmchan) _ftdm_channel_call_place(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_call_place(ftdmchan) _ftdm_channel_call_place(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_call_place_ex(ftdmchan, usrmsg) _ftdm_channel_call_place_ex(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (usrmsg))
 
 /*! \brief Place an outgoing call recording the source code point where it was called (see ftdm_channel_call_place for an easy to use macro) 
  *  \deprecated This function is deprecated since leaves the door open to glare issues, use ftdm_call_place instead
  */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Place an outgoing call with the given caller data in a channel according to the hunting scheme provided */
-#define ftdm_call_place(callerdata, hunting) _ftdm_call_place(__FILE__, __FUNCTION__, __LINE__, (callerdata), (hunting))
+#define ftdm_call_place(callerdata, hunting) _ftdm_call_place(__FILE__, __FUNCTION__, __LINE__, (callerdata), (hunting), NULL)
+#define ftdm_call_place_ex(callerdata, hunting, usrmsg) _ftdm_call_place(__FILE__, __FUNCTION__, __LINE__, (callerdata), (hunting), (usrmsg))
 
 /*! \brief Place an outgoing call with the given caller data in a channel according to the hunting scheme provided and records
  *         the place where it was called. See ftdm_call_place for an easy to use macro
@@ -912,7 +926,7 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char
  *  \note When this function is successful you are guaranteed to receive FTDM_SIGEVENT_DIALING, this event could even be delivered
  *        before your execution thread returns from this function
  */
-FT_DECLARE(ftdm_status_t) _ftdm_call_place(const char *file, const char *func, int line, ftdm_caller_data_t *caller_data, ftdm_hunting_scheme_t *hunting);
+FT_DECLARE(ftdm_status_t) _ftdm_call_place(const char *file, const char *func, int line, ftdm_caller_data_t *caller_data, ftdm_hunting_scheme_t *hunting, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Indicate a new condition in an incoming call 
  *
@@ -927,48 +941,48 @@ FT_DECLARE(ftdm_status_t) _ftdm_call_place(const char *file, const char *func, i
  * \note  You cannot send more than one indication at the time. You must wait for the completed event before 
  *        calling this function again (unless the return code was different than FTDM_SUCCESS)
  */
-#define ftdm_channel_call_indicate(ftdmchan, indication) _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication))
+#define ftdm_channel_call_indicate(ftdmchan, indication) _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication), NULL)
+#define ftdm_channel_call_indicate_ex(ftdmchan, indication, usrmsg) _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication), (usrmsg))
 
 /*! \brief Indicate a new condition in an incoming call recording the source code point where it was called (see ftdm_channel_call_indicate for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication);
-
-/*! \brief Send a message on a call */
-#define ftdm_channel_call_send_msg(ftdmchan, sigmsg) _ftdm_channel_call_send_msg(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (sigmsg))
-
-/*! \brief Send a signal on a call recording the source code point where it was called (see ftdm_channel_call_send_msg for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_send_msg(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_indicate(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Hangup the call without cause */
-#define ftdm_channel_call_hangup(ftdmchan) _ftdm_channel_call_hangup(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_call_hangup(ftdmchan) _ftdm_channel_call_hangup(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_call_hangup_ex(ftdmchan, usrmsg) _ftdm_channel_call_hangup(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (usrmsg))
 
 /*! \brief Hangup the call without cause recording the source code point where it was called (see ftdm_channel_call_hangup for an easy to use macro)*/
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Hangup the call with cause */
-#define ftdm_channel_call_hangup_with_cause(ftdmchan, cause) _ftdm_channel_call_hangup_with_cause(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (cause))
+#define ftdm_channel_call_hangup_with_cause(ftdmchan, cause) _ftdm_channel_call_hangup_with_cause(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (cause), NULL)
+#define ftdm_channel_call_hangup_with_cause_ex(ftdmchan, cause, usrmsg) _ftdm_channel_call_hangup_with_cause(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (cause), (usrmsg))
 
 /*! \brief Hangup the call with cause recording the source code point where it was called (see ftdm_channel_call_hangup_with_cause for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup_with_cause(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_call_cause_t);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hangup_with_cause(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_call_cause_t, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Reset the channel */
-#define ftdm_channel_reset(ftdmchan) _ftdm_channel_reset(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_reset(ftdmchan) _ftdm_channel_reset(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_reset_ex(ftdmchan, usrmsg) _ftdm_channel_reset(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), usrmsg)
 
 /*! \brief Reset the channel (see _ftdm_channel_reset for an easy to use macro) 
  *  \note if there was a call on this channel, call will be cleared without any notifications to the user
  */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_reset(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_reset(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Put a call on hold (if supported by the signaling stack) */
-#define ftdm_channel_call_hold(ftdmchan) _ftdm_channel_call_hold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_call_hold(ftdmchan) _ftdm_channel_call_hold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_call_hold_ex(ftdmchan, usrmsg) _ftdm_channel_call_hold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (usrmsg))
 
 /*! \brief Put a call on hold recording the source code point where it was called (see ftdm_channel_call_hold for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_hold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Unhold a call */
-#define ftdm_channel_call_unhold(ftdmchan) _ftdm_channel_call_unhold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
+#define ftdm_channel_call_unhold(ftdmchan) _ftdm_channel_call_unhold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), NULL)
+#define ftdm_channel_call_unhold_ex(ftdmchan, usrmsg) _ftdm_channel_call_unhold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (usrmsg))
 
 /*! \brief Unhold a call recording the source code point where it was called (see ftdm_channel_call_unhold for an easy to use macro) */
-FT_DECLARE(ftdm_status_t) _ftdm_channel_call_unhold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);
+FT_DECLARE(ftdm_status_t) _ftdm_channel_call_unhold(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
 
 /*! \brief Check if the call is answered already */
 FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_answered(const ftdm_channel_t *ftdmchan);
@@ -1382,24 +1396,55 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_read(ftdm_channel_t *ftdmchan, void *data
  */
 FT_DECLARE(ftdm_status_t) ftdm_channel_write(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t datasize, ftdm_size_t *datalen);
 
-/*! \brief Add a custom variable to the channel
- *  \note This variables may be used by signaling modules to override signaling parameters
- *  \todo Document which signaling variables are available
- * */
-FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value);
+/*! \brief Get a custom variable from the sigmsg
+ *  \note The variable pointer returned is only valid while the before the event is processed and it'll be destroyed once the event is processed. */
+FT_DECLARE(const char *) ftdm_sigmsg_get_var(ftdm_sigmsg_t *sigmsg, const char *var_name);
 
-/*! \brief Get a custom variable from the channel. 
- *  \note The variable pointer returned is only valid while the channel is open and it'll be destroyed when the channel is closed. */
-FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name);
-
-/*! \brief Get an iterator to iterate over the channel variables
- *  \param ftdmchan The channel structure containing the variables
+/*! \brief Get an iterator to iterate over the sigmsg variables
+ *  \param sigmsg The message structure containing the variables
  *  \param iter Optional iterator. You can reuse an old iterator (not previously freed) to avoid the extra allocation of a new iterator.
  *  \note The iterator pointer returned is only valid while the channel is open and it'll be destroyed when the channel is closed. 
  *        This iterator is completely non-thread safe, if you are adding variables or removing variables while iterating 
  *        results are unpredictable
  */
-FT_DECLARE(ftdm_iterator_t *) ftdm_channel_get_var_iterator(const ftdm_channel_t *ftdmchan, ftdm_iterator_t *iter);
+FT_DECLARE(ftdm_iterator_t *) ftdm_sigmsg_get_var_iterator(const ftdm_sigmsg_t *sigmsg, ftdm_iterator_t *iter);
+
+/*! \brief Get raw data from sigmsg
+ *  \param sigmsg The message structure containing the variables
+ *  \param data	data will point to available data pointer if available
+ *  \param datalen datalen will be set to length of data available
+ *  \retval FTDM_SUCCESS data is available
+ *  \retval FTDM_FAIL no data available
+ *  \note data is only valid within the duration of the callback, to receive a data pointer that does not get
+ *  \note destroyed when callback returns, see ftdm_sigmsg_get_raw_data_detached
+ */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_get_raw_data(ftdm_sigmsg_t *sigmsg, void **data, ftdm_size_t *datalen);
+
+/*! \brief Get raw data from event
+ *  \param sigmsg The message structure containing the variables
+ *  \param data	data will point to available data pointer if available
+ *  \param datalen datalen will be set to length of data available
+ *  \retval FTDM_SUCCESS data is available
+ *  \retval FTDM_FAIL no data available
+ *  \note Once this function returns, User owns data, and is responsible to free data using ftdm_safe_free();
+ */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_get_raw_data_detached(ftdm_sigmsg_t *sigmsg, void **data, ftdm_size_t *datalen);
+
+/*! \brief Add a custom variable to the user message
+ *  \note This variables may be used by signaling modules to override signaling parameters
+ *  \todo Document which signaling variables are available
+ * */
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_add_var(ftdm_usrmsg_t *usrmsg, const char *var_name, const char *value);
+
+/*! \brief Attach raw data to usrmsg
+ *  \param usrmsg The message structure containing the variables
+ *  \param data pointer to data
+ *  \param datalen datalen length of data
+ *  \retval FTDM_SUCCESS success, data was successfully saved
+ *  \retval FTDM_FAIL failed, event already had data attached to it.
+ *  \note data must have been allocated using ftdm_calloc, FreeTDM will free data once the usrmsg is processed.
+ */
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_set_raw_data(ftdm_usrmsg_t *usrmsg, void *data, ftdm_size_t datalen);
 
 /*! \brief Get iterator current value (depends on the iterator type)
  *  \note Channel iterators return a pointer to ftdm_channel_t
@@ -1408,7 +1453,7 @@ FT_DECLARE(ftdm_iterator_t *) ftdm_channel_get_var_iterator(const ftdm_channel_t
 FT_DECLARE(void *) ftdm_iterator_current(ftdm_iterator_t *iter);
 
 /*! \brief Get variable name and value for the current iterator position */
-FT_DECLARE(ftdm_status_t) ftdm_channel_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val);
+FT_DECLARE(ftdm_status_t) ftdm_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val);
 
 /*! \brief Advance iterator */
 FT_DECLARE(ftdm_iterator_t *) ftdm_iterator_next(ftdm_iterator_t *iter);
@@ -1418,40 +1463,6 @@ FT_DECLARE(ftdm_iterator_t *) ftdm_iterator_next(ftdm_iterator_t *iter);
  */
 FT_DECLARE(ftdm_status_t) ftdm_iterator_free(ftdm_iterator_t *iter);
 
-/*! \brief Add a custom variable to the call
- *  \note This variables may be used by signaling modules to override signaling parameters
- *  \todo Document which signaling variables are available
- * */
-FT_DECLARE(ftdm_status_t) ftdm_call_add_var(ftdm_caller_data_t *caller_data, const char *var_name, const char *value);
-
-/*! \brief Get a custom variable from the call.
- *  \note The variable pointer returned is only valid during the callback receiving SIGEVENT. */
-FT_DECLARE(const char *) ftdm_call_get_var(ftdm_caller_data_t *caller_data, const char *var_name);
-
-/*! \brief Get an iterator to iterate over the channel variables
- *  \param caller_data The signal msg structure containing the variables
- *  \param iter Optional iterator. You can reuse an old iterator (not previously freed) to avoid the extra allocation of a new iterator.
- *  \note The iterator pointer returned is only valid while the signal message and it'll be destroyed when the signal message is processed.
- *        This iterator is completely non-thread safe, if you are adding variables or removing variables while iterating
- *        results are unpredictable
- */
-FT_DECLARE(ftdm_iterator_t *) ftdm_call_get_var_iterator(const ftdm_caller_data_t *caller_data, ftdm_iterator_t *iter);
-
-/*! \brief Get variable name and value for the current iterator position */
-FT_DECLARE(ftdm_status_t) ftdm_call_get_current_var(ftdm_iterator_t *iter, const char **var_name, const char **var_val);
-
-/*! \brief Clear all variables  attached to the call
- *  \note Variables are cleared at the end of each call back, so it is not necessary for the user to call this function.
- *  \todo Document which signaling variables are available
- * */
-FT_DECLARE(ftdm_status_t) ftdm_call_clear_vars(ftdm_caller_data_t *caller_data);
-
-/*! \brief Remove a variable attached to the call
- *  \note Removes a variable that was attached to the call.
- *  \todo Document which call variables are available
- * */
-FT_DECLARE(ftdm_status_t) ftdm_call_remove_var(ftdm_caller_data_t *caller_data, const char *var_name);
-
 /*! \brief Clears all the temporary data attached to this call
  *  \note Clears caller_data->variables and caller_data->raw_data.
  * */
diff --git a/libs/freetdm/src/include/ftdm_declare.h b/libs/freetdm/src/include/ftdm_declare.h
index b443f2d5f5..9c7f9cbe4a 100644
--- a/libs/freetdm/src/include/ftdm_declare.h
+++ b/libs/freetdm/src/include/ftdm_declare.h
@@ -223,6 +223,7 @@ typedef struct ftdm_conf_node ftdm_conf_node_t;
 typedef struct ftdm_group ftdm_group_t;
 typedef size_t ftdm_size_t;
 typedef struct ftdm_sigmsg ftdm_sigmsg_t;
+typedef struct ftdm_usrmsg ftdm_usrmsg_t;
 typedef struct ftdm_io_interface ftdm_io_interface_t;
 typedef struct ftdm_stream_handle ftdm_stream_handle_t;
 typedef struct ftdm_queue ftdm_queue_t;
diff --git a/libs/freetdm/src/include/private/ftdm_core.h b/libs/freetdm/src/include/private/ftdm_core.h
index 7b26d655c5..464b1c0209 100644
--- a/libs/freetdm/src/include/private/ftdm_core.h
+++ b/libs/freetdm/src/include/private/ftdm_core.h
@@ -468,6 +468,7 @@ struct ftdm_channel {
 	ftdm_interrupt_t *state_completed_interrupt; /*!< Notify when a state change is completed */
 	int32_t txdrops;
 	int32_t rxdrops;
+	ftdm_usrmsg_t *usrmsg;
 };
 
 struct ftdm_span {
@@ -493,7 +494,7 @@ struct ftdm_span {
 	teletone_multi_tone_t tone_finder[FTDM_TONEMAP_INVALID+1];
 	ftdm_channel_t *channels[FTDM_MAX_CHANNELS_SPAN+1];
 	fio_channel_outgoing_call_t outgoing_call;
-	fio_channel_send_msg_t send_msg;
+	fio_channel_indicate_t indicate;
 	fio_channel_set_sig_status_t set_channel_sig_status;
 	fio_channel_get_sig_status_t get_channel_sig_status;
 	fio_span_set_sig_status_t set_span_sig_status;
@@ -588,6 +589,10 @@ FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
 FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
 FT_DECLARE(void) ftdm_ack_indication(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_status_t status);
 
+
+FT_DECLARE(ftdm_iterator_t) *ftdm_get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter);
+
+
 /*! 
  * \brief Retrieves an event from the span
  *
@@ -625,10 +630,57 @@ FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
 /*! \brief clear the tone detector state */
 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
 
-/* start/stop echo cancelling at the beginning/end of a call */
+/*! \brief adjust echocanceller for beginning of call */
 FT_DECLARE(void) ftdm_set_echocancel_call_begin(ftdm_channel_t *chan);
+
+/*! \brief adjust echocanceller for end of call */
 FT_DECLARE(void) ftdm_set_echocancel_call_end(ftdm_channel_t *chan);
 
+
+/*! \brief save data from user */
+FT_DECLARE(ftdm_status_t) ftdm_channel_save_usrmsg(ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
+
+/*! \brief free usrmsg and variables/raw data attached to it */
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_free(ftdm_usrmsg_t **usrmsg);
+
+/*! \brief Get a custom variable from the user message
+ *  \note The variable pointer returned is only valid while the before the event is processed and it'll be destroyed once the event is processed. */
+FT_DECLARE(const char *) ftdm_usrmsg_get_var(ftdm_usrmsg_t *usrmsg, const char *var_name);
+
+/*! \brief Get raw data from user message
+ *  \param usrmsg The message structure containing the variables
+ *  \param data	data will point to available data pointer if available
+ *  \param datalen datalen will be set to length of data available
+ *  \retval FTDM_SUCCESS data is available
+ *  \retval FTDM_FAIL no data available
+ *  \note data is only valid within the duration of the callback, to receive a data pointer that does not get
+ *  \note destroyed when callback returns, see ftdm_sigmsg_get_raw_data_detached
+ */
+FT_DECLARE(ftdm_status_t) ftdm_usrmsg_get_raw_data(ftdm_usrmsg_t *usrmsg, void **data, ftdm_size_t *datalen);
+
+/*! \brief free sigmsg and variables/raw data attached to it */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_free(ftdm_sigmsg_t **sigmsg);
+
+/*! \brief Add a custom variable to the event
+ *  \note This variables may be used by signaling modules to override signaling parameters
+ *  \todo Document which signaling variables are available
+ * */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_add_var(ftdm_sigmsg_t *sigmsg, const char *var_name, const char *value);
+
+/*! \brief Remove a custom variable from the event
+ *  \note The variable pointer returned is only valid while the before the event is processed and it'll be destroyed once the event is processed. */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_remove_var(ftdm_sigmsg_t *sigmsg, const char *var_name);
+
+/*! \brief Attach raw data to sigmsg
+ *  \param sigmsg The message structure containing the variables
+ *  \param data pointer to data
+ *  \param datalen datalen length of data
+ *  \retval FTDM_SUCCESS success, data was successfully saved
+ *  \retval FTDM_FAIL failed, event already had data attached to it.
+ *  \note data must have been allocated using ftdm_calloc, FreeTDM will free data once the usrmsg is processed.
+ */
+FT_DECLARE(ftdm_status_t) ftdm_sigmsg_set_raw_data(ftdm_sigmsg_t *sigmsg, void *data, ftdm_size_t datalen);
+
 /*!
   \brief Assert condition
 */
diff --git a/libs/freetdm/src/include/private/ftdm_state.h b/libs/freetdm/src/include/private/ftdm_state.h
index 5672839d15..191f8aef82 100644
--- a/libs/freetdm/src/include/private/ftdm_state.h
+++ b/libs/freetdm/src/include/private/ftdm_state.h
@@ -188,7 +188,7 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_cancel_state(const char *file, const char
  * \note If this function is called with the wait parameter set to a non-zero value, the recursivity
  *       of the channel lock must be == 1 because the channel will be unlocked/locked when waiting */
 FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line,
-		ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int wait);
+		ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int wait, ftdm_usrmsg_t *usrmsg);
 
 /*!\brief Set the state of a channel immediately and implicitly complete the previous state if needed 
  * \note FTDM_SIGEVENT_INDICATION_COMPLETED will be sent if the state change 
@@ -207,7 +207,7 @@ FT_DECLARE(ftdm_status_t) _ftdm_set_state(const char *file, const char *func, in
 #define ftdm_set_state_locked(obj, s) \
 	do { \
 		ftdm_channel_lock(obj); \
-		ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);									\
+		ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0, NULL);									\
 		ftdm_channel_unlock(obj); \
 	} while(0);