Update documentation to make it explicit that "stream file" will not restart musiconhold.
[asterisk/asterisk.git] / res / res_agi.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief AGI - the Asterisk Gateway Interface
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \todo Convert the rest of the AGI commands over to XML documentation
26  */
27
28 /*** MODULEINFO
29         <support_level>core</support_level>
30  ***/
31
32 #include "asterisk.h"
33
34 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
35
36 #include <math.h>
37 #include <signal.h>
38 #include <sys/time.h>
39 #include <sys/wait.h>
40 #include <sys/stat.h>
41 #include <pthread.h>
42
43 #include "asterisk/paths.h"     /* use many ast_config_AST_*_DIR */
44 #include "asterisk/network.h"
45 #include "asterisk/file.h"
46 #include "asterisk/channel.h"
47 #include "asterisk/pbx.h"
48 #include "asterisk/module.h"
49 #include "asterisk/astdb.h"
50 #include "asterisk/callerid.h"
51 #include "asterisk/cli.h"
52 #include "asterisk/image.h"
53 #include "asterisk/say.h"
54 #include "asterisk/app.h"
55 #include "asterisk/dsp.h"
56 #include "asterisk/musiconhold.h"
57 #include "asterisk/utils.h"
58 #include "asterisk/lock.h"
59 #include "asterisk/strings.h"
60 #include "asterisk/manager.h"
61 #include "asterisk/ast_version.h"
62 #include "asterisk/speech.h"
63 #include "asterisk/manager.h"
64 #include "asterisk/term.h"
65 #include "asterisk/xmldoc.h"
66 #include "asterisk/srv.h"
67 #include "asterisk/test.h"
68 #include "asterisk/netsock2.h"
69
70 #define AST_API_MODULE
71 #include "asterisk/agi.h"
72
73 /*** DOCUMENTATION
74         <agi name="answer" language="en_US">
75                 <synopsis>
76                         Answer channel
77                 </synopsis>
78                 <syntax />
79                 <description>
80                         <para>Answers channel if not already in answer state. Returns <literal>-1</literal> on
81                         channel failure, or <literal>0</literal> if successful.</para>
82                 </description>
83                 <see-also>
84                         <ref type="agi">hangup</ref>
85                 </see-also>
86         </agi>
87         <agi name="asyncagi break" language="en_US">
88                 <synopsis>
89                         Interrupts Async AGI
90                 </synopsis>
91                 <syntax />
92                 <description>
93                         <para>Interrupts expected flow of Async AGI commands and returns control to previous source
94                         (typically, the PBX dialplan).</para>
95                 </description>
96                 <see-also>
97                         <ref type="agi">hangup</ref>
98                 </see-also>
99         </agi>
100         <agi name="channel status" language="en_US">
101                 <synopsis>
102                         Returns status of the connected channel.
103                 </synopsis>
104                 <syntax>
105                         <parameter name="channelname" />
106                 </syntax>
107                 <description>
108                         <para>Returns the status of the specified <replaceable>channelname</replaceable>.
109                         If no channel name is given then returns the status of the current channel.</para>
110                         <para>Return values:</para>
111                         <enumlist>
112                                 <enum name="0">
113                                         <para>Channel is down and available.</para>
114                                 </enum>
115                                 <enum name="1">
116                                         <para>Channel is down, but reserved.</para>
117                                 </enum>
118                                 <enum name="2">
119                                         <para>Channel is off hook.</para>
120                                 </enum>
121                                 <enum name="3">
122                                         <para>Digits (or equivalent) have been dialed.</para>
123                                 </enum>
124                                 <enum name="4">
125                                         <para>Line is ringing.</para>
126                                 </enum>
127                                 <enum name="5">
128                                         <para>Remote end is ringing.</para>
129                                 </enum>
130                                 <enum name="6">
131                                         <para>Line is up.</para>
132                                 </enum>
133                                 <enum name="7">
134                                         <para>Line is busy.</para>
135                                 </enum>
136                         </enumlist>
137                 </description>
138         </agi>
139         <agi name="control stream file" language="en_US">
140                 <synopsis>
141                         Sends audio file on channel and allows the listener to control the stream.
142                 </synopsis>
143                 <syntax>
144                         <parameter name="filename" required="true">
145                                 <para>The file extension must not be included in the filename.</para>
146                         </parameter>
147                         <parameter name="escape_digits" required="true" />
148                         <parameter name="skipms" />
149                         <parameter name="ffchar">
150                                 <para>Defaults to <literal>*</literal></para>
151                         </parameter>
152                         <parameter name="rewchr">
153                                 <para>Defaults to <literal>#</literal></para>
154                         </parameter>
155                         <parameter name="pausechr" />
156                 </syntax>
157                 <description>
158                         <para>Send the given file, allowing playback to be controlled by the given
159                         digits, if any. Use double quotes for the digits if you wish none to be
160                         permitted. Returns <literal>0</literal> if playback completes without a digit
161                         being pressed, or the ASCII numerical value of the digit if one was pressed,
162                         or <literal>-1</literal> on error or if the channel was disconnected.</para>
163                 </description>
164         </agi>
165         <agi name="database del" language="en_US">
166                 <synopsis>
167                         Removes database key/value
168                 </synopsis>
169                 <syntax>
170                         <parameter name="family" required="true" />
171                         <parameter name="key" required="true" />
172                 </syntax>
173                 <description>
174                         <para>Deletes an entry in the Asterisk database for a given
175                         <replaceable>family</replaceable> and <replaceable>key</replaceable>.</para>
176                         <para>Returns <literal>1</literal> if successful, <literal>0</literal>
177                         otherwise.</para>
178                 </description>
179         </agi>
180         <agi name="database deltree" language="en_US">
181                 <synopsis>
182                         Removes database keytree/value
183                 </synopsis>
184                 <syntax>
185                         <parameter name="family" required="true" />
186                         <parameter name="keytree" />
187                 </syntax>
188                 <description>
189                         <para>Deletes a <replaceable>family</replaceable> or specific <replaceable>keytree</replaceable>
190                         within a <replaceable>family</replaceable> in the Asterisk database.</para>
191                         <para>Returns <literal>1</literal> if successful, <literal>0</literal> otherwise.</para>
192                 </description>
193         </agi>
194         <agi name="database get" language="en_US">
195                 <synopsis>
196                         Gets database value
197                 </synopsis>
198                 <syntax>
199                         <parameter name="family" required="true" />
200                         <parameter name="key" required="true" />
201                 </syntax>
202                 <description>
203                         <para>Retrieves an entry in the Asterisk database for a given <replaceable>family</replaceable>
204                         and <replaceable>key</replaceable>.</para>
205                         <para>Returns <literal>0</literal> if <replaceable>key</replaceable> is not set.
206                         Returns <literal>1</literal> if <replaceable>key</replaceable> is set and returns the variable
207                         in parenthesis.</para>
208                         <para>Example return code: 200 result=1 (testvariable)</para>
209                 </description>
210         </agi>
211         <agi name="database put" language="en_US">
212                 <synopsis>
213                         Adds/updates database value
214                 </synopsis>
215                 <syntax>
216                         <parameter name="family" required="true" />
217                         <parameter name="key" required="true" />
218                         <parameter name="value" required="true" />
219                 </syntax>
220                 <description>
221                         <para>Adds or updates an entry in the Asterisk database for a given
222                         <replaceable>family</replaceable>, <replaceable>key</replaceable>, and
223                         <replaceable>value</replaceable>.</para>
224                         <para>Returns <literal>1</literal> if successful, <literal>0</literal> otherwise.</para>
225                 </description>
226         </agi>
227         <agi name="exec" language="en_US">
228                 <synopsis>
229                         Executes a given Application
230                 </synopsis>
231                 <syntax>
232                         <parameter name="application" required="true" />
233                         <parameter name="options" required="true" />
234                 </syntax>
235                 <description>
236                         <para>Executes <replaceable>application</replaceable> with given
237                         <replaceable>options</replaceable>.</para>
238                         <para>Returns whatever the <replaceable>application</replaceable> returns, or
239                         <literal>-2</literal> on failure to find <replaceable>application</replaceable>.</para>
240                 </description>
241         </agi>
242         <agi name="get data" language="en_US">
243                 <synopsis>
244                         Prompts for DTMF on a channel
245                 </synopsis>
246                 <syntax>
247                         <parameter name="file" required="true" />
248                         <parameter name="timeout" />
249                         <parameter name="maxdigits" />
250                 </syntax>
251                 <description>
252                         <para>Stream the given <replaceable>file</replaceable>, and receive DTMF data.</para>
253                         <para>Returns the digits received from the channel at the other end.</para>
254                 </description>
255         </agi>
256         <agi name="get full variable" language="en_US">
257                 <synopsis>
258                         Evaluates a channel expression
259                 </synopsis>
260                 <syntax>
261                         <parameter name="variablename" required="true" />
262                         <parameter name="channel name" />
263                 </syntax>
264                 <description>
265                         <para>Returns <literal>0</literal> if <replaceable>variablename</replaceable> is not set
266                         or channel does not exist. Returns <literal>1</literal> if <replaceable>variablename</replaceable>
267                         is set and returns the variable in parenthesis. Understands complex variable names and builtin
268                         variables, unlike GET VARIABLE.</para>
269                         <para>Example return code: 200 result=1 (testvariable)</para>
270                 </description>
271         </agi>
272         <agi name="get option" language="en_US">
273                 <synopsis>
274                         Stream file, prompt for DTMF, with timeout.
275                 </synopsis>
276                 <syntax>
277                         <parameter name="filename" required="true" />
278                         <parameter name="escape_digits" required="true" />
279                         <parameter name="timeout" />
280                 </syntax>
281                 <description>
282                         <para>Behaves similar to STREAM FILE but used with a timeout option.</para>
283                 </description>
284                 <see-also>
285                         <ref type="agi">stream file</ref>
286                 </see-also>
287         </agi>
288         <agi name="get variable" language="en_US">
289                 <synopsis>
290                         Gets a channel variable.
291                 </synopsis>
292                 <syntax>
293                         <parameter name="variablename" required="true" />
294                 </syntax>
295                 <description>
296                         <para>Returns <literal>0</literal> if <replaceable>variablename</replaceable> is not set.
297                         Returns <literal>1</literal> if <replaceable>variablename</replaceable> is set and returns
298                         the variable in parentheses.</para>
299                         <para>Example return code: 200 result=1 (testvariable)</para>
300                 </description>
301         </agi>
302         <agi name="hangup" language="en_US">
303                 <synopsis>
304                         Hangup a channel.
305                 </synopsis>
306                 <syntax>
307                         <parameter name="channelname" />
308                 </syntax>
309                 <description>
310                         <para>Hangs up the specified channel. If no channel name is given, hangs
311                         up the current channel</para>
312                 </description>
313         </agi>
314         <agi name="noop" language="en_US">
315                 <synopsis>
316                         Does nothing.
317                 </synopsis>
318                 <syntax />
319                 <description>
320                         <para>Does nothing.</para>
321                 </description>
322         </agi>
323         <agi name="receive char" language="en_US">
324                 <synopsis>
325                         Receives one character from channels supporting it.
326                 </synopsis>
327                 <syntax>
328                         <parameter name="timeout" required="true">
329                                 <para>The maximum time to wait for input in milliseconds, or <literal>0</literal>
330                                 for infinite. Most channels</para>
331                         </parameter>
332                 </syntax>
333                 <description>
334                         <para>Receives a character of text on a channel. Most channels do not support
335                         the reception of text. Returns the decimal value of the character
336                         if one is received, or <literal>0</literal> if the channel does not support
337                         text reception. Returns <literal>-1</literal> only on error/hangup.</para>
338                 </description>
339         </agi>
340         <agi name="receive text" language="en_US">
341                 <synopsis>
342                         Receives text from channels supporting it.
343                 </synopsis>
344                 <syntax>
345                         <parameter name="timeout" required="true">
346                                 <para>The timeout to be the maximum time to wait for input in
347                                 milliseconds, or <literal>0</literal> for infinite.</para>
348                         </parameter>
349                 </syntax>
350                 <description>
351                         <para>Receives a string of text on a channel. Most channels 
352                         do not support the reception of text. Returns <literal>-1</literal> for failure
353                         or <literal>1</literal> for success, and the string in parenthesis.</para> 
354                 </description>
355         </agi>
356         <agi name="record file" language="en_US">
357                 <synopsis>
358                         Records to a given file.
359                 </synopsis>
360                 <syntax>
361                         <parameter name="filename" required="true" />
362                         <parameter name="format" required="true" />
363                         <parameter name="escape_digits" required="true" />
364                         <parameter name="timeout" required="true" />
365                         <parameter name="offset samples" />
366                         <parameter name="BEEP" />
367                         <parameter name="s=silence" />
368                 </syntax>
369                 <description>
370                         <para>Record to a file until a given dtmf digit in the sequence is received.
371                         Returns <literal>-1</literal> on hangup or error.  The format will specify what kind of file
372                         will be recorded. The <replaceable>timeout</replaceable> is the maximum record time in
373                         milliseconds, or <literal>-1</literal> for no <replaceable>timeout</replaceable>.
374                         <replaceable>offset samples</replaceable> is optional, and, if provided, will seek
375                         to the offset without exceeding the end of the file. <replaceable>silence</replaceable> is
376                         the number of seconds of silence allowed before the function returns despite the
377                         lack of dtmf digits or reaching <replaceable>timeout</replaceable>. <replaceable>silence</replaceable>
378                         value must be preceded by <literal>s=</literal> and is also optional.</para>
379                 </description>
380         </agi>
381         <agi name="say alpha" language="en_US">
382                 <synopsis>
383                         Says a given character string.
384                 </synopsis>
385                 <syntax>
386                         <parameter name="number" required="true" />
387                         <parameter name="escape_digits" required="true" />
388                 </syntax>
389                 <description>
390                         <para>Say a given character string, returning early if any of the given DTMF digits
391                         are received on the channel. Returns <literal>0</literal> if playback completes
392                         without a digit being pressed, or the ASCII numerical value of the digit if one
393                         was pressed or <literal>-1</literal> on error/hangup.</para>
394                 </description>
395         </agi>
396         <agi name="say digits" language="en_US">
397                 <synopsis>
398                         Says a given digit string.
399                 </synopsis>
400                 <syntax>
401                         <parameter name="number" required="true" />
402                         <parameter name="escape_digits" required="true" />
403                 </syntax>
404                 <description>
405                         <para>Say a given digit string, returning early if any of the given DTMF digits
406                         are received on the channel. Returns <literal>0</literal> if playback completes
407                         without a digit being pressed, or the ASCII numerical value of the digit if one
408                         was pressed or <literal>-1</literal> on error/hangup.</para>
409                 </description>
410         </agi>
411         <agi name="say number" language="en_US">
412                 <synopsis>
413                         Says a given number.
414                 </synopsis>
415                 <syntax>
416                         <parameter name="number" required="true" />
417                         <parameter name="escape_digits" required="true" />
418                         <parameter name="gender" />
419                 </syntax>
420                 <description>
421                         <para>Say a given number, returning early if any of the given DTMF digits
422                         are received on the channel.  Returns <literal>0</literal> if playback
423                         completes without a digit being pressed, or the ASCII numerical value of
424                         the digit if one was pressed or <literal>-1</literal> on error/hangup.</para>
425                 </description>
426         </agi>
427         <agi name="say phonetic" language="en_US">
428                 <synopsis>
429                         Says a given character string with phonetics.
430                 </synopsis>
431                 <syntax>
432                         <parameter name="string" required="true" />
433                         <parameter name="escape_digits" required="true" />
434                 </syntax>
435                 <description>
436                         <para>Say a given character string with phonetics, returning early if any of the
437                         given DTMF digits are received on the channel. Returns <literal>0</literal> if
438                         playback completes without a digit pressed, the ASCII numerical value of the digit
439                         if one was pressed, or <literal>-1</literal> on error/hangup.</para>
440                 </description>
441         </agi>
442         <agi name="say date" language="en_US">
443                 <synopsis>
444                         Says a given date.
445                 </synopsis>
446                 <syntax>
447                         <parameter name="date" required="true">
448                                 <para>Is number of seconds elapsed since 00:00:00 on January 1, 1970.
449                                 Coordinated Universal Time (UTC).</para>
450                         </parameter>
451                         <parameter name="escape_digits" required="true" />
452                 </syntax>
453                 <description>
454                         <para>Say a given date, returning early if any of the given DTMF digits are
455                         received on the channel. Returns <literal>0</literal> if playback
456                         completes without a digit being pressed, or the ASCII numerical value of the
457                         digit if one was pressed or <literal>-1</literal> on error/hangup.</para>
458                 </description>
459         </agi>
460         <agi name="say time" language="en_US">
461                 <synopsis>
462                         Says a given time.
463                 </synopsis>
464                 <syntax>
465                         <parameter name="time" required="true">
466                                 <para>Is number of seconds elapsed since 00:00:00 on January 1, 1970.
467                                 Coordinated Universal Time (UTC).</para>
468                         </parameter>
469                         <parameter name="escape_digits" required="true" />
470                 </syntax>
471                 <description>
472                         <para>Say a given time, returning early if any of the given DTMF digits are
473                         received on the channel. Returns <literal>0</literal> if playback completes
474                         without a digit being pressed, or the ASCII numerical value of the digit if
475                         one was pressed or <literal>-1</literal> on error/hangup.</para>
476                 </description>
477         </agi>
478         <agi name="say datetime" language="en_US">
479                 <synopsis>
480                         Says a given time as specified by the format given.
481                 </synopsis>
482                 <syntax>
483                         <parameter name="time" required="true">
484                                 <para>Is number of seconds elapsed since 00:00:00
485                                 on January 1, 1970, Coordinated Universal Time (UTC)</para>
486                         </parameter>
487                         <parameter name="escape_digits" required="true" />
488                         <parameter name="format">
489                                 <para>Is the format the time should be said in. See
490                                 <filename>voicemail.conf</filename> (defaults to <literal>ABdY
491                                 'digits/at' IMp</literal>).</para>
492                         </parameter>
493                         <parameter name="timezone">
494                                 <para>Acceptable values can be found in <filename>/usr/share/zoneinfo</filename>
495                                 Defaults to machine default.</para>
496                         </parameter>
497                 </syntax>
498                 <description>
499                         <para>Say a given time, returning early if any of the given DTMF digits are
500                         received on the channel. Returns <literal>0</literal> if playback
501                         completes without a digit being pressed, or the ASCII numerical value of the
502                         digit if one was pressed or <literal>-1</literal> on error/hangup.</para>
503                 </description>
504         </agi>
505         <agi name="send image" language="en_US">
506                 <synopsis>
507                         Sends images to channels supporting it.
508                 </synopsis>
509                 <syntax>
510                         <parameter name="image" required="true" />
511                 </syntax>
512                 <description>
513                         <para>Sends the given image on a channel. Most channels do not support the
514                         transmission of images. Returns <literal>0</literal> if image is sent, or if
515                         the channel does not support image transmission.  Returns <literal>-1</literal>
516                         only on error/hangup. Image names should not include extensions.</para>
517                 </description>
518         </agi>
519         <agi name="send text" language="en_US">
520                 <synopsis>
521                         Sends text to channels supporting it.
522                 </synopsis>
523                 <syntax>
524                         <parameter name="text to send" required="true">
525                                 <para>Text consisting of greater than one word should be placed
526                                 in quotes since the command only accepts a single argument.</para>
527                         </parameter>
528                 </syntax>
529                 <description>
530                         <para>Sends the given text on a channel. Most channels do not support the
531                         transmission of text. Returns <literal>0</literal> if text is sent, or if the
532                         channel does not support text transmission. Returns <literal>-1</literal> only
533                         on error/hangup.</para>
534                 </description>
535         </agi>
536         <agi name="set autohangup" language="en_US">
537                 <synopsis>
538                         Autohangup channel in some time.
539                 </synopsis>
540                 <syntax>
541                         <parameter name="time" required="true" />
542                 </syntax>
543                 <description>
544                         <para>Cause the channel to automatically hangup at <replaceable>time</replaceable>
545                         seconds in the future. Of course it can be hungup before then as well. Setting to
546                         <literal>0</literal> will cause the autohangup feature to be disabled on this channel.</para>
547                 </description>
548         </agi>
549         <agi name="set callerid" language="en_US">
550                 <synopsis>
551                         Sets callerid for the current channel.
552                 </synopsis>
553                 <syntax>
554                         <parameter name="number" required="true" />
555                 </syntax>
556                 <description>
557                         <para>Changes the callerid of the current channel.</para>
558                 </description>
559         </agi>
560         <agi name="set context" language="en_US">
561                 <synopsis>
562                         Sets channel context.
563                 </synopsis>
564                 <syntax>
565                         <parameter name="desired context" required="true" />
566                 </syntax>
567                 <description>
568                         <para>Sets the context for continuation upon exiting the application.</para>
569                 </description>
570         </agi>
571         <agi name="set extension" language="en_US">
572                 <synopsis>
573                         Changes channel extension.
574                 </synopsis>
575                 <syntax>
576                         <parameter name="new extension" required="true" />
577                 </syntax>
578                 <description>
579                         <para>Changes the extension for continuation upon exiting the application.</para>
580                 </description>
581         </agi>
582         <agi name="set music" language="en_US">
583                 <synopsis>
584                         Enable/Disable Music on hold generator
585                 </synopsis>
586                 <syntax>
587                         <parameter required="true">
588                                 <enumlist>
589                                         <enum>
590                                                 <parameter name="on" literal="true" required="true" />
591                                         </enum>
592                                         <enum>
593                                                 <parameter name="off" literal="true" required="true" />
594                                         </enum>
595                                 </enumlist>
596                         </parameter>
597                         <parameter name="class" required="true" />
598                 </syntax>
599                 <description>
600                         <para>Enables/Disables the music on hold generator. If <replaceable>class</replaceable>
601                         is not specified, then the <literal>default</literal> music on hold class will be
602                         used. This generator will be stopped automatically when playing a file.</para>
603                         <para>Always returns <literal>0</literal>.</para>
604                 </description>
605         </agi>
606         <agi name="set priority" language="en_US">
607                 <synopsis>
608                         Set channel dialplan priority.
609                 </synopsis>
610                 <syntax>
611                         <parameter name="priority" required="true" />
612                 </syntax>
613                 <description>
614                         <para>Changes the priority for continuation upon exiting the application.
615                         The priority must be a valid priority or label.</para>
616                 </description>
617         </agi>
618         <agi name="set variable" language="en_US">
619                 <synopsis>
620                         Sets a channel variable.
621                 </synopsis>
622                 <syntax>
623                         <parameter name="variablename" required="true" />
624                         <parameter name="value" required="true" />
625                 </syntax>
626                 <description>
627                         <para>Sets a variable to the current channel.</para>
628                 </description>
629         </agi>
630         <agi name="stream file" language="en_US">
631                 <synopsis>
632                         Sends audio file on channel.
633                 </synopsis>
634                 <syntax>
635                         <parameter name="filename" required="true">
636                                 <para>File name to play. The file extension must not be
637                                 included in the <replaceable>filename</replaceable>.</para>
638                         </parameter>
639                         <parameter name="escape_digits" required="true">
640                                 <para>Use double quotes for the digits if you wish none to be
641                                 permitted.</para>
642                         </parameter>
643                         <parameter name="sample offset">
644                                 <para>If sample offset is provided then the audio will seek to sample
645                                 offset before play starts.</para>
646                         </parameter>
647                 </syntax>
648                 <description>
649                         <para>Send the given file, allowing playback to be interrupted by the given
650                         digits, if any. Returns <literal>0</literal> if playback completes without a digit
651                         being pressed, or the ASCII numerical value of the digit if one was pressed,
652                         or <literal>-1</literal> on error or if the channel was disconnected. If
653                         musiconhold is playing before calling stream file it will be automatically
654                         stopped and will not be restarted after completion.</para>
655                 </description>
656                 <see-also>
657                         <ref type="agi">control stream file</ref>
658                 </see-also>
659         </agi>
660         <agi name="tdd mode" language="en_US">
661                 <synopsis>
662                         Toggles TDD mode (for the deaf).
663                 </synopsis>
664                 <syntax>
665                         <parameter name="boolean" required="true">
666                                 <enumlist>
667                                         <enum name="on" />
668                                         <enum name="off" />
669                                 </enumlist>
670                         </parameter>
671                 </syntax>
672                 <description>
673                         <para>Enable/Disable TDD transmission/reception on a channel. Returns <literal>1</literal> if
674                         successful, or <literal>0</literal> if channel is not TDD-capable.</para>
675                 </description>
676         </agi>
677         <agi name="verbose" language="en_US">
678                 <synopsis>
679                         Logs a message to the asterisk verbose log.
680                 </synopsis>
681                 <syntax>
682                         <parameter name="message" required="true" />
683                         <parameter name="level" required="true" />
684                 </syntax>
685                 <description>
686                         <para>Sends <replaceable>message</replaceable> to the console via verbose
687                         message system. <replaceable>level</replaceable> is the verbose level (1-4).
688                         Always returns <literal>1</literal></para>
689                 </description>
690         </agi>
691         <agi name="wait for digit" language="en_US">
692                 <synopsis>
693                         Waits for a digit to be pressed.
694                 </synopsis>
695                 <syntax>
696                         <parameter name="timeout" required="true" />
697                 </syntax>
698                 <description>
699                         <para>Waits up to <replaceable>timeout</replaceable> milliseconds for channel to
700                         receive a DTMF digit. Returns <literal>-1</literal> on channel failure, <literal>0</literal>
701                         if no digit is received in the timeout, or the numerical value of the ascii of the digit if
702                         one is received. Use <literal>-1</literal> for the <replaceable>timeout</replaceable> value if
703                         you desire the call to block indefinitely.</para>
704                 </description>
705         </agi>
706         <agi name="speech create" language="en_US">
707                 <synopsis>
708                         Creates a speech object.
709                 </synopsis>
710                 <syntax>
711                         <parameter name="engine" required="true" />
712                 </syntax>
713                 <description>
714                         <para>Create a speech object to be used by the other Speech AGI commands.</para>
715                 </description>
716         </agi>
717         <agi name="speech set" language="en_US">
718                 <synopsis>
719                         Sets a speech engine setting.
720                 </synopsis>
721                 <syntax>
722                         <parameter name="name" required="true" />
723                         <parameter name="value" required="true" />
724                 </syntax>
725                 <description>
726                         <para>Set an engine-specific setting.</para>
727                 </description>
728         </agi>
729         <agi name="speech destroy" language="en_US">
730                 <synopsis>
731                         Destroys a speech object.
732                 </synopsis>
733                 <syntax>
734                 </syntax>
735                 <description>
736                         <para>Destroy the speech object created by <literal>SPEECH CREATE</literal>.</para>
737                 </description>
738                 <see-also>
739                         <ref type="agi">speech create</ref>
740                 </see-also>
741         </agi>
742         <agi name="speech load grammar" language="en_US">
743                 <synopsis>
744                         Loads a grammar.
745                 </synopsis>
746                 <syntax>
747                         <parameter name="grammar name" required="true" />
748                         <parameter name="path to grammar" required="true" />
749                 </syntax>
750                 <description>
751                         <para>Loads the specified grammar as the specified name.</para>
752                 </description>
753         </agi>
754         <agi name="speech unload grammar" language="en_US">
755                 <synopsis>
756                         Unloads a grammar.
757                 </synopsis>
758                 <syntax>
759                         <parameter name="grammar name" required="true" />
760                 </syntax>
761                 <description>
762                         <para>Unloads the specified grammar.</para>
763                 </description>
764         </agi>
765         <agi name="speech activate grammar" language="en_US">
766                 <synopsis>
767                         Activates a grammar.
768                 </synopsis>
769                 <syntax>
770                         <parameter name="grammar name" required="true" />
771                 </syntax>
772                 <description>
773                         <para>Activates the specified grammar on the speech object.</para>
774                 </description>
775         </agi>
776         <agi name="speech deactivate grammar" language="en_US">
777                 <synopsis>
778                         Deactivates a grammar.
779                 </synopsis>
780                 <syntax>
781                         <parameter name="grammar name" required="true" />
782                 </syntax>
783                 <description>
784                         <para>Deactivates the specified grammar on the speech object.</para>
785                 </description>
786         </agi>
787         <agi name="speech recognize" language="en_US">
788                 <synopsis>
789                         Recognizes speech.
790                 </synopsis>
791                 <syntax>
792                         <parameter name="prompt" required="true" />
793                         <parameter name="timeout" required="true" />
794                         <parameter name="offset" />
795                 </syntax>
796                 <description>
797                         <para>Plays back given <replaceable>prompt</replaceable> while listening for
798                         speech and dtmf.</para>
799                 </description>
800         </agi>
801         <application name="AGI" language="en_US">
802                 <synopsis>
803                         Executes an AGI compliant application.
804                 </synopsis>
805                 <syntax>
806                         <parameter name="command" required="true" />
807                         <parameter name="args">
808                                 <argument name="arg1" required="true" />
809                                 <argument name="arg2" multiple="yes" />
810                         </parameter>
811                 </syntax>
812                 <description>
813                         <para>Executes an Asterisk Gateway Interface compliant
814                         program on a channel. AGI allows Asterisk to launch external programs written
815                         in any language to control a telephony channel, play audio, read DTMF digits,
816                         etc. by communicating with the AGI protocol on <emphasis>stdin</emphasis> and
817                         <emphasis>stdout</emphasis>. As of <literal>1.6.0</literal>, this channel will
818                         not stop dialplan execution on hangup inside of this application. Dialplan
819                         execution will continue normally, even upon hangup until the AGI application
820                         signals a desire to stop (either by exiting or, in the case of a net script, by
821                         closing the connection). A locally executed AGI script will receive SIGHUP on
822                         hangup from the channel except when using DeadAGI. A fast AGI server will
823                         correspondingly receive a HANGUP inline with the command dialog. Both of theses
824                         signals may be disabled by setting the <variable>AGISIGHUP</variable> channel
825                         variable to <literal>no</literal> before executing the AGI application.
826                         Alternatively, if you would like the AGI application to exit immediately
827                         after a channel hangup is detected, set the <variable>AGIEXITONHANGUP</variable>
828                         variable to <literal>yes</literal>.</para>
829                         <para>Use the CLI command <literal>agi show commands</literal> to list available agi
830                         commands.</para>
831                         <para>This application sets the following channel variable upon completion:</para>
832                         <variablelist>
833                                 <variable name="AGISTATUS">
834                                         <para>The status of the attempt to the run the AGI script
835                                         text string, one of:</para>
836                                         <value name="SUCCESS" />
837                                         <value name="FAILURE" />
838                                         <value name="NOTFOUND" />
839                                         <value name="HANGUP" />
840                                 </variable>
841                         </variablelist>
842                 </description>
843                 <see-also>
844                         <ref type="application">EAGI</ref>
845                         <ref type="application">DeadAGI</ref>
846                 </see-also>
847         </application>
848         <application name="EAGI" language="en_US">
849                 <synopsis>
850                         Executes an EAGI compliant application.
851                 </synopsis>
852                 <syntax>
853                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/syntax/parameter[@name='command'])" />
854                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/syntax/parameter[@name='args'])" />
855                 </syntax>
856                 <description>
857                         <para>Using 'EAGI' provides enhanced AGI, with incoming audio available out of band
858                         on file descriptor 3.</para>
859                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/description/para)" />
860                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/description/variablelist)" />
861                 </description>
862                 <see-also>
863                         <ref type="application">AGI</ref>
864                         <ref type="application">DeadAGI</ref>
865                 </see-also>
866         </application>
867         <application name="DeadAGI" language="en_US">
868                 <synopsis>
869                         Executes AGI on a hungup channel.
870                 </synopsis>
871                 <syntax>
872                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/syntax/parameter[@name='command'])" />
873                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/syntax/parameter[@name='args'])" />
874                 </syntax>
875                 <description>
876                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/description/para)" />
877                         <xi:include xpointer="xpointer(/docs/application[@name='AGI']/description/variablelist)" />
878                 </description>
879                 <see-also>
880                         <ref type="application">AGI</ref>
881                         <ref type="application">EAGI</ref>
882                 </see-also>
883         </application>
884         <manager name="AGI" language="en_US">
885                 <synopsis>
886                         Add an AGI command to execute by Async AGI.
887                 </synopsis>
888                 <syntax>
889                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
890                         <parameter name="Channel" required="true">
891                                 <para>Channel that is currently in Async AGI.</para>
892                         </parameter>
893                         <parameter name="Command" required="true">
894                                 <para>Application to execute.</para>
895                         </parameter>
896                         <parameter name="CommandID">
897                                 <para>This will be sent back in CommandID header of AsyncAGI exec
898                                 event notification.</para>
899                         </parameter>
900                 </syntax>
901                 <description>
902                         <para>Add an AGI command to the execute queue of the channel in Async AGI.</para>
903                 </description>
904         </manager>
905  ***/
906
907 #define MAX_ARGS 128
908 #define MAX_CMD_LEN 80
909 #define AGI_NANDFS_RETRY 3
910 #define AGI_BUF_LEN 2048
911 #define SRV_PREFIX "_agi._tcp."
912
913 static char *app = "AGI";
914
915 static char *eapp = "EAGI";
916
917 static char *deadapp = "DeadAGI";
918
919 static int agidebug = 0;
920
921 #define TONE_BLOCK_SIZE 200
922
923 /* Max time to connect to an AGI remote host */
924 #define MAX_AGI_CONNECT 2000
925
926 #define AGI_PORT 4573
927
928 /*! Special return code for "asyncagi break" command. */
929 #define ASYNC_AGI_BREAK 3
930
931 enum agi_result {
932         AGI_RESULT_FAILURE = -1,
933         AGI_RESULT_SUCCESS,
934         AGI_RESULT_SUCCESS_FAST,
935         AGI_RESULT_SUCCESS_ASYNC,
936         AGI_RESULT_NOTFOUND,
937         AGI_RESULT_HANGUP,
938 };
939
940 static agi_command *find_command(const char * const cmds[], int exact);
941
942 AST_THREADSTORAGE(agi_buf);
943 #define AGI_BUF_INITSIZE 256
944
945 int AST_OPTIONAL_API_NAME(ast_agi_send)(int fd, struct ast_channel *chan, char *fmt, ...)
946 {
947         int res = 0;
948         va_list ap;
949         struct ast_str *buf;
950
951         if (!(buf = ast_str_thread_get(&agi_buf, AGI_BUF_INITSIZE)))
952                 return -1;
953
954         va_start(ap, fmt);
955         res = ast_str_set_va(&buf, 0, fmt, ap);
956         va_end(ap);
957
958         if (res == -1) {
959                 ast_log(LOG_ERROR, "Out of memory\n");
960                 return -1;
961         }
962
963         if (agidebug) {
964                 if (chan) {
965                         ast_verbose("<%s>AGI Tx >> %s", ast_channel_name(chan), ast_str_buffer(buf));
966                 } else {
967                         ast_verbose("AGI Tx >> %s", ast_str_buffer(buf));
968                 }
969         }
970
971         return ast_carefulwrite(fd, ast_str_buffer(buf), ast_str_strlen(buf), 100);
972 }
973
974 /* linked list of AGI commands ready to be executed by Async AGI */
975 struct agi_cmd {
976         char *cmd_buffer;
977         char *cmd_id;
978         AST_LIST_ENTRY(agi_cmd) entry;
979 };
980
981 static void free_agi_cmd(struct agi_cmd *cmd)
982 {
983         ast_free(cmd->cmd_buffer);
984         ast_free(cmd->cmd_id);
985         ast_free(cmd);
986 }
987
988 /* AGI datastore destructor */
989 static void agi_destroy_commands_cb(void *data)
990 {
991         struct agi_cmd *cmd;
992         AST_LIST_HEAD(, agi_cmd) *chan_cmds = data;
993         AST_LIST_LOCK(chan_cmds);
994         while ( (cmd = AST_LIST_REMOVE_HEAD(chan_cmds, entry)) ) {
995                 free_agi_cmd(cmd);
996         }
997         AST_LIST_UNLOCK(chan_cmds);
998         AST_LIST_HEAD_DESTROY(chan_cmds);
999         ast_free(chan_cmds);
1000 }
1001
1002 /* channel datastore to keep the queue of AGI commands in the channel */
1003 static const struct ast_datastore_info agi_commands_datastore_info = {
1004         .type = "AsyncAGI",
1005         .destroy = agi_destroy_commands_cb
1006 };
1007
1008 /*!
1009  * \brief Retrieve the list head to the requested channel's AGI datastore
1010  * \param chan Channel datastore is requested for
1011  * \param cmd Pointer to the struct pointer which will reference the head of the agi command list.
1012  *
1013  * \retval 0 if the datastore was valid and the list head was retrieved appropriately (even if it's
1014  *           NULL and the list is empty)
1015  * \retval -1 if the datastore could not be retrieved causing an error
1016 */
1017 static int get_agi_cmd(struct ast_channel *chan, struct agi_cmd **cmd)
1018 {
1019         struct ast_datastore *store;
1020         AST_LIST_HEAD(, agi_cmd) *agi_commands;
1021
1022         ast_channel_lock(chan);
1023         store = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL);
1024         ast_channel_unlock(chan);
1025         if (!store) {
1026                 ast_log(LOG_ERROR, "Huh? Async AGI datastore disappeared on Channel %s!\n",
1027                         ast_channel_name(chan));
1028                 *cmd = NULL;
1029                 return -1;
1030         }
1031         agi_commands = store->data;
1032         AST_LIST_LOCK(agi_commands);
1033         *cmd = AST_LIST_REMOVE_HEAD(agi_commands, entry);
1034         AST_LIST_UNLOCK(agi_commands);
1035         return 0;
1036 }
1037
1038 /* channel is locked when calling this one either from the CLI or manager thread */
1039 static int add_agi_cmd(struct ast_channel *chan, const char *cmd_buff, const char *cmd_id)
1040 {
1041         struct ast_datastore *store;
1042         struct agi_cmd *cmd;
1043         AST_LIST_HEAD(, agi_cmd) *agi_commands;
1044
1045         store = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL);
1046         if (!store) {
1047                 ast_log(LOG_WARNING, "Channel %s is not setup for Async AGI.\n", ast_channel_name(chan));
1048                 return -1;
1049         }
1050         agi_commands = store->data;
1051         cmd = ast_calloc(1, sizeof(*cmd));
1052         if (!cmd) {
1053                 return -1;
1054         }
1055         cmd->cmd_buffer = ast_strdup(cmd_buff);
1056         if (!cmd->cmd_buffer) {
1057                 ast_free(cmd);
1058                 return -1;
1059         }
1060         cmd->cmd_id = ast_strdup(cmd_id);
1061         if (!cmd->cmd_id) {
1062                 ast_free(cmd->cmd_buffer);
1063                 ast_free(cmd);
1064                 return -1;
1065         }
1066         AST_LIST_LOCK(agi_commands);
1067         AST_LIST_INSERT_TAIL(agi_commands, cmd, entry);
1068         AST_LIST_UNLOCK(agi_commands);
1069         return 0;
1070 }
1071
1072 static int add_to_agi(struct ast_channel *chan)
1073 {
1074         struct ast_datastore *datastore;
1075         AST_LIST_HEAD(, agi_cmd) *agi_cmds_list;
1076
1077         /* check if already on AGI */
1078         ast_channel_lock(chan);
1079         datastore = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL);
1080         ast_channel_unlock(chan);
1081         if (datastore) {
1082                 /* we already have an AGI datastore, let's just
1083                    return success */
1084                 return 0;
1085         }
1086
1087         /* the channel has never been on Async AGI,
1088            let's allocate it's datastore */
1089         datastore = ast_datastore_alloc(&agi_commands_datastore_info, "AGI");
1090         if (!datastore) {
1091                 return -1;
1092         }
1093         agi_cmds_list = ast_calloc(1, sizeof(*agi_cmds_list));
1094         if (!agi_cmds_list) {
1095                 ast_log(LOG_ERROR, "Unable to allocate Async AGI commands list.\n");
1096                 ast_datastore_free(datastore);
1097                 return -1;
1098         }
1099         datastore->data = agi_cmds_list;
1100         AST_LIST_HEAD_INIT(agi_cmds_list);
1101         ast_channel_lock(chan);
1102         ast_channel_datastore_add(chan, datastore);
1103         ast_channel_unlock(chan);
1104         return 0;
1105 }
1106
1107 /*!
1108  * \brief CLI command to add applications to execute in Async AGI
1109  * \param e
1110  * \param cmd
1111  * \param a
1112  *
1113  * \retval CLI_SUCCESS on success
1114  * \retval NULL when init or tab completion is used
1115 */
1116 static char *handle_cli_agi_add_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1117 {
1118         struct ast_channel *chan;
1119         switch (cmd) {
1120         case CLI_INIT:
1121                 e->command = "agi exec";
1122                 e->usage = "Usage: agi exec <channel name> <app and arguments> [id]\n"
1123                            "       Add AGI command to the execute queue of the specified channel in Async AGI\n";
1124                 return NULL;
1125         case CLI_GENERATE:
1126                 if (a->pos == 2)
1127                         return ast_complete_channels(a->line, a->word, a->pos, a->n, 2);
1128                 return NULL;
1129         }
1130
1131         if (a->argc < 4) {
1132                 return CLI_SHOWUSAGE;
1133         }
1134
1135         if (!(chan = ast_channel_get_by_name(a->argv[2]))) {
1136                 ast_cli(a->fd, "Channel %s does not exist.\n", a->argv[2]);
1137                 return CLI_FAILURE;
1138         }
1139
1140         ast_channel_lock(chan);
1141
1142         if (add_agi_cmd(chan, a->argv[3], (a->argc > 4 ? a->argv[4] : ""))) {
1143                 ast_cli(a->fd, "Failed to add AGI command to queue of channel %s\n", ast_channel_name(chan));
1144                 ast_channel_unlock(chan);
1145                 chan = ast_channel_unref(chan);
1146                 return CLI_FAILURE;
1147         }
1148
1149         ast_debug(1, "Added AGI command to channel %s queue\n", ast_channel_name(chan));
1150
1151         ast_channel_unlock(chan);
1152         chan = ast_channel_unref(chan);
1153
1154         return CLI_SUCCESS;
1155 }
1156
1157 /*!
1158  * \brief Add a new command to execute by the Async AGI application
1159  * \param s
1160  * \param m
1161  *
1162  * It will append the application to the specified channel's queue
1163  * if the channel is not inside Async AGI application it will return an error
1164  * \retval 0 on success or incorrect use
1165  * \retval 1 on failure to add the command ( most likely because the channel
1166  * is not in Async AGI loop )
1167 */
1168 static int action_add_agi_cmd(struct mansession *s, const struct message *m)
1169 {
1170         const char *channel = astman_get_header(m, "Channel");
1171         const char *cmdbuff = astman_get_header(m, "Command");
1172         const char *cmdid   = astman_get_header(m, "CommandID");
1173         struct ast_channel *chan;
1174         char buf[256];
1175
1176         if (ast_strlen_zero(channel) || ast_strlen_zero(cmdbuff)) {
1177                 astman_send_error(s, m, "Both, Channel and Command are *required*");
1178                 return 0;
1179         }
1180
1181         if (!(chan = ast_channel_get_by_name(channel))) {
1182                 snprintf(buf, sizeof(buf), "Channel %s does not exist.", channel);
1183                 astman_send_error(s, m, buf);
1184                 return 0;
1185         }
1186
1187         ast_channel_lock(chan);
1188
1189         if (add_agi_cmd(chan, cmdbuff, cmdid)) {
1190                 snprintf(buf, sizeof(buf), "Failed to add AGI command to channel %s queue", ast_channel_name(chan));
1191                 astman_send_error(s, m, buf);
1192                 ast_channel_unlock(chan);
1193                 chan = ast_channel_unref(chan);
1194                 return 0;
1195         }
1196
1197         ast_channel_unlock(chan);
1198         chan = ast_channel_unref(chan);
1199
1200         astman_send_ack(s, m, "Added AGI command to queue");
1201
1202         return 0;
1203 }
1204
1205 static enum agi_result agi_handle_command(struct ast_channel *chan, AGI *agi, char *buf, int dead);
1206 static void setup_env(struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[]);
1207
1208 /*!
1209  * \internal
1210  * \brief Read and handle a channel frame for Async AGI.
1211  *
1212  * \param chan Channel to read a frame from.
1213  *
1214  * \retval AGI_RESULT_SUCCESS on success.
1215  * \retval AGI_RESULT_HANGUP on hangup.
1216  * \retval AGI_RESULT_FAILURE on error.
1217  */
1218 static enum agi_result async_agi_read_frame(struct ast_channel *chan)
1219 {
1220         struct ast_frame *f;
1221
1222         f = ast_read(chan);
1223         if (!f) {
1224                 ast_debug(3, "No frame read on channel %s, going out ...\n", ast_channel_name(chan));
1225                 return AGI_RESULT_HANGUP;
1226         }
1227         if (f->frametype == AST_FRAME_CONTROL) {
1228                 /*
1229                  * Is there any other frame we should care about besides
1230                  * AST_CONTROL_HANGUP?
1231                  */
1232                 switch (f->subclass.integer) {
1233                 case AST_CONTROL_HANGUP:
1234                         ast_debug(3, "Got HANGUP frame on channel %s, going out ...\n", ast_channel_name(chan));
1235                         ast_frfree(f);
1236                         return AGI_RESULT_HANGUP;
1237                 default:
1238                         break;
1239                 }
1240         }
1241         ast_frfree(f);
1242
1243         return AGI_RESULT_SUCCESS;
1244 }
1245
1246 static enum agi_result launch_asyncagi(struct ast_channel *chan, char *argv[], int *efd)
1247 {
1248 /* This buffer sizes might cause truncation if the AGI command writes more data
1249    than AGI_BUF_SIZE as result. But let's be serious, is there an AGI command
1250    that writes a response larger than 1024 bytes?, I don't think so, most of
1251    them are just result=blah stuff. However probably if GET VARIABLE is called
1252    and the variable has large amount of data, that could be a problem. We could
1253    make this buffers dynamic, but let's leave that as a second step.
1254
1255    AMI_BUF_SIZE is twice AGI_BUF_SIZE just for the sake of choosing a safe
1256    number. Some characters of AGI buf will be url encoded to be sent to manager
1257    clients.  An URL encoded character will take 3 bytes, but again, to cause
1258    truncation more than about 70% of the AGI buffer should be URL encoded for
1259    that to happen.  Not likely at all.
1260
1261    On the other hand. I wonder if read() could eventually return less data than
1262    the amount already available in the pipe? If so, how to deal with that?
1263    So far, my tests on Linux have not had any problems.
1264  */
1265 #define AGI_BUF_SIZE 1024
1266 #define AMI_BUF_SIZE 2048
1267         enum agi_result cmd_status;
1268         struct agi_cmd *cmd;
1269         int res;
1270         int fds[2];
1271         int hungup;
1272         int timeout = 100;
1273         char agi_buffer[AGI_BUF_SIZE + 1];
1274         char ami_buffer[AMI_BUF_SIZE];
1275         enum agi_result returnstatus = AGI_RESULT_SUCCESS;
1276         AGI async_agi;
1277
1278         if (efd) {
1279                 ast_log(LOG_WARNING, "Async AGI does not support Enhanced AGI yet\n");
1280                 return AGI_RESULT_FAILURE;
1281         }
1282
1283         /* add AsyncAGI datastore to the channel */
1284         if (add_to_agi(chan)) {
1285                 ast_log(LOG_ERROR, "Failed to start Async AGI on channel %s\n", ast_channel_name(chan));
1286                 return AGI_RESULT_FAILURE;
1287         }
1288
1289         /* this pipe allows us to create a "fake" AGI struct to use
1290            the AGI commands */
1291         res = pipe(fds);
1292         if (res) {
1293                 ast_log(LOG_ERROR, "Failed to create Async AGI pipe\n");
1294                 /*
1295                  * Intentionally do not remove the datastore added with
1296                  * add_to_agi() the from channel.  It will be removed when the
1297                  * channel is hung up anyway.
1298                  */
1299                 return AGI_RESULT_FAILURE;
1300         }
1301
1302         /* handlers will get the pipe write fd and we read the AGI responses
1303            from the pipe read fd */
1304         async_agi.fd = fds[1];
1305         async_agi.ctrl = fds[1];
1306         async_agi.audio = -1; /* no audio support */
1307         async_agi.fast = 0;
1308         async_agi.speech = NULL;
1309
1310         /* notify possible manager users of a new channel ready to
1311            receive commands */
1312         setup_env(chan, "async", fds[1], 0, 0, NULL);
1313         /* read the environment */
1314         res = read(fds[0], agi_buffer, AGI_BUF_SIZE);
1315         if (res <= 0) {
1316                 ast_log(LOG_ERROR, "Failed to read from Async AGI pipe on channel %s: %s\n",
1317                                 ast_channel_name(chan), res < 0 ? strerror(errno) : "EOF");
1318                 returnstatus = AGI_RESULT_FAILURE;
1319                 goto async_agi_abort;
1320         }
1321         agi_buffer[res] = '\0';
1322         /* encode it and send it thru the manager so whoever is going to take
1323            care of AGI commands on this channel can decide which AGI commands
1324            to execute based on the setup info */
1325         ast_uri_encode(agi_buffer, ami_buffer, AMI_BUF_SIZE, ast_uri_http);
1326         manager_event(EVENT_FLAG_AGI, "AsyncAGI",
1327                 "SubEvent: Start\r\n"
1328                 "Channel: %s\r\n"
1329                 "Env: %s\r\n", ast_channel_name(chan), ami_buffer);
1330         hungup = ast_check_hangup(chan);
1331         for (;;) {
1332                 /*
1333                  * Process as many commands as we can.  Commands are added via
1334                  * the manager or the cli threads.
1335                  */
1336                 while (!hungup) {
1337                         res = get_agi_cmd(chan, &cmd);
1338
1339                         if (res) {
1340                                 returnstatus = AGI_RESULT_FAILURE;
1341                                 goto async_agi_done;
1342                         } else if (!cmd) {
1343                                 break;
1344                         }
1345
1346                         /* OK, we have a command, let's call the command handler. */
1347                         cmd_status = agi_handle_command(chan, &async_agi, cmd->cmd_buffer, 0);
1348
1349                         /*
1350                          * The command handler must have written to our fake AGI struct
1351                          * fd (the pipe), let's read the response.
1352                          */
1353                         res = read(fds[0], agi_buffer, AGI_BUF_SIZE);
1354                         if (res <= 0) {
1355                                 ast_log(LOG_ERROR, "Failed to read from Async AGI pipe on channel %s: %s\n",
1356                                         ast_channel_name(chan), res < 0 ? strerror(errno) : "EOF");
1357                                 free_agi_cmd(cmd);
1358                                 returnstatus = AGI_RESULT_FAILURE;
1359                                 goto async_agi_done;
1360                         }
1361                         /*
1362                          * We have a response, let's send the response thru the manager.
1363                          * Include the CommandID if it was specified when the command
1364                          * was added.
1365                          */
1366                         agi_buffer[res] = '\0';
1367                         ast_uri_encode(agi_buffer, ami_buffer, AMI_BUF_SIZE, ast_uri_http);
1368                         if (ast_strlen_zero(cmd->cmd_id)) {
1369                                 manager_event(EVENT_FLAG_AGI, "AsyncAGI",
1370                                         "SubEvent: Exec\r\n"
1371                                         "Channel: %s\r\n"
1372                                         "Result: %s\r\n", ast_channel_name(chan), ami_buffer);
1373                         } else {
1374                                 manager_event(EVENT_FLAG_AGI, "AsyncAGI",
1375                                         "SubEvent: Exec\r\n"
1376                                         "Channel: %s\r\n"
1377                                         "CommandID: %s\r\n"
1378                                         "Result: %s\r\n", ast_channel_name(chan), cmd->cmd_id, ami_buffer);
1379                         }
1380                         free_agi_cmd(cmd);
1381
1382                         /*
1383                          * Check the command status to determine if we should continue
1384                          * executing more commands.
1385                          */
1386                         hungup = ast_check_hangup(chan);
1387                         switch (cmd_status) {
1388                         case AGI_RESULT_FAILURE:
1389                                 if (!hungup) {
1390                                         /* The failure was not because of a hangup. */
1391                                         returnstatus = AGI_RESULT_FAILURE;
1392                                         goto async_agi_done;
1393                                 }
1394                                 break;
1395                         case AGI_RESULT_SUCCESS_ASYNC:
1396                                 /* Only the "asyncagi break" command does this. */
1397                                 returnstatus = AGI_RESULT_SUCCESS_ASYNC;
1398                                 goto async_agi_done;
1399                         default:
1400                                 break;
1401                         }
1402                 }
1403
1404                 if (!hungup) {
1405                         /* Wait a bit for a frame to read or to poll for a new command. */
1406                         res = ast_waitfor(chan, timeout);
1407                         if (res < 0) {
1408                                 ast_debug(1, "ast_waitfor returned <= 0 on chan %s\n", ast_channel_name(chan));
1409                                 returnstatus = AGI_RESULT_FAILURE;
1410                                 break;
1411                         }
1412                 } else {
1413                         /*
1414                          * Read the channel control queue until it is dry so we can
1415                          * quit.
1416                          */
1417                         res = 1;
1418                 }
1419                 if (0 < res) {
1420                         do {
1421                                 cmd_status = async_agi_read_frame(chan);
1422                                 if (cmd_status != AGI_RESULT_SUCCESS) {
1423                                         returnstatus = cmd_status;
1424                                         goto async_agi_done;
1425                                 }
1426                                 hungup = ast_check_hangup(chan);
1427                         } while (hungup);
1428                 } else {
1429                         hungup = ast_check_hangup(chan);
1430                 }
1431         }
1432 async_agi_done:
1433
1434         if (async_agi.speech) {
1435                 ast_speech_destroy(async_agi.speech);
1436         }
1437         /* notify manager users this channel cannot be
1438            controlled anymore by Async AGI */
1439         manager_event(EVENT_FLAG_AGI, "AsyncAGI",
1440                 "SubEvent: End\r\n"
1441                 "Channel: %s\r\n", ast_channel_name(chan));
1442
1443 async_agi_abort:
1444         /* close the pipe */
1445         close(fds[0]);
1446         close(fds[1]);
1447
1448         /*
1449          * Intentionally do not remove the datastore added with
1450          * add_to_agi() the from channel.  There might be commands still
1451          * in the queue or in-flight to us and AsyncAGI may get called
1452          * again.  The datastore destructor will be called on channel
1453          * destruction anyway.
1454          */
1455
1456         if (returnstatus == AGI_RESULT_SUCCESS) {
1457                 returnstatus = AGI_RESULT_SUCCESS_ASYNC;
1458         }
1459         return returnstatus;
1460
1461 #undef AGI_BUF_SIZE
1462 #undef AMI_BUF_SIZE
1463 }
1464
1465 /* launch_netscript: The fastagi handler.
1466         FastAGI defaults to port 4573 */
1467 static enum agi_result launch_netscript(char *agiurl, char *argv[], int *fds)
1468 {
1469         int s = 0, flags, res;
1470         struct pollfd pfds[1];
1471         char *host, *script;
1472         int num_addrs = 0, i = 0;
1473         struct ast_sockaddr *addrs;
1474
1475         /* agiurl is "agi://host.domain[:port][/script/name]" */
1476         host = ast_strdupa(agiurl + 6); /* Remove agi:// */
1477
1478         /* Strip off any script name */
1479         if ((script = strchr(host, '/'))) {
1480                 *script++ = '\0';
1481         } else {
1482                 script = "";
1483         }
1484
1485         if (!(num_addrs = ast_sockaddr_resolve(&addrs, host, 0, AST_AF_UNSPEC))) {
1486                 ast_log(LOG_WARNING, "Unable to locate host '%s'\n", host);
1487                 return AGI_RESULT_FAILURE;
1488         }
1489
1490         for (i = 0; i < num_addrs; i++) {
1491                 if (!ast_sockaddr_port(&addrs[i])) {
1492                         ast_sockaddr_set_port(&addrs[i], AGI_PORT);
1493                 }
1494
1495                 if ((s = socket(addrs[i].ss.ss_family, SOCK_STREAM, IPPROTO_TCP)) < 0) {
1496                         ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
1497                         continue;
1498                 }
1499
1500                 if ((flags = fcntl(s, F_GETFL)) < 0) {
1501                         ast_log(LOG_WARNING, "fcntl(F_GETFL) failed: %s\n", strerror(errno));
1502                         close(s);
1503                         continue;
1504                 }
1505
1506                 if (fcntl(s, F_SETFL, flags | O_NONBLOCK) < 0) {
1507                         ast_log(LOG_WARNING, "fnctl(F_SETFL) failed: %s\n", strerror(errno));
1508                         close(s);
1509                         continue;
1510                 }
1511
1512                 if (ast_connect(s, &addrs[i]) && (errno != EINPROGRESS)) {
1513                         ast_log(LOG_WARNING, "Connection to %s failed with unexpected error: %s\n",
1514                                 ast_sockaddr_stringify(&addrs[i]),
1515                                 strerror(errno));
1516                         close(s);
1517                         continue;
1518                 }
1519
1520                 break;
1521         }
1522
1523         ast_free(addrs);
1524
1525         if (i == num_addrs) {
1526                 ast_log(LOG_WARNING, "Couldn't connect to any host.  FastAGI failed.\n");
1527                 return AGI_RESULT_FAILURE;
1528         }
1529
1530         pfds[0].fd = s;
1531         pfds[0].events = POLLOUT;
1532         while ((res = ast_poll(pfds, 1, MAX_AGI_CONNECT)) != 1) {
1533                 if (errno != EINTR) {
1534                         if (!res) {
1535                                 ast_log(LOG_WARNING, "FastAGI connection to '%s' timed out after MAX_AGI_CONNECT (%d) milliseconds.\n",
1536                                         agiurl, MAX_AGI_CONNECT);
1537                         } else
1538                                 ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno));
1539                         close(s);
1540                         return AGI_RESULT_FAILURE;
1541                 }
1542         }
1543
1544         if (ast_agi_send(s, NULL, "agi_network: yes\n") < 0) {
1545                 if (errno != EINTR) {
1546                         ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno));
1547                         close(s);
1548                         return AGI_RESULT_FAILURE;
1549                 }
1550         }
1551
1552         /* If we have a script parameter, relay it to the fastagi server */
1553         /* Script parameters take the form of: AGI(agi://my.example.com/?extension=${EXTEN}) */
1554         if (!ast_strlen_zero(script))
1555                 ast_agi_send(s, NULL, "agi_network_script: %s\n", script);
1556
1557         ast_debug(4, "Wow, connected!\n");
1558         fds[0] = s;
1559         fds[1] = s;
1560         return AGI_RESULT_SUCCESS_FAST;
1561 }
1562
1563 /*!
1564  * \internal
1565  * \brief The HA fastagi handler.
1566  * \param agiurl The request URL as passed to Agi() in the dial plan
1567  * \param argv The parameters after the URL passed to Agi() in the dial plan
1568  * \param fds Input/output file descriptors
1569  *
1570  * Uses SRV lookups to try to connect to a list of FastAGI servers. The hostname in
1571  * the URI is prefixed with _agi._tcp. prior to the DNS resolution. For
1572  * example, if you specify the URI \a hagi://agi.example.com/foo.agi the DNS
1573  * query would be for \a _agi._tcp.agi.example.com and you'll need to make sure
1574  * this resolves.
1575  *
1576  * This function parses the URI, resolves the SRV service name, forms new URIs
1577  * with the results of the DNS lookup, and then calls launch_netscript on the
1578  * new URIs until one succeeds.
1579  *
1580  * \return the result of the AGI operation.
1581  */
1582 static enum agi_result launch_ha_netscript(char *agiurl, char *argv[], int *fds)
1583 {
1584         char *host, *script;
1585         enum agi_result result;
1586         struct srv_context *context = NULL;
1587         int srv_ret;
1588         char service[256];
1589         char resolved_uri[1024];
1590         const char *srvhost;
1591         unsigned short srvport;
1592
1593         /* format of agiurl is "hagi://host.domain[:port][/script/name]" */
1594         if (strlen(agiurl) < 7) { /* Remove hagi:// */
1595                 ast_log(LOG_WARNING, "An error occurred parsing the AGI URI: %s", agiurl);
1596                 return AGI_RESULT_FAILURE;
1597         }
1598         host = ast_strdupa(agiurl + 7);
1599
1600         /* Strip off any script name */
1601         if ((script = strchr(host, '/'))) {
1602                 *script++ = '\0';
1603         } else {
1604                 script = "";
1605         }
1606
1607         if (strchr(host, ':')) {
1608                 ast_log(LOG_WARNING, "Specifying a port number disables SRV lookups: %s\n", agiurl);
1609                 return launch_netscript(agiurl + 1, argv, fds); /* +1 to strip off leading h from hagi:// */
1610         }
1611
1612         snprintf(service, sizeof(service), "%s%s", SRV_PREFIX, host);
1613
1614         while (!(srv_ret = ast_srv_lookup(&context, service, &srvhost, &srvport))) {
1615                 snprintf(resolved_uri, sizeof(resolved_uri), "agi://%s:%d/%s", srvhost, srvport, script);
1616                 result = launch_netscript(resolved_uri, argv, fds);
1617                 if (result == AGI_RESULT_FAILURE || result == AGI_RESULT_NOTFOUND) {
1618                         ast_log(LOG_WARNING, "AGI request failed for host '%s' (%s:%d)\n", host, srvhost, srvport);
1619                 } else {
1620                         /* The script launched so we must cleanup the context. */
1621                         ast_srv_cleanup(&context);
1622                         return result;
1623                 }
1624         }
1625         /*
1626          * The DNS SRV lookup failed or we ran out of servers to check.
1627          * ast_srv_lookup() has already cleaned up the context for us.
1628          */
1629         if (srv_ret < 0) {
1630                 ast_log(LOG_WARNING, "SRV lookup failed for %s\n", agiurl);
1631         }
1632
1633         return AGI_RESULT_FAILURE;
1634 }
1635
1636 static enum agi_result launch_script(struct ast_channel *chan, char *script, char *argv[], int *fds, int *efd, int *opid)
1637 {
1638         char tmp[256];
1639         int pid, toast[2], fromast[2], audio[2], res;
1640         struct stat st;
1641
1642         if (!strncasecmp(script, "agi://", 6)) {
1643                 return (efd == NULL) ? launch_netscript(script, argv, fds) : AGI_RESULT_FAILURE;
1644         }
1645         if (!strncasecmp(script, "hagi://", 7)) {
1646                 return (efd == NULL) ? launch_ha_netscript(script, argv, fds) : AGI_RESULT_FAILURE;
1647         }
1648         if (!strncasecmp(script, "agi:async", sizeof("agi:async") - 1)) {
1649                 return launch_asyncagi(chan, argv, efd);
1650         }
1651
1652         if (script[0] != '/') {
1653                 snprintf(tmp, sizeof(tmp), "%s/%s", ast_config_AST_AGI_DIR, script);
1654                 script = tmp;
1655         }
1656
1657         /* Before even trying let's see if the file actually exists */
1658         if (stat(script, &st)) {
1659                 ast_log(LOG_WARNING, "Failed to execute '%s': File does not exist.\n", script);
1660                 return AGI_RESULT_NOTFOUND;
1661         }
1662
1663         if (pipe(toast)) {
1664                 ast_log(LOG_WARNING, "Unable to create toast pipe: %s\n",strerror(errno));
1665                 return AGI_RESULT_FAILURE;
1666         }
1667         if (pipe(fromast)) {
1668                 ast_log(LOG_WARNING, "unable to create fromast pipe: %s\n", strerror(errno));
1669                 close(toast[0]);
1670                 close(toast[1]);
1671                 return AGI_RESULT_FAILURE;
1672         }
1673         if (efd) {
1674                 if (pipe(audio)) {
1675                         ast_log(LOG_WARNING, "unable to create audio pipe: %s\n", strerror(errno));
1676                         close(fromast[0]);
1677                         close(fromast[1]);
1678                         close(toast[0]);
1679                         close(toast[1]);
1680                         return AGI_RESULT_FAILURE;
1681                 }
1682                 res = fcntl(audio[1], F_GETFL);
1683                 if (res > -1)
1684                         res = fcntl(audio[1], F_SETFL, res | O_NONBLOCK);
1685                 if (res < 0) {
1686                         ast_log(LOG_WARNING, "unable to set audio pipe parameters: %s\n", strerror(errno));
1687                         close(fromast[0]);
1688                         close(fromast[1]);
1689                         close(toast[0]);
1690                         close(toast[1]);
1691                         close(audio[0]);
1692                         close(audio[1]);
1693                         return AGI_RESULT_FAILURE;
1694                 }
1695         }
1696
1697         if ((pid = ast_safe_fork(1)) < 0) {
1698                 ast_log(LOG_WARNING, "Failed to fork(): %s\n", strerror(errno));
1699                 return AGI_RESULT_FAILURE;
1700         }
1701         if (!pid) {
1702                 /* Pass paths to AGI via environmental variables */
1703                 setenv("AST_CONFIG_DIR", ast_config_AST_CONFIG_DIR, 1);
1704                 setenv("AST_CONFIG_FILE", ast_config_AST_CONFIG_FILE, 1);
1705                 setenv("AST_MODULE_DIR", ast_config_AST_MODULE_DIR, 1);
1706                 setenv("AST_SPOOL_DIR", ast_config_AST_SPOOL_DIR, 1);
1707                 setenv("AST_MONITOR_DIR", ast_config_AST_MONITOR_DIR, 1);
1708                 setenv("AST_VAR_DIR", ast_config_AST_VAR_DIR, 1);
1709                 setenv("AST_DATA_DIR", ast_config_AST_DATA_DIR, 1);
1710                 setenv("AST_LOG_DIR", ast_config_AST_LOG_DIR, 1);
1711                 setenv("AST_AGI_DIR", ast_config_AST_AGI_DIR, 1);
1712                 setenv("AST_KEY_DIR", ast_config_AST_KEY_DIR, 1);
1713                 setenv("AST_RUN_DIR", ast_config_AST_RUN_DIR, 1);
1714
1715                 /* Don't run AGI scripts with realtime priority -- it causes audio stutter */
1716                 ast_set_priority(0);
1717
1718                 /* Redirect stdin and out, provide enhanced audio channel if desired */
1719                 dup2(fromast[0], STDIN_FILENO);
1720                 dup2(toast[1], STDOUT_FILENO);
1721                 if (efd)
1722                         dup2(audio[0], STDERR_FILENO + 1);
1723                 else
1724                         close(STDERR_FILENO + 1);
1725
1726                 /* Close everything but stdin/out/error */
1727                 ast_close_fds_above_n(STDERR_FILENO + 1);
1728
1729                 /* Execute script */
1730                 /* XXX argv should be deprecated in favor of passing agi_argX paramaters */
1731                 execv(script, argv);
1732                 /* Can't use ast_log since FD's are closed */
1733                 ast_child_verbose(1, "Failed to execute '%s': %s", script, strerror(errno));
1734                 /* Special case to set status of AGI to failure */
1735                 fprintf(stdout, "failure\n");
1736                 fflush(stdout);
1737                 _exit(1);
1738         }
1739         ast_verb(3, "Launched AGI Script %s\n", script);
1740         fds[0] = toast[0];
1741         fds[1] = fromast[1];
1742         if (efd)
1743                 *efd = audio[1];
1744         /* close what we're not using in the parent */
1745         close(toast[1]);
1746         close(fromast[0]);
1747
1748         if (efd)
1749                 close(audio[0]);
1750
1751         *opid = pid;
1752         return AGI_RESULT_SUCCESS;
1753 }
1754
1755 static void setup_env(struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[])
1756 {
1757         int count;
1758
1759         /* Print initial environment, with agi_request always being the first
1760            thing */
1761         ast_agi_send(fd, chan, "agi_request: %s\n", request);
1762         ast_agi_send(fd, chan, "agi_channel: %s\n", ast_channel_name(chan));
1763         ast_agi_send(fd, chan, "agi_language: %s\n", ast_channel_language(chan));
1764         ast_agi_send(fd, chan, "agi_type: %s\n", ast_channel_tech(chan)->type);
1765         ast_agi_send(fd, chan, "agi_uniqueid: %s\n", ast_channel_uniqueid(chan));
1766         ast_agi_send(fd, chan, "agi_version: %s\n", ast_get_version());
1767
1768         /* ANI/DNIS */
1769         ast_agi_send(fd, chan, "agi_callerid: %s\n",
1770                 S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, "unknown"));
1771         ast_agi_send(fd, chan, "agi_calleridname: %s\n",
1772                 S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, "unknown"));
1773         ast_agi_send(fd, chan, "agi_callingpres: %d\n",
1774                 ast_party_id_presentation(&ast_channel_caller(chan)->id));
1775         ast_agi_send(fd, chan, "agi_callingani2: %d\n", ast_channel_caller(chan)->ani2);
1776         ast_agi_send(fd, chan, "agi_callington: %d\n", ast_channel_caller(chan)->id.number.plan);
1777         ast_agi_send(fd, chan, "agi_callingtns: %d\n", ast_channel_dialed(chan)->transit_network_select);
1778         ast_agi_send(fd, chan, "agi_dnid: %s\n", S_OR(ast_channel_dialed(chan)->number.str, "unknown"));
1779         ast_agi_send(fd, chan, "agi_rdnis: %s\n",
1780                 S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, "unknown"));
1781
1782         /* Context information */
1783         ast_agi_send(fd, chan, "agi_context: %s\n", ast_channel_context(chan));
1784         ast_agi_send(fd, chan, "agi_extension: %s\n", ast_channel_exten(chan));
1785         ast_agi_send(fd, chan, "agi_priority: %d\n", ast_channel_priority(chan));
1786         ast_agi_send(fd, chan, "agi_enhanced: %s\n", enhanced ? "1.0" : "0.0");
1787
1788         /* User information */
1789         ast_agi_send(fd, chan, "agi_accountcode: %s\n", ast_channel_accountcode(chan) ? ast_channel_accountcode(chan) : "");
1790         ast_agi_send(fd, chan, "agi_threadid: %ld\n", (long)pthread_self());
1791
1792         /* Send any parameters to the fastagi server that have been passed via the agi application */
1793         /* Agi application paramaters take the form of: AGI(/path/to/example/script|${EXTEN}) */
1794         for(count = 1; count < argc; count++)
1795                 ast_agi_send(fd, chan, "agi_arg_%d: %s\n", count, argv[count]);
1796
1797         /* End with empty return */
1798         ast_agi_send(fd, chan, "\n");
1799 }
1800
1801 static int handle_answer(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1802 {
1803         int res = 0;
1804
1805         /* Answer the channel */
1806         if (ast_channel_state(chan) != AST_STATE_UP)
1807                 res = ast_answer(chan);
1808
1809         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1810         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
1811 }
1812
1813 static int handle_asyncagi_break(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1814 {
1815         ast_agi_send(agi->fd, chan, "200 result=0\n");
1816         return ASYNC_AGI_BREAK;
1817 }
1818
1819 static int handle_waitfordigit(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1820 {
1821         int res, to;
1822
1823         if (argc != 4)
1824                 return RESULT_SHOWUSAGE;
1825         if (sscanf(argv[3], "%30d", &to) != 1)
1826                 return RESULT_SHOWUSAGE;
1827         res = ast_waitfordigit_full(chan, to, agi->audio, agi->ctrl);
1828         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1829         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
1830 }
1831
1832 static int handle_sendtext(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1833 {
1834         int res;
1835
1836         if (argc != 3)
1837                 return RESULT_SHOWUSAGE;
1838
1839         /* At the moment, the parser (perhaps broken) returns with
1840            the last argument PLUS the newline at the end of the input
1841            buffer. This probably needs to be fixed, but I wont do that
1842            because other stuff may break as a result. The right way
1843            would probably be to strip off the trailing newline before
1844            parsing, then here, add a newline at the end of the string
1845            before sending it to ast_sendtext --DUDE */
1846         res = ast_sendtext(chan, argv[2]);
1847         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1848         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
1849 }
1850
1851 static int handle_recvchar(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1852 {
1853         int res;
1854
1855         if (argc != 3)
1856                 return RESULT_SHOWUSAGE;
1857
1858         res = ast_recvchar(chan,atoi(argv[2]));
1859         if (res == 0) {
1860                 ast_agi_send(agi->fd, chan, "200 result=%d (timeout)\n", res);
1861                 return RESULT_SUCCESS;
1862         }
1863         if (res > 0) {
1864                 ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1865                 return RESULT_SUCCESS;
1866         }
1867         ast_agi_send(agi->fd, chan, "200 result=%d (hangup)\n", res);
1868         return RESULT_FAILURE;
1869 }
1870
1871 static int handle_recvtext(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1872 {
1873         char *buf;
1874
1875         if (argc != 3)
1876                 return RESULT_SHOWUSAGE;
1877
1878         buf = ast_recvtext(chan, atoi(argv[2]));
1879         if (buf) {
1880                 ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", buf);
1881                 ast_free(buf);
1882         } else {
1883                 ast_agi_send(agi->fd, chan, "200 result=-1\n");
1884         }
1885         return RESULT_SUCCESS;
1886 }
1887
1888 static int handle_tddmode(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1889 {
1890         int res, x;
1891
1892         if (argc != 3)
1893                 return RESULT_SHOWUSAGE;
1894
1895         if (!strncasecmp(argv[2],"on",2)) {
1896                 x = 1;
1897         } else  {
1898                 x = 0;
1899         }
1900         if (!strncasecmp(argv[2],"mate",4))  {
1901                 x = 2;
1902         }
1903         if (!strncasecmp(argv[2],"tdd",3)) {
1904                 x = 1;
1905         }
1906         res = ast_channel_setoption(chan, AST_OPTION_TDD, &x, sizeof(char), 0);
1907         if (res) {
1908                 /* Set channel option failed */
1909                 ast_agi_send(agi->fd, chan, "200 result=0\n");
1910         } else {
1911                 ast_agi_send(agi->fd, chan, "200 result=1\n");
1912         }
1913         return RESULT_SUCCESS;
1914 }
1915
1916 static int handle_sendimage(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1917 {
1918         int res;
1919
1920         if (argc != 3) {
1921                 return RESULT_SHOWUSAGE;
1922         }
1923
1924         res = ast_send_image(chan, argv[2]);
1925         if (!ast_check_hangup(chan)) {
1926                 res = 0;
1927         }
1928         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1929         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
1930 }
1931
1932 static int handle_controlstreamfile(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1933 {
1934         int res = 0, skipms = 3000;
1935         const char *fwd = "#", *rev = "*", *suspend = NULL, *stop = NULL;       /* Default values */
1936
1937         if (argc < 5 || argc > 9) {
1938                 return RESULT_SHOWUSAGE;
1939         }
1940
1941         if (!ast_strlen_zero(argv[4])) {
1942                 stop = argv[4];
1943         }
1944
1945         if ((argc > 5) && (sscanf(argv[5], "%30d", &skipms) != 1)) {
1946                 return RESULT_SHOWUSAGE;
1947         }
1948
1949         if (argc > 6 && !ast_strlen_zero(argv[6])) {
1950                 fwd = argv[6];
1951         }
1952
1953         if (argc > 7 && !ast_strlen_zero(argv[7])) {
1954                 rev = argv[7];
1955         }
1956
1957         if (argc > 8 && !ast_strlen_zero(argv[8])) {
1958                 suspend = argv[8];
1959         }
1960
1961         res = ast_control_streamfile(chan, argv[3], fwd, rev, stop, suspend, NULL, skipms, NULL);
1962
1963         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
1964
1965         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
1966 }
1967
1968 static int handle_streamfile(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
1969 {
1970         int res;
1971         struct ast_filestream *fs, *vfs;
1972         long sample_offset = 0, max_length;
1973         const char *edigits = "";
1974
1975         if (argc < 4 || argc > 5) {
1976                 return RESULT_SHOWUSAGE;
1977         }
1978
1979         if (argv[3]) {
1980                 edigits = argv[3];
1981         }
1982
1983         if ((argc > 4) && (sscanf(argv[4], "%30ld", &sample_offset) != 1)) {
1984                 return RESULT_SHOWUSAGE;
1985         }
1986
1987         if (!(fs = ast_openstream(chan, argv[2], ast_channel_language(chan)))) {
1988                 ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", 0, sample_offset);
1989                 return RESULT_SUCCESS;
1990         }
1991
1992         if ((vfs = ast_openvstream(chan, argv[2], ast_channel_language(chan)))) {
1993                 ast_debug(1, "Ooh, found a video stream, too\n");
1994         }
1995
1996         ast_verb(3, "Playing '%s' (escape_digits=%s) (sample_offset %ld)\n", argv[2], edigits, sample_offset);
1997
1998         ast_seekstream(fs, 0, SEEK_END);
1999         max_length = ast_tellstream(fs);
2000         ast_seekstream(fs, sample_offset, SEEK_SET);
2001         res = ast_applystream(chan, fs);
2002         if (vfs) {
2003                 ast_applystream(chan, vfs);
2004         }
2005         ast_playstream(fs);
2006         if (vfs) {
2007                 ast_playstream(vfs);
2008         }
2009
2010         res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl);
2011         /* this is to check for if ast_waitstream closed the stream, we probably are at
2012          * the end of the stream, return that amount, else check for the amount */
2013         sample_offset = (ast_channel_stream(chan)) ? ast_tellstream(fs) : max_length;
2014         ast_stopstream(chan);
2015         if (res == 1) {
2016                 /* Stop this command, don't print a result line, as there is a new command */
2017                 return RESULT_SUCCESS;
2018         }
2019         ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", res, sample_offset);
2020         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2021 }
2022
2023 /*! \brief get option - really similar to the handle_streamfile, but with a timeout */
2024 static int handle_getoption(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2025 {
2026         int res;
2027         struct ast_filestream *fs, *vfs;
2028         long sample_offset = 0, max_length;
2029         int timeout = 0;
2030         const char *edigits = "";
2031
2032         if ( argc < 4 || argc > 5 )
2033                 return RESULT_SHOWUSAGE;
2034
2035         if ( argv[3] )
2036                 edigits = argv[3];
2037
2038         if ( argc == 5 )
2039                 timeout = atoi(argv[4]);
2040         else if (ast_channel_pbx(chan)->dtimeoutms) {
2041                 /* by default dtimeout is set to 5sec */
2042                 timeout = ast_channel_pbx(chan)->dtimeoutms; /* in msec */
2043         }
2044
2045         if (!(fs = ast_openstream(chan, argv[2], ast_channel_language(chan)))) {
2046                 ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", 0, sample_offset);
2047                 ast_log(LOG_WARNING, "Unable to open %s\n", argv[2]);
2048                 return RESULT_SUCCESS;
2049         }
2050
2051         if ((vfs = ast_openvstream(chan, argv[2], ast_channel_language(chan))))
2052                 ast_debug(1, "Ooh, found a video stream, too\n");
2053
2054         ast_verb(3, "Playing '%s' (escape_digits=%s) (timeout %d)\n", argv[2], edigits, timeout);
2055
2056         ast_seekstream(fs, 0, SEEK_END);
2057         max_length = ast_tellstream(fs);
2058         ast_seekstream(fs, sample_offset, SEEK_SET);
2059         res = ast_applystream(chan, fs);
2060         if (vfs)
2061                 ast_applystream(chan, vfs);
2062         ast_playstream(fs);
2063         if (vfs)
2064                 ast_playstream(vfs);
2065
2066         res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl);
2067         /* this is to check for if ast_waitstream closed the stream, we probably are at
2068          * the end of the stream, return that amount, else check for the amount */
2069         sample_offset = (ast_channel_stream(chan))?ast_tellstream(fs):max_length;
2070         ast_stopstream(chan);
2071         if (res == 1) {
2072                 /* Stop this command, don't print a result line, as there is a new command */
2073                 return RESULT_SUCCESS;
2074         }
2075
2076         /* If the user didnt press a key, wait for digitTimeout*/
2077         if (res == 0 ) {
2078                 res = ast_waitfordigit_full(chan, timeout, agi->audio, agi->ctrl);
2079                 /* Make sure the new result is in the escape digits of the GET OPTION */
2080                 if ( !strchr(edigits,res) )
2081                         res=0;
2082         }
2083
2084         ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", res, sample_offset);
2085         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2086 }
2087
2088
2089
2090
2091 /*! \brief Say number in various language syntaxes */
2092 /* While waiting, we're sending a NULL.  */
2093 static int handle_saynumber(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2094 {
2095         int res, num;
2096
2097         if (argc < 4 || argc > 5)
2098                 return RESULT_SHOWUSAGE;
2099         if (sscanf(argv[2], "%30d", &num) != 1)
2100                 return RESULT_SHOWUSAGE;
2101         res = ast_say_number_full(chan, num, argv[3], ast_channel_language(chan), argc > 4 ? argv[4] : NULL, agi->audio, agi->ctrl);
2102         if (res == 1)
2103                 return RESULT_SUCCESS;
2104         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2105         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2106 }
2107
2108 static int handle_saydigits(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2109 {
2110         int res, num;
2111
2112         if (argc != 4)
2113                 return RESULT_SHOWUSAGE;
2114         if (sscanf(argv[2], "%30d", &num) != 1)
2115                 return RESULT_SHOWUSAGE;
2116
2117         res = ast_say_digit_str_full(chan, argv[2], argv[3], ast_channel_language(chan), agi->audio, agi->ctrl);
2118         if (res == 1) /* New command */
2119                 return RESULT_SUCCESS;
2120         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2121         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2122 }
2123
2124 static int handle_sayalpha(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2125 {
2126         int res;
2127
2128         if (argc != 4)
2129                 return RESULT_SHOWUSAGE;
2130
2131         res = ast_say_character_str_full(chan, argv[2], argv[3], ast_channel_language(chan), agi->audio, agi->ctrl);
2132         if (res == 1) /* New command */
2133                 return RESULT_SUCCESS;
2134         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2135         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2136 }
2137
2138 static int handle_saydate(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2139 {
2140         int res, num;
2141
2142         if (argc != 4)
2143                 return RESULT_SHOWUSAGE;
2144         if (sscanf(argv[2], "%30d", &num) != 1)
2145                 return RESULT_SHOWUSAGE;
2146         res = ast_say_date(chan, num, argv[3], ast_channel_language(chan));
2147         if (res == 1)
2148                 return RESULT_SUCCESS;
2149         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2150         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2151 }
2152
2153 static int handle_saytime(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2154 {
2155         int res, num;
2156
2157         if (argc != 4)
2158                 return RESULT_SHOWUSAGE;
2159         if (sscanf(argv[2], "%30d", &num) != 1)
2160                 return RESULT_SHOWUSAGE;
2161         res = ast_say_time(chan, num, argv[3], ast_channel_language(chan));
2162         if (res == 1)
2163                 return RESULT_SUCCESS;
2164         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2165         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2166 }
2167
2168 static int handle_saydatetime(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2169 {
2170         int res = 0;
2171         time_t unixtime;
2172         const char *format, *zone = NULL;
2173
2174         if (argc < 4)
2175                 return RESULT_SHOWUSAGE;
2176
2177         if (argc > 4) {
2178                 format = argv[4];
2179         } else {
2180                 /* XXX this doesn't belong here, but in the 'say' module */
2181                 if (!strcasecmp(ast_channel_language(chan), "de")) {
2182                         format = "A dBY HMS";
2183                 } else {
2184                         format = "ABdY 'digits/at' IMp";
2185                 }
2186         }
2187
2188         if (argc > 5 && !ast_strlen_zero(argv[5]))
2189                 zone = argv[5];
2190
2191         if (ast_get_time_t(argv[2], &unixtime, 0, NULL))
2192                 return RESULT_SHOWUSAGE;
2193
2194         res = ast_say_date_with_format(chan, unixtime, argv[3], ast_channel_language(chan), format, zone);
2195         if (res == 1)
2196                 return RESULT_SUCCESS;
2197
2198         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2199         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2200 }
2201
2202 static int handle_sayphonetic(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2203 {
2204         int res;
2205
2206         if (argc != 4)
2207                 return RESULT_SHOWUSAGE;
2208
2209         res = ast_say_phonetic_str_full(chan, argv[2], argv[3], ast_channel_language(chan), agi->audio, agi->ctrl);
2210         if (res == 1) /* New command */
2211                 return RESULT_SUCCESS;
2212         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2213         return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
2214 }
2215
2216 static int handle_getdata(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2217 {
2218         int res, max, timeout;
2219         char data[1024];
2220
2221         if (argc < 3)
2222                 return RESULT_SHOWUSAGE;
2223         if (argc >= 4)
2224                 timeout = atoi(argv[3]);
2225         else
2226                 timeout = 0;
2227         if (argc >= 5)
2228                 max = atoi(argv[4]);
2229         else
2230                 max = 1024;
2231         res = ast_app_getdata_full(chan, argv[2], data, max, timeout, agi->audio, agi->ctrl);
2232         if (res == 2)                   /* New command */
2233                 return RESULT_SUCCESS;
2234         else if (res == 1)
2235                 ast_agi_send(agi->fd, chan, "200 result=%s (timeout)\n", data);
2236         else if (res < 0 )
2237                 ast_agi_send(agi->fd, chan, "200 result=-1\n");
2238         else
2239                 ast_agi_send(agi->fd, chan, "200 result=%s\n", data);
2240         return RESULT_SUCCESS;
2241 }
2242
2243 static int handle_setcontext(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2244 {
2245
2246         if (argc != 3)
2247                 return RESULT_SHOWUSAGE;
2248         ast_channel_context_set(chan, argv[2]);
2249         ast_agi_send(agi->fd, chan, "200 result=0\n");
2250         return RESULT_SUCCESS;
2251 }
2252
2253 static int handle_setextension(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2254 {
2255         if (argc != 3)
2256                 return RESULT_SHOWUSAGE;
2257         ast_channel_exten_set(chan, argv[2]);
2258         ast_agi_send(agi->fd, chan, "200 result=0\n");
2259         return RESULT_SUCCESS;
2260 }
2261
2262 static int handle_setpriority(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2263 {
2264         int pri;
2265
2266         if (argc != 3)
2267                 return RESULT_SHOWUSAGE;
2268
2269         if (sscanf(argv[2], "%30d", &pri) != 1) {
2270                 pri = ast_findlabel_extension(chan, ast_channel_context(chan), ast_channel_exten(chan), argv[2],
2271                         S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL));
2272                 if (pri < 1)
2273                         return RESULT_SHOWUSAGE;
2274         }
2275
2276         ast_explicit_goto(chan, NULL, NULL, pri);
2277         ast_agi_send(agi->fd, chan, "200 result=0\n");
2278         return RESULT_SUCCESS;
2279 }
2280
2281 static int handle_recordfile(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2282 {
2283         struct ast_filestream *fs;
2284         struct ast_frame *f;
2285         struct timeval start;
2286         long sample_offset = 0;
2287         int res = 0;
2288         int ms;
2289
2290         struct ast_dsp *sildet=NULL;         /* silence detector dsp */
2291         int totalsilence = 0;
2292         int dspsilence = 0;
2293         int silence = 0;                /* amount of silence to allow */
2294         int gotsilence = 0;             /* did we timeout for silence? */
2295         char *silencestr = NULL;
2296         struct ast_format rfmt;
2297         ast_format_clear(&rfmt);
2298
2299         /* XXX EAGI FIXME XXX */
2300
2301         if (argc < 6)
2302                 return RESULT_SHOWUSAGE;
2303         if (sscanf(argv[5], "%30d", &ms) != 1)
2304                 return RESULT_SHOWUSAGE;
2305
2306         if (argc > 6)
2307                 silencestr = strchr(argv[6],'s');
2308         if ((argc > 7) && (!silencestr))
2309                 silencestr = strchr(argv[7],'s');
2310         if ((argc > 8) && (!silencestr))
2311                 silencestr = strchr(argv[8],'s');
2312
2313         if (silencestr) {
2314                 if (strlen(silencestr) > 2) {
2315                         if ((silencestr[0] == 's') && (silencestr[1] == '=')) {
2316                                 silencestr++;
2317                                 silencestr++;
2318                                 if (silencestr)
2319                                         silence = atoi(silencestr);
2320                                 if (silence > 0)
2321                                         silence *= 1000;
2322                         }
2323                 }
2324         }
2325
2326         if (silence > 0) {
2327                 ast_format_copy(&rfmt, ast_channel_readformat(chan));
2328                 res = ast_set_read_format_by_id(chan, AST_FORMAT_SLINEAR);
2329                 if (res < 0) {
2330                         ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
2331                         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2332                         return RESULT_FAILURE;
2333                 }
2334                 sildet = ast_dsp_new();
2335                 if (!sildet) {
2336                         ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
2337                         ast_agi_send(agi->fd, chan, "200 result=-1\n");
2338                         return RESULT_FAILURE;
2339                 }
2340                 ast_dsp_set_threshold(sildet, ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE));
2341         }
2342         
2343         /* backward compatibility, if no offset given, arg[6] would have been
2344          * caught below and taken to be a beep, else if it is a digit then it is a
2345          * offset */
2346         if ((argc >6) && (sscanf(argv[6], "%30ld", &sample_offset) != 1) && (!strchr(argv[6], '=')))
2347                 res = ast_streamfile(chan, "beep", ast_channel_language(chan));
2348
2349         if ((argc > 7) && (!strchr(argv[7], '=')))
2350                 res = ast_streamfile(chan, "beep", ast_channel_language(chan));
2351
2352         if (!res)
2353                 res = ast_waitstream(chan, argv[4]);
2354         if (res) {
2355                 ast_agi_send(agi->fd, chan, "200 result=%d (randomerror) endpos=%ld\n", res, sample_offset);
2356         } else {
2357                 fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_WRONLY | (sample_offset ? O_APPEND : 0), 0, AST_FILE_MODE);
2358                 if (!fs) {
2359                         res = -1;
2360                         ast_agi_send(agi->fd, chan, "200 result=%d (writefile)\n", res);
2361                         if (sildet)
2362                                 ast_dsp_free(sildet);
2363                         return RESULT_FAILURE;
2364                 }
2365
2366                 /* Request a video update */
2367                 ast_indicate(chan, AST_CONTROL_VIDUPDATE);
2368
2369                 ast_channel_stream_set(chan, fs);
2370                 ast_applystream(chan,fs);
2371                 /* really should have checks */
2372                 ast_seekstream(fs, sample_offset, SEEK_SET);
2373                 ast_truncstream(fs);
2374
2375                 start = ast_tvnow();
2376                 while ((ms < 0) || ast_tvdiff_ms(ast_tvnow(), start) < ms) {
2377                         res = ast_waitfor(chan, ms - ast_tvdiff_ms(ast_tvnow(), start));
2378                         if (res < 0) {
2379                                 ast_closestream(fs);
2380                                 ast_agi_send(agi->fd, chan, "200 result=%d (waitfor) endpos=%ld\n", res,sample_offset);
2381                                 if (sildet)
2382                                         ast_dsp_free(sildet);
2383                                 return RESULT_FAILURE;
2384                         }
2385                         f = ast_read(chan);
2386                         if (!f) {
2387                                 ast_agi_send(agi->fd, chan, "200 result=%d (hangup) endpos=%ld\n", -1, sample_offset);
2388                                 ast_closestream(fs);
2389                                 if (sildet)
2390                                         ast_dsp_free(sildet);
2391                                 return RESULT_FAILURE;
2392                         }
2393                         switch(f->frametype) {
2394                         case AST_FRAME_DTMF:
2395                                 if (strchr(argv[4], f->subclass.integer)) {
2396                                         /* This is an interrupting chracter, so rewind to chop off any small
2397                                            amount of DTMF that may have been recorded
2398                                         */
2399                                         ast_stream_rewind(fs, 200);
2400                                         ast_truncstream(fs);
2401                                         sample_offset = ast_tellstream(fs);
2402                                         ast_agi_send(agi->fd, chan, "200 result=%d (dtmf) endpos=%ld\n", f->subclass.integer, sample_offset);
2403                                         ast_closestream(fs);
2404                                         ast_frfree(f);
2405                                         if (sildet)
2406                                                 ast_dsp_free(sildet);
2407                                         return RESULT_SUCCESS;
2408                                 }
2409                                 break;
2410                         case AST_FRAME_VOICE:
2411                                 ast_writestream(fs, f);
2412                                 /* this is a safe place to check progress since we know that fs
2413                                  * is valid after a write, and it will then have our current
2414                                  * location */
2415                                 sample_offset = ast_tellstream(fs);
2416                                 if (silence > 0) {
2417                                         dspsilence = 0;
2418                                         ast_dsp_silence(sildet, f, &dspsilence);
2419                                         if (dspsilence) {
2420                                                 totalsilence = dspsilence;
2421                                         } else {
2422                                                 totalsilence = 0;
2423                                         }
2424                                         if (totalsilence > silence) {
2425                                                 /* Ended happily with silence */
2426                                                 gotsilence = 1;
2427                                                 break;
2428                                         }
2429                                 }
2430                                 break;
2431                         case AST_FRAME_VIDEO:
2432                                 ast_writestream(fs, f);
2433                         default:
2434                                 /* Ignore all other frames */
2435                                 break;
2436                         }
2437                         ast_frfree(f);
2438                         if (gotsilence)
2439                                 break;
2440                 }
2441
2442                 if (gotsilence) {
2443                         ast_stream_rewind(fs, silence-1000);
2444                         ast_truncstream(fs);
2445                         sample_offset = ast_tellstream(fs);
2446                 }
2447                 ast_agi_send(agi->fd, chan, "200 result=%d (timeout) endpos=%ld\n", res, sample_offset);
2448                 ast_closestream(fs);
2449         }
2450
2451         if (silence > 0) {
2452                 res = ast_set_read_format(chan, &rfmt);
2453                 if (res)
2454                         ast_log(LOG_WARNING, "Unable to restore read format on '%s'\n", ast_channel_name(chan));
2455                 ast_dsp_free(sildet);
2456         }
2457
2458         return RESULT_SUCCESS;
2459 }
2460
2461 static int handle_autohangup(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2462 {
2463         double timeout;
2464         struct timeval whentohangup = { 0, 0 };
2465
2466         if (argc != 3)
2467                 return RESULT_SHOWUSAGE;
2468         if (sscanf(argv[2], "%30lf", &timeout) != 1)
2469                 return RESULT_SHOWUSAGE;
2470         if (timeout < 0)
2471                 timeout = 0;
2472         if (timeout) {
2473                 whentohangup.tv_sec = timeout;
2474                 whentohangup.tv_usec = (timeout - whentohangup.tv_sec) * 1000000.0;
2475         }
2476         ast_channel_setwhentohangup_tv(chan, whentohangup);
2477         ast_agi_send(agi->fd, chan, "200 result=0\n");
2478         return RESULT_SUCCESS;
2479 }
2480
2481 static int handle_hangup(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2482 {
2483         struct ast_channel *c;
2484
2485         if (argc == 1) {
2486                 /* no argument: hangup the current channel */
2487                 ast_set_hangupsource(chan, "dialplan/agi", 0);
2488                 ast_softhangup(chan,AST_SOFTHANGUP_EXPLICIT);
2489                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2490                 return RESULT_SUCCESS;
2491         } else if (argc == 2) {
2492                 /* one argument: look for info on the specified channel */
2493                 if ((c = ast_channel_get_by_name(argv[1]))) {
2494                         /* we have a matching channel */
2495                         ast_set_hangupsource(c, "dialplan/agi", 0);
2496                         ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
2497                         c = ast_channel_unref(c);
2498                         ast_agi_send(agi->fd, chan, "200 result=1\n");
2499                         return RESULT_SUCCESS;
2500                 }
2501                 /* if we get this far no channel name matched the argument given */
2502                 ast_agi_send(agi->fd, chan, "200 result=-1\n");
2503                 return RESULT_SUCCESS;
2504         } else {
2505                 return RESULT_SHOWUSAGE;
2506         }
2507 }
2508
2509 static int handle_exec(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2510 {
2511         int res, workaround;
2512         struct ast_app *app_to_exec;
2513
2514         if (argc < 2)
2515                 return RESULT_SHOWUSAGE;
2516
2517         ast_verb(3, "AGI Script Executing Application: (%s) Options: (%s)\n", argv[1], argc >= 3 ? argv[2] : "");
2518
2519         if ((app_to_exec = pbx_findapp(argv[1]))) {
2520                 if (!(workaround = ast_test_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_WORKAROUNDS))) {
2521                         ast_set_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_WORKAROUNDS);
2522                 }
2523                 if (ast_compat_res_agi && argc >= 3 && !ast_strlen_zero(argv[2])) {
2524                         char *compat = ast_alloca(strlen(argv[2]) * 2 + 1), *cptr;
2525                         const char *vptr;
2526                         for (cptr = compat, vptr = argv[2]; *vptr; vptr++) {
2527                                 if (*vptr == ',') {
2528                                         *cptr++ = '\\';
2529                                         *cptr++ = ',';
2530                                 } else if (*vptr == '|') {
2531                                         *cptr++ = ',';
2532                                 } else {
2533                                         *cptr++ = *vptr;
2534                                 }
2535                         }
2536                         *cptr = '\0';
2537                         res = pbx_exec(chan, app_to_exec, compat);
2538                 } else {
2539                         res = pbx_exec(chan, app_to_exec, argc == 2 ? "" : argv[2]);
2540                 }
2541                 if (!workaround) {
2542                         ast_clear_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_WORKAROUNDS);
2543                 }
2544         } else {
2545                 ast_log(LOG_WARNING, "Could not find application (%s)\n", argv[1]);
2546                 res = -2;
2547         }
2548         ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
2549
2550         /* Even though this is wrong, users are depending upon this result. */
2551         return res;
2552 }
2553
2554 static int handle_setcallerid(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2555 {
2556         char tmp[256]="";
2557         char *l = NULL, *n = NULL;
2558
2559         if (argv[2]) {
2560                 ast_copy_string(tmp, argv[2], sizeof(tmp));
2561                 ast_callerid_parse(tmp, &n, &l);
2562                 if (l)
2563                         ast_shrink_phone_number(l);
2564                 else
2565                         l = "";
2566                 if (!n)
2567                         n = "";
2568                 ast_set_callerid(chan, l, n, NULL);
2569         }
2570
2571         ast_agi_send(agi->fd, chan, "200 result=1\n");
2572         return RESULT_SUCCESS;
2573 }
2574
2575 static int handle_channelstatus(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2576 {
2577         struct ast_channel *c;
2578         if (argc == 2) {
2579                 /* no argument: supply info on the current channel */
2580                 ast_agi_send(agi->fd, chan, "200 result=%d\n", ast_channel_state(chan));
2581                 return RESULT_SUCCESS;
2582         } else if (argc == 3) {
2583                 /* one argument: look for info on the specified channel */
2584                 if ((c = ast_channel_get_by_name(argv[2]))) {
2585                         ast_agi_send(agi->fd, chan, "200 result=%d\n", ast_channel_state(c));
2586                         c = ast_channel_unref(c);
2587                         return RESULT_SUCCESS;
2588                 }
2589                 /* if we get this far no channel name matched the argument given */
2590                 ast_agi_send(agi->fd, chan, "200 result=-1\n");
2591                 return RESULT_SUCCESS;
2592         } else {
2593                 return RESULT_SHOWUSAGE;
2594         }
2595 }
2596
2597 static int handle_setvariable(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2598 {
2599         if (argv[3])
2600                 pbx_builtin_setvar_helper(chan, argv[2], argv[3]);
2601
2602         ast_agi_send(agi->fd, chan, "200 result=1\n");
2603         return RESULT_SUCCESS;
2604 }
2605
2606 static int handle_getvariable(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2607 {
2608         char *ret;
2609         char tempstr[1024] = "";
2610
2611         if (argc != 3)
2612                 return RESULT_SHOWUSAGE;
2613
2614         /* check if we want to execute an ast_custom_function */
2615         if (!ast_strlen_zero(argv[2]) && (argv[2][strlen(argv[2]) - 1] == ')')) {
2616                 ret = ast_func_read(chan, argv[2], tempstr, sizeof(tempstr)) ? NULL : tempstr;
2617         } else {
2618                 pbx_retrieve_variable(chan, argv[2], &ret, tempstr, sizeof(tempstr), NULL);
2619         }
2620
2621         if (ret)
2622                 ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ret);
2623         else
2624                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2625
2626         return RESULT_SUCCESS;
2627 }
2628
2629 static int handle_getvariablefull(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2630 {
2631         struct ast_channel *chan2 = NULL;
2632
2633         if (argc != 4 && argc != 5) {
2634                 return RESULT_SHOWUSAGE;
2635         }
2636
2637         if (argc == 5) {
2638                 chan2 = ast_channel_get_by_name(argv[4]);
2639         } else {
2640                 chan2 = ast_channel_ref(chan);
2641         }
2642
2643         if (chan2) {
2644                 struct ast_str *str = ast_str_create(16);
2645                 if (!str) {
2646                         ast_agi_send(agi->fd, chan, "200 result=0\n");
2647                         return RESULT_SUCCESS;
2648                 }
2649                 ast_str_substitute_variables(&str, 0, chan2, argv[3]);
2650                 ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ast_str_buffer(str));
2651                 ast_free(str);
2652         } else {
2653                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2654         }
2655
2656         if (chan2) {
2657                 chan2 = ast_channel_unref(chan2);
2658         }
2659
2660         return RESULT_SUCCESS;
2661 }
2662
2663 static int handle_verbose(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2664 {
2665         int level = 0;
2666
2667         if (argc < 2)
2668                 return RESULT_SHOWUSAGE;
2669
2670         if (argv[2])
2671                 sscanf(argv[2], "%30d", &level);
2672
2673         ast_verb(level, "%s: %s\n", ast_channel_data(chan), argv[1]);
2674
2675         ast_agi_send(agi->fd, chan, "200 result=1\n");
2676
2677         return RESULT_SUCCESS;
2678 }
2679
2680 static int handle_dbget(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2681 {
2682         int res;
2683         struct ast_str *buf;
2684
2685         if (argc != 4)
2686                 return RESULT_SHOWUSAGE;
2687
2688         if (!(buf = ast_str_create(16))) {
2689                 ast_agi_send(agi->fd, chan, "200 result=-1\n");
2690                 return RESULT_SUCCESS;
2691         }
2692
2693         do {
2694                 res = ast_db_get(argv[2], argv[3], ast_str_buffer(buf), ast_str_size(buf));
2695                 ast_str_update(buf);
2696                 if (ast_str_strlen(buf) < ast_str_size(buf) - 1) {
2697                         break;
2698                 }
2699                 if (ast_str_make_space(&buf, ast_str_size(buf) * 2)) {
2700                         break;
2701                 }
2702         } while (1);
2703         
2704         if (res)
2705                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2706         else
2707                 ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ast_str_buffer(buf));
2708
2709         ast_free(buf);
2710         return RESULT_SUCCESS;
2711 }
2712
2713 static int handle_dbput(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2714 {
2715         int res;
2716
2717         if (argc != 5)
2718                 return RESULT_SHOWUSAGE;
2719         res = ast_db_put(argv[2], argv[3], argv[4]);
2720         ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1');
2721         return RESULT_SUCCESS;
2722 }
2723
2724 static int handle_dbdel(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2725 {
2726         int res;
2727
2728         if (argc != 4)
2729                 return RESULT_SHOWUSAGE;
2730         res = ast_db_del(argv[2], argv[3]);
2731         ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1');
2732         return RESULT_SUCCESS;
2733 }
2734
2735 static int handle_dbdeltree(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2736 {
2737         int res;
2738
2739         if ((argc < 3) || (argc > 4))
2740                 return RESULT_SHOWUSAGE;
2741         if (argc == 4)
2742                 res = ast_db_deltree(argv[2], argv[3]);
2743         else
2744                 res = ast_db_deltree(argv[2], NULL);
2745
2746         ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1');
2747         return RESULT_SUCCESS;
2748 }
2749
2750 static char *handle_cli_agi_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2751 {
2752         switch (cmd) {
2753         case CLI_INIT:
2754                 e->command = "agi set debug [on|off]";
2755                 e->usage =
2756                         "Usage: agi set debug [on|off]\n"
2757                         "       Enables/disables dumping of AGI transactions for\n"
2758                         "       debugging purposes.\n";
2759                 return NULL;
2760
2761         case CLI_GENERATE:
2762                 return NULL;
2763         }
2764
2765         if (a->argc != e->args)
2766                 return CLI_SHOWUSAGE;
2767
2768         if (strncasecmp(a->argv[3], "off", 3) == 0) {
2769                 agidebug = 0;
2770         } else if (strncasecmp(a->argv[3], "on", 2) == 0) {
2771                 agidebug = 1;
2772         } else {
2773                 return CLI_SHOWUSAGE;
2774         }
2775         ast_cli(a->fd, "AGI Debugging %sabled\n", agidebug ? "En" : "Dis");
2776         return CLI_SUCCESS;
2777 }
2778
2779 static int handle_noop(struct ast_channel *chan, AGI *agi, int arg, const char * const argv[])
2780 {
2781         ast_agi_send(agi->fd, chan, "200 result=0\n");
2782         return RESULT_SUCCESS;
2783 }
2784
2785 static int handle_setmusic(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2786 {
2787         if (argc < 3) {
2788                 return RESULT_SHOWUSAGE;
2789         }
2790         if (!strncasecmp(argv[2], "on", 2))
2791                 ast_moh_start(chan, argc > 3 ? argv[3] : NULL, NULL);
2792         else if (!strncasecmp(argv[2], "off", 3))
2793                 ast_moh_stop(chan);
2794         ast_agi_send(agi->fd, chan, "200 result=0\n");
2795         return RESULT_SUCCESS;
2796 }
2797
2798 static int handle_speechcreate(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2799 {
2800         struct ast_format_cap *cap;
2801         struct ast_format tmpfmt;
2802
2803         /* If a structure already exists, return an error */
2804         if (agi->speech) {
2805                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2806                 return RESULT_SUCCESS;
2807         }
2808
2809         if (!(cap = ast_format_cap_alloc_nolock())) {
2810                 return RESULT_FAILURE;
2811         }
2812         ast_format_cap_add(cap, ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR, 0));
2813         if ((agi->speech = ast_speech_new(argv[2], cap))) {
2814                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2815         } else {
2816                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2817         }
2818         cap = ast_format_cap_destroy(cap);
2819
2820         return RESULT_SUCCESS;
2821 }
2822
2823 static int handle_speechset(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2824 {
2825         /* Check for minimum arguments */
2826         if (argc != 4)
2827                 return RESULT_SHOWUSAGE;
2828
2829         /* Check to make sure speech structure exists */
2830         if (!agi->speech) {
2831                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2832                 return RESULT_SUCCESS;
2833         }
2834
2835         ast_speech_change(agi->speech, argv[2], argv[3]);
2836         ast_agi_send(agi->fd, chan, "200 result=1\n");
2837
2838         return RESULT_SUCCESS;
2839 }
2840
2841 static int handle_speechdestroy(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2842 {
2843         if (agi->speech) {
2844                 ast_speech_destroy(agi->speech);
2845                 agi->speech = NULL;
2846                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2847         } else {
2848                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2849         }
2850
2851         return RESULT_SUCCESS;
2852 }
2853
2854 static int handle_speechloadgrammar(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2855 {
2856         if (argc != 5)
2857                 return RESULT_SHOWUSAGE;
2858
2859         if (!agi->speech) {
2860                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2861                 return RESULT_SUCCESS;
2862         }
2863
2864         if (ast_speech_grammar_load(agi->speech, argv[3], argv[4]))
2865                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2866         else
2867                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2868
2869         return RESULT_SUCCESS;
2870 }
2871
2872 static int handle_speechunloadgrammar(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2873 {
2874         if (argc != 4)
2875                 return RESULT_SHOWUSAGE;
2876
2877         if (!agi->speech) {
2878                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2879                 return RESULT_SUCCESS;
2880         }
2881
2882         if (ast_speech_grammar_unload(agi->speech, argv[3]))
2883                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2884         else
2885                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2886
2887         return RESULT_SUCCESS;
2888 }
2889
2890 static int handle_speechactivategrammar(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2891 {
2892         if (argc != 4)
2893                 return RESULT_SHOWUSAGE;
2894
2895         if (!agi->speech) {
2896                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2897                 return RESULT_SUCCESS;
2898         }
2899
2900         if (ast_speech_grammar_activate(agi->speech, argv[3]))
2901                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2902         else
2903                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2904
2905         return RESULT_SUCCESS;
2906 }
2907
2908 static int handle_speechdeactivategrammar(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2909 {
2910         if (argc != 4)
2911                 return RESULT_SHOWUSAGE;
2912
2913         if (!agi->speech) {
2914                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2915                 return RESULT_SUCCESS;
2916         }
2917
2918         if (ast_speech_grammar_deactivate(agi->speech, argv[3]))
2919                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2920         else
2921                 ast_agi_send(agi->fd, chan, "200 result=1\n");
2922
2923         return RESULT_SUCCESS;
2924 }
2925
2926 static int speech_streamfile(struct ast_channel *chan, const char *filename, const char *preflang, int offset)
2927 {
2928         struct ast_filestream *fs = NULL;
2929
2930         if (!(fs = ast_openstream(chan, filename, preflang)))
2931                 return -1;
2932
2933         if (offset)
2934                 ast_seekstream(fs, offset, SEEK_SET);
2935
2936         if (ast_applystream(chan, fs))
2937                 return -1;
2938
2939         if (ast_playstream(fs))
2940                 return -1;
2941
2942         return 0;
2943 }
2944
2945 static int handle_speechrecognize(struct ast_channel *chan, AGI *agi, int argc, const char * const argv[])
2946 {
2947         struct ast_speech *speech = agi->speech;
2948         const char *prompt;
2949         char dtmf = 0, tmp[4096] = "", *buf = tmp;
2950         int timeout = 0, offset = 0, res = 0, i = 0;
2951         struct ast_format old_read_format;
2952         long current_offset = 0;
2953         const char *reason = NULL;
2954         struct ast_frame *fr = NULL;
2955         struct ast_speech_result *result = NULL;
2956         size_t left = sizeof(tmp);
2957         time_t start = 0, current;
2958
2959         if (argc < 4)
2960                 return RESULT_SHOWUSAGE;
2961
2962         if (!speech) {
2963                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2964                 return RESULT_SUCCESS;
2965         }
2966
2967         prompt = argv[2];
2968         timeout = atoi(argv[3]);
2969
2970         /* If offset is specified then convert from text to integer */
2971         if (argc == 5)
2972                 offset = atoi(argv[4]);
2973
2974         /* We want frames coming in signed linear */
2975         ast_format_copy(&old_read_format, ast_channel_readformat(chan));
2976         if (ast_set_read_format_by_id(chan, AST_FORMAT_SLINEAR)) {
2977                 ast_agi_send(agi->fd, chan, "200 result=0\n");
2978                 return RESULT_SUCCESS;
2979         }
2980
2981         /* Setup speech structure */
2982         if (speech->state == AST_SPEECH_STATE_NOT_READY || speech->state == AST_SPEECH_STATE_DONE) {
2983                 ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
2984                 ast_speech_start(speech);
2985         }
2986
2987         /* Start playing prompt */
2988         speech_streamfile(chan, prompt, ast_channel_language(chan), offset);
2989
2990         /* Go into loop reading in frames, passing to speech thingy, checking for hangup, all that jazz */
2991         while (ast_strlen_zero(reason)) {
2992                 /* Run scheduled items */
2993                 ast_sched_runq(ast_channel_sched(chan));
2994
2995                 /* See maximum time of waiting */
2996                 if ((res = ast_sched_wait(ast_channel_sched(chan))) < 0)
2997                         res = 1000;
2998
2999                 /* Wait for frame */
3000                 if (ast_waitfor(chan, res) > 0) {
3001                         if (!(fr = ast_read(chan))) {
3002                                 reason = "hangup";
3003                                 break;
3004                         }
3005                 }
3006
3007                 /* Perform timeout check */
3008                 if ((timeout > 0) && (start > 0)) {
3009                         time(&current);
3010                         if ((current - start) >= timeout) {
3011                                 reason = "timeout";
3012                                 if (fr)
3013                                         ast_frfree(fr);
3014                                 break;
3015                         }
3016                 }
3017
3018                 /* Check the speech structure for any changes */
3019                 ast_mutex_lock(&speech->lock);
3020
3021                 /* See if we need to quiet the audio stream playback */
3022                 if (ast_test_flag(speech, AST_SPEECH_QUIET) && ast_channel_stream(chan)) {
3023                         current_offset = ast_tellstream(ast_channel_stream(chan));
3024                         ast_stopstream(chan);
3025                         ast_clear_flag(speech, AST_SPEECH_QUIET);
3026                 }
3027
3028                 /* Check each state */
3029                 switch (speech->state) {
3030                 case AST_SPEECH_STATE_READY:
3031                         /* If the stream is done, start timeout calculation */
3032                         if ((timeout > 0) && start == 0 && ((!ast_channel_stream(chan)) || (ast_channel_streamid(chan) == -1 && ast_channel_timingfunc(chan) == NULL))) {
3033                                 ast_stopstream(chan);
3034                                 time(&start);
3035                         }
3036                         /* Write audio frame data into speech engine if possible */
3037                         if (fr && fr->frametype == AST_FRAME_VOICE)
3038                                 ast_speech_write(speech, fr->data.ptr, fr->datalen);
3039                         break;
3040                 case AST_SPEECH_STATE_WAIT:
3041                         /* Cue waiting sound if not already playing */
3042                         if ((!ast_channel_stream(chan)) || (ast_channel_streamid(chan) == -1 && ast_channel_timingfunc(chan) == NULL)) {
3043                                 ast_stopstream(chan);
3044                                 /* If a processing sound exists, or is not none - play it */
3045                                 if (!ast_strlen_zero(speech->processing_sound) && strcasecmp(speech->processing_sound, "none"))
3046                                         speech_streamfile(chan, speech->processing_sound, ast_channel_language(chan), 0);
3047                         }
3048                         break;
3049                 case AST_SPEECH_STATE_DONE:
3050                         /* Get the results */
3051                         speech->results = ast_speech_results_get(speech);
3052                         /* Change state to not ready */
3053                         ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY);
3054                         reason = "speech";
3055                         break;
3056                 default:
3057                         break;
3058                 }
3059                 ast_mutex_unlock(&speech->lock);
3060
3061                 /* Check frame for DTMF or hangup */
3062                 if (fr) {
3063                         if (fr->frametype == AST_FRAME_DTMF) {
3064                                 reason = "dtmf";
3065                                 dtmf = fr->subclass.integer;
3066                         } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass.integer == AST_CONTROL_HANGUP) {
3067                                 reason = "hangup";
3068                         }
3069    &nb