#include <switch.h>
#include <switch_channel.h>
#include <pcre.h>

Include dependency graph for switch_channel.c:

Data Structures
struct	switch_cause_table

struct	switch_device_state_binding_s

struct	switch_channel

struct	switch_callstate_table

struct	switch_device_state_table

Macros
#define	resize(l)

Typedefs
typedef struct switch_device_state_binding_s	switch_device_state_binding_t

Enumerations
enum	opaque_channel_flag_t { OCF_HANGUP = (1 << 0) }

enum	switch_originator_type_t { LP_NEITHER, LP_ORIGINATOR, LP_ORIGINATEE }

Functions
static void	process_device_hup (switch_channel_t *channel)

static void	switch_channel_check_device_state (switch_channel_t *channel, switch_channel_callstate_t callstate)

switch_hold_record_t *	switch_channel_get_hold_record (switch_channel_t *channel)

const char *	switch_channel_cause2str (switch_call_cause_t cause)

switch_call_cause_t	switch_channel_str2cause (const char *str)

switch_call_cause_t	switch_channel_get_cause (switch_channel_t *channel)

switch_call_cause_t *	switch_channel_get_cause_ptr (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)

const char *	switch_channel_device_state2str (switch_device_state_t device_state)

switch_channel_callstate_t	switch_channel_str2callstate (const char *str)

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)

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_channel_timetable_t *	switch_channel_get_timetable (switch_channel_t *channel)

void	switch_channel_set_direction (switch_channel_t *channel, switch_call_direction_t direction)

switch_call_direction_t	switch_channel_direction (switch_channel_t *channel)

switch_call_direction_t	switch_channel_logical_direction (switch_channel_t *channel)

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

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_size_t	switch_channel_has_dtmf (switch_channel_t *channel)

switch_status_t	switch_channel_queue_dtmf (switch_channel_t channel, const switch_dtmf_t dtmf)

switch_status_t	switch_channel_queue_dtmf_string (switch_channel_t channel, const char dtmf_string)

switch_status_t	switch_channel_dequeue_dtmf (switch_channel_t channel, switch_dtmf_t dtmf)

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

void	switch_channel_flush_dtmf (switch_channel_t *channel)

void	switch_channel_uninit (switch_channel_t *channel)
	Uninitalize a 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_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_mark_hold (switch_channel_t *channel, switch_bool_t on)

const char *	switch_channel_get_hold_music (switch_channel_t *channel)

const char *	switch_channel_get_hold_music_partner (switch_channel_t *channel)

void	switch_channel_set_scope_variables (switch_channel_t channel, switch_event_t *event)

switch_status_t	switch_channel_get_scope_variables (switch_channel_t channel, switch_event_t *event)

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

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

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

switch_event_header_t *	switch_channel_variable_first (switch_channel_t *channel)
	Start iterating over the entries in the channel variable list. 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_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...

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_var_check (switch_channel_t channel, const char varname, const char val, const char export_varname, switch_bool_t var_check)

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

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)

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

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_event_base_add_header (switch_event_t event, switch_stack_t stack, const char header_name, char *data)

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)

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

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

uint32_t	switch_channel_test_flag_partner (switch_channel_t *channel, switch_channel_flag_t flag)

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

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

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)

char *	switch_channel_get_flag_string (switch_channel_t *channel)

char *	switch_channel_get_cap_string (switch_channel_t *channel)

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_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 key, switch_channel_t channel, uint32_t flags)

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

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

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_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_state_change_pending (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...

const char *	switch_channel_state_name (switch_channel_state_t state)

switch_channel_state_t	switch_channel_name_state (const char *name)

static void	careful_set (switch_channel_t channel, switch_channel_state_t state, switch_channel_state_t val)

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

void	switch_channel_state_thread_lock (switch_channel_t *channel)

switch_status_t	switch_channel_state_thread_trylock (switch_channel_t *channel)

void	switch_channel_state_thread_unlock (switch_channel_t *channel)

void	switch_channel_event_set_basic_data (switch_channel_t channel, switch_event_t event)

void	switch_channel_event_set_extended_data (switch_channel_t channel, switch_event_t event)

void	switch_channel_event_set_data (switch_channel_t channel, switch_event_t event)

void	switch_channel_step_caller_profile (switch_channel_t *channel)

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

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)

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

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_originator_caller_profile (switch_channel_t *channel)
	Retrieve the given channel's originator 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...

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

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

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

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

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_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_queued_extension (switch_channel_t *channel)

void	switch_channel_transfer_to_extension (switch_channel_t channel, switch_caller_extension_t caller_extension)

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

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

void	switch_channel_set_bridge_time (switch_channel_t *channel)

void	switch_channel_set_hangup_time (switch_channel_t *channel)

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)

static switch_status_t	send_ind (switch_channel_t channel, switch_core_session_message_types_t msg_id, 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)

void	switch_channel_check_zrtp (switch_channel_t *channel)

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

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

static void	do_api_on (switch_channel_t channel, const char variable)

switch_status_t	switch_channel_api_on (switch_channel_t channel, const char variable_prefix)

static void	do_execute_on (switch_channel_t channel, const char variable)

switch_status_t	switch_channel_execute_on (switch_channel_t channel, const char variable_prefix)

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

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

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 (switch_channel_t channel, switch_caller_profile_t caller_profile, const char *prefix)

switch_status_t	switch_channel_pass_callee_id (switch_channel_t channel, switch_channel_t other_channel)

switch_status_t	switch_channel_get_variables (switch_channel_t channel, switch_event_t *event)

switch_core_session_t *	switch_channel_get_session (switch_channel_t *channel)

switch_status_t	switch_channel_set_timestamps (switch_channel_t *channel)

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

static void	fetch_device_stats (switch_device_record_t *drec)

void	switch_channel_clear_device_record (switch_channel_t *channel)

void	switch_channel_process_device_hangup (switch_channel_t *channel)

static void	add_uuid (switch_device_record_t drec, switch_channel_t channel)

static switch_status_t	create_device_record (switch_device_record_t *drecp, const char device_id)

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

switch_device_record_t *	switch_channel_get_device_record (switch_channel_t *channel)

void	switch_channel_release_device_record (switch_device_record_t **drecp)

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)

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

Variables
struct {
switch_memory_pool_t * pool

switch_hash_t * device_hash

switch_mutex_t * device_mutex

switch_device_state_binding_t * device_bindings

}	globals

static struct switch_cause_table	CAUSE_CHART []

static struct switch_callstate_table	CALLSTATE_CHART []

static struct switch_device_state_table	DEVICE_STATE_CHART []

static const char *	state_names []

Macro Definition Documentation

#define resize ( l )

Value:

{\
        char *dp;\
        olen += (len + l + block);\
        cpos = c - data;\
	if ((dp = realloc(data, olen))) {\
        data = dp;\
        c = data + cpos;\
	memset(c, 0, olen - cpos);\
        }}                           \

Definition at line 3829 of file switch_channel.c.

Referenced by switch_channel_expand_variables_check().

Typedef Documentation

typedef struct switch_device_state_binding_s switch_device_state_binding_t

Enumeration Type Documentation

enum opaque_channel_flag_t

Enumerator
OCF_HANGUP

Definition at line 130 of file switch_channel.c.

              {
         OCF_HANGUP = (1 << 0)
 } opaque_channel_flag_t;

enum switch_originator_type_t

Enumerator
LP_NEITHER
LP_ORIGINATOR
LP_ORIGINATEE

Definition at line 134 of file switch_channel.c.

              {
         LP_NEITHER,
         LP_ORIGINATOR,
         LP_ORIGINATEE
 } switch_originator_type_t;

Function Documentation

static void add_uuid	(	switch_device_record_t *	drec,
		switch_channel_t *	channel
	)

static

Definition at line 5202 of file switch_channel.c.

References device_uuid_node_s::callstate, switch_channel::callstate, CF_DEVICE_LEG, switch_channel::device_node, device_uuid_node_s::direction, switch_channel::logical_direction, device_uuid_node_s::next, device_uuid_node_s::parent, switch_device_record_s::pool, switch_device_record_s::refs, switch_channel::session, switch_assert, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_channel_set_flag, switch_core_alloc, switch_core_session_get_uuid(), switch_core_strdup, device_uuid_node_s::uuid, switch_device_record_s::uuid, switch_device_record_s::uuid_list, and switch_device_record_s::uuid_tail.

Referenced by switch_channel_set_device_id().

 {
         switch_device_node_t *node;
 
         switch_assert(drec);
 
         switch_channel_set_flag(channel, CF_DEVICE_LEG);
         node = switch_core_alloc(drec->pool, sizeof(*node));
 
         node->uuid = switch_core_strdup(drec->pool, switch_core_session_get_uuid(channel->session));
         node->parent = drec;
         node->callstate = channel->callstate;
         node->direction = channel->logical_direction == SWITCH_CALL_DIRECTION_INBOUND ? SWITCH_CALL_DIRECTION_OUTBOUND : SWITCH_CALL_DIRECTION_INBOUND;
 
         channel->device_node = node;
 
         if (!drec->uuid_list) {
                 drec->uuid_list = node;
                 drec->uuid = node->uuid;
         } else {
                 drec->uuid_tail->next = node;
         }
 
         drec->uuid_tail = node;
         drec->refs++;
 }

