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

switch_status_t	switch_channel_get_variables (switch_channel_t channel, switch_event_t *event)

switch_status_t	switch_channel_pass_callee_id (switch_channel_t channel, switch_channel_t other_channel)

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)

void	switch_channel_check_zrtp (switch_channel_t *channel)

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

#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 426 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(), and switch_ivr_process_indications().

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

Definition at line 626 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_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_parse_event(), switch_ivr_play_file(), switch_ivr_session_transfer(), switch_ivr_sleep(), and switch_ivr_speak_text_handle().

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

Definition at line 639 of file switch_channel.h.

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

Definition at line 89 of file switch_channel.h.

Referenced by CoreSession::hangupState(), switch_channel_wait_for_flag(), switch_channel_wait_for_state(), switch_core_media_activate_rtp(), switch_core_media_patch_sdp(), switch_core_media_receive_message(), switch_core_media_set_outgoing_bitrate(), switch_core_media_start_udptl(), switch_core_session_read_frame(), switch_core_session_recv_dtmf(), switch_core_session_send_dtmf(), switch_core_session_send_dtmf_string(), switch_core_session_video_reinit(), switch_core_session_write_frame(), switch_core_session_write_video_frame(), and uuid_bridge_on_soft_execute().

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

Definition at line 92 of file switch_channel.h.

Referenced by audio_bridge_thread(), check_channel_status(), record_callback(), recording_thread(), speech_thread(), switch_channel_event_set_basic_data(), switch_channel_state_change_pending(), switch_channel_wait_for_state(), switch_core_session_execute_application_get_flags(), switch_core_session_perform_receive_message(), switch_core_session_read_lock(), switch_core_session_read_video_frame(), switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_signal_bridge(), switch_ivr_uuid_bridge(), and uuid_bridge_on_soft_execute().

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

Definition at line 613 of file switch_channel.h.

Referenced by exec_app(), play_and_collect(), record_callback(), switch_channel_get_hold_music(), switch_core_session_exec(), switch_core_standard_on_routing(), switch_ivr_phrase_macro_event(), and switch_ivr_record_file().

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

Definition at line 300 of file switch_channel.h.

Referenced by switch_channel_export_variable_printf().

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

Definition at line 314 of file switch_channel.h.

#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 548 of file switch_channel.h.

Referenced by abort_call(), audio_bridge_on_exchange_media(), audio_bridge_thread(), check_channel_status(), check_per_channel_timeouts(), 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_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_var_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(), switch_ivr_record_session(), switch_ivr_session_transfer(), switch_ivr_signal_bridge(), switch_ivr_wait_for_answer(), SWITCH_STANDARD_SCHED_FUNC(), and uuid_bridge_on_soft_execute().

#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 615 of file switch_channel.h.

Referenced by switch_ivr_uuid_bridge().

#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 433 of file switch_channel.h.

#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 440 of file switch_channel.h.

#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 475 of file switch_channel.h.

#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 478 of file switch_channel.h.

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

#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))

Definition at line 86 of file switch_channel.h.

Referenced by audio_bridge_thread(), switch_channel_perform_audio_sync(), switch_channel_perform_video_sync(), switch_core_media_check_dtls(), switch_core_session_execute_application_get_flags(), switch_ivr_displace_session(), switch_ivr_eavesdrop_session(), switch_ivr_inband_dtmf_generate_session(), switch_ivr_parse_all_events(), switch_ivr_record_session(), switch_ivr_uuid_bridge(), and video_helper_thread().

#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 617 of file switch_channel.h.

Referenced by switch_ivr_uuid_bridge().

#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 468 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(), switch_ivr_record_session(), switch_ivr_session_audio(), switch_ivr_session_echo(), switch_ivr_speak_text(), switch_ivr_speak_text_handle(), and switch_ivr_tone_detect_session().

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

Definition at line 184 of file switch_channel.h.

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

