#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_vars_ans (switch_event_t *vars, switch_call_cause_t cause, switch_hup_type_t type)

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...

switch_status_t	switch_core_session_try_reset (switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
	Reset the buffers and resampler on a session, fail if can not lock codec mutexes. 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_thread_pool_wait (switch_thread_data_t *td, int ms)

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)

const char *	switch_core_session_get_text_buffer (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)

switch_status_t	switch_core_session_set_external_id (switch_core_session_t session, const char use_external_id)

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)

const char *	switch_core_session_get_external_id (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)

uint32_t	switch_core_session_stack_count (switch_core_session_t *session, int x)

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)

switch_status_t	switch_core_session_override_io_routines (switch_core_session_t session, switch_io_routines_t ior)

Variables
struct switch_session_manager	session_manager

static const char *	message_names []

Macro Definition Documentation

◆ check_media

#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 1285 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().

◆ DEBUG_THREAD_POOL

#define DEBUG_THREAD_POOL

Definition at line 40 of file switch_core_session.c.

◆ SWITCH_PREFIX_DIR

#define SWITCH_PREFIX_DIR "."

Definition at line 2565 of file switch_core_session.c.

Referenced by switch_core_set_globals().

Typedef Documentation

◆ switch_thread_pool_node_t

typedef struct switch_thread_pool_node_s switch_thread_pool_node_t

Function Documentation

◆ check_queue()

static switch_status_t check_queue ( void )

static

Definition at line 1853 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;
 }

◆ parse_array()

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

static

Definition at line 2110 of file switch_core_session.c.

References str_node::next, and 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);
 }

◆ switch_core_session_add_stream()

int switch_core_session_add_stream	(	switch_core_session_t *	session,
		void *	private_info
	)

Definition at line 504 of file switch_core_session.c.

References switch_core_session::stream_count, and switch_core_session::streams.

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

◆ switch_core_session_debug_pool()

void switch_core_session_debug_pool ( switch_stream_handle_t * stream )

Definition at line 3126 of file switch_core_session.c.

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

 {
         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_core_session_dequeue_event()

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

Definition at line 1247 of file switch_core_session.c.

References CF_DIVERT_EVENTS, switch_core_session::channel, switch_core_session::event_queue, 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_core_session_dequeue_message()

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

Definition at line 1092 of file switch_core_session.c.

References switch_core_session::message_queue, 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_core_session_dequeue_private_event()

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

Definition at line 1316 of file switch_core_session.c.

References CF_EVENT_LOCK, CF_EVENT_LOCK_PRI, check_media, switch_core_session::private_event_queue, switch_core_session::private_event_queue_pri, 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;
 }

◆ switch_core_session_event_count()

uint32_t switch_core_session_event_count ( switch_core_session_t * session )

Definition at line 1238 of file switch_core_session.c.

References switch_core_session::event_queue, and switch_queue_size().

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

◆ switch_core_session_event_send()

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

Definition at line 460 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_core_session_exec()

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 2838 of file switch_core_session.c.

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, *app_uuid_name;
         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;
         switch_bool_t expand_variables = !switch_true(switch_channel_get_variable(session->channel, "app_disable_expand_variables"));
 
         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));
         }
 
         if((app_uuid_name = switch_channel_get_variable(channel, "app_uuid_name"))) {
                 switch_channel_set_variable(channel, "app_uuid_name", NULL);
         }
 
         switch_assert(application_interface);
 
         app = application_interface->interface_name;
 
         if (arg) {
                 if (expand_variables) {
                         expanded = switch_channel_expand_variables(session->channel, arg);
                 } else {
                         expanded = (char *)arg;
                 }
         }
 
         if (expand_variables && 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_INFO, "EXECUTE [depth=%d] %s %s(%s)\n",
                                           switch_core_session_stack_count(session, 0), switch_channel_get_name(session->channel), app, switch_str_nil(expanded));
         } else {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(session), SWITCH_LOG_INFO, "EXECUTE [depth=%d] %s %s(%s)\n",
                                           switch_core_session_stack_count(session, 0), 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_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID-Name", app_uuid_name);
                 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_add_header_string(event, SWITCH_STACK_BOTTOM, "Application-UUID-Name", app_uuid_name);
                 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_core_session_execute_application_get_flags()

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 2728 of file switch_core_session.c.

References switch_application_interface::application_function, CF_PROXY_MODE, CF_VIDEO, switch_core_session::channel, switch_application_interface::flags, SAF_SUPPORT_NOMEDIA, SAF_SUPPORT_TEXT_ONLY, SAF_ZOMBIE_EXEC, SMF_NONE, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED, 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_channel_text_only, 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, UNPROTECT_INTERFACE, and switch_core_session::uuid_str.

 {
         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);
                         }
                 }
         }
 
         if (switch_channel_text_only(session->channel) &&
                 !switch_test_flag(application_interface, SAF_SUPPORT_NOMEDIA) &&
                 !switch_test_flag(application_interface, SAF_SUPPORT_TEXT_ONLY)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Application %s does not support text-only mode on channel %s!\n",
                                                   app, switch_channel_get_name(session->channel));
                 switch_channel_hangup(session->channel, SWITCH_CAUSE_SERVICE_NOT_IMPLEMENTED);
                 switch_goto_status(SWITCH_STATUS_FALSE, done);
         }
 
  exec:
 
         switch_core_session_exec(session, application_interface, arg);
 
   done:
 
         UNPROTECT_INTERFACE(application_interface);
 
         return status;
 }