static void careful_set	(	switch_channel_t *	channel,
		switch_channel_state_t *	state,
		switch_channel_state_t	val
	)

inlinestatic

Definition at line 2190 of file switch_channel.c.

References mutex, switch_channel::session, switch_cond_next(), switch_core_session_get_mutex(), switch_mutex_trylock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, and switch_channel::thread_mutex.

Referenced by switch_channel_perform_set_running_state(), and switch_channel_perform_set_state().

                                                                                                                      {
 
         if (switch_mutex_trylock(channel->thread_mutex) == SWITCH_STATUS_SUCCESS) {
                 *state = val;
                 switch_mutex_unlock(channel->thread_mutex);
         } else {
                 switch_mutex_t *mutex = switch_core_session_get_mutex(channel->session);
                 int x = 0;
 
                 for (x = 0; x < 100; x++) {
                         if (switch_mutex_trylock(mutex) == SWITCH_STATUS_SUCCESS) {
                                 *state = val;
                                 switch_mutex_unlock(mutex);
                                 break;
                         } else {
                                 switch_cond_next();
                         }
                 }
 
                 if (x == 100) {
                         *state = val;
                 }
 
         }
 }

static switch_status_t create_device_record	(	switch_device_record_t **	drecp,
		const char *	device_id
	)

static

Definition at line 5229 of file switch_channel.c.

References switch_device_record_s::device_id, switch_device_record_s::mutex, pool, switch_device_record_s::pool, switch_assert, switch_core_alloc, switch_core_new_memory_pool, switch_core_strdup, switch_mutex_init(), SWITCH_MUTEX_NESTED, and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_set_device_id().

 {
         switch_device_record_t *drec;
         switch_memory_pool_t *pool;
 
         switch_assert(drecp);
 
         switch_core_new_memory_pool(&pool);
         drec = switch_core_alloc(pool, sizeof(*drec));
         drec->pool = pool;
         drec->device_id = switch_core_strdup(drec->pool, device_id);
         switch_mutex_init(&drec->mutex, SWITCH_MUTEX_NESTED, drec->pool);
 
         *drecp = drec;
 
         return SWITCH_STATUS_SUCCESS;
 }

static void do_api_on	(	switch_channel_t *	channel,
		const char *	variable
	)

static

Definition at line 3555 of file switch_channel.c.

References switch_stream_handle::data, switch_channel::name, switch_channel::session, switch_api_execute(), SWITCH_CHANNEL_CHANNEL_LOG, switch_core_session_strdup, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STANDARD_STREAM, and switch_str_nil.

Referenced by switch_channel_api_on().

 {
         char *app;
         char *arg = NULL;       
         switch_stream_handle_t stream = { 0 };
 
         app = switch_core_session_strdup(channel->session, variable);
         
         if ((arg = strchr(app, ' '))) {
                 *arg++ = '\0';
         }
         
         SWITCH_STANDARD_STREAM(stream);
         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "%s process %s: %s(%s)\n%s\n",
                                           channel->name, variable, app, switch_str_nil(arg), (char *) stream.data);
         switch_api_execute(app, arg, NULL, &stream);
         free(stream.data);
 }

static void do_execute_on	(	switch_channel_t *	channel,
		const char *	variable
	)

static

Definition at line 3607 of file switch_channel.c.

References switch_channel::session, switch_core_session_execute_application, switch_core_session_execute_application_async(), and switch_core_session_strdup.

Referenced by switch_channel_execute_on().

 {
         char *arg = NULL;
         char *p;
         int bg = 0;
         char *app;
 
         app = switch_core_session_strdup(channel->session, variable);
 
         for(p = app; p && *p; p++) {
                 if (*p == ' ' || (*p == ':' && (*(p+1) != ':'))) {
                         *p++ = '\0';
                         arg = p;
                         break;
                 } else if (*p == ':' && (*(p+1) == ':')) {
                         bg++;
                         break;
                 }
         }
         
         if (!strncasecmp(app, "perl", 4)) {
                 bg++;
         }
         
         if (bg) {
                 switch_core_session_execute_application_async(channel->session, app, arg);
         } else {
                 switch_core_session_execute_application(channel->session, app, arg);
         }
 }

static void fetch_device_stats ( switch_device_record_t * drec )

static

Definition at line 4826 of file switch_channel.c.

Referenced by process_device_hup(), and switch_channel_check_device_state().

 {
         switch_device_node_t *np;
 
 
         memset(&drec->stats, 0, sizeof(switch_device_stats_t));
         
         switch_mutex_lock(drec->mutex);
         for(np = drec->uuid_list; np; np = np->next) {
                 drec->stats.total++;
                 if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                         drec->stats.total_in++;
                 } else {
                         drec->stats.total_out++;
                 }
                 
                 if (!np->hup_profile) {
                         drec->stats.offhook++;
                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                 drec->stats.offhook_in++;
                         } else {
                                 drec->stats.offhook_out++;
                         }
 
                         if (np->callstate == CCS_HELD) {
                                 drec->stats.held++;
                                 if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                         drec->stats.held_in++;
                                 } else {
                                         drec->stats.held_out++;
                                 }
                         } else if (np->callstate == CCS_UNHELD) {
                                 drec->stats.unheld++;
                                 if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                         drec->stats.unheld_in++;
                                 } else {
                                         drec->stats.unheld_out++;
                                 }
                         } else {
                                 if (np->callstate == CCS_EARLY) {
                                         drec->stats.early++;
                                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                                 drec->stats.early_in++;
                                         } else {
                                                 drec->stats.early_out++;
                                         }
                                 } else if (np->callstate == CCS_RINGING) {
                                         drec->stats.ringing++;
                                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                                 drec->stats.ringing_in++;
                                         } else {
                                                 drec->stats.ringing_out++;
                                         }
                                 } else if (np->callstate == CCS_RING_WAIT) {
                                         drec->stats.ring_wait++;
                                 } else if (np->callstate == CCS_HANGUP) {
                                         drec->stats.hup++;
                                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                                 drec->stats.hup_in++;
                                         } else {
                                                 drec->stats.hup_out++;
                                         }
                                 } else if (np->callstate != CCS_DOWN) {
                                         drec->stats.active++;
                                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                                 drec->stats.active_in++;
                                         } else {
                                                 drec->stats.active_out++;
                                         }
                                 }
                         }
                 } else {
                         drec->stats.hup++;
                         if (np->direction == SWITCH_CALL_DIRECTION_INBOUND) {
                                 drec->stats.hup_in++;
                         } else {
                                 drec->stats.hup_out++;
                         }
                 }
         }
         switch_mutex_unlock(drec->mutex);
 
 }

static void process_device_hup ( switch_channel_t * channel )

static

Definition at line 4975 of file switch_channel.c.

References switch_channel::caller_profile, CF_FINAL_DEVICE_LEG, switch_device_record_s::device_id, switch_channel::device_node, device_uuid_node_s::event, fetch_device_stats(), globals, device_uuid_node_s::hold_record, switch_channel::hold_record, device_uuid_node_s::hup_profile, switch_hold_record_s::next, switch_hold_record_s::off, switch_device_stats_s::offhook, switch_hold_record_s::on, device_uuid_node_s::parent, switch_device_record_s::pool, switch_device_record_s::refs, switch_channel::session, switch_device_record_s::stats, switch_caller_profile_dup(), SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_event_set_extended_data(), switch_channel_set_flag, switch_core_alloc, switch_core_hash_delete(), switch_core_strdup, SWITCH_EVENT_CALL_DETAIL, switch_event_create, switch_ivr_generate_xml_cdr(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_SUCCESS, switch_hold_record_s::uuid, and device_uuid_node_s::xml_cdr.

Referenced by switch_channel_process_device_hangup().

 {
         switch_hold_record_t *hr, *newhr, *last = NULL;
         switch_device_record_t *drec = NULL;
         switch_device_node_t *node;
 
         if (!channel->device_node) {
                 return;
         }
         
         switch_mutex_lock(globals.device_mutex);
         node = channel->device_node;
         drec = channel->device_node->parent;
 
         node->hup_profile = switch_caller_profile_dup(drec->pool, channel->caller_profile);
         fetch_device_stats(drec);
 
         switch_ivr_generate_xml_cdr(channel->session, &node->xml_cdr);
         if (switch_event_create(&node->event, SWITCH_EVENT_CALL_DETAIL) == SWITCH_STATUS_SUCCESS) {
                 switch_channel_event_set_extended_data(channel, node->event);
         }
 
         for (hr = channel->hold_record; hr; hr = hr->next) {
                 newhr = switch_core_alloc(drec->pool, sizeof(*newhr));
                 newhr->on = hr->on;
                 newhr->off = hr->off;
 
                 if (hr->uuid) {
                         newhr->uuid = switch_core_strdup(drec->pool, hr->uuid);
                 }
 
                 if (!node->hold_record) {
                         node->hold_record = newhr;
                 } else if (last) {
                         last->next = newhr;
                 }
 
                 last = newhr;
         }       
 
         if (!drec->stats.offhook) { /* this is final call */
 
                 switch_core_hash_delete(globals.device_hash, drec->device_id);
                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "Processing last call from device [%s]\n", 
                                                   drec->device_id);
                 switch_channel_set_flag(channel, CF_FINAL_DEVICE_LEG);
         } else {
                 channel->device_node = NULL;
         }
 
         drec->refs--;
 
         switch_mutex_unlock(globals.device_mutex);
         
 }

static switch_status_t send_ind	(	switch_channel_t *	channel,
		switch_core_session_message_types_t	msg_id,
		const char *	file,
		const char *	func,
		int	line
	)

static

Definition at line 3296 of file switch_channel.c.

References switch_core_session_message::from, switch_core_session_message::message_id, switch_channel::name, switch_channel::session, and switch_core_session_perform_receive_message().

Referenced by switch_channel_perform_mark_answered(), switch_channel_perform_mark_pre_answered(), and switch_channel_perform_mark_ring_ready_value().

 {
         switch_core_session_message_t msg = { 0 };
 
         msg.message_id = msg_id;
         msg.from = channel->name;
         return switch_core_session_perform_receive_message(channel->session, &msg, file, func, line);
 }

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

Definition at line 437 of file switch_channel.c.

References switch_assert, SWITCH_CALL_DIRECTION_OUTBOUND, SWITCH_CAUSE_NONE, switch_channel_direction(), switch_channel_set_variable, switch_core_alloc, switch_core_hash_init, SWITCH_DTMF_LOG_LEN, SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), switch_mutex_init(), SWITCH_MUTEX_NESTED, switch_queue_create(), SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

 {
         switch_assert(pool != NULL);
 
         if (((*channel) = switch_core_alloc(pool, sizeof(switch_channel_t))) == 0) {
                 return SWITCH_STATUS_MEMERR;
         }
 
         switch_event_create_plain(&(*channel)->variables, SWITCH_EVENT_CHANNEL_DATA);
 
         switch_core_hash_init(&(*channel)->private_hash);
         switch_queue_create(&(*channel)->dtmf_queue, SWITCH_DTMF_LOG_LEN, pool);
         switch_queue_create(&(*channel)->dtmf_log_queue, SWITCH_DTMF_LOG_LEN, pool);
 
         switch_mutex_init(&(*channel)->dtmf_mutex, SWITCH_MUTEX_NESTED, pool);
         switch_mutex_init(&(*channel)->flag_mutex, SWITCH_MUTEX_NESTED, pool);
         switch_mutex_init(&(*channel)->state_mutex, SWITCH_MUTEX_NESTED, pool);
         switch_mutex_init(&(*channel)->thread_mutex, SWITCH_MUTEX_NESTED, pool);
         switch_mutex_init(&(*channel)->profile_mutex, SWITCH_MUTEX_NESTED, pool);
         (*channel)->hangup_cause = SWITCH_CAUSE_NONE;
         (*channel)->name = "";
         (*channel)->direction = (*channel)->logical_direction = direction;
         switch_channel_set_variable(*channel, "direction", switch_channel_direction(*channel) == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
 
         return SWITCH_STATUS_SUCCESS;
 }

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

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

Definition at line 4129 of file switch_channel.c.

References switch_stream_handle::data, switch_event_header::name, profile_node_s::next, switch_event_header::next, switch_assert, switch_channel_get_caller_profile(), switch_channel_variable_first(), switch_channel_variable_last(), switch_safe_free, SWITCH_STANDARD_STREAM, switch_url_encode(), profile_node_s::val, switch_event_header::value, profile_node_s::var, switch_stream_handle::write_function, and zstr.

 {
         switch_stream_handle_t stream = { 0 };
         switch_size_t encode_len = 1024, new_len = 0;
         char *encode_buf = NULL;
         const char *prof[13] = { 0 }, *prof_names[13] = {
         0};
         char *e = NULL;
         switch_event_header_t *hi;
         uint32_t x = 0;
 
         SWITCH_STANDARD_STREAM(stream);
 
         if (prefix) {
                 stream.write_function(&stream, "%s&", prefix);
         }
 
         encode_buf = malloc(encode_len);
         switch_assert(encode_buf);
 
         if (!caller_profile) {
                 caller_profile = switch_channel_get_caller_profile(channel);
         }
 
         switch_assert(caller_profile != NULL);
 
         prof[0] = caller_profile->context;
         prof[1] = caller_profile->destination_number;
         prof[2] = caller_profile->caller_id_name;
         prof[3] = caller_profile->caller_id_number;
         prof[4] = caller_profile->network_addr;
         prof[5] = caller_profile->ani;
         prof[6] = caller_profile->aniii;
         prof[7] = caller_profile->rdnis;
         prof[8] = caller_profile->source;
         prof[9] = caller_profile->chan_name;
         prof[10] = caller_profile->uuid;
         prof[11] = caller_profile->transfer_source;
         
         prof_names[0] = "context";
         prof_names[1] = "destination_number";
         prof_names[2] = "caller_id_name";
         prof_names[3] = "caller_id_number";
         prof_names[4] = "network_addr";
         prof_names[5] = "ani";
         prof_names[6] = "aniii";
         prof_names[7] = "rdnis";
         prof_names[8] = "source";
         prof_names[9] = "chan_name";
         prof_names[10] = "uuid";
         prof_names[11] = "transfer_source";
 
         for (x = 0; prof[x]; x++) {
                 if (zstr(prof[x])) {
                         continue;
                 }
                 new_len = (strlen(prof[x]) * 3) + 1;
                 if (encode_len < new_len) {
                         char *tmp;
                         
                         encode_len = new_len;
 
                         if (!(tmp = realloc(encode_buf, encode_len))) {
                                 abort();
                         }
 
                         encode_buf = tmp;
                 }
                 switch_url_encode(prof[x], encode_buf, encode_len);
                 stream.write_function(&stream, "%s=%s&", prof_names[x], encode_buf);
         }
 
         if (channel->caller_profile->soft) {
                 profile_node_t *pn;
 
                 for(pn = channel->caller_profile->soft; pn; pn = pn->next) {
                         char *var = pn->var;
                         char *val = pn->val;
 
                         new_len = (strlen((char *) var) * 3) + 1;
                         if (encode_len < new_len) {
                                 char *tmp;
 
                                 encode_len = new_len;
 
                                 tmp = realloc(encode_buf, encode_len);
                                 switch_assert(tmp);
                                 encode_buf = tmp;
                         }
 
                         switch_url_encode((char *) val, encode_buf, encode_len);
                         stream.write_function(&stream, "%s=%s&", (char *) var, encode_buf);
 
                 }
         }
 
         if ((hi = switch_channel_variable_first(channel))) {
                 for (; hi; hi = hi->next) {
                         char *var = hi->name;
                         char *val = hi->value;
 
                         new_len = (strlen((char *) var) * 3) + 1;
                         if (encode_len < new_len) {
                                 char *tmp;
 
                                 encode_len = new_len;
 
                                 tmp = realloc(encode_buf, encode_len);
                                 switch_assert(tmp);
                                 encode_buf = tmp;
                         }
 
                         switch_url_encode((char *) val, encode_buf, encode_len);
                         stream.write_function(&stream, "%s=%s&", (char *) var, encode_buf);
 
                 }
                 switch_channel_variable_last(channel);
         }
 
         e = (char *) stream.data + (strlen((char *) stream.data) - 1);
 
         if (e && *e == '&') {
                 *e = '\0';
         }
 
         switch_safe_free(encode_buf);
 
         return stream.data;
 }

const char* switch_channel_cause2str ( switch_call_cause_t cause )

Definition at line 189 of file switch_channel.c.

References CAUSE_CHART, and switch_cause_table::name.

Referenced by switch_channel_event_set_basic_data(), switch_channel_handle_cause(), and switch_channel_perform_hangup().

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

static void switch_channel_check_device_state	(	switch_channel_t *	channel,
		switch_channel_callstate_t	callstate
	)

static

Definition at line 5031 of file switch_channel.c.

Referenced by switch_channel_perform_set_callstate(), switch_channel_process_device_hangup(), and switch_channel_set_device_id().

 {
         switch_device_record_t *drec = NULL;
         switch_device_state_binding_t *ptr = NULL;
         switch_event_t *event = NULL;
 
         if (!channel->device_node) {
                 return;
         }
 
         drec = channel->device_node->parent;
 
         switch_mutex_lock(globals.device_mutex);
         switch_mutex_lock(drec->mutex);
 
         fetch_device_stats(drec);
 
         if (drec->state != SDS_HANGUP) {
                 if (drec->stats.offhook == 0 || drec->stats.hup == drec->stats.total) {
                         drec->state = SDS_HANGUP;
                 } else {
                         if (drec->stats.active == 0) {
                                 if ((drec->stats.ringing_out + drec->stats.early_out) > 0 || drec->stats.ring_wait > 0) {
                                         drec->state = SDS_RINGING;
                                 } else {
                                         if (drec->stats.held > 0) {
                                                 drec->state = SDS_HELD;
                                         } else if (drec->stats.unheld > 0) {
                                                 drec->state = SDS_UNHELD;
                                         } else {
                                                 drec->state = SDS_DOWN;
                                         }
                                 }
                         } else if (drec->stats.active == 1) {
                                 drec->state = SDS_ACTIVE;
                         } else {
                                 drec->state = SDS_ACTIVE_MULTI;
                         }
                 }
         }
 
         if ((drec->state == SDS_DOWN && drec->last_state == SDS_DOWN) || (drec->state == SDS_HANGUP && drec->last_state == SDS_HANGUP)) {
                 switch_mutex_unlock(drec->mutex);
                 switch_mutex_unlock(globals.device_mutex);
                 return;
         }
 
         if (!drec->call_start) {
                 drec->call_start = switch_micro_time_now();
         }
 
         switch(drec->state) {
         case SDS_RINGING:
                 if (!drec->ring_start) {
                         drec->ring_start = switch_micro_time_now();
                         drec->ring_stop = 0;
                 }
                 break;
         case SDS_ACTIVE:
         case SDS_ACTIVE_MULTI:
                 if (!drec->active_start) {
                         drec->active_start = switch_micro_time_now();
                         drec->active_stop = 0;
                 }
                 break;
         case SDS_HELD:
                 if (!drec->hold_start) {
                         drec->hold_start = switch_micro_time_now();
                         drec->hold_stop = 0;
                 }
                 break;
         default:
                 break;
         }
 
         if (callstate != CCS_UNHELD && drec->active_start && drec->state != SDS_ACTIVE && drec->state != SDS_ACTIVE_MULTI) {
                 drec->active_stop = switch_micro_time_now();
         }
 
         if (drec->ring_start && !drec->ring_stop && drec->state != SDS_RINGING) {
                 drec->ring_stop = switch_micro_time_now();
         }
 
         if (drec->hold_start && !drec->hold_stop && drec->state != SDS_HELD) {
                 drec->hold_stop = switch_micro_time_now();
         }
 
 
         if (switch_event_create(&event, SWITCH_EVENT_DEVICE_STATE) == SWITCH_STATUS_SUCCESS) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-ID", drec->device_id);
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Last-Device-State", switch_channel_device_state2str(drec->last_state));
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-State", switch_channel_device_state2str(drec->state));
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Device-Call-State", switch_channel_callstate2str(callstate));
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Total-Legs", "%u", drec->stats.total);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Offhook", "%u", drec->stats.offhook);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Ringing", "%u", drec->stats.ringing);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Early", "%u", drec->stats.early);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Active", "%u", drec->stats.active);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Held", "%u", drec->stats.held);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-UnHeld", "%u", drec->stats.unheld);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Legs-Hup", "%u", drec->stats.hup);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Start-Uepoch", "%"SWITCH_TIME_T_FMT, drec->active_start);
                 if (drec->active_stop) {
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Stop-Uepoch", "%"SWITCH_TIME_T_FMT, drec->active_stop);
                         switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Device-Talk-Time-Milliseconds", "%u", (uint32_t)(drec->active_stop - drec->active_start) / 1000);
                 }
         }
 
         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG1, 
                                           "%s device: %s\nState: %s Dev State: %s/%s Total:%u Offhook:%u "
                                           "Ringing:%u Early:%u Active:%u Held:%u Unheld:%u Hungup:%u Dur: %u Ringtime: %u Holdtime: %u %s\n", 
                                           switch_channel_get_name(channel),
                                           drec->device_id,
                                           switch_channel_callstate2str(callstate),
                                           switch_channel_device_state2str(drec->last_state),
                                           switch_channel_device_state2str(drec->state),
                                           drec->stats.total,
                                           drec->stats.offhook,
                                           drec->stats.ringing,
                                           drec->stats.early,
                                           drec->stats.active,
                                           drec->stats.held,
                                           drec->stats.unheld,
                                           drec->stats.hup,
                                           drec->active_stop ? (uint32_t)(drec->active_stop - drec->active_start) / 1000 : 0,
                                           drec->ring_stop ? (uint32_t)(drec->ring_stop - drec->ring_start) / 1000 : 0,
                                           drec->hold_stop ? (uint32_t)(drec->hold_stop - drec->hold_start) / 1000 : 0,
                                           switch_channel_test_flag(channel, CF_FINAL_DEVICE_LEG) ? "FINAL LEG" : "");
 
         for (ptr = globals.device_bindings; ptr; ptr = ptr->next) {
                 ptr->function(channel->session, callstate, drec);
         }
 
         drec->last_stats = drec->stats;
 
         if (drec->active_stop) {
                 drec->active_start = drec->active_stop = 0;
                 if (drec->state == SDS_ACTIVE || drec->state == SDS_ACTIVE_MULTI) {
                         drec->active_start = switch_micro_time_now();
                 }
         }
 
         if (drec->hold_stop) {
                 drec->hold_start = drec->hold_stop = 0;
                 if (drec->state == SDS_HELD) {
                         drec->hold_start = switch_micro_time_now();
                 }
         }
 
         if (drec->ring_stop) {
                 drec->ring_start = drec->ring_stop = 0;
                 if (drec->state == SDS_RINGING) {
                         drec->ring_start = switch_micro_time_now();
                 }
         }
 
         drec->last_call_time = switch_micro_time_now();
 
         drec->last_state = drec->state;
 
         switch_mutex_unlock(drec->mutex);
         switch_mutex_unlock(globals.device_mutex);
         
 
         if (event) {
                 switch_event_fire(&event);
         }
 
 }

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

switch_status_t switch_channel_dequeue_dtmf	(	switch_channel_t *	channel,
		switch_dtmf_t *	dtmf
	)

Definition at line 623 of file switch_channel.c.

References CF_DIVERT_EVENTS, DTMF_FLAG_SENSITIVE, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_event_set_data(), switch_channel_get_name(), switch_channel_test_flag(), switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_min_dtmf_duration(), switch_core_session_queue_event(), SWITCH_DTMF_APP, SWITCH_DTMF_ENDPOINT, SWITCH_DTMF_INBAND_AUDIO, SWITCH_DTMF_RTP, SWITCH_DTMF_UNKNOWN, switch_event_add_header(), switch_event_create, SWITCH_EVENT_DTMF, switch_event_fire, switch_log_printf(), SWITCH_LOG_WARNING, switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_queue_trypush(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by switch_channel_dequeue_dtmf_string().

 {
         switch_event_t *event;
         void *pop;
         switch_dtmf_t *dt;
         switch_status_t status = SWITCH_STATUS_FALSE;
         int sensitive = 0;
 
         switch_mutex_lock(channel->dtmf_mutex);
 
         if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 dt = (switch_dtmf_t *) pop;
                 *dtmf = *dt;
                 sensitive = switch_test_flag(dtmf, DTMF_FLAG_SENSITIVE);
 
                 if (!sensitive && switch_queue_trypush(channel->dtmf_log_queue, dt) != SWITCH_STATUS_SUCCESS) {
                         free(dt);
                 }
 
                 dt = NULL;
 
                 if (dtmf->duration > switch_core_max_dtmf_duration(0)) {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_WARNING, "%s EXCESSIVE DTMF DIGIT [%c] LEN [%d]\n",
                                                           switch_channel_get_name(channel), sensitive ? 'S' : dtmf->digit, dtmf->duration);
                         dtmf->duration = switch_core_max_dtmf_duration(0);
                 } else if (dtmf->duration < switch_core_min_dtmf_duration(0)) {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_WARNING, "%s SHORT DTMF DIGIT [%c] LEN [%d]\n",
                                                           switch_channel_get_name(channel), sensitive ? 'S' : dtmf->digit, dtmf->duration);
                         dtmf->duration = switch_core_min_dtmf_duration(0);
                 } else if (!dtmf->duration) {
                         dtmf->duration = switch_core_default_dtmf_duration(0);
                 }
 
                 status = SWITCH_STATUS_SUCCESS;
         }
         switch_mutex_unlock(channel->dtmf_mutex);
 
         if (!sensitive && status == SWITCH_STATUS_SUCCESS && switch_event_create(&event, SWITCH_EVENT_DTMF) == SWITCH_STATUS_SUCCESS) {
                 const char *dtmf_source_str = NULL;
                 switch_channel_event_set_data(channel, event);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Digit", "%c", dtmf->digit);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Duration", "%u", dtmf->duration);
                 switch(dtmf->source) {
                         case SWITCH_DTMF_INBAND_AUDIO:  /* From audio */
                                 dtmf_source_str = "INBAND_AUDIO";
                                 break;
                         case SWITCH_DTMF_RTP:                   /* From RTP as a telephone event */
                                 dtmf_source_str = "RTP";
                                 break;
                         case SWITCH_DTMF_ENDPOINT:              /* From endpoint signaling */
                                 dtmf_source_str = "ENDPOINT";
                                 break;
                         case SWITCH_DTMF_APP:                   /* Injected by application */
                                 dtmf_source_str = "APP";
                                 break;
                         case SWITCH_DTMF_UNKNOWN:               /* Unknown source */
                         default:
                                 dtmf_source_str = "UNKNOWN";
                                 break;
                 }
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "DTMF-Source", "%s", dtmf_source_str);
                 if (switch_channel_test_flag(channel, CF_DIVERT_EVENTS)) {
                         switch_core_session_queue_event(channel->session, &event);
                 } else {
                         switch_event_fire(&event);
                 }
         }
 
         return status;
 }

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

Definition at line 694 of file switch_channel.c.

References switch_dtmf_t::digit, memset(), switch_channel_dequeue_dtmf(), and SWITCH_STATUS_SUCCESS.

 {
         switch_size_t x = 0;
         switch_dtmf_t dtmf = { 0 };
 
         memset(dtmf_str, 0, len);
 
         while (x < len - 1 && switch_channel_dequeue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
                 dtmf_str[x++] = dtmf.digit;
         }
 
         return x;
 
 }

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

void switch_channel_event_set_basic_data	(	switch_channel_t *	channel,
		switch_event_t *	event
	)

Definition at line 2507 of file switch_channel.c.

References switch_codec_implementation::actual_samples_per_second, switch_codec_implementation::bits_per_second, CF_ANSWERED, CF_DIALPLAN, CF_EARLY_MEDIA, switch_codec_implementation::iananame, LP_ORIGINATEE, LP_ORIGINATOR, switch_caller_profile::originatee_caller_profile, switch_caller_profile::originator_caller_profile, SWITCH_CALL_DIRECTION_INBOUND, SWITCH_CALL_DIRECTION_OUTBOUND, switch_caller_profile_event_set_data(), switch_channel_callstate2str(), switch_channel_cause2str(), switch_channel_direction(), switch_channel_down_nosig, switch_channel_get_name(), switch_channel_get_variable_dup(), switch_channel_state_name(), switch_channel_test_flag(), switch_core_session_get_read_impl(), switch_core_session_get_uuid(), switch_core_session_get_write_impl(), switch_event_add_header(), switch_event_add_header_string(), switch_event_add_presence_data_cols(), SWITCH_FALSE, switch_mutex_lock(), switch_mutex_unlock(), switch_snprintf(), and SWITCH_STACK_BOTTOM.

Referenced by switch_channel_event_set_data().

 {
         switch_caller_profile_t *caller_profile, *originator_caller_profile = NULL, *originatee_caller_profile = NULL;
         switch_codec_implementation_t impl = { 0 };
         char state_num[25];
         const char *v;
 
         switch_mutex_lock(channel->profile_mutex);
 
         if ((caller_profile = channel->caller_profile)) {
                 originator_caller_profile = caller_profile->originator_caller_profile;
                 originatee_caller_profile = caller_profile->originatee_caller_profile;
         }
 
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-State", switch_channel_state_name(channel->running_state));
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-State", switch_channel_callstate2str(channel->callstate));
         switch_snprintf(state_num, sizeof(state_num), "%d", channel->state);
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-State-Number", state_num);
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Name", switch_channel_get_name(channel));
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(channel->session));
 
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Call-Direction",
                                                                    channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Call-Direction",
                                                                    channel->direction == SWITCH_CALL_DIRECTION_OUTBOUND ? "outbound" : "inbound");
 
         switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-HIT-Dialplan", 
                                                                    switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND ||
                                                                    switch_channel_test_flag(channel, CF_DIALPLAN) ? "true" : "false");
 
 
         if ((v = switch_channel_get_variable_dup(channel, "presence_id", SWITCH_FALSE, -1))) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Presence-ID", v);
         }
 
         if ((v = switch_channel_get_variable_dup(channel, "presence_data", SWITCH_FALSE, -1))) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Presence-Data", v);
         }
 
 
         if ((v = switch_channel_get_variable_dup(channel, "presence_data_cols", SWITCH_FALSE, -1))) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Presence-Data-Cols", v);
                 switch_event_add_presence_data_cols(channel, event, "PD-");
         }
 
         if ((v = switch_channel_get_variable_dup(channel, "call_uuid", SWITCH_FALSE, -1))) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-UUID", v);
         } else {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Call-UUID", switch_core_session_get_uuid(channel->session));
         }
 
         if (switch_channel_down_nosig(channel)) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "hangup");
         } else if (switch_channel_test_flag(channel, CF_ANSWERED)) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "answered");
         } else if (switch_channel_test_flag(channel, CF_EARLY_MEDIA)) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "early");
         } else {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Answer-State", "ringing");
         }
 
         if (channel->hangup_cause) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Hangup-Cause", switch_channel_cause2str(channel->hangup_cause));
         }
 
 
         switch_core_session_get_read_impl(channel->session, &impl);
 
         if (impl.iananame) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Name", impl.iananame);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Rate", "%u", impl.actual_samples_per_second);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Read-Codec-Bit-Rate", "%d", impl.bits_per_second);
         }
 
         switch_core_session_get_write_impl(channel->session, &impl);
 
         if (impl.iananame) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Name", impl.iananame);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Rate", "%u", impl.actual_samples_per_second);
                 switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Channel-Write-Codec-Bit-Rate", "%d", impl.bits_per_second);
         }
 
         /* Index Caller's Profile */
         if (caller_profile) {
                 switch_caller_profile_event_set_data(caller_profile, "Caller", event);
         }
 
         /* Index Originator/ee's Profile */
         if (originator_caller_profile && channel->last_profile_type == LP_ORIGINATOR) {
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Other-Type", "originator");
                 switch_caller_profile_event_set_data(originator_caller_profile, "Other-Leg", event);
         } else if (originatee_caller_profile && channel->last_profile_type == LP_ORIGINATEE) {  /* Index Originatee's Profile */
                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Other-Type", "originatee");
                 switch_caller_profile_event_set_data(originatee_caller_profile, "Other-Leg", event);
         }
 
 
         switch_mutex_unlock(channel->profile_mutex);
 }

void switch_channel_event_set_data	(	switch_channel_t *	channel,
		switch_event_t *	event
	)

Definition at line 2689 of file switch_channel.c.

References switch_channel_event_set_basic_data(), switch_channel_event_set_extended_data(), switch_mutex_lock(), and switch_mutex_unlock().

Referenced by switch_channel_dequeue_dtmf(), switch_channel_flip_cid(), switch_channel_mark_hold(), 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_presence(), switch_channel_perform_set_callstate(), and switch_channel_perform_set_running_state().

 {
         switch_mutex_lock(channel->profile_mutex);
         switch_channel_event_set_basic_data(channel, event);
         switch_channel_event_set_extended_data(channel, event);
         switch_mutex_unlock(channel->profile_mutex);
 }

void switch_channel_event_set_extended_data	(	switch_channel_t *	channel,
		switch_event_t *	event
	)

Definition at line 2607 of file switch_channel.c.

Referenced by process_device_hup(), and switch_channel_event_set_data().

 {
         switch_event_header_t *hi;
         int global_verbose_events = -1;
 
         switch_mutex_lock(channel->profile_mutex);
 
         switch_core_session_ctl(SCSC_VERBOSE_EVENTS, &global_verbose_events);
 
         if (global_verbose_events || 
                 switch_channel_test_flag(channel, CF_VERBOSE_EVENTS) ||
                 switch_event_get_header(event, "presence-data-cols") ||
                 event->event_id == SWITCH_EVENT_CHANNEL_CREATE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_ORIGINATE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_UUID ||
                 event->event_id == SWITCH_EVENT_CHANNEL_ANSWER ||
                 event->event_id == SWITCH_EVENT_CHANNEL_PARK ||
                 event->event_id == SWITCH_EVENT_CHANNEL_UNPARK ||
                 event->event_id == SWITCH_EVENT_CHANNEL_BRIDGE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_UNBRIDGE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_PROGRESS ||
                 event->event_id == SWITCH_EVENT_CHANNEL_PROGRESS_MEDIA ||
                 event->event_id == SWITCH_EVENT_CHANNEL_HANGUP ||
                 event->event_id == SWITCH_EVENT_CHANNEL_HANGUP_COMPLETE ||
                 event->event_id == SWITCH_EVENT_REQUEST_PARAMS ||
                 event->event_id == SWITCH_EVENT_CHANNEL_DATA ||
                 event->event_id == SWITCH_EVENT_CHANNEL_EXECUTE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_EXECUTE_COMPLETE ||
                 event->event_id == SWITCH_EVENT_CHANNEL_DESTROY ||
                 event->event_id == SWITCH_EVENT_SESSION_HEARTBEAT ||
                 event->event_id == SWITCH_EVENT_API ||
                 event->event_id == SWITCH_EVENT_RECORD_START ||
                 event->event_id == SWITCH_EVENT_RECORD_STOP || 
                 event->event_id == SWITCH_EVENT_PLAYBACK_START ||
                 event->event_id == SWITCH_EVENT_PLAYBACK_STOP ||
                 event->event_id == SWITCH_EVENT_CALL_UPDATE || 
                 event->event_id == SWITCH_EVENT_MEDIA_BUG_START || 
                 event->event_id == SWITCH_EVENT_MEDIA_BUG_STOP || 
                 event->event_id == SWITCH_EVENT_CUSTOM) {
 
                 /* Index Variables */
 
                 if (channel->scope_variables) {
                         switch_event_t *ep;
 
                         for (ep = channel->scope_variables; ep; ep = ep->next) {
                                 for (hi = ep->headers; hi; hi = hi->next) {
                                         char buf[1024];
                                         char *vvar = NULL, *vval = NULL;
                                         
                                         vvar = (char *) hi->name;
                                         vval = (char *) hi->value;
                                                 
                                         switch_assert(vvar && vval);
                                         switch_snprintf(buf, sizeof(buf), "scope_variable_%s", vvar);
                                         
                                         if (!switch_event_get_header(event, buf)) {
                                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, buf, vval);
                                         }
                                 }
                         }
                 }
 
                 if (channel->variables) {
                         for (hi = channel->variables->headers; hi; hi = hi->next) {
                                 char buf[1024];
                                 char *vvar = NULL, *vval = NULL;
 
                                 vvar = (char *) hi->name;
                                 vval = (char *) hi->value;
                                 
                                 switch_assert(vvar && vval);
                                 switch_snprintf(buf, sizeof(buf), "variable_%s", vvar);
                                 switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, buf, vval);
                         }
                 }
         }
 
         switch_mutex_unlock(channel->profile_mutex);
 }

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

