#include "switch.h"
#include "switch_core.h"
#include "private/switch_core_pvt.h"

Include dependency graph for switch_core_session.c:

Data Structures
struct	str_node

struct	switch_thread_pool_node_s

Macros
#define	DEBUG_THREAD_POOL

#define	check_media(session)

#define	SWITCH_PREFIX_DIR "."

Typedefs
typedef struct switch_thread_pool_node_s	switch_thread_pool_node_t

Functions
void	switch_core_session_set_dmachine (switch_core_session_t session, switch_ivr_dmachine_t dmachine, switch_digit_action_target_t target)

switch_ivr_dmachine_t *	switch_core_session_get_dmachine (switch_core_session_t *session, switch_digit_action_target_t target)

switch_jb_t *	switch_core_session_get_jb (switch_core_session_t *session, switch_media_type_t type)

void	switch_core_session_soft_lock (switch_core_session_t *session, uint32_t sec)

void	switch_core_session_soft_unlock (switch_core_session_t *session)

switch_status_t	switch_core_session_set_codec_slin (switch_core_session_t session, switch_slin_data_t data)

switch_core_session_t *	switch_core_session_perform_locate (const char uuid_str, const char file, const char *func, int line)

switch_core_session_t *	switch_core_session_perform_force_locate (const char uuid_str, const char file, const char *func, int line)

switch_status_t	switch_core_session_perform_get_partner (switch_core_session_t session, switch_core_session_t partner, const char file, const char *func, int line)
	Get the session's partner (the session its bridged to) More...

uint32_t	switch_core_session_hupall_matching_var_ans (const char var_name, const char var_val, switch_call_cause_t cause, switch_hup_type_t type)

switch_console_callback_match_t *	switch_core_session_findall_matching_var (const char var_name, const char var_val)

void	switch_core_session_hupall_endpoint (const switch_endpoint_interface_t *endpoint_interface, switch_call_cause_t cause)
	Hangup all sessions that belong to an endpoint. More...

void	switch_core_session_hupall (switch_call_cause_t cause)

switch_console_callback_match_t *	switch_core_session_findall (void)

switch_status_t	switch_core_session_message_send (const char uuid_str, switch_core_session_message_t message)

switch_status_t	switch_core_session_event_send (const char uuid_str, switch_event_t *event)

void *	switch_core_session_get_private_class (switch_core_session_t *session, switch_pvt_class_t index)

switch_status_t	switch_core_session_set_private_class (switch_core_session_t session, void private_info, switch_pvt_class_t index)

int	switch_core_session_add_stream (switch_core_session_t session, void private_info)

void *	switch_core_session_get_stream (switch_core_session_t *session, int index)

int	switch_core_session_get_stream_count (switch_core_session_t *session)

switch_call_cause_t	switch_core_session_outgoing_channel (switch_core_session_t session, switch_event_t var_event, const char endpoint_name, switch_caller_profile_t caller_profile, switch_core_session_t new_session, switch_memory_pool_t pool, switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)

switch_status_t	switch_core_session_perform_receive_message (switch_core_session_t session, switch_core_session_message_t message, const char file, const char func, int line)

switch_status_t	switch_core_session_pass_indication (switch_core_session_t *session, switch_core_session_message_types_t indication)

switch_status_t	switch_core_session_queue_indication (switch_core_session_t *session, switch_core_session_message_types_t indication)

switch_status_t	switch_core_session_queue_message (switch_core_session_t session, switch_core_session_message_t message)

void	switch_core_session_free_message (switch_core_session_message_t **message)

switch_status_t	switch_core_session_dequeue_message (switch_core_session_t session, switch_core_session_message_t *message)

switch_status_t	switch_core_session_flush_message (switch_core_session_t *session)

switch_status_t	switch_core_session_queue_signal_data (switch_core_session_t session, void signal_data)

switch_status_t	switch_core_session_dequeue_signal_data (switch_core_session_t session, void *signal_data)

switch_status_t	switch_core_session_receive_event (switch_core_session_t session, switch_event_t *event)

switch_status_t	switch_core_session_queue_event (switch_core_session_t session, switch_event_t *event)

uint32_t	switch_core_session_messages_waiting (switch_core_session_t *session)

uint32_t	switch_core_session_event_count (switch_core_session_t *session)

switch_status_t	switch_core_session_dequeue_event (switch_core_session_t session, switch_event_t *event, switch_bool_t force)

switch_status_t	switch_core_session_queue_private_event (switch_core_session_t session, switch_event_t *event, switch_bool_t priority)

uint32_t	switch_core_session_private_event_count (switch_core_session_t *session)

switch_status_t	switch_core_session_dequeue_private_event (switch_core_session_t session, switch_event_t *event)

uint32_t	switch_core_session_flush_private_events (switch_core_session_t *session)
	Flush the private event queue of a session. More...

void	switch_core_session_reset (switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)

switch_channel_t *	switch_core_session_get_channel (switch_core_session_t *session)

switch_mutex_t *	switch_core_session_get_mutex (switch_core_session_t *session)
	Signal a session's state machine thread that a state change has occured. More...

switch_status_t	switch_core_session_wake_session_thread (switch_core_session_t *session)

void	switch_core_session_signal_state_change (switch_core_session_t *session)

unsigned int	switch_core_session_running (switch_core_session_t *session)

unsigned int	switch_core_session_started (switch_core_session_t *session)

int	switch_core_session_sync_clock (void)

void	switch_core_session_perform_destroy (switch_core_session_t *session, const char file, const char *func, int line)

	SWITCH_STANDARD_SCHED_FUNC (sch_heartbeat_callback)

void	switch_core_session_unsched_heartbeat (switch_core_session_t *session)

void	switch_core_session_sched_heartbeat (switch_core_session_t *session, uint32_t seconds)

void	switch_core_session_enable_heartbeat (switch_core_session_t *session, uint32_t seconds)

void	switch_core_session_disable_heartbeat (switch_core_session_t *session)

switch_bool_t	switch_core_session_in_thread (switch_core_session_t *session)

static void *SWITCH_THREAD_FUNC	switch_core_session_thread (switch_thread_t thread, void obj)

static void *SWITCH_THREAD_FUNC	switch_core_session_thread_pool_worker (switch_thread_t thread, void obj)

static void	thread_launch_failure (void)

static switch_status_t	check_queue (void)

switch_status_t	switch_thread_pool_launch_thread (switch_thread_data_t **tdp)

switch_status_t	switch_core_session_thread_pool_launch (switch_core_session_t *session)

switch_status_t	switch_core_session_thread_launch (switch_core_session_t *session)

void	switch_core_session_launch_thread (switch_core_session_t session, switch_thread_start_t func, void obj)

switch_status_t	switch_core_session_set_uuid (switch_core_session_t session, const char use_uuid)

static char *	xml_find_var (switch_xml_t vars, const char *name)

static void	parse_array (const char str, uint32_t array, int32_t array_len)

switch_core_session_t *	switch_core_session_request_xml (switch_endpoint_interface_t endpoint_interface, switch_memory_pool_t *pool, switch_xml_t xml)

switch_core_session_t *	switch_core_session_request_uuid (switch_endpoint_interface_t endpoint_interface, switch_call_direction_t direction, switch_originate_flag_t originate_flags, switch_memory_pool_t pool, const char use_uuid)

uint32_t	switch_core_session_count (void)
	Provide the total number of sessions. More...

switch_size_t	switch_core_session_get_id (switch_core_session_t *session)

switch_size_t	switch_core_session_id_dec (void)

switch_size_t	switch_core_session_id (void)
	Provide the current session_id. More...

switch_core_session_t *	switch_core_session_request_by_name (const char endpoint_name, switch_call_direction_t direction, switch_memory_pool_t *pool)

uint8_t	switch_core_session_compare (switch_core_session_t a, switch_core_session_t b)
	Checks if 2 sessions are using the same endpoint module. More...

uint8_t	switch_core_session_check_interface (switch_core_session_t session, const switch_endpoint_interface_t endpoint_interface)
	Checks if a session is using a specific endpoint. More...

char *	switch_core_session_get_uuid (switch_core_session_t *session)

uint32_t	switch_core_session_limit (uint32_t new_limit)

double	switch_core_min_idle_cpu (double new_limit)

double	switch_core_idle_cpu (void)

uint32_t	switch_core_sessions_per_second (uint32_t new_limit)

void	switch_core_session_init (switch_memory_pool_t *pool)

void	switch_core_session_uninit (void)

switch_app_log_t *	switch_core_session_get_app_log (switch_core_session_t *session)

switch_status_t	switch_core_session_get_app_flags (const char app, int32_t flags)

switch_status_t	switch_core_session_execute_application_async (switch_core_session_t session, const char app, const char *arg)

void	switch_core_session_video_reset (switch_core_session_t *session)

switch_status_t	switch_core_session_execute_application_get_flags (switch_core_session_t session, const char app, const char arg, int32_t flags)

switch_status_t	switch_core_session_exec (switch_core_session_t session, const switch_application_interface_t application_interface, const char *arg)

switch_status_t	switch_core_session_execute_exten (switch_core_session_t session, const char exten, const char dialplan, const char context)

switch_status_t	switch_core_session_set_loglevel (switch_core_session_t *session, switch_log_level_t loglevel)
	Sets the log level for a session. More...

switch_log_level_t	switch_core_session_get_loglevel (switch_core_session_t *session)
	Get the log level for a session. More...

void	switch_core_session_debug_pool (switch_stream_handle_t *stream)

void	switch_core_session_raw_read (switch_core_session_t *session)

Variables
struct switch_session_manager	session_manager

static const char *	message_names []

Macro Definition Documentation

#define check_media ( session )

Value:

{                                                                                                                                       \
		if (switch_channel_test_flag(session->channel, CF_BROADCAST_DROP_MEDIA)) { \
			switch_channel_clear_flag(session->channel, CF_BROADCAST_DROP_MEDIA); \
			switch_ivr_nomedia(session->uuid_str, SMF_REBRIDGE);         \
                }                                                                                                                               \
        }                                                                                                                                       \

Definition at line 1213 of file switch_core_session.c.

Referenced by switch_core_session_dequeue_private_event(), switch_core_session_flush_private_events(), and switch_core_session_private_event_count().

#define DEBUG_THREAD_POOL

Definition at line 40 of file switch_core_session.c.

#define SWITCH_PREFIX_DIR "."

Definition at line 2403 of file switch_core_session.c.

Typedef Documentation

typedef struct switch_thread_pool_node_s switch_thread_pool_node_t

Function Documentation

static switch_status_t check_queue ( void )

static

Definition at line 1749 of file switch_core_session.c.

References switch_session_manager::busy, switch_session_manager::cond, switch_session_manager::mutex, pool, switch_thread_pool_node_s::pool, switch_session_manager::running, session_manager, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_session_thread_pool_worker(), SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_PRI_LOW, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_thread_cond_signal(), switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_priority_set(), switch_threadattr_stacksize_set(), thread, and thread_launch_failure().

Referenced by switch_core_session_thread_pool_launch(), and switch_thread_pool_launch_thread().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_mutex_lock(session_manager.mutex);
         if (session_manager.running >= ++session_manager.busy) {
                 switch_mutex_unlock(session_manager.mutex);
                 return SWITCH_STATUS_SUCCESS;
         }
         ++session_manager.running;
         switch_mutex_unlock(session_manager.mutex);
 
         {
                 switch_thread_t *thread;
                 switch_threadattr_t *thd_attr;
                 switch_memory_pool_t *pool;
                 switch_thread_pool_node_t *node;
                 
                 switch_core_new_memory_pool(&pool);
                 node = switch_core_alloc(pool, sizeof(*node));
                 node->pool = pool;
 
                 switch_threadattr_create(&thd_attr, node->pool);
                 switch_threadattr_detach_set(thd_attr, 1);
                 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                 switch_threadattr_priority_set(thd_attr, SWITCH_PRI_LOW);
 
                 if (switch_thread_create(&thread, thd_attr, switch_core_session_thread_pool_worker, node, node->pool) != SWITCH_STATUS_SUCCESS) {
                         switch_mutex_lock(session_manager.mutex);
                         if (!--session_manager.running) {
                                 switch_thread_cond_signal(session_manager.cond);
                         }
                         switch_mutex_unlock(session_manager.mutex);
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Thread Failure!\n");
                         switch_core_destroy_memory_pool(&pool);
                         status = SWITCH_STATUS_GENERR;
                         thread_launch_failure();
                 } else {
                         status = SWITCH_STATUS_SUCCESS;
                 }
         }
         return status;
 }

