chlog: freetdm: channel/call variables moved to sigmsg

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

@@ -649,8 +649,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 +673,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 +693,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 +709,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 +721,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 +734,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 +761,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 +875,22 @@ static ftdm_status_t ftdm_sangoma_isdn_process_state_change(ftdm_channel_t *ftdm
 		}
 		break;
 	}
-	
+
+	/* If sngisdn_info->variables is not NULL, it means did not send any
+	* sigevent to the user, therefore we have to free that sigmsg */
+	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 sigmsg */
+	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");
 	}
@@ -902,8 +914,7 @@ static FIO_CHANNEL_SEND_MSG_FUNCTION(ftdm_sangoma_isdn_send_msg)
 		default:
 			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING, "Unsupported signalling msg requested\n");
 			status = FTDM_BREAK;
-	}
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+	}	
 	return status;
 }
 
@@ -911,34 +922,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)

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);

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,7 +267,6 @@ 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;
@@ -306,7 +300,7 @@ void sngisdn_snd_info_req(ftdm_channel_t *ftdmchan)
 	//ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "Sending INFO REQ\n");
 
 
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+	
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending INFO REQ (suId:%d dchan:%d ces:%d)\n", signal_data->cc_id, signal_data->dchan_id, sngisdn_info->ces);
 
@@ -327,8 +321,6 @@ void sngisdn_snd_status_enq(ftdm_channel_t *ftdmchan)
 	//ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "Sending STATUS ENQ\n");
 
 	memset(&staEvnt, 0, sizeof(StaEvnt));
-
-	ftdm_call_clear_data(&ftdmchan->caller_data);
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending Status ENQ on suId:%d suInstId:%u spInstId:%d dchan:%d ces:%d\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, signal_data->dchan_id, sngisdn_info->ces);
 	if (sng_isdn_status_request(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &staEvnt, MI_STATENQ)) {
@@ -367,8 +359,7 @@ void sngisdn_snd_disconnect(ftdm_channel_t *ftdmchan)
 	discEvnt.causeDgn[0].recommend.pres = NOTPRSNT;
 	discEvnt.causeDgn[0].dgnVal.pres = NOTPRSNT;
 
-	set_facility_ie(ftdmchan, &discEvnt.facilityStr);
-	ftdm_call_clear_data(&ftdmchan->caller_data);
+	set_facility_ie(ftdmchan, &discEvnt.facilityStr);	
 
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending DISCONNECT (suId:%d suInstId:%u spInstId:%u)\n", signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId);
 	if (sng_isdn_disc_request(signal_data->cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId, &discEvnt)) {
@@ -416,7 +407,6 @@ void sngisdn_snd_release(ftdm_channel_t *ftdmchan, uint8_t glare)
 	}
 
 	set_facility_ie(ftdmchan, &relEvnt.facilityStr);
-	ftdm_call_clear_data(&ftdmchan->caller_data);
 	
 	ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Sending RELEASE/RELEASE COMPLETE (suId:%d suInstId:%u spInstId:%u)\n", signal_data->cc_id, suInstId, spInstId);
 

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

@@ -225,26 +225,26 @@ ftdm_status_t get_calling_num2(ftdm_channel_t *ftdmchan, CgPtyNmb *cgPtyNmb)
 	}
 
 	if (cgPtyNmb->screenInd.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.screen_ind", ftdm_screening2str(cgPtyNmb->screenInd.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.screen_ind", ftdm_screening2str(cgPtyNmb->screenInd.val));
 	}
 
 	if (cgPtyNmb->presInd0.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.presentation_ind", ftdm_presentation2str(cgPtyNmb->presInd0.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.presentation_ind", ftdm_presentation2str(cgPtyNmb->presInd0.val));
 	}
 
 	if (cgPtyNmb->nmbPlanId.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.npi", ftdm_npi2str(cgPtyNmb->nmbPlanId.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.npi", ftdm_npi2str(cgPtyNmb->nmbPlanId.val));
 	}
 		
 	if (cgPtyNmb->typeNmb1.pres == PRSNT_NODEF) {
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.ton", ftdm_ton2str(cgPtyNmb->typeNmb1.val));
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.ton", ftdm_ton2str(cgPtyNmb->typeNmb1.val));
 	}
 	
 	if (cgPtyNmb->nmbDigits.pres == PRSNT_NODEF) {
 		char digits_string [32];
 		memcpy(digits_string, (const char*)cgPtyNmb->nmbDigits.val, cgPtyNmb->nmbDigits.len);
 		digits_string[cgPtyNmb->nmbDigits.len] = '\0';
-		ftdm_call_add_var(caller_data, "isdn.cg_pty2.digits", digits_string);
+		sngisdn_add_var((sngisdn_chan_data_t*)ftdmchan->call_data, "isdn.cg_pty2.digits", digits_string);
 	}
 	memcpy(&caller_data->ani, &caller_data->cid_num, sizeof(caller_data->ani));
 	return FTDM_SUCCESS;
@@ -343,7 +343,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 +358,20 @@ 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 */
@@ -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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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_event_get_raw_data(ftdmchan->sigmsg, (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_event_get_var(ftdmchan->sigmsg, "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_event_get_var(ftdmchan->sigmsg, "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,75 @@ 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;
+		sigev.raw.autofree = 1;
+		
+		sngisdn_info->raw_data = NULL;
+		sngisdn_info->raw_data_len = 0;
+	}
+	ftdm_span_send_signal(ftdmchan->span, &sigev);
+}
+
+
 /* For Emacs:
  * Local Variables:
  * mode:c