void switch_channel_flush_dtmf ( switch_channel_t * channel )

Definition at line 709 of file switch_channel.c.

References CS_HANGUP, switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_queue_trypush(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_channel_uninit().

 {
         void *pop;
 
         switch_mutex_lock(channel->dtmf_mutex);
         while (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 switch_dtmf_t *dt = (switch_dtmf_t *) pop;
                 if (channel->state >= CS_HANGUP || switch_queue_trypush(channel->dtmf_log_queue, dt) != SWITCH_STATUS_SUCCESS) {
                         free(dt);
                 }
         }
         switch_mutex_unlock(channel->dtmf_mutex);
 }

switch_call_cause_t switch_channel_get_cause ( switch_channel_t * channel )

Definition at line 225 of file switch_channel.c.

 {
         return channel->hangup_cause;
 }

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

switch_channel_timetable_t* switch_channel_get_timetable ( switch_channel_t * channel )

Definition at line 406 of file switch_channel.c.

References switch_mutex_lock(), and switch_mutex_unlock().

 {
         switch_channel_timetable_t *times = NULL;
 
         if (channel->caller_profile) {
                 switch_mutex_lock(channel->profile_mutex);
                 times = channel->caller_profile->times;
                 switch_mutex_unlock(channel->profile_mutex);
         }
 
         return times;
 }

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_size_t switch_channel_has_dtmf ( switch_channel_t * channel )

Definition at line 479 of file switch_channel.c.

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

 {
         switch_size_t has;
 
         switch_mutex_lock(channel->dtmf_mutex);
         has = switch_queue_size(channel->dtmf_queue);
         switch_mutex_unlock(channel->dtmf_mutex);
 
         return has;
 }

switch_channel_state_t switch_channel_name_state ( const char * name )

Definition at line 2178 of file switch_channel.c.

References CS_DESTROY.

 {
         uint32_t x = 0;
         for (x = 0; state_names[x]; x++) {
                 if (!strcasecmp(state_names[x], name)) {
                         return (switch_channel_state_t) x;
                 }
         }
 
         return CS_DESTROY;
 }

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

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

Definition at line 490 of file switch_channel.c.

References switch_dtmf_t::digit, DTMF_FLAG_SENSITIVE, switch_dtmf_t::duration, is_dtmf, switch_assert, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_get_name(), switch_channel_get_variable_dup(), switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_media_break(), switch_core_min_dtmf_duration(), switch_core_session_recv_dtmf(), SWITCH_FALSE, SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_MEDIA_TYPE_AUDIO, switch_mutex_lock(), switch_mutex_unlock(), switch_queue_trypop(), switch_queue_trypush(), SWITCH_SENSITIVE_DTMF_VARIABLE, switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), and switch_zmalloc.

Referenced by switch_channel_queue_dtmf_string().

 {
         switch_status_t status;
         void *pop;
         switch_dtmf_t new_dtmf = { 0 };
         switch_bool_t sensitive = switch_true(switch_channel_get_variable_dup(channel, SWITCH_SENSITIVE_DTMF_VARIABLE, SWITCH_FALSE, -1));
 
         switch_assert(dtmf);
 
         switch_mutex_lock(channel->dtmf_mutex);
         new_dtmf = *dtmf;
 
         if (sensitive) {
                 switch_set_flag((&new_dtmf), DTMF_FLAG_SENSITIVE);
         }
 
         if ((status = switch_core_session_recv_dtmf(channel->session, dtmf) != SWITCH_STATUS_SUCCESS)) {
                 goto done;
         }
 
         if (is_dtmf(new_dtmf.digit)) {
                 switch_dtmf_t *dt;
                 int x = 0;
 
                 if (!sensitive) {
                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_INFO, "RECV DTMF %c:%d\n", new_dtmf.digit, new_dtmf.duration);
                 }
 
                 if (new_dtmf.digit != 'w' && new_dtmf.digit != 'W') {
                         if (new_dtmf.duration > switch_core_max_dtmf_duration(0)) {
                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "%s EXCESSIVE DTMF DIGIT LEN [%d]\n",
                                                                   switch_channel_get_name(channel), new_dtmf.duration);
                                 new_dtmf.duration = switch_core_max_dtmf_duration(0);
                         } else if (new_dtmf.duration < switch_core_min_dtmf_duration(0)) {
                                 switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "%s SHORT DTMF DIGIT LEN [%d]\n",
                                                                   switch_channel_get_name(channel), new_dtmf.duration);
                                 new_dtmf.duration = switch_core_min_dtmf_duration(0);
                         } 
                 }
                 
                 if (!new_dtmf.duration) {
                         new_dtmf.duration = switch_core_default_dtmf_duration(0);
                 }
                 
 
                 switch_zmalloc(dt, sizeof(*dt));
                 *dt = new_dtmf;
 
 
                 while (switch_queue_trypush(channel->dtmf_queue, dt) != SWITCH_STATUS_SUCCESS) {
                         if (switch_queue_trypop(channel->dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                                 free(pop);
                         }
                         if (++x > 100) {
                                 status = SWITCH_STATUS_FALSE;
                                 free(dt);
                                 goto done;
                         }
                 }
         }
 
         status = SWITCH_STATUS_SUCCESS;
 
   done:
 
         switch_mutex_unlock(channel->dtmf_mutex);
 
         switch_core_media_break(channel->session, SWITCH_MEDIA_TYPE_AUDIO);
 
         return status;
 }

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

Definition at line 562 of file switch_channel.c.

References switch_dtmf_t::digit, DTMF_FLAG_SKIP_PROCESS, switch_dtmf_t::duration, switch_dtmf_t::flags, is_dtmf, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_get_name(), switch_channel_queue_dtmf(), switch_core_default_dtmf_duration(), switch_core_max_dtmf_duration(), switch_core_min_dtmf_duration(), switch_core_session_strdup, SWITCH_DTMF_APP, SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_LOG_WARNING, switch_separate_string(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

 {
         char *p;
         switch_dtmf_t dtmf = { 0, switch_core_default_dtmf_duration(0), 0, SWITCH_DTMF_APP };
         int sent = 0, dur;
         char *string;
         int i, argc;
         char *argv[256];
 
         if (zstr(dtmf_string)) {
                 return SWITCH_STATUS_FALSE;
         }
 
 
         dtmf.flags = DTMF_FLAG_SKIP_PROCESS;
 
         if (*dtmf_string == '~') {
                 dtmf_string++;
                 dtmf.flags = 0;
         }
 
         string = switch_core_session_strdup(channel->session, dtmf_string);
         argc = switch_separate_string(string, '+', argv, (sizeof(argv) / sizeof(argv[0])));
 
         for (i = 0; i < argc; i++) {
                 dtmf.duration = switch_core_default_dtmf_duration(0);
                 dur = switch_core_default_dtmf_duration(0) / 8;
                 if ((p = strchr(argv[i], '@'))) {
                         *p++ = '\0';
                         if ((dur = atoi(p)) > (int)switch_core_min_dtmf_duration(0) / 8) {
                                 dtmf.duration = dur * 8;
                         }
                 }
 
                 for (p = argv[i]; p && *p; p++) {
                         if (is_dtmf(*p)) {
                                 dtmf.digit = *p;
 
                                 if (dtmf.duration > switch_core_max_dtmf_duration(0)) {
                                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_WARNING, "EXCESSIVE DTMF DIGIT LEN %c %d\n", dtmf.digit, dtmf.duration);
                                         dtmf.duration = switch_core_max_dtmf_duration(0);
                                 } else if (dtmf.duration < switch_core_min_dtmf_duration(0)) {
                                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_WARNING, "SHORT DTMF DIGIT LEN %c %d\n", dtmf.digit, dtmf.duration);
                                         dtmf.duration = switch_core_min_dtmf_duration(0);
                                 } else if (!dtmf.duration) {
                                         dtmf.duration = switch_core_default_dtmf_duration(0);
                                 }
 
                                 if (switch_channel_queue_dtmf(channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
                                         switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "%s Queue dtmf\ndigit=%c ms=%u samples=%u\n",
                                                                           switch_channel_get_name(channel), dtmf.digit, dur, dtmf.duration);
                                         sent++;
                                 }
                         }
                 }
 
         }
 
         return sent ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
 }

void switch_channel_release_device_record ( switch_device_record_t ** drecp )

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

switch_status_t switch_channel_set_timestamps ( switch_channel_t * channel )

Definition at line 4304 of file switch_channel.c.

 {
         switch_status_t status = SWITCH_STATUS_SUCCESS;
         const char *cid_buf = NULL;
         switch_caller_profile_t *caller_profile;
         switch_app_log_t *app_log, *ap;
         char *last_app = NULL, *last_arg = NULL;
         char start[80] = "", resurrect[80] = "", answer[80] = "", hold[80], 
                 bridge[80] = "", progress[80] = "", progress_media[80] = "", end[80] = "", tmp[80] = "",
                 profile_start[80] =     "";
         int32_t duration = 0, legbillsec = 0, billsec = 0, mduration = 0, billmsec = 0, legbillmsec = 0, progressmsec = 0, progress_mediamsec = 0;
         int32_t answersec = 0, answermsec = 0, waitsec = 0, waitmsec = 0;
         switch_time_t answerusec = 0;
         switch_time_t uduration = 0, legbillusec = 0, billusec = 0, progresssec = 0, progressusec = 0, progress_mediasec = 0, progress_mediausec = 0, waitusec = 0;
         time_t tt_created = 0, tt_answered = 0, tt_resurrected = 0, tt_bridged, tt_last_hold, tt_hold_accum,
                 tt_progress = 0, tt_progress_media = 0, tt_hungup = 0, mtt_created = 0, mtt_answered = 0, mtt_bridged = 0,
                 mtt_hungup = 0, tt_prof_created, mtt_progress = 0, mtt_progress_media = 0;
         void *pop;
         char dtstr[SWITCH_DTMF_LOG_LEN + 1] = "";
         int x = 0;
 
         switch_mutex_lock(channel->profile_mutex);
 
         if (switch_channel_test_flag(channel, CF_TIMESTAMP_SET)) {
                 switch_mutex_unlock(channel->profile_mutex);
                 return SWITCH_STATUS_FALSE;
         }
 
         if (!(caller_profile = channel->caller_profile) || !channel->variables) {
                 switch_mutex_unlock(channel->profile_mutex);
                 return SWITCH_STATUS_FALSE;
         }
 
         switch_channel_set_flag(channel, CF_TIMESTAMP_SET);
 
         if ((app_log = switch_core_session_get_app_log(channel->session))) {
                 for (ap = app_log; ap && ap->next; ap = ap->next);
                 last_app = ap->app;
                 last_arg = ap->arg;
         }
 
         if (!zstr(caller_profile->caller_id_name)) {
                 cid_buf = switch_core_session_sprintf(channel->session, "\"%s\" <%s>", caller_profile->caller_id_name,
                                                                                           switch_str_nil(caller_profile->caller_id_number));
         } else {
                 cid_buf = caller_profile->caller_id_number;
         }
 
         while (x < SWITCH_DTMF_LOG_LEN && switch_queue_trypop(channel->dtmf_log_queue, &pop) == SWITCH_STATUS_SUCCESS) {
                 switch_dtmf_t *dt = (switch_dtmf_t *) pop;
 
                 if (dt) {
                         dtstr[x++] = dt->digit;
                         free(dt);
                         dt = NULL;
                 }
         }
 
         if (x) {
                 const char *var = switch_channel_get_variable(channel, "digits_dialed_filter");
                 char *digit_string = dtstr;
                 char *X = NULL;
                 switch_regex_t *re = NULL;
                 char *substituted = NULL;
 
                 if (!zstr(var)) {
                         int proceed = 0;
                         int ovector[30];
 
                         if ((proceed = switch_regex_perform(dtstr, var, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                                 int len = (strlen(dtstr) + strlen(var) + 10) * proceed;
                                 int i = 0;
                                 const char *replace = NULL;
 
                                 X = malloc(len);
                                 
                                 for (i = 0; i < proceed; i++) {
                                         if (pcre_get_substring(dtstr, ovector, proceed, i, &replace) > 0) {
                                                 switch_size_t plen = strlen(replace);
                                                 memset(X, 'X', plen);
                                                 *(X+plen) = '\0';
 
                                                 switch_safe_free(substituted);
                                                 substituted = switch_string_replace(substituted ? substituted : dtstr, replace, X);
                                                 
                                                 pcre_free_substring(replace);
                                         }
                                 }
                                 
                                 if (!zstr(substituted)) {
                                         digit_string = substituted;
                                 }
                         }
                 }
 
                 switch_channel_set_variable(channel, "digits_dialed", digit_string);
                 switch_regex_safe_free(re);
                 switch_safe_free(substituted);
                 switch_safe_free(X);
         } else {
                 switch_channel_set_variable(channel, "digits_dialed", "none");
         }
 
         if (caller_profile->times) {
                 switch_time_exp_t tm;
                 switch_size_t retsize;
                 const char *fmt = "%Y-%m-%d %T";
 
                 switch_time_exp_lt(&tm, caller_profile->times->created);
                 switch_strftime_nocheck(start, &retsize, sizeof(start), fmt, &tm);
                 switch_channel_set_variable(channel, "start_stamp", start);
 
                 switch_time_exp_lt(&tm, caller_profile->times->profile_created);
                 switch_strftime_nocheck(profile_start, &retsize, sizeof(profile_start), fmt, &tm);
                 switch_channel_set_variable(channel, "profile_start_stamp", profile_start);
 
                 if (caller_profile->times->answered) {
                         switch_time_exp_lt(&tm, caller_profile->times->answered);
                         switch_strftime_nocheck(answer, &retsize, sizeof(answer), fmt, &tm);
                         switch_channel_set_variable(channel, "answer_stamp", answer);
                 }
 
                 if (caller_profile->times->bridged) {
                         switch_time_exp_lt(&tm, caller_profile->times->bridged);
                         switch_strftime_nocheck(bridge, &retsize, sizeof(bridge), fmt, &tm);
                         switch_channel_set_variable(channel, "bridge_stamp", bridge);
                 }
 
                 if (caller_profile->times->last_hold) {
                         switch_time_exp_lt(&tm, caller_profile->times->last_hold);
                         switch_strftime_nocheck(hold, &retsize, sizeof(hold), fmt, &tm);
                         switch_channel_set_variable(channel, "hold_stamp", hold);
                 }
 
                 if (caller_profile->times->resurrected) {
                         switch_time_exp_lt(&tm, caller_profile->times->resurrected);
                         switch_strftime_nocheck(resurrect, &retsize, sizeof(resurrect), fmt, &tm);
                         switch_channel_set_variable(channel, "resurrect_stamp", resurrect);
                 }
 
                 if (caller_profile->times->progress) {
                         switch_time_exp_lt(&tm, caller_profile->times->progress);
                         switch_strftime_nocheck(progress, &retsize, sizeof(progress), fmt, &tm);
                         switch_channel_set_variable(channel, "progress_stamp", progress);
                 }
 
                 if (caller_profile->times->progress_media) {
                         switch_time_exp_lt(&tm, caller_profile->times->progress_media);
                         switch_strftime_nocheck(progress_media, &retsize, sizeof(progress_media), fmt, &tm);
                         switch_channel_set_variable(channel, "progress_media_stamp", progress_media);
                 }
 
                 if (channel->hold_record) {
                         switch_hold_record_t *hr;
                         switch_stream_handle_t stream = { 0 };
 
                         SWITCH_STANDARD_STREAM(stream);
 
                         stream.write_function(&stream, "{", SWITCH_VA_NONE);
 
                         for (hr = channel->hold_record; hr; hr = hr->next) {
                                 stream.write_function(&stream, "{%"SWITCH_TIME_T_FMT",%"SWITCH_TIME_T_FMT"},", hr->on, hr->off);
                         }
                         end_of((char *)stream.data) = '}';
 
                         switch_channel_set_variable(channel, "hold_events", (char *)stream.data);
                         free(stream.data);
                 }
 
                 switch_time_exp_lt(&tm, caller_profile->times->hungup);
                 switch_strftime_nocheck(end, &retsize, sizeof(end), fmt, &tm);
                 switch_channel_set_variable(channel, "end_stamp", end);
 
                 tt_created = (time_t) (caller_profile->times->created / 1000000);
                 mtt_created = (time_t) (caller_profile->times->created / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_created);
                 switch_channel_set_variable(channel, "start_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->created);
                 switch_channel_set_variable(channel, "start_uepoch", tmp);
 
                 tt_prof_created = (time_t) (caller_profile->times->profile_created / 1000000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_prof_created);
                 switch_channel_set_variable(channel, "profile_start_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->profile_created);
                 switch_channel_set_variable(channel, "profile_start_uepoch", tmp);
 
                 tt_answered = (time_t) (caller_profile->times->answered / 1000000);
                 mtt_answered = (time_t) (caller_profile->times->answered / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_answered);
                 switch_channel_set_variable(channel, "answer_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->answered);
                 switch_channel_set_variable(channel, "answer_uepoch", tmp);
 
                 tt_bridged = (time_t) (caller_profile->times->bridged / 1000000);
                 mtt_bridged = (time_t) (caller_profile->times->bridged / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_bridged);
                 switch_channel_set_variable(channel, "bridge_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->bridged);
                 switch_channel_set_variable(channel, "bridge_uepoch", tmp);
 
                 tt_last_hold = (time_t) (caller_profile->times->last_hold / 1000000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_last_hold);
                 switch_channel_set_variable(channel, "last_hold_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->last_hold);
                 switch_channel_set_variable(channel, "last_hold_uepoch", tmp);
 
                 tt_hold_accum = (time_t) (caller_profile->times->hold_accum / 1000000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_hold_accum);
                 switch_channel_set_variable(channel, "hold_accum_seconds", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hold_accum);
                 switch_channel_set_variable(channel, "hold_accum_usec", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hold_accum / 1000);
                 switch_channel_set_variable(channel, "hold_accum_ms", tmp);
 
                 tt_resurrected = (time_t) (caller_profile->times->resurrected / 1000000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_resurrected);
                 switch_channel_set_variable(channel, "resurrect_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->resurrected);
                 switch_channel_set_variable(channel, "resurrect_uepoch", tmp);
 
                 tt_progress = (time_t) (caller_profile->times->progress / 1000000);
                 mtt_progress = (time_t) (caller_profile->times->progress / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_progress);
                 switch_channel_set_variable(channel, "progress_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress);
                 switch_channel_set_variable(channel, "progress_uepoch", tmp);
 
                 tt_progress_media = (time_t) (caller_profile->times->progress_media / 1000000);
                 mtt_progress_media = (time_t) (caller_profile->times->progress_media / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_progress_media);
                 switch_channel_set_variable(channel, "progress_media_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->progress_media);
                 switch_channel_set_variable(channel, "progress_media_uepoch", tmp);
 
                 tt_hungup = (time_t) (caller_profile->times->hungup / 1000000);
                 mtt_hungup = (time_t) (caller_profile->times->hungup / 1000);
                 switch_snprintf(tmp, sizeof(tmp), "%" TIME_T_FMT, tt_hungup);
                 switch_channel_set_variable(channel, "end_epoch", tmp);
                 switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, caller_profile->times->hungup);
                 switch_channel_set_variable(channel, "end_uepoch", tmp);
 
                 duration = (int32_t) (tt_hungup - tt_created);
                 mduration = (int32_t) (mtt_hungup - mtt_created);
                 uduration = caller_profile->times->hungup - caller_profile->times->created;
 
                 if (caller_profile->times->bridged > caller_profile->times->created) {
                         waitsec = (int32_t) (tt_bridged - tt_created);
                         waitmsec = (int32_t) (mtt_bridged - mtt_created);
                         waitusec = caller_profile->times->bridged - caller_profile->times->created;
                 } else {
                         waitsec = 0;
                         waitmsec = 0;
                         waitusec = 0;
                 }
 
                 if (caller_profile->times->answered) {
                         billsec = (int32_t) (tt_hungup - tt_answered);
                         billmsec = (int32_t) (mtt_hungup - mtt_answered);
                         billusec = caller_profile->times->hungup - caller_profile->times->answered;
 
                         legbillsec = (int32_t) (tt_hungup - tt_created);
                         legbillmsec = (int32_t) (mtt_hungup - mtt_created);
                         legbillusec = caller_profile->times->hungup - caller_profile->times->created;
 
                         answersec = (int32_t) (tt_answered - tt_created);
                         answermsec = (int32_t) (mtt_answered - mtt_created);
                         answerusec = caller_profile->times->answered - caller_profile->times->created;
                 }
 
                 if (caller_profile->times->progress) {
                         progresssec = (int32_t) (tt_progress - tt_created);
                         progressmsec = (int32_t) (mtt_progress - mtt_created);
                         progressusec = caller_profile->times->progress - caller_profile->times->created;
                 }
 
                 if (caller_profile->times->progress_media) {
                         progress_mediasec = (int32_t) (tt_progress_media - tt_created);
                         progress_mediamsec = (int32_t) (mtt_progress_media - mtt_created);
                         progress_mediausec = caller_profile->times->progress_media - caller_profile->times->created;
                 }
 
         }
 
         switch_channel_set_variable(channel, "last_app", last_app);
         switch_channel_set_variable(channel, "last_arg", last_arg);
         switch_channel_set_variable(channel, "caller_id", cid_buf);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", duration);
         switch_channel_set_variable(channel, "duration", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", billsec);
         switch_channel_set_variable(channel, "billsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%"SWITCH_TIME_T_FMT, progresssec);
         switch_channel_set_variable(channel, "progresssec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", answersec);
         switch_channel_set_variable(channel, "answersec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", waitsec);
         switch_channel_set_variable(channel, "waitsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%"SWITCH_TIME_T_FMT, progress_mediasec);
         switch_channel_set_variable(channel, "progress_mediasec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", legbillsec);
         switch_channel_set_variable(channel, "flow_billsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", mduration);
         switch_channel_set_variable(channel, "mduration", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", billmsec);
         switch_channel_set_variable(channel, "billmsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", progressmsec);
         switch_channel_set_variable(channel, "progressmsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", answermsec);
         switch_channel_set_variable(channel, "answermsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", waitmsec);
         switch_channel_set_variable(channel, "waitmsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", progress_mediamsec);
         switch_channel_set_variable(channel, "progress_mediamsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%d", legbillmsec);
         switch_channel_set_variable(channel, "flow_billmsec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, uduration);
         switch_channel_set_variable(channel, "uduration", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, billusec);
         switch_channel_set_variable(channel, "billusec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, progressusec);
         switch_channel_set_variable(channel, "progressusec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, answerusec);
         switch_channel_set_variable(channel, "answerusec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, waitusec);
         switch_channel_set_variable(channel, "waitusec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, progress_mediausec);
         switch_channel_set_variable(channel, "progress_mediausec", tmp);
 
         switch_snprintf(tmp, sizeof(tmp), "%" SWITCH_TIME_T_FMT, legbillusec);
         switch_channel_set_variable(channel, "flow_billusec", tmp);
 
         switch_mutex_unlock(channel->profile_mutex);
 
         return status;
 }

const char* switch_channel_state_name ( switch_channel_state_t state )

Definition at line 2172 of file switch_channel.c.

Referenced by switch_channel_event_set_basic_data().

 {
         return state_names[state];
 }

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

switch_call_cause_t switch_channel_str2cause ( const char * str )

Definition at line 204 of file switch_channel.c.

References switch_cause_table::cause, CAUSE_CHART, SWITCH_CAUSE_NORMAL_CLEARING, and zstr.

 {
         uint8_t x;
         switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;
 
         if (!zstr(str)) {
                 if (*str > 47 && *str < 58) {
                         cause = atoi(str);
                 } else {
                         for (x = 0; x < (sizeof(CAUSE_CHART) / sizeof(struct switch_cause_table)) - 1 && CAUSE_CHART[x].name; x++) {
                                 if (!strcasecmp(CAUSE_CHART[x].name, str)) {
                                         cause = CAUSE_CHART[x].cause;
                                         break;
                                 }
                         }
                 }
         }
 
         return cause;
 }

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

switch_status_t switch_event_base_add_header	(	switch_event_t *	event,
		switch_stack_t	stack,
		const char *	header_name,
		char *	data
	)

Variable Documentation

struct switch_callstate_table CALLSTATE_CHART[]

static

Initial value:

= {
        {"DOWN", CCS_DOWN},
        {"DIALING", CCS_DIALING},
        {"RINGING", CCS_RINGING},
        {"EARLY", CCS_EARLY},
        {"ACTIVE", CCS_ACTIVE},
        {"HELD", CCS_HELD},
        {"RING_WAIT", CCS_RING_WAIT},
        {"HANGUP", CCS_HANGUP},
        {"UNHELD", CCS_UNHELD},
        {NULL, 0}
}

Definition at line 241 of file switch_channel.c.

Referenced by switch_channel_callstate2str(), and switch_channel_str2callstate().

struct switch_cause_table CAUSE_CHART[]

static

Definition at line 56 of file switch_channel.c.

Referenced by switch_channel_cause2str(), and switch_channel_str2cause().

switch_device_state_binding_t* device_bindings

Definition at line 53 of file switch_channel.c.

switch_hash_t* device_hash

Definition at line 51 of file switch_channel.c.

switch_mutex_t* device_mutex

Definition at line 52 of file switch_channel.c.

struct switch_device_state_table DEVICE_STATE_CHART[]

static

Initial value:

= {
        {"DOWN", SDS_DOWN},
        {"RINGING", SDS_RINGING},
        {"ACTIVE", SDS_ACTIVE},
        {"ACTIVE_MULTI", SDS_ACTIVE_MULTI},
        {"HELD", SDS_HELD},
        {"UNHELD", SDS_UNHELD},
        {"HANGUP", SDS_HANGUP},
        {NULL, 0}
}

Definition at line 258 of file switch_channel.c.

Referenced by switch_channel_device_state2str().

struct { ... } globals

Referenced by process_device_hup(), switch_channel_bind_device_state_handler(), switch_channel_check_device_state(), switch_channel_clear_device_record(), switch_channel_global_init(), switch_channel_global_uninit(), switch_channel_set_device_id(), and switch_channel_unbind_device_state_handler().

switch_memory_pool_t* pool

Definition at line 50 of file switch_channel.c.

const char* state_names[]

static

Initial value:

= {
        "CS_NEW",
        "CS_INIT",
        "CS_ROUTING",
        "CS_SOFT_EXECUTE",
        "CS_EXECUTE",
        "CS_EXCHANGE_MEDIA",
        "CS_PARK",
        "CS_CONSUME_MEDIA",
        "CS_HIBERNATE",
        "CS_RESET",
        "CS_HANGUP",
        "CS_REPORTING",
        "CS_DESTROY",
        "CS_NONE",
        NULL
}

Definition at line 2154 of file switch_channel.c.

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation