switch_ivr.c File Reference

#include <switch.h>
#include <switch_ivr.h>

Include dependency graph for switch_ivr.c:

Go to the source code of this file.

Data Structures
struct	media_job_t
struct	switch_ivr_digit_stream_parser
struct	switch_ivr_digit_stream

Macros
#define	add_stat(_x, _i, _s)
#define	add_stat_double(_x, _i, _s)
#define	add_jstat(_j, _i, _s)
#define	START_SAMPLES   32768

Functions
switch_status_t	switch_ivr_sound_test (switch_core_session_t *session)
switch_status_t	switch_ivr_sleep (switch_core_session_t *session, uint32_t ms, switch_bool_t sync, switch_input_args_t *args)
	Wait for time to pass for a specified number of milliseconds. More...
static void *SWITCH_THREAD_FUNC	unicast_thread_run (switch_thread_t *thread, void *obj)
static void	unicast_thread_launch (switch_unicast_conninfo_t *conninfo)
switch_status_t	switch_ivr_deactivate_unicast (switch_core_session_t *session)
switch_status_t	switch_ivr_activate_unicast (switch_core_session_t *session, char *local_ip, switch_port_t local_port, char *remote_ip, switch_port_t remote_port, char *transport, char *flags)
switch_status_t	switch_ivr_parse_event (switch_core_session_t *session, switch_event_t *event)
switch_status_t	switch_ivr_parse_next_event (switch_core_session_t *session)
switch_status_t	switch_ivr_process_indications (switch_core_session_t *session, switch_core_session_message_t *message)
switch_status_t	switch_ivr_parse_all_messages (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_signal_data (switch_core_session_t *session, switch_bool_t all, switch_bool_t only_session_thread)
switch_status_t	switch_ivr_parse_all_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_next_signal_data (switch_core_session_t *session)
switch_status_t	switch_ivr_parse_all_events (switch_core_session_t *session)
	Parse all commands from an event. More...
switch_status_t	switch_ivr_park (switch_core_session_t *session, switch_input_args_t *args)
switch_status_t	switch_ivr_collect_digits_callback (switch_core_session_t *session, switch_input_args_t *args, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for DTMF digits calling a pluggable callback function when digits are collected. More...
switch_status_t	switch_ivr_collect_digits_count (switch_core_session_t *session, char *buf, switch_size_t buflen, switch_size_t maxdigits, const char *terminators, char *terminator, uint32_t first_timeout, uint32_t digit_timeout, uint32_t abs_timeout)
	Wait for specified number of DTMF digits, untile terminator is received or until the channel hangs up. More...
switch_status_t	switch_ivr_hold (switch_core_session_t *session, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_hold_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Signal the session with a protocol specific hold message. More...
switch_status_t	switch_ivr_hold_toggle_uuid (const char *uuid, const char *message, switch_bool_t moh)
	Toggles channel hold state of session. More...
switch_status_t	switch_ivr_unhold (switch_core_session_t *session)
	Signal the session with a protocol specific unhold message. More...
switch_status_t	switch_ivr_unhold_uuid (const char *uuid)
	Signal the session with a protocol specific unhold message. More...
switch_status_t	switch_ivr_3p_media (const char *uuid, switch_media_flag_t flags)
switch_status_t	switch_ivr_media (const char *uuid, switch_media_flag_t flags)
	Signal a session to request direct media access to it's remote end. More...
switch_status_t	switch_ivr_3p_nomedia (const char *uuid, switch_media_flag_t flags)
switch_status_t	switch_ivr_nomedia (const char *uuid, switch_media_flag_t flags)
	Signal a session to request indirect media allowing it to exchange media directly with another device. More...
static void *SWITCH_THREAD_FUNC	media_thread_run (switch_thread_t *thread, void *obj)
void	switch_ivr_bg_media (const char *uuid, switch_media_flag_t flags, switch_bool_t on, switch_bool_t is3p, uint32_t delay)
switch_status_t	switch_ivr_session_transfer (switch_core_session_t *session, const char *extension, const char *dialplan, const char *context)
switch_status_t	switch_ivr_transfer_variable (switch_core_session_t *sessa, switch_core_session_t *sessb, char *var)
	Transfer variables from one session to another. More...
switch_status_t	switch_ivr_digit_stream_parser_new (switch_memory_pool_t *pool, switch_ivr_digit_stream_parser_t **parser)
	Create a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_parser_destroy (switch_ivr_digit_stream_parser_t *parser)
	Destroy a digit stream parser object. More...
switch_status_t	switch_ivr_digit_stream_new (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t **stream)
	Create a new digit stream object. More...
switch_status_t	switch_ivr_digit_stream_destroy (switch_ivr_digit_stream_t **stream)
	Destroys a digit stream object. More...
switch_status_t	switch_ivr_digit_stream_parser_set_event (switch_ivr_digit_stream_parser_t *parser, char *digits, void *data)
	Set a digit string to action mapping. More...
switch_status_t	switch_ivr_digit_stream_parser_del_event (switch_ivr_digit_stream_parser_t *parser, char *digits)
	Delete a string to action mapping. More...
void *	switch_ivr_digit_stream_parser_feed (switch_ivr_digit_stream_parser_t *parser, switch_ivr_digit_stream_t *stream, char digit)
	Feed digits collected into the stream for event match testing. More...
switch_status_t	switch_ivr_digit_stream_reset (switch_ivr_digit_stream_t *stream)
	Reset the collected digit stream to nothing. More...
switch_status_t	switch_ivr_digit_stream_parser_set_terminator (switch_ivr_digit_stream_parser_t *parser, char digit)
	Set a digit string terminator. More...
int	switch_ivr_set_xml_profile_data (switch_xml_t xml, switch_caller_profile_t *caller_profile, int off)
int	switch_ivr_set_xml_call_stats (switch_xml_t xml, switch_core_session_t *session, int off, switch_media_type_t type)
static int	switch_ivr_set_xml_chan_var (switch_xml_t xml, const char *var, const char *val, int off)
int	switch_ivr_set_xml_chan_vars (switch_xml_t xml, switch_channel_t *channel, int off)
switch_status_t	switch_ivr_generate_xml_cdr (switch_core_session_t *session, switch_xml_t *xml_cdr)
	Generate an XML CDR report. More...
static void	switch_ivr_set_json_profile_data (cJSON *json, switch_caller_profile_t *caller_profile)
void	switch_ivr_set_json_call_stats (cJSON *json, switch_core_session_t *session, switch_media_type_t type)
static void	switch_ivr_set_json_chan_vars (cJSON *json, switch_channel_t *channel, switch_bool_t urlencode)
switch_status_t	switch_ivr_generate_json_cdr (switch_core_session_t *session, cJSON **json_cdr, switch_bool_t urlencode)
	Generate an JSON CDR report. More...
void	switch_ivr_park_session (switch_core_session_t *session)
void	switch_ivr_delay_echo (switch_core_session_t *session, uint32_t delay_ms)
switch_status_t	switch_ivr_say (switch_core_session_t *session, const char *tosay, const char *module_name, const char *say_type, const char *say_method, const char *say_gender, switch_input_args_t *args)
switch_status_t	switch_ivr_say_string (switch_core_session_t *session, const char *lang, const char *ext, const char *tosay, const char *module_name, const char *say_type, const char *say_method, const char *say_gender, char **rstr)
static const char *	get_prefixed_str (char *buffer, size_t buffer_size, const char *prefix, size_t prefix_size, const char *str)
switch_status_t	switch_ivr_set_user_xml (switch_core_session_t *session, const char *prefix, const char *user, const char *domain, switch_xml_t x_user)
switch_status_t	switch_ivr_set_user (switch_core_session_t *session, const char *data)
switch_bool_t	switch_ivr_uuid_exists (const char *uuid)
switch_bool_t	switch_ivr_uuid_force_exists (const char *uuid)
switch_status_t	switch_ivr_process_fh (switch_core_session_t *session, const char *cmd, switch_file_handle_t *fhp)
switch_status_t	switch_ivr_insert_file (switch_core_session_t *session, const char *file, const char *insert_file, switch_size_t sample_point)
switch_status_t	switch_ivr_create_message_reply (switch_event_t **reply, switch_event_t *message, const char *new_proto)
char *	switch_ivr_check_presence_mapping (const char *exten_name, const char *domain_name)
switch_status_t	switch_ivr_kill_uuid (const char *uuid, switch_call_cause_t cause)
switch_status_t	switch_ivr_blind_transfer_ack (switch_core_session_t *session, switch_bool_t success)

Macro Definition Documentation

#define add_jstat	(		_j,
			_i,
			_s
	)

Value:

switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_SIZE_T_FMT, _i); \
	cJSON_AddItemToObject(_j, _s, cJSON_CreateNumber(_i))

Definition at line 3072 of file switch_ivr.c.

Referenced by switch_ivr_set_json_call_stats().

#define add_stat	(		_x,
			_i,
			_s
	)

Value:

switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_SIZE_T_FMT, _i); \
        x_tmp = switch_xml_add_child_d(_x, _s, loff++);                                         \
	switch_xml_set_txt_d(x_tmp, var_val)

Definition at line 2569 of file switch_ivr.c.

Referenced by switch_ivr_set_xml_call_stats().

#define add_stat_double	(		_x,
			_i,
			_s
	)

Value:

switch_snprintf(var_val, sizeof(var_val), "%0.2f", _i);                         \
        x_tmp = switch_xml_add_child_d(_x, _s, loff++);                                         \
	switch_xml_set_txt_d(x_tmp, var_val)

Definition at line 2574 of file switch_ivr.c.

Referenced by switch_ivr_set_xml_call_stats().

#define START_SAMPLES   32768

Definition at line 4007 of file switch_ivr.c.

Referenced by switch_ivr_insert_file().

Function Documentation

static const char* get_prefixed_str ( char *  buffer, size_t  buffer_size, const char *  prefix, size_t  prefix_size, const char *  str  )

static

Definition at line 3736 of file switch_ivr.c.

Referenced by switch_ivr_set_user_xml().

{
        size_t str_len;

        if (!buffer) {
                /*
                   if buffer is null then it just returns the str without the prefix appended, otherwise buffer contains the prefix followed by the original string
                 */

                return str;
        }

        str_len = strlen(str);
        memcpy(buffer, prefix, prefix_size);

        if (str_len + prefix_size + 1 > buffer_size) {
                memcpy(buffer + prefix_size, str, buffer_size - prefix_size - 1);
                buffer[buffer_size - prefix_size - 1] = '\0';
        } else {
                memcpy(buffer + prefix_size, str, str_len + 1);
        }

        return buffer;
}

static void* SWITCH_THREAD_FUNC media_thread_run ( switch_thread_t *  thread, void *  obj  )

static

Definition at line 1988 of file switch_ivr.c.

References media_job_t::delay, media_job_t::flags, media_job_t::is3p, media_job_t::on, switch_ivr_3p_media(), switch_ivr_3p_nomedia(), switch_ivr_media(), switch_ivr_nomedia(), switch_yield, and media_job_t::uuid.

Referenced by switch_ivr_bg_media().

{
        media_job_t *job = (media_job_t *) obj;

        if (job->delay) {
                switch_yield(job->delay * 1000);
        }

        if (job->on) {
                if (job->is3p) {
                        switch_ivr_3p_media(job->uuid, job->flags);
                } else {
                        switch_ivr_media(job->uuid, job->flags);
                }
        } else {
                if (job->is3p) {
                        switch_ivr_3p_nomedia(job->uuid, job->flags);
                } else {
                        switch_ivr_nomedia(job->uuid, job->flags);
                }
        }

        return NULL;
}

switch_status_t switch_ivr_parse_event	(	switch_core_session_t *	session,
		switch_event_t *	event
	)

Definition at line 497 of file switch_ivr.c.

References CF_BREAK, CF_BRIDGED, CF_BROADCAST, CF_EVENT_LOCK, CF_EVENT_LOCK_PRI, CF_EVENT_PARSE, CF_STOP_BROADCAST, switch_event_header::name, switch_event_header::next, SFF_CNG, SMF_ECHO_ALEG, SMF_LOOP, SMF_REBRIDGE, switch_caller_extension_add_application(), switch_caller_extension_new(), SWITCH_CAUSE_NORMAL_CLEARING, switch_channel_audio_sync, switch_channel_clear_flag(), switch_channel_clear_flag_recursive(), switch_channel_get_hold_music(), switch_channel_get_hold_music_partner(), switch_channel_get_name(), switch_channel_get_partner_uuid(), switch_channel_hangup, switch_channel_media_ready, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_flag_recursive(), switch_channel_set_variable, switch_channel_set_variable_printf(), switch_channel_stop_broadcast, switch_channel_str2cause(), switch_channel_test_flag(), switch_channel_transfer_to_extension(), switch_channel_wait_for_flag(), switch_core_session_execute_application, switch_core_session_flush_private_events(), switch_core_session_get_channel(), switch_core_session_kill_channel, switch_core_session_locate, switch_core_session_read_frame(), switch_core_session_rwunlock(), switch_core_session_strdup, switch_event_get_body(), switch_event_get_header, SWITCH_FALSE, switch_hashfunc_default(), SWITCH_IO_FLAG_NONE, switch_is_moh(), switch_ivr_activate_unicast(), switch_ivr_broadcast(), switch_ivr_nomedia(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), SWITCH_READ_ACCEPTABLE, SWITCH_SIG_BREAK, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_str_nil, switch_test_flag, SWITCH_TRUE, switch_true(), switch_event_header::value, and zstr.

Referenced by switch_ivr_park(), and switch_ivr_parse_next_event().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char *cmd = switch_event_get_header(event, "call-command");
        unsigned long cmd_hash;
        switch_ssize_t hlen = -1;
        unsigned long CMD_EXECUTE = switch_hashfunc_default("execute", &hlen);
        unsigned long CMD_HANGUP = switch_hashfunc_default("hangup", &hlen);
        unsigned long CMD_NOMEDIA = switch_hashfunc_default("nomedia", &hlen);
        unsigned long CMD_UNICAST = switch_hashfunc_default("unicast", &hlen);
        unsigned long CMD_XFEREXT = switch_hashfunc_default("xferext", &hlen);
        char *lead_frames = switch_event_get_header(event, "lead-frames");
        char *event_lock = switch_event_get_header(event, "event-lock");
        char *event_lock_pri = switch_event_get_header(event, "event-lock-pri");
        switch_status_t status = SWITCH_STATUS_FALSE;
        int el = 0, elp = 0;

        if (zstr(cmd)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Command!\n");
                return SWITCH_STATUS_FALSE;
        }

        cmd_hash = switch_hashfunc_default(cmd, &hlen);

        switch_channel_set_flag_recursive(channel, CF_EVENT_PARSE);

        if (switch_true(event_lock)) {
                switch_channel_set_flag_recursive(channel, CF_EVENT_LOCK);
                el = 1;
        }

        if (switch_true(event_lock_pri)) {
                switch_channel_set_flag_recursive(channel, CF_EVENT_LOCK_PRI);
                elp = 1;
        }

        if (lead_frames && switch_channel_media_ready(channel)) {
                switch_frame_t *read_frame;
                int frame_count = atoi(lead_frames);
                int max_frames = frame_count * 2;

                while (frame_count > 0 && --max_frames > 0) {
                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                goto done;
                        }
                        if (!switch_test_flag(read_frame, SFF_CNG)) {
                                frame_count--;
                        }
                }
        }

        if (cmd_hash == CMD_EXECUTE) {
                char *app_name = switch_event_get_header(event, "execute-app-name");
                char *event_uuid = switch_event_get_header(event, "event-uuid");
                char *app_arg = switch_event_get_header(event, "execute-app-arg");
                char *content_type = switch_event_get_header(event, "content-type");
                char *loop_h = switch_event_get_header(event, "loops");
                char *hold_bleg = switch_event_get_header(event, "hold-bleg");
                int loops = 1;
                int inner = 0;

                if (zstr(app_arg) && !zstr(content_type) && !strcasecmp(content_type, "text/plain")) {
                        app_arg = switch_event_get_body(event);
                }

                if (loop_h) {
                        loops = atoi(loop_h);
                }

                if (app_name) {
                        int x;
                        const char *b_uuid = NULL;
                        switch_core_session_t *b_session = NULL;

                        switch_channel_clear_flag(channel, CF_STOP_BROADCAST);

                        if (!switch_channel_test_flag(channel, CF_BRIDGED) || switch_channel_test_flag(channel, CF_BROADCAST)) {
                                inner++;
                                hold_bleg = NULL;
                        } 

                        if (!switch_channel_test_flag(channel, CF_BROADCAST)) {
                                switch_channel_set_flag(channel, CF_BROADCAST);
                                if (inner) {
                                        inner--;
                                }
                        }

                        if (hold_bleg && switch_true(hold_bleg)) {
                                if ((b_uuid = switch_channel_get_partner_uuid(channel))) {
                                        const char *stream;
                                        b_uuid = switch_core_session_strdup(session, b_uuid);

                                        if (!(stream = switch_channel_get_hold_music_partner(channel))) {
                                                stream = switch_channel_get_hold_music(channel);
                                        }

                                        if (stream && switch_is_moh(stream)) {
                                                if ((b_session = switch_core_session_locate(b_uuid))) {
                                                        switch_channel_t *b_channel = switch_core_session_get_channel(b_session);
                                                        switch_status_t st;
                                                        
                                                        switch_ivr_broadcast(b_uuid, stream, SMF_ECHO_ALEG | SMF_LOOP);
                                                        st = switch_channel_wait_for_flag(b_channel, CF_BROADCAST, SWITCH_TRUE, 5000, NULL);
                                                        if (st != SWITCH_STATUS_SUCCESS && 
                                                                switch_channel_ready(channel) && switch_channel_ready(b_channel) && !switch_channel_test_flag(b_channel, CF_BROADCAST)) {
                                                                switch_core_session_kill_channel(b_session, SWITCH_SIG_BREAK);
                                                                st = switch_channel_wait_for_flag(b_channel, CF_BROADCAST, SWITCH_TRUE, 5000, NULL);
                                                        
                                                                if (st != SWITCH_STATUS_SUCCESS && 
                                                                        switch_channel_ready(channel) && switch_channel_ready(b_channel) && !switch_channel_test_flag(b_channel, CF_BROADCAST)) {
                                                                        switch_core_session_flush_private_events(b_session);
                                                                }
                                                        }
                                                        switch_core_session_rwunlock(b_session);
                                                }
                                        } else {
                                                b_uuid = NULL;
                                        }
                                }
                        }

                        for (x = 0; x < loops || loops < 0; x++) {
                                switch_time_t b4, aftr;

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Command Execute %s(%s)\n",
                                                                  switch_channel_get_name(channel), app_name, switch_str_nil(app_arg));
                                b4 = switch_micro_time_now();

                                if (event_uuid) {
                                        switch_channel_set_variable(channel, "app_uuid", event_uuid);
                                }

                                switch_channel_set_variable_printf(channel, "current_loop", "%d", x + 1);
                                switch_channel_set_variable_printf(channel, "total_loops", "%d", loops);

                                if (switch_core_session_execute_application(session, app_name, app_arg) != SWITCH_STATUS_SUCCESS) {
                                        if (!inner || switch_channel_test_flag(channel, CF_STOP_BROADCAST)) switch_channel_clear_flag(channel, CF_BROADCAST);
                                        break;
                                }

                                aftr = switch_micro_time_now();
                                if (!switch_channel_ready(channel) || switch_channel_test_flag(channel, CF_STOP_BROADCAST) || aftr - b4 < 500000) {
                                        break;
                                }
                        }

                        switch_channel_set_variable(channel, "current_loop", NULL);
                        switch_channel_set_variable(channel, "total_loops", NULL);

                        if (b_uuid) {
                                if ((b_session = switch_core_session_locate(b_uuid))) {
                                        switch_channel_t *b_channel = switch_core_session_get_channel(b_session);
                                        switch_channel_stop_broadcast(b_channel);
                                        switch_channel_wait_for_flag(b_channel, CF_BROADCAST, SWITCH_FALSE, 5000, NULL);
                                        switch_core_session_rwunlock(b_session);
                                }
                        }

                        if (!inner) {
                                switch_channel_clear_flag(channel, CF_BROADCAST);
                        }

                        if (switch_channel_test_flag(channel, CF_STOP_BROADCAST)) {
                                switch_channel_clear_flag(channel, CF_BROADCAST);
                                switch_channel_set_flag(channel, CF_BREAK); 
                        }
                        
                        switch_channel_audio_sync(channel);
                }
        } else if (cmd_hash == CMD_UNICAST) {
                char *local_ip = switch_event_get_header(event, "local-ip");
                char *local_port = switch_event_get_header(event, "local-port");
                char *remote_ip = switch_event_get_header(event, "remote-ip");
                char *remote_port = switch_event_get_header(event, "remote-port");
                char *transport = switch_event_get_header(event, "transport");
                char *flags = switch_event_get_header(event, "flags");

                if (zstr(local_ip)) {
                        local_ip = "127.0.0.1";
                }
                if (zstr(remote_ip)) {
                        remote_ip = "127.0.0.1";
                }
                if (zstr(local_port)) {
                        local_port = "8025";
                }
                if (zstr(remote_port)) {
                        remote_port = "8026";
                }
                if (zstr(transport)) {
                        transport = "udp";
                }

                switch_ivr_activate_unicast(session, local_ip, (switch_port_t) atoi(local_port), remote_ip, (switch_port_t) atoi(remote_port), transport, flags);

        } else if (cmd_hash == CMD_XFEREXT) {
                switch_event_header_t *hp;
                switch_caller_extension_t *extension = NULL;


                if ((extension = switch_caller_extension_new(session, "xferext", "xferext")) == 0) {
                        abort();
                }
                
                for (hp = event->headers; hp; hp = hp->next) {
                        char *app;
                        char *data;
                        
                        if (!strcasecmp(hp->name, "application")) {
                                app = strdup(hp->value);
                                if (app) {
                                        data = strchr(app, ' ');

                                        if (data) {
                                                *data++ = '\0';
                                        }

                                        switch_caller_extension_add_application(session, extension, app, data);
                                        free(app);
                                }
                        }
                }

                switch_channel_transfer_to_extension(channel, extension);
                
        } else if (cmd_hash == CMD_HANGUP) {
                char *cause_name = switch_event_get_header(event, "hangup-cause");
                switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING;

                if (cause_name) {
                        cause = switch_channel_str2cause(cause_name);
                }

                switch_channel_hangup(channel, cause);
        } else if (cmd_hash == CMD_NOMEDIA) {
                char *uuid = switch_event_get_header(event, "nomedia-uuid");
                switch_ivr_nomedia(uuid, SMF_REBRIDGE);
        }

        status = SWITCH_STATUS_SUCCESS;

  done:

        switch_channel_clear_flag_recursive(channel, CF_EVENT_PARSE);

        if (el) {
                switch_channel_clear_flag_recursive(channel, CF_EVENT_LOCK);
        }

        if (elp) {
                switch_channel_clear_flag_recursive(channel, CF_EVENT_LOCK_PRI);
        }

        return switch_channel_test_flag(channel, CF_BREAK) ? SWITCH_STATUS_BREAK : status;
}

switch_status_t switch_ivr_session_transfer	(	switch_core_session_t *	session,
		const char *	extension,
		const char *	dialplan,
		const char *	context
	)

Definition at line 2037 of file switch_ivr.c.

References CF_ORIGINATING, CF_TRANSFER, switch_caller_profile::context, CS_ROUTING, switch_caller_profile::destination_number, switch_caller_profile::dialplan, switch_core_session_message::from, switch_core_session_message::message_id, switch_caller_profile::pool, switch_caller_profile::rdnis, SMF_NONE, SWITCH_BRIDGE_VARIABLE, switch_caller_profile_clone(), SWITCH_CAUSE_BLIND_TRANSFER, SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR, switch_channel_add_variable_var_check(), switch_channel_audio_sync, switch_channel_clear_flag(), switch_channel_clear_state_handler(), switch_channel_execute_on(), switch_channel_get_caller_profile(), switch_channel_get_name(), switch_channel_get_variable, switch_channel_hangup, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_caller_profile(), switch_channel_set_flag, switch_channel_set_state, switch_channel_set_variable, switch_channel_set_variable_var_check(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_reset(), switch_core_session_rwunlock(), switch_core_session_sprintf(), switch_core_sprintf(), switch_core_strdup, switch_epoch_time_now(), SWITCH_FALSE, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, switch_ivr_media(), SWITCH_LOG_NOTICE, switch_log_printf(), SWITCH_MAX_FORWARDS_VARIABLE, SWITCH_MAX_SESSION_TRANSFERS_VARIABLE, SWITCH_MESSAGE_INDICATE_TRANSFER, SWITCH_SIGNAL_BOND_VARIABLE, SWITCH_SIGNAL_BRIDGE_VARIABLE, SWITCH_STACK_PUSH, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_TEMP_HOLD_MUSIC_VARIABLE, SWITCH_TRANSFER_HISTORY_VARIABLE, SWITCH_TRANSFER_SOURCE_VARIABLE, SWITCH_TRUE, switch_caller_profile::transfer_source, switch_caller_profile::uuid_str, and zstr.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_caller_profile_t *profile, *new_profile;
        switch_core_session_message_t msg = { 0 };
        switch_core_session_t *other_session;
        switch_channel_t *other_channel = NULL;
        const char *uuid = NULL;
        const char *max_forwards;
        const char *forwardvar_name = SWITCH_MAX_SESSION_TRANSFERS_VARIABLE; /* max_session_transfers has first priority for setting maximum */
        const char *forwardvar = switch_channel_get_variable(channel, forwardvar_name);
        int forwardval = 70;
        const char *use_dialplan = dialplan, *use_context = context;

        if (zstr(forwardvar)) {
                forwardvar_name = SWITCH_MAX_FORWARDS_VARIABLE; /* fall back to max_forwards variable for setting maximum */
                forwardvar = switch_channel_get_variable(channel, forwardvar_name);
        }
        if (!zstr(forwardvar)) {
                forwardval = atoi(forwardvar) - 1;
        }
        if (forwardval <= 0) {
                switch_channel_hangup(channel, SWITCH_CAUSE_EXCHANGE_ROUTING_ERROR);
                return SWITCH_STATUS_FALSE;
        }

        max_forwards = switch_core_session_sprintf(session, "%d", forwardval);
        switch_channel_set_variable(channel, forwardvar_name, max_forwards);

        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);
        switch_channel_clear_flag(channel, CF_ORIGINATING);

        /* clear all state handlers */
        switch_channel_clear_state_handler(channel, NULL);

        /* reset temp hold music */
        switch_channel_set_variable(channel, SWITCH_TEMP_HOLD_MUSIC_VARIABLE, NULL);

        switch_channel_execute_on(channel, "execute_on_blind_transfer");
        
        if ((profile = switch_channel_get_caller_profile(channel))) {
                const char *var;

                if (zstr(dialplan) && (var = switch_channel_get_variable(channel, "force_transfer_dialplan"))) {
                        use_dialplan = var;
                }

                if (zstr(context) && (var = switch_channel_get_variable(channel, "force_transfer_context"))) {
                        use_context = var;
                }

                if (zstr(use_dialplan)) {
                        use_dialplan = profile->dialplan;
                        if (!zstr(use_dialplan) && !strcasecmp(use_dialplan, "inline")) {
                                use_dialplan = NULL;
                        }
                }

                if (zstr(use_context)) {
                        use_context = profile->context;
                }

                if (zstr(use_dialplan)) {
                        use_dialplan = "XML";
                }

                if (zstr(use_context)) {
                        use_context = "default";
                }

                if (zstr(extension)) {
                        extension = "service";
                }

                new_profile = switch_caller_profile_clone(session, profile);

                new_profile->dialplan = switch_core_strdup(new_profile->pool, use_dialplan);
                new_profile->context = switch_core_strdup(new_profile->pool, use_context);
                new_profile->destination_number = switch_core_strdup(new_profile->pool, extension);
                new_profile->rdnis = switch_core_strdup(new_profile->pool, profile->destination_number);

                switch_channel_set_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE, NULL);

                /* Set CF_TRANSFER flag before hanging up bleg to avoid race condition */
                switch_channel_set_flag(channel, CF_TRANSFER);

                /* If HANGUP_AFTER_BRIDGE is set to 'true', SWITCH_SIGNAL_BRIDGE_VARIABLE 
                 * will not have a value, so we need to check SWITCH_BRIDGE_VARIABLE */

                uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE);

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

                if (uuid && (other_session = switch_core_session_locate(uuid))) {
                        other_channel = switch_core_session_get_channel(other_session);
                        switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BOND_VARIABLE, NULL);
                        switch_core_session_rwunlock(other_session);
                }

                if ((uuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE))
                        && (other_session = switch_core_session_locate(uuid))) {
                        other_channel = switch_core_session_get_channel(other_session);

                        switch_channel_set_variable(channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);
                        switch_channel_set_variable(other_channel, SWITCH_SIGNAL_BRIDGE_VARIABLE, NULL);

                        switch_channel_set_variable(channel, SWITCH_BRIDGE_VARIABLE, NULL);
                        switch_channel_set_variable(other_channel, SWITCH_BRIDGE_VARIABLE, NULL);

                        /* If we are transferring the CALLER out of the bridge, we do not want to hang up on them */
                        switch_channel_set_variable(channel, SWITCH_HANGUP_AFTER_BRIDGE_VARIABLE, "false");

                        switch_channel_hangup(other_channel, SWITCH_CAUSE_BLIND_TRANSFER);
                        switch_ivr_media(uuid, SMF_NONE);

                        switch_core_session_rwunlock(other_session);
                }

                switch_channel_set_caller_profile(channel, new_profile);

                switch_channel_set_state(channel, CS_ROUTING);
                switch_channel_audio_sync(channel);

                msg.message_id = SWITCH_MESSAGE_INDICATE_TRANSFER;
                msg.from = __FILE__;
                switch_core_session_receive_message(session, &msg);

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Transfer %s to %s[%s@%s]\n", switch_channel_get_name(channel), use_dialplan,
                                                  extension, use_context);


                new_profile->transfer_source = switch_core_sprintf(new_profile->pool, "%ld:%s:bl_xfer:%s/%s/%s", 
                                                                                                                   (long) switch_epoch_time_now(NULL), new_profile->uuid_str,
                                                                                                                   extension, use_context, use_dialplan);
                switch_channel_add_variable_var_check(channel, SWITCH_TRANSFER_HISTORY_VARIABLE, new_profile->transfer_source, SWITCH_FALSE, SWITCH_STACK_PUSH);
                switch_channel_set_variable_var_check(channel, SWITCH_TRANSFER_SOURCE_VARIABLE, new_profile->transfer_source, SWITCH_FALSE);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

