c2d6f20e7a27ce4d5365b214d36cd8a1553a3a88
[asterisk/asterisk.git] / 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_answer(struct ast_channel *chan, int fd, int argc, char *argv[])
165 {
166         int res;
167         res = 0;
168         if (chan->state != AST_STATE_UP) {
169                 /* Answer the chan */
170                 res = ast_answer(chan);
171         }
172         fdprintf(fd, "200 result=%d\n", res);
173         if (res >= 0)
174                 return RESULT_SUCCESS;
175         else
176                 return RESULT_FAILURE;
177 }
178
179 static int handle_waitfordigit(struct ast_channel *chan, int fd, int argc, char *argv[])
180 {
181         int res;
182         int to;
183         if (argc != 4)
184                 return RESULT_SHOWUSAGE;
185         if (sscanf(argv[3], "%i", &to) != 1)
186                 return RESULT_SHOWUSAGE;
187         res = ast_waitfordigit(chan, to);
188         fdprintf(fd, "200 result=%d\n", res);
189         if (res >= 0)
190                 return RESULT_SUCCESS;
191         else
192                 return RESULT_FAILURE;
193 }
194
195 static int handle_sendtext(struct ast_channel *chan, int fd, int argc, char *argv[])
196 {
197         int res;
198         if (argc != 3)
199                 return RESULT_SHOWUSAGE;
200         /* At the moment, the parser (perhaps broken) returns with
201            the last argument PLUS the newline at the end of the input
202            buffer. This probably needs to be fixed, but I wont do that
203            because other stuff may break as a result. The right way
204            would probably be to strip off the trailing newline before
205            parsing, then here, add a newline at the end of the string
206            before sending it to ast_sendtext --DUDE */
207         res = ast_sendtext(chan, argv[2]);
208         fdprintf(fd, "200 result=%d\n", res);
209         if (res >= 0)
210                 return RESULT_SUCCESS;
211         else
212                 return RESULT_FAILURE;
213 }
214
215 static int handle_recvchar(struct ast_channel *chan, int fd, int argc, char *argv[])
216 {
217         int res;
218         if (argc != 3)
219                 return RESULT_SHOWUSAGE;
220         res = ast_recvchar(chan,atoi(argv[2]));
221         if (res == 0) {
222                 fdprintf(fd, "200 result=%d (timeout)\n", res);
223                 return RESULT_SUCCESS;
224         }
225         if (res > 0) {
226                 fdprintf(fd, "200 result=%d\n", res);
227                 return RESULT_SUCCESS;
228         }
229         else {
230                 fdprintf(fd, "200 result=%d (hangup)\n", res);
231                 return RESULT_FAILURE;
232         }
233 }
234
235 static int handle_tddmode(struct ast_channel *chan, int fd, int argc, char *argv[])
236 {
237         int res,x;
238         if (argc != 3)
239                 return RESULT_SHOWUSAGE;
240         if (!strncasecmp(argv[2],"on",2)) x = 1; else x = 0;
241         if (!strncasecmp(argv[2],"mate",4)) x = 2;
242         if (!strncasecmp(argv[2],"tdd",3)) x = 1;
243         res = ast_channel_setoption(chan,AST_OPTION_TDD,&x,sizeof(char),0);
244         fdprintf(fd, "200 result=%d\n", res);
245         if (res >= 0) 
246                 return RESULT_SUCCESS;
247         else
248                 return RESULT_FAILURE;
249 }
250
251 static int handle_sendimage(struct ast_channel *chan, int fd, int argc, char *argv[])
252 {
253         int res;
254         if (argc != 3)
255                 return RESULT_SHOWUSAGE;
256         res = ast_send_image(chan, argv[2]);
257         if (!ast_check_hangup(chan))
258                 res = 0;
259         fdprintf(fd, "200 result=%d\n", res);
260         if (res >= 0)
261                 return RESULT_SUCCESS;
262         else
263                 return RESULT_FAILURE;
264 }
265
266 static int handle_streamfile(struct ast_channel *chan, int fd, int argc, char *argv[])
267 {
268         int res;
269         if (argc != 4)
270                 return RESULT_SHOWUSAGE;
271         res = ast_streamfile(chan, argv[2],chan->language);
272         if (res) {
273                 fdprintf(fd, "200 result=%d\n", res);
274                 if (res >= 0)
275                         return RESULT_SHOWUSAGE;
276                 else
277                         return RESULT_FAILURE;
278         }
279         res = ast_waitstream(chan, argv[3]);
280         ast_stopstream(chan);
281         fdprintf(fd, "200 result=%d\n", res);
282         if (res >= 0)
283                 return RESULT_SUCCESS;
284         else
285                 return RESULT_FAILURE;
286 }
287
288 static int handle_saynumber(struct ast_channel *chan, int fd, int argc, char *argv[])
289 {
290         int res;
291         int num;
292         if (argc != 4)
293                 return RESULT_SHOWUSAGE;
294         if (sscanf(argv[2], "%i", &num) != 1)
295                 return RESULT_SHOWUSAGE;
296         res = ast_say_number(chan, num, AST_DIGIT_ANY, chan->language);
297         fdprintf(fd, "200 result=%d\n", res);
298         if (res >= 0)
299                 return RESULT_SUCCESS;
300         else
301                 return RESULT_FAILURE;
302 }
303
304 static int handle_saydigits(struct ast_channel *chan, int fd, int argc, char *argv[])
305 {
306         int res;
307         int num;
308         if (argc != 4)
309                 return RESULT_SHOWUSAGE;
310         if (sscanf(argv[2], "%i", &num) != 1)
311                 return RESULT_SHOWUSAGE;
312         res = ast_say_digit_str(chan, argv[2], AST_DIGIT_ANY, chan->language);
313         fdprintf(fd, "200 result=%d\n", res);
314         if (res >= 0)
315                 return RESULT_SUCCESS;
316         else
317                 return RESULT_FAILURE;
318 }
319
320 int ast_app_getdata(struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout);
321
322 static int handle_getdata(struct ast_channel *chan, int fd, int argc, char *argv[])
323 {
324         int res;
325         char data[50];
326         int max;
327         int timeout;
328
329         if (argc < 3)
330                 return RESULT_SHOWUSAGE;
331         if (argc >= 4) timeout = atoi(argv[3]); else timeout = 0;
332         if (argc >= 5) max = atoi(argv[4]); else max = 50;
333         res = ast_app_getdata(chan, argv[2], data, max, timeout);
334         if (res == 1)
335                 fdprintf(fd, "200 result=%s (timeout)\n", data);
336         else
337                 fdprintf(fd, "200 result=%s\n", data);
338         if (res >= 0)
339                 return RESULT_SUCCESS;
340         else
341                 return RESULT_FAILURE;
342 }
343
344 static int handle_setcontext(struct ast_channel *chan, int fd, int argc, char *argv[])
345 {
346
347         if (argc != 3)
348                 return RESULT_SHOWUSAGE;
349         strncpy(chan->context, argv[2], sizeof(chan->context)-1);
350         fdprintf(fd, "200 result=0\n");
351         return RESULT_SUCCESS;
352 }
353         
354 static int handle_setextension(struct ast_channel *chan, int fd, int argc, char **argv)
355 {
356         if (argc != 3)
357                 return RESULT_SHOWUSAGE;
358         strncpy(chan->exten, argv[2], sizeof(chan->exten)-1);
359         fdprintf(fd, "200 result=0\n");
360         return RESULT_SUCCESS;
361 }
362
363 static int handle_setpriority(struct ast_channel *chan, int fd, int argc, char **argv)
364 {
365         int pri;
366         if (argc != 3)
367                 return RESULT_SHOWUSAGE;        
368         if (sscanf(argv[2], "%i", &pri) != 1)
369                 return RESULT_SHOWUSAGE;
370         chan->priority = pri - 1;
371         fdprintf(fd, "200 result=0\n");
372         return RESULT_SUCCESS;
373 }
374                 
375 static int ms_diff(struct timeval *tv1, struct timeval *tv2)
376 {
377 int     ms;
378         
379         ms = (tv1->tv_sec - tv2->tv_sec) * 1000;
380         ms += (tv1->tv_usec - tv2->tv_usec) / 1000;
381         return(ms);
382 }
383
384 static int handle_recordfile(struct ast_channel *chan, int fd, int argc, char *argv[])
385 {
386         struct ast_filestream *fs;
387         struct ast_frame *f,wf;
388         struct timeval tv, start, lastout, now, notime = { 0,0 } ;
389         fd_set readfds;
390         unsigned char tone_block[TONE_BLOCK_SIZE];
391         int res = -1;
392         int ms,i,j;
393
394         if (argc < 6)
395                 return RESULT_SHOWUSAGE;
396         if (sscanf(argv[5], "%i", &ms) != 1)
397                 return RESULT_SHOWUSAGE;
398
399         if (argc > 6) { /* if to beep */
400                 i = 0;
401                 lastout.tv_sec = lastout.tv_usec = 0;
402                 for(j = 0; j < 13; j++)
403                    {
404                         do gettimeofday(&now,NULL);
405                         while (lastout.tv_sec && 
406                                 (ms_diff(&now,&lastout) < 25));
407                         lastout.tv_sec = now.tv_sec;
408                         lastout.tv_usec = now.tv_usec;
409                         wf.frametype = AST_FRAME_VOICE;
410                         wf.subclass = AST_FORMAT_ULAW;
411                         wf.offset = AST_FRIENDLY_OFFSET;
412                         wf.mallocd = 0;
413                         wf.data = tone_block;
414                         wf.datalen = TONE_BLOCK_SIZE;                           
415                         /* make this tone block */
416                         make_tone_block(tone_block,1000.0,&i);
417                         wf.timelen = wf.datalen / 8;
418                         if (ast_write(chan, &wf)) {
419                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
420                                 return RESULT_FAILURE;
421                         }
422                         FD_ZERO(&readfds);
423                         FD_SET(chan->fds[0],&readfds);
424                           /* if no read avail, do send again */
425                         if (select(chan->fds[0] + 1,&readfds,NULL,
426                                 NULL,&notime) < 1) continue;
427                         f = ast_read(chan);
428                         if (!f) {
429                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
430                                 return RESULT_FAILURE;
431                         }
432                         switch(f->frametype) {
433                         case AST_FRAME_DTMF:
434                                 if (strchr(argv[4], f->subclass)) {
435                                         /* This is an interrupting chracter */
436                                         fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
437                                         ast_frfree(f);
438                                         return RESULT_SUCCESS;
439                                 }
440                                 break;
441                         case AST_FRAME_VOICE:
442                                 break;  /* throw it away */
443                         }
444                         ast_frfree(f);
445                    }
446                   /* suck in 5 voice frames to make up for echo of beep, etc */
447                 for(i = 0; i < 5; i++) {
448                         f = ast_read(chan);
449                         if (!f) {
450                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
451                                 return RESULT_FAILURE;
452                         }
453                         switch(f->frametype) {
454                         case AST_FRAME_DTMF:
455                                 if (strchr(argv[4], f->subclass)) {
456                                         /* This is an interrupting chracter */
457                                         fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
458                                         ast_frfree(f);
459                                         return RESULT_SUCCESS;
460                                 }
461                                 break;
462                         case AST_FRAME_VOICE:
463                                 break;  /* throw it away */
464                         }
465                         ast_frfree(f);
466                 }
467
468         }
469
470         fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_TRUNC | O_WRONLY, 0, 0644);
471         if (!fs) {
472                 fdprintf(fd, "200 result=%d (writefile)\n", res);
473                 return RESULT_FAILURE;
474         }
475         gettimeofday(&start, NULL);
476         gettimeofday(&tv, NULL);
477         while ((ms < 0) || (((tv.tv_sec - start.tv_sec) * 1000 + (tv.tv_usec - start.tv_usec)/1000) < ms)) {
478                 res = ast_waitfor(chan, -1);
479                 if (res < 0) {
480                         ast_closestream(fs);
481                         fdprintf(fd, "200 result=%d (waitfor)\n", res);
482                         return RESULT_FAILURE;
483                 }
484                 f = ast_read(chan);
485                 if (!f) {
486                         fdprintf(fd, "200 result=%d (hangup)\n", 0);
487                         ast_closestream(fs);
488                         return RESULT_FAILURE;
489                 }
490                 switch(f->frametype) {
491                 case AST_FRAME_DTMF:
492                         if (strchr(argv[4], f->subclass)) {
493                                 /* This is an interrupting chracter */
494                                 fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
495                                 ast_closestream(fs);
496                                 ast_frfree(f);
497                                 return RESULT_SUCCESS;
498                         }
499                         break;
500                 case AST_FRAME_VOICE:
501                         ast_writestream(fs, f);
502                         break;
503                 };
504                 ast_frfree(f);
505                 gettimeofday(&tv, NULL);
506         }
507         fdprintf(fd, "200 result=%d (timeout)\n", 0);
508         ast_closestream(fs);
509         return RESULT_SUCCESS;
510 }
511
512 static char usage_answer[] = 
513 " Usage: ANSWER\n"
514 "        Answers channel if not already in answer state. Returns -1 on\n"
515 " channel failure, or 0 if successful.\n";
516
517 static char usage_waitfordigit[] = 
518 " Usage: WAIT FOR DIGIT <timeout>\n"
519 "        Waits up to 'timeout' seconds for channel to receive a DTMF digit.\n"
520 " Returns -1 on channel failure, 0 if no digit is received in the timeout, or\n"
521 " the numerical value of the ascii of the digit if one is received.  Use -1\n"
522 " for the timeout value if you desire the call to block indefinitely.\n";
523
524 static char usage_sendtext[] =
525 " Usage: SEND TEXT \"<text to send>\"\n"
526 "        Sends the given text on a channel.  Most channels do not support the\n"
527 " transmission of text.  Returns 0 if text is sent, or if the channel does not\n"
528 " support text transmission.  Returns -1 only on error/hangup.  Text\n"
529 " consisting of greater than one word should be placed in quotes since the\n"
530 " command only accepts a single argument.\n";
531
532 static char usage_recvchar[] =
533 " Usage: RECEIVE CHAR <timeout>\n"
534 "        Receives a character of text on a channel.  Specify timeout to be the\n"
535 " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n"
536 " do not support the reception of text.  Returns the decimal value of the character\n"
537 " if one is received, or 0 if the channel does not support text reception.  Returns\n"
538 " -1 only on error/hangup.\n";
539
540 static char usage_tddmode[] =
541 " Usage: TDD MODE <on|off>\n"
542 "        Enable/Disable TDD transmission/reception on a channel. Returns 1 if\n"
543 " successful, or 0 if channel is not TDD-capable.\n";
544
545 static char usage_sendimage[] =
546 " Usage: SEND IMAGE <image>\n"
547 "        Sends the given image on a channel.  Most channels do not support the\n"
548 " transmission of images.  Returns 0 if image is sent, or if the channel does not\n"
549 " support image transmission.  Returns -1 only on error/hangup.  Image names\n"
550 " should not include extensions.\n";
551
552 static char usage_streamfile[] =
553 " Usage: STREAM FILE <filename> <escape digits>\n"
554 "        Send the given file, allowing playback to be interrupted by the given\n"
555 " digits, if any.  Use double quotes for the digits if you wish none to be\n"
556 " permitted.  Returns 0 if playback completes without a digit being pressed, or\n"
557 " the ASCII numerical value of the digit if one was pressed, or -1 on error or\n"
558 " if the channel was disconnected.  Remember, the file extension must not be\n"
559 " included in the filename.\n";
560
561 static char usage_saynumber[] =
562 " Usage: SAY NUMBER <number> <escape digits>\n"
563 "        Say a given number, returning early if any of the given DTMF digits\n"
564 " are received on the channel.  Returns 0 if playback completes without a digit\n"
565 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
566 " -1 on error/hangup.\n";
567
568 static char usage_saydigits[] =
569 " Usage: SAY DIGITS <number> <escape digits>\n"
570 "        Say a given digit string, returning early if any of the given DTMF digits\n"
571 " are received on the channel.  Returns 0 if playback completes without a digit\n"
572 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
573 " -1 on error/hangup.\n";
574
575 static char usage_getdata[] =
576 " Usage: GET DATA <file to be streamed> [timeout] [max digits]\n"
577 "        Stream the given file, and recieve DTMF data. Returns the digits recieved\n"
578 "from the channel at the other end.\n";
579
580 static char usage_setcontext[] =
581 " Usage: SET CONTEXT <desired context>\n"
582 "        Sets the context for continuation upon exiting the application.\n";
583
584 static char usage_setextension[] =
585 " Usage: SET EXTENSION <new extension>\n"
586 "        Changes the extension for continuation upon exiting the application.\n";
587
588 static char usage_setpriority[] =
589 " Usage: SET PRIORITY <num>\n"
590 "        Changes the priority for continuation upon exiting the application.\n";
591
592 static char usage_recordfile[] =
593 " Usage: RECORD FILE <filename> <format> <escape digits> <timeout> [BEEP]\n"
594 "        Record to a file until a given dtmf digit in the sequence is received\n"
595 " Returns -1 on hangup or error.  The format will specify what kind of file\n"
596 " will be recorded.  The timeout is the maximum record time in milliseconds, or\n"
597 " -1 for no timeout\n";
598
599 agi_command commands[] = {
600         { { "answer", NULL }, handle_answer, "Asserts answer", usage_answer },
601         { { "answer\n", NULL }, handle_answer, "Asserts answer", usage_answer },
602         { { "wait", "for", "digit", NULL }, handle_waitfordigit, "Waits for a digit to be pressed", usage_waitfordigit },
603         { { "send", "text", NULL }, handle_sendtext, "Sends text to channels supporting it", usage_sendtext },
604         { { "receive", "char", NULL }, handle_recvchar, "Receives text from channels supporting it", usage_recvchar },
605         { { "tdd", "mode", NULL }, handle_tddmode, "Sends text to channels supporting it", usage_tddmode },
606         { { "stream", "file", NULL }, handle_streamfile, "Sends audio file on channel", usage_streamfile },
607         { { "send", "image", NULL }, handle_sendimage, "Sends images to channels supporting it", usage_sendimage },
608         { { "say", "digits", NULL }, handle_saydigits, "Says a given digit string", usage_saydigits },
609         { { "say", "number", NULL }, handle_saynumber, "Says a given number", usage_saynumber },
610         { { "get", "data", NULL }, handle_getdata, "Gets data on a channel", usage_getdata },
611         { { "set", "context", NULL }, handle_setcontext, "Sets channel context", usage_setcontext },
612         { { "set", "extension", NULL }, handle_setextension, "Changes channel extension", usage_setextension },
613         { { "set", "priority", NULL }, handle_setpriority, "Prioritizes the channel", usage_setpriority },
614         { { "record", "file", NULL }, handle_recordfile, "Records to a given file", usage_recordfile }
615 };
616
617 static agi_command *find_command(char *cmds[])
618 {
619         int x;
620         int y;
621         int match;
622         for (x=0;x < sizeof(commands) / sizeof(commands[0]);x++) {
623                 /* start optimistic */
624                 match = 1;
625                 for (y=0;match && cmds[y]; y++) {
626                         /* If there are no more words in the command (and we're looking for
627                            an exact match) or there is a difference between the two words,
628                            then this is not a match */
629                         if (!commands[x].cmda[y])
630                                 break;
631                         if (strcasecmp(commands[x].cmda[y], cmds[y]))
632                                 match = 0;
633                 }
634                 /* If more words are needed to complete the command then this is not
635                    a candidate (unless we're looking for a really inexact answer  */
636                 if (commands[x].cmda[y])
637                         match = 0;
638                 if (match)
639                         return &commands[x];
640         }
641         return NULL;
642 }
643
644
645 static int parse_args(char *s, int *max, char *argv[])
646 {
647         int x=0;
648         int quoted=0;
649         int escaped=0;
650         int whitespace=1;
651         char *cur;
652
653         cur = s;
654         while(*s) {
655                 switch(*s) {
656                 case '"':
657                         /* If it's escaped, put a literal quote */
658                         if (escaped) 
659                                 goto normal;
660                         else 
661                                 quoted = !quoted;
662                         if (quoted && whitespace) {
663                                 /* If we're starting a quote, coming off white space start a new word, too */
664                                 argv[x++] = cur;
665                                 whitespace=0;
666                         }
667                         escaped = 0;
668                 break;
669                 case ' ':
670                 case '\t':
671                         if (!quoted && !escaped) {
672                                 /* If we're not quoted, mark this as whitespace, and
673                                    end the previous argument */
674                                 whitespace = 1;
675                                 *(cur++) = '\0';
676                         } else
677                                 /* Otherwise, just treat it as anything else */ 
678                                 goto normal;
679                         break;
680                 case '\\':
681                         /* If we're escaped, print a literal, otherwise enable escaping */
682                         if (escaped) {
683                                 goto normal;
684                         } else {
685                                 escaped=1;
686                         }
687                         break;
688                 default:
689 normal:
690                         if (whitespace) {
691                                 if (x >= MAX_ARGS -1) {
692                                         ast_log(LOG_WARNING, "Too many arguments, truncating\n");
693                                         break;
694                                 }
695                                 /* Coming off of whitespace, start the next argument */
696                                 argv[x++] = cur;
697                                 whitespace=0;
698                         }
699                         *(cur++) = *s;
700                         escaped=0;
701                 }
702                 s++;
703         }
704         /* Null terminate */
705         *(cur++) = '\0';
706         argv[x] = NULL;
707         *max = x;
708         return 0;
709 }
710
711 static int agi_handle_command(struct ast_channel *chan, int fd, char *buf)
712 {
713         char *argv[MAX_ARGS];
714         int argc = 0;
715         int res;
716         agi_command *c;
717         argc = MAX_ARGS;
718         parse_args(buf, &argc, argv);
719 #if     0
720         { int x;
721         for (x=0;x<argc;x++) 
722                 fprintf(stderr, "Got Arg%d: %s\n", x, argv[x]); }
723 #endif
724         c = find_command(argv);
725         if (c) {
726                 res = c->handler(chan, fd, argc, argv);
727                 switch(res) {
728                 case RESULT_SHOWUSAGE:
729                         fdprintf(fd, "520-Invalid command syntax.  Proper usage follows:\n");
730                         fdprintf(fd, c->usage);
731                         fdprintf(fd, "520 End of proper usage.\n");
732                         break;
733                 case RESULT_FAILURE:
734                         /* They've already given the failure.  We've been hung up on so handle this
735                            appropriately */
736                         return -1;
737                 }
738         } else {
739                 fdprintf(fd, "510 Invalid or unknown command\n");
740         }
741         return 0;
742 }
743
744 static int run_agi(struct ast_channel *chan, char *request, int *fds, int pid)
745 {
746         struct ast_channel *c;
747         int outfd;
748         int ms;
749         int returnstatus = 0;
750         struct ast_frame *f;
751         char buf[2048];
752         FILE *readf;
753         if (!(readf = fdopen(fds[0], "r"))) {
754                 ast_log(LOG_WARNING, "Unable to fdopen file descriptor\n");
755                 kill(pid, SIGHUP);
756                 return -1;
757         }
758         setlinebuf(readf);
759         setup_env(chan, request, fds[1]);
760         for (;;) {
761                 ms = -1;
762                 c = ast_waitfor_nandfds(&chan, 1, &fds[0], 1, NULL, &outfd, &ms);
763                 if (c) {
764                         /* Idle the channel until we get a command */
765                         f = ast_read(c);
766                         if (!f) {
767                                 ast_log(LOG_DEBUG, "%s hungup\n", chan->name);
768                                 returnstatus = -1;
769                                 break;
770                         } else {
771                                 ast_frfree(f);
772                         }
773                 } else if (outfd > -1) {
774                         if (!fgets(buf, sizeof(buf), readf)) {
775                                 /* Program terminated */
776                                 if (returnstatus)
777                                         returnstatus = -1;
778                                 if (option_verbose > 2) 
779                                         ast_verbose(VERBOSE_PREFIX_3 "AGI Script %s completed, returning %d\n", request, returnstatus);
780                                 /* No need to kill the pid anymore, since they closed us */
781                                 pid = -1;
782                                 break;
783                         }
784                           /* get rid of trailing newline, if any */
785                         if (*buf && buf[strlen(buf) - 1] == '\n')
786                                 buf[strlen(buf) - 1] = 0;
787
788                         returnstatus |= agi_handle_command(chan, fds[1], buf);
789                         /* If the handle_command returns -1, we need to stop */
790                         if (returnstatus < 0) {
791                                 break;
792                         }
793                 } else {
794                         ast_log(LOG_WARNING, "No channel, no fd?\n");
795                         returnstatus = -1;
796                         break;
797                 }
798         }
799         /* Notify process */
800         if (pid > -1)
801                 kill(pid, SIGHUP);
802         fclose(readf);
803         return returnstatus;
804 }
805
806 static int agi_exec(struct ast_channel *chan, void *data)
807 {
808         int res=0;
809         struct localuser *u;
810         char *args,*ringy;
811         char tmp[256];
812         int fds[2];
813         int pid;
814         if (!data || !strlen(data)) {
815                 ast_log(LOG_WARNING, "AGI requires an argument (script)\n");
816                 return -1;
817         }
818
819
820         strncpy(tmp, data, sizeof(tmp)-1);
821         strtok(tmp, "|");
822         args = strtok(NULL, "|");
823         ringy = strtok(NULL,"|");
824         if (!args)
825                 args = "";
826         LOCAL_USER_ADD(u);
827 #if 0
828          /* Answer if need be */
829         if (chan->state != AST_STATE_UP) {
830                 if (ringy) { /* if for ringing first */
831                         /* a little ringy-dingy first */
832                         ast_indicate(chan, AST_CONTROL_RINGING);  
833                         sleep(3); 
834                 }
835                 if (ast_answer(chan)) {
836                         LOCAL_USER_REMOVE(u);
837                         return -1;
838                 }
839         }
840 #endif
841         res = launch_script(tmp, args, fds, &pid);
842         if (!res) {
843                 res = run_agi(chan, tmp, fds, pid);
844                 close(fds[0]);
845                 close(fds[1]);
846         }
847         LOCAL_USER_REMOVE(u);
848         return res;
849 }
850
851 int unload_module(void)
852 {
853         STANDARD_HANGUP_LOCALUSERS;
854         return ast_unregister_application(app);
855 }
856
857 int load_module(void)
858 {
859         return ast_register_application(app, agi_exec, synopsis, descrip);
860 }
861
862 char *description(void)
863 {
864         return tdesc;
865 }
866
867 int usecount(void)
868 {
869         int res;
870         STANDARD_USECOUNT(res);
871         return res;
872 }
873
874 char *key()
875 {
876         return ASTERISK_GPL_KEY;
877 }
878
879 #define CLIP 32635
880 #define BIAS 0x84
881
882 unsigned char
883 linear2ulaw(sample)
884 short sample; {
885   static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
886                              4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
887                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
888                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
889                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
890                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
891                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
892                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
893                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
894                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
895                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
896                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
897                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
898                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
899                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
900                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
901   int sign, exponent, mantissa;
902   unsigned char ulawbyte;
903  
904   /* Get the sample into sign-magnitude. */
905   sign = (sample >> 8) & 0x80;          /* set aside the sign */
906   if (sign != 0) sample = -sample;              /* get magnitude */
907   if (sample > CLIP) sample = CLIP;             /* clip the magnitude */
908  
909   /* Convert from 16 bit linear to ulaw. */
910   sample = sample + BIAS;
911   exponent = exp_lut[(sample >> 7) & 0xFF];
912   mantissa = (sample >> (exponent + 3)) & 0x0F;
913   ulawbyte = ~(sign | (exponent << 4) | mantissa);
914 #ifdef ZEROTRAP
915   if (ulawbyte == 0) ulawbyte = 0x02;   /* optional CCITT trap */
916 #endif
917  
918   return(ulawbyte);
919 }