static void parse_array	(	const char *	str,
		uint32_t *	array,
		int32_t	array_len
	)

static

Definition at line 1953 of file switch_core_session.c.

References zstr.

Referenced by switch_core_session_request_xml().

 {
         char *p, *v, *dup, *next = NULL;
 
         if (zstr(str)) {
                 return;
         }
 
         dup = strdup(str);
 
         p = dup;
         while (p) {
                 if ((next = strchr(p, ';'))) {
                         *next++ = '\0';
                 }
 
                 if ((v = strchr(p, '='))) {
                         *v++ = '\0';
                 }
 
                 if (p && v) {
                         int x = 0, y = 0;
 
                         x = atoi(p);
                         y = atoi(v);
 
                         if (x < array_len) {
                                 array[x] = y;
                         }
                 }
 
                 p = next;
 
         }
 
         free(dup);
 }

int switch_core_session_add_stream	(	switch_core_session_t *	session,
		void *	private_info
	)

Definition at line 477 of file switch_core_session.c.

 {
         session->streams[session->stream_count++] = private_info;
         return session->stream_count - 1;
 }

void switch_core_session_debug_pool ( switch_stream_handle_t * stream )

Definition at line 2927 of file switch_core_session.c.

References switch_session_manager::busy, switch_session_manager::running, and session_manager.

 {
         stream->write_function(stream, "Thread pool: running:%d busy:%d popping:%d\n",
                 session_manager.running, session_manager.busy, session_manager.running - session_manager.busy);
 }

switch_status_t switch_core_session_dequeue_event	(	switch_core_session_t *	session,
		switch_event_t **	event,
		switch_bool_t	force
	)

Definition at line 1175 of file switch_core_session.c.

References CF_DIVERT_EVENTS, switch_assert, switch_channel_test_flag(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         void *pop;
 
         switch_assert(session != NULL);
 
         if (session->event_queue && (force || !switch_channel_test_flag(session->channel, CF_DIVERT_EVENTS))) {
                 if ((status = (switch_status_t) switch_queue_trypop(session->event_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         *event = (switch_event_t *) pop;
                 }
         }
 
         return status;
 }

switch_status_t switch_core_session_dequeue_message	(	switch_core_session_t *	session,
		switch_core_session_message_t **	message
	)

Definition at line 1018 of file switch_core_session.c.

References switch_assert, switch_core_session_queue_message(), switch_epoch_time_now(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         void *pop;
 
         switch_assert(session != NULL);
 
         if (session->message_queue) {
                 if ((status = (switch_status_t) switch_queue_trypop(session->message_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         *message = (switch_core_session_message_t *) pop;
                         if ((*message)->delivery_time && (*message)->delivery_time > switch_epoch_time_now(NULL)) {
                                 switch_core_session_queue_message(session, *message);
                                 *message = NULL;
                                 status = SWITCH_STATUS_FALSE;
                         }
                 }
         }
 
         return status;
 }

switch_status_t switch_core_session_dequeue_private_event	(	switch_core_session_t *	session,
		switch_event_t **	event
	)

Definition at line 1244 of file switch_core_session.c.

References CF_EVENT_LOCK, CF_EVENT_LOCK_PRI, check_media, switch_channel_test_flag(), switch_core_session_get_channel(), switch_queue_size(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         void *pop;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_queue_t *queue;
 
         if (session->private_event_queue) {
                 if (switch_queue_size(session->private_event_queue_pri)) {
                         queue = session->private_event_queue_pri;
 
                         if (switch_channel_test_flag(channel, CF_EVENT_LOCK_PRI)) {
                                 return SWITCH_STATUS_FALSE;
                         }
                 } else {
                         queue = session->private_event_queue;
 
                         if (switch_channel_test_flag(channel, CF_EVENT_LOCK)) {
                                 return SWITCH_STATUS_FALSE;
                         }
                 }
 
                 if ((status = (switch_status_t) switch_queue_trypop(queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         *event = (switch_event_t *) pop;
                 } else {
                         check_media(session);
                 }
         }
 
         return status;
 }

uint32_t switch_core_session_event_count ( switch_core_session_t * session )

Definition at line 1166 of file switch_core_session.c.

References switch_queue_size().

 {
         if (session->event_queue) {
                 return switch_queue_size(session->event_queue);
         }
 
         return 0;
 }

switch_status_t switch_core_session_event_send	(	const char *	uuid_str,
		switch_event_t **	event
	)

Definition at line 433 of file switch_core_session.c.

References switch_core_session::channel, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_channel_up_nosig, switch_core_hash_find(), switch_core_session_queue_event(), switch_core_session_read_lock(), switch_core_session_rwunlock(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_t *session = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_mutex_lock(runtime.session_hash_mutex);
         if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
                 /* Acquire a read lock on the session or forget it the channel is dead */
                 if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
                         if (switch_channel_up_nosig(session->channel)) {
                                 status = switch_core_session_queue_event(session, event);
                         }
                         switch_core_session_rwunlock(session);
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         return status;
 }

switch_status_t switch_core_session_exec	(	switch_core_session_t *	session,
		const switch_application_interface_t *	application_interface,
		const char *	arg
	)

Definition at line 2662 of file switch_core_session.c.

References switch_app_log::app, switch_app_log::arg, CF_BREAK, switch_core_session_message::from, switch_core_session_message::message_id, switch_app_log::next, SCF_DIALPLAN_TIMESTAMPS, switch_app_log::stamp, switch_core_session_message::string_array_arg, switch_assert, switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_expand_variables, switch_channel_get_name(), switch_channel_get_variable, switch_channel_presence, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CHANNEL_SESSION_LOG_CLEAN, switch_channel_set_scope_variables(), switch_channel_set_variable, switch_channel_set_variable_var_check(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_receive_message, switch_core_session_strdup, switch_core_test_flag(), SWITCH_CURRENT_APPLICATION_DATA_VARIABLE, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, SWITCH_CURRENT_APPLICATION_VARIABLE, SWITCH_DISABLE_APP_LOG_VARIABLE, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_EXECUTE, SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE, switch_event_create, switch_event_create_brackets(), switch_event_fire, SWITCH_FALSE, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC, SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE, switch_mprintf(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_time_now(), SWITCH_TRUE, switch_true(), SWITCH_UUID_FORMATTED_LENGTH, switch_uuid_str(), and zstr.

Referenced by switch_core_session_execute_application_get_flags().

 {
         switch_app_log_t *log, *lp;
         switch_event_t *event;
         const char *var;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         char *expanded = NULL;
         const char *app, *app_uuid_var;
         switch_core_session_message_t msg = { 0 };
         char delim = ',';
         int scope = 0;
         char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
         char *app_uuid = uuid_str;
 
         if ((app_uuid_var = switch_channel_get_variable(channel, "app_uuid"))) {
                 app_uuid = (char *)app_uuid_var;
                 switch_channel_set_variable(channel, "app_uuid", NULL);
         } else {
                 switch_uuid_str(uuid_str, sizeof(uuid_str));
         }
 
         switch_assert(application_interface);
 
         app = application_interface->interface_name;
 
         if (arg) {
                 expanded = switch_channel_expand_variables(session->channel, arg);
         }
 
         if (expanded && *expanded == '%' && (*(expanded+1) == '[' || *(expanded+2) == '[')) {
                 char *p, *dup;
                 switch_event_t *ovars = NULL;
                 
                 p = expanded + 1;
 
                 if (*p != '[') {
                         delim = *p;
                         p++;
                 }
 
                 dup = strdup(p);
                 
                 if (expanded != arg) {
                         switch_safe_free(expanded);
                 }
 
                 switch_event_create_brackets(dup, '[', ']', delim, &ovars, &expanded, SWITCH_TRUE);
                 free(dup);
 
                 switch_channel_set_scope_variables(session->channel, &ovars);
                 scope = 1;
         }
 
         
         if ( switch_core_test_flag(SCF_DIALPLAN_TIMESTAMPS) ) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "EXECUTE %s %s(%s)\n",
                                           switch_channel_get_name(session->channel), app, switch_str_nil(expanded));
         } else {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(session), SWITCH_LOG_DEBUG, "EXECUTE %s %s(%s)\n",
                                           switch_channel_get_name(session->channel), app, switch_str_nil(expanded));
         }
 
         if ((var = switch_channel_get_variable(session->channel, "verbose_presence")) && switch_true(var)) {
                 char *myarg = NULL;
                 if (expanded) {
                         myarg = switch_mprintf("%s(%s)", app, expanded);
                 } else if (!zstr(arg)) {
                         myarg = switch_mprintf("%s(%s)", app, arg);
                 } else {
                         myarg = switch_mprintf("%s", app);
                 }
                 if (myarg) {
                         switch_channel_presence(session->channel, "unknown", myarg, NULL);
                         switch_safe_free(myarg);
                 }
         }
 
         if (!(var = switch_channel_get_variable(session->channel, SWITCH_DISABLE_APP_LOG_VARIABLE)) || (!(switch_true(var)))) {
                 log = switch_core_session_alloc(session, sizeof(*log));
 
                 log->app = switch_core_session_strdup(session, application_interface->interface_name);
                 if (expanded) {
                         log->arg = switch_core_session_strdup(session, expanded);
                 }
 
                 log->stamp = switch_time_now();
 
                 for (lp = session->app_log; lp && lp->next; lp = lp->next);
 
                 if (lp) {
                         lp->next = log;
                 } else {
                         session->app_log = log;
                 }
         }
 
         switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_VARIABLE, application_interface->interface_name);
         switch_channel_set_variable_var_check(channel, SWITCH_CURRENT_APPLICATION_DATA_VARIABLE, expanded, SWITCH_FALSE);
         switch_channel_set_variable(channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE, NULL);
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data(session->channel, event);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", application_interface->interface_name);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", expanded);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID", app_uuid);
                 switch_event_fire(&event);
         }
 
         switch_channel_clear_flag(session->channel, CF_BREAK);
 
         switch_assert(application_interface->application_function);
 
         switch_channel_set_variable(session->channel, SWITCH_CURRENT_APPLICATION_VARIABLE, application_interface->interface_name);
 
         msg.from = __FILE__;
         msg.message_id = SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC;
         msg.string_array_arg[0] = application_interface->interface_name;
         msg.string_array_arg[1] = expanded;
         switch_core_session_receive_message(session, &msg);
 
         application_interface->application_function(session, expanded);
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE) == SWITCH_STATUS_SUCCESS) {
                 const char *resp = switch_channel_get_variable(session->channel, SWITCH_CURRENT_APPLICATION_RESPONSE_VARIABLE);
                 switch_channel_event_set_data(session->channel, event);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application", application_interface->interface_name);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Data", expanded);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-Response", resp ? resp : "_none_");
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID", app_uuid);
                 switch_event_fire(&event);
         }
 
         msg.message_id = SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC_COMPLETE;
         switch_core_session_receive_message(session, &msg);
 
         if (expanded != arg) {
                 switch_safe_free(expanded);
         }
 
         if (scope) {
                 switch_channel_set_scope_variables(session->channel, NULL);
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_core_session_execute_application_get_flags	(	switch_core_session_t *	session,
		const char *	app,
		const char *	arg,
		int32_t *	flags
	)

Definition at line 2561 of file switch_core_session.c.

References switch_application_interface::application_function, CF_PROXY_MODE, CF_VIDEO, switch_application_interface::flags, SAF_SUPPORT_NOMEDIA, SAF_ZOMBIE_EXEC, SMF_NONE, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, switch_channel_direction(), switch_channel_down_nosig, switch_channel_get_name(), switch_channel_hangup, switch_channel_media_ready, switch_channel_media_up, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_cond_next(), switch_core_media_gen_key_frame, switch_core_session_exec(), switch_core_session_execute_application_async(), switch_core_session_request_video_refresh(), switch_goto_status, switch_ivr_media(), switch_loadable_module_get_application_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STATUS_FALSE, SWITCH_STATUS_IGNORE, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_test_flag, and UNPROTECT_INTERFACE.

 {
         switch_application_interface_t *application_interface;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_core_session_request_video_refresh(session);
         switch_core_media_gen_key_frame(session);
 
         if (switch_channel_down_nosig(session->channel)) {
                 char *p;
                 if (!arg && (p = strstr(app, "::"))) {
                         *p++ = '0';
                         *p++ = '0';
                         arg = p;
 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s ASYNC CALL CONVERTED TO INLINE %s(%s)\n", 
                                                           switch_channel_get_name(session->channel), app, switch_str_nil(arg));                 
                 }
                 
                 if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
                         return SWITCH_STATUS_FALSE;
                 }
 
                 if (switch_test_flag(application_interface, SAF_ZOMBIE_EXEC)) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s ZOMBIE EXEC %s(%s)\n", 
                                                           switch_channel_get_name(session->channel), app, switch_str_nil(arg));
                         goto exec;
                 }
 
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, 
                                                   "%s Channel is hungup and application '%s' does not have the zombie_exec flag.\n",
                                                   switch_channel_get_name(session->channel), app);
 
                 switch_goto_status(SWITCH_STATUS_IGNORE, done);
         }
 
         if (!arg && strstr(app, "::")) {
                 return switch_core_session_execute_application_async(session, app, arg);
         }
 
         if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Application %s\n", app);
                 switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                 switch_goto_status(SWITCH_STATUS_FALSE, done);
         }
 
         if (!application_interface->application_function) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No Function for %s\n", app);
                 switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                 switch_goto_status(SWITCH_STATUS_FALSE, done);
         }
 
         if (flags && application_interface->flags) {
                 *flags = application_interface->flags;
         }
 
         if (!switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) && (switch_channel_test_flag(session->channel, CF_VIDEO))) {
                 switch_core_session_request_video_refresh(session);
         }
 
         if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) && !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA)) {
                 switch_ivr_media(session->uuid_str, SMF_NONE);
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Application %s Requires media on channel %s!\n",
                                                   app, switch_channel_get_name(session->channel));
         } else if (!switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) && !switch_channel_media_ready(session->channel)) {
                 if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Application %s Requires media! pre_answering channel %s\n",
                                                           app, switch_channel_get_name(session->channel));
                         if (switch_channel_pre_answer(session->channel) != SWITCH_STATUS_SUCCESS) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Well, that didn't work very well did it? ...\n");
                                 switch_goto_status(SWITCH_STATUS_FALSE, done);
                         }
                 } else {
                         uint32_t ready = 0, sanity = 2000;
 
                         do {
                                 sanity--;
                                 ready = switch_channel_media_up(session->channel);
                                 switch_cond_next();
                         } while(!ready && sanity);
 
                         if (!ready) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, 
                                                                   "Cannot execute app '%s' media required on an outbound channel that does not have media established\n", app);
                                 switch_goto_status(SWITCH_STATUS_FALSE, done);
                         }
                 }
         }
 
  exec:
 
         switch_core_session_exec(session, application_interface, arg);
 
   done:
 
         UNPROTECT_INTERFACE(application_interface);
 
         return status;
 }

