res/res_agi.c

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