switch_ivr_menu.c File Reference

#include <switch.h>

Include dependency graph for switch_ivr_menu.c:

Go to the source code of this file.

Data Structures
struct	switch_ivr_menu
struct	switch_ivr_menu_action
struct	switch_ivr_menu_xml_map
struct	switch_ivr_menu_xml_ctx
struct	iam_s

Macros
#define	MENU_EVENT_ENTER   "menu::enter"
#define	MENU_EVENT_EXIT   "menu::exit"

Typedefs
typedef struct switch_ivr_menu_xml_map	switch_ivr_menu_xml_map_t

Functions
static void	ivr_send_event (switch_core_session_t *session, char *event_type, switch_ivr_menu_t *menu)
static switch_ivr_menu_t *	switch_ivr_menu_find (switch_ivr_menu_t *stack, const char *name)
static void	switch_ivr_menu_stack_add (switch_ivr_menu_t **top, switch_ivr_menu_t *bottom)
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_stack_free (switch_ivr_menu_t *stack)
	free a stack of menu objects. More...
static switch_status_t	play_and_collect (switch_core_session_t *session, switch_ivr_menu_t *menu, char *sound, switch_size_t need)
static void	exec_app (switch_core_session_t *session, char *app_str)
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...
static switch_ivr_menu_xml_map_t *	switch_ivr_menu_stack_xml_find (switch_ivr_menu_xml_ctx_t *xml_ctx, const char *name)
static switch_status_t	switch_ivr_menu_stack_xml_add (switch_ivr_menu_xml_ctx_t *xml_ctx, const char *name, int action, switch_ivr_menu_action_function_t *function)
switch_status_t	switch_ivr_menu_str2action (const char *action_name, switch_ivr_action_t *action)
static switch_bool_t	is_valid_action (const char *action)
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_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_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...

Variables
static struct iam_s	iam []

Macro Definition Documentation

MENU_EVENT_ENTER

#define MENU_EVENT_ENTER   "menu::enter"

Definition at line 78 of file switch_ivr_menu.c.

Referenced by switch_ivr_menu_execute().

MENU_EVENT_EXIT

#define MENU_EVENT_EXIT   "menu::exit"

Definition at line 79 of file switch_ivr_menu.c.

Referenced by switch_ivr_menu_execute().

Typedef Documentation

switch_ivr_menu_xml_map_t

typedef struct switch_ivr_menu_xml_map switch_ivr_menu_xml_map_t

Function Documentation

exec_app()

static void exec_app ( switch_core_session_t *  session, char *  app_str  )

static

Definition at line 430 of file switch_ivr_menu.c.

References switch_channel_expand_variables, switch_core_session_execute_application, switch_core_session_get_channel(), and switch_core_session_strdup.

Referenced by audio_bridge_thread(), record_callback(), send_record_stop_event(), and switch_ivr_menu_execute().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char *app = switch_core_session_strdup(session, app_str);
        char *data = strchr(app, ' ');
        char *expanded = NULL;

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

        expanded = switch_channel_expand_variables(channel, data);

        switch_core_session_execute_application(session, app, expanded);

        if (expanded && expanded != data) {
                free(expanded);
        }

}

is_valid_action()

static switch_bool_t is_valid_action ( const char *  action )

static

Definition at line 788 of file switch_ivr_menu.c.

References iam, switch_ivr_menu::name, SWITCH_CHANNEL_LOG, SWITCH_FALSE, switch_log_printf(), SWITCH_LOG_WARNING, switch_str_nil, SWITCH_TRUE, and zstr.

Referenced by switch_ivr_menu_stack_xml_build().

{
        int i;

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

                        if (!strcmp(iam[i].name, action)) {
                                return SWITCH_TRUE;
                        }
                }
        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid Action [%s]\n", switch_str_nil(action));
        return SWITCH_FALSE;
}

ivr_send_event()

static void ivr_send_event ( switch_core_session_t *  session, char *  event_type, switch_ivr_menu_t *  menu  )

static

Definition at line 81 of file switch_ivr_menu.c.

References switch_ivr_menu::name, switch_channel_event_set_data(), switch_core_session_get_channel(), switch_event_add_header_string(), switch_event_create_subclass, SWITCH_EVENT_CUSTOM, switch_event_fire, SWITCH_STACK_BOTTOM, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_menu_execute().

{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_event_t *event = NULL;
        if (switch_event_create_subclass(&event, SWITCH_EVENT_CUSTOM, event_type) == SWITCH_STATUS_SUCCESS) {
                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Menu-Name", menu->name);
                switch_channel_event_set_data(channel, event);
                switch_event_fire(&event);
        }
}

play_and_collect()

static switch_status_t play_and_collect ( switch_core_session_t *  session, switch_ivr_menu_t *  menu, char *  sound, switch_size_t  need  )

static

Definition at line 327 of file switch_ivr_menu.c.

References switch_ivr_menu::buf, switch_input_args_t::buf, switch_input_args_t::buflen, switch_ivr_menu::confirm_attempts, switch_ivr_menu::confirm_key, switch_ivr_menu::confirm_macro, switch_ivr_menu::inlen, switch_ivr_menu::inter_timeout, memset(), switch_ivr_menu::ptr, switch_channel_expand_variables, switch_channel_get_variable, SWITCH_CHANNEL_SESSION_LOG, switch_core_session_get_channel(), switch_ivr_collect_digits_count(), switch_ivr_phrase_macro, switch_ivr_play_file(), SWITCH_LOG_DEBUG, switch_log_printf(), switch_safe_free, SWITCH_STATUS_FALSE, SWITCH_STATUS_SUCCESS, switch_ivr_menu::timeout, and zstr.

Referenced by switch_ivr_menu_execute().

{
        char terminator;
        uint32_t len;
        char *ptr;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_input_args_t args = { 0 };
        switch_channel_t *channel;
        char *sound_expanded = sound;
        switch_size_t menu_buf_len = 0;
        const char *terminator_str = "#";

        if (!session || !menu || zstr(sound)) {
                return status;
        }

        if ((channel = switch_core_session_get_channel(session))) {
                const char *tmp;
                sound_expanded = switch_channel_expand_variables(channel, sound);
                if ((tmp = switch_channel_get_variable(channel, "ivr_menu_terminator")) && !zstr(tmp)) {
                        terminator_str = tmp;
                }
        }

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

        if (!need) {
                len = 1;
                ptr = NULL;
        } else {
                len = (uint32_t) menu->inlen + 1;
                ptr = menu->ptr;
        }
        args.buf = ptr;
        args.buflen = len;

        status = switch_ivr_play_file(session, NULL, sound_expanded, &args);

        if (sound_expanded != sound) {
                switch_safe_free(sound_expanded);
        }

        if (!need) {
                return status;
        }

        menu_buf_len = strlen(menu->buf);

        menu->ptr += menu_buf_len;
        if (menu_buf_len < need) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "waiting for %u/%u digits t/o %d\n",
                                                  (uint32_t) (menu->inlen - strlen(menu->buf)), (uint32_t) need, menu->inter_timeout);
                status = switch_ivr_collect_digits_count(session, menu->ptr, menu->inlen - strlen(menu->buf),
                                                                                                 need, terminator_str, &terminator, menu_buf_len ? menu->inter_timeout : menu->timeout,
                                                                                                 menu->inter_timeout, menu->timeout);
        }

        if (menu->confirm_macro && status == SWITCH_STATUS_SUCCESS && *menu->buf != '\0') {
                switch_input_args_t confirm_args = { 0 }, *ap = NULL;
                char buf[10] = "";
                char terminator_key;
                int att = menu->confirm_attempts;

                while (att) {
                        confirm_args.buf = buf;
                        confirm_args.buflen = sizeof(buf);
                        memset(buf, 0, confirm_args.buflen);

                        if (menu->confirm_key) {
                                ap = &confirm_args;
                        }

                        switch_ivr_phrase_macro(session, menu->confirm_macro, menu->buf, NULL, ap);

                        if (menu->confirm_key && *buf == '\0') {
                                switch_ivr_collect_digits_count(session, buf, sizeof(buf), 1, terminator_str, &terminator_key, menu->timeout, 0, 0);
                        }

                        if (menu->confirm_key && *buf != '\0') {
                                if (*menu->confirm_key == *buf) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "approving digits '%s' via confirm key %s\n", menu->buf, menu->confirm_key);
                                        break;
                                } else {
                                        att = 0;
                                        break;
                                }
                        }
                        att--;
                }
                if (!att) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rejecting digits '%s' via confirm key %s\n", menu->buf,
                                                          menu->confirm_key);
                        *menu->buf = '\0';
                }
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "digits '%s'\n", menu->buf);

        return status;
}

switch_ivr_menu_find()

static switch_ivr_menu_t* switch_ivr_menu_find ( switch_ivr_menu_t *  stack, const char *  name  )

static

Definition at line 92 of file switch_ivr_menu.c.

References switch_ivr_menu::name, and switch_ivr_menu::next.

Referenced by switch_ivr_menu_execute(), and switch_ivr_menu_stack_xml_build().

{
        switch_ivr_menu_t *ret;
        for (ret = stack; ret; ret = ret->next) {
                if (!name || !strcmp(ret->name, name))
                        break;
        }
        return ret;
}

switch_ivr_menu_stack_add()

static void switch_ivr_menu_stack_add ( switch_ivr_menu_t **  top, switch_ivr_menu_t *  bottom  )

static

Definition at line 102 of file switch_ivr_menu.c.

References switch_ivr_menu::next, and switch_ivr_menu::ptr.

Referenced by switch_ivr_menu_init().

{
        switch_ivr_menu_t *ptr;

        for (ptr = *top; ptr && ptr->next; ptr = ptr->next);

        if (ptr) {
                ptr->next = bottom;
        } else {
                *top = bottom;
        }

}

switch_ivr_menu_stack_xml_add()

static switch_status_t switch_ivr_menu_stack_xml_add ( switch_ivr_menu_xml_ctx_t *  xml_ctx, const char *  name, int  action, switch_ivr_menu_action_function_t *  function  )

static

Definition at line 720 of file switch_ivr_menu.c.

References switch_ivr_menu_xml_map::action, switch_ivr_menu_xml_map::function, switch_ivr_menu_xml_ctx::map, switch_ivr_menu_xml_map::name, switch_ivr_menu_xml_map::next, switch_ivr_menu_xml_ctx::pool, SWITCH_CHANNEL_LOG, switch_core_alloc, switch_core_strdup, switch_ivr_menu_stack_xml_find(), SWITCH_LOG_DEBUG, SWITCH_LOG_ERROR, switch_log_printf(), SWITCH_STATUS_FALSE, SWITCH_STATUS_MEMERR, and SWITCH_STATUS_SUCCESS.

Referenced by switch_ivr_menu_stack_xml_add_custom(), and switch_ivr_menu_stack_xml_init().

{
        switch_status_t status = SWITCH_STATUS_FALSE;

        /* if this action/function does not exist yet */
        if (xml_ctx != NULL && name != NULL && xml_ctx->pool != NULL && switch_ivr_menu_stack_xml_find(xml_ctx, name) == NULL) {
                switch_ivr_menu_xml_map_t *map = switch_core_alloc(xml_ctx->pool, sizeof(switch_ivr_menu_xml_map_t));

                if (map != NULL) {
                        map->name = switch_core_strdup(xml_ctx->pool, name);
                        map->action = action;
                        map->function = function;

                        if (map->name != NULL) {
                                /* insert map item at top of list */
                                map->next = xml_ctx->map;
                                xml_ctx->map = map;
                                status = SWITCH_STATUS_SUCCESS;
                        } else {
                                status = SWITCH_STATUS_MEMERR;
                        }
                } else {
                        status = SWITCH_STATUS_MEMERR;
                }

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "switch_ivr_menu_stack_xml_add binding '%s'\n", name);
        } else {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to add binding %s\n", name);
        }

        return status;
}

switch_ivr_menu_stack_xml_find()

static switch_ivr_menu_xml_map_t* switch_ivr_menu_stack_xml_find ( switch_ivr_menu_xml_ctx_t *  xml_ctx, const char *  name  )

static

Definition at line 708 of file switch_ivr_menu.c.

References switch_ivr_menu_xml_ctx::map, switch_ivr_menu_xml_map::name, and switch_ivr_menu_xml_map::next.

Referenced by switch_ivr_menu_stack_xml_add().

{
        switch_ivr_menu_xml_map_t *map = (xml_ctx != NULL ? xml_ctx->map : NULL);
        int rc = -1;

        while (map != NULL && (rc = strcasecmp(map->name, name)) != 0) {
                map = map->next;
        }

        return (rc == 0 ? map : NULL);
}

Variable Documentation

iam

struct iam_s iam[]

static

Initial value:

= {
        {
        "menu-exit", SWITCH_IVR_ACTION_DIE}, {
        "menu-sub", SWITCH_IVR_ACTION_EXECMENU}, {
        "menu-exec-app", SWITCH_IVR_ACTION_EXECAPP}, {
        "menu-play-sound", SWITCH_IVR_ACTION_PLAYSOUND}, {
        "menu-back", SWITCH_IVR_ACTION_BACK}, {
        "menu-top", SWITCH_IVR_ACTION_TOMAIN}, {
        NULL, 0}
}

Referenced by is_valid_action(), switch_ivr_menu_stack_xml_init(), and switch_ivr_menu_str2action().