res/res_agi.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, 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 AGI - the Asterisk Gateway Interface
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  */
  25
  26 #include "asterisk.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #include <sys/types.h>
  31 #include <netdb.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34 #include <netinet/tcp.h>
  35 #include <arpa/inet.h>
  36 #include <math.h>
  37 #include <stdlib.h>
  38 #include <unistd.h>
  39 #include <string.h>
  40 #include <stdlib.h>
  41 #include <signal.h>
  42 #include <sys/time.h>
  43 #include <stdio.h>
  44 #include <fcntl.h>
  45 #include <errno.h>
  46 #include <sys/wait.h>
  47
  48 #include "asterisk/file.h"
  49 #include "asterisk/logger.h"
  50 #include "asterisk/channel.h"
  51 #include "asterisk/pbx.h"
  52 #include "asterisk/module.h"
  53 #include "asterisk/astdb.h"
  54 #include "asterisk/callerid.h"
  55 #include "asterisk/cli.h"
  56 #include "asterisk/logger.h"
  57 #include "asterisk/options.h"
  58 #include "asterisk/image.h"
  59 #include "asterisk/say.h"
  60 #include "asterisk/app.h"
  61 #include "asterisk/dsp.h"
  62 #include "asterisk/musiconhold.h"
  63 #include "asterisk/utils.h"
  64 #include "asterisk/lock.h"
  65 #include "asterisk/strings.h"
  66 #include "asterisk/agi.h"
  67
  68 #define MAX_ARGS 128
  69 #define MAX_COMMANDS 128
  70
  71 /* Recycle some stuff from the CLI interface */
  72 #define fdprintf agi_debug_cli
  73
  74 static char *app = "AGI";
  75
  76 static char *eapp = "EAGI";
  77
  78 static char *deadapp = "DeadAGI";
  79
  80 static char *synopsis = "Executes an AGI compliant application";
  81 static char *esynopsis = "Executes an EAGI compliant application";
  82 static char *deadsynopsis = "Executes AGI on a hungup channel";
  83
  84 static char *descrip =
  85 "  [E|Dead]AGI(command|args): Executes an Asterisk Gateway Interface compliant\n"
  86 "program on a channel. AGI allows Asterisk to launch external programs\n"
  87 "written in any language to control a telephony channel, play audio,\n"
  88 "read DTMF digits, etc. by communicating with the AGI protocol on stdin\n"
  89 "and stdout.\n"
  90 "  This channel will stop dialplan execution on hangup inside of this\n"
  91 "application, except when using DeadAGI.  Otherwise, dialplan execution\n"
  92 "will continue normally.\n"
  93 "  A locally executed AGI script will receive SIGHUP on hangup from the channel\n"
  94 "except when using DeadAGI. This can be disabled by setting the AGISIGHUP channel\n"
  95 "variable to \"no\" before executing the AGI application.\n"
  96 "  Using 'EAGI' provides enhanced AGI, with incoming audio available out of band\n"
  97 "on file descriptor 3\n\n"
  98 "  Use the CLI command 'agi show' to list available agi commands\n"
  99 "  This application sets the following channel variable upon completion:\n"
 100 "     AGISTATUS      The status of the attempt to the run the AGI script\n"
 101 "                    text string, one of SUCCESS | FAILED | HANGUP\n";
 102
 103 static int agidebug = 0;
 104
 105 #define TONE_BLOCK_SIZE 200
 106
 107 /* Max time to connect to an AGI remote host */
 108 #define MAX_AGI_CONNECT 2000
 109
 110 #define AGI_PORT 4573
 111
 112 enum agi_result {
 113         AGI_RESULT_SUCCESS,
 114         AGI_RESULT_FAILURE,
 115         AGI_RESULT_HANGUP
 116 };
 117
 118 static void agi_debug_cli(int fd, char *fmt, ...)
 119 {
 120         char *stuff;
 121         int res = 0;
 122
 123         va_list ap;
 124         va_start(ap, fmt);
 125         res = vasprintf(&stuff, fmt, ap);
 126         va_end(ap);
 127         if (res == -1) {
 128                 ast_log(LOG_ERROR, "Out of memory\n");
 129         } else {
 130                 if (agidebug)
 131                         ast_verbose("AGI Tx >> %s\n", stuff);
 132                 ast_carefulwrite(fd, stuff, strlen(stuff), 100);
 133                 ast_free(stuff);
 134         }
 135 }
 136
 137 /* launch_netscript: The fastagi handler.
 138         FastAGI defaults to port 4573 */
 139 static enum agi_result launch_netscript(char *agiurl, char *argv[], int *fds, int *efd, int *opid)
 140 {
 141         int s;
 142         int flags;
 143         struct pollfd pfds[1];
 144         char *host;
 145         char *c; int port = AGI_PORT;
 146         char *script="";
 147         struct sockaddr_in sin;
 148         struct hostent *hp;
 149         struct ast_hostent ahp;
 150         int res;
 151
 152         /* agiusl is "agi://host.domain[:port][/script/name]" */
 153         host = ast_strdupa(agiurl + 6); /* Remove agi:// */
 154         /* Strip off any script name */
 155         if ((c = strchr(host, '/'))) {
 156                 *c = '\0';
 157                 c++;
 158                 script = c;
 159         }
 160         if ((c = strchr(host, ':'))) {
 161                 *c = '\0';
 162                 c++;
 163                 port = atoi(c);
 164         }
 165         if (efd) {
 166                 ast_log(LOG_WARNING, "AGI URI's don't support Enhanced AGI yet\n");
 167                 return -1;
 168         }
 169         hp = ast_gethostbyname(host, &ahp);
 170         if (!hp) {
 171                 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", host);
 172                 return -1;
 173         }
 174         s = socket(AF_INET, SOCK_STREAM, 0);
 175         if (s < 0) {
 176                 ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
 177                 return -1;
 178         }
 179         flags = fcntl(s, F_GETFL);
 180         if (flags < 0) {
 181                 ast_log(LOG_WARNING, "Fcntl(F_GETFL) failed: %s\n", strerror(errno));
 182                 close(s);
 183                 return -1;
 184         }
 185         if (fcntl(s, F_SETFL, flags | O_NONBLOCK) < 0) {
 186                 ast_log(LOG_WARNING, "Fnctl(F_SETFL) failed: %s\n", strerror(errno));
 187                 close(s);
 188                 return -1;
 189         }
 190         memset(&sin, 0, sizeof(sin));
 191         sin.sin_family = AF_INET;
 192         sin.sin_port = htons(port);
 193         memcpy(&sin.sin_addr, hp->h_addr, sizeof(sin.sin_addr));
 194         if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) && (errno != EINPROGRESS)) {
 195                 ast_log(LOG_WARNING, "Connect failed with unexpected error: %s\n", strerror(errno));
 196                 close(s);
 197                 return AGI_RESULT_FAILURE;
 198         }
 199
 200         pfds[0].fd = s;
 201         pfds[0].events = POLLOUT;
 202         while ((res = poll(pfds, 1, MAX_AGI_CONNECT)) != 1) {
 203                 if (errno != EINTR) {
 204                         if (!res) {
 205                                 ast_log(LOG_WARNING, "FastAGI connection to '%s' timed out after MAX_AGI_CONNECT (%d) milliseconds.\n",
 206                                         agiurl, MAX_AGI_CONNECT);
 207                         } else
 208                                 ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno));
 209                         close(s);
 210                         return AGI_RESULT_FAILURE;
 211                 }
 212         }
 213         /* XXX in theory should check for partial writes... */
 214         while (write(s, "agi_network: yes\n", strlen("agi_network: yes\n")) < 0) {
 215                 if (errno != EINTR) {
 216                         ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno));
 217                         close(s);
 218                         return AGI_RESULT_FAILURE;
 219                 }
 220         }
 221
 222         /* If we have a script parameter, relay it to the fastagi server */
 223         /* Script parameters take the form of: AGI(agi://my.example.com/?extension=${EXTEN}) */
 224         if (!ast_strlen_zero(script))
 225                 fdprintf(s, "agi_network_script: %s\n", script);
 226
 227         ast_debug(4, "Wow, connected!\n");
 228         fds[0] = s;
 229         fds[1] = s;
 230         *opid = -1;
 231         return AGI_RESULT_SUCCESS;
 232 }
 233
 234 static enum agi_result launch_script(char *script, char *argv[], int *fds, int *efd, int *opid)
 235 {
 236         char tmp[256];
 237         int pid;
 238         int toast[2];
 239         int fromast[2];
 240         int audio[2];
 241         int x;
 242         int res;
 243         sigset_t signal_set, old_set;
 244
 245         if (!strncasecmp(script, "agi://", 6))
 246                 return launch_netscript(script, argv, fds, efd, opid);
 247
 248         if (script[0] != '/') {
 249                 snprintf(tmp, sizeof(tmp), "%s/%s", ast_config_AST_AGI_DIR, script);
 250                 script = tmp;
 251         }
 252         if (pipe(toast)) {
 253                 ast_log(LOG_WARNING, "Unable to create toast pipe: %s\n",strerror(errno));
 254                 return AGI_RESULT_FAILURE;
 255         }
 256         if (pipe(fromast)) {
 257                 ast_log(LOG_WARNING, "unable to create fromast pipe: %s\n", strerror(errno));
 258                 close(toast[0]);
 259                 close(toast[1]);
 260                 return AGI_RESULT_FAILURE;
 261         }
 262         if (efd) {
 263                 if (pipe(audio)) {
 264                         ast_log(LOG_WARNING, "unable to create audio pipe: %s\n", strerror(errno));
 265                         close(fromast[0]);
 266                         close(fromast[1]);
 267                         close(toast[0]);
 268                         close(toast[1]);
 269                         return AGI_RESULT_FAILURE;
 270                 }
 271                 res = fcntl(audio[1], F_GETFL);
 272                 if (res > -1)
 273                         res = fcntl(audio[1], F_SETFL, res | O_NONBLOCK);
 274                 if (res < 0) {
 275                         ast_log(LOG_WARNING, "unable to set audio pipe parameters: %s\n", strerror(errno));
 276                         close(fromast[0]);
 277                         close(fromast[1]);
 278                         close(toast[0]);
 279                         close(toast[1]);
 280                         close(audio[0]);
 281                         close(audio[1]);
 282                         return AGI_RESULT_FAILURE;
 283                 }
 284         }
 285
 286         /* Block SIGHUP during the fork - prevents a race */
 287         sigfillset(&signal_set);
 288         pthread_sigmask(SIG_BLOCK, &signal_set, &old_set);
 289         pid = fork();
 290         if (pid < 0) {
 291                 ast_log(LOG_WARNING, "Failed to fork(): %s\n", strerror(errno));
 292                 pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 293                 return AGI_RESULT_FAILURE;
 294         }
 295         if (!pid) {
 296                 /* Pass paths to AGI via environmental variables */
 297                 setenv("AST_CONFIG_DIR", ast_config_AST_CONFIG_DIR, 1);
 298                 setenv("AST_CONFIG_FILE", ast_config_AST_CONFIG_FILE, 1);
 299                 setenv("AST_MODULE_DIR", ast_config_AST_MODULE_DIR, 1);
 300                 setenv("AST_SPOOL_DIR", ast_config_AST_SPOOL_DIR, 1);
 301                 setenv("AST_MONITOR_DIR", ast_config_AST_MONITOR_DIR, 1);
 302                 setenv("AST_VAR_DIR", ast_config_AST_VAR_DIR, 1);
 303                 setenv("AST_DATA_DIR", ast_config_AST_DATA_DIR, 1);
 304                 setenv("AST_LOG_DIR", ast_config_AST_LOG_DIR, 1);
 305                 setenv("AST_AGI_DIR", ast_config_AST_AGI_DIR, 1);
 306                 setenv("AST_KEY_DIR", ast_config_AST_KEY_DIR, 1);
 307                 setenv("AST_RUN_DIR", ast_config_AST_RUN_DIR, 1);
 308
 309                 /* Don't run AGI scripts with realtime priority -- it causes audio stutter */
 310                 ast_set_priority(0);
 311
 312                 /* Redirect stdin and out, provide enhanced audio channel if desired */
 313                 dup2(fromast[0], STDIN_FILENO);
 314                 dup2(toast[1], STDOUT_FILENO);
 315                 if (efd) {
 316                         dup2(audio[0], STDERR_FILENO + 1);
 317                 } else {
 318                         close(STDERR_FILENO + 1);
 319                 }
 320
 321                 /* Before we unblock our signals, return our trapped signals back to the defaults */
 322                 signal(SIGHUP, SIG_DFL);
 323                 signal(SIGCHLD, SIG_DFL);
 324                 signal(SIGINT, SIG_DFL);
 325                 signal(SIGURG, SIG_DFL);
 326                 signal(SIGTERM, SIG_DFL);
 327                 signal(SIGPIPE, SIG_DFL);
 328                 signal(SIGXFSZ, SIG_DFL);
 329
 330                 /* unblock important signal handlers */
 331                 if (pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL)) {
 332                         ast_log(LOG_WARNING, "unable to unblock signals for AGI script: %s\n", strerror(errno));
 333                         _exit(1);
 334                 }
 335
 336                 /* Close everything but stdin/out/error */
 337                 for (x=STDERR_FILENO + 2;x<1024;x++)
 338                         close(x);
 339
 340                 /* Execute script */
 341                 /* XXX argv should be deprecated in favor of passing agi_argX paramaters */
 342                 execv(script, argv);
 343                 /* Can't use ast_log since FD's are closed */
 344                 fprintf(stdout, "verbose \"Failed to execute '%s': %s\" 2\n", script, strerror(errno));
 345                 fflush(stdout);
 346                 _exit(1);
 347         }
 348         pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 349         if (option_verbose > 2)
 350                 ast_verbose(VERBOSE_PREFIX_3 "Launched AGI Script %s\n", script);
 351         fds[0] = toast[0];
 352         fds[1] = fromast[1];
 353         if (efd) {
 354                 *efd = audio[1];
 355         }
 356         /* close what we're not using in the parent */
 357         close(toast[1]);
 358         close(fromast[0]);
 359
 360         if (efd)
 361                 close(audio[0]);
 362
 363         *opid = pid;
 364         return AGI_RESULT_SUCCESS;
 365 }
 366
 367 static void setup_env(struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[])
 368 {
 369         int count;
 370
 371         /* Print initial environment, with agi_request always being the first
 372            thing */
 373         fdprintf(fd, "agi_request: %s\n", request);
 374         fdprintf(fd, "agi_channel: %s\n", chan->name);
 375         fdprintf(fd, "agi_language: %s\n", chan->language);
 376         fdprintf(fd, "agi_type: %s\n", chan->tech->type);
 377         fdprintf(fd, "agi_uniqueid: %s\n", chan->uniqueid);
 378
 379         /* ANI/DNIS */
 380         fdprintf(fd, "agi_callerid: %s\n", S_OR(chan->cid.cid_num, "unknown"));
 381         fdprintf(fd, "agi_calleridname: %s\n", S_OR(chan->cid.cid_name, "unknown"));
 382         fdprintf(fd, "agi_callingpres: %d\n", chan->cid.cid_pres);
 383         fdprintf(fd, "agi_callingani2: %d\n", chan->cid.cid_ani2);
 384         fdprintf(fd, "agi_callington: %d\n", chan->cid.cid_ton);
 385         fdprintf(fd, "agi_callingtns: %d\n", chan->cid.cid_tns);
 386         fdprintf(fd, "agi_dnid: %s\n", S_OR(chan->cid.cid_dnid, "unknown"));
 387         fdprintf(fd, "agi_rdnis: %s\n", S_OR(chan->cid.cid_rdnis, "unknown"));
 388
 389         /* Context information */
 390         fdprintf(fd, "agi_context: %s\n", chan->context);
 391         fdprintf(fd, "agi_extension: %s\n", chan->exten);
 392         fdprintf(fd, "agi_priority: %d\n", chan->priority);
 393         fdprintf(fd, "agi_enhanced: %s\n", enhanced ? "1.0" : "0.0");
 394
 395         /* User information */
 396         fdprintf(fd, "agi_accountcode: %s\n", chan->accountcode ? chan->accountcode : "");
 397
 398         /* Send any parameters to the fastagi server that have been passed via the agi application */
 399         /* Agi application paramaters take the form of: AGI(/path/to/example/script|${EXTEN}) */
 400         for(count = 1; count < argc; count++)
 401                 fdprintf(fd, "agi_arg_%d: %s\n", count, argv[count]);
 402
 403         /* End with empty return */
 404         fdprintf(fd, "\n");
 405 }
 406
 407 static int handle_answer(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 408 {
 409         int res;
 410         res = 0;
 411         if (chan->_state != AST_STATE_UP) {
 412                 /* Answer the chan */
 413                 res = ast_answer(chan);
 414         }
 415         fdprintf(agi->fd, "200 result=%d\n", res);
 416         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 417 }
 418
 419 static int handle_waitfordigit(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 420 {
 421         int res;
 422         int to;
 423         if (argc != 4)
 424                 return RESULT_SHOWUSAGE;
 425         if (sscanf(argv[3], "%d", &to) != 1)
 426                 return RESULT_SHOWUSAGE;
 427         res = ast_waitfordigit_full(chan, to, agi->audio, agi->ctrl);
 428         fdprintf(agi->fd, "200 result=%d\n", res);
 429         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 430 }
 431
 432 static int handle_sendtext(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 433 {
 434         int res;
 435         if (argc != 3)
 436                 return RESULT_SHOWUSAGE;
 437         /* At the moment, the parser (perhaps broken) returns with
 438            the last argument PLUS the newline at the end of the input
 439            buffer. This probably needs to be fixed, but I wont do that
 440            because other stuff may break as a result. The right way
 441            would probably be to strip off the trailing newline before
 442            parsing, then here, add a newline at the end of the string
 443            before sending it to ast_sendtext --DUDE */
 444         res = ast_sendtext(chan, argv[2]);
 445         fdprintf(agi->fd, "200 result=%d\n", res);
 446         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 447 }
 448
 449 static int handle_recvchar(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 450 {
 451         int res;
 452         if (argc != 3)
 453                 return RESULT_SHOWUSAGE;
 454         res = ast_recvchar(chan,atoi(argv[2]));
 455         if (res == 0) {
 456                 fdprintf(agi->fd, "200 result=%d (timeout)\n", res);
 457                 return RESULT_SUCCESS;
 458         }
 459         if (res > 0) {
 460                 fdprintf(agi->fd, "200 result=%d\n", res);
 461                 return RESULT_SUCCESS;
 462         }
 463         else {
 464                 fdprintf(agi->fd, "200 result=%d (hangup)\n", res);
 465                 return RESULT_FAILURE;
 466         }
 467 }
 468
 469 static int handle_recvtext(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 470 {
 471         char *buf;
 472
 473         if (argc != 3)
 474                 return RESULT_SHOWUSAGE;
 475         buf = ast_recvtext(chan,atoi(argv[2]));
 476         if (buf) {
 477                 fdprintf(agi->fd, "200 result=1 (%s)\n", buf);
 478                 ast_free(buf);
 479         } else {
 480                 fdprintf(agi->fd, "200 result=-1\n");
 481         }
 482         return RESULT_SUCCESS;
 483 }
 484
 485 static int handle_tddmode(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 486 {
 487         int res,x;
 488         if (argc != 3)
 489                 return RESULT_SHOWUSAGE;
 490         if (!strncasecmp(argv[2],"on",2))
 491                 x = 1;
 492         else
 493                 x = 0;
 494         if (!strncasecmp(argv[2],"mate",4))
 495                 x = 2;
 496         if (!strncasecmp(argv[2],"tdd",3))
 497                 x = 1;
 498         res = ast_channel_setoption(chan, AST_OPTION_TDD, &x, sizeof(char), 0);
 499         if (res != RESULT_SUCCESS)
 500                 fdprintf(agi->fd, "200 result=0\n");
 501         else
 502                 fdprintf(agi->fd, "200 result=1\n");
 503         return RESULT_SUCCESS;
 504 }
 505
 506 static int handle_sendimage(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 507 {
 508         int res;
 509         if (argc != 3)
 510                 return RESULT_SHOWUSAGE;
 511         res = ast_send_image(chan, argv[2]);
 512         if (!ast_check_hangup(chan))
 513                 res = 0;
 514         fdprintf(agi->fd, "200 result=%d\n", res);
 515         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 516 }
 517
 518 static int handle_controlstreamfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 519 {
 520         int res = 0;
 521         int skipms = 3000;
 522         char *fwd = NULL;
 523         char *rev = NULL;
 524         char *pause = NULL;
 525         char *stop = NULL;
 526
 527         if (argc < 5 || argc > 9)
 528                 return RESULT_SHOWUSAGE;
 529
 530         if (!ast_strlen_zero(argv[4]))
 531                 stop = argv[4];
 532         else
 533                 stop = NULL;
 534
 535         if ((argc > 5) && (sscanf(argv[5], "%d", &skipms) != 1))
 536                 return RESULT_SHOWUSAGE;
 537
 538         if (argc > 6 && !ast_strlen_zero(argv[6]))
 539                 fwd = argv[6];
 540         else
 541                 fwd = "#";
 542
 543         if (argc > 7 && !ast_strlen_zero(argv[7]))
 544                 rev = argv[7];
 545         else
 546                 rev = "*";
 547
 548         if (argc > 8 && !ast_strlen_zero(argv[8]))
 549                 pause = argv[8];
 550         else
 551                 pause = NULL;
 552
 553         res = ast_control_streamfile(chan, argv[3], fwd, rev, stop, pause, NULL, skipms, NULL);
 554
 555         fdprintf(agi->fd, "200 result=%d\n", res);
 556
 557         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 558 }
 559
 560 static int handle_streamfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 561 {
 562         int res;
 563         int vres;
 564         struct ast_filestream *fs;
 565         struct ast_filestream *vfs;
 566         long sample_offset = 0;
 567         long max_length;
 568         char *edigits = "";
 569
 570         if (argc < 4 || argc > 5)
 571                 return RESULT_SHOWUSAGE;
 572
 573         if (argv[3])
 574                 edigits = argv[3];
 575
 576         if ((argc > 4) && (sscanf(argv[4], "%ld", &sample_offset) != 1))
 577                 return RESULT_SHOWUSAGE;
 578
 579         fs = ast_openstream(chan, argv[2], chan->language);
 580
 581         if (!fs) {
 582                 fdprintf(agi->fd, "200 result=%d endpos=%ld\n", 0, sample_offset);
 583                 return RESULT_SUCCESS;
 584         }
 585         vfs = ast_openvstream(chan, argv[2], chan->language);
 586         ast_debug(vfs && 1, "Ooh, found a video stream, too\n");
 587
 588         if (option_verbose > 2)
 589                 ast_verbose(VERBOSE_PREFIX_3 "Playing '%s' (escape_digits=%s) (sample_offset %ld)\n", argv[2], edigits, sample_offset);
 590
 591         ast_seekstream(fs, 0, SEEK_END);
 592         max_length = ast_tellstream(fs);
 593         ast_seekstream(fs, sample_offset, SEEK_SET);
 594         res = ast_applystream(chan, fs);
 595         if (vfs)
 596                 vres = ast_applystream(chan, vfs);
 597         res = ast_playstream(fs);
 598         if (vfs)
 599                 vres = ast_playstream(vfs);
 600
 601         if (res) {
 602                 fdprintf(agi->fd, "200 result=%d endpos=%ld\n", res, sample_offset);
 603                 return (res >= 0) ? RESULT_SHOWUSAGE : RESULT_FAILURE;
 604         }
 605         res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl);
 606         /* this is to check for if ast_waitstream closed the stream, we probably are at
 607          * the end of the stream, return that amount, else check for the amount */
 608         sample_offset = (chan->stream) ? ast_tellstream(fs) : max_length;
 609         ast_stopstream(chan);
 610         if (res == 1) {
 611                 /* Stop this command, don't print a result line, as there is a new command */
 612                 return RESULT_SUCCESS;
 613         }
 614         fdprintf(agi->fd, "200 result=%d endpos=%ld\n", res, sample_offset);
 615         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 616 }
 617
 618 /* get option - really similar to the handle_streamfile, but with a timeout */
 619 static int handle_getoption(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 620 {
 621         int res;
 622         int vres;
 623         struct ast_filestream *fs;
 624         struct ast_filestream *vfs;
 625         long sample_offset = 0;
 626         long max_length;
 627         int timeout = 0;
 628         char *edigits = "";
 629
 630         if ( argc < 4 || argc > 5 )
 631                 return RESULT_SHOWUSAGE;
 632
 633         if ( argv[3] )
 634                 edigits = argv[3];
 635
 636         if ( argc == 5 )
 637                 timeout = atoi(argv[4]);
 638         else if (chan->pbx->dtimeout) {
 639                 /* by default dtimeout is set to 5sec */
 640                 timeout = chan->pbx->dtimeout * 1000; /* in msec */
 641         }
 642
 643         fs = ast_openstream(chan, argv[2], chan->language);
 644         if (!fs) {
 645                 fdprintf(agi->fd, "200 result=%d endpos=%ld\n", 0, sample_offset);
 646                 ast_log(LOG_WARNING, "Unable to open %s\n", argv[2]);
 647                 return RESULT_SUCCESS;
 648         }
 649         vfs = ast_openvstream(chan, argv[2], chan->language);
 650         ast_debug(vfs && 1, "Ooh, found a video stream, too\n");
 651
 652         if (option_verbose > 2)
 653                 ast_verbose(VERBOSE_PREFIX_3 "Playing '%s' (escape_digits=%s) (timeout %d)\n", argv[2], edigits, timeout);
 654
 655         ast_seekstream(fs, 0, SEEK_END);
 656         max_length = ast_tellstream(fs);
 657         ast_seekstream(fs, sample_offset, SEEK_SET);
 658         res = ast_applystream(chan, fs);
 659         if (vfs)
 660                 vres = ast_applystream(chan, vfs);
 661         res = ast_playstream(fs);
 662         if (vfs)
 663                 vres = ast_playstream(vfs);
 664         if (res) {
 665                 fdprintf(agi->fd, "200 result=%d endpos=%ld\n", res, sample_offset);
 666                 if (res >= 0)
 667                         return RESULT_SHOWUSAGE;
 668                 else
 669                         return RESULT_FAILURE;
 670         }
 671         res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl);
 672         /* this is to check for if ast_waitstream closed the stream, we probably are at
 673          * the end of the stream, return that amount, else check for the amount */
 674         sample_offset = (chan->stream)?ast_tellstream(fs):max_length;
 675         ast_stopstream(chan);
 676         if (res == 1) {
 677                 /* Stop this command, don't print a result line, as there is a new command */
 678                 return RESULT_SUCCESS;
 679         }
 680
 681         /* If the user didnt press a key, wait for digitTimeout*/
 682         if (res == 0 ) {
 683                 res = ast_waitfordigit_full(chan, timeout, agi->audio, agi->ctrl);
 684                 /* Make sure the new result is in the escape digits of the GET OPTION */
 685                 if ( !strchr(edigits,res) )
 686                         res=0;
 687         }
 688
 689         fdprintf(agi->fd, "200 result=%d endpos=%ld\n", res, sample_offset);
 690         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 691 }
 692
 693
 694
 695
 696 /*--- handle_saynumber: Say number in various language syntaxes ---*/
 697 /* While waiting, we're sending a NULL.  */
 698 static int handle_saynumber(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 699 {
 700         int res;
 701         int num;
 702         if (argc < 4 || argc > 5)
 703                 return RESULT_SHOWUSAGE;
 704         if (sscanf(argv[2], "%d", &num) != 1)
 705                 return RESULT_SHOWUSAGE;
 706         res = ast_say_number_full(chan, num, argv[3], chan->language, argc > 4 ? argv[4] : NULL, agi->audio, agi->ctrl);
 707         if (res == 1)
 708                 return RESULT_SUCCESS;
 709         fdprintf(agi->fd, "200 result=%d\n", res);
 710         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 711 }
 712
 713 static int handle_saydigits(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 714 {
 715         int res;
 716         int num;
 717
 718         if (argc != 4)
 719                 return RESULT_SHOWUSAGE;
 720         if (sscanf(argv[2], "%d", &num) != 1)
 721                 return RESULT_SHOWUSAGE;
 722
 723         res = ast_say_digit_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl);
 724         if (res == 1) /* New command */
 725                 return RESULT_SUCCESS;
 726         fdprintf(agi->fd, "200 result=%d\n", res);
 727         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 728 }
 729
 730 static int handle_sayalpha(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 731 {
 732         int res;
 733
 734         if (argc != 4)
 735                 return RESULT_SHOWUSAGE;
 736
 737         res = ast_say_character_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl);
 738         if (res == 1) /* New command */
 739                 return RESULT_SUCCESS;
 740         fdprintf(agi->fd, "200 result=%d\n", res);
 741         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 742 }
 743
 744 static int handle_saydate(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 745 {
 746         int res;
 747         int num;
 748         if (argc != 4)
 749                 return RESULT_SHOWUSAGE;
 750         if (sscanf(argv[2], "%d", &num) != 1)
 751                 return RESULT_SHOWUSAGE;
 752         res = ast_say_date(chan, num, argv[3], chan->language);
 753         if (res == 1)
 754                 return RESULT_SUCCESS;
 755         fdprintf(agi->fd, "200 result=%d\n", res);
 756         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 757 }
 758
 759 static int handle_saytime(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 760 {
 761         int res;
 762         int num;
 763         if (argc != 4)
 764                 return RESULT_SHOWUSAGE;
 765         if (sscanf(argv[2], "%d", &num) != 1)
 766                 return RESULT_SHOWUSAGE;
 767         res = ast_say_time(chan, num, argv[3], chan->language);
 768         if (res == 1)
 769                 return RESULT_SUCCESS;
 770         fdprintf(agi->fd, "200 result=%d\n", res);
 771         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 772 }
 773
 774 static int handle_saydatetime(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 775 {
 776         int res=0;
 777         time_t unixtime;
 778         char *format, *zone=NULL;
 779
 780         if (argc < 4)
 781                 return RESULT_SHOWUSAGE;
 782
 783         if (argc > 4) {
 784                 format = argv[4];
 785         } else {
 786                 /* XXX this doesn't belong here, but in the 'say' module */
 787                 if (!strcasecmp(chan->language, "de")) {
 788                         format = "A dBY HMS";
 789                 } else {
 790                         format = "ABdY 'digits/at' IMp";
 791                 }
 792         }
 793
 794         if (argc > 5 && !ast_strlen_zero(argv[5]))
 795                 zone = argv[5];
 796
 797         if (ast_get_time_t(argv[2], &unixtime, 0, NULL))
 798                 return RESULT_SHOWUSAGE;
 799
 800         res = ast_say_date_with_format(chan, unixtime, argv[3], chan->language, format, zone);
 801         if (res == 1)
 802                 return RESULT_SUCCESS;
 803
 804         fdprintf(agi->fd, "200 result=%d\n", res);
 805         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 806 }
 807
 808 static int handle_sayphonetic(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 809 {
 810         int res;
 811
 812         if (argc != 4)
 813                 return RESULT_SHOWUSAGE;
 814
 815         res = ast_say_phonetic_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl);
 816         if (res == 1) /* New command */
 817                 return RESULT_SUCCESS;
 818         fdprintf(agi->fd, "200 result=%d\n", res);
 819         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
 820 }
 821
 822 static int handle_getdata(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 823 {
 824         int res;
 825         char data[1024];
 826         int max;
 827         int timeout;
 828
 829         if (argc < 3)
 830                 return RESULT_SHOWUSAGE;
 831         if (argc >= 4)
 832                 timeout = atoi(argv[3]);
 833         else
 834                 timeout = 0;
 835         if (argc >= 5)
 836                 max = atoi(argv[4]);
 837         else
 838                 max = 1024;
 839         res = ast_app_getdata_full(chan, argv[2], data, max, timeout, agi->audio, agi->ctrl);
 840         if (res == 2)                   /* New command */
 841                 return RESULT_SUCCESS;
 842         else if (res == 1)
 843                 fdprintf(agi->fd, "200 result=%s (timeout)\n", data);
 844         else if (res < 0 )
 845                 fdprintf(agi->fd, "200 result=-1\n");
 846         else
 847                 fdprintf(agi->fd, "200 result=%s\n", data);
 848         return RESULT_SUCCESS;
 849 }
 850
 851 static int handle_setcontext(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 852 {
 853
 854         if (argc != 3)
 855                 return RESULT_SHOWUSAGE;
 856         ast_copy_string(chan->context, argv[2], sizeof(chan->context));
 857         fdprintf(agi->fd, "200 result=0\n");
 858         return RESULT_SUCCESS;
 859 }
 860
 861 static int handle_setextension(struct ast_channel *chan, AGI *agi, int argc, char **argv)
 862 {
 863         if (argc != 3)
 864                 return RESULT_SHOWUSAGE;
 865         ast_copy_string(chan->exten, argv[2], sizeof(chan->exten));
 866         fdprintf(agi->fd, "200 result=0\n");
 867         return RESULT_SUCCESS;
 868 }
 869
 870 static int handle_setpriority(struct ast_channel *chan, AGI *agi, int argc, char **argv)
 871 {
 872         int pri;
 873         if (argc != 3)
 874                 return RESULT_SHOWUSAGE;
 875
 876         if (sscanf(argv[2], "%d", &pri) != 1) {
 877                 if ((pri = ast_findlabel_extension(chan, chan->context, chan->exten, argv[2], chan->cid.cid_num)) < 1)
 878                         return RESULT_SHOWUSAGE;
 879         }
 880
 881         ast_explicit_goto(chan, NULL, NULL, pri);
 882         fdprintf(agi->fd, "200 result=0\n");
 883         return RESULT_SUCCESS;
 884 }
 885
 886 static int handle_recordfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
 887 {
 888         struct ast_filestream *fs;
 889         struct ast_frame *f;
 890         struct timeval start;
 891         long sample_offset = 0;
 892         int res = 0;
 893         int ms;
 894
 895         struct ast_dsp *sildet=NULL;         /* silence detector dsp */
 896         int totalsilence = 0;
 897         int dspsilence = 0;
 898         int silence = 0;                /* amount of silence to allow */
 899         int gotsilence = 0;             /* did we timeout for silence? */
 900         char *silencestr=NULL;
 901         int rfmt=0;
 902
 903
 904         /* XXX EAGI FIXME XXX */
 905
 906         if (argc < 6)
 907                 return RESULT_SHOWUSAGE;
 908         if (sscanf(argv[5], "%d", &ms) != 1)
 909                 return RESULT_SHOWUSAGE;
 910
 911         if (argc > 6)
 912                 silencestr = strchr(argv[6],'s');
 913         if ((argc > 7) && (!silencestr))
 914                 silencestr = strchr(argv[7],'s');
 915         if ((argc > 8) && (!silencestr))
 916                 silencestr = strchr(argv[8],'s');
 917
 918         if (silencestr) {
 919                 if (strlen(silencestr) > 2) {
 920                         if ((silencestr[0] == 's') && (silencestr[1] == '=')) {
 921                                 silencestr++;
 922                                 silencestr++;
 923                                 if (silencestr)
 924                                         silence = atoi(silencestr);
 925                                 if (silence > 0)
 926                                         silence *= 1000;
 927                         }
 928                 }
 929         }
 930
 931         if (silence > 0) {
 932                 rfmt = chan->readformat;
 933                 res = ast_set_read_format(chan, AST_FORMAT_SLINEAR);
 934                 if (res < 0) {
 935                         ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
 936                         return -1;
 937                 }
 938                 sildet = ast_dsp_new();
 939                 if (!sildet) {
 940                         ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
 941                         return -1;
 942                 }
 943                 ast_dsp_set_threshold(sildet, 256);
 944         }
 945
 946         /* backward compatibility, if no offset given, arg[6] would have been
 947          * caught below and taken to be a beep, else if it is a digit then it is a
 948          * offset */
 949         if ((argc >6) && (sscanf(argv[6], "%ld", &sample_offset) != 1) && (!strchr(argv[6], '=')))
 950                 res = ast_streamfile(chan, "beep", chan->language);
 951
 952         if ((argc > 7) && (!strchr(argv[7], '=')))
 953                 res = ast_streamfile(chan, "beep", chan->language);
 954
 955         if (!res)
 956                 res = ast_waitstream(chan, argv[4]);
 957         if (res) {
 958                 fdprintf(agi->fd, "200 result=%d (randomerror) endpos=%ld\n", res, sample_offset);
 959         } else {
 960                 fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_WRONLY | (sample_offset ? O_APPEND : 0), 0, AST_FILE_MODE);
 961                 if (!fs) {
 962                         res = -1;
 963                         fdprintf(agi->fd, "200 result=%d (writefile)\n", res);
 964                         if (sildet)
 965                                 ast_dsp_free(sildet);
 966                         return RESULT_FAILURE;
 967                 }
 968
 969                 /* Request a video update */
 970                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
 971
 972                 chan->stream = fs;
 973                 ast_applystream(chan,fs);
 974                 /* really should have checks */
 975                 ast_seekstream(fs, sample_offset, SEEK_SET);
 976                 ast_truncstream(fs);
 977
 978                 start = ast_tvnow();
 979                 while ((ms < 0) || ast_tvdiff_ms(ast_tvnow(), start) < ms) {
 980                         res = ast_waitfor(chan, -1);
 981                         if (res < 0) {
 982                                 ast_closestream(fs);
 983                                 fdprintf(agi->fd, "200 result=%d (waitfor) endpos=%ld\n", res,sample_offset);
 984                                 if (sildet)
 985                                         ast_dsp_free(sildet);
 986                                 return RESULT_FAILURE;
 987                         }
 988                         f = ast_read(chan);
 989                         if (!f) {
 990                                 fdprintf(agi->fd, "200 result=%d (hangup) endpos=%ld\n", 0, sample_offset);
 991                                 ast_closestream(fs);
 992                                 if (sildet)
 993                                         ast_dsp_free(sildet);
 994                                 return RESULT_FAILURE;
 995                         }
 996                         switch(f->frametype) {
 997                         case AST_FRAME_DTMF:
 998                                 if (strchr(argv[4], f->subclass)) {
 999                                         /* This is an interrupting chracter, so rewind to chop off any small
1000                                            amount of DTMF that may have been recorded
1001                                         */
1002                                         ast_stream_rewind(fs, 200);
1003                                         ast_truncstream(fs);
1004                                         sample_offset = ast_tellstream(fs);
1005                                         fdprintf(agi->fd, "200 result=%d (dtmf) endpos=%ld\n", f->subclass, sample_offset);
1006                                         ast_closestream(fs);
1007                                         ast_frfree(f);
1008                                         if (sildet)
1009                                                 ast_dsp_free(sildet);
1010                                         return RESULT_SUCCESS;
1011                                 }
1012                                 break;
1013                         case AST_FRAME_VOICE:
1014                                 ast_writestream(fs, f);
1015                                 /* this is a safe place to check progress since we know that fs
1016                                  * is valid after a write, and it will then have our current
1017                                  * location */
1018                                 sample_offset = ast_tellstream(fs);
1019                                 if (silence > 0) {
1020                                         dspsilence = 0;
1021                                         ast_dsp_silence(sildet, f, &dspsilence);
1022                                         if (dspsilence) {
1023                                                 totalsilence = dspsilence;
1024                                         } else {
1025                                                 totalsilence = 0;
1026                                         }
1027                                         if (totalsilence > silence) {
1028                                              /* Ended happily with silence */
1029                                                 gotsilence = 1;
1030                                                 break;
1031                                         }
1032                                 }
1033                                 break;
1034                         case AST_FRAME_VIDEO:
1035                                 ast_writestream(fs, f);
1036                         default:
1037                                 /* Ignore all other frames */
1038                                 break;
1039                         }
1040                         ast_frfree(f);
1041                         if (gotsilence)
1042                                 break;
1043                 }
1044
1045                 if (gotsilence) {
1046                         ast_stream_rewind(fs, silence-1000);
1047                         ast_truncstream(fs);
1048                         sample_offset = ast_tellstream(fs);
1049                 }
1050                 fdprintf(agi->fd, "200 result=%d (timeout) endpos=%ld\n", res, sample_offset);
1051                 ast_closestream(fs);
1052         }
1053
1054         if (silence > 0) {
1055                 res = ast_set_read_format(chan, rfmt);
1056                 if (res)
1057                         ast_log(LOG_WARNING, "Unable to restore read format on '%s'\n", chan->name);
1058                 ast_dsp_free(sildet);
1059         }
1060         return RESULT_SUCCESS;
1061 }
1062
1063 static int handle_autohangup(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
1064 {
1065         int timeout;
1066
1067         if (argc != 3)
1068                 return RESULT_SHOWUSAGE;
1069         if (sscanf(argv[2], "%d", &timeout) != 1)
1070                 return RESULT_SHOWUSAGE;
1071         if (timeout < 0)
1072                 timeout = 0;
1073         if (timeout)
1074                 chan->whentohangup = time(NULL) + timeout;
1075         else
1076                 chan->whentohangup = 0;
1077         fdprintf(agi->fd, "200 result=0\n");
1078         return RESULT_SUCCESS;
1079 }
1080
1081 static int handle_hangup(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1082 {
1083         struct ast_channel *c;
1084         if (argc == 1) {
1085                 /* no argument: hangup the current channel */
1086                 ast_softhangup(chan,AST_SOFTHANGUP_EXPLICIT);
1087                 fdprintf(agi->fd, "200 result=1\n");
1088                 return RESULT_SUCCESS;
1089         } else if (argc == 2) {
1090                 /* one argument: look for info on the specified channel */
1091                 c = ast_get_channel_by_name_locked(argv[1]);
1092                 if (c) {
1093                         /* we have a matching channel */
1094                         ast_softhangup(c,AST_SOFTHANGUP_EXPLICIT);
1095                         fdprintf(agi->fd, "200 result=1\n");
1096                         ast_channel_unlock(c);
1097                         return RESULT_SUCCESS;
1098                 }
1099                 /* if we get this far no channel name matched the argument given */
1100                 fdprintf(agi->fd, "200 result=-1\n");
1101                 return RESULT_SUCCESS;
1102         } else {
1103                 return RESULT_SHOWUSAGE;
1104         }
1105 }
1106
1107 static int handle_exec(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1108 {
1109         int res;
1110         struct ast_app *app;
1111
1112         if (argc < 2)
1113                 return RESULT_SHOWUSAGE;
1114
1115         if (option_verbose > 2)
1116                 ast_verbose(VERBOSE_PREFIX_3 "AGI Script Executing Application: (%s) Options: (%s)\n", argv[1], argv[2]);
1117
1118         app = pbx_findapp(argv[1]);
1119
1120         if (app) {
1121                 res = pbx_exec(chan, app, argv[2]);
1122         } else {
1123                 ast_log(LOG_WARNING, "Could not find application (%s)\n", argv[1]);
1124                 res = -2;
1125         }
1126         fdprintf(agi->fd, "200 result=%d\n", res);
1127
1128         return res;
1129 }
1130
1131 static int handle_setcallerid(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1132 {
1133         char tmp[256]="";
1134         char *l = NULL, *n = NULL;
1135
1136         if (argv[2]) {
1137                 ast_copy_string(tmp, argv[2], sizeof(tmp));
1138                 ast_callerid_parse(tmp, &n, &l);
1139                 if (l)
1140                         ast_shrink_phone_number(l);
1141                 else
1142                         l = "";
1143                 if (!n)
1144                         n = "";
1145                 ast_set_callerid(chan, l, n, NULL);
1146         }
1147
1148         fdprintf(agi->fd, "200 result=1\n");
1149         return RESULT_SUCCESS;
1150 }
1151
1152 static int handle_channelstatus(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1153 {
1154         struct ast_channel *c;
1155         if (argc == 2) {
1156                 /* no argument: supply info on the current channel */
1157                 fdprintf(agi->fd, "200 result=%d\n", chan->_state);
1158                 return RESULT_SUCCESS;
1159         } else if (argc == 3) {
1160                 /* one argument: look for info on the specified channel */
1161                 c = ast_get_channel_by_name_locked(argv[2]);
1162                 if (c) {
1163                         fdprintf(agi->fd, "200 result=%d\n", c->_state);
1164                         ast_channel_unlock(c);
1165                         return RESULT_SUCCESS;
1166                 }
1167                 /* if we get this far no channel name matched the argument given */
1168                 fdprintf(agi->fd, "200 result=-1\n");
1169                 return RESULT_SUCCESS;
1170         } else {
1171                 return RESULT_SHOWUSAGE;
1172         }
1173 }
1174
1175 static int handle_setvariable(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1176 {
1177         if (argv[3])
1178                 pbx_builtin_setvar_helper(chan, argv[2], argv[3]);
1179
1180         fdprintf(agi->fd, "200 result=1\n");
1181         return RESULT_SUCCESS;
1182 }
1183
1184 static int handle_getvariable(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1185 {
1186         char *ret;
1187         char tempstr[1024];
1188
1189         if (argc != 3)
1190                 return RESULT_SHOWUSAGE;
1191
1192         /* check if we want to execute an ast_custom_function */
1193         if (!ast_strlen_zero(argv[2]) && (argv[2][strlen(argv[2]) - 1] == ')')) {
1194                 ret = ast_func_read(chan, argv[2], tempstr, sizeof(tempstr)) ? NULL : tempstr;
1195         } else {
1196                 pbx_retrieve_variable(chan, argv[2], &ret, tempstr, sizeof(tempstr), NULL);
1197         }
1198
1199         if (ret)
1200                 fdprintf(agi->fd, "200 result=1 (%s)\n", ret);
1201         else
1202                 fdprintf(agi->fd, "200 result=0\n");
1203
1204         return RESULT_SUCCESS;
1205 }
1206
1207 static int handle_getvariablefull(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1208 {
1209         char tmp[4096] = "";
1210         struct ast_channel *chan2=NULL;
1211
1212         if ((argc != 4) && (argc != 5))
1213                 return RESULT_SHOWUSAGE;
1214         if (argc == 5) {
1215                 chan2 = ast_get_channel_by_name_locked(argv[4]);
1216         } else {
1217                 chan2 = chan;
1218         }
1219         if (chan) { /* XXX isn't this chan2 ? */
1220                 pbx_substitute_variables_helper(chan2, argv[3], tmp, sizeof(tmp) - 1);
1221                 fdprintf(agi->fd, "200 result=1 (%s)\n", tmp);
1222         } else {
1223                 fdprintf(agi->fd, "200 result=0\n");
1224         }
1225         if (chan2 && (chan2 != chan))
1226                 ast_channel_unlock(chan2);
1227         return RESULT_SUCCESS;
1228 }
1229
1230 static int handle_verbose(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1231 {
1232         int level = 0;
1233         char *prefix;
1234
1235         if (argc < 2)
1236                 return RESULT_SHOWUSAGE;
1237
1238         if (argv[2])
1239                 sscanf(argv[2], "%d", &level);
1240
1241         switch (level) {
1242                 case 4:
1243                         prefix = VERBOSE_PREFIX_4;
1244                         break;
1245                 case 3:
1246                         prefix = VERBOSE_PREFIX_3;
1247                         break;
1248                 case 2:
1249                         prefix = VERBOSE_PREFIX_2;
1250                         break;
1251                 case 1:
1252                 default:
1253                         prefix = VERBOSE_PREFIX_1;
1254                         break;
1255         }
1256
1257         if (level <= option_verbose)
1258                 ast_verbose("%s %s: %s\n", prefix, chan->data, argv[1]);
1259
1260         fdprintf(agi->fd, "200 result=1\n");
1261
1262         return RESULT_SUCCESS;
1263 }
1264
1265 static int handle_dbget(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1266 {
1267         int res;
1268         char tmp[256];
1269
1270         if (argc != 4)
1271                 return RESULT_SHOWUSAGE;
1272         res = ast_db_get(argv[2], argv[3], tmp, sizeof(tmp));
1273         if (res)
1274                 fdprintf(agi->fd, "200 result=0\n");
1275         else
1276                 fdprintf(agi->fd, "200 result=1 (%s)\n", tmp);
1277
1278         return RESULT_SUCCESS;
1279 }
1280
1281 static int handle_dbput(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1282 {
1283         int res;
1284
1285         if (argc != 5)
1286                 return RESULT_SHOWUSAGE;
1287         res = ast_db_put(argv[2], argv[3], argv[4]);
1288         fdprintf(agi->fd, "200 result=%c\n", res ? '0' : '1');
1289         return RESULT_SUCCESS;
1290 }
1291
1292 static int handle_dbdel(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1293 {
1294         int res;
1295
1296         if (argc != 4)
1297                 return RESULT_SHOWUSAGE;
1298         res = ast_db_del(argv[2], argv[3]);
1299         fdprintf(agi->fd, "200 result=%c\n", res ? '0' : '1');
1300         return RESULT_SUCCESS;
1301 }
1302
1303 static int handle_dbdeltree(struct ast_channel *chan, AGI *agi, int argc, char **argv)
1304 {
1305         int res;
1306         if ((argc < 3) || (argc > 4))
1307                 return RESULT_SHOWUSAGE;
1308         if (argc == 4)
1309                 res = ast_db_deltree(argv[2], argv[3]);
1310         else
1311                 res = ast_db_deltree(argv[2], NULL);
1312
1313         fdprintf(agi->fd, "200 result=%c\n", res ? '0' : '1');
1314         return RESULT_SUCCESS;
1315 }
1316
1317 static const char debug_usage[] =
1318 "Usage: agi debug\n"
1319 "       Enables dumping of AGI transactions for debugging purposes\n";
1320
1321 static const char no_debug_usage[] =
1322 "Usage: agi debug off\n"
1323 "       Disables dumping of AGI transactions for debugging purposes\n";
1324
1325 static int agi_do_debug(int fd, int argc, char *argv[])
1326 {
1327         if (argc != 2)
1328                 return RESULT_SHOWUSAGE;
1329         agidebug = 1;
1330         ast_cli(fd, "AGI Debugging Enabled\n");
1331         return RESULT_SUCCESS;
1332 }
1333
1334 static int agi_no_debug(int fd, int argc, char *argv[])
1335 {
1336         if (argc != 3)
1337                 return RESULT_SHOWUSAGE;
1338         agidebug = 0;
1339         ast_cli(fd, "AGI Debugging Disabled\n");
1340         return RESULT_SUCCESS;
1341 }
1342
1343 static int handle_noop(struct ast_channel *chan, AGI *agi, int arg, char *argv[])
1344 {
1345         fdprintf(agi->fd, "200 result=0\n");
1346         return RESULT_SUCCESS;
1347 }
1348
1349 static int handle_setmusic(struct ast_channel *chan, AGI *agi, int argc, char *argv[])
1350 {
1351         if (!strncasecmp(argv[2], "on", 2))
1352                 ast_moh_start(chan, argc > 3 ? argv[3] : NULL, NULL);
1353         else if (!strncasecmp(argv[2], "off", 3))
1354                 ast_moh_stop(chan);
1355         fdprintf(agi->fd, "200 result=0\n");
1356         return RESULT_SUCCESS;
1357 }
1358
1359 static char usage_setmusic[] =
1360 " Usage: SET MUSIC ON <on|off> <class>\n"
1361 "       Enables/Disables the music on hold generator.  If <class> is\n"
1362 " not specified, then the default music on hold class will be used.\n"
1363 " Always returns 0.\n";
1364
1365 static char usage_dbput[] =
1366 " Usage: DATABASE PUT <family> <key> <value>\n"
1367 "       Adds or updates an entry in the Asterisk database for a\n"
1368 " given family, key, and value.\n"
1369 " Returns 1 if successful, 0 otherwise.\n";
1370
1371 static char usage_dbget[] =
1372 " Usage: DATABASE GET <family> <key>\n"
1373 "       Retrieves an entry in the Asterisk database for a\n"
1374 " given family and key.\n"
1375 " Returns 0 if <key> is not set.  Returns 1 if <key>\n"
1376 " is set and returns the variable in parentheses.\n"
1377 " Example return code: 200 result=1 (testvariable)\n";
1378
1379 static char usage_dbdel[] =
1380 " Usage: DATABASE DEL <family> <key>\n"
1381 "       Deletes an entry in the Asterisk database for a\n"
1382 " given family and key.\n"
1383 " Returns 1 if successful, 0 otherwise.\n";
1384
1385 static char usage_dbdeltree[] =
1386 " Usage: DATABASE DELTREE <family> [keytree]\n"
1387 "       Deletes a family or specific keytree within a family\n"
1388 " in the Asterisk database.\n"
1389 " Returns 1 if successful, 0 otherwise.\n";
1390
1391 static char usage_verbose[] =
1392 " Usage: VERBOSE <message> <level>\n"
1393 "       Sends <message> to the console via verbose message system.\n"
1394 " <level> is the the verbose level (1-4)\n"
1395 " Always returns 1.\n";
1396
1397 static char usage_getvariable[] =
1398 " Usage: GET VARIABLE <variablename>\n"
1399 "       Returns 0 if <variablename> is not set.  Returns 1 if <variablename>\n"
1400 " is set and returns the variable in parentheses.\n"
1401 " example return code: 200 result=1 (testvariable)\n";
1402
1403 static char usage_getvariablefull[] =
1404 " Usage: GET FULL VARIABLE <variablename> [<channel name>]\n"
1405 "       Returns 0 if <variablename> is not set or channel does not exist.  Returns 1\n"
1406 "if <variablename>  is set and returns the variable in parenthesis.  Understands\n"
1407 "complex variable names and builtin variables, unlike GET VARIABLE.\n"
1408 " example return code: 200 result=1 (testvariable)\n";
1409
1410 static char usage_setvariable[] =
1411 " Usage: SET VARIABLE <variablename> <value>\n";
1412
1413 static char usage_channelstatus[] =
1414 " Usage: CHANNEL STATUS [<channelname>]\n"
1415 "       Returns the status of the specified channel.\n"
1416 " If no channel name is given the returns the status of the\n"
1417 " current channel.  Return values:\n"
1418 "  0 Channel is down and available\n"
1419 "  1 Channel is down, but reserved\n"
1420 "  2 Channel is off hook\n"
1421 "  3 Digits (or equivalent) have been dialed\n"
1422 "  4 Line is ringing\n"
1423 "  5 Remote end is ringing\n"
1424 "  6 Line is up\n"
1425 "  7 Line is busy\n";
1426
1427 static char usage_setcallerid[] =
1428 " Usage: SET CALLERID <number>\n"
1429 "       Changes the callerid of the current channel.\n";
1430
1431 static char usage_exec[] =
1432 " Usage: EXEC <application> <options>\n"
1433 "       Executes <application> with given <options>.\n"
1434 " Returns whatever the application returns, or -2 on failure to find application\n";
1435
1436 static char usage_hangup[] =
1437 " Usage: HANGUP [<channelname>]\n"
1438 "       Hangs up the specified channel.\n"
1439 " If no channel name is given, hangs up the current channel\n";
1440
1441 static char usage_answer[] =
1442 " Usage: ANSWER\n"
1443 "       Answers channel if not already in answer state. Returns -1 on\n"
1444 " channel failure, or 0 if successful.\n";
1445
1446 static char usage_waitfordigit[] =
1447 " Usage: WAIT FOR DIGIT <timeout>\n"
1448 "       Waits up to 'timeout' milliseconds for channel to receive a DTMF digit.\n"
1449 " Returns -1 on channel failure, 0 if no digit is received in the timeout, or\n"
1450 " the numerical value of the ascii of the digit if one is received.  Use -1\n"
1451 " for the timeout value if you desire the call to block indefinitely.\n";
1452
1453 static char usage_sendtext[] =
1454 " Usage: SEND TEXT \"<text to send>\"\n"
1455 "       Sends the given text on a channel. Most channels do not support the\n"
1456 " transmission of text.  Returns 0 if text is sent, or if the channel does not\n"
1457 " support text transmission.  Returns -1 only on error/hangup.  Text\n"
1458 " consisting of greater than one word should be placed in quotes since the\n"
1459 " command only accepts a single argument.\n";
1460
1461 static char usage_recvchar[] =
1462 " Usage: RECEIVE CHAR <timeout>\n"
1463 "       Receives a character of text on a channel. Specify timeout to be the\n"
1464 " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n"
1465 " do not support the reception of text. Returns the decimal value of the character\n"
1466 " if one is received, or 0 if the channel does not support text reception.  Returns\n"
1467 " -1 only on error/hangup.\n";
1468
1469 static char usage_recvtext[] =
1470 " Usage: RECEIVE TEXT <timeout>\n"
1471 "       Receives a string of text on a channel. Specify timeout to be the\n"
1472 " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n"
1473 " do not support the reception of text. Returns -1 for failure or 1 for success, and the string in parentheses.\n";
1474
1475 static char usage_tddmode[] =
1476 " Usage: TDD MODE <on|off>\n"
1477 "       Enable/Disable TDD transmission/reception on a channel. Returns 1 if\n"
1478 " successful, or 0 if channel is not TDD-capable.\n";
1479
1480 static char usage_sendimage[] =
1481 " Usage: SEND IMAGE <image>\n"
1482 "       Sends the given image on a channel. Most channels do not support the\n"
1483 " transmission of images. Returns 0 if image is sent, or if the channel does not\n"
1484 " support image transmission.  Returns -1 only on error/hangup. Image names\n"
1485 " should not include extensions.\n";
1486
1487 static char usage_streamfile[] =
1488 " Usage: STREAM FILE <filename> <escape digits> [sample offset]\n"
1489 "       Send the given file, allowing playback to be interrupted by the given\n"
1490 " digits, if any. Use double quotes for the digits if you wish none to be\n"
1491 " permitted. If sample offset is provided then the audio will seek to sample\n"
1492 " offset before play starts.  Returns 0 if playback completes without a digit\n"
1493 " being pressed, or the ASCII numerical value of the digit if one was pressed,\n"
1494 " or -1 on error or if the channel was disconnected. Remember, the file\n"
1495 " extension must not be included in the filename.\n";
1496
1497 static char usage_controlstreamfile[] =
1498 " Usage: CONTROL STREAM FILE <filename> <escape digits> [skipms] [ffchar] [rewchr] [pausechr]\n"
1499 "       Send the given file, allowing playback to be controled by the given\n"
1500 " digits, if any. Use double quotes for the digits if you wish none to be\n"
1501 " permitted.  Returns 0 if playback completes without a digit\n"
1502 " being pressed, or the ASCII numerical value of the digit if one was pressed,\n"
1503 " or -1 on error or if the channel was disconnected. Remember, the file\n"
1504 " extension must not be included in the filename.\n\n"
1505 " Note: ffchar and rewchar default to * and # respectively.\n";
1506
1507 static char usage_getoption[] =
1508 " Usage: GET OPTION <filename> <escape_digits> [timeout]\n"
1509 "       Behaves similar to STREAM FILE but used with a timeout option.\n";
1510
1511 static char usage_saynumber[] =
1512 " Usage: SAY NUMBER <number> <escape digits> [gender]\n"
1513 "       Say a given number, returning early if any of the given DTMF digits\n"
1514 " are received on the channel.  Returns 0 if playback completes without a digit\n"
1515 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
1516 " -1 on error/hangup.\n";
1517
1518 static char usage_saydigits[] =
1519 " Usage: SAY DIGITS <number> <escape digits>\n"
1520 "       Say a given digit string, returning early if any of the given DTMF digits\n"
1521 " are received on the channel. Returns 0 if playback completes without a digit\n"
1522 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
1523 " -1 on error/hangup.\n";
1524
1525 static char usage_sayalpha[] =
1526 " Usage: SAY ALPHA <number> <escape digits>\n"
1527 "       Say a given character string, returning early if any of the given DTMF digits\n"
1528 " are received on the channel. Returns 0 if playback completes without a digit\n"
1529 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
1530 " -1 on error/hangup.\n";
1531
1532 static char usage_saydate[] =
1533 " Usage: SAY DATE <date> <escape digits>\n"
1534 "       Say a given date, returning early if any of the given DTMF digits are\n"
1535 " received on the channel.  <date> is number of seconds elapsed since 00:00:00\n"
1536 " on January 1, 1970, Coordinated Universal Time (UTC). Returns 0 if playback\n"
1537 " completes without a digit being pressed, or the ASCII numerical value of the\n"
1538 " digit if one was pressed or -1 on error/hangup.\n";
1539
1540 static char usage_saytime[] =
1541 " Usage: SAY TIME <time> <escape digits>\n"
1542 "       Say a given time, returning early if any of the given DTMF digits are\n"
1543 " received on the channel.  <time> is number of seconds elapsed since 00:00:00\n"
1544 " on January 1, 1970, Coordinated Universal Time (UTC). Returns 0 if playback\n"
1545 " completes without a digit being pressed, or the ASCII numerical value of the\n"
1546 " digit if one was pressed or -1 on error/hangup.\n";
1547
1548 static char usage_saydatetime[] =
1549 " Usage: SAY DATETIME <time> <escape digits> [format] [timezone]\n"
1550 "       Say a given time, returning early if any of the given DTMF digits are\n"
1551 " received on the channel.  <time> is number of seconds elapsed since 00:00:00\n"
1552 " on January 1, 1970, Coordinated Universal Time (UTC). [format] is the format\n"
1553 " the time should be said in.  See voicemail.conf (defaults to \"ABdY\n"
1554 " 'digits/at' IMp\").  Acceptable values for [timezone] can be found in\n"
1555 " /usr/share/zoneinfo.  Defaults to machine default. Returns 0 if playback\n"
1556 " completes without a digit being pressed, or the ASCII numerical value of the\n"
1557 " digit if one was pressed or -1 on error/hangup.\n";
1558
1559 static char usage_sayphonetic[] =
1560 " Usage: SAY PHONETIC <string> <escape digits>\n"
1561 "       Say a given character string with phonetics, returning early if any of the\n"
1562 " given DTMF digits are received on the channel. Returns 0 if playback\n"
1563 " completes without a digit pressed, the ASCII numerical value of the digit\n"
1564 " if one was pressed, or -1 on error/hangup.\n";
1565
1566 static char usage_getdata[] =
1567 " Usage: GET DATA <file to be streamed> [timeout] [max digits]\n"
1568 "       Stream the given file, and recieve DTMF data. Returns the digits received\n"
1569 "from the channel at the other end.\n";
1570
1571 static char usage_setcontext[] =
1572 " Usage: SET CONTEXT <desired context>\n"
1573 "       Sets the context for continuation upon exiting the application.\n";
1574
1575 static char usage_setextension[] =
1576 " Usage: SET EXTENSION <new extension>\n"
1577 "       Changes the extension for continuation upon exiting the application.\n";
1578
1579 static char usage_setpriority[] =
1580 " Usage: SET PRIORITY <priority>\n"
1581 "       Changes the priority for continuation upon exiting the application.\n"
1582 " The priority must be a valid priority or label.\n";
1583
1584 static char usage_recordfile[] =
1585 " Usage: RECORD FILE <filename> <format> <escape digits> <timeout> \\\n"
1586 "                                          [offset samples] [BEEP] [s=silence]\n"
1587 "       Record to a file until a given dtmf digit in the sequence is received\n"
1588 " Returns -1 on hangup or error.  The format will specify what kind of file\n"
1589 " will be recorded.  The timeout is the maximum record time in milliseconds, or\n"
1590 " -1 for no timeout. \"Offset samples\" is optional, and, if provided, will seek\n"
1591 " to the offset without exceeding the end of the file.  \"silence\" is the number\n"
1592 " of seconds of silence allowed before the function returns despite the\n"
1593 " lack of dtmf digits or reaching timeout.  Silence value must be\n"
1594 " preceeded by \"s=\" and is also optional.\n";
1595
1596 static char usage_autohangup[] =
1597 " Usage: SET AUTOHANGUP <time>\n"
1598 "       Cause the channel to automatically hangup at <time> seconds in the\n"
1599 " future.  Of course it can be hungup before then as well. Setting to 0 will\n"
1600 " cause the autohangup feature to be disabled on this channel.\n";
1601
1602 static char usage_noop[] =
1603 " Usage: NoOp\n"
1604 "       Does nothing.\n";
1605
1606 static agi_command commands[MAX_COMMANDS] = {
1607         { { "answer", NULL }, handle_answer, "Answer channel", usage_answer },
1608         { { "channel", "status", NULL }, handle_channelstatus, "Returns status of the connected channel", usage_channelstatus },
1609         { { "database", "del", NULL }, handle_dbdel, "Removes database key/value", usage_dbdel },
1610         { { "database", "deltree", NULL }, handle_dbdeltree, "Removes database keytree/value", usage_dbdeltree },
1611         { { "database", "get", NULL }, handle_dbget, "Gets database value", usage_dbget },
1612         { { "database", "put", NULL }, handle_dbput, "Adds/updates database value", usage_dbput },
1613         { { "exec", NULL }, handle_exec, "Executes a given Application", usage_exec },
1614         { { "get", "data", NULL }, handle_getdata, "Prompts for DTMF on a channel", usage_getdata },
1615         { { "get", "full", "variable", NULL }, handle_getvariablefull, "Evaluates a channel expression", usage_getvariablefull },
1616         { { "get", "option", NULL }, handle_getoption, "Stream file, prompt for DTMF, with timeout", usage_getoption },
1617         { { "get", "variable", NULL }, handle_getvariable, "Gets a channel variable", usage_getvariable },
1618         { { "hangup", NULL }, handle_hangup, "Hangup the current channel", usage_hangup },
1619         { { "noop", NULL }, handle_noop, "Does nothing", usage_noop },
1620         { { "receive", "char", NULL }, handle_recvchar, "Receives one character from channels supporting it", usage_recvchar },
1621         { { "receive", "text", NULL }, handle_recvtext, "Receives text from channels supporting it", usage_recvtext },
1622         { { "record", "file", NULL }, handle_recordfile, "Records to a given file", usage_recordfile },
1623         { { "say", "alpha", NULL }, handle_sayalpha, "Says a given character string", usage_sayalpha },
1624         { { "say", "digits", NULL }, handle_saydigits, "Says a given digit string", usage_saydigits },
1625         { { "say", "number", NULL }, handle_saynumber, "Says a given number", usage_saynumber },
1626         { { "say", "phonetic", NULL }, handle_sayphonetic, "Says a given character string with phonetics", usage_sayphonetic },
1627         { { "say", "date", NULL }, handle_saydate, "Says a given date", usage_saydate },
1628         { { "say", "time", NULL }, handle_saytime, "Says a given time", usage_saytime },
1629         { { "say", "datetime", NULL }, handle_saydatetime, "Says a given time as specfied by the format given", usage_saydatetime },
1630         { { "send", "image", NULL }, handle_sendimage, "Sends images to channels supporting it", usage_sendimage },
1631         { { "send", "text", NULL }, handle_sendtext, "Sends text to channels supporting it", usage_sendtext },
1632         { { "set", "autohangup", NULL }, handle_autohangup, "Autohangup channel in some time", usage_autohangup },
1633         { { "set", "callerid", NULL }, handle_setcallerid, "Sets callerid for the current channel", usage_setcallerid },
1634         { { "set", "context", NULL }, handle_setcontext, "Sets channel context", usage_setcontext },
1635         { { "set", "extension", NULL }, handle_setextension, "Changes channel extension", usage_setextension },
1636         { { "set", "music", NULL }, handle_setmusic, "Enable/Disable Music on hold generator", usage_setmusic },
1637         { { "set", "priority", NULL }, handle_setpriority, "Set channel dialplan priority", usage_setpriority },
1638         { { "set", "variable", NULL }, handle_setvariable, "Sets a channel variable", usage_setvariable },
1639         { { "stream", "file", NULL }, handle_streamfile, "Sends audio file on channel", usage_streamfile },
1640         { { "control", "stream", "file", NULL }, handle_controlstreamfile, "Sends audio file on channel and allows the listner to control the stream", usage_controlstreamfile },
1641         { { "tdd", "mode", NULL }, handle_tddmode, "Toggles TDD mode (for the deaf)", usage_tddmode },
1642         { { "verbose", NULL }, handle_verbose, "Logs a message to the asterisk verbose log", usage_verbose },
1643         { { "wait", "for", "digit", NULL }, handle_waitfordigit, "Waits for a digit to be pressed", usage_waitfordigit },
1644 };
1645
1646 static int help_workhorse(int fd, char *match[])
1647 {
1648         char fullcmd[80];
1649         char matchstr[80];
1650         int x;
1651         struct agi_command *e;
1652         if (match)
1653                 ast_join(matchstr, sizeof(matchstr), match);
1654         for (x=0;x<sizeof(commands)/sizeof(commands[0]);x++) {
1655                 e = &commands[x];
1656                 if (!e->cmda[0])
1657                         break;
1658                 /* Hide commands that start with '_' */
1659                 if ((e->cmda[0])[0] == '_')
1660                         continue;
1661                 ast_join(fullcmd, sizeof(fullcmd), e->cmda);
1662                 if (match && strncasecmp(matchstr, fullcmd, strlen(matchstr)))
1663                         continue;
1664                 ast_cli(fd, "%20.20s   %s\n", fullcmd, e->summary);
1665         }
1666         return 0;
1667 }
1668
1669 int ast_agi_register(agi_command *agi)
1670 {
1671         int x;
1672         for (x=0; x<MAX_COMMANDS - 1; x++) {
1673                 if (commands[x].cmda[0] == agi->cmda[0]) {
1674                         ast_log(LOG_WARNING, "Command already registered!\n");
1675                         return -1;
1676                 }
1677         }
1678         for (x=0; x<MAX_COMMANDS - 1; x++) {
1679                 if (!commands[x].cmda[0]) {
1680                         commands[x] = *agi;
1681                         return 0;
1682                 }
1683         }
1684         ast_log(LOG_WARNING, "No more room for new commands!\n");
1685         return -1;
1686 }
1687
1688 void ast_agi_unregister(agi_command *agi)
1689 {
1690         int x;
1691         for (x=0; x<MAX_COMMANDS - 1; x++) {
1692                 if (commands[x].cmda[0] == agi->cmda[0]) {
1693                         memset(&commands[x], 0, sizeof(agi_command));
1694                 }
1695         }
1696 }
1697
1698 static agi_command *find_command(char *cmds[], int exact)
1699 {
1700         int x;
1701         int y;
1702         int match;
1703
1704         for (x=0; x < sizeof(commands) / sizeof(commands[0]); x++) {
1705                 if (!commands[x].cmda[0])
1706                         break;
1707                 /* start optimistic */
1708                 match = 1;
1709                 for (y=0; match && cmds[y]; y++) {
1710                         /* If there are no more words in the command (and we're looking for
1711                            an exact match) or there is a difference between the two words,
1712                            then this is not a match */
1713                         if (!commands[x].cmda[y] && !exact)
1714                                 break;
1715                         /* don't segfault if the next part of a command doesn't exist */
1716                         if (!commands[x].cmda[y])
1717                                 return NULL;
1718                         if (strcasecmp(commands[x].cmda[y], cmds[y]))
1719                                 match = 0;
1720                 }
1721                 /* If more words are needed to complete the command then this is not
1722                    a candidate (unless we're looking for a really inexact answer  */
1723                 if ((exact > -1) && commands[x].cmda[y])
1724                         match = 0;
1725                 if (match)
1726                         return &commands[x];
1727         }
1728         return NULL;
1729 }
1730
1731
1732 static int parse_args(char *s, int *max, char *argv[])
1733 {
1734         int x=0;
1735         int quoted=0;
1736         int escaped=0;
1737         int whitespace=1;
1738         char *cur;
1739
1740         cur = s;
1741         while(*s) {
1742                 switch(*s) {
1743                 case '"':
1744                         /* If it's escaped, put a literal quote */
1745                         if (escaped)
1746                                 goto normal;
1747                         else
1748                                 quoted = !quoted;
1749                         if (quoted && whitespace) {
1750                                 /* If we're starting a quote, coming off white space start a new word, too */
1751                                 argv[x++] = cur;
1752                                 whitespace=0;
1753                         }
1754                         escaped = 0;
1755                 break;
1756                 case ' ':
1757                 case '\t':
1758                         if (!quoted && !escaped) {
1759                                 /* If we're not quoted, mark this as whitespace, and
1760                                    end the previous argument */
1761                                 whitespace = 1;
1762                                 *(cur++) = '\0';
1763                         } else
1764                                 /* Otherwise, just treat it as anything else */
1765                                 goto normal;
1766                         break;
1767                 case '\\':
1768                         /* If we're escaped, print a literal, otherwise enable escaping */
1769                         if (escaped) {
1770                                 goto normal;
1771                         } else {
1772                                 escaped=1;
1773                         }
1774                         break;
1775                 default:
1776 normal:
1777                         if (whitespace) {
1778                                 if (x >= MAX_ARGS -1) {
1779                                         ast_log(LOG_WARNING, "Too many arguments, truncating\n");
1780                                         break;
1781                                 }
1782                                 /* Coming off of whitespace, start the next argument */
1783                                 argv[x++] = cur;
1784                                 whitespace=0;
1785                         }
1786                         *(cur++) = *s;
1787                         escaped=0;
1788                 }
1789                 s++;
1790         }
1791         /* Null terminate */
1792         *(cur++) = '\0';
1793         argv[x] = NULL;
1794         *max = x;
1795         return 0;
1796 }
1797
1798 static int agi_handle_command(struct ast_channel *chan, AGI *agi, char *buf)
1799 {
1800         char *argv[MAX_ARGS];
1801         int argc = MAX_ARGS;
1802         int res;
1803         agi_command *c;
1804
1805         parse_args(buf, &argc, argv);
1806         c = find_command(argv, 0);
1807         if (c) {
1808                 res = c->handler(chan, agi, argc, argv);
1809                 switch(res) {
1810                 case RESULT_SHOWUSAGE:
1811                         fdprintf(agi->fd, "520-Invalid command syntax.  Proper usage follows:\n");
1812                         fdprintf(agi->fd, c->usage);
1813                         fdprintf(agi->fd, "520 End of proper usage.\n");
1814                         break;
1815                 case AST_PBX_KEEPALIVE:
1816                         /* We've been asked to keep alive, so do so */
1817                         return AST_PBX_KEEPALIVE;
1818                         break;
1819                 case RESULT_FAILURE:
1820                         /* They've already given the failure.  We've been hung up on so handle this
1821                            appropriately */
1822                         return -1;
1823                 }
1824         } else {
1825                 fdprintf(agi->fd, "510 Invalid or unknown command\n");
1826         }
1827         return 0;
1828 }
1829 #define RETRY   3
1830 static enum agi_result run_agi(struct ast_channel *chan, char *request, AGI *agi, int pid, int *status, int dead, int argc, char *argv[])
1831 {
1832         struct ast_channel *c;
1833         int outfd;
1834         int ms;
1835         enum agi_result returnstatus = AGI_RESULT_SUCCESS;
1836         struct ast_frame *f;
1837         char buf[2048];
1838         FILE *readf;
1839         /* how many times we'll retry if ast_waitfor_nandfs will return without either
1840           channel or file descriptor in case select is interrupted by a system call (EINTR) */
1841         int retry = RETRY;
1842
1843         if (!(readf = fdopen(agi->ctrl, "r"))) {
1844                 ast_log(LOG_WARNING, "Unable to fdopen file descriptor\n");
1845                 if (pid > -1)
1846                         kill(pid, SIGHUP);
1847                 close(agi->ctrl);
1848                 return AGI_RESULT_FAILURE;
1849         }
1850         setlinebuf(readf);
1851         setup_env(chan, request, agi->fd, (agi->audio > -1), argc, argv);
1852         for (;;) {
1853                 ms = -1;
1854                 c = ast_waitfor_nandfds(&chan, dead ? 0 : 1, &agi->ctrl, 1, NULL, &outfd, &ms);
1855                 if (c) {
1856                         retry = RETRY;
1857                         /* Idle the channel until we get a command */
1858                         f = ast_read(c);
1859                         if (!f) {
1860                                 ast_debug(1, "%s hungup\n", chan->name);
1861                                 returnstatus = AGI_RESULT_HANGUP;
1862                                 break;
1863                         } else {
1864                                 /* If it's voice, write it to the audio pipe */
1865                                 if ((agi->audio > -1) && (f->frametype == AST_FRAME_VOICE)) {
1866                                         /* Write, ignoring errors */
1867                                         write(agi->audio, f->data, f->datalen);
1868                                 }
1869                                 ast_frfree(f);
1870                         }
1871                 } else if (outfd > -1) {
1872                         retry = RETRY;
1873                         if (!fgets(buf, sizeof(buf), readf)) {
1874                                 /* Program terminated */
1875                                 if (returnstatus)
1876                                         returnstatus = -1;
1877                                 if (option_verbose > 2)
1878                                         ast_verbose(VERBOSE_PREFIX_3 "AGI Script %s completed, returning %d\n", request, returnstatus);
1879                                 if (pid > 0)
1880                                         waitpid(pid, status, 0);
1881                                 /* No need to kill the pid anymore, since they closed us */
1882                                 pid = -1;
1883                                 break;
1884                         }
1885                         /* get rid of trailing newline, if any */
1886                         if (*buf && buf[strlen(buf) - 1] == '\n')
1887                                 buf[strlen(buf) - 1] = 0;
1888                         if (agidebug)
1889                                 ast_verbose("AGI Rx << %s\n", buf);
1890                         returnstatus |= agi_handle_command(chan, agi, buf);
1891                         /* If the handle_command returns -1, we need to stop */
1892                         if ((returnstatus < 0) || (returnstatus == AST_PBX_KEEPALIVE)) {
1893                                 break;
1894                         }
1895                 } else {
1896                         if (--retry <= 0) {
1897                                 ast_log(LOG_WARNING, "No channel, no fd?\n");
1898                                 returnstatus = AGI_RESULT_FAILURE;
1899                                 break;
1900                         }
1901                 }
1902         }
1903         /* Notify process */
1904         if (pid > -1) {
1905                 const char *sighup = pbx_builtin_getvar_helper(chan, "AGISIGHUP");
1906                 if (ast_strlen_zero(sighup) || !ast_false(sighup)) {
1907                         if (kill(pid, SIGHUP))
1908                                 ast_log(LOG_WARNING, "unable to send SIGHUP to AGI process %d: %s\n", pid, strerror(errno));
1909                 }
1910         }
1911         fclose(readf);
1912         return returnstatus;
1913 }
1914
1915 static int handle_showagi(int fd, int argc, char *argv[])
1916 {
1917         struct agi_command *e;
1918         char fullcmd[80];
1919         if ((argc < 2))
1920                 return RESULT_SHOWUSAGE;
1921         if (argc > 2) {
1922                 e = find_command(argv + 2, 1);
1923                 if (e)
1924                         ast_cli(fd, e->usage);
1925                 else {
1926                         if (find_command(argv + 2, -1)) {
1927                                 return help_workhorse(fd, argv + 1);
1928                         } else {
1929                                 ast_join(fullcmd, sizeof(fullcmd), argv+1);
1930                                 ast_cli(fd, "No such command '%s'.\n", fullcmd);
1931                         }
1932                 }
1933         } else {
1934                 return help_workhorse(fd, NULL);
1935         }
1936         return RESULT_SUCCESS;
1937 }
1938
1939 /*! \brief Convert string to use HTML escaped characters
1940         \note Maybe this should be a generic function?
1941 */
1942 static void write_html_escaped(FILE *htmlfile, char *str)
1943 {
1944         char *cur = str;
1945
1946         while(*cur) {
1947                 switch (*cur) {
1948                 case '<':
1949                         fprintf(htmlfile, "%s", "&lt;");
1950                         break;
1951                 case '>':
1952                         fprintf(htmlfile, "%s", "&gt;");
1953                         break;
1954                 case '&':
1955                         fprintf(htmlfile, "%s", "&amp;");
1956                         break;
1957                 case '"':
1958                         fprintf(htmlfile, "%s", "&quot;");
1959                         break;
1960                 default:
1961                         fprintf(htmlfile, "%c", *cur);
1962                         break;
1963                 }
1964                 cur++;
1965         }
1966
1967         return;
1968 }
1969
1970 static int handle_agidumphtml(int fd, int argc, char *argv[])
1971 {
1972         struct agi_command *e;
1973         char fullcmd[80];
1974         int x;
1975         FILE *htmlfile;
1976
1977         if ((argc < 3))
1978                 return RESULT_SHOWUSAGE;
1979
1980         if (!(htmlfile = fopen(argv[2], "wt"))) {
1981                 ast_cli(fd, "Could not create file '%s'\n", argv[2]);
1982                 return RESULT_SHOWUSAGE;
1983         }
1984
1985         fprintf(htmlfile, "<HTML>\n<HEAD>\n<TITLE>AGI Commands</TITLE>\n</HEAD>\n");
1986         fprintf(htmlfile, "<BODY>\n<CENTER><B><H1>AGI Commands</H1></B></CENTER>\n\n");
1987
1988
1989         fprintf(htmlfile, "<TABLE BORDER=\"0\" CELLSPACING=\"10\">\n");
1990
1991         for (x=0;x<sizeof(commands)/sizeof(commands[0]);x++) {
1992                 char *stringp, *tempstr;
1993
1994                 e = &commands[x];
1995                 if (!e->cmda[0])        /* end ? */
1996                         break;
1997                 /* Hide commands that start with '_' */
1998                 if ((e->cmda[0])[0] == '_')
1999                         continue;
2000                 ast_join(fullcmd, sizeof(fullcmd), e->cmda);
2001
2002                 fprintf(htmlfile, "<TR><TD><TABLE BORDER=\"1\" CELLPADDING=\"5\" WIDTH=\"100%%\">\n");
2003                 fprintf(htmlfile, "<TR><TH ALIGN=\"CENTER\"><B>%s - %s</B></TH></TR>\n", fullcmd,e->summary);
2004
2005                 stringp=e->usage;
2006                 tempstr = strsep(&stringp, "\n");
2007
2008                 fprintf(htmlfile, "<TR><TD ALIGN=\"CENTER\">");
2009                 write_html_escaped(htmlfile, tempstr);
2010                 fprintf(htmlfile, "</TD></TR>\n");
2011
2012
2013                 fprintf(htmlfile, "<TR><TD ALIGN=\"CENTER\">\n");
2014                 while ((tempstr = strsep(&stringp, "\n")) != NULL) {
2015                         write_html_escaped(htmlfile, tempstr);
2016                         fprintf(htmlfile, "<BR>\n");
2017                 }
2018                 fprintf(htmlfile, "</TD></TR>\n");
2019                 fprintf(htmlfile, "</TABLE></TD></TR>\n\n");
2020
2021         }
2022
2023         fprintf(htmlfile, "</TABLE>\n</BODY>\n</HTML>\n");
2024         fclose(htmlfile);
2025         ast_cli(fd, "AGI HTML Commands Dumped to: %s\n", argv[2]);
2026         return RESULT_SUCCESS;
2027 }
2028
2029 static int agi_exec_full(struct ast_channel *chan, void *data, int enhanced, int dead)
2030 {
2031         enum agi_result res;
2032         struct ast_module_user *u;
2033         char *argv[MAX_ARGS];
2034         char buf[2048]="";
2035         char *tmp = buf;
2036         int argc = 0;
2037         int fds[2];
2038         int efd = -1;
2039         int pid;
2040         char *stringp;
2041         AGI agi;
2042
2043         if (ast_strlen_zero(data)) {
2044                 ast_log(LOG_WARNING, "AGI requires an argument (script)\n");
2045                 return -1;
2046         }
2047         ast_copy_string(buf, data, sizeof(buf));
2048
2049         memset(&agi, 0, sizeof(agi));
2050         while ((stringp = strsep(&tmp, "|")) && argc < MAX_ARGS-1)
2051                 argv[argc++] = stringp;
2052         argv[argc] = NULL;
2053
2054         u = ast_module_user_add(chan);
2055 #if 0
2056          /* Answer if need be */
2057         if (chan->_state != AST_STATE_UP) {
2058                 if (ast_answer(chan)) {
2059                         LOCAL_USER_REMOVE(u);
2060                         return -1;
2061                 }
2062         }
2063 #endif
2064         res = launch_script(argv[0], argv, fds, enhanced ? &efd : NULL, &pid);
2065         if (res == AGI_RESULT_SUCCESS) {
2066                 int status = 0;
2067                 agi.fd = fds[1];
2068                 agi.ctrl = fds[0];
2069                 agi.audio = efd;
2070                 res = run_agi(chan, argv[0], &agi, pid, &status, dead, argc, argv);
2071                 /* If the fork'd process returns non-zero, set AGISTATUS to FAILURE */
2072                 if (res == AGI_RESULT_SUCCESS && status)
2073                         res = AGI_RESULT_FAILURE;
2074                 if (fds[1] != fds[0])
2075                         close(fds[1]);
2076                 if (efd > -1)
2077                         close(efd);
2078                 ast_unreplace_sigchld();
2079         }
2080         ast_module_user_remove(u);
2081
2082         switch (res) {
2083         case AGI_RESULT_SUCCESS:
2084                 pbx_builtin_setvar_helper(chan, "AGISTATUS", "SUCCESS");
2085                 break;
2086         case AGI_RESULT_FAILURE:
2087                 pbx_builtin_setvar_helper(chan, "AGISTATUS", "FAILURE");
2088                 break;
2089         case AGI_RESULT_HANGUP:
2090                 pbx_builtin_setvar_helper(chan, "AGISTATUS", "HANGUP");
2091                 return -1;
2092         }
2093
2094         return 0;
2095 }
2096
2097 static int agi_exec(struct ast_channel *chan, void *data)
2098 {
2099         if (chan->_softhangup)
2100                 ast_log(LOG_WARNING, "If you want to run AGI on hungup channels you should use DeadAGI!\n");
2101         return agi_exec_full(chan, data, 0, 0);
2102 }
2103
2104 static int eagi_exec(struct ast_channel *chan, void *data)
2105 {
2106         int readformat;
2107         int res;
2108
2109         if (chan->_softhangup)
2110                 ast_log(LOG_WARNING, "If you want to run AGI on hungup channels you should use DeadAGI!\n");
2111         readformat = chan->readformat;
2112         if (ast_set_read_format(chan, AST_FORMAT_SLINEAR)) {
2113                 ast_log(LOG_WARNING, "Unable to set channel '%s' to linear mode\n", chan->name);
2114                 return -1;
2115         }
2116         res = agi_exec_full(chan, data, 1, 0);
2117         if (!res) {
2118                 if (ast_set_read_format(chan, readformat)) {
2119                         ast_log(LOG_WARNING, "Unable to restore channel '%s' to format %s\n", chan->name, ast_getformatname(readformat));
2120                 }
2121         }
2122         return res;
2123 }
2124
2125 static int deadagi_exec(struct ast_channel *chan, void *data)
2126 {
2127         return agi_exec_full(chan, data, 0, 1);
2128 }
2129
2130 static char showagi_help[] =
2131 "Usage: agi show [topic]\n"
2132 "       When called with a topic as an argument, displays usage\n"
2133 "       information on the given command.  If called without a\n"
2134 "       topic, it provides a list of AGI commands.\n";
2135
2136
2137 static char dumpagihtml_help[] =
2138 "Usage: agi dumphtml <filename>\n"
2139 "       Dumps the agi command list in html format to given filename\n";
2140
2141 static struct ast_cli_entry cli_agi[] = {
2142         { { "agi", "debug", NULL },
2143         agi_do_debug, "Enable AGI debugging",
2144         debug_usage },
2145
2146         { { "agi", "debug", "off", NULL },
2147         agi_no_debug, "Disable AGI debugging",
2148         no_debug_usage },
2149
2150         { { "agi", "show", NULL },
2151         handle_showagi, "List AGI commands or specific help",
2152         showagi_help },
2153
2154         { { "agi", "dumphtml", NULL },
2155         handle_agidumphtml, "Dumps a list of agi commands in html format",
2156         dumpagihtml_help },
2157 };
2158
2159 static int unload_module(void)
2160 {
2161         ast_module_user_hangup_all();
2162         ast_cli_unregister_multiple(cli_agi, sizeof(cli_agi) / sizeof(struct ast_cli_entry));
2163         ast_unregister_application(eapp);
2164         ast_unregister_application(deadapp);
2165         return ast_unregister_application(app);
2166 }
2167
2168 static int load_module(void)
2169 {
2170         ast_cli_register_multiple(cli_agi, sizeof(cli_agi) / sizeof(struct ast_cli_entry));
2171         ast_register_application(deadapp, deadagi_exec, deadsynopsis, descrip);
2172         ast_register_application(eapp, eagi_exec, esynopsis, descrip);
2173         return ast_register_application(app, agi_exec, synopsis, descrip);
2174 }
2175
2176 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Asterisk Gateway Interface (AGI)",
2177                 .load = load_module,
2178                 .unload = unload_module,
2179                 );