Collaboration diagram for Channel Functions:

Macros
#define	switch_channel_ready(_channel) switch_channel_test_ready(_channel, SWITCH_TRUE, SWITCH_FALSE)

#define	switch_channel_media_ready(_channel) switch_channel_test_ready(_channel, SWITCH_TRUE, SWITCH_TRUE)

#define	switch_channel_media_up(_channel) (switch_channel_test_flag(_channel, CF_ANSWERED) \|\| switch_channel_test_flag(_channel, CF_EARLY_MEDIA))

#define	switch_channel_up(_channel) (switch_channel_check_signal(_channel, SWITCH_TRUE) \|\| switch_channel_get_state(_channel) < CS_HANGUP)

#define	switch_channel_down(_channel) (switch_channel_check_signal(_channel, SWITCH_TRUE) \|\| switch_channel_get_state(_channel) >= CS_HANGUP)

#define	switch_channel_up_nosig(_channel) (switch_channel_get_state(_channel) < CS_HANGUP)

#define	switch_channel_down_nosig(_channel) (switch_channel_get_state(_channel) >= CS_HANGUP)

#define	switch_channel_media_ack(_channel) (!switch_channel_test_cap(_channel, CC_MEDIA_ACK) \|\| switch_channel_test_flag(_channel, CF_MEDIA_ACK))

#define	switch_channel_text_only(_channel) (switch_channel_test_flag(_channel, CF_HAS_TEXT) && !switch_channel_test_flag(_channel, CF_AUDIO))

#define	switch_channel_set_running_state(channel, state) switch_channel_perform_set_running_state(channel, state, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_set_state(channel, state) switch_channel_perform_set_state(channel, __FILE__, __SWITCH_FUNC__, __LINE__, state)
	Set the current state of a channel. More...

#define	switch_channel_presence(_a, _b, _c, _d) switch_channel_perform_presence(_a, _b, _c, _d, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_set_variable_safe(_channel, _var, _val) switch_channel_set_variable_var_check(_channel, _var, _val, SWITCH_FALSE)

#define	switch_channel_set_variable(_channel, _var, _val) switch_channel_set_variable_var_check(_channel, _var, _val, SWITCH_TRUE)

#define	switch_channel_set_variable_strip_quotes(_channel, _var, _val) switch_channel_set_variable_strip_quotes_var_check(_channel, _var, _val, SWITCH_TRUE)

#define	switch_channel_set_variable_partner(_channel, _var, _val) switch_channel_set_variable_partner_var_check(_channel, _var, _val, SWITCH_TRUE)

#define	switch_channel_export_variable(_channel, _varname, _value, _ev) switch_channel_export_variable_var_check(_channel, _varname, _value, _ev, SWITCH_TRUE)

#define	switch_channel_get_variable(_c, _v) switch_channel_get_variable_dup(_c, _v, SWITCH_TRUE, -1)

#define	switch_channel_set_flag(_c, _f) switch_channel_set_flag_value(_c, _f, 1)

#define	switch_channel_set_cap(_c, _cc) switch_channel_set_cap_value(_c, _cc, 1)

#define	switch_channel_answer(channel) switch_channel_perform_answer(channel, __FILE__, __SWITCH_FUNC__, __LINE__)
	Answer a channel (initiate/acknowledge a successful connection) More...

#define	switch_channel_mark_answered(channel) switch_channel_perform_mark_answered(channel, __FILE__, __SWITCH_FUNC__, __LINE__)
	Mark a channel answered with no indication (for outbound calls) More...

#define	switch_channel_mark_pre_answered(channel) switch_channel_perform_mark_pre_answered(channel, __FILE__, __SWITCH_FUNC__, __LINE__)
	Mark a channel pre_answered (early media) with no indication (for outbound calls) More...

#define	switch_channel_acknowledge_call(channel) switch_channel_perform_acknowledge_call(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_ring_ready(channel) switch_channel_perform_ring_ready_value(channel, SWITCH_RING_READY_RINGING, __FILE__, __SWITCH_FUNC__, __LINE__)
	Send Ringing message to a channel. More...

#define	switch_channel_ring_ready_value(channel, _rv) switch_channel_perform_ring_ready_value(channel, _rv, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_pre_answer(channel) switch_channel_perform_pre_answer(channel, __FILE__, __SWITCH_FUNC__, __LINE__)
	Indicate progress on a channel to attempt early media. More...

#define	switch_channel_mark_ring_ready(channel) switch_channel_perform_mark_ring_ready_value(channel, SWITCH_RING_READY_RINGING, __FILE__, __SWITCH_FUNC__, __LINE__)
	Indicate a channel is ready to provide ringback. More...

#define	switch_channel_mark_ring_ready_value(channel, _rv) switch_channel_perform_mark_ring_ready_value(channel, _rv, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_hangup(channel, hangup_cause) switch_channel_perform_hangup(channel, __FILE__, __SWITCH_FUNC__, __LINE__, hangup_cause)
	Hangup a channel flagging it's state machine to end. More...

#define	switch_channel_expand_variables(_channel, _in) switch_channel_expand_variables_check(_channel, _in, NULL, NULL, 0)

#define	switch_channel_inbound_display(_channel) ((switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_INBOUND && !switch_channel_test_flag(_channel, CF_BLEG)) \|\| (switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && switch_channel_test_flag(_channel, CF_DIALPLAN)))

#define	switch_channel_outbound_display(_channel) ((switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_INBOUND && switch_channel_test_flag(_channel, CF_BLEG)) \|\| (switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_channel_test_flag(_channel, CF_DIALPLAN)))

#define	switch_channel_stop_broadcast(_channel) for(;;) {if (switch_channel_test_flag(_channel, CF_BROADCAST)) {switch_channel_set_flag(_channel, CF_STOP_BROADCAST); switch_channel_set_flag(_channel, CF_BREAK); } break;}

#define	switch_channel_audio_sync(_c) switch_channel_perform_audio_sync(_c, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_video_sync(_c) switch_channel_perform_video_sync(_c, __FILE__, __SWITCH_FUNC__, __LINE__)

#define	switch_channel_set_app_flag(_c, _f) switch_channel_set_app_flag_key(__FILE__, _c, _f)

#define	switch_channel_clear_app_flag(_c, _f) switch_channel_clear_app_flag_key(__FILE__, _c, _f)

#define	switch_channel_test_app_flag(_c, _f) switch_channel_test_app_flag_key(__FILE__, _c, _f)

#define	switch_channel_set_callstate(channel, state) switch_channel_perform_set_callstate(channel, state, __FILE__, __SWITCH_FUNC__, __LINE__)

Functions
switch_channel_state_t	switch_channel_get_state (switch_channel_t *channel)
	Get the current state of a channel in the state engine. More...

switch_channel_state_t	switch_channel_get_running_state (switch_channel_t *channel)

int	switch_channel_check_signal (switch_channel_t *channel, switch_bool_t in_thread_only)

int	switch_channel_test_ready (switch_channel_t *channel, switch_bool_t check_ready, switch_bool_t check_media)
	Determine if a channel is ready for io. More...

void	switch_channel_wait_for_state (switch_channel_t channel, switch_channel_t other_channel, switch_channel_state_t want_state)

void	switch_channel_wait_for_state_timeout (switch_channel_t *other_channel, switch_channel_state_t want_state, uint32_t timeout)

switch_status_t	switch_channel_wait_for_flag (switch_channel_t channel, switch_channel_flag_t want_flag, switch_bool_t pres, uint32_t to, switch_channel_t super_channel)

switch_status_t	switch_channel_wait_for_app_flag (switch_channel_t channel, uint32_t app_flag, const char key, switch_bool_t pres, uint32_t to)

switch_channel_state_t	switch_channel_perform_set_state (switch_channel_t channel, const char file, const char *func, int line, switch_channel_state_t state)

switch_channel_state_t	switch_channel_perform_set_running_state (switch_channel_t channel, switch_channel_state_t state, const char file, const char *func, int line)

switch_call_cause_t	switch_channel_str2cause (_In_ const char *str)
	return a cause code for a given string More...

switch_call_cause_t	switch_channel_get_cause (_In_ switch_channel_t *channel)
	return the cause code for a given channel More...

switch_call_cause_t	switch_channel_cause_q850 (switch_call_cause_t cause)

switch_call_cause_t	switch_channel_get_cause_q850 (switch_channel_t *channel)

switch_call_cause_t *	switch_channel_get_cause_ptr (switch_channel_t *channel)

const char *	switch_channel_cause2str (_In_ switch_call_cause_t cause)
	return a cause string for a given cause More...

switch_channel_timetable_t *	switch_channel_get_timetable (_In_ switch_channel_t *channel)
	View the timetable of a channel. More...

switch_status_t	switch_channel_alloc (_In_ switch_channel_t *channel, _In_ switch_call_direction_t direction, _In_ switch_memory_pool_t pool)
	Allocate a new channel. More...

switch_status_t	switch_channel_init (switch_channel_t channel, switch_core_session_t session, switch_channel_state_t state, switch_channel_flag_t flag)
	Connect a newly allocated channel to a session object and setup it's initial state. More...

void	switch_channel_set_presence_data_vals (switch_channel_t channel, const char presence_data_cols)
	Takes presence_data_cols as a parameter or as a channel variable and copies them to channel profile variables. More...

void	switch_channel_perform_presence (switch_channel_t channel, const char rpid, const char status, const char id, const char file, const char func, int line)
	Fire A presence event for the channel. More...

void	switch_channel_uninit (switch_channel_t *channel)
	Uninitalize a channel. More...

void	switch_channel_set_caller_profile (switch_channel_t channel, switch_caller_profile_t caller_profile)
	Set the given channel's caller profile. More...

void	switch_channel_step_caller_profile (switch_channel_t *channel)

switch_caller_profile_t *	switch_channel_get_caller_profile (switch_channel_t *channel)
	Retrieve the given channel's caller profile. More...

void	switch_channel_set_originator_caller_profile (switch_channel_t channel, switch_caller_profile_t caller_profile)
	Set the given channel's originator caller profile. More...

void	switch_channel_set_hunt_caller_profile (switch_channel_t channel, switch_caller_profile_t caller_profile)

switch_caller_profile_t *	switch_channel_get_originator_caller_profile (switch_channel_t *channel)
	Retrieve the given channel's originator caller profile. More...

void	switch_channel_set_originatee_caller_profile (switch_channel_t channel, switch_caller_profile_t caller_profile)
	Set the given channel's originatee caller profile. More...

switch_caller_profile_t *	switch_channel_get_originatee_caller_profile (switch_channel_t *channel)
	Retrieve the given channel's originatee caller profile. More...

void	switch_channel_set_origination_caller_profile (switch_channel_t channel, switch_caller_profile_t caller_profile)
	Set the given channel's origination caller profile. More...

switch_caller_profile_t *	switch_channel_get_origination_caller_profile (switch_channel_t *channel)
	Retrieve the given channel's origination caller profile. More...

char *	switch_channel_get_uuid (switch_channel_t *channel)
	Retrieve the given channel's unique id. More...

switch_status_t	switch_channel_set_profile_var (switch_channel_t channel, const char name, const char *val)
	Set a variable on a given channel. More...

switch_status_t	switch_channel_set_log_tag (switch_channel_t channel, const char tagname, const char *tagvalue)

switch_status_t	switch_channel_get_log_tags (switch_channel_t channel, switch_event_t *log_tags)

switch_status_t	switch_channel_set_variable_var_check (switch_channel_t channel, const char varname, const char *value, switch_bool_t var_check)

switch_status_t	switch_channel_set_variable_strip_quotes_var_check (switch_channel_t channel, const char varname, const char *value, switch_bool_t var_check)

switch_status_t	switch_channel_add_variable_var_check (switch_channel_t channel, const char varname, const char *value, switch_bool_t var_check, switch_stack_t stack)

switch_status_t	switch_channel_set_variable_printf (switch_channel_t channel, const char varname, const char *fmt,...)

switch_status_t	switch_channel_set_variable_name_printf (switch_channel_t channel, const char val, const char *fmt,...)

switch_status_t	switch_channel_set_variable_partner_var_check (switch_channel_t channel, const char varname, const char *value, switch_bool_t var_check)

const char *	switch_channel_get_variable_partner (switch_channel_t channel, const char varname)

const char *	switch_channel_get_hold_music (switch_channel_t *channel)

const char *	switch_channel_get_hold_music_partner (switch_channel_t *channel)

uint32_t	switch_channel_del_variable_prefix (switch_channel_t channel, const char prefix)

switch_status_t	switch_channel_transfer_variable_prefix (switch_channel_t orig_channel, switch_channel_t new_channel, const char *prefix)

switch_status_t	switch_channel_export_variable_var_check (switch_channel_t channel, const char varname, const char val, const char export_varname, switch_bool_t var_check)

void	switch_channel_process_export (switch_channel_t channel, switch_channel_t peer_channel, switch_event_t var_event, const char export_varname)

switch_status_t	switch_channel_export_variable_printf (switch_channel_t channel, const char varname, const char export_varname, const char fmt,...)

void	switch_channel_set_scope_variables (switch_channel_t channel, switch_event_t *event)

switch_status_t	switch_channel_get_scope_variables (switch_channel_t channel, switch_event_t *event)

const char *	switch_channel_get_variable_dup (switch_channel_t channel, const char varname, switch_bool_t dup, int idx)
	Retrieve a variable from a given channel. More...

const char *	switch_channel_get_variable_strdup (switch_channel_t channel, const char varname)
	Retrieve a copy of a variable from a given channel. switch_safe_free() call will be required. More...

switch_status_t	switch_channel_get_variable_buf (switch_channel_t channel, const char varname, char *buf, switch_size_t buflen)
	Retrieve a variable from a given channel to a pre-allocated buffer without using a memory pool. More...

switch_status_t	switch_channel_get_variables (switch_channel_t channel, switch_event_t *event)

switch_status_t	switch_channel_get_variables_prefix (switch_channel_t channel, const char prefix, switch_event_t **event)

switch_status_t	switch_channel_pass_callee_id (switch_channel_t channel, switch_channel_t other_channel)

static int	switch_channel_var_false (switch_channel_t channel, const char variable)

static int	switch_channel_var_true (switch_channel_t channel, const char variable)

switch_event_header_t *	switch_channel_variable_first (switch_channel_t *channel)
	Start iterating over the entries in the channel variable list. More...

void	switch_channel_variable_last (switch_channel_t *channel)
	Stop iterating over channel variables. More...

void	switch_channel_restart (switch_channel_t *channel)

switch_status_t	switch_channel_caller_extension_masquerade (switch_channel_t orig_channel, switch_channel_t new_channel, uint32_t offset)

void	switch_channel_set_caller_extension (switch_channel_t channel, switch_caller_extension_t caller_extension)
	Assign a caller extension to a given channel. More...

void	switch_channel_invert_cid (switch_channel_t *channel)

void	switch_channel_flip_cid (switch_channel_t *channel)

void	switch_channel_sort_cid (switch_channel_t *channel)

switch_caller_extension_t *	switch_channel_get_caller_extension (switch_channel_t *channel)
	Retrieve caller extension from a given channel. More...

uint32_t	switch_channel_test_flag (switch_channel_t *channel, switch_channel_flag_t flag)
	Test for presence of given flag on a given channel. More...

void	switch_channel_set_flag_value (switch_channel_t *channel, switch_channel_flag_t flag, uint32_t value)
	Set given flag(s) on a given channel. More...

void	switch_channel_set_flag_recursive (switch_channel_t *channel, switch_channel_flag_t flag)

void	switch_channel_set_cap_value (switch_channel_t *channel, switch_channel_cap_t cap, uint32_t value)

void	switch_channel_clear_cap (switch_channel_t *channel, switch_channel_cap_t cap)

uint32_t	switch_channel_test_cap (switch_channel_t *channel, switch_channel_cap_t cap)

uint32_t	switch_channel_test_cap_partner (switch_channel_t *channel, switch_channel_cap_t cap)

switch_bool_t	switch_channel_set_flag_partner (switch_channel_t *channel, switch_channel_flag_t flag)
	Set given flag(s) on a given channel's bridge partner. More...

switch_bool_t	switch_channel_clear_flag_partner (switch_channel_t *channel, switch_channel_flag_t flag)
	Clears given flag(s) on a given channel's bridge partner. More...

uint32_t	switch_channel_test_flag_partner (switch_channel_t *channel, switch_channel_flag_t flag)

void	switch_channel_set_state_flag (switch_channel_t *channel, switch_channel_flag_t flag)
	Set given flag(s) on a given channel to be applied on the next state change. More...

void	switch_channel_clear_state_flag (switch_channel_t *channel, switch_channel_flag_t flag)

void	switch_channel_clear_flag (switch_channel_t *channel, switch_channel_flag_t flag)
	Clear given flag(s) from a channel. More...

void	switch_channel_clear_flag_recursive (switch_channel_t *channel, switch_channel_flag_t flag)

