Move AGI command 'gosub' static documentation to XML.
[asterisk/asterisk.git] / apps / app_stack.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (c) 2004-2006 Tilghman Lesher <app_stack_v003@the-tilghman.com>.
5  *
6  * This code is released by the author with no restrictions on usage.
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 Stack applications Gosub, Return, etc.
22  *
23  * \author Tilghman Lesher <app_stack_v003@the-tilghman.com>
24  * 
25  * \ingroup applications
26  */
27
28 /*** MODULEINFO
29         <use>res_agi</use>
30  ***/
31
32 #include "asterisk.h"
33  
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include "asterisk/pbx.h"
37 #include "asterisk/module.h"
38 #include "asterisk/app.h"
39 #include "asterisk/manager.h"
40 #include "asterisk/channel.h"
41 #include "asterisk/agi.h"
42
43 /*** DOCUMENTATION
44         <application name="Gosub" language="en_US">
45                 <synopsis>
46                         Jump to label, saving return address.
47                 </synopsis>
48                 <syntax>
49                         <parameter name="context" />
50                         <parameter name="exten" />
51                         <parameter name="priority" required="true" hasparams="optional">
52                                 <argument name="arg1" multiple="true" required="true" />
53                                 <argument name="argN" />
54                         </parameter>
55                 </syntax>
56                 <description>
57                         <para>Jumps to the label specified, saving the return address.</para>
58                 </description>
59                 <see-also>
60                         <ref type="application">GosubIf</ref>
61                         <ref type="application">Macro</ref>
62                         <ref type="application">Goto</ref>
63                         <ref type="application">Return</ref>
64                         <ref type="application">StackPop</ref>
65                 </see-also>
66         </application>
67         <application name="GosubIf" language="en_US">
68                 <synopsis>
69                         Conditionally jump to label, saving return address.
70                 </synopsis>
71                 <syntax argsep="?">
72                         <parameter name="condition" required="true" />
73                         <parameter name="destination" required="true" argsep=":">
74                                 <argument name="labeliftrue" hasparams="optional">
75                                         <argument name="arg1" required="true" multiple="true" />
76                                         <argument name="argN" />
77                                 </argument>
78                                 <argument name="labeliffalse" hasparams="optional">
79                                         <argument name="arg1" required="true" multiple="true" />
80                                         <argument name="argN" />
81                                 </argument>
82                         </parameter>
83                 </syntax>
84                 <description>
85                         <para>If the condition is true, then jump to labeliftrue.  If false, jumps to
86                         labeliffalse, if specified.  In either case, a jump saves the return point
87                         in the dialplan, to be returned to with a Return.</para>
88                 </description>
89                 <see-also>
90                         <ref type="application">Gosub</ref>
91                         <ref type="application">Return</ref>
92                         <ref type="application">MacroIf</ref>
93                         <ref type="function">IF</ref>
94                         <ref type="application">GotoIf</ref>
95                 </see-also>
96         </application>
97         <application name="Return" language="en_US">
98                 <synopsis>
99                         Return from gosub routine.
100                 </synopsis>
101                 <syntax>
102                         <parameter name="value">
103                                 <para>Return value.</para>
104                         </parameter>
105                 </syntax>
106                 <description>
107                         <para>Jumps to the last label on the stack, removing it. The return <replaceable>value</replaceable>, if
108                         any, is saved in the channel variable <variable>GOSUB_RETVAL</variable>.</para>
109                 </description>
110                 <see-also>
111                         <ref type="application">Gosub</ref>
112                         <ref type="application">StackPop</ref>
113                 </see-also>
114         </application>
115         <application name="StackPop" language="en_US">
116                 <synopsis>
117                         Remove one address from gosub stack.
118                 </synopsis>
119                 <syntax />
120                 <description>
121                         <para>Removes last label on the stack, discarding it.</para>
122                 </description>
123                 <see-also>
124                         <ref type="application">Return</ref>
125                         <ref type="application">Gosub</ref>
126                 </see-also>
127         </application>
128         <function name="LOCAL" language="en_US">
129                 <synopsis>
130                         Manage variables local to the gosub stack frame.
131                 </synopsis>
132                 <syntax>
133                         <parameter name="varname" required="true" />
134                 </syntax>
135                 <description>
136                         <para>Read and write a variable local to the gosub stack frame, once we Return() it will be lost
137                         (or it will go back to whatever value it had before the Gosub()).</para>
138                 </description>
139                 <see-also>
140                         <ref type="application">Gosub</ref>
141                         <ref type="application">GosubIf</ref>
142                         <ref type="application">Return</ref>
143                 </see-also>
144         </function>
145         <function name="LOCAL_PEEK" language="en_US">
146                 <synopsis>
147                         Retrieve variables hidden by the local gosub stack frame.
148                 </synopsis>
149                 <syntax>
150                         <parameter name="n" required="true" />
151                         <parameter name="varname" required="true" />
152                 </syntax>
153                 <description>
154                         <para>Read a variable <replaceable>varname</replaceable> hidden by
155                         <replaceable>n</replaceable> levels of gosub stack frames.  Note that ${LOCAL_PEEK(0,foo)}
156                         is the same as <variable>foo</variable>, since the value of <replaceable>n</replaceable>
157                         peeks under 0 levels of stack frames; in other words, 0 is the current level.  If
158                         <replaceable>n</replaceable> exceeds the available number of stack frames, then an empty
159                         string is returned.</para>
160                 </description>
161                 <see-also>
162                         <ref type="application">Gosub</ref>
163                         <ref type="application">GosubIf</ref>
164                         <ref type="application">Return</ref>
165                 </see-also>
166         </function>
167         <agi name="gosub" language="en_US">
168                 <synopsis>
169                         Cause the channel to execute the specified dialplan subroutine.
170                 </synopsis>
171                 <syntax>
172                         <parameter name="context" required="true" />
173                         <parameter name="extension" required="true" />
174                         <parameter name="priority" required="true" />
175                         <parameter name="optional-argument" />
176                 </syntax>
177                 <description>
178                         <para>Cause the channel to execute the specified dialplan subroutine,
179                         returning to the dialplan with execution of a Return().</para>
180                 </description>
181         </agi>
182  ***/
183
184 static const char * const app_gosub = "Gosub";
185 static const char * const app_gosubif = "GosubIf";
186 static const char * const app_return = "Return";
187 static const char * const app_pop = "StackPop";
188
189 static void gosub_free(void *data);
190
191 static struct ast_datastore_info stack_info = {
192         .type = "GOSUB",
193         .destroy = gosub_free,
194 };
195
196 struct gosub_stack_frame {
197         AST_LIST_ENTRY(gosub_stack_frame) entries;
198         /* 100 arguments is all that we support anyway, but this will handle up to 255 */
199         unsigned char arguments;
200         struct varshead varshead;
201         int priority;
202         char *context;
203         char extension[0];
204 };
205
206 static int frame_set_var(struct ast_channel *chan, struct gosub_stack_frame *frame, const char *var, const char *value)
207 {
208         struct ast_var_t *variables;
209         int found = 0;
210
211         /* Does this variable already exist? */
212         AST_LIST_TRAVERSE(&frame->varshead, variables, entries) {
213                 if (!strcmp(var, ast_var_name(variables))) {
214                         found = 1;
215                         break;
216                 }
217         }
218
219         if (!found) {
220                 variables = ast_var_assign(var, "");
221                 AST_LIST_INSERT_HEAD(&frame->varshead, variables, entries);
222                 pbx_builtin_pushvar_helper(chan, var, value);
223         } else {
224                 pbx_builtin_setvar_helper(chan, var, value);
225         }
226
227         manager_event(EVENT_FLAG_DIALPLAN, "VarSet",
228                 "Channel: %s\r\n"
229                 "Variable: LOCAL(%s)\r\n"
230                 "Value: %s\r\n"
231                 "Uniqueid: %s\r\n",
232                 chan->name, var, value, chan->uniqueid);
233         return 0;
234 }
235
236 static void gosub_release_frame(struct ast_channel *chan, struct gosub_stack_frame *frame)
237 {
238         struct ast_var_t *vardata;
239
240         /* If chan is not defined, then we're calling it as part of gosub_free,
241          * and the channel variables will be deallocated anyway.  Otherwise, we're
242          * just releasing a single frame, so we need to clean up the arguments for
243          * that frame, so that we re-expose the variables from the previous frame
244          * that were hidden by this one.
245          */
246         while ((vardata = AST_LIST_REMOVE_HEAD(&frame->varshead, entries))) {
247                 if (chan)
248                         pbx_builtin_setvar_helper(chan, ast_var_name(vardata), NULL);   
249                 ast_var_delete(vardata);
250         }
251
252         ast_free(frame);
253 }
254
255 static struct gosub_stack_frame *gosub_allocate_frame(const char *context, const char *extension, int priority, unsigned char arguments)
256 {
257         struct gosub_stack_frame *new = NULL;
258         int len_extension = strlen(extension), len_context = strlen(context);
259
260         if ((new = ast_calloc(1, sizeof(*new) + 2 + len_extension + len_context))) {
261                 AST_LIST_HEAD_INIT_NOLOCK(&new->varshead);
262                 strcpy(new->extension, extension);
263                 new->context = new->extension + len_extension + 1;
264                 strcpy(new->context, context);
265                 new->priority = priority;
266                 new->arguments = arguments;
267         }
268         return new;
269 }
270
271 static void gosub_free(void *data)
272 {
273         AST_LIST_HEAD(, gosub_stack_frame) *oldlist = data;
274         struct gosub_stack_frame *oldframe;
275         AST_LIST_LOCK(oldlist);
276         while ((oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
277                 gosub_release_frame(NULL, oldframe);
278         }
279         AST_LIST_UNLOCK(oldlist);
280         AST_LIST_HEAD_DESTROY(oldlist);
281         ast_free(oldlist);
282 }
283
284 static int pop_exec(struct ast_channel *chan, const char *data)
285 {
286         struct ast_datastore *stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
287         struct gosub_stack_frame *oldframe;
288         AST_LIST_HEAD(, gosub_stack_frame) *oldlist;
289
290         if (!stack_store) {
291                 ast_log(LOG_WARNING, "%s called with no gosub stack allocated.\n", app_pop);
292                 return 0;
293         }
294
295         oldlist = stack_store->data;
296         AST_LIST_LOCK(oldlist);
297         oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries);
298         AST_LIST_UNLOCK(oldlist);
299
300         if (oldframe) {
301                 gosub_release_frame(chan, oldframe);
302         } else {
303                 ast_debug(1, "%s called with an empty gosub stack\n", app_pop);
304         }
305         return 0;
306 }
307
308 static int return_exec(struct ast_channel *chan, const char *data)
309 {
310         struct ast_datastore *stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
311         struct gosub_stack_frame *oldframe;
312         AST_LIST_HEAD(, gosub_stack_frame) *oldlist;
313         const char *retval = data;
314
315         if (!stack_store) {
316                 ast_log(LOG_ERROR, "Return without Gosub: stack is unallocated\n");
317                 return -1;
318         }
319
320         oldlist = stack_store->data;
321         AST_LIST_LOCK(oldlist);
322         oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries);
323         AST_LIST_UNLOCK(oldlist);
324
325         if (!oldframe) {
326                 ast_log(LOG_ERROR, "Return without Gosub: stack is empty\n");
327                 return -1;
328         }
329
330         ast_explicit_goto(chan, oldframe->context, oldframe->extension, oldframe->priority);
331         gosub_release_frame(chan, oldframe);
332
333         /* Set a return value, if any */
334         pbx_builtin_setvar_helper(chan, "GOSUB_RETVAL", S_OR(retval, ""));
335         return 0;
336 }
337
338 static int gosub_exec(struct ast_channel *chan, const char *data)
339 {
340         struct ast_datastore *stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
341         AST_LIST_HEAD(, gosub_stack_frame) *oldlist;
342         struct gosub_stack_frame *newframe;
343         char argname[15], *tmp = ast_strdupa(data), *label, *endparen;
344         int i;
345         AST_DECLARE_APP_ARGS(args2,
346                 AST_APP_ARG(argval)[100];
347         );
348
349         if (ast_strlen_zero(data)) {
350                 ast_log(LOG_ERROR, "%s requires an argument: %s([[context,]exten,]priority[(arg1[,...][,argN])])\n", app_gosub, app_gosub);
351                 return -1;
352         }
353
354         if (!stack_store) {
355                 ast_debug(1, "Channel %s has no datastore, so we're allocating one.\n", chan->name);
356                 stack_store = ast_datastore_alloc(&stack_info, NULL);
357                 if (!stack_store) {
358                         ast_log(LOG_ERROR, "Unable to allocate new datastore.  Gosub will fail.\n");
359                         return -1;
360                 }
361
362                 oldlist = ast_calloc(1, sizeof(*oldlist));
363                 if (!oldlist) {
364                         ast_log(LOG_ERROR, "Unable to allocate datastore list head.  Gosub will fail.\n");
365                         ast_datastore_free(stack_store);
366                         return -1;
367                 }
368
369                 stack_store->data = oldlist;
370                 AST_LIST_HEAD_INIT(oldlist);
371                 ast_channel_datastore_add(chan, stack_store);
372         }
373
374         /* Separate the arguments from the label */
375         /* NOTE:  you cannot use ast_app_separate_args for this, because '(' cannot be used as a delimiter. */
376         label = strsep(&tmp, "(");
377         if (tmp) {
378                 endparen = strrchr(tmp, ')');
379                 if (endparen)
380                         *endparen = '\0';
381                 else
382                         ast_log(LOG_WARNING, "Ouch.  No closing paren: '%s'?\n", (char *)data);
383                 AST_STANDARD_APP_ARGS(args2, tmp);
384         } else
385                 args2.argc = 0;
386
387         /* Create the return address, but don't save it until we know that the Gosub destination exists */
388         newframe = gosub_allocate_frame(chan->context, chan->exten, chan->priority + 1, args2.argc);
389
390         if (!newframe) {
391                 return -1;
392         }
393
394         if (ast_parseable_goto(chan, label)) {
395                 ast_log(LOG_ERROR, "Gosub address is invalid: '%s'\n", (char *)data);
396                 ast_free(newframe);
397                 return -1;
398         }
399
400         if (!ast_exists_extension(chan, chan->context, chan->exten, ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP) ? chan->priority + 1 : chan->priority, chan->cid.cid_num)) {
401                 ast_log(LOG_ERROR, "Attempt to reach a non-existent destination for gosub: (Context:%s, Extension:%s, Priority:%d)\n",
402                                 chan->context, chan->exten, chan->priority);
403                 ast_copy_string(chan->context, newframe->context, sizeof(chan->context));
404                 ast_copy_string(chan->exten, newframe->extension, sizeof(chan->exten));
405                 chan->priority = newframe->priority;
406                 ast_free(newframe);
407                 return -1;
408         }
409
410         /* Now that we know for certain that we're going to a new location, set our arguments */
411         for (i = 0; i < args2.argc; i++) {
412                 snprintf(argname, sizeof(argname), "ARG%d", i + 1);
413                 frame_set_var(chan, newframe, argname, args2.argval[i]);
414                 ast_debug(1, "Setting '%s' to '%s'\n", argname, args2.argval[i]);
415         }
416         snprintf(argname, sizeof(argname), "%d", args2.argc);
417         frame_set_var(chan, newframe, "ARGC", argname);
418
419         /* And finally, save our return address */
420         oldlist = stack_store->data;
421         AST_LIST_LOCK(oldlist);
422         AST_LIST_INSERT_HEAD(oldlist, newframe, entries);
423         AST_LIST_UNLOCK(oldlist);
424
425         return 0;
426 }
427
428 static int gosubif_exec(struct ast_channel *chan, const char *data)
429 {
430         char *args;
431         int res=0;
432         AST_DECLARE_APP_ARGS(cond,
433                 AST_APP_ARG(ition);
434                 AST_APP_ARG(labels);
435         );
436         AST_DECLARE_APP_ARGS(label,
437                 AST_APP_ARG(iftrue);
438                 AST_APP_ARG(iffalse);
439         );
440
441         if (ast_strlen_zero(data)) {
442                 ast_log(LOG_WARNING, "GosubIf requires an argument: GosubIf(cond?label1(args):label2(args)\n");
443                 return 0;
444         }
445
446         args = ast_strdupa(data);
447         AST_NONSTANDARD_APP_ARGS(cond, args, '?');
448         if (cond.argc != 2) {
449                 ast_log(LOG_WARNING, "GosubIf requires an argument: GosubIf(cond?label1(args):label2(args)\n");
450                 return 0;
451         }
452
453         AST_NONSTANDARD_APP_ARGS(label, cond.labels, ':');
454
455         if (pbx_checkcondition(cond.ition)) {
456                 if (!ast_strlen_zero(label.iftrue))
457                         res = gosub_exec(chan, label.iftrue);
458         } else if (!ast_strlen_zero(label.iffalse)) {
459                 res = gosub_exec(chan, label.iffalse);
460         }
461
462         return res;
463 }
464
465 static int local_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
466 {
467         struct ast_datastore *stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
468         AST_LIST_HEAD(, gosub_stack_frame) *oldlist;
469         struct gosub_stack_frame *frame;
470         struct ast_var_t *variables;
471
472         if (!stack_store)
473                 return -1;
474
475         oldlist = stack_store->data;
476         AST_LIST_LOCK(oldlist);
477         frame = AST_LIST_FIRST(oldlist);
478         AST_LIST_TRAVERSE(&frame->varshead, variables, entries) {
479                 if (!strcmp(data, ast_var_name(variables))) {
480                         const char *tmp;
481                         ast_channel_lock(chan);
482                         tmp = pbx_builtin_getvar_helper(chan, data);
483                         ast_copy_string(buf, S_OR(tmp, ""), len);
484                         ast_channel_unlock(chan);
485                         break;
486                 }
487         }
488         AST_LIST_UNLOCK(oldlist);
489         return 0;
490 }
491
492 static int local_write(struct ast_channel *chan, const char *cmd, char *var, const char *value)
493 {
494         struct ast_datastore *stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
495         AST_LIST_HEAD(, gosub_stack_frame) *oldlist;
496         struct gosub_stack_frame *frame;
497
498         if (!stack_store) {
499                 ast_log(LOG_ERROR, "Tried to set LOCAL(%s), but we aren't within a Gosub routine\n", var);
500                 return -1;
501         }
502
503         oldlist = stack_store->data;
504         AST_LIST_LOCK(oldlist);
505         frame = AST_LIST_FIRST(oldlist);
506
507         if (frame)
508                 frame_set_var(chan, frame, var, value);
509
510         AST_LIST_UNLOCK(oldlist);
511
512         return 0;
513 }
514
515 static struct ast_custom_function local_function = {
516         .name = "LOCAL",
517         .write = local_write,
518         .read = local_read,
519 };
520
521 static int peek_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
522 {
523         int found = 0, n;
524         struct ast_var_t *variables;
525         AST_DECLARE_APP_ARGS(args,
526                 AST_APP_ARG(n);
527                 AST_APP_ARG(name);
528         );
529
530         if (!chan) {
531                 ast_log(LOG_ERROR, "LOCAL_PEEK must be called on an active channel\n");
532                 return -1;
533         }
534
535         AST_STANDARD_APP_ARGS(args, data);
536         n = atoi(args.n);
537         *buf = '\0';
538
539         ast_channel_lock(chan);
540         AST_LIST_TRAVERSE(&chan->varshead, variables, entries) {
541                 if (!strcmp(args.name, ast_var_name(variables)) && ++found > n) {
542                         ast_copy_string(buf, ast_var_value(variables), len);
543                         break;
544                 }
545         }
546         ast_channel_unlock(chan);
547         return 0;
548 }
549
550 static struct ast_custom_function peek_function = {
551         .name = "LOCAL_PEEK",
552         .read = peek_read,
553 };
554
555 static int handle_gosub(struct ast_channel *chan, AGI *agi, int argc, const char * const *argv)
556 {
557         int old_priority, priority;
558         char old_context[AST_MAX_CONTEXT], old_extension[AST_MAX_EXTENSION];
559         struct ast_app *theapp;
560         char *gosub_args;
561
562         if (argc < 4 || argc > 5) {
563                 return RESULT_SHOWUSAGE;
564         }
565
566         ast_debug(1, "Gosub called with %d arguments: 0:%s 1:%s 2:%s 3:%s 4:%s\n", argc, argv[0], argv[1], argv[2], argv[3], argc == 5 ? argv[4] : "");
567
568         if (sscanf(argv[3], "%d", &priority) != 1 || priority < 1) {
569                 /* Lookup the priority label */
570                 if ((priority = ast_findlabel_extension(chan, argv[1], argv[2], argv[3], chan->cid.cid_num)) < 0) {
571                         ast_log(LOG_ERROR, "Priority '%s' not found in '%s@%s'\n", argv[3], argv[2], argv[1]);
572                         ast_agi_send(agi->fd, chan, "200 result=-1 Gosub label not found\n");
573                         return RESULT_FAILURE;
574                 }
575         } else if (!ast_exists_extension(chan, argv[1], argv[2], priority, chan->cid.cid_num)) {
576                 ast_agi_send(agi->fd, chan, "200 result=-1 Gosub label not found\n");
577                 return RESULT_FAILURE;
578         }
579
580         /* Save previous location, since we're going to change it */
581         ast_copy_string(old_context, chan->context, sizeof(old_context));
582         ast_copy_string(old_extension, chan->exten, sizeof(old_extension));
583         old_priority = chan->priority;
584
585         if (!(theapp = pbx_findapp("Gosub"))) {
586                 ast_log(LOG_ERROR, "Gosub() cannot be found in the list of loaded applications\n");
587                 ast_agi_send(agi->fd, chan, "503 result=-2 Gosub is not loaded\n");
588                 return RESULT_FAILURE;
589         }
590
591         /* Apparently, if you run ast_pbx_run on a channel that already has a pbx
592          * structure, you need to add 1 to the priority to get it to go to the
593          * right place.  But if it doesn't have a pbx structure, then leaving off
594          * the 1 is the right thing to do.  See how this code differs when we
595          * call a Gosub for the CALLEE channel in Dial or Queue.
596          */
597         if (argc == 5) {
598                 if (asprintf(&gosub_args, "%s,%s,%d(%s)", argv[1], argv[2], priority + 1, argv[4]) < 0) {
599                         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
600                         gosub_args = NULL;
601                 }
602         } else {
603                 if (asprintf(&gosub_args, "%s,%s,%d", argv[1], argv[2], priority + 1) < 0) {
604                         ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
605                         gosub_args = NULL;
606                 }
607         }
608
609         if (gosub_args) {
610                 int res;
611
612                 ast_debug(1, "Trying gosub with arguments '%s'\n", gosub_args);
613
614                 if ((res = pbx_exec(chan, theapp, gosub_args)) == 0) {
615                         struct ast_pbx *pbx = chan->pbx;
616                         struct ast_pbx_args args;
617                         memset(&args, 0, sizeof(args));
618                         args.no_hangup_chan = 1;
619                         /* Suppress warning about PBX already existing */
620                         chan->pbx = NULL;
621                         ast_agi_send(agi->fd, chan, "100 result=0 Trying...\n");
622                         ast_pbx_run_args(chan, &args);
623                         ast_agi_send(agi->fd, chan, "200 result=0 Gosub complete\n");
624                         if (chan->pbx) {
625                                 ast_free(chan->pbx);
626                         }
627                         chan->pbx = pbx;
628                 } else {
629                         ast_agi_send(agi->fd, chan, "200 result=%d Gosub failed\n", res);
630                 }
631                 ast_free(gosub_args);
632         } else {
633                 ast_agi_send(agi->fd, chan, "503 result=-2 Memory allocation failure\n");
634                 return RESULT_FAILURE;
635         }
636
637         /* Restore previous location */
638         ast_copy_string(chan->context, old_context, sizeof(chan->context));
639         ast_copy_string(chan->exten, old_extension, sizeof(chan->exten));
640         chan->priority = old_priority;
641
642         return RESULT_SUCCESS;
643 }
644
645 struct agi_command gosub_agi_command =
646         { { "gosub", NULL }, handle_gosub, NULL, NULL, 0 };
647
648 static int unload_module(void)
649 {
650         if (ast_agi_unregister) {
651                  ast_agi_unregister(ast_module_info->self, &gosub_agi_command);
652         }
653
654         ast_unregister_application(app_return);
655         ast_unregister_application(app_pop);
656         ast_unregister_application(app_gosubif);
657         ast_unregister_application(app_gosub);
658         ast_custom_function_unregister(&local_function);
659         ast_custom_function_unregister(&peek_function);
660
661         return 0;
662 }
663
664 static int load_module(void)
665 {
666         if (ast_agi_register) {
667                  ast_agi_register(ast_module_info->self, &gosub_agi_command);
668         }
669
670         ast_register_application_xml(app_pop, pop_exec);
671         ast_register_application_xml(app_return, return_exec);
672         ast_register_application_xml(app_gosubif, gosubif_exec);
673         ast_register_application_xml(app_gosub, gosub_exec);
674         ast_custom_function_register(&local_function);
675         ast_custom_function_register(&peek_function);
676
677         return 0;
678 }
679
680 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dialplan subroutines (Gosub, Return, etc)");