Collaboration diagram for Session Creation / Management:

Macros
#define	switch_core_session_request(_ep, _d, _f, _p) switch_core_session_request_uuid(_ep, _d, _f, _p, NULL)

#define	switch_core_session_destroy(session) switch_core_session_perform_destroy(session, __FILE__, __SWITCH_FUNC__, __LINE__)
	Destroy a session and return the memory pool to the core. More...

#define	switch_core_session_locate(uuid_str) switch_core_session_perform_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)
	Locate a session based on it's uuid. More...

#define	switch_core_session_force_locate(uuid_str) switch_core_session_perform_force_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)
	Locate a session based on it's uuid even if the channel is not ready. More...

#define	switch_core_session_hupall_matching_var(_vn, _vv, _c) switch_core_session_hupall_matching_var_ans(_vn, _vv, _c, SHT_UNANSWERED \| SHT_ANSWERED)

#define	switch_core_session_get_partner(_session, _partner) switch_core_session_perform_get_partner(_session, _partner, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_core_session_execute_application(_a, _b, _c) switch_core_session_execute_application_get_flags(_a, _b, _c, NULL)
	Execute an application on a session. More...

#define	switch_core_session_get_private(_s) switch_core_session_get_private_class(_s, SWITCH_PVT_PRIMARY)

#define	switch_core_session_set_private(_s, _p) switch_core_session_set_private_class(_s, _p, SWITCH_PVT_PRIMARY)

#define	switch_core_service_session(_s) switch_core_service_session_av(_s, SWITCH_TRUE, SWITCH_FALSE)

#define	switch_core_session_receive_message(_session, _message)

#define	switch_core_session_kill_channel(session, sig) switch_core_session_perform_kill_channel(session, __FILE__, __SWITCH_FUNC__, __LINE__, sig)
	Send a signal to a channel. More...

Enumerations
enum	switch_hup_type_t { SHT_NONE = 0, SHT_UNANSWERED = (1 << 0), SHT_ANSWERED = (1 << 1) }

Functions
switch_core_session_t *	switch_core_session_request_uuid (_In_ switch_endpoint_interface_t endpoint_interface, _In_ switch_call_direction_t direction, switch_originate_flag_t originate_flags, _Inout_opt_ switch_memory_pool_t pool, _In_opt_z_ const char use_uuid)
	Allocate and return a new session from the core. More...

switch_status_t	switch_core_session_set_uuid (_In_ switch_core_session_t session, _In_z_ const char use_uuid)

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

void	switch_core_session_destroy_state (switch_core_session_t *session)

void	switch_core_session_reporting_state (switch_core_session_t *session)

void	switch_core_session_hangup_state (switch_core_session_t *session, switch_bool_t force)

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

switch_size_t	switch_core_session_get_id (_In_ switch_core_session_t *session)

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

switch_size_t	switch_core_session_id_dec (void)

switch_core_session_t *	switch_core_session_request_by_name (_In_z_ const char endpoint_name, _In_ switch_call_direction_t direction, _Inout_ switch_memory_pool_t *pool)
	Allocate and return a new session from the core based on a given endpoint module name. More...

switch_status_t	switch_core_session_thread_launch (_In_ switch_core_session_t *session)
	Launch the session thread (state machine) on a given session. More...

switch_status_t	switch_thread_pool_launch_thread (switch_thread_data_t **tdp)

switch_status_t	switch_core_session_thread_pool_launch (switch_core_session_t *session)

_Ret_ switch_channel_t *	switch_core_session_get_channel (_In_ switch_core_session_t *session)
	Retrieve a pointer to the channel object associated with a given session. More...

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 (_In_ switch_core_session_t *session)

void	switch_core_session_signal_state_change (_In_ switch_core_session_t *session)

char *	switch_core_session_get_uuid (_In_ switch_core_session_t *session)
	Retrieve the unique identifier from a session. More...

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

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)

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_digit_action_target_t	switch_ivr_dmachine_get_target (switch_ivr_dmachine_t *dmachine)

void	switch_ivr_dmachine_set_target (switch_ivr_dmachine_t *dmachine, switch_digit_action_target_t target)

switch_status_t	switch_ivr_dmachine_set_terminators (switch_ivr_dmachine_t dmachine, const char terminators)

switch_status_t	switch_core_session_set_codec_slin (switch_core_session_t session, switch_slin_data_t data)

void	switch_core_session_raw_read (switch_core_session_t *session)

char *	switch_core_get_uuid (void)
	Retrieve the unique identifier from the core. More...

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)

char *	switch_core_get_variable (_In_z_ const char *varname)
	Retrieve a global variable from the core. More...

char *	switch_core_get_variable_dup (_In_z_ const char *varname)

char *	switch_core_get_variable_pdup (_In_z_ const char varname, switch_memory_pool_t pool)

const char *	switch_core_get_hostname (void)

const char *	switch_core_get_switchname (void)

char *	switch_core_get_domain (switch_bool_t dup)

void	switch_core_set_variable (_In_z_ const char varname, _In_opt_z_ const char value)
	Add a global variable to the core. More...

switch_status_t	switch_core_get_variables (switch_event_t **event)

switch_bool_t	switch_core_set_var_conditional (_In_z_ const char varname, _In_opt_z_ const char value, _In_opt_z_ const char *val2)
	Conditionally add a global variable to the core. More...

void	switch_core_dump_variables (_In_ switch_stream_handle_t *stream)

void	switch_core_session_hupall (_In_ switch_call_cause_t cause)
	Hangup all sessions. More...

uint32_t	switch_core_session_hupall_matching_var_ans (_In_ const char var_name, _In_ const char var_val, _In_ switch_call_cause_t cause, switch_hup_type_t type)
	Hangup all sessions which match a specific channel variable. More...

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

switch_console_callback_match_t *	switch_core_session_findall (void)

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

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

switch_status_t	switch_core_session_message_send (_In_z_ const char uuid_str, _In_ switch_core_session_message_t message)
	Send a message to another session using it's uuid. More...

switch_status_t	switch_core_session_queue_message (_In_ switch_core_session_t session, _In_ switch_core_session_message_t message)
	Queue a message on a session. More...

void	switch_core_session_free_message (switch_core_session_message_t **message)

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_pass_indication (_In_ switch_core_session_t *session, _In_ switch_core_session_message_types_t indication)
	pass an indication message on a session More...

switch_status_t	switch_core_session_queue_indication (_In_ switch_core_session_t *session, _In_ switch_core_session_message_types_t indication)
	Queue an indication message on a session. More...

switch_status_t	switch_core_session_dequeue_message (_In_ switch_core_session_t session, _Out_ switch_core_session_message_t *message)
	DE-Queue an message on a given session. More...

switch_status_t	switch_core_session_flush_message (_In_ switch_core_session_t *session)
	Flush a message queue on a given session. More...

switch_status_t	switch_core_session_event_send (_In_z_ const char uuid_str, _Inout_ switch_event_t *event)
	Queue an event on another session using its uuid. More...

switch_app_log_t *	switch_core_session_get_app_log (_In_ switch_core_session_t *session)

switch_status_t	switch_core_session_exec (_In_ switch_core_session_t session, _In_ const switch_application_interface_t application_interface, _In_opt_z_ const char *arg)
	Execute an application on a session. More...

void	switch_core_session_video_reset (switch_core_session_t *session)

switch_status_t	switch_core_session_execute_application_get_flags (_In_ switch_core_session_t session, _In_ const char app, _In_opt_z_ const char arg, _Out_opt_ int32_t flags)
	Execute an application on a session. More...

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

switch_status_t	switch_core_session_get_app_flags (const char app, int32_t flags)

switch_status_t	switch_core_session_execute_exten (_In_ switch_core_session_t session, _In_z_ const char exten, _In_opt_z_ const char dialplan, _In_opt_z_ const char context)
	Run a dialplan and execute an extension. More...

switch_status_t	switch_core_session_receive_event (_In_ switch_core_session_t session, _Inout_ switch_event_t *event)
	Send an event to a session translating it to it's native message format. More...

void *	switch_core_session_get_private_class (_In_ switch_core_session_t *session, _In_ switch_pvt_class_t index)
	Retrieve private user data from a session. More...

switch_status_t	switch_core_session_set_private_class (_In_ switch_core_session_t session, _In_ void private_info, _In_ switch_pvt_class_t index)
	Add private user data to a session. More...

int	switch_core_session_add_stream (_In_ switch_core_session_t session, _In_opt_ void private_info)
	Add a logical stream to a session. More...

void *	switch_core_session_get_stream (_In_ switch_core_session_t *session, _In_ int index)
	Retreive a logical stream from a session. More...

int	switch_core_session_get_stream_count (_In_ switch_core_session_t *session)
	Determine the number of logical streams a session has. More...

void	switch_core_session_launch_thread (_In_ switch_core_session_t session, _In_ void (func)(switch_thread_t , void ), _In_opt_ void obj)
	Launch a thread designed to exist within the scope of a given session. More...

void	switch_core_thread_session_end (_In_ switch_core_session_t *session)
	Signal a thread using a thread session to terminate. More...

void	switch_core_service_session_av (_In_ switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)
	Launch a service thread on a session to drop inbound data. More...