switch_status_t	switch_channel_perform_answer (switch_channel_t channel, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_mark_answered (switch_channel_t channel, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_acknowledge_call (switch_channel_t channel, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_ring_ready_value (switch_channel_t channel, switch_ring_ready_t rv, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_pre_answer (switch_channel_t channel, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_mark_pre_answered (switch_channel_t channel, const char file, const char *func, int line)

switch_status_t	switch_channel_perform_mark_ring_ready_value (switch_channel_t channel, switch_ring_ready_t rv, const char file, const char *func, int line)

int	switch_channel_add_state_handler (switch_channel_t channel, const switch_state_handler_table_t state_handler)
	add a state handler table to a given channel More...

void	switch_channel_clear_state_handler (switch_channel_t channel, const switch_state_handler_table_t state_handler)
	clear a state handler table from a given channel More...

const switch_state_handler_table_t *	switch_channel_get_state_handler (switch_channel_t *channel, int index)
	Retrieve an state handler tablefrom a given channel at given index level. More...

switch_status_t	switch_channel_set_private (switch_channel_t channel, const char key, const void *private_info)
	Set private data on channel. More...

void *	switch_channel_get_private (switch_channel_t channel, const char key)
	Retrieve private from a given channel. More...

void *	switch_channel_get_private_partner (switch_channel_t channel, const char key)

switch_status_t	switch_channel_set_name (switch_channel_t channel, const char name)
	Assign a name to a given channel. More...

char *	switch_channel_get_name (switch_channel_t *channel)
	Retrieve the name of a given channel. More...

switch_channel_state_t	switch_channel_perform_hangup (switch_channel_t channel, const char file, const char *func, int line, switch_call_cause_t hangup_cause)

switch_size_t	switch_channel_has_dtmf (_In_ switch_channel_t *channel)
	Test for presence of DTMF on a given channel. More...

switch_status_t	switch_channel_dtmf_lock (switch_channel_t *channel)

switch_status_t	switch_channel_try_dtmf_lock (switch_channel_t *channel)

switch_status_t	switch_channel_dtmf_unlock (switch_channel_t *channel)

switch_status_t	switch_channel_queue_dtmf (_In_ switch_channel_t channel, _In_ const switch_dtmf_t dtmf)
	Queue DTMF on a given channel. More...

switch_status_t	switch_channel_queue_dtmf_string (_In_ switch_channel_t channel, _In_ const char dtmf_string)

switch_status_t	switch_channel_dequeue_dtmf (_In_ switch_channel_t channel, _In_ switch_dtmf_t dtmf)
	Retrieve DTMF digits from a given channel. More...

void	switch_channel_flush_dtmf (_In_ switch_channel_t *channel)

switch_size_t	switch_channel_dequeue_dtmf_string (_In_ switch_channel_t channel, _Out_opt_bytecapcount_(len) char dtmf_str, _In_ switch_size_t len)

const char *	switch_channel_state_name (_In_ switch_channel_state_t state)
	Render the name of the provided state enum. More...

switch_channel_state_t	switch_channel_name_state (_In_ const char *name)
	Render the enum of the provided state name. More...

void	switch_channel_event_set_data (_In_ switch_channel_t channel, _In_ switch_event_t event)
	Add information about a given channel to an event object. More...

void	switch_channel_event_set_basic_data (_In_ switch_channel_t channel, _In_ switch_event_t event)

void	switch_channel_event_set_extended_data (_In_ switch_channel_t channel, _In_ switch_event_t event)

char *	switch_channel_expand_variables_check (switch_channel_t channel, const char in, switch_event_t var_list, switch_event_t api_list, uint32_t recur)
	Expand varaibles in a string based on the variables in a paticular channel. More...

char *	switch_channel_build_param_string (_In_ switch_channel_t channel, _In_opt_ switch_caller_profile_t caller_profile, _In_opt_ const char *prefix)

switch_status_t	switch_channel_set_timestamps (_In_ switch_channel_t *channel)

void	switch_channel_perform_audio_sync (switch_channel_t channel, const char file, const char *func, int line)

void	switch_channel_perform_video_sync (switch_channel_t channel, const char file, const char *func, int line)

void	switch_channel_set_private_flag (switch_channel_t *channel, uint32_t flags)

void	switch_channel_clear_private_flag (switch_channel_t *channel, uint32_t flags)

int	switch_channel_test_private_flag (switch_channel_t *channel, uint32_t flags)

void	switch_channel_set_app_flag_key (const char app, switch_channel_t channel, uint32_t flags)

void	switch_channel_clear_app_flag_key (const char app, switch_channel_t channel, uint32_t flags)

int	switch_channel_test_app_flag_key (const char app, switch_channel_t channel, uint32_t flags)

void	switch_channel_set_bridge_time (switch_channel_t *channel)

void	switch_channel_set_hangup_time (switch_channel_t *channel)

switch_call_direction_t	switch_channel_direction (switch_channel_t *channel)

switch_call_direction_t	switch_channel_logical_direction (switch_channel_t *channel)

void	switch_channel_set_direction (switch_channel_t *channel, switch_call_direction_t direction)

switch_core_session_t *	switch_channel_get_session (switch_channel_t *channel)

char *	switch_channel_get_flag_string (switch_channel_t *channel)

char *	switch_channel_get_cap_string (switch_channel_t *channel)

int	switch_channel_state_change_pending (switch_channel_t *channel)

void	switch_channel_perform_set_callstate (switch_channel_t channel, switch_channel_callstate_t callstate, const char file, const char *func, int line)

switch_channel_callstate_t	switch_channel_get_callstate (switch_channel_t *channel)

const char *	switch_channel_callstate2str (switch_channel_callstate_t callstate)

switch_channel_callstate_t	switch_channel_str2callstate (const char *str)

void	switch_channel_mark_hold (switch_channel_t *channel, switch_bool_t on)

Detailed Description

The switch_channel object is a private entity that belongs to a session that contains the call specific information such as the call state, variables, caller profiles and DTMF queue

Macro Definition Documentation

◆ switch_channel_acknowledge_call

#define switch_channel_acknowledge_call ( channel ) switch_channel_perform_acknowledge_call(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 481 of file switch_channel.h.

◆ switch_channel_answer

#define switch_channel_answer ( channel ) switch_channel_perform_answer(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

Answer a channel (initiate/acknowledge a successful connection)

Parameters

channel channel to answer

Returns: SWITCH_STATUS_SUCCESS if channel was answered successfully

Definition at line 463 of file switch_channel.h.

Referenced by CoreSession::answer(), audio_bridge_thread(), check_channel_status(), fs_channel_answer(), switch_ivr_intercept_session(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_process_indications(), and SWITCH_STANDARD_APP().

◆ switch_channel_audio_sync

#define switch_channel_audio_sync ( _c ) switch_channel_perform_audio_sync(_c, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 667 of file switch_channel.h.

Referenced by check_channel_status(), switch_channel_perform_answer(), switch_channel_perform_pre_answer(), switch_core_media_receive_message(), switch_core_media_set_codec(), switch_core_standard_on_execute(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_parse_event(), switch_ivr_play_file(), switch_ivr_resume_detect_speech(), switch_ivr_session_transfer(), switch_ivr_sleep(), and switch_ivr_speak_text_handle().

◆ switch_channel_clear_app_flag

#define switch_channel_clear_app_flag	(	_c,
		_f
	)	switch_channel_clear_app_flag_key(__FILE__, _c, _f)

Definition at line 680 of file switch_channel.h.

◆ switch_channel_down

#define switch_channel_down ( _channel ) (switch_channel_check_signal(_channel, SWITCH_TRUE) || switch_channel_get_state(_channel) >= CS_HANGUP)

◆ switch_channel_down_nosig

#define switch_channel_down_nosig ( _channel ) (switch_channel_get_state(_channel) >= CS_HANGUP)

◆ switch_channel_expand_variables

#define switch_channel_expand_variables	(	_channel,
		_in
	)	switch_channel_expand_variables_check(_channel, _in, NULL, NULL, 0)

Definition at line 654 of file switch_channel.h.

Referenced by do_api_on(), exec_app(), play_and_collect(), record_helper_post_process(), switch_channel_execute_on_value(), switch_channel_get_hold_music(), switch_core_session_exec(), switch_core_standard_on_routing(), switch_ivr_phrase_macro_event(), and switch_ivr_record_file_event().

◆ switch_channel_export_variable

#define switch_channel_export_variable	(	_channel,
		_varname,
		_value,
		_ev
	)	switch_channel_export_variable_var_check(_channel, _varname, _value, _ev, SWITCH_TRUE)

Definition at line 312 of file switch_channel.h.

Referenced by switch_channel_export_variable_printf().

◆ switch_channel_get_variable

#define switch_channel_get_variable	(	_c,
		_v
	)	switch_channel_get_variable_dup(_c, _v, SWITCH_TRUE, -1)

Definition at line 326 of file switch_channel.h.

◆ switch_channel_hangup

#define switch_channel_hangup	(	channel,
		hangup_cause
	)	switch_channel_perform_hangup(channel, __FILE__, __SWITCH_FUNC__, __LINE__, hangup_cause)

Hangup a channel flagging it's state machine to end.

Parameters

channel	channel to hangup
hangup_cause	the appropriate hangup cause

Returns: the resulting channel state.

Definition at line 589 of file switch_channel.h.

Referenced by abort_call(), audio_bridge_on_exchange_media(), audio_bridge_thread(), check_channel_status(), check_per_channel_timeouts(), check_timeout(), cleanup_proxy_mode_a(), collect_thread_run(), CoreSession::destroy(), dtls_state_fail(), eavesdrop_callback(), enterprise_originate_thread(), fs_channel_hangup(), fs_switch_ivr_originate(), CoreSession::hangup(), monitor_callback(), read_bundle_rtp_packet(), read_rtp_packet(), record_callback(), recording_thread(), setup_ringback(), signal_bridge_on_hangup(), switch_channel_handle_cause(), switch_channel_perform_answer(), switch_channel_perform_pre_answer(), switch_channel_perform_ring_ready_value(), switch_core_media_activate_rtp(), switch_core_media_choose_ports(), switch_core_media_negotiate_sdp(), switch_core_media_process_t38_passthru(), switch_core_media_read_frame(), switch_core_media_set_codec(), switch_core_session_execute_application_get_flags(), switch_core_session_hupall(), switch_core_session_hupall_endpoint(), switch_core_session_hupall_matching_vars_ans(), switch_core_session_read_frame(), switch_core_session_run(), switch_core_session_write_frame(), switch_core_standard_on_execute(), switch_core_standard_on_routing(), switch_ivr_displace_session(), switch_ivr_intercept_session(), switch_ivr_kill_uuid(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_parse_event(), switch_ivr_process_indications(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_ivr_session_transfer(), switch_ivr_signal_bridge(), switch_ivr_wait_for_answer(), switch_rtp_add_dtls(), SWITCH_STANDARD_SCHED_FUNC(), text_bridge_thread(), and uuid_bridge_on_soft_execute().

◆ switch_channel_inbound_display

#define switch_channel_inbound_display ( _channel ) ((switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_INBOUND && !switch_channel_test_flag(_channel, CF_BLEG)) || (switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && switch_channel_test_flag(_channel, CF_DIALPLAN)))

Definition at line 656 of file switch_channel.h.

Referenced by switch_ivr_uuid_bridge().

◆ switch_channel_mark_answered

#define switch_channel_mark_answered ( channel ) switch_channel_perform_mark_answered(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

Mark a channel answered with no indication (for outbound calls)

Parameters

channel channel to mark answered

Returns: SWITCH_STATUS_SUCCESS if channel was answered successfully

Definition at line 470 of file switch_channel.h.

◆ switch_channel_mark_pre_answered

#define switch_channel_mark_pre_answered ( channel ) switch_channel_perform_mark_pre_answered(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

Mark a channel pre_answered (early media) with no indication (for outbound calls)

Parameters

channel channel to mark pre_answered

Returns: SWITCH_STATUS_SUCCESS if channel was pre_answered successfully

Definition at line 477 of file switch_channel.h.

◆ switch_channel_mark_ring_ready

#define switch_channel_mark_ring_ready ( channel ) switch_channel_perform_mark_ring_ready_value(channel, SWITCH_RING_READY_RINGING, __FILE__, __SWITCH_FUNC__, __LINE__)

Indicate a channel is ready to provide ringback.

Parameters

channel channel

Returns: SWITCH_STATUS_SUCCESS

Definition at line 516 of file switch_channel.h.

◆ switch_channel_mark_ring_ready_value

#define switch_channel_mark_ring_ready_value	(	channel,
		_rv
	)	switch_channel_perform_mark_ring_ready_value(channel, _rv, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 519 of file switch_channel.h.

◆ switch_channel_media_ack

#define switch_channel_media_ack ( _channel ) (!switch_channel_test_cap(_channel, CC_MEDIA_ACK) || switch_channel_test_flag(_channel, CF_MEDIA_ACK))

Definition at line 94 of file switch_channel.h.

Referenced by audio_bridge_thread(), and switch_ivr_eavesdrop_session().

◆ switch_channel_media_ready

#define switch_channel_media_ready ( _channel ) switch_channel_test_ready(_channel, SWITCH_TRUE, SWITCH_TRUE)

◆ switch_channel_media_up

#define switch_channel_media_up ( _channel ) (switch_channel_test_flag(_channel, CF_ANSWERED) || switch_channel_test_flag(_channel, CF_EARLY_MEDIA))

Definition at line 86 of file switch_channel.h.

Referenced by _switch_core_session_request_video_refresh(), audio_bridge_thread(), switch_channel_perform_audio_sync(), switch_channel_perform_video_sync(), switch_core_media_check_dtls(), switch_core_media_set_smode(), switch_core_session_execute_application_get_flags(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_inband_dtmf_generate_session(), switch_ivr_originate(), switch_ivr_parse_all_events(), switch_ivr_record_session_event(), switch_ivr_uuid_bridge(), text_bridge_thread(), and video_helper_thread().

◆ switch_channel_outbound_display

#define switch_channel_outbound_display ( _channel ) ((switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_INBOUND && switch_channel_test_flag(_channel, CF_BLEG)) || (switch_channel_direction(_channel) == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_channel_test_flag(_channel, CF_DIALPLAN)))

Definition at line 658 of file switch_channel.h.

Referenced by switch_ivr_uuid_bridge().

◆ switch_channel_pre_answer

#define switch_channel_pre_answer ( channel ) switch_channel_perform_pre_answer(channel, __FILE__, __SWITCH_FUNC__, __LINE__)

Indicate progress on a channel to attempt early media.

Parameters

channel channel to pre-answer

Returns: SWITCH_STATUS_SUCCESS

Definition at line 509 of file switch_channel.h.

Referenced by audio_bridge_thread(), bridge(), fs_channel_pre_answer(), CoreSession::preAnswer(), setup_ringback(), switch_core_media_bug_add(), switch_core_session_execute_application_get_flags(), switch_core_session_send_dtmf_string(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_gentones(), switch_ivr_inband_dtmf_generate_session(), switch_ivr_inband_dtmf_session(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_phrase_macro_event(), switch_ivr_play_file(), switch_ivr_process_indications(), switch_ivr_read(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_ivr_session_audio(), switch_ivr_session_echo(), switch_ivr_speak_text(), switch_ivr_speak_text_handle(), and switch_ivr_tone_detect_session().

◆ switch_channel_presence

#define switch_channel_presence	(	_a,
		_b,
		_c,
		_d
	)	switch_channel_perform_presence(_a, _b, _c, _d, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 190 of file switch_channel.h.

Referenced by check_presence(), switch_channel_perform_mark_answered(), switch_core_media_toggle_hold(), and switch_core_session_exec().

◆ switch_channel_ready

#define switch_channel_ready ( _channel ) switch_channel_test_ready(_channel, SWITCH_TRUE, SWITCH_FALSE)

Definition at line 84 of file switch_channel.h.

Referenced by audio_bridge_thread(), bridge(), check_channel_status(), collect_thread_run(), enterprise_originate_ringback_thread(), CoreSession::ready(), setup_ringback(), signal_bridge_on_hibernate(), switch_channel_wait_for_flag(), switch_core_media_check_dtls(), switch_core_media_write_frame(), switch_core_session_execute_exten(), switch_core_session_wait_for_video_input_params(), switch_core_session_write_frame(), switch_core_standard_on_execute(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_delay_echo(), switch_ivr_detect_audio(), switch_ivr_detect_silence(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_gentones(), switch_ivr_insert_file(), switch_ivr_menu_execute(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_parse_event(), switch_ivr_play_and_collect_input(), switch_ivr_play_and_detect_speech(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_record_session_event(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), switch_play_and_get_digits(), SWITCH_STANDARD_APP(), and uuid_bridge_on_soft_execute().

◆ switch_channel_ring_ready

#define switch_channel_ring_ready ( channel ) switch_channel_perform_ring_ready_value(channel, SWITCH_RING_READY_RINGING, __FILE__, __SWITCH_FUNC__, __LINE__)

Send Ringing message to a channel.

Parameters

channel channel to ring

Returns: SWITCH_STATUS_SUCCESS if successful

Definition at line 491 of file switch_channel.h.

Referenced by check_channel_status(), and switch_ivr_process_indications().

◆ switch_channel_ring_ready_value

#define switch_channel_ring_ready_value	(	channel,
		_rv
	)	switch_channel_perform_ring_ready_value(channel, _rv, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 492 of file switch_channel.h.

Referenced by check_channel_status().

◆ switch_channel_set_app_flag

#define switch_channel_set_app_flag	(	_c,
		_f
	)	switch_channel_set_app_flag_key(__FILE__, _c, _f)

Definition at line 679 of file switch_channel.h.

◆ switch_channel_set_callstate

#define switch_channel_set_callstate	(	channel,
		state
	)	switch_channel_perform_set_callstate(channel, state, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 696 of file switch_channel.h.

Referenced by switch_channel_clear_flag(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_channel_perform_set_running_state(), switch_channel_set_flag_value(), switch_core_session_destroy_state(), switch_core_session_hangup_state(), and switch_core_session_read_frame().

◆ switch_channel_set_cap

#define switch_channel_set_cap	(	_c,
		_cc
	)	switch_channel_set_cap_value(_c, _cc, 1)

Definition at line 413 of file switch_channel.h.

◆ switch_channel_set_flag

#define switch_channel_set_flag	(	_c,
		_f
	)	switch_channel_set_flag_value(_c, _f, 1)

Definition at line 408 of file switch_channel.h.

◆ switch_channel_set_running_state

#define switch_channel_set_running_state	(	channel,
		state
	)	switch_channel_perform_set_running_state(channel, state, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 113 of file switch_channel.h.

Referenced by switch_core_session_destroy_state(), and switch_core_session_run().

◆ switch_channel_set_state

#define switch_channel_set_state	(	channel,
		state
	)	switch_channel_perform_set_state(channel, __FILE__, __SWITCH_FUNC__, __LINE__, state)

Set the current state of a channel.

Parameters

channel	channel to set state of
state	new state

Returns: current state of channel after application of new state

Definition at line 121 of file switch_channel.h.

Referenced by audio_bridge_on_exchange_media(), audio_bridge_on_routing(), audio_bridge_thread(), CoreSession::CoreSession(), fs_channel_set_state(), CoreSession::originate(), originate_on_routing(), recover_callback(), sb_on_dtmf(), signal_bridge_on_hangup(), switch_channel_restart(), switch_channel_transfer_to_extension(), switch_core_session_run(), switch_core_standard_on_execute(), switch_core_standard_on_init(), switch_core_standard_on_routing(), switch_ivr_3p_nomedia(), switch_ivr_intercept_session(), switch_ivr_multi_threaded_bridge(), switch_ivr_nomedia(), switch_ivr_park_session(), switch_ivr_session_transfer(), switch_ivr_signal_bridge(), switch_ivr_uuid_bridge(), switch_ivr_wait_for_answer(), uuid_bridge_on_hibernate(), uuid_bridge_on_reset(), and uuid_bridge_on_soft_execute().

◆ switch_channel_set_variable

#define switch_channel_set_variable	(	_channel,
		_var,
		_val
	)	switch_channel_set_variable_var_check(_channel, _var, _val, SWITCH_TRUE)

Definition at line 299 of file switch_channel.h.

◆ switch_channel_set_variable_partner

#define switch_channel_set_variable_partner	(	_channel,
		_var,
		_val
	)	switch_channel_set_variable_partner_var_check(_channel, _var, _val, SWITCH_TRUE)

Definition at line 301 of file switch_channel.h.

Referenced by switch_channel_perform_hangup(), and switch_ivr_intercept_session().

◆ switch_channel_set_variable_safe

#define switch_channel_set_variable_safe	(	_channel,
		_var,
		_val
	)	switch_channel_set_variable_var_check(_channel, _var, _val, SWITCH_FALSE)

Definition at line 298 of file switch_channel.h.

◆ switch_channel_set_variable_strip_quotes

#define switch_channel_set_variable_strip_quotes	(	_channel,
		_var,
		_val
	)	switch_channel_set_variable_strip_quotes_var_check(_channel, _var, _val, SWITCH_TRUE)

Definition at line 300 of file switch_channel.h.

◆ switch_channel_stop_broadcast

#define switch_channel_stop_broadcast ( _channel ) for(;;) {if (switch_channel_test_flag(_channel, CF_BROADCAST)) {switch_channel_set_flag(_channel, CF_STOP_BROADCAST); switch_channel_set_flag(_channel, CF_BREAK); } break;}

Definition at line 664 of file switch_channel.h.

Referenced by audio_bridge_thread(), switch_core_media_toggle_hold(), switch_core_session_hangup_state(), switch_ivr_multi_threaded_bridge(), switch_ivr_parse_event(), switch_ivr_soft_hold(), switch_ivr_unhold(), and switch_ivr_uuid_bridge().

◆ switch_channel_test_app_flag

#define switch_channel_test_app_flag	(	_c,
		_f
	)	switch_channel_test_app_flag_key(__FILE__, _c, _f)

Definition at line 681 of file switch_channel.h.

◆ switch_channel_text_only

#define switch_channel_text_only ( _channel ) (switch_channel_test_flag(_channel, CF_HAS_TEXT) && !switch_channel_test_flag(_channel, CF_AUDIO))

Definition at line 96 of file switch_channel.h.

Referenced by switch_core_session_execute_application_get_flags().

◆ switch_channel_up

#define switch_channel_up ( _channel ) (switch_channel_check_signal(_channel, SWITCH_TRUE) || switch_channel_get_state(_channel) < CS_HANGUP)

Definition at line 88 of file switch_channel.h.

Referenced by audio_bridge_thread(), CoreSession::bridged(), check_channel_status(), CoreSession::destroy(), early_thread_run(), switch_core_media_activate_rtp(), switch_core_standard_on_reset(), switch_ivr_eavesdrop_session(), and switch_ivr_originate().

◆ switch_channel_up_nosig

#define switch_channel_up_nosig ( _channel ) (switch_channel_get_state(_channel) < CS_HANGUP)

Definition at line 91 of file switch_channel.h.

Referenced by audio_bridge_thread(), audio_write_thread(), check_per_channel_timeouts(), collect_thread_run(), early_thread_run(), signal_bridge_on_hangup(), speech_thread(), switch_channel_clear_flag(), switch_channel_handle_cause(), switch_channel_perform_presence(), switch_channel_set_flag_value(), switch_core_media_read_frame(), switch_core_media_read_lock_unlock(), switch_core_session_event_send(), switch_core_session_findall_matching_var(), switch_core_session_hupall_matching_vars_ans(), switch_core_session_message_send(), switch_core_session_perform_receive_message(), switch_core_session_receive_event(), switch_core_session_write_frame(), switch_ivr_eavesdrop_session(), switch_ivr_originate(), switch_ivr_signal_bridge(), switch_ivr_wait_for_answer(), text_bridge_thread(), text_helper_thread(), video_helper_thread(), and video_write_thread().

◆ switch_channel_video_sync

#define switch_channel_video_sync ( _c ) switch_channel_perform_video_sync(_c, __FILE__, __SWITCH_FUNC__, __LINE__)

Definition at line 669 of file switch_channel.h.

Referenced by switch_core_media_set_video_file(), and switch_core_standard_on_execute().

Function Documentation

◆ switch_channel_add_state_handler()

int switch_channel_add_state_handler	(	switch_channel_t *	channel,
		const switch_state_handler_table_t *	state_handler
	)

add a state handler table to a given channel

Parameters

channel	channel on which to add the state handler table
state_handler	table of state handler functions

Returns: the index number/priority of the table negative value indicates failure

Definition at line 3043 of file switch_channel.c.

References index, state_handler_index, state_handlers, state_mutex, switch_assert, SWITCH_MAX_STATE_HANDLERS, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_signal_bridge(), and switch_ivr_uuid_bridge().

 {
         int x, index;
 
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->state_mutex);
         for (x = 0; x < SWITCH_MAX_STATE_HANDLERS; x++) {
                 if (channel->state_handlers[x] == state_handler) {
                         index = x;
                         goto end;
                 }
         }
         index = channel->state_handler_index++;
 
         if (channel->state_handler_index >= SWITCH_MAX_STATE_HANDLERS) {
                 index = -1;
                 goto end;
         }
 
         channel->state_handlers[index] = state_handler;
 
   end:
         switch_mutex_unlock(channel->state_mutex);
         return index;
 }

◆ switch_channel_add_variable_var_check()

switch_status_t switch_channel_add_variable_var_check	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	value,
		switch_bool_t	var_check,
		switch_stack_t	stack
	)

Definition at line 1562 of file switch_channel.c.

References profile_mutex, switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, switch_event_add_header_string(), switch_event_base_add_header(), switch_event_del_header, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_string_var_check_const(), variables, and zstr.

Referenced by switch_ivr_originate(), switch_ivr_session_transfer(), switch_ivr_uuid_bridge(), and switch_regex_set_var_callback().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables && !zstr(varname)) {
                 if (zstr(value)) {
                         switch_event_del_header(channel->variables, varname);
                 } else {
                         int ok = 1;
 
                         if (var_check) {
                                 ok = !switch_string_var_check_const(value);
                         }
                         if (ok) {
                                 switch_event_add_header_string(channel->variables, stack, varname, value);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
                         }
                 }
                 status = SWITCH_STATUS_SUCCESS;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_alloc()

switch_status_t switch_channel_alloc	(	_In_ switch_channel_t **	channel,
		_In_ switch_call_direction_t	direction,
		_In_ switch_memory_pool_t *	pool
	)

Allocate a new channel.

Parameters

channel	NULL pointer to allocate channel to
pool	memory_pool to use for allocation

Returns: SWITCH_STATUS_SUCCESS if successful

Referenced by switch_core_session_request_uuid().

◆ switch_channel_build_param_string()

char* switch_channel_build_param_string	(	_In_ switch_channel_t *	channel,
		_In_opt_ switch_caller_profile_t *	caller_profile,
		_In_opt_ const char *	prefix
	)

◆ switch_channel_caller_extension_masquerade()

switch_status_t switch_channel_caller_extension_masquerade	(	switch_channel_t *	orig_channel,
		switch_channel_t *	new_channel,
		uint32_t	offset
	)

Definition at line 3139 of file switch_channel.c.

References switch_caller_application::application_data, switch_caller_application::application_name, caller_profile, switch_caller_profile::destination_number, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_caller_application::next, switch_caller_profile::pool, profile_mutex, session, switch_assert, switch_caller_extension_add_application(), switch_caller_extension_new(), switch_caller_profile_clone(), switch_channel_get_caller_extension(), switch_channel_get_variable, switch_channel_set_caller_extension(), switch_channel_set_caller_profile(), switch_channel_set_variable, switch_core_session_strdup, switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_event_header::value, and variables.

Referenced by switch_channel_var_true(), and switch_ivr_originate().

 {
         switch_caller_profile_t *caller_profile;
         switch_caller_extension_t *extension = NULL, *orig_extension = NULL;
         switch_caller_application_t *ap;
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_event_header_t *hi = NULL;
         const char *no_copy = switch_channel_get_variable(orig_channel, "attended_transfer_no_copy");
         char *dup;
         int i, argc = 0;
         char *argv[128];
 
         if (no_copy) {
                 dup = switch_core_session_strdup(new_channel->session, no_copy);
                 argc = switch_separate_string(dup, ',', argv, (sizeof(argv) / sizeof(argv[0])));
         }
 
 
         switch_mutex_lock(orig_channel->profile_mutex);
         switch_mutex_lock(new_channel->profile_mutex);
 
 
         caller_profile = switch_caller_profile_clone(new_channel->session, new_channel->caller_profile);
         switch_assert(caller_profile);
         extension = switch_caller_extension_new(new_channel->session, caller_profile->destination_number, caller_profile->destination_number);
         orig_extension = switch_channel_get_caller_extension(orig_channel);
 
 
         if (extension && orig_extension) {
                 for (ap = orig_extension->current_application; ap && offset > 0; offset--) {
                         ap = ap->next;
                 }
 
                 for (; ap; ap = ap->next) {
                         switch_caller_extension_add_application(new_channel->session, extension, ap->application_name, ap->application_data);
                 }
 
                 caller_profile->destination_number = switch_core_strdup(caller_profile->pool, orig_channel->caller_profile->destination_number);
                 switch_channel_set_caller_profile(new_channel, caller_profile);
                 switch_channel_set_caller_extension(new_channel, extension);
 
                 for (hi = orig_channel->variables->headers; hi; hi = hi->next) {
                         int ok = 1;
                         for (i = 0; i < argc; i++) {
                                 if (!strcasecmp(argv[i], hi->name)) {
                                         ok = 0;
                                         break;
                                 }
                         }
 
                         if (!ok)
                                 continue;
 
                         switch_channel_set_variable(new_channel, hi->name, hi->value);
                 }
 
                 status = SWITCH_STATUS_SUCCESS;
         }
 
 
         switch_mutex_unlock(new_channel->profile_mutex);
         switch_mutex_unlock(orig_channel->profile_mutex);
 
 
         return status;
 }

◆ switch_channel_callstate2str()

const char* switch_channel_callstate2str ( switch_channel_callstate_t callstate )

Definition at line 315 of file switch_channel.c.

References CALLSTATE_CHART, and switch_callstate_table::name.

Referenced by switch_channel_check_device_state(), switch_channel_event_set_basic_data(), and switch_channel_perform_set_callstate().

 {
         uint8_t x;
         const char *str = "UNKNOWN";
 
         for (x = 0; x < (sizeof(CALLSTATE_CHART) / sizeof(struct switch_cause_table)) - 1; x++) {
                 if (CALLSTATE_CHART[x].callstate == callstate) {
                         str = CALLSTATE_CHART[x].name;
                         break;
                 }
         }
 
         return str;
 }

◆ switch_channel_cause2str()

const char* switch_channel_cause2str ( _In_ switch_call_cause_t cause )

return a cause string for a given cause

Parameters

cause the code to check

Returns: the string

Referenced by CoreSession::hangupCause(), switch_core_session_hangup_state(), switch_core_session_outgoing_channel(), switch_core_session_reporting_state(), switch_core_standard_on_hangup(), switch_core_standard_on_reporting(), switch_ivr_enterprise_orig_and_bridge(), switch_ivr_enterprise_originate(), switch_ivr_multi_threaded_bridge(), switch_ivr_orig_and_bridge(), and switch_ivr_originate().

◆ switch_channel_cause_q850()

switch_call_cause_t switch_channel_cause_q850 ( switch_call_cause_t cause )

Definition at line 405 of file switch_channel.c.

References switch_cause_table::cause, SWITCH_CAUSE_INTERWORKING, and SWITCH_CAUSE_NORMAL_CLEARING.

Referenced by switch_channel_get_cause_q850().

 {
         if (cause <= SWITCH_CAUSE_INTERWORKING) {
                 return cause;
         } else {
                 return SWITCH_CAUSE_NORMAL_CLEARING;
         }
 }

◆ switch_channel_check_signal()

int switch_channel_check_signal	(	switch_channel_t *	channel,
		switch_bool_t	in_thread_only
	)

Definition at line 2264 of file switch_channel.c.

References session, SWITCH_FALSE, and switch_ivr_parse_signal_data().

Referenced by switch_channel_test_ready(), and switch_channel_wait_for_state_timeout().

 {
         switch_ivr_parse_signal_data(channel->session, SWITCH_FALSE, in_thread_only);
         return 0;
 }

◆ switch_channel_clear_app_flag_key()

void switch_channel_clear_app_flag_key	(	const char *	app,
		switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2094 of file switch_channel.c.

References app_flag_hash, flag_mutex, switch_assert, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_media_negotiate_sdp(), switch_core_media_reset_t38(), and switch_ivr_eavesdrop_update_display().

 {
         uint32_t *flagp = NULL;
 
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->flag_mutex);
         if (channel->app_flag_hash && (flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
                 if (!flags) {
                         *flagp = 0;
                 } else {
                         *flagp &= ~flags;
                 }
         }
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_clear_cap()

void switch_channel_clear_cap	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

Definition at line 1864 of file switch_channel.c.

References caps, flag_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         channel->caps[cap] = 0;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_clear_flag()

void switch_channel_clear_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Clear given flag(s) from a channel.

Parameters

channel	channel to clear flags from
flag	flag to clear

Definition at line 2145 of file switch_channel.c.

References caller_profile, CCS_ACTIVE, CCS_UNHELD, CF_ANSWERED, CF_BRIDGED, CF_DIALPLAN, CF_LEG_HOLDING, CF_NO_RECOVER, CF_ORIGINATOR, CF_OUTBOUND, CF_PROXY_MODE, CF_RECOVERED, CF_RECOVERING, CF_VIDEO, CF_VIDEO_PASSIVE, CF_VIDEO_READY, device_node, device_uuid_node_s::direction, direction, flag_mutex, flags, hangup_cause, switch_channel_timetable::hold_accum, hold_record, switch_channel_timetable::last_hold, logical_direction, switch_hold_record_s::off, profile_mutex, session, switch_assert, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_set_callstate, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_up_nosig, switch_core_recovery_track(), switch_core_session_wake_video_thread(), switch_mutex_lock(), switch_mutex_unlock(), switch_time_now(), and switch_caller_profile::times.

 {
         int ACTIVE = 0;
         int CLEAR = 0;
 
         switch_assert(channel != NULL);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         if (flag == CF_LEG_HOLDING && channel->flags[flag] && channel->flags[CF_ANSWERED]) {
                 ACTIVE = 1;
         }
 
         if (flag == CF_VIDEO_PASSIVE && channel->flags[CF_VIDEO]) {
                 channel->flags[CF_VIDEO_READY] = 1;
 
                 if (channel->flags[flag]) {
                         CLEAR = 1;
                 }
         }
 
         channel->flags[flag] = 0;
         switch_mutex_unlock(channel->flag_mutex);
 
         if (flag == CF_DIALPLAN) {
                 if (channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
                         channel->logical_direction = SWITCH_CALL_DIRECTION_OUTBOUND;
                         if (channel->device_node) {
                                 channel->device_node->direction = SWITCH_CALL_DIRECTION_INBOUND;
                         }
                 }
         }
 
         if (ACTIVE) {
                 switch_channel_set_callstate(channel, CCS_UNHELD);
                 switch_mutex_lock(channel->profile_mutex);
                 if (channel->caller_profile->times->last_hold) {
                         channel->caller_profile->times->hold_accum += (switch_time_now() - channel->caller_profile->times->last_hold);
                 }
 
                 if (channel->hold_record) {
                         channel->hold_record->off = switch_time_now();
                 }
 
                 if (switch_channel_test_flag(channel, CF_PROXY_MODE) && switch_channel_test_flag(channel, CF_BRIDGED)) {
                         switch_channel_set_callstate(channel, CCS_ACTIVE);
                 }
 
                 switch_mutex_unlock(channel->profile_mutex);
         }
 
         if (flag == CF_ORIGINATOR && switch_channel_test_flag(channel, CF_ANSWERED) && switch_channel_up_nosig(channel)) {
                 switch_channel_set_callstate(channel, CCS_ACTIVE);
         }
 
         if (flag == CF_OUTBOUND) {
                 switch_channel_set_variable(channel, "is_outbound", NULL);
         }
 
         if (flag == CF_RECOVERED) {
                 switch_channel_set_variable(channel, "recovered", NULL);
         }
 
         if (flag == CF_VIDEO_PASSIVE && CLEAR) {
                 switch_core_session_wake_video_thread(channel->session);
         }
 
         if (flag == CF_RECOVERING && !channel->hangup_cause && !switch_channel_test_flag(channel, CF_NO_RECOVER)) {
                 switch_core_recovery_track(channel->session);
         }
 
 }

◆ switch_channel_clear_flag_partner()

switch_bool_t switch_channel_clear_flag_partner	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Clears given flag(s) on a given channel's bridge partner.

Parameters

channel	channel to derive the partner channel to clear flag(s) from
flag	the flag to clear

Returns: true if the flag was cleared

Definition at line 1726 of file switch_channel.c.

References switch_assert, switch_channel_clear_flag(), switch_channel_get_partner_uuid(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_FALSE, and SWITCH_TRUE.

 {
         const char *uuid;
 
         switch_assert(channel != NULL);
 
         if ((uuid = switch_channel_get_partner_uuid(channel))) {
                 switch_core_session_t *session;
                 if ((session = switch_core_session_locate(uuid))) {
                         switch_channel_clear_flag(switch_core_session_get_channel(session), flag);
                         switch_core_session_rwunlock(session);
                         return SWITCH_TRUE;
                 }
         }
 
         return SWITCH_FALSE;
 }

◆ switch_channel_clear_flag_recursive()

void switch_channel_clear_flag_recursive	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 2219 of file switch_channel.c.

References CF_OUTBOUND, flag_mutex, flags, switch_assert, switch_channel_set_variable, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by eavesdrop_callback(), hanguphook(), signal_bridge_on_hangup(), switch_core_media_bug_close(), switch_core_media_set_video_file(), switch_ivr_multi_threaded_bridge(), switch_ivr_parse_event(), switch_ivr_record_file_event(), switch_ivr_session_echo(), switch_jb_get_packet(), and text_bridge_thread().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         if (channel->flags[flag]) {
                 channel->flags[flag]--;
         }
         switch_mutex_unlock(channel->flag_mutex);
 
         if (flag == CF_OUTBOUND) {
                 switch_channel_set_variable(channel, "is_outbound", NULL);
         }
 }

◆ switch_channel_clear_private_flag()

void switch_channel_clear_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2056 of file switch_channel.c.

References flag_mutex, private_flags, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->flag_mutex);
         channel->private_flags &= ~flags;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_clear_state_flag()

void switch_channel_clear_state_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 2136 of file switch_channel.c.

References flag_mutex, state_flags, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_ivr_uuid_bridge().

 {
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->flag_mutex);
         channel->state_flags[flag] = 0;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_clear_state_handler()

void switch_channel_clear_state_handler	(	switch_channel_t *	channel,
		const switch_state_handler_table_t *	state_handler
	)

clear a state handler table from a given channel

Parameters

channel	channel from which to clear the state handler table
state_handler	table of state handler functions

Definition at line 3086 of file switch_channel.c.

References index, SSH_FLAG_STICKY, state_handler_index, state_handlers, state_mutex, switch_assert, SWITCH_MAX_STATE_HANDLERS, switch_mutex_lock(), switch_mutex_unlock(), and switch_test_flag.

Referenced by audio_bridge_on_exchange_media(), originate_on_consume_media_transmit(), switch_ivr_3p_media(), switch_ivr_media(), switch_ivr_session_transfer(), switch_ivr_signal_bridge(), switch_ivr_uuid_bridge(), and uuid_bridge_on_soft_execute().

 {
         int index, i = channel->state_handler_index;
         const switch_state_handler_table_t *new_handlers[SWITCH_MAX_STATE_HANDLERS] = { 0 };
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->state_mutex);
         channel->state_handler_index = 0;
 
         if (state_handler) {
                 for (index = 0; index < i; index++) {
                         if (channel->state_handlers[index] != state_handler) {
                                 new_handlers[channel->state_handler_index++] = channel->state_handlers[index];
                         }
                 }
         } else {
                 for (index = 0; index < i; index++) {
                         if (channel->state_handlers[index] && switch_test_flag(channel->state_handlers[index], SSH_FLAG_STICKY)) {
                                 new_handlers[channel->state_handler_index++] = channel->state_handlers[index];
                         }
                 }
         }
 
         for (index = 0; index < SWITCH_MAX_STATE_HANDLERS; index++) {
                 channel->state_handlers[index] = NULL;
         }
 
         if (channel->state_handler_index > 0) {
                 for (index = 0; index < channel->state_handler_index; index++) {
                         channel->state_handlers[index] = new_handlers[index];
                 }
         }
 
         switch_mutex_unlock(channel->state_mutex);
 }

◆ switch_channel_del_variable_prefix()

uint32_t switch_channel_del_variable_prefix	(	switch_channel_t *	channel,
		const char *	prefix
	)

Definition at line 1383 of file switch_channel.c.

References switch_event::headers, switch_event_header::name, switch_event_header::next, switch_channel_get_variables(), switch_channel_set_variable, switch_event_destroy(), and zstr.

 {
         switch_event_t *event;
         switch_event_header_t *hp;
         uint32_t r = 0;
 
         switch_channel_get_variables(channel, &event);
 
         if (event) {
                 for (hp = event->headers; hp; hp = hp->next) {
                         if (zstr(prefix) || !strncasecmp(hp->name, prefix, strlen(prefix))) {
                                 switch_channel_set_variable(channel, hp->name, NULL);
                         }
                 }
         }
 
         switch_event_destroy(&event);
 
         return r;
 }

◆ switch_channel_dequeue_dtmf()

switch_status_t switch_channel_dequeue_dtmf	(	_In_ switch_channel_t *	channel,
		_In_ switch_dtmf_t *	dtmf
	)

Retrieve DTMF digits from a given channel.

Parameters

channel	channel to retrieve digits from
dtmf	digit

Returns: number of bytes read into the buffer

Referenced by audio_bridge_thread(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

◆ switch_channel_dequeue_dtmf_string()

switch_size_t switch_channel_dequeue_dtmf_string	(	_In_ switch_channel_t *	channel,
		_Out_opt_bytecapcount_(len) char *	dtmf_str,
		_In_ switch_size_t	len
	)

◆ switch_channel_direction()

switch_call_direction_t switch_channel_direction ( switch_channel_t * channel )

Definition at line 440 of file switch_channel.c.

References direction.

Referenced by audio_bridge_thread(), bridge(), generate_m(), switch_channel_alloc(), switch_channel_event_set_basic_data(), switch_channel_perform_answer(), switch_channel_perform_pre_answer(), switch_channel_perform_ring_ready_value(), switch_channel_perform_set_running_state(), switch_channel_set_direction(), switch_channel_sort_cid(), switch_core_media_activate_rtp(), switch_core_media_check_video_codecs(), switch_core_media_gen_local_sdp(), switch_core_media_get_codec_string(), switch_core_media_negotiate_sdp(), switch_core_media_set_r_sdp_codec_string(), switch_core_media_set_rmode(), switch_core_session_execute_application_get_flags(), switch_core_session_parse_crypto_prefs(), switch_core_session_run(), switch_core_standard_on_routing(), switch_ice_direction(), switch_ivr_generate_json_cdr(), switch_ivr_generate_xml_cdr(), switch_ivr_uuid_bridge(), and switch_rtp_add_crypto_key().

 {
         return channel->direction;
 }

◆ switch_channel_dtmf_lock()

switch_status_t switch_channel_dtmf_lock ( switch_channel_t * channel )

Definition at line 477 of file switch_channel.c.

References dtmf_mutex, and switch_mutex_lock().

Referenced by switch_core_session_read_frame().

 {
         return switch_mutex_lock(channel->dtmf_mutex);
 }

◆ switch_channel_dtmf_unlock()

switch_status_t switch_channel_dtmf_unlock ( switch_channel_t * channel )

Definition at line 487 of file switch_channel.c.

References dtmf_mutex, and switch_mutex_unlock().

Referenced by switch_core_session_read_frame().

 {
         return switch_mutex_unlock(channel->dtmf_mutex);
 }

◆ switch_channel_event_set_basic_data()

void switch_channel_event_set_basic_data	(	_In_ switch_channel_t *	channel,
		_In_ switch_event_t *	event
	)

◆ switch_channel_event_set_data()

void switch_channel_event_set_data	(	_In_ switch_channel_t *	channel,
		_In_ switch_event_t *	event
	)

Add information about a given channel to an event object.

Parameters

channel	channel to add information about
event	event to add information to

◆ switch_channel_event_set_extended_data()

void switch_channel_event_set_extended_data	(	_In_ switch_channel_t *	channel,
		_In_ switch_event_t *	event
	)

◆ switch_channel_expand_variables_check()

char* switch_channel_expand_variables_check	(	switch_channel_t *	channel,
		const char *	in,
		switch_event_t *	var_list,
		switch_event_t *	api_list,
		uint32_t	recur
	)

Expand varaibles in a string based on the variables in a paticular channel.

Parameters

channel	channel to expand the variables from
in	the original string

Returns: the original string if no expansion takes place otherwise a new string that must be freed

Note: it's necessary to test if the return val is the same as the input and free the string if it is not.

Definition at line 3986 of file switch_channel.c.

References switch_stream_handle::data, end_of_p, in, memset(), resize, SCF_API_EXPANSION, session, switch_api_execute(), switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_get_variable_dup(), switch_core_test_flag(), switch_event_check_permission_list(), SWITCH_LOG_CRIT, switch_log_printf(), switch_safe_free, SWITCH_STANDARD_STREAM, SWITCH_STATUS_SUCCESS, switch_string_has_escaped_data(), switch_string_var_check_const(), SWITCH_TRUE, and zstr.

 {
         char *p, *c = NULL;
         char *data, *indup, *endof_indup;
         size_t sp = 0, len = 0, olen = 0, vtype = 0, br = 0, cpos, block = 128;
         char *cloned_sub_val = NULL, *sub_val = NULL, *expanded_sub_val = NULL;
         char *func_val = NULL, *sb = NULL;
         int nv = 0;
 
         if (recur > 100) {
                 return (char *) in;
         }
 
         if (zstr(in)) {
                 return (char *) in;
         }
 
         nv = switch_string_var_check_const(in) || switch_string_has_escaped_data(in);
 
         if (!nv) {
                 return (char *) in;
         }
 
 
         nv = 0;
         olen = strlen(in) + 1;
         indup = strdup(in);
         endof_indup = end_of_p(indup) + 1;
 
         if ((data = malloc(olen))) {
                 memset(data, 0, olen);
                 c = data;
                 for (p = indup; p && p < endof_indup && *p; p++) {
                         int global = 0;
                         vtype = 0;
 
                         if (*p == '\\') {
                                 if (*(p + 1) == '$') {
                                         nv = 1;
                                         p++;
                                         if (*(p + 1) == '$') {
                                                 p++;
                                         }
                                 } else if (*(p + 1) == '\'') {
                                         p++;
                                         continue;
                                 } else if (*(p + 1) == '\\') {
                                         if (len + 1 >= olen) {
                                                 resize(1);
                                         }
 
                                         *c++ = *p++;
                                         len++;
                                         continue;
                                 }
                         }
 
                         if (*p == '$' && !nv) {
 
                                 if (*(p + 1) == '$') {
                                         p++;
                                         global++;
                                 }
 
                                 if (*(p + 1)) {
                                         if (*(p + 1) == '{') {
                                                 vtype = global ? 3 : 1;
                                         } else {
                                                 nv = 1;
                                         }
                                 } else {
                                         nv = 1;
                                 }
                         }
 
                         if (nv) {
                                 if (len + 1 >= olen) {
                                         resize(1);
                                 }
 
                                 *c++ = *p;
                                 len++;
                                 nv = 0;
                                 continue;
                         }
 
                         if (vtype) {
                                 char *s = p, *e, *vname, *vval = NULL;
                                 size_t nlen;
 
                                 s++;
 
                                 if ((vtype == 1 || vtype == 3) && *s == '{') {
                                         br = 1;
                                         s++;
                                 }
 
                                 e = s;
                                 vname = s;
                                 while (*e) {
                                         if (br == 1 && *e == '}') {
                                                 br = 0;
                                                 *e++ = '\0';
                                                 break;
                                         }
 
                                         if (br > 0) {
                                                 if (e != s && *e == '{') {
                                                         br++;
                                                 } else if (br > 1 && *e == '}') {
                                                         br--;
                                                 }
                                         }
 
                                         e++;
                                 }
                                 p = e > endof_indup ? endof_indup : e;
 
                                 vval = NULL;
                                 for(sb = vname; sb && *sb; sb++) {
                                         if (*sb == ' ') {
                                                 vval = sb;
                                                 break;
                                         } else if (*sb == '(') {
                                                 vval = sb;
                                                 br = 1;
                                                 break;
                                         }
                                 }
 
                                 if (vval) {
                                         e = vval - 1;
                                         *vval++ = '\0';
                                         while (*e == ' ') {
                                                 *e-- = '\0';
                                         }
                                         e = vval;
 
                                         while (e && *e) {
                                                 if (*e == '(') {
                                                         br++;
                                                 } else if (br > 1 && *e == ')') {
                                                         br--;
                                                 } else if (br == 1 && *e == ')') {
                                                         *e = '\0';
                                                         break;
                                                 }
                                                 e++;
                                         }
 
                                         vtype = 2;
                                 }
 
                                 if (vtype == 1 || vtype == 3) {
                                         char *expanded = NULL;
                                         int offset = 0;
                                         int ooffset = 0;
                                         char *ptr;
                                         int idx = -1;
 
                                         if ((expanded = switch_channel_expand_variables_check(channel, (char *) vname, var_list, api_list, recur+1)) == vname) {
                                                 expanded = NULL;
                                         } else {
                                                 vname = expanded;
                                         }
 
                                         if ((ptr = strchr(vname, ':'))) {
                                                 *ptr++ = '\0';
                                                 offset = atoi(ptr);
                                                 if ((ptr = strchr(ptr, ':'))) {
                                                         ptr++;
                                                         ooffset = atoi(ptr);
                                                 }
                                         }
 
                                         if ((ptr = strchr(vname, '[')) && strchr(ptr, ']')) {
                                                 *ptr++ = '\0';
                                                 idx = atoi(ptr);
                                         }
 
                                         if ((sub_val = (char *) switch_channel_get_variable_dup(channel, vname, SWITCH_TRUE, idx))) {
                                                 if (var_list && !switch_event_check_permission_list(var_list, vname)) {
                                                         sub_val = "<Variable Expansion Permission Denied>";
                                                 }
 
                                                 if ((expanded_sub_val = switch_channel_expand_variables_check(channel, sub_val, var_list, api_list, recur+1)) == sub_val) {
                                                         expanded_sub_val = NULL;
                                                 } else {
                                                         sub_val = expanded_sub_val;
                                                 }
 
                                                 if (offset || ooffset) {
                                                         cloned_sub_val = strdup(sub_val);
                                                         switch_assert(cloned_sub_val);
                                                         sub_val = cloned_sub_val;
                                                 }
 
                                                 if (offset >= 0) {
                                                         if ((size_t) offset > strlen(sub_val)) {
                                                                 *sub_val = '\0';
                                                         } else {
                                                                 sub_val += offset;
                                                         }
                                                 } else if ((size_t) abs(offset) <= strlen(sub_val)) {
                                                         sub_val = cloned_sub_val + (strlen(cloned_sub_val) + offset);
                                                 }
 
                                                 if (ooffset > 0 && (size_t) ooffset < strlen(sub_val)) {
                                                         if ((ptr = (char *) sub_val + ooffset)) {
                                                                 *ptr = '\0';
                                                         }
                                                 }
                                         }
 
                                         switch_safe_free(expanded);
                                 } else {
                                         switch_stream_handle_t stream = { 0 };
                                         char *expanded = NULL;
 
                                         SWITCH_STANDARD_STREAM(stream);
 
                                         if (stream.data) {
                                                 char *expanded_vname = NULL;
 
                                                 if ((expanded_vname = switch_channel_expand_variables_check(channel, (char *) vname, var_list, api_list, recur+1)) == vname) {
                                                         expanded_vname = NULL;
                                                 } else {
                                                         vname = expanded_vname;
                                                 }
 
                                                 if ((expanded = switch_channel_expand_variables_check(channel, vval, var_list, api_list, recur+1)) == vval) {
                                                         expanded = NULL;
                                                 } else {
                                                         vval = expanded;
                                                 }
 
                                                 if (!switch_core_test_flag(SCF_API_EXPANSION) || (api_list && !switch_event_check_permission_list(api_list, vname))) {
                                                         func_val = NULL;
                                                         sub_val = "<API Execute Permission Denied>";
                                                         free(stream.data);
                                                 } else {
                                                         if (switch_api_execute(vname, vval, channel->session, &stream) == SWITCH_STATUS_SUCCESS) {
                                                                 func_val = stream.data;
                                                                 sub_val = func_val;
                                                         } else {
                                                                 free(stream.data);
                                                         }
                                                 }
 
                                                 switch_safe_free(expanded);
                                                 switch_safe_free(expanded_vname);
 
                                         } else {
                                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_CRIT, "Memory Error!\n");
                                                 free(data);
                                                 free(indup);
                                                 return (char *) in;
                                         }
                                 }
                                 if ((nlen = sub_val ? strlen(sub_val) : 0)) {
                                         if (len + nlen >= olen) {
                                                 resize(nlen);
                                         }
 
                                         len += nlen;
                                         strcat(c, sub_val);
                                         c += nlen;
                                 }
 
                                 switch_safe_free(func_val);
                                 switch_safe_free(cloned_sub_val);
                                 switch_safe_free(expanded_sub_val);
                                 sub_val = NULL;
                                 vname = NULL;
                                 br = 0;
                         }
 
                         if (sp) {
                                 if (len + 1 >= olen) {
                                         resize(1);
                                 }
 
                                 *c++ = ' ';
                                 sp = 0;
                                 len++;
                         }
 
                         if (*p == '$') {
                                 p--;
                         } else {
                                 if (len + 1 >= olen) {
                                         resize(1);
                                 }
 
                                 *c++ = *p;
                                 len++;
                         }
                 }
         }
         free(indup);
 
         return data;
 }

◆ switch_channel_export_variable_printf()

switch_status_t switch_channel_export_variable_printf	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	export_varname,
		const char *	fmt,
			...
	)

Definition at line 1357 of file switch_channel.c.

References switch_assert, switch_channel_export_variable, SWITCH_STATUS_FALSE, and switch_vasprintf().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         char *data = NULL;
         va_list ap;
         int ret;
 
         switch_assert(channel != NULL);
 
         va_start(ap, fmt);
         ret = switch_vasprintf(&data, fmt, ap);
         va_end(ap);
 
         if (ret == -1) {
                 return SWITCH_STATUS_FALSE;
         }
 
         status = switch_channel_export_variable(channel, varname, data, export_varname);
 
         free(data);
 
         return status;
 }

