similar patch for verbose vs debug with minor changes
[asterisk/asterisk.git] / apps / app_macro.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Dial plan macro Implementation
22  *
23  * \author Mark Spencer <markster@digium.com>
24  * 
25  * \ingroup applications
26  */
27
28 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <unistd.h>
36 #include <sys/types.h>
37
38 #include "asterisk/file.h"
39 #include "asterisk/logger.h"
40 #include "asterisk/channel.h"
41 #include "asterisk/pbx.h"
42 #include "asterisk/module.h"
43 #include "asterisk/options.h"
44 #include "asterisk/config.h"
45 #include "asterisk/utils.h"
46 #include "asterisk/lock.h"
47
48 #define MAX_ARGS 80
49
50 /* special result value used to force macro exit */
51 #define MACRO_EXIT_RESULT 1024
52
53 static char *descrip =
54 "  Macro(macroname|arg1|arg2...): Executes a macro using the context\n"
55 "'macro-<macroname>', jumping to the 's' extension of that context and\n"
56 "executing each step, then returning when the steps end. \n"
57 "The calling extension, context, and priority are stored in ${MACRO_EXTEN}, \n"
58 "${MACRO_CONTEXT} and ${MACRO_PRIORITY} respectively.  Arguments become\n"
59 "${ARG1}, ${ARG2}, etc in the macro context.\n"
60 "If you Goto out of the Macro context, the Macro will terminate and control\n"
61 "will be returned at the location of the Goto.\n"
62 "If ${MACRO_OFFSET} is set at termination, Macro will attempt to continue\n"
63 "at priority MACRO_OFFSET + N + 1 if such a step exists, and N + 1 otherwise.\n";
64
65 static char *if_descrip =
66 "  MacroIf(<expr>?macroname_a[|arg1][:macroname_b[|arg1]])\n"
67 "Executes macro defined in <macroname_a> if <expr> is true\n"
68 "(otherwise <macroname_b> if provided)\n"
69 "Arguments and return values as in application macro()\n";
70
71 static char *exclusive_descrip =
72 "  MacroExclusive(macroname|arg1|arg2...):\n"
73 "Executes macro defined in the context 'macro-macroname'\n"
74 "Only one call at a time may run the macro.\n"
75 "(we'll wait if another call is busy executing in the Macro)\n"
76 "Arguments and return values as in application Macro()\n";
77
78 static char *exit_descrip =
79 "  MacroExit():\n"
80 "Causes the currently running macro to exit as if it had\n"
81 "ended normally by running out of priorities to execute.\n"
82 "If used outside a macro, will likely cause unexpected\n"
83 "behavior.\n";
84
85 static char *app = "Macro";
86 static char *if_app = "MacroIf";
87 static char *exclusive_app = "MacroExclusive";
88 static char *exit_app = "MacroExit";
89
90 static char *synopsis = "Macro Implementation";
91 static char *if_synopsis = "Conditional Macro Implementation";
92 static char *exclusive_synopsis = "Exclusive Macro Implementation";
93 static char *exit_synopsis = "Exit From Macro";
94
95
96 static int _macro_exec(struct ast_channel *chan, void *data, int exclusive)
97 {
98         const char *s;
99
100         char *tmp;
101         char *cur, *rest;
102         char *macro;
103         char fullmacro[80];
104         char varname[80];
105         char *oldargs[MAX_ARGS + 1] = { NULL, };
106         int argc, x;
107         int res=0;
108         char oldexten[256]="";
109         int oldpriority;
110         char pc[80], depthc[12];
111         char oldcontext[AST_MAX_CONTEXT] = "";
112         int offset, depth = 0, maxdepth = 7;
113         int setmacrocontext=0;
114         int autoloopflag, dead = 0;
115   
116         char *save_macro_exten;
117         char *save_macro_context;
118         char *save_macro_priority;
119         char *save_macro_offset;
120         struct ast_module_user *u;
121  
122         if (ast_strlen_zero(data)) {
123                 ast_log(LOG_WARNING, "Macro() requires arguments. See \"show application macro\" for help.\n");
124                 return -1;
125         }
126
127         u = ast_module_user_add(chan);
128
129         /* does the user want a deeper rabbit hole? */
130         s = pbx_builtin_getvar_helper(chan, "MACRO_RECURSION");
131         if (s)
132                 sscanf(s, "%d", &maxdepth);
133
134         /* Count how many levels deep the rabbit hole goes */
135         s = pbx_builtin_getvar_helper(chan, "MACRO_DEPTH");
136         if (s)
137                 sscanf(s, "%d", &depth);
138         if (depth >= maxdepth) {
139                 ast_log(LOG_ERROR, "Macro():  possible infinite loop detected.  Returning early.\n");
140                 ast_module_user_remove(u);
141                 return 0;
142         }
143         snprintf(depthc, sizeof(depthc), "%d", depth + 1);
144         pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
145
146         tmp = ast_strdupa(data);
147         rest = tmp;
148         macro = strsep(&rest, "|");
149         if (ast_strlen_zero(macro)) {
150                 ast_log(LOG_WARNING, "Invalid macro name specified\n");
151                 ast_module_user_remove(u);
152                 return 0;
153         }
154
155         snprintf(fullmacro, sizeof(fullmacro), "macro-%s", macro);
156         if (!ast_exists_extension(chan, fullmacro, "s", 1, chan->cid.cid_num)) {
157                 if (!ast_context_find(fullmacro)) 
158                         ast_log(LOG_WARNING, "No such context '%s' for macro '%s'\n", fullmacro, macro);
159                 else
160                         ast_log(LOG_WARNING, "Context '%s' for macro '%s' lacks 's' extension, priority 1\n", fullmacro, macro);
161                 ast_module_user_remove(u);
162                 return 0;
163         }
164
165         /* If we are to run the macro exclusively, take the mutex */
166         if (exclusive) {
167                 ast_log(LOG_DEBUG, "Locking macrolock for '%s'\n", fullmacro);
168                 ast_autoservice_start(chan);
169                 if (ast_context_lockmacro(fullmacro)) {
170                         ast_log(LOG_WARNING, "Failed to lock macro '%s' as in-use\n", fullmacro);
171                         ast_autoservice_stop(chan);
172                         ast_module_user_remove(u);
173
174                         return 0;
175                 }
176                 ast_autoservice_stop(chan);
177         }
178         
179         /* Save old info */
180         oldpriority = chan->priority;
181         ast_copy_string(oldexten, chan->exten, sizeof(oldexten));
182         ast_copy_string(oldcontext, chan->context, sizeof(oldcontext));
183         if (ast_strlen_zero(chan->macrocontext)) {
184                 ast_copy_string(chan->macrocontext, chan->context, sizeof(chan->macrocontext));
185                 ast_copy_string(chan->macroexten, chan->exten, sizeof(chan->macroexten));
186                 chan->macropriority = chan->priority;
187                 setmacrocontext=1;
188         }
189         argc = 1;
190         /* Save old macro variables */
191         save_macro_exten = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_EXTEN"));
192         pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", oldexten);
193
194         save_macro_context = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_CONTEXT"));
195         pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", oldcontext);
196
197         save_macro_priority = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_PRIORITY"));
198         snprintf(pc, sizeof(pc), "%d", oldpriority);
199         pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", pc);
200   
201         save_macro_offset = ast_strdup(pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"));
202         pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", NULL);
203
204         /* Setup environment for new run */
205         chan->exten[0] = 's';
206         chan->exten[1] = '\0';
207         ast_copy_string(chan->context, fullmacro, sizeof(chan->context));
208         chan->priority = 1;
209
210         while((cur = strsep(&rest, "|")) && (argc < MAX_ARGS)) {
211                 const char *s;
212                 /* Save copy of old arguments if we're overwriting some, otherwise
213                 let them pass through to the other macro */
214                 snprintf(varname, sizeof(varname), "ARG%d", argc);
215                 s = pbx_builtin_getvar_helper(chan, varname);
216                 if (s)
217                         oldargs[argc] = ast_strdup(s);
218                 pbx_builtin_setvar_helper(chan, varname, cur);
219                 argc++;
220         }
221         autoloopflag = ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP);
222         ast_set_flag(chan, AST_FLAG_IN_AUTOLOOP);
223         while(ast_exists_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num)) {
224                 /* Reset the macro depth, if it was changed in the last iteration */
225                 pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
226                 if ((res = ast_spawn_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num))) {
227                         /* Something bad happened, or a hangup has been requested. */
228                         if (((res >= '0') && (res <= '9')) || ((res >= 'A') && (res <= 'F')) ||
229                         (res == '*') || (res == '#')) {
230                                 /* Just return result as to the previous application as if it had been dialed */
231                                 ast_log(LOG_DEBUG, "Oooh, got something to jump out with ('%c')!\n", res);
232                                 break;
233                         }
234                         switch(res) {
235                         case MACRO_EXIT_RESULT:
236                                 res = 0;
237                                 goto out;
238                         case AST_PBX_KEEPALIVE:
239                                 if (option_debug)
240                                         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);
241                                 if (option_verbose > 1)
242                                         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);
243                                 goto out;
244                                 break;
245                         default:
246                                 if (option_debug)
247                                         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);
248                                 if (option_verbose > 1)
249                                         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);
250                                 dead = 1;
251                                 goto out;
252                         }
253                 }
254                 if (strcasecmp(chan->context, fullmacro)) {
255                         if (option_verbose > 1)
256                                 ast_verbose(VERBOSE_PREFIX_2 "Channel '%s' jumping out of macro '%s'\n", chan->name, macro);
257                         break;
258                 }
259                 /* don't stop executing extensions when we're in "h" */
260                 if (chan->_softhangup && strcasecmp(oldexten,"h") && strcasecmp(chan->macroexten,"h")) {
261                         ast_log(LOG_DEBUG, "Extension %s, macroexten %s, priority %d returned normally even though call was hung up\n",
262                                 chan->exten, chan->macroexten, chan->priority);
263                         goto out;
264                 }
265                 chan->priority++;
266         }
267         out:
268         /* Reset the depth back to what it was when the routine was entered (like if we called Macro recursively) */
269         snprintf(depthc, sizeof(depthc), "%d", depth);
270         if (!dead) {
271                 pbx_builtin_setvar_helper(chan, "MACRO_DEPTH", depthc);
272                 ast_set2_flag(chan, autoloopflag, AST_FLAG_IN_AUTOLOOP);
273         }
274
275         for (x = 1; x < argc; x++) {
276                 /* Restore old arguments and delete ours */
277                 snprintf(varname, sizeof(varname), "ARG%d", x);
278                 if (oldargs[x]) {
279                         if (!dead)
280                                 pbx_builtin_setvar_helper(chan, varname, oldargs[x]);
281                         free(oldargs[x]);
282                 } else if (!dead) {
283                         pbx_builtin_setvar_helper(chan, varname, NULL);
284                 }
285         }
286
287         /* Restore macro variables */
288         if (!dead) {
289                 pbx_builtin_setvar_helper(chan, "MACRO_EXTEN", save_macro_exten);
290                 pbx_builtin_setvar_helper(chan, "MACRO_CONTEXT", save_macro_context);
291                 pbx_builtin_setvar_helper(chan, "MACRO_PRIORITY", save_macro_priority);
292         }
293         if (save_macro_exten)
294                 free(save_macro_exten);
295         if (save_macro_context)
296                 free(save_macro_context);
297         if (save_macro_priority)
298                 free(save_macro_priority);
299
300         if (!dead && setmacrocontext) {
301                 chan->macrocontext[0] = '\0';
302                 chan->macroexten[0] = '\0';
303                 chan->macropriority = 0;
304         }
305
306         if (!dead && !strcasecmp(chan->context, fullmacro)) {
307                 /* If we're leaving the macro normally, restore original information */
308                 chan->priority = oldpriority;
309                 ast_copy_string(chan->context, oldcontext, sizeof(chan->context));
310                 if (!(chan->_softhangup & AST_SOFTHANGUP_ASYNCGOTO)) {
311                         /* Copy the extension, so long as we're not in softhangup, where we could be given an asyncgoto */
312                         const char *offsets;
313                         ast_copy_string(chan->exten, oldexten, sizeof(chan->exten));
314                         if ((offsets = pbx_builtin_getvar_helper(chan, "MACRO_OFFSET"))) {
315                                 /* Handle macro offset if it's set by checking the availability of step n + offset + 1, otherwise continue
316                                 normally if there is any problem */
317                                 if (sscanf(offsets, "%d", &offset) == 1) {
318                                         if (ast_exists_extension(chan, chan->context, chan->exten, chan->priority + offset + 1, chan->cid.cid_num)) {
319                                                 chan->priority += offset;
320                                         }
321                                 }
322                         }
323                 }
324         }
325
326         if (!dead)
327                 pbx_builtin_setvar_helper(chan, "MACRO_OFFSET", save_macro_offset);
328         if (save_macro_offset)
329                 free(save_macro_offset);
330
331         /* Unlock the macro */
332         if (exclusive) {
333                 ast_log(LOG_DEBUG, "Unlocking macrolock for '%s'\n", fullmacro);
334                 if (ast_context_unlockmacro(fullmacro)) {
335                         ast_log(LOG_ERROR, "Failed to unlock macro '%s' - that isn't good\n", fullmacro);
336                         res = 0;
337                 }
338         }
339         
340         ast_module_user_remove(u);
341
342         return res;
343 }
344
345 static int macro_exec(struct ast_channel *chan, void *data)
346 {
347         return _macro_exec(chan, data, 0);
348 }
349
350 static int macroexclusive_exec(struct ast_channel *chan, void *data)
351 {
352         return _macro_exec(chan, data, 1);
353 }
354
355 static int macroif_exec(struct ast_channel *chan, void *data) 
356 {
357         char *expr = NULL, *label_a = NULL, *label_b = NULL;
358         int res = 0;
359         struct ast_module_user *u;
360
361         u = ast_module_user_add(chan);
362
363         if (!(expr = ast_strdupa(data))) {
364                 ast_module_user_remove(u);
365                 return -1;
366         }
367
368         if ((label_a = strchr(expr, '?'))) {
369                 *label_a = '\0';
370                 label_a++;
371                 if ((label_b = strchr(label_a, ':'))) {
372                         *label_b = '\0';
373                         label_b++;
374                 }
375                 if (pbx_checkcondition(expr))
376                         macro_exec(chan, label_a);
377                 else if (label_b) 
378                         macro_exec(chan, label_b);
379         } else
380                 ast_log(LOG_WARNING, "Invalid Syntax.\n");
381
382         ast_module_user_remove(u);
383
384         return res;
385 }
386                         
387 static int macro_exit_exec(struct ast_channel *chan, void *data)
388 {
389         return MACRO_EXIT_RESULT;
390 }
391
392 static int unload_module(void)
393 {
394         int res;
395
396         res = ast_unregister_application(if_app);
397         res |= ast_unregister_application(exit_app);
398         res |= ast_unregister_application(app);
399         res |= ast_unregister_application(exclusive_app);
400
401         ast_module_user_hangup_all();
402
403         return res;
404 }
405
406 static int load_module(void)
407 {
408         int res;
409
410         res = ast_register_application(exit_app, macro_exit_exec, exit_synopsis, exit_descrip);
411         res |= ast_register_application(if_app, macroif_exec, if_synopsis, if_descrip);
412         res |= ast_register_application(exclusive_app, macroexclusive_exec, exclusive_synopsis, exclusive_descrip);
413         res |= ast_register_application(app, macro_exec, synopsis, descrip);
414
415         return res;
416 }
417
418 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Extension Macros");