void switch_ivr_set_json_call_stats	(	cJSON *	json,
		switch_core_session_t *	session,
		switch_media_type_t	type
	)

Definition at line 3076 of file switch_ivr.c.

References add_jstat, switch_rtp_numbers_t::burstrate, cJSON_AddItemToArray(), cJSON_AddItemToObject(), cJSON_CreateArray(), cJSON_CreateNumber(), cJSON_CreateObject(), switch_rtp_numbers_t::cng_packet_count, switch_rtp_numbers_t::dtmf_packet_count, ep, switch_rtp_numbers_t::error_log, switch_rtp_numbers_t::flaws, switch_rtp_numbers_t::flush_packet_count, switch_rtp_stats_t::inbound, switch_rtp_numbers_t::jb_packet_count, switch_rtp_numbers_t::largest_jb_size, switch_rtp_numbers_t::lossrate, switch_rtp_numbers_t::max_variance, switch_rtp_numbers_t::mean_interval, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, error_period::next, switch_rtcp_numbers_t::octet_count, switch_rtp_stats_t::outbound, switch_rtp_numbers_t::packet_count, switch_rtcp_numbers_t::packet_count, switch_rtp_numbers_t::R, switch_rtp_numbers_t::raw_bytes, switch_rtp_stats_t::rtcp, switch_rtp_numbers_t::skip_packet_count, error_period::start, switch_rtp_numbers_t::std_deviation, error_period::stop, switch_core_media_get_stats(), SWITCH_MEDIA_TYPE_VIDEO, and switch_rtp_numbers_t::variance.

Referenced by switch_ivr_generate_json_cdr().

{
        const char *name = (type == SWITCH_MEDIA_TYPE_VIDEO) ? "video" : "audio";
        cJSON *j_stat, *j_in, *j_out;
        switch_rtp_stats_t *stats = switch_core_media_get_stats(session, type, NULL);
        char var_val[35] = "";

        if (!stats) return;

        j_stat = cJSON_CreateObject();
        j_in = cJSON_CreateObject();
        j_out = cJSON_CreateObject();

        cJSON_AddItemToObject(json, name, j_stat);
        cJSON_AddItemToObject(j_stat, "inbound", j_in);
        cJSON_AddItemToObject(j_stat, "outbound", j_out);

        stats->inbound.std_deviation = sqrt(stats->inbound.variance);

        add_jstat(j_in, stats->inbound.raw_bytes, "raw_bytes");
        add_jstat(j_in, stats->inbound.media_bytes, "media_bytes");
        add_jstat(j_in, stats->inbound.packet_count, "packet_count");
        add_jstat(j_in, stats->inbound.media_packet_count, "media_packet_count");
        add_jstat(j_in, stats->inbound.skip_packet_count, "skip_packet_count");
        add_jstat(j_in, stats->inbound.jb_packet_count, "jitter_packet_count");
        add_jstat(j_in, stats->inbound.dtmf_packet_count, "dtmf_packet_count");
        add_jstat(j_in, stats->inbound.cng_packet_count, "cng_packet_count");
        add_jstat(j_in, stats->inbound.flush_packet_count, "flush_packet_count");
        add_jstat(j_in, stats->inbound.largest_jb_size, "largest_jb_size");
        add_jstat(j_in, stats->inbound.min_variance, "jitter_min_variance");
        add_jstat(j_in, stats->inbound.max_variance, "jitter_max_variance");
        add_jstat(j_in, stats->inbound.lossrate, "jitter_loss_rate");
        add_jstat(j_in, stats->inbound.burstrate, "jitter_burst_rate");
        add_jstat(j_in, stats->inbound.mean_interval, "mean_interval");
        add_jstat(j_in, stats->inbound.flaws, "flaw_total");
        add_jstat(j_in, stats->inbound.R, "quality_percentage");
        add_jstat(j_in, stats->inbound.mos, "mos");
        

        if (stats->inbound.error_log) {
                cJSON *j_err_log, *j_err;
                switch_error_period_t *ep;

                j_err_log = cJSON_CreateArray();
                cJSON_AddItemToObject(j_in, "errorLog", j_err_log);

                for(ep = stats->inbound.error_log; ep; ep = ep->next) {

                        if (!(ep->start && ep->stop)) continue;

                        j_err = cJSON_CreateObject();

                        cJSON_AddItemToObject(j_err, "start", cJSON_CreateNumber(ep->start));
                        cJSON_AddItemToObject(j_err, "stop", cJSON_CreateNumber(ep->stop));
                        cJSON_AddItemToObject(j_err, "durationMS", cJSON_CreateNumber((ep->stop - ep->start) / 1000));
                        cJSON_AddItemToArray(j_err_log, j_err);
                }
        }

        add_jstat(j_out, stats->outbound.raw_bytes, "raw_bytes");
        add_jstat(j_out, stats->outbound.media_bytes, "media_bytes");
        add_jstat(j_out, stats->outbound.packet_count, "packet_count");
        add_jstat(j_out, stats->outbound.media_packet_count, "media_packet_count");
        add_jstat(j_out, stats->outbound.skip_packet_count, "skip_packet_count");
        add_jstat(j_out, stats->outbound.dtmf_packet_count, "dtmf_packet_count");
        add_jstat(j_out, stats->outbound.cng_packet_count, "cng_packet_count");
        add_jstat(j_out, stats->rtcp.packet_count, "rtcp_packet_count");
        add_jstat(j_out, stats->rtcp.octet_count, "rtcp_octet_count");
}

static void switch_ivr_set_json_chan_vars ( cJSON *  json, switch_channel_t *  channel, switch_bool_t  urlencode  )

static

Definition at line 3146 of file switch_ivr.c.

References cJSON_AddItemToObject(), cJSON_CreateString(), memset(), switch_event_header::name, switch_event_header::next, switch_channel_variable_first(), switch_channel_variable_last(), switch_safe_free, switch_url_encode(), switch_event_header::value, and zstr.

Referenced by switch_ivr_generate_json_cdr().

{
        switch_event_header_t *hi = switch_channel_variable_first(channel);

        if (!hi)
                return;

        for (; hi; hi = hi->next) {
                if (!zstr(hi->name) && !zstr(hi->value)) {
                        char *data = hi->value;
                        if (urlencode) {
                                switch_size_t dlen = strlen(hi->value) * 3;

                                if ((data = malloc(dlen))) {
                                        memset(data, 0, dlen);
                                        switch_url_encode(hi->value, data, dlen);
                                }
                        }

                        cJSON_AddItemToObject(json, hi->name, cJSON_CreateString(data));

                        if (data != hi->value) {
                                switch_safe_free(data);
                        }
                }
        }
        switch_channel_variable_last(channel);
}

static void switch_ivr_set_json_profile_data ( cJSON *  json, switch_caller_profile_t *  caller_profile  )

static

Definition at line 3055 of file switch_ivr.c.

References switch_caller_profile::ani, switch_caller_profile::aniii, switch_caller_profile::caller_id_name, switch_caller_profile::caller_id_number, switch_caller_profile::chan_name, cJSON_AddItemToObject(), cJSON_CreateString(), switch_caller_profile::context, switch_caller_profile::destination_number, switch_caller_profile::dialplan, switch_caller_profile::network_addr, switch_caller_profile::rdnis, switch_caller_profile::source, switch_caller_profile::username, and switch_caller_profile::uuid.

Referenced by switch_ivr_generate_json_cdr().

{
        cJSON_AddItemToObject(json, "username", cJSON_CreateString((char *)caller_profile->username));
        cJSON_AddItemToObject(json, "dialplan", cJSON_CreateString((char *)caller_profile->dialplan));
        cJSON_AddItemToObject(json, "caller_id_name", cJSON_CreateString((char *)caller_profile->caller_id_name));
        cJSON_AddItemToObject(json, "ani", cJSON_CreateString((char *)caller_profile->ani));
        cJSON_AddItemToObject(json, "aniii", cJSON_CreateString((char *)caller_profile->aniii));
        cJSON_AddItemToObject(json, "caller_id_number", cJSON_CreateString((char *)caller_profile->caller_id_number));
        cJSON_AddItemToObject(json, "network_addr", cJSON_CreateString((char *)caller_profile->network_addr));
        cJSON_AddItemToObject(json, "rdnis", cJSON_CreateString((char *)caller_profile->rdnis));
        cJSON_AddItemToObject(json, "destination_number", cJSON_CreateString(caller_profile->destination_number));
        cJSON_AddItemToObject(json, "uuid", cJSON_CreateString(caller_profile->uuid));
        cJSON_AddItemToObject(json, "source", cJSON_CreateString((char *)caller_profile->source));
        cJSON_AddItemToObject(json, "context", cJSON_CreateString((char *)caller_profile->context));
        cJSON_AddItemToObject(json, "chan_name", cJSON_CreateString(caller_profile->chan_name));
}

int switch_ivr_set_xml_call_stats	(	switch_xml_t	xml,
		switch_core_session_t *	session,
		int	off,
		switch_media_type_t	type
	)

Definition at line 2579 of file switch_ivr.c.

References add_stat, add_stat_double, switch_rtp_numbers_t::burstrate, switch_rtp_numbers_t::cng_packet_count, switch_rtp_numbers_t::dtmf_packet_count, ep, switch_rtp_numbers_t::error_log, switch_rtp_numbers_t::flaws, switch_rtp_numbers_t::flush_packet_count, switch_rtp_stats_t::inbound, switch_rtp_numbers_t::jb_packet_count, switch_rtp_numbers_t::largest_jb_size, switch_rtp_numbers_t::lossrate, switch_rtp_numbers_t::max_variance, switch_rtp_numbers_t::mean_interval, switch_rtp_numbers_t::media_bytes, switch_rtp_numbers_t::media_packet_count, switch_rtp_numbers_t::min_variance, switch_rtp_numbers_t::mos, error_period::next, switch_rtcp_numbers_t::octet_count, switch_rtp_stats_t::outbound, switch_rtp_numbers_t::packet_count, switch_rtcp_numbers_t::packet_count, switch_rtp_numbers_t::R, switch_rtp_numbers_t::raw_bytes, switch_rtp_stats_t::rtcp, switch_rtp_numbers_t::skip_packet_count, error_period::start, switch_rtp_numbers_t::std_deviation, error_period::stop, switch_core_media_get_stats(), SWITCH_MEDIA_TYPE_VIDEO, switch_snprintf(), SWITCH_TIME_T_FMT, switch_xml_add_child_d, switch_xml_set_txt_d, and switch_rtp_numbers_t::variance.

Referenced by switch_ivr_generate_xml_cdr().

{
        const char *name = (type == SWITCH_MEDIA_TYPE_VIDEO) ? "video" : "audio";
        switch_xml_t x_stat, x_in, x_out, x_tmp = NULL;
        int loff = 0;
        switch_rtp_stats_t *stats = switch_core_media_get_stats(session, type, NULL);
        char var_val[35] = "";

        if (!stats) return off;

        if (!(x_stat = switch_xml_add_child_d(xml, name, off++))) {
                abort();
        }

        if (!(x_in = switch_xml_add_child_d(x_stat, "inbound", off++))) {
                abort();
        }

        if (!(x_out = switch_xml_add_child_d(x_stat, "outbound", off++))) {
                abort();
        }

        stats->inbound.std_deviation = sqrt(stats->inbound.variance);

        add_stat(x_in, stats->inbound.raw_bytes, "raw_bytes");
        add_stat(x_in, stats->inbound.media_bytes, "media_bytes");
        add_stat(x_in, stats->inbound.packet_count, "packet_count");
        add_stat(x_in, stats->inbound.media_packet_count, "media_packet_count");
        add_stat(x_in, stats->inbound.skip_packet_count, "skip_packet_count");
        add_stat(x_in, stats->inbound.jb_packet_count, "jitter_packet_count");
        add_stat(x_in, stats->inbound.dtmf_packet_count, "dtmf_packet_count");
        add_stat(x_in, stats->inbound.cng_packet_count, "cng_packet_count");
        add_stat(x_in, stats->inbound.flush_packet_count, "flush_packet_count");
        add_stat(x_in, stats->inbound.largest_jb_size, "largest_jb_size");
        add_stat_double(x_in, stats->inbound.min_variance, "jitter_min_variance");
        add_stat_double(x_in, stats->inbound.max_variance, "jitter_max_variance");
        add_stat_double(x_in, stats->inbound.lossrate, "jitter_loss_rate");
        add_stat_double(x_in, stats->inbound.burstrate, "jitter_burst_rate");
        add_stat_double(x_in, stats->inbound.mean_interval, "mean_interval");
        add_stat(x_in, stats->inbound.flaws, "flaw_total");
        add_stat_double(x_in, stats->inbound.R, "quality_percentage");
        add_stat_double(x_in, stats->inbound.mos, "mos");
        

        if (stats->inbound.error_log) {
                switch_xml_t x_err_log, x_err;
                switch_error_period_t *ep;
                int eoff = 0;

                if (!(x_err_log = switch_xml_add_child_d(x_stat, "error-log", off++))) {
                        abort();
                }
                
                for(ep = stats->inbound.error_log; ep; ep = ep->next) {

                        if (!(ep->start && ep->stop)) continue;

                        if (!(x_err = switch_xml_add_child_d(x_err_log, "error-period", eoff++))) {
                                abort();
                        }

                        switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_TIME_T_FMT, ep->start);
                        x_tmp = switch_xml_add_child_d(x_err, "start", 0);
                        switch_xml_set_txt_d(x_tmp, var_val);

                        switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_TIME_T_FMT, ep->stop);
                        x_tmp = switch_xml_add_child_d(x_err, "stop", 1);
                        switch_xml_set_txt_d(x_tmp, var_val);

                        switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_TIME_T_FMT, (ep->stop - ep->start) / 1000);
                        x_tmp = switch_xml_add_child_d(x_err, "duration-msec", 2);
                        switch_xml_set_txt_d(x_tmp, var_val);
                }
        }

        add_stat(x_out, stats->outbound.raw_bytes, "raw_bytes");
        add_stat(x_out, stats->outbound.media_bytes, "media_bytes");
        add_stat(x_out, stats->outbound.packet_count, "packet_count");
        add_stat(x_out, stats->outbound.media_packet_count, "media_packet_count");
        add_stat(x_out, stats->outbound.skip_packet_count, "skip_packet_count");
        add_stat(x_out, stats->outbound.dtmf_packet_count, "dtmf_packet_count");
        add_stat(x_out, stats->outbound.cng_packet_count, "cng_packet_count");
        add_stat(x_out, stats->rtcp.packet_count, "rtcp_packet_count");
        add_stat(x_out, stats->rtcp.octet_count, "rtcp_octet_count");
        
        return off;
}

static int switch_ivr_set_xml_chan_var ( switch_xml_t  xml, const char *  var, const char *  val, int  off  )

static

Definition at line 2667 of file switch_ivr.c.

References memset(), switch_url_encode(), switch_xml_add_child_d, switch_xml_set_txt_d, and zstr.

Referenced by switch_ivr_set_xml_chan_vars().

{
        char *data;
        switch_size_t dlen = strlen(val) * 3 + 1;
        switch_xml_t variable;

        if (!val) val = "";
        
        if (!zstr(var) && ((variable = switch_xml_add_child_d(xml, var, off++)))) {
                if ((data = malloc(dlen))) {
                        memset(data, 0, dlen);
                        switch_url_encode(val, data, dlen);
                        switch_xml_set_txt_d(variable, data);
                        free(data);
                } else abort();
        }
        
        return off;
        
}

static void unicast_thread_launch ( switch_unicast_conninfo_t *  conninfo )

static

Definition at line 355 of file switch_ivr.c.

References switch_unicast_conninfo::session, SUF_THREAD_RUNNING, switch_core_session_get_pool(), switch_set_flag_locked, switch_thread_create(), SWITCH_THREAD_STACKSIZE, switch_threadattr_create(), switch_threadattr_stacksize_set(), switch_unicast_conninfo::thread, and unicast_thread_run().

Referenced by switch_ivr_park().

{
        switch_threadattr_t *thd_attr = NULL;

        switch_threadattr_create(&thd_attr, switch_core_session_get_pool(conninfo->session));
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
        switch_set_flag_locked(conninfo, SUF_THREAD_RUNNING);
        switch_thread_create(&conninfo->thread, thd_attr, unicast_thread_run, conninfo, switch_core_session_get_pool(conninfo->session));
}

static void* SWITCH_THREAD_FUNC unicast_thread_run ( switch_thread_t *  thread, void *  obj  )

static

Definition at line 330 of file switch_ivr.c.

References switch_frame::buflen, switch_frame::data, switch_frame::datalen, switch_frame::samples, switch_unicast_conninfo::session, switch_unicast_conninfo::socket, switch_unicast_conninfo::stream_id, SUF_READY, SUF_THREAD_RUNNING, switch_clear_flag_locked, switch_core_session_write_frame(), SWITCH_IO_FLAG_NONE, switch_socket_recv(), SWITCH_STATUS_SUCCESS, switch_test_flag, and switch_unicast_conninfo::write_frame.

Referenced by unicast_thread_launch().

{
        switch_unicast_conninfo_t *conninfo = (switch_unicast_conninfo_t *) obj;
        switch_size_t len;

        if (!conninfo) {
                return NULL;
        }

        while (switch_test_flag(conninfo, SUF_READY) && switch_test_flag(conninfo, SUF_THREAD_RUNNING)) {
                len = conninfo->write_frame.buflen;
                if (switch_socket_recv(conninfo->socket, conninfo->write_frame.data, &len) != SWITCH_STATUS_SUCCESS || len == 0) {
                        break;
                }
                conninfo->write_frame.datalen = (uint32_t) len;
                conninfo->write_frame.samples = conninfo->write_frame.datalen / 2;
                switch_core_session_write_frame(conninfo->session, &conninfo->write_frame, SWITCH_IO_FLAG_NONE, conninfo->stream_id);
        }

        switch_clear_flag_locked(conninfo, SUF_READY);
        switch_clear_flag_locked(conninfo, SUF_THREAD_RUNNING);

        return NULL;
}