◆ switch_channel_export_variable_var_check()

switch_status_t switch_channel_export_variable_var_check	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	val,
		const char *	export_varname,
		switch_bool_t	var_check
	)

Definition at line 1309 of file switch_channel.c.

References session, switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_set_variable_var_check(), switch_core_session_strdup, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mprintf(), switch_safe_free, and SWITCH_STATUS_SUCCESS.

 {
         char *var_name = NULL;
         const char *exports;
         char *var, *new_exports, *new_exports_d = NULL;
         int local = 1;
 
         exports = switch_channel_get_variable(channel, export_varname);
 
         var = switch_core_session_strdup(channel->session, varname);
 
         if (var) {
                 if (!strncasecmp(var, "nolocal:", 8)) { /* remove this later ? */
                         var_name = var + 8;
                         local = 0;
                 } else if (!strncasecmp(var, "_nolocal_", 9)) {
                         var_name = var + 9;
                         local = 0;
                 } else {
                         var_name = var;
                 }
         }
 
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_DEBUG, "EXPORT (%s) %s[%s]=[%s]\n",
                                           export_varname, local ? "" : "(REMOTE ONLY) ",
                                           var_name ? var_name : "", val ? val : "UNDEF");
 
 
         switch_channel_set_variable_var_check(channel, var, val, var_check);
 
         if (var && val) {
                 if (exports) {
                         new_exports_d = switch_mprintf("%s,%s", exports, var);
                         new_exports = new_exports_d;
                 } else {
                         new_exports = var;
                 }
 
                 switch_channel_set_variable(channel, export_varname, new_exports);
 
                 switch_safe_free(new_exports_d);
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_flip_cid()

void switch_channel_flip_cid ( switch_channel_t * channel )

Definition at line 3236 of file switch_channel.c.

References switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, caller_profile, CF_BRIDGED, CF_RECOVERING, switch_caller_profile::pool, profile_mutex, session, SWITCH_BLANK_STRING, switch_channel_event_set_data(), switch_channel_get_name(), switch_channel_get_partner_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_channel_test_flag(), switch_core_strdup, switch_event_add_header_string(), SWITCH_EVENT_CALL_UPDATE, switch_event_create, switch_event_fire, SWITCH_LOG_INFO, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_str_nil, and switch_true().

Referenced by switch_channel_sort_cid(), switch_channel_var_true(), and switch_ivr_uuid_bridge().

 {
         switch_event_t *event;
         const char *tmp = NULL;
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (switch_channel_test_flag(channel, CF_RECOVERING) && switch_true(switch_channel_get_variable(channel, "channel_cid_flipped"))) {
                 switch_mutex_unlock(channel->profile_mutex);
                 return;
         }
 
         if (channel->caller_profile->callee_id_name) {
                 tmp = channel->caller_profile->caller_id_name;
                 switch_channel_set_variable(channel, "pre_transfer_caller_id_name", channel->caller_profile->caller_id_name);
                 channel->caller_profile->caller_id_name = switch_core_strdup(channel->caller_profile->pool, channel->caller_profile->callee_id_name);
         }
 
         if (switch_channel_test_flag(channel, CF_BRIDGED)) {
                 channel->caller_profile->callee_id_name = SWITCH_BLANK_STRING;
         } else if (tmp) {
                 channel->caller_profile->callee_id_name = tmp;
         }
 
         if (channel->caller_profile->callee_id_number) {
                 tmp = channel->caller_profile->caller_id_number;
                 switch_channel_set_variable(channel, "pre_transfer_caller_id_number", channel->caller_profile->caller_id_number);
                 channel->caller_profile->caller_id_number = switch_core_strdup(channel->caller_profile->pool, channel->caller_profile->callee_id_number);
         }
 
         if (switch_channel_test_flag(channel, CF_BRIDGED)) {
                 channel->caller_profile->callee_id_number = SWITCH_BLANK_STRING;
         } else if (tmp) {
                 channel->caller_profile->callee_id_number = tmp;
         }
 
         switch_channel_set_variable(channel, "channel_cid_flipped", "yes");
 
         switch_mutex_unlock(channel->profile_mutex);
 
 
         if (switch_event_create(&event, SWITCH_EVENT_CALL_UPDATE) == SWITCH_STATUS_SUCCESS) {
                 const char *uuid = switch_channel_get_partner_uuid(channel);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Direction", "RECV");
 
                 if (uuid) {
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Bridged-To", uuid);
                 }
                 switch_channel_event_set_data(channel, event);
                 switch_event_fire(&event);
         }
 
 
         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_INFO, "%s Flipping CID from \"%s\" <%s> to \"%s\" <%s>\n",
                                           switch_channel_get_name(channel),
                                           switch_str_nil(switch_channel_get_variable(channel, "pre_transfer_caller_id_name")),
                                           switch_str_nil(switch_channel_get_variable(channel, "pre_transfer_caller_id_number")),
                                           channel->caller_profile->caller_id_name,
                                           channel->caller_profile->caller_id_number
                                           );
 
 }

