refactor some of the message parsing code to use fifo to reduce threading contention

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@15142 d0543943-73ff-0310-b7d9-9358b9ac24b2

src/include/switch_core.h

@@ -59,6 +59,7 @@ struct switch_app_log {
 	struct switch_app_log *next;
 };
 
+#define MESSAGE_STRING_ARG_MAX 10
 /*! \brief A message object designed to allow unlike technologies to exchange data */
 struct switch_core_session_message {
 	/*! uuid of the sender (for replies) */
@@ -92,7 +93,7 @@ struct switch_core_session_message {
 	const char *_file;
 	const char *_func;
 	int _line;
-	const char *string_array_arg[10];
+	const char *string_array_arg[MESSAGE_STRING_ARG_MAX];
 };
 
 /*! \brief A generic object to pass as a thread's session object to allow mutiple arguements and a pool */
@@ -634,6 +635,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_thread_launch(_In_ switch_co
 /*! 
   \brief Signal a session's state machine thread that a state change has occured
 */
+SWITCH_DECLARE(void) switch_core_session_wake_session_thread(_In_ switch_core_session_t *session);
 SWITCH_DECLARE(void) switch_core_session_signal_state_change(_In_ switch_core_session_t *session);
 
 /*! 
@@ -653,6 +655,10 @@ SWITCH_DECLARE(char *) switch_core_get_uuid(void);
 SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_locate(const char *uuid_str, const char *file, const char *func, int line);
 #endif
 
+#ifdef SWITCH_DEBUG_RWLOCKS
+SWITCH_DECLARE(switch_core_session_t *) switch_core_session_perform_force_locate(const char *uuid_str, const char *file, const char *func, int line);
+#endif
+
 /*! 
   \brief Locate a session based on it's uuid
   \param uuid_str the unique id of the session you want to find
@@ -737,6 +743,8 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_message_send(_In_z_ const ch
 */
 SWITCH_DECLARE(switch_status_t) switch_core_session_queue_message(_In_ switch_core_session_t *session, _In_ switch_core_session_message_t *message);
 
+SWITCH_DECLARE(void) switch_core_session_free_message(switch_core_session_message_t **message);
+
 /*! 
   \brief pass an indication message on a session
   \param session the session to pass the message across

src/include/switch_ivr.h

@@ -102,6 +102,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_parse_event(_In_ switch_core_session_
 */
 SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_events(switch_core_session_t *session);
 SWITCH_DECLARE(switch_status_t) switch_ivr_parse_next_event(switch_core_session_t *session);
+SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_messages(switch_core_session_t *session);
 
 /*!
   \brief Wait for time to pass for a specified number of milliseconds

src/mod/applications/mod_conference/mod_conference.c

@@ -2359,6 +2359,8 @@ static void conference_loop_output(conference_member_t *member)
 			switch_channel_clear_app_flag(channel, CF_APP_TAGGED);
 			switch_set_flag_locked(member, MFLAG_FLUSH_BUFFER);
 			switch_core_session_set_read_codec(member->session, &member->read_codec);
+		} else {
+			switch_ivr_parse_all_messages(member->session);
 		}
 		
 		if (use_timer) {

src/mod/endpoints/mod_alsa/mod_alsa.c

@@ -243,7 +243,6 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
 			}
 		}
 
-		switch_core_session_queue_indication(session, SWITCH_MESSAGE_INDICATE_RINGING);
 		switch_channel_mark_ring_ready(channel);
 
 		while (switch_channel_get_state(channel) == CS_INIT && !switch_test_flag(tech_pvt, TFLAG_ANSWER)) {

src/mod/endpoints/mod_dingaling/mod_dingaling.c

@@ -1090,7 +1090,6 @@ static switch_status_t negotiate_media(switch_core_session_t *session)
 	started = switch_micro_time_now();
 
 	/* jingle has no ringing indication so we will just pretend that we got one */
-	switch_core_session_queue_indication(session, SWITCH_MESSAGE_INDICATE_RINGING);
 	switch_channel_mark_ring_ready(channel);
 
 	if (switch_test_flag(tech_pvt, TFLAG_OUTBOUND)) {

src/mod/endpoints/mod_iax/mod_iax.c

@@ -1032,7 +1032,6 @@ SWITCH_MODULE_RUNTIME_FUNCTION(mod_iax_runtime)
 				break;
 			case IAX_EVENT_RINGA:
 				if (channel) {
-					switch_core_session_queue_indication(tech_pvt->session, SWITCH_MESSAGE_INDICATE_RINGING);
 					switch_channel_mark_ring_ready(channel);
 				}
 				switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_NOTICE, "Ringing heard.\n");

src/mod/endpoints/mod_portaudio/mod_portaudio.c

@@ -248,7 +248,6 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
 			switch_mutex_unlock(globals.pvt_lock);
 			switch_yield(1000000);
 		} else {
-			switch_core_session_queue_indication(session, SWITCH_MESSAGE_INDICATE_RINGING);
 			switch_channel_mark_ring_ready(channel);
 		}
 

src/mod/endpoints/mod_sofia/sofia.c

@@ -401,13 +401,14 @@ void sofia_send_callee_id(switch_core_session_t *session, const char *name, cons
 	}
 	
 	if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE)) && (session_b = switch_core_session_locate(uuid))) {
-		switch_core_session_message_t msg = { 0 };
+		switch_core_session_message_t *msg;
 		
-		msg.message_id = SWITCH_MESSAGE_INDICATE_DISPLAY;
+		msg = switch_core_session_alloc(session_b, sizeof(*msg));
-		msg.string_array_arg[0] = name;
+		msg->message_id = SWITCH_MESSAGE_INDICATE_DISPLAY;
-		msg.string_array_arg[1] = number;
+		msg->string_array_arg[0] = switch_core_session_strdup(session_b, name);
-		msg.from = __FILE__;
+		msg->string_array_arg[1] = switch_core_session_strdup(session_b, number);
-		switch_core_session_receive_message(session_b, &msg);
+		msg->from = __FILE__;
+		switch_core_session_queue_message(session_b, msg);
 		switch_core_session_rwunlock(session_b);
 	}
 }
@@ -3275,7 +3276,7 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
 
 			if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE)) && (other_session = switch_core_session_locate(uuid))) {
 				const char *r_sdp = NULL;
-				switch_core_session_message_t msg = { 0 };
+				switch_core_session_message_t *msg;
 
 				if (sip->sip_payload && sip->sip_payload->pl_data &&
 					sip->sip_content_type && sip->sip_content_type->c_subtype && switch_stristr("sdp", sip->sip_content_type->c_subtype)) {
@@ -3286,23 +3287,17 @@ static void sofia_handle_sip_r_invite(switch_core_session_t *session, int status
 
 				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Passing %d %s to other leg\n", status, phrase);
 
-				msg.message_id = SWITCH_MESSAGE_INDICATE_RESPOND;
+				msg = switch_core_session_alloc(other_session, sizeof(*msg));
-				msg.from = __FILE__;
+				msg->message_id = SWITCH_MESSAGE_INDICATE_RESPOND;
-				msg.numeric_arg = status;
+				msg->from = __FILE__;
-				msg.string_arg = switch_core_session_strdup(other_session, phrase);
+				msg->numeric_arg = status;
+				msg->string_arg = switch_core_session_strdup(other_session, phrase);
 				if (r_sdp) {
-					msg.pointer_arg = switch_core_session_strdup(other_session, r_sdp);
+					msg->pointer_arg = switch_core_session_strdup(other_session, r_sdp);
-					msg.pointer_arg_size = strlen(r_sdp);
+					msg->pointer_arg_size = strlen(r_sdp);
 				}
 
-				switch_mutex_unlock(tech_pvt->sofia_mutex);
+				switch_core_session_queue_message(other_session, msg);
-				status = switch_core_session_receive_message(other_session, &msg);
-				switch_mutex_lock(tech_pvt->sofia_mutex);
-
-				if (status != SWITCH_STATUS_SUCCESS) {
-					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Other leg is not available\n");
-					nua_respond(tech_pvt->nh, 403, "Hangup in progress", TAG_END());
-				}
 				switch_core_session_rwunlock(other_session);
 			}
 			return;
@@ -3550,23 +3545,6 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 	case nua_callstate_proceeding:
 		if (status == 180) {
 			switch_channel_mark_ring_ready(channel);
-			if (!switch_channel_test_flag(channel, CF_GEN_RINGBACK)) {
-				if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
-					if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))
-						&& (other_session = switch_core_session_locate(uuid))) {
-						switch_core_session_message_t msg;
-						msg.message_id = SWITCH_MESSAGE_INDICATE_RINGING;
-						msg.from = __FILE__;
-						switch_mutex_unlock(tech_pvt->sofia_mutex);
-						switch_core_session_receive_message(other_session, &msg);
-						switch_mutex_lock(tech_pvt->sofia_mutex);
-						switch_core_session_rwunlock(other_session);
-					}
-
-				} else {
-					switch_core_session_queue_indication(session, SWITCH_MESSAGE_INDICATE_RINGING);
-				}
-			}
 		}
 			
 		if (r_sdp) {
@@ -3582,7 +3560,7 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 						goto done;
 					}
 				}
-				if (!switch_channel_test_flag(channel, CF_GEN_RINGBACK) && (uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))
+				if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))
 					&& (other_session = switch_core_session_locate(uuid))) {
 					other_channel = switch_core_session_get_channel(other_session);
 					if (!switch_channel_get_variable(other_channel, SWITCH_B_SDP_VARIABLE)) {
@@ -3764,7 +3742,7 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 					
 					if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))
 						&& (other_session = switch_core_session_locate(uuid))) {
-						switch_core_session_message_t msg = { 0 };
+						switch_core_session_message_t *msg;
 						
 						if (profile->media_options & MEDIA_OPT_MEDIA_ON_HOLD) {
 							tech_pvt->hold_laps = 1;
@@ -3807,9 +3785,10 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 							goto done;
 						}
 						
-						msg.message_id = SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT;
+						msg = switch_core_session_alloc(other_session, sizeof(*msg));
-						msg.from = __FILE__;
+						msg->message_id = SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT;
-						msg.string_arg = (char *) r_sdp;
+						msg->from = __FILE__;
+						msg->string_arg = switch_core_session_strdup(other_session, r_sdp);
 						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Passing SDP to other leg.\n%s\n", r_sdp);
 						
 						if (sofia_test_flag(tech_pvt, TFLAG_SIP_HOLD)) {
@@ -3822,17 +3801,12 @@ static void sofia_handle_sip_i_state(switch_core_session_t *session, int status,
 							switch_channel_presence(tech_pvt->channel, "unknown", "hold", NULL);
 						}
 					
-						switch_mutex_unlock(tech_pvt->sofia_mutex);
+						switch_core_session_queue_message(other_session, msg);
-						status = switch_core_session_receive_message(other_session, &msg);
-						switch_mutex_lock(tech_pvt->sofia_mutex);
 
-						if (status != SWITCH_STATUS_SUCCESS) {
-							switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Other leg is not available\n");
-							nua_respond(tech_pvt->nh, 403, "Hangup in progress", TAG_END());
-						}
 						switch_core_session_rwunlock(other_session);
 					} else {
-						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Re-INVITE to a no-media channel that is not in a bridge.\n");
+						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, 
+										  "Re-INVITE to a no-media channel that is not in a bridge.\n");
 						is_ok = 0;
 						switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
 					}

src/switch_channel.c

@@ -176,7 +176,7 @@ SWITCH_DECLARE(switch_call_cause_t) switch_channel_get_cause(switch_channel_t *c
 SWITCH_DECLARE(void) switch_channel_audio_sync(switch_channel_t *channel) 
 {
 	if (switch_channel_media_ready(channel)) {
-		switch_core_session_message_t msg;
+		switch_core_session_message_t msg = { 0 };
 		msg.message_id = SWITCH_MESSAGE_INDICATE_AUDIO_SYNC;
 		msg.from = channel->name;
 		switch_core_session_receive_message(channel->session, &msg);
@@ -1914,7 +1914,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_pre_answered(switch_
 
 SWITCH_DECLARE(switch_status_t) switch_channel_perform_pre_answer(switch_channel_t *channel, const char *file, const char *func, int line)
 {
-	switch_core_session_message_t msg;
+	switch_core_session_message_t msg = { 0 };
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_assert(channel != NULL);
@@ -1948,7 +1948,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_pre_answer(switch_channel
 
 SWITCH_DECLARE(switch_status_t) switch_channel_perform_ring_ready(switch_channel_t *channel, const char *file, const char *func, int line)
 {
-	switch_core_session_message_t msg;
+	switch_core_session_message_t msg = { 0 };
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_assert(channel != NULL);
@@ -2064,7 +2064,7 @@ SWITCH_DECLARE(switch_status_t) switch_channel_perform_mark_answered(switch_chan
 
 SWITCH_DECLARE(switch_status_t) switch_channel_perform_answer(switch_channel_t *channel, const char *file, const char *func, int line)
 {
-	switch_core_session_message_t msg;
+	switch_core_session_message_t msg = { 0 };
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 
 	switch_assert(channel != NULL);

src/switch_core_session.c

@@ -633,6 +633,7 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_perform_receive_message(swit
 		break;
 	}
 
+	switch_core_session_free_message(&message);
 	switch_core_session_rwunlock(session);
 
 	return status;
@@ -684,11 +685,37 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_queue_message(switch_core_se
 		if (switch_queue_trypush(session->message_queue, message) == SWITCH_STATUS_SUCCESS) {
 			status = SWITCH_STATUS_SUCCESS;
 		}
+
+		if (switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
+			switch_core_session_wake_session_thread(session);
+		}
 	}
 
 	return status;
 }
 
+SWITCH_DECLARE(void) switch_core_session_free_message(switch_core_session_message_t **message)
+{
+	switch_core_session_message_t *to_free = *message;
+	int i;
+	char *s;
+
+	*message = NULL;
+
+	if (switch_test_flag(to_free, SCSMF_DYNAMIC)) {
+		s = (char *)to_free->string_arg;
+		switch_safe_free(s);
+		switch_safe_free(to_free->pointer_arg);
+		
+		for (i = 0; i < MESSAGE_STRING_ARG_MAX; i++) {
+			s = (char *)to_free->string_array_arg[i];
+			switch_safe_free(s);
+		}
+
+		switch_safe_free(to_free);
+	}
+}
+
 SWITCH_DECLARE(switch_status_t) switch_core_session_dequeue_message(switch_core_session_t *session, switch_core_session_message_t **message)
 {
 	switch_status_t status = SWITCH_STATUS_FALSE;
@@ -709,12 +736,8 @@ SWITCH_DECLARE(switch_status_t) switch_core_session_flush_message(switch_core_se
 {
 	switch_core_session_message_t *message;
 
-	if (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
+	while (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
-		if (switch_test_flag(message, SCSMF_DYNAMIC)) {
+		switch_core_session_free_message(&message);
-			switch_safe_free(message);
-		} else {
-			message = NULL;
-		}
 	}
 
 	return SWITCH_STATUS_SUCCESS;
@@ -907,16 +930,21 @@ SWITCH_DECLARE(switch_channel_t *) switch_core_session_get_channel(switch_core_s
 	return session->channel;
 }
 
-SWITCH_DECLARE(void) switch_core_session_signal_state_change(switch_core_session_t *session)
+SWITCH_DECLARE(void) switch_core_session_wake_session_thread(switch_core_session_t *session)
 {
-	switch_status_t status = SWITCH_STATUS_SUCCESS;
-	switch_io_event_hook_state_change_t *ptr;
-
 	/* If trylock fails the signal is already awake so we needn't bother */
 	if (switch_mutex_trylock(session->mutex) == SWITCH_STATUS_SUCCESS) {
 		switch_thread_cond_signal(session->cond);
 		switch_mutex_unlock(session->mutex);
 	}
+}
+
+SWITCH_DECLARE(void) switch_core_session_signal_state_change(switch_core_session_t *session)
+{
+	switch_status_t status = SWITCH_STATUS_SUCCESS;
+	switch_io_event_hook_state_change_t *ptr;
+
+	switch_core_session_wake_session_thread(session);
 
 	if (session->endpoint_interface->io_routines->state_change) {
 		status = session->endpoint_interface->io_routines->state_change(session);

src/switch_core_state_machine.c

@@ -375,7 +375,19 @@ SWITCH_DECLARE(void) switch_core_session_run(switch_core_session_t *session)
 					switch_channel_hangup(session->channel, SWITCH_CAUSE_INVALID_CALL_REFERENCE);
 				}
 			} else {
+				switch_core_session_message_t *message;
+					
+				while (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
+					switch_core_session_receive_message(session, message);
+					message = NULL;
+				}
+				
 				switch_thread_cond_wait(session->cond, session->mutex);
+				
+				while (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
+					switch_core_session_receive_message(session, message);
+					message = NULL;
+				}
 			}
 		}
 	}

src/switch_ivr.c

@@ -220,9 +220,9 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_sleep(switch_core_session_t *session,
 			break;
 		}
 		
-		if (switch_core_session_private_event_count(session)) {
+
-			switch_ivr_parse_all_events(session);
+		switch_ivr_parse_all_events(session);
-		}
+
 
 		if (args && (args->input_callback || args->buf || args->buflen)) {
 			switch_dtmf_t dtmf;
@@ -624,10 +624,26 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_parse_next_event(switch_core_session_
 
 }
 
+SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_messages(switch_core_session_t *session)
+{
+	switch_core_session_message_t *message;
+	int i = 0;
+	
+	while (switch_core_session_dequeue_message(session, &message) == SWITCH_STATUS_SUCCESS) {
+		i++;
+		switch_core_session_receive_message(session, message);
+		message = NULL;
+	}
+
+	return i ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
+}
+
 SWITCH_DECLARE(switch_status_t) switch_ivr_parse_all_events(switch_core_session_t *session)
 {
 
+
 	while (switch_ivr_parse_next_event(session) == SWITCH_STATUS_SUCCESS);
+	switch_ivr_parse_all_messages(session);
 	switch_ivr_sleep(session, 0, SWITCH_TRUE, NULL);
 
 	return SWITCH_STATUS_SUCCESS;
@@ -773,9 +789,8 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_park(switch_core_session_t *session,
 				}
 			}
 
-			if (switch_core_session_private_event_count(session)) {
+			switch_ivr_parse_all_events(session);
-				switch_ivr_parse_all_events(session);
+
-			}
 
 			if (switch_channel_has_dtmf(channel)) {
 				switch_dtmf_t dtmf = { 0 };
@@ -859,9 +874,9 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_callback(switch_core_s
 			}
 		}
 
-		if (switch_core_session_private_event_count(session)) {
+
-			switch_ivr_parse_all_events(session);
+		switch_ivr_parse_all_events(session);
-		}
+
 
 		if (switch_channel_has_dtmf(channel)) {
 			switch_channel_dequeue_dtmf(channel, &dtmf);
@@ -990,9 +1005,9 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_collect_digits_count(switch_core_sess
 			}
 		}
 
-		if (switch_core_session_private_event_count(session)) {
+
-			switch_ivr_parse_all_events(session);
+		switch_ivr_parse_all_events(session);
-		}
+
 
 		
 		if (eff_timeout) {

src/switch_ivr_async.c

@@ -100,9 +100,7 @@ SWITCH_DECLARE(void) switch_ivr_session_echo(switch_core_session_t *session, swi
 			break;
 		}
 
-		if (switch_core_session_private_event_count(session)) {
+		switch_ivr_parse_all_events(session);
-            switch_ivr_parse_all_events(session);
-        }
 
 		if (args && (args->input_callback || args->buf || args->buflen)) {
 			switch_dtmf_t dtmf;

src/switch_ivr_bridge.c

@@ -357,11 +357,7 @@ static void *audio_bridge_thread(switch_thread_t *thread, void *obj)
 
 		if (switch_core_session_dequeue_message(session_b, &message) == SWITCH_STATUS_SUCCESS) {
 			switch_core_session_receive_message(session_a, message);
-			if (switch_test_flag(message, SCSMF_DYNAMIC)) {
+			message = NULL;
-				switch_safe_free(message);
-			} else {
-				message = NULL;
-			}
 		}
 
 		if (!ans_a && answer_limit && switch_epoch_time_now(NULL) > answer_limit) {

src/switch_ivr_originate.c

@@ -384,6 +384,9 @@ static uint8_t check_channel_status(originate_global_t *oglobals, originate_stat
 
 			if (!oglobals->ring_ready) {
 				oglobals->ring_ready = 1;
+				if (caller_channel && !oglobals->ignore_ring_ready) {
+					switch_channel_ring_ready(caller_channel);
+				}
 			}
 		}
 
@@ -534,13 +537,12 @@ static uint8_t check_channel_status(originate_global_t *oglobals, originate_stat
 				
 				if (!oglobals->ring_ready && !oglobals->ignore_ring_ready) {
 					oglobals->ring_ready = 1;
+					
 				}
 			}
 		}
 		
-		if (switch_core_session_private_event_count(originate_status[i].peer_session)) {
+		switch_ivr_parse_all_events(originate_status[i].peer_session);
-			switch_ivr_parse_all_events(originate_status[i].peer_session);
-		}
 
 		state = switch_channel_get_state(originate_status[i].peer_channel);
 		if (state >= CS_HANGUP || state == CS_RESET || switch_channel_test_flag(originate_status[i].peer_channel, CF_TRANSFER) ||
@@ -659,7 +661,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
 	switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
 	uint8_t pass = 0;
 	ringback_t ringback = { 0 };
-	switch_core_session_message_t *message = NULL;
 	switch_frame_t *read_frame = NULL;
 	switch_status_t status = SWITCH_STATUS_SUCCESS;
 	int timelimit = 60;
@@ -848,15 +849,6 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_wait_for_answer(switch_core_session_t
 			goto done;
 		}
 
-
-		if (switch_core_session_dequeue_message(peer_session, &message) == SWITCH_STATUS_SUCCESS) {
-			if (switch_test_flag(message, SCSMF_DYNAMIC)) {
-				switch_safe_free(message);
-			} else {
-				message = NULL;
-			}
-		}
-		
 		if (switch_channel_media_ready(caller_channel)) {
 			status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
 			if (!SWITCH_READ_ACCEPTABLE(status)) {
@@ -1991,7 +1983,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
 				
 				check_per_channel_timeouts(&oglobals, originate_status, and_argc, start);
 
-				if (oglobals.session && switch_core_session_private_event_count(oglobals.session)) {
+				if (oglobals.session) {
 					switch_ivr_parse_all_events(oglobals.session);
 				}
 
@@ -2035,17 +2027,12 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_originate(switch_core_session_t *sess
 				}
 
 				if (originate_status[0].peer_session
-					&& switch_core_session_dequeue_message(originate_status[0].peer_session, &message) == SWITCH_STATUS_SUCCESS) {
+					&& switch_core_session_dequeue_message(oglobals.session, &message) == SWITCH_STATUS_SUCCESS) {
 					if (oglobals.session && !ringback_data && or_argc == 1 && and_argc == 1) {	
 						/* when there is only 1 channel to call and bridge and no ringback */
 						switch_core_session_receive_message(oglobals.session, message);
 					}
-
+					message = NULL;
-					if (switch_test_flag(message, SCSMF_DYNAMIC)) {
-						switch_safe_free(message);
-					} else {
-						message = NULL;
-					}
 				}
 
 				/* read from the channel while we wait if the audio is up on it */

src/switch_ivr_play_say.c

@@ -612,9 +612,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_record_file(switch_core_session_t *se
 			break;
 		}
 
-		if (switch_core_session_private_event_count(session)) {
+		switch_ivr_parse_all_events(session);
-			switch_ivr_parse_all_events(session);
-		}
 
 		if (start && (switch_epoch_time_now(NULL) - start) > limit) {
 			break;
@@ -803,9 +801,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_gentones(switch_core_session_t *sessi
 			break;
 		}
 
-		if (switch_core_session_private_event_count(session)) {
+		switch_ivr_parse_all_events(session);
-            switch_ivr_parse_all_events(session);
-        }
 
 		if (args && (args->input_callback || args->buf || args->buflen)) {
 			/*
@@ -1193,9 +1189,7 @@ SWITCH_DECLARE(switch_status_t) switch_ivr_play_file(switch_core_session_t *sess
 				break; 
 			}
 
-			if (switch_core_session_private_event_count(session)) {
+			switch_ivr_parse_all_events(session);
-				switch_ivr_parse_all_events(session);
-			}
 
 			if (args && (args->input_callback || args->buf || args->buflen)) {
 				/*