◆ switch_core_session_execute_exten()

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 3008 of file switch_core_session.c.

References switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_profile::caller_extension, switch_core_session::channel, 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_stack_count(), 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;
         uint32_t stack_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 ((stack_count = switch_core_session_stack_count(session, 0)) > SWITCH_MAX_STACKS) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error %s too many stacked extensions [depth=%d]\n",
                                                   switch_channel_get_name(session->channel), stack_count);
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_core_session_stack_count(session, 1);
 
         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;
                 }
 
                 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 [depth=%d] %s(%s)\n",
                                                   switch_core_session_stack_count(session, 0),
                                                   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);
 
         switch_core_session_stack_count(session, -1);
         return status;
 }

◆ switch_core_session_flush_message()

switch_status_t switch_core_session_flush_message ( switch_core_session_t * session )

Definition at line 1113 of file switch_core_session.c.

References switch_core_session::message_queue, switch_assert, switch_core_session_free_message(), switch_ivr_process_indications(), switch_queue_trypop(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_reset().

 {
         void *pop;
         switch_core_session_message_t *message;
 
         switch_assert(session != NULL);
 
         if (session->message_queue) {
                 while (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_core_session_get_app_log()

switch_app_log_t* switch_core_session_get_app_log ( switch_core_session_t * session )

Definition at line 2651 of file switch_core_session.c.

References switch_core_session::app_log.

 {
         return session->app_log;
 }

◆ switch_core_session_get_channel()

switch_channel_t* switch_core_session_get_channel ( switch_core_session_t * session )

Definition at line 1435 of file switch_core_session.c.

References switch_core_session::channel, and switch_assert.

Referenced by switch_core_session_dequeue_private_event(), switch_core_session_exec(), switch_core_session_execute_exten(), switch_core_session_hupall_matching_vars_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_core_session_get_external_id()

const char* switch_core_session_get_external_id ( switch_core_session_t * session )

Definition at line 2590 of file switch_core_session.c.

References switch_core_session::external_id.

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

◆ switch_core_session_get_id()

switch_size_t switch_core_session_get_id ( switch_core_session_t * session )

Definition at line 2527 of file switch_core_session.c.

References switch_core_session::id.

 {
         return session->id;
 }

◆ switch_core_session_get_private_class()

void* switch_core_session_get_private_class	(	switch_core_session_t *	session,
		switch_pvt_class_t	index
	)

Definition at line 481 of file switch_core_session.c.

References index, switch_core_session::private_info, 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];
 }

◆ switch_core_session_get_stream()

void* switch_core_session_get_stream	(	switch_core_session_t *	session,
		int	index
	)

Definition at line 510 of file switch_core_session.c.

References index, and switch_core_session::streams.

 {
         return session->streams[index];
 }

◆ switch_core_session_get_stream_count()

int switch_core_session_get_stream_count ( switch_core_session_t * session )

Definition at line 516 of file switch_core_session.c.

References switch_core_session::stream_count.

 {
         return session->stream_count;
 }

◆ switch_core_session_get_uuid()

char* switch_core_session_get_uuid ( switch_core_session_t * session )

Definition at line 2584 of file switch_core_session.c.

References switch_core_session::uuid_str.

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

◆ switch_core_session_hupall()

void switch_core_session_hupall ( switch_call_cause_t cause )

Definition at line 378 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);
 
 }