switch_status_t switch_core_session_execute_exten	(	switch_core_session_t *	session,
		const char *	exten,
		const char *	dialplan,
		const char *	context
	)

Definition at line 2809 of file switch_core_session.c.

References switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_profile::caller_extension, switch_caller_extension::children, switch_caller_profile::context, switch_caller_extension::current_application, switch_caller_profile::destination_number, switch_caller_profile::dialplan, switch_dialplan_interface::hunt_function, switch_caller_profile::next, switch_caller_application::next, switch_caller_profile::pool, switch_caller_profile_clone(), switch_channel_get_caller_profile(), switch_channel_get_name(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_hunt_caller_profile(), switch_core_session_alloc, switch_core_session_execute_application, switch_core_session_get_channel(), switch_core_session_strdup, switch_core_strdup, switch_loadable_module_get_dialplan_interface(), SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MAX_STACKS, switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_caller_profile::times, UNPROTECT_INTERFACE, and zstr.

 {
         char *dp[25];
         char *dpstr;
         int argc, x, count = 0;
         switch_caller_profile_t *profile, *new_profile, *pp = NULL;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_dialplan_interface_t *dialplan_interface = NULL;
         switch_caller_extension_t *extension = NULL;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         if (!(profile = switch_channel_get_caller_profile(channel))) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (session->stack_count > SWITCH_MAX_STACKS) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error %s too many stacked extensions\n",
                                                   switch_channel_get_name(session->channel));
                 return SWITCH_STATUS_FALSE;
         }
 
         session->stack_count++;
 
         new_profile = switch_caller_profile_clone(session, profile);
         new_profile->destination_number = switch_core_strdup(new_profile->pool, exten);
         new_profile->times = (switch_channel_timetable_t *) switch_core_session_alloc(session, sizeof(*new_profile->times));
         *new_profile->times = *profile->times;
 
 
         if (!zstr(dialplan)) {
                 new_profile->dialplan = switch_core_strdup(new_profile->pool, dialplan);
         }
 
         if (!zstr(context)) {
                 new_profile->context = switch_core_strdup(new_profile->pool, context);
         }
 
         dpstr = switch_core_session_strdup(session, new_profile->dialplan);
 
         switch_channel_set_hunt_caller_profile(channel, new_profile);
         argc = switch_separate_string(dpstr, ',', dp, (sizeof(dp) / sizeof(dp[0])));
         for (x = 0; x < argc; x++) {
                 char *dpname = dp[x];
                 char *dparg = NULL;
 
                 if (dpname) {
                         if ((dparg = strchr(dpname, ':'))) {
                                 *dparg++ = '\0';
                         }
                 } else {
                         continue;
                 }
 
                 if (!(dialplan_interface = switch_loadable_module_get_dialplan_interface(dpname))) {
                         continue;
                 }
 
                 count++;
 
                 extension = dialplan_interface->hunt_function(session, dparg, new_profile);
                 UNPROTECT_INTERFACE(dialplan_interface);
 
                 if (extension) {
                         break;
                 }
         }
 
         if (!extension) {
                 status = SWITCH_STATUS_FALSE;
                 goto done;
         }
 
         new_profile->caller_extension = extension;
 
         if (profile->caller_extension) {
                 for (pp = profile->caller_extension->children; pp && pp->next; pp = pp->next);
 
                 if (pp) {
                         pp->next = new_profile;
                 } else {
                         profile->caller_extension->children = new_profile;
                 }
         }
 
         while (switch_channel_ready(channel) && extension->current_application) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Execute %s(%s)\n",
                                                   extension->current_application->application_name, switch_str_nil(extension->current_application->application_data));
 
                 if (switch_core_session_execute_application(session,
                                                                                                         extension->current_application->application_name,
                                                                                                         extension->current_application->application_data) != SWITCH_STATUS_SUCCESS) {
                         goto done;
                 }
 
                 extension->current_application = extension->current_application->next;
         }
 
   done:
         switch_channel_set_hunt_caller_profile(channel, NULL);
 
         session->stack_count--;
         return status;
 }

switch_status_t switch_core_session_flush_message ( switch_core_session_t * session )

Definition at line 1039 of file switch_core_session.c.

References switch_assert, switch_core_session_free_message(), switch_ivr_process_indications(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_reset().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         void *pop;
         switch_core_session_message_t *message;
 
         switch_assert(session != NULL);
 
 
         if (session->message_queue) {
                 while ((status = (switch_status_t) switch_queue_trypop(session->message_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         message = (switch_core_session_message_t *) pop;
                         switch_ivr_process_indications(session, message);
                         switch_core_session_free_message(&message);
                 }
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_app_log_t* switch_core_session_get_app_log ( switch_core_session_t * session )

Definition at line 2484 of file switch_core_session.c.

 {
         return session->app_log;
 }

switch_channel_t* switch_core_session_get_channel ( switch_core_session_t * session )

Definition at line 1355 of file switch_core_session.c.

References switch_assert.

Referenced by switch_core_session_dequeue_private_event(), switch_core_session_exec(), switch_core_session_execute_exten(), switch_core_session_hupall_matching_var_ans(), switch_core_session_outgoing_channel(), switch_core_session_pass_indication(), switch_core_session_private_event_count(), switch_core_session_request_xml(), and switch_core_session_reset().

 {
         switch_assert(session->channel);
         return session->channel;
 }

switch_size_t switch_core_session_get_id ( switch_core_session_t * session )

Definition at line 2365 of file switch_core_session.c.

 {
         return session->id;
 }

void* switch_core_session_get_private_class	(	switch_core_session_t *	session,
		switch_pvt_class_t	index
	)

Definition at line 454 of file switch_core_session.c.

References switch_assert, and SWITCH_CORE_SESSION_MAX_PRIVATES.

 {
         if ((int)index >= SWITCH_CORE_SESSION_MAX_PRIVATES) {
                 return NULL;
         }
 
         switch_assert(session != NULL);
         return session->private_info[index];
 }

void* switch_core_session_get_stream	(	switch_core_session_t *	session,
		int	index
	)

Definition at line 483 of file switch_core_session.c.

 {
         return session->streams[index];
 }

int switch_core_session_get_stream_count ( switch_core_session_t * session )

Definition at line 489 of file switch_core_session.c.

 {
         return session->stream_count;
 }

char* switch_core_session_get_uuid ( switch_core_session_t * session )

Definition at line 2422 of file switch_core_session.c.

Referenced by switch_core_session_outgoing_channel(), switch_core_session_perform_destroy(), switch_core_session_perform_force_locate(), switch_core_session_perform_receive_message(), and switch_core_session_sched_heartbeat().

 {
         if (!session) return NULL;
         return session->uuid_str;
 }

void switch_core_session_hupall ( switch_call_cause_t cause )

Definition at line 351 of file switch_core_session.c.

References switch_core_session::channel, str_node::next, pool, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_channel_hangup, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_new_memory_pool, switch_core_session_locate, switch_core_session_read_lock(), switch_core_session_rwunlock(), switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_core_session::uuid_str.

 {
         switch_hash_index_t *hi;
         void *val;
         switch_core_session_t *session;
         switch_memory_pool_t *pool;
         struct str_node *head = NULL, *np;
 
         switch_core_new_memory_pool(&pool);
 
 
         switch_mutex_lock(runtime.session_hash_mutex);
         for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
                 switch_core_hash_this(hi, NULL, NULL, &val);
                 if (val) {
                         session = (switch_core_session_t *) val;
                         if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
                                 np = switch_core_alloc(pool, sizeof(*np));
                                 np->str = switch_core_strdup(pool, session->uuid_str);
                                 np->next = head;
                                 head = np;
                                 switch_core_session_rwunlock(session);
                         }
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         for(np = head; np; np = np->next) { 
                 if ((session = switch_core_session_locate(np->str))) {
                         switch_channel_hangup(session->channel, cause);
                         switch_core_session_rwunlock(session);
                 }
         }
 
         switch_core_destroy_memory_pool(&pool);
 
 }

uint32_t switch_core_session_hupall_matching_var_ans	(	const char *	var_name,
		const char *	var_val,
		switch_call_cause_t	cause,
		switch_hup_type_t	type
	)

Definition at line 210 of file switch_core_session.c.

References CF_ANSWERED, switch_core_session::channel, str_node::next, pool, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, SHT_ANSWERED, SHT_UNANSWERED, switch_channel_get_variable, switch_channel_hangup, switch_channel_test_flag(), switch_channel_up_nosig, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_new_memory_pool, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_read_lock(), switch_core_session_rwunlock(), switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_core_session::uuid_str.

 {
         switch_hash_index_t *hi;
         void *val;
         switch_core_session_t *session;
         switch_memory_pool_t *pool;
         struct str_node *head = NULL, *np;
         uint32_t r = 0;
 
         switch_core_new_memory_pool(&pool);
 
         if (!var_val)
                 return r;
 
         switch_mutex_lock(runtime.session_hash_mutex);
         for (hi = switch_core_hash_first(session_manager.session_table); hi; hi = switch_core_hash_next(&hi)) {
                 switch_core_hash_this(hi, NULL, NULL, &val);
                 if (val) {
                         session = (switch_core_session_t *) val;
                         if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
                                 int ans = switch_channel_test_flag(switch_core_session_get_channel(session), CF_ANSWERED);
                                 if ((ans && (type & SHT_ANSWERED)) || (!ans && (type & SHT_UNANSWERED))) {
                                         np = switch_core_alloc(pool, sizeof(*np));
                                         np->str = switch_core_strdup(pool, session->uuid_str);
                                         np->next = head;
                                         head = np;
                                 }
                                 switch_core_session_rwunlock(session);
                         }
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         for(np = head; np; np = np->next) {
                 if ((session = switch_core_session_locate(np->str))) {
                         const char *this_val;
                         if (switch_channel_up_nosig(session->channel) &&
                                 (this_val = switch_channel_get_variable(session->channel, var_name)) && (!strcmp(this_val, var_val))) {                 
                                 switch_channel_hangup(session->channel, cause);
                                 r++;
                         }
                         switch_core_session_rwunlock(session);
                 }
         }
 
         switch_core_destroy_memory_pool(&pool);
 
         return r;
 }

switch_bool_t switch_core_session_in_thread ( switch_core_session_t * session )

Definition at line 1614 of file switch_core_session.c.

References SWITCH_FALSE, switch_thread_equal(), switch_thread_self(), and SWITCH_TRUE.

Referenced by switch_channel_perform_answer(), switch_channel_set_direction(), switch_channel_state_change_pending(), switch_ivr_3p_nomedia(), switch_ivr_nomedia(), and switch_ivr_parse_signal_data().

 {
         return switch_thread_equal(switch_thread_self(), session->thread_id) ? SWITCH_TRUE : SWITCH_FALSE;
 }

void switch_core_session_init ( switch_memory_pool_t * pool )

Definition at line 2462 of file switch_core_session.c.

References switch_session_manager::cond, switch_session_manager::memory_pool, memset(), switch_session_manager::mutex, pool, switch_session_manager::session_id, switch_session_manager::session_limit, session_manager, switch_session_manager::session_table, switch_core_hash_init, SWITCH_MUTEX_DEFAULT, switch_mutex_init(), switch_queue_create(), switch_thread_cond_create(), and switch_session_manager::thread_queue.

Referenced by switch_core_init().

 {
         memset(&session_manager, 0, sizeof(session_manager));
         session_manager.session_limit = 1000;
         session_manager.session_id = 1;
         session_manager.memory_pool = pool;
         switch_core_hash_init(&session_manager.session_table);
         switch_mutex_init(&session_manager.mutex, SWITCH_MUTEX_DEFAULT, session_manager.memory_pool);
         switch_thread_cond_create(&session_manager.cond, session_manager.memory_pool);
         switch_queue_create(&session_manager.thread_queue, 100000, session_manager.memory_pool);
 }

void switch_core_session_launch_thread	(	switch_core_session_t *	session,
		switch_thread_start_t	func,
		void *	obj
	)

Definition at line 1882 of file switch_core_session.c.

References apr_threadattr_t::pool, SWITCH_CHANNEL_SESSION_LOG, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_STATUS_SUCCESS, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), thread, and thread_launch_failure().

 {
         switch_thread_t *thread;
         switch_threadattr_t *thd_attr = NULL;
         switch_threadattr_create(&thd_attr, session->pool);
         switch_threadattr_detach_set(thd_attr, 1);
 
         switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
         if (switch_thread_create(&thread, thd_attr, func, obj, session->pool) != SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot create thread!\n");
                 thread_launch_failure();
         }
 
 }

uint32_t switch_core_session_limit ( uint32_t new_limit )

Definition at line 2429 of file switch_core_session.c.

References switch_session_manager::session_limit, and session_manager.

Referenced by thread_launch_failure().

 {
         if (new_limit) {
                 session_manager.session_limit = new_limit;
         }
 
         return session_manager.session_limit;
 }

switch_status_t switch_core_session_message_send	(	const char *	uuid_str,
		switch_core_session_message_t *	message
	)

Definition at line 413 of file switch_core_session.c.

References switch_core_session::channel, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_channel_up_nosig, switch_core_hash_find(), switch_core_session_read_lock(), switch_core_session_receive_message, switch_core_session_rwunlock(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_t *session = NULL;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_mutex_lock(runtime.session_hash_mutex);
         if ((session = switch_core_hash_find(session_manager.session_table, uuid_str)) != 0) {
                 /* Acquire a read lock on the session or forget it the channel is dead */
                 if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
                         if (switch_channel_up_nosig(session->channel)) {
                                 status = switch_core_session_receive_message(session, message);
                         }
                         switch_core_session_rwunlock(session);
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         return status;
 }

switch_call_cause_t switch_core_session_outgoing_channel	(	switch_core_session_t *	session,
		switch_event_t *	var_event,
		const char *	endpoint_name,
		switch_caller_profile_t *	caller_profile,
		switch_core_session_t **	new_session,
		switch_memory_pool_t **	pool,
		switch_originate_flag_t	flags,
		switch_call_cause_t *	cancel_cause
	)

Definition at line 494 of file switch_core_session.c.

References switch_caller_profile::ani, switch_caller_profile::aniii, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, CC_BYPASS_MEDIA, CC_PROXY_MEDIA, CF_PROXY_MEDIA, CF_PROXY_MODE, CF_VIDEO, CF_ZRTP_PASSTHRU_REQ, ep, switch_codec::implementation, switch_endpoint_interface::io_routines, switch_io_event_hook_outgoing_channel::next, switch_io_event_hook_outgoing_channel::outgoing_channel, switch_io_routines::outgoing_channel, SOF_NO_EFFECTIVE_ANI, SOF_NO_EFFECTIVE_ANIII, SOF_NO_EFFECTIVE_CID_NAME, SOF_NO_EFFECTIVE_CID_NUM, switch_assert, switch_caller_profile_clone(), SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR, SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL, SWITCH_CAUSE_SUCCESS, switch_channel_cause2str(), switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_get_caller_profile(), switch_channel_get_name(), switch_channel_get_variable, switch_channel_pass_sdp(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_origination_caller_profile(), switch_channel_set_originator_caller_profile(), switch_channel_set_variable, switch_channel_test_cap(), switch_channel_test_flag(), switch_codec2str, switch_core_codec_ready(), switch_core_session_get_channel(), switch_core_session_get_read_codec(), switch_core_session_get_uuid(), switch_core_session_get_video_read_codec(), switch_core_session_set_uuid(), switch_core_session_sprintf(), switch_core_session_strdup, SWITCH_EVENT_CHANNEL_OUTGOING, switch_event_create, switch_event_del_header, switch_event_fire, switch_event_get_header, switch_loadable_module_get_endpoint_interface(), SWITCH_LOG_CRIT, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_MAX_FORWARDS_VARIABLE, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, SWITCH_ORIGINATOR_CODEC_VARIABLE, SWITCH_ORIGINATOR_VARIABLE, SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE, SWITCH_PROCESS_CDR_VARIABLE, SWITCH_R_SDP_VARIABLE, SWITCH_SIGNAL_BOND_VARIABLE, switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), UNPROTECT_INTERFACE, and zstr.

 {
         switch_io_event_hook_outgoing_channel_t *ptr;
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_endpoint_interface_t *endpoint_interface;
         switch_channel_t *channel = NULL;
         switch_caller_profile_t *outgoing_profile = caller_profile;
         switch_call_cause_t cause = SWITCH_CAUSE_REQUESTED_CHAN_UNAVAIL;
         const char *forwardvar;
         int forwardval = 70;
 
         if ((endpoint_interface = switch_loadable_module_get_endpoint_interface(endpoint_name)) == 0) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Could not locate channel type %s\n", endpoint_name);
                 return SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED;
         }
 
         if (!endpoint_interface->io_routines->outgoing_channel) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Could not locate outgoing channel interface for %s\n", endpoint_name);
                 return SWITCH_CAUSE_CHAN_NOT_IMPLEMENTED;
         }
 
         if (session) {
                 channel = switch_core_session_get_channel(session);
 
                 switch_assert(channel != NULL);
 
                 forwardvar = switch_channel_get_variable(channel, SWITCH_MAX_FORWARDS_VARIABLE);
                 if (!zstr(forwardvar)) {
                         forwardval = atoi(forwardvar) - 1;
                 }
                 if (forwardval <= 0) {
                         return SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR;
                 }
 
                 if (caller_profile) {
                         const char *eani = NULL, *eaniii = NULL;
                         const char *ecaller_id_name = NULL, *ecaller_id_number = NULL;
 
                         if (!(flags & SOF_NO_EFFECTIVE_ANI)) {
                                 eani = switch_channel_get_variable(channel, "effective_ani");
                         }
 
                         if (!(flags & SOF_NO_EFFECTIVE_ANIII)) {
                                 eaniii = switch_channel_get_variable(channel, "effective_aniii");
                         }
 
                         if (!(flags & SOF_NO_EFFECTIVE_CID_NAME)) {
                                 ecaller_id_name = switch_channel_get_variable(channel, "effective_caller_id_name");
                         }
 
                         if (!(flags & SOF_NO_EFFECTIVE_CID_NUM)) {
                                 ecaller_id_number = switch_channel_get_variable(channel, "effective_caller_id_number");
                         }
 
                         if (eani || eaniii || ecaller_id_name || ecaller_id_number) {
                                 outgoing_profile = switch_caller_profile_clone(session, caller_profile);
 
                                 if (eani) {
                                         outgoing_profile->ani = eani;
                                 }
                                 if (eaniii) {
                                         outgoing_profile->aniii = eaniii;
                                 }
                                 if (ecaller_id_name) {
                                         outgoing_profile->caller_id_name = ecaller_id_name;
                                 }
                                 if (ecaller_id_number) {
                                         outgoing_profile->caller_id_number = ecaller_id_number;
                                 }
                         }
                 }
                 if (!outgoing_profile) {
                         outgoing_profile = switch_channel_get_caller_profile(channel);
                 }
         }
 
         if ((cause =
                  endpoint_interface->io_routines->outgoing_channel(session, var_event, outgoing_profile, new_session, pool, flags,
                                                                                                                    cancel_cause)) != SWITCH_CAUSE_SUCCESS) {
                 UNPROTECT_INTERFACE(endpoint_interface);
                 return cause;
         }
 
         if (session) {
                 for (ptr = session->event_hooks.outgoing_channel; ptr; ptr = ptr->next) {
                         if ((status = ptr->outgoing_channel(session, var_event, caller_profile, *new_session, flags)) != SWITCH_STATUS_SUCCESS) {
                                 break;
                         }
                 }
         }
 
         if (!*new_session) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT,
                                                   "Outgoing method for endpoint: [%s] returned: [%s] but there is no new session!\n", endpoint_name,
                                                   switch_channel_cause2str(cause));
                 UNPROTECT_INTERFACE(endpoint_interface);
                 return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
         } else {
                 switch_caller_profile_t *profile = NULL, *cloned_profile = NULL;
                 switch_event_t *event;
                 switch_channel_t *peer_channel = switch_core_session_get_channel(*new_session);
                 const char *use_uuid;
 
                 switch_assert(peer_channel);
 
                 if (channel && switch_true(switch_channel_get_variable(channel, "session_copy_loglevel"))) {
                         (*new_session)->loglevel = session->loglevel;
                 }
 
 
                 if ((use_uuid = switch_event_get_header(var_event, "origination_uuid"))) {
                         use_uuid = switch_core_session_strdup(*new_session, use_uuid);
                         if (switch_core_session_set_uuid(*new_session, use_uuid) == SWITCH_STATUS_SUCCESS) {
                                 switch_event_del_header(var_event, "origination_uuid");
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_DEBUG, "%s set UUID=%s\n", switch_channel_get_name(peer_channel),
                                                                   use_uuid);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_CRIT, "%s set UUID=%s FAILED\n",
                                                                   switch_channel_get_name(peer_channel), use_uuid);
                         }
                 }
 
                 if (channel) {
                         const char *val;
                         switch_codec_t *vid_read_codec = NULL, *read_codec = switch_core_session_get_read_codec(session);
                         const char *ep, *max_forwards = switch_core_session_sprintf(session, "%d", forwardval);
 
                         switch_channel_set_variable(peer_channel, SWITCH_MAX_FORWARDS_VARIABLE, max_forwards);
 
                         profile = switch_channel_get_caller_profile(channel);
 
                         vid_read_codec = switch_core_session_get_video_read_codec(session);
 
                         if (read_codec && read_codec->implementation && switch_core_codec_ready(read_codec)) {
                                 char rc[80] = "", vrc[80] = "", tmp[160] = "";
 
                                 switch_codec2str(read_codec, rc, sizeof(rc));
                                 if (vid_read_codec && vid_read_codec->implementation && switch_core_codec_ready(vid_read_codec)) {
                                         vrc[0] = ',';
                                         switch_codec2str(vid_read_codec, vrc + 1, sizeof(vrc) - 1);
                                         switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_VIDEO_CODEC_VARIABLE, vrc + 1);
                                 }
 
                                 switch_snprintf(tmp, sizeof(tmp), "%s%s", rc, vrc);
                                 switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_CODEC_VARIABLE, tmp);
                         } else if ((ep = switch_channel_get_variable(channel, "ep_codec_string"))) {
                                 switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_CODEC_VARIABLE, ep);
                         }
 
                         switch_channel_set_variable(peer_channel, SWITCH_ORIGINATOR_VARIABLE, switch_core_session_get_uuid(session));
                         switch_channel_set_variable(peer_channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(session));
                         // Needed by 3PCC proxy so that aleg can find bleg to pass SDP to, when final ACK arrives.
                         switch_channel_set_variable(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(*new_session));
 
                         if ((val = switch_channel_get_variable(channel, SWITCH_PROCESS_CDR_VARIABLE))) {
                                 switch_channel_set_variable(peer_channel, SWITCH_PROCESS_CDR_VARIABLE, val);
                         }
 
                         if ((val = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE))) {
                                 switch_channel_pass_sdp(channel, peer_channel, val);
                         }
 
                         if (switch_channel_test_flag(channel, CF_PROXY_MODE)) {
                                 if (switch_channel_test_cap(peer_channel, CC_BYPASS_MEDIA)) {
                                         switch_channel_set_flag(peer_channel, CF_PROXY_MODE);
                                 } else {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                           "%s does not support the proxy feature, disabling.\n", switch_channel_get_name(peer_channel));
                                         switch_channel_clear_flag(channel, CF_PROXY_MODE);
                                 }
                         }
 
                         if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
                                 if (switch_channel_test_cap(peer_channel, CC_PROXY_MEDIA)) {
                                         switch_channel_set_flag(peer_channel, CF_PROXY_MEDIA);
                                         if (switch_channel_test_flag(channel, CF_VIDEO)) {
                                                 switch_channel_set_flag(peer_channel, CF_VIDEO);
                                         }
                                 } else {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                           "%s does not support the proxy feature, disabling.\n", switch_channel_get_name(peer_channel));
                                         switch_channel_clear_flag(channel, CF_PROXY_MEDIA);
                                 }
                         }
 
                         if (switch_channel_test_flag(channel, CF_ZRTP_PASSTHRU_REQ)) {
                                 switch_channel_set_flag(peer_channel, CF_ZRTP_PASSTHRU_REQ);
                         }
 
                         if (profile) {
                                 if ((cloned_profile = switch_caller_profile_clone(*new_session, profile)) != 0) {
                                         switch_channel_set_originator_caller_profile(peer_channel, cloned_profile);
                                 }
                         }
 
 
                         if ((profile = switch_channel_get_caller_profile(peer_channel))) {
                                 if ((cloned_profile = switch_caller_profile_clone(session, profile)) != 0) {
                                         switch_channel_set_origination_caller_profile(channel, cloned_profile);
                                 }
                         }
 
                 }
 
                 if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_OUTGOING) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(peer_channel, event);
                         switch_event_fire(&event);
                 }
         }
 
         UNPROTECT_INTERFACE(endpoint_interface);
         return cause;
 }