◆ switch_channel_flush_dtmf()

void switch_channel_flush_dtmf ( _In_ switch_channel_t * channel )

Referenced by CoreSession::flushDigits(), and switch_core_session_reset().

◆ switch_channel_get_caller_extension()

switch_caller_extension_t* switch_channel_get_caller_extension ( switch_channel_t * channel )

Retrieve caller extension from a given channel.

Parameters

channel channel to retrieve extension from

Returns: the requested extension

Definition at line 3346 of file switch_channel.c.

References switch_caller_profile::caller_extension, caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_channel_caller_extension_masquerade(), switch_channel_var_true(), switch_core_standard_on_execute(), and switch_core_standard_on_hangup().

 {
         switch_caller_extension_t *extension = NULL;
 
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->profile_mutex);
         if (channel->caller_profile) {
                 extension = channel->caller_profile->caller_extension;
         }
         switch_mutex_unlock(channel->profile_mutex);
         return extension;
 }

◆ switch_channel_get_caller_profile()

switch_caller_profile_t* switch_channel_get_caller_profile ( switch_channel_t * channel )

Retrieve the given channel's caller profile.

Parameters

channel channel to retrieve the profile from

Returns: the requested profile

Definition at line 2914 of file switch_channel.c.

References caller_profile, switch_caller_profile::hunt_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by check_bridge_export(), check_channel_status(), send_display(), switch_channel_build_param_string(), switch_channel_get_variable_dup(), switch_channel_invert_cid(), switch_core_session_execute_exten(), switch_core_session_outgoing_channel(), switch_core_session_request_xml(), switch_core_session_set_uuid(), switch_core_standard_on_routing(), switch_ivr_eavesdrop_session(), switch_ivr_enterprise_originate(), switch_ivr_generate_json_cdr(), switch_ivr_generate_xml_cdr(), switch_ivr_originate(), switch_ivr_session_transfer(), switch_ivr_set_user_xml(), and switch_ivr_uuid_bridge().

 {
         switch_caller_profile_t *profile;
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->profile_mutex);
         if ((profile = channel->caller_profile) && profile->hunt_caller_profile) {
                 profile = profile->hunt_caller_profile;
         }
         switch_mutex_unlock(channel->profile_mutex);
         return profile;
 }

◆ switch_channel_get_callstate()

switch_channel_callstate_t switch_channel_get_callstate ( switch_channel_t * channel )

Definition at line 309 of file switch_channel.c.

References callstate.

Referenced by switch_core_session_read_frame(), switch_ivr_hold(), switch_ivr_hold_toggle_uuid(), and switch_ivr_unhold().

 {
         return channel->callstate;
 }

◆ switch_channel_get_cap_string()

char* switch_channel_get_cap_string ( switch_channel_t * channel )

Definition at line 1924 of file switch_channel.c.

