switch_channel.h File Reference

Media Channel Interface. More...

#include <switch.h>

Include dependency graph for switch_channel.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	switch_channel_timetable

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

Typedefs
typedef struct switch_channel_timetable	switch_channel_timetable_t

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)
switch_status_t	switch_channel_execute_on (switch_channel_t *channel, const char *variable_prefix)
switch_status_t	switch_channel_api_on (switch_channel_t *channel, const char *variable_prefix)
void	switch_channel_process_device_hangup (switch_channel_t *channel)
switch_caller_extension_t *	switch_channel_get_queued_extension (switch_channel_t *channel)
void	switch_channel_transfer_to_extension (switch_channel_t *channel, switch_caller_extension_t *caller_extension)
const char *	switch_channel_get_partner_uuid (switch_channel_t *channel)
switch_hold_record_t *	switch_channel_get_hold_record (switch_channel_t *channel)
void	switch_channel_state_thread_lock (switch_channel_t *channel)
void	switch_channel_state_thread_unlock (switch_channel_t *channel)
switch_status_t	switch_channel_state_thread_trylock (switch_channel_t *channel)
void	switch_channel_handle_cause (switch_channel_t *channel, switch_call_cause_t cause)
void	switch_channel_global_init (switch_memory_pool_t *pool)
void	switch_channel_global_uninit (void)
const char *	switch_channel_set_device_id (switch_channel_t *channel, const char *device_id)
void	switch_channel_clear_device_record (switch_channel_t *channel)
switch_device_record_t *	switch_channel_get_device_record (switch_channel_t *channel)
void	switch_channel_release_device_record (switch_device_record_t **dcdrp)
switch_status_t	switch_channel_bind_device_state_handler (switch_device_state_function_t function, void *user_data)
switch_status_t	switch_channel_unbind_device_state_handler (switch_device_state_function_t function)
const char *	switch_channel_device_state2str (switch_device_state_t device_state)
switch_status_t	switch_channel_pass_sdp (switch_channel_t *from_channel, switch_channel_t *to_channel, const char *sdp)

Detailed Description

Media Channel Interface.

See also

switch_channel

Definition in file switch_channel.h.

Typedef Documentation

typedef struct switch_channel_timetable switch_channel_timetable_t

Definition at line 58 of file switch_channel.h.

Function Documentation

switch_status_t switch_channel_api_on	(	switch_channel_t *	channel,
		const char *	variable_prefix
	)

Definition at line 3575 of file switch_channel.c.

