apps/app_agi.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Asterisk Gateway Interface
   5  *
   6  * Copyright (C) 1999, Mark Spencer
   7  *
   8  * Mark Spencer <markster@linux-support.net>
   9  *
  10  * This program is free software, distributed under the terms of
  11  * the GNU General Public License
  12  */
  13
  14 #include <asterisk/file.h>
  15 #include <asterisk/logger.h>
  16 #include <asterisk/channel.h>
  17 #include <asterisk/pbx.h>
  18 #include <asterisk/module.h>
  19 #include <math.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <sys/signal.h>
  25 #include <sys/time.h>
  26 #include <asterisk/cli.h>
  27 #include <asterisk/logger.h>
  28 #include <asterisk/options.h>
  29 #include <asterisk/image.h>
  30 #include <asterisk/say.h>
  31 #include "../asterisk.h"
  32
  33 #include <pthread.h>
  34
  35 #define MAX_ARGS 128
  36
  37 /* Recycle some stuff from the CLI interface */
  38 #define fdprintf ast_cli
  39
  40 typedef struct agi_command {
  41         /* Null terminated list of the words of the command */
  42         char *cmda[AST_MAX_CMD_LEN];
  43         /* Handler for the command (fd for output, # of arguments, argument list).
  44             Returns RESULT_SHOWUSAGE for improper arguments */
  45         int (*handler)(struct ast_channel *chan, int fd, int argc, char *argv[]);
  46         /* Summary of the command (< 60 characters) */
  47         char *summary;
  48         /* Detailed usage information */
  49         char *usage;
  50 } agi_command;
  51
  52 static char *tdesc = "Asterisk Gateway Interface (AGI)";
  53
  54 static char *app = "AGI";
  55
  56 static char *synopsis = "Executes an AGI compliant application";
  57
  58 static char *descrip =
  59 "  AGI(command|args): Executes an Asterisk Gateway Interface compliant\n"
  60 "program on a channel.   AGI allows Asterisk to launch external programs\n"
  61 "written in any language to control a telephony channel, play audio,\n"
  62 "read DTMF digits, etc. by communicating with the AGI protocol on stdin\n"
  63 "and stdout.  Returns -1 on hangup or if application requested hangup, or\n"
  64 "0 on non-hangup exit.\n";
  65
  66 STANDARD_LOCAL_USER;
  67
  68 LOCAL_USER_DECL;
  69
  70 #define TONE_BLOCK_SIZE 200
  71
  72 static float loudness = 8192.0;
  73
  74 unsigned char linear2ulaw(short sample);
  75 static void make_tone_block(unsigned char *data, float f1, int *x);
  76
  77 static void make_tone_block(unsigned char *data, float f1, int *x)
  78 {
  79 int     i;
  80 float   val;
  81
  82         for(i = 0; i < TONE_BLOCK_SIZE; i++)
  83         {
  84                 val = loudness * sin((f1 * 2.0 * M_PI * (*x)++)/8000.0);
  85                 data[i] = linear2ulaw((int)val);
  86          }
  87           /* wrap back around from 8000 */
  88         if (*x >= 8000) *x = 0;
  89         return;
  90 }
  91
  92 static int launch_script(char *script, char *args, int *fds, int *opid)
  93 {
  94         char tmp[256];
  95         int pid;
  96         int toast[2];
  97         int fromast[2];
  98         int x;
  99         if (script[0] != '/') {
 100                 snprintf(tmp, sizeof(tmp), "%s/%s", AST_AGI_DIR, script);
 101                 script = tmp;
 102         }
 103         if (pipe(toast)) {
 104                 ast_log(LOG_WARNING, "Unable to create toast pipe: %s\n",strerror(errno));
 105                 return -1;
 106         }
 107         if (pipe(fromast)) {
 108                 ast_log(LOG_WARNING, "unable to create fromast pipe: %s\n", strerror(errno));
 109                 close(toast[0]);
 110                 close(toast[1]);
 111                 return -1;
 112         }
 113         pid = fork();
 114         if (pid < 0) {
 115                 ast_log(LOG_WARNING, "Failed to fork(): %s\n", strerror(errno));
 116                 return -1;
 117         }
 118         if (!pid) {
 119                 /* Redirect stdin and out */
 120                 dup2(fromast[0], STDIN_FILENO);
 121                 dup2(toast[1], STDOUT_FILENO);
 122                 /* Close everything but stdin/out/error */
 123                 for (x=STDERR_FILENO + 1;x<1024;x++)
 124                         close(x);
 125                 /* Execute script */
 126                 execl(script, script, args, NULL);
 127                 ast_log(LOG_WARNING, "Failed to execute '%s': %s\n", script, strerror(errno));
 128                 exit(1);
 129         }
 130         if (option_verbose > 2)
 131                 ast_verbose(VERBOSE_PREFIX_3 "Launched AGI Script %s\n", script);
 132         fds[0] = toast[0];
 133         fds[1] = fromast[1];
 134         /* close what we're not using in the parent */
 135         close(toast[1]);
 136         close(fromast[0]);
 137         *opid = pid;
 138         return 0;
 139
 140 }
 141
 142 static void setup_env(struct ast_channel *chan, char *request, int fd)
 143 {
 144         /* Print initial environment, with agi_request always being the first
 145            thing */
 146         fdprintf(fd, "agi_request: %s\n", request);
 147         fdprintf(fd, "agi_channel: %s\n", chan->name);
 148         fdprintf(fd, "agi_language: %s\n", chan->language);
 149         fdprintf(fd, "agi_type: %s\n", chan->type);
 150
 151         /* ANI/DNIS */
 152         fdprintf(fd, "agi_callerid: %s\n", chan->callerid ? chan->callerid : "");
 153         fdprintf(fd, "agi_dnid: %s\n", chan->dnid ? chan->dnid : "");
 154
 155         /* Context information */
 156         fdprintf(fd, "agi_context: %s\n", chan->context);
 157         fdprintf(fd, "agi_extension: %s\n", chan->exten);
 158         fdprintf(fd, "agi_priority: %d\n", chan->priority);
 159
 160         /* End with empty return */
 161         fdprintf(fd, "\n");
 162 }
 163
 164 static int handle_waitfordigit(struct ast_channel *chan, int fd, int argc, char *argv[])
 165 {
 166         int res;
 167         int to;
 168         if (argc != 4)
 169                 return RESULT_SHOWUSAGE;
 170         if (sscanf(argv[3], "%i", &to) != 1)
 171                 return RESULT_SHOWUSAGE;
 172         res = ast_waitfordigit(chan, to);
 173         fdprintf(fd, "200 result=%d\n", res);
 174         if (res >= 0)
 175                 return RESULT_SUCCESS;
 176         else
 177                 return RESULT_FAILURE;
 178 }
 179
 180 static int handle_sendtext(struct ast_channel *chan, int fd, int argc, char *argv[])
 181 {
 182         int res;
 183         if (argc != 3)
 184                 return RESULT_SHOWUSAGE;
 185         /* At the moment, the parser (perhaps broken) returns with
 186            the last argument PLUS the newline at the end of the input
 187            buffer. This probably needs to be fixed, but I wont do that
 188            because other stuff may break as a result. The right way
 189            would probably be to strip off the trailing newline before
 190            parsing, then here, add a newline at the end of the string
 191            before sending it to ast_sendtext --DUDE */
 192         res = ast_sendtext(chan, argv[2]);
 193         fdprintf(fd, "200 result=%d\n", res);
 194         if (res >= 0)
 195                 return RESULT_SUCCESS;
 196         else
 197                 return RESULT_FAILURE;
 198 }
 199
 200 static int handle_recvchar(struct ast_channel *chan, int fd, int argc, char *argv[])
 201 {
 202         int res;
 203         if (argc != 3)
 204                 return RESULT_SHOWUSAGE;
 205         res = ast_recvchar(chan,atoi(argv[2]));
 206         if (res == 0) {
 207                 fdprintf(fd, "200 result=%d (timeout)\n", res);
 208                 return RESULT_SUCCESS;
 209         }
 210         if (res > 0) {
 211                 fdprintf(fd, "200 result=%d\n", res);
 212                 return RESULT_SUCCESS;
 213         }
 214         else {
 215                 fdprintf(fd, "200 result=%d (hangup)\n", res);
 216                 return RESULT_FAILURE;
 217         }
 218 }
 219
 220 static int handle_tddmode(struct ast_channel *chan, int fd, int argc, char *argv[])
 221 {
 222         int res,x;
 223         if (argc != 3)
 224                 return RESULT_SHOWUSAGE;
 225         if (!strncasecmp(argv[2],"on",2)) x = 1; else x = 0;
 226         res = ast_channel_setoption(chan,AST_OPTION_TDD,&x,sizeof(char),0);
 227         fdprintf(fd, "200 result=%d\n", res);
 228         if (res >= 0)
 229                 return RESULT_SUCCESS;
 230         else
 231                 return RESULT_FAILURE;
 232 }
 233
 234 static int handle_sendimage(struct ast_channel *chan, int fd, int argc, char *argv[])
 235 {
 236         int res;
 237         if (argc != 3)
 238                 return RESULT_SHOWUSAGE;
 239         res = ast_send_image(chan, argv[2]);
 240         if (!ast_check_hangup(chan))
 241                 res = 0;
 242         fdprintf(fd, "200 result=%d\n", res);
 243         if (res >= 0)
 244                 return RESULT_SUCCESS;
 245         else
 246                 return RESULT_FAILURE;
 247 }
 248
 249 static int handle_streamfile(struct ast_channel *chan, int fd, int argc, char *argv[])
 250 {
 251         int res;
 252         if (argc != 4)
 253                 return RESULT_SHOWUSAGE;
 254         res = ast_streamfile(chan, argv[2],chan->language);
 255         if (res) {
 256                 fdprintf(fd, "200 result=%d\n", res);
 257                 if (res >= 0)
 258                         return RESULT_SHOWUSAGE;
 259                 else
 260                         return RESULT_FAILURE;
 261         }
 262         res = ast_waitstream(chan, argv[3]);
 263
 264         fdprintf(fd, "200 result=%d\n", res);
 265         if (res >= 0)
 266                 return RESULT_SUCCESS;
 267         else
 268                 return RESULT_FAILURE;
 269 }
 270
 271 static int handle_saynumber(struct ast_channel *chan, int fd, int argc, char *argv[])
 272 {
 273         int res;
 274         int num;
 275         if (argc != 4)
 276                 return RESULT_SHOWUSAGE;
 277         if (sscanf(argv[2], "%i", &num) != 1)
 278                 return RESULT_SHOWUSAGE;
 279         res = ast_say_number(chan, num, AST_DIGIT_ANY, chan->language);
 280         fdprintf(fd, "200 result=%d\n", res);
 281         if (res >= 0)
 282                 return RESULT_SUCCESS;
 283         else
 284                 return RESULT_FAILURE;
 285 }
 286
 287 int ast_app_getdata(struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout);
 288
 289 static int handle_getdata(struct ast_channel *chan, int fd, int argc, char *argv[])
 290 {
 291         int res;
 292         char data[50];
 293         int max;
 294         int timeout;
 295
 296         if (argc < 3)
 297                 return RESULT_SHOWUSAGE;
 298         if (argc >= 4) timeout = atoi(argv[3]); else timeout = 0;
 299         if (argc >= 5) max = atoi(argv[4]); else max = 50;
 300         res = ast_app_getdata(chan, argv[2], data, max, timeout);
 301         if (res == 1)
 302                 fdprintf(fd, "200 result=%s (timeout)\n", data);
 303         else
 304                 fdprintf(fd, "200 result=%s\n", data);
 305         if (res >= 0)
 306                 return RESULT_SUCCESS;
 307         else
 308                 return RESULT_FAILURE;
 309 }
 310
 311 static int handle_setcontext(struct ast_channel *chan, int fd, int argc, char *argv[])
 312 {
 313
 314         if (argc != 3)
 315                 return RESULT_SHOWUSAGE;
 316         strncpy(chan->context, argv[2], sizeof(chan->context)-1);
 317         fdprintf(fd, "200 result=0\n");
 318         return RESULT_SUCCESS;
 319 }
 320
 321 static int handle_setextension(struct ast_channel *chan, int fd, int argc, char **argv)
 322 {
 323         if (argc != 3)
 324                 return RESULT_SHOWUSAGE;
 325         strncpy(chan->exten, argv[2], sizeof(chan->exten)-1);
 326         fdprintf(fd, "200 result=0\n");
 327         return RESULT_SUCCESS;
 328 }
 329
 330 static int handle_setpriority(struct ast_channel *chan, int fd, int argc, char **argv)
 331 {
 332         int pri;
 333         if (argc != 3)
 334                 return RESULT_SHOWUSAGE;
 335         if (sscanf(argv[2], "%i", &pri) != 1)
 336                 return RESULT_SHOWUSAGE;
 337         chan->priority = pri - 1;
 338         fdprintf(fd, "200 result=0\n");
 339         return RESULT_SUCCESS;
 340 }
 341
 342 static int ms_diff(struct timeval *tv1, struct timeval *tv2)
 343 {
 344 int     ms;
 345
 346         ms = (tv1->tv_sec - tv2->tv_sec) * 1000;
 347         ms += (tv1->tv_usec - tv2->tv_usec) / 1000;
 348         return(ms);
 349 }
 350
 351 static int handle_recordfile(struct ast_channel *chan, int fd, int argc, char *argv[])
 352 {
 353         struct ast_filestream *fs;
 354         struct ast_frame *f,wf;
 355         struct timeval tv, start, lastout, now, notime = { 0,0 } ;
 356         fd_set readfds;
 357         unsigned char tone_block[TONE_BLOCK_SIZE];
 358         int res = -1;
 359         int ms,i,j;
 360
 361         if (argc < 6)
 362                 return RESULT_SHOWUSAGE;
 363         if (sscanf(argv[5], "%i", &ms) != 1)
 364                 return RESULT_SHOWUSAGE;
 365
 366         if (argc > 6) { /* if to beep */
 367                 i = 0;
 368                 lastout.tv_sec = lastout.tv_usec = 0;
 369                 for(j = 0; j < 13; j++)
 370                    {
 371                         do gettimeofday(&now,NULL);
 372                         while (lastout.tv_sec &&
 373                                 (ms_diff(&now,&lastout) < 25));
 374                         lastout.tv_sec = now.tv_sec;
 375                         lastout.tv_usec = now.tv_usec;
 376                         wf.frametype = AST_FRAME_VOICE;
 377                         wf.subclass = AST_FORMAT_ULAW;
 378                         wf.offset = AST_FRIENDLY_OFFSET;
 379                         wf.mallocd = 0;
 380                         wf.data = tone_block;
 381                         wf.datalen = TONE_BLOCK_SIZE;
 382                         /* make this tone block */
 383                         make_tone_block(tone_block,1000.0,&i);
 384                         wf.timelen = wf.datalen / 8;
 385                         if (ast_write(chan, &wf)) {
 386                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
 387                                 return RESULT_FAILURE;
 388                         }
 389                         FD_ZERO(&readfds);
 390                         FD_SET(chan->fds[0],&readfds);
 391                           /* if no read avail, do send again */
 392                         if (select(chan->fds[0] + 1,&readfds,NULL,
 393                                 NULL,&notime) < 1) continue;
 394                         f = ast_read(chan);
 395                         if (!f) {
 396                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
 397                                 return RESULT_FAILURE;
 398                         }
 399                         switch(f->frametype) {
 400                         case AST_FRAME_DTMF:
 401                                 if (strchr(argv[4], f->subclass)) {
 402                                         /* This is an interrupting chracter */
 403                                         fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
 404                                         ast_frfree(f);
 405                                         return RESULT_SUCCESS;
 406                                 }
 407                                 break;
 408                         case AST_FRAME_VOICE:
 409                                 break;  /* throw it away */
 410                         }
 411                         ast_frfree(f);
 412                    }
 413                   /* suck in 5 voice frames to make up for echo of beep, etc */
 414                 for(i = 0; i < 5; i++) {
 415                         f = ast_read(chan);
 416                         if (!f) {
 417                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
 418                                 return RESULT_FAILURE;
 419                         }
 420                         switch(f->frametype) {
 421                         case AST_FRAME_DTMF:
 422                                 if (strchr(argv[4], f->subclass)) {
 423                                         /* This is an interrupting chracter */
 424                                         fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
 425                                         ast_frfree(f);
 426                                         return RESULT_SUCCESS;
 427                                 }
 428                                 break;
 429                         case AST_FRAME_VOICE:
 430                                 break;  /* throw it away */
 431                         }
 432                         ast_frfree(f);
 433                 }
 434
 435         }
 436
 437         fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_TRUNC | O_WRONLY, 0, 0644);
 438         if (!fs) {
 439                 fdprintf(fd, "200 result=%d (writefile)\n", res);
 440                 return RESULT_FAILURE;
 441         }
 442         gettimeofday(&start, NULL);
 443         gettimeofday(&tv, NULL);
 444         while ((ms < 0) || (((tv.tv_sec - start.tv_sec) * 1000 + (tv.tv_usec - start.tv_usec)/1000) < ms)) {
 445                 res = ast_waitfor(chan, -1);
 446                 if (res < 0) {
 447                         ast_closestream(fs);
 448                         fdprintf(fd, "200 result=%d (waitfor)\n", res);
 449                         return RESULT_FAILURE;
 450                 }
 451                 f = ast_read(chan);
 452                 if (!f) {
 453                         fdprintf(fd, "200 result=%d (hangup)\n", 0);
 454                         ast_closestream(fs);
 455                         return RESULT_FAILURE;
 456                 }
 457                 switch(f->frametype) {
 458                 case AST_FRAME_DTMF:
 459                         if (strchr(argv[4], f->subclass)) {
 460                                 /* This is an interrupting chracter */
 461                                 fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
 462                                 ast_closestream(fs);
 463                                 ast_frfree(f);
 464                                 return RESULT_SUCCESS;
 465                         }
 466                         break;
 467                 case AST_FRAME_VOICE:
 468                         ast_writestream(fs, f);
 469                         break;
 470                 };
 471                 ast_frfree(f);
 472                 gettimeofday(&tv, NULL);
 473         }
 474         fdprintf(fd, "200 result=%d (timeout)\n", 0);
 475         ast_closestream(fs);
 476         return RESULT_SUCCESS;
 477 }
 478
 479 static char usage_waitfordigit[] =
 480 " Usage: WAIT FOR DIGIT <timeout>\n"
 481 "        Waits up to 'timeout' seconds for channel to receive a DTMF digit.\n"
 482 " Returns -1 on channel failure, 0 if no digit is received in the timeout, or\n"
 483 " the numerical value of the ascii of the digit if one is received.  Use -1\n"
 484 " for the timeout value if you desire the call to block indefinitely.\n";
 485
 486 static char usage_sendtext[] =
 487 " Usage: SEND TEXT \"<text to send>\"\n"
 488 "        Sends the given text on a channel.  Most channels do not support the\n"
 489 " transmission of text.  Returns 0 if text is sent, or if the channel does not\n"
 490 " support text transmission.  Returns -1 only on error/hangup.  Text\n"
 491 " consisting of greater than one word should be placed in quotes since the\n"
 492 " command only accepts a single argument.\n";
 493
 494 static char usage_recvchar[] =
 495 " Usage: RECEIVE CHAR <timeout>\n"
 496 "        Receives a character of text on a channel.  Specify timeout to be the\n"
 497 " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n"
 498 " do not support the reception of text.  Returns the decimal value of the character\n"
 499 " if one is received, or 0 if the channel does not support text reception.  Returns\n"
 500 " -1 only on error/hangup.\n";
 501
 502 static char usage_tddmode[] =
 503 " Usage: TDD MODE <on|off>\n"
 504 "        Enable/Disable TDD transmission/reception on a channel. Returns 1 if\n"
 505 " successful, or 0 if channel is not TDD-capable.\n";
 506
 507 static char usage_sendimage[] =
 508 " Usage: SEND IMAGE <image>\n"
 509 "        Sends the given image on a channel.  Most channels do not support the\n"
 510 " transmission of images.  Returns 0 if image is sent, or if the channel does not\n"
 511 " support image transmission.  Returns -1 only on error/hangup.  Image names\n"
 512 " should not include extensions.\n";
 513
 514 static char usage_streamfile[] =
 515 " Usage: STREAM FILE <filename> <escape digits>\n"
 516 "        Send the given file, allowing playback to be interrupted by the given\n"
 517 " digits, if any.  Use double quotes for the digits if you wish none to be\n"
 518 " permitted.  Returns 0 if playback completes without a digit being pressed, or\n"
 519 " the ASCII numerical value of the digit if one was pressed, or -1 on error or\n"
 520 " if the channel was disconnected.  Remember, the file extension must not be\n"
 521 " included in the filename.\n";
 522
 523 static char usage_saynumber[] =
 524 " Usage: SAY NUMBER <number> <escape digits>\n"
 525 "        Say a given number, returning early if any of the given DTMF digits\n"
 526 " are received on the channel.  Returns 0 if playback completes without a digit\n"
 527 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
 528 " -1 on error/hangup.\n";
 529
 530 static char usage_getdata[] =
 531 " Usage: GET DATA <file to be streamed> [timeout] [max digits]\n"
 532 "        Stream the given file, and recieve DTMF data. Returns the digits recieved\n"
 533 "from the channel at the other end.\n";
 534
 535 static char usage_setcontext[] =
 536 " Usage: SET CONTEXT <desired context>\n"
 537 "        Sets the context for continuation upon exiting the application.\n";
 538
 539 static char usage_setextension[] =
 540 " Usage: SET EXTENSION <new extension>\n"
 541 "        Changes the extension for continuation upon exiting the application.\n";
 542
 543 static char usage_setpriority[] =
 544 " Usage: SET PRIORITY <num>\n"
 545 "        Changes the priority for continuation upon exiting the application.\n";
 546
 547 static char usage_recordfile[] =
 548 " Usage: RECORD FILE <filename> <format> <escape digits> <timeout> [BEEP]\n"
 549 "        Record to a file until a given dtmf digit in the sequence is received\n"
 550 " Returns -1 on hangup or error.  The format will specify what kind of file\n"
 551 " will be recorded.  The timeout is the maximum record time in milliseconds, or\n"
 552 " -1 for no timeout\n";
 553
 554 agi_command commands[] = {
 555         { { "wait", "for", "digit", NULL }, handle_waitfordigit, "Waits for a digit to be pressed", usage_waitfordigit },
 556         { { "send", "text", NULL }, handle_sendtext, "Sends text to channels supporting it", usage_sendtext },
 557         { { "receive", "char", NULL }, handle_recvchar, "Receives text from channels supporting it", usage_recvchar },
 558         { { "tdd", "mode", NULL }, handle_tddmode, "Sends text to channels supporting it", usage_tddmode },
 559         { { "stream", "file", NULL }, handle_streamfile, "Sends audio file on channel", usage_streamfile },
 560         { { "send", "image", NULL }, handle_sendimage, "Sends images to channels supporting it", usage_sendimage },
 561         { { "say", "number", NULL }, handle_saynumber, "Says a given number", usage_saynumber },
 562         { { "get", "data", NULL }, handle_getdata, "Gets data on a channel", usage_getdata },
 563         { { "set", "context", NULL }, handle_setcontext, "Sets channel context", usage_setcontext },
 564         { { "set", "extension", NULL }, handle_setextension, "Changes channel extension", usage_setextension },
 565         { { "set", "priority", NULL }, handle_setpriority, "Prioritizes the channel", usage_setpriority },
 566         { { "record", "file", NULL }, handle_recordfile, "Records to a given file", usage_recordfile }
 567 };
 568
 569 static agi_command *find_command(char *cmds[])
 570 {
 571         int x;
 572         int y;
 573         int match;
 574         for (x=0;x < sizeof(commands) / sizeof(commands[0]);x++) {
 575                 /* start optimistic */
 576                 match = 1;
 577                 for (y=0;match && cmds[y]; y++) {
 578                         /* If there are no more words in the command (and we're looking for
 579                            an exact match) or there is a difference between the two words,
 580                            then this is not a match */
 581                         if (!commands[x].cmda[y])
 582                                 break;
 583                         if (strcasecmp(commands[x].cmda[y], cmds[y]))
 584                                 match = 0;
 585                 }
 586                 /* If more words are needed to complete the command then this is not
 587                    a candidate (unless we're looking for a really inexact answer  */
 588                 if (commands[x].cmda[y])
 589                         match = 0;
 590                 if (match)
 591                         return &commands[x];
 592         }
 593         return NULL;
 594 }
 595
 596
 597 static int parse_args(char *s, int *max, char *argv[])
 598 {
 599         int x=0;
 600         int quoted=0;
 601         int escaped=0;
 602         int whitespace=1;
 603         char *cur;
 604
 605         cur = s;
 606         while(*s) {
 607                 switch(*s) {
 608                 case '"':
 609                         /* If it's escaped, put a literal quote */
 610                         if (escaped)
 611                                 goto normal;
 612                         else
 613                                 quoted = !quoted;
 614                         if (quoted && whitespace) {
 615                                 /* If we're starting a quote, coming off white space start a new word, too */
 616                                 argv[x++] = cur;
 617                                 whitespace=0;
 618                         }
 619                         escaped = 0;
 620                 break;
 621                 case ' ':
 622                 case '\t':
 623                         if (!quoted && !escaped) {
 624                                 /* If we're not quoted, mark this as whitespace, and
 625                                    end the previous argument */
 626                                 whitespace = 1;
 627                                 *(cur++) = '\0';
 628                         } else
 629                                 /* Otherwise, just treat it as anything else */
 630                                 goto normal;
 631                         break;
 632                 case '\\':
 633                         /* If we're escaped, print a literal, otherwise enable escaping */
 634                         if (escaped) {
 635                                 goto normal;
 636                         } else {
 637                                 escaped=1;
 638                         }
 639                         break;
 640                 default:
 641 normal:
 642                         if (whitespace) {
 643                                 if (x >= MAX_ARGS -1) {
 644                                         ast_log(LOG_WARNING, "Too many arguments, truncating\n");
 645                                         break;
 646                                 }
 647                                 /* Coming off of whitespace, start the next argument */
 648                                 argv[x++] = cur;
 649                                 whitespace=0;
 650                         }
 651                         *(cur++) = *s;
 652                         escaped=0;
 653                 }
 654                 s++;
 655         }
 656         /* Null terminate */
 657         *(cur++) = '\0';
 658         argv[x] = NULL;
 659         *max = x;
 660         return 0;
 661 }
 662
 663 static int agi_handle_command(struct ast_channel *chan, int fd, char *buf)
 664 {
 665         char *argv[MAX_ARGS];
 666         int argc = 0;
 667         int res;
 668         agi_command *c;
 669         argc = MAX_ARGS;
 670         parse_args(buf, &argc, argv);
 671 #if     0
 672         { int x;
 673         for (x=0;x<argc;x++)
 674                 fprintf(stderr, "Got Arg%d: %s\n", x, argv[x]); }
 675 #endif
 676         c = find_command(argv);
 677         if (c) {
 678                 res = c->handler(chan, fd, argc, argv);
 679                 switch(res) {
 680                 case RESULT_SHOWUSAGE:
 681                         fdprintf(fd, "520-Invalid command syntax.  Proper usage follows:\n");
 682                         fdprintf(fd, c->usage);
 683                         fdprintf(fd, "520 End of proper usage.\n");
 684                         break;
 685                 case RESULT_FAILURE:
 686                         /* They've already given the failure.  We've been hung up on so handle this
 687                            appropriately */
 688                         return -1;
 689                 }
 690         } else {
 691                 fdprintf(fd, "510 Invalid or unknown command\n");
 692         }
 693         return 0;
 694 }
 695
 696 static int run_agi(struct ast_channel *chan, char *request, int *fds, int pid)
 697 {
 698         struct ast_channel *c;
 699         int outfd;
 700         int ms;
 701         int returnstatus = 0;
 702         struct ast_frame *f;
 703         char buf[2048];
 704         FILE *readf;
 705         if (!(readf = fdopen(fds[0], "r"))) {
 706                 ast_log(LOG_WARNING, "Unable to fdopen file descriptor\n");
 707                 kill(pid, SIGHUP);
 708                 return -1;
 709         }
 710         setlinebuf(readf);
 711         setup_env(chan, request, fds[1]);
 712         for (;;) {
 713                 ms = -1;
 714                 c = ast_waitfor_nandfds(&chan, 1, &fds[0], 1, NULL, &outfd, &ms);
 715                 if (c) {
 716                         /* Idle the channel until we get a command */
 717                         f = ast_read(c);
 718                         if (!f) {
 719                                 ast_log(LOG_DEBUG, "%s hungup\n", chan->name);
 720                                 returnstatus = -1;
 721                                 break;
 722                         } else {
 723                                 ast_frfree(f);
 724                         }
 725                 } else if (outfd > -1) {
 726                         if (!fgets(buf, sizeof(buf), readf)) {
 727                                 /* Program terminated */
 728                                 if (returnstatus)
 729                                         returnstatus = -1;
 730                                 if (option_verbose > 2)
 731                                         ast_verbose(VERBOSE_PREFIX_3 "AGI Script %s completed, returning %d\n", request, returnstatus);
 732                                 /* No need to kill the pid anymore, since they closed us */
 733                                 pid = -1;
 734                                 break;
 735                         }
 736 #if     0
 737                         /* Un-comment this code to fix the problem with
 738                            the newline being included in the parsed
 739                            command string(s) output --DUDE */
 740                           /* get rid of trailing newline, if any */
 741                         if (*buf && buf[strlen(buf) - 1] == '\n')
 742                                 buf[strlen(buf) - 1] = 0;
 743 #endif
 744                         returnstatus |= agi_handle_command(chan, fds[1], buf);
 745                         /* If the handle_command returns -1, we need to stop */
 746                         if (returnstatus < 0) {
 747                                 break;
 748                         }
 749                 } else {
 750                         ast_log(LOG_WARNING, "No channel, no fd?\n");
 751                         returnstatus = -1;
 752                         break;
 753                 }
 754         }
 755         /* Notify process */
 756         if (pid > -1)
 757                 kill(pid, SIGHUP);
 758         fclose(readf);
 759         return returnstatus;
 760 }
 761
 762 static int agi_exec(struct ast_channel *chan, void *data)
 763 {
 764         int res=0;
 765         struct localuser *u;
 766         char *args,*ringy;
 767         char tmp[256];
 768         int fds[2];
 769         int pid;
 770         if (!data || !strlen(data)) {
 771                 ast_log(LOG_WARNING, "AGI requires an argument (script)\n");
 772                 return -1;
 773         }
 774
 775
 776         strncpy(tmp, data, sizeof(tmp)-1);
 777         strtok(tmp, "|");
 778         args = strtok(NULL, "|");
 779         ringy = strtok(NULL,"|");
 780         if (!args)
 781                 args = "";
 782         LOCAL_USER_ADD(u);
 783          /* Answer if need be */
 784         if (chan->state != AST_STATE_UP) {
 785                 if (ringy) { /* if for ringing first */
 786                         /* a little ringy-dingy first */
 787                         ast_indicate(chan, AST_CONTROL_RINGING);
 788                         sleep(3);
 789                 }
 790                 if (ast_answer(chan)) {
 791                         LOCAL_USER_REMOVE(u);
 792                         return -1;
 793                 }
 794         }
 795         res = launch_script(tmp, args, fds, &pid);
 796         if (!res) {
 797                 res = run_agi(chan, tmp, fds, pid);
 798                 close(fds[0]);
 799                 close(fds[1]);
 800         }
 801         LOCAL_USER_REMOVE(u);
 802         return res;
 803 }
 804
 805 int unload_module(void)
 806 {
 807         STANDARD_HANGUP_LOCALUSERS;
 808         return ast_unregister_application(app);
 809 }
 810
 811 int load_module(void)
 812 {
 813         return ast_register_application(app, agi_exec, synopsis, descrip);
 814 }
 815
 816 char *description(void)
 817 {
 818         return tdesc;
 819 }
 820
 821 int usecount(void)
 822 {
 823         int res;
 824         STANDARD_USECOUNT(res);
 825         return res;
 826 }
 827
 828 char *key()
 829 {
 830         return ASTERISK_GPL_KEY;
 831 }
 832
 833 #define CLIP 32635
 834 #define BIAS 0x84
 835
 836 unsigned char
 837 linear2ulaw(sample)
 838 short sample; {
 839   static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
 840                              4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
 841                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 842                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 843                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 844                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 845                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 846                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 847                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 848                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 849                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 850                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 851                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 852                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 853                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 854                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
 855   int sign, exponent, mantissa;
 856   unsigned char ulawbyte;
 857
 858   /* Get the sample into sign-magnitude. */
 859   sign = (sample >> 8) & 0x80;          /* set aside the sign */
 860   if (sign != 0) sample = -sample;              /* get magnitude */
 861   if (sample > CLIP) sample = CLIP;             /* clip the magnitude */
 862
 863   /* Convert from 16 bit linear to ulaw. */
 864   sample = sample + BIAS;
 865   exponent = exp_lut[(sample >> 7) & 0xFF];
 866   mantissa = (sample >> (exponent + 3)) & 0x0F;
 867   ulawbyte = ~(sign | (exponent << 4) | mantissa);
 868 #ifdef ZEROTRAP
 869   if (ulawbyte == 0) ulawbyte = 0x02;   /* optional CCITT trap */
 870 #endif
 871
 872   return(ulawbyte);
 873 }