#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_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_detect_speech(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_sound_test(), switch_ivr_speak_text_handle(), switch_ivr_wait_for_answer(), switch_ivr_wait_for_silence(), switch_play_and_get_digits(), and uuid_bridge_on_soft_execute().

#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 450 of file switch_channel.h.

Referenced by check_channel_status(), and switch_ivr_process_indications().

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

Definition at line 451 of file switch_channel.h.

Referenced by check_channel_status().

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

Definition at line 638 of file switch_channel.h.

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

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

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

Definition at line 375 of file switch_channel.h.

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

Definition at line 370 of file switch_channel.h.

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

Definition at line 107 of file switch_channel.h.

Referenced by switch_core_session_destroy_state(), and switch_core_session_run().

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

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

Definition at line 288 of file switch_channel.h.

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

Definition at line 289 of file switch_channel.h.

Referenced by switch_channel_perform_hangup().

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

Definition at line 287 of file switch_channel.h.

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

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

Definition at line 640 of file switch_channel.h.

#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(), and switch_ivr_eavesdrop_session().

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

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

Definition at line 628 of file switch_channel.h.

Referenced by switch_core_media_set_video_file().

Function Documentation

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 2889 of file switch_channel.c.

References 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_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 1447 of file switch_channel.c.

References 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_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_string_var_check_const(), 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_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().

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_caller_extension_masquerade	(	switch_channel_t *	orig_channel,
		switch_channel_t *	new_channel,
		uint32_t	offset
	)

Definition at line 2985 of file switch_channel.c.

References switch_caller_application::application_data, switch_caller_application::application_name, switch_caller_profile::destination_number, switch_event_header::name, switch_event_header::next, switch_caller_application::next, switch_caller_profile::pool, 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, and switch_event_header::value.

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

const char* switch_channel_callstate2str ( switch_channel_callstate_t callstate )

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

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_originate(), switch_ivr_multi_threaded_bridge(), and switch_ivr_originate().

switch_call_cause_t switch_channel_cause_q850 ( switch_call_cause_t cause )

Definition at line 392 of file switch_channel.c.

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

int switch_channel_check_signal	(	switch_channel_t *	channel,
		switch_bool_t	in_thread_only
	)

Definition at line 2114 of file switch_channel.c.

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

void switch_channel_check_zrtp ( switch_channel_t * channel )

Definition at line 3353 of file switch_channel.c.