References switch_event_header::array, do_api_on(), switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_channel_get_variables(), switch_event_destroy(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_event_header::value.

Referenced by audio_bridge_thread(), check_channel_status(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_core_media_process_udptl(), switch_ivr_originate(), and tone_on_dtmf().

{
        switch_event_header_t *hp;
        switch_event_t *event;
        int x = 0;

                                                                
        switch_channel_get_variables(channel, &event);
        
        for (hp = event->headers; hp; hp = hp->next) {
                char *var = hp->name;
                char *val = hp->value;

                if (!strncasecmp(var, variable_prefix, strlen(variable_prefix))) {
                        if (hp->idx) {
                                int i;
                                for (i = 0; i < hp->idx; i++) {
                                        x++;
                                        do_api_on(channel, hp->array[i]);                                       
                                }
                        } else {
                                x++;
                                do_api_on(channel, val);
                        }
                }
        }
        
        switch_event_destroy(&event);

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_status_t switch_channel_bind_device_state_handler	(	switch_device_state_function_t	function,
		void *	user_data
	)

Definition at line 5294 of file switch_channel.c.

References switch_device_state_binding_s::function, globals, switch_core_alloc, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, and switch_device_state_binding_s::user_data.

{
        switch_device_state_binding_t *binding = NULL, *ptr = NULL;
        assert(function != NULL);

        if (!(binding = (switch_device_state_binding_t *) switch_core_alloc(globals.pool, sizeof(*binding)))) {
                return SWITCH_STATUS_MEMERR;
        }

        binding->function = function;
        binding->user_data = user_data;

        switch_mutex_lock(globals.device_mutex);
        for (ptr = globals.device_bindings; ptr && ptr->next; ptr = ptr->next);

        if (ptr) {
                ptr->next = binding;
        } else {
                globals.device_bindings = binding;
        }

        switch_mutex_unlock(globals.device_mutex);

        return SWITCH_STATUS_SUCCESS;
}

void switch_channel_clear_device_record

(

switch_channel_t *

channel

)

Definition at line 4910 of file switch_channel.c.

References CF_FINAL_DEVICE_LEG, device_uuid_node_s::event, globals, device_uuid_node_s::hup_profile, device_uuid_node_s::next, device_uuid_node_s::parent, pool, switch_caller_profile_event_set_data(), SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_test_flag(), switch_core_destroy_memory_pool, switch_event_add_header_string(), SWITCH_EVENT_CALL_DETAIL, switch_event_create, switch_event_destroy(), switch_event_fire, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_SUCCESS, switch_xml_free(), switch_yield, switch_device_record_s::uuid_list, and device_uuid_node_s::xml_cdr.

Referenced by switch_core_session_destroy_state().

{
        switch_memory_pool_t *pool;
        int sanity = 100;
        switch_device_node_t *np;
        switch_event_t *event;

        if (!channel->device_node || !switch_channel_test_flag(channel, CF_FINAL_DEVICE_LEG)) {
                return;
        }

        while(--sanity && channel->device_node->parent->refs) {
                switch_yield(100000);
        }

        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "Destroying device cdr %s on device [%s]\n", 
                                          channel->device_node->parent->uuid,
                                          channel->device_node->parent->device_id);

        if (switch_event_create(&event, SWITCH_EVENT_CALL_DETAIL) == SWITCH_STATUS_SUCCESS) {
                int x = 0;
                char prefix[80] = "";

                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Type", "device");
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-ID", channel->device_node->parent->device_id);

                switch_mutex_lock(channel->device_node->parent->mutex);
                for(np = channel->device_node->parent->uuid_list; np; np = np->next) {
                        switch_snprintf(prefix, sizeof(prefix), "Call-%d", ++x);
                        switch_caller_profile_event_set_data(np->hup_profile, prefix, event);
                }
                switch_mutex_unlock(channel->device_node->parent->mutex);

                switch_event_fire(&event);
        }

        switch_mutex_lock(channel->device_node->parent->mutex);
        for(np = channel->device_node->parent->uuid_list; np; np = np->next) {
                if (np->xml_cdr) {
                        switch_xml_free(np->xml_cdr);
                }
                if (np->event) {
                        switch_event_destroy(&np->event);
                }
        }
        switch_mutex_unlock(channel->device_node->parent->mutex);

        pool = channel->device_node->parent->pool;

        switch_mutex_lock(globals.device_mutex);
        switch_core_destroy_memory_pool(&pool);         

        switch_mutex_unlock(globals.device_mutex);
        
        
}

const char* switch_channel_device_state2str

(

switch_device_state_t

device_state

)

Definition at line 317 of file switch_channel.c.

References DEVICE_STATE_CHART, and switch_device_state_table::name.

Referenced by switch_channel_check_device_state().

{
        uint8_t x;
        const char *str = "UNKNOWN";

        for (x = 0; x < (sizeof(DEVICE_STATE_CHART) / sizeof(struct switch_cause_table)) - 1; x++) {
                if (DEVICE_STATE_CHART[x].device_state == device_state) {
                        str = DEVICE_STATE_CHART[x].name;
                        break;
                }
        }

        return str;
}

switch_status_t switch_channel_execute_on	(	switch_channel_t *	channel,
		const char *	variable_prefix
	)

Definition at line 3638 of file switch_channel.c.

References switch_event_header::array, do_execute_on(), switch_event::headers, switch_event_header::idx, switch_event_header::name, switch_event_header::next, switch_channel_get_variables(), switch_core_get_variables(), switch_event_destroy(), switch_event_merge(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_event_header::value.

Referenced by audio_bridge_thread(), check_channel_status(), record_callback(), switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), switch_channel_perform_mark_ring_ready_value(), switch_core_media_process_udptl(), switch_core_media_read_frame(), switch_ivr_originate(), switch_ivr_session_transfer(), tone_detect_callback(), and tone_on_dtmf().

{
        switch_event_header_t *hp;
        switch_event_t *event, *cevent;
        int x = 0;

        switch_core_get_variables(&event);
        switch_channel_get_variables(channel, &cevent);
        switch_event_merge(event, cevent);
        
        for (hp = event->headers; hp; hp = hp->next) {
                char *var = hp->name;
                char *val = hp->value;

                if (!strncasecmp(var, variable_prefix, strlen(variable_prefix))) {
                        if (hp->idx) {
                                int i;
                                for (i = 0; i < hp->idx; i++) {
                                        x++;
                                        do_execute_on(channel, hp->array[i]);                                   
                                }
                        } else {
                                x++;
                                do_execute_on(channel, val);
                        }
                }
        }
        
        switch_event_destroy(&event);
        switch_event_destroy(&cevent);

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

switch_device_record_t* switch_channel_get_device_record

(

switch_channel_t *

channel

)

Definition at line 5276 of file switch_channel.c.

References switch_mutex_lock().

{
        if (channel->device_node) {
                switch_mutex_lock(channel->device_node->parent->mutex);
                return channel->device_node->parent;
        }

        return NULL;
}

switch_hold_record_t* switch_channel_get_hold_record

(

switch_channel_t *

channel

)

Definition at line 184 of file switch_channel.c.

Referenced by switch_ivr_generate_xml_cdr().

{
        return channel->hold_record;
}

const char* switch_channel_get_partner_uuid

(

switch_channel_t *

channel

)

Definition at line 4659 of file switch_channel.c.

References switch_channel_get_variable, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, and SWITCH_SIGNAL_BOND_VARIABLE.

Referenced by recover_callback(), rtp_common_read(), switch_channel_clear_flag_partner(), switch_channel_flip_cid(), switch_channel_get_private_partner(), switch_channel_get_variable_partner(), switch_channel_set_flag_partner(), switch_channel_set_flag_value(), switch_channel_set_variable_partner_var_check(), switch_channel_test_cap_partner(), switch_channel_test_flag_partner(), switch_core_media_gen_local_sdp(), switch_core_media_receive_message(), switch_core_session_pass_indication(), switch_core_session_perform_get_partner(), switch_core_session_read_frame(), switch_core_session_write_frame(), switch_core_standard_on_reset(), switch_ivr_broadcast(), switch_ivr_find_bridged_uuid(), switch_ivr_hold(), switch_ivr_intercept_session(), switch_ivr_parse_event(), switch_ivr_soft_hold(), switch_ivr_unhold(), switch_rtp_write_frame(), and switch_rtp_zerocopy_read_frame().

{
        const char *uuid = NULL;

        if (!(uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE))) {
                uuid = switch_channel_get_variable(channel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE);
        }

        return uuid;
}

switch_caller_extension_t* switch_channel_get_queued_extension

(

switch_channel_t *

channel

)

Definition at line 3149 of file switch_channel.c.

References switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_core_standard_on_routing().

{
        switch_caller_extension_t *caller_extension;

        switch_mutex_lock(channel->profile_mutex);
        caller_extension = channel->queued_extension;
        channel->queued_extension = NULL;
        switch_mutex_unlock(channel->profile_mutex);

        return caller_extension;
}

void switch_channel_global_init

(

switch_memory_pool_t *

pool

)

Definition at line 4811 of file switch_channel.c.

References globals, memset(), pool, switch_core_hash_init, switch_mutex_init(), and SWITCH_MUTEX_NESTED.

Referenced by switch_core_init().

{
        memset(&globals, 0, sizeof(globals));
        globals.pool = pool;

        switch_mutex_init(&globals.device_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_core_hash_init(&globals.device_hash);
}

void switch_channel_global_uninit

(

void

)

Definition at line 4820 of file switch_channel.c.

References globals, and switch_core_hash_destroy().

Referenced by switch_core_destroy().

{
        switch_core_hash_destroy(&globals.device_hash);
}

void switch_channel_handle_cause	(	switch_channel_t *	channel,
		switch_call_cause_t	cause
	)

Definition at line 4670 of file switch_channel.c.

References CF_CONFIRM_BLIND_TRANSFER, CF_TRANSFER, CS_ROUTING, SWITCH_CAUSE_ATTENDED_TRANSFER, SWITCH_CAUSE_NO_ANSWER, SWITCH_CAUSE_NO_USER_RESPONSE, SWITCH_CAUSE_ORIGINATOR_CANCEL, switch_channel_cause2str(), switch_channel_get_state(), switch_channel_get_variable, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_test_flag(), switch_channel_up_nosig, switch_core_session_strdup, switch_ivr_session_transfer(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_separate_string(), switch_snprintf(), switch_split, and switch_true().

Referenced by signal_bridge_on_hangup(), switch_ivr_enterprise_originate(), and switch_ivr_multi_threaded_bridge().

{
        switch_core_session_t *session = channel->session;
        const char *transfer_on_fail = NULL;
        char *tof_data = NULL;
        char *tof_array[4] = { 0 };
        //int tof_arrayc = 0;

        if (!switch_channel_up_nosig(channel)) {
                return;
        }

        transfer_on_fail = switch_channel_get_variable(channel, "transfer_on_fail");
        tof_data = switch_core_session_strdup(session, transfer_on_fail);
        switch_split(tof_data, ' ', tof_array);
        transfer_on_fail = tof_array[0];

        /* 
           if the variable continue_on_fail is set it can be:
           'true' to continue on all failures.
           'false' to not continue.
           A list of codes either names or numbers eg "user_busy,normal_temporary_failure,603"
           failure_causes acts as the opposite version  
           EXCEPTION... ATTENDED_TRANSFER never is a reason to continue.......
        */
        if (cause != SWITCH_CAUSE_ATTENDED_TRANSFER) {
                const char *continue_on_fail = NULL, *failure_causes = NULL;

                continue_on_fail = switch_channel_get_variable(channel, "continue_on_fail");
                failure_causes = switch_channel_get_variable(channel, "failure_causes");

                if (continue_on_fail || failure_causes) {
                        const char *cause_str;
                        char cause_num[35] = "";

                        cause_str = switch_channel_cause2str(cause);
                        switch_snprintf(cause_num, sizeof(cause_num), "%u", cause);

                        if (failure_causes) {
                                char *lbuf = switch_core_session_strdup(session, failure_causes);
                                char *argv[256] = { 0 };
                                int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
                                int i, x = 0;

                                for (i = 0; i < argc; i++) {
                                        if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
                                                x++;
                                                break;
                                        }
                                }
                                if (!x) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "Failure causes [%s]:  Cause: %s\n", failure_causes, cause_str);
                                        return;
                                }
                        }

                        if (continue_on_fail) {
                                if (switch_true(continue_on_fail)) {
                                        return;
                                } else {
                                        char *lbuf = switch_core_session_strdup(session, continue_on_fail);
                                        char *argv[256] = { 0 };
                                        int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
                                        int i;

                                        for (i = 0; i < argc; i++) {
                                                if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "Continue on fail [%s]:  Cause: %s\n", continue_on_fail, cause_str);
                                                        return;
                                                }
                                        }
                                }
                        }
                } else {
                        /* no answer is *always* a reason to continue */
                        if (cause == SWITCH_CAUSE_NO_ANSWER || cause == SWITCH_CAUSE_NO_USER_RESPONSE || cause == SWITCH_CAUSE_ORIGINATOR_CANCEL) {
                                return;
                        }
                }
                        
                if (transfer_on_fail || failure_causes) {
                        const char *cause_str;
                        char cause_num[35] = "";

                        cause_str = switch_channel_cause2str(cause);
                        switch_snprintf(cause_num, sizeof(cause_num), "%u", cause);

                        if ((tof_array[1] == NULL ) || (!strcasecmp(tof_array[1], "auto_cause"))){
                                tof_array[1] = (char *) cause_str;
                        }

                        if (failure_causes) {
                                char *lbuf = switch_core_session_strdup(session, failure_causes);
                                char *argv[256] = { 0 };
                                int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
                                int i, x = 0;

                                for (i = 0; i < argc; i++) {
                                        if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
                                                x++;
                                                break;
                                        }
                                }
                                if (!x) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "Failure causes [%s]:  Cause: %s\n", failure_causes, cause_str);
                                                                                  
                                        switch_ivr_session_transfer(session, tof_array[1], tof_array[2], tof_array[3]);
                                }
                        }

                        if (transfer_on_fail) {
                                if (switch_true(transfer_on_fail)) {
                                        return;
                                } else {
                                        char *lbuf = switch_core_session_strdup(session, transfer_on_fail);
                                        char *argv[256] = { 0 };
                                        int argc = switch_separate_string(lbuf, ',', argv, (sizeof(argv) / sizeof(argv[0])));
                                        int i;

                                        for (i = 0; i < argc; i++) {
                                                if (!strcasecmp(argv[i], cause_str) || !strcasecmp(argv[i], cause_num)) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "Transfer on fail [%s]:  Cause: %s\n", transfer_on_fail, cause_str);
                                                        switch_ivr_session_transfer(session, tof_array[1], tof_array[2], tof_array[3]);
                                                }
                                        }
                                }
                        }
                } 
        }


        if (!switch_channel_test_flag(channel, CF_TRANSFER) && !switch_channel_test_flag(channel, CF_CONFIRM_BLIND_TRANSFER) && 
                switch_channel_get_state(channel) != CS_ROUTING) {
                switch_channel_hangup(channel, cause);
        }
}