switch_call_cause_t	switch_core_session_outgoing_channel (_In_opt_ switch_core_session_t session, _In_opt_ switch_event_t var_event, _In_z_ const char endpoint_name, _In_ switch_caller_profile_t caller_profile, _Inout_ switch_core_session_t new_session, _Inout_ switch_memory_pool_t pool, _In_ switch_originate_flag_t flags, switch_call_cause_t *cancel_cause)
	Request an outgoing session spawned from an existing session using a desired endpoing module. More...

switch_status_t	switch_core_session_perform_receive_message (_In_ switch_core_session_t session, _In_ switch_core_session_message_t message, const char file, const char func, int line)
	Receive a message on a given session. More...

switch_status_t	switch_core_session_queue_event (_In_ switch_core_session_t session, _Inout_ switch_event_t *event)
	Queue an event on a given session. More...

uint32_t	switch_core_session_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting events on a session. More...

uint32_t	switch_core_session_messages_waiting (switch_core_session_t *session)

switch_status_t	switch_core_session_dequeue_event (_In_ switch_core_session_t session, _Out_ switch_event_t *event, switch_bool_t force)
	DE-Queue an event on a given session. More...

switch_status_t	switch_core_session_queue_private_event (_In_ switch_core_session_t session, _Inout_ switch_event_t *event, switch_bool_t priority)
	Queue a private event on a given session. More...

uint32_t	switch_core_session_private_event_count (_In_ switch_core_session_t *session)
	Indicate the number of waiting private events on a session. More...

switch_status_t	switch_core_session_dequeue_private_event (_In_ switch_core_session_t session, _Out_ switch_event_t *event)
	DE-Queue a private event on a given session. More...

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_read_frame (_In_ switch_core_session_t session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
	Read a frame from a session. More...

switch_status_t	switch_core_session_read_video_frame (_In_ switch_core_session_t session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
	Read a video frame from a session. More...

switch_status_t	switch_core_session_write_video_frame (_In_ switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id)
	Write a video frame to a session. More...

switch_status_t	switch_core_session_write_encoded_video_frame (switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id)

switch_status_t	switch_core_session_set_read_impl (switch_core_session_t session, const switch_codec_implementation_t impp)

switch_status_t	switch_core_session_set_write_impl (switch_core_session_t session, const switch_codec_implementation_t impp)

switch_status_t	switch_core_session_set_video_read_impl (switch_core_session_t session, const switch_codec_implementation_t impp)

switch_status_t	switch_core_session_set_video_write_impl (switch_core_session_t session, const switch_codec_implementation_t impp)

void	switch_core_session_reset (_In_ switch_core_session_t *session, switch_bool_t flush_dtmf, switch_bool_t reset_read_codec)
	Reset the buffers and resampler on a session. More...

switch_status_t	switch_core_session_write_frame (_In_ switch_core_session_t session, switch_frame_t frame, switch_io_flag_t flags, int stream_id)
	Write a frame to a session. More...

switch_status_t	switch_core_session_perform_kill_channel (_In_ switch_core_session_t session, const char file, const char *func, int line, switch_signal_t sig)

switch_status_t	switch_core_session_send_dtmf (_In_ switch_core_session_t session, const switch_dtmf_t dtmf)
	Send DTMF to a session. More...

switch_status_t	switch_core_session_send_dtmf_string (switch_core_session_t session, const char dtmf_string)
	Send DTMF to a session. More...

switch_status_t	switch_core_session_recv_dtmf (_In_ switch_core_session_t session, const switch_dtmf_t dtmf)
	RECV DTMF on a session. More...

Detailed Description

Macro Definition Documentation

#define switch_core_service_session ( _s ) switch_core_service_session_av(_s, SWITCH_TRUE, SWITCH_FALSE)

Definition at line 1186 of file switch_core.h.

Referenced by switch_ivr_play_file(), and switch_ivr_speak_text().

#define switch_core_session_destroy ( session ) switch_core_session_perform_destroy(session, __FILE__, __SWITCH_FUNC__, __LINE__)

Destroy a session and return the memory pool to the core.

Parameters

session pointer to a pointer of the session to destroy

Returns

Definition at line 809 of file switch_core.h.

Referenced by switch_core_session_request_xml(), and switch_core_session_thread().

#define switch_core_session_execute_application	(	_a,
		_b,
		_c
	)	switch_core_session_execute_application_get_flags(_a, _b, _c, NULL)

Execute an application on a session.

Parameters

session	the current session
app	the application's name
arg	application arguments

Returns: the application's return value

Definition at line 1103 of file switch_core.h.

Referenced by do_execute_on(), exec_app(), exec_cb(), CoreSession::execute(), switch_core_session_execute_exten(), switch_core_standard_on_execute(), switch_core_standard_on_hangup(), switch_ivr_broadcast(), and switch_ivr_parse_event().

#define switch_core_session_force_locate ( uuid_str ) switch_core_session_perform_force_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)

Locate a session based on it's uuid even if the channel is not ready.

Parameters

uuid_str the unique id of the session you want to find

Returns: the session or NULL

Note: if the session was located it will have a read lock obtained which will need to be released with switch_core_session_rwunlock()

Definition at line 925 of file switch_core.h.

Referenced by CoreSession::CoreSession(), and switch_ivr_uuid_force_exists().

#define switch_core_session_get_partner	(	_session,
		_partner
	)	switch_core_session_perform_get_partner(_session, _partner, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 1002 of file switch_core.h.

Referenced by cleanup_proxy_mode_a(), dtls_state_ready(), switch_channel_check_zrtp(), switch_channel_get_hold_music_partner(), switch_channel_mark_hold(), switch_core_media_gen_local_sdp(), switch_core_media_negotiate_sdp(), switch_core_media_pass_zrtp_hash(), switch_core_media_receive_message(), switch_core_media_toggle_hold(), switch_core_session_read_frame(), and switch_ivr_record_session().

#define switch_core_session_get_private ( _s ) switch_core_session_get_private_class(_s, SWITCH_PVT_PRIMARY)

Definition at line 1132 of file switch_core.h.

#define switch_core_session_hupall_matching_var	(	_vn,
		_vv,
		_c
	)	switch_core_session_hupall_matching_var_ans(_vn, _vv, _c, SHT_UNANSWERED \| SHT_ANSWERED)

Definition at line 984 of file switch_core.h.

Referenced by switch_loadable_module_unprocess().

#define switch_core_session_kill_channel	(	session,
		sig
	)	switch_core_session_perform_kill_channel(session, __FILE__, __SWITCH_FUNC__, __LINE__, sig)

Send a signal to a channel.

Parameters

session	session to send signal to
sig	signal to send

Returns: status returned by the session's signal handler

Definition at line 1352 of file switch_core.h.

Referenced by audio_bridge_thread(), switch_channel_perform_hangup(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_core_session_perform_receive_message(), switch_core_session_queue_message(), switch_core_session_queue_private_event(), switch_core_session_queue_signal_data(), switch_core_session_receive_event(), switch_core_session_signal_state_change(), switch_core_thread_session_end(), and switch_ivr_parse_event().

#define switch_core_session_locate ( uuid_str ) switch_core_session_perform_locate(uuid_str, __FILE__, __SWITCH_FUNC__, __LINE__)

Locate a session based on it's uuid.

Parameters

uuid_str the unique id of the session you want to find

Returns: the session or NULL

Note: if the session was located it will have a read lock obtained which will need to be released with switch_core_session_rwunlock()

Definition at line 916 of file switch_core.h.

#define switch_core_session_receive_message	(	_session,
		_message
	)

Value:

switch_core_session_perform_receive_message(_session, _message, \

__FILE__, __SWITCH_FUNC__, __LINE__)

__SWITCH_FUNC__

#define __SWITCH_FUNC__

Definition: switch_platform.h:51

switch_core_session_perform_receive_message

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

Receive a message on a given session.

Definition at line 1217 of file switch_core.h.

#define switch_core_session_request	(	_ep,
		_d,
		_f,
		_p
	)	switch_core_session_request_uuid(_ep, _d, _f, _p, NULL)

Definition at line 797 of file switch_core.h.

Referenced by switch_core_session_request_by_name().

#define switch_core_session_set_private	(	_s,
		_p
	)	switch_core_session_set_private_class(_s, _p, SWITCH_PVT_PRIMARY)

Definition at line 1141 of file switch_core.h.

Enumeration Type Documentation

enum switch_hup_type_t

Enumerator
SHT_NONE
SHT_UNANSWERED
SHT_ANSWERED

Definition at line 969 of file switch_core.h.

              {
         SHT_NONE = 0,
         SHT_UNANSWERED = (1 << 0),
         SHT_ANSWERED = (1 << 1)
 } switch_hup_type_t;

Function Documentation

void switch_core_dump_variables ( _In_ switch_stream_handle_t * stream )

char* switch_core_get_domain ( switch_bool_t dup )

Definition at line 355 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_core_get_variable(), switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

 {
         char *domain;
         const char *var;
 
         switch_thread_rwlock_rdlock(runtime.global_var_rwlock);  
         if (!(var = switch_core_get_variable("domain"))) {
                 var = "freeswitch.local";
         }
         if (dup) {
                 domain = strdup(var);
         } else {
                 domain = (char *) var;
         }
         switch_thread_rwlock_unlock(runtime.global_var_rwlock);
 
         return domain;
 }