References CF_ZRTP_HASH, CF_ZRTP_PASSTHRU, CF_ZRTP_PASSTHRU_REQ, switch_channel_clear_flag(), switch_channel_get_name(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_partner, switch_core_session_rwunlock(), SWITCH_LOG_INFO, switch_log_printf(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_perform_mark_answered(), and switch_channel_perform_mark_pre_answered().

 {
 
         if (!switch_channel_test_flag(channel, CF_ZRTP_PASSTHRU)
                 && switch_channel_test_flag(channel, CF_ZRTP_PASSTHRU_REQ)
                 && switch_channel_test_flag(channel, CF_ZRTP_HASH)) {
                 switch_core_session_t *other_session;
                 switch_channel_t *other_channel;
                 int doit = 1;
                 
                 if (switch_core_session_get_partner(channel->session, &other_session) == SWITCH_STATUS_SUCCESS) {
                         other_channel = switch_core_session_get_channel(other_session);
 
                         if (switch_channel_test_flag(other_channel, CF_ZRTP_HASH) && !switch_channel_test_flag(other_channel, CF_ZRTP_PASSTHRU)) {
                                 
                                 switch_channel_set_flag(channel, CF_ZRTP_PASSTHRU);
                                 switch_channel_set_flag(other_channel, CF_ZRTP_PASSTHRU);
                         
                                 switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_INFO, 
                                                                   "%s Activating ZRTP passthru mode.\n", switch_channel_get_name(channel));
         
                                 switch_channel_set_variable(channel, "zrtp_passthru_active", "true");
                                 switch_channel_set_variable(other_channel, "zrtp_passthru_active", "true");
                                 switch_channel_set_variable(channel, "zrtp_secure_media", "false");
                                 switch_channel_set_variable(other_channel, "zrtp_secure_media", "false");
                                 doit = 0;
                         }
 
                         switch_core_session_rwunlock(other_session);
                 }
 
                 if (doit) {
                         switch_channel_set_variable(channel, "zrtp_passthru_active", "false");
                         switch_channel_set_variable(channel, "zrtp_secure_media", "true");
                         switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(channel->session), SWITCH_LOG_INFO, 
                                                           "%s ZRTP not negotiated on both sides; disabling ZRTP passthru mode.\n", switch_channel_get_name(channel));
 
                         switch_channel_clear_flag(channel, CF_ZRTP_PASSTHRU);
                         switch_channel_clear_flag(channel, CF_ZRTP_HASH);
 
                         if (switch_core_session_get_partner(channel->session, &other_session) == SWITCH_STATUS_SUCCESS) {
                                 other_channel = switch_core_session_get_channel(other_session);  
 
                                 switch_channel_set_variable(other_channel, "zrtp_passthru_active", "false");
                                 switch_channel_set_variable(other_channel, "zrtp_secure_media", "true");
                                 switch_channel_clear_flag(other_channel, CF_ZRTP_PASSTHRU);
                                 switch_channel_clear_flag(other_channel, CF_ZRTP_HASH);
                                 
                                 switch_core_session_rwunlock(other_session);
                         }
 
                 }
         }
 }

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

Definition at line 1944 of file switch_channel.c.

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

Referenced by switch_core_media_negotiate_sdp(), 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);
 }

void switch_channel_clear_cap	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

Definition at line 1714 of file switch_channel.c.

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

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 1995 of file switch_channel.c.

References CCS_ACTIVE, CCS_UNHELD, CF_ANSWERED, CF_BRIDGED, CF_DIALPLAN, CF_LEG_HOLDING, CF_ORIGINATOR, CF_OUTBOUND, CF_PROXY_MODE, CF_RECOVERED, CF_RECOVERING, CF_VIDEO, CF_VIDEO_PASSIVE, CF_VIDEO_READY, 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(), and switch_time_now().

 {
         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_core_recovery_track(channel->session);
         }
 
 }

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

void switch_channel_clear_flag_recursive	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 2069 of file switch_channel.c.

References CF_OUTBOUND, 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(), and switch_ivr_record_file().

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

void switch_channel_clear_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 1906 of file switch_channel.c.

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

void switch_channel_clear_state_flag	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 1986 of file switch_channel.c.

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

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 2932 of file switch_channel.c.

References SSH_FLAG_STICKY, 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);
 }

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

Definition at line 1345 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_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(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

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_call_direction_t switch_channel_direction ( switch_channel_t * channel )

Definition at line 427 of file switch_channel.c.

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_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(), switch_rtp_add_crypto_key(), switch_rtp_create(), and switch_rtp_zerocopy_read_frame().

 {
         return channel->direction;
 }

switch_status_t switch_channel_dtmf_lock ( switch_channel_t * channel )

Definition at line 464 of file switch_channel.c.

References switch_mutex_lock().

Referenced by switch_core_session_read_frame().

 {
         return switch_mutex_lock(channel->dtmf_mutex);
 }

switch_status_t switch_channel_dtmf_unlock ( switch_channel_t * channel )

Definition at line 474 of file switch_channel.c.

References switch_mutex_unlock().

Referenced by switch_core_session_read_frame().

 {
         return switch_mutex_unlock(channel->dtmf_mutex);
 }

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

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

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.

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 3839 of file switch_channel.c.

References switch_stream_handle::data, end_of_p, in, memset(), resize, SCF_API_EXPANSION, 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) == '\\') {
                                         *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) {
                                 *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>";
                                                 } 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 (len + 1 >= olen) {
                                 resize(1);
                         }
 
                         if (sp) {
                                 *c++ = ' ';
                                 sp = 0;
                                 len++;
                         }
 
                         if (*p == '$') {
                                 p--;
                         } else {
                                 *c++ = *p;
                                 len++;
                         }
                 }
         }
         free(indup);
 
         return data;
 }

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 1319 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_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 1271 of file switch_channel.c.

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