switch_status_t switch_core_session_pass_indication	(	switch_core_session_t *	session,
		switch_core_session_message_types_t	indication
	)

Definition at line 940 of file switch_core_session.c.

References switch_core_session_message::from, switch_core_session_message::message_id, switch_channel_get_partner_uuid(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_message_t msg = { 0 };
         switch_core_session_t *other_session;
         const char *uuid;
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         if (((uuid = switch_channel_get_partner_uuid(channel))) && (other_session = switch_core_session_locate(uuid))) {
                 msg.message_id = indication;
                 msg.from = __FILE__;
                 status = switch_core_session_receive_message(other_session, &msg);
                 switch_core_session_rwunlock(other_session);
         } else {
                 status = SWITCH_STATUS_FALSE;
         }
 
         return status;
 }

void switch_core_session_perform_destroy	(	switch_core_session_t **	session,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 1452 of file switch_core_session.c.

References pool, runtime, SCF_SYNC_CLOCK_REQUESTED, switch_session_manager::session_count, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, SSF_DESTROYABLE, switch_buffer_destroy(), switch_channel_event_set_data(), switch_channel_get_name(), switch_channel_get_state(), SWITCH_CHANNEL_ID_LOG, switch_channel_state_name(), switch_channel_uninit(), switch_clear_flag, switch_core_destroy_memory_pool, switch_core_hash_delete(), switch_core_media_bug_remove_all, switch_core_session_destroy_state(), switch_core_session_flush_private_events(), switch_core_session_get_uuid(), switch_core_session_reset(), switch_core_session_running(), SWITCH_EVENT_CHANNEL_DESTROY, switch_event_create, switch_event_fire, switch_ivr_clear_speech_cache(), switch_ivr_deactivate_unicast(), switch_ivr_dmachine_destroy(), SWITCH_LOG_ERROR, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_scheduler_del_task_group(), SWITCH_STATUS_SUCCESS, switch_test_flag, switch_time_sync(), SWITCH_TRUE, and UNPROTECT_INTERFACE.

 {
         switch_memory_pool_t *pool;
         switch_event_t *event;
         switch_endpoint_interface_t *endpoint_interface = (*session)->endpoint_interface;
         int i;
 
 
         switch_core_session_flush_private_events(*session);
 
         if (switch_core_session_running(*session) && !switch_test_flag((*session), SSF_DESTROYABLE)) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(*session), SWITCH_LOG_ERROR,
                                                   "Cowardly ignoring an attempt to call destroy on a running session.\n");
         }
 
         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(*session), SWITCH_LOG_NOTICE, "Close Channel %s [%s]\n",
                                           switch_channel_get_name((*session)->channel), switch_channel_state_name(switch_channel_get_state((*session)->channel)));
 
 
         switch_core_session_reset(*session, SWITCH_TRUE, SWITCH_TRUE);
 
         switch_core_media_bug_remove_all(*session);
         switch_ivr_deactivate_unicast(*session);
 
         switch_scheduler_del_task_group((*session)->uuid_str);
 
         switch_mutex_lock(runtime.session_hash_mutex);
         switch_core_hash_delete(session_manager.session_table, (*session)->uuid_str);
         if (session_manager.session_count) {
                 session_manager.session_count--;
                 if (session_manager.session_count == 0) {
                         if (switch_test_flag((&runtime), SCF_SYNC_CLOCK_REQUESTED)) {
                                 switch_time_sync();
                                 switch_clear_flag((&runtime), SCF_SYNC_CLOCK_REQUESTED);
                         }
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         if ((*session)->plc) {
                 plc_free((*session)->plc);
                 (*session)->plc = NULL;
         }
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_DESTROY) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data((*session)->channel, event);
                 switch_event_fire(&event);
         }
 
         switch_core_session_destroy_state(*session);
 
         switch_buffer_destroy(&(*session)->raw_read_buffer);
         switch_buffer_destroy(&(*session)->raw_write_buffer);
         switch_ivr_clear_speech_cache(*session);
         switch_channel_uninit((*session)->channel);
 
         for (i = 0; i < 2; i++) {
                 if ((*session)->dmachine[i]) {
                         switch_ivr_dmachine_destroy(&(*session)->dmachine[i]);
                 }
         }
 
         pool = (*session)->pool;
         //#ifndef NDEBUG
         //memset(*session, 0, sizeof(switch_core_session_t));
         //#endif
         *session = NULL;
         switch_core_destroy_memory_pool(&pool);
 
         UNPROTECT_INTERFACE(endpoint_interface);
 }

