Version 0.2.0 from FTP
[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, argv[3], 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], argv[3], 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;
388         struct timeval tv, start;
389         int res = 0;
390         int ms;
391
392         if (argc < 6)
393                 return RESULT_SHOWUSAGE;
394         if (sscanf(argv[5], "%i", &ms) != 1)
395                 return RESULT_SHOWUSAGE;
396
397         if (argc > 6)
398                 res = ast_streamfile(chan, "beep", chan->language);
399         if (!res)
400                 res = ast_waitstream(chan, argv[4]);
401         if (!res) {
402                 fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_TRUNC | O_WRONLY, 0, 0644);
403                 if (!fs) {
404                         res = -1;
405                         fdprintf(fd, "200 result=%d (writefile)\n", res);
406                         return RESULT_FAILURE;
407                 }
408                 gettimeofday(&start, NULL);
409                 gettimeofday(&tv, NULL);
410                 while ((ms < 0) || (((tv.tv_sec - start.tv_sec) * 1000 + (tv.tv_usec - start.tv_usec)/1000) < ms)) {
411                         res = ast_waitfor(chan, -1);
412                         if (res < 0) {
413                                 ast_closestream(fs);
414                                 fdprintf(fd, "200 result=%d (waitfor)\n", res);
415                                 return RESULT_FAILURE;
416                         }
417                         f = ast_read(chan);
418                         if (!f) {
419                                 fdprintf(fd, "200 result=%d (hangup)\n", 0);
420                                 ast_closestream(fs);
421                                 return RESULT_FAILURE;
422                         }
423                         switch(f->frametype) {
424                         case AST_FRAME_DTMF:
425                                 if (strchr(argv[4], f->subclass)) {
426                                         /* This is an interrupting chracter */
427                                         fdprintf(fd, "200 result=%d (dtmf)\n", f->subclass);
428                                         ast_closestream(fs);
429                                         ast_frfree(f);
430                                         return RESULT_SUCCESS;
431                                 }
432                                 break;
433                         case AST_FRAME_VOICE:
434                                 ast_writestream(fs, f);
435                                 break;
436                         }
437                         ast_frfree(f);
438                 }
439                 gettimeofday(&tv, NULL);
440                 fdprintf(fd, "200 result=%d (timeout)\n", res);
441                 ast_closestream(fs);
442         } else
443                 fdprintf(fd, "200 result=%d (randomerror)\n", res);
444         return RESULT_SUCCESS;
445 }
446
447 static int handle_autohangup(struct ast_channel *chan, int fd, int argc, char *argv[])
448 {
449         int timeout;
450
451         if (argc != 3)
452                 return RESULT_SHOWUSAGE;
453         if (sscanf(argv[2], "%d", &timeout) != 1)
454                 return RESULT_SHOWUSAGE;
455         if (timeout < 0)
456                 timeout = 0;
457         if (timeout)
458                 chan->whentohangup = time(NULL) + timeout;
459         else
460                 chan->whentohangup = 0;
461         fdprintf(fd, "200 result=0\n");
462         return RESULT_SUCCESS;
463 }
464
465 static int handle_hangup(struct ast_channel *chan, int fd, int argc, char **argv)
466 {
467         ast_softhangup(chan,AST_SOFTHANGUP_EXPLICIT);
468         fdprintf(fd, "200 result=1\n");
469         return RESULT_SUCCESS;
470 }
471
472 static int handle_exec(struct ast_channel *chan, int fd, int argc, char **argv)
473 {
474         int res;
475         struct ast_app *app;
476
477         if (argc < 2)
478                 return RESULT_SHOWUSAGE;
479
480         if (option_verbose > 2)
481                 ast_verbose(VERBOSE_PREFIX_3 "AGI Script Executing Application: (%s) Options: (%s)\n", argv[1], argv[2]);
482
483         app = pbx_findapp(argv[1]);
484
485         if (app) {
486                 res = pbx_exec(chan, app, argv[2], 1);
487         } else {
488                 ast_log(LOG_WARNING, "Could not find application (%s)\n", argv[1]);
489                 res = -2;
490         }
491         fdprintf(fd, "200 result=%d\n", res);
492
493         return res;
494 }
495
496 static int handle_setcallerid(struct ast_channel *chan, int fd, int argc, char **argv)
497 {
498         if (argv[2])
499                 ast_set_callerid(chan, argv[2]);
500
501 /*      strncpy(chan->callerid, argv[2], sizeof(chan->callerid)-1);
502 */      fdprintf(fd, "200 result=1\n");
503         return RESULT_SUCCESS;
504 }
505
506 static int handle_channelstatus(struct ast_channel *chan, int fd, int argc, char **argv)
507 {
508         fdprintf(fd, "200 result=%d\n", chan->_state);
509         return RESULT_SUCCESS;
510 }
511
512 static char usage_channelstatus[] =
513 " Usage: CHANNEL STATUS\n"
514 "       Returns the status of the connected channel. Return values:\n"
515 " 0 Channel is down and available\n"
516 " 1 Channel is down, but reserved\n"
517 " 2 Channel is off hook\n"
518 " 3 Digits (or equivalent) have been dialed\n"
519 " 4 Line is ringing\n"
520 " 5 Remote end is ringing\n"
521 " 6 Line is up\n"
522 " 7 Line is busy\n";
523
524 static char usage_setcallerid[] =
525 " Usage: SET CALLERID <number>\n"
526 "       Changes the callerid of the current channel.\n";
527
528 static char usage_exec[] =
529 " Usage: EXEC <application> <options>\n"
530 "       Executes <application> with given <options>.\n"
531 "       Returns whatever the application returns, or -2 on failure to find application\n";
532
533 static char usage_hangup[] =
534 " Usage: HANGUP\n"
535 "       Hangs up the current channel.\n";
536
537
538 static char usage_answer[] = 
539 " Usage: ANSWER\n"
540 "        Answers channel if not already in answer state. Returns -1 on\n"
541 " channel failure, or 0 if successful.\n";
542
543 static char usage_waitfordigit[] = 
544 " Usage: WAIT FOR DIGIT <timeout>\n"
545 "        Waits up to 'timeout' milliseconds for channel to receive a DTMF digit.\n"
546 " Returns -1 on channel failure, 0 if no digit is received in the timeout, or\n"
547 " the numerical value of the ascii of the digit if one is received.  Use -1\n"
548 " for the timeout value if you desire the call to block indefinitely.\n";
549
550 static char usage_sendtext[] =
551 " Usage: SEND TEXT \"<text to send>\"\n"
552 "        Sends the given text on a channel.  Most channels do not support the\n"
553 " transmission of text.  Returns 0 if text is sent, or if the channel does not\n"
554 " support text transmission.  Returns -1 only on error/hangup.  Text\n"
555 " consisting of greater than one word should be placed in quotes since the\n"
556 " command only accepts a single argument.\n";
557
558 static char usage_recvchar[] =
559 " Usage: RECEIVE CHAR <timeout>\n"
560 "        Receives a character of text on a channel.  Specify timeout to be the\n"
561 " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n"
562 " do not support the reception of text.  Returns the decimal value of the character\n"
563 " if one is received, or 0 if the channel does not support text reception.  Returns\n"
564 " -1 only on error/hangup.\n";
565
566 static char usage_tddmode[] =
567 " Usage: TDD MODE <on|off>\n"
568 "        Enable/Disable TDD transmission/reception on a channel. Returns 1 if\n"
569 " successful, or 0 if channel is not TDD-capable.\n";
570
571 static char usage_sendimage[] =
572 " Usage: SEND IMAGE <image>\n"
573 "        Sends the given image on a channel.  Most channels do not support the\n"
574 " transmission of images.  Returns 0 if image is sent, or if the channel does not\n"
575 " support image transmission.  Returns -1 only on error/hangup.  Image names\n"
576 " should not include extensions.\n";
577
578 static char usage_streamfile[] =
579 " Usage: STREAM FILE <filename> <escape digits>\n"
580 "        Send the given file, allowing playback to be interrupted by the given\n"
581 " digits, if any.  Use double quotes for the digits if you wish none to be\n"
582 " permitted.  Returns 0 if playback completes without a digit being pressed, or\n"
583 " the ASCII numerical value of the digit if one was pressed, or -1 on error or\n"
584 " if the channel was disconnected.  Remember, the file extension must not be\n"
585 " included in the filename.\n";
586
587 static char usage_saynumber[] =
588 " Usage: SAY NUMBER <number> <escape digits>\n"
589 "        Say a given number, returning early if any of the given DTMF digits\n"
590 " are received on the channel.  Returns 0 if playback completes without a digit\n"
591 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
592 " -1 on error/hangup.\n";
593
594 static char usage_saydigits[] =
595 " Usage: SAY DIGITS <number> <escape digits>\n"
596 "        Say a given digit string, returning early if any of the given DTMF digits\n"
597 " are received on the channel.  Returns 0 if playback completes without a digit\n"
598 " being pressed, or the ASCII numerical value of the digit if one was pressed or\n"
599 " -1 on error/hangup.\n";
600
601 static char usage_getdata[] =
602 " Usage: GET DATA <file to be streamed> [timeout] [max digits]\n"
603 "        Stream the given file, and recieve DTMF data. Returns the digits recieved\n"
604 "from the channel at the other end.\n";
605
606 static char usage_setcontext[] =
607 " Usage: SET CONTEXT <desired context>\n"
608 "        Sets the context for continuation upon exiting the application.\n";
609
610 static char usage_setextension[] =
611 " Usage: SET EXTENSION <new extension>\n"
612 "        Changes the extension for continuation upon exiting the application.\n";
613
614 static char usage_setpriority[] =
615 " Usage: SET PRIORITY <num>\n"
616 "        Changes the priority for continuation upon exiting the application.\n";
617
618 static char usage_recordfile[] =
619 " Usage: RECORD FILE <filename> <format> <escape digits> <timeout> [BEEP]\n"
620 "        Record to a file until a given dtmf digit in the sequence is received\n"
621 " Returns -1 on hangup or error.  The format will specify what kind of file\n"
622 " will be recorded.  The timeout is the maximum record time in milliseconds, or\n"
623 " -1 for no timeout\n";
624
625 static char usage_autohangup[] =
626 " Usage: SET AUTOHANGUP <time>\n"
627 "    Cause the channel to automatically hangup at <time> seconds in the\n"
628 "future.  Of course it can be hungup before then as well.   Setting to\n"
629 "0 will cause the autohangup feature to be disabled on this channel.\n";
630
631 agi_command commands[] = {
632         { { "answer", NULL }, handle_answer, "Asserts answer", usage_answer },
633         { { "answer\n", NULL }, handle_answer, "Asserts answer", usage_answer },
634         { { "wait", "for", "digit", NULL }, handle_waitfordigit, "Waits for a digit to be pressed", usage_waitfordigit },
635         { { "send", "text", NULL }, handle_sendtext, "Sends text to channels supporting it", usage_sendtext },
636         { { "receive", "char", NULL }, handle_recvchar, "Receives text from channels supporting it", usage_recvchar },
637         { { "tdd", "mode", NULL }, handle_tddmode, "Sends text to channels supporting it", usage_tddmode },
638         { { "stream", "file", NULL }, handle_streamfile, "Sends audio file on channel", usage_streamfile },
639         { { "send", "image", NULL }, handle_sendimage, "Sends images to channels supporting it", usage_sendimage },
640         { { "say", "digits", NULL }, handle_saydigits, "Says a given digit string", usage_saydigits },
641         { { "say", "number", NULL }, handle_saynumber, "Says a given number", usage_saynumber },
642         { { "get", "data", NULL }, handle_getdata, "Gets data on a channel", usage_getdata },
643         { { "set", "context", NULL }, handle_setcontext, "Sets channel context", usage_setcontext },
644         { { "set", "extension", NULL }, handle_setextension, "Changes channel extension", usage_setextension },
645         { { "set", "priority", NULL }, handle_setpriority, "Prioritizes the channel", usage_setpriority },
646         { { "record", "file", NULL }, handle_recordfile, "Records to a given file", usage_recordfile },
647         { { "set", "autohangup", NULL }, handle_autohangup, "Autohangup channel in some time", usage_autohangup },
648         { { "hangup", NULL }, handle_hangup, "Hangup the current channel", usage_hangup },
649         { { "exec", NULL }, handle_exec, "Executes a given Application", usage_exec },
650         { { "set", "callerid", NULL }, handle_setcallerid, "Sets callerid for the current channel", usage_setcallerid },
651         { { "channel", "status", NULL }, handle_channelstatus, "Returns status of the connected channel", usage_channelstatus }
652 };
653
654 static agi_command *find_command(char *cmds[])
655 {
656         int x;
657         int y;
658         int match;
659         for (x=0;x < sizeof(commands) / sizeof(commands[0]);x++) {
660                 /* start optimistic */
661                 match = 1;
662                 for (y=0;match && cmds[y]; y++) {
663                         /* If there are no more words in the command (and we're looking for
664                            an exact match) or there is a difference between the two words,
665                            then this is not a match */
666                         if (!commands[x].cmda[y])
667                                 break;
668                         if (strcasecmp(commands[x].cmda[y], cmds[y]))
669                                 match = 0;
670                 }
671                 /* If more words are needed to complete the command then this is not
672                    a candidate (unless we're looking for a really inexact answer  */
673                 if (commands[x].cmda[y])
674                         match = 0;
675                 if (match)
676                         return &commands[x];
677         }
678         return NULL;
679 }
680
681
682 static int parse_args(char *s, int *max, char *argv[])
683 {
684         int x=0;
685         int quoted=0;
686         int escaped=0;
687         int whitespace=1;
688         char *cur;
689
690         cur = s;
691         while(*s) {
692                 switch(*s) {
693                 case '"':
694                         /* If it's escaped, put a literal quote */
695                         if (escaped) 
696                                 goto normal;
697                         else 
698                                 quoted = !quoted;
699                         if (quoted && whitespace) {
700                                 /* If we're starting a quote, coming off white space start a new word, too */
701                                 argv[x++] = cur;
702                                 whitespace=0;
703                         }
704                         escaped = 0;
705                 break;
706                 case ' ':
707                 case '\t':
708                         if (!quoted && !escaped) {
709                                 /* If we're not quoted, mark this as whitespace, and
710                                    end the previous argument */
711                                 whitespace = 1;
712                                 *(cur++) = '\0';
713                         } else
714                                 /* Otherwise, just treat it as anything else */ 
715                                 goto normal;
716                         break;
717                 case '\\':
718                         /* If we're escaped, print a literal, otherwise enable escaping */
719                         if (escaped) {
720                                 goto normal;
721                         } else {
722                                 escaped=1;
723                         }
724                         break;
725                 default:
726 normal:
727                         if (whitespace) {
728                                 if (x >= MAX_ARGS -1) {
729                                         ast_log(LOG_WARNING, "Too many arguments, truncating\n");
730                                         break;
731                                 }
732                                 /* Coming off of whitespace, start the next argument */
733                                 argv[x++] = cur;
734                                 whitespace=0;
735                         }
736                         *(cur++) = *s;
737                         escaped=0;
738                 }
739                 s++;
740         }
741         /* Null terminate */
742         *(cur++) = '\0';
743         argv[x] = NULL;
744         *max = x;
745         return 0;
746 }
747
748 static int agi_handle_command(struct ast_channel *chan, int fd, char *buf)
749 {
750         char *argv[MAX_ARGS];
751         int argc = 0;
752         int res;
753         agi_command *c;
754         argc = MAX_ARGS;
755         parse_args(buf, &argc, argv);
756 #if     0
757         { int x;
758         for (x=0;x<argc;x++) 
759                 fprintf(stderr, "Got Arg%d: %s\n", x, argv[x]); }
760 #endif
761         c = find_command(argv);
762         if (c) {
763                 res = c->handler(chan, fd, argc, argv);
764                 switch(res) {
765                 case RESULT_SHOWUSAGE:
766                         fdprintf(fd, "520-Invalid command syntax.  Proper usage follows:\n");
767                         fdprintf(fd, c->usage);
768                         fdprintf(fd, "520 End of proper usage.\n");
769                         break;
770                 case RESULT_FAILURE:
771                         /* They've already given the failure.  We've been hung up on so handle this
772                            appropriately */
773                         return -1;
774                 }
775         } else {
776                 fdprintf(fd, "510 Invalid or unknown command\n");
777         }
778         return 0;
779 }
780
781 static int run_agi(struct ast_channel *chan, char *request, int *fds, int pid)
782 {
783         struct ast_channel *c;
784         int outfd;
785         int ms;
786         int returnstatus = 0;
787         struct ast_frame *f;
788         char buf[2048];
789         FILE *readf;
790         if (!(readf = fdopen(fds[0], "r"))) {
791                 ast_log(LOG_WARNING, "Unable to fdopen file descriptor\n");
792                 kill(pid, SIGHUP);
793                 return -1;
794         }
795         setlinebuf(readf);
796         setup_env(chan, request, fds[1]);
797         for (;;) {
798                 ms = -1;
799                 c = ast_waitfor_nandfds(&chan, 1, &fds[0], 1, NULL, &outfd, &ms);
800                 if (c) {
801                         /* Idle the channel until we get a command */
802                         f = ast_read(c);
803                         if (!f) {
804                                 ast_log(LOG_DEBUG, "%s hungup\n", chan->name);
805                                 returnstatus = -1;
806                                 break;
807                         } else {
808                                 ast_frfree(f);
809                         }
810                 } else if (outfd > -1) {
811                         if (!fgets(buf, sizeof(buf), readf)) {
812                                 /* Program terminated */
813                                 if (returnstatus)
814                                         returnstatus = -1;
815                                 if (option_verbose > 2) 
816                                         ast_verbose(VERBOSE_PREFIX_3 "AGI Script %s completed, returning %d\n", request, returnstatus);
817                                 /* No need to kill the pid anymore, since they closed us */
818                                 pid = -1;
819                                 break;
820                         }
821                           /* get rid of trailing newline, if any */
822                         if (*buf && buf[strlen(buf) - 1] == '\n')
823                                 buf[strlen(buf) - 1] = 0;
824
825                         returnstatus |= agi_handle_command(chan, fds[1], buf);
826                         /* If the handle_command returns -1, we need to stop */
827                         if (returnstatus < 0) {
828                                 break;
829                         }
830                 } else {
831                         ast_log(LOG_WARNING, "No channel, no fd?\n");
832                         returnstatus = -1;
833                         break;
834                 }
835         }
836         /* Notify process */
837         if (pid > -1)
838                 kill(pid, SIGHUP);
839         fclose(readf);
840         return returnstatus;
841 }
842
843 static int agi_exec(struct ast_channel *chan, void *data)
844 {
845         int res=0;
846         struct localuser *u;
847         char *args,*ringy;
848         char tmp[256];
849         int fds[2];
850         int pid;
851         if (!data || !strlen(data)) {
852                 ast_log(LOG_WARNING, "AGI requires an argument (script)\n");
853                 return -1;
854         }
855
856
857         strncpy(tmp, data, sizeof(tmp)-1);
858         strtok(tmp, "|");
859         args = strtok(NULL, "|");
860         ringy = strtok(NULL,"|");
861         if (!args)
862                 args = "";
863         LOCAL_USER_ADD(u);
864 #if 0
865          /* Answer if need be */
866         if (chan->_state != AST_STATE_UP) {
867                 if (ringy) { /* if for ringing first */
868                         /* a little ringy-dingy first */
869                         ast_indicate(chan, AST_CONTROL_RINGING);  
870                         sleep(3); 
871                 }
872                 if (ast_answer(chan)) {
873                         LOCAL_USER_REMOVE(u);
874                         return -1;
875                 }
876         }
877 #endif
878         res = launch_script(tmp, args, fds, &pid);
879         if (!res) {
880                 res = run_agi(chan, tmp, fds, pid);
881                 close(fds[0]);
882                 close(fds[1]);
883         }
884         LOCAL_USER_REMOVE(u);
885         return res;
886 }
887
888 int unload_module(void)
889 {
890         STANDARD_HANGUP_LOCALUSERS;
891         return ast_unregister_application(app);
892 }
893
894 int load_module(void)
895 {
896         return ast_register_application(app, agi_exec, synopsis, descrip);
897 }
898
899 char *description(void)
900 {
901         return tdesc;
902 }
903
904 int usecount(void)
905 {
906         int res;
907         STANDARD_USECOUNT(res);
908         return res;
909 }
910
911 char *key()
912 {
913         return ASTERISK_GPL_KEY;
914 }
915
916 #define CLIP 32635
917 #define BIAS 0x84
918
919 unsigned char
920 linear2ulaw(sample)
921 short sample; {
922   static int exp_lut[256] = {0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
923                              4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
924                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
925                              5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
926                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
927                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
928                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
929                              6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
930                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
931                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
932                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
933                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
934                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
935                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
936                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
937                              7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7};
938   int sign, exponent, mantissa;
939   unsigned char ulawbyte;
940  
941   /* Get the sample into sign-magnitude. */
942   sign = (sample >> 8) & 0x80;          /* set aside the sign */
943   if (sign != 0) sample = -sample;              /* get magnitude */
944   if (sample > CLIP) sample = CLIP;             /* clip the magnitude */
945  
946   /* Convert from 16 bit linear to ulaw. */
947   sample = sample + BIAS;
948   exponent = exp_lut[(sample >> 7) & 0xFF];
949   mantissa = (sample >> (exponent + 3)) & 0x0F;
950   ulawbyte = ~(sign | (exponent << 4) | mantissa);
951 #ifdef ZEROTRAP
952   if (ulawbyte == 0) ulawbyte = 0x02;   /* optional CCITT trap */
953 #endif
954  
955   return(ulawbyte);
956 }