switch_status_t switch_channel_pass_sdp	(	switch_channel_t *	from_channel,
		switch_channel_t *	to_channel,
		const char *	sdp
	)

Definition at line 5345 of file switch_channel.c.

References SWITCH_B_SDP_VARIABLE, switch_channel_get_variable, switch_channel_set_variable, switch_core_media_process_sdp_filter(), switch_safe_free, and SWITCH_STATUS_FALSE.

Referenced by switch_core_session_outgoing_channel().

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        char *use_sdp = (char *) sdp;
        char *patched_sdp = NULL;

        if (!switch_channel_get_variable(to_channel, SWITCH_B_SDP_VARIABLE)) {
                const char *var;

                if ((var = switch_channel_get_variable(from_channel, "bypass_media_sdp_filter"))) {
                        if ((patched_sdp = switch_core_media_process_sdp_filter(use_sdp, var, from_channel->session))) {
                                use_sdp = patched_sdp;
                        }
                }

                switch_channel_set_variable(to_channel, SWITCH_B_SDP_VARIABLE, use_sdp);
        }

        switch_safe_free(patched_sdp);

        return status;
}

void switch_channel_process_device_hangup

(

switch_channel_t *

channel

)

Definition at line 4967 of file switch_channel.c.

References process_device_hup(), and switch_channel_check_device_state().

Referenced by switch_core_session_hangup_state().

{

        switch_channel_check_device_state(channel, channel->callstate);
        process_device_hup(channel);

}

void switch_channel_release_device_record

(

switch_device_record_t **

dcdrp

)

Definition at line 5286 of file switch_channel.c.

References switch_mutex_unlock().

{
        if (drecp && *drecp) {
                switch_mutex_unlock((*drecp)->mutex);
                *drecp = NULL;
        }
}

const char* switch_channel_set_device_id	(	switch_channel_t *	channel,
		const char *	device_id
	)

Definition at line 5248 of file switch_channel.c.

References add_uuid(), create_device_record(), switch_device_record_s::device_id, globals, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_check_device_state(), switch_core_hash_find(), switch_core_hash_insert, switch_core_session_strdup, SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_channel_set_profile_var().

{
        switch_device_record_t *drec;

        if (channel->device_node) {
                return NULL;
        }

        channel->device_id = switch_core_session_strdup(channel->session, device_id);

        switch_mutex_lock(globals.device_mutex);

        if (!(drec = switch_core_hash_find(globals.device_hash, channel->device_id))) {
                create_device_record(&drec, channel->device_id);
                switch_core_hash_insert(globals.device_hash, drec->device_id, drec);
        }

        add_uuid(drec, channel);
        
        switch_mutex_unlock(globals.device_mutex);

        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "Setting DEVICE ID to [%s]\n", device_id);
        
        switch_channel_check_device_state(channel, channel->callstate);
        
        return device_id;
}