◆ switch_core_session_hupall_matching_var_ans()

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 273 of file switch_core_session.c.

References switch_core_session_hupall_matching_vars_ans(), switch_event_add_header_string(), SWITCH_EVENT_CLONE, switch_event_create, switch_event_destroy(), and SWITCH_STACK_BOTTOM.

 {
         switch_event_t *vars;
         int r = 0;
 
         if (!var_val || !var_name)
                 return r;
 
         switch_event_create(&vars, SWITCH_EVENT_CLONE);
         switch_event_add_header_string(vars, SWITCH_STACK_BOTTOM, var_name, var_val);
         r = switch_core_session_hupall_matching_vars_ans(vars, cause, type);
         switch_event_destroy(&vars);
         return r;
 }

◆ switch_core_session_hupall_matching_vars_ans()

uint32_t switch_core_session_hupall_matching_vars_ans	(	switch_event_t *	vars,
		switch_call_cause_t	cause,
		switch_hup_type_t	type
	)

Definition at line 211 of file switch_core_session.c.

References CF_ANSWERED, switch_core_session::channel, switch_event::headers, switch_event_header::name, switch_event_header::next, 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, switch_core_session::uuid_str, and switch_event_header::value.

Referenced by switch_core_session_hupall_matching_var_ans().

 {
         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 (!vars || !vars->headers)
                 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_value;
                         if (switch_channel_up_nosig(session->channel)) {
                                 /* check if all conditions are satisfied */
                                 int do_hangup = 1;
                                 switch_event_header_t *hp;
                                 for (hp = vars->headers; hp; hp = hp->next) {
                                         const char *var_name = hp->name;
                                         const char *var_value = hp->value;
                                         if (!(this_value = switch_channel_get_variable(session->channel, var_name)) || (strcmp(this_value, var_value))) {
                                                 do_hangup = 0;
                                                 break;
                                         }
                                 }
                                 if (do_hangup) {
                                         switch_channel_hangup(session->channel, cause);
                                         r++;
                                 }
                         }
                         switch_core_session_rwunlock(session);
                 }
         }
 
         switch_core_destroy_memory_pool(&pool);
 
         return r;
 }

◆ switch_core_session_in_thread()

switch_bool_t switch_core_session_in_thread ( switch_core_session_t * session )

Definition at line 1716 of file switch_core_session.c.

References SWITCH_FALSE, switch_thread_equal(), switch_thread_self(), SWITCH_TRUE, and switch_core_session::thread_id.

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

◆ switch_core_session_init()

void switch_core_session_init ( switch_memory_pool_t * pool )

Definition at line 2629 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);
 }

◆ switch_core_session_launch_thread()

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

Definition at line 2007 of file switch_core_session.c.

References switch_core_session::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();
         }
 
 }

◆ switch_core_session_limit()

uint32_t switch_core_session_limit ( uint32_t new_limit )

Definition at line 2596 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_core_session_message_send()

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