switch_status_t switch_core_session_perform_receive_message	(	switch_core_session_t *	session,
		switch_core_session_message_t *	message,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 773 of file switch_core_session.c.

 {
         switch_io_event_hook_receive_message_t *ptr;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_assert(session != NULL);
 
         if (message->message_id == SWITCH_MESSAGE_INDICATE_SIGNAL_DATA) {
                 if (session->endpoint_interface->io_routines->receive_message) {
                         status = session->endpoint_interface->io_routines->receive_message(session, message);
                 }
 
                 switch_core_session_free_message(&message);
                 return status;
         }
 
         if ((status = switch_core_session_read_lock_hangup(session)) != SWITCH_STATUS_SUCCESS) {
                 return status;
         }
         
         if (!message->_file) {
                 message->_file = file;
         }
 
         if (!message->_func) {
                 message->_func = func;
         }
 
         if (!message->_line) {
                 message->_line = line;
         }
 
         if (message->message_id > SWITCH_MESSAGE_INVALID-1) {
                 message->message_id = SWITCH_MESSAGE_INVALID-1;
         }
 
         switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
                                           switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG1, "%s receive message [%s]\n",
                                           switch_channel_get_name(session->channel), message_names[message->message_id]);
 
 
         if (message->message_id == SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS) {
                 switch_channel_clear_flag(session->channel, CF_EARLY_MEDIA);
         }
 
         if (message->message_id == SWITCH_MESSAGE_INDICATE_MEDIA) {
                 switch_channel_set_flag(session->channel, CF_PROXY_OFF);
         }
 
         if (message->message_id == SWITCH_MESSAGE_INDICATE_DISPLAY) {
                 char *arg = NULL;
 
                 if (zstr(message->string_array_arg[0]) && !zstr(message->string_arg)) {
                         arg = switch_core_session_strdup(session, message->string_arg);
                         switch_separate_string(arg, '|', (char **)message->string_array_arg, 2);                        
                 }
 
                 if (!zstr(message->string_array_arg[0])) {
                         switch_channel_set_variable(session->channel, "last_sent_callee_id_name", message->string_array_arg[0]);
                 }
 
                 if (!zstr(message->string_array_arg[1])) {
                         switch_channel_set_variable(session->channel, "last_sent_callee_id_number", message->string_array_arg[1]);
                 }
                 
 
                 if (switch_true(switch_channel_get_variable(session->channel, SWITCH_IGNORE_DISPLAY_UPDATES_VARIABLE))) {
                         switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
                                                           switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG1, "Ignoring display update.\n");
                         status = SWITCH_STATUS_SUCCESS;
                         goto end;
                 }
 
         }
 
         if (switch_channel_down_nosig(session->channel)) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, message->_file, message->_func, message->_line,
                                                   switch_core_session_get_uuid(session), SWITCH_LOG_DEBUG, "%s skip receive message [%s] (channel is hungup already)\n",
                                                   switch_channel_get_name(session->channel), message_names[message->message_id]);
         
         } else {
                 if (session->media_handle) {
                         status = switch_core_media_receive_message(session, message);
                 }
                 if (status == SWITCH_STATUS_SUCCESS) {
                         if (session->endpoint_interface->io_routines->receive_message) {
                                 status = session->endpoint_interface->io_routines->receive_message(session, message);
                         }
                 }
         }
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 for (ptr = session->event_hooks.receive_message; ptr; ptr = ptr->next) {
                         if ((status = ptr->receive_message(session, message)) != SWITCH_STATUS_SUCCESS) {
                                 break;
                         }
                 }
 
 
                 if (message->message_id == SWITCH_MESSAGE_INDICATE_BRIDGE &&
                         switch_channel_test_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER)) {
                         switch_core_session_t *other_session;
                         const char *uuid = switch_channel_get_variable(session->channel, "blind_transfer_uuid");
 
                         switch_channel_clear_flag(session->channel, CF_CONFIRM_BLIND_TRANSFER);
 
                         if (!zstr(uuid) && (other_session = switch_core_session_locate(uuid))) {
                                 switch_core_session_message_t msg = { 0 };                      
                                 msg.message_id = SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE;
                                 msg.from = __FILE__;
                                 msg.numeric_arg = 1;
                                 switch_core_session_receive_message(other_session, &msg);
                                 switch_core_session_rwunlock(other_session);
                         }
                 }
         }
 
 
         message->_file = NULL;
         message->_func = NULL;
         message->_line = 0;
 
         if (switch_channel_up_nosig(session->channel)) {
                 if (message->message_id == SWITCH_MESSAGE_INDICATE_BRIDGE || message->message_id == SWITCH_MESSAGE_INDICATE_UNBRIDGE) {
                         switch_core_media_bug_flush_all(session);
                         switch_core_recovery_track(session);
                 }
 
                 switch (message->message_id) {
                 case SWITCH_MESSAGE_REDIRECT_AUDIO:
                 case SWITCH_MESSAGE_INDICATE_ANSWER:
                 case SWITCH_MESSAGE_INDICATE_PROGRESS:
                 case SWITCH_MESSAGE_INDICATE_BRIDGE:
                 case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
                 case SWITCH_MESSAGE_INDICATE_TRANSFER:
                 case SWITCH_MESSAGE_INDICATE_RINGING:
                 case SWITCH_MESSAGE_INDICATE_MEDIA:
                 case SWITCH_MESSAGE_INDICATE_NOMEDIA:
                 case SWITCH_MESSAGE_INDICATE_HOLD:
                 case SWITCH_MESSAGE_INDICATE_UNHOLD:
                 case SWITCH_MESSAGE_INDICATE_REDIRECT:
                 case SWITCH_MESSAGE_INDICATE_RESPOND:
                 case SWITCH_MESSAGE_INDICATE_BROADCAST:
                 case SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT:
                 case SWITCH_MESSAGE_INDICATE_DEFLECT:
                         switch_channel_set_flag(session->channel, CF_VIDEO_BREAK);
                         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
                         break;
                 default:
                         break;
                 }
         }
 
   end:
 
         if (message->message_id == SWITCH_MESSAGE_INDICATE_MEDIA) {
                 switch_channel_clear_flag(session->channel, CF_PROXY_OFF);
         }
 
         switch_core_session_free_message(&message);
         switch_core_session_rwunlock(session);
 
         return status;
 }

uint32_t switch_core_session_private_event_count ( switch_core_session_t * session )

Definition at line 1221 of file switch_core_session.c.

References CF_EVENT_LOCK, CF_EVENT_LOCK_PRI, check_media, switch_channel_test_flag(), switch_core_session_get_channel(), and switch_queue_size().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         uint32_t count = 0;
 
         if (session->private_event_queue) {
 
                 if (!switch_channel_test_flag(channel, CF_EVENT_LOCK)) {
                         count = switch_queue_size(session->private_event_queue);
                 }
 
                 if (!switch_channel_test_flag(channel, CF_EVENT_LOCK_PRI)) {
                         count += switch_queue_size(session->private_event_queue_pri);
                 }
 
                 if (count == 0) {
                         check_media(session);
                 }
         }
 
         return count;
 }

switch_status_t switch_core_session_queue_event	(	switch_core_session_t *	session,
		switch_event_t **	event
	)

Definition at line 1133 of file switch_core_session.c.

References switch_assert, switch_core_session_wake_session_thread(), switch_queue_trypush(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_event_send().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(session != NULL);
 
         if (session->event_queue) {
                 if (switch_queue_trypush(session->event_queue, *event) == SWITCH_STATUS_SUCCESS) {
                         *event = NULL;
                         status = SWITCH_STATUS_SUCCESS;
 
                         switch_core_session_wake_session_thread(session);
                 }
         }
 
         return status;
 }

switch_status_t switch_core_session_queue_indication	(	switch_core_session_t *	session,
		switch_core_session_message_types_t	indication
	)

Definition at line 960 of file switch_core_session.c.

References switch_core_session_message::from, memset(), switch_core_session_message::message_id, SCSMF_DYNAMIC, switch_core_session_queue_message(), switch_set_flag, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_message_t *msg;
 
         if ((msg = malloc(sizeof(*msg)))) {
                 memset(msg, 0, sizeof(*msg));
                 msg->message_id = indication;
                 msg->from = __FILE__;
                 switch_set_flag(msg, SCSMF_DYNAMIC);
                 switch_core_session_queue_message(session, msg);
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

switch_status_t switch_core_session_queue_message	(	switch_core_session_t *	session,
		switch_core_session_message_t *	message
	)

Definition at line 976 of file switch_core_session.c.

References switch_assert, switch_core_session_kill_channel, switch_core_session_wake_session_thread(), switch_queue_trypush(), SWITCH_SIG_BREAK, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_dequeue_message(), and switch_core_session_queue_indication().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(session != NULL);
 
         if (session->message_queue) {
                 if (switch_queue_trypush(session->message_queue, message) == SWITCH_STATUS_SUCCESS) {
                         status = SWITCH_STATUS_SUCCESS;
                 }
 
                 switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
 
                 switch_core_session_wake_session_thread(session);
 
         }
 
         return status;
 }

switch_status_t switch_core_session_queue_private_event	(	switch_core_session_t *	session,
		switch_event_t **	event,
		switch_bool_t	priority
	)

Definition at line 1191 of file switch_core_session.c.

References switch_assert, switch_core_session_kill_channel, SWITCH_EVENT_PRIVATE_COMMAND, switch_queue_trypush(), SWITCH_SIG_BREAK, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_execute_application_async().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_queue_t *queue;
 
         switch_assert(session != NULL);
         switch_assert(event != NULL);
 
         if (session->private_event_queue) {
                 queue = priority ? session->private_event_queue_pri : session->private_event_queue;
 
                 (*event)->event_id = SWITCH_EVENT_PRIVATE_COMMAND;
                 if (switch_queue_trypush(queue, *event) == SWITCH_STATUS_SUCCESS) {
                         *event = NULL;
                         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
                         status = SWITCH_STATUS_SUCCESS;
                 }
         }
 
         return status;
 }

switch_status_t switch_core_session_receive_event	(	switch_core_session_t *	session,
		switch_event_t **	event
	)

Definition at line 1095 of file switch_core_session.c.

References switch_io_event_hook_receive_event::next, switch_io_event_hook_receive_event::receive_event, switch_assert, switch_channel_up_nosig, switch_core_session_kill_channel, switch_core_session_read_lock(), switch_core_session_rwunlock(), switch_event_destroy(), SWITCH_SIG_BREAK, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_io_event_hook_receive_event_t *ptr;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(session != NULL);
 
         /* Acquire a read lock on the session or forget it the channel is dead */
         if (switch_core_session_read_lock(session) == SWITCH_STATUS_SUCCESS) {
                 if (switch_channel_up_nosig(session->channel)) {
                         if (session->endpoint_interface->io_routines->receive_event) {
                                 status = session->endpoint_interface->io_routines->receive_event(session, *event);
                         }
 
                         if (status == SWITCH_STATUS_SUCCESS) {
                                 for (ptr = session->event_hooks.receive_event; ptr; ptr = ptr->next) {
                                         if ((status = ptr->receive_event(session, *event)) != SWITCH_STATUS_SUCCESS) {
                                                 break;
                                         }
                                 }
                         }
 
                         if (status == SWITCH_STATUS_BREAK) {
                                 status = SWITCH_STATUS_SUCCESS;
                         }
 
                         if (status == SWITCH_STATUS_SUCCESS) {
                                 switch_event_destroy(event);
                         }
                 }
                 switch_core_session_rwunlock(session);
         }
 
         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
 
         return status;
 }

switch_core_session_t* switch_core_session_request_by_name	(	const char *	endpoint_name,
		switch_call_direction_t	direction,
		switch_memory_pool_t **	pool
	)

Definition at line 2384 of file switch_core_session.c.

References SOF_NONE, SWITCH_CHANNEL_LOG, switch_core_session_request, switch_loadable_module_get_endpoint_interface(), SWITCH_LOG_ERROR, switch_log_printf(), and UNPROTECT_INTERFACE.

 {
         switch_endpoint_interface_t *endpoint_interface;
         switch_core_session_t *session;
 
         if ((endpoint_interface = switch_loadable_module_get_endpoint_interface(endpoint_name)) == 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not locate channel type %s\n", endpoint_name);
                 return NULL;
         }
 
         session = switch_core_session_request(endpoint_interface, direction, SOF_NONE, pool);
 
         UNPROTECT_INTERFACE(endpoint_interface);
 
         return session;
 }

switch_core_session_t* switch_core_session_request_uuid	(	switch_endpoint_interface_t *	endpoint_interface,
		switch_call_direction_t	direction,
		switch_originate_flag_t	originate_flags,
		switch_memory_pool_t **	pool,
		const char *	use_uuid
	)

Definition at line 2218 of file switch_core_session.c.

Referenced by switch_core_session_request_xml().

 {
         switch_memory_pool_t *usepool;
         switch_core_session_t *session;
         switch_uuid_t uuid;
         uint32_t count = 0;
         int32_t sps = 0;
 
 
         if (use_uuid && switch_core_hash_find(session_manager.session_table, use_uuid)) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Duplicate UUID!\n");
                 return NULL;
         }
 
         if (direction == SWITCH_CALL_DIRECTION_INBOUND && !switch_core_ready_inbound()) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any inbound sessions at this time.\n");
                 return NULL;
         }
 
         if (direction == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_core_ready_outbound()) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any outbound sessions at this time.\n");
                 return NULL;
         }
 
         if (!switch_core_ready() || endpoint_interface == NULL) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The system cannot create any sessions at this time.\n");
                 return NULL;
         }
 
         if (runtime.min_idle_time > 0 && runtime.profile_time < runtime.min_idle_time) {
                 return NULL;
         }
 
         PROTECT_INTERFACE(endpoint_interface);
 
         if (!(originate_flags & SOF_NO_LIMITS)) {
                 switch_mutex_lock(runtime.throttle_mutex);
                 count = session_manager.session_count;
                 sps = --runtime.sps;
                 switch_mutex_unlock(runtime.throttle_mutex);
                 
                 if (sps <= 0) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Throttle Error! %d\n", session_manager.session_count);
                         UNPROTECT_INTERFACE(endpoint_interface);
                         return NULL;
                 }
 
                 if ((count + 1) > session_manager.session_limit) {
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Over Session Limit! %d\n", session_manager.session_limit);
                         UNPROTECT_INTERFACE(endpoint_interface);
                         return NULL;
                 }
         }
 
 
         if (pool && *pool) {
                 usepool = *pool;
                 *pool = NULL;
         } else {
                 switch_core_new_memory_pool(&usepool);
         }
 
         session = switch_core_alloc(usepool, sizeof(*session));
         session->pool = usepool;
 
         switch_core_memory_pool_set_data(session->pool, "__session", session);
 
         if (switch_channel_alloc(&session->channel, direction, session->pool) != SWITCH_STATUS_SUCCESS) {
                 abort();
         }
 
         switch_channel_init(session->channel, session, CS_NEW, 0);
 
         if (direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
                 switch_channel_set_flag(session->channel, CF_OUTBOUND);
         }
 
         /* The session *IS* the pool you may not alter it because you have no idea how
            its all private it will be passed to the thread run function */
 
         if (use_uuid) {
                 switch_set_string(session->uuid_str, use_uuid);
         } else {
                 switch_uuid_get(&uuid);
                 switch_uuid_format(session->uuid_str, &uuid);
         }
 
         switch_channel_set_variable(session->channel, "uuid", session->uuid_str);
         switch_channel_set_variable(session->channel, "call_uuid", session->uuid_str);
 
         session->endpoint_interface = endpoint_interface;
         session->raw_write_frame.data = session->raw_write_buf;
         session->raw_write_frame.buflen = sizeof(session->raw_write_buf);
         session->raw_read_frame.data = session->raw_read_buf;
         session->raw_read_frame.buflen = sizeof(session->raw_read_buf);
 
 
         session->enc_write_frame.data = session->enc_write_buf;
         session->enc_write_frame.buflen = sizeof(session->enc_write_buf);
         session->enc_read_frame.data = session->enc_read_buf;
         session->enc_read_frame.buflen = sizeof(session->enc_read_buf);
 
         switch_mutex_init(&session->mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->resample_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->codec_read_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->codec_write_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->video_codec_read_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->video_codec_write_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->frame_read_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_thread_rwlock_create(&session->bug_rwlock, session->pool);
         switch_thread_cond_create(&session->cond, session->pool);
         switch_thread_rwlock_create(&session->rwlock, session->pool);
         switch_thread_rwlock_create(&session->io_rwlock, session->pool);
         switch_queue_create(&session->message_queue, SWITCH_MESSAGE_QUEUE_LEN, session->pool);
         switch_queue_create(&session->signal_data_queue, SWITCH_MESSAGE_QUEUE_LEN, session->pool);
         switch_queue_create(&session->event_queue, SWITCH_EVENT_QUEUE_LEN, session->pool);
         switch_queue_create(&session->private_event_queue, SWITCH_EVENT_QUEUE_LEN, session->pool);
         switch_queue_create(&session->private_event_queue_pri, SWITCH_EVENT_QUEUE_LEN, session->pool);
 
         switch_mutex_lock(runtime.session_hash_mutex);
         switch_core_hash_insert(session_manager.session_table, session->uuid_str, session);
         session->id = session_manager.session_id++;
         session_manager.session_count++;
 
         if (session_manager.session_count > (uint32_t)runtime.sessions_peak) {
                 runtime.sessions_peak = session_manager.session_count;
         }
         if (session_manager.session_count > (uint32_t)runtime.sessions_peak_fivemin) {
                 runtime.sessions_peak_fivemin = session_manager.session_count;
         }
 
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         switch_channel_set_variable_printf(session->channel, "session_id", "%u", session->id);
 
         return session;
 }

void switch_core_session_reset	(	switch_core_session_t *	session,
		switch_bool_t	flush_dtmf,
		switch_bool_t	reset_read_codec
	)

Definition at line 1303 of file switch_core_session.c.

References CF_BREAK, SSF_WARN_TRANSCODE, switch_buffer_destroy(), switch_channel_clear_flag(), switch_channel_flush_dtmf(), switch_channel_has_dtmf(), switch_clear_flag, switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_session_flush_message(), switch_core_session_get_channel(), switch_core_session_set_read_codec(), switch_ivr_deactivate_unicast(), switch_mutex_lock(), switch_mutex_unlock(), switch_resample_destroy(), and switch_safe_free.

Referenced by switch_core_session_perform_destroy().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
         switch_size_t has;
 
         if (reset_read_codec) {
                 switch_core_session_set_read_codec(session, NULL);
                 if (session->sdata && switch_core_codec_ready(&session->sdata->codec)) {
                         switch_core_codec_destroy(&session->sdata->codec);
                 }
         }
 
         /* clear resamplers */
         switch_mutex_lock(session->resample_mutex);
         switch_resample_destroy(&session->read_resampler);
         switch_resample_destroy(&session->write_resampler);
         switch_mutex_unlock(session->resample_mutex);
         /* clear indications */
         switch_core_session_flush_message(session);
 
         /* wipe these, they will be recreated if need be */
         switch_mutex_lock(session->codec_write_mutex);
         switch_buffer_destroy(&session->raw_write_buffer);
         switch_mutex_unlock(session->codec_write_mutex);
 
         switch_mutex_lock(session->codec_read_mutex);
         switch_buffer_destroy(&session->raw_read_buffer);
         switch_mutex_unlock(session->codec_read_mutex);
 
         switch_mutex_lock(session->video_codec_write_mutex);
         switch_buffer_destroy(&session->video_raw_write_buffer);
         switch_mutex_unlock(session->video_codec_write_mutex);
 
         switch_mutex_lock(session->video_codec_read_mutex);
         switch_buffer_destroy(&session->video_raw_read_buffer);
         switch_mutex_unlock(session->video_codec_read_mutex);
 
         //video_raw_read_frame.data is dynamically allocated if necessary, so wipe this also
         switch_safe_free(session->video_raw_read_frame.data);
 
         if (flush_dtmf) {
                 while ((has = switch_channel_has_dtmf(channel))) {
                         switch_channel_flush_dtmf(channel);
                 }
         }
 
         switch_clear_flag(session, SSF_WARN_TRANSCODE);
         switch_ivr_deactivate_unicast(session);
         switch_channel_clear_flag(channel, CF_BREAK);
 }

unsigned int switch_core_session_running ( switch_core_session_t * session )

Definition at line 1422 of file switch_core_session.c.

References SSF_THREAD_RUNNING, and switch_test_flag.

Referenced by switch_core_session_perform_destroy().

 {
         return switch_test_flag(session, SSF_THREAD_RUNNING) ? 1 : 0;
 }

switch_status_t switch_core_session_set_private_class	(	switch_core_session_t *	session,
		void *	private_info,
		switch_pvt_class_t	index
	)

Definition at line 465 of file switch_core_session.c.

References switch_assert, SWITCH_CORE_SESSION_MAX_PRIVATES, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_assert(session != NULL);
 
         if ((int)index >= SWITCH_CORE_SESSION_MAX_PRIVATES) {
                 return SWITCH_STATUS_FALSE;
         }
 
         session->private_info[index] = private_info;
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_core_session_set_uuid	(	switch_core_session_t *	session,
		const char *	use_uuid
	)

Definition at line 1897 of file switch_core_session.c.

References switch_core_session_message::from, switch_core_session_message::message_id, switch_caller_profile::pool, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_core_session_message::string_array_arg, switch_assert, switch_channel_event_set_data(), switch_channel_get_caller_profile(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert, switch_core_session_receive_message, switch_core_strdup, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_UUID, switch_event_create, switch_event_fire, SWITCH_LOG_CRIT, switch_log_printf(), SWITCH_MESSAGE_INDICATE_UUID_CHANGE, switch_mutex_lock(), switch_mutex_unlock(), switch_set_string, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_caller_profile::uuid.

Referenced by switch_core_session_outgoing_channel().

 {
         switch_event_t *event;
         switch_core_session_message_t msg = { 0 };
         switch_caller_profile_t *profile;
 
         switch_assert(use_uuid);
 
         if (!strcmp(use_uuid, session->uuid_str)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
 
         switch_mutex_lock(runtime.session_hash_mutex);
         if (switch_core_hash_find(session_manager.session_table, use_uuid)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Duplicate UUID!\n");
                 switch_mutex_unlock(runtime.session_hash_mutex);
                 return SWITCH_STATUS_FALSE;
         }
 
         msg.message_id = SWITCH_MESSAGE_INDICATE_UUID_CHANGE;
         msg.from = switch_channel_get_name(session->channel);
         msg.string_array_arg[0] = session->uuid_str;
         msg.string_array_arg[1] = use_uuid;
         switch_core_session_receive_message(session, &msg);
 
         if ((profile = switch_channel_get_caller_profile(session->channel))) {
                 profile->uuid = switch_core_strdup(profile->pool, use_uuid);
         }
 
         switch_channel_set_variable(session->channel, "uuid", use_uuid);
         switch_channel_set_variable(session->channel, "call_uuid", use_uuid);
 
         switch_event_create(&event, SWITCH_EVENT_CHANNEL_UUID);
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Old-Unique-ID", session->uuid_str);
         switch_core_hash_delete(session_manager.session_table, session->uuid_str);
         switch_set_string(session->uuid_str, use_uuid);
         switch_core_hash_insert(session_manager.session_table, session->uuid_str, session);
         switch_mutex_unlock(runtime.session_hash_mutex);
         switch_channel_event_set_data(session->channel, event);
         switch_event_fire(&event);
 
 
         return SWITCH_STATUS_SUCCESS;
 }

void switch_core_session_signal_state_change ( switch_core_session_t * session )

Definition at line 1401 of file switch_core_session.c.

References switch_io_event_hook_state_change::next, switch_io_event_hook_state_change::state_change, switch_core_session_kill_channel, switch_core_session_wake_session_thread(), SWITCH_SIG_BREAK, and SWITCH_STATUS_SUCCESS.

 {
         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);
         }
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 for (ptr = session->event_hooks.state_change; ptr; ptr = ptr->next) {
                         if ((status = ptr->state_change(session)) != SWITCH_STATUS_SUCCESS) {
                                 break;
                         }
                 }
         }
         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
 }

unsigned int switch_core_session_started ( switch_core_session_t * session )

Definition at line 1427 of file switch_core_session.c.

References SSF_THREAD_STARTED, and switch_test_flag.

 {
         return switch_test_flag(session, SSF_THREAD_STARTED) ? 1 : 0;
 }

static void* SWITCH_THREAD_FUNC switch_core_session_thread	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1619 of file switch_core_session.c.