void switch_channel_state_thread_lock

(

switch_channel_t *

channel

)

Definition at line 2490 of file switch_channel.c.

References switch_mutex_lock().

Referenced by switch_core_session_run().

{
        switch_mutex_lock(channel->thread_mutex);
}

switch_status_t switch_channel_state_thread_trylock

(

switch_channel_t *

channel

)

Definition at line 2496 of file switch_channel.c.

References switch_mutex_trylock().

Referenced by switch_core_session_wake_session_thread().

{
        return switch_mutex_trylock(channel->thread_mutex);
}

void switch_channel_state_thread_unlock

(

switch_channel_t *

channel

)

Definition at line 2502 of file switch_channel.c.

References switch_mutex_unlock().

Referenced by switch_core_session_run(), and switch_core_session_wake_session_thread().

{
        switch_mutex_unlock(channel->thread_mutex);
}

void switch_channel_transfer_to_extension	(	switch_channel_t *	channel,
		switch_caller_extension_t *	caller_extension
	)

Definition at line 3161 of file switch_channel.c.

References CF_TRANSFER, CS_ROUTING, switch_channel_set_flag, switch_channel_set_state, switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_ivr_parse_event().

{
        switch_mutex_lock(channel->profile_mutex);
        channel->queued_extension = caller_extension;
        switch_mutex_unlock(channel->profile_mutex);

        switch_channel_set_flag(channel, CF_TRANSFER);
        switch_channel_set_state(channel, CS_ROUTING);  
}

switch_status_t switch_channel_unbind_device_state_handler

(

switch_device_state_function_t

function

)

Definition at line 5320 of file switch_channel.c.

References switch_device_state_binding_s::function, globals, switch_device_state_binding_s::next, switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_device_state_binding_t *ptr, *last = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_mutex_lock(globals.device_mutex);
        for (ptr = globals.device_bindings; ptr; ptr = ptr->next) {
                if (ptr->function == function) {
                        status = SWITCH_STATUS_SUCCESS;

                        if (last) {
                                last->next = ptr->next;
                        } else {
                                globals.device_bindings = ptr->next;
                                last = NULL;
                                continue;
                        }
                }
                last = ptr;
        }
        switch_mutex_unlock(globals.device_mutex);

        return status;
}