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 type="module">res_agi</use>
  30         <support_level>core</support_level>
  31  ***/
  32
  33 #include "asterisk.h"
  34
  35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  36
  37 #include "asterisk/pbx.h"
  38 #include "asterisk/module.h"
  39 #include "asterisk/app.h"
  40 #include "asterisk/manager.h"
  41 #include "asterisk/channel.h"
  42 #include "asterisk/agi.h"
  43 #include "asterisk/stasis_channels.h"
  44
  45 /*** DOCUMENTATION
  46         <application name="Gosub" language="en_US">
  47                 <synopsis>
  48                         Jump to label, saving return address.
  49                 </synopsis>
  50                 <syntax>
  51                         <parameter name="context" />
  52                         <parameter name="exten" />
  53                         <parameter name="priority" required="true" hasparams="optional">
  54                                 <argument name="arg1" multiple="true" required="true" />
  55                                 <argument name="argN" />
  56                         </parameter>
  57                 </syntax>
  58                 <description>
  59                         <para>Jumps to the label specified, saving the return address.</para>
  60                 </description>
  61                 <see-also>
  62                         <ref type="application">GosubIf</ref>
  63                         <ref type="application">Macro</ref>
  64                         <ref type="application">Goto</ref>
  65                         <ref type="application">Return</ref>
  66                         <ref type="application">StackPop</ref>
  67                 </see-also>
  68         </application>
  69         <application name="GosubIf" language="en_US">
  70                 <synopsis>
  71                         Conditionally jump to label, saving return address.
  72                 </synopsis>
  73                 <syntax argsep="?">
  74                         <parameter name="condition" required="true" />
  75                         <parameter name="destination" required="true" argsep=":">
  76                                 <argument name="labeliftrue" hasparams="optional">
  77                                         <para>Continue at <replaceable>labeliftrue</replaceable> if the condition is true.
  78                                         Takes the form similar to Goto() of [[context,]extension,]priority.</para>
  79                                         <argument name="arg1" required="true" multiple="true" />
  80                                         <argument name="argN" />
  81                                 </argument>
  82                                 <argument name="labeliffalse" hasparams="optional">
  83                                         <para>Continue at <replaceable>labeliffalse</replaceable> if the condition is false.
  84                                         Takes the form similar to Goto() of [[context,]extension,]priority.</para>
  85                                         <argument name="arg1" required="true" multiple="true" />
  86                                         <argument name="argN" />
  87                                 </argument>
  88                         </parameter>
  89                 </syntax>
  90                 <description>
  91                         <para>If the condition is true, then jump to labeliftrue.  If false, jumps to
  92                         labeliffalse, if specified.  In either case, a jump saves the return point
  93                         in the dialplan, to be returned to with a Return.</para>
  94                 </description>
  95                 <see-also>
  96                         <ref type="application">Gosub</ref>
  97                         <ref type="application">Return</ref>
  98                         <ref type="application">MacroIf</ref>
  99                         <ref type="function">IF</ref>
 100                         <ref type="application">GotoIf</ref>
 101                         <ref type="application">Goto</ref>
 102                 </see-also>
 103         </application>
 104         <application name="Return" language="en_US">
 105                 <synopsis>
 106                         Return from gosub routine.
 107                 </synopsis>
 108                 <syntax>
 109                         <parameter name="value">
 110                                 <para>Return value.</para>
 111                         </parameter>
 112                 </syntax>
 113                 <description>
 114                         <para>Jumps to the last label on the stack, removing it. The return <replaceable>value</replaceable>, if
 115                         any, is saved in the channel variable <variable>GOSUB_RETVAL</variable>.</para>
 116                 </description>
 117                 <see-also>
 118                         <ref type="application">Gosub</ref>
 119                         <ref type="application">StackPop</ref>
 120                 </see-also>
 121         </application>
 122         <application name="StackPop" language="en_US">
 123                 <synopsis>
 124                         Remove one address from gosub stack.
 125                 </synopsis>
 126                 <syntax />
 127                 <description>
 128                         <para>Removes last label on the stack, discarding it.</para>
 129                 </description>
 130                 <see-also>
 131                         <ref type="application">Return</ref>
 132                         <ref type="application">Gosub</ref>
 133                 </see-also>
 134         </application>
 135         <function name="LOCAL" language="en_US">
 136                 <synopsis>
 137                         Manage variables local to the gosub stack frame.
 138                 </synopsis>
 139                 <syntax>
 140                         <parameter name="varname" required="true" />
 141                 </syntax>
 142                 <description>
 143                         <para>Read and write a variable local to the gosub stack frame, once we Return() it will be lost
 144                         (or it will go back to whatever value it had before the Gosub()).</para>
 145                 </description>
 146                 <see-also>
 147                         <ref type="application">Gosub</ref>
 148                         <ref type="application">GosubIf</ref>
 149                         <ref type="application">Return</ref>
 150                 </see-also>
 151         </function>
 152         <function name="LOCAL_PEEK" language="en_US">
 153                 <synopsis>
 154                         Retrieve variables hidden by the local gosub stack frame.
 155                 </synopsis>
 156                 <syntax>
 157                         <parameter name="n" required="true" />
 158                         <parameter name="varname" required="true" />
 159                 </syntax>
 160                 <description>
 161                         <para>Read a variable <replaceable>varname</replaceable> hidden by
 162                         <replaceable>n</replaceable> levels of gosub stack frames.  Note that ${LOCAL_PEEK(0,foo)}
 163                         is the same as <variable>foo</variable>, since the value of <replaceable>n</replaceable>
 164                         peeks under 0 levels of stack frames; in other words, 0 is the current level.  If
 165                         <replaceable>n</replaceable> exceeds the available number of stack frames, then an empty
 166                         string is returned.</para>
 167                 </description>
 168                 <see-also>
 169                         <ref type="application">Gosub</ref>
 170                         <ref type="application">GosubIf</ref>
 171                         <ref type="application">Return</ref>
 172                 </see-also>
 173         </function>
 174         <function name="STACK_PEEK" language="en_US">
 175                 <synopsis>
 176                         View info about the location which called Gosub
 177                 </synopsis>
 178                 <syntax>
 179                         <parameter name="n" required="true" />
 180                         <parameter name="which" required="true" />
 181                         <parameter name="suppress" required="false" />
 182                 </syntax>
 183                 <description>
 184                         <para>Read the calling <literal>c</literal>ontext, <literal>e</literal>xtension,
 185                         <literal>p</literal>riority, or <literal>l</literal>abel, as specified by
 186                         <replaceable>which</replaceable>, by going up <replaceable>n</replaceable> frames
 187                         in the Gosub stack.  If <replaceable>suppress</replaceable> is true, then if the
 188                         number of available stack frames is exceeded, then no error message will be
 189                         printed.</para>
 190                 </description>
 191         </function>
 192         <agi name="gosub" language="en_US">
 193                 <synopsis>
 194                         Cause the channel to execute the specified dialplan subroutine.
 195                 </synopsis>
 196                 <syntax>
 197                         <parameter name="context" required="true" />
 198                         <parameter name="extension" required="true" />
 199                         <parameter name="priority" required="true" />
 200                         <parameter name="optional-argument" />
 201                 </syntax>
 202                 <description>
 203                         <para>Cause the channel to execute the specified dialplan subroutine,
 204                         returning to the dialplan with execution of a Return().</para>
 205                 </description>
 206                 <see-also>
 207                         <ref type="application">GoSub</ref>
 208                 </see-also>
 209         </agi>
 210         <managerEvent language="en_US" name="VarSet">
 211                 <managerEventInstance class="EVENT_FLAG_DIALPLAN">
 212                         <synopsis>Raised when a variable local to the gosub stack frame is set due to a subroutine call.</synopsis>
 213                         <syntax>
 214                                 <channel_snapshot/>
 215                                 <parameter name="Variable">
 216                                         <para>The LOCAL variable being set.</para>
 217                                         <note><para>The variable name will always be enclosed with
 218                                         <literal>LOCAL()</literal></para></note>
 219                                 </parameter>
 220                                 <parameter name="Value">
 221                                         <para>The new value of the variable.</para>
 222                                 </parameter>
 223                         </syntax>
 224                         <see-also>
 225                                 <ref type="application">GoSub</ref>
 226                                 <ref type="agi">gosub</ref>
 227                                 <ref type="function">LOCAL</ref>
 228                                 <ref type="function">LOCAL_PEEK</ref>
 229                         </see-also>
 230                 </managerEventInstance>
 231         </managerEvent>
 232  ***/
 233
 234 static const char app_gosub[] = "Gosub";
 235 static const char app_gosubif[] = "GosubIf";
 236 static const char app_return[] = "Return";
 237 static const char app_pop[] = "StackPop";
 238
 239 static void gosub_free(void *data);
 240
 241 static const struct ast_datastore_info stack_info = {
 242         .type = "GOSUB",
 243         .destroy = gosub_free,
 244 };
 245
 246 struct gosub_stack_frame {
 247         AST_LIST_ENTRY(gosub_stack_frame) entries;
 248         /* 100 arguments is all that we support anyway, but this will handle up to 255 */
 249         unsigned char arguments;
 250         struct varshead varshead;
 251         int priority;
 252         /*! TRUE if the return location marks the end of a special routine. */
 253         unsigned int is_special:1;
 254         char *context;
 255         char extension[0];
 256 };
 257
 258 AST_LIST_HEAD(gosub_stack_list, gosub_stack_frame);
 259
 260 static int frame_set_var(struct ast_channel *chan, struct gosub_stack_frame *frame, const char *var, const char *value)
 261 {
 262         struct ast_var_t *variables;
 263         int found = 0;
 264         int len;
 265         RAII_VAR(char *, local_buffer, NULL, ast_free);
 266
 267         /* Does this variable already exist? */
 268         AST_LIST_TRAVERSE(&frame->varshead, variables, entries) {
 269                 if (!strcmp(var, ast_var_name(variables))) {
 270                         found = 1;
 271                         break;
 272                 }
 273         }
 274
 275         if (!found) {
 276                 if ((variables = ast_var_assign(var, ""))) {
 277                         AST_LIST_INSERT_HEAD(&frame->varshead, variables, entries);
 278                 }
 279                 pbx_builtin_pushvar_helper(chan, var, value);
 280         } else {
 281                 pbx_builtin_setvar_helper(chan, var, value);
 282         }
 283
 284         len = 8 + strlen(var); /* LOCAL() + var */
 285         local_buffer = ast_malloc(len);
 286         if (!local_buffer) {
 287                 return 0;
 288         }
 289         sprintf(local_buffer, "LOCAL(%s)", var);
 290         ast_channel_publish_varset(chan, local_buffer, value);
 291         return 0;
 292 }
 293
 294 static void gosub_release_frame(struct ast_channel *chan, struct gosub_stack_frame *frame)
 295 {
 296         struct ast_var_t *vardata;
 297
 298         /* If chan is not defined, then we're calling it as part of gosub_free,
 299          * and the channel variables will be deallocated anyway.  Otherwise, we're
 300          * just releasing a single frame, so we need to clean up the arguments for
 301          * that frame, so that we re-expose the variables from the previous frame
 302          * that were hidden by this one.
 303          */
 304         while ((vardata = AST_LIST_REMOVE_HEAD(&frame->varshead, entries))) {
 305                 if (chan)
 306                         pbx_builtin_setvar_helper(chan, ast_var_name(vardata), NULL);
 307                 ast_var_delete(vardata);
 308         }
 309
 310         ast_free(frame);
 311 }
 312
 313 static struct gosub_stack_frame *gosub_allocate_frame(const char *context, const char *extension, int priority, unsigned char arguments)
 314 {
 315         struct gosub_stack_frame *new = NULL;
 316         int len_extension = strlen(extension), len_context = strlen(context);
 317
 318         if ((new = ast_calloc(1, sizeof(*new) + 2 + len_extension + len_context))) {
 319                 AST_LIST_HEAD_INIT_NOLOCK(&new->varshead);
 320                 strcpy(new->extension, extension);
 321                 new->context = new->extension + len_extension + 1;
 322                 strcpy(new->context, context);
 323                 new->priority = priority;
 324                 new->arguments = arguments;
 325         }
 326         return new;
 327 }
 328
 329 static void gosub_free(void *data)
 330 {
 331         struct gosub_stack_list *oldlist = data;
 332         struct gosub_stack_frame *oldframe;
 333
 334         AST_LIST_LOCK(oldlist);
 335         while ((oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
 336                 gosub_release_frame(NULL, oldframe);
 337         }
 338         AST_LIST_UNLOCK(oldlist);
 339         AST_LIST_HEAD_DESTROY(oldlist);
 340         ast_free(oldlist);
 341 }
 342
 343 static int pop_exec(struct ast_channel *chan, const char *data)
 344 {
 345         struct ast_datastore *stack_store;
 346         struct gosub_stack_frame *oldframe;
 347         struct gosub_stack_list *oldlist;
 348         int res = 0;
 349
 350         ast_channel_lock(chan);
 351         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 352                 ast_log(LOG_WARNING, "%s called with no gosub stack allocated.\n", app_pop);
 353                 ast_channel_unlock(chan);
 354                 return 0;
 355         }
 356
 357         oldlist = stack_store->data;
 358         AST_LIST_LOCK(oldlist);
 359         oldframe = AST_LIST_FIRST(oldlist);
 360         if (oldframe) {
 361                 if (oldframe->is_special) {
 362                         ast_debug(1, "%s attempted to pop special return location.\n", app_pop);
 363
 364                         /* Abort the special routine dialplan execution.  Dialplan programming error. */
 365                         res = -1;
 366                 } else {
 367                         AST_LIST_REMOVE_HEAD(oldlist, entries);
 368                         gosub_release_frame(chan, oldframe);
 369                 }
 370         } else {
 371                 ast_debug(1, "%s called with an empty gosub stack\n", app_pop);
 372         }
 373         AST_LIST_UNLOCK(oldlist);
 374         ast_channel_unlock(chan);
 375         return res;
 376 }
 377
 378 static int return_exec(struct ast_channel *chan, const char *data)
 379 {
 380         struct ast_datastore *stack_store;
 381         struct gosub_stack_frame *oldframe;
 382         struct gosub_stack_list *oldlist;
 383         const char *retval = data;
 384         int res = 0;
 385
 386         ast_channel_lock(chan);
 387         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 388                 ast_log(LOG_ERROR, "Return without Gosub: stack is unallocated\n");
 389                 ast_channel_unlock(chan);
 390                 return -1;
 391         }
 392
 393         oldlist = stack_store->data;
 394         AST_LIST_LOCK(oldlist);
 395         oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries);
 396         AST_LIST_UNLOCK(oldlist);
 397
 398         if (!oldframe) {
 399                 ast_log(LOG_ERROR, "Return without Gosub: stack is empty\n");
 400                 ast_channel_unlock(chan);
 401                 return -1;
 402         }
 403         if (oldframe->is_special) {
 404                 /* Exit from special routine. */
 405                 res = -1;
 406         }
 407
 408         /*
 409          * We cannot use ast_explicit_goto() because we MUST restore
 410          * what was there before.  Channels that do not have a PBX may
 411          * not have the context or exten set.
 412          */
 413         ast_channel_context_set(chan, oldframe->context);
 414         ast_channel_exten_set(chan, oldframe->extension);
 415         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP)) {
 416                 --oldframe->priority;
 417         }
 418         ast_channel_priority_set(chan, oldframe->priority);
 419
 420         gosub_release_frame(chan, oldframe);
 421
 422         /* Set a return value, if any */
 423         pbx_builtin_setvar_helper(chan, "GOSUB_RETVAL", S_OR(retval, ""));
 424         ast_channel_unlock(chan);
 425         return res;
 426 }
 427
 428 /*!
 429  * \internal
 430  * \brief Add missing context and/or exten to Gosub application argument string.
 431  * \since 11.0
 432  *
 433  * \param chan Channel to obtain context/exten.
 434  * \param args Gosub application argument string.
 435  *
 436  * \details
 437  * Fills in the optional context and exten from the given channel.
 438  * Convert: [[context,]exten,]priority[(arg1[,...][,argN])]
 439  * To: context,exten,priority[(arg1[,...][,argN])]
 440  *
 441  * \retval expanded Gosub argument string on success.  Must be freed.
 442  * \retval NULL on error.
 443  *
 444  * \note The parsing needs to be kept in sync with the
 445  * gosub_exec() argument format.
 446  */
 447 static const char *expand_gosub_args(struct ast_channel *chan, const char *args)
 448 {
 449         int len;
 450         char *parse;
 451         char *label;
 452         char *new_args;
 453         const char *context;
 454         const char *exten;
 455         const char *pri;
 456
 457         /* Separate the context,exten,pri from the optional routine arguments. */
 458         parse = ast_strdupa(args);
 459         label = strsep(&parse, "(");
 460         if (parse) {
 461                 char *endparen;
 462
 463                 endparen = strrchr(parse, ')');
 464                 if (endparen) {
 465                         *endparen = '\0';
 466                 } else {
 467                         ast_log(LOG_WARNING, "Ouch.  No closing paren: '%s'?\n", args);
 468                 }
 469         }
 470
 471         /* Split context,exten,pri */
 472         context = strsep(&label, ",");
 473         exten = strsep(&label, ",");
 474         pri = strsep(&label, ",");
 475         if (!exten) {
 476                 /* Only a priority in this one */
 477                 pri = context;
 478                 exten = NULL;
 479                 context = NULL;
 480         } else if (!pri) {
 481                 /* Only an extension and priority in this one */
 482                 pri = exten;
 483                 exten = context;
 484                 context = NULL;
 485         }
 486
 487         ast_channel_lock(chan);
 488         if (ast_strlen_zero(exten)) {
 489                 exten = ast_channel_exten(chan);
 490         }
 491         if (ast_strlen_zero(context)) {
 492                 context = ast_channel_context(chan);
 493         }
 494         len = strlen(context) + strlen(exten) + strlen(pri) + 3;
 495         if (!ast_strlen_zero(parse)) {
 496                 len += 2 + strlen(parse);
 497         }
 498         new_args = ast_malloc(len);
 499         if (new_args) {
 500                 if (ast_strlen_zero(parse)) {
 501                         snprintf(new_args, len, "%s,%s,%s", context, exten, pri);
 502                 } else {
 503                         snprintf(new_args, len, "%s,%s,%s(%s)", context, exten, pri, parse);
 504                 }
 505         }
 506         ast_channel_unlock(chan);
 507
 508         ast_debug(4, "Gosub args:%s new_args:%s\n", args, new_args ? new_args : "");
 509
 510         return new_args;
 511 }
 512
 513 static int gosub_exec(struct ast_channel *chan, const char *data)
 514 {
 515         struct ast_datastore *stack_store;
 516         struct gosub_stack_list *oldlist;
 517         struct gosub_stack_frame *newframe;
 518         struct gosub_stack_frame *lastframe;
 519         char argname[15];
 520         char *parse;
 521         char *label;
 522         char *caller_id;
 523         char *orig_context;
 524         char *orig_exten;
 525         char *dest_context;
 526         char *dest_exten;
 527         int orig_priority;
 528         int dest_priority;
 529         int i;
 530         int max_argc = 0;
 531         AST_DECLARE_APP_ARGS(args2,
 532                 AST_APP_ARG(argval)[100];
 533         );
 534
 535         if (ast_strlen_zero(data)) {
 536                 ast_log(LOG_ERROR, "%s requires an argument: %s([[context,]exten,]priority[(arg1[,...][,argN])])\n", app_gosub, app_gosub);
 537                 return -1;
 538         }
 539
 540         /*
 541          * Separate the arguments from the label
 542          *
 543          * NOTE:  You cannot use ast_app_separate_args for this, because
 544          * '(' cannot be used as a delimiter.
 545          */
 546         parse = ast_strdupa(data);
 547         label = strsep(&parse, "(");
 548         if (parse) {
 549                 char *endparen;
 550
 551                 endparen = strrchr(parse, ')');
 552                 if (endparen) {
 553                         *endparen = '\0';
 554                 } else {
 555                         ast_log(LOG_WARNING, "Ouch.  No closing paren: '%s'?\n", data);
 556                 }
 557                 AST_STANDARD_RAW_ARGS(args2, parse);
 558         } else {
 559                 args2.argc = 0;
 560         }
 561
 562         ast_channel_lock(chan);
 563         orig_context = ast_strdupa(ast_channel_context(chan));
 564         orig_exten = ast_strdupa(ast_channel_exten(chan));
 565         orig_priority = ast_channel_priority(chan);
 566         ast_channel_unlock(chan);
 567
 568         if (ast_parseable_goto(chan, label)) {
 569                 ast_log(LOG_ERROR, "%s address is invalid: '%s'\n", app_gosub, data);
 570                 goto error_exit;
 571         }
 572
 573         ast_channel_lock(chan);
 574         dest_context = ast_strdupa(ast_channel_context(chan));
 575         dest_exten = ast_strdupa(ast_channel_exten(chan));
 576         dest_priority = ast_channel_priority(chan);
 577         if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP)) {
 578                 ++dest_priority;
 579         }
 580         caller_id = S_COR(ast_channel_caller(chan)->id.number.valid,
 581                 ast_channel_caller(chan)->id.number.str, NULL);
 582         if (caller_id) {
 583                 caller_id = ast_strdupa(caller_id);
 584         }
 585         ast_channel_unlock(chan);
 586
 587         if (!ast_exists_extension(chan, dest_context, dest_exten, dest_priority, caller_id)) {
 588                 ast_log(LOG_ERROR, "Attempt to reach a non-existent destination for %s: (Context:%s, Extension:%s, Priority:%d)\n",
 589                         app_gosub, dest_context, dest_exten, dest_priority);
 590                 goto error_exit;
 591         }
 592
 593         /* Now we know that we're going to a new location */
 594
 595         ast_channel_lock(chan);
 596
 597         /* Find stack datastore return list. */
 598         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 599                 ast_debug(1, "Channel %s has no datastore, so we're allocating one.\n",
 600                         ast_channel_name(chan));
 601                 stack_store = ast_datastore_alloc(&stack_info, NULL);
 602                 if (!stack_store) {
 603                         ast_log(LOG_ERROR, "Unable to allocate new datastore.  %s failed.\n",
 604                                 app_gosub);
 605                         goto error_exit_locked;
 606                 }
 607
 608                 oldlist = ast_calloc(1, sizeof(*oldlist));
 609                 if (!oldlist) {
 610                         ast_log(LOG_ERROR, "Unable to allocate datastore list head.  %s failed.\n",
 611                                 app_gosub);
 612                         ast_datastore_free(stack_store);
 613                         goto error_exit_locked;
 614                 }
 615                 AST_LIST_HEAD_INIT(oldlist);
 616
 617                 stack_store->data = oldlist;
 618                 ast_channel_datastore_add(chan, stack_store);
 619         } else {
 620                 oldlist = stack_store->data;
 621         }
 622
 623         if ((lastframe = AST_LIST_FIRST(oldlist))) {
 624                 max_argc = lastframe->arguments;
 625         }
 626
 627         /* Mask out previous Gosub arguments in this invocation */
 628         if (args2.argc > max_argc) {
 629                 max_argc = args2.argc;
 630         }
 631
 632         /* Create the return address */
 633         newframe = gosub_allocate_frame(orig_context, orig_exten, orig_priority + 1, max_argc);
 634         if (!newframe) {
 635                 goto error_exit_locked;
 636         }
 637
 638         /* Set our arguments */
 639         for (i = 0; i < max_argc; i++) {
 640                 snprintf(argname, sizeof(argname), "ARG%d", i + 1);
 641                 frame_set_var(chan, newframe, argname, i < args2.argc ? args2.argval[i] : "");
 642                 ast_debug(1, "Setting '%s' to '%s'\n", argname, i < args2.argc ? args2.argval[i] : "");
 643         }
 644         snprintf(argname, sizeof(argname), "%d", args2.argc);
 645         frame_set_var(chan, newframe, "ARGC", argname);
 646
 647         /* And finally, save our return address */
 648         AST_LIST_LOCK(oldlist);
 649         AST_LIST_INSERT_HEAD(oldlist, newframe, entries);
 650         AST_LIST_UNLOCK(oldlist);
 651         ast_channel_unlock(chan);
 652
 653         return 0;
 654
 655 error_exit:
 656         ast_channel_lock(chan);
 657
 658 error_exit_locked:
 659         /* Restore the original dialplan location. */
 660         ast_channel_context_set(chan, orig_context);
 661         ast_channel_exten_set(chan, orig_exten);
 662         ast_channel_priority_set(chan, orig_priority);
 663         ast_channel_unlock(chan);
 664         return -1;
 665 }
 666
 667 static int gosubif_exec(struct ast_channel *chan, const char *data)
 668 {
 669         char *args;
 670         int res=0;
 671         AST_DECLARE_APP_ARGS(cond,
 672                 AST_APP_ARG(ition);
 673                 AST_APP_ARG(labels);
 674         );
 675         AST_DECLARE_APP_ARGS(label,
 676                 AST_APP_ARG(iftrue);
 677                 AST_APP_ARG(iffalse);
 678         );
 679
 680         if (ast_strlen_zero(data)) {
 681                 ast_log(LOG_WARNING, "GosubIf requires an argument: GosubIf(cond?label1(args):label2(args)\n");
 682                 return 0;
 683         }
 684
 685         args = ast_strdupa(data);
 686         AST_NONSTANDARD_RAW_ARGS(cond, args, '?');
 687         if (cond.argc != 2) {
 688                 ast_log(LOG_WARNING, "GosubIf requires an argument: GosubIf(cond?label1(args):label2(args)\n");
 689                 return 0;
 690         }
 691
 692         AST_NONSTANDARD_RAW_ARGS(label, cond.labels, ':');
 693
 694         if (pbx_checkcondition(cond.ition)) {
 695                 if (!ast_strlen_zero(label.iftrue))
 696                         res = gosub_exec(chan, label.iftrue);
 697         } else if (!ast_strlen_zero(label.iffalse)) {
 698                 res = gosub_exec(chan, label.iffalse);
 699         }
 700
 701         return res;
 702 }
 703
 704 static int local_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 705 {
 706         struct ast_datastore *stack_store;
 707         struct gosub_stack_list *oldlist;
 708         struct gosub_stack_frame *frame;
 709         struct ast_var_t *variables;
 710
 711         if (!chan) {
 712                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
 713                 return -1;
 714         }
 715
 716         ast_channel_lock(chan);
 717         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 718                 ast_channel_unlock(chan);
 719                 return -1;
 720         }
 721
 722         oldlist = stack_store->data;
 723         AST_LIST_LOCK(oldlist);
 724         if (!(frame = AST_LIST_FIRST(oldlist))) {
 725                 /* Not within a Gosub routine */
 726                 AST_LIST_UNLOCK(oldlist);
 727                 ast_channel_unlock(chan);
 728                 return -1;
 729         }
 730
 731         AST_LIST_TRAVERSE(&frame->varshead, variables, entries) {
 732                 if (!strcmp(data, ast_var_name(variables))) {
 733                         const char *tmp;
 734                         tmp = pbx_builtin_getvar_helper(chan, data);
 735                         ast_copy_string(buf, S_OR(tmp, ""), len);
 736                         break;
 737                 }
 738         }
 739         AST_LIST_UNLOCK(oldlist);
 740         ast_channel_unlock(chan);
 741         return 0;
 742 }
 743
 744 static int local_write(struct ast_channel *chan, const char *cmd, char *var, const char *value)
 745 {
 746         struct ast_datastore *stack_store;
 747         struct gosub_stack_list *oldlist;
 748         struct gosub_stack_frame *frame;
 749
 750         if (!chan) {
 751                 ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
 752                 return -1;
 753         }
 754
 755         ast_channel_lock(chan);
 756         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 757                 ast_log(LOG_ERROR, "Tried to set LOCAL(%s), but we aren't within a Gosub routine\n", var);
 758                 ast_channel_unlock(chan);
 759                 return -1;
 760         }
 761
 762         oldlist = stack_store->data;
 763         AST_LIST_LOCK(oldlist);
 764         frame = AST_LIST_FIRST(oldlist);
 765
 766         if (frame) {
 767                 frame_set_var(chan, frame, var, value);
 768         }
 769
 770         AST_LIST_UNLOCK(oldlist);
 771         ast_channel_unlock(chan);
 772
 773         return 0;
 774 }
 775
 776 static struct ast_custom_function local_function = {
 777         .name = "LOCAL",
 778         .write = local_write,
 779         .read = local_read,
 780 };
 781
 782 static int peek_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
 783 {
 784         int found = 0, n;
 785         struct ast_var_t *variables;
 786         AST_DECLARE_APP_ARGS(args,
 787                 AST_APP_ARG(n);
 788                 AST_APP_ARG(name);
 789         );
 790
 791         if (!chan) {
 792                 ast_log(LOG_ERROR, "LOCAL_PEEK must be called on an active channel\n");
 793                 return -1;
 794         }
 795
 796         AST_STANDARD_RAW_ARGS(args, data);
 797
 798         if (ast_strlen_zero(args.n) || ast_strlen_zero(args.name)) {
 799                 ast_log(LOG_ERROR, "LOCAL_PEEK requires parameters n and varname\n");
 800                 return -1;
 801         }
 802
 803         n = atoi(args.n);
 804         *buf = '\0';
 805
 806         ast_channel_lock(chan);
 807         AST_LIST_TRAVERSE(ast_channel_varshead(chan), variables, entries) {
 808                 if (!strcmp(args.name, ast_var_name(variables)) && ++found > n) {
 809                         ast_copy_string(buf, ast_var_value(variables), len);
 810                         break;
 811                 }
 812         }
 813         ast_channel_unlock(chan);
 814         return 0;
 815 }
 816
 817 static struct ast_custom_function peek_function = {
 818         .name = "LOCAL_PEEK",
 819         .read = peek_read,
 820 };
 821
 822 static int stackpeek_read(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **str, ssize_t len)
 823 {
 824         struct ast_datastore *stack_store;
 825         struct gosub_stack_list *oldlist;
 826         struct gosub_stack_frame *frame;
 827         int n;
 828         AST_DECLARE_APP_ARGS(args,
 829                 AST_APP_ARG(n);
 830                 AST_APP_ARG(which);
 831                 AST_APP_ARG(suppress);
 832         );
 833
 834         if (!chan) {
 835                 ast_log(LOG_ERROR, "STACK_PEEK must be called on an active channel\n");
 836                 return -1;
 837         }
 838
 839         data = ast_strdupa(data);
 840         AST_STANDARD_APP_ARGS(args, data);
 841
 842         if (ast_strlen_zero(args.n) || ast_strlen_zero(args.which)) {
 843                 ast_log(LOG_ERROR, "STACK_PEEK requires parameters n and which\n");
 844                 return -1;
 845         }
 846
 847         n = atoi(args.n);
 848         if (n <= 0) {
 849                 ast_log(LOG_ERROR, "STACK_PEEK must be called with a positive peek value\n");
 850                 return -1;
 851         }
 852
 853         ast_channel_lock(chan);
 854         if (!(stack_store = ast_channel_datastore_find(chan, &stack_info, NULL))) {
 855                 if (!ast_true(args.suppress)) {
 856                         ast_log(LOG_ERROR, "STACK_PEEK called on a channel without a gosub stack\n");
 857                 }
 858                 ast_channel_unlock(chan);
 859                 return -1;
 860         }
 861
 862         oldlist = stack_store->data;
 863
 864         AST_LIST_LOCK(oldlist);
 865         AST_LIST_TRAVERSE(oldlist, frame, entries) {
 866                 if (--n == 0) {
 867                         break;
 868                 }
 869         }
 870
 871         if (!frame) {
 872                 /* Too deep */
 873                 if (!ast_true(args.suppress)) {
 874                         ast_log(LOG_ERROR, "Stack peek of '%s' is more stack frames than I have\n", args.n);
 875                 }
 876                 AST_LIST_UNLOCK(oldlist);
 877                 ast_channel_unlock(chan);
 878                 return -1;
 879         }
 880
 881         args.which = ast_skip_blanks(args.which);
 882
 883         switch (args.which[0]) {
 884         case 'l': /* label */
 885                 ast_str_set(str, len, "%s,%s,%d", frame->context, frame->extension, frame->priority - 1);
 886                 break;
 887         case 'c': /* context */
 888                 ast_str_set(str, len, "%s", frame->context);
 889                 break;
 890         case 'e': /* extension */
 891                 ast_str_set(str, len, "%s", frame->extension);
 892                 break;
 893         case 'p': /* priority */
 894                 ast_str_set(str, len, "%d", frame->priority - 1);
 895                 break;
 896         default:
 897                 ast_log(LOG_ERROR, "Unknown argument '%s' to STACK_PEEK\n", args.which);
 898                 break;
 899         }
 900
 901         AST_LIST_UNLOCK(oldlist);
 902         ast_channel_unlock(chan);
 903
 904         return 0;
 905 }
 906
 907 static struct ast_custom_function stackpeek_function = {
 908         .name = "STACK_PEEK",
 909         .read2 = stackpeek_read,
 910 };
 911
 912 /*!
 913  * \internal
 914  * \brief Pop stack frames until remove a special return location.
 915  * \since 11.0
 916  *
 917  * \param chan Channel to balance stack on.
 918  *
 919  * \note The channel is already locked when called.
 920  *
 921  * \return Nothing
 922  */
 923 static void balance_stack(struct ast_channel *chan)
 924 {
 925         struct ast_datastore *stack_store;
 926         struct gosub_stack_list *oldlist;
 927         struct gosub_stack_frame *oldframe;
 928         int found;
 929
 930         stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
 931         if (!stack_store) {
 932                 ast_log(LOG_WARNING, "No %s stack allocated.\n", app_gosub);
 933                 return;
 934         }
 935
 936         oldlist = stack_store->data;
 937         AST_LIST_LOCK(oldlist);
 938         do {
 939                 oldframe = AST_LIST_REMOVE_HEAD(oldlist, entries);
 940                 if (!oldframe) {
 941                         break;
 942                 }
 943                 found = oldframe->is_special;
 944                 gosub_release_frame(chan, oldframe);
 945         } while (!found);
 946         AST_LIST_UNLOCK(oldlist);
 947 }
 948
 949 /*!
 950  * \internal
 951  * \brief Run a subroutine on a channel.
 952  * \since 11.0
 953  *
 954  * \note Absolutely _NO_ channel locks should be held before calling this function.
 955  *
 956  * \param chan Channel to execute subroutine on.
 957  * \param sub_args Gosub application argument string.
 958  * \param ignore_hangup TRUE if a hangup does not stop execution of the routine.
 959  *
 960  * \retval 0 success
 961  * \retval -1 on error
 962  */
 963 static int gosub_run(struct ast_channel *chan, const char *sub_args, int ignore_hangup)
 964 {
 965         const char *saved_context;
 966         const char *saved_exten;
 967         int saved_priority;
 968         int saved_hangup_flags;
 969         int saved_autoloopflag;
 970         int res;
 971
 972         ast_channel_lock(chan);
 973
 974         ast_verb(3, "%s Internal %s(%s) start\n",
 975                 ast_channel_name(chan), app_gosub, sub_args);
 976
 977         /* Save non-hangup softhangup flags. */
 978         saved_hangup_flags = ast_channel_softhangup_internal_flag(chan)
 979                 & (AST_SOFTHANGUP_ASYNCGOTO | AST_SOFTHANGUP_UNBRIDGE);
 980         if (saved_hangup_flags) {
 981                 ast_channel_clear_softhangup(chan,
 982                         AST_SOFTHANGUP_ASYNCGOTO | AST_SOFTHANGUP_UNBRIDGE);
 983         }
 984
 985         /* Save autoloop flag */
 986         saved_autoloopflag = ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
 987         ast_set_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
 988
 989         /* Save current dialplan location */
 990         saved_context = ast_strdupa(ast_channel_context(chan));
 991         saved_exten = ast_strdupa(ast_channel_exten(chan));
 992         saved_priority = ast_channel_priority(chan);
 993
 994         ast_debug(4, "%s Original location: %s,%s,%d\n", ast_channel_name(chan),
 995                 saved_context, saved_exten, saved_priority);
 996
 997         ast_channel_unlock(chan);
 998         res = gosub_exec(chan, sub_args);
 999         ast_debug(4, "%s exited with status %d\n", app_gosub, res);
1000         ast_channel_lock(chan);
1001         if (!res) {
1002                 struct ast_datastore *stack_store;
1003
1004                 /* Mark the return location as special. */
1005                 stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
1006                 if (!stack_store) {
1007                         /* Should never happen! */
1008                         ast_log(LOG_ERROR, "No %s stack!\n", app_gosub);
1009                         res = -1;
1010                 } else {
1011                         struct gosub_stack_list *oldlist;
1012                         struct gosub_stack_frame *cur;
1013
1014                         oldlist = stack_store->data;
1015                         cur = AST_LIST_FIRST(oldlist);
1016                         cur->is_special = 1;
1017                 }
1018         }
1019         if (!res) {
1020                 int found = 0;  /* set if we find at least one match */
1021
1022                 /*
1023                  * Run gosub body autoloop.
1024                  *
1025                  * Note that this loop is inverted from the normal execution
1026                  * loop because we just executed the Gosub application as the
1027                  * first extension of the autoloop.
1028                  */
1029                 do {
1030                         /* Check for hangup. */
1031                         if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_UNBRIDGE) {
1032                                 saved_hangup_flags |= AST_SOFTHANGUP_UNBRIDGE;
1033                                 ast_channel_clear_softhangup(chan, AST_SOFTHANGUP_UNBRIDGE);
1034                         }
1035                         if (ast_check_hangup(chan)) {
1036                                 if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
1037                                         ast_log(LOG_ERROR, "%s An async goto just messed up our execution location.\n",
1038                                                 ast_channel_name(chan));
1039                                         break;
1040                                 }
1041                                 if (!ignore_hangup) {
1042                                         break;
1043                                 }
1044                         }
1045
1046                         /* Next dialplan priority. */
1047                         ast_channel_priority_set(chan, ast_channel_priority(chan) + 1);
1048
1049                         ast_channel_unlock(chan);
1050                         res = ast_spawn_extension(chan, ast_channel_context(chan),
1051                                 ast_channel_exten(chan), ast_channel_priority(chan),
1052                                 S_COR(ast_channel_caller(chan)->id.number.valid,
1053                                         ast_channel_caller(chan)->id.number.str, NULL),
1054                                 &found, 1);
1055                         ast_channel_lock(chan);
1056                 } while (!res);
1057                 if (found && res) {
1058                         /* Something bad happened, or a hangup has been requested. */
1059                         ast_debug(1, "Spawn extension (%s,%s,%d) exited with %d on '%s'\n",
1060                                 ast_channel_context(chan), ast_channel_exten(chan),
1061                                 ast_channel_priority(chan), res, ast_channel_name(chan));
1062                         ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n",
1063                                 ast_channel_context(chan), ast_channel_exten(chan),
1064                                 ast_channel_priority(chan), ast_channel_name(chan));
1065                 }
1066
1067                 /* Did the routine return? */
1068                 if (ast_channel_priority(chan) == saved_priority
1069                         && !strcmp(ast_channel_context(chan), saved_context)
1070                         && !strcmp(ast_channel_exten(chan), saved_exten)) {
1071                         ast_verb(3, "%s Internal %s(%s) complete GOSUB_RETVAL=%s\n",
1072                                 ast_channel_name(chan), app_gosub, sub_args,
1073                                 S_OR(pbx_builtin_getvar_helper(chan, "GOSUB_RETVAL"), ""));
1074                 } else {
1075                         ast_log(LOG_NOTICE, "%s Abnormal '%s(%s)' exit.  Popping routine return locations.\n",
1076                                 ast_channel_name(chan), app_gosub, sub_args);
1077                         balance_stack(chan);
1078                         pbx_builtin_setvar_helper(chan, "GOSUB_RETVAL", "");
1079                 }
1080
1081                 /* We executed the requested subroutine to the best of our ability. */
1082                 res = 0;
1083         }
1084
1085         ast_debug(4, "%s Ending location: %s,%s,%d\n", ast_channel_name(chan),
1086                 ast_channel_context(chan), ast_channel_exten(chan),
1087                 ast_channel_priority(chan));
1088
1089         /* Restore dialplan location */
1090         if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)) {
1091                 ast_channel_context_set(chan, saved_context);
1092                 ast_channel_exten_set(chan, saved_exten);
1093                 ast_channel_priority_set(chan, saved_priority);
1094         }
1095
1096         /* Restore autoloop flag */
1097         ast_set2_flag(ast_channel_flags(chan), saved_autoloopflag, AST_FLAG_IN_AUTOLOOP);
1098
1099         /* Restore non-hangup softhangup flags. */
1100         if (saved_hangup_flags) {
1101                 ast_softhangup_nolock(chan, saved_hangup_flags);
1102         }
1103
1104         ast_channel_unlock(chan);
1105
1106         return res;
1107 }
1108
1109 static int handle_gosub(struct ast_channel *chan, AGI *agi, int argc, const char * const *argv)
1110 {
1111         int res;
1112         int priority;
1113         int old_autoloopflag;
1114         int old_priority;
1115         const char *old_context;
1116         const char *old_extension;
1117         char *gosub_args;
1118
1119         if (argc < 4 || argc > 5) {
1120                 return RESULT_SHOWUSAGE;
1121         }
1122
1123         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] : "");
1124
1125         if (sscanf(argv[3], "%30d", &priority) != 1 || priority < 1) {
1126                 /* Lookup the priority label */
1127                 priority = ast_findlabel_extension(chan, argv[1], argv[2], argv[3],
1128                         S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL));
1129                 if (priority < 0) {
1130                         ast_log(LOG_ERROR, "Priority '%s' not found in '%s@%s'\n", argv[3], argv[2], argv[1]);
1131                         ast_agi_send(agi->fd, chan, "200 result=-1 Gosub label not found\n");
1132                         return RESULT_FAILURE;
1133                 }
1134         } else if (!ast_exists_extension(chan, argv[1], argv[2], priority,
1135                 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
1136                 ast_agi_send(agi->fd, chan, "200 result=-1 Gosub label not found\n");
1137                 return RESULT_FAILURE;
1138         }
1139
1140         if (argc == 5) {
1141                 if (ast_asprintf(&gosub_args, "%s,%s,%d(%s)", argv[1], argv[2], priority, argv[4]) < 0) {
1142                         gosub_args = NULL;
1143                 }
1144         } else {
1145                 if (ast_asprintf(&gosub_args, "%s,%s,%d", argv[1], argv[2], priority) < 0) {
1146                         gosub_args = NULL;
1147                 }
1148         }
1149         if (!gosub_args) {
1150                 ast_agi_send(agi->fd, chan, "503 result=-2 Memory allocation failure\n");
1151                 return RESULT_FAILURE;
1152         }
1153
1154         ast_channel_lock(chan);
1155
1156         ast_verb(3, "%s AGI %s(%s) start\n", ast_channel_name(chan), app_gosub, gosub_args);
1157
1158         /* Save autoloop flag */
1159         old_autoloopflag = ast_test_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
1160         ast_set_flag(ast_channel_flags(chan), AST_FLAG_IN_AUTOLOOP);
1161
1162         /* Save previous location, since we're going to change it */
1163         old_context = ast_strdupa(ast_channel_context(chan));
1164         old_extension = ast_strdupa(ast_channel_exten(chan));
1165         old_priority = ast_channel_priority(chan);
1166
1167         ast_debug(4, "%s Original location: %s,%s,%d\n", ast_channel_name(chan),
1168                 old_context, old_extension, old_priority);
1169         ast_channel_unlock(chan);
1170
1171         res = gosub_exec(chan, gosub_args);
1172         if (!res) {
1173                 struct ast_datastore *stack_store;
1174
1175                 /* Mark the return location as special. */
1176                 ast_channel_lock(chan);
1177                 stack_store = ast_channel_datastore_find(chan, &stack_info, NULL);
1178                 if (!stack_store) {
1179                         /* Should never happen! */
1180                         ast_log(LOG_ERROR, "No %s stack!\n", app_gosub);
1181                         res = -1;
1182                 } else {
1183                         struct gosub_stack_list *oldlist;
1184                         struct gosub_stack_frame *cur;
1185
1186                         oldlist = stack_store->data;
1187                         cur = AST_LIST_FIRST(oldlist);
1188                         cur->is_special = 1;
1189                 }
1190                 ast_channel_unlock(chan);
1191         }
1192         if (!res) {
1193                 struct ast_pbx *pbx;
1194                 struct ast_pbx_args args;
1195                 int abnormal_exit;
1196
1197                 memset(&args, 0, sizeof(args));
1198                 args.no_hangup_chan = 1;
1199
1200                 ast_channel_lock(chan);
1201
1202                 /* Next dialplan priority. */
1203                 ast_channel_priority_set(chan, ast_channel_priority(chan) + 1);
1204
1205                 /* Suppress warning about PBX already existing */
1206                 pbx = ast_channel_pbx(chan);
1207                 ast_channel_pbx_set(chan, NULL);
1208                 ast_channel_unlock(chan);
1209
1210                 ast_agi_send(agi->fd, chan, "100 result=0 Trying...\n");
1211                 ast_pbx_run_args(chan, &args);
1212
1213                 ast_channel_lock(chan);
1214                 ast_free(ast_channel_pbx(chan));
1215                 ast_channel_pbx_set(chan, pbx);
1216
1217                 /* Did the routine return? */
1218                 if (ast_channel_priority(chan) == old_priority
1219                         && !strcmp(ast_channel_context(chan), old_context)
1220                         && !strcmp(ast_channel_exten(chan), old_extension)) {
1221                         ast_verb(3, "%s AGI %s(%s) complete GOSUB_RETVAL=%s\n",
1222                                 ast_channel_name(chan), app_gosub, gosub_args,
1223                                 S_OR(pbx_builtin_getvar_helper(chan, "GOSUB_RETVAL"), ""));
1224                         abnormal_exit = 0;
1225                 } else {
1226                         ast_log(LOG_NOTICE, "%s Abnormal AGI %s(%s) exit.  Popping routine return locations.\n",
1227                                 ast_channel_name(chan), app_gosub, gosub_args);
1228                         balance_stack(chan);
1229                         pbx_builtin_setvar_helper(chan, "GOSUB_RETVAL", "");
1230                         abnormal_exit = 1;
1231                 }
1232                 ast_channel_unlock(chan);
1233
1234                 ast_agi_send(agi->fd, chan, "200 result=0 Gosub complete%s\n",
1235                         abnormal_exit ? " (abnormal exit)" : "");
1236         } else {
1237                 ast_agi_send(agi->fd, chan, "200 result=%d Gosub failed\n", res);
1238         }
1239
1240         ast_free(gosub_args);
1241
1242         ast_channel_lock(chan);
1243         ast_debug(4, "%s Ending location: %s,%s,%d\n", ast_channel_name(chan),
1244                 ast_channel_context(chan), ast_channel_exten(chan),
1245                 ast_channel_priority(chan));
1246
1247         /* Restore previous location */
1248         ast_channel_context_set(chan, old_context);
1249         ast_channel_exten_set(chan, old_extension);
1250         ast_channel_priority_set(chan, old_priority);
1251
1252         /* Restore autoloop flag */
1253         ast_set2_flag(ast_channel_flags(chan), old_autoloopflag, AST_FLAG_IN_AUTOLOOP);
1254         ast_channel_unlock(chan);
1255
1256         return RESULT_SUCCESS;
1257 }
1258
1259 static struct agi_command gosub_agi_command =
1260         { { "gosub", NULL }, handle_gosub, NULL, NULL, 0 };
1261
1262 static int unload_module(void)
1263 {
1264         ast_install_stack_functions(NULL);
1265
1266         ast_agi_unregister(ast_module_info->self, &gosub_agi_command);
1267
1268         ast_unregister_application(app_return);
1269         ast_unregister_application(app_pop);
1270         ast_unregister_application(app_gosubif);
1271         ast_unregister_application(app_gosub);
1272         ast_custom_function_unregister(&local_function);
1273         ast_custom_function_unregister(&peek_function);
1274         ast_custom_function_unregister(&stackpeek_function);
1275
1276         return 0;
1277 }
1278
1279 static int load_module(void)
1280 {
1281         /* Setup the stack application callback functions. */
1282         static struct ast_app_stack_funcs funcs = {
1283                 .run_sub = gosub_run,
1284                 .expand_sub_args = expand_gosub_args,
1285         };
1286
1287         ast_agi_register(ast_module_info->self, &gosub_agi_command);
1288
1289         ast_register_application_xml(app_pop, pop_exec);
1290         ast_register_application_xml(app_return, return_exec);
1291         ast_register_application_xml(app_gosubif, gosubif_exec);
1292         ast_register_application_xml(app_gosub, gosub_exec);
1293         ast_custom_function_register(&local_function);
1294         ast_custom_function_register(&peek_function);
1295         ast_custom_function_register(&stackpeek_function);
1296
1297         funcs.module = ast_module_info->self,
1298         ast_install_stack_functions(&funcs);
1299
1300         return 0;
1301 }
1302
1303 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT | AST_MODFLAG_LOAD_ORDER, "Dialplan subroutines (Gosub, Return, etc)",
1304                 .load = load_module,
1305                 .unload = unload_module,
1306                 .load_pri = AST_MODPRI_APP_DEPEND,
1307                 .nonoptreq = "res_agi",
1308                 );