IVR Menu Library

Collaboration diagram for IVR Menu Library:

Macros
#define	switch_ivr_phrase_macro(session, macro_name, data, lang, args)   switch_ivr_phrase_macro_event(session, macro_name, data, NULL, lang, args)

Typedefs
typedef switch_ivr_action_t	switch_ivr_menu_action_function_t (struct switch_ivr_menu *, char *, char *, size_t, void *)
typedef struct switch_ivr_menu	switch_ivr_menu_t
typedef struct switch_ivr_menu_action	switch_ivr_menu_action_t
typedef struct switch_ivr_menu_xml_ctx	switch_ivr_menu_xml_ctx_t

Enumerations
enum	switch_ivr_menu_flags { SWITCH_IVR_MENU_FLAG_FALLTOMAIN = (1 << 0), SWITCH_IVR_MENU_FLAG_FREEPOOL = (1 << 1), SWITCH_IVR_MENU_FLAG_STACK = (1 << 2) }
enum	switch_ivr_action_t {   SWITCH_IVR_ACTION_DIE, SWITCH_IVR_ACTION_EXECMENU, SWITCH_IVR_ACTION_EXECAPP, SWITCH_IVR_ACTION_PLAYSOUND,   SWITCH_IVR_ACTION_BACK, SWITCH_IVR_ACTION_TOMAIN, SWITCH_IVR_ACTION_NOOP }

Functions
switch_status_t	switch_ivr_menu_init (switch_ivr_menu_t **new_menu, switch_ivr_menu_t *main, const char *name, const char *greeting_sound, const char *short_greeting_sound, const char *invalid_sound, const char *exit_sound, const char *transfer_sound, const char *confirm_macro, const char *confirm_key, const char *tts_engine, const char *tts_voice, int confirm_attempts, int inter_timeout, int digit_len, int timeout, int max_failures, int max_timeouts, switch_memory_pool_t *pool)
	Create a new menu object. More...
switch_status_t	switch_ivr_menu_bind_action (switch_ivr_menu_t *menu, switch_ivr_action_t ivr_action, const char *arg, const char *bind)
	switch_ivr_menu_bind_action: Bind a keystroke to an action. More...
switch_status_t	switch_ivr_menu_bind_function (switch_ivr_menu_t *menu, switch_ivr_menu_action_function_t *function, const char *arg, const char *bind)
	Bind a keystroke to a callback function. More...
switch_status_t	switch_ivr_menu_execute (switch_core_session_t *session, switch_ivr_menu_t *stack, char *name, void *obj)
	Execute a menu. More...
switch_status_t	switch_ivr_menu_stack_free (switch_ivr_menu_t *stack)
	free a stack of menu objects. More...
switch_status_t	switch_ivr_menu_stack_xml_build (switch_ivr_menu_xml_ctx_t *xml_menu_ctx, switch_ivr_menu_t **menu_stack, switch_xml_t xml_menus, switch_xml_t xml_menu)
	Build a menu stack from an xml source. More...
switch_status_t	switch_ivr_menu_str2action (const char *action_name, switch_ivr_action_t *action)
switch_status_t	switch_ivr_menu_stack_xml_add_custom (switch_ivr_menu_xml_ctx_t *xml_menu_ctx, const char *name, switch_ivr_menu_action_function_t *function)
switch_status_t	switch_ivr_menu_stack_xml_init (switch_ivr_menu_xml_ctx_t **xml_menu_ctx, switch_memory_pool_t *pool)
switch_status_t	switch_ivr_phrase_macro_event (switch_core_session_t *session, const char *macro_name, const char *data, switch_event_t *event, const char *lang, switch_input_args_t *args)
void	switch_ivr_delay_echo (switch_core_session_t *session, uint32_t delay_ms)
switch_status_t	switch_ivr_find_bridged_uuid (const char *uuid, char *b_uuid, switch_size_t blen)
void	switch_ivr_intercept_session (switch_core_session_t *session, const char *uuid, switch_bool_t bleg)
void	switch_ivr_park_session (switch_core_session_t *session)
switch_status_t	switch_ivr_wait_for_answer (switch_core_session_t *session, switch_core_session_t *peer_session)
switch_status_t	switch_ivr_read (switch_core_session_t *session, uint32_t min_digits, uint32_t max_digits, const char *prompt_audio_file, const char *var_name, char *digit_buffer, switch_size_t digit_buffer_length, uint32_t timeout, const char *valid_terminators, uint32_t digit_timeout)
switch_status_t	switch_ivr_block_dtmf_session (switch_core_session_t *session)
switch_status_t	switch_ivr_unblock_dtmf_session (switch_core_session_t *session)
switch_status_t	switch_ivr_bind_dtmf_meta_session (switch_core_session_t *session, uint32_t key, switch_bind_flag_t bind_flags, const char *app)
switch_status_t	switch_ivr_unbind_dtmf_meta_session (switch_core_session_t *session, uint32_t key)
switch_status_t	switch_ivr_soft_hold (switch_core_session_t *session, const char *unhold_key, const char *moh_a, const char *moh_b)
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)
switch_say_method_t	switch_ivr_get_say_method_by_name (const char *name)
switch_say_gender_t	switch_ivr_get_say_gender_by_name (const char *name)
switch_say_type_t	switch_ivr_get_say_type_by_name (const char *name)
switch_status_t	switch_ivr_say_spell (switch_core_session_t *session, char *tosay, switch_say_args_t *say_args, switch_input_args_t *args)
switch_status_t	switch_ivr_say_ip (switch_core_session_t *session, char *tosay, switch_say_callback_t number_func, switch_say_args_t *say_args, switch_input_args_t *args)
switch_status_t	switch_ivr_set_user (switch_core_session_t *session, const char *data)
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_sound_test (switch_core_session_t *session)
void	switch_process_import (switch_core_session_t *session, switch_channel_t *peer_channel, const char *varname, const char *prefix)
switch_bool_t	switch_ivr_uuid_exists (const char *uuid)
switch_bool_t	switch_ivr_uuid_force_exists (const char *uuid)
switch_bool_t	switch_ivr_dmachine_is_parsing (switch_ivr_dmachine_t *dmachine)
switch_status_t	switch_ivr_dmachine_last_ping (switch_ivr_dmachine_t *dmachine)
const char *	switch_ivr_dmachine_get_name (switch_ivr_dmachine_t *dmachine)
void	switch_ivr_dmachine_set_match_callback (switch_ivr_dmachine_t *dmachine, switch_ivr_dmachine_callback_t match_callback)
void	switch_ivr_dmachine_set_nonmatch_callback (switch_ivr_dmachine_t *dmachine, switch_ivr_dmachine_callback_t nonmatch_callback)
switch_status_t	switch_ivr_dmachine_create (switch_ivr_dmachine_t **dmachine_p, const char *name, switch_memory_pool_t *pool, uint32_t digit_timeout, uint32_t input_timeout, switch_ivr_dmachine_callback_t match_callback, switch_ivr_dmachine_callback_t nonmatch_callback, void *user_data)
void	switch_ivr_dmachine_destroy (switch_ivr_dmachine_t **dmachine)
switch_status_t	switch_ivr_dmachine_bind (switch_ivr_dmachine_t *dmachine, const char *realm, const char *digits, int32_t key, switch_ivr_dmachine_callback_t callback, void *user_data)
switch_status_t	switch_ivr_dmachine_feed (switch_ivr_dmachine_t *dmachine, const char *digits, switch_ivr_dmachine_match_t **match)
switch_status_t	switch_ivr_dmachine_clear (switch_ivr_dmachine_t *dmachine)
switch_status_t	switch_ivr_dmachine_ping (switch_ivr_dmachine_t *dmachine, switch_ivr_dmachine_match_t **match_p)
switch_ivr_dmachine_match_t *	switch_ivr_dmachine_get_match (switch_ivr_dmachine_t *dmachine)
const char *	switch_ivr_dmachine_get_failed_digits (switch_ivr_dmachine_t *dmachine)
void	switch_ivr_dmachine_set_digit_timeout_ms (switch_ivr_dmachine_t *dmachine, uint32_t digit_timeout_ms)
void	switch_ivr_dmachine_set_input_timeout_ms (switch_ivr_dmachine_t *dmachine, uint32_t input_timeout_ms)
switch_status_t	switch_ivr_dmachine_clear_realm (switch_ivr_dmachine_t *dmachine, const char *realm)
switch_status_t	switch_ivr_dmachine_set_realm (switch_ivr_dmachine_t *dmachine, const char *realm)
switch_status_t	switch_ivr_get_file_handle (switch_core_session_t *session, switch_file_handle_t **fh)
switch_status_t	switch_ivr_release_file_handle (switch_core_session_t *session, switch_file_handle_t **fh)
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)
switch_status_t	switch_ivr_record_session_mask (switch_core_session_t *session, const char *file, switch_bool_t on)
switch_status_t	switch_ivr_stop_video_write_overlay_session (switch_core_session_t *session)
switch_status_t	switch_ivr_video_write_overlay_session (switch_core_session_t *session, const char *img_path, switch_img_position_t pos, uint8_t alpha)

Detailed Description

IVR menu functions

Macro Definition Documentation

#define switch_ivr_phrase_macro	(		session,
			macro_name,
			data,
			lang,
			args
	)		switch_ivr_phrase_macro_event(session, macro_name, data, NULL, lang, args)

Definition at line 903 of file switch_ivr.h.

Referenced by play_and_collect(), CoreSession::sayPhrase(), switch_ivr_eavesdrop_session(), switch_ivr_phrase_macro_event(), and switch_ivr_play_file().

Typedef Documentation

typedef switch_ivr_action_t switch_ivr_menu_action_function_t(struct switch_ivr_menu *, char *, char *, size_t, void *)

Definition at line 783 of file switch_ivr.h.

typedef struct switch_ivr_menu_action switch_ivr_menu_action_t

Definition at line 785 of file switch_ivr.h.

typedef struct switch_ivr_menu switch_ivr_menu_t

Definition at line 784 of file switch_ivr.h.

typedef struct switch_ivr_menu_xml_ctx switch_ivr_menu_xml_ctx_t

Definition at line 871 of file switch_ivr.h.

Enumeration Type Documentation

enum switch_ivr_action_t

Enumerator
SWITCH_IVR_ACTION_DIE
SWITCH_IVR_ACTION_EXECMENU
SWITCH_IVR_ACTION_EXECAPP
SWITCH_IVR_ACTION_PLAYSOUND
SWITCH_IVR_ACTION_BACK
SWITCH_IVR_ACTION_TOMAIN
SWITCH_IVR_ACTION_NOOP

Definition at line 773 of file switch_ivr.h.

                      {
                 SWITCH_IVR_ACTION_DIE, /* Exit the menu.                  */
                 SWITCH_IVR_ACTION_EXECMENU,    /* Goto another menu in the stack. */
                 SWITCH_IVR_ACTION_EXECAPP,     /* Execute an application.         */
                 SWITCH_IVR_ACTION_PLAYSOUND,   /* Play a sound.                   */
                 SWITCH_IVR_ACTION_BACK,        /* Go back 1 menu.                 */
                 SWITCH_IVR_ACTION_TOMAIN,      /* Go back to the top level menu.  */
                 SWITCH_IVR_ACTION_NOOP /* No operation                    */
         } switch_ivr_action_t;

enum switch_ivr_menu_flags

Enumerator
SWITCH_IVR_MENU_FLAG_FALLTOMAIN
SWITCH_IVR_MENU_FLAG_FREEPOOL
SWITCH_IVR_MENU_FLAG_STACK

Definition at line 767 of file switch_ivr.h.

                      {
                 SWITCH_IVR_MENU_FLAG_FALLTOMAIN = (1 << 0),
                 SWITCH_IVR_MENU_FLAG_FREEPOOL = (1 << 1),
                 SWITCH_IVR_MENU_FLAG_STACK = (1 << 2)
         } switch_ivr_menu_flags;

Function Documentation

switch_status_t switch_ivr_bind_dtmf_meta_session	(	switch_core_session_t *	session,
		uint32_t	key,
		switch_bind_flag_t	bind_flags,
		const char *	app
	)

Definition at line 4110 of file switch_ivr_async.c.

References dtmf_meta_app_t::app, dtmf_meta_app_t::bind_flags, dtmf_meta_app_t::flags, is_dtmf, dtmf_meta_settings_t::map, dtmf_meta_settings_t::meta, meta_on_dtmf(), SBF_DIAL_ALEG, SBF_DIAL_BLEG, SMF_HOLD_BLEG, dtmf_meta_data_t::sr, switch_channel_get_private(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_session_alloc, switch_core_session_get_channel(), switch_core_session_strdup, SWITCH_DTMF_RECV, SWITCH_DTMF_SEND, switch_dtmftoi(), switch_itodtmf(), SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_META_VAR_KEY, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, dtmf_meta_settings_t::up, and zstr.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        dtmf_meta_data_t *md = switch_channel_get_private(channel, SWITCH_META_VAR_KEY);
        const char *meta_var = switch_channel_get_variable(channel, "bind_meta_key");
        char meta = '*';
        char str[2] = "";

        if (meta_var) {
                char t_meta = *meta_var;
                if (is_dtmf(t_meta)) {
                        meta = t_meta;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Invalid META KEY %c\n", t_meta);
                }
        }

        if (meta != '*' && meta != '#') {
                str[0] = meta;

                if (switch_dtmftoi(str) == (char)key) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid key %u, same as META CHAR\n", key);
                        return SWITCH_STATUS_FALSE;
                }
        }


        if (key > 13) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid key %u\n", key);
                return SWITCH_STATUS_FALSE;
        }

        if (!md) {
                md = switch_core_session_alloc(session, sizeof(*md));
                switch_channel_set_private(channel, SWITCH_META_VAR_KEY, md);
                switch_core_event_hook_add_send_dtmf(session, meta_on_dtmf);
                switch_core_event_hook_add_recv_dtmf(session, meta_on_dtmf);
        }

        if (!zstr(app)) {
                if ((bind_flags & SBF_DIAL_ALEG)) {
                        md->sr[SWITCH_DTMF_RECV].meta = meta;
                        md->sr[SWITCH_DTMF_RECV].up = 1;
                        md->sr[SWITCH_DTMF_RECV].map[key].app = switch_core_session_strdup(session, app);
                        md->sr[SWITCH_DTMF_RECV].map[key].flags |= SMF_HOLD_BLEG;
                        md->sr[SWITCH_DTMF_RECV].map[key].bind_flags = bind_flags;
                        
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Bound A-Leg: %c%c %s\n", meta, switch_itodtmf((char)key), app);
                }
                if ((bind_flags & SBF_DIAL_BLEG)) {
                        md->sr[SWITCH_DTMF_SEND].meta = meta;
                        md->sr[SWITCH_DTMF_SEND].up = 1;
                        md->sr[SWITCH_DTMF_SEND].map[key].app = switch_core_session_strdup(session, app);
                        md->sr[SWITCH_DTMF_SEND].map[key].flags |= SMF_HOLD_BLEG;
                        md->sr[SWITCH_DTMF_SEND].map[key].bind_flags = bind_flags;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Bound B-Leg: %c%c %s\n", meta, switch_itodtmf((char)key), app);
                }

        } else {
                if ((bind_flags & SBF_DIAL_ALEG)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "UnBound A-Leg: %c%c\n", meta, switch_itodtmf((char)key));
                        md->sr[SWITCH_DTMF_SEND].map[key].app = NULL;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "UnBound: B-Leg %c%d\n", meta, key);
                        md->sr[SWITCH_DTMF_SEND].map[key].app = NULL;
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_blind_transfer_ack	(	switch_core_session_t *	session,
		switch_bool_t	success
	)

Definition at line 4254 of file switch_ivr.c.

References CF_CONFIRM_BLIND_TRANSFER, switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::numeric_arg, switch_channel_clear_flag(), switch_channel_get_variable, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_receive_message, switch_core_session_rwunlock(), SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by switch_core_standard_on_routing().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_channel_test_flag(channel, CF_CONFIRM_BLIND_TRANSFER)) {
                switch_core_session_t *other_session;
                const char *uuid = switch_channel_get_variable(channel, "blind_transfer_uuid");

                switch_channel_clear_flag(channel, CF_CONFIRM_BLIND_TRANSFER);

                if (!zstr(uuid) && (other_session = switch_core_session_locate(uuid))) {
                        switch_core_session_message_t msg = { 0 };                      
                        msg.message_id = SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE;
                        msg.from = __FILE__;
                        msg.numeric_arg = success;
                        switch_core_session_receive_message(other_session, &msg);
                        switch_core_session_rwunlock(other_session);
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        return status;

}

switch_status_t switch_ivr_block_dtmf_session

(

switch_core_session_t *

session

)

Definition at line 4096 of file switch_ivr_async.c.

References block_on_dtmf(), SWITCH_BLOCK_DTMF_KEY, switch_channel_get_private(), switch_channel_set_private(), switch_core_session_get_channel(), and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        uint8_t enabled = (uint8_t)(intptr_t)switch_channel_get_private(channel, SWITCH_BLOCK_DTMF_KEY);

        if (!enabled) {
                switch_channel_set_private(channel, SWITCH_BLOCK_DTMF_KEY, (void *)(intptr_t)1);
                switch_core_event_hook_add_send_dtmf(session, block_on_dtmf);
                switch_core_event_hook_add_recv_dtmf(session, block_on_dtmf);
        }

        return SWITCH_STATUS_SUCCESS;
}

char* switch_ivr_check_presence_mapping	(	const char *	exten_name,
		const char *	domain_name
	)

Definition at line 4176 of file switch_ivr.c.

References switch_xml::next, switch_assert, SWITCH_CHANNEL_LOG, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, SWITCH_LOG_DEBUG1, SWITCH_LOG_ERROR, switch_log_printf(), switch_regex_perform(), switch_regex_safe_free, SWITCH_STACK_BOTTOM, switch_xml_attr(), switch_xml_child(), switch_xml_free(), switch_xml_open_cfg(), and zstr.

{
        char *cf = "presence_map.conf";
        switch_xml_t cfg, xml, x_domains, x_domain, x_exten;
        char *r = NULL;
        switch_event_t *params = NULL;
        switch_regex_t *re = NULL;
        int proceed = 0, ovector[100];

        switch_event_create(&params, SWITCH_EVENT_REQUEST_PARAMS);
        switch_assert(params);

        if ( !zstr(domain_name) ) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "domain", domain_name);
        }

        if ( !zstr(exten_name) ) {
                switch_event_add_header_string(params, SWITCH_STACK_BOTTOM, "exten", exten_name);
        }

        if (!(xml = switch_xml_open_cfg(cf, &cfg, params))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Open of %s failed\n", cf);
                goto end;
        }

        if (!(x_domains = switch_xml_child(cfg, "domains"))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't find any domains!\n");
                goto end;
        }

        for (x_domain = switch_xml_child(x_domains, "domain"); x_domain; x_domain = x_domain->next) {
                const char *dname = switch_xml_attr(x_domain, "name");
                if (!dname || (strcasecmp(dname, "*") && strcasecmp(domain_name, dname))) continue;
                
                for (x_exten = switch_xml_child(x_domain, "exten"); x_exten; x_exten = x_exten->next) {
                        const char *regex = switch_xml_attr(x_exten, "regex");
                        const char *proto = switch_xml_attr(x_exten, "proto");
                        
                        if (!zstr(regex) && !zstr(proto)) {
                                proceed = switch_regex_perform(exten_name, regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0]));
                                switch_regex_safe_free(re);
                                
                                if (proceed) {
                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Mapping %s@%s to proto %s matching expression [%s]\n", 
                                                                          exten_name, domain_name, proto, regex);
                                        r = strdup(proto);
                                        goto end;
                                }
                                
                        }
                }
        }

 end:
        switch_event_destroy(&params);

        if (xml) {
                switch_xml_free(xml);
        }

        return r;
        
}

switch_status_t switch_ivr_create_message_reply	(	switch_event_t **	reply,
		switch_event_t *	message,
		const char *	new_proto
	)

Definition at line 4163 of file switch_ivr.c.

References switch_event_add_header_string(), switch_event_dup_reply(), SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if ((status = switch_event_dup_reply(reply, message) != SWITCH_STATUS_SUCCESS)) {
                abort();
        }

        switch_event_add_header_string(*reply, SWITCH_STACK_BOTTOM, "proto", new_proto);

        return status;
}

void switch_ivr_delay_echo	(	switch_core_session_t *	session,
		uint32_t	delay_ms
	)

Definition at line 3419 of file switch_ivr.c.

References switch_rtp_packet_t::body, switch_frame::buflen, switch_frame::codec, switch_frame::data, switch_frame::datalen, switch_rtp_packet_t::header, switch_codec_implementation::microseconds_per_packet, switch_frame::packet, switch_frame::packetlen, switch_codec_implementation::samples_per_packet, switch_rtp_hdr_t::seq, SFF_CNG, SJB_AUDIO, switch_channel_get_variable, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), switch_core_session_write_frame(), SWITCH_IO_FLAG_NONE, switch_jb_create(), switch_jb_debug_level(), switch_jb_destroy(), switch_jb_get_packet(), switch_jb_put_packet(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_READ_ACCEPTABLE, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_rtp_hdr_t::ts, and switch_rtp_hdr_t::version.

{
        switch_jb_t *jb;
        int qlen = 0;
        switch_frame_t *read_frame, write_frame = { 0 };
        switch_status_t status;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        uint32_t interval;
        uint32_t ts = 0;
        uint16_t seq = 0;
        switch_codec_implementation_t read_impl = { 0 };
        int is_rtp = 0;
        int debug = 0;
        const char *var;


        switch_core_session_get_read_impl(session, &read_impl);

        if (delay_ms < 1 || delay_ms > 10000) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid delay [%d] must be between 1 and 10000\n", delay_ms);
                return;
        }

        interval = read_impl.microseconds_per_packet / 1000;

        if (delay_ms < interval * 2) {
                delay_ms = interval * 2;
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Minimum possible delay for this codec (%d) has been chosen\n", delay_ms);
        }

        qlen = delay_ms / (interval);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setting delay to %dms (%d frames)\n", delay_ms, qlen);

        switch_jb_create(&jb, SJB_AUDIO, qlen, qlen, switch_core_session_get_pool(session));

        if ((var = switch_channel_get_variable(channel, "delay_echo_debug_level"))) {
                debug = atoi(var);
        }

        if (debug) {
                switch_jb_debug_level(jb, debug);
        }

        write_frame.codec = switch_core_session_get_read_codec(session);

        while (switch_channel_ready(channel)) {
                switch_rtp_packet_t packet = { {0} };
                switch_size_t plen = sizeof(packet);

                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        break;
                }

                if (switch_test_flag(read_frame, SFF_CNG)) {
                        continue;
                }

                if (read_frame->packet) {
                        is_rtp = 1;
                        switch_jb_put_packet(jb, (switch_rtp_packet_t *) read_frame->packet, read_frame->packetlen);
                } else if (is_rtp) {
                        continue;
                } else {
                        ts += read_impl.samples_per_packet;
                        memcpy(packet.body, read_frame->data, read_frame->datalen);
                        packet.header.ts = htonl(ts);
                        packet.header.seq = htons(++seq);
                        packet.header.version = 2;
                }
                
                if (switch_jb_get_packet(jb, (switch_rtp_packet_t *) &packet, &plen) == SWITCH_STATUS_SUCCESS) {
                        write_frame.data = packet.body;
                        write_frame.datalen = (uint32_t) plen - 12;
                        write_frame.buflen = (uint32_t) plen;

                        status = switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0);

                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                break;
                        }
                }
        }

        switch_jb_destroy(&jb);
}

switch_status_t switch_ivr_dmachine_bind	(	switch_ivr_dmachine_t *	dmachine,
		const char *	realm,
		const char *	digits,
		int32_t	key,
		switch_ivr_dmachine_callback_t	callback,
		void *	user_data
	)

Definition at line 248 of file switch_ivr_async.c.

References dm_binding_head_t::binding_list, switch_ivr_dmachine_binding::callback, switch_ivr_dmachine_binding::digits, DMACHINE_MAX_DIGIT_LEN, switch_ivr_dmachine_binding::is_regex, switch_ivr_dmachine_binding::key, dm_binding_head_t::name, switch_ivr_dmachine_binding::next, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_hash_find(), switch_core_hash_insert, switch_core_strdup, switch_ivr_dmachine_set_realm(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, dm_binding_head_t::tail, switch_ivr_dmachine_binding::user_data, and zstr.

{
        switch_ivr_dmachine_binding_t *binding = NULL, *ptr;
        switch_size_t len;
        dm_binding_head_t *headp;
        const char *msg = "";

        if (strlen(digits) > DMACHINE_MAX_DIGIT_LEN -1) {
                return SWITCH_STATUS_FALSE;
        }

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

        if (!(headp = switch_core_hash_find(dmachine->binding_hash, realm))) {
                headp = switch_core_alloc(dmachine->pool, sizeof(*headp));
                headp->name = switch_core_strdup(dmachine->pool, realm);
                switch_core_hash_insert(dmachine->binding_hash, realm, headp);
        }

        for(ptr = headp->binding_list; ptr; ptr = ptr->next) {
                if ((ptr->is_regex && !strcmp(ptr->digits, digits+1)) || !strcmp(ptr->digits, digits)) {
                        msg = "Reuse Existing ";
                        binding = ptr;
                        binding->callback = callback;
                        binding->user_data = user_data; 
                        goto done;
                }
        }
        
        
        binding = switch_core_alloc(dmachine->pool, sizeof(*binding));

        if (*digits == '~') {
                binding->is_regex = 1;
                digits++;
        }

        binding->key = key;
        binding->digits = switch_core_strdup(dmachine->pool, digits);
        binding->callback = callback;
        binding->user_data = user_data;

        if (headp->tail) {
                headp->tail->next = binding;
        } else {
                headp->binding_list = binding;
        }

        headp->tail = binding;

        len = strlen(digits);

        if (dmachine->realm != headp) {
                switch_ivr_dmachine_set_realm(dmachine, realm);
        }

        if (binding->is_regex && dmachine->max_digit_len != DMACHINE_MAX_DIGIT_LEN -1) { 
                dmachine->max_digit_len = DMACHINE_MAX_DIGIT_LEN -1;
        } else if (len > dmachine->max_digit_len) {
                dmachine->max_digit_len = (uint32_t) len;
        }
        
 done:

        if (binding->is_regex) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%sDigit parser %s: binding %s/%s/%d callback: %p data: %p\n", 
                                                  msg, dmachine->name, digits, realm, key, (void *)(intptr_t) callback, user_data);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%sDigit parser %s: binding %s/%s/%d callback: %p data: %p\n", 
                                                  msg, dmachine->name, digits, realm, key, (void *)(intptr_t) callback, user_data);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_dmachine_clear

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 634 of file switch_ivr_async.c.

References memset(), and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_dmachine_ping().

{

        memset(dmachine->digits, 0, sizeof(dmachine->digits));
        dmachine->cur_digit_len = 0;
        dmachine->last_digit_time = 0;
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_dmachine_clear_realm	(	switch_ivr_dmachine_t *	dmachine,
		const char *	realm
	)

Definition at line 224 of file switch_ivr_async.c.

References SWITCH_CHANNEL_LOG, switch_core_hash_delete(), switch_core_hash_find(), SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

{
        dm_binding_head_t *headp;

        if (zstr(realm)) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Digit parser %s: Error unknown realm: '%s'\n", dmachine->name, realm);
                return SWITCH_STATUS_FALSE;
        }

        headp = switch_core_hash_find(dmachine->binding_hash, realm);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Digit parser %s: Clearing realm '%s'\n", dmachine->name, realm);

        if (headp == dmachine->realm) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, 
                                                  "Digit parser %s: '%s' was the active realm, no realm currently selected.\n", dmachine->name, realm);
                dmachine->realm = NULL;
        }

        /* pool alloc'd just ditch it and it will give back the memory when we destroy ourselves */
        switch_core_hash_delete(dmachine->binding_hash, realm);
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_dmachine_create	(	switch_ivr_dmachine_t **	dmachine_p,
		const char *	name,
		switch_memory_pool_t *	pool,
		uint32_t	digit_timeout,
		uint32_t	input_timeout,
		switch_ivr_dmachine_callback_t	match_callback,
		switch_ivr_dmachine_callback_t	nonmatch_callback,
		void *	user_data
	)

Definition at line 125 of file switch_ivr_async.c.

References switch_ivr_dmachine::binding_hash, switch_ivr_dmachine::digit_timeout_ms, switch_ivr_dmachine_match::dmachine, switch_ivr_dmachine::input_timeout_ms, switch_ivr_dmachine::match, switch_ivr_dmachine::match_callback, switch_ivr_dmachine::mutex, switch_ivr_dmachine::my_pool, switch_ivr_dmachine::name, switch_ivr_dmachine::nonmatch_callback, pool, switch_ivr_dmachine::pool, switch_core_alloc, switch_core_hash_init, switch_core_new_memory_pool, switch_core_strdup, switch_mutex_init(), SWITCH_MUTEX_NESTED, SWITCH_STATUS_SUCCESS, and switch_ivr_dmachine::user_data.

{
        switch_byte_t my_pool = 0;
        switch_ivr_dmachine_t *dmachine;

        if (!pool) {
                switch_core_new_memory_pool(&pool);
                my_pool = 1;
        }

        dmachine = switch_core_alloc(pool, sizeof(*dmachine));
        dmachine->pool = pool;
        dmachine->my_pool = my_pool;
        dmachine->digit_timeout_ms = digit_timeout_ms;
        dmachine->input_timeout_ms = input_timeout_ms;
        dmachine->match.dmachine = dmachine;
        dmachine->name = switch_core_strdup(dmachine->pool, name);
        switch_mutex_init(&dmachine->mutex, SWITCH_MUTEX_NESTED, dmachine->pool);
        
        switch_core_hash_init(&dmachine->binding_hash);
        
        if (match_callback) {
                dmachine->match_callback = match_callback;
        }

        if (nonmatch_callback) {
                dmachine->nonmatch_callback = nonmatch_callback;
        }

        dmachine->user_data = user_data;
        
        *dmachine_p = dmachine;
        
        return SWITCH_STATUS_SUCCESS;
}

void switch_ivr_dmachine_destroy

(

switch_ivr_dmachine_t **

dmachine

)

Definition at line 179 of file switch_ivr_async.c.

References pool, switch_core_destroy_memory_pool, and switch_core_hash_destroy().

Referenced by switch_core_session_perform_destroy().

{
        switch_memory_pool_t *pool;

        if (!(dmachine && *dmachine)) return;
        
        pool = (*dmachine)->pool;

        switch_core_hash_destroy(&(*dmachine)->binding_hash);
        
        if ((*dmachine)->my_pool) {
                switch_core_destroy_memory_pool(&pool);
        }
}

switch_status_t switch_ivr_dmachine_feed	(	switch_ivr_dmachine_t *	dmachine,
		const char *	digits,
		switch_ivr_dmachine_match_t **	match
	)

Definition at line 596 of file switch_ivr_async.c.

References SWITCH_CHANNEL_LOG, switch_ivr_dmachine_ping(), SWITCH_LOG_ERROR, switch_log_printf(), switch_mutex_lock(), switch_mutex_unlock(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_time_now(), and zstr.

Referenced by switch_core_session_recv_dtmf(), switch_core_session_send_dtmf(), switch_ivr_collect_digits_callback(), switch_ivr_gentones(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_sleep(), and switch_ivr_speak_text_handle().

{
        const char *p;
        switch_status_t status = SWITCH_STATUS_BREAK;
        
        if (!zstr(digits)) {
                status = SWITCH_STATUS_SUCCESS;
        }

        for (p = digits; p && *p; p++) {
                switch_mutex_lock(dmachine->mutex);
                if (dmachine->cur_digit_len < dmachine->max_digit_len) {
                        switch_status_t istatus;
                        char *e = dmachine->digits + strlen(dmachine->digits);
                        
                        *e++ = *p;
                        *e = '\0';
                        dmachine->cur_digit_len++;
                        switch_mutex_unlock(dmachine->mutex);
                        dmachine->last_digit_time = switch_time_now();
                        if (status == SWITCH_STATUS_SUCCESS && (istatus = switch_ivr_dmachine_ping(dmachine, match)) != SWITCH_STATUS_SUCCESS) {
                                status = istatus;
                        }
                } else {
                        switch_mutex_unlock(dmachine->mutex);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "dmachine overflow error!\n");
                        status = SWITCH_STATUS_FALSE;
                }
        }
                
        return status;
}

const char* switch_ivr_dmachine_get_failed_digits

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 470 of file switch_ivr_async.c.

{

        return dmachine->last_failed_digits;
}

switch_ivr_dmachine_match_t* switch_ivr_dmachine_get_match

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 460 of file switch_ivr_async.c.

{
        if (dmachine->is_match) {
                dmachine->is_match = 0;
                return &dmachine->match;
        }

        return NULL;
}

const char* switch_ivr_dmachine_get_name

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 120 of file switch_ivr_async.c.

{
        return (const char *) dmachine->name;
}

switch_bool_t switch_ivr_dmachine_is_parsing

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 629 of file switch_ivr_async.c.

Referenced by switch_ivr_play_file().

{
        return !!dmachine->cur_digit_len;
}

switch_status_t switch_ivr_dmachine_last_ping

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 86 of file switch_ivr_async.c.

Referenced by switch_ivr_play_and_detect_speech().

{
        return dmachine->last_return;
}

switch_status_t switch_ivr_dmachine_ping	(	switch_ivr_dmachine_t *	dmachine,
		switch_ivr_dmachine_match_t **	match_p
	)

Definition at line 476 of file switch_ivr_async.c.

References DM_MATCH_BOTH, DM_MATCH_EXACT, DM_MATCH_NEGATIVE, DM_MATCH_NEVER, DM_MATCH_NONE, DM_MATCH_POSITIVE, switch_ivr_dmachine_check_match(), switch_ivr_dmachine_check_timeout(), switch_ivr_dmachine_clear(), switch_mutex_trylock(), switch_mutex_unlock(), switch_set_string, SWITCH_STATUS_BREAK, SWITCH_STATUS_CONTINUE, SWITCH_STATUS_FALSE, SWITCH_STATUS_FOUND, SWITCH_STATUS_NOTFOUND, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, and zstr.

Referenced by signal_bridge_on_hibernate(), switch_core_session_read_frame(), switch_ivr_collect_digits_callback(), switch_ivr_dmachine_feed(), switch_ivr_gentones(), switch_ivr_park(), switch_ivr_play_file(), switch_ivr_record_file(), switch_ivr_sleep(), and switch_ivr_speak_text_handle().

{
        switch_bool_t is_timeout = switch_ivr_dmachine_check_timeout(dmachine);
        dm_match_t is_match = switch_ivr_dmachine_check_match(dmachine, is_timeout);
        switch_status_t r, s;
        int clear = 0;

        if (is_match == DM_MATCH_NEVER) {
                is_timeout++;
        }
        
        if (switch_mutex_trylock(dmachine->mutex) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (dmachine->pinging) {
                return SWITCH_STATUS_BREAK;
        }

        dmachine->pinging = 1;

        if (zstr(dmachine->digits) && !is_timeout) {
                r = SWITCH_STATUS_SUCCESS;
        } else if (dmachine->cur_digit_len > dmachine->max_digit_len) {
                r = SWITCH_STATUS_FALSE;
        } else if (is_match == DM_MATCH_EXACT || (is_match == DM_MATCH_BOTH && is_timeout)) {
                r = SWITCH_STATUS_FOUND;
                
                dmachine->match.match_digits = dmachine->last_matching_digits;
                dmachine->match.match_key = dmachine->last_matching_binding->key;
                dmachine->match.user_data = dmachine->last_matching_binding->user_data;
                
                if (match_p) {
                        *match_p = &dmachine->match;
                }

                dmachine->is_match = 1;

                dmachine->match.type = DM_MATCH_POSITIVE;
                
                if (dmachine->last_matching_binding->callback) {
                        s = dmachine->last_matching_binding->callback(&dmachine->match);
                        
                        switch(s) {
                        case SWITCH_STATUS_CONTINUE:
                                r = SWITCH_STATUS_SUCCESS;
                                break;
                        case SWITCH_STATUS_SUCCESS:
                                break;
                        default:
                                r = SWITCH_STATUS_BREAK;
                                break;
                        }
                }

                if (dmachine->match_callback) {
                        dmachine->match.user_data = dmachine->user_data;
                        s = dmachine->match_callback(&dmachine->match);

                        switch(s) {
                        case SWITCH_STATUS_CONTINUE:
                                r = SWITCH_STATUS_SUCCESS;
                                break;
                        case SWITCH_STATUS_SUCCESS:
                                break;
                        default:
                                r = SWITCH_STATUS_BREAK;
                                break;
                        }

                }

                clear++;
        } else if (is_timeout) {
                r = SWITCH_STATUS_TIMEOUT;
        } else if (is_match == DM_MATCH_NONE && dmachine->cur_digit_len == dmachine->max_digit_len) {
                r = SWITCH_STATUS_NOTFOUND;
        } else {
                r = SWITCH_STATUS_SUCCESS;
        }
        
        if (r != SWITCH_STATUS_FOUND && r != SWITCH_STATUS_SUCCESS && r != SWITCH_STATUS_BREAK) {
                switch_set_string(dmachine->last_failed_digits, dmachine->digits);
                dmachine->match.match_digits = dmachine->last_failed_digits;
                
                dmachine->match.type = DM_MATCH_NEGATIVE;
                
                if (dmachine->nonmatch_callback) {
                        dmachine->match.user_data = dmachine->user_data;
                        s = dmachine->nonmatch_callback(&dmachine->match);

                        switch(s) {
                        case SWITCH_STATUS_CONTINUE:
                                r = SWITCH_STATUS_SUCCESS;
                                break;
                        case SWITCH_STATUS_SUCCESS:
                                break;
                        default:
                                r = SWITCH_STATUS_BREAK;
                                break;
                        }

                }
                
                clear++;
        }
        
        if (clear) {
                switch_ivr_dmachine_clear(dmachine);
        }

        dmachine->last_return = r;

        dmachine->pinging = 0;

        switch_mutex_unlock(dmachine->mutex);

        return r;
}

void switch_ivr_dmachine_set_digit_timeout_ms	(	switch_ivr_dmachine_t *	dmachine,
		uint32_t	digit_timeout_ms
	)

Definition at line 169 of file switch_ivr_async.c.

{
        dmachine->digit_timeout_ms = digit_timeout_ms;
}

void switch_ivr_dmachine_set_input_timeout_ms	(	switch_ivr_dmachine_t *	dmachine,
		uint32_t	input_timeout_ms
	)

Definition at line 174 of file switch_ivr_async.c.

{
        dmachine->input_timeout_ms = input_timeout_ms;
}

void switch_ivr_dmachine_set_match_callback	(	switch_ivr_dmachine_t *	dmachine,
		switch_ivr_dmachine_callback_t	match_callback
	)

Definition at line 104 of file switch_ivr_async.c.

References switch_assert.

{

        switch_assert(dmachine);
        dmachine->match_callback = match_callback;

}

void switch_ivr_dmachine_set_nonmatch_callback	(	switch_ivr_dmachine_t *	dmachine,
		switch_ivr_dmachine_callback_t	nonmatch_callback
	)

Definition at line 112 of file switch_ivr_async.c.

References switch_assert.

{

        switch_assert(dmachine);
        dmachine->nonmatch_callback = nonmatch_callback;

}

switch_status_t switch_ivr_dmachine_set_realm	(	switch_ivr_dmachine_t *	dmachine,
		const char *	realm
	)

Definition at line 209 of file switch_ivr_async.c.

References SWITCH_CHANNEL_LOG, switch_core_hash_find(), SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_dmachine_bind().

{
        dm_binding_head_t *headp = switch_core_hash_find(dmachine->binding_hash, realm);

        if (headp) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Digit parser %s: Setting realm to '%s'\n", dmachine->name, realm);
                dmachine->realm = headp;
                return SWITCH_STATUS_SUCCESS;
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Digit parser %s: Error Setting realm to '%s'\n", dmachine->name, realm);
        
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_find_bridged_uuid	(	const char *	uuid,
		char *	b_uuid,
		switch_size_t	blen
	)

Definition at line 2033 of file switch_ivr_bridge.c.

References switch_assert, switch_channel_get_partner_uuid(), switch_channel_get_variable, switch_copy_string(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_intercept_session().

{
        switch_core_session_t *rsession;
        switch_status_t status = SWITCH_STATUS_FALSE;

        switch_assert(uuid);

        if ((rsession = switch_core_session_locate(uuid))) {
                switch_channel_t *rchannel = switch_core_session_get_channel(rsession);
                const char *brto;

                if ((brto = switch_channel_get_variable(rchannel, SWITCH_ORIGINATE_SIGNAL_BOND_VARIABLE)) || 
                        (brto = switch_channel_get_partner_uuid(rchannel))) {
                        switch_copy_string(b_uuid, brto, blen);
                        status = SWITCH_STATUS_SUCCESS;
                }
                switch_core_session_rwunlock(rsession);
        }

        return status;

}

switch_status_t switch_ivr_get_file_handle	(	switch_core_session_t *	session,
		switch_file_handle_t **	fh
	)

Definition at line 1123 of file switch_ivr_play_say.c.

References switch_channel_get_private(), switch_core_session_get_channel(), switch_core_session_io_read_lock(), switch_core_session_io_rwunlock(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_file_handle_t *fhp;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        *fh = NULL;
        switch_core_session_io_read_lock(session);

        if ((fhp = switch_channel_get_private(channel, "__fh"))) {
                *fh = fhp;
                return SWITCH_STATUS_SUCCESS;
        }

        switch_core_session_io_rwunlock(session);

        return SWITCH_STATUS_FALSE;
}

switch_say_gender_t switch_ivr_get_say_gender_by_name

(

const char *

name

)

Definition at line 74 of file switch_ivr_say.c.

References SAY_GENDER_NAMES.

Referenced by switch_ivr_phrase_macro_event(), switch_ivr_say(), and switch_ivr_say_string().

{
        int x = 0;

        if (!name) return (switch_say_gender_t)0;

        for (x = 0; SAY_GENDER_NAMES[x]; x++) {
                if (!strcasecmp(SAY_GENDER_NAMES[x], name)) {
                        break;
                }
        }

        return (switch_say_gender_t) x;
}

switch_say_method_t switch_ivr_get_say_method_by_name

(

const char *

name

)

Definition at line 89 of file switch_ivr_say.c.

References SAY_METHOD_NAMES.

Referenced by switch_ivr_phrase_macro_event(), switch_ivr_say(), and switch_ivr_say_string().

{
        int x = 0;

        if (!name) return (switch_say_method_t)0;

        for (x = 0; SAY_METHOD_NAMES[x]; x++) {
                if (!strcasecmp(SAY_METHOD_NAMES[x], name)) {
                        break;
                }
        }

        return (switch_say_method_t) x;
}

switch_say_type_t switch_ivr_get_say_type_by_name

(

const char *

name

)

Definition at line 104 of file switch_ivr_say.c.

References SAY_TYPE_NAMES.

Referenced by switch_ivr_phrase_macro_event(), switch_ivr_say(), and switch_ivr_say_string().

{
        int x = 0;

        if (!name) return (switch_say_type_t)0;

        for (x = 0; SAY_TYPE_NAMES[x]; x++) {
                if (!strcasecmp(SAY_TYPE_NAMES[x], name)) {
                        break;
                }
        }

        return (switch_say_type_t) x;
}

switch_status_t switch_ivr_insert_file	(	switch_core_session_t *	session,
		const char *	file,
		const char *	insert_file,
		switch_size_t	sample_point
	)

Definition at line 4009 of file switch_ivr.c.

References switch_codec_implementation::actual_samples_per_second, switch_file_handle::channels, switch_file_handle::native_rate, switch_codec_implementation::number_of_channels, START_SAMPLES, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_core_file_close(), switch_core_file_open, switch_core_file_read(), switch_core_file_seek(), switch_core_file_write(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_sprintf(), SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, SWITCH_FILE_FLAG_WRITE, SWITCH_FILE_NATIVE, SWITCH_FILE_OPEN, switch_file_rename(), SWITCH_GLOBAL_dirs, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_PATH_SEPARATOR, switch_safe_free, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_uuid_format(), SWITCH_UUID_FORMATTED_LENGTH, switch_uuid_get(), switch_zmalloc, and switch_directories::temp_dir.

Referenced by CoreSession::insertFile().

{
        switch_file_handle_t orig_fh = { 0 };
        switch_file_handle_t new_fh = { 0 };
        switch_codec_implementation_t read_impl = { 0 };
        char *tmp_file;
        switch_uuid_t uuid;
        char uuid_str[SWITCH_UUID_FORMATTED_LENGTH + 1];
        int16_t *abuf = NULL;
        switch_size_t olen = 0;
        int asis = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_size_t sample_count = 0;
        uint32_t pos = 0;
        char *ext;

        switch_uuid_get(&uuid);
        switch_uuid_format(uuid_str, &uuid);

        if ((ext = strrchr(file, '.'))) {
                ext++;
        } else {
                ext = "wav";
        }
        
        tmp_file = switch_core_session_sprintf(session, "%s%smsg_%s.%s", 
                                                                                   SWITCH_GLOBAL_dirs.temp_dir, SWITCH_PATH_SEPARATOR, uuid_str, ext);  
        
        switch_core_session_get_read_impl(session, &read_impl);
        
        new_fh.channels = read_impl.number_of_channels;
        new_fh.native_rate = read_impl.actual_samples_per_second;


        if (switch_core_file_open(&new_fh,
                                                          tmp_file,
                                                          new_fh.channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_WRITE | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Failed to open file %s\n", tmp_file);
                goto end;
        }


        if (switch_core_file_open(&orig_fh,
                                                          file,
                                                          new_fh.channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Failed to open file %s\n", file);
                goto end;
        }


        switch_zmalloc(abuf, START_SAMPLES * sizeof(*abuf));

        if (switch_test_flag((&orig_fh), SWITCH_FILE_NATIVE)) {
                asis = 1;
        }

        while (switch_channel_ready(channel)) {
                olen = START_SAMPLES;

                if (!asis) {
                        olen /= 2;
                }

                if ((sample_count + olen) > sample_point) {
                        olen = sample_point - sample_count;
                }

                if (!olen || switch_core_file_read(&orig_fh, abuf, &olen) != SWITCH_STATUS_SUCCESS || !olen) {
                        break;
                }

                sample_count += olen;

                switch_core_file_write(&new_fh, abuf, &olen);
        }

        switch_core_file_close(&orig_fh);


        if (switch_core_file_open(&orig_fh,
                                                          insert_file,
                                                          new_fh.channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Failed to open file %s\n", file);
                goto end;
        }


        while (switch_channel_ready(channel)) {
                olen = START_SAMPLES;

                if (!asis) {
                        olen /= 2;
                }

                if (switch_core_file_read(&orig_fh, abuf, &olen) != SWITCH_STATUS_SUCCESS || !olen) {
                        break;
                }

                sample_count += olen;

                switch_core_file_write(&new_fh, abuf, &olen);
        }

        switch_core_file_close(&orig_fh);

        if (switch_core_file_open(&orig_fh,
                                                          file,
                                                          new_fh.channels,
                                                          read_impl.actual_samples_per_second, SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Failed to open file %s\n", file);
                goto end;
        }

        pos = 0;
        switch_core_file_seek(&orig_fh, &pos, sample_point, SEEK_SET);

        while (switch_channel_ready(channel)) {
                olen = START_SAMPLES;

                if (!asis) {
                        olen /= 2;
                }

                if (switch_core_file_read(&orig_fh, abuf, &olen) != SWITCH_STATUS_SUCCESS || !olen) {
                        break;
                }

                sample_count += olen;

                switch_core_file_write(&new_fh, abuf, &olen);
        }

 end:

        if (switch_test_flag((&orig_fh), SWITCH_FILE_OPEN)) {
                switch_core_file_close(&orig_fh);
        }

        if (switch_test_flag((&new_fh), SWITCH_FILE_OPEN)) {
                switch_core_file_close(&new_fh);
        }

        switch_file_rename(tmp_file, file, switch_core_session_get_pool(session));
        unlink(tmp_file);

        switch_safe_free(abuf);

        return SWITCH_STATUS_SUCCESS;
}

void switch_ivr_intercept_session	(	switch_core_session_t *	session,
		const char *	uuid,
		switch_bool_t	bleg
	)

Definition at line 2056 of file switch_ivr_bridge.c.

References CF_ANSWERED, CF_BRIDGED, CF_INTERCEPT, CF_INTERCEPTED, CF_TRANSFER, CS_PARK, SWITCH_CAUSE_PICKED_OFF, switch_channel_answer, switch_channel_get_partner_uuid(), switch_channel_get_variable, switch_channel_hangup, switch_channel_mark_hold(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_state, switch_channel_set_state_flag(), switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_get_uuid(), switch_core_session_locate, switch_core_session_rwunlock(), switch_core_session_strdup, SWITCH_FALSE, switch_ivr_find_bridged_uuid(), switch_ivr_uuid_bridge(), SWITCH_LOG_DEBUG, switch_log_printf(), SWITCH_STATUS_SUCCESS, switch_true(), SWITCH_UUID_FORMATTED_LENGTH, and zstr.

{
        switch_core_session_t *rsession, *bsession = NULL;
        switch_channel_t *channel, *rchannel, *bchannel = NULL;
        const char *buuid, *var;
        char brto[SWITCH_UUID_FORMATTED_LENGTH + 1] = "";
        
        if (bleg) {
                if (switch_ivr_find_bridged_uuid(uuid, brto, sizeof(brto)) == SWITCH_STATUS_SUCCESS) {
                        uuid = switch_core_session_strdup(session, brto);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "no uuid bridged to %s\n", uuid);
                        return;
                }
        }

        if (zstr(uuid) || !(rsession = switch_core_session_locate(uuid))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "no uuid %s\n", uuid);
                return;
        }

        channel = switch_core_session_get_channel(session);
        rchannel = switch_core_session_get_channel(rsession);
        buuid = switch_channel_get_partner_uuid(rchannel);

        if ((var = switch_channel_get_variable(channel, "intercept_unbridged_only")) && switch_true(var)) {
                if ((switch_channel_test_flag(rchannel, CF_BRIDGED))) {
                        switch_core_session_rwunlock(rsession);
                        return;
                }
        }

        if ((var = switch_channel_get_variable(channel, "intercept_unanswered_only")) && switch_true(var)) {
                if ((switch_channel_test_flag(rchannel, CF_ANSWERED))) {
                        switch_core_session_rwunlock(rsession);
                        return;
                }
        }

        switch_channel_answer(channel);

        if (!zstr(buuid)) {
                if ((bsession = switch_core_session_locate(buuid))) {
                        bchannel = switch_core_session_get_channel(bsession);
                        switch_channel_set_flag(bchannel, CF_INTERCEPT);
                }
        }

        if (!switch_channel_test_flag(rchannel, CF_ANSWERED)) {
                switch_channel_answer(rchannel);
        }

        switch_channel_mark_hold(rchannel, SWITCH_FALSE);

        switch_channel_set_state_flag(rchannel, CF_TRANSFER);
        switch_channel_set_state(rchannel, CS_PARK);

        if (bchannel) {
                switch_channel_set_variable(bchannel, "park_after_bridge", "true");
        }

        switch_channel_set_flag(rchannel, CF_INTERCEPTED);
        switch_ivr_uuid_bridge(switch_core_session_get_uuid(session), uuid);
        switch_core_session_rwunlock(rsession);

        if (bsession) {
                switch_channel_hangup(bchannel, SWITCH_CAUSE_PICKED_OFF);
                switch_core_session_rwunlock(bsession);
        }



}

switch_status_t switch_ivr_kill_uuid	(	const char *	uuid,
		switch_call_cause_t	cause
	)

Definition at line 4240 of file switch_ivr.c.

References switch_channel_hangup, switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_core_session_t *session;

        if (zstr(uuid) || !(session = switch_core_session_locate(uuid))) {
                return SWITCH_STATUS_FALSE;
        } else {
                switch_channel_t *channel = switch_core_session_get_channel(session);
                switch_channel_hangup(channel, cause);
                switch_core_session_rwunlock(session);
                return SWITCH_STATUS_SUCCESS;
        }
}

switch_status_t switch_ivr_menu_bind_action	(	switch_ivr_menu_t *	menu,
		switch_ivr_action_t	ivr_action,
		const char *	arg,
		const char *	bind
	)

switch_ivr_menu_bind_action: Bind a keystroke to an action.

Parameters

menu	The menu obj you wish to bind to.
ivr_action	switch_ivr_action_t enum of what you want to do.
arg	Optional (sometimes necessary) string arguement.
bind	KeyStrokes to bind the action to.

Returns

SWUTCH_STATUS_SUCCESS if the action was binded

Definition at line 244 of file switch_ivr_menu.c.

References switch_ivr_menu_action::arg, switch_ivr_menu_action::bind, switch_ivr_menu_action::ivr_action, switch_ivr_menu_action::next, switch_ivr_menu_action::re, switch_core_alloc, switch_core_strdup, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

Referenced by IVRMenu::bindAction(), and switch_ivr_menu_stack_xml_build().

{
        switch_ivr_menu_action_t *action, *ap;
        uint32_t len;

        if ((action = switch_core_alloc(menu->pool, sizeof(*action)))) {
                action->bind = switch_core_strdup(menu->pool, bind);
                action->arg = switch_core_strdup(menu->pool, arg);
                if (*action->bind == '/') {
                        action->re = 1;
                } else {
                        len = (uint32_t) strlen(action->bind);
                        if (len > menu->inlen) {
                                menu->inlen = len;
                        }
                }
                action->ivr_action = ivr_action;

                if (menu->actions) {
                        for(ap = menu->actions; ap && ap->next; ap = ap->next);
                        ap->next = action;
                } else {
                menu->actions = action;
                }

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_MEMERR;
}

switch_status_t switch_ivr_menu_bind_function	(	switch_ivr_menu_t *	menu,
		switch_ivr_menu_action_function_t *	function,
		const char *	arg,
		const char *	bind
	)

Bind a keystroke to a callback function.

Parameters

menu	The menu obj you wish to bind to.
function	The function to call [int proto(struct switch_ivr_menu *, char *, size_t, void *)]
arg	Optional (sometimes necessary) string arguement.
bind	KeyStrokes to bind the action to.

Note

The function is passed a buffer to fill in with any required argument data.

The function is also passed an optional void pointer to an object set upon menu execution. (think threads)

The function returns an switch_ivr_action_t enum of what you want to do. and looks to your buffer for args.

Returns

SWUTCH_STATUS_SUCCESS if the function was binded

Definition at line 275 of file switch_ivr_menu.c.

References switch_ivr_menu_action::arg, switch_ivr_menu_action::bind, switch_ivr_menu_action::function, switch_ivr_menu_action::next, switch_ivr_menu_action::re, switch_core_alloc, switch_core_strdup, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_menu_stack_xml_build().

{
        switch_ivr_menu_action_t *action, *ap;
        uint32_t len;

        if ((action = switch_core_alloc(menu->pool, sizeof(*action)))) {
                action->bind = switch_core_strdup(menu->pool, bind);
                action->arg = switch_core_strdup(menu->pool, arg);

                if (*action->bind == '/') {
                        action->re = 1;
                } else {
                        len = (uint32_t) strlen(action->bind);
                        if (len > menu->inlen) {
                                menu->inlen = len;
                        }
                }

                action->function = function;
                
                if (menu->actions) {
                        for(ap = menu->actions; ap && ap->next; ap = ap->next);
                        ap->next = action;
                } else {
                menu->actions = action;
                }

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_MEMERR;
}

switch_status_t switch_ivr_menu_execute	(	switch_core_session_t *	session,
		switch_ivr_menu_t *	stack,
		char *	name,
		void *	obj
	)

Execute a menu.

Parameters

session	The session running the menu.
stack	The top-level menu object (the first one you created.)
name	A pointer to the name of the menu.
obj	A void pointer to an object you want to make avaliable to your callback functions that you may have binded with switch_ivr_menu_bind_function.

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 450 of file switch_ivr_menu.c.

References actions, switch_ivr_menu_action::arg, bad_pin_file, switch_ivr_menu_action::bind, buf, exec_app(), exec_on_max_fail, exec_on_max_timeout, exit_sound, switch_ivr_menu_action::function, greeting_sound, inlen, invalid_sound, switch_ivr_menu_action::ivr_action, ivr_send_event(), max_failures, max_timeouts, memset(), MENU_EVENT_ENTER, MENU_EVENT_EXIT, name, switch_ivr_menu_action::next, pin, play_and_collect(), prompt_pin_file, switch_ivr_menu_action::re, running, short_greeting_sound, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_clear_flag, switch_core_session_exec(), switch_core_session_get_channel(), switch_core_session_sprintf(), switch_core_session_strdup, switch_goto_status, SWITCH_IVR_ACTION_BACK, SWITCH_IVR_ACTION_DIE, SWITCH_IVR_ACTION_EXECAPP, SWITCH_IVR_ACTION_EXECMENU, SWITCH_IVR_ACTION_NOOP, SWITCH_IVR_ACTION_PLAYSOUND, SWITCH_IVR_ACTION_TOMAIN, switch_ivr_menu_find(), SWITCH_IVR_MENU_FLAG_FALLTOMAIN, SWITCH_IVR_MENU_FLAG_STACK, switch_ivr_play_file(), switch_loadable_module_get_application_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_perform_substitution(), switch_play_and_get_digits(), switch_regex_perform(), switch_regex_safe_free, switch_set_flag, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_IS_BREAK, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_test_flag, transfer_sound, tts_engine, tts_voice, UNPROTECT_INTERFACE, and zstr.

Referenced by IVRMenu::execute().

{
        int reps = 0, errs = 0, timeouts = 0, match = 0, running = 1;
        char *greeting_sound = NULL, *aptr = NULL;
        char arg[512];
        switch_ivr_action_t todo = SWITCH_IVR_ACTION_DIE;
        switch_ivr_menu_action_t *ap;
        switch_ivr_menu_t *menu = NULL;
        switch_channel_t *channel;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        if (++stack->stack_count > 12) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Too many levels of recursion.\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (!session || !stack || zstr(name)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid menu context\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        channel = switch_core_session_get_channel(session);

        if (!(menu = switch_ivr_menu_find(stack, name))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Menu!\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (!zstr(menu->tts_engine) && !zstr(menu->tts_voice)) {
                switch_channel_set_variable(channel, "tts_engine", menu->tts_engine);
                switch_channel_set_variable(channel, "tts_voice", menu->tts_voice);
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Executing IVR menu %s\n", menu->name);
        switch_channel_set_variable(channel, "ivr_menu_status", "success");

        ivr_send_event(session, MENU_EVENT_ENTER, menu);

        if (!zstr(menu->pin)) {
                char digit_buffer[128] = "";
                char *digits_regex = switch_core_session_sprintf(session, "^%s$", menu->pin);

                if (switch_play_and_get_digits(session, (uint32_t)strlen(menu->pin), (uint32_t)strlen(menu->pin), 3, 3000, "#",
                                                                           menu->prompt_pin_file, menu->bad_pin_file, NULL, digit_buffer, sizeof(digit_buffer), 
                                                                           digits_regex, 10000, NULL) != SWITCH_STATUS_SUCCESS) {
                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                }
        }


        for (reps = 0; running && status == SWITCH_STATUS_SUCCESS; reps++) {
                if (!switch_channel_ready(channel)) {
                        break;
                }
                if (errs == menu->max_failures) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Maximum failures\n");
                        switch_channel_set_variable(channel, "ivr_menu_status", "failure");
                        if (!zstr(menu->exec_on_max_fail)) {
                                exec_app(session, menu->exec_on_max_fail);
                        }
                        break;
                }
                if (timeouts == menu->max_timeouts) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Maximum timeouts\n");
                        switch_channel_set_variable(channel, "ivr_menu_status", "timeout");
                        if (!zstr(menu->exec_on_max_timeout)) {
                                exec_app(session, menu->exec_on_max_timeout);
                        }
                        break;
                }

                if (reps > 0 && menu->short_greeting_sound) {
                        greeting_sound = menu->short_greeting_sound;
                } else {
                        greeting_sound = menu->greeting_sound;
                }

                match = 0;
                aptr = NULL;

                memset(arg, 0, sizeof(arg));

                memset(menu->buf, 0, menu->inlen + 1);

                if (play_and_collect(session, menu, greeting_sound, menu->inlen) == SWITCH_STATUS_TIMEOUT && *menu->buf == '\0') {
                        timeouts++;
                        continue;
                }

                if (*menu->buf != '\0') {

                        for (ap = menu->actions; ap; ap = ap->next) {
                                int ok = 0;
                                char substituted[1024];
                                char *use_arg = ap->arg;

                                if (!zstr(menu->tts_engine) && !zstr(menu->tts_voice)) {
                                        switch_channel_set_variable(channel, "tts_engine", menu->tts_engine);
                                        switch_channel_set_variable(channel, "tts_voice", menu->tts_voice);
                                }

                                if (ap->re) {
                                        switch_regex_t *re = NULL;
                                        int ovector[30];

                                        if ((ok = switch_regex_perform(menu->buf, ap->bind, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                                                switch_perform_substitution(re, ok, ap->arg, menu->buf, substituted, sizeof(substituted), ovector);
                                                use_arg = substituted;
                                        }
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "action regex [%s] [%s] [%d]\n", menu->buf, ap->bind, ok);

                                        switch_regex_safe_free(re);
                                } else {
                                        ok = !strcmp(menu->buf, ap->bind);
                                }

                                if (ok) {
                                        match++;
                                        errs = 0;
                                        if (ap->function) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                  "IVR function on menu '%s' matched '%s' param '%s'\n", menu->name, menu->buf, use_arg);
                                                todo = ap->function(menu, use_arg, arg, sizeof(arg), obj);
                                                aptr = arg;
                                        } else {
                                                todo = ap->ivr_action;
                                                aptr = use_arg;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                  "IVR action on menu '%s' matched '%s' param '%s'\n", menu->name, menu->buf, aptr);
                                        }

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "switch_ivr_menu_execute todo=[%d]\n", todo);

                                        switch (todo) {
                                        case SWITCH_IVR_ACTION_DIE:
                                                status = SWITCH_STATUS_FALSE;
                                                break;
                                        case SWITCH_IVR_ACTION_PLAYSOUND:
                                                status = switch_ivr_play_file(session, NULL, aptr, NULL);
                                                break;
                                        case SWITCH_IVR_ACTION_EXECMENU:
                                                if (!strcmp(aptr, menu->name)) {
                                                        status = SWITCH_STATUS_SUCCESS;
                                                } else {
                                                        reps = -1;
                                                        ivr_send_event(session, MENU_EVENT_EXIT, menu);
                                                        status = switch_ivr_menu_execute(session, stack, aptr, obj);
                                                        ivr_send_event(session, MENU_EVENT_ENTER, menu);
                                                }
                                                break;
                                        case SWITCH_IVR_ACTION_EXECAPP:
                                                {
                                                        switch_application_interface_t *application_interface;
                                                        char *app_name;
                                                        char *app_arg = NULL;

                                                        status = SWITCH_STATUS_FALSE;

                                                        if (!zstr(aptr)) {
                                                                app_name = switch_core_session_strdup(session, aptr);
                                                                if ((app_arg = strchr(app_name, ' '))) {
                                                                        *app_arg++ = '\0';
                                                                }

                                                                if ((application_interface = switch_loadable_module_get_application_interface(app_name))) {
                                                                        if (!zstr(menu->transfer_sound) && !strcmp(app_name, "transfer")) {
                                                                                status = play_and_collect(session, menu, menu->transfer_sound, 0);
                                                                        }

                                                                        switch_core_session_exec(session, application_interface, app_arg);
                                                                        UNPROTECT_INTERFACE(application_interface);
                                                                        status = SWITCH_STATUS_SUCCESS;
                                                                }
                                                        }
                                                }
                                                break;
                                        case SWITCH_IVR_ACTION_BACK:
                                                running = 0;
                                                status = SWITCH_STATUS_SUCCESS;
                                                break;
                                        case SWITCH_IVR_ACTION_TOMAIN:
                                                switch_set_flag(stack, SWITCH_IVR_MENU_FLAG_FALLTOMAIN);
                                                status = SWITCH_STATUS_BREAK;
                                                break;
                                        case SWITCH_IVR_ACTION_NOOP:
                                                status = SWITCH_STATUS_SUCCESS;
                                                break;
                                        default:
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Invalid TODO!\n");
                                                break;
                                        }
                                }
                        }

                        if (switch_test_flag(menu, SWITCH_IVR_MENU_FLAG_STACK)) {       /* top level */
                                if (switch_test_flag(stack, SWITCH_IVR_MENU_FLAG_FALLTOMAIN)) { /* catch the fallback and recover */
                                        switch_clear_flag(stack, SWITCH_IVR_MENU_FLAG_FALLTOMAIN);
                                        status = SWITCH_STATUS_SUCCESS;
                                        running = 1;
                                        continue;
                                }
                        }
                }
                if (!match) {
                        if (*menu->buf) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "IVR menu '%s' caught invalid input '%s'\n", menu->name,
                                                                  menu->buf);
                                if (menu->invalid_sound) {
                                        play_and_collect(session, menu, menu->invalid_sound, 0);
                                }
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "IVR menu '%s' no input detected\n", menu->name);
                        }
                        errs++;

                        /* breaks are ok too */
                        if (SWITCH_STATUS_IS_BREAK(status)) {
                                status = SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        if (stack->stack_count == 1) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "exit-sound '%s'\n", menu->exit_sound);
                if (!zstr(menu->exit_sound)) {
                        status = play_and_collect(session, menu, menu->exit_sound, 0);
                }
        }

  end:

        stack->stack_count--;

        if (menu) {
                ivr_send_event(session, MENU_EVENT_EXIT, menu);
        }

        return status;
}

switch_status_t switch_ivr_menu_init	(	switch_ivr_menu_t **	new_menu,
		switch_ivr_menu_t *	main,
		const char *	name,
		const char *	greeting_sound,
		const char *	short_greeting_sound,
		const char *	invalid_sound,
		const char *	exit_sound,
		const char *	transfer_sound,
		const char *	confirm_macro,
		const char *	confirm_key,
		const char *	tts_engine,
		const char *	tts_voice,
		int	confirm_attempts,
		int	inter_timeout,
		int	digit_len,
		int	timeout,
		int	max_failures,
		int	max_timeouts,
		switch_memory_pool_t *	pool
	)

Create a new menu object.

Parameters

new_menu	the pointer to the new menu
main	The top level menu, (NULL if this is the top level one).
name	A pointer to the name of this menu.
greeting_sound	Optional pointer to a main sound (press 1 for this 2 for that).
short_greeting_sound	Optional pointer to a shorter main sound for subsequent loops.
invalid_sound	Optional pointer to a sound to play after invalid input.
exit_sound	Optional pointer to a sound to play upon exiting the menu.
transfer_sound	Optional pointer to a sound to play upon transfer away from the menu.
confirm_macro	phrase macro name to confirm input
confirm_key	the dtmf key required for positive confirmation
tts_engine	the tts engine to use for this menu
tts_voice	the tts voice to use for this menu
confirm_attempts	number of times to prompt to confirm input before failure
inter_timeout	inter-digit timeout
digit_len	max number of digits
timeout	A number of milliseconds to pause before looping.
max_failures	Maximum number of failures to withstand before hangingup This resets everytime you enter the menu.
pool	memory pool (NULL to create one).

Returns

SWITCH_STATUS_SUCCESS if the menu was created.

Definition at line 116 of file switch_ivr_menu.c.

References actions, buf, confirm_attempts, confirm_key, confirm_macro, exit_sound, greeting_sound, inlen, inter_timeout, invalid_sound, max_failures, max_timeouts, name, pool, pool, short_greeting_sound, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_destroy_memory_pool, switch_core_new_memory_pool, switch_core_strdup, SWITCH_IVR_MENU_FLAG_FREEPOOL, SWITCH_IVR_MENU_FLAG_STACK, switch_ivr_menu_stack_add(), SWITCH_LOG_CRIT, switch_log_printf(), switch_set_flag, SWITCH_STATUS_MEMERR, SWITCH_STATUS_SUCCESS, timeout, transfer_sound, tts_engine, tts_voice, and zstr.

Referenced by IVRMenu::IVRMenu(), and switch_ivr_menu_stack_xml_build().

{
        switch_ivr_menu_t *menu;
        uint8_t newpool = 0;

        if (!pool) {
                if (switch_core_new_memory_pool(&pool) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "OH OH no pool\n");
                        return SWITCH_STATUS_MEMERR;
                }
                newpool = 1;
        }

        if (!(menu = switch_core_alloc(pool, sizeof(*menu)))) {
                if (newpool) {
                        switch_core_destroy_memory_pool(&pool);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
                        return SWITCH_STATUS_MEMERR;
                }
        }

        menu->pool = pool;

        if (!confirm_attempts) {
                confirm_attempts = 3;
        }

        if (!inter_timeout) {
                inter_timeout = timeout / 2;
        }

        if (!zstr(name)) {
                menu->name = switch_core_strdup(menu->pool, name);
        }

        if (!zstr(greeting_sound)) {
                menu->greeting_sound = switch_core_strdup(menu->pool, greeting_sound);
        }

        if (!zstr(short_greeting_sound)) {
                menu->short_greeting_sound = switch_core_strdup(menu->pool, short_greeting_sound);
        }

        if (!zstr(invalid_sound)) {
                menu->invalid_sound = switch_core_strdup(menu->pool, invalid_sound);
        }

        if (!zstr(transfer_sound)) {
                menu->transfer_sound = switch_core_strdup(menu->pool, transfer_sound);
        }

        if (!zstr(exit_sound)) {
                menu->exit_sound = switch_core_strdup(menu->pool, exit_sound);
        }

        if (!zstr(confirm_key)) {
                menu->confirm_key = switch_core_strdup(menu->pool, confirm_key);
        }

        if (!zstr(confirm_macro)) {
                menu->confirm_macro = switch_core_strdup(menu->pool, confirm_macro);
        }

        if (!zstr(tts_engine)) {
                menu->tts_engine = switch_core_strdup(menu->pool, tts_engine);
        }

        if (!zstr(tts_voice)) {
                menu->tts_voice = switch_core_strdup(menu->pool, tts_voice);
        }

        menu->confirm_attempts = confirm_attempts;

        menu->inlen = digit_len;

        if (max_failures > 0) {
                menu->max_failures = max_failures;
        } else {
                menu->max_failures = 3;
        }

        if (max_timeouts > 0) {
                menu->max_timeouts = max_timeouts;
        } else {
                menu->max_timeouts = 3;
        }

        menu->timeout = timeout;

        menu->inter_timeout = inter_timeout;

        menu->actions = NULL;

        if (newpool) {
                switch_set_flag(menu, SWITCH_IVR_MENU_FLAG_FREEPOOL);
        }

        if (menu->timeout <= 0) {
                menu->timeout = 10000;
        }

        if (main) {
                switch_ivr_menu_stack_add(&main, menu);
        } else {
                switch_set_flag(menu, SWITCH_IVR_MENU_FLAG_STACK);
        }

        menu->buf = switch_core_alloc(menu->pool, 1024);

        *new_menu = menu;

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_menu_stack_free

(

switch_ivr_menu_t *

stack

)

free a stack of menu objects.

Parameters

stack

The top level menu you wish to destroy.

Returns

SWITCH_STATUS_SUCCESS if the object was a top level menu and it was freed

Definition at line 309 of file switch_ivr_menu.c.

References pool, switch_core_destroy_memory_pool, SWITCH_IVR_MENU_FLAG_FREEPOOL, SWITCH_IVR_MENU_FLAG_STACK, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

Referenced by IVRMenu::~IVRMenu().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (stack != NULL && stack->pool != NULL) {
                if (switch_test_flag(stack, SWITCH_IVR_MENU_FLAG_STACK)
                        && switch_test_flag(stack, SWITCH_IVR_MENU_FLAG_FREEPOOL)) {
                        switch_memory_pool_t *pool = stack->pool;
                        status = switch_core_destroy_memory_pool(&pool);
                } else {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        return status;
}

switch_status_t switch_ivr_menu_stack_xml_add_custom	(	switch_ivr_menu_xml_ctx_t *	xml_menu_ctx,
		const char *	name,
		switch_ivr_menu_action_function_t *	function
	)

Parameters

xml_menu_ctx	The XML menu parser context previously created by switch_ivr_menu_stack_xml_init
name	The xml tag name to add to the parser engine
function	The menu function callback that will be executed when menu digits are bound to this name

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 840 of file switch_ivr_menu.c.

References switch_ivr_menu_stack_xml_add().

{
        return switch_ivr_menu_stack_xml_add(xml_menu_ctx, name, -1, function);
}

switch_status_t switch_ivr_menu_stack_xml_build	(	switch_ivr_menu_xml_ctx_t *	xml_menu_ctx,
		switch_ivr_menu_t **	menu_stack,
		switch_xml_t	xml_menus,
		switch_xml_t	xml_menu
	)

Build a menu stack from an xml source.

Parameters

xml_menu_ctx	The XML menu parser context previously created by switch_ivr_menu_stack_xml_init
menu_stack	The menu stack object that will be created for you
xml_menus	The xml Menus source
xml_menu	The xml Menu source of the menu to be created

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 846 of file switch_ivr_menu.c.

References switch_ivr_menu_xml_map::action, bad_pin_file, exec_on_max_fail, exec_on_max_timeout, switch_ivr_menu_xml_map::function, is_valid_action(), switch_ivr_menu_xml_map::name, switch_xml::next, switch_ivr_menu_xml_map::next, pin, pool, prompt_pin_file, SWITCH_CHANNEL_LOG, switch_core_strdup, SWITCH_IVR_ACTION_EXECMENU, switch_ivr_menu_bind_action(), switch_ivr_menu_bind_function(), switch_ivr_menu_find(), SWITCH_IVR_MENU_FLAG_FREEPOOL, switch_ivr_menu_init(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_set_flag, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_attr(), switch_xml_attr_soft(), switch_xml_child(), switch_xml_find_child(), and zstr.

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (xml_menu_ctx != NULL && menu_stack != NULL && xml_menu != NULL) {
                const char *menu_name = switch_xml_attr_soft(xml_menu, "name"); /* if the attr doesn't exist, return "" */
                const char *greet_long = switch_xml_attr(xml_menu, "greet-long");       /* if the attr doesn't exist, return NULL */
                const char *greet_short = switch_xml_attr(xml_menu, "greet-short");     /* if the attr doesn't exist, return NULL */
                const char *invalid_sound = switch_xml_attr(xml_menu, "invalid-sound"); /* if the attr doesn't exist, return NULL */
                const char *exit_sound = switch_xml_attr(xml_menu, "exit-sound");       /* if the attr doesn't exist, return NULL */
                const char *transfer_sound = switch_xml_attr(xml_menu, "transfer-sound");       /* if the attr doesn't exist, return NULL */
                const char *timeout = switch_xml_attr_soft(xml_menu, "timeout");        /* if the attr doesn't exist, return "" */
                const char *max_failures = switch_xml_attr_soft(xml_menu, "max-failures");      /* if the attr doesn't exist, return "" */
                const char *max_timeouts = switch_xml_attr_soft(xml_menu, "max-timeouts");
                const char *exec_on_max_fail = switch_xml_attr(xml_menu, "exec-on-max-failures");
                const char *exec_on_max_timeout = switch_xml_attr(xml_menu, "exec-on-max-timeouts");
                const char *confirm_macro = switch_xml_attr(xml_menu, "confirm-macro");
                const char *confirm_key = switch_xml_attr(xml_menu, "confirm-key");
                const char *tts_engine = switch_xml_attr(xml_menu, "tts-engine");
                const char *tts_voice = switch_xml_attr(xml_menu, "tts-voice");
                const char *confirm_attempts = switch_xml_attr_soft(xml_menu, "confirm-attempts");
                const char *digit_len = switch_xml_attr_soft(xml_menu, "digit-len");
                const char *inter_timeout = switch_xml_attr_soft(xml_menu, "inter-digit-timeout");
                const char *pin = switch_xml_attr_soft(xml_menu, "pin");
                const char *prompt_pin_file = switch_xml_attr_soft(xml_menu, "pin-file");
                const char *bad_pin_file = switch_xml_attr_soft(xml_menu, "bad-pin-file");
                
                switch_ivr_menu_t *menu = NULL;

                if (zstr(max_timeouts)) {
                        max_timeouts = max_failures;
                }

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "building menu '%s'\n", menu_name);

                status = switch_ivr_menu_init(&menu,
                                                                          *menu_stack,
                                                                          menu_name,
                                                                          greet_long,
                                                                          greet_short,
                                                                          invalid_sound,
                                                                          exit_sound,
                                                                          transfer_sound,
                                                                          confirm_macro,
                                                                          confirm_key,
                                                                          tts_engine,
                                                                          tts_voice,
                                                                          atoi(confirm_attempts),
                                                                          atoi(inter_timeout),
                                                                          atoi(digit_len),
                                                                          atoi(timeout),
                                                                          strlen(max_failures) ? atoi(max_failures) : 0, strlen(max_timeouts) ? atoi(max_timeouts) : 0, xml_menu_ctx->pool);


                if (!zstr(exec_on_max_fail)) {
                        menu->exec_on_max_fail = switch_core_strdup(menu->pool, exec_on_max_fail);
                }

                if (!zstr(exec_on_max_timeout)) {
                        menu->exec_on_max_timeout = switch_core_strdup(menu->pool, exec_on_max_timeout);
                }

                if (!zstr(pin)) {
                        if (zstr(prompt_pin_file)) {
                                prompt_pin_file = "ivr/ivr-please_enter_pin_followed_by_pound.wav";
                        }
                        if (zstr(bad_pin_file)) {
                                bad_pin_file = "conference/conf-bad-pin.wav";
                        }
                        menu->pin = switch_core_strdup(menu->pool, pin);
                        menu->prompt_pin_file = switch_core_strdup(menu->pool, prompt_pin_file);
                        menu->bad_pin_file = switch_core_strdup(menu->pool, bad_pin_file);
                }

                /* set the menu_stack for the caller */
                if (status == SWITCH_STATUS_SUCCESS && *menu_stack == NULL) {
                        *menu_stack = menu;

                        if (xml_menu_ctx->autocreated) {
                                switch_set_flag(menu, SWITCH_IVR_MENU_FLAG_FREEPOOL);
                        }
                }

                if (status == SWITCH_STATUS_SUCCESS && menu != NULL) {
                        switch_xml_t xml_kvp;

                        /* build menu entries */
                        for (xml_kvp = switch_xml_child(xml_menu, "entry"); xml_kvp != NULL && status == SWITCH_STATUS_SUCCESS; xml_kvp = xml_kvp->next) {
                                const char *action = switch_xml_attr(xml_kvp, "action");
                                const char *digits = switch_xml_attr(xml_kvp, "digits");
                                const char *param = switch_xml_attr_soft(xml_kvp, "param");

                                if (is_valid_action(action) && !zstr(digits)) {
                                        switch_ivr_menu_xml_map_t *xml_map = xml_menu_ctx->map;
                                        int found = 0;

                                        /* find and appropriate xml handler */
                                        while (xml_map != NULL && !found) {
                                                if (!(found = (strcasecmp(xml_map->name, action) == 0))) {
                                                        xml_map = xml_map->next;
                                                }
                                        }

                                        if (found && xml_map != NULL) {
                                                /* do we need to build a new sub-menu ? */
                                                if (xml_map->action == SWITCH_IVR_ACTION_EXECMENU && switch_ivr_menu_find(*menu_stack, param) == NULL) {
                                                        if ((xml_menu = switch_xml_find_child(xml_menus, "menu", "name", param)) != NULL) {
                                                                status = switch_ivr_menu_stack_xml_build(xml_menu_ctx, menu_stack, xml_menus, xml_menu);
                                                        }
                                                }
                                                /* finally bind the menu entry */
                                                if (status == SWITCH_STATUS_SUCCESS) {
                                                        if (xml_map->function != NULL) {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
                                                                                                  "binding menu caller control '%s'/'%s' to '%s'\n", xml_map->name, param, digits);
                                                                status = switch_ivr_menu_bind_function(menu, xml_map->function, param, digits);
                                                        } else {
                                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "binding menu action '%s' to '%s'\n", xml_map->name, digits);
                                                                status = switch_ivr_menu_bind_action(menu, xml_map->action, param, digits);
                                                        }
                                                }
                                        }
                                } else {
                                        status = SWITCH_STATUS_FALSE;
                                }
                        }
                }
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to build xml menu\n");
        }

        return status;
}

switch_status_t switch_ivr_menu_stack_xml_init	(	switch_ivr_menu_xml_ctx_t **	xml_menu_ctx,
		switch_memory_pool_t *	pool
	)

Parameters

xml_menu_ctx	A pointer of a XML menu parser context to be created
pool	memory pool (NULL to create one)

Returns

SWITCH_STATUS_SUCCESS if all is well

Definition at line 805 of file switch_ivr_menu.c.

References iam, iam_s::name, pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_new_memory_pool, switch_ivr_menu_stack_xml_add(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        int autocreated = 0;

        /* build a memory pool ? */
        if (pool == NULL) {
                status = switch_core_new_memory_pool(&pool);
                autocreated = 1;
        }
        /* allocate the xml context */
        if (xml_menu_ctx != NULL && pool != NULL) {
                *xml_menu_ctx = switch_core_alloc(pool, sizeof(switch_ivr_menu_xml_ctx_t));
                if (*xml_menu_ctx != NULL) {
                        (*xml_menu_ctx)->pool = pool;
                        (*xml_menu_ctx)->autocreated = autocreated;
                        (*xml_menu_ctx)->map = NULL;
                        status = SWITCH_STATUS_SUCCESS;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to alloc xml_ctx\n");
                        status = SWITCH_STATUS_FALSE;
                }
        }
        /* build the standard/default xml menu handler mappings */
        if (status == SWITCH_STATUS_SUCCESS && xml_menu_ctx != NULL && *xml_menu_ctx != NULL) {
                int i;

                for (i = 0; iam[i].name && status == SWITCH_STATUS_SUCCESS; i++) {
                        status = switch_ivr_menu_stack_xml_add(*xml_menu_ctx, iam[i].name, iam[i].action, NULL);
                }
        }

        return status;
}

switch_status_t switch_ivr_menu_str2action	(	const char *	action_name,
		switch_ivr_action_t *	action
	)

Definition at line 765 of file switch_ivr_menu.c.

References iam_s::action, iam, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

Referenced by IVRMenu::bindAction().

{
        int i;

        if (!zstr(action_name)) {
                for (i = 0;; i++) {
                        if (!iam[i].name) {
                                break;
                        }

                        if (!strcasecmp(iam[i].name, action_name)) {
                                *action = iam[i].action;
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        return SWITCH_STATUS_FALSE;
}

void switch_ivr_park_session

(

switch_core_session_t *

session

)

Definition at line 3411 of file switch_ivr.c.

References CF_TRANSFER, CS_PARK, switch_channel_set_flag, switch_channel_set_state, and switch_core_session_get_channel().

Referenced by audio_bridge_on_exchange_media(), signal_bridge_on_hangup(), switch_ivr_multi_threaded_bridge(), and uuid_bridge_on_soft_execute().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_channel_set_state(channel, CS_PARK);
        switch_channel_set_flag(channel, CF_TRANSFER);

}

switch_status_t switch_ivr_phrase_macro_event	(	switch_core_session_t *	session,
		const char *	macro_name,
		const char *	data,
		switch_event_t *	event,
		const char *	lang,
		switch_input_args_t *	args
	)

Definition at line 39 of file switch_ivr_play_say.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_say_args_t::gender, memset(), switch_say_args_t::method, switch_xml::next, switch_say_interface::say_function, switch_assert, switch_channel_event_set_data(), switch_channel_expand_variables, switch_channel_get_variable, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_exec(), switch_core_session_get_channel(), switch_core_session_strdup, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), switch_event_expand_headers, SWITCH_EVENT_REQUEST_PARAMS, SWITCH_FALSE, switch_ivr_get_say_gender_by_name(), switch_ivr_get_say_method_by_name(), switch_ivr_get_say_type_by_name(), switch_ivr_phrase_macro, switch_ivr_play_file(), switch_ivr_sleep(), switch_ivr_speak_text(), switch_loadable_module_get_application_interface(), switch_loadable_module_get_say_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, switch_perform_substitution(), switch_regex_perform(), switch_regex_safe_free, switch_safe_free, switch_separate_paren_args(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_str_nil, SWITCH_TRUE, switch_true(), switch_xml_attr(), switch_xml_attr_soft(), switch_xml_child(), switch_xml_find_child(), switch_xml_free(), switch_xml_locate_language(), switch_say_args_t::type, UNPROTECT_INTERFACE, and zstr.

{
        switch_event_t *hint_data;
        switch_xml_t cfg, xml = NULL, language = NULL, macros = NULL, phrases = NULL, macro, input, action;
        switch_status_t status = SWITCH_STATUS_GENERR;
        const char *old_sound_prefix = NULL, *sound_path = NULL, *tts_engine = NULL, *tts_voice = NULL;
        const char *module_name = NULL, *chan_lang = NULL;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        uint8_t done = 0, searched = 0;
        int matches = 0;
        const char *pause_val;
        int pause = 100;
        const char *group_macro_name = NULL;
        const char *local_macro_name = macro_name;
        switch_bool_t sound_prefix_enforced = switch_true(switch_channel_get_variable(channel, "sound_prefix_enforced"));
        switch_bool_t local_sound_prefix_enforced = SWITCH_FALSE;


        if (!macro_name) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No phrase macro specified.\n");
                return status;
        }

        arg_recursion_check_start(args);

        if (!lang) {
                chan_lang = switch_channel_get_variable(channel, "default_language");
                if (!chan_lang) {
                        chan_lang = "en";
                }
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No language specified - Using [%s]\n", chan_lang);
        } else {
                chan_lang = lang;
        }

        switch_event_create(&hint_data, SWITCH_EVENT_REQUEST_PARAMS);
        switch_assert(hint_data);

        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "macro_name", macro_name);
        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "lang", chan_lang);
        if (data) {
                switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "data", data);
                if (event) {
                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "data", data);
                }
        } else {
                data = "";
        }
        switch_channel_event_set_data(channel, hint_data);

        if (switch_xml_locate_language(&xml, &cfg, hint_data, &language, &phrases, &macros, chan_lang) != SWITCH_STATUS_SUCCESS) {
                goto done;
        }

        if ((module_name = switch_xml_attr(language, "say-module"))) {
        } else if ((module_name = switch_xml_attr(language, "module"))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Deprecated usage of module attribute. Use say-module instead\n");
        } else {
                module_name = chan_lang;
        }

        if (!(sound_path = (char *) switch_xml_attr(language, "sound-prefix"))) {
                if (!(sound_path = (char *) switch_xml_attr(language, "sound-path"))) {
                        sound_path = (char *) switch_xml_attr(language, "sound_path");
                }
        }

        if (!(tts_engine = (char *) switch_xml_attr(language, "tts-engine"))) {
                tts_engine = (char *) switch_xml_attr(language, "tts_engine");
        }

        if (!(tts_voice = (char *) switch_xml_attr(language, "tts-voice"))) {
                tts_voice = (char *) switch_xml_attr(language, "tts_voice");
        }

        /* If we use the new structure, check for a group name */
        if (language != macros) {
                char *p;
                char *macro_name_dup = switch_core_session_strdup(session, macro_name);
                const char *group_sound_path;
                const char *sound_prefix_enforced_str;

                if ((p = strchr(macro_name_dup, '@'))) {
                        *p++ = '\0';
                        local_macro_name = macro_name_dup;
                        group_macro_name = p;

                        if (!(macros = switch_xml_find_child(phrases, "macros", "name", group_macro_name))) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't find macros group %s.\n", group_macro_name);
                                goto done;
                        }
                }
                /* Support override of certain language attribute */
                if ((group_sound_path = (char *) switch_xml_attr(macros, "sound-prefix")) || (group_sound_path = (char *) switch_xml_attr(macros, "sound-path")) || (group_sound_path = (char *) switch_xml_attr(macros, "sound_path"))) {
                        sound_path = group_sound_path;
                }

                if (sound_prefix_enforced == SWITCH_FALSE && (sound_prefix_enforced_str = switch_xml_attr(macros, "sound-prefix-enforced"))
                                && (local_sound_prefix_enforced = switch_true(sound_prefix_enforced_str)) == SWITCH_TRUE) {
                        switch_channel_set_variable(channel, "sound_prefix_enforced", sound_prefix_enforced_str);
                }

        }

        if (!(macro = switch_xml_find_child(macros, "macro", "name", local_macro_name))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't find macro %s.\n", macro_name);
                goto done;
        }

        if (sound_path && sound_prefix_enforced == SWITCH_FALSE) {
                char *p;
                old_sound_prefix = switch_str_nil(switch_channel_get_variable(channel, "sound_prefix"));
                p = switch_core_session_strdup(session, old_sound_prefix);
                old_sound_prefix = p;
                switch_channel_set_variable(channel, "sound_prefix", sound_path);
        }

        if ((pause_val = switch_xml_attr(macro, "pause"))) {
                int tmp = atoi(pause_val);
                if (tmp >= 0) {
                        pause = tmp;
                }
        }

        if (!(input = switch_xml_child(macro, "input"))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't find any input tags.\n");
                goto done;
        }

        if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                status = SWITCH_STATUS_FALSE;
                goto done;
        }

        while (input) {
                char *field = (char *) switch_xml_attr(input, "field");
                char *pattern = (char *) switch_xml_attr(input, "pattern");
                const char *do_break = switch_xml_attr_soft(input, "break_on_match");
                char *field_expanded = NULL;
                char *field_expanded_alloc = NULL;
                switch_regex_t *re = NULL;
                int proceed = 0, ovector[100];
                switch_xml_t match = NULL;

                searched = 1;
                if (!field) {
                        field = (char *) data;
                }
                if (event) {
                        field_expanded_alloc = switch_event_expand_headers(event, field);
                } else {
                        field_expanded_alloc = switch_channel_expand_variables(channel, field);
                }

                if (field_expanded_alloc == field) {
                        field_expanded_alloc = NULL;
                        field_expanded = field;
                } else {
                        field_expanded = field_expanded_alloc;
                }

                if (!pattern) {
                        pattern = ".*";
                }

                status = SWITCH_STATUS_SUCCESS;

                if ((proceed = switch_regex_perform(field_expanded, pattern, &re, ovector, sizeof(ovector) / sizeof(ovector[0])))) {
                        match = switch_xml_child(input, "match");
                } else {
                        match = switch_xml_child(input, "nomatch");
                }

                if (match) {
                        matches++;
                        for (action = switch_xml_child(match, "action"); action; action = action->next) {
                                char *adata = (char *) switch_xml_attr_soft(action, "data");
                                char *func = (char *) switch_xml_attr_soft(action, "function");
                                char *substituted = NULL;
                                uint32_t len = 0;
                                char *odata = NULL;
                                char *expanded = NULL;

                                if (strchr(pattern, '(') && strchr(adata, '$') && proceed > 0) {
                                        len = (uint32_t) (strlen(data) + strlen(adata) + 10) * proceed;
                                        if (!(substituted = malloc(len))) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Memory Error!\n");
                                                switch_regex_safe_free(re);
                                                switch_safe_free(field_expanded_alloc);
                                                goto done;
                                        }
                                        memset(substituted, 0, len);
                                        switch_perform_substitution(re, proceed, adata, field_expanded, substituted, len, ovector);
                                        odata = substituted;
                                } else {
                                        odata = adata;
                                }

                                if (event) {
                                        expanded = switch_event_expand_headers(event, odata);
                                } else {
                                        expanded = switch_channel_expand_variables(channel, odata);
                                }

                                if (expanded == odata) {
                                        expanded = NULL;
                                } else {
                                        odata = expanded;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Handle %s:[%s] (%s:%s)\n", func, odata, chan_lang,
                                                                  module_name);

                                if (!strcasecmp(func, "play-file")) {
                                        status = switch_ivr_play_file(session, NULL, odata, args);
                                } else if (!strcasecmp(func, "phrase")) {
                                        char *name = (char *) switch_xml_attr_soft(action, "phrase");
                                        status = switch_ivr_phrase_macro(session, name, odata, chan_lang, args);
                                } else if (!strcasecmp(func, "break")) {
                                        done = 1; /* don't break or we leak memory */
                                } else if (!strcasecmp(func, "execute")) {
                                        switch_application_interface_t *app;
                                        char *cmd, *cmd_args;
                                        status = SWITCH_STATUS_FALSE;

                                        cmd = switch_core_session_strdup(session, odata);
                                        cmd_args = switch_separate_paren_args(cmd);

                                        if (!cmd_args) {
                                                cmd_args = "";
                                        }

                                        if ((app = switch_loadable_module_get_application_interface(cmd)) != NULL) {
                                                status = switch_core_session_exec(session, app, cmd_args);
                                                UNPROTECT_INTERFACE(app);
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Application %s\n", cmd);
                                        }
                                } else if (!strcasecmp(func, "say")) {
                                        switch_say_interface_t *si;
                                        if ((si = switch_loadable_module_get_say_interface(module_name))) {
                                                char *say_type = (char *) switch_xml_attr_soft(action, "type");
                                                char *say_method = (char *) switch_xml_attr_soft(action, "method");
                                                char *say_gender = (char *) switch_xml_attr_soft(action, "gender");
                                                switch_say_args_t say_args = {0};

                                                say_args.type = switch_ivr_get_say_type_by_name(say_type);
                                                say_args.method = switch_ivr_get_say_method_by_name(say_method);
                                                say_args.gender = switch_ivr_get_say_gender_by_name(say_gender);

                                                status = si->say_function(session, odata, &say_args, args);
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid SAY Interface [%s]!\n", module_name);
                                        }
                                } else if (!strcasecmp(func, "speak-text")) {
                                        const char *my_tts_engine = switch_xml_attr(action, "tts-engine");
                                        const char *my_tts_voice = switch_xml_attr(action, "tts-voice");

                                        if (!my_tts_engine) {
                                                my_tts_engine = tts_engine;
                                        }

                                        if (!my_tts_voice) {
                                                my_tts_voice = tts_voice;
                                        }
                                        if (zstr(tts_engine) || zstr(tts_voice)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "TTS is not configured\n");
                                        } else {
                                                status = switch_ivr_speak_text(session, my_tts_engine, my_tts_voice, odata, args);
                                        }
                                }

                                switch_ivr_sleep(session, pause, SWITCH_FALSE, NULL);
                                switch_safe_free(expanded);
                                switch_safe_free(substituted);
                                if (done || status != SWITCH_STATUS_SUCCESS) break;
                        }
                }

                switch_regex_safe_free(re);
                switch_safe_free(field_expanded_alloc);

                if (done || status != SWITCH_STATUS_SUCCESS
                        || (match && do_break && switch_true(do_break))) {
                        break;
                }

                input = input->next;
        }

  done:

        arg_recursion_check_stop(args);

        if (hint_data) {
                switch_event_destroy(&hint_data);
        }

        if (searched && !matches) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Macro [%s]: '%s' did not match any patterns\n", macro_name, data);
        }

        if (old_sound_prefix) {
                switch_channel_set_variable(channel, "sound_prefix", old_sound_prefix);
        }
        if (local_sound_prefix_enforced == SWITCH_TRUE) {
                switch_channel_set_variable(channel, "sound_prefix_enforced", NULL);
        }

        if (xml) {
                switch_xml_free(xml);
        }

        return status;
}

switch_status_t switch_ivr_process_fh	(	switch_core_session_t *	session,
		const char *	cmd,
		switch_file_handle_t *	fhp
	)

Definition at line 3888 of file switch_ivr.c.

References if(), SCFC_PAUSE_READ, switch_atoui(), SWITCH_CHANNEL_SESSION_LOG, switch_clear_flag_locked, switch_core_file_command(), switch_core_file_seek(), switch_core_file_truncate(), SWITCH_FILE_DONE, SWITCH_FILE_OPEN, SWITCH_FILE_PAUSE, SWITCH_LOG_DEBUG, switch_log_printf(), switch_normalize_volume, switch_set_flag_locked, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_test_flag, and zstr.

Referenced by CoreSession::process_callback_result().

{
        if (zstr(cmd)) {
                return SWITCH_STATUS_SUCCESS;   
        }

        if (fhp) {
                if (!switch_test_flag(fhp, SWITCH_FILE_OPEN)) {
                        return SWITCH_STATUS_FALSE;
                }

                if (!strncasecmp(cmd, "speed", 5)) {
                        char *p;
                
                        if ((p = strchr(cmd, ':'))) {
                                p++;
                                if (*p == '+' || *p == '-') {
                                        int step;
                                        if (!(step = atoi(p))) {
                                                step = 1;
                                        }
                                        fhp->speed += step;
                                } else {
                                        int speed = atoi(p);
                                        fhp->speed = speed;
                                }
                                return SWITCH_STATUS_SUCCESS;
                        }

                        return SWITCH_STATUS_FALSE;

                } else if (!strncasecmp(cmd, "volume", 6)) {
                        char *p;
                        
                        if ((p = strchr(cmd, ':'))) {
                                p++;
                                if (*p == '+' || *p == '-') {
                                        int step;
                                        if (!(step = atoi(p))) {
                                                step = 1;
                                        }
                                        fhp->vol += step;
                                } else {
                                        int vol = atoi(p);
                                        fhp->vol = vol;
                                }
                                return SWITCH_STATUS_SUCCESS;
                        }
                        
                        if (fhp->vol) {
                                switch_normalize_volume(fhp->vol);
                        }
                        
                        return SWITCH_STATUS_FALSE;
                } else if (!strcasecmp(cmd, "pause")) {
                        if (switch_test_flag(fhp, SWITCH_FILE_PAUSE)) {
                                switch_clear_flag_locked(fhp, SWITCH_FILE_PAUSE);
                        } else {
                                switch_set_flag_locked(fhp, SWITCH_FILE_PAUSE);
                        }

                        switch_core_file_command(fhp, SCFC_PAUSE_READ);

                        return SWITCH_STATUS_SUCCESS;
                } else if (!strcasecmp(cmd, "stop")) {
                        switch_set_flag_locked(fhp, SWITCH_FILE_DONE);
                        return SWITCH_STATUS_FALSE;
                } else if (!strcasecmp(cmd, "truncate")) {
                        switch_core_file_truncate(fhp, 0);
                } else if (!strcasecmp(cmd, "restart")) {
                        unsigned int pos = 0;
                        fhp->speed = 0;
                        switch_core_file_seek(fhp, &pos, 0, SEEK_SET);
                        return SWITCH_STATUS_SUCCESS;
                } else if (!strncasecmp(cmd, "seek", 4)) {
                        //switch_codec_t *codec;
                        unsigned int samps = 0;
                        unsigned int pos = 0;
                        char *p;
                        //codec = switch_core_session_get_read_codec(session);
                        
                        if ((p = strchr(cmd, ':'))) {
                                p++;
                                if (*p == '+' || *p == '-') {
                                        int step;
                                        int32_t target;
                                        if (!(step = atoi(p))) {
                                                step = 1000;
                                        }

                                        samps = step * (fhp->native_rate / 1000);
                                        target = (int32_t)fhp->offset_pos + samps;

                                        if (target < 0) {
                                                target = 0;
                                        }

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "seek to position %d\n", target);
                                        switch_core_file_seek(fhp, &pos, target, SEEK_SET);

                                } else {
                                        samps = switch_atoui(p) * (fhp->native_rate / 1000);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "seek to position %d\n", samps);
                                        switch_core_file_seek(fhp, &pos, samps, SEEK_SET);
                                }
                        }

                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (!strcmp(cmd, "true") || !strcmp(cmd, "undefined")) {
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
        
}

switch_status_t switch_ivr_read	(	switch_core_session_t *	session,
		uint32_t	min_digits,
		uint32_t	max_digits,
		const char *	prompt_audio_file,
		const char *	var_name,
		char *	digit_buffer,
		switch_size_t	digit_buffer_length,
		uint32_t	timeout,
		const char *	valid_terminators,
		uint32_t	digit_timeout
	)

Definition at line 2114 of file switch_ivr_play_say.c.

References switch_input_args_t::buf, switch_input_args_t::buflen, memset(), switch_assert, switch_channel_pre_answer, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_get_channel(), switch_ivr_collect_digits_count(), switch_ivr_play_file(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_READ_RESULT_VARIABLE, SWITCH_READ_TERMINATOR_USED_VARIABLE, switch_snprintf(), SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_RESTART, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, SWITCH_STATUS_TOO_SMALL, and zstr.

Referenced by collect_thread_run(), CoreSession::read(), and switch_play_and_get_digits().

{
        switch_channel_t *channel;
        switch_input_args_t args = { 0 };
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        size_t len = 0;
        char tb[2] = "";
        int term_required = 0;


        if (valid_terminators && *valid_terminators == '=') {
                term_required = 1;
        }

        switch_assert(session);

        if (!digit_timeout) {
                digit_timeout = timeout;
        }

        if (max_digits < min_digits) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                  "Max digits %u is less than Min %u, forcing Max to %u\n", max_digits, min_digits, min_digits);
                max_digits = min_digits;
        }

        channel = switch_core_session_get_channel(session);
        switch_channel_set_variable(channel, SWITCH_READ_RESULT_VARIABLE, NULL);

        if (var_name) {
                switch_channel_set_variable(channel, var_name, NULL);
        }

        if ((min_digits && digit_buffer_length < min_digits) || digit_buffer_length < max_digits) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Buffer too small!\n");
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_pre_answer(channel) != SWITCH_STATUS_SUCCESS) {
                return SWITCH_STATUS_FALSE;
        }

        memset(digit_buffer, 0, digit_buffer_length);
        args.buf = digit_buffer;
        args.buflen = (uint32_t) digit_buffer_length;

        if (!zstr(prompt_audio_file) && strcasecmp(prompt_audio_file, "silence")) {
                if ((status = switch_ivr_play_file(session, NULL, prompt_audio_file, &args)) == SWITCH_STATUS_BREAK) {
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
                goto end;
        }

        len = strlen(digit_buffer);

        if ((min_digits && len < min_digits) || len < max_digits) {
                args.buf = digit_buffer + len;
                args.buflen = (uint32_t) (digit_buffer_length - len);
                status = switch_ivr_collect_digits_count(session, digit_buffer, digit_buffer_length, max_digits, valid_terminators, &tb[0],
                                                                                                 len ? digit_timeout : timeout, digit_timeout, 0);
        }


        if (tb[0]) {
                char *p;

                switch_channel_set_variable(channel, SWITCH_READ_TERMINATOR_USED_VARIABLE, tb);

                if (!zstr(valid_terminators) && (p = strchr(valid_terminators, tb[0]))) {
                        if (p >= (valid_terminators + 1) && (*(p - 1) == '+' || *(p - 1) == 'x')) {
                                switch_snprintf(digit_buffer + strlen(digit_buffer), digit_buffer_length - strlen(digit_buffer), "%s", tb);
                                if (*(p - 1) == 'x') {
                                        status = SWITCH_STATUS_RESTART;
                                }
                        }
                }
        } else if (term_required) {
                status = SWITCH_STATUS_TOO_SMALL;
        }

        len = strlen(digit_buffer);
        if ((min_digits && len < min_digits)) {
                status = SWITCH_STATUS_TOO_SMALL;
        }

        switch (status) {
        case SWITCH_STATUS_SUCCESS:
                switch_channel_set_variable(channel, SWITCH_READ_RESULT_VARIABLE, "success");
                break;
        case SWITCH_STATUS_TIMEOUT:
                switch_channel_set_variable(channel, SWITCH_READ_RESULT_VARIABLE, "timeout");
                break;
        default:
                switch_channel_set_variable(channel, SWITCH_READ_RESULT_VARIABLE, "failure");
                break;

        }

  end:

        if (status != SWITCH_STATUS_RESTART && max_digits == 1 && len == 1 && valid_terminators && strchr(valid_terminators, *digit_buffer)) {
                *digit_buffer = '\0';
        }

        if (var_name && !zstr(digit_buffer)) {
                switch_channel_set_variable(channel, var_name, digit_buffer);
        }

        return status;

}

switch_status_t switch_ivr_record_session_mask	(	switch_core_session_t *	session,
		const char *	file,
		switch_bool_t	on
	)

Definition at line 1528 of file switch_ivr_async.c.

References SMBF_MASK, switch_channel_get_private(), switch_core_media_bug_clear_flag(), switch_core_media_bug_set_flag(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_media_bug_t *bug;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if ((bug = switch_channel_get_private(channel, file))) {
                if (on) {
                        switch_core_media_bug_set_flag(bug, SMBF_MASK);
                } else {
                        switch_core_media_bug_clear_flag(bug, SMBF_MASK);
                }
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_release_file_handle	(	switch_core_session_t *	session,
		switch_file_handle_t **	fh
	)

Definition at line 1141 of file switch_ivr_play_say.c.

References switch_core_session_io_rwunlock(), and SWITCH_STATUS_SUCCESS.

{
        *fh = NULL;
        switch_core_session_io_rwunlock(session);

        return SWITCH_STATUS_SUCCESS;
}

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
	)

Definition at line 3507 of file switch_ivr.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_say_args_t::gender, switch_say_args_t::method, switch_say_interface::say_function, switch_assert, switch_channel_event_set_data(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_get_channel(), switch_core_session_strdup, switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, switch_ivr_get_say_gender_by_name(), switch_ivr_get_say_method_by_name(), switch_ivr_get_say_type_by_name(), switch_loadable_module_get_say_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), switch_xml_attr(), switch_xml_free(), switch_xml_locate_language(), switch_say_args_t::type, and zstr.

Referenced by CoreSession::say().

{
        switch_say_interface_t *si;
        switch_channel_t *channel;
        switch_status_t status = SWITCH_STATUS_FALSE;
        const char *save_path = NULL, *chan_lang = NULL, *lang = NULL, *sound_path = NULL;
        switch_event_t *hint_data;
        switch_xml_t cfg, xml = NULL, language = NULL, macros = NULL, phrases = NULL;
        char *p;

        switch_assert(session);
        channel = switch_core_session_get_channel(session);
        switch_assert(channel);

        arg_recursion_check_start(args);


        if (zstr(module_name)) {
                module_name = "en";
        }

        if (module_name) {
                char *p;
                p = switch_core_session_strdup(session, module_name);
                module_name = p;
                
                if ((p = strchr(module_name, ':'))) {
                        *p++ = '\0';
                        chan_lang = p;
                }
        }

        if (!chan_lang) {
                lang = switch_channel_get_variable(channel, "language");

                if (!lang) {
                        chan_lang = switch_channel_get_variable(channel, "default_language");
                        if (!chan_lang) {
                                chan_lang = module_name;
                        }
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No language specified - Using [%s]\n", chan_lang);
                } else {
                        chan_lang = lang;
                }
        }

        switch_event_create(&hint_data, SWITCH_EVENT_REQUEST_PARAMS);
        switch_assert(hint_data);

        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "macro_name", "say_app");
        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "lang", chan_lang);
        switch_channel_event_set_data(channel, hint_data);

        if (switch_xml_locate_language(&xml, &cfg, hint_data, &language, &phrases, &macros, chan_lang) != SWITCH_STATUS_SUCCESS) {
                goto done;
        }

        if ((p = (char *) switch_xml_attr(language, "say-module"))) {
                module_name = switch_core_session_strdup(session, p);
        } else if ((p = (char *) switch_xml_attr(language, "module"))) {
                module_name = switch_core_session_strdup(session, p);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Deprecated usage of module attribute\n");
        } else {
                module_name = chan_lang;
        }

        if (!(sound_path = (char *) switch_xml_attr(language, "sound-prefix"))) {
                if (!(sound_path = (char *) switch_xml_attr(language, "sound-path"))) {
                        sound_path = (char *) switch_xml_attr(language, "sound_path");
                }
        }

        if (channel) {
                const char *p = switch_channel_get_variable(channel, "sound_prefix_enforced");
                if (!switch_true(p)) {
                        save_path = switch_channel_get_variable(channel, "sound_prefix");
                        if (sound_path) {
                                switch_channel_set_variable(channel, "sound_prefix", sound_path);
                        }
                }
        }

        if ((si = switch_loadable_module_get_say_interface(module_name))) {
                /* should go back and proto all the say mods to const.... */
                switch_say_args_t say_args = {0};
                
                say_args.type = switch_ivr_get_say_type_by_name(say_type);
                say_args.method = switch_ivr_get_say_method_by_name(say_method);
                say_args.gender = switch_ivr_get_say_gender_by_name(say_gender);
                
                status = si->say_function(session, (char *) tosay, &say_args, args);
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid SAY Interface [%s]!\n", module_name);
                status = SWITCH_STATUS_FALSE;
        }

  done:

        arg_recursion_check_stop(args);


        if (hint_data) {
                switch_event_destroy(&hint_data);
        }

        if (save_path) {
                switch_channel_set_variable(channel, "sound_prefix", save_path);
        }

        if (xml) {
                switch_xml_free(xml);
        }

        return status;
}

switch_status_t switch_ivr_say_ip	(	switch_core_session_t *	session,
		char *	tosay,
		switch_say_callback_t	number_func,
		switch_say_args_t *	say_args,
		switch_input_args_t *	args
	)

Definition at line 172 of file switch_ivr_say.c.

References arg_recursion_check_start, arg_recursion_check_stop, say_file, say_num, switch_core_session_strdup, switch_goto_status, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        char *a, *b, *c, *d;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        arg_recursion_check_start(args);

        if (!(a = switch_core_session_strdup(session, tosay))) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (!(b = strchr(a, '.'))) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        *b++ = '\0';

        if (!(c = strchr(b, '.'))) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        *c++ = '\0';

        if (!(d = strchr(c, '.'))) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        *d++ = '\0';

        say_num(atoi(a), say_args->method);
        say_file("digits/dot.wav");
        say_num(atoi(b), say_args->method);
        say_file("digits/dot.wav");
        say_num(atoi(c), say_args->method);
        say_file("digits/dot.wav");
        say_num(atoi(d), say_args->method);

 end:

        arg_recursion_check_stop(args);

        return status;
}

switch_status_t switch_ivr_say_spell	(	switch_core_session_t *	session,
		char *	tosay,
		switch_say_args_t *	say_args,
		switch_input_args_t *	args
	)

Definition at line 133 of file switch_ivr_say.c.

References arg_recursion_check_start, arg_recursion_check_stop, say_file, SST_NAME_PHONETIC, SST_NAME_SPELLED, and SWITCH_STATUS_SUCCESS.

{
        char *p;
        
        arg_recursion_check_start(args);

        for (p = tosay; p && *p; p++) {
                int a = tolower((int) *p);
                if (a >= '0' && a <= '9') {
                        say_file("digits/%d.wav", a - '0');
                } else {
                        if (say_args->type == SST_NAME_SPELLED) {
                                say_file("ascii/%d.wav", a);
                        } else if (say_args->type == SST_NAME_PHONETIC) {
                                say_file("phonetic-ascii/%d.wav", a);
                        }
                }
        }

        arg_recursion_check_stop(args);

        return SWITCH_STATUS_SUCCESS;
}

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
	)

Definition at line 3629 of file switch_ivr.c.

References switch_say_args_t::ext, switch_say_args_t::gender, switch_say_args_t::method, switch_say_interface::say_string_function, switch_assert, switch_channel_event_set_data(), switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_variable, switch_core_session_get_channel(), switch_event_add_header_string(), switch_event_create, switch_event_destroy(), SWITCH_EVENT_REQUEST_PARAMS, switch_ivr_get_say_gender_by_name(), switch_ivr_get_say_method_by_name(), switch_ivr_get_say_type_by_name(), switch_loadable_module_get_say_interface(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STACK_BOTTOM, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_true(), switch_xml_attr(), switch_xml_free(), switch_xml_locate_language(), and switch_say_args_t::type.

{
        switch_say_interface_t *si;
        switch_channel_t *channel = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        const char *save_path = NULL, *chan_lang = NULL, *sound_path = NULL;
        switch_event_t *hint_data;
        switch_xml_t cfg, xml = NULL, language = NULL, macros = NULL, phrases = NULL;

        if (session) {
                channel = switch_core_session_get_channel(session);

                if (!lang) {
                        lang = switch_channel_get_variable(channel, "language");

                        if (!lang) {
                                chan_lang = switch_channel_get_variable(channel, "default_language");
                                if (!chan_lang) {
                                        chan_lang = "en";
                                }
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No language specified - Using [%s]\n", chan_lang);
                        } else {
                                chan_lang = lang;
                        }
                }
        }

        if (!lang) lang = "en";
        if (!chan_lang) chan_lang = lang;

        switch_event_create(&hint_data, SWITCH_EVENT_REQUEST_PARAMS);
        switch_assert(hint_data);

        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "macro_name", "say_app");
        switch_event_add_header_string(hint_data, SWITCH_STACK_BOTTOM, "lang", chan_lang);

        if (channel) {
                switch_channel_event_set_data(channel, hint_data);
        }

        if (switch_xml_locate_language(&xml, &cfg, hint_data, &language, &phrases, &macros, chan_lang) != SWITCH_STATUS_SUCCESS) {
                goto done;
        }

        if ((module_name = switch_xml_attr(language, "say-module"))) {
        } else if ((module_name = switch_xml_attr(language, "module"))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Deprecated usage of module attribute\n");
        } else {
                module_name = chan_lang;
        }

        if (!(sound_path = (char *) switch_xml_attr(language, "sound-prefix"))) {
                if (!(sound_path = (char *) switch_xml_attr(language, "sound-path"))) {
                        sound_path = (char *) switch_xml_attr(language, "sound_path");
                }
        }

        if (channel) {
                const char *p = switch_channel_get_variable(channel, "sound_prefix_enforced");  
                if (!switch_true(p)) {
                        save_path = switch_channel_get_variable(channel, "sound_prefix");
                        if (sound_path) {
                                switch_channel_set_variable(channel, "sound_prefix", sound_path);
                        }
                }
        }

        if ((si = switch_loadable_module_get_say_interface(module_name)) && si->say_string_function) {
                /* should go back and proto all the say mods to const.... */
                switch_say_args_t say_args = {0};
                
                say_args.type = switch_ivr_get_say_type_by_name(say_type);
                say_args.method = switch_ivr_get_say_method_by_name(say_method);
                say_args.gender = switch_ivr_get_say_gender_by_name(say_gender);
                say_args.ext = ext;
                status = si->say_string_function(session, (char *) tosay, &say_args, rstr);
        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid SAY Interface [%s]!\n", module_name);
                status = SWITCH_STATUS_FALSE;
        }

  done:

        if (hint_data) {
                switch_event_destroy(&hint_data);
        }

        if (save_path && channel) {
                switch_channel_set_variable(channel, "sound_prefix", save_path);
        }

        if (xml) {
                switch_xml_free(xml);
        }

        return status;
}

switch_status_t switch_ivr_set_user	(	switch_core_session_t *	session,
		const char *	data
	)

Definition at line 3816 of file switch_ivr.c.

References SWITCH_CHANNEL_SESSION_LOG, switch_core_session_strdup, switch_ivr_set_user_xml(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_free(), switch_xml_locate_user_merged(), and zstr.

{
        switch_xml_t x_user = 0;
        char *user, *domain;
        switch_status_t status = SWITCH_STATUS_FALSE;

        char *prefix;

        if (zstr(data)) {
                goto error;
        }

        user = switch_core_session_strdup(session, data);

        if ((prefix = strchr(user, ' '))) {
                *prefix++ = 0;
        }

        if (!(domain = strchr(user, '@'))) {
                goto error;
        }

        *domain++ = '\0';


        if (switch_xml_locate_user_merged("id", user, domain, NULL, &x_user, NULL) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "can't find user [%s@%s]\n", user, domain);
                goto done;
        }

        status = switch_ivr_set_user_xml(session, prefix, user, domain, x_user);
        
        goto done;

  error:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "No user@domain specified.\n");

  done:

        if (x_user) {
                switch_xml_free(x_user);
        }

        return status;
}

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
	)

Definition at line 3761 of file switch_ivr.c.

References get_prefixed_str(), switch_xml::next, switch_channel_get_caller_profile(), switch_channel_set_profile_var(), switch_channel_set_variable, switch_core_session_alloc, switch_core_session_get_channel(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_xml_attr(), switch_xml_child(), and zstr.

Referenced by switch_ivr_set_user().

{
        switch_xml_t x_params, x_param;
        char *number_alias;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_FALSE;

        char *prefix_buffer = NULL;
        size_t buffer_size = 0;
        size_t prefix_size = 0;


        status = SWITCH_STATUS_SUCCESS;

        if (!zstr(prefix)) {
                prefix_size = strlen(prefix);
                buffer_size = 1024 + prefix_size + 1;
                prefix_buffer = switch_core_session_alloc(session, buffer_size);
        }

        if ((number_alias = (char *) switch_xml_attr(x_user, "number-alias"))) {
                switch_channel_set_variable(channel, get_prefixed_str(prefix_buffer, buffer_size, prefix, prefix_size, "number_alias"), number_alias);
        }

        if ((x_params = switch_xml_child(x_user, "variables"))) {
                for (x_param = switch_xml_child(x_params, "variable"); x_param; x_param = x_param->next) {
                        const char *var = switch_xml_attr(x_param, "name");
                        const char *val = switch_xml_attr(x_param, "value");

                        if (var && val) {
                                switch_channel_set_variable(channel, get_prefixed_str(prefix_buffer, buffer_size, prefix, prefix_size, var), val);
                        }
                }
        }

        if (switch_channel_get_caller_profile(channel) && (x_params = switch_xml_child(x_user, "profile-variables"))) {
                for (x_param = switch_xml_child(x_params, "variable"); x_param; x_param = x_param->next) {
                        const char *var = switch_xml_attr(x_param, "name");
                        const char *val = switch_xml_attr(x_param, "value");

                        if (var && val) {
                                switch_channel_set_profile_var(channel, get_prefixed_str(prefix_buffer, buffer_size, prefix, prefix_size, var), val);
                        }
                }
        }

        if (user && domain) {
                switch_channel_set_variable(channel, get_prefixed_str(prefix_buffer, buffer_size, prefix, prefix_size, "user_name"), user);
                switch_channel_set_variable(channel, get_prefixed_str(prefix_buffer, buffer_size, prefix, prefix_size, "domain_name"), domain);
        }

        return status;
}

switch_status_t switch_ivr_soft_hold	(	switch_core_session_t *	session,
		const char *	unhold_key,
		const char *	moh_a,
		const char *	moh_b
	)

Definition at line 2819 of file switch_ivr_play_say.c.

References switch_input_args_t::buf, switch_input_args_t::buflen, CF_BROADCAST, hold_on_dtmf(), switch_input_args_t::input_callback, SMF_ECHO_ALEG, SMF_LOOP, switch_assert, switch_channel_get_hold_music(), switch_channel_get_name(), switch_channel_get_partner_uuid(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_stop_broadcast, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_locate, switch_core_session_rwunlock(), switch_ivr_broadcast(), switch_ivr_collect_digits_callback(), switch_ivr_play_file(), switch_log_printf(), SWITCH_LOG_WARNING, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and zstr.

{
        switch_channel_t *channel, *other_channel;
        switch_core_session_t *other_session;
        const char *other_uuid, *moh = NULL;
        int moh_br = 0;
        switch_input_args_t args = { 0 };
        args.input_callback = hold_on_dtmf;
        args.buf = (void *) unhold_key;
        args.buflen = (uint32_t) strlen(unhold_key);

        switch_assert(session != NULL);
        channel = switch_core_session_get_channel(session);
        switch_assert(channel != NULL);

        if ((other_uuid = switch_channel_get_partner_uuid(channel))) {
                if ((other_session = switch_core_session_locate(other_uuid))) {
                        other_channel = switch_core_session_get_channel(other_session);

                        if (moh_b) {
                                moh = moh_b;
                        } else {
                                moh = switch_channel_get_hold_music(other_channel);
                        }

                        if (!zstr(moh) && strcasecmp(moh, "silence") && !switch_channel_test_flag(other_channel, CF_BROADCAST)) {
                                switch_ivr_broadcast(other_uuid, moh, SMF_ECHO_ALEG | SMF_LOOP);
                                moh_br++;
                        }

                        if (moh_a) {
                                moh = moh_a;
                        } else {
                                moh = switch_channel_get_hold_music(channel);
                        }

                        if (!zstr(moh) && strcasecmp(moh, "silence")) {
                                switch_ivr_play_file(session, NULL, moh, &args);
                        } else {
                                switch_ivr_collect_digits_callback(session, &args, 0, 0);
                        }

                        if (moh_br) {
                                switch_channel_stop_broadcast(other_channel);
                        }

                        switch_core_session_rwunlock(other_session);


                        return SWITCH_STATUS_SUCCESS;
                }

        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Channel %s is not in a bridge\n", switch_channel_get_name(channel));
        return SWITCH_STATUS_FALSE;

}

switch_status_t switch_ivr_sound_test

(

switch_core_session_t *

session

)

Definition at line 41 of file switch_ivr.c.

References switch_codec_implementation::actual_samples_per_second, switch_frame::data, switch_codec_implementation::microseconds_per_packet, switch_codec_implementation::number_of_channels, switch_frame::samples, switch_codec_implementation::samples_per_packet, switch_codec_implementation::samples_per_second, SFF_CNG, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, switch_core_codec_destroy(), switch_core_codec_init, switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_impl(), switch_core_session_read_frame(), SWITCH_IO_FLAG_NONE, SWITCH_LOG_CONSOLE, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_READ_ACCEPTABLE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_test_flag.

{

        switch_codec_implementation_t imp = { 0 };
        switch_codec_t codec = { 0 };
        int16_t peak = 0;
        int16_t *data;
        switch_frame_t *read_frame = NULL;
        uint32_t i;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int64_t global_total = 0, global_sum = 0, period_sum = 0;
        int period_total = 0;
        int period_avg = 0, global_avg = 0;
        int avg = 0;
        int period_len;

        switch_core_session_get_read_impl(session, &imp);

        period_len = imp.actual_samples_per_second / imp.samples_per_packet;

        if (switch_core_codec_init(&codec,
                                                           "L16",
                                                           NULL,
                                                           NULL,
                                                           imp.samples_per_second,
                                                           imp.microseconds_per_packet / 1000,
                                                           imp.number_of_channels,
                                                           SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                           switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec Error L16@%uhz %u channels %dms\n",
                                                  imp.samples_per_second, imp.number_of_channels, imp.microseconds_per_packet / 1000);
                return SWITCH_STATUS_FALSE;
        }

        while (switch_channel_ready(channel)) {
                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        break;
                }

                if (switch_test_flag(read_frame, SFF_CNG) || !read_frame->samples) {
                        continue;
                }


                data = (int16_t *) read_frame->data;
                peak = 0;
                avg = 0;
                for (i = 0; i < read_frame->samples; i++) {
                        const int16_t s = (int16_t) abs(data[i]);
                        if (s > peak) {
                                peak = s;
                        }
                        avg += s;
                }

                avg /= read_frame->samples;

                period_sum += peak;
                global_sum += peak;

                global_total++;
                period_total++;

                period_avg = (int) (period_sum / period_total);

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CONSOLE,
                                                  "\npacket_avg=%d packet_peak=%d period_avg=%d global_avg=%d\n\n", avg, peak, period_avg, global_avg);

                if (period_total >= period_len) {
                        global_avg = (int) (global_sum / global_total);
                        period_total = 0;
                        period_sum = 0;
                }

        }


        switch_core_codec_destroy(&codec);

        return SWITCH_STATUS_SUCCESS;

}

switch_status_t switch_ivr_stop_video_write_overlay_session

(

switch_core_session_t *

session

)

Definition at line 5133 of file switch_ivr_async.c.

References switch_channel_get_private(), switch_channel_set_private(), switch_core_media_bug_remove(), switch_core_session_get_channel(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_bug_t *bug = switch_channel_get_private(channel, "_video_write_overlay_bug_");

        if (bug) {
                switch_channel_set_private(channel, "_video_write_overlay_bug_", NULL);
                switch_core_media_bug_remove(session, &bug);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

switch_status_t switch_ivr_unbind_dtmf_meta_session	(	switch_core_session_t *	session,
		uint32_t	key
	)

Definition at line 4048 of file switch_ivr_async.c.

References dtmf_meta_settings_t::map, memset(), dtmf_meta_data_t::sr, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_session_get_channel(), SWITCH_DTMF_RECV, SWITCH_DTMF_SEND, SWITCH_LOG_ERROR, SWITCH_LOG_INFO, switch_log_printf(), SWITCH_META_VAR_KEY, SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);

        if (key) {
                dtmf_meta_data_t *md = switch_channel_get_private(channel, SWITCH_META_VAR_KEY);

                if (!md || key > 9) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid key %u\n", key);
                        return SWITCH_STATUS_FALSE;
                }

                memset(&md->sr[SWITCH_DTMF_RECV].map[key], 0, sizeof(md->sr[SWITCH_DTMF_RECV].map[key]));
                memset(&md->sr[SWITCH_DTMF_SEND].map[key], 0, sizeof(md->sr[SWITCH_DTMF_SEND].map[key]));
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "UnBound A-Leg: %d\n", key);

        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "UnBound A-Leg: ALL\n");
                switch_channel_set_private(channel, SWITCH_META_VAR_KEY, NULL);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_unblock_dtmf_session

(

switch_core_session_t *

session

)

Definition at line 4084 of file switch_ivr_async.c.

References SWITCH_BLOCK_DTMF_KEY, switch_channel_get_private(), switch_channel_set_private(), switch_core_session_get_channel(), and SWITCH_STATUS_SUCCESS.

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        uint8_t enabled = (uint8_t)(intptr_t)switch_channel_get_private(channel, SWITCH_BLOCK_DTMF_KEY);
        
        if (enabled) {
                switch_channel_set_private(channel, SWITCH_BLOCK_DTMF_KEY, NULL);
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_bool_t switch_ivr_uuid_exists

(

const char *

uuid

)

Definition at line 3862 of file switch_ivr.c.

References switch_core_session_locate, switch_core_session_rwunlock(), and SWITCH_FALSE.

Referenced by core_event_handler().

{
        switch_bool_t exists = SWITCH_FALSE;
        switch_core_session_t *psession = NULL;

        if ((psession = switch_core_session_locate(uuid))) {
                switch_core_session_rwunlock(psession);
                exists = 1;
        }

        return exists;
}

switch_bool_t switch_ivr_uuid_force_exists

(

const char *

uuid

)

Definition at line 3875 of file switch_ivr.c.

References switch_core_session_force_locate, switch_core_session_rwunlock(), and SWITCH_FALSE.

{
        switch_bool_t exists = SWITCH_FALSE;
        switch_core_session_t *psession = NULL;

        if ((psession = switch_core_session_force_locate(uuid))) {
                switch_core_session_rwunlock(psession);
                exists = 1;
        }

        return exists;
}

switch_status_t switch_ivr_video_write_overlay_session	(	switch_core_session_t *	session,
		const char *	img_path,
		switch_img_position_t	pos,
		uint8_t	alpha
	)

Definition at line 5147 of file switch_ivr_async.c.

References oht_s::alpha, oht_s::img, oht_s::pos, SMBF_NO_PAUSE, SMBF_WRITE_VIDEO_PING, switch_channel_get_private(), SWITCH_CHANNEL_LOG, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_session_alloc, switch_core_session_get_channel(), SWITCH_IMG_FMT_ARGB, switch_img_free(), switch_img_read_png(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and video_write_overlay_callback().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_status_t status;
        switch_media_bug_flag_t bflags = SMBF_WRITE_VIDEO_PING;
        switch_media_bug_t *bug;
        overly_helper_t *oht;
        switch_image_t *img;

        bflags |= SMBF_NO_PAUSE;

        if (switch_channel_get_private(channel, "_video_write_overlay_bug_")) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Only one of this type of bug per channel\n");
                return SWITCH_STATUS_FALSE;
        }

        if (!(img = switch_img_read_png(img_path, SWITCH_IMG_FMT_ARGB))) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening file: %s\n", img_path);
                return SWITCH_STATUS_FALSE;
        }

        oht = switch_core_session_alloc(session, sizeof(*oht));
        oht->img = img;
        oht->pos = pos;
        oht->alpha = alpha;

        if ((status = switch_core_media_bug_add(session, "video_write_overlay", NULL,
                                                                                        video_write_overlay_callback, oht, 0, bflags, &bug)) != SWITCH_STATUS_SUCCESS) {

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error creating bug, file: %s\n", img_path);
                switch_img_free(&oht->img);
                return status;
        }

        switch_channel_set_private(channel, "_video_write_overlay_bug_", bug);
        
        return SWITCH_STATUS_SUCCESS;
}

switch_status_t switch_ivr_wait_for_answer	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session
	)

Definition at line 858 of file switch_ivr_originate.c.

References switch_codec_implementation::actual_samples_per_second, ringback::asis, ringback::audio_buffer, switch_frame::buflen, CF_ANSWERED, CF_DISABLE_RINGBACK, CF_EARLY_MEDIA, CF_PROXY_MEDIA, CF_PROXY_MODE, CF_XFER_ZOMBIE, switch_file_handle::channels, ringback::channels, switch_frame::codec, CS_RESET, CS_SOFT_EXECUTE, switch_frame::data, switch_frame::datalen, switch_codec_implementation::decoded_bytes_per_packet, switch_dtmf_t::digit, switch_codec_implementation::encoded_bytes_per_packet, ringback::fh, ringback::fhb, switch_file_handle::file_path, switch_codec_implementation::iananame, switch_codec::implementation, memset(), switch_codec_implementation::microseconds_per_packet, ringback::mux_buf, switch_codec_implementation::number_of_channels, teletone_generation_session::rate, switch_file_handle::samplerate, switch_frame::samples, switch_codec_implementation::samples_per_packet, ringback::silence, switch_file_handle::speed, switch_assert, switch_buffer_create_dynamic(), switch_buffer_destroy(), switch_buffer_read_loop(), switch_buffer_set_loops(), SWITCH_CALL_TIMEOUT_VARIABLE, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER, SWITCH_CHANNEL_CHANNEL_LOG, switch_channel_dequeue_dtmf(), switch_channel_get_state(), switch_channel_get_variable, switch_channel_hangup, switch_channel_has_dtmf(), switch_channel_media_ready, switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_state, switch_channel_test_flag(), switch_channel_up_nosig, SWITCH_CODEC_FLAG_DECODE, SWITCH_CODEC_FLAG_ENCODE, SWITCH_CODEC_FLAG_PASSTHROUGH, switch_cond_next(), switch_core_codec_destroy(), switch_core_codec_init, switch_core_codec_ready(), switch_core_file_close(), switch_core_file_open, switch_core_file_read(), switch_core_file_seek(), switch_core_session_get_channel(), switch_core_session_get_pool(), switch_core_session_get_read_codec(), switch_core_session_read_frame(), switch_core_session_reset(), switch_core_session_set_read_codec(), switch_core_session_sprintf(), switch_core_session_write_frame(), SWITCH_FILE_DATA_SHORT, SWITCH_FILE_FLAG_READ, switch_generate_sln_silence(), SWITCH_IO_FLAG_NONE, switch_is_file_path(), switch_ivr_parse_all_events(), switch_ivr_parse_all_messages(), SWITCH_IVR_VERIFY_SILENCE_DIVISOR, SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), switch_micro_time_now(), switch_mprintf(), SWITCH_READ_ACCEPTABLE, SWITCH_RECOMMENDED_BUFFER_SIZE, switch_safe_free, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, SWITCH_STATUS_TIMEOUT, switch_test_flag, SWITCH_TRUE, SWITCH_URL_SEPARATOR, switch_yield, switch_zmalloc, teletone_destroy_session(), teletone_handler(), teletone_init_session(), teletone_run(), ringback::ts, and zstr.

Referenced by switch_ivr_multi_threaded_bridge(), uuid_bridge_on_soft_execute(), and CoreSession::waitForAnswer().

{
        switch_channel_t *caller_channel = NULL;
        switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);
        const char *ringback_data = NULL;
        switch_frame_t write_frame = { 0 };
        switch_codec_t write_codec = { 0 };
        switch_codec_t *read_codec = switch_core_session_get_read_codec(session);
        uint8_t pass = 0;
        ringback_t ringback = { 0 };
        switch_frame_t *read_frame = NULL;
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int timelimit = 60;
        const char *var;
        switch_time_t start = 0;
        const char *cancel_key = NULL;
        switch_channel_state_t wait_state = 0;

        switch_assert(peer_channel);

        if (switch_channel_get_state(peer_channel) == CS_RESET) {
                switch_channel_set_state(peer_channel, CS_SOFT_EXECUTE);
        }

        if (session) {
                caller_channel = switch_core_session_get_channel(session);
        }

        if ((switch_channel_test_flag(peer_channel, CF_ANSWERED) || switch_channel_test_flag(peer_channel, CF_EARLY_MEDIA))) {
                goto end;
        }

        switch_zmalloc(write_frame.data, SWITCH_RECOMMENDED_BUFFER_SIZE);
        write_frame.buflen = SWITCH_RECOMMENDED_BUFFER_SIZE;

        if (caller_channel && (var = switch_channel_get_variable(caller_channel, SWITCH_CALL_TIMEOUT_VARIABLE))) {
                timelimit = atoi(var);
                if (timelimit < 0) {
                        timelimit = 60;
                }
        }

        timelimit *= 1000000;
        start = switch_micro_time_now();

        if (caller_channel) {
                cancel_key = switch_channel_get_variable(caller_channel, "origination_cancel_key");

                if (switch_channel_test_flag(caller_channel, CF_ANSWERED)) {
                        ringback_data = switch_channel_get_variable(caller_channel, "transfer_ringback");
                }

                if (!ringback_data) {
                        ringback_data = switch_channel_get_variable(caller_channel, "ringback");
                }

                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE) || switch_channel_test_flag(caller_channel, CF_PROXY_MEDIA)) {
                        ringback_data = NULL;
                } else if (zstr(ringback_data)) {
                        if ((var = switch_channel_get_variable(caller_channel, SWITCH_SEND_SILENCE_WHEN_IDLE_VARIABLE))) {
                                int sval = atoi(var);

                                if (sval) {
                                        ringback_data = switch_core_session_sprintf(session, "silence:%d", sval);
                                }
                        }
                }
        }


        if (read_codec && ringback_data) {
                if (switch_is_file_path(ringback_data)) {
                        if (!(strrchr(ringback_data, '.') || strstr(ringback_data, SWITCH_URL_SEPARATOR))) {
                                ringback.asis++;
                        }
                }



                if (!ringback.asis) {
                        if ((pass = (uint8_t) switch_test_flag(read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH))) {
                                goto no_ringback;
                        }

                        if (switch_core_codec_init(&write_codec,
                                                                           "L16",
                                                                           NULL,
                                                                           NULL,
                                                                           read_codec->implementation->actual_samples_per_second,
                                                                           read_codec->implementation->microseconds_per_packet / 1000,
                                                                           read_codec->implementation->number_of_channels, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
                                                                           switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec Error!\n");
                                if (caller_channel) {
                                        switch_channel_hangup(caller_channel, SWITCH_CAUSE_BEARERCAPABILITY_NOTIMPL);
                                }
                                read_codec = NULL;
                                goto done;
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "Raw Codec Activation Success L16@%uhz 1 channel %dms\n",
                                                                  read_codec->implementation->actual_samples_per_second, read_codec->implementation->microseconds_per_packet / 1000);

                                write_frame.codec = &write_codec;
                                write_frame.datalen = read_codec->implementation->decoded_bytes_per_packet;
                                write_frame.samples = write_frame.datalen / 2;
                                memset(write_frame.data, 255, write_frame.datalen);
                                switch_core_session_set_read_codec(session, &write_codec);
                        }
                }

                if (switch_channel_test_flag(caller_channel, CF_DISABLE_RINGBACK)) {
                        ringback_data = NULL;
                }

                if (ringback_data) {
                        char *tmp_data = NULL;

                        if (switch_is_file_path(ringback_data)) {
                                char *ext;

                                if (ringback.asis) {
                                        write_frame.codec = read_codec;
                                        ext = read_codec->implementation->iananame;
                                        tmp_data = switch_mprintf("%s.%s", ringback_data, ext);
                                        ringback_data = tmp_data;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Play Ringback File [%s]\n", ringback_data);

                                ringback.fhb.channels = read_codec->implementation->number_of_channels;
                                ringback.fhb.samplerate = read_codec->implementation->actual_samples_per_second;
                                if (switch_core_file_open(&ringback.fhb,
                                                                                  ringback_data,
                                                                                  read_codec->implementation->number_of_channels,
                                                                                  read_codec->implementation->actual_samples_per_second,
                                                                                  SWITCH_FILE_FLAG_READ | SWITCH_FILE_DATA_SHORT, NULL) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error Playing File\n");
                                        switch_safe_free(tmp_data);
                                        goto done;
                                }
                                ringback.fh = &ringback.fhb;
                        } else {
                                if (!strncasecmp(ringback_data, "silence", 7)) {
                                        const char *p = ringback_data + 7;
                                        if (*p == ':') {
                                                p++;
                                                if (p) {
                                                        ringback.silence = atoi(p);
                                                }
                                        }
                                        SWITCH_IVR_VERIFY_SILENCE_DIVISOR(ringback.silence);
                                } else {
                                        switch_buffer_create_dynamic(&ringback.audio_buffer, 512, 1024, 0);
                                        switch_buffer_set_loops(ringback.audio_buffer, -1);

                                        teletone_init_session(&ringback.ts, 0, teletone_handler, &ringback);
                                        ringback.ts.rate = read_codec->implementation->actual_samples_per_second;
                                        ringback.channels = read_codec->implementation->number_of_channels;
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Play Ringback Tone [%s]\n", ringback_data);
                                        if (teletone_run(&ringback.ts, ringback_data)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error Playing Tone\n");
                                                teletone_destroy_session(&ringback.ts);
                                                switch_buffer_destroy(&ringback.audio_buffer);
                                                ringback_data = NULL;
                                        }
                                }
                        }
                        switch_safe_free(tmp_data);
                }
        }

  no_ringback:

        if (caller_channel) {
                wait_state = switch_channel_get_state(caller_channel);
        }

        while (switch_channel_ready(peer_channel) && !switch_channel_media_ready(peer_channel)) {
                int diff = (int) (switch_micro_time_now() - start);

                switch_ivr_parse_all_messages(session);

                if (caller_channel && cancel_key) {
                        if (switch_channel_has_dtmf(caller_channel)) {
                                switch_dtmf_t dtmf = { 0, 0 };
                                if (switch_channel_dequeue_dtmf(caller_channel, &dtmf) == SWITCH_STATUS_SUCCESS) {
                                        if (dtmf.digit == *cancel_key) {
                                                status = SWITCH_STATUS_FALSE;
                                                goto done;
                                        }
                                }
                        }
                }

                if (caller_channel && switch_channel_get_state(caller_channel) != wait_state) {
                        goto done;
                }

                if (diff > timelimit) {
                        status = SWITCH_STATUS_TIMEOUT;
                        goto done;
                }

                if (switch_channel_media_ready(caller_channel)) {
                        status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);
                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                break;
                        }
                } else {
                        read_frame = NULL;
                }

                if (read_frame && !pass) {

                        if (ringback.fh) {
                                switch_size_t mlen, olen;
                                unsigned int pos = 0;

                                if (ringback.asis) {
                                        mlen = write_frame.codec->implementation->encoded_bytes_per_packet;
                                } else {
                                        mlen = write_frame.codec->implementation->samples_per_packet;
                                }

                                olen = mlen;
                                //if (ringback.fh->resampler && ringback.fh->resampler->rfactor > 1) {
                                //olen = (switch_size_t) (olen * ringback.fh->resampler->rfactor);
                                //}
                                switch_core_file_read(ringback.fh, write_frame.data, &olen);

                                if (olen == 0) {
                                        olen = mlen;
                                        ringback.fh->speed = 0;
                                        switch_core_file_seek(ringback.fh, &pos, 0, SEEK_SET);
                                        switch_core_file_read(ringback.fh, write_frame.data, &olen);
                                        if (olen == 0) {
                                                switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(caller_channel), SWITCH_LOG_ERROR, 
                                                                                  "Failure to read or re-read after seeking to beginning on file [%s]\n", ringback.fh->file_path);
                                                break;
                                        }
                                }
                                write_frame.datalen = (uint32_t) (ringback.asis ? olen : olen * 2 * ringback.fh->channels);
                        } else if (ringback.audio_buffer) {
                                if ((write_frame.datalen = (uint32_t) switch_buffer_read_loop(ringback.audio_buffer,
                                                                                                                                                          write_frame.data,
                                                                                                                                                          write_frame.codec->implementation->decoded_bytes_per_packet)) <= 0) {
                                        break;
                                }
                        } else if (ringback.silence) {
                                write_frame.datalen = write_frame.codec->implementation->decoded_bytes_per_packet;
                                switch_generate_sln_silence((int16_t *) write_frame.data, write_frame.datalen / 2, 
                                                                                        write_frame.codec->implementation->number_of_channels, ringback.silence);
                        }

                        if ((ringback.fh || ringback.silence || ringback.audio_buffer) && write_frame.codec && write_frame.datalen) {
                                if (switch_core_session_write_frame(session, &write_frame, SWITCH_IO_FLAG_NONE, 0) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                } else {
                        switch_cond_next();
                }
        }

  done:

        if (ringback.fh) {
                switch_core_file_close(ringback.fh);
                ringback.fh = NULL;
        } else if (ringback.audio_buffer) {
                teletone_destroy_session(&ringback.ts);
                switch_safe_free(ringback.mux_buf);
                switch_buffer_destroy(&ringback.audio_buffer);
        }

        
        switch_ivr_parse_all_events(session);
        
        switch_core_session_reset(session, SWITCH_TRUE, SWITCH_TRUE);

        if (switch_core_codec_ready(&write_codec)) {
                switch_core_codec_destroy(&write_codec);
        }

        switch_safe_free(write_frame.data);

  end:

        if (!switch_channel_media_ready(peer_channel)) {
                if (switch_channel_up_nosig(peer_channel)) {
                        switch_channel_hangup(peer_channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                }
                status = SWITCH_STATUS_FALSE;
        }

        if (switch_channel_test_flag(caller_channel, CF_XFER_ZOMBIE)) {
                switch_channel_state_t peer_state = switch_channel_get_state(peer_channel);

                while (switch_channel_ready(peer_channel) && switch_channel_get_state(peer_channel) == peer_state) {
                        switch_ivr_parse_all_messages(session);
                        switch_channel_ready(caller_channel);
                        switch_yield(20000);
                }
        }

        if (caller_channel && !switch_channel_up_nosig(caller_channel)) {
                status = SWITCH_STATUS_FALSE;
        }

        return status;
}

void switch_process_import	(	switch_core_session_t *	session,
		switch_channel_t *	peer_channel,
		const char *	varname,
		const char *	prefix
	)

Definition at line 1171 of file switch_ivr_originate.c.

References switch_assert, switch_channel_get_variable, switch_channel_set_variable, switch_core_session_get_channel(), switch_core_session_strdup, switch_mprintf(), and switch_separate_string().

Referenced by switch_ivr_originate().

{
        const char *import, *val;
        switch_channel_t *caller_channel;

        switch_assert(session && peer_channel);
        caller_channel = switch_core_session_get_channel(session);

        if ((import = switch_channel_get_variable(caller_channel, varname))) {
                char *mydata = switch_core_session_strdup(session, import);
                int i, argc;
                char *argv[64] = { 0 };

                if ((argc = switch_separate_string(mydata, ',', argv, (sizeof(argv) / sizeof(argv[0]))))) {
                        for (i = 0; i < argc; i++) {
                                if ((val = switch_channel_get_variable(peer_channel, argv[i]))) {
                                        if (prefix) {
                                                char *var = switch_mprintf("%s%s", prefix, argv[i]);
                                                switch_channel_set_variable(caller_channel, var, val);
                                                free(var);
                                        } else {
                                                switch_channel_set_variable(caller_channel, argv[i], val);
                                        }
                                }
                        }
                }
        }
}