void switch_channel_flip_cid ( switch_channel_t * channel )

Definition at line 3082 of file switch_channel.c.

References CF_BRIDGED, 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, and switch_str_nil.

Referenced by switch_channel_sort_cid(), and switch_ivr_uuid_bridge().

 {
         switch_event_t *event;
         const char *tmp = NULL;
 
         switch_mutex_lock(channel->profile_mutex);
         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_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
                                           );
 
 }

void switch_channel_flush_dtmf ( _In_ switch_channel_t * channel )

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

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 3184 of file switch_channel.c.

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

Referenced by switch_channel_caller_extension_masquerade(), 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_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 2760 of file switch_channel.c.

References switch_caller_profile::hunt_caller_profile, 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_callstate_t switch_channel_get_callstate ( switch_channel_t * channel )

Definition at line 296 of file switch_channel.c.

Referenced by switch_core_session_read_frame(), and switch_ivr_hold_toggle_uuid().

 {
         return channel->callstate;
 }

char* switch_channel_get_cap_string ( switch_channel_t * channel )

Definition at line 1774 of file switch_channel.c.

References CC_FLAG_MAX, switch_stream_handle::data, end_of, 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_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_call_cause_t* switch_channel_get_cause_ptr ( switch_channel_t * channel )

Definition at line 231 of file switch_channel.c.

 {
         return &channel->hangup_cause;
 }

switch_call_cause_t switch_channel_get_cause_q850 ( switch_channel_t * channel )

Definition at line 401 of file switch_channel.c.

References switch_channel_cause_q850().

Referenced by switch_core_session_hangup_state().

 {
         return switch_channel_cause_q850(channel->hangup_cause);
 }

char* switch_channel_get_flag_string ( switch_channel_t * channel )

Definition at line 1748 of file switch_channel.c.

References CF_FLAG_MAX, switch_stream_handle::data, end_of, 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;
 
 }

const char* switch_channel_get_hold_music ( switch_channel_t * channel )

Definition at line 874 of file switch_channel.c.

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

const char* switch_channel_get_hold_music_partner ( switch_channel_t * channel )

Definition at line 895 of file switch_channel.c.

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

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 1110 of file switch_channel.c.

References switch_assert, and zstr.

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

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 2868 of file switch_channel.c.

References switch_caller_profile::originatee_caller_profile, 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_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 2822 of file switch_channel.c.

References switch_caller_profile::origination_caller_profile, 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_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 2853 of file switch_channel.c.

References switch_caller_profile::originator_caller_profile, 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;
 }

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 1062 of file switch_channel.c.

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

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

Definition at line 1070 of file switch_channel.c.

References 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_state_t switch_channel_get_running_state ( switch_channel_t * channel )

Definition at line 2095 of file switch_channel.c.

References 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_status_t switch_channel_get_scope_variables	(	switch_channel_t *	channel,
		switch_event_t **	event
	)

Definition at line 926 of file switch_channel.c.

References ep, switch_event::headers, switch_event_header::name, switch_event_header::next, switch_event::next, 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_core_session_t* switch_channel_get_session ( switch_channel_t * channel )

Definition at line 4298 of file switch_channel.c.

References switch_assert.

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

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 2085 of file switch_channel.c.

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

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 2915 of file switch_channel.c.

References 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_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..)

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 2882 of file switch_channel.c.

References 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(), and switch_rtp_add_crypto_key().

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

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 953 of file switch_channel.c.

References ep, switch_event::next, switch_caller_profile::originatee_caller_profile, switch_caller_profile::originator_caller_profile, 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(), and zstr.

Referenced by audio_bridge_thread(), check_jb_sync(), switch_channel_event_set_basic_data(), switch_channel_expand_variables_check(), switch_channel_queue_dtmf(), switch_channel_set_presence_data_vals(), switch_core_media_gen_local_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;
 }

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

Definition at line 1005 of file switch_channel.c.

References 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_gen_local_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_status_t switch_channel_get_variables	(	switch_channel_t *	channel,
		switch_event_t **	event
	)

Definition at line 4285 of file switch_channel.c.

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

Referenced by api_hook(), 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_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(), switch_ivr_session_echo(), switch_ivr_sleep(), switch_ivr_speak_text_handle(), and switch_ivr_wait_for_answer().

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 747 of file switch_channel.c.

References CS_NONE, 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;
 }

void switch_channel_invert_cid ( switch_channel_t * channel )

Definition at line 3052 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_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_call_direction_t switch_channel_logical_direction ( switch_channel_t * channel )

Definition at line 432 of file switch_channel.c.

 {
         return channel->logical_direction;
 }

void switch_channel_mark_hold	(	switch_channel_t *	channel,
		switch_bool_t	on
	)

Definition at line 841 of file switch_channel.c.

References CF_LEG_HOLDING, switch_channel_clear_flag(), switch_channel_event_set_data(), switch_channel_get_variable, switch_channel_set_flag, switch_channel_test_flag(), switch_core_media_bug_transfer_recordings(), switch_core_session_get_partner, switch_core_session_rwunlock(), SWITCH_EVENT_CHANNEL_HOLD, SWITCH_EVENT_CHANNEL_UNHOLD, switch_event_create, switch_event_fire, 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_core_media_bug_transfer_recordings(channel->session, other_session);
                                 switch_core_session_rwunlock(other_session);
                         }
                 }
         }
 
 }

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_status_t switch_channel_pass_callee_id	(	switch_channel_t *	channel,
		switch_channel_t *	other_channel
	)

Definition at line 4259 of file switch_channel.c.

References 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_status_t switch_channel_perform_answer	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3779 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CF_PROXY_MODE, CS_HANGUP, switch_core_session_message::from, switch_core_session_message::message_id, 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)) {
                 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;
 }

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

Definition at line 353 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, 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_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 3218 of file switch_channel.c.

References CF_BLOCK_STATE, CF_BRIDGE_ORIGINATOR, CF_BRIDGED, CF_HANGUP_HELD, CF_LEG_HOLDING, CS_HANGUP, OCF_HANGUP, 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_status_t switch_channel_perform_mark_answered	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3672 of file switch_channel.c.

References CCS_ACTIVE, CF_ANSWERED, CF_EARLY_MEDIA, CF_PASSTHRU_PTIME_MISMATCH, CF_VIDEO_MIRROR_INPUT, CS_HANGUP, send_ind(), switch_assert, switch_channel_api_on(), SWITCH_CHANNEL_API_ON_ANSWER_VARIABLE, SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE, switch_channel_check_zrtp(), 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_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, and switch_true().

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_check_zrtp(channel);
         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);
 
         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);
 
         return SWITCH_STATUS_SUCCESS;
 }

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

Definition at line 3408 of file switch_channel.c.

References caller_profile, CCS_EARLY, CF_ANSWERED, CF_EARLY_MEDIA, CF_PASSTHRU_PTIME_MISMATCH, CF_VIDEO_MIRROR_INPUT, switch_channel_timetable::progress_media, send_ind(), switch_channel_api_on(), SWITCH_CHANNEL_API_ON_MEDIA_VARIABLE, SWITCH_CHANNEL_API_ON_PRE_ANSWER_VARIABLE, switch_channel_check_zrtp(), 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(), and switch_caller_profile::times.

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_channel_check_zrtp(channel);
                 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_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 3306 of file switch_channel.c.

References caller_profile, CCS_RINGING, CF_ANSWERED, CF_RING_READY, 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, and switch_caller_profile::times.

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);
 
 
                 if (channel->caller_profile && channel->caller_profile->times) {
                         switch_mutex_lock(channel->profile_mutex);
                         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);
                                         if (other_channel->caller_profile) {
                                                 other_channel->caller_profile->times->progress = channel->caller_profile->times->progress;
                                         }
                                         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_status_t switch_channel_perform_pre_answer	(	switch_channel_t *	channel,
		const char *	file,
		const char *	func,
		int	line
	)

Definition at line 3483 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CS_HANGUP, switch_core_session_message::from, switch_core_session_message::message_id, 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;
 }

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 758 of file switch_channel.c.

References CF_ANSWERED, CF_NO_PRESENCE, CF_SLA_INTERCEPT, 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_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 3518 of file switch_channel.c.

References CF_ANSWERED, CF_EARLY_MEDIA, CS_HANGUP, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, 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;
 }

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 270 of file switch_channel.c.

References CCS_HANGUP, 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_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 2216 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, 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_EVENT_CHANNEL_STATE, switch_event_create, switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), 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\n",
                                           channel->name, state_names[state]);
 
         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_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 2269 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, 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;
 }

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

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

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 1214 of file switch_channel.c.

References 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_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_status_t switch_channel_queue_dtmf_string	(	_In_ switch_channel_t *	channel,
		_In_ const char *	dtmf_string
	)

void switch_channel_restart ( switch_channel_t * channel )

Definition at line 2969 of file switch_channel.c.

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

Referenced by 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);
 }

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

Definition at line 1920 of file switch_channel.c.

References 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_process_udptl(), 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);
 }

void switch_channel_set_bridge_time ( switch_channel_t * channel )

Definition at line 3198 of file switch_channel.c.

References switch_micro_time_now(), switch_mutex_lock(), and switch_mutex_unlock().

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

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 3171 of file switch_channel.c.

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

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 2709 of file switch_channel.c.

References 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(), and switch_mutex_unlock().

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

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

Definition at line 1704 of file switch_channel.c.

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

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

void switch_channel_set_direction	(	switch_channel_t *	channel,
		switch_call_direction_t	direction
	)

Definition at line 419 of file switch_channel.c.

References 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_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 1575 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.

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

void switch_channel_set_flag_recursive	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

Definition at line 1879 of file switch_channel.c.

References CF_OUTBOUND, CF_RECOVERED, 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(), and switch_ivr_signal_bridge().

 {
         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");
         }
 }

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 1800 of file switch_channel.c.

References 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, switch_hold_record_s::next, switch_hold_record_s::on, 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(), and switch_hold_record_s::uuid.

Referenced by switch_channel_perform_mark_ring_ready_value(), 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);
         }
 }

void switch_channel_set_hangup_time ( switch_channel_t * channel )

Definition at line 3208 of file switch_channel.c.

References switch_micro_time_now(), switch_mutex_lock(), and switch_mutex_unlock().

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

void switch_channel_set_hunt_caller_profile	(	switch_channel_t *	channel,
		switch_caller_profile_t *	caller_profile
	)

Definition at line 2791 of file switch_channel.c.

References 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_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 1088 of file switch_channel.c.

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

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 2837 of file switch_channel.c.

References LP_ORIGINATEE, switch_assert, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_request_xml(), 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);
 }

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 2807 of file switch_channel.c.

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

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 2772 of file switch_channel.c.

References LP_ORIGINATOR, switch_assert, switch_core_alloc, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_session_outgoing_channel(), switch_core_session_request_xml(), 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);
 }

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 1387 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_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 1055 of file switch_channel.c.

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

void switch_channel_set_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 1898 of file switch_channel.c.

References 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_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 1116 of file switch_channel.c.

References profile_node_s::next, SWITCH_BLANK_STRING, switch_channel_set_device_id(), switch_core_alloc, switch_core_strdup, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, profile_node_s::val, profile_node_s::var, and zstr.

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

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

Definition at line 908 of file switch_channel.c.

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

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 1976 of file switch_channel.c.

References 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_status_t switch_channel_set_timestamps ( _In_ switch_channel_t * channel )

Referenced by switch_core_session_hangup_state(), and switch_ivr_originate().

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

Definition at line 1511 of file switch_channel.c.

References 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_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 1541 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_status_t switch_channel_set_variable_printf	(	switch_channel_t *	channel,
		const char *	varname,
		const char *	fmt,
			...
	)

Definition at line 1480 of file switch_channel.c.

References switch_assert, switch_channel_set_variable, switch_event_del_header, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, switch_vasprintf(), 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_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 1416 of file switch_channel.c.

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

void switch_channel_sort_cid ( switch_channel_t * channel )

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

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

int switch_channel_state_change_pending ( switch_channel_t * channel )

Definition at line 2105 of file switch_channel.c.

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

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

void switch_channel_step_caller_profile ( switch_channel_t * channel )

Definition at line 2697 of file switch_channel.c.

References 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_callstate_t switch_channel_str2callstate ( const char * str )

Definition at line 333 of file switch_channel.c.

References switch_callstate_table::callstate, CALLSTATE_CHART, switch_device_state_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_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().

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

Definition at line 1960 of file switch_channel.c.

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

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

uint32_t switch_channel_test_cap	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

Definition at line 1724 of file switch_channel.c.

References switch_assert.

Referenced by switch_channel_test_cap_partner(), switch_core_session_outgoing_channel(), and switch_core_session_send_dtmf().

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

uint32_t switch_channel_test_cap_partner	(	switch_channel_t *	channel,
		switch_channel_cap_t	cap
	)

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

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 1562 of file switch_channel.c.

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

uint32_t switch_channel_test_flag_partner	(	switch_channel_t *	channel,
		switch_channel_flag_t	flag
	)

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

int switch_channel_test_private_flag	(	switch_channel_t *	channel,
		uint32_t	flags
	)

Definition at line 1914 of file switch_channel.c.

References switch_assert.

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

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 2120 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, 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_status_t switch_channel_transfer_variable_prefix	(	switch_channel_t *	orig_channel,
		switch_channel_t *	new_channel,
		const char *	prefix
	)

Definition at line 1366 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_status_t switch_channel_try_dtmf_lock ( switch_channel_t * channel )

Definition at line 469 of file switch_channel.c.

References switch_mutex_trylock().

 {
         return switch_mutex_trylock(channel->dtmf_mutex);
 }

void switch_channel_uninit ( switch_channel_t * channel )

Uninitalize a channel.

Parameters

channel the channel to uninit

Definition at line 723 of file switch_channel.c.

References switch_channel_flush_dtmf(), switch_core_hash_destroy(), switch_event_destroy(), switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_safe_free, and SWITCH_STATUS_SUCCESS.

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);
         switch_mutex_unlock(channel->profile_mutex);
 }

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 1040 of file switch_channel.c.

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

Referenced by switch_channel_build_param_string(), switch_channel_transfer_variable_prefix(), 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;
 }

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 1029 of file switch_channel.c.

References switch_assert, and switch_mutex_unlock().

Referenced by switch_channel_build_param_string(), switch_channel_transfer_variable_prefix(), 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_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 1665 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_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;
 }

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

Definition at line 1629 of file switch_channel.c.

References CS_HANGUP, 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();
         }
 }

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

Definition at line 1644 of file switch_channel.c.

References CS_HANGUP, 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

Function Documentation