const char* switch_core_get_hostname ( void )

Definition at line 344 of file switch_core.c.

References switch_runtime::hostname.

Referenced by core_event_handler(), switch_console_complete(), switch_console_set_complete(), switch_core_sqldb_start(), and switch_event_prep_for_delivery_detailed().

 {
         return runtime.hostname;
 }

const char* switch_core_get_switchname ( void )

Definition at line 349 of file switch_core.c.

References switch_runtime::hostname, switch_runtime::switchname, and zstr.

Referenced by core_event_handler(), switch_console_list_uuid(), switch_console_loop(), switch_console_set_alias(), switch_core_add_registration(), switch_core_del_registration(), switch_core_expire_registration(), switch_core_recovery_track(), switch_core_sqldb_start(), switch_event_prep_for_delivery_detailed(), switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

 {
         if (!zstr(runtime.switchname)) return runtime.switchname;
         return runtime.hostname;
 }

char* switch_core_get_uuid ( void )

Retrieve the unique identifier from the core.

Returns: a string representing the uuid

Definition at line 482 of file switch_core.c.

References switch_runtime::uuid_str.

Referenced by switch_core_recovery_recover(), switch_core_recovery_track(), switch_core_recovery_untrack(), switch_event_prep_for_delivery_detailed(), switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

 {
         return runtime.uuid_str;
 }

char* switch_core_get_variable ( _In_z_ const char * varname )

Retrieve a global variable from the core.

Parameters

varname the name of the variable

Returns: the value of the desired variable

Referenced by get_channels(), init_upnp(), switch_ivr_originate(), and switch_rtp_add_crypto_key().

char* switch_core_get_variable_dup ( _In_z_ const char * varname )

Referenced by expand_vars(), getGlobalVariable(), switch_event_expand_headers_check(), and switch_find_local_ip().

char* switch_core_get_variable_pdup	(	_In_z_ const char *	varname,
		switch_memory_pool_t *	pool
	)

Referenced by switch_channel_get_variable_dup(), switch_core_perform_file_open(), and switch_rtp_init().

switch_status_t switch_core_get_variables ( switch_event_t ** event )

Definition at line 374 of file switch_core.c.

References switch_runtime::global_var_rwlock, switch_runtime::global_vars, switch_event_dup(), switch_thread_rwlock_rdlock(), and switch_thread_rwlock_unlock().

Referenced by switch_channel_execute_on().

 {
         switch_status_t status;
         switch_thread_rwlock_rdlock(runtime.global_var_rwlock);
         status = switch_event_dup(event, runtime.global_vars);
         switch_thread_rwlock_unlock(runtime.global_var_rwlock);
         return status;
 }

void switch_core_service_session_av	(	_In_ switch_core_session_t *	session,
		switch_bool_t	audio,
		switch_bool_t	video
	)

Launch a service thread on a session to drop inbound data.

Parameters

session the session the launch thread on

int switch_core_session_add_stream	(	_In_ switch_core_session_t *	session,
		_In_opt_ void *	private_info
	)

Add a logical stream to a session.

Parameters

session	the session to add the stream to
private_info	an optional pointer to private data for the new stream

Returns: the stream id of the new stream

uint32_t switch_core_session_count ( void )

Provide the total number of sessions.

Returns: the total number of allocated sessions

Definition at line 2360 of file switch_core_session.c.

References switch_session_manager::session_count, and session_manager.

Referenced by send_heartbeat(), switch_core_session_ctl(), and thread_launch_failure().

 {
         return session_manager.session_count;
 }

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

DE-Queue an event on a given session.

Parameters

session	the session to de-queue the message on
event	the de-queued event
force	force the dequeue

Returns: the SWITCH_STATUS_SUCCESS if the event was de-queued

Referenced by audio_bridge_thread(), CoreSession::flushEvents(), switch_ivr_collect_digits_callback(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_session_echo(), switch_ivr_sleep(), and switch_ivr_speak_text_handle().

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

DE-Queue an message on a given session.

Parameters

session	the session to de-queue the message on
message	the de-queued message

Returns: SWITCH_STATUS_SUCCESS if the message was de-queued

Referenced by switch_ivr_parse_all_messages().

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

DE-Queue a private event on a given session.

Parameters

session	the session to de-queue the message on
event	the de-queued event

Returns: the SWITCH_STATUS_SUCCESS if the event was de-queued

Referenced by switch_ivr_park(), switch_ivr_parse_next_event(), and switch_ivr_speak_text_handle().

switch_status_t switch_core_session_dequeue_signal_data	(	switch_core_session_t *	session,
		void **	signal_data
	)

Definition at line 1079 of file switch_core_session.c.

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

Referenced by switch_ivr_parse_signal_data().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         void *pop;
 
         switch_assert(session != NULL);
 
         if (session->signal_data_queue) {
                 if ((status = (switch_status_t) switch_queue_trypop(session->signal_data_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         *signal_data = pop;
                 }
         }
 
         return status;
 }

void switch_core_session_destroy_state ( switch_core_session_t * session )

Definition at line 685 of file switch_core_state_machine.c.

References CCS_DOWN, CF_REDIRECT, CF_TRANSFER, CS_DESTROY, switch_endpoint_interface::state_handler, STATE_MACRO, switch_assert, switch_channel_clear_device_record(), switch_channel_clear_flag(), switch_channel_set_callstate, and switch_channel_set_running_state.

Referenced by switch_core_session_perform_destroy().

 {
         switch_channel_state_t state = CS_DESTROY, midstate = CS_DESTROY;
         const switch_endpoint_interface_t *endpoint_interface;
         const switch_state_handler_table_t *driver_state_handler = NULL;
         const switch_state_handler_table_t *application_state_handler = NULL;
         int proceed = 1;
         int global_proceed = 1;
         int do_extra_handlers = 1;
         int silly = 0;
         int index = 0;
 
         switch_channel_set_callstate(session->channel, CCS_DOWN);
 
         switch_assert(session != NULL);
         switch_channel_set_running_state(session->channel, CS_DESTROY);
         switch_channel_clear_flag(session->channel, CF_TRANSFER);
         switch_channel_clear_flag(session->channel, CF_REDIRECT);
 
         endpoint_interface = session->endpoint_interface;
         switch_assert(endpoint_interface != NULL);
 
         driver_state_handler = endpoint_interface->state_handler;
         switch_assert(driver_state_handler != NULL);
 
         STATE_MACRO(destroy, "DESTROY");
 
         switch_channel_clear_device_record(session->channel);
 
         return;
 }

uint32_t switch_core_session_event_count ( _In_ switch_core_session_t * session )

Indicate the number of waiting events on a session.

Parameters

session the session to check

Returns: the number of events

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

Queue an event on another session using its uuid.

Parameters

uuid_str	the unique id of the session you want to send a message to
event	the event to send

Returns: the status returned by the message handler

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

Execute an application on a session.

Parameters

session	the current session
application_interface	the interface of the application to execute
arg	application arguments

Warning: Has to be called from the session's thread

Returns: the application's return value

Referenced by collect_thread_run(), switch_ivr_menu_execute(), and switch_ivr_phrase_macro_event().

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

Definition at line 2514 of file switch_core_session.c.

References CF_BLOCK_BROADCAST_UNTIL_MEDIA, CF_PROXY_MODE, switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_queue_private_event(), switch_core_session_strdup, switch_event_add_header_string(), SWITCH_EVENT_COMMAND, switch_event_create, SWITCH_FALSE, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by audio_bridge_thread(), do_execute_on(), switch_core_session_execute_application_get_flags(), tone_detect_callback(), and tone_on_dtmf().

 {
         switch_event_t *execute_event;
         char *ap, *arp;
         
         if (!arg && strstr(app, "::")) {
                 ap = switch_core_session_strdup(session, app);
                 app = ap;
 
                 if ((arp = strstr(ap, "::"))) {
                         *arp = '\0';
                         arg = arp + 2;
                 }
         }
         
         if (switch_event_create(&execute_event, SWITCH_EVENT_COMMAND) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "call-command", "execute");
                 switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "execute-app-name", app);
 
                 if (arg) {
                         switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "execute-app-arg", arg);
                 }
                 
                 if (!switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
                         switch_channel_set_flag(session->channel, CF_BLOCK_BROADCAST_UNTIL_MEDIA);
                 }
 
                 switch_event_add_header_string(execute_event, SWITCH_STACK_BOTTOM, "event-lock", "true");
                 switch_core_session_queue_private_event(session, &execute_event, SWITCH_FALSE);
                 
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

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

Execute an application on a session.

Parameters

session	the current session
app	the application's name
arg	application arguments
flags	pointer to a flags variable to set the applications flags to

Returns: the application's return value

Referenced by switch_ivr_broadcast().

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

Run a dialplan and execute an extension.

Parameters

session	the current session
exten	the interface of the application to execute
arg	application arguments

Note: It does not change the channel back to CS_ROUTING, it manually calls the dialplan and executes the applications

Warning: Has to be called from the session's thread

Returns: the application's return value

switch_console_callback_match_t* switch_core_session_findall ( void )

Definition at line 390 of file switch_core_session.c.

References runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_console_push_match(), switch_core_hash_first, switch_core_hash_next(), switch_core_hash_this(), switch_core_session_read_lock(), switch_core_session_rwunlock(), 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_console_callback_match_t *my_matches = NULL;
 
         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) {
                                 switch_console_push_match(&my_matches, session->uuid_str);
                                 switch_core_session_rwunlock(session);
                         }
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         return my_matches;
 }

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