Definition at line 440 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_core_session_outgoing_channel()

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 521 of file switch_core_session.c.

 {
         switch_io_event_hook_outgoing_channel_t *ptr;
         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 (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;
                 const char *use_external_id;
                 switch_core_session_t *other_session = NULL;
 
                 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 ((use_external_id = switch_event_get_header(var_event, "origination_external_id"))) {
                         if (switch_core_session_set_external_id(*new_session, use_external_id) == SWITCH_STATUS_SUCCESS) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_DEBUG, "%s set external_id=%s\n", switch_channel_get_name(peer_channel),
                                                                   use_external_id);
                                 switch_event_del_header(var_event, "origination_external_id");
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(*new_session), SWITCH_LOG_CRIT, "%s set external_id=%s FAILED\n",
                                                                   switch_channel_get_name(peer_channel), use_external_id);
                         }
                 }
 
                 if (!channel && var_event) {
                         const char *other_uuid;
 
                         if ((other_uuid = switch_event_get_header(var_event, "origination_aleg_uuid")) && (other_session = switch_core_session_locate(other_uuid))) {
                                 channel = switch_core_session_get_channel(other_session);
                                 session = other_session;
                         }
                 }
                 
                 if (channel) {
                         const char *val;
                         switch_codec_t *vid_read_codec = NULL, *read_codec = switch_core_session_get_read_codec(session);
                         const char *ep = NULL, *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);
 
                         ep = switch_channel_get_variable(channel, "ep_codec_string");
 
                         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_set_variable(peer_channel, SWITCH_ORIGINATOR_CODEC_VARIABLE, ep);
                         }
 
 
                         if (switch_channel_test_flag(channel, CF_MSRPS) || switch_channel_test_flag(channel, CF_WANT_MSRPS)) {
                                 switch_channel_set_flag(peer_channel, CF_WANT_MSRPS);
                         } else if (switch_channel_test_flag(channel, CF_MSRP) || switch_channel_test_flag(channel, CF_WANT_MSRP)) {
                                 switch_channel_set_flag(peer_channel, CF_WANT_MSRP);
                         }
 
                         if (switch_channel_test_flag(channel, CF_RTT) || switch_channel_test_flag(channel, CF_WANT_RTT)) {
                                 switch_channel_set_flag(peer_channel, CF_WANT_RTT);
                         }
 
 
                         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 (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 (other_session) {
                         switch_core_session_rwunlock(other_session);
                         channel = NULL;
                         session = NULL;
                 }
 
 
                 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_core_session_override_io_routines()

switch_status_t switch_core_session_override_io_routines	(	switch_core_session_t *	session,
		switch_io_routines_t *	ior
	)

Definition at line 3146 of file switch_core_session.c.

References CC_IO_OVERRIDE, switch_core_session::channel, switch_core_session::endpoint_interface, switch_core_session::io_override, switch_channel_test_cap(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         if (session->endpoint_interface && switch_channel_test_cap(session->channel, CC_IO_OVERRIDE)) {
                 session->io_override = ior;
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_core_session_pass_indication()

switch_status_t switch_core_session_pass_indication	(	switch_core_session_t *	session,
		switch_core_session_message_types_t	indication
	)

Definition at line 1010 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;
 }

◆ switch_core_session_perform_destroy()

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

Definition at line 1533 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_destroy(), 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_plc_free(), switch_queue_trypop(), 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)));
 
 
         if ((*session)->text_buffer) {
                 switch_buffer_destroy(&(*session)->text_buffer);
         }
 
         if ((*session)->text_line_buffer) {
                 switch_buffer_destroy(&(*session)->text_line_buffer);
         }
 
         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)->external_id) {
                 switch_core_hash_delete(session_manager.session_table, (*session)->external_id);
         }
         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) {
                 switch_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]);
                 }
         }
 
         if ((*session)->event_queue) {
                 void *pop;
                 while (switch_queue_trypop((*session)->event_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                         if (pop) {
                                 switch_event_t *event = (switch_event_t *) pop;
                                 switch_event_destroy(&event);
                         }
                 }
         }
 
         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_core_session_perform_receive_message()

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 843 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;
 }

◆ switch_core_session_private_event_count()

uint32_t switch_core_session_private_event_count ( switch_core_session_t * session )

Definition at line 1293 of file switch_core_session.c.

References CF_EVENT_LOCK, CF_EVENT_LOCK_PRI, check_media, count, switch_core_session::private_event_queue, switch_core_session::private_event_queue_pri, 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_core_session_queue_event()

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

Definition at line 1205 of file switch_core_session.c.

References switch_core_session::event_queue, 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_core_session_queue_indication()

switch_status_t switch_core_session_queue_indication	(	switch_core_session_t *	session,
		switch_core_session_message_types_t	indication
	)

Definition at line 1030 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);
 
                 if (switch_core_session_queue_message(session, msg) == SWITCH_STATUS_SUCCESS) {
                         return SWITCH_STATUS_SUCCESS;
                 }
 
                 free(msg);
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_core_session_queue_message()

switch_status_t switch_core_session_queue_message	(	switch_core_session_t *	session,
		switch_core_session_message_t *	message
	)

Definition at line 1050 of file switch_core_session.c.

References switch_core_session::message_queue, 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_core_session_queue_private_event()

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 1263 of file switch_core_session.c.

References switch_core_session::private_event_queue, switch_core_session::private_event_queue_pri, 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_core_session_receive_event()

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

Definition at line 1167 of file switch_core_session.c.

References switch_core_session::channel, switch_core_session::endpoint_interface, switch_core_session::event_hooks, switch_endpoint_interface::io_routines, switch_io_event_hook_receive_event::next, switch_io_event_hook_receive_event::receive_event, switch_io_routines::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_request_by_name()

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 2546 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_request_uuid()

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 2375 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 (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);
 
         switch_mutex_lock(runtime.session_hash_mutex);
         if (use_uuid && switch_core_hash_find(session_manager.session_table, use_uuid)) {
                 switch_mutex_unlock(runtime.session_hash_mutex);
                 UNPROTECT_INTERFACE(endpoint_interface);
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Duplicate UUID!\n");
 
                 return NULL;
         }
 
         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_mutex_unlock(runtime.session_hash_mutex);
                         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_mutex_unlock(runtime.session_hash_mutex);
                         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->stack_count_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->resample_mutex, SWITCH_MUTEX_NESTED, session->pool);
         switch_mutex_init(&session->codec_init_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->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_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;
 }

◆ switch_core_session_reset()

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

Definition at line 1391 of file switch_core_session.c.

Referenced by switch_core_session_perform_destroy(), and switch_core_session_try_reset().

 {
         switch_channel_t *channel = switch_core_session_get_channel(session);
 
         switch_core_codec_lock_full(session);
 
         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);
 
         if (flush_dtmf) {
                 while (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);
 
         switch_core_codec_unlock_full(session);
 }

◆ switch_core_session_running()

unsigned int switch_core_session_running ( switch_core_session_t * session )

Definition at line 1503 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_core_session_set_external_id()

switch_status_t switch_core_session_set_external_id	(	switch_core_session_t *	session,
		const char *	use_external_id
	)

Definition at line 2068 of file switch_core_session.c.

References switch_core_session::channel, switch_core_session::external_id, runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_assert, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_hash_delete(), switch_core_hash_find(), switch_core_hash_insert, switch_core_session_strdup, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_core_session::uuid_str.

Referenced by switch_core_session_outgoing_channel().

 {
         switch_assert(use_external_id);
 
         if (session->external_id && !strcmp(use_external_id, session->external_id)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
 
         switch_mutex_lock(runtime.session_hash_mutex);
         if (strcmp(use_external_id, session->uuid_str) && switch_core_hash_find(session_manager.session_table, use_external_id)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Duplicate External ID!\n");
                 switch_mutex_unlock(runtime.session_hash_mutex);
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_channel_set_variable(session->channel, "session_external_id", use_external_id);
 
         if (session->external_id && strcmp(session->external_id, session->uuid_str)) {
                 switch_core_hash_delete(session_manager.session_table, session->external_id);
         }
 
         session->external_id = switch_core_session_strdup(session, use_external_id);
 
         if (strcmp(session->external_id, session->uuid_str)) {
                 switch_core_hash_insert(session_manager.session_table, session->external_id, session);
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_core_session_set_private_class()

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 492 of file switch_core_session.c.

References index, switch_core_session::private_info, 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_core_session_set_uuid()

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

Definition at line 2022 of file switch_core_session.c.

References switch_core_session::channel, 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, switch_caller_profile::uuid, and switch_core_session::uuid_str.

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

◆ switch_core_session_signal_state_change()

void switch_core_session_signal_state_change ( switch_core_session_t * session )

Definition at line 1482 of file switch_core_session.c.

References switch_core_session::endpoint_interface, switch_core_session::event_hooks, switch_endpoint_interface::io_routines, switch_io_event_hook_state_change::next, switch_io_event_hook_state_change::state_change, switch_io_routines::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 (ptr->state_change(session) != SWITCH_STATUS_SUCCESS) {
                                 break;
                         }
                 }
         }
         switch_core_session_kill_channel(session, SWITCH_SIG_BREAK);
 }

◆ switch_core_session_started()

unsigned int switch_core_session_started ( switch_core_session_t * session )

Definition at line 1508 of file switch_core_session.c.

References SSF_THREAD_STARTED, and switch_test_flag.

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

◆ switch_core_session_thread()

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

static

Definition at line 1721 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_core_session_thread_launch()

switch_status_t switch_core_session_thread_launch ( switch_core_session_t * session )

Definition at line 1946 of file switch_core_session.c.

References switch_core_session::mutex, switch_core_session::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;
 }

◆ switch_core_session_thread_pool_worker()

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

static

Definition at line 1778 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_thread_data_s::running, 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->running = 1;
                         td->func(thread, td->obj);
                         td->running = 0;
                         
                         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;
 }

◆ switch_core_session_uninit()

void switch_core_session_uninit ( void )

Definition at line 2641 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_core_session_wake_session_thread()

switch_status_t switch_core_session_wake_session_thread ( switch_core_session_t * session )

Definition at line 1446 of file switch_core_session.c.

References CF_STATE_REPEAT, switch_core_session::channel, switch_core_session::cond, switch_core_session::mutex, switch_channel_set_flag, 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_set_flag(session->channel, CF_STATE_REPEAT);
                         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;
 }

◆ switch_core_sessions_per_second()

uint32_t switch_core_sessions_per_second ( uint32_t new_limit )

Definition at line 2620 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()

SWITCH_STANDARD_SCHED_FUNC ( sch_heartbeat_callback )

Definition at line 1628 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);
         }
 }

◆ thread_launch_failure()

static void thread_launch_failure ( void )

static

Definition at line 1830 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);
 }

◆ xml_find_var()

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

static

Definition at line 2100 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

◆ message_names

const char* message_names[]

static

Definition at line 778 of file switch_core_session.c.

Referenced by switch_core_session_perform_receive_message().

◆ session_manager

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

◆ check_media

◆ DEBUG_THREAD_POOL

◆ SWITCH_PREFIX_DIR

Typedef Documentation

◆ switch_thread_pool_node_t

Function Documentation

◆ check_queue()

◆ parse_array()

◆ switch_core_session_add_stream()

◆ switch_core_session_debug_pool()

◆ switch_core_session_dequeue_event()

◆ switch_core_session_dequeue_message()

◆ switch_core_session_dequeue_private_event()

◆ switch_core_session_event_count()

◆ switch_core_session_event_send()

◆ switch_core_session_exec()

◆ switch_core_session_execute_application_get_flags()

◆ switch_core_session_execute_exten()

◆ switch_core_session_flush_message()

◆ switch_core_session_get_app_log()

◆ switch_core_session_get_channel()

◆ switch_core_session_get_external_id()

◆ switch_core_session_get_id()

◆ switch_core_session_get_private_class()

◆ switch_core_session_get_stream()

◆ switch_core_session_get_stream_count()

◆ switch_core_session_get_uuid()

◆ switch_core_session_hupall()

◆ switch_core_session_hupall_matching_var_ans()

◆ switch_core_session_hupall_matching_vars_ans()

◆ switch_core_session_in_thread()

◆ switch_core_session_init()

◆ switch_core_session_launch_thread()

◆ switch_core_session_limit()

◆ switch_core_session_message_send()

◆ switch_core_session_outgoing_channel()

◆ switch_core_session_override_io_routines()

◆ switch_core_session_pass_indication()

◆ switch_core_session_perform_destroy()

◆ switch_core_session_perform_receive_message()

◆ switch_core_session_private_event_count()

◆ switch_core_session_queue_event()

◆ switch_core_session_queue_indication()

◆ switch_core_session_queue_message()

◆ switch_core_session_queue_private_event()

◆ switch_core_session_receive_event()

◆ switch_core_session_request_by_name()

◆ switch_core_session_request_uuid()

◆ switch_core_session_reset()

◆ switch_core_session_running()

◆ switch_core_session_set_external_id()

◆ switch_core_session_set_private_class()

◆ switch_core_session_set_uuid()

◆ switch_core_session_signal_state_change()

◆ switch_core_session_started()

◆ switch_core_session_thread()

◆ switch_core_session_thread_launch()

◆ switch_core_session_thread_pool_worker()

◆ switch_core_session_uninit()

◆ switch_core_session_wake_session_thread()

◆ switch_core_sessions_per_second()

◆ SWITCH_STANDARD_SCHED_FUNC()

◆ thread_launch_failure()

◆ xml_find_var()

Variable Documentation

◆ message_names

◆ session_manager