Referenced by switch_core_session_thread_launch(), and switch_core_session_thread_pool_launch().

 {
         switch_core_session_t *session = obj;
         switch_event_t *event;
         char *event_str = NULL;
         const char *val;
 
         session->thread = thread;
         session->thread_id = switch_thread_self();
 
         switch_core_session_run(session);
         switch_core_media_bug_remove_all(session);
 
         if (session->soft_lock) {
                 uint32_t loops = session->soft_lock * 10;
 
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Session %" SWITCH_SIZE_T_FMT " (%s) Soft-Locked, "
                                                   "Waiting %u for external entities\n",
                                                   session->id, switch_channel_get_name(session->channel), session->soft_lock);
 
                 while(--loops > 0) {
                         if (!session->soft_lock) break;
                         switch_yield(100000);
                 }
 
         }
 
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Session %" SWITCH_SIZE_T_FMT " (%s) Locked, Waiting on external entities\n",
                                           session->id, switch_channel_get_name(session->channel));
         switch_core_session_write_lock(session);
         switch_set_flag(session, SSF_DESTROYED);
 
         if ((val = switch_channel_get_variable(session->channel, "memory_debug")) && switch_true(val)) {
                 if (switch_event_create(&event, SWITCH_EVENT_GENERAL) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(session->channel, event);
                         switch_event_serialize(event, &event_str, SWITCH_FALSE);
                         switch_assert(event_str);
                         switch_core_memory_pool_tag(switch_core_session_get_pool(session), switch_core_session_strdup(session, event_str));
                         free(event_str);
                         switch_event_destroy(&event);
                 }
         }
 
         switch_core_session_rwunlock(session);
 
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Session %" SWITCH_SIZE_T_FMT " (%s) Ended\n",
                                           session->id, switch_channel_get_name(session->channel));
 
         switch_set_flag(session, SSF_DESTROYABLE);
         switch_core_session_destroy(&session);
         return NULL;
 }

switch_status_t switch_core_session_thread_launch ( switch_core_session_t * session )

Definition at line 1834 of file switch_core_session.c.

References apr_threadattr_t::pool, runtime, SCF_SESSION_THREAD_POOL, SSF_THREAD_RUNNING, SSF_THREAD_STARTED, SWITCH_CHANNEL_SESSION_LOG, switch_clear_flag, switch_core_session_thread(), switch_core_session_thread_pool_launch(), SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_INUSE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_detach_set(), switch_threadattr_stacksize_set(), thread, and thread_launch_failure().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_thread_t *thread;
         switch_threadattr_t *thd_attr;
         
         if (switch_test_flag(session, SSF_THREAD_RUNNING) || switch_test_flag(session, SSF_THREAD_STARTED)) {
                 status = SWITCH_STATUS_INUSE;
                 goto end;
         }
 
 
         if (switch_test_flag((&runtime), SCF_SESSION_THREAD_POOL)) {
                 return switch_core_session_thread_pool_launch(session);
         }
         
         switch_mutex_lock(session->mutex);
 
         if (switch_test_flag(session, SSF_THREAD_RUNNING)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot double-launch thread!\n");
         } else if (switch_test_flag(session, SSF_THREAD_STARTED)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot launch thread again after it has already been run!\n");
         } else {
                 switch_set_flag(session, SSF_THREAD_RUNNING);
                 switch_set_flag(session, SSF_THREAD_STARTED);
 
                 switch_threadattr_create(&thd_attr, session->pool);
                 switch_threadattr_detach_set(thd_attr, 1);
                 switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
 
                 if (switch_thread_create(&thread, thd_attr, switch_core_session_thread, session, session->pool) == SWITCH_STATUS_SUCCESS) {
                         switch_set_flag(session, SSF_THREAD_STARTED);
                         status = SWITCH_STATUS_SUCCESS;
                 } else {
                         switch_clear_flag(session, SSF_THREAD_RUNNING);
                         switch_clear_flag(session, SSF_THREAD_STARTED); 
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "Cannot create thread!\n");
                         thread_launch_failure();
                 }
         }
 
         switch_mutex_unlock(session->mutex);
 
  end:
 
         return status;
 }

static void* SWITCH_THREAD_FUNC switch_core_session_thread_pool_worker	(	switch_thread_t *	thread,
		void *	obj
	)

static

Definition at line 1676 of file switch_core_session.c.

References switch_thread_data_s::alloc, switch_session_manager::busy, switch_session_manager::cond, switch_thread_data_s::func, switch_session_manager::mutex, switch_thread_data_s::obj, pool, switch_thread_data_s::pool, switch_thread_pool_node_s::pool, switch_session_manager::running, session_manager, SWITCH_CHANNEL_LOG, switch_core_destroy_memory_pool, SWITCH_LOG_DEBUG10, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_pop_timeout(), switch_status_is_timeup(), SWITCH_STATUS_SUCCESS, switch_thread_cond_signal(), and switch_session_manager::thread_queue.

Referenced by check_queue().

 {
         switch_thread_pool_node_t *node = (switch_thread_pool_node_t *) obj;
         switch_memory_pool_t *pool = node->pool;
 #ifdef DEBUG_THREAD_POOL
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Started\n", (long) (intptr_t) thread);
 #endif
         for (;;) {
                 void *pop;
                 switch_status_t check_status = switch_queue_pop_timeout(session_manager.thread_queue, &pop, 5000000);
                 if (check_status == SWITCH_STATUS_SUCCESS) {
                         switch_thread_data_t *td = (switch_thread_data_t *) pop;
 
 #ifdef DEBUG_THREAD_POOL                        
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Processing\n", (long) (intptr_t) thread);
 #endif
                         td->func(thread, td->obj);
 
                         if (td->pool) {
                                 switch_memory_pool_t *pool = td->pool;
                                 td = NULL;
                                 switch_core_destroy_memory_pool(&pool);
                         } else if (td->alloc) {
                                 free(td);
                         }
 #ifdef DEBUG_THREAD_POOL
                         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Done Processing\n", (long)(intptr_t) thread);
 #endif
                         switch_mutex_lock(session_manager.mutex);
                         session_manager.busy--;
                         switch_mutex_unlock(session_manager.mutex);
                 } else {
                         switch_mutex_lock(session_manager.mutex);
                         if (!switch_status_is_timeup(check_status) || session_manager.running > session_manager.busy) {
                                 if (!--session_manager.running) {
                                         switch_thread_cond_signal(session_manager.cond);
                                 }
                                 switch_mutex_unlock(session_manager.mutex);
                                 break;
                         }
                         switch_mutex_unlock(session_manager.mutex);
                 }
         }
 #ifdef DEBUG_THREAD_POOL
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG10, "Worker Thread %ld Ended\n", (long)(intptr_t) thread);
 #endif
         switch_core_destroy_memory_pool(&pool);
         return NULL;
 }

void switch_core_session_uninit ( void )

Definition at line 2474 of file switch_core_session.c.

References switch_session_manager::cond, switch_session_manager::mutex, switch_session_manager::running, session_manager, switch_session_manager::session_table, switch_core_hash_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_term(), switch_thread_cond_timedwait(), and switch_session_manager::thread_queue.

Referenced by switch_core_destroy().

 {
         switch_queue_term(session_manager.thread_queue);
         switch_mutex_lock(session_manager.mutex);
         if (session_manager.running)
                 switch_thread_cond_timedwait(session_manager.cond, session_manager.mutex, 10000000);
         switch_mutex_unlock(session_manager.mutex);
         switch_core_hash_destroy(&session_manager.session_table);
 }

switch_status_t switch_core_session_wake_session_thread ( switch_core_session_t * session )

Definition at line 1366 of file switch_core_session.c.

References switch_channel_state_thread_trylock(), switch_channel_state_thread_unlock(), switch_cond_next(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_thread_cond_signal().

Referenced by switch_core_session_queue_event(), switch_core_session_queue_message(), switch_core_session_queue_signal_data(), and switch_core_session_signal_state_change().

 {
         switch_status_t status;
         int tries = 0;
 
         /* If trylock fails the signal is already awake so we needn't bother ..... or do we????*/
 
  top:
 
         status = switch_mutex_trylock(session->mutex);
         
         if (status == SWITCH_STATUS_SUCCESS) {
                 switch_thread_cond_signal(session->cond);
                 switch_mutex_unlock(session->mutex);
         } else {
                 if (switch_channel_state_thread_trylock(session->channel) == SWITCH_STATUS_SUCCESS) {
                         /* We've beat them for sure, as soon as we release this lock, they will be checking their queue on the next line. */
                         switch_channel_state_thread_unlock(session->channel);
                 } else {
                         /* What luck!  The channel has already started going to sleep *after* we checked if we need to wake it up.
                            It will miss any messages in its queue because they were inserted after *it* checked its queue.  (catch-22)
                            So, it's not asleep yet, but it's too late for us to be sure they know we want them to stay awake and check its queue again.
                            Now *we* need to sleep instead but just for 1ms so we can circle back and try again.
                            This is so rare (yet possible) to happen that we can be fairly certian it will not happen 2x in a row but we'll try 10x just in case.
                          */
                         if (++tries < 10) {
                                 switch_cond_next();
                                 goto top;
                         }
                 }
         }
 
         return status;
 }

uint32_t switch_core_sessions_per_second ( uint32_t new_limit )

Definition at line 2453 of file switch_core_session.c.

References runtime, and switch_runtime::sps_total.

 {
         if (new_limit) {
                 runtime.sps_total = new_limit;
         }
 
         return runtime.sps_total;
 }

SWITCH_STANDARD_SCHED_FUNC ( sch_heartbeat_callback )

Definition at line 1526 of file switch_core_session.c.

References switch_core_session::channel, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, switch_channel_event_set_data(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), switch_epoch_time_now(), switch_event_create, switch_event_fire, SWITCH_EVENT_SESSION_HEARTBEAT, SWITCH_MESSAGE_HEARTBEAT_EVENT, and switch_core_session::track_duration.

 {
         switch_event_t *event;
         switch_core_session_t *session;
         char *uuid = task->cmd_arg;
         switch_core_session_message_t msg = { 0 }; 
 
         if ((session = switch_core_session_locate(uuid))) {
                 switch_event_create(&event, SWITCH_EVENT_SESSION_HEARTBEAT);
                 switch_channel_event_set_data(session->channel, event);
                 switch_event_fire(&event);
 
                 /* reschedule this task */
                 task->runtime = switch_epoch_time_now(NULL) + session->track_duration;
 
                 msg.message_id = SWITCH_MESSAGE_HEARTBEAT_EVENT;
                 msg.numeric_arg = session->track_duration;
                 switch_core_session_receive_message(session, &msg);
 
                 switch_core_session_rwunlock(session);
         }
 }

static void thread_launch_failure ( void )

static

Definition at line 1726 of file switch_core_session.c.

References switch_session_manager::mutex, session_manager, SWITCH_CHANNEL_LOG, switch_core_session_count(), switch_core_session_limit(), SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by check_queue(), switch_core_session_launch_thread(), and switch_core_session_thread_launch().

 {
         uint32_t sess_count;
 
         switch_mutex_lock(session_manager.mutex);
 
         sess_count = switch_core_session_count();
 
         if (sess_count > 110) {
 
                 switch_core_session_limit(sess_count - 10);
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "LUKE: I'm hit, but not bad.\n");
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT,
                                                   "LUKE'S VOICE: Artoo, see what you can do with it. Hang on back there....\n"
                                                   "Green laserfire moves past the beeping little robot as his head turns.  "
                                                   "After a few beeps and a twist of his mechanical arm,\n"
                                                   "Artoo reduces the max sessions to %d thus, saving the switch from certain doom.\n", sess_count - 10);
 
         }
         
         switch_mutex_unlock(session_manager.mutex);
 }

static char* xml_find_var	(	switch_xml_t	vars,
		const char *	name
	)

static

Definition at line 1943 of file switch_core_session.c.

References switch_xml_child(), and switch_xml::txt.

Referenced by switch_core_session_request_xml().

 {
         switch_xml_t var;
         if ((var = switch_xml_child(vars, name)) && var->txt) {
                 return var->txt;
         }
 
         return NULL;
 }

Variable Documentation

const char* message_names[]

static

Definition at line 713 of file switch_core_session.c.

Referenced by switch_core_session_perform_receive_message().

struct switch_session_manager session_manager

Definition at line 42 of file switch_core_session.c.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation