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)
switch_status_t	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_extended (switch_core_session_t *session, const char *data, switch_event_t *params)
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, switch_byte_t is_priority, 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_record_session_pause (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)
switch_status_t	switch_ivr_capture_text (switch_core_session_t *session, switch_bool_t on)
switch_status_t	switch_dial_handle_create (switch_dial_handle_t **handle)
switch_status_t	switch_dial_handle_create_json_obj (switch_dial_handle_t **handle, cJSON *json)
switch_status_t	switch_dial_handle_create_json (switch_dial_handle_t **handle, const char *handle_string)
void	switch_dial_handle_destroy (switch_dial_handle_t **handle)
switch_status_t	switch_dial_handle_serialize_json_obj (switch_dial_handle_t *handle, cJSON **json)
switch_status_t	switch_dial_handle_serialize_json (switch_dial_handle_t *handle, char **str)
void	switch_dial_handle_add_leg_list (switch_dial_handle_t *handle, switch_dial_leg_list_t **leg_listP)
void	switch_dial_leg_list_add_leg (switch_dial_leg_list_t *parent, switch_dial_leg_t **legP, const char *dial_string)
void	switch_dial_leg_list_add_leg_printf (switch_dial_leg_list_t *parent, switch_dial_leg_t **legP, const char *fmt,...)
void	switch_dial_handle_add_global_var (switch_dial_handle_t *handle, const char *var, const char *val)
void	switch_dial_handle_add_global_var_printf (switch_dial_handle_t *handle, const char *var, const char *fmt,...)
switch_status_t	switch_dial_handle_add_leg_var (switch_dial_leg_t *leg, const char *var, const char *val)
switch_status_t	switch_dial_handle_add_leg_var_printf (switch_dial_leg_t *leg, const char *var, const char *fmt,...)
int	switch_dial_handle_get_peers (switch_dial_handle_t *handle, int idx, char **array, int max)
int	switch_dial_handle_get_vars (switch_dial_handle_t *handle, int idx, switch_event_t **array, int max)
switch_event_t *	switch_dial_handle_get_global_vars (switch_dial_handle_t *handle)
switch_event_t *	switch_dial_leg_get_vars (switch_dial_leg_t *leg)
const char *	switch_dial_leg_get_var (switch_dial_leg_t *leg, const char *key)
int	switch_dial_handle_get_total (switch_dial_handle_t *handle)
switch_status_t	switch_dial_handle_list_serialize_json_obj (switch_dial_handle_list_t *hl, cJSON **json)
switch_status_t	switch_dial_handle_list_serialize_json (switch_dial_handle_list_t *hl, char **str)
switch_status_t	switch_dial_handle_list_create_json_obj (switch_dial_handle_list_t **handle, cJSON *json)
switch_status_t	switch_dial_handle_list_create_json (switch_dial_handle_list_t **handle, const char *handle_string)
switch_status_t	switch_dial_handle_list_create (switch_dial_handle_list_t **hl)
switch_status_t	switch_dial_handle_list_create_handle (switch_dial_handle_list_t *hl, switch_dial_handle_t **handle)
void	switch_dial_handle_list_destroy (switch_dial_handle_list_t **hl)
void	switch_dial_handle_list_add_global_var (switch_dial_handle_list_t *hl, const char *var, const char *val)
void	switch_dial_handle_list_add_global_var_printf (switch_dial_handle_list_t *hl, const char *var, const char *fmt,...)
switch_status_t	switch_ivr_enterprise_orig_and_bridge (switch_core_session_t *session, const char *data, switch_dial_handle_list_t *hl, switch_call_cause_t *cause)
switch_status_t	switch_ivr_orig_and_bridge (switch_core_session_t *session, const char *data, switch_dial_handle_t *dh, switch_call_cause_t *cause)
switch_status_t	switch_ivr_send_prompt (switch_core_session_t *session, const char *type, const char *text, const char *regex)
switch_status_t	switch_ivr_play_and_collect_input (switch_core_session_t *session, const char *prompt, const char *recognizer_mod_name, const char *recognizer_grammar, int min_digits, int max_digits, const char *terminators, uint32_t digit_timeout, cJSON **recognition_result, char **digits_collected, char *terminator_collected, switch_input_args_t *args)
	Play prompt and collect input. More...

Detailed Description

IVR menu functions

Macro Definition Documentation

switch_ivr_phrase_macro

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

switch_ivr_menu_action_function_t

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

Definition at line 816 of file switch_ivr.h.

switch_ivr_menu_action_t

typedef struct switch_ivr_menu_action switch_ivr_menu_action_t

Definition at line 818 of file switch_ivr.h.

switch_ivr_menu_t

typedef struct switch_ivr_menu switch_ivr_menu_t

Definition at line 817 of file switch_ivr.h.

switch_ivr_menu_xml_ctx_t

typedef struct switch_ivr_menu_xml_ctx switch_ivr_menu_xml_ctx_t

Definition at line 904 of file switch_ivr.h.

Enumeration Type Documentation

switch_ivr_action_t

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

switch_ivr_menu_flags

enum switch_ivr_menu_flags

Enumerator
SWITCH_IVR_MENU_FLAG_FALLTOMAIN
SWITCH_IVR_MENU_FLAG_FREEPOOL
SWITCH_IVR_MENU_FLAG_STACK

Definition at line 800 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_dial_handle_add_global_var()

void switch_dial_handle_add_global_var	(	switch_dial_handle_t *	handle,
		const char *	var,
		const char *	val
	)

Definition at line 4508 of file switch_ivr_originate.c.

References switch_dial_handle_s::global_vars, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), and SWITCH_STACK_BOTTOM.

Referenced by switch_dial_handle_add_global_var_printf(), and switch_dial_handle_create_json_obj().

{
        switch_assert(handle);
        
        if (!handle->global_vars) {
                switch_event_create_plain(&handle->global_vars, SWITCH_EVENT_CHANNEL_DATA);
        }

        switch_event_add_header_string(handle->global_vars, SWITCH_STACK_BOTTOM, var, val);
}

switch_dial_handle_add_global_var_printf()

void switch_dial_handle_add_global_var_printf	(	switch_dial_handle_t *	handle,
		const char *	var,
		const char *	fmt,
			...
	)

Definition at line 4519 of file switch_ivr_originate.c.

References switch_dial_handle_add_global_var(), and switch_vasprintf().

{
        int ret = 0;
        char *data = NULL;
        va_list ap;

        va_start(ap, fmt);
        ret = switch_vasprintf(&data, fmt, ap);
        va_end(ap);

        if (ret == -1) {
                abort();
        }

        switch_dial_handle_add_global_var(handle, var, data);
        free(data);
}

switch_dial_handle_add_leg_list()

void switch_dial_handle_add_leg_list	(	switch_dial_handle_t *	handle,
		switch_dial_leg_list_t **	leg_listP
	)

Definition at line 4459 of file switch_ivr_originate.c.

References switch_dial_leg_list_s::handle, switch_dial_handle_s::leg_list_idx, switch_dial_handle_s::leg_lists, switch_dial_handle_s::pool, switch_assert, and switch_core_alloc.

Referenced by switch_dial_handle_create_json_obj(), and switch_dial_handle_dup().

{
        switch_dial_leg_list_t *leg_list;
        
        switch_assert(handle);

        leg_list = switch_core_alloc(handle->pool, sizeof(*leg_list));
        leg_list->handle = handle;

        handle->leg_lists[handle->leg_list_idx++] = leg_list;
        
        *leg_listP = leg_list;
}

switch_dial_handle_add_leg_var()

switch_status_t switch_dial_handle_add_leg_var	(	switch_dial_leg_t *	leg,
		const char *	var,
		const char *	val
	)

Definition at line 4537 of file switch_ivr_originate.c.

References switch_dial_leg_s::leg_vars, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), SWITCH_STACK_BOTTOM, SWITCH_STATUS_NOTFOUND, and SWITCH_STATUS_SUCCESS.

Referenced by switch_dial_handle_add_leg_var_printf(), and switch_dial_handle_create_json_obj().

{
        if (!leg) return SWITCH_STATUS_NOTFOUND;
        
        if (!leg->leg_vars) {
                switch_event_create_plain(&leg->leg_vars, SWITCH_EVENT_CHANNEL_DATA);
        }

        switch_event_add_header_string(leg->leg_vars, SWITCH_STACK_BOTTOM, var, val);

        return SWITCH_STATUS_SUCCESS;
        
}

switch_dial_handle_add_leg_var_printf()

switch_status_t switch_dial_handle_add_leg_var_printf	(	switch_dial_leg_t *	leg,
		const char *	var,
		const char *	fmt,
			...
	)

Definition at line 4551 of file switch_ivr_originate.c.

References switch_dial_handle_add_leg_var(), and switch_vasprintf().

{
        int ret = 0;
        char *data = NULL;
        va_list ap;
        switch_status_t status;
        
        va_start(ap, fmt);
        ret = switch_vasprintf(&data, fmt, ap);
        va_end(ap);

        if (ret == -1) {
                abort();
        }

        status = switch_dial_handle_add_leg_var(leg, var, data);

        free(data);

        return status;
}

switch_dial_handle_create()

switch_status_t switch_dial_handle_create

(

switch_dial_handle_t **

handle

)

Definition at line 4418 of file switch_ivr_originate.c.

References pool, switch_dial_handle_s::pool, switch_assert, switch_core_alloc, switch_core_new_memory_pool, and SWITCH_STATUS_SUCCESS.

Referenced by switch_dial_handle_create_json_obj(), switch_dial_handle_dup(), and switch_dial_handle_list_create_handle().

{
        switch_dial_handle_t *hp;
        switch_memory_pool_t *pool = NULL;

        switch_core_new_memory_pool(&pool);
        switch_assert(pool);
        
        hp = switch_core_alloc(pool, sizeof(*hp));
        switch_assert(hp);

        hp->pool = pool;

        *handle = hp;
        
        return SWITCH_STATUS_SUCCESS;
}

switch_dial_handle_create_json()

switch_status_t switch_dial_handle_create_json	(	switch_dial_handle_t **	handle,
		const char *	handle_string
	)

Definition at line 4769 of file switch_ivr_originate.c.

References switch_dial_handle_create_json_obj(), SWITCH_STATUS_FALSE, and zstr.

{
        switch_status_t status;
        cJSON *handle_json = NULL;

        if (zstr(handle_string)) {
                return SWITCH_STATUS_FALSE;
        }

        handle_json = cJSON_Parse(handle_string);
        if (!handle_json) {
                return SWITCH_STATUS_FALSE;
        }

        status = switch_dial_handle_create_json_obj(handle, handle_json);
        cJSON_Delete(handle_json);
        return status;
}

switch_dial_handle_create_json_obj()

switch_status_t switch_dial_handle_create_json_obj	(	switch_dial_handle_t **	handle,
		cJSON *	json
	)

Definition at line 4710 of file switch_ivr_originate.c.

References cJSON_Array, cJSON_ArrayForEach, cJSON_GetObjectCstr(), cJSON_Object, cJSON_String, cJSON::string, switch_dial_handle_add_global_var(), switch_dial_handle_add_leg_list(), switch_dial_handle_add_leg_var(), switch_dial_handle_create(), switch_dial_leg_list_add_leg(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, cJSON::type, and cJSON::valuestring.

Referenced by switch_dial_handle_create_json(), and switch_dial_handle_list_create_json_obj().

{
        cJSON *vars_json = NULL;
        cJSON *var_json = NULL;
        cJSON *leg_lists_json = NULL;
        if (!json) {
                return SWITCH_STATUS_FALSE;
        }
        switch_dial_handle_create(handle);

        leg_lists_json = cJSON_GetObjectItem(json, "leg_lists");
        if (leg_lists_json && leg_lists_json->type == cJSON_Array) {
                cJSON *leg_list_json = NULL;
                cJSON_ArrayForEach(leg_list_json, leg_lists_json) {
                        cJSON *legs_json = cJSON_GetObjectItem(leg_list_json, "legs");
                        cJSON *leg_json = NULL;
                        switch_dial_leg_list_t *ll = NULL;
                        if (!legs_json || legs_json->type != cJSON_Array) {
                                continue;
                        }
                        switch_dial_handle_add_leg_list(*handle, &ll);
                        cJSON_ArrayForEach(leg_json, legs_json) {
                                switch_dial_leg_t *leg = NULL;
                                const char *dial_string = NULL;
                                if (!leg_json || leg_json->type != cJSON_Object) {
                                        continue;
                                }
                                dial_string = cJSON_GetObjectCstr(leg_json, "dial_string");
                                if (!dial_string) {
                                        continue;
                                }
                                switch_dial_leg_list_add_leg(ll, &leg, dial_string);

                                vars_json = cJSON_GetObjectItem(leg_json, "vars");
                                if (vars_json && vars_json->type == cJSON_Object) {
                                        cJSON_ArrayForEach(var_json, vars_json) {
                                                if (!var_json || var_json->type != cJSON_String || !var_json->valuestring || !var_json->string) {
                                                        continue;
                                                }
                                                switch_dial_handle_add_leg_var(leg, var_json->string, var_json->valuestring);
                                        }
                                }
                        }
                }
        }

        vars_json = cJSON_GetObjectItem(json, "vars");
        if (vars_json && vars_json->type == cJSON_Object) {
                cJSON_ArrayForEach(var_json, vars_json) {
                        if (!var_json || var_json->type != cJSON_String || !var_json->valuestring || !var_json->string) {
                                continue;
                        }
                        switch_dial_handle_add_global_var(*handle, var_json->string, var_json->valuestring);
                }
        }
        return SWITCH_STATUS_SUCCESS;
}

switch_dial_handle_destroy()

void switch_dial_handle_destroy

(

switch_dial_handle_t **

handle

)

Definition at line 4436 of file switch_ivr_originate.c.

References switch_dial_handle_s::global_vars, switch_dial_leg_list_s::handle, switch_dial_leg_list_s::leg_idx, switch_dial_handle_s::leg_list_idx, switch_dial_handle_s::leg_lists, switch_dial_leg_s::leg_vars, switch_dial_leg_list_s::legs, pool, switch_dial_handle_s::pool, switch_core_destroy_memory_pool, and switch_event_destroy().

Referenced by switch_dial_handle_list_create_json_obj(), switch_dial_handle_list_destroy(), and switch_ivr_enterprise_originate().

{
        switch_dial_handle_t *hp = *handle;
        switch_memory_pool_t *pool = NULL;

        *handle = NULL;

        if (hp) {
                int i, j;

                for (i = 0; i < hp->leg_list_idx; i++) {
                        for(j = 0; j < hp->leg_lists[i]->leg_idx; j++) {
                                switch_event_destroy(&hp->leg_lists[i]->legs[j]->leg_vars);
                        }
                }

                switch_event_destroy(&hp->global_vars);
                pool = hp->pool;
                hp = NULL;
                switch_core_destroy_memory_pool(&pool); 
        }
}

switch_dial_handle_get_global_vars()

switch_event_t* switch_dial_handle_get_global_vars

(

switch_dial_handle_t *

handle

)

Definition at line 4606 of file switch_ivr_originate.c.

References switch_dial_handle_s::global_vars, and switch_assert.

Referenced by switch_ivr_originate().

{
        switch_assert(handle);
        
        return handle->global_vars;
}

switch_dial_handle_get_peers()

int switch_dial_handle_get_peers	(	switch_dial_handle_t *	handle,
		int	idx,
		char **	array,
		int	max
	)

Definition at line 4578 of file switch_ivr_originate.c.

References switch_dial_leg_s::dial_string, switch_dial_handle_s::leg_lists, and switch_dial_leg_list_s::legs.

Referenced by switch_ivr_originate().

{
        int i, j = 0;

        if (!handle->leg_lists[idx]) return 0;
        
        for (i = 0; i < max && handle->leg_lists[idx]->legs[i]; i++) {
                array[j++] = handle->leg_lists[idx]->legs[i]->dial_string;
        }

        return j;
}

switch_dial_handle_get_total()

int switch_dial_handle_get_total

(

switch_dial_handle_t *

handle

)

Definition at line 4573 of file switch_ivr_originate.c.

References switch_dial_handle_s::leg_list_idx.

Referenced by switch_ivr_originate().

{
        return handle->leg_list_idx;
}

switch_dial_handle_get_vars()

int switch_dial_handle_get_vars	(	switch_dial_handle_t *	handle,
		int	idx,
		switch_event_t **	array,
		int	max
	)

Definition at line 4592 of file switch_ivr_originate.c.

References switch_dial_handle_s::leg_lists, switch_dial_leg_s::leg_vars, and switch_dial_leg_list_s::legs.

Referenced by switch_ivr_originate().

{
        int i, j = 0;

        if (!handle->leg_lists[idx]) return 0;
        
        for (i = 0; i < max && handle->leg_lists[idx]->legs[i]; i++) {
                array[j++] = handle->leg_lists[idx]->legs[i]->leg_vars;
        }

        return j;
}

switch_dial_handle_list_add_global_var()

void switch_dial_handle_list_add_global_var	(	switch_dial_handle_list_t *	hl,
		const char *	var,
		const char *	val
	)

Definition at line 4349 of file switch_ivr_originate.c.

References switch_dial_handle_list_s::global_vars, switch_assert, switch_event_add_header_string(), SWITCH_EVENT_CHANNEL_DATA, switch_event_create_plain(), and SWITCH_STACK_BOTTOM.

Referenced by switch_dial_handle_list_add_global_var_printf(), and switch_dial_handle_list_create_json_obj().

{
        switch_assert(hl);

        if (!hl->global_vars) {
                switch_event_create_plain(&hl->global_vars, SWITCH_EVENT_CHANNEL_DATA);
        }

        switch_event_add_header_string(hl->global_vars, SWITCH_STACK_BOTTOM, var, val);
}

switch_dial_handle_list_add_global_var_printf()

void switch_dial_handle_list_add_global_var_printf	(	switch_dial_handle_list_t *	hl,
		const char *	var,
		const char *	fmt,
			...
	)

Definition at line 4360 of file switch_ivr_originate.c.

References switch_dial_handle_list_add_global_var(), and switch_vasprintf().

{
        int ret = 0;
        char *data = NULL;
        va_list ap;

        va_start(ap, fmt);
        ret = switch_vasprintf(&data, fmt, ap);
        va_end(ap);

        if (ret == -1) {
                abort();
        }

        switch_dial_handle_list_add_global_var(hl, var, data);
        free(data);
}

switch_dial_handle_list_create()

switch_status_t switch_dial_handle_list_create

(

switch_dial_handle_list_t **

hl

)

Definition at line 4291 of file switch_ivr_originate.c.

References pool, switch_dial_handle_list_s::pool, switch_assert, switch_core_alloc, switch_core_new_memory_pool, and SWITCH_STATUS_SUCCESS.

Referenced by switch_dial_handle_list_create_json_obj().

{
        switch_dial_handle_list_t *hlP = NULL;
        switch_memory_pool_t *pool = NULL;

        switch_core_new_memory_pool(&pool);
        switch_assert(pool);

        hlP = switch_core_alloc(pool, sizeof(*hlP));
        switch_assert(hlP);

        hlP->pool = pool;

        *hl = hlP;

        return SWITCH_STATUS_SUCCESS;
}

switch_dial_handle_list_create_handle()

switch_status_t switch_dial_handle_list_create_handle	(	switch_dial_handle_list_t *	hl,
		switch_dial_handle_t **	handle
	)

Definition at line 4318 of file switch_ivr_originate.c.

References switch_dial_handle_list_s::handle_idx, switch_dial_handle_list_s::handles, MAX_PEERS, switch_dial_handle_create(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        switch_dial_handle_t *hp = NULL;
        if (hl->handle_idx < MAX_PEERS && switch_dial_handle_create(&hp) == SWITCH_STATUS_SUCCESS && hp) {
                hl->handles[hl->handle_idx++] = hp;
                *handle = hp;
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_dial_handle_list_create_json()

switch_status_t switch_dial_handle_list_create_json	(	switch_dial_handle_list_t **	handle,
		const char *	handle_string
	)

Definition at line 4878 of file switch_ivr_originate.c.

References switch_dial_handle_list_create_json_obj(), SWITCH_STATUS_FALSE, and zstr.

{
        switch_status_t status;
        cJSON *handle_list_json = NULL;

        if (zstr(handle_list_string)) {
                return SWITCH_STATUS_FALSE;
        }

        handle_list_json = cJSON_Parse(handle_list_string);
        if (!handle_list_json) {
                return SWITCH_STATUS_FALSE;
        }

        status = switch_dial_handle_list_create_json_obj(hl, handle_list_json);
        cJSON_Delete(handle_list_json);
        return status;
}

switch_dial_handle_list_create_json_obj()

switch_status_t switch_dial_handle_list_create_json_obj	(	switch_dial_handle_list_t **	handle,
		cJSON *	json
	)

Definition at line 4828 of file switch_ivr_originate.c.

References cJSON::child, cJSON_ArrayForEach, cJSON_Object, cJSON_String, switch_dial_leg_list_s::handle, MAX_PEERS, cJSON::next, cJSON::string, switch_assert, SWITCH_CHANNEL_LOG, switch_dial_handle_create_json_obj(), switch_dial_handle_destroy(), switch_dial_handle_list_add_global_var(), switch_dial_handle_list_add_handle(), switch_dial_handle_list_create(), switch_dial_handle_list_destroy(), switch_log_printf(), SWITCH_LOG_WARNING, switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, cJSON::type, and cJSON::valuestring.

Referenced by switch_dial_handle_list_create_json().

{
        cJSON *handle_json = NULL;
        cJSON *handles_json = NULL;
        cJSON *vars_json = NULL;

        *hl = NULL;

        handles_json = cJSON_GetObjectItem(handle_list_json, "handles");
        if (!handles_json || !cJSON_IsArray(handles_json)) {
                return SWITCH_STATUS_FALSE;
        }
        switch_dial_handle_list_create(hl);
        switch_assert(*hl);
        for (handle_json = handles_json->child; handle_json; handle_json = handle_json->next) {
                switch_dial_handle_t *handle = NULL;
                if (switch_dial_handle_create_json_obj(&handle, handle_json) == SWITCH_STATUS_SUCCESS && handle) {
                        if (switch_dial_handle_list_add_handle(*hl, handle) != SWITCH_STATUS_SUCCESS) {
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Not adding remaining dial handles: exceeded limit of %d handles\n", MAX_PEERS);
                                switch_dial_handle_destroy(&handle);
                                break;
                        }
                } else {
                        char *handle_json_str = cJSON_PrintUnformatted(handle_json);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to create dial handle: %s\n", handle_json_str);
                        switch_safe_free(handle_json_str);
                }
        }

        if ((*hl)->handle_idx == 0) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Failed to create dial handle list: no handles added!\n");
                switch_dial_handle_list_destroy(hl);
                return SWITCH_STATUS_FALSE;
        }

        vars_json = cJSON_GetObjectItem(handle_list_json, "vars");
        if (vars_json && vars_json->type == cJSON_Object) {
                cJSON *var_json = NULL;
                cJSON_ArrayForEach(var_json, vars_json) {
                        if (!var_json || var_json->type != cJSON_String || !var_json->valuestring || !var_json->string) {
                                continue;
                        }
                        switch_dial_handle_list_add_global_var(*hl, var_json->string, var_json->valuestring);
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_dial_handle_list_destroy()

void switch_dial_handle_list_destroy

(

switch_dial_handle_list_t **

hl

)

Definition at line 4329 of file switch_ivr_originate.c.

References switch_dial_handle_list_s::global_vars, switch_dial_handle_list_s::handle_idx, switch_dial_handle_list_s::handles, pool, switch_dial_handle_list_s::pool, switch_core_destroy_memory_pool, switch_dial_handle_destroy(), and switch_event_destroy().

Referenced by switch_dial_handle_list_create_json_obj().

{
        switch_dial_handle_list_t *hlP = *hl;
        switch_memory_pool_t *pool = NULL;

        *hl = NULL;

        if (hlP) {
                int i;
                for (i = 0; i < hlP->handle_idx; i++) {
                        switch_dial_handle_destroy(&hlP->handles[i]);
                }

                switch_event_destroy(&hlP->global_vars);
                pool = hlP->pool;
                hlP = NULL;
                switch_core_destroy_memory_pool(&pool);
        }
}

switch_dial_handle_list_serialize_json()

switch_status_t switch_dial_handle_list_serialize_json	(	switch_dial_handle_list_t *	hl,
		char **	str
	)

Definition at line 4816 of file switch_ivr_originate.c.

References switch_dial_handle_list_serialize_json_obj(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        cJSON *json = NULL;
        if (switch_dial_handle_list_serialize_json_obj(hl, &json) == SWITCH_STATUS_SUCCESS && json) {
                *str = cJSON_PrintUnformatted(json);
                cJSON_Delete(json);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_dial_handle_list_serialize_json_obj()

switch_status_t switch_dial_handle_list_serialize_json_obj	(	switch_dial_handle_list_t *	hl,
		cJSON **	json
	)

Definition at line 4789 of file switch_ivr_originate.c.

References switch_dial_handle_list_s::global_vars, switch_dial_leg_list_s::handle, switch_dial_handle_list_s::handle_idx, switch_dial_handle_list_s::handles, switch_dial_handle_serialize_json_obj(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and vars_serialize_json_obj().

Referenced by switch_dial_handle_list_serialize_json().

{
        int i;
        cJSON *global_vars_json = NULL;
        cJSON *handles_json = NULL;
        if (!hl) {
                return SWITCH_STATUS_FALSE;
        }
        *json = cJSON_CreateObject();
        if (hl->global_vars && vars_serialize_json_obj(hl->global_vars, &global_vars_json) == SWITCH_STATUS_SUCCESS && global_vars_json) {
                cJSON_AddItemToObject(*json, "vars", global_vars_json);
        }

        handles_json = cJSON_CreateArray();
        cJSON_AddItemToObject(*json, "handles", handles_json);
        for (i = 0; i < hl->handle_idx; i++) {
                switch_dial_handle_t *handle = hl->handles[i];
                cJSON *handle_json = NULL;
                if (switch_dial_handle_serialize_json_obj(handle, &handle_json) == SWITCH_STATUS_SUCCESS && handle_json) {
                        cJSON_AddItemToArray(handles_json, handle_json);
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_dial_handle_serialize_json()

switch_status_t switch_dial_handle_serialize_json	(	switch_dial_handle_t *	handle,
		char **	str
	)

Definition at line 4698 of file switch_ivr_originate.c.

References switch_dial_handle_serialize_json_obj(), SWITCH_STATUS_FALSE, and SWITCH_STATUS_SUCCESS.

{
        cJSON *json = NULL;
        if (switch_dial_handle_serialize_json_obj(handle, &json) == SWITCH_STATUS_SUCCESS && json) {
                *str = cJSON_PrintUnformatted(json);
                cJSON_Delete(json);
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_dial_handle_serialize_json_obj()

switch_status_t switch_dial_handle_serialize_json_obj	(	switch_dial_handle_t *	handle,
		cJSON **	json
	)

Definition at line 4671 of file switch_ivr_originate.c.

References switch_dial_handle_s::global_vars, switch_dial_handle_s::leg_list_idx, leg_list_serialize_json_obj(), switch_dial_handle_s::leg_lists, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and vars_serialize_json_obj().

Referenced by switch_dial_handle_list_serialize_json_obj(), and switch_dial_handle_serialize_json().

{
        int i;
        cJSON *global_vars_json = NULL;
        cJSON *leg_lists_json = NULL;
        if (!handle) {
                return SWITCH_STATUS_FALSE;
        }
        *json = cJSON_CreateObject();
        if (handle->global_vars && vars_serialize_json_obj(handle->global_vars, &global_vars_json) == SWITCH_STATUS_SUCCESS && global_vars_json) {
                cJSON_AddItemToObject(*json, "vars", global_vars_json);
        }

        leg_lists_json = cJSON_CreateArray();
        cJSON_AddItemToObject(*json, "leg_lists", leg_lists_json);
        for (i = 0; i < handle->leg_list_idx; i++) {
                switch_dial_leg_list_t *ll = handle->leg_lists[i];
                cJSON *leg_list_json = NULL;
                if (leg_list_serialize_json_obj(ll, &leg_list_json) == SWITCH_STATUS_SUCCESS && leg_list_json) {
                        cJSON_AddItemToArray(leg_lists_json, leg_list_json);
                }
        }

        return SWITCH_STATUS_SUCCESS;
}

switch_dial_leg_get_var()

const char* switch_dial_leg_get_var	(	switch_dial_leg_t *	leg,
		const char *	key
	)

Definition at line 4620 of file switch_ivr_originate.c.

References switch_dial_leg_s::leg_vars, switch_assert, and switch_event_get_header.

{
        switch_assert(leg);

        return switch_event_get_header(leg->leg_vars, key);
}

switch_dial_leg_get_vars()

switch_event_t* switch_dial_leg_get_vars

(

switch_dial_leg_t *

leg

)

Definition at line 4613 of file switch_ivr_originate.c.

References switch_dial_leg_s::leg_vars, and switch_assert.

{
        switch_assert(leg);
        
        return leg->leg_vars;
}

switch_dial_leg_list_add_leg()

void switch_dial_leg_list_add_leg	(	switch_dial_leg_list_t *	parent,
		switch_dial_leg_t **	legP,
		const char *	dial_string
	)

Definition at line 4491 of file switch_ivr_originate.c.

References switch_dial_leg_s::dial_string, switch_dial_leg_list_s::handle, switch_dial_leg_s::handle, switch_dial_leg_list_s::leg_idx, switch_dial_leg_list_s::legs, switch_dial_handle_s::pool, switch_assert, switch_core_alloc, and switch_core_strdup.

Referenced by switch_dial_handle_create_json_obj(), switch_dial_handle_dup(), and switch_dial_leg_list_add_leg_printf().

{
        switch_dial_leg_t *leg;
        
        switch_assert(parent);

        leg = switch_core_alloc(parent->handle->pool, sizeof(*leg));
        leg->handle = parent->handle;
        leg->dial_string = switch_core_strdup(parent->handle->pool, dial_string);
        
        parent->legs[parent->leg_idx++] = leg;

        if (legP) {
                *legP = leg;
        }
}

switch_dial_leg_list_add_leg_printf()

void switch_dial_leg_list_add_leg_printf	(	switch_dial_leg_list_t *	parent,
		switch_dial_leg_t **	legP,
		const char *	fmt,
			...
	)

Definition at line 4473 of file switch_ivr_originate.c.

References switch_dial_leg_list_add_leg(), and switch_vasprintf().

{
        int ret = 0;
        char *data = NULL;
        va_list ap;

        va_start(ap, fmt);
        ret = switch_vasprintf(&data, fmt, ap);
        va_end(ap);

        if (ret == -1) {
                abort();
        }

        switch_dial_leg_list_add_leg(parent, legP, data);
        free(data);
}

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

Definition at line 4731 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, switch_ivr_dmachine_binding::key, 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_ivr_blind_transfer_ack()

switch_status_t switch_ivr_blind_transfer_ack	(	switch_core_session_t *	session,
		switch_bool_t	success
	)

Definition at line 4418 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_ivr_block_dtmf_session()

switch_status_t switch_ivr_block_dtmf_session

(

switch_core_session_t *

session

)

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

switch_ivr_capture_text()

switch_status_t switch_ivr_capture_text	(	switch_core_session_t *	session,
		switch_bool_t	on
	)

Definition at line 1847 of file switch_ivr_async.c.

References record_helper::bug, SMBF_READ_TEXT_STREAM, switch_channel_get_private(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_private(), switch_core_media_bug_add(), switch_core_media_bug_remove(), switch_core_session_get_channel(), switch_core_session_get_uuid(), SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and text_callback().

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

        bug = (switch_media_bug_t *) switch_channel_get_private(channel, "capture_text");

        if (on) {

                if (bug) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "text bug already attached\n");
                        return SWITCH_STATUS_FALSE;
                }


                if (switch_core_media_bug_add(session, "capture_text", switch_core_session_get_uuid(session),
                                                                          text_callback, NULL, 0,
                                                                          SMBF_READ_TEXT_STREAM,
                                                                          &bug) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot attach bug\n");
                        return SWITCH_STATUS_FALSE;
                }

                switch_channel_set_private(channel, "capture_text", bug);
                return SWITCH_STATUS_SUCCESS;

        } else {

                if (bug) {
                        switch_channel_set_private(channel, "capture_text", NULL);
                        switch_core_media_bug_remove(session, &bug);
                        return SWITCH_STATUS_SUCCESS;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "text bug not attached\n");
                        return SWITCH_STATUS_FALSE;
                }

        }
}

switch_ivr_check_presence_mapping()

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

Definition at line 4340 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_ivr_create_message_reply()

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

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

switch_ivr_delay_echo()

void switch_ivr_delay_echo	(	switch_core_session_t *	session,
		uint32_t	delay_ms
	)

Definition at line 3579 of file switch_ivr.c.

References switch_rtp_packet_t::body, switch_frame::buflen, switch_frame::codec, switch_frame::data, switch_frame::datalen, debug, 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_ivr_dmachine_bind()

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

Definition at line 255 of file switch_ivr_async.c.

References switch_ivr_dmachine::binding_hash, dm_binding_head_t::binding_list, switch_ivr_dmachine_binding::callback, switch_ivr_dmachine_binding::digits, DMACHINE_MAX_DIGIT_LEN, switch_ivr_dmachine_binding::first_match, switch_ivr_dmachine_binding::is_priority, switch_ivr_dmachine_binding::is_regex, switch_ivr_dmachine_binding::key, switch_ivr_dmachine::max_digit_len, dm_binding_head_t::name, switch_ivr_dmachine::name, switch_ivr_dmachine_binding::next, switch_ivr_dmachine::pool, switch_ivr_dmachine::realm, switch_ivr_dmachine_binding::repl, 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 = "";
        char *repl = NULL;
        char *digits_;

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

        digits_ = switch_core_strdup(dmachine->pool, digits);

        if (*digits_ == '=') {
                binding->first_match = 1;
                digits_++;
        }
        
        if (*digits_ == '~') {
                binding->is_regex = 1;
                digits_++;
                if ((repl = strchr(digits_, '~')) && *(repl+1) == '~') {
                        *repl++ = '\0';
                        *repl++ = '\0';
                }
        }

        binding->key = key;
        binding->digits = digits_;
        binding->is_priority = is_priority;
        binding->callback = callback;
        binding->user_data = user_data;
        binding->repl = repl;

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

switch_status_t switch_ivr_dmachine_clear

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 692 of file switch_ivr_async.c.

References switch_ivr_dmachine::cur_digit_len, switch_ivr_dmachine::digits, switch_ivr_dmachine::last_digit_time, 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_ivr_dmachine_clear_realm()

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

Definition at line 231 of file switch_ivr_async.c.

References switch_ivr_dmachine::binding_hash, switch_ivr_dmachine::name, switch_ivr_dmachine::realm, 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_ivr_dmachine_create()

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 132 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, switch_ivr_dmachine_binding::user_data, 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;
}

switch_ivr_dmachine_destroy()

void switch_ivr_dmachine_destroy

(

switch_ivr_dmachine_t **

dmachine

)

Definition at line 186 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_ivr_dmachine_feed()

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

Definition at line 654 of file switch_ivr_async.c.

References switch_ivr_dmachine::cur_digit_len, switch_ivr_dmachine::digits, switch_ivr_dmachine::last_digit_time, switch_ivr_dmachine::max_digit_len, switch_ivr_dmachine::mutex, 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_event(), 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;
}

switch_ivr_dmachine_get_failed_digits()

const char* switch_ivr_dmachine_get_failed_digits

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 527 of file switch_ivr_async.c.

References switch_ivr_dmachine::last_failed_digits.

{

        return dmachine->last_failed_digits;
}

switch_ivr_dmachine_get_match()

switch_ivr_dmachine_match_t* switch_ivr_dmachine_get_match

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 517 of file switch_ivr_async.c.

References switch_ivr_dmachine::is_match, and switch_ivr_dmachine::match.

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

        return NULL;
}

switch_ivr_dmachine_get_name()

const char* switch_ivr_dmachine_get_name

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 127 of file switch_ivr_async.c.

References switch_ivr_dmachine::name.

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

switch_ivr_dmachine_is_parsing()

switch_bool_t switch_ivr_dmachine_is_parsing

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 687 of file switch_ivr_async.c.

References switch_ivr_dmachine::cur_digit_len.

Referenced by switch_ivr_play_file().

{
        return !!dmachine->cur_digit_len;
}

switch_ivr_dmachine_last_ping()

switch_status_t switch_ivr_dmachine_last_ping

(

switch_ivr_dmachine_t *

dmachine

)

Definition at line 93 of file switch_ivr_async.c.

References switch_ivr_dmachine::last_return.

Referenced by switch_ivr_play_and_collect_input(), and switch_ivr_play_and_detect_speech().

{
        return dmachine->last_return;
}

switch_ivr_dmachine_ping()

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

Definition at line 533 of file switch_ivr_async.c.

References switch_ivr_dmachine_binding::callback, switch_ivr_dmachine::cur_digit_len, switch_ivr_dmachine::digits, DM_MATCH_BOTH, DM_MATCH_EXACT, DM_MATCH_NEGATIVE, DM_MATCH_NEVER, DM_MATCH_NONE, DM_MATCH_POSITIVE, switch_ivr_dmachine::is_match, switch_ivr_dmachine_binding::key, switch_ivr_dmachine::last_failed_digits, switch_ivr_dmachine::last_matching_binding, switch_ivr_dmachine::last_matching_digits, switch_ivr_dmachine::last_return, switch_ivr_dmachine::match, switch_ivr_dmachine::match_callback, switch_ivr_dmachine_match::match_digits, switch_ivr_dmachine_match::match_key, switch_ivr_dmachine::max_digit_len, switch_ivr_dmachine::mutex, switch_ivr_dmachine::nonmatch_callback, switch_ivr_dmachine::pinging, 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, switch_ivr_dmachine_match::type, switch_ivr_dmachine_binding::user_data, switch_ivr_dmachine::user_data, switch_ivr_dmachine_match::user_data, 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_event(), 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) {
                switch_mutex_unlock(dmachine->mutex);
                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;
}

switch_ivr_dmachine_set_digit_timeout_ms()

void switch_ivr_dmachine_set_digit_timeout_ms	(	switch_ivr_dmachine_t *	dmachine,
		uint32_t	digit_timeout_ms
	)

Definition at line 176 of file switch_ivr_async.c.

References switch_ivr_dmachine::digit_timeout_ms.

{
        dmachine->digit_timeout_ms = digit_timeout_ms;
}

switch_ivr_dmachine_set_input_timeout_ms()

void switch_ivr_dmachine_set_input_timeout_ms	(	switch_ivr_dmachine_t *	dmachine,
		uint32_t	input_timeout_ms
	)

Definition at line 181 of file switch_ivr_async.c.

References switch_ivr_dmachine::input_timeout_ms.

{
        dmachine->input_timeout_ms = input_timeout_ms;
}

switch_ivr_dmachine_set_match_callback()

void switch_ivr_dmachine_set_match_callback	(	switch_ivr_dmachine_t *	dmachine,
		switch_ivr_dmachine_callback_t	match_callback
	)

Definition at line 111 of file switch_ivr_async.c.

References switch_ivr_dmachine::match_callback, and switch_assert.

{

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

}

switch_ivr_dmachine_set_nonmatch_callback()

void switch_ivr_dmachine_set_nonmatch_callback	(	switch_ivr_dmachine_t *	dmachine,
		switch_ivr_dmachine_callback_t	nonmatch_callback
	)

Definition at line 119 of file switch_ivr_async.c.

References switch_ivr_dmachine::nonmatch_callback, and switch_assert.

{

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

}

switch_ivr_dmachine_set_realm()

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

Definition at line 216 of file switch_ivr_async.c.

References switch_ivr_dmachine::binding_hash, switch_ivr_dmachine::name, switch_ivr_dmachine::realm, 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_ivr_enterprise_orig_and_bridge()

switch_status_t switch_ivr_enterprise_orig_and_bridge	(	switch_core_session_t *	session,
		const char *	data,
		switch_dial_handle_list_t *	hl,
		switch_call_cause_t *	cause
	)

Definition at line 4912 of file switch_ivr_originate.c.

References CF_BYPASS_MEDIA_AFTER_BRIDGE, CF_PROXY_MODE, fail, o_bridge_on_dtmf(), SOF_NONE, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE, switch_channel_cause2str(), switch_channel_get_variable, switch_channel_handle_cause(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_rwunlock(), switch_core_session_strdup, switch_ivr_enterprise_originate(), switch_ivr_multi_threaded_bridge(), switch_ivr_signal_bridge(), SWITCH_LOG_INFO, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_true().

{
        switch_channel_t *caller_channel = switch_core_session_get_channel(session);
        switch_core_session_t *peer_session = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int fail = 0;

        if ((status = switch_ivr_enterprise_originate(session,
                                                                           &peer_session,
                                                                           cause, data, 0, NULL, NULL, NULL, NULL, NULL, SOF_NONE, NULL, hl)) != SWITCH_STATUS_SUCCESS) {
                fail = 1;
        }


        if (fail) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Originate Failed.  Cause: %s\n", switch_channel_cause2str(*cause));

                switch_channel_set_variable(caller_channel, "originate_failed_cause", switch_channel_cause2str(*cause));

                switch_channel_handle_cause(caller_channel, *cause);

                return status;
        } else {
                switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);

                if (switch_true(switch_channel_get_variable(caller_channel, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE)) ||
                        switch_true(switch_channel_get_variable(peer_channel, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE))) {
                        switch_channel_set_flag(caller_channel, CF_BYPASS_MEDIA_AFTER_BRIDGE);
                }

                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                        switch_ivr_signal_bridge(session, peer_session);
                } else {
                        char *a_key = (char *) switch_channel_get_variable(caller_channel, "bridge_terminate_key");
                        char *b_key = (char *) switch_channel_get_variable(peer_channel, "bridge_terminate_key");
                        int ok = 0;
                        switch_input_callback_function_t func = NULL;

                        if (a_key) {
                                a_key = switch_core_session_strdup(session, a_key);
                                ok++;
                        }
                        if (b_key) {
                                b_key = switch_core_session_strdup(session, b_key);
                                ok++;
                        }
                        if (ok) {
                                func = o_bridge_on_dtmf;
                        } else {
                                a_key = NULL;
                                b_key = NULL;
                        }

                        switch_ivr_multi_threaded_bridge(session, peer_session, func, a_key, b_key);
                }

                switch_core_session_rwunlock(peer_session);
        }

        return status;
}

switch_ivr_find_bridged_uuid()

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

Definition at line 2234 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_ivr_get_file_handle()

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

Definition at line 1214 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_ivr_get_say_gender_by_name()

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

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

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

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

switch_ivr_intercept_session()

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

Definition at line 2257 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_set_variable_partner, 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_SIGNAL_BOND_VARIABLE, SWITCH_STATUS_FALSE, 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] = "";
        switch_status_t status = SWITCH_STATUS_FALSE;

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

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

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

        if (zstr(buuid) || !strcasecmp(buuid, switch_core_session_get_uuid(session))) {
                buuid = NULL;
        }

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

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

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

        if ((var = switch_channel_get_variable(channel, "intercept_pre_bond")) && switch_true(var)) {
                switch_channel_set_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE, uuid);
                switch_channel_set_variable_partner(channel, SWITCH_SIGNAL_BOND_VARIABLE, switch_core_session_get_uuid(session));
        }

        switch_channel_set_flag(rchannel, CF_INTERCEPTED);
        status = 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);
        }

        return status;

}

switch_ivr_kill_uuid()

switch_status_t switch_ivr_kill_uuid	(	const char *	uuid,
		switch_call_cause_t	cause
	)

Definition at line 4404 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_ivr_menu_bind_action()

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 245 of file switch_ivr_menu.c.

References actions, switch_ivr_menu_action::arg, switch_ivr_menu_action::bind, inlen, switch_ivr_menu_action::ivr_action, switch_ivr_menu_action::next, pool, 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_ivr_menu_bind_function()

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 276 of file switch_ivr_menu.c.

References actions, switch_ivr_menu_action::arg, switch_ivr_menu_action::bind, switch_ivr_menu_action::function, inlen, switch_ivr_menu_action::next, pool, 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_ivr_menu_execute()

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 451 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, stack_count, switch_assert, 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;

        switch_assert(stack);

        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 || 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")) {
                                                                                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_ivr_menu_init()

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, digit_len, exit_sound, greeting_sound, inlen, inter_timeout, invalid_sound, max_failures, max_timeouts, name, 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_ivr_menu_stack_free()

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 310 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_ivr_menu_stack_xml_add_custom()

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 843 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_ivr_menu_stack_xml_build()

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 849 of file switch_ivr_menu.c.

References switch_ivr_menu_xml_map::action, switch_ivr_menu_xml_ctx::autocreated, bad_pin_file, confirm_attempts, confirm_key, confirm_macro, digit_len, exec_on_max_fail, exec_on_max_timeout, exit_sound, switch_ivr_menu_xml_map::function, inter_timeout, invalid_sound, is_valid_action(), switch_ivr_menu_xml_ctx::map, max_failures, max_timeouts, switch_ivr_menu_xml_map::name, switch_xml::next, switch_ivr_menu_xml_map::next, pin, pool, switch_ivr_menu_xml_ctx::pool, prompt_pin_file, switch_assert, 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(), timeout, transfer_sound, tts_engine, tts_voice, 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);

                switch_assert(menu);

                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) {
                        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_ivr_menu_stack_xml_init()

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 808 of file switch_ivr_menu.c.

References iam, name, 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_ivr_menu_str2action()

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

Definition at line 768 of file switch_ivr_menu.c.

References iam_s::action, iam, name, 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;
}

switch_ivr_orig_and_bridge()

switch_status_t switch_ivr_orig_and_bridge	(	switch_core_session_t *	session,
		const char *	data,
		switch_dial_handle_t *	dh,
		switch_call_cause_t *	cause
	)

Definition at line 4975 of file switch_ivr_originate.c.

References CF_BYPASS_MEDIA_AFTER_BRIDGE, CF_PROXY_MODE, fail, o_bridge_on_dtmf(), SOF_NONE, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE, switch_channel_cause2str(), switch_channel_get_variable, switch_channel_handle_cause(), SWITCH_CHANNEL_SESSION_LOG, switch_channel_set_flag, switch_channel_set_variable, switch_channel_test_flag(), switch_core_session_get_channel(), switch_core_session_rwunlock(), switch_core_session_strdup, switch_ivr_multi_threaded_bridge(), switch_ivr_originate(), switch_ivr_signal_bridge(), SWITCH_LOG_INFO, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, and switch_true().

{
        switch_channel_t *caller_channel = switch_core_session_get_channel(session);
        switch_core_session_t *peer_session = NULL;
        switch_status_t status = SWITCH_STATUS_FALSE;
        int fail = 0;
        
        if ((status = switch_ivr_originate(session,
                                                                           &peer_session,
                                                                           cause, data, 0, NULL, NULL, NULL, NULL, NULL, SOF_NONE, NULL, dh)) != SWITCH_STATUS_SUCCESS) {
                fail = 1;
        }


        if (fail) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Originate Failed.  Cause: %s\n", switch_channel_cause2str(*cause));
                
                switch_channel_set_variable(caller_channel, "originate_failed_cause", switch_channel_cause2str(*cause));

                switch_channel_handle_cause(caller_channel, *cause);

                return status;
        } else {
                switch_channel_t *peer_channel = switch_core_session_get_channel(peer_session);

                if (switch_true(switch_channel_get_variable(caller_channel, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE)) ||
                        switch_true(switch_channel_get_variable(peer_channel, SWITCH_BYPASS_MEDIA_AFTER_BRIDGE_VARIABLE))) {
                        switch_channel_set_flag(caller_channel, CF_BYPASS_MEDIA_AFTER_BRIDGE);
                }

                if (switch_channel_test_flag(caller_channel, CF_PROXY_MODE)) {
                        switch_ivr_signal_bridge(session, peer_session);
                } else {
                        char *a_key = (char *) switch_channel_get_variable(caller_channel, "bridge_terminate_key");
                        char *b_key = (char *) switch_channel_get_variable(peer_channel, "bridge_terminate_key");
                        int ok = 0;
                        switch_input_callback_function_t func = NULL;

                        if (a_key) {
                                a_key = switch_core_session_strdup(session, a_key);
                                ok++;
                        }
                        if (b_key) {
                                b_key = switch_core_session_strdup(session, b_key);
                                ok++;
                        }
                        if (ok) {
                                func = o_bridge_on_dtmf;
                        } else {
                                a_key = NULL;
                                b_key = NULL;
                        }

                        switch_ivr_multi_threaded_bridge(session, peer_session, func, a_key, b_key);
                }

                switch_core_session_rwunlock(peer_session);
        }

        return status;
}