References caps, CC_FLAG_MAX, switch_stream_handle::data, end_of, flag_mutex, if(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STANDARD_STREAM, and switch_stream_handle::write_function.

Referenced by switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

 {
         switch_stream_handle_t stream = { 0 };
         char *r;
         int i = 0;
 
         SWITCH_STANDARD_STREAM(stream);
 
         switch_mutex_lock(channel->flag_mutex);
         for (i = 0; i < CC_FLAG_MAX; i++) {
                 if (channel->caps[i]) {
                         stream.write_function(&stream, "%d=%d;", i, channel->caps[i]);
                 }
         }
         switch_mutex_unlock(channel->flag_mutex);
 
         r = (char *) stream.data;
 
         if (end_of(r) == ';') {
                 end_of(r) = '\0';
         }
 
         return r;
 
 }

◆ switch_channel_get_cause()

switch_call_cause_t switch_channel_get_cause ( _In_ switch_channel_t * channel )

return the cause code for a given channel

Parameters

channel the channel

Returns: the code

Referenced by abort_call(), audio_bridge_thread(), check_channel_status(), check_presence(), hanguphook(), signal_bridge_on_hangup(), switch_core_session_hangup_state(), switch_core_session_reporting_state(), switch_core_standard_on_hangup(), switch_core_standard_on_reporting(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_signal_bridge(), and wait_for_cause().

◆ switch_channel_get_cause_ptr()

switch_call_cause_t* switch_channel_get_cause_ptr ( switch_channel_t * channel )

Definition at line 244 of file switch_channel.c.

References hangup_cause.

 {
         return &channel->hangup_cause;
 }

◆ switch_channel_get_cause_q850()

switch_call_cause_t switch_channel_get_cause_q850 ( switch_channel_t * channel )

Definition at line 414 of file switch_channel.c.

References hangup_cause, and switch_channel_cause_q850().

Referenced by switch_core_session_hangup_state().

 {
         return switch_channel_cause_q850(channel->hangup_cause);
 }

◆ switch_channel_get_flag_string()

char* switch_channel_get_flag_string ( switch_channel_t * channel )

Definition at line 1898 of file switch_channel.c.

References CF_FLAG_MAX, switch_stream_handle::data, end_of, flag_mutex, flags, if(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STANDARD_STREAM, and switch_stream_handle::write_function.

Referenced by switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

 {
         switch_stream_handle_t stream = { 0 };
         char *r;
         int i = 0;
 
         SWITCH_STANDARD_STREAM(stream);
 
         switch_mutex_lock(channel->flag_mutex);
         for (i = 0; i < CF_FLAG_MAX; i++) {
                 if (channel->flags[i]) {
                         stream.write_function(&stream, "%d=%d;", i, channel->flags[i]);
                 }
         }
         switch_mutex_unlock(channel->flag_mutex);
 
         r = (char *) stream.data;
 
         if (end_of(r) == ';') {
                 end_of(r) = '\0';
         }
 
         return r;
 
 }

◆ switch_channel_get_hold_music()

const char* switch_channel_get_hold_music ( switch_channel_t * channel )

Definition at line 894 of file switch_channel.c.

References session, switch_channel_expand_variables, switch_channel_get_variable, switch_core_session_strdup, SWITCH_HOLD_MUSIC_VARIABLE, SWITCH_TEMP_HOLD_MUSIC_VARIABLE, and zstr.

Referenced by switch_channel_get_hold_music_partner(), switch_core_media_toggle_hold(), switch_ivr_hold(), switch_ivr_parse_event(), and switch_ivr_soft_hold().

 {
         const char *var;
 
         if (!(var = switch_channel_get_variable(channel, SWITCH_TEMP_HOLD_MUSIC_VARIABLE))) {
                 var = switch_channel_get_variable(channel, SWITCH_HOLD_MUSIC_VARIABLE);
         }
 
         if (!zstr(var)) {
                 char *expanded = switch_channel_expand_variables(channel, var);
 
                 if (expanded != var) {
                         var = switch_core_session_strdup(channel->session, expanded);
                         free(expanded);
                 }
         }
 
 
         return var;
 }

◆ switch_channel_get_hold_music_partner()

const char* switch_channel_get_hold_music_partner ( switch_channel_t * channel )

Definition at line 915 of file switch_channel.c.

References session, switch_channel_get_hold_music(), switch_core_session_get_channel(), switch_core_session_get_partner, switch_core_session_rwunlock(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_parse_event().

 {
         switch_core_session_t *session;
         const char *r = NULL;
 
         if (switch_core_session_get_partner(channel->session, &session) == SWITCH_STATUS_SUCCESS) {
                 r = switch_channel_get_hold_music(switch_core_session_get_channel(session));
                 switch_core_session_rwunlock(session);
         }
 
         return r;
 }

◆ switch_channel_get_log_tags()

switch_status_t switch_channel_get_log_tags	(	switch_channel_t *	channel,
		switch_event_t **	log_tags
	)

Definition at line 1473 of file switch_channel.c.

References log_tags, profile_mutex, switch_assert, switch_event_dup(), switch_mutex_lock(), switch_mutex_unlock(), and SWITCH_STATUS_FALSE.

Referenced by switch_log_meta_vprintf().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_assert(channel != NULL);
         if (!channel->log_tags) {
                 return status;
         }
         switch_mutex_lock(channel->profile_mutex);
         if (channel->log_tags && log_tags) {
                 status = switch_event_dup(log_tags, channel->log_tags);
         }
         switch_mutex_unlock(channel->profile_mutex);
         return status;
 }

◆ switch_channel_get_name()

char* switch_channel_get_name ( switch_channel_t * channel )

Retrieve the name of a given channel.

Parameters

channel channel to get name of

Returns: the channel's name

Definition at line 1148 of file switch_channel.c.

References name, switch_assert, and zstr.

 {
         switch_assert(channel != NULL);
         return (!zstr(channel->name)) ? channel->name : "N/A";
 }

◆ switch_channel_get_originatee_caller_profile()

switch_caller_profile_t* switch_channel_get_originatee_caller_profile ( switch_channel_t * channel )

Retrieve the given channel's originatee caller profile.

Parameters

channel channel to retrieve the profile from

Returns: the requested profile

Definition at line 3022 of file switch_channel.c.

References caller_profile, switch_caller_profile::originatee_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_reporting_state().

 {
         switch_caller_profile_t *profile = NULL;
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->caller_profile) {
                 profile = channel->caller_profile->originatee_caller_profile;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return profile;
 }

◆ switch_channel_get_origination_caller_profile()

switch_caller_profile_t* switch_channel_get_origination_caller_profile ( switch_channel_t * channel )

Retrieve the given channel's origination caller profile.

Parameters

channel channel to retrieve the profile from

Returns: the requested profile

Definition at line 2976 of file switch_channel.c.

References caller_profile, switch_caller_profile::origination_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_caller_profile_t *profile = NULL;
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->caller_profile) {
                 profile = channel->caller_profile->origination_caller_profile;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return profile;
 }

◆ switch_channel_get_originator_caller_profile()

switch_caller_profile_t* switch_channel_get_originator_caller_profile ( switch_channel_t * channel )

Retrieve the given channel's originator caller profile.

Parameters

channel channel to retrieve the profile from

Returns: the requested profile

Definition at line 3007 of file switch_channel.c.

References caller_profile, switch_caller_profile::originator_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_reporting_state().

 {
         switch_caller_profile_t *profile = NULL;
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (channel->caller_profile) {
                 profile = channel->caller_profile->originator_caller_profile;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return profile;
 }

◆ switch_channel_get_private()

void* switch_channel_get_private	(	switch_channel_t *	channel,
		const char *	key
	)

Retrieve private from a given channel.

Parameters

channel	channel to retrieve data from
key	unique keyname to retrieve your private data

Returns: void pointer to channel's private data

Definition at line 1100 of file switch_channel.c.

References private_hash, profile_mutex, switch_assert, and switch_core_hash_find_locked().

 {
         void *val;
         switch_assert(channel != NULL);
         val = switch_core_hash_find_locked(channel->private_hash, key, channel->profile_mutex);
         return val;
 }

◆ switch_channel_get_private_partner()

void* switch_channel_get_private_partner	(	switch_channel_t *	channel,
		const char *	key
	)

Definition at line 1108 of file switch_channel.c.

References private_hash, profile_mutex, switch_assert, switch_channel_get_partner_uuid(), switch_core_hash_find_locked(), switch_core_session_locate, and switch_core_session_rwunlock().

 {
         const char *uuid;
         void *val = NULL;
 
         switch_assert(channel != NULL);
 
         if ((uuid = switch_channel_get_partner_uuid(channel))) {
                 switch_core_session_t *session;
                 if ((session = switch_core_session_locate(uuid))) {
                         val = switch_core_hash_find_locked(channel->private_hash, key, channel->profile_mutex);
                         switch_core_session_rwunlock(session);
                 }
         }
 
         return val;
 }

◆ switch_channel_get_running_state()

switch_channel_state_t switch_channel_get_running_state ( switch_channel_t * channel )

Definition at line 2245 of file switch_channel.c.

References running_state, and switch_assert.

Referenced by check_presence(), switch_core_session_run(), and uuid_bridge_on_soft_execute().

 {
         switch_channel_state_t state;
         switch_assert(channel != NULL);
 
         state = channel->running_state;
 
         return state;
 }

◆ switch_channel_get_scope_variables()

switch_status_t switch_channel_get_scope_variables	(	switch_channel_t *	channel,
		switch_event_t **	event
	)

Definition at line 946 of file switch_channel.c.

References switch_event::headers, switch_event_header::name, switch_event_header::next, switch_event::next, profile_mutex, scope_variables, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_get_header, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_event_header::value.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_event_t *new_event;
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->scope_variables) {
                 switch_event_t *ep;
                 switch_event_header_t *hp;
 
                 switch_event_create_plain(&new_event, SWITCH_EVENT_CHANNEL_DATA);
                 status = SWITCH_STATUS_SUCCESS;
                 *event = new_event;
 
                 for (ep = channel->scope_variables; ep; ep = ep->next) {
                         for (hp = ep->headers; hp; hp = hp->next) {
                                 if (!switch_event_get_header(new_event, hp->value)) {
                                         switch_event_add_header_string(new_event, SWITCH_STACK_BOTTOM, hp->name, hp->value);
                                 }
                         }
                 }
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_get_session()

switch_core_session_t* switch_channel_get_session ( switch_channel_t * channel )

Definition at line 4482 of file switch_channel.c.

References session, and switch_assert.

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

◆ switch_channel_get_state()

switch_channel_state_t switch_channel_get_state ( switch_channel_t * channel )

Get the current state of a channel in the state engine.

Parameters

channel channel to retrieve state from

Returns: current state of channel

Definition at line 2235 of file switch_channel.c.

References state, and switch_assert.

Referenced by audio_bridge_on_exchange_media(), audio_bridge_thread(), check_channel_status(), check_per_channel_timeouts(), fs_channel_set_state(), CoreSession::getState(), hanguphook(), limit_state_handler(), originate_on_consume_media_transmit(), originate_on_routing(), CoreSession::setHangupHook(), signal_bridge_on_hibernate(), switch_channel_handle_cause(), switch_core_recovery_track(), switch_core_recovery_untrack(), switch_core_session_hangup_state(), switch_core_session_perform_destroy(), switch_core_session_read_frame(), switch_core_session_read_lock_hangup(), switch_core_session_reporting_state(), switch_core_session_run(), switch_core_standard_on_execute(), switch_ivr_generate_json_cdr(), switch_ivr_generate_xml_cdr(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_uuid_bridge(), switch_ivr_wait_for_answer(), and uuid_bridge_on_soft_execute().

 {
         switch_channel_state_t state;
         switch_assert(channel != NULL);
 
         state = channel->state;
 
         return state;
 }

◆ switch_channel_get_state_handler()

const switch_state_handler_table_t* switch_channel_get_state_handler	(	switch_channel_t *	channel,
		int	index
	)

Retrieve an state handler tablefrom a given channel at given index level.

Parameters

channel	channel from which to retrieve the state handler table
index	the index of the state handler table (start from 0)

Returns: given channel's state handler table at given index or NULL if requested index does not exist.

Definition at line 3069 of file switch_channel.c.

References index, state_handler_index, state_handlers, state_mutex, switch_assert, SWITCH_MAX_STATE_HANDLERS, switch_mutex_lock(), and switch_mutex_unlock().

 {
         const switch_state_handler_table_t *h = NULL;
 
         switch_assert(channel != NULL);
 
         if (index >= SWITCH_MAX_STATE_HANDLERS || index > channel->state_handler_index) {
                 return NULL;
         }
 
         switch_mutex_lock(channel->state_mutex);
         h = channel->state_handlers[index];
         switch_mutex_unlock(channel->state_mutex);
 
         return h;
 }

◆ switch_channel_get_timetable()

switch_channel_timetable_t* switch_channel_get_timetable ( _In_ switch_channel_t * channel )

View the timetable of a channel.

Parameters

channel channel to retrieve timetable from

Returns: a pointer to the channel's timetable (created, answered, etc..)

◆ switch_channel_get_uuid()

char* switch_channel_get_uuid ( switch_channel_t * channel )

Retrieve the given channel's unique id.

Parameters

channel channel to retrieve the unique id from

Returns: the unique id

Definition at line 3036 of file switch_channel.c.

References session, switch_assert, and switch_core_session_get_uuid().

Referenced by switch_channel_perform_hangup(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_channel_perform_ring_ready_value(), switch_channel_perform_set_callstate(), switch_channel_perform_set_running_state(), switch_channel_perform_set_state(), switch_ivr_originate(), and switch_rtp_add_crypto_key().

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

◆ switch_channel_get_variable_buf()

switch_status_t switch_channel_get_variable_buf	(	switch_channel_t *	channel,
		const char *	varname,
		char *	buf,
		switch_size_t	buflen
	)

Retrieve a variable from a given channel to a pre-allocated buffer without using a memory pool.

Parameters

channel	channel to retrieve variable from
varname	the name of the variable
buf	a pre allocated buffer to put the value to
buflen	size of the buffer

Returns: SWITCH_STATUS_SUCCESS if the value was copied to the buffer and it is not NULL, SWITCH_STATUS_FALSE otherwise.

Definition at line 1032 of file switch_channel.c.

References switch_channel_get_variable_dup(), switch_copy_string(), SWITCH_FALSE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and value.

 {
         const char *value = switch_channel_get_variable_dup(channel, varname, SWITCH_FALSE, -1);
 
         if (value && buf && buflen && switch_copy_string(buf, value, buflen)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_channel_get_variable_dup()

const char* switch_channel_get_variable_dup	(	switch_channel_t *	channel,
		const char *	varname,
		switch_bool_t	dup,
		int	idx
	)

Retrieve a variable from a given channel.

Parameters

channel	channel to retrieve variable from
varname	the name of the variable

Returns: the value of the requested variable

Definition at line 973 of file switch_channel.c.

References switch_event::next, switch_caller_profile::originatee_caller_profile, switch_caller_profile::originator_caller_profile, profile_mutex, scope_variables, session, switch_assert, switch_caller_get_field_by_name(), switch_channel_get_caller_profile(), switch_core_get_variable_pdup(), switch_core_session_get_pool(), switch_core_session_strdup, switch_event_get_header_idx(), switch_mutex_lock(), switch_mutex_unlock(), variables, and zstr.

Referenced by audio_bridge_thread(), check_ice(), check_jb_sync(), switch_channel_event_set_basic_data(), switch_channel_expand_variables_check(), switch_channel_get_partner_uuid_copy(), switch_channel_get_variable_buf(), switch_channel_get_variable_strdup(), switch_channel_queue_dtmf(), switch_channel_set_presence_data_vals(), switch_channel_var_false(), switch_channel_var_true(), switch_core_media_gen_local_sdp(), switch_core_media_negotiate_sdp(), switch_core_media_prepare_codecs(), switch_core_media_toggle_hold(), switch_core_recovery_track(), switch_core_session_enable_heartbeat(), switch_core_session_findall_matching_var(), switch_core_session_send_dtmf(), switch_jb_set_session(), and switch_rtp_activate_jitter_buffer().

 {
         const char *v = NULL, *r = NULL, *vdup = NULL;
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (!zstr(varname)) {
                 if (channel->scope_variables) {
                         switch_event_t *ep;
 
                         for (ep = channel->scope_variables; ep; ep = ep->next) {
                                 if ((v = switch_event_get_header_idx(ep, varname, idx))) {
                                         break;
                                 }
                         }
                 }
 
                 if (!v && (!channel->variables || !(v = switch_event_get_header_idx(channel->variables, varname, idx)))) {
                         switch_caller_profile_t *cp = switch_channel_get_caller_profile(channel);
 
                         if (cp) {
                                 if (!strncmp(varname, "aleg_", 5)) {
                                         cp = cp->originator_caller_profile;
                                         varname += 5;
                                 } else if (!strncmp(varname, "bleg_", 5)) {
                                         cp = cp->originatee_caller_profile;
                                         varname += 5;
                                 }
                         }
 
                         if (!cp || !(v = switch_caller_get_field_by_name(cp, varname))) {
                                 if ((vdup = switch_core_get_variable_pdup(varname, switch_core_session_get_pool(channel->session)))) {
                                         v = vdup;
                                 }
                         }
                 }
         }
 
         if (dup && v != vdup) {
                 if (v) {
                         r = switch_core_session_strdup(channel->session, v);
                 }
         } else {
                 r = v;
         }
 
         switch_mutex_unlock(channel->profile_mutex);
 
         return r;
 }

◆ switch_channel_get_variable_partner()

const char* switch_channel_get_variable_partner	(	switch_channel_t *	channel,
		const char *	varname
	)

Definition at line 1043 of file switch_channel.c.

References session, switch_assert, switch_channel_get_partner_uuid(), switch_channel_get_variable, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_core_session_strdup, and zstr.

Referenced by switch_core_media_negotiate_sdp().

 {
         const char *uuid;
         const char *val = NULL, *r = NULL;
         switch_assert(channel != NULL);
 
         if (!zstr(varname)) {
                 if ((uuid = switch_channel_get_partner_uuid(channel))) {
                         switch_core_session_t *session;
                         if ((session = switch_core_session_locate(uuid))) {
                                 switch_channel_t *tchannel = switch_core_session_get_channel(session);
                                 val = switch_channel_get_variable(tchannel, varname);
                                 switch_core_session_rwunlock(session);
                         }
                 }
         }
 
         if (val)
                 r = switch_core_session_strdup(channel->session, val);
 
         return r;
 }

◆ switch_channel_get_variable_strdup()

const char* switch_channel_get_variable_strdup	(	switch_channel_t *	channel,
		const char *	varname
	)

Retrieve a copy of a variable from a given channel. switch_safe_free() call will be required.

Parameters

channel	channel to retrieve variable from
varname	the name of the variable

Returns: a strdup copy the value of the requested variable without using a memory pool.

Definition at line 1025 of file switch_channel.c.

References switch_channel_get_variable_dup(), SWITCH_FALSE, and value.

 {
         const char *value = switch_channel_get_variable_dup(channel, varname, SWITCH_FALSE, -1);
 
         return value ? (const char *)strdup(value) : NULL;
 }

◆ switch_channel_get_variables()

switch_status_t switch_channel_get_variables	(	switch_channel_t *	channel,
		switch_event_t **	event
	)

Definition at line 4446 of file switch_channel.c.

References profile_mutex, SWITCH_EVENT_CHANNEL_DATA, switch_event_create, switch_event_dup(), switch_mutex_lock(), switch_mutex_unlock(), and variables.

Referenced by api_hook(), asr_set_json_text_params(), switch_channel_api_on(), switch_channel_del_variable_prefix(), switch_channel_execute_on(), and switch_ivr_transfer_variable().

 {
         switch_status_t status;
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables) {
                 status = switch_event_dup(event, channel->variables);
         } else {
                 status = switch_event_create(event, SWITCH_EVENT_CHANNEL_DATA);
         }
         switch_mutex_unlock(channel->profile_mutex);
         return status;
 }

◆ switch_channel_get_variables_prefix()

switch_status_t switch_channel_get_variables_prefix	(	switch_channel_t *	channel,
		const char *	prefix,
		switch_event_t **	event
	)

Definition at line 4459 of file switch_channel.c.

References switch_event::headers, switch_event_header::name, switch_event_header::next, profile_mutex, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_event_header::value, and variables.

 {
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         switch_event_t *vars;
         
         switch_event_create(&vars, SWITCH_EVENT_CHANNEL_DATA);
         
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables) {
                 switch_event_header_t *hi;
 
                 for (hi = channel->variables->headers; hi; hi = hi->next) {
                         if (!strncmp(hi->name, prefix, strlen(prefix))) {
                                 switch_event_add_header_string(vars, SWITCH_STACK_BOTTOM, hi->name, hi->value);
                         }
                 }
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         *event = vars;
         return status;
 }

◆ switch_channel_has_dtmf()

switch_size_t switch_channel_has_dtmf ( _In_ switch_channel_t * channel )

Test for presence of DTMF on a given channel.

Parameters

channel channel to test

Returns: number of digits in the queue

Referenced by audio_bridge_thread(), switch_core_session_reset(), switch_ivr_collect_digits_callback(), switch_ivr_collect_digits_count(), switch_ivr_eavesdrop_session(), switch_ivr_gentones(), switch_ivr_originate(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file_event(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

◆ switch_channel_init()

switch_status_t switch_channel_init	(	switch_channel_t *	channel,
		switch_core_session_t *	session,
		switch_channel_state_t	state,
		switch_channel_flag_t	flag
	)

Connect a newly allocated channel to a session object and setup it's initial state.

Parameters

channel	the channel to initilize
session	the session to connect the channel to
state	the initial state of the channel
flags	the initial channel flags

Definition at line 767 of file switch_channel.c.

References CS_NONE, running_state, session, state, switch_assert, switch_channel_set_flag, and SWITCH_STATUS_SUCCESS.

Referenced by switch_core_session_request_uuid().

 {
         switch_assert(channel != NULL);
         channel->state = state;
         switch_channel_set_flag(channel, flag);
         channel->session = session;
         channel->running_state = CS_NONE;
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_invert_cid()

void switch_channel_invert_cid ( switch_channel_t * channel )

Definition at line 3206 of file switch_channel.c.

References switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, switch_channel_get_caller_profile(), SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, switch_log_printf(), and zstr.

Referenced by switch_channel_var_true(), and switch_ivr_uuid_bridge().

 {
         const char *tname, *tnum;
         switch_caller_profile_t *cp;
 
         cp = switch_channel_get_caller_profile(channel);
 
         tname = cp->caller_id_name;
         tnum = cp->caller_id_number;
 
 #ifdef DEEP_DEBUG_CID
         switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "SWAP [%s][%s] [%s][%s]\n", cp->caller_id_name, cp->caller_id_number, cp->callee_id_name, cp->callee_id_number);
 #endif
 
         cp->caller_id_name = cp->callee_id_name;
         cp->caller_id_number = cp->callee_id_number;
 
         cp->callee_id_name = tname;
         cp->callee_id_number = tnum;
 
         if (zstr(cp->caller_id_name)) {
                 cp->caller_id_name = "Unknown";
         }
 
         if (zstr(cp->caller_id_number)) {
                 cp->caller_id_number = "Unknown";
         }
 }

◆ switch_channel_logical_direction()

switch_call_direction_t switch_channel_logical_direction ( switch_channel_t * channel )

Definition at line 445 of file switch_channel.c.

References logical_direction.

 {
         return channel->logical_direction;
 }

◆ switch_channel_mark_hold()

void switch_channel_mark_hold	(	switch_channel_t *	channel,
		switch_bool_t	on
	)

Definition at line 861 of file switch_channel.c.

References CF_LEG_HOLDING, session, switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_get_variable, switch_channel_set_flag, switch_channel_test_flag(), switch_core_session_get_partner, switch_core_session_rwunlock(), SWITCH_EVENT_CHANNEL_HOLD, SWITCH_EVENT_CHANNEL_UNHOLD, switch_event_create, switch_event_fire, switch_ivr_transfer_recordings(), SWITCH_STATUS_SUCCESS, and switch_true().

Referenced by audio_bridge_thread(), switch_channel_perform_hangup(), switch_core_media_toggle_hold(), and switch_ivr_intercept_session().

 {
         switch_event_t *event;
 
         if (!!on == !!switch_channel_test_flag(channel, CF_LEG_HOLDING)) {
                 goto end;
         }
 
         if (on) {
                 switch_channel_set_flag(channel, CF_LEG_HOLDING);
         } else {
                 switch_channel_clear_flag(channel, CF_LEG_HOLDING);
         }
 
         if (switch_event_create(&event, on ? SWITCH_EVENT_CHANNEL_HOLD : SWITCH_EVENT_CHANNEL_UNHOLD) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data(channel, event);
                 switch_event_fire(&event);
         }
 
  end:
 
         if (on) {
                 if (switch_true(switch_channel_get_variable(channel, "flip_record_on_hold"))) {
                         switch_core_session_t *other_session;
                         if (switch_core_session_get_partner(channel->session, &other_session) == SWITCH_STATUS_SUCCESS) {
                                 switch_ivr_transfer_recordings(channel->session, other_session);
                                 switch_core_session_rwunlock(other_session);
                         }
                 }
         }
 
 }

◆ switch_channel_name_state()

switch_channel_state_t switch_channel_name_state ( _In_ const char * name )

Render the enum of the provided state name.

Parameters

name	the name of the state

Returns: the enum value (numeric)

Referenced by fs_channel_set_state().

◆ switch_channel_pass_callee_id()

switch_status_t switch_channel_pass_callee_id	(	switch_channel_t *	channel,
		switch_channel_t *	other_channel
	)

Definition at line 4420 of file switch_channel.c.

References switch_caller_profile::callee_id_name, switch_caller_profile::callee_id_number, caller_profile, switch_caller_profile::pool, profile_mutex, switch_assert, switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by audio_bridge_thread(), check_channel_status(), switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

 {
         int x = 0;
 
         switch_assert(channel);
         switch_assert(other_channel);
 
         switch_mutex_lock(channel->profile_mutex);
         switch_mutex_lock(other_channel->profile_mutex);
 
         if (!zstr(channel->caller_profile->callee_id_name)) {
                 other_channel->caller_profile->callee_id_name = switch_core_strdup(other_channel->caller_profile->pool, channel->caller_profile->callee_id_name);
                 x++;
         }
 
         if (!zstr(channel->caller_profile->callee_id_number)) {
                 other_channel->caller_profile->callee_id_number = switch_core_strdup(other_channel->caller_profile->pool, channel->caller_profile->callee_id_number);
                 x++;
         }
 
         switch_mutex_unlock(other_channel->profile_mutex);
         switch_mutex_unlock(channel->profile_mutex);
 
         return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

◆ switch_channel_perform_acknowledge_call()

switch_status_t switch_channel_perform_acknowledge_call	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3467 of file switch_channel.c.

References send_ind(), SWITCH_MESSAGE_INDICATE_ACKNOWLEDGE_CALL, and SWITCH_STATUS_SUCCESS.

 {
         send_ind(channel, SWITCH_MESSAGE_INDICATE_ACKNOWLEDGE_CALL, file, func, line);
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_perform_answer()

switch_status_t switch_channel_perform_answer	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3925 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CF_HAS_TEXT, CF_PROXY_MODE, CS_HANGUP, switch_core_session_message::from, hangup_cause, switch_core_session_message::message_id, name, session, state, switch_assert, SWITCH_CALL_DIRECTION_OUTBOUND, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION, switch_channel_audio_sync, switch_channel_direction(), switch_channel_get_variable, switch_channel_hangup, switch_channel_perform_mark_answered(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_core_session_in_thread(), switch_core_session_perform_receive_message(), switch_ivr_sleep(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_MESSAGE_INDICATE_ANSWER, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_TRUE.

 {
         switch_core_session_message_t msg = { 0 };
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_assert(channel != NULL);
 
         if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (channel->hangup_cause || channel->state >= CS_HANGUP) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         msg.message_id = SWITCH_MESSAGE_INDICATE_ANSWER;
         msg.from = channel->name;
         status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
 
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 switch_channel_perform_mark_answered(channel, file, func, line);
                 if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                         switch_channel_audio_sync(channel);
                 }
         } else {
                 switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
         }
 
 
         if (switch_core_session_in_thread(channel->session) && !switch_channel_test_flag(channel, CF_PROXY_MODE) &&
                 !switch_channel_test_flag(channel, CF_HAS_TEXT)) {
                 const char *delay;
 
                 if ((delay = switch_channel_get_variable(channel, "answer_delay"))) {
                         uint32_t msec = atoi(delay);
 
                         if (msec) {
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_DEBUG, "Answer delay for %u msec\n", msec);
                                 switch_ivr_sleep(channel->session, msec, SWITCH_TRUE, NULL);
                         }
                 }
         }
 
         return status;
 }

◆ switch_channel_perform_audio_sync()

void switch_channel_perform_audio_sync	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 366 of file switch_channel.c.

References switch_core_session_message::_file, switch_core_session_message::_func, switch_core_session_message::_line, switch_core_session_message::from, switch_core_session_message::message_id, MESSAGE_STAMP_FFL, name, session, switch_channel_media_up, switch_core_session_alloc, switch_core_session_queue_message(), and SWITCH_MESSAGE_INDICATE_AUDIO_SYNC.

 {
         if (switch_channel_media_up(channel)) {
                 switch_core_session_message_t *msg = NULL;
 
                 msg = switch_core_session_alloc(channel->session, sizeof(*msg));
                 MESSAGE_STAMP_FFL(msg);
                 msg->message_id = SWITCH_MESSAGE_INDICATE_AUDIO_SYNC;
                 msg->from = channel->name;
                 msg->_file = file;
                 msg->_func = func;
                 msg->_line = line;
 
                 switch_core_session_queue_message(channel->session, msg);
         }
 }

◆ switch_channel_perform_hangup()

switch_channel_state_t switch_channel_perform_hangup	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line,
		switch_call_cause_t	hangup_cause
	)

Definition at line 3380 of file switch_channel.c.

References CF_BLOCK_STATE, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_HANGUP_HELD, CF_LEG_HOLDING, CS_HANGUP, hangup_cause, hold_record, name, OCF_HANGUP, switch_hold_record_s::off, opaque_flags, profile_mutex, session, state, state_mutex, state_names, switch_assert, switch_channel_cause2str(), switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_get_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_ID_LOG, switch_channel_mark_hold(), switch_channel_set_flag, switch_channel_set_variable, switch_channel_set_variable_partner, switch_channel_test_flag(), switch_core_session_hangup_state(), switch_core_session_kill_channel, switch_core_session_running(), switch_core_session_signal_state_change(), switch_core_session_started(), switch_core_session_thread_launch(), SWITCH_EVENT_CHANNEL_HANGUP, switch_event_create, switch_event_fire, SWITCH_FALSE, SWITCH_LOG_NOTICE, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE, SWITCH_SIG_KILL, SWITCH_STATUS_SUCCESS, and switch_time_now().

 {
         int ok = 0;
 
         switch_assert(channel != NULL);
 
         /* one per customer */
         switch_mutex_lock(channel->state_mutex);
         if (!(channel->opaque_flags & OCF_HANGUP)) {
                 channel->opaque_flags |= OCF_HANGUP;
                 ok = 1;
         }
         switch_mutex_unlock(channel->state_mutex);
 
         if (switch_channel_test_flag(channel, CF_LEG_HOLDING)) {
                 switch_channel_mark_hold(channel, SWITCH_FALSE);
                 switch_channel_set_flag(channel, CF_HANGUP_HELD);
         }
 
         if (!ok) {
                 return channel->state;
         }
 
         switch_channel_clear_flag(channel, CF_BLOCK_STATE);
 
         if (channel->state < CS_HANGUP) {
                 switch_channel_state_t last_state;
                 switch_event_t *event;
                 const char *var;
 
 
                 switch_mutex_lock(channel->profile_mutex);
                 if (channel->hold_record && !channel->hold_record->off) {
                         channel->hold_record->off = switch_time_now();
                 }
                 switch_mutex_unlock(channel->profile_mutex);
 
                 switch_mutex_lock(channel->state_mutex);
                 last_state = channel->state;
                 channel->state = CS_HANGUP;
                 switch_mutex_unlock(channel->state_mutex);
 
                 channel->hangup_cause = hangup_cause;
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Hangup %s [%s] [%s]\n",
                                                   channel->name, state_names[last_state], switch_channel_cause2str(channel->hangup_cause));
 
 
                 switch_channel_set_variable_partner(channel, "last_bridge_hangup_cause", switch_channel_cause2str(hangup_cause));
 
                 if ((var = switch_channel_get_variable(channel, SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE))) {
                         switch_channel_set_variable_partner(channel, "last_bridge_" SWITCH_PROTO_SPECIFIC_HANGUP_CAUSE_VARIABLE, var);
                 }
 
                 if (switch_channel_test_flag(channel, CF_BRIDGE_ORIGINATOR)) {
                         switch_channel_set_variable(channel, "last_bridge_role", "originator");
                 } else if (switch_channel_test_flag(channel, CF_BRIDGED)) {
                         switch_channel_set_variable(channel, "last_bridge_role", "originatee");
                 }
 
 
                 if (!switch_core_session_running(channel->session) && !switch_core_session_started(channel->session)) {
                         switch_core_session_thread_launch(channel->session);
                 }
 
                 if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_HANGUP) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(channel, event);
                         switch_event_fire(&event);
                 }
 
                 switch_core_session_kill_channel(channel->session, SWITCH_SIG_KILL);
                 switch_core_session_signal_state_change(channel->session);
                 switch_core_session_hangup_state(channel->session, SWITCH_FALSE);
         }
 
         return channel->state;
 }

◆ switch_channel_perform_mark_answered()

switch_status_t switch_channel_perform_mark_answered	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3813 of file switch_channel.c.

References switch_channel_timetable::answered, caller_profile, CCS_ACTIVE, CF_ANSWERED, CF_EARLY_MEDIA, CF_NO_RECOVER, CF_PASSTHRU_PTIME_MISMATCH, CF_RTT, CF_VIDEO_MIRROR_INPUT, CS_HANGUP, hangup_cause, name, profile_mutex, send_ind(), session, state, switch_assert, switch_channel_api_on(), SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE, switch_channel_event_set_data(), switch_channel_execute_on(), SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE, SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE, switch_channel_get_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_ID_LOG, switch_channel_presence, switch_channel_set_callstate, switch_channel_set_flag, switch_channel_set_flag_partner(), switch_channel_set_variable, switch_channel_test_flag(), switch_core_media_check_autoadj(), switch_core_media_check_dtls(), switch_core_recovery_track(), switch_core_session_enable_heartbeat(), switch_core_session_kill_channel, switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_ENABLE_HEARTBEAT_EVENTS_VARIABLE, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, SWITCH_EVENT_CHANNEL_ANSWER, switch_event_create, switch_event_fire, switch_is_number(), SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MESSAGE_ANSWER_EVENT, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_ORIGINATOR_VARIABLE, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE, SWITCH_SIG_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), and switch_caller_profile::times.

Referenced by switch_channel_perform_answer().

 {
         switch_event_t *event;
         const char *uuid;
         switch_core_session_t *other_session;
         const char *var;
 
         switch_assert(channel != NULL);
 
         if (channel->hangup_cause || channel->state >= CS_HANGUP) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         switch_core_media_check_dtls(channel->session, SWITCH_MEDIA_TYPE_AUDIO);
 
         if (channel->caller_profile && channel->caller_profile->times) {
                 switch_mutex_lock(channel->profile_mutex);
                 channel->caller_profile->times->answered = switch_micro_time_now();
                 switch_mutex_unlock(channel->profile_mutex);
         }
 
         switch_channel_set_flag(channel, CF_ANSWERED);
 
         if (switch_true(switch_channel_get_variable(channel, "video_mirror_input"))) {
                 switch_channel_set_flag(channel, CF_VIDEO_MIRROR_INPUT);
                 //switch_channel_set_flag(channel, CF_VIDEO_DECODED_READ);
         }
 
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_ANSWER) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data(channel, event);
                 switch_event_fire(&event);
         }
 
         /* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send
            a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel
          */
         if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE))
                 && (other_session = switch_core_session_locate(uuid))) {
                 switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK);
                 switch_core_session_rwunlock(other_session);
         }
 
         if (switch_true(switch_channel_get_variable(channel, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE))) {
                 switch_channel_set_flag(channel, CF_PASSTHRU_PTIME_MISMATCH);
         }
 
         if ((var = switch_channel_get_variable(channel, SWITCH_ENABLE_HEARTBEAT_EVENTS_VARIABLE))) {
                 uint32_t seconds = 60;
                 int tmp;
 
                 if (switch_is_number(var)) {
                         tmp = atoi(var);
                         if (tmp > 0) {
                                 seconds = tmp;
                         }
                 } else if (!switch_true(var)) {
                         seconds = 0;
                 }
 
                 if (seconds) {
                         switch_core_session_enable_heartbeat(channel->session, seconds);
                 }
         }
 
         switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "ANSWER");
         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Channel [%s] has been answered\n",
                                           channel->name);
 
 
         if (switch_channel_get_variable(channel, "absolute_codec_string")) {
                 /* inherit_codec == true will implicitly clear the absolute_codec_string
                    variable if used since it was the reason it was set in the first place and is no longer needed */
                 if (switch_true(switch_channel_get_variable(channel, "inherit_codec"))) {
                         switch_channel_set_variable(channel, "absolute_codec_string", NULL);
                 }
         }
 
         switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_ANSWER_VARIABLE);
 
         if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                 switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE);
                 switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE);
         }
 
         switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE);
 
         switch_channel_presence(channel, "unknown", "answered", NULL);
 
         //switch_channel_audio_sync(channel);
                         
         if (!switch_channel_test_flag(channel, CF_NO_RECOVER)) { 
                 switch_core_recovery_track(channel->session);
         }
         
         switch_channel_set_callstate(channel, CCS_ACTIVE);
 
         send_ind(channel, SWITCH_MESSAGE_ANSWER_EVENT, file, func, line);
 
         switch_core_media_check_autoadj(channel->session);
 
         if (switch_channel_test_flag(channel, CF_RTT)) {
                 switch_channel_set_flag_partner(channel, CF_RTT);
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_perform_mark_pre_answered()

switch_status_t switch_channel_perform_mark_pre_answered	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3523 of file switch_channel.c.

References caller_profile, CCS_EARLY, CF_ANSWERED, CF_EARLY_MEDIA, CF_PASSTHRU_PTIME_MISMATCH, CF_VIDEO_MIRROR_INPUT, name, switch_caller_profile::originator_caller_profile, profile_mutex, switch_channel_timetable::progress_media, send_ind(), session, switch_channel_api_on(), SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE, SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE, switch_channel_event_set_data(), switch_channel_execute_on(), SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE, SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE, switch_channel_get_uuid(), switch_channel_get_variable, SWITCH_CHANNEL_ID_LOG, switch_channel_set_callstate, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_core_media_check_autoadj(), switch_core_media_check_dtls(), switch_core_session_get_channel(), switch_core_session_kill_channel, switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_ENDPOINT_DISPOSITION_VARIABLE, SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA, switch_event_create, switch_event_fire, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MESSAGE_PROGRESS_EVENT, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_ORIGINATOR_VARIABLE, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE, SWITCH_SIG_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), switch_caller_profile::times, and switch_caller_profile::uuid.

Referenced by switch_channel_perform_pre_answer().

 {
         switch_event_t *event;
 
         if (!switch_channel_test_flag(channel, CF_EARLY_MEDIA) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
                 const char *uuid;
                 switch_core_session_t *other_session;
 
                 switch_core_media_check_dtls(channel->session, SWITCH_MEDIA_TYPE_AUDIO);
 
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Pre-Answer %s!\n", channel->name);
                 switch_channel_set_flag(channel, CF_EARLY_MEDIA);
 
                 switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "EARLY MEDIA");
 
                 if (switch_true(switch_channel_get_variable(channel, "video_mirror_input"))) {
                         switch_channel_set_flag(channel, CF_VIDEO_MIRROR_INPUT);
                 }
 
                 if (channel->caller_profile && channel->caller_profile->times) {
                         switch_mutex_lock(channel->profile_mutex);
                         channel->caller_profile->times->progress_media = switch_micro_time_now();
                         if (channel->caller_profile->originator_caller_profile) {
                                 switch_core_session_t *osession;
                                 if ((osession = switch_core_session_locate(channel->caller_profile->originator_caller_profile->uuid))) {
                                         switch_channel_t *other_channel;
                                         other_channel = switch_core_session_get_channel(osession);
                                         if (other_channel->caller_profile) {
                                                 other_channel->caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
                                         }
                                         switch_core_session_rwunlock(osession);
                                 }
                                 channel->caller_profile->originator_caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
                         }
                         switch_mutex_unlock(channel->profile_mutex);
                 }
 
                 if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(channel, event);
                         switch_event_fire(&event);
                 }
 
                 switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_PRE_ANSWER_VARIABLE);
                 switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_MEDIA_VARIABLE);
 
                 switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE);
                 switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE);
 
                 if (switch_true(switch_channel_get_variable(channel, SWITCH_PASSTHRU_PTIME_MISMATCH_VARIABLE))) {
                         switch_channel_set_flag(channel, CF_PASSTHRU_PTIME_MISMATCH);
                 }
 
 
                 /* if we're the child of another channel and the other channel is in a blocking read they will never realize we have answered so send
                    a SWITCH_SIG_BREAK to interrupt any blocking reads on that channel
                  */
                 if ((uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATOR_VARIABLE))
                         && (other_session = switch_core_session_locate(uuid))) {
                         switch_core_session_kill_channel(other_session, SWITCH_SIG_BREAK);
                         switch_core_session_rwunlock(other_session);
                 }
 
                 switch_channel_set_callstate(channel, CCS_EARLY);
 
                 send_ind(channel, SWITCH_MESSAGE_PROGRESS_EVENT, file, func, line);
 
                 switch_core_media_check_autoadj(channel->session);
 
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_channel_perform_mark_ring_ready_value()

switch_status_t switch_channel_perform_mark_ring_ready_value	(	switch_channel_t *	channel,
		switch_ring_ready_t	rv,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3475 of file switch_channel.c.

References caller_profile, CCS_RINGING, CF_ANSWERED, CF_RING_READY, name, switch_caller_profile::originator_caller_profile, profile_mutex, switch_channel_timetable::progress, send_ind(), switch_channel_api_on(), SWITCH_CHANNEL_API_ON_RING_VARIABLE, switch_channel_event_set_data(), switch_channel_execute_on(), SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE, switch_channel_get_uuid(), SWITCH_CHANNEL_ID_LOG, switch_channel_set_callstate, switch_channel_set_flag_value(), switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_EVENT_CHANNEL_PROGRESS, switch_event_create, switch_event_fire, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MESSAGE_RING_EVENT, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_caller_profile::times, and switch_caller_profile::uuid.

Referenced by switch_channel_perform_ring_ready_value().

 {
         switch_event_t *event;
 
         if (!switch_channel_test_flag(channel, CF_RING_READY) && !switch_channel_test_flag(channel, CF_ANSWERED)) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Ring-Ready %s!\n", channel->name);
                 switch_channel_set_flag_value(channel, CF_RING_READY, rv);
 
                 switch_mutex_lock(channel->profile_mutex);
                 if (channel->caller_profile && channel->caller_profile->times && !channel->caller_profile->times->progress) {
                         channel->caller_profile->times->progress = switch_micro_time_now();
                         if (channel->caller_profile->originator_caller_profile) {
                                 switch_core_session_t *other_session;
                                 if ((other_session = switch_core_session_locate(channel->caller_profile->originator_caller_profile->uuid))) {
                                         switch_channel_t *other_channel;
                                         other_channel = switch_core_session_get_channel(other_session);
                                         switch_mutex_lock(other_channel->profile_mutex);
                                         if (other_channel->caller_profile && !other_channel->caller_profile->times->progress) {
                                                 other_channel->caller_profile->times->progress = channel->caller_profile->times->progress;
                                         }
                                         switch_mutex_unlock(other_channel->profile_mutex);
                                         switch_core_session_rwunlock(other_session);
                                 }
                                 channel->caller_profile->originator_caller_profile->times->progress = channel->caller_profile->times->progress;
                         }
                 }
                 switch_mutex_unlock(channel->profile_mutex);
 
                 if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_PROGRESS) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(channel, event);
                         switch_event_fire(&event);
                 }
 
                 switch_channel_execute_on(channel, SWITCH_CHANNEL_EXECUTE_ON_RING_VARIABLE);
                 switch_channel_api_on(channel, SWITCH_CHANNEL_API_ON_RING_VARIABLE);
 
                 switch_channel_set_callstate(channel, CCS_RINGING);
 
                 send_ind(channel, SWITCH_MESSAGE_RING_EVENT, file, func, line);
 
                 return SWITCH_STATUS_SUCCESS;
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_channel_perform_pre_answer()

switch_status_t switch_channel_perform_pre_answer	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3597 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CS_HANGUP, switch_core_session_message::from, hangup_cause, switch_core_session_message::message_id, name, session, state, switch_assert, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION, switch_channel_audio_sync, switch_channel_direction(), switch_channel_hangup, switch_channel_perform_mark_pre_answered(), switch_channel_test_flag(), switch_core_session_perform_receive_message(), SWITCH_MESSAGE_INDICATE_PROGRESS, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_message_t msg = { 0 };
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_assert(channel != NULL);
 
         if (channel->hangup_cause || channel->state >= CS_HANGUP) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                 msg.message_id = SWITCH_MESSAGE_INDICATE_PROGRESS;
                 msg.from = channel->name;
                 status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
         }
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 switch_channel_perform_mark_pre_answered(channel, file, func, line);
                 switch_channel_audio_sync(channel);
         } else {
                 switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
         }
 
         return status;
 }

◆ switch_channel_perform_presence()

void switch_channel_perform_presence	(	switch_channel_t *	channel,
		const char *	rpid,
		const char *	status,
		const char *	id,
		const char *	file,
		const char *	func,
		int	line
	)

Fire A presence event for the channel.

Parameters

channel	the channel to initilize
rpid	the rpid if for the icon to use
status	the status message
id	presence id

Definition at line 778 of file switch_channel.c.

References CF_ANSWERED, CF_NO_PRESENCE, CF_SLA_INTERCEPT, direction, event_count, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_event_set_data(), switch_channel_get_variable, switch_channel_test_flag(), switch_channel_up_nosig, switch_event_add_header(), switch_event_add_header_string(), switch_event_create, switch_event_fire, SWITCH_EVENT_PRESENCE_IN, SWITCH_EVENT_PRESENCE_OUT, SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, and switch_true().

 {
         switch_event_t *event;
         switch_event_types_t type = SWITCH_EVENT_PRESENCE_IN;
         const char *call_info = NULL;
         char *call_info_state = "active";
 
         if (switch_channel_test_flag(channel, CF_NO_PRESENCE)) {
                 return;
         }
 
         if (!status) {
                 type = SWITCH_EVENT_PRESENCE_OUT;
                 status = "idle";
         }
 
         if (!id) {
                 id = switch_channel_get_variable(channel, "presence_id");
         }
 
         if (!id) {
                 return;
         }
 
         call_info = switch_channel_get_variable(channel, "presence_call_info");
 
         if (switch_event_create(&event, type) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_data(channel, event);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "proto", "any");
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "login", __FILE__);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "from", id);
                 if (type == SWITCH_EVENT_PRESENCE_IN) {
                         if (!rpid) {
                                 rpid = "unknown";
                         }
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "rpid", rpid);
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "status", status);
                 }
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "event_type", "presence");
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alt_event_type", "dialog");
 
 
                 if (!strcasecmp(status, "idle") || !switch_channel_up_nosig(channel)) {
                         call_info_state = "idle";
                 } else if (!strcasecmp(status, "hold-private")) {
                         call_info_state = "held-private";
                 } else if (!strcasecmp(status, "hold")) {
                         call_info_state = "held";
                 } else if (!switch_channel_test_flag(channel, CF_ANSWERED)) {
                         if (channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND) {
                                 call_info_state = "progressing";
                         } else {
                                 if (switch_channel_test_flag(channel, CF_SLA_INTERCEPT)) {
                                         call_info_state = "idle";
                                 } else {
                                         call_info_state = "alerting";
                                 }
                         }
                 }
 
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-info-state", call_info_state);
 
                 if (call_info) {
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-info", call_info);
                 }
 
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "presence-call-direction",
                                                                            channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
 
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "event_count", "%d", channel->event_count++);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Calling-File", file);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Calling-Function", func);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Presence-Calling-Line", "%d", line);
 
                 if (switch_true(switch_channel_get_variable(channel, "presence_privacy"))) {
                         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Privacy", "true");
                 }
 
                 switch_event_fire(&event);
         }
 }

◆ switch_channel_perform_ring_ready_value()

switch_status_t switch_channel_perform_ring_ready_value	(	switch_channel_t *	channel,
		switch_ring_ready_t	rv,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3632 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CS_HANGUP, switch_core_session_message::from, hangup_cause, switch_core_session_message::message_id, name, switch_core_session_message::numeric_arg, session, state, switch_assert, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION, switch_channel_direction(), switch_channel_get_uuid(), switch_channel_hangup, SWITCH_CHANNEL_ID_LOG, switch_channel_perform_mark_ring_ready_value(), switch_channel_test_flag(), switch_core_session_perform_receive_message(), SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MESSAGE_INDICATE_RINGING, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

 {
         switch_core_session_message_t msg = { 0 };
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_assert(channel != NULL);
 
         if (channel->hangup_cause || channel->state >= CS_HANGUP) {
                 return SWITCH_STATUS_FALSE;
         }
 
         if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                 return SWITCH_STATUS_SUCCESS;
         }
 
         if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                 msg.message_id = SWITCH_MESSAGE_INDICATE_RINGING;
                 msg.from = channel->name;
                 msg.numeric_arg = rv;
                 status = switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
         }
 
         if (status == SWITCH_STATUS_SUCCESS) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_NOTICE, "Ring Ready %s!\n", channel->name);
                 switch_channel_perform_mark_ring_ready_value(channel, rv, file, func, line);
         } else {
                 switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
         }
 
         return status;
 }

◆ switch_channel_perform_set_callstate()

void switch_channel_perform_set_callstate	(	switch_channel_t *	channel,
		switch_channel_callstate_t	callstate,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 283 of file switch_channel.c.

References device_uuid_node_s::callstate, callstate, CCS_HANGUP, device_node, name, switch_channel_callstate2str(), switch_channel_check_device_state(), switch_channel_event_set_data(), switch_channel_get_uuid(), SWITCH_CHANNEL_ID_LOG, switch_event_add_header(), switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_CALLSTATE, switch_event_create, switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

 {
         switch_event_t *event;
         switch_channel_callstate_t o_callstate = channel->callstate;
 
         if (o_callstate == callstate || o_callstate == CCS_HANGUP) return;
 
         channel->callstate = callstate;
         if (channel->device_node) {
                 channel->device_node->callstate = callstate;
         }
         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG,
                                           "(%s) Callstate Change %s -> %s\n", channel->name,
                                           switch_channel_callstate2str(o_callstate), switch_channel_callstate2str(callstate));
 
         switch_channel_check_device_state(channel, channel->callstate);
 
         if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_CALLSTATE) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Original-Channel-Call-State", switch_channel_callstate2str(o_callstate));
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Call-State-Number", "%d", callstate);
                 switch_channel_event_set_data(channel, event);
                 switch_event_fire(&event);
         }
 }

◆ switch_channel_perform_set_running_state()

switch_channel_state_t switch_channel_perform_set_running_state	(	switch_channel_t *	channel,
		switch_channel_state_t	state,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 2366 of file switch_channel.c.

References careful_set(), CCS_ACTIVE, CCS_EARLY, CCS_RINGING, CF_ANSWERED, CF_EARLY_MEDIA, CF_FLAG_MAX, CF_TAGGED, CS_DESTROY, CS_HANGUP, CS_ROUTING, flag_mutex, flags, name, running_state, state_flags, state_mutex, state_names, SWITCH_CALL_DIRECTION_INBOUND, switch_channel_clear_flag(), switch_channel_direction(), switch_channel_event_set_data(), switch_channel_get_uuid(), SWITCH_CHANNEL_ID_LOG, switch_channel_set_callstate, switch_channel_test_flag(), switch_core_session_count(), switch_core_session_id(), SWITCH_EVENT_CHANNEL_STATE, switch_event_create, switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_SIZE_T_FMT, and SWITCH_STATUS_SUCCESS.

 {
         int x;
 
         switch_mutex_lock(channel->flag_mutex);
         if (channel->state_flags[0]) {
                 for (x = 1; x < CF_FLAG_MAX; x++) {
                         if (channel->state_flags[x]) {
                                 channel->flags[x] = 1;
                                 channel->state_flags[x] = 0;
                         }
                 }
                 channel->state_flags[0] = 0;
         }
         switch_mutex_unlock(channel->flag_mutex);
 
         switch_channel_clear_flag(channel, CF_TAGGED);
 
 
         switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG, "(%s) Running State Change %s (Cur %d Tot %" SWITCH_SIZE_T_FMT ")\n",
                                           channel->name, state_names[state], switch_core_session_count(), switch_core_session_id() - 1);
 
         switch_mutex_lock(channel->state_mutex);
 
         careful_set(channel, &channel->running_state, state);
 
         if (state <= CS_DESTROY) {
                 switch_event_t *event;
 
                 if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                         if (state < CS_HANGUP) {
                                 if (state == CS_ROUTING) {
                                         switch_channel_set_callstate(channel, CCS_RINGING);
                                 } else if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                                         switch_channel_set_callstate(channel, CCS_ACTIVE);
                                 } else if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                                         switch_channel_set_callstate(channel, CCS_EARLY);
                                 }
                         }
                 }
 
                 if (switch_event_create(&event, SWITCH_EVENT_CHANNEL_STATE) == SWITCH_STATUS_SUCCESS) {
                         switch_channel_event_set_data(channel, event);
                         switch_event_fire(&event);
                 }
         }
 
         switch_mutex_unlock(channel->state_mutex);
 
         return (switch_channel_state_t) SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_perform_set_state()

switch_channel_state_t switch_channel_perform_set_state	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line,
		switch_channel_state_t	state
	)

Definition at line 2419 of file switch_channel.c.

References careful_set(), CS_CONSUME_MEDIA, CS_DESTROY, CS_EXCHANGE_MEDIA, CS_EXECUTE, CS_HANGUP, CS_HIBERNATE, CS_INIT, CS_NEW, CS_PARK, CS_REPORTING, CS_RESET, CS_ROUTING, CS_SOFT_EXECUTE, hangup_cause, name, session, state, state_mutex, state_names, switch_assert, SWITCH_CAUSE_NORMAL_CLEARING, switch_channel_get_uuid(), SWITCH_CHANNEL_ID_LOG, switch_core_session_signal_state_change(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_channel_state_t last_state;
         int ok = 0;
 
         switch_assert(channel != NULL);
         switch_assert(state <= CS_DESTROY);
         switch_mutex_lock(channel->state_mutex);
 
         last_state = channel->state;
         switch_assert(last_state <= CS_DESTROY);
 
         if (last_state == state) {
                 goto done;
         }
 
         if (last_state >= CS_HANGUP && state < last_state) {
                 goto done;
         }
 
         /* STUB for more dev
            case CS_INIT:
            switch(state) {
 
            case CS_NEW:
            case CS_INIT:
            case CS_EXCHANGE_MEDIA:
            case CS_SOFT_EXECUTE:
            case CS_ROUTING:
            case CS_EXECUTE:
            case CS_HANGUP:
            case CS_DESTROY:
 
            default:
            break;
            }
            break;
          */
 
         switch (last_state) {
         case CS_NEW:
         case CS_RESET:
                 switch (state) {
                 default:
                         ok++;
                         break;
                 }
                 break;
 
         case CS_INIT:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_SOFT_EXECUTE:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_HIBERNATE:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_EXCHANGE_MEDIA:
                 switch (state) {
                 case CS_SOFT_EXECUTE:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_HIBERNATE:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_SOFT_EXECUTE:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_HIBERNATE:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_PARK:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_SOFT_EXECUTE:
                 case CS_HIBERNATE:
                 case CS_RESET:
                 case CS_CONSUME_MEDIA:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_CONSUME_MEDIA:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_SOFT_EXECUTE:
                 case CS_HIBERNATE:
                 case CS_RESET:
                 case CS_PARK:
                         ok++;
                 default:
                         break;
                 }
                 break;
         case CS_HIBERNATE:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_INIT:
                 case CS_ROUTING:
                 case CS_EXECUTE:
                 case CS_SOFT_EXECUTE:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_ROUTING:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_EXECUTE:
                 case CS_SOFT_EXECUTE:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_HIBERNATE:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_EXECUTE:
                 switch (state) {
                 case CS_EXCHANGE_MEDIA:
                 case CS_SOFT_EXECUTE:
                 case CS_ROUTING:
                 case CS_PARK:
                 case CS_CONSUME_MEDIA:
                 case CS_HIBERNATE:
                 case CS_RESET:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_HANGUP:
                 switch (state) {
                 case CS_REPORTING:
                 case CS_DESTROY:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         case CS_REPORTING:
                 switch (state) {
                 case CS_DESTROY:
                         ok++;
                 default:
                         break;
                 }
                 break;
 
         default:
                 break;
 
         }
 
         if (ok) {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_DEBUG, "(%s) State Change %s -> %s\n",
                                                   channel->name, state_names[last_state], state_names[state]);
 
                 careful_set(channel, &channel->state, state);
 
                 if (state == CS_HANGUP && !channel->hangup_cause) {
                         channel->hangup_cause = SWITCH_CAUSE_NORMAL_CLEARING;
                 }
 
                 if (state <= CS_DESTROY) {
                         switch_core_session_signal_state_change(channel->session);
                 }
         } else {
                 switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_channel_get_uuid(channel), SWITCH_LOG_WARNING,
                                                   "(%s) Invalid State Change %s -> %s\n", channel->name, state_names[last_state], state_names[state]);
                 /* we won't tolerate an invalid state change so we can make sure we are as robust as a nice cup of dark coffee! */
                 /* not cool lets crash this bad boy and figure out wtf is going on */
                 switch_assert(channel->state >= CS_HANGUP);
         }
   done:
 
         switch_mutex_unlock(channel->state_mutex);
         return channel->state;
 }

◆ switch_channel_perform_video_sync()

void switch_channel_perform_video_sync	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 384 of file switch_channel.c.

References switch_core_session_message::_file, switch_core_session_message::_func, switch_core_session_message::_line, switch_core_session_message::from, switch_core_session_message::message_id, MESSAGE_STAMP_FFL, name, session, switch_channel_media_up, switch_core_session_alloc, switch_core_session_queue_message(), switch_core_session_request_video_refresh, and SWITCH_MESSAGE_INDICATE_VIDEO_SYNC.

 {
 
         if (switch_channel_media_up(channel)) {
                 switch_core_session_message_t *msg = NULL;
 
                 msg = switch_core_session_alloc(channel->session, sizeof(*msg));
                 MESSAGE_STAMP_FFL(msg);
                 msg->message_id = SWITCH_MESSAGE_INDICATE_VIDEO_SYNC;
                 msg->from = channel->name;
                 msg->_file = file;
                 msg->_func = func;
                 msg->_line = line;
 
                 switch_core_session_request_video_refresh(channel->session);
                 switch_core_session_queue_message(channel->session, msg);
         }
 }

◆ switch_channel_process_export()

void switch_channel_process_export	(	switch_channel_t *	channel,
		switch_channel_t *	peer_channel,
		switch_event_t *	var_event,
		const char *	export_varname
	)

Definition at line 1252 of file switch_channel.c.

References session, switch_channel_get_name(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_strdup, switch_event_add_header_string(), switch_event_del_header, SWITCH_LOG_DEBUG, switch_log_printf(), switch_separate_string(), SWITCH_STACK_BOTTOM, and zstr.

Referenced by check_bridge_export(), switch_ivr_enterprise_originate(), and switch_ivr_originate().

 {
 
         const char *export_vars = switch_channel_get_variable(channel, export_varname);
         char *cptmp = switch_core_session_strdup(channel->session, export_vars);
         int argc;
         char *argv[256];
 
         if (zstr(export_vars)) return;
 
 
         if (var_event) {
                 switch_event_del_header(var_event, export_varname);
                 switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, export_varname, export_vars);
         }
 
         if (peer_channel) {
                 switch_channel_set_variable(peer_channel, export_varname, export_vars);
         }
 
         if ((argc = switch_separate_string(cptmp, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                 int x;
 
                 for (x = 0; x < argc; x++) {
                         const char *vval;
                         if ((vval = switch_channel_get_variable(channel, argv[x]))) {
                                 char *vvar = argv[x];
                                 if (!strncasecmp(vvar, "nolocal:", 8)) { /* remove this later ? */
                                         vvar += 8;
                                 } else if (!strncasecmp(vvar, "_nolocal_", 9)) {
                                         vvar += 9;
                                 }
                                 if (var_event) {
                                         switch_event_del_header(var_event, vvar);
                                         switch_event_add_header_string(var_event, SWITCH_STACK_BOTTOM, vvar, vval);
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_DEBUG,
                                                                           "%s EXPORTING[%s] [%s]=[%s] to event\n",
                                                                           switch_channel_get_name(channel),
                                                                           export_varname,
                                                                           vvar, vval);
                                 }
                                 if (peer_channel) {
                                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_DEBUG,
                                                                           "%s EXPORTING[%s] [%s]=[%s] to %s\n",
                                                                           switch_channel_get_name(channel),
                                                                           export_varname,
                                                                           vvar, vval, switch_channel_get_name(peer_channel));
                                         switch_channel_set_variable(peer_channel, vvar, vval);
                                 }
                         }
                 }
         }
 
 
 }

◆ switch_channel_queue_dtmf()

switch_status_t switch_channel_queue_dtmf	(	_In_ switch_channel_t *	channel,
		_In_ const switch_dtmf_t *	dtmf
	)

Queue DTMF on a given channel.

Parameters

channel	channel to queue DTMF to
dtmf	digit

Returns: SWITCH_STATUS_SUCCESS if successful

Referenced by inband_dtmf_callback(), speech_thread(), and switch_core_media_read_frame().

◆ switch_channel_queue_dtmf_string()

switch_status_t switch_channel_queue_dtmf_string	(	_In_ switch_channel_t *	channel,
		_In_ const char *	dtmf_string
	)

◆ switch_channel_restart()

void switch_channel_restart ( switch_channel_t * channel )

Definition at line 3123 of file switch_channel.c.

References CS_EXECUTE, CS_RESET, switch_channel_set_state, and switch_channel_wait_for_state_timeout().

Referenced by switch_channel_var_true(), and switch_ivr_originate().

 {
         switch_channel_set_state(channel, CS_RESET);
         switch_channel_wait_for_state_timeout(channel, CS_RESET, 5000);
         switch_channel_set_state(channel, CS_EXECUTE);
 }

◆ switch_channel_set_app_flag_key()

void switch_channel_set_app_flag_key	(	const char *	app,
		switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2070 of file switch_channel.c.

References app_flag_hash, flag_mutex, session, switch_assert, switch_core_hash_find(), switch_core_hash_init, switch_core_hash_insert, switch_core_session_alloc, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_media_negotiate_sdp(), switch_core_media_process_udptl(), switch_core_media_reset_t38(), and switch_ivr_eavesdrop_update_display().

 {
         uint32_t *flagp = NULL;
         switch_byte_t new = 0;
 
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->flag_mutex);
 
         if (!channel->app_flag_hash) {
                 switch_core_hash_init(&channel->app_flag_hash);
                 new++;
         }
 
         if (new || !(flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
                 flagp = switch_core_session_alloc(channel->session, sizeof(uint32_t));
                 switch_core_hash_insert(channel->app_flag_hash, key, flagp);
         }
 
         switch_assert(flagp);
         *flagp |= flags;
 
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_set_bridge_time()

void switch_channel_set_bridge_time ( switch_channel_t * channel )

Definition at line 3360 of file switch_channel.c.

References switch_channel_timetable::bridged, caller_profile, profile_mutex, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), and switch_caller_profile::times.

Referenced by signal_bridge_on_hibernate(), and switch_ivr_multi_threaded_bridge().

 {
         switch_mutex_lock(channel->profile_mutex);
         if (channel->caller_profile && channel->caller_profile->times) {
                 channel->caller_profile->times->bridged = switch_micro_time_now();
         }
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_caller_extension()

void switch_channel_set_caller_extension	(	switch_channel_t *	channel,
		switch_caller_extension_t *	caller_extension
	)

Assign a caller extension to a given channel.

Parameters

channel	channel to assign extension to
caller_extension	extension to assign

Definition at line 3333 of file switch_channel.c.

References switch_caller_profile::caller_extension, caller_profile, switch_caller_extension::next, profile_mutex, switch_assert, switch_channel_sort_cid(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by audio_bridge_thread(), recover_callback(), switch_channel_caller_extension_masquerade(), switch_channel_var_true(), and switch_core_standard_on_routing().

 {
         switch_assert(channel != NULL);
 
         switch_channel_sort_cid(channel);
 
         switch_mutex_lock(channel->profile_mutex);
         caller_extension->next = channel->caller_profile->caller_extension;
         channel->caller_profile->caller_extension = caller_extension;
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_caller_profile()

void switch_channel_set_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Set the given channel's caller profile.

Parameters

channel	channel to assign the profile to
caller_profile	the profile to assign

Definition at line 2863 of file switch_channel.c.

References switch_channel_timetable::answered, switch_caller_profile::caller_extension, caller_profile, switch_caller_profile::chan_name, switch_caller_profile::context, switch_channel_timetable::created, switch_caller_profile::direction, direction, switch_channel_timetable::hungup, switch_caller_profile::logical_direction, logical_direction, name, switch_caller_profile::next, switch_caller_profile::pool, switch_channel_timetable::profile_created, switch_caller_profile::profile_index, profile_index, profile_mutex, switch_channel_timetable::progress, switch_channel_timetable::progress_media, session, switch_assert, switch_caller_extension_clone(), switch_core_session_alloc, switch_core_session_get_uuid(), switch_core_session_strdup, switch_core_sprintf(), switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), switch_caller_profile::times, switch_channel_timetable::transferred, and switch_caller_profile::uuid.

Referenced by switch_channel_caller_extension_masquerade(), switch_channel_step_caller_profile(), switch_core_session_request_xml(), and switch_ivr_session_transfer().

 {
         char *uuid = NULL;
         switch_assert(channel != NULL);
         switch_assert(channel->session != NULL);
         switch_mutex_lock(channel->profile_mutex);
         switch_assert(caller_profile != NULL);
 
         caller_profile->direction = channel->direction;
         caller_profile->logical_direction = channel->logical_direction;
         uuid = switch_core_session_get_uuid(channel->session);
 
         if (!caller_profile->uuid || strcasecmp(caller_profile->uuid, uuid)) {
                 caller_profile->uuid = switch_core_session_strdup(channel->session, uuid);
         }
 
         if (!caller_profile->chan_name || strcasecmp(caller_profile->chan_name, channel->name)) {
                 caller_profile->chan_name = switch_core_session_strdup(channel->session, channel->name);
         }
 
         if (!caller_profile->context) {
                 caller_profile->context = switch_core_session_strdup(channel->session, "default");
         }
 
         if (!caller_profile->times) {
                 caller_profile->times = (switch_channel_timetable_t *) switch_core_session_alloc(channel->session, sizeof(*caller_profile->times));
                 caller_profile->times->profile_created = switch_micro_time_now();
         }
 
         if (channel->caller_profile && channel->caller_profile->times) {
                 channel->caller_profile->times->transferred = caller_profile->times->profile_created;
                 caller_profile->times->answered = channel->caller_profile->times->answered;
                 caller_profile->times->progress = channel->caller_profile->times->progress;
                 caller_profile->times->progress_media = channel->caller_profile->times->progress_media;
                 caller_profile->times->created = channel->caller_profile->times->created;
                 caller_profile->times->hungup = channel->caller_profile->times->hungup;
                 if (channel->caller_profile->caller_extension) {
                         switch_caller_extension_clone(&caller_profile->caller_extension, channel->caller_profile->caller_extension, caller_profile->pool);
                 }
         } else {
                 caller_profile->times->created = switch_micro_time_now();
         }
 
 
         caller_profile->next = channel->caller_profile;
         channel->caller_profile = caller_profile;
         caller_profile->profile_index = switch_core_sprintf(caller_profile->pool, "%d", ++channel->profile_index);
 
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_cap_value()

void switch_channel_set_cap_value	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap,
		uint32_t	value
	)

Definition at line 1854 of file switch_channel.c.

References caps, flag_mutex, switch_assert, switch_mutex_lock(), switch_mutex_unlock(), and value.

Referenced by switch_core_session_request_xml().

 {
         switch_assert(channel);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         channel->caps[cap] = value;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_set_direction()

void switch_channel_set_direction	(	switch_channel_t *	channel,
		switch_call_direction_t	direction
	)

Definition at line 432 of file switch_channel.c.

References direction, logical_direction, session, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_direction(), switch_channel_set_variable, and switch_core_session_in_thread().

 {
         if (!switch_core_session_in_thread(channel->session)) {
                 channel->direction = channel->logical_direction = direction;
                 switch_channel_set_variable(channel, "direction", switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
         }
 }

◆ switch_channel_set_flag_partner()

switch_bool_t switch_channel_set_flag_partner	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Set given flag(s) on a given channel's bridge partner.

Parameters

channel	channel to derive the partner channel to set flag on
flag	to set

Returns: true if the flag was set

Definition at line 1690 of file switch_channel.c.

References switch_assert, switch_channel_get_partner_uuid(), switch_channel_set_flag, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_FALSE, and SWITCH_TRUE.

Referenced by switch_channel_perform_mark_answered().

 {
         const char *uuid;
 
         switch_assert(channel != NULL);
 
         if ((uuid = switch_channel_get_partner_uuid(channel))) {
                 switch_core_session_t *session;
                 if ((session = switch_core_session_locate(uuid))) {
                         switch_channel_set_flag(switch_core_session_get_channel(session), flag);
                         switch_core_session_rwunlock(session);
                         return SWITCH_TRUE;
                 }
         }
 
         return SWITCH_FALSE;
 }

◆ switch_channel_set_flag_recursive()

void switch_channel_set_flag_recursive	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 2029 of file switch_channel.c.

References CF_OUTBOUND, CF_RECOVERED, flag_mutex, flags, switch_assert, switch_channel_set_variable, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by eavesdrop_callback(), switch_core_media_bug_add(), switch_core_media_set_video_file(), switch_ivr_multi_threaded_bridge(), switch_ivr_parse_event(), switch_ivr_record_file_event(), switch_ivr_session_echo(), switch_ivr_signal_bridge(), switch_jb_get_packet(), and text_bridge_thread().

 {
         switch_assert(channel);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         channel->flags[flag]++;
         switch_mutex_unlock(channel->flag_mutex);
 
         if (flag == CF_OUTBOUND) {
                 switch_channel_set_variable(channel, "is_outbound", "true");
         }
 
         if (flag == CF_RECOVERED) {
                 switch_channel_set_variable(channel, "recovered", "true");
         }
 }

◆ switch_channel_set_flag_value()

void switch_channel_set_flag_value	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag,
		uint32_t	value
	)

Set given flag(s) on a given channel.

Parameters

channel	channel on which to set flag
flag	or'd list of flags to set

Definition at line 1950 of file switch_channel.c.

References caller_profile, CCS_HELD, CCS_RING_WAIT, CF_ANSWERED, CF_DIALPLAN, CF_LEG_HOLDING, CF_ORIGINATOR, CF_OUTBOUND, CF_RECOVERED, CF_VIDEO, CF_VIDEO_BLANK, CF_VIDEO_DECODED_READ, CF_VIDEO_ECHO, CF_VIDEO_PASSIVE, CF_VIDEO_READY, device_node, device_uuid_node_s::direction, direction, flag_mutex, flags, hold_record, switch_channel_timetable::last_hold, logical_direction, switch_hold_record_s::next, switch_hold_record_s::on, profile_mutex, session, switch_assert, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_get_partner_uuid(), switch_channel_set_callstate, switch_channel_set_variable, switch_channel_test_flag(), switch_channel_up_nosig, switch_core_session_alloc, switch_core_session_request_video_refresh, switch_core_session_start_video_thread(), switch_core_session_strdup, switch_mutex_lock(), switch_mutex_unlock(), switch_time_now(), switch_caller_profile::times, switch_hold_record_s::uuid, and value.

Referenced by switch_channel_perform_mark_ring_ready_value(), switch_channel_var_true(), and switch_core_session_request_xml().

 {
         int HELD = 0;
         int just_set = 0;
 
         switch_assert(channel);
         switch_assert(channel->flag_mutex);
 
         switch_mutex_lock(channel->flag_mutex);
         if (flag == CF_LEG_HOLDING && !channel->flags[flag] && channel->flags[CF_ANSWERED]) {
                 HELD = 1;
         }
         if (channel->flags[flag] != value) {
                 just_set = 1;
                 channel->flags[flag] = value;
         }
         switch_mutex_unlock(channel->flag_mutex);
 
         if (flag == CF_VIDEO_READY && just_set) {
                 switch_core_session_request_video_refresh(channel->session);
         }
 
         if (flag == CF_ORIGINATOR && switch_channel_test_flag(channel, CF_ANSWERED) && switch_channel_up_nosig(channel)) {
                 switch_channel_set_callstate(channel, CCS_RING_WAIT);
         }
 
         if (flag == CF_DIALPLAN) {
                 if (channel->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                         channel->logical_direction = SWITCH_CALL_DIRECTION_OUTBOUND;
                         if (channel->device_node) {
                                 channel->device_node->direction = SWITCH_CALL_DIRECTION_INBOUND;
                         }
                 } else {
                         channel->logical_direction = SWITCH_CALL_DIRECTION_INBOUND;
                         if (channel->device_node) {
                                 channel->device_node->direction = SWITCH_CALL_DIRECTION_OUTBOUND;
                         }
                 }
         }
 
         if (HELD) {
                 switch_hold_record_t *hr;
                 const char *brto = switch_channel_get_partner_uuid(channel);
 
                 switch_channel_set_callstate(channel, CCS_HELD);
                 switch_mutex_lock(channel->profile_mutex);
                 channel->caller_profile->times->last_hold = switch_time_now();
 
                 hr = switch_core_session_alloc(channel->session, sizeof(*hr));
                 hr->on = switch_time_now();
                 if (brto) {
                         hr->uuid = switch_core_session_strdup(channel->session, brto);
                 }
 
                 if (channel->hold_record) {
                         hr->next = channel->hold_record;
                 }
                 channel->hold_record = hr;
 
                 switch_mutex_unlock(channel->profile_mutex);
         }
 
         if (flag == CF_OUTBOUND) {
                 switch_channel_set_variable(channel, "is_outbound", "true");
         }
 
         if (flag == CF_RECOVERED) {
                 switch_channel_set_variable(channel, "recovered", "true");
         }
 
         if (flag == CF_VIDEO_ECHO || flag == CF_VIDEO_BLANK || flag == CF_VIDEO_DECODED_READ || flag == CF_VIDEO_PASSIVE) {
                 switch_core_session_start_video_thread(channel->session);
         }
 
         if (flag == CF_VIDEO_DECODED_READ && channel->flags[CF_VIDEO]) {
                 switch_core_session_request_video_refresh(channel->session);
         }
 }

◆ switch_channel_set_hangup_time()

void switch_channel_set_hangup_time ( switch_channel_t * channel )

Definition at line 3370 of file switch_channel.c.

References caller_profile, switch_channel_timetable::hungup, profile_mutex, switch_micro_time_now(), switch_mutex_lock(), switch_mutex_unlock(), and switch_caller_profile::times.

Referenced by switch_core_session_hangup_state().

 {
         if (channel->caller_profile && channel->caller_profile->times && !channel->caller_profile->times->hungup) {
                 switch_mutex_lock(channel->profile_mutex);
                 channel->caller_profile->times->hungup = switch_micro_time_now();
                 switch_mutex_unlock(channel->profile_mutex);
         }
 }

◆ switch_channel_set_hunt_caller_profile()

void switch_channel_set_hunt_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Definition at line 2945 of file switch_channel.c.

References caller_profile, switch_caller_profile::direction, direction, switch_caller_profile::hunt_caller_profile, switch_caller_profile::logical_direction, logical_direction, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_execute_exten().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->caller_profile != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         channel->caller_profile->hunt_caller_profile = NULL;
         if (channel->caller_profile && caller_profile) {
                 caller_profile->direction = channel->direction;
                 caller_profile->logical_direction = channel->logical_direction;
                 channel->caller_profile->hunt_caller_profile = caller_profile;
         }
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_log_tag()

switch_status_t switch_channel_set_log_tag	(	switch_channel_t *	channel,
		const char *	tagname,
		const char *	tagvalue
	)

Definition at line 1453 of file switch_channel.c.

References log_tags, profile_mutex, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_event_del_header, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->profile_mutex);
         if (!zstr(tagname)) {
                 if (!channel->log_tags) {
                         switch_event_create_plain(&channel->log_tags, SWITCH_EVENT_CHANNEL_DATA);
                 }
                 if (zstr(tagvalue)) {
                         switch_event_del_header(channel->log_tags, tagname);
                 } else {
                         switch_event_add_header_string(channel->log_tags, SWITCH_STACK_BOTTOM, tagname, tagvalue);
                 }
                 status = SWITCH_STATUS_SUCCESS;
         }
         switch_mutex_unlock(channel->profile_mutex);
         return status;
 }

◆ switch_channel_set_name()

switch_status_t switch_channel_set_name	(	switch_channel_t *	channel,
		const char *	name
	)

Assign a name to a given channel.

Parameters

channel	channel to assign name to
name	name to assign

Returns: SWITCH_STATUS_SUCCESS if name was assigned

Definition at line 1126 of file switch_channel.c.

References name, session, switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, SWITCH_CHANNEL_NAME_VARIABLE, switch_channel_set_variable, switch_core_session_get_uuid(), switch_core_session_strdup, SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_core_session_request_xml(), and switch_ivr_originate().

 {
         const char *old = NULL;
 
         switch_assert(channel != NULL);
         if (!zstr(channel->name)) {
                 old = channel->name;
         }
         channel->name = NULL;
         if (name) {
                 char *uuid = switch_core_session_get_uuid(channel->session);
                 channel->name = switch_core_session_strdup(channel->session, name);
                 switch_channel_set_variable(channel, SWITCH_CHANNEL_NAME_VARIABLE, name);
                 if (old) {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_NOTICE, "Rename Channel %s->%s [%s]\n", old, name, uuid);
                 } else {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_NOTICE, "New Channel %s [%s]\n", name, uuid);
                 }
         }
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_set_originatee_caller_profile()

void switch_channel_set_originatee_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Set the given channel's originatee caller profile.

Parameters

channel	channel to assign the profile to
caller_profile	the profile to assign

Definition at line 2991 of file switch_channel.c.

References caller_profile, last_profile_type, LP_ORIGINATEE, switch_caller_profile::next, switch_caller_profile::originatee_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_request_xml(), switch_ivr_enterprise_originate(), switch_ivr_originate(), and switch_ivr_uuid_bridge().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->caller_profile != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (channel->caller_profile) {
                 caller_profile->next = channel->caller_profile->originatee_caller_profile;
                 channel->caller_profile->originatee_caller_profile = caller_profile;
                 channel->last_profile_type = LP_ORIGINATEE;
         }
         switch_assert(channel->caller_profile->originatee_caller_profile->next != channel->caller_profile->originatee_caller_profile);
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_origination_caller_profile()

void switch_channel_set_origination_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Set the given channel's origination caller profile.

Parameters

channel	channel to assign the profile to
caller_profile	the profile to assign

Definition at line 2961 of file switch_channel.c.

References caller_profile, switch_caller_profile::next, switch_caller_profile::origination_caller_profile, profile_mutex, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_outgoing_channel().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->caller_profile != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (channel->caller_profile) {
                 caller_profile->next = channel->caller_profile->origination_caller_profile;
                 channel->caller_profile->origination_caller_profile = caller_profile;
         }
         switch_assert(channel->caller_profile->origination_caller_profile->next != channel->caller_profile->origination_caller_profile);
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_originator_caller_profile()

void switch_channel_set_originator_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Set the given channel's originator caller profile.

Parameters

channel	channel to assign the profile to
caller_profile	the profile to assign

Definition at line 2926 of file switch_channel.c.

References caller_profile, last_profile_type, LP_ORIGINATOR, switch_caller_profile::next, switch_caller_profile::originator_caller_profile, switch_caller_profile::pool, profile_mutex, switch_assert, switch_core_alloc, switch_mutex_lock(), switch_mutex_unlock(), and switch_caller_profile::times.

Referenced by switch_core_session_outgoing_channel(), switch_core_session_request_xml(), switch_ivr_enterprise_originate(), and switch_ivr_uuid_bridge().

 {
         switch_assert(channel != NULL);
         switch_assert(channel->caller_profile != NULL);
         switch_mutex_lock(channel->profile_mutex);
 
         if (!caller_profile->times) {
                 caller_profile->times = (switch_channel_timetable_t *) switch_core_alloc(caller_profile->pool, sizeof(*caller_profile->times));
         }
 
         if (channel->caller_profile) {
                 caller_profile->next = channel->caller_profile->originator_caller_profile;
                 channel->caller_profile->originator_caller_profile = caller_profile;
                 channel->last_profile_type = LP_ORIGINATOR;
         }
         switch_assert(channel->caller_profile->originator_caller_profile->next != channel->caller_profile->originator_caller_profile);
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_set_presence_data_vals()

void switch_channel_set_presence_data_vals	(	switch_channel_t *	channel,
		const char *	presence_data_cols
	)

Takes presence_data_cols as a parameter or as a channel variable and copies them to channel profile variables.

Parameters

channel	the channel on which to set the channel profile variables
presence_data_cols	is a colon separated list of channel variables to copy to channel profile variables

Definition at line 1425 of file switch_channel.c.

References switch_channel_get_variable, switch_channel_get_variable_dup(), switch_channel_set_profile_var(), SWITCH_FALSE, switch_safe_free, switch_snprintf(), switch_split, and zstr.

 {
         char *cols[128] = { 0 };
         char header_name[128] = "";
         int col_count = 0, i = 0;
         char *data_copy = NULL;
 
         if (zstr(presence_data_cols)) {
                 presence_data_cols = switch_channel_get_variable_dup(channel, "presence_data_cols", SWITCH_FALSE, -1);
                 if (zstr(presence_data_cols)) {
                         return;
                 }
         }
 
         data_copy = strdup(presence_data_cols);
 
         col_count = switch_split(data_copy, ':', cols);
 
         for (i = 0; i < col_count; i++) {
                 const char *val = NULL;
                 switch_snprintf(header_name, sizeof(header_name), "PD-%s", cols[i]);
                 val = switch_channel_get_variable(channel, cols[i]);
                 switch_channel_set_profile_var(channel, header_name, val);
         }
 
         switch_safe_free(data_copy);
 }

◆ switch_channel_set_private()

switch_status_t switch_channel_set_private	(	switch_channel_t *	channel,
		const char *	key,
		const void *	private_info
	)

Set private data on channel.

Parameters

channel	channel on which to set data
key	unique keyname to associate your private data to
private_info	void pointer to private data

Returns: SWITCH_STATUS_SUCCESS if data was set

Remarks: set NULL to delete your private data

Definition at line 1093 of file switch_channel.c.

References private_hash, profile_mutex, switch_assert, switch_core_hash_insert_locked(), and SWITCH_STATUS_SUCCESS.

 {
         switch_assert(channel != NULL);
         switch_core_hash_insert_locked(channel->private_hash, key, private_info, channel->profile_mutex);
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_set_private_flag()

void switch_channel_set_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2048 of file switch_channel.c.

References flag_mutex, private_flags, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->flag_mutex);
         channel->private_flags |= flags;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_set_profile_var()

switch_status_t switch_channel_set_profile_var	(	switch_channel_t *	channel,
		const char *	name,
		const char *	val
	)

Set a variable on a given channel.

Parameters

channel	channel to set variable on
varname	the name of the variable
value	the value of the variable

Returns: SWITCH_STATUS_SUCCESS if successful

Definition at line 1154 of file switch_channel.c.

Referenced by switch_channel_set_presence_data_vals(), switch_ivr_originate(), and switch_ivr_set_user_xml().

 {
         char *v;
         switch_status_t status = SWITCH_STATUS_SUCCESS;
 
         switch_mutex_lock(channel->profile_mutex);
 
 
         if (!strcasecmp(name, "device_id") && !zstr(val)) {
                 const char *device_id;
                 if (!(device_id = switch_channel_set_device_id(channel, val))) {
                         /* one time setting */
                         switch_mutex_unlock(channel->profile_mutex);
                         return status;
                 }
 
                 val = device_id;
         }
 
         if (!zstr(val)) {
                 v = switch_core_strdup(channel->caller_profile->pool, val);
         } else {
                 v = SWITCH_BLANK_STRING;
         }
 
         if (!strcasecmp(name, "dialplan")) {
                 channel->caller_profile->dialplan = v;
         } else if (!strcasecmp(name, "username")) {
                 channel->caller_profile->username = v;
         } else if (!strcasecmp(name, "caller_id_name")) {
                 channel->caller_profile->caller_id_name = v;
         } else if (!strcasecmp(name, "caller_id_number")) {
                 channel->caller_profile->caller_id_number = v;
         } else if (!strcasecmp(name, "callee_id_name")) {
                 channel->caller_profile->callee_id_name = v;
         } else if (!strcasecmp(name, "callee_id_number")) {
                 channel->caller_profile->callee_id_number = v;
         } else if (val && !strcasecmp(name, "caller_ton")) {
                 channel->caller_profile->caller_ton = (uint8_t) atoi(v);
         } else if (val && !strcasecmp(name, "caller_numplan")) {
                 channel->caller_profile->caller_numplan = (uint8_t) atoi(v);
         } else if (val && !strcasecmp(name, "destination_number_ton")) {
                 channel->caller_profile->destination_number_ton = (uint8_t) atoi(v);
         } else if (val && !strcasecmp(name, "destination_number_numplan")) {
                 channel->caller_profile->destination_number_numplan = (uint8_t) atoi(v);
         } else if (!strcasecmp(name, "ani")) {
                 channel->caller_profile->ani = v;
         } else if (!strcasecmp(name, "aniii")) {
                 channel->caller_profile->aniii = v;
         } else if (!strcasecmp(name, "network_addr")) {
                 channel->caller_profile->network_addr = v;
         } else if (!strcasecmp(name, "rdnis")) {
                 channel->caller_profile->rdnis = v;
         } else if (!strcasecmp(name, "destination_number")) {
                 channel->caller_profile->destination_number = v;
         } else if (!strcasecmp(name, "uuid")) {
                 channel->caller_profile->uuid = v;
         } else if (!strcasecmp(name, "source")) {
                 channel->caller_profile->source = v;
         } else if (!strcasecmp(name, "context")) {
                 channel->caller_profile->context = v;
         } else if (!strcasecmp(name, "chan_name")) {
                 channel->caller_profile->chan_name = v;
         } else {
                 profile_node_t *pn, *n = switch_core_alloc(channel->caller_profile->pool, sizeof(*n));
                 int var_found;
 
                 n->var = switch_core_strdup(channel->caller_profile->pool, name);
                 n->val = v;
 
                 if (!channel->caller_profile->soft) {
                         channel->caller_profile->soft = n;
                 } else {
                         var_found = 0;
 
                         for(pn = channel->caller_profile->soft; pn ; pn = pn->next) {
                                 if (!strcasecmp(pn->var,n->var)) {
                                         pn->val = n->val;
                                         var_found = 1;
                                         break;
                                 }
 
                                 if(!pn->next) {
                                         break;
                                 }
                         }
 
                         if (pn && !pn->next && !var_found) {
                                 pn->next = n;
                         }
                 }
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_set_scope_variables()

void switch_channel_set_scope_variables	(	switch_channel_t *	channel,
		switch_event_t **	event
	)

Definition at line 928 of file switch_channel.c.

References switch_event::next, profile_mutex, scope_variables, switch_event_destroy(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_exec().

 {
         switch_mutex_lock(channel->profile_mutex);
 
         if (event && *event) { /* push */
                 (*event)->next = channel->scope_variables;
                 channel->scope_variables = *event;
                 *event = NULL;
         } else if (channel->scope_variables) { /* pop */
                 switch_event_t *top_event = channel->scope_variables;
                 channel->scope_variables = channel->scope_variables->next;
                 switch_event_destroy(&top_event);
         }
 
         switch_mutex_unlock(channel->profile_mutex);
 
 }

◆ switch_channel_set_state_flag()

void switch_channel_set_state_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Set given flag(s) on a given channel to be applied on the next state change.

Parameters

channel	channel on which to set flag(s)
flag	flag to set

Definition at line 2126 of file switch_channel.c.

References flag_mutex, state_flags, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_ivr_intercept_session(), switch_ivr_signal_bridge(), and switch_ivr_uuid_bridge().

 {
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->flag_mutex);
         channel->state_flags[0] = 1;
         channel->state_flags[flag] = 1;
         switch_mutex_unlock(channel->flag_mutex);
 }

◆ switch_channel_set_timestamps()

switch_status_t switch_channel_set_timestamps ( _In_ switch_channel_t * channel )

Referenced by switch_core_session_hangup_state(), and switch_ivr_originate().

◆ switch_channel_set_variable_name_printf()

switch_status_t switch_channel_set_variable_name_printf	(	switch_channel_t *	channel,
		const char *	val,
		const char *	fmt,
			...
	)

Definition at line 1626 of file switch_channel.c.

References profile_mutex, switch_assert, switch_channel_set_variable, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, and switch_vasprintf().

Referenced by switch_core_media_build_crypto(), switch_ivr_multi_threaded_bridge(), and tone_detect_set_total_time().

 {
         int ret = 0;
         char *varname;
         va_list ap;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
 
         va_start(ap, fmt);
         ret = switch_vasprintf(&varname, fmt, ap);
         va_end(ap);
 
         if (ret == -1) {
                 switch_mutex_unlock(channel->profile_mutex);
                 return SWITCH_STATUS_MEMERR;
         }
 
         status = switch_channel_set_variable(channel, varname, val);
 
         free(varname);
 
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_set_variable_partner_var_check()

switch_status_t switch_channel_set_variable_partner_var_check	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	value,
		switch_bool_t	var_check
	)

Definition at line 1656 of file switch_channel.c.

References switch_assert, switch_channel_get_partner_uuid(), switch_channel_set_variable_var_check(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

 {
         const char *uuid;
         switch_assert(channel != NULL);
 
         if (!zstr(varname)) {
                 if ((uuid = switch_channel_get_partner_uuid(channel))) {
                         switch_core_session_t *session;
                         if ((session = switch_core_session_locate(uuid))) {
                                 switch_channel_t *tchannel = switch_core_session_get_channel(session);
                                 switch_channel_set_variable_var_check(tchannel, varname, value, var_check);
                                 switch_core_session_rwunlock(session);
                         }
                         return SWITCH_STATUS_SUCCESS;
                 }
         }
 
         return SWITCH_STATUS_FALSE;
 }

◆ switch_channel_set_variable_printf()

switch_status_t switch_channel_set_variable_printf	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	fmt,
			...
	)

Definition at line 1595 of file switch_channel.c.

References profile_mutex, switch_assert, switch_channel_set_variable, switch_event_del_header, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, switch_vasprintf(), variables, and zstr.

 {
         int ret = 0;
         char *data;
         va_list ap;
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables && !zstr(varname)) {
                 switch_event_del_header(channel->variables, varname);
 
                 va_start(ap, fmt);
                 ret = switch_vasprintf(&data, fmt, ap);
                 va_end(ap);
 
                 if (ret == -1) {
                         switch_mutex_unlock(channel->profile_mutex);
                         return SWITCH_STATUS_MEMERR;
                 }
 
                 status = switch_channel_set_variable(channel, varname, data);
                 free(data);
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_set_variable_strip_quotes_var_check()

switch_status_t switch_channel_set_variable_strip_quotes_var_check	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	value,
		switch_bool_t	var_check
	)

Definition at line 1518 of file switch_channel.c.

References end_of, profile_mutex, switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, switch_event_add_header_string(), switch_event_del_header, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_safe_free, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_string_var_check_const(), variables, and zstr.

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables && !zstr(varname)) {
                 if (zstr(value)) {
                         switch_event_del_header(channel->variables, varname);
                 } else {
                         int ok = 1;
                         char *t = (char *)value;
                         char *r = (char *)value;
                         char *tmp = NULL;
 
                         if (t && *t == '"') {
                                 t++;
                                 if (end_of(t) == '"') {
                                         r = tmp = strdup(t);
                                         switch_assert(r);
                                         end_of(r) = '\0';
                                 }
                         }
 
                         if (var_check) {
                                 ok = !switch_string_var_check_const(r);
                         }
                         if (ok) {
                                 switch_event_add_header_string(channel->variables, SWITCH_STACK_BOTTOM, varname, r);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
                         }
 
                         switch_safe_free(tmp);
                 }
                 status = SWITCH_STATUS_SUCCESS;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_set_variable_var_check()

switch_status_t switch_channel_set_variable_var_check	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	value,
		switch_bool_t	var_check
	)

Definition at line 1488 of file switch_channel.c.

References profile_mutex, switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, switch_event_add_header_string(), switch_event_del_header, SWITCH_LOG_CRIT, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_string_var_check_const(), variables, and zstr.

Referenced by CoreSession::setVariable(), switch_channel_export_variable_var_check(), switch_channel_set_variable_partner_var_check(), switch_core_session_exec(), switch_ivr_originate(), and switch_ivr_session_transfer().

 {
         switch_status_t status = SWITCH_STATUS_FALSE;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables && !zstr(varname)) {
                 if (zstr(value)) {
                         switch_event_del_header(channel->variables, varname);
                 } else {
                         int ok = 1;
 
                         if (var_check) {
                                 ok = !switch_string_var_check_const(value);
                         }
                         if (ok) {
                                 switch_event_add_header_string(channel->variables, SWITCH_STACK_BOTTOM, varname, value);
                         } else {
                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_CRIT, "Invalid data (${%s} contains a variable)\n", varname);
                         }
                 }
                 status = SWITCH_STATUS_SUCCESS;
         }
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

◆ switch_channel_sort_cid()

void switch_channel_sort_cid ( switch_channel_t * channel )

Definition at line 3299 of file switch_channel.c.

References CF_BLEG, CF_DIALPLAN, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_clear_flag(), switch_channel_direction(), switch_channel_flip_cid(), switch_channel_set_flag, and switch_channel_test_flag().

Referenced by switch_channel_set_caller_extension(), and switch_channel_var_true().

 {
 
         if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND && switch_channel_test_flag(channel, CF_BLEG)) {
                 switch_channel_flip_cid(channel);
                 switch_channel_clear_flag(channel, CF_BLEG);
         } else if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND && !switch_channel_test_flag(channel, CF_DIALPLAN)) {
                 switch_channel_set_flag(channel, CF_DIALPLAN);
                 switch_channel_flip_cid(channel);
         }
 }

◆ switch_channel_state_change_pending()

int switch_channel_state_change_pending ( switch_channel_t * channel )

Definition at line 2255 of file switch_channel.c.

References running_state, session, state, switch_channel_down_nosig, and switch_core_session_in_thread().

Referenced by switch_channel_test_ready(), switch_ivr_eavesdrop_session(), and switch_ivr_originate().

 {
         if (switch_channel_down_nosig(channel) || !switch_core_session_in_thread(channel->session)) {
                 return 0;
         }
 
         return channel->running_state != channel->state;
 }

◆ switch_channel_state_name()

const char* switch_channel_state_name ( _In_ switch_channel_state_t state )

Render the name of the provided state enum.

Parameters

state state to get name of

Returns: the string representation of the state

Referenced by check_presence(), CoreSession::getState(), switch_core_session_perform_destroy(), switch_core_session_run(), switch_ivr_generate_json_cdr(), and switch_ivr_generate_xml_cdr().

◆ switch_channel_step_caller_profile()

void switch_channel_step_caller_profile ( switch_channel_t * channel )

Definition at line 2851 of file switch_channel.c.

References caller_profile, profile_mutex, session, switch_caller_profile_clone(), switch_channel_set_caller_profile(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_ivr_uuid_bridge().

 {
         switch_caller_profile_t *cp;
 
 
         switch_mutex_lock(channel->profile_mutex);
         cp = switch_caller_profile_clone(channel->session, channel->caller_profile);
         switch_mutex_unlock(channel->profile_mutex);
 
         switch_channel_set_caller_profile(channel, cp);
 }

◆ switch_channel_str2callstate()

switch_channel_callstate_t switch_channel_str2callstate ( const char * str )

Definition at line 346 of file switch_channel.c.

References switch_callstate_table::callstate, CALLSTATE_CHART, switch_cause_table::name, and SWITCH_CAUSE_NONE.

 {
         uint8_t x;
         switch_channel_callstate_t callstate = (switch_channel_callstate_t) SWITCH_CAUSE_NONE;
 
         if (*str > 47 && *str < 58) {
                 callstate = atoi(str);
         } else {
                 for (x = 0; x < (sizeof(CALLSTATE_CHART) / sizeof(struct switch_callstate_table)) - 1 && CALLSTATE_CHART[x].name; x++) {
                         if (!strcasecmp(CALLSTATE_CHART[x].name, str)) {
                                 callstate = CALLSTATE_CHART[x].callstate;
                                 break;
                         }
                 }
         }
         return callstate;
 }

◆ switch_channel_str2cause()

switch_call_cause_t switch_channel_str2cause ( _In_ const char * str )

return a cause code for a given string

Parameters

str	the string to check

Returns: the code

Referenced by fs_channel_hangup(), CoreSession::hangup(), monitor_callback(), switch_core_session_reporting_state(), switch_ivr_park(), and switch_ivr_parse_event().

◆ switch_channel_test_app_flag_key()

int switch_channel_test_app_flag_key	(	const char *	app,
		switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2110 of file switch_channel.c.

References app_flag_hash, flag_mutex, switch_assert, switch_core_hash_find(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_channel_wait_for_app_flag(), switch_core_media_negotiate_sdp(), and switch_ivr_eavesdrop_update_display().

 {
         int r = 0;
         uint32_t *flagp = NULL;
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->flag_mutex);
         if (channel->app_flag_hash && (flagp = switch_core_hash_find(channel->app_flag_hash, key))) {
                 r = (*flagp & flags);
         }
         switch_mutex_unlock(channel->flag_mutex);
 
 
         return r;
 }

◆ switch_channel_test_cap()

uint32_t switch_channel_test_cap	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

Definition at line 1874 of file switch_channel.c.

References caps, and switch_assert.

Referenced by switch_channel_test_cap_partner(), switch_core_media_gen_local_sdp(), switch_core_session_outgoing_channel(), switch_core_session_override_io_routines(), switch_core_session_send_dtmf(), switch_core_session_write_text_frame(), and switch_ivr_check_hold().

 {
         switch_assert(channel != NULL);
         return channel->caps[cap] ? 1 : 0;
 }

◆ switch_channel_test_cap_partner()

uint32_t switch_channel_test_cap_partner	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

Definition at line 1880 of file switch_channel.c.

References switch_assert, switch_channel_get_partner_uuid(), switch_channel_test_cap(), switch_core_session_get_channel(), switch_core_session_locate, and switch_core_session_rwunlock().

Referenced by switch_core_media_receive_message().

 {
         const char *uuid;
         int r = 0;
 
         switch_assert(channel != NULL);
 
         if ((uuid = switch_channel_get_partner_uuid(channel))) {
                 switch_core_session_t *session;
                 if ((session = switch_core_session_locate(uuid))) {
                         r = switch_channel_test_cap(switch_core_session_get_channel(session), cap);
                         switch_core_session_rwunlock(session);
                 }
         }
 
         return r;
 }

◆ switch_channel_test_flag()

uint32_t switch_channel_test_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Test for presence of given flag on a given channel.

Parameters

channel	channel to test
flag	to test

Returns: TRUE if flags were present

Definition at line 1677 of file switch_channel.c.

References flag_mutex, flags, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

 {
         uint32_t r = 0;
 
         switch_assert(channel != NULL);
 
         switch_mutex_lock(channel->flag_mutex);
         r = channel->flags[flag];
         switch_mutex_unlock(channel->flag_mutex);
 
         return r;
 }

◆ switch_channel_test_flag_partner()

uint32_t switch_channel_test_flag_partner	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 1708 of file switch_channel.c.

References switch_assert, switch_channel_get_partner_uuid(), switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_locate, and switch_core_session_rwunlock().

Referenced by switch_core_media_receive_message().

 {
         const char *uuid;
         int r = 0;
 
         switch_assert(channel != NULL);
 
         if ((uuid = switch_channel_get_partner_uuid(channel))) {
                 switch_core_session_t *session;
                 if ((session = switch_core_session_locate(uuid))) {
                         r = switch_channel_test_flag(switch_core_session_get_channel(session), flag);
                         switch_core_session_rwunlock(session);
                 }
         }
 
         return r;
 }

◆ switch_channel_test_private_flag()

int switch_channel_test_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 2064 of file switch_channel.c.

References private_flags, and switch_assert.

 {
         switch_assert(channel != NULL);
         return (channel->private_flags & flags);
 }

◆ switch_channel_test_ready()

int switch_channel_test_ready	(	switch_channel_t *	channel,
		switch_bool_t	check_ready,
		switch_bool_t	check_media
	)

Determine if a channel is ready for io.

Parameters

channel channel to test

Returns: true if the channel is ready

Definition at line 2270 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CF_NOT_READY, CF_PROXY_MODE, CF_TRANSFER, CS_HANGUP, CS_RESET, CS_ROUTING, hangup_cause, session, state, switch_assert, switch_channel_check_signal(), switch_channel_state_change_pending(), switch_channel_test_flag(), switch_core_session_get_read_codec(), switch_core_session_get_write_codec(), and SWITCH_TRUE.

 {
         int ret = 0;
 
         switch_assert(channel != NULL);
 
         switch_channel_check_signal(channel, SWITCH_TRUE);
 
         if (check_media) {
                 ret = ((switch_channel_test_flag(channel, CF_ANSWERED) ||
                                 switch_channel_test_flag(channel, CF_EARLY_MEDIA)) && !switch_channel_test_flag(channel, CF_PROXY_MODE) &&
                            switch_core_session_get_read_codec(channel->session) && switch_core_session_get_write_codec(channel->session));
 
 
                 if (!ret)
                         return ret;
         }
 
         if (!check_ready)
                 return ret;
 
         ret = 0;
 
         if (!channel->hangup_cause && channel->state > CS_ROUTING && channel->state < CS_HANGUP && channel->state != CS_RESET &&
                 !switch_channel_test_flag(channel, CF_TRANSFER) && !switch_channel_test_flag(channel, CF_NOT_READY) &&
                 !switch_channel_state_change_pending(channel)) {
                 ret++;
         }
 
 
 
         return ret;
 }

◆ switch_channel_transfer_variable_prefix()

switch_status_t switch_channel_transfer_variable_prefix	(	switch_channel_t *	orig_channel,
		switch_channel_t *	new_channel,
		const char *	prefix
	)

Definition at line 1404 of file switch_channel.c.

References switch_event_header::name, switch_event_header::next, switch_channel_set_variable, switch_channel_variable_first(), switch_channel_variable_last(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_event_header::value, and zstr.

Referenced by switch_ivr_transfer_recordings().

 {
         switch_event_header_t *hi = NULL;
         int x = 0;
 
         if ((hi = switch_channel_variable_first(orig_channel))) {
                 for (; hi; hi = hi->next) {
                         char *var = hi->name;
                         char *val = hi->value;
 
                         if (zstr(prefix) || !strncasecmp(var, prefix, strlen(prefix))) {
                                 x++;
                                 switch_channel_set_variable(new_channel, var, val);
                         }
                 }
                 switch_channel_variable_last(orig_channel);
         }
 
         return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

◆ switch_channel_try_dtmf_lock()

switch_status_t switch_channel_try_dtmf_lock ( switch_channel_t * channel )

Definition at line 482 of file switch_channel.c.

References dtmf_mutex, and switch_mutex_trylock().

 {
         return switch_mutex_trylock(channel->dtmf_mutex);
 }

◆ switch_channel_uninit()

void switch_channel_uninit ( switch_channel_t * channel )

Uninitalize a channel.

Parameters

channel the channel to uninit

Definition at line 740 of file switch_channel.c.

References api_list, app_flag_hash, app_list, dtmf_log_queue, log_tags, private_hash, profile_mutex, switch_channel_flush_dtmf(), switch_core_hash_destroy(), switch_event_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_safe_free, SWITCH_STATUS_SUCCESS, var_list, and variables.

Referenced by switch_core_session_perform_destroy().

 {
         void *pop;
         switch_channel_flush_dtmf(channel);
         while (switch_queue_trypop(channel->dtmf_log_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 switch_safe_free(pop);
         }
 
         if (channel->private_hash) {
                 switch_core_hash_destroy(&channel->private_hash);
         }
 
         if (channel->app_flag_hash) {
                 switch_core_hash_destroy(&channel->app_flag_hash);
         }
 
         switch_mutex_lock(channel->profile_mutex);
         switch_event_destroy(&channel->variables);
         switch_event_destroy(&channel->api_list);
         switch_event_destroy(&channel->var_list);
         switch_event_destroy(&channel->app_list);
         if (channel->log_tags) {
                 switch_event_destroy(&channel->log_tags);
         }
         switch_mutex_unlock(channel->profile_mutex);
 }

◆ switch_channel_var_false()

static int switch_channel_var_false	(	switch_channel_t *	channel,
		const char *	variable
	)

inlinestatic

Definition at line 350 of file switch_channel.h.

References switch_channel_get_variable_dup(), SWITCH_FALSE, and switch_false().

Referenced by switch_core_media_build_crypto().

                                                                                             {
         return switch_false(switch_channel_get_variable_dup(channel, variable, SWITCH_FALSE, -1));
 }

◆ switch_channel_var_true()

static int switch_channel_var_true	(	switch_channel_t *	channel,
		const char *	variable
	)

inlinestatic

Definition at line 354 of file switch_channel.h.

References switch_channel_caller_extension_masquerade(), switch_channel_flip_cid(), switch_channel_get_caller_extension(), switch_channel_get_variable_dup(), switch_channel_invert_cid(), switch_channel_restart(), switch_channel_set_caller_extension(), switch_channel_set_flag_value(), switch_channel_sort_cid(), switch_channel_test_flag(), switch_channel_variable_first(), switch_channel_variable_last(), SWITCH_DECLARE, SWITCH_FALSE, switch_true(), and value.

Referenced by check_dtls_reinvite(), gen_ice(), generate_m(), CoreSession::getDigits(), recover_callback(), switch_core_media_activate_rtp(), switch_core_media_build_crypto(), switch_core_media_gen_local_sdp(), switch_core_media_negotiate_sdp(), switch_core_media_set_r_sdp_codec_string(), switch_core_media_set_smode(), switch_core_session_apply_crypto(), switch_core_session_passthru(), switch_determine_ice_type(), switch_ivr_originate(), switch_ivr_play_and_detect_speech(), switch_ivr_session_echo(), switch_jb_set_session(), switch_rtp_dequeue_dtmf(), and text_helper_thread().

                                                                                            {
         return switch_true(switch_channel_get_variable_dup(channel, variable, SWITCH_FALSE, -1));
 }

◆ switch_channel_variable_first()

switch_event_header_t* switch_channel_variable_first ( switch_channel_t * channel )

Start iterating over the entries in the channel variable list.

Parameters

channel the channel to iterate the variables for

Remarks: This function locks the profile mutex, use switch_channel_variable_last to unlock

Definition at line 1078 of file switch_channel.c.

References switch_event::headers, profile_mutex, switch_assert, switch_mutex_lock(), switch_mutex_unlock(), variables, and vi.

Referenced by switch_channel_build_param_string(), switch_channel_transfer_variable_prefix(), switch_channel_var_true(), switch_ivr_originate(), switch_ivr_set_json_chan_vars(), and switch_ivr_set_xml_chan_vars().

 {
         switch_event_header_t *hi = NULL;
 
         switch_assert(channel != NULL);
         switch_mutex_lock(channel->profile_mutex);
         if (channel->variables && (hi = channel->variables->headers)) {
                 channel->vi = 1;
         } else {
                 switch_mutex_unlock(channel->profile_mutex);
         }
 
         return hi;
 }

◆ switch_channel_variable_last()

void switch_channel_variable_last ( switch_channel_t * channel )

Stop iterating over channel variables.

Remarks: Unlocks the profile mutex initially locked in switch_channel_variable_first

Definition at line 1067 of file switch_channel.c.

References profile_mutex, switch_assert, switch_mutex_unlock(), and vi.

Referenced by switch_channel_build_param_string(), switch_channel_transfer_variable_prefix(), switch_channel_var_true(), switch_ivr_originate(), switch_ivr_set_json_chan_vars(), and switch_ivr_set_xml_chan_vars().

 {
         switch_assert(channel != NULL);
         if (!channel->vi) {
                 return;
         }
         channel->vi = 0;
         switch_mutex_unlock(channel->profile_mutex);
 
 }

◆ switch_channel_wait_for_app_flag()

switch_status_t switch_channel_wait_for_app_flag	(	switch_channel_t *	channel,
		uint32_t	app_flag,
		const char *	key,
		switch_bool_t	pres,
		uint32_t	to
	)

Definition at line 1818 of file switch_channel.c.

References switch_channel_down, switch_channel_test_app_flag_key(), and switch_cond_next().

Referenced by switch_core_media_negotiate_sdp().

 {
         int r = 0;
         
         if (to) {
                 to++;
         }
 
         for (;;) {
                 if (pres) {
                         if ((r = switch_channel_test_app_flag_key(key, channel, app_flag))) {
                                 break;
                         }
                 } else {
                         if (!(r = switch_channel_test_app_flag_key(key, channel, app_flag))) {
                                 break;
                         }
                 }
 
                 switch_cond_next();
 
                 if (switch_channel_down(channel)) {
                         return r;
                 }
 
                 if (to && !--to) {
                         return r;
                 }
         }
 
         return r;
 }

◆ switch_channel_wait_for_flag()

switch_status_t switch_channel_wait_for_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	want_flag,
		switch_bool_t	pres,
		uint32_t	to,
		switch_channel_t *	super_channel
	)

Definition at line 1780 of file switch_channel.c.

References switch_channel_down, switch_channel_ready, switch_channel_test_flag(), switch_cond_next(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and SWITCH_STATUS_TIMEOUT.

Referenced by audio_bridge_thread(), switch_core_media_toggle_hold(), switch_core_session_run(), switch_core_standard_on_reset(), switch_ivr_3p_media(), switch_ivr_3p_nomedia(), switch_ivr_bridge_bleg(), switch_ivr_media(), switch_ivr_multi_threaded_bridge(), switch_ivr_nomedia(), switch_ivr_parse_event(), and switch_ivr_unhold().

 {
 
         if (to) {
                 to++;
         }
 
         for (;;) {
                 if (pres) {
                         if (switch_channel_test_flag(channel, want_flag)) {
                                 break;
                         }
                 } else {
                         if (!switch_channel_test_flag(channel, want_flag)) {
                                 break;
                         }
                 }
 
                 switch_cond_next();
 
                 if (super_channel && !switch_channel_ready(super_channel)) {
                         return SWITCH_STATUS_FALSE;
                 }
 
                 if (switch_channel_down(channel)) {
                         return SWITCH_STATUS_FALSE;
                 }
 
                 if (to && !--to) {
                         return SWITCH_STATUS_TIMEOUT;
                 }
         }
 
         return SWITCH_STATUS_SUCCESS;
 }

◆ switch_channel_wait_for_state()

void switch_channel_wait_for_state	(	switch_channel_t *	channel,
		switch_channel_t *	other_channel,
		switch_channel_state_t	want_state
	)

Definition at line 1744 of file switch_channel.c.

References CS_HANGUP, running_state, state, switch_assert, switch_channel_down, switch_channel_down_nosig, and switch_cond_next().

Referenced by CoreSession::CoreSession(), switch_ivr_3p_nomedia(), switch_ivr_multi_threaded_bridge(), and switch_ivr_nomedia().

 {
 
         switch_assert(channel);
 
         for (;;) {
                 if ((channel->state < CS_HANGUP && channel->state == channel->running_state && channel->running_state == want_state) ||
                         (other_channel && switch_channel_down_nosig(other_channel)) || switch_channel_down(channel)) {
                         break;
                 }
                 switch_cond_next();
         }
 }

◆ switch_channel_wait_for_state_timeout()

void switch_channel_wait_for_state_timeout	(	switch_channel_t *	other_channel,
		switch_channel_state_t	want_state,
		uint32_t	timeout
	)

Definition at line 1759 of file switch_channel.c.

References count, CS_HANGUP, running_state, state, switch_channel_check_signal(), switch_cond_next(), and SWITCH_TRUE.

Referenced by switch_channel_restart(), switch_core_standard_on_reset(), and switch_ivr_originate().

 {
 
         uint32_t count = 0;
 
         for (;;) {
 
                 if ((channel->state == channel->running_state && channel->running_state == want_state) || channel->state >= CS_HANGUP) {
                         break;
                 }
 
                 switch_channel_check_signal(channel, SWITCH_TRUE);
 
                 switch_cond_next();
 
                 if (++count >= timeout) {
                         break;
                 }
         }
 }

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ switch_channel_acknowledge_call

◆ switch_channel_answer

◆ switch_channel_audio_sync

◆ switch_channel_clear_app_flag

◆ switch_channel_down

◆ switch_channel_down_nosig

◆ switch_channel_expand_variables

◆ switch_channel_export_variable

◆ switch_channel_get_variable

◆ switch_channel_hangup

◆ switch_channel_inbound_display

◆ switch_channel_mark_answered

◆ switch_channel_mark_pre_answered

◆ switch_channel_mark_ring_ready

◆ switch_channel_mark_ring_ready_value

◆ switch_channel_media_ack

◆ switch_channel_media_ready

◆ switch_channel_media_up

◆ switch_channel_outbound_display

◆ switch_channel_pre_answer

◆ switch_channel_presence

◆ switch_channel_ready

◆ switch_channel_ring_ready

◆ switch_channel_ring_ready_value

◆ switch_channel_set_app_flag

◆ switch_channel_set_callstate

◆ switch_channel_set_cap

◆ switch_channel_set_flag

◆ switch_channel_set_running_state

◆ switch_channel_set_state

◆ switch_channel_set_variable

◆ switch_channel_set_variable_partner

◆ switch_channel_set_variable_safe

◆ switch_channel_set_variable_strip_quotes

◆ switch_channel_stop_broadcast

◆ switch_channel_test_app_flag

◆ switch_channel_text_only

◆ switch_channel_up

◆ switch_channel_up_nosig

◆ switch_channel_video_sync

Function Documentation

◆ switch_channel_add_state_handler()

◆ switch_channel_add_variable_var_check()

◆ switch_channel_alloc()

◆ switch_channel_build_param_string()

◆ switch_channel_caller_extension_masquerade()

◆ switch_channel_callstate2str()

◆ switch_channel_cause2str()

◆ switch_channel_cause_q850()

◆ switch_channel_check_signal()

◆ switch_channel_clear_app_flag_key()

◆ switch_channel_clear_cap()

◆ switch_channel_clear_flag()

◆ switch_channel_clear_flag_partner()

◆ switch_channel_clear_flag_recursive()

◆ switch_channel_clear_private_flag()

◆ switch_channel_clear_state_flag()

◆ switch_channel_clear_state_handler()

◆ switch_channel_del_variable_prefix()

◆ switch_channel_dequeue_dtmf()

◆ switch_channel_dequeue_dtmf_string()

◆ switch_channel_direction()

◆ switch_channel_dtmf_lock()

◆ switch_channel_dtmf_unlock()

◆ switch_channel_event_set_basic_data()

◆ switch_channel_event_set_data()

◆ switch_channel_event_set_extended_data()

◆ switch_channel_expand_variables_check()

◆ switch_channel_export_variable_printf()

◆ switch_channel_export_variable_var_check()

◆ switch_channel_flip_cid()

◆ switch_channel_flush_dtmf()

◆ switch_channel_get_caller_extension()

◆ switch_channel_get_caller_profile()

◆ switch_channel_get_callstate()

◆ switch_channel_get_cap_string()