Definition at line 262 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_get_variable_dup(), switch_channel_up_nosig, switch_console_push_match(), 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_FALSE, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, switch_stristr(), 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_console_callback_match_t *my_matches = NULL;
         const char *like = NULL;
 
         if (var_val && *var_val == '~') {
                 like = var_val + 1;
         }
 
         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))) {
                         const char *this_val;
                         if (switch_channel_up_nosig(session->channel) &&
                                 (this_val = switch_channel_get_variable_dup(session->channel, var_name, SWITCH_FALSE, -1)) && 
                                 (!var_val || (like && switch_stristr(like, var_val)) || !strcmp(this_val, var_val))) {
                                 switch_console_push_match(&my_matches, (const char *) np->str);
                         }
                         switch_core_session_rwunlock(session);
                 }
         }
 
         switch_core_destroy_memory_pool(&pool);
 
 
         return my_matches;
 }

switch_status_t switch_core_session_flush_message ( _In_ switch_core_session_t * session )

Flush a message queue on a given session.

Parameters

session the session to de-queue the message on

Returns: SWITCH_STATUS_SUCCESS if the message was de-queued

uint32_t switch_core_session_flush_private_events ( switch_core_session_t * session )

Flush the private event queue of a session.

Parameters

session the session to flush

Returns: SWITCH_STATUS_SUCCESS if the events have been flushed

Definition at line 1276 of file switch_core_session.c.

References check_media, switch_event_destroy(), switch_queue_trypop(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_perform_destroy(), and switch_ivr_parse_event().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         int x = 0;
         void *pop;
 
         if (session->private_event_queue) {
                 while ((status = (switch_status_t) switch_queue_trypop(session->private_event_queue_pri, &pop)) == SWITCH_STATUS_SUCCESS) {
                         if (pop) {
                                 switch_event_t *event = (switch_event_t *) pop;
                                 switch_event_destroy(&event);
                         }
                         x++;
                 }
                 while ((status = (switch_status_t) switch_queue_trypop(session->private_event_queue, &pop)) == SWITCH_STATUS_SUCCESS) {
                         if (pop) {
                                 switch_event_t *event = (switch_event_t *) pop;
                                 switch_event_destroy(&event);
                         }
                         x++;
                 }
                 check_media(session);
         }
 
         return x;
 }

void switch_core_session_free_message ( switch_core_session_message_t ** message )

Definition at line 996 of file switch_core_session.c.

References MESSAGE_STRING_ARG_MAX, switch_core_session_message::pointer_arg, SCSMF_DYNAMIC, switch_core_session_message::string_arg, switch_core_session_message::string_array_arg, switch_safe_free, and switch_test_flag.

Referenced by switch_core_session_flush_message(), switch_core_session_perform_receive_message(), and switch_ivr_parse_all_messages().

 {
         switch_core_session_message_t *to_free = *message;
         int i;
         char *s;
 
         *message = NULL;
 
         if (switch_test_flag(to_free, SCSMF_DYNAMIC)) {
                 s = (char *) to_free->string_arg;
                 switch_safe_free(s);
                 switch_safe_free(to_free->pointer_arg);
 
                 for (i = 0; i < MESSAGE_STRING_ARG_MAX; i++) {
                         s = (char *) to_free->string_array_arg[i];
                         switch_safe_free(s);
                 }
 
                 switch_safe_free(to_free);
         }
 }

switch_status_t switch_core_session_get_app_flags	(	const char *	app,
		int32_t *	flags
	)

Definition at line 2489 of file switch_core_session.c.

References switch_application_interface::flags, switch_assert, SWITCH_CHANNEL_LOG, switch_loadable_module_get_application_interface(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and UNPROTECT_INTERFACE.

Referenced by switch_ivr_broadcast().

 {
         switch_application_interface_t *application_interface;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(flags);
 
         *flags = 0;
 
         if ((application_interface = switch_loadable_module_get_application_interface(app)) == 0) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid Application %s\n", app);
                 goto end;
         } else if (application_interface->flags) {
                 *flags = application_interface->flags;
                 status = SWITCH_STATUS_SUCCESS;
         }
 
         UNPROTECT_INTERFACE(application_interface);
 
   end:
 
         return status;
 
 }

switch_app_log_t* switch_core_session_get_app_log ( _In_ switch_core_session_t * session )

Referenced by switch_channel_set_timestamps(), switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

_Ret_ switch_channel_t* switch_core_session_get_channel ( _In_ switch_core_session_t * session )

Retrieve a pointer to the channel object associated with a given session.

Parameters

session the session to retrieve from

Returns: a pointer to the channel object

switch_ivr_dmachine_t* switch_core_session_get_dmachine	(	switch_core_session_t *	session,
		switch_digit_action_target_t	target
	)

Definition at line 56 of file switch_core_session.c.

Referenced by signal_bridge_on_hibernate().

 {
         int i = (int) target;
 
         if (i == 0 || i == 1) { 
                 return session->dmachine[i];
         }
 
         return NULL;
 }

switch_size_t switch_core_session_get_id ( _In_ switch_core_session_t * session )

switch_jb_t* switch_core_session_get_jb	(	switch_core_session_t *	session,
		switch_media_type_t	type
	)

Definition at line 68 of file switch_core_session.c.

 {
         if (session->endpoint_interface->io_routines->get_jb) {
                 return session->endpoint_interface->io_routines->get_jb(session, type);
         }
 
         return NULL;
 }

switch_log_level_t switch_core_session_get_loglevel ( switch_core_session_t * session )

Get the log level for a session.

Parameters

session the session to get the log level from

Returns: the log level

Definition at line 2921 of file switch_core_session.c.

References switch_assert.

 {
         switch_assert(session != NULL);
         return session->loglevel;
 }

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.

Definition at line 1361 of file switch_core_session.c.

Referenced by careful_set().

 {
         return session->mutex;
 }

void* switch_core_session_get_private_class	(	_In_ switch_core_session_t *	session,
		_In_ switch_pvt_class_t	index
	)

Retrieve private user data from a session.

Parameters

session the session to retrieve from

Returns: a pointer to the private data

void* switch_core_session_get_stream	(	_In_ switch_core_session_t *	session,
		_In_ int	index
	)

Retreive a logical stream from a session.

Parameters

session	the session to add the stream to
index	the index to retrieve

Returns: the stream

int switch_core_session_get_stream_count ( _In_ switch_core_session_t * session )

Determine the number of logical streams a session has.

Parameters

session the session to query

Returns: the total number of logical streams

char* switch_core_session_get_uuid ( _In_ switch_core_session_t * session )

Retrieve the unique identifier from a session.

Parameters

session the session to retrieve the uuid from

Returns: a string representing the uuid

Referenced by add_uuid(), audio_bridge_thread(), bcast_thread(), check_channel_status(), check_jb_sync(), cleanup_proxy_mode_b(), CoreSession::CoreSession(), meta_on_dtmf(), CoreSession::originate(), signal_bridge_on_hangup(), signal_bridge_on_hibernate(), switch_channel_event_set_basic_data(), switch_channel_get_uuid(), switch_channel_set_caller_profile(), switch_channel_set_name(), switch_core_media_read_frame(), switch_core_media_toggle_hold(), switch_core_recovery_track(), switch_core_recovery_untrack(), switch_core_session_perform_kill_channel(), switch_core_session_read_lock(), switch_core_session_read_lock_hangup(), switch_core_session_send_dtmf(), switch_core_standard_on_execute(), switch_core_standard_on_reset(), switch_core_standard_on_routing(), switch_ivr_enterprise_originate(), switch_ivr_intercept_session(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_signal_bridge(), switch_ivr_uuid_bridge(), switch_log_vprintf(), and uuid_bridge_on_soft_execute().

void switch_core_session_hangup_state	(	switch_core_session_t *	session,
		switch_bool_t	force
	)

Definition at line 758 of file switch_core_state_machine.c.

References api_hook(), CCS_HANGUP, CF_EARLY_HANGUP, runtime, SCF_EARLY_HANGUP, SSF_HANGUP, switch_endpoint_interface::state_handler, STATE_MACRO, SWITCH_API_HANGUP_HOOK_VARIABLE, switch_assert, switch_channel_cause2str(), switch_channel_get_cause(), switch_channel_get_cause_q850(), switch_channel_get_name(), switch_channel_get_state(), switch_channel_get_variable, switch_channel_process_device_hangup(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_callstate, switch_channel_set_hangup_time(), switch_channel_set_timestamps(), switch_channel_set_variable, switch_channel_set_variable_printf(), switch_channel_stop_broadcast, switch_channel_test_flag(), switch_core_media_bug_remove_all, switch_core_media_set_stats(), SWITCH_LOG_DEBUG10, switch_log_printf(), SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE, switch_set_flag, switch_test_flag, switch_thread_self(), and switch_true().

Referenced by CoreSession::hangupState(), switch_channel_perform_hangup(), and switch_core_session_run().

 {
         switch_call_cause_t cause = switch_channel_get_cause(session->channel);
         switch_call_cause_t cause_q850 = switch_channel_get_cause_q850(session->channel);
         int proceed = 1;
         int global_proceed = 1;
         int do_extra_handlers = 1;
         int silly = 0;
         int index = 0;
         switch_channel_state_t state = switch_channel_get_state(session->channel), midstate = state;
         const switch_endpoint_interface_t *endpoint_interface;
         const switch_state_handler_table_t *driver_state_handler = NULL;
         const switch_state_handler_table_t *application_state_handler = NULL;
         const char *hook_var;
         int use_session = 0;
 
         if (!force) {
                 if (!switch_channel_test_flag(session->channel, CF_EARLY_HANGUP) && !switch_test_flag((&runtime), SCF_EARLY_HANGUP)) {
                         return;
                 }
 
                 if (switch_thread_self() != session->thread_id) {
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10, "%s thread mismatch skipping state handler.\n",
                                                           switch_channel_get_name(session->channel));
                         return;
                 }
         }
 
         if (switch_test_flag(session, SSF_HANGUP)) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10, "%s handler already called, skipping state handler.\n",
                                                   switch_channel_get_name(session->channel));
                 return;
         }
 
         endpoint_interface = session->endpoint_interface;
         switch_assert(endpoint_interface != NULL);
 
         driver_state_handler = endpoint_interface->state_handler;
         switch_assert(driver_state_handler != NULL);
 
         switch_channel_set_hangup_time(session->channel);
 
         switch_core_media_bug_remove_all(session);
 
         switch_channel_stop_broadcast(session->channel);
 
         switch_channel_set_variable(session->channel, "hangup_cause", switch_channel_cause2str(cause));
         switch_channel_set_variable_printf(session->channel, "hangup_cause_q850", "%d", cause_q850);
         //switch_channel_presence(session->channel, "unknown", switch_channel_cause2str(cause), NULL);
 
         switch_channel_set_timestamps(session->channel);
         switch_channel_set_callstate(session->channel, CCS_HANGUP);
 
         STATE_MACRO(hangup, "HANGUP");
 
         switch_core_media_set_stats(session);
 
         if ((hook_var = switch_channel_get_variable(session->channel, SWITCH_API_HANGUP_HOOK_VARIABLE))) {
 
                 if (switch_true(switch_channel_get_variable(session->channel, SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE))) {
                         use_session = 1;
                 }
 
                 api_hook(session, hook_var, use_session);
         }
 
         switch_channel_process_device_hangup(session->channel);
         
         switch_set_flag(session, SSF_HANGUP);
 
 }

void switch_core_session_hupall ( _In_ switch_call_cause_t cause )

Hangup all sessions.

Parameters

cause the hangup cause to apply to the hungup channels

Referenced by switch_core_destroy(), and switch_core_session_ctl().

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.

Parameters

endpoint_interface	The endpoint interface
cause	the hangup cause to apply to the hungup channels

Definition at line 312 of file switch_core_session.c.

References switch_core_session::channel, switch_core_session::endpoint_interface, 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.

Referenced by switch_loadable_module_unprocess().

 {
         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) {
                                 if (session->endpoint_interface == endpoint_interface) {
                                         np = switch_core_alloc(pool, sizeof(*np));
                                         np->str = switch_core_strdup(pool, session->uuid_str);
                                         np->next = head;
                                         head = np;
                                 }
                                 switch_core_session_rwunlock(session);
                         }
                 }
         }
         switch_mutex_unlock(runtime.session_hash_mutex);
 
         for(np = head; np; np = np->next) {
                 if ((session = switch_core_session_locate(np->str))) {
                         switch_channel_hangup(session->channel, cause);
                         switch_core_session_rwunlock(session);
                 }
         }
 
         switch_core_destroy_memory_pool(&pool);
 
 }

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

Hangup all sessions which match a specific channel variable.

Parameters

var_name	The variable name to look for
var_val	The value to look for
cause	the hangup cause to apply to the hungup channels

switch_size_t switch_core_session_id ( void )

Provide the current session_id.

Returns: the total number of allocated sessions since core startup

Definition at line 2378 of file switch_core_session.c.

References switch_session_manager::session_id, and session_manager.

Referenced by send_heartbeat().

 {
         return session_manager.session_id;
 }

switch_size_t switch_core_session_id_dec ( void )

Definition at line 2370 of file switch_core_session.c.

References runtime, switch_runtime::session_hash_mutex, switch_session_manager::session_id, session_manager, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_mutex_lock(runtime.session_hash_mutex);
         session_manager.session_id--;
         switch_mutex_unlock(runtime.session_hash_mutex);
         return session_manager.session_id;
 }

void switch_core_session_launch_thread	(	_In_ switch_core_session_t *	session,
		_In_ void ()(switch_thread_t , void )	func,
		_In_opt_ void *	obj
	)

Launch a thread designed to exist within the scope of a given session.

Parameters

session	a session to allocate the thread from
func	a function to execute in the thread
obj	an arguement

Referenced by switch_core_service_session_av().

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

Send a message to another session using it's uuid.

Parameters

uuid_str	the unique id of the session you want to send a message to
message	the switch_core_session_message_t object to send

Returns: the status returned by the message handler

uint32_t switch_core_session_messages_waiting ( switch_core_session_t * session )

Definition at line 1151 of file switch_core_session.c.

References switch_queue_size().

Referenced by check_channel_status().

 {
         int x = 0;
 
         if (session->private_event_queue) {
                 x += switch_queue_size(session->private_event_queue);
         }
 
         if (session->message_queue) {
                 x += switch_queue_size(session->message_queue);
         }
 
         return x;
 }

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

Request an outgoing session spawned from an existing session using a desired endpoing module.

Parameters

session	the originating session
var_event	switch_event_t containing paramaters
endpoint_name	the name of the module to use for the new session
caller_profile	the originator's caller profile
new_session	a NULL pointer to aim at the newly created session
pool	optional existing memory pool to donate to the session
flags	flags to use

Returns: the cause code of the attempted call

Referenced by switch_ivr_originate().

switch_status_t switch_core_session_pass_indication	(	_In_ switch_core_session_t *	session,
		_In_ switch_core_session_message_types_t	indication
	)

pass an indication message on a session

Parameters

session	the session to pass the message across
indication	the indication message to pass

Returns: SWITCH_STATUS_SUCCESS if the message was passed

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

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

Definition at line 152 of file switch_core_session.c.

References switch_core_session::channel, runtime, switch_core_session::rwlock, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, SSF_DESTROYED, switch_channel_get_name(), SWITCH_CHANNEL_ID_LOG, switch_core_hash_find(), switch_core_session_get_uuid(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, and switch_thread_rwlock_tryrdlock().

 {
         switch_core_session_t *session = NULL;
         switch_status_t status;
 
         if (uuid_str) {
                 switch_mutex_lock(runtime.session_hash_mutex);
                 if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) {
                         /* Acquire a read lock on the session */
 
                         if (switch_test_flag(session, SSF_DESTROYED)) {
                                 status = SWITCH_STATUS_FALSE;
 #ifdef SWITCH_DEBUG_RWLOCKS
                                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, uuid_str, SWITCH_LOG_ERROR, "%s %s Read lock FAIL\n",
                                                                   switch_core_session_get_uuid(session), switch_channel_get_name(session->channel));
 #endif
                         } else {
                                 status = (switch_status_t) switch_thread_rwlock_tryrdlock(session->rwlock);
 #ifdef SWITCH_DEBUG_RWLOCKS
                                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, uuid_str, SWITCH_LOG_ERROR, "%s %s Read lock ACQUIRED\n",
                                                                   switch_core_session_get_uuid(session), switch_channel_get_name(session->channel));
 #endif
                         }
 
                         if (status != SWITCH_STATUS_SUCCESS) {
                                 /* not available, forget it */
                                 session = NULL;
                         }
                 }
                 switch_mutex_unlock(runtime.session_hash_mutex);
         }
 
         /* if its not NULL, now it's up to you to rwunlock this */
         return session;
 }

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)

Parameters

session	The session we're searching with
partner	[out] The session's partner, or NULL if it wasnt found

Returns: SWITCH_STATUS_SUCCESS or SWITCH_STATUS_FALSE if this session isn't bridged

Definition at line 189 of file switch_core_session.c.

References switch_channel_get_partner_uuid(), switch_core_session_perform_locate(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         const char *uuid;
 
         if ((uuid = switch_channel_get_partner_uuid(session->channel))) {
                 if ((*partner = switch_core_session_perform_locate(uuid, file, func, line))) {
                         return SWITCH_STATUS_SUCCESS;
                 }
         }
 
         *partner = NULL;
         return SWITCH_STATUS_FALSE;
 }

switch_status_t switch_core_session_perform_kill_channel	(	_In_ switch_core_session_t *	session,
		const char *	file,
		const char *	func,
		int	line,
		switch_signal_t	sig
	)

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

Definition at line 121 of file switch_core_session.c.

References runtime, switch_runtime::session_hash_mutex, session_manager, switch_session_manager::session_table, switch_core_hash_find(), switch_core_session_read_lock(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_perform_get_partner().

 {
         switch_core_session_t *session = NULL;
 
         if (uuid_str) {
                 switch_mutex_lock(runtime.session_hash_mutex);
                 if ((session = switch_core_hash_find(session_manager.session_table, uuid_str))) {
                         /* Acquire a read lock on the session */
 #ifdef SWITCH_DEBUG_RWLOCKS
                         if (switch_core_session_perform_read_lock(session, file, func, line) != SWITCH_STATUS_SUCCESS) {
 #if EMACS_CC_MODE_IS_BUGGY
                         }
 #endif
 #else
                         if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
 #endif
                                 /* not available, forget it */
                                 session = NULL;
                         }
                 }
                 switch_mutex_unlock(runtime.session_hash_mutex);
         }
 
         /* if its not NULL, now it's up to you to rwunlock this */
         return session;
 }

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

Receive a message on a given session.

Parameters

session	the session to receive the message from
message	the message to recieve

Returns: the status returned by the message handler

Referenced by send_ind(), switch_channel_perform_answer(), switch_channel_perform_pre_answer(), and switch_channel_perform_ring_ready_value().

uint32_t switch_core_session_private_event_count ( _In_ switch_core_session_t * session )

Indicate the number of waiting private events on a session.

Parameters

session the session to check

Returns: the number of events

Referenced by audio_bridge_thread().

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

Queue an event on a given session.

Parameters

session	the session to queue the message on
event	the event to queue

Returns: the status returned by the message handler

Referenced by generate_on_dtmf(), speech_thread(), switch_channel_dequeue_dtmf(), and tone_detect_callback().

switch_status_t switch_core_session_queue_indication	(	_In_ switch_core_session_t *	session,
		_In_ switch_core_session_message_types_t	indication
	)

Queue an indication message on a session.

Parameters

session	the session to queue the message to
indication	the indication message to queue

Returns: SWITCH_STATUS_SUCCESS if the message was queued

switch_status_t switch_core_session_queue_message	(	_In_ switch_core_session_t *	session,
		_In_ switch_core_session_message_t *	message
	)

Queue a message on a session.

Parameters

session	the session to queue the message to
message	the message to queue

Returns: SWITCH_STATUS_SUCCESS if the message was queued

Referenced by hanguphook(), send_display(), switch_channel_perform_audio_sync(), switch_channel_perform_video_sync(), and switch_core_media_negotiate_sdp().

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

Queue a private event on a given session.

Parameters

session	the session to queue the message on
event	the event to queue
priority	event has high priority

Returns: the status returned by the message handler

Referenced by switch_ivr_broadcast().

switch_status_t switch_core_session_queue_signal_data	(	switch_core_session_t *	session,
		void *	signal_data
	)

Definition at line 1059 of file switch_core_session.c.

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

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(session != NULL);
 
         if (session->signal_data_queue) {
                 if (switch_queue_push(session->signal_data_queue, signal_data) == 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;
 }

void switch_core_session_raw_read ( switch_core_session_t * session )

Definition at line 2933 of file switch_core_session.c.

References memset(), switch_core_codec_destroy(), switch_core_codec_ready(), switch_core_session_alloc, and switch_core_session_set_codec_slin().

Referenced by switch_ivr_session_echo().

 {
         if (session->sdata) {
                 if (session->sdata && switch_core_codec_ready(&session->sdata->codec)) {
                         switch_core_codec_destroy(&session->sdata->codec);
                 }
                 memset(session->sdata, 0, sizeof(*session->sdata));
         } else {
                 session->sdata = switch_core_session_alloc(session, sizeof(*session->sdata));
         }
 
         switch_core_session_set_codec_slin(session, session->sdata);
 }

switch_status_t switch_core_session_read_frame	(	_In_ switch_core_session_t *	session,
		switch_frame_t **	frame,
		switch_io_flag_t	flags,
		int	stream_id
	)

Read a frame from a session.

Parameters

session	the session to read from
frame	a NULL pointer to a frame to aim at the newly read frame
flags	I/O flags to modify behavior (i.e. non blocking)
stream_id	which logical media channel to use

Returns: SWITCH_STATUS_SUCCESS a the frame was read

Referenced by audio_bridge_thread(), early_thread_run(), switch_core_service_thread(), switch_core_session_wait_for_video_input_params(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_delay_echo(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_media(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_parse_event(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), and switch_ivr_wait_for_silence().

switch_status_t switch_core_session_read_video_frame	(	_In_ switch_core_session_t *	session,
		switch_frame_t **	frame,
		switch_io_flag_t	flags,
		int	stream_id
	)

Read a video frame from a session.

Parameters

session	the session to read from
frame	a NULL pointer to a frame to aim at the newly read frame
flags	I/O flags to modify behavior (i.e. non blocking)
stream_id	which logical media channel to use

Returns: SWITCH_STATUS_SUCCESS a if the frame was read

Referenced by audio_bridge_thread(), and switch_core_service_thread().

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

Send an event to a session translating it to it's native message format.

Parameters

session	the session to receive the event
event	the event to receive

Returns: the status returned by the handler

Referenced by audio_bridge_thread(), and CoreSession::sendEvent().

switch_status_t switch_core_session_recv_dtmf	(	_In_ switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf
	)

RECV DTMF on a session.

Parameters

session	session to recv DTMF from
dtmf	string to recv from the session

Returns: SWITCH_STATUS_SUCCESS if the dtmf is ok to queue

Referenced by switch_channel_queue_dtmf().

void switch_core_session_reporting_state ( switch_core_session_t * session )

Definition at line 830 of file switch_core_state_machine.c.

References api_hook(), CF_NO_CDR, CF_REPORTING, db_job::event, switch_endpoint_interface::state_handler, STATE_MACRO, SWITCH_API_REPORTING_HOOK_VARIABLE, switch_assert, switch_channel_cause2str(), switch_channel_event_set_data(), switch_channel_get_cause(), switch_channel_get_originatee_caller_profile(), switch_channel_get_originator_caller_profile(), switch_channel_get_state(), switch_channel_get_variable, switch_channel_set_flag, switch_channel_str2cause(), switch_channel_test_flag(), switch_core_session_strdup, switch_event_add_body(), switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_HANGUP_COMPLETE, switch_event_create, switch_event_fire, SWITCH_FALSE, switch_ivr_generate_xml_cdr(), SWITCH_PROCESS_CDR_VARIABLE, switch_safe_free, SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE, SWITCH_SKIP_CDR_CAUSES_VARIABLE, switch_split, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_true(), switch_xml_free(), switch_xml_toxml(), and zstr.

Referenced by switch_core_session_run().

 {
         switch_channel_state_t state = switch_channel_get_state(session->channel), midstate = state;
         const switch_endpoint_interface_t *endpoint_interface;
         const switch_state_handler_table_t *driver_state_handler = NULL;
         const switch_state_handler_table_t *application_state_handler = NULL;
         int proceed = 1;
         int global_proceed = 1;
         int do_extra_handlers = 1;
         int silly = 0;
         int index = 0;
         const char *var = switch_channel_get_variable(session->channel, SWITCH_PROCESS_CDR_VARIABLE);
         const char *skip_var = switch_channel_get_variable(session->channel, SWITCH_SKIP_CDR_CAUSES_VARIABLE);
         const char *hook_var;
         int use_session = 0;
         switch_event_t *event;
         switch_call_cause_t cause = switch_channel_get_cause(session->channel);
 
         if (switch_channel_test_flag(session->channel, CF_REPORTING)) {
                 return;
         }
 
         switch_channel_set_flag(session->channel, CF_REPORTING);
 
         switch_assert(session != NULL);
 
         endpoint_interface = session->endpoint_interface;
         switch_assert(endpoint_interface != NULL);
 
         driver_state_handler = endpoint_interface->state_handler;
         switch_assert(driver_state_handler != NULL);
 
         if (!zstr(var)) {
                 if (!strcasecmp(var, "a_only")) {
                         if (switch_channel_get_originator_caller_profile(session->channel)) {
                                 do_extra_handlers = 0;
                         }
                 } else if (!strcasecmp(var, "b_only")) {
                         if (switch_channel_get_originatee_caller_profile(session->channel)) {
                                 do_extra_handlers = 0;
                         }
                 } else if (!switch_true(var)) {
                         do_extra_handlers = 0;
                 }
         }
 
 
         if (!zstr(skip_var)) {
                 int x, ttl = 0;
                 char *list[128] = { 0 };
                 char *dup = switch_core_session_strdup(session, skip_var);
 
                 ttl = switch_split(dup, '|', list);
 
                 for(x = 0; x < ttl; x++) {
                         if (switch_channel_str2cause(list[x]) == cause) {
                                 do_extra_handlers = 0;
                                 break;
                         }
                 }
         }
 
         if (switch_channel_test_flag(session->channel, CF_NO_CDR)) {
                 do_extra_handlers = 0;
         }
 
 
         STATE_MACRO(reporting, "REPORTING");
 
         if ((hook_var = switch_channel_get_variable(session->channel, SWITCH_API_REPORTING_HOOK_VARIABLE))) {
 
                 if (switch_true(switch_channel_get_variable(session->channel, SWITCH_SESSION_IN_HANGUP_HOOK_VARIABLE))) {
                         use_session = 1;
                 }
 
                 api_hook(session, hook_var, use_session);
         }
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HANGUP_COMPLETE) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Hangup-Cause", switch_channel_cause2str(cause));
                 switch_channel_event_set_data(session->channel, event);
                 if (switch_true(switch_channel_get_variable(session->channel, "hangup_complete_with_xml"))) {
                         switch_xml_t cdr = NULL;
                         char *xml_cdr_text;
                         
                         if (switch_ivr_generate_xml_cdr(session, &cdr) == SWITCH_STATUS_SUCCESS) {
                                 xml_cdr_text = switch_xml_toxml(cdr, SWITCH_FALSE);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "CDR-Attached", "xml");
                                 switch_event_add_body(event, "%s", xml_cdr_text);
                                 switch_xml_free(cdr);
                                 switch_safe_free(xml_cdr_text);
                         }
                 }
                 switch_event_fire(&event);
         }
 
 
 
         return;
 }

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

Allocate and return a new session from the core based on a given endpoint module name.

Parameters

endpoint_name	the name of the endpoint module
pool	the pool to use

Returns: the newly created session

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

Allocate and return a new session from the core.

Parameters

endpoint_interface	the endpoint interface the session is to be based on
pool	the pool to use for the allocation (a new one will be used if NULL)

Returns: the newly created session

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

Reset the buffers and resampler on a session.

Parameters

session	the session to reset
flush_dtmf	flush all queued dtmf events too

Referenced by audio_bridge_on_exchange_media(), audio_bridge_thread(), early_thread_run(), eavesdrop_callback(), record_callback(), recording_thread(), switch_core_media_set_codec(), switch_core_standard_on_park(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_originate(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_record_session(), switch_ivr_session_echo(), switch_ivr_session_transfer(), switch_ivr_speak_text(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), and uuid_bridge_on_soft_execute().

switch_status_t switch_core_session_send_dtmf	(	_In_ switch_core_session_t *	session,
		const switch_dtmf_t *	dtmf
	)

Send DTMF to a session.

Parameters

session	session to send DTMF to
dtmf	dtmf to send to the session

Returns: SWITCH_STATUS_SUCCESS if the dtmf was written

Referenced by audio_bridge_thread().

switch_status_t switch_core_session_send_dtmf_string	(	switch_core_session_t *	session,
		const char *	dtmf_string
	)

Send DTMF to a session.

Parameters

session	session to send DTMF to
dtmf_string	string to send to the session

Returns: SWITCH_STATUS_SUCCESS if the dtmf was written

Definition at line 1823 of file switch_core_io.c.

References switch_dtmf_t::digit, DTMF_FLAG_SKIP_PROCESS, switch_dtmf_t::duration, switch_dtmf_t::flags, is_dtmf, switch_assert, switch_channel_down, switch_channel_get_name(), switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_min_dtmf_duration(), switch_core_session_send_dtmf(), switch_core_session_strdup, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_separate_string(), switch_snprintf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

 {
         char *p;
         switch_dtmf_t dtmf = { 0, switch_core_default_dtmf_duration(0), DTMF_FLAG_SKIP_PROCESS, 0};
         int sent = 0, dur;
         char *string;
         int i, argc;
         char *argv[256];
         int dur_total = 0;
 
         switch_assert(session != NULL);
 
         if (zstr(dtmf_string)) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (*dtmf_string == '~') {
                 dtmf_string++;
                 dtmf.flags = 0;
         }
 
         if (switch_channel_down(session->channel)) {
                 return SWITCH_STATUS_FALSE;
         }
 
 
         if (strlen(dtmf_string) > 99) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Attempt to send very large dtmf string ignored!\n");
                 return SWITCH_STATUS_FALSE;
         }
 
         string = switch_core_session_strdup(session, dtmf_string);
         argc = switch_separate_string(string, '+', argv, (sizeof(argv) / sizeof(argv[0])));
 
         if (argc) {
                 switch_channel_pre_answer(session->channel);
         }
 
         for (i = 0; i < argc; i++) {
                 dtmf.duration = switch_core_default_dtmf_duration(0);
                 dur = switch_core_default_dtmf_duration(0) / 8;
                 if ((p = strchr(argv[i], '@'))) {
                         *p++ = '\0';
                         if ((dur = atoi(p)) > (int)switch_core_min_dtmf_duration(0) / 8) {
                                 dtmf.duration = dur * 8;
                         }
                 }
 
 
                 for (p = argv[i]; p && *p; p++) {
                         if (is_dtmf(*p)) {
                                 dtmf.digit = *p;
 
                                 if (dtmf.digit != 'w' && dtmf.digit != 'W') {
                                         if (dtmf.duration > switch_core_max_dtmf_duration(0)) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s EXCESSIVE DTMF DIGIT [%c] LEN [%d]\n",
                                                                                   switch_channel_get_name(session->channel), dtmf.digit, dtmf.duration);
                                                 dtmf.duration = switch_core_max_dtmf_duration(0);
                                         } else if (dtmf.duration < switch_core_min_dtmf_duration(0)) {
                                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s SHORT DTMF DIGIT [%c] LEN [%d]\n",
                                                                                   switch_channel_get_name(session->channel), dtmf.digit, dtmf.duration);
                                                 dtmf.duration = switch_core_min_dtmf_duration(0);
                                         } 
                                 }
 
                                 if (!dtmf.duration) {
                                         dtmf.duration = switch_core_default_dtmf_duration(0);
                                 }
                                 
 
                                 if (switch_core_session_send_dtmf(session, &dtmf) == SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s send dtmf\ndigit=%c ms=%u samples=%u\n",
                                                                           switch_channel_get_name(session->channel), dtmf.digit, dur, dtmf.duration);
                                         sent++;
                                         dur_total += dtmf.duration + 2000;      /* account for 250ms pause */
                                 }
                         }
                 }
 
                 if (dur_total) {
                         char tmp[32] = "";
                         switch_snprintf(tmp, sizeof(tmp), "%d", dur_total / 8);
                         switch_channel_set_variable(session->channel, "last_dtmf_duration", tmp);
                 }
 
         }
         return sent ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

switch_status_t switch_core_session_set_codec_slin	(	switch_core_session_t *	session,
		switch_slin_data_t *	data
	)

Definition at line 87 of file switch_core_session.c.

References switch_codec_implementation::actual_samples_per_second, memset(), switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_init, switch_core_session_get_read_impl(), switch_core_session_set_read_codec(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_raw_read().

 {
         switch_codec_implementation_t read_impl = { 0 };
         int interval;
 
         switch_core_session_get_read_impl(session, &read_impl);
         interval = read_impl.microseconds_per_packet / 1000;
         data->session = session;
 
         if (switch_core_codec_init(&data->codec,
                                                            "L16",
                                                            NULL,
                                                            NULL,
                                                            read_impl.actual_samples_per_second,
                                                            interval,
                                                            read_impl.number_of_channels, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, NULL) == SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                                   SWITCH_LOG_DEBUG, "Codec Activated L16@%uhz %dms\n", read_impl.actual_samples_per_second, interval);
 
                 memset(&data->write_frame, 0, sizeof(data->write_frame));
 
                 data->write_frame.codec = &data->codec;
                 data->write_frame.data = data->frame_data;
                 data->write_frame.buflen = sizeof(data->frame_data);
                 data->write_frame.datalen = 0;
                 switch_core_session_set_read_codec(session, &data->codec);
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

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

Definition at line 44 of file switch_core_session.c.

References switch_ivr_dmachine_set_target().

 {
         int i = (int) target;
 
         if (i == 0 || i == 1) {
                 if (dmachine) {
                         switch_ivr_dmachine_set_target(dmachine, target);
                 }
                 session->dmachine[i] = dmachine;
         }
 }

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.

Parameters

session the session to set the log level on

Returns: SWITCH_STATUS_SUCCESS

Definition at line 2914 of file switch_core_session.c.

References switch_assert, and SWITCH_STATUS_SUCCESS.

 {
         switch_assert(session != NULL);
         session->loglevel = loglevel;
         return SWITCH_STATUS_SUCCESS;
 }

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

Add private user data to a session.

Parameters

session	the session to add used data to
private_info	the used data to add

Returns: SWITCH_STATUS_SUCCESS if data is added

switch_status_t switch_core_session_set_read_impl	(	switch_core_session_t *	session,
		const switch_codec_implementation_t *	impp
	)

Definition at line 376 of file switch_core_codec.c.

References SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_set_codec().

 {
         session->read_impl = *impp;
         return SWITCH_STATUS_SUCCESS;
 }

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

switch_status_t switch_core_session_set_video_read_impl	(	switch_core_session_t *	session,
		const switch_codec_implementation_t *	impp
	)

Definition at line 388 of file switch_core_codec.c.

References SWITCH_STATUS_SUCCESS.

 {
         session->video_read_impl = *impp;
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_core_session_set_video_write_impl	(	switch_core_session_t *	session,
		const switch_codec_implementation_t *	impp
	)

Definition at line 394 of file switch_core_codec.c.

References SWITCH_STATUS_SUCCESS.

 {
         session->video_write_impl = *impp;
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_core_session_set_write_impl	(	switch_core_session_t *	session,
		const switch_codec_implementation_t *	impp
	)

Definition at line 382 of file switch_core_codec.c.

References SWITCH_STATUS_SUCCESS.

Referenced by switch_core_media_set_codec().

 {
         session->write_impl = *impp;
         return SWITCH_STATUS_SUCCESS;
 }

void switch_core_session_signal_state_change ( _In_ switch_core_session_t * session )

Referenced by switch_channel_perform_hangup(), and switch_channel_perform_set_state().

void switch_core_session_soft_lock	(	switch_core_session_t *	session,
		uint32_t	sec
	)

Definition at line 77 of file switch_core_session.c.

 {
         session->soft_lock = sec;
 }

void switch_core_session_soft_unlock ( switch_core_session_t * session )

Definition at line 82 of file switch_core_session.c.

 {
         session->soft_lock = 0;
 }

switch_status_t switch_core_session_thread_launch ( _In_ switch_core_session_t * session )

Launch the session thread (state machine) on a given session.

Parameters

session the session to activate the state machine on

Returns: SWITCH_STATUS_SUCCESS if the thread was launched

Referenced by recover_callback(), switch_channel_perform_hangup(), and switch_ivr_originate().

switch_status_t switch_core_session_thread_pool_launch ( switch_core_session_t * session )

Definition at line 1809 of file switch_core_session.c.

References check_queue(), switch_thread_data_s::func, switch_thread_data_s::obj, session_manager, SSF_THREAD_RUNNING, SSF_THREAD_STARTED, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_alloc, switch_core_session_thread(), SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_push(), switch_set_flag, SWITCH_STATUS_INUSE, switch_test_flag, and switch_session_manager::thread_queue.

Referenced by switch_core_session_thread_launch().

 {
         switch_status_t status = SWITCH_STATUS_INUSE;
         switch_thread_data_t *td;
 
         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);
                 td = switch_core_session_alloc(session, sizeof(*td));
                 td->obj = session;
                 td->func = switch_core_session_thread;
                 status = switch_queue_push(session_manager.thread_queue, td);
                 check_queue();
         }
         switch_mutex_unlock(session->mutex);
 
         return status;
 }

void switch_core_session_video_reset ( switch_core_session_t * session )

Definition at line 2550 of file switch_core_session.c.

References CF_VIDEO_BLANK, CF_VIDEO_DEBUG_READ, CF_VIDEO_DEBUG_WRITE, CF_VIDEO_ECHO, CF_VIDEO_PASSIVE, switch_channel_clear_flag(), and switch_core_session_request_video_refresh().

Referenced by audio_bridge_thread(), switch_core_media_set_video_file(), switch_core_media_start_video_function(), switch_core_standard_on_execute(), and switch_ivr_session_echo().

 {
         switch_channel_clear_flag(session->channel, CF_VIDEO_ECHO);
         switch_channel_clear_flag(session->channel, CF_VIDEO_PASSIVE);
         //switch_channel_clear_flag(session->channel, CF_VIDEO_DECODED_READ);
         switch_channel_clear_flag(session->channel, CF_VIDEO_DEBUG_READ);
         switch_channel_clear_flag(session->channel, CF_VIDEO_DEBUG_WRITE);
         switch_channel_clear_flag(session->channel, CF_VIDEO_BLANK);
         switch_core_session_request_video_refresh(session);
 }

switch_status_t switch_core_session_wake_session_thread ( _In_ switch_core_session_t * session )

Referenced by check_channel_status(), and switch_core_session_read_lock().

switch_status_t switch_core_session_write_encoded_video_frame	(	switch_core_session_t *	session,
		switch_frame_t *	frame,
		switch_io_flag_t	flags,
		int	stream_id
	)

Definition at line 11013 of file switch_core_media.c.

References switch_io_event_hook_video_write_frame::next, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_media_flow(), SWITCH_LOG_DEBUG3, switch_log_printf(), SWITCH_MEDIA_FLOW_RECVONLY, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_io_event_hook_video_write_frame::video_write_frame.

Referenced by switch_core_session_write_video_frame().

 {
         switch_io_event_hook_video_write_frame_t *ptr;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         if (switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_RECVONLY) {
                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG3, "Writing video to RECVONLY session\n");
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (session->endpoint_interface->io_routines->write_video_frame) {
                 if ((status = session->endpoint_interface->io_routines->write_video_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                         for (ptr = session->event_hooks.video_write_frame; ptr; ptr = ptr->next) {
                                 if ((status = ptr->video_write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                         break;
                                 }
                         }
                 }
         }
 
         return status;
 }

switch_status_t switch_core_session_write_frame	(	_In_ switch_core_session_t *	session,
		switch_frame_t *	frame,
		switch_io_flag_t	flags,
		int	stream_id
	)

Write a frame to a session.

Parameters

session	the session to write to
frame	the frame to write
flags	I/O flags to modify behavior (i.e. non blocking)
stream_id	which logical media channel to use

Returns: SWITCH_STATUS_SUCCESS a the frame was written

Referenced by audio_bridge_thread(), switch_ivr_collect_digits_count(), switch_ivr_delay_echo(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), and unicast_thread_run().

switch_status_t switch_core_session_write_video_frame	(	_In_ switch_core_session_t *	session,
		switch_frame_t *	frame,
		switch_io_flag_t	flags,
		int	stream_id
	)

Write a video frame to a session.

Parameters

session	the session to write to
frame	a pointer to a frame to write
flags	I/O flags to modify behavior (i.e. non blocking)
stream_id	which logical media channel to use

Returns: SWITCH_STATUS_SUCCESS a if the frame was written

Referenced by audio_bridge_thread(), and eavesdrop_callback().

switch_bool_t switch_core_set_var_conditional	(	_In_z_ const char *	varname,
		_In_opt_z_ const char *	value,
		_In_opt_z_ const char *	val2
	)

Conditionally add a global variable to the core.

Parameters

varname	the name of the variable
value	the value of the variable
val2	the value of the variable to verify against \ If the global did not exist and val2=="", add global with value, return true \ If the global exists with the value of val2, replace it, return true \ If the global exists with a value other than val2, return false

Referenced by globalSetVariable().

void switch_core_set_variable	(	_In_z_ const char *	varname,
		_In_opt_z_ const char *	value
	)

Add a global variable to the core.

Parameters

varname	the name of the variable
value	the value of the variable \ If `value` is NULL, then `varname` is deleted.

Referenced by globalSetVariable(), preprocess(), preprocess_exec_set(), setGlobalVariable(), switch_nat_init(), and switch_rtp_init().

void switch_core_thread_session_end ( _In_ switch_core_session_t * session )

Signal a thread using a thread session to terminate.

Parameters

session the session to indicate to

Referenced by switch_ivr_play_file(), and switch_ivr_speak_text().

switch_digit_action_target_t switch_ivr_dmachine_get_target ( switch_ivr_dmachine_t * dmachine )

Definition at line 91 of file switch_ivr_async.c.

References switch_assert.

 {
         switch_assert(dmachine);
         return dmachine->target;
 }

void switch_ivr_dmachine_set_target	(	switch_ivr_dmachine_t *	dmachine,
		switch_digit_action_target_t	target
	)

Definition at line 97 of file switch_ivr_async.c.

References switch_assert.

Referenced by switch_core_session_set_dmachine().

 {
         switch_assert(dmachine);
         dmachine->target = target;
 }

switch_status_t switch_ivr_dmachine_set_terminators	(	switch_ivr_dmachine_t *	dmachine,
		const char *	terminators
	)

Definition at line 194 of file switch_ivr_async.c.

References SWITCH_CHANNEL_LOG, switch_core_strdup, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         if (!dmachine->realm) {
                 switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No realm selected.\n");
                 return SWITCH_STATUS_FALSE;
         }
 
 
         dmachine->realm->terminators = switch_core_strdup(dmachine->pool, terminators);
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Digit parser %s: Setting terminators for realm '%s' to '%s'\n",
                                           dmachine->name, dmachine->realm->name, terminators);
 
         return SWITCH_STATUS_SUCCESS;
 }

switch_status_t switch_thread_pool_launch_thread ( switch_thread_data_t ** tdp )

Definition at line 1793 of file switch_core_session.c.

References check_queue(), session_manager, switch_assert, switch_queue_push(), SWITCH_STATUS_SUCCESS, and switch_session_manager::thread_queue.

Referenced by switch_event_channel_broadcast(), switch_event_deliver_thread_pool(), switch_ivr_bg_media(), switch_sql_queue_manager_execute_sql_callback(), switch_sql_queue_manager_execute_sql_callback_err(), switch_sql_queue_manager_execute_sql_event_callback(), and switch_sql_queue_manager_execute_sql_event_callback_err().

 {
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         switch_thread_data_t *td;
 
         switch_assert(tdp);
 
         td = *tdp;
         *tdp = NULL;
 
         status = switch_queue_push(session_manager.thread_queue, td);
         check_queue();
 
         return status;  
 }

Macros

Enumerations

Functions

Detailed Description

Macro Definition Documentation

Enumeration Type Documentation

Function Documentation