diff options
Diffstat (limited to '1.2/apps/app_macro.c')
-rw-r--r-- | 1.2/apps/app_macro.c | 540 |
1 files changed, 540 insertions, 0 deletions
diff --git a/1.2/apps/app_macro.c b/1.2/apps/app_macro.c new file mode 100644 index 000000000..4002a8b00 --- /dev/null +++ b/1.2/apps/app_macro.c @@ -0,0 +1,540 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2005, Digium, Inc. + * + * Mark Spencer <markster@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Dial plan macro Implementation + * + * \ingroup applications + */ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <unistd.h> +#include <sys/types.h> + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include "asterisk/file.h" +#include "asterisk/logger.h" +#include "asterisk/channel.h" +#include "asterisk/pbx.h" +#include "asterisk/module.h" +#include "asterisk/options.h" +#include "asterisk/config.h" +#include "asterisk/utils.h" +#include "asterisk/lock.h" + +#define MAX_ARGS 80 + +/* special result value used to force macro exit */ +#define MACRO_EXIT_RESULT 1024 + +static char *tdesc = "Extension Macros"; + +static char *descrip = +" Macro(macroname|arg1|arg2...): Executes a macro using the context\n" +"'macro-<macroname>', jumping to the 's' extension of that context and\n" +"executing each step, then returning when the steps end. \n" +"The calling extension, context, and priority are stored in ${MACRO_EXTEN}, \n" +"${MACRO_CONTEXT} and ${MACRO_PRIORITY} respectively. Arguments become\n" +"${ARG1}, ${ARG2}, etc in the macro context.\n" +"If you Goto out of the Macro context, the Macro will terminate and control\n" +"will be returned at the location of the Goto.\n" +"If ${MACRO_OFFSET} is set at termination, Macro will attempt to continue\n" +"at priority MACRO_OFFSET + N + 1 if such a step exists, and N + 1 otherwise.\n" +"Extensions: While a macro is being executed, it becomes the current context.\n" +" This means that if a hangup occurs, for instance, that the macro\n" +" will be searched for an 'h' extension, NOT the context from which\n" +" the macro was called. So, make sure to define all appropriate\n" +" extensions in your macro! (you can use 'catch' in AEL) \n" +"WARNING: Because of the way Macro is implemented (it executes the priorities\n" +" contained within it via sub-engine), and a fixed per-thread\n" +" memory stack allowance, macros are limited to 7 levels\n" +" of nesting (macro calling macro calling macro, etc.); It\n" +" may be possible that stack-intensive applications in deeply nested\n" +" macros could cause asterisk to crash earlier than this limit.\n"; + +static char *if_descrip = +" MacroIf(<expr>?macroname_a[|arg1][:macroname_b[|arg1]])\n" +"Executes macro defined in <macroname_a> if <expr> is true\n" +"(otherwise <macroname_b> if provided)\n" +"Arguments and return values as in application macro()\n"; + +static char *exit_descrip = +" MacroExit():\n" +"Causes the currently running macro to exit as if it had\n" +"ended normally by running out of priorities to execute.\n" +"If used outside a macro, will likely cause unexpected\n" +"behavior.\n"; + +static char *app = "Macro"; +static char *if_app = "MacroIf"; +static char *exit_app = "MacroExit"; + +static char *synopsis = "Macro Implementation"; +static char *if_synopsis = "Conditional Macro Implementation"; +static char *exit_synopsis = "Exit From Macro"; + +STANDARD_LOCAL_USER; + +LOCAL_USER_DECL; + +static struct ast_exten *find_matching_priority(struct ast_context *c, const char *exten, int priority, const char *callerid) +{ + struct ast_exten *e; + struct ast_include *i; + struct ast_context *c2; + + for (e=ast_walk_context_extensions(c, NULL); e; e=ast_walk_context_extensions(c, e)) { + if (ast_extension_match(ast_get_extension_name(e), exten)) { + int needmatch = ast_get_extension_matchcid(e); + if ((needmatch && ast_extension_match(ast_get_extension_cidmatch(e), callerid)) || + (!needmatch)) { + /* This is the matching extension we want */ + struct ast_exten *p; + for (p=ast_walk_extension_priorities(e, NULL); p; p=ast_walk_extension_priorities(e, p)) { + if (priority != ast_get_extension_priority(p)) + continue; + return p; + } + } + } + } + + /* No match; run through includes */ + for (i=ast_walk_context_includes(c, NULL); i; i=ast_walk_context_includes(c, i)) { + for (c2=ast_walk_contexts(NULL); c2; c2=ast_walk_contexts(c2)) { + if (!strcmp(ast_get_context_name(c2), ast_get_include_name(i))) { + e = find_matching_priority(c2, exten, priority, callerid); + if (e) + return e; + } + } + } + return NULL; +} + +static int macro_exec(struct ast_channel *chan, void *data) +{ + char *tmp; + char *cur, *rest; + char *macro; + char fullmacro[80]; + char varname[80]; + char runningapp[80], runningdata[1024]; + char *oldargs[MAX_ARGS + 1] = { NULL, }; + int argc, x; + int res=0; + char oldexten[256]=""; + int oldpriority, gosub_level = 0; + char pc[80], depthc[12]; + char oldcontext[AST_MAX_CONTEXT] = ""; + char *offsets, *s, *inhangupc; + int offset, depth = 0, maxdepth = 7; + int setmacrocontext=0; + int autoloopflag, dead = 0, inhangup = 0; + + char *save_macro_exten; + char *save_macro_context; + char *save_macro_priority; + char *save_macro_offset; + struct localuser *u; + + if (ast_strlen_zero(data)) { + ast_log(LOG_WARNING, "Macro() requires arguments. See \"show application macro\" for help.\n"); + return -1; + } + + LOCAL_USER_ADD(u); + + /* does the user want a deeper rabbit hole? */ + s = pbx_builtin_getvar_helper(chan, "MACRO_RECURSION"); + if (s) + sscanf(s, "%d", &maxdepth); + + /* Count how many levels deep the rabbit hole goes */ + tmp = pbx_builtin_getvar_helper(chan, "MACRO_DEPTH"); + if (tmp) { + sscanf(tmp, "%d", &depth); + } else { + depth = 0; + } + + /* Used for detecting whether to return when a Macro is called from another Macro after hangup */ + if (strcmp(chan->exten, "h") == 0) + pbx_builtin_setvar_helper(chan, "MACRO_IN_HANGUP", "1"); + inhangupc = pbx_builtin_getvar_helper(chan, "MACRO_IN_HANGUP"); + if (!ast_strlen_zero(inhangupc)) + sscanf(inhangupc, "%d", &inhangup); + + if (depth >= maxdepth) { + ast_log(LOG_ERROR, "Macro(): possible infinite loop detected. Returning early.\n"); + LOCAL_USER_REMOVE(u); + return 0; + } + snprintf(depthc, sizeof(depthc), "%d", depth + 1); + pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc); + + tmp = ast_strdupa(data); + rest = tmp; + macro = strsep(&rest, "|"); + if (ast_strlen_zero(macro)) { + ast_log(LOG_WARNING, "Invalid macro name specified\n"); + LOCAL_USER_REMOVE(u); + return 0; + } + snprintf(fullmacro, sizeof(fullmacro), "macro-%s", macro); + if (!ast_exists_extension(chan, fullmacro, "s", 1, chan->cid.cid_num)) { + if (!ast_context_find(fullmacro)) + ast_log(LOG_WARNING, "No such context '%s' for macro '%s'\n", fullmacro, macro); + else + ast_log(LOG_WARNING, "Context '%s' for macro '%s' lacks 's' extension, priority 1\n", fullmacro, macro); + LOCAL_USER_REMOVE(u); + return 0; + } + + /* Save old info */ + oldpriority = chan->priority; + ast_copy_string(oldexten, chan->exten, sizeof(oldexten)); + ast_copy_string(oldcontext, chan->context, sizeof(oldcontext)); + if (ast_strlen_zero(chan->macrocontext)) { + ast_copy_string(chan->macrocontext, chan->context, sizeof(chan->macrocontext)); + ast_copy_string(chan->macroexten, chan->exten, sizeof(chan->macroexten)); + chan->macropriority = chan->priority; + setmacrocontext=1; + } + argc = 1; + /* Save old macro variables */ + save_macro_exten = pbx_builtin_getvar_helper(chan, "MACRO_EXTEN"); + if (save_macro_exten) + save_macro_exten = strdup(save_macro_exten); + pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", oldexten); + + save_macro_context = pbx_builtin_getvar_helper(chan, "MACRO_CONTEXT"); + if (save_macro_context) + save_macro_context = strdup(save_macro_context); + pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", oldcontext); + + save_macro_priority = pbx_builtin_getvar_helper(chan, "MACRO_PRIORITY"); + if (save_macro_priority) + save_macro_priority = strdup(save_macro_priority); + snprintf(pc, sizeof(pc), "%d", oldpriority); + pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", pc); + + save_macro_offset = pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"); + if (save_macro_offset) + save_macro_offset = strdup(save_macro_offset); + pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", NULL); + + /* Setup environment for new run */ + chan->exten[0] = 's'; + chan->exten[1] = '\0'; + ast_copy_string(chan->context, fullmacro, sizeof(chan->context)); + chan->priority = 1; + + while((cur = strsep(&rest, "|")) && (argc < MAX_ARGS)) { + /* Save copy of old arguments if we're overwriting some, otherwise + let them pass through to the other macro */ + snprintf(varname, sizeof(varname), "ARG%d", argc); + oldargs[argc] = pbx_builtin_getvar_helper(chan, varname); + if (oldargs[argc]) + oldargs[argc] = strdup(oldargs[argc]); + pbx_builtin_setvar_helper(chan, varname, cur); + argc++; + } + autoloopflag = ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP); + ast_set_flag(chan, AST_FLAG_IN_AUTOLOOP); + while(ast_exists_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num)) { + struct ast_context *c; + struct ast_exten *e; + runningapp[0] = '\0'; + runningdata[0] = '\0'; + + /* What application will execute? */ + if (ast_lock_contexts()) { + ast_log(LOG_WARNING, "Failed to lock contexts list\n"); + } else { + for (c = ast_walk_contexts(NULL), e = NULL; c; c = ast_walk_contexts(c)) { + if (!strcmp(ast_get_context_name(c), chan->context)) { + if (ast_lock_context(c)) { + ast_log(LOG_WARNING, "Unable to lock context?\n"); + } else { + e = find_matching_priority(c, chan->exten, chan->priority, chan->cid.cid_num); + if (e) { /* This will only be undefined for pbx_realtime, which is majorly broken. */ + ast_copy_string(runningapp, ast_get_extension_app(e), sizeof(runningapp)); + ast_copy_string(runningdata, ast_get_extension_app_data(e), sizeof(runningdata)); + } + ast_unlock_context(c); + } + break; + } + } + } + ast_unlock_contexts(); + + /* Reset the macro depth, if it was changed in the last iteration */ + pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc); + + if ((res = ast_spawn_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num))) { + /* Something bad happened, or a hangup has been requested. */ + if (((res >= '0') && (res <= '9')) || ((res >= 'A') && (res <= 'F')) || + (res == '*') || (res == '#')) { + /* Just return result as to the previous application as if it had been dialed */ + ast_log(LOG_DEBUG, "Oooh, got something to jump out with ('%c')!\n", res); + break; + } + switch(res) { + case MACRO_EXIT_RESULT: + res = 0; + goto out; + case AST_PBX_KEEPALIVE: + if (option_debug) + ast_log(LOG_DEBUG, "Spawn extension (%s,%s,%d) exited KEEPALIVE in macro %s on '%s'\n", chan->context, chan->exten, chan->priority, macro, chan->name); + if (option_verbose > 1) + ast_verbose( VERBOSE_PREFIX_2 "Spawn extension (%s, %s, %d) exited KEEPALIVE in macro '%s' on '%s'\n", chan->context, chan->exten, chan->priority, macro, chan->name); + goto out; + break; + default: + if (option_debug) + ast_log(LOG_DEBUG, "Spawn extension (%s,%s,%d) exited non-zero on '%s' in macro '%s'\n", chan->context, chan->exten, chan->priority, chan->name, macro); + if (option_verbose > 1) + ast_verbose( VERBOSE_PREFIX_2 "Spawn extension (%s, %s, %d) exited non-zero on '%s' in macro '%s'\n", chan->context, chan->exten, chan->priority, chan->name, macro); + dead = 1; + goto out; + } + } + + ast_log(LOG_DEBUG, "Executed application: %s\n", runningapp); + + if (!strcasecmp(runningapp, "GOSUB")) { + gosub_level++; + ast_log(LOG_DEBUG, "Incrementing gosub_level\n"); + } else if (!strcasecmp(runningapp, "GOSUBIF")) { + char tmp2[1024] = "", *cond, *app, *app2 = tmp2; + pbx_substitute_variables_helper(chan, runningdata, tmp2, sizeof(tmp2) - 1); + cond = strsep(&app2, "?"); + app = strsep(&app2, ":"); + if (pbx_checkcondition(cond)) { + if (!ast_strlen_zero(app)) { + gosub_level++; + ast_log(LOG_DEBUG, "Incrementing gosub_level\n"); + } + } else { + if (!ast_strlen_zero(app2)) { + gosub_level++; + ast_log(LOG_DEBUG, "Incrementing gosub_level\n"); + } + } + } else if (!strcasecmp(runningapp, "RETURN")) { + gosub_level--; + ast_log(LOG_DEBUG, "Decrementing gosub_level\n"); + } else if (!strcasecmp(runningapp, "STACKPOP")) { + gosub_level--; + ast_log(LOG_DEBUG, "Decrementing gosub_level\n"); + } else if (!strncasecmp(runningapp, "EXEC", 4)) { + /* Must evaluate args to find actual app */ + char tmp2[1024] = "", *tmp3 = NULL; + pbx_substitute_variables_helper(chan, runningdata, tmp2, sizeof(tmp2) - 1); + if (!strcasecmp(runningapp, "EXECIF")) { + tmp3 = strchr(tmp2, '|'); + if (tmp3) + *tmp3++ = '\0'; + if (!pbx_checkcondition(tmp2)) + tmp3 = NULL; + } else + tmp3 = tmp2; + + if (tmp3) + ast_log(LOG_DEBUG, "Last app: %s\n", tmp3); + + if (tmp3 && !strncasecmp(tmp3, "GOSUB", 5)) { + gosub_level++; + ast_log(LOG_DEBUG, "Incrementing gosub_level\n"); + } else if (tmp3 && !strncasecmp(tmp3, "RETURN", 6)) { + gosub_level--; + ast_log(LOG_DEBUG, "Decrementing gosub_level\n"); + } else if (tmp3 && !strncasecmp(tmp3, "STACKPOP", 8)) { + gosub_level--; + ast_log(LOG_DEBUG, "Decrementing gosub_level\n"); + } + } + + if (gosub_level == 0 && strcasecmp(chan->context, fullmacro)) { + if (option_verbose > 1) + ast_verbose(VERBOSE_PREFIX_2 "Channel '%s' jumping out of macro '%s'\n", chan->name, macro); + break; + } + + /* don't stop executing extensions when we're in "h" */ + if (chan->_softhangup && !inhangup) { + ast_log(LOG_DEBUG, "Extension %s, macroexten %s, priority %d returned normally even though call was hung up\n", + chan->exten, chan->macroexten, chan->priority); + goto out; + } + chan->priority++; + } + out: + /* Reset the depth back to what it was when the routine was entered (like if we called Macro recursively) */ + snprintf(depthc, sizeof(depthc), "%d", depth); + if (!dead) { + pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc); + + ast_set2_flag(chan, autoloopflag, AST_FLAG_IN_AUTOLOOP); + } + + for (x = 1; x < argc; x++) { + /* Restore old arguments and delete ours */ + snprintf(varname, sizeof(varname), "ARG%d", x); + if (oldargs[x]) { + if (!dead) + pbx_builtin_setvar_helper(chan, varname, oldargs[x]); + free(oldargs[x]); + } else if (!dead) { + pbx_builtin_setvar_helper(chan, varname, NULL); + } + } + + /* Restore macro variables */ + if (!dead) { + pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", save_macro_exten); + pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", save_macro_context); + pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", save_macro_priority); + } + if (save_macro_exten) + free(save_macro_exten); + if (save_macro_context) + free(save_macro_context); + if (save_macro_priority) + free(save_macro_priority); + + if (!dead && setmacrocontext) { + chan->macrocontext[0] = '\0'; + chan->macroexten[0] = '\0'; + chan->macropriority = 0; + } + + if (!dead && !strcasecmp(chan->context, fullmacro)) { + /* If we're leaving the macro normally, restore original information */ + chan->priority = oldpriority; + ast_copy_string(chan->context, oldcontext, sizeof(chan->context)); + if (!(chan->_softhangup & AST_SOFTHANGUP_ASYNCGOTO)) { + /* Copy the extension, so long as we're not in softhangup, where we could be given an asyncgoto */ + ast_copy_string(chan->exten, oldexten, sizeof(chan->exten)); + if ((offsets = pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"))) { + /* Handle macro offset if it's set by checking the availability of step n + offset + 1, otherwise continue + normally if there is any problem */ + if (sscanf(offsets, "%d", &offset) == 1) { + if (ast_exists_extension(chan, chan->context, chan->exten, chan->priority + offset + 1, chan->cid.cid_num)) { + chan->priority += offset; + } + } + } + } + } + + if (!dead) + pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", save_macro_offset); + if (save_macro_offset) + free(save_macro_offset); + LOCAL_USER_REMOVE(u); + return res; +} + +static int macroif_exec(struct ast_channel *chan, void *data) +{ + char *expr = NULL, *label_a = NULL, *label_b = NULL; + int res = 0; + struct localuser *u; + + LOCAL_USER_ADD(u); + + expr = ast_strdupa(data); + if (!expr) { + ast_log(LOG_ERROR, "Out of Memory!\n"); + LOCAL_USER_REMOVE(u); + return -1; + } + + if ((label_a = strchr(expr, '?'))) { + *label_a = '\0'; + label_a++; + if ((label_b = strchr(label_a, ':'))) { + *label_b = '\0'; + label_b++; + } + if (pbx_checkcondition(expr)) + macro_exec(chan, label_a); + else if (label_b) + macro_exec(chan, label_b); + } else + ast_log(LOG_WARNING, "Invalid Syntax.\n"); + + LOCAL_USER_REMOVE(u); + + return res; +} + +static int macro_exit_exec(struct ast_channel *chan, void *data) +{ + return MACRO_EXIT_RESULT; +} + +int unload_module(void) +{ + int res; + + res = ast_unregister_application(if_app); + res |= ast_unregister_application(exit_app); + res |= ast_unregister_application(app); + + STANDARD_HANGUP_LOCALUSERS; + + return res; +} + +int load_module(void) +{ + int res; + + res = ast_register_application(exit_app, macro_exit_exec, exit_synopsis, exit_descrip); + res |= ast_register_application(if_app, macroif_exec, if_synopsis, if_descrip); + res |= ast_register_application(app, macro_exec, synopsis, descrip); + + return res; +} + +char *description(void) +{ + return tdesc; +} + +int usecount(void) +{ + int res; + STANDARD_USECOUNT(res); + return res; +} + +char *key() +{ + return ASTERISK_GPL_KEY; +} |