switch_ivr_park_session()

void switch_ivr_park_session

(

switch_core_session_t *

session

)

Definition at line 3571 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_flag(channel, CF_TRANSFER);
        switch_channel_set_state(channel, CS_PARK);

}

switch_ivr_phrase_macro_event()

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, name, 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_is_number(), 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_normalize_volume_granular, 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, switch_file_handle::volgranular, 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")) {
                                        char *volume_str = (char *) switch_xml_attr_soft(action, "volume");
                                        switch_file_handle_t pfh = { 0 };
                                        if (volume_str && switch_is_number(volume_str)) {
                                                int32_t volume = atoi(volume_str);

                                                switch_normalize_volume_granular(volume)
                                                pfh.volgranular = volume;

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Setting playback volume to %d\n", pfh.volgranular);
                                        }
                                        status = switch_ivr_play_file(session, &pfh, 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_ivr_play_and_collect_input()

switch_status_t switch_ivr_play_and_collect_input	(	switch_core_session_t *	session,
		const char *	prompt,
		const char *	recognizer_mod_name,
		const char *	recognizer_grammar,
		int	min_digits,
		int	max_digits,
		const char *	terminators,
		uint32_t	digit_timeout,
		cJSON **	recognition_result,
		char **	digits_collected,
		char *	terminator_collected,
		switch_input_args_t *	args
	)

Play prompt and collect input.

Returns collect status

Parameters

[in]

session

the current session

Returns

Returns status SWITCH_STATUS_SUCCESS when success SWITCH_STATUS_FALSE when error SWITCH_STATUS_GENERR when error

Definition at line 3411 of file switch_ivr_play_say.c.

References arg_recursion_check_start, arg_recursion_check_stop, switch_input_args_t::buf, switch_input_args_t::buflen, switch_collect_input_state_t::digits, switch_input_args_t::dmachine, switch_input_args_t::input_callback, switch_collect_input_state_t::is_speech, switch_collect_input_state_t::last_digit_time, switch_collect_input_state_t::max_digits, switch_collect_input_state_t::min_digits, switch_collect_input_state_t::original_args, switch_input_args_t::read_frame_callback, switch_collect_input_state_t::recognition_result, switch_channel_get_name(), switch_channel_ready, SWITCH_CHANNEL_SESSION_LOG, switch_clear_flag, switch_collect_input_callback(), SWITCH_COLLECT_INPUT_DIGITS, SWITCH_COLLECT_INPUT_DIGITS_DONE, SWITCH_COLLECT_INPUT_PROMPT, SWITCH_COLLECT_INPUT_SPEECH, SWITCH_COLLECT_INPUT_SPEECH_DONE, switch_core_session_alloc, switch_core_session_get_channel(), SWITCH_FALSE, SWITCH_INT64_T_FMT, switch_ivr_detect_speech(), switch_ivr_detect_speech_start_input_timers(), switch_ivr_dmachine_last_ping(), switch_ivr_pause_detect_speech(), switch_ivr_play_file(), switch_ivr_sleep(), SWITCH_LOG_DEBUG, SWITCH_LOG_INFO, switch_log_printf(), switch_micro_time_now(), switch_set_flag, SWITCH_STATUS_BREAK, SWITCH_STATUS_FALSE, SWITCH_STATUS_GENERR, SWITCH_STATUS_SUCCESS, switch_test_flag, switch_collect_input_state_t::terminator, switch_collect_input_state_t::terminators, switch_input_args_t::user_data, and zstr.

{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_input_args_t myargs = { 0 };
        switch_collect_input_state_t state = { 0 };
        switch_channel_t *channel = switch_core_session_get_channel(session);

        arg_recursion_check_start(args);

        /* configure digit collection */
        if (digit_timeout <= 0) digit_timeout = 5000;
        if (min_digits < 0) {
                min_digits = 0;
        }

        /* check if digit collection is enabled */
        if (min_digits > 0) {
                if (max_digits < min_digits) {
                        max_digits = min_digits;
                }
                if (max_digits > 100) {
                        max_digits = 100;
                }
                state.digits = switch_core_session_alloc(session, sizeof(char) * (max_digits + 1));
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_DIGITS);
        } else {
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE);
        }

        state.min_digits = min_digits;
        state.max_digits = max_digits;
        if (!zstr(terminators)) {
                if (!strcasecmp(terminators, "any")) {
                        state.terminators = "1234567890*#";
                } else if (!strcasecmp(terminators, "none")) {
                        state.terminators = NULL;
                } else {
                        state.terminators = terminators;
                }
        }

        /* start speech recognition, if enabled */
        if (recognizer_grammar && recognizer_mod_name) {
                if ((status = switch_ivr_detect_speech(session, recognizer_mod_name, recognizer_grammar, "", NULL, NULL)) != SWITCH_STATUS_SUCCESS) {
                        /* map SWITCH_STATUS_FALSE to SWITCH_STATUS_GENERR to indicate grammar load failed
                        SWITCH_STATUS_NOT_INITALIZED will be passed back to indicate ASR resource problem */
                        if (status == SWITCH_STATUS_FALSE) {
                                status = SWITCH_STATUS_GENERR;
                        }
                        goto done;
                }
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_SPEECH);
        } else {
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
        }

        /* play the prompt, looking for input result */

        if (args) {
                state.original_args = args;
                myargs.dmachine = args->dmachine;
                myargs.read_frame_callback = args->read_frame_callback;
                myargs.user_data = args->user_data;
        }

        myargs.input_callback = switch_collect_input_callback;
        myargs.buf = &state;
        myargs.buflen = sizeof(state);

        switch_set_flag(&state, SWITCH_COLLECT_INPUT_PROMPT);
        status = switch_ivr_play_file(session, NULL, prompt, &myargs);
        switch_clear_flag(&state, SWITCH_COLLECT_INPUT_PROMPT);

        if (args && args->dmachine && switch_ivr_dmachine_last_ping(args->dmachine) != SWITCH_STATUS_SUCCESS) {
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE);
                switch_set_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
                status = SWITCH_STATUS_SUCCESS;
        }

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

        // wait for final result if not done
        if (!switch_test_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE) || !switch_test_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE)) {
                int sleep_time = digit_timeout;

                if (switch_test_flag(&state, SWITCH_COLLECT_INPUT_SPEECH)) {
                        switch_ivr_detect_speech_start_input_timers(session);
                }
                state.last_digit_time = switch_micro_time_now();

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "(%s) WAITING FOR RESULT\n", switch_channel_get_name(channel));

                while ((!switch_test_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE) || !switch_test_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE))
                           && switch_channel_ready(channel)) {

                        status = switch_ivr_sleep(session, sleep_time, SWITCH_FALSE, &myargs);

                        if (args && args->dmachine && switch_ivr_dmachine_last_ping(args->dmachine) != SWITCH_STATUS_SUCCESS) {
                                // dmachine done
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "(%s) DMACHINE DONE\n", switch_channel_get_name(channel));
                                switch_set_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE);
                                switch_set_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
                                status = SWITCH_STATUS_SUCCESS;
                                goto done;
                        }

                        if (state.terminator != 0) {
                                switch_set_flag(&state, SWITCH_COLLECT_INPUT_SPEECH_DONE);
                                status = SWITCH_STATUS_SUCCESS;
                                sleep_time = digit_timeout;
                                continue;
                        }

                        if (state.is_speech == SWITCH_FALSE) {

                                // calculating how much time has elapsed since the last digit was collected
                                sleep_time = (switch_micro_time_now() - state.last_digit_time) / 1000;

                                if (sleep_time >= digit_timeout) {
                                        // too much time since last digit
                                        if (!switch_test_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, " (%s) INTER-DIGIT TIMEOUT is_speech = false; sleep_time >= digit_timeout; sleep_time=%i; last_digit_time=%" SWITCH_INT64_T_FMT "; digit_timeout=%lu \n", switch_channel_get_name(channel), sleep_time, state.last_digit_time, (unsigned long)digit_timeout);
                                                switch_set_flag(&state, SWITCH_COLLECT_INPUT_DIGITS_DONE);
                                        } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "\nis_speech = false; sleep_time >= digit_timeout; sleep_time=%i; last_digit_time=%" SWITCH_INT64_T_FMT "; digit_timeout=%lu \n", sleep_time, state.last_digit_time, (unsigned long)digit_timeout);
                                        }
                                        status = SWITCH_STATUS_SUCCESS;
                                        sleep_time = digit_timeout;
                                } else {                
                                        // woke up early, sleep for remaining digit timeout
                                        sleep_time = digit_timeout - sleep_time;
                                }
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "\nis_speech = true; sleep_time < digit_timeout; sleep_time=%i; last_digit_time=%" SWITCH_INT64_T_FMT "; digit_timeout=%lu \n", sleep_time, state.last_digit_time, (unsigned long)digit_timeout);
                        }

                        if (status != SWITCH_STATUS_BREAK && status != SWITCH_STATUS_SUCCESS) {
                                // error of some sort
                                status = SWITCH_STATUS_FALSE;
                                goto done;
                        }

                }
        }

done:

        if (status == SWITCH_STATUS_BREAK) {
                status = SWITCH_STATUS_SUCCESS;
        }

        if (switch_test_flag(&state, SWITCH_COLLECT_INPUT_SPEECH)) {
                switch_ivr_pause_detect_speech(session);
        }

        if (!zstr(state.digits) && strlen(state.digits) >= state.min_digits) {
                /* got DTMF result */
                if (digits_collected) {
                        *digits_collected = state.digits;
                }

                if (state.recognition_result) {
                        cJSON_Delete(state.recognition_result);
                }
        } else if (state.recognition_result) {
                /* have some kind of recognition result or error */
                if (recognition_result) {
                        *recognition_result = state.recognition_result;
                } else {
                        cJSON_Delete(state.recognition_result);
                }
        }

        if (terminator_collected && state.terminator != 0) {
                *terminator_collected = state.terminator;
        }

        arg_recursion_check_stop(args);

        return status;
}

switch_ivr_process_fh()

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

Definition at line 4052 of file switch_ivr.c.

References if(), switch_file_handle::native_rate, switch_file_handle::offset_pos, SCFC_PAUSE_READ, switch_file_handle::speed, 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, target, switch_file_handle::vol, 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_ivr_read()

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 2502 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_ivr_record_session_mask()

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

Definition at line 1888 of file switch_ivr_async.c.

References record_helper::bug, 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_ivr_record_session_pause()

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

Definition at line 1904 of file switch_ivr_async.c.

References record_helper::bug, SMBF_PAUSE, 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_PAUSE);
                } else {
                        switch_core_media_bug_clear_flag(bug, SMBF_PAUSE);
                }
                return SWITCH_STATUS_SUCCESS;
        }
        return SWITCH_STATUS_FALSE;
}

switch_ivr_release_file_handle()

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

Definition at line 1232 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_ivr_say()

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 3667 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_ivr_say_ip()

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, b, switch_say_args_t::method, 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_ivr_say_spell()

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, SWITCH_STATUS_SUCCESS, and switch_say_args_t::type.

{
        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_ivr_say_string()

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 3789 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_ivr_send_prompt()

switch_status_t switch_ivr_send_prompt	(	switch_core_session_t *	session,
		const char *	type,
		const char *	text,
		const char *	regex
	)

Definition at line 1510 of file switch_ivr.c.

References switch_core_session_message::from, switch_core_session_message::message_id, switch_core_session_message::string_array_arg, switch_core_session_receive_message, SWITCH_MESSAGE_INDICATE_PROMPT, and SWITCH_STATUS_SUCCESS.

{
        switch_core_session_message_t msg = { 0 };
        
        msg.message_id = SWITCH_MESSAGE_INDICATE_PROMPT;
        msg.string_array_arg[0] = type;
        msg.string_array_arg[1] = text;
        msg.string_array_arg[2] = regex;
        msg.from = __FILE__;

        switch_core_session_receive_message(session, &msg);

        return SWITCH_STATUS_SUCCESS;
}

switch_ivr_set_user()

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

Definition at line 3976 of file switch_ivr.c.

References switch_ivr_set_user_extended().

{
        return switch_ivr_set_user_extended(session, data, NULL);
}

switch_ivr_set_user_extended()

switch_status_t switch_ivr_set_user_extended	(	switch_core_session_t *	session,
		const char *	data,
		switch_event_t *	params
	)

Definition at line 3981 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.

Referenced by switch_ivr_set_user().

{
        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, params) != 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_ivr_set_user_xml()

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

{
        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_ivr_soft_hold()

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 3198 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 };
        switch_status_t res;

        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")) {
                                res = switch_ivr_play_file(session, NULL, moh, &args);
                        } else {
                                res = switch_ivr_collect_digits_callback(session, &args, 0, 0);
                        }

                        (void)res;

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

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

switch_status_t switch_ivr_stop_video_write_overlay_session

(

switch_core_session_t *

session

)

Definition at line 5821 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_ivr_unbind_dtmf_meta_session()

switch_status_t switch_ivr_unbind_dtmf_meta_session	(	switch_core_session_t *	session,
		uint32_t	key
	)

Definition at line 4669 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_ivr_unblock_dtmf_session()

switch_status_t switch_ivr_unblock_dtmf_session

(

switch_core_session_t *

session

)

Definition at line 4705 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_ivr_uuid_exists()

switch_bool_t switch_ivr_uuid_exists

(

const char *

uuid

)

Definition at line 4026 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_ivr_uuid_force_exists()

switch_bool_t switch_ivr_uuid_force_exists

(

const char *

uuid

)

Definition at line 4039 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_ivr_video_write_overlay_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
	)

Definition at line 5835 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_ivr_wait_for_answer()

switch_status_t switch_ivr_wait_for_answer	(	switch_core_session_t *	session,
		switch_core_session_t *	peer_session
	)

Definition at line 943 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_DEFAULT_TIMEOUT, 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 = SWITCH_DEFAULT_TIMEOUT;
        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 = SWITCH_DEFAULT_TIMEOUT;
                }
        }

        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 (!write_frame.codec) {
                                status = SWITCH_STATUS_FALSE;
                                break;
                        }

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

switch_process_import()

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

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