ea4c5ba237b744e8d55d8264b622d7707db85657
[asterisk/asterisk.git] / apps / app_dial.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, 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 dial() & retrydial() - Trivial application to dial a channel and send an URL on answer
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \ingroup applications
26  */
27
28 /*** MODULEINFO
29         <depend>chan_local</depend>
30  ***/
31
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include <sys/time.h>
38 #include <sys/signal.h>
39 #include <sys/stat.h>
40 #include <netinet/in.h>
41
42 #include "asterisk/paths.h" /* use ast_config_AST_DATA_DIR */
43 #include "asterisk/lock.h"
44 #include "asterisk/file.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/pbx.h"
47 #include "asterisk/module.h"
48 #include "asterisk/translate.h"
49 #include "asterisk/say.h"
50 #include "asterisk/config.h"
51 #include "asterisk/features.h"
52 #include "asterisk/musiconhold.h"
53 #include "asterisk/callerid.h"
54 #include "asterisk/utils.h"
55 #include "asterisk/app.h"
56 #include "asterisk/causes.h"
57 #include "asterisk/rtp_engine.h"
58 #include "asterisk/cdr.h"
59 #include "asterisk/manager.h"
60 #include "asterisk/privacy.h"
61 #include "asterisk/stringfields.h"
62 #include "asterisk/global_datastores.h"
63 #include "asterisk/dsp.h"
64
65 /*** DOCUMENTATION
66         <application name="Dial" language="en_US">
67                 <synopsis>
68                         Attempt to connect to another device or endpoint and bridge the call.
69                 </synopsis>
70                 <syntax>
71                         <parameter name="Technology/Resource" required="true" argsep="&amp;">
72                                 <argument name="Technology/Resource" required="true">
73                                         <para>Specification of the device(s) to dial.  These must be in the format of
74                                         <literal>Technology/Resource</literal>, where <replaceable>Technology</replaceable>
75                                         represents a particular channel driver, and <replaceable>Resource</replaceable>
76                                         represents a resource available to that particular channel driver.</para>
77                                 </argument>
78                                 <argument name="Technology2/Resource2" required="false" multiple="true">
79                                         <para>Optional extra devices to dial in parallel</para>
80                                         <para>If you need more then one enter them as
81                                         Technology2/Resource2&amp;Technology3/Resourse3&amp;.....</para>
82                                 </argument>
83                         </parameter>
84                         <parameter name="timeout" required="false">
85                                 <para>Specifies the number of seconds we attempt to dial the specified devices</para>
86                                 <para>If not specified, this defaults to 136 years.</para>
87                         </parameter>
88                         <parameter name="options" required="false">
89                            <optionlist>
90                                 <option name="A">
91                                         <argument name="x" required="true">
92                                                 <para>The file to play to the called party</para>
93                                         </argument>
94                                         <para>Play an announcement to the called party, where <replaceable>x</replaceable> is the prompt to be played</para>
95                                 </option>
96                                 <option name="C">
97                                         <para>Reset the call detail record (CDR) for this call.</para>
98                                 </option>
99                                 <option name="c">
100                                         <para>If the Dial() application cancels this call, always set the flag to tell the channel
101                                         driver that the call is answered elsewhere.</para>
102                                 </option>
103                                 <option name="d">
104                                         <para>Allow the calling user to dial a 1 digit extension while waiting for
105                                         a call to be answered. Exit to that extension if it exists in the
106                                         current context, or the context defined in the <variable>EXITCONTEXT</variable> variable,
107                                         if it exists.</para>
108                                 </option>
109                                 <option name="D" argsep=":">
110                                         <argument name="called" />
111                                         <argument name="calling" />
112                                         <argument name="progress" />
113                                         <para>Send the specified DTMF strings <emphasis>after</emphasis> the called
114                                         party has answered, but before the call gets bridged. The 
115                                         <replaceable>called</replaceable> DTMF string is sent to the called party, and the 
116                                         <replaceable>calling</replaceable> DTMF string is sent to the calling party. Both arguments 
117                                         can be used alone.  If <replaceable>progress</replaceable> is specified, its DTMF is sent
118                                         immediately after receiving a PROGRESS message.</para>
119                                 </option>
120                                 <option name="e">
121                                         <para>Execute the <literal>h</literal> extension for peer after the call ends</para>
122                                 </option>
123                                 <option name="f">
124                                         <para>Force the callerid of the <emphasis>calling</emphasis> channel to be set as the
125                                         extension associated with the channel using a dialplan <literal>hint</literal>.
126                                         For example, some PSTNs do not allow CallerID to be set to anything
127                                         other than the number assigned to the caller.</para>
128                                 </option>
129                                 <option name="F" argsep="^">
130                                         <argument name="context" required="false" />
131                                         <argument name="exten" required="false" />
132                                         <argument name="priority" required="true" />
133                                         <para>When the caller hangs up, transfer the called party
134                                         to the specified destination and continue execution at that location.</para>
135                                 </option>
136                                 <option name="F">
137                                         <para>Proceed with dialplan execution at the next priority in the current extension if the
138                                         source channel hangs up.</para>
139                                 </option>
140                                 <option name="g">
141                                         <para>Proceed with dialplan execution at the next priority in the current extension if the
142                                         destination channel hangs up.</para>
143                                 </option>
144                                 <option name="G" argsep="^">
145                                         <argument name="context" required="false" />
146                                         <argument name="exten" required="false" />
147                                         <argument name="priority" required="true" />
148                                         <para>If the call is answered, transfer the calling party to
149                                         the specified <replaceable>priority</replaceable> and the called party to the specified 
150                                         <replaceable>priority</replaceable> plus one.</para>
151                                         <note>
152                                                 <para>You cannot use any additional action post answer options in conjunction with this option.</para>
153                                         </note>
154                                 </option>
155                                 <option name="h">
156                                         <para>Allow the called party to hang up by sending the <literal>*</literal> DTMF digit.</para>
157                                 </option>
158                                 <option name="H">
159                                         <para>Allow the calling party to hang up by hitting the <literal>*</literal> DTMF digit.</para>
160                                 </option>
161                                 <option name="i">
162                                         <para>Asterisk will ignore any forwarding requests it may receive on this dial attempt.</para>
163                                 </option>
164                                 <option name="I">
165                                         <para>Asterisk will ignore any connected line update requests or redirecting party update
166                                         requests it may receiveon this dial attempt.</para>
167                                 </option>
168                                 <option name="k">
169                                         <para>Allow the called party to enable parking of the call by sending
170                                         the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
171                                 </option>
172                                 <option name="K">
173                                         <para>Allow the calling party to enable parking of the call by sending
174                                         the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
175                                 </option>
176                                 <option name="L" argsep=":">
177                                         <argument name="x" required="true">
178                                                 <para>Maximum call time, in milliseconds</para>
179                                         </argument>
180                                         <argument name="y">
181                                                 <para>Warning time, in milliseconds</para>
182                                         </argument>
183                                         <argument name="z">
184                                                 <para>Repeat time, in milliseconds</para>
185                                         </argument>
186                                         <para>Limit the call to <replaceable>x</replaceable> milliseconds. Play a warning when <replaceable>y</replaceable> milliseconds are
187                                         left. Repeat the warning every <replaceable>z</replaceable> milliseconds until time expires.</para>
188                                         <para>This option is affected by the following variables:</para>
189                                         <variablelist>
190                                                 <variable name="LIMIT_PLAYAUDIO_CALLER">
191                                                         <value name="yes" default="true" />
192                                                         <value name="no" />
193                                                         <para>If set, this variable causes Asterisk to play the prompts to the caller.</para>
194                                                 </variable>
195                                                 <variable name="LIMIT_PLAYAUDIO_CALLEE">
196                                                         <value name="yes" />
197                                                         <value name="no" default="true"/>
198                                                         <para>If set, this variable causes Asterisk to play the prompts to the callee.</para>
199                                                 </variable>
200                                                 <variable name="LIMIT_TIMEOUT_FILE">
201                                                         <value name="filename"/>
202                                                         <para>If specified, <replaceable>filename</replaceable> specifies the sound prompt to play when the timeout is reached.
203                                                         If not set, the time remaining will be announced.</para>
204                                                 </variable>
205                                                 <variable name="LIMIT_CONNECT_FILE">
206                                                         <value name="filename"/>
207                                                         <para>If specified, <replaceable>filename</replaceable> specifies the sound prompt to play when the call begins.
208                                                         If not set, the time remaining will be announced.</para>
209                                                 </variable>
210                                                 <variable name="LIMIT_WARNING_FILE">
211                                                         <value name="filename"/>
212                                                         <para>If specified, <replaceable>filename</replaceable> specifies the sound prompt to play as
213                                                         a warning when time <replaceable>x</replaceable> is reached. If not set, the time remaining will be announced.</para>
214                                                 </variable>
215                                         </variablelist>
216                                 </option>
217                                 <option name="m">
218                                         <argument name="class" required="false"/>
219                                         <para>Provide hold music to the calling party until a requested
220                                         channel answers. A specific music on hold <replaceable>class</replaceable>
221                                         (as defined in <filename>musiconhold.conf</filename>) can be specified.</para>
222                                 </option>
223                                 <option name="M" argsep="^">
224                                         <argument name="macro" required="true">
225                                                 <para>Name of the macro that should be executed.</para>
226                                         </argument>
227                                         <argument name="arg" multiple="true">
228                                                 <para>Macro arguments</para>
229                                         </argument>
230                                         <para>Execute the specified <replaceable>macro</replaceable> for the <emphasis>called</emphasis> channel 
231                                         before connecting to the calling channel. Arguments can be specified to the Macro
232                                         using <literal>^</literal> as a delimiter. The macro can set the variable
233                                         <variable>MACRO_RESULT</variable> to specify the following actions after the macro is
234                                         finished executing:</para>
235                                         <variablelist>
236                                                 <variable name="MACRO_RESULT">
237                                                         <para>If set, this action will be taken after the macro finished executing.</para>
238                                                         <value name="ABORT">
239                                                                 Hangup both legs of the call
240                                                         </value>
241                                                         <value name="CONGESTION">
242                                                                 Behave as if line congestion was encountered
243                                                         </value>
244                                                         <value name="BUSY">
245                                                                 Behave as if a busy signal was encountered
246                                                         </value>
247                                                         <value name="CONTINUE">
248                                                                 Hangup the called party and allow the calling party to continue dialplan execution at the next priority
249                                                         </value>
250                                                         <!-- TODO: Fix this syntax up, once we've figured out how to specify the GOTO syntax -->
251                                                         <value name="GOTO:&lt;context&gt;^&lt;exten&gt;^&lt;priority&gt;">
252                                                                 Transfer the call to the specified destination.
253                                                         </value>
254                                                 </variable>
255                                         </variablelist>
256                                         <note>
257                                                 <para>You cannot use any additional action post answer options in conjunction
258                                                 with this option. Also, pbx services are not run on the peer (called) channel,
259                                                 so you will not be able to set timeouts via the TIMEOUT() function in this macro.</para>
260                                         </note>
261                                 </option>
262                                 <option name="n">
263                                         <para>This option is a modifier for the call screening/privacy mode. (See the 
264                                         <literal>p</literal> and <literal>P</literal> options.) It specifies
265                                         that no introductions are to be saved in the <directory>priv-callerintros</directory>
266                                         directory.</para>
267                                 </option>
268                                 <option name="N">
269                                         <para>This option is a modifier for the call screening/privacy mode. It specifies
270                                         that if Caller*ID is present, do not screen the call.</para>
271                                 </option>
272                                 <option name="o">
273                                         <para>Specify that the Caller*ID that was present on the <emphasis>calling</emphasis> channel
274                                         be set as the Caller*ID on the <emphasis>called</emphasis> channel. This was the
275                                         behavior of Asterisk 1.0 and earlier.</para>
276                                 </option>
277                                 <option name="O">
278                                         <argument name="mode">
279                                                 <para>With <replaceable>mode</replaceable> either not specified or set to <literal>1</literal>,
280                                                 the originator hanging up will cause the phone to ring back immediately.</para>
281                                                 <para>With <replaceable>mode</replaceable> set to <literal>2</literal>, when the operator 
282                                                 flashes the trunk, it will ring their phone back.</para>
283                                         </argument>
284                                         <para>Enables <emphasis>operator services</emphasis> mode.  This option only
285                                         works when bridging a DAHDI channel to another DAHDI channel
286                                         only. if specified on non-DAHDI interfaces, it will be ignored.
287                                         When the destination answers (presumably an operator services
288                                         station), the originator no longer has control of their line.
289                                         They may hang up, but the switch will not release their line
290                                         until the destination party (the operator) hangs up.</para>
291                                 </option>
292                                 <option name="p">
293                                         <para>This option enables screening mode. This is basically Privacy mode
294                                         without memory.</para>
295                                 </option>
296                                 <option name="P">
297                                         <argument name="x" />
298                                         <para>Enable privacy mode. Use <replaceable>x</replaceable> as the family/key in the AstDB database if
299                                         it is provided. The current extension is used if a database family/key is not specified.</para>
300                                 </option>
301                                 <option name="r">
302                                         <para>Indicate ringing to the calling party, even if the called party isn't actually ringing. Pass no audio to the calling
303                                         party until the called channel has answered.</para>
304                                 </option>
305                                 <option name="S">
306                                         <argument name="x" required="true" />
307                                         <para>Hang up the call <replaceable>x</replaceable> seconds <emphasis>after</emphasis> the called party has
308                                         answered the call.</para>
309                                 </option>
310                                 <option name="t">
311                                         <para>Allow the called party to transfer the calling party by sending the
312                                         DTMF sequence defined in <filename>features.conf</filename>.</para>
313                                 </option>
314                                 <option name="T">
315                                         <para>Allow the calling party to transfer the called party by sending the
316                                         DTMF sequence defined in <filename>features.conf</filename>.</para>
317                                 </option>
318                                 <option name="U" argsep="^">
319                                         <argument name="x" required="true">
320                                                 <para>Name of the subroutine to execute via Gosub</para>
321                                         </argument>
322                                         <argument name="arg" multiple="true" required="false">
323                                                 <para>Arguments for the Gosub routine</para>
324                                         </argument>
325                                         <para>Execute via Gosub the routine <replaceable>x</replaceable> for the <emphasis>called</emphasis> channel before connecting
326                                         to the calling channel. Arguments can be specified to the Gosub
327                                         using <literal>^</literal> as a delimiter. The Gosub routine can set the variable
328                                         <variable>GOSUB_RESULT</variable> to specify the following actions after the Gosub returns.</para>
329                                         <variablelist>
330                                                 <variable name="GOSUB_RESULT">
331                                                         <value name="ABORT">
332                                                                 Hangup both legs of the call.
333                                                         </value>
334                                                         <value name="CONGESTION">
335                                                                 Behave as if line congestion was encountered.
336                                                         </value>
337                                                         <value name="BUSY">
338                                                                 Behave as if a busy signal was encountered.
339                                                         </value>
340                                                         <value name="CONTINUE">
341                                                                 Hangup the called party and allow the calling party
342                                                                 to continue dialplan execution at the next priority.
343                                                         </value>
344                                                         <!-- TODO: Fix this syntax up, once we've figured out how to specify the GOTO syntax -->
345                                                         <value name="GOTO:&lt;context&gt;^&lt;exten&gt;^&lt;priority&gt;">
346                                                                 Transfer the call to the specified priority. Optionally, an extension, or
347                                                                 extension and priority can be specified.
348                                                         </value>
349                                                 </variable>
350                                         </variablelist>
351                                         <note>
352                                                 <para>You cannot use any additional action post answer options in conjunction
353                                                 with this option. Also, pbx services are not run on the peer (called) channel,
354                                                 so you will not be able to set timeouts via the TIMEOUT() function in this routine.</para>
355                                         </note>
356                                 </option>
357                                 <option name="w">
358                                         <para>Allow the called party to enable recording of the call by sending
359                                         the DTMF sequence defined for one-touch recording in <filename>features.conf</filename>.</para>
360                                 </option>
361                                 <option name="W">
362                                         <para>Allow the calling party to enable recording of the call by sending
363                                         the DTMF sequence defined for one-touch recording in <filename>features.conf</filename>.</para>
364                                 </option>
365                                 <option name="x">
366                                         <para>Allow the called party to enable recording of the call by sending
367                                         the DTMF sequence defined for one-touch automixmonitor in <filename>features.conf</filename>.</para>
368                                 </option>
369                                 <option name="X">
370                                         <para>Allow the calling party to enable recording of the call by sending
371                                         the DTMF sequence defined for one-touch automixmonitor in <filename>features.conf</filename>.</para>
372                                 </option>
373                                 <option name="z">
374                                         <para>On a call forward, cancel any dial timeout which has been set for this call.</para>
375                                 </option>
376                                 </optionlist>
377                         </parameter>
378                         <parameter name="URL">
379                                 <para>The optional URL will be sent to the called party if the channel driver supports it.</para>
380                         </parameter>
381                 </syntax>
382                 <description>
383                         <para>This application will place calls to one or more specified channels. As soon
384                         as one of the requested channels answers, the originating channel will be
385                         answered, if it has not already been answered. These two channels will then
386                         be active in a bridged call. All other channels that were requested will then
387                         be hung up.</para>
388
389                         <para>Unless there is a timeout specified, the Dial application will wait
390                         indefinitely until one of the called channels answers, the user hangs up, or
391                         if all of the called channels are busy or unavailable. Dialplan executing will
392                         continue if no requested channels can be called, or if the timeout expires.
393                         This application will report normal termination if the originating channel
394                         hangs up, or if the call is bridged and either of the parties in the bridge
395                         ends the call.</para>
396                         <para>If the <variable>OUTBOUND_GROUP</variable> variable is set, all peer channels created by this
397                         application will be put into that group (as in Set(GROUP()=...).
398                         If the <variable>OUTBOUND_GROUP_ONCE</variable> variable is set, all peer channels created by this
399                         application will be put into that group (as in Set(GROUP()=...). Unlike OUTBOUND_GROUP,
400                         however, the variable will be unset after use.</para>
401
402                         <para>This application sets the following channel variables:</para>
403                         <variablelist>
404                                 <variable name="DIALEDTIME">
405                                         <para>This is the time from dialing a channel until when it is disconnected.</para>
406                                 </variable>
407                                 <variable name="ANSWEREDTIME">
408                                         <para>This is the amount of time for actual call.</para>
409                                 </variable>
410                                 <variable name="DIALSTATUS">
411                                         <para>This is the status of the call</para>
412                                         <value name="CHANUNAVAIL" />
413                                         <value name="CONGESTION" />
414                                         <value name="NOANSWER" />
415                                         <value name="BUSY" />
416                                         <value name="ANSWER" />
417                                         <value name="CANCEL" />
418                                         <value name="DONTCALL">
419                                                 For the Privacy and Screening Modes.
420                                                 Will be set if the called party chooses to send the calling party to the 'Go Away' script.
421                                         </value>
422                                         <value name="TORTURE">
423                                                 For the Privacy and Screening Modes.
424                                                 Will be set if the called party chooses to send the calling party to the 'torture' script.
425                                         </value>
426                                         <value name="INVALIDARGS" />
427                                 </variable>
428                         </variablelist>
429                 </description>
430         </application>
431         <application name="RetryDial" language="en_US">
432                 <synopsis>
433                         Place a call, retrying on failure allowing an optional exit extension.
434                 </synopsis>
435                 <syntax>
436                         <parameter name="announce" required="true">
437                                 <para>Filename of sound that will be played when no channel can be reached</para>
438                         </parameter>
439                         <parameter name="sleep" required="true">
440                                 <para>Number of seconds to wait after a dial attempt failed before a new attempt is made</para>
441                         </parameter>
442                         <parameter name="retries" required="true">
443                                 <para>Number of retries</para>
444                                 <para>When this is reached flow will continue at the next priority in the dialplan</para>
445                         </parameter>
446                         <parameter name="dialargs" required="true">
447                                 <para>Same format as arguments provided to the Dial application</para>
448                         </parameter>
449                 </syntax>
450                 <description>
451                         <para>This application will attempt to place a call using the normal Dial application.
452                         If no channel can be reached, the <replaceable>announce</replaceable> file will be played.
453                         Then, it will wait <replaceable>sleep</replaceable> number of seconds before retrying the call.
454                         After <replaceable>retries</replaceable> number of attempts, the calling channel will continue at the next priority in the dialplan.
455                         If the <replaceable>retries</replaceable> setting is set to 0, this application will retry endlessly.
456                         While waiting to retry a call, a 1 digit extension may be dialed. If that
457                         extension exists in either the context defined in <variable>EXITCONTEXT</variable> or the current
458                         one, The call will jump to that extension immediately.
459                         The <replaceable>dialargs</replaceable> are specified in the same format that arguments are provided
460                         to the Dial application.</para>
461                 </description>
462         </application>
463  ***/
464
465 static char *app = "Dial";
466 static char *rapp = "RetryDial";
467
468 enum {
469         OPT_ANNOUNCE =          (1 << 0),
470         OPT_RESETCDR =          (1 << 1),
471         OPT_DTMF_EXIT =         (1 << 2),
472         OPT_SENDDTMF =          (1 << 3),
473         OPT_FORCECLID =         (1 << 4),
474         OPT_GO_ON =             (1 << 5),
475         OPT_CALLEE_HANGUP =     (1 << 6),
476         OPT_CALLER_HANGUP =     (1 << 7),
477         OPT_ORIGINAL_CLID =     (1 << 8),
478         OPT_DURATION_LIMIT =    (1 << 9),
479         OPT_MUSICBACK =         (1 << 10),
480         OPT_CALLEE_MACRO =      (1 << 11),
481         OPT_SCREEN_NOINTRO =    (1 << 12),
482         OPT_SCREEN_NOCALLERID = (1 << 13),
483         OPT_IGNORE_CONNECTEDLINE = (1 << 14),
484         OPT_SCREENING =         (1 << 15),
485         OPT_PRIVACY =           (1 << 16),
486         OPT_RINGBACK =          (1 << 17),
487         OPT_DURATION_STOP =     (1 << 18),
488         OPT_CALLEE_TRANSFER =   (1 << 19),
489         OPT_CALLER_TRANSFER =   (1 << 20),
490         OPT_CALLEE_MONITOR =    (1 << 21),
491         OPT_CALLER_MONITOR =    (1 << 22),
492         OPT_GOTO =              (1 << 23),
493         OPT_OPERMODE =          (1 << 24),
494         OPT_CALLEE_PARK =       (1 << 25),
495         OPT_CALLER_PARK =       (1 << 26),
496         OPT_IGNORE_FORWARDING = (1 << 27),
497         OPT_CALLEE_GOSUB =      (1 << 28),
498         OPT_CALLEE_MIXMONITOR = (1 << 29),
499         OPT_CALLER_MIXMONITOR = (1 << 30),
500 };
501
502 #define DIAL_STILLGOING      (1 << 31)
503 #define DIAL_NOFORWARDHTML   ((uint64_t)1 << 32) /* flags are now 64 bits, so keep it up! */
504 #define DIAL_NOCONNECTEDLINE ((uint64_t)1 << 33)
505 #define OPT_CANCEL_ELSEWHERE ((uint64_t)1 << 34)
506 #define OPT_PEER_H           ((uint64_t)1 << 35)
507 #define OPT_CALLEE_GO_ON     ((uint64_t)1 << 36)
508 #define OPT_CANCEL_TIMEOUT   ((uint64_t)1 << 37)
509
510 enum {
511         OPT_ARG_ANNOUNCE = 0,
512         OPT_ARG_SENDDTMF,
513         OPT_ARG_GOTO,
514         OPT_ARG_DURATION_LIMIT,
515         OPT_ARG_MUSICBACK,
516         OPT_ARG_CALLEE_MACRO,
517         OPT_ARG_CALLEE_GOSUB,
518         OPT_ARG_CALLEE_GO_ON,
519         OPT_ARG_PRIVACY,
520         OPT_ARG_DURATION_STOP,
521         OPT_ARG_OPERMODE,
522         /* note: this entry _MUST_ be the last one in the enum */
523         OPT_ARG_ARRAY_SIZE,
524 };
525
526 AST_APP_OPTIONS(dial_exec_options, BEGIN_OPTIONS
527         AST_APP_OPTION_ARG('A', OPT_ANNOUNCE, OPT_ARG_ANNOUNCE),
528         AST_APP_OPTION('C', OPT_RESETCDR),
529         AST_APP_OPTION('c', OPT_CANCEL_ELSEWHERE),
530         AST_APP_OPTION('d', OPT_DTMF_EXIT),
531         AST_APP_OPTION_ARG('D', OPT_SENDDTMF, OPT_ARG_SENDDTMF),
532         AST_APP_OPTION('e', OPT_PEER_H),
533         AST_APP_OPTION('f', OPT_FORCECLID),
534         AST_APP_OPTION_ARG('F', OPT_CALLEE_GO_ON, OPT_ARG_CALLEE_GO_ON),
535         AST_APP_OPTION('g', OPT_GO_ON),
536         AST_APP_OPTION_ARG('G', OPT_GOTO, OPT_ARG_GOTO),
537         AST_APP_OPTION('h', OPT_CALLEE_HANGUP),
538         AST_APP_OPTION('H', OPT_CALLER_HANGUP),
539         AST_APP_OPTION('i', OPT_IGNORE_FORWARDING),
540         AST_APP_OPTION('I', OPT_IGNORE_CONNECTEDLINE),
541         AST_APP_OPTION('k', OPT_CALLEE_PARK),
542         AST_APP_OPTION('K', OPT_CALLER_PARK),
543         AST_APP_OPTION_ARG('L', OPT_DURATION_LIMIT, OPT_ARG_DURATION_LIMIT),
544         AST_APP_OPTION_ARG('m', OPT_MUSICBACK, OPT_ARG_MUSICBACK),
545         AST_APP_OPTION_ARG('M', OPT_CALLEE_MACRO, OPT_ARG_CALLEE_MACRO),
546         AST_APP_OPTION('n', OPT_SCREEN_NOINTRO),
547         AST_APP_OPTION('N', OPT_SCREEN_NOCALLERID),
548         AST_APP_OPTION('o', OPT_ORIGINAL_CLID),
549         AST_APP_OPTION_ARG('O', OPT_OPERMODE, OPT_ARG_OPERMODE),
550         AST_APP_OPTION('p', OPT_SCREENING),
551         AST_APP_OPTION_ARG('P', OPT_PRIVACY, OPT_ARG_PRIVACY),
552         AST_APP_OPTION('r', OPT_RINGBACK),
553         AST_APP_OPTION_ARG('S', OPT_DURATION_STOP, OPT_ARG_DURATION_STOP),
554         AST_APP_OPTION('t', OPT_CALLEE_TRANSFER),
555         AST_APP_OPTION('T', OPT_CALLER_TRANSFER),
556         AST_APP_OPTION_ARG('U', OPT_CALLEE_GOSUB, OPT_ARG_CALLEE_GOSUB),
557         AST_APP_OPTION('w', OPT_CALLEE_MONITOR),
558         AST_APP_OPTION('W', OPT_CALLER_MONITOR),
559         AST_APP_OPTION('x', OPT_CALLEE_MIXMONITOR),
560         AST_APP_OPTION('X', OPT_CALLER_MIXMONITOR),
561         AST_APP_OPTION('z', OPT_CANCEL_TIMEOUT),
562 END_OPTIONS );
563
564 #define CAN_EARLY_BRIDGE(flags,chan,peer) (!ast_test_flag64(flags, OPT_CALLEE_HANGUP | \
565         OPT_CALLER_HANGUP | OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER | \
566         OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR | OPT_CALLEE_PARK | OPT_CALLER_PARK) && \
567         !chan->audiohooks && !peer->audiohooks)
568
569 /*
570  * The list of active channels
571  */
572 struct chanlist {
573         struct chanlist *next;
574         struct ast_channel *chan;
575         uint64_t flags;
576         struct ast_party_connected_line connected;
577 };
578
579 static int detect_disconnect(struct ast_channel *chan, char code, struct ast_str *featurecode);
580
581 static void hanguptree(struct chanlist *outgoing, struct ast_channel *exception, int answered_elsewhere)
582 {
583         /* Hang up a tree of stuff */
584         struct chanlist *oo;
585         while (outgoing) {
586                 /* Hangup any existing lines we have open */
587                 if (outgoing->chan && (outgoing->chan != exception)) {
588                         if (answered_elsewhere) {
589                                 /* The flag is used for local channel inheritance and stuff */
590                                 ast_set_flag(outgoing->chan, AST_FLAG_ANSWERED_ELSEWHERE);
591                                 /* This is for the channel drivers */
592                                 outgoing->chan->hangupcause = AST_CAUSE_ANSWERED_ELSEWHERE;
593                         }
594                         ast_hangup(outgoing->chan);
595                 }
596                 oo = outgoing;
597                 outgoing = outgoing->next;
598                 ast_free(oo);
599         }
600 }
601
602 #define AST_MAX_WATCHERS 256
603
604 /*
605  * argument to handle_cause() and other functions.
606  */
607 struct cause_args {
608         struct ast_channel *chan;
609         int busy;
610         int congestion;
611         int nochan;
612 };
613
614 static void handle_cause(int cause, struct cause_args *num)
615 {
616         struct ast_cdr *cdr = num->chan->cdr;
617
618         switch(cause) {
619         case AST_CAUSE_BUSY:
620                 if (cdr)
621                         ast_cdr_busy(cdr);
622                 num->busy++;
623                 break;
624
625         case AST_CAUSE_CONGESTION:
626                 if (cdr)
627                         ast_cdr_failed(cdr);
628                 num->congestion++;
629                 break;
630
631         case AST_CAUSE_NO_ROUTE_DESTINATION:
632         case AST_CAUSE_UNREGISTERED:
633                 if (cdr)
634                         ast_cdr_failed(cdr);
635                 num->nochan++;
636                 break;
637
638         case AST_CAUSE_NORMAL_CLEARING:
639                 break;
640
641         default:
642                 num->nochan++;
643                 break;
644         }
645 }
646
647 /* free the buffer if allocated, and set the pointer to the second arg */
648 #define S_REPLACE(s, new_val)           \
649         do {                            \
650                 if (s)                  \
651                         ast_free(s);    \
652                 s = (new_val);          \
653         } while (0)
654
655 static int onedigit_goto(struct ast_channel *chan, const char *context, char exten, int pri)
656 {
657         char rexten[2] = { exten, '\0' };
658
659         if (context) {
660                 if (!ast_goto_if_exists(chan, context, rexten, pri))
661                         return 1;
662         } else {
663                 if (!ast_goto_if_exists(chan, chan->context, rexten, pri))
664                         return 1;
665                 else if (!ast_strlen_zero(chan->macrocontext)) {
666                         if (!ast_goto_if_exists(chan, chan->macrocontext, rexten, pri))
667                                 return 1;
668                 }
669         }
670         return 0;
671 }
672
673 /* do not call with chan lock held */
674 static const char *get_cid_name(char *name, int namelen, struct ast_channel *chan)
675 {
676         const char *context;
677         const char *exten;
678
679         ast_channel_lock(chan);
680         context = ast_strdupa(S_OR(chan->macrocontext, chan->context));
681         exten = ast_strdupa(S_OR(chan->macroexten, chan->exten));
682         ast_channel_unlock(chan);
683
684         return ast_get_hint(NULL, 0, name, namelen, chan, context, exten) ? name : "";
685 }
686
687 static void senddialevent(struct ast_channel *src, struct ast_channel *dst, const char *dialstring)
688 {
689         manager_event(EVENT_FLAG_CALL, "Dial",
690                 "SubEvent: Begin\r\n"
691                 "Channel: %s\r\n"
692                 "Destination: %s\r\n"
693                 "CallerIDNum: %s\r\n"
694                 "CallerIDName: %s\r\n"
695                 "UniqueID: %s\r\n"
696                 "DestUniqueID: %s\r\n"
697                 "Dialstring: %s\r\n",
698                 src->name, dst->name, S_OR(src->cid.cid_num, "<unknown>"),
699                 S_OR(src->cid.cid_name, "<unknown>"), src->uniqueid,
700                 dst->uniqueid, dialstring ? dialstring : "");
701 }
702
703 static void senddialendevent(const struct ast_channel *src, const char *dialstatus)
704 {
705         manager_event(EVENT_FLAG_CALL, "Dial",
706                 "SubEvent: End\r\n"
707                 "Channel: %s\r\n"
708                 "UniqueID: %s\r\n"
709                 "DialStatus: %s\r\n",
710                 src->name, src->uniqueid, dialstatus);
711 }
712
713 /*!
714  * helper function for wait_for_answer()
715  *
716  * XXX this code is highly suspicious, as it essentially overwrites
717  * the outgoing channel without properly deleting it.
718  */
719 static void do_forward(struct chanlist *o,
720         struct cause_args *num, struct ast_flags64 *peerflags, int single, int *to)
721 {
722         char tmpchan[256];
723         struct ast_channel *original = o->chan;
724         struct ast_channel *c = o->chan; /* the winner */
725         struct ast_channel *in = num->chan; /* the input channel */
726         struct ast_party_redirecting *apr = &o->chan->redirecting;
727         struct ast_party_connected_line *apc = &o->chan->connected;
728         char *stuff;
729         char *tech;
730         int cause;
731
732         ast_copy_string(tmpchan, c->call_forward, sizeof(tmpchan));
733         if ((stuff = strchr(tmpchan, '/'))) {
734                 *stuff++ = '\0';
735                 tech = tmpchan;
736         } else {
737                 const char *forward_context;
738                 ast_channel_lock(c);
739                 forward_context = pbx_builtin_getvar_helper(c, "FORWARD_CONTEXT");
740                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", c->call_forward, forward_context ? forward_context : c->context);
741                 ast_channel_unlock(c);
742                 stuff = tmpchan;
743                 tech = "Local";
744         }
745         /* Before processing channel, go ahead and check for forwarding */
746         ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, c->name);
747         /* If we have been told to ignore forwards, just set this channel to null and continue processing extensions normally */
748         if (ast_test_flag64(peerflags, OPT_IGNORE_FORWARDING)) {
749                 ast_verb(3, "Forwarding %s to '%s/%s' prevented.\n", in->name, tech, stuff);
750                 c = o->chan = NULL;
751                 cause = AST_CAUSE_BUSY;
752         } else {
753                 /* Setup parameters */
754                 c = o->chan = ast_request(tech, in->nativeformats, stuff, &cause);
755                 if (c) {
756                         if (single)
757                                 ast_channel_make_compatible(o->chan, in);
758                         ast_channel_inherit_variables(in, o->chan);
759                         ast_channel_datastore_inherit(in, o->chan);
760                 } else
761                         ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s' (cause = %d)\n", tech, stuff, cause);
762         }
763         if (!c) {
764                 ast_clear_flag64(o, DIAL_STILLGOING);
765                 handle_cause(cause, num);
766                 ast_hangup(original);
767         } else {
768                 if (single) {
769                         ast_rtp_instance_early_bridge_make_compatible(c, in);
770                 }
771
772                 c->cdrflags = in->cdrflags;
773
774                 ast_channel_set_redirecting(c, apr);
775                 ast_channel_lock(c);
776                 while (ast_channel_trylock(in)) {
777                         CHANNEL_DEADLOCK_AVOIDANCE(c);
778                 }
779                 S_REPLACE(c->cid.cid_rdnis, ast_strdup(S_OR(original->cid.cid_rdnis, S_OR(in->macroexten, in->exten))));
780
781                 c->cid.cid_tns = in->cid.cid_tns;
782
783                 if (ast_test_flag64(o, OPT_FORCECLID)) {
784                         S_REPLACE(c->cid.cid_num, ast_strdupa(S_OR(in->macroexten, in->exten)));
785                         S_REPLACE(c->cid.cid_name, NULL);
786                         ast_string_field_set(c, accountcode, c->accountcode);
787                 } else {
788                         ast_party_caller_copy(&c->cid, &in->cid);
789                         ast_string_field_set(c, accountcode, in->accountcode);
790                 }
791                 ast_party_connected_line_copy(&c->connected, apc);
792
793                 S_REPLACE(in->cid.cid_rdnis, ast_strdup(c->cid.cid_rdnis));
794                 ast_channel_update_redirecting(in, apr);
795
796                 ast_clear_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE);
797                 if (ast_test_flag64(peerflags, OPT_CANCEL_TIMEOUT)) {
798                         *to = -1;
799                 }
800
801                 ast_channel_unlock(in);
802                 ast_channel_unlock(c);
803
804                 if (ast_call(c, tmpchan, 0)) {
805                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
806                         ast_clear_flag64(o, DIAL_STILLGOING);
807                         ast_hangup(original);
808                         ast_hangup(c);
809                         c = o->chan = NULL;
810                         num->nochan++;
811                 } else {
812                         ast_channel_lock(c);
813                         while (ast_channel_trylock(in)) {
814                                 CHANNEL_DEADLOCK_AVOIDANCE(c);
815                         }
816                         senddialevent(in, c, stuff);
817                         if (!ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
818                                 char cidname[AST_MAX_EXTENSION] = "";
819                                 const char *tmpexten;
820                                 tmpexten = ast_strdupa(S_OR(in->macroexten, in->exten));
821                                 ast_channel_unlock(in);
822                                 ast_channel_unlock(c);
823                                 ast_set_callerid(c, tmpexten, get_cid_name(cidname, sizeof(cidname), in), NULL);
824                         } else {
825                                 ast_channel_unlock(in);
826                                 ast_channel_unlock(c);
827                         }
828                         /* Hangup the original channel now, in case we needed it */
829                         ast_hangup(original);
830                 }
831                 if (single) {
832                         ast_indicate(in, -1);
833                 }
834         }
835 }
836
837 /* argument used for some functions. */
838 struct privacy_args {
839         int sentringing;
840         int privdb_val;
841         char privcid[256];
842         char privintro[1024];
843         char status[256];
844 };
845
846 static struct ast_channel *wait_for_answer(struct ast_channel *in,
847         struct chanlist *outgoing, int *to, struct ast_flags64 *peerflags,
848         struct privacy_args *pa,
849         const struct cause_args *num_in, int *result, char *dtmf_progress)
850 {
851         struct cause_args num = *num_in;
852         int prestart = num.busy + num.congestion + num.nochan;
853         int orig = *to;
854         struct ast_channel *peer = NULL;
855         /* single is set if only one destination is enabled */
856         int single = outgoing && !outgoing->next;
857 #ifdef HAVE_EPOLL
858         struct chanlist *epollo;
859 #endif
860         struct ast_party_connected_line connected_caller;
861         struct ast_str *featurecode = ast_str_alloca(FEATURE_MAX_LEN + 1);
862         if (single) {
863                 /* Turn off hold music, etc */
864                 if (!ast_test_flag64(outgoing, OPT_MUSICBACK | OPT_RINGBACK))
865                         ast_deactivate_generator(in);
866
867                 /* If we are calling a single channel, make them compatible for in-band tone purpose */
868                 ast_channel_make_compatible(outgoing->chan, in);
869
870                 if (!ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE) && !ast_test_flag64(outgoing, DIAL_NOCONNECTEDLINE)) {
871                         ast_channel_lock(outgoing->chan);
872                         ast_connected_line_copy_from_caller(&connected_caller, &outgoing->chan->cid);
873                         ast_channel_unlock(outgoing->chan);
874                         connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
875                         ast_channel_update_connected_line(in, &connected_caller);
876                         ast_party_connected_line_free(&connected_caller);
877                 }
878         }
879
880 #ifdef HAVE_EPOLL
881         for (epollo = outgoing; epollo; epollo = epollo->next)
882                 ast_poll_channel_add(in, epollo->chan);
883 #endif
884
885         while (*to && !peer) {
886                 struct chanlist *o;
887                 int pos = 0; /* how many channels do we handle */
888                 int numlines = prestart;
889                 struct ast_channel *winner;
890                 struct ast_channel *watchers[AST_MAX_WATCHERS];
891
892                 watchers[pos++] = in;
893                 for (o = outgoing; o; o = o->next) {
894                         /* Keep track of important channels */
895                         if (ast_test_flag64(o, DIAL_STILLGOING) && o->chan)
896                                 watchers[pos++] = o->chan;
897                         numlines++;
898                 }
899                 if (pos == 1) { /* only the input channel is available */
900                         if (numlines == (num.busy + num.congestion + num.nochan)) {
901                                 ast_verb(2, "Everyone is busy/congested at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
902                                 if (num.busy)
903                                         strcpy(pa->status, "BUSY");
904                                 else if (num.congestion)
905                                         strcpy(pa->status, "CONGESTION");
906                                 else if (num.nochan)
907                                         strcpy(pa->status, "CHANUNAVAIL");
908                         } else {
909                                 ast_verb(3, "No one is available to answer at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
910                         }
911                         *to = 0;
912                         return NULL;
913                 }
914                 winner = ast_waitfor_n(watchers, pos, to);
915                 for (o = outgoing; o; o = o->next) {
916                         struct ast_frame *f;
917                         struct ast_channel *c = o->chan;
918
919                         if (c == NULL)
920                                 continue;
921                         if (ast_test_flag64(o, DIAL_STILLGOING) && c->_state == AST_STATE_UP) {
922                                 if (!peer) {
923                                         ast_verb(3, "%s answered %s\n", c->name, in->name);
924                                         if (!single && !ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
925                                                 if (o->connected.id.number) {
926                                                         ast_channel_update_connected_line(in, &o->connected);
927                                                 } else if (!ast_test_flag64(o, DIAL_NOCONNECTEDLINE)) {
928                                                         ast_channel_lock(c);
929                                                         ast_connected_line_copy_from_caller(&connected_caller, &c->cid);
930                                                         ast_channel_unlock(c);
931                                                         connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
932                                                         ast_channel_update_connected_line(in, &connected_caller);
933                                                         ast_party_connected_line_free(&connected_caller);
934                                                 }
935                                         }
936                                         peer = c;
937                                         ast_copy_flags64(peerflags, o,
938                                                 OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
939                                                 OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
940                                                 OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
941                                                 OPT_CALLEE_PARK | OPT_CALLER_PARK |
942                                                 OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
943                                                 DIAL_NOFORWARDHTML);
944                                         ast_string_field_set(c, dialcontext, "");
945                                         ast_copy_string(c->exten, "", sizeof(c->exten));
946                                 }
947                                 continue;
948                         }
949                         if (c != winner)
950                                 continue;
951                         /* here, o->chan == c == winner */
952                         if (!ast_strlen_zero(c->call_forward)) {
953                                 do_forward(o, &num, peerflags, single, to);
954                                 continue;
955                         }
956                         f = ast_read(winner);
957                         if (!f) {
958                                 in->hangupcause = c->hangupcause;
959 #ifdef HAVE_EPOLL
960                                 ast_poll_channel_del(in, c);
961 #endif
962                                 ast_hangup(c);
963                                 c = o->chan = NULL;
964                                 ast_clear_flag64(o, DIAL_STILLGOING);
965                                 handle_cause(in->hangupcause, &num);
966                                 continue;
967                         }
968                         if (f->frametype == AST_FRAME_CONTROL) {
969                                 switch(f->subclass) {
970                                 case AST_CONTROL_ANSWER:
971                                         /* This is our guy if someone answered. */
972                                         if (!peer) {
973                                                 ast_verb(3, "%s answered %s\n", c->name, in->name);
974                                                 if (!single && !ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
975                                                         if (o->connected.id.number) {
976                                                                 ast_channel_update_connected_line(in, &o->connected);
977                                                         } else if (!ast_test_flag64(o, DIAL_NOCONNECTEDLINE)) {
978                                                                 ast_channel_lock(c);
979                                                                 ast_connected_line_copy_from_caller(&connected_caller, &c->cid);
980                                                                 ast_channel_unlock(c);
981                                                                 connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
982                                                                 ast_channel_update_connected_line(in, &connected_caller);
983                                                                 ast_party_connected_line_free(&connected_caller);
984                                                         }
985                                                 }
986                                                 peer = c;
987                                                 if (peer->cdr) {
988                                                         peer->cdr->answer = ast_tvnow();
989                                                         peer->cdr->disposition = AST_CDR_ANSWERED;
990                                                 }
991                                                 ast_copy_flags64(peerflags, o,
992                                                         OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
993                                                         OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
994                                                         OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
995                                                         OPT_CALLEE_PARK | OPT_CALLER_PARK |
996                                                         OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
997                                                         DIAL_NOFORWARDHTML);
998                                                 ast_string_field_set(c, dialcontext, "");
999                                                 ast_copy_string(c->exten, "", sizeof(c->exten));
1000                                                 if (CAN_EARLY_BRIDGE(peerflags, in, peer))
1001                                                         /* Setup early bridge if appropriate */
1002                                                         ast_channel_early_bridge(in, peer);
1003                                         }
1004                                         /* If call has been answered, then the eventual hangup is likely to be normal hangup */
1005                                         in->hangupcause = AST_CAUSE_NORMAL_CLEARING;
1006                                         c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
1007                                         break;
1008                                 case AST_CONTROL_BUSY:
1009                                         ast_verb(3, "%s is busy\n", c->name);
1010                                         in->hangupcause = c->hangupcause;
1011                                         ast_hangup(c);
1012                                         c = o->chan = NULL;
1013                                         ast_clear_flag64(o, DIAL_STILLGOING);
1014                                         handle_cause(AST_CAUSE_BUSY, &num);
1015                                         break;
1016                                 case AST_CONTROL_CONGESTION:
1017                                         ast_verb(3, "%s is circuit-busy\n", c->name);
1018                                         in->hangupcause = c->hangupcause;
1019                                         ast_hangup(c);
1020                                         c = o->chan = NULL;
1021                                         ast_clear_flag64(o, DIAL_STILLGOING);
1022                                         handle_cause(AST_CAUSE_CONGESTION, &num);
1023                                         break;
1024                                 case AST_CONTROL_RINGING:
1025                                         ast_verb(3, "%s is ringing\n", c->name);
1026                                         /* Setup early media if appropriate */
1027                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1028                                                 ast_channel_early_bridge(in, c);
1029                                         if (!(pa->sentringing) && !ast_test_flag64(outgoing, OPT_MUSICBACK)) {
1030                                                 ast_indicate(in, AST_CONTROL_RINGING);
1031                                                 pa->sentringing++;
1032                                         }
1033                                         break;
1034                                 case AST_CONTROL_PROGRESS:
1035                                         ast_verb(3, "%s is making progress passing it to %s\n", c->name, in->name);
1036                                         /* Setup early media if appropriate */
1037                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1038                                                 ast_channel_early_bridge(in, c);
1039                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK))
1040                                                 ast_indicate(in, AST_CONTROL_PROGRESS);
1041                                                 if(!ast_strlen_zero(dtmf_progress)) {
1042                                                         ast_verb(3, "Sending DTMF '%s' to the called party as result of receiving a PROGRESS message.\n", dtmf_progress);
1043                                                         ast_dtmf_stream(c, in, dtmf_progress, 250, 0);
1044                                                 }
1045                                         break;
1046                                 case AST_CONTROL_VIDUPDATE:
1047                                         ast_verb(3, "%s requested a video update, passing it to %s\n", c->name, in->name);
1048                                         ast_indicate(in, AST_CONTROL_VIDUPDATE);
1049                                         break;
1050                                 case AST_CONTROL_SRCUPDATE:
1051                                         ast_verb(3, "%s requested a source update, passing it to %s\n", c->name, in->name);
1052                                         ast_indicate(in, AST_CONTROL_SRCUPDATE);
1053                                         break;
1054                                 case AST_CONTROL_CONNECTED_LINE:
1055                                         if (ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
1056                                                 ast_verb(3, "Connected line update to %s prevented.\n", in->name);
1057                                         } else if (!single) {
1058                                                 struct ast_party_connected_line connected;
1059                                                 ast_verb(3, "%s connected line has changed. Saving it until answer for %s\n", c->name, in->name);
1060                                                 ast_party_connected_line_set_init(&connected, &o->connected);
1061                                                 ast_connected_line_parse_data(f->data.ptr, f->datalen, &connected);
1062                                                 ast_party_connected_line_set(&o->connected, &connected);
1063                                                 ast_party_connected_line_free(&connected);
1064                                         } else {
1065                                                 ast_verb(3, "%s connected line has changed, passing it to %s\n", c->name, in->name);
1066                                                 ast_indicate_data(in, AST_CONTROL_CONNECTED_LINE, f->data.ptr, f->datalen);
1067                                         }
1068                                         break;
1069                                 case AST_CONTROL_REDIRECTING:
1070                                         if (ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
1071                                                 ast_verb(3, "Redirecting update to %s prevented.\n", in->name);
1072                                         } else {
1073                                                 ast_verb(3, "%s redirecting info has changed, passing it to %s\n", c->name, in->name);
1074                                                 ast_indicate_data(in, AST_CONTROL_REDIRECTING, f->data.ptr, f->datalen);
1075                                         }
1076                                         break;
1077                                 case AST_CONTROL_PROCEEDING:
1078                                         ast_verb(3, "%s is proceeding passing it to %s\n", c->name, in->name);
1079                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1080                                                 ast_channel_early_bridge(in, c);
1081                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK))
1082                                                 ast_indicate(in, AST_CONTROL_PROCEEDING);
1083                                         break;
1084                                 case AST_CONTROL_HOLD:
1085                                         ast_verb(3, "Call on %s placed on hold\n", c->name);
1086                                         ast_indicate(in, AST_CONTROL_HOLD);
1087                                         break;
1088                                 case AST_CONTROL_UNHOLD:
1089                                         ast_verb(3, "Call on %s left from hold\n", c->name);
1090                                         ast_indicate(in, AST_CONTROL_UNHOLD);
1091                                         break;
1092                                 case AST_CONTROL_OFFHOOK:
1093                                 case AST_CONTROL_FLASH:
1094                                         /* Ignore going off hook and flash */
1095                                         break;
1096                                 case -1:
1097                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK | OPT_MUSICBACK)) {
1098                                                 ast_verb(3, "%s stopped sounds\n", c->name);
1099                                                 ast_indicate(in, -1);
1100                                                 pa->sentringing = 0;
1101                                         }
1102                                         break;
1103                                 default:
1104                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
1105                                 }
1106                         } else if (single) {
1107                                 switch (f->frametype) {
1108                                         case AST_FRAME_VOICE:
1109                                         case AST_FRAME_IMAGE:
1110                                         case AST_FRAME_TEXT:
1111                                                 if (ast_write(in, f)) {
1112                                                         ast_log(LOG_WARNING, "Unable to write frame\n");
1113                                                 }
1114                                                 break;
1115                                         case AST_FRAME_HTML:
1116                                                 if (!ast_test_flag64(outgoing, DIAL_NOFORWARDHTML) && ast_channel_sendhtml(in, f->subclass, f->data.ptr, f->datalen) == -1) {
1117                                                         ast_log(LOG_WARNING, "Unable to send URL\n");
1118                                                 }
1119                                                 break;
1120                                         default:
1121                                                 break;
1122                                 }
1123                         }
1124                         ast_frfree(f);
1125                 } /* end for */
1126                 if (winner == in) {
1127                         struct ast_frame *f = ast_read(in);
1128 #if 0
1129                         if (f && (f->frametype != AST_FRAME_VOICE))
1130                                 printf("Frame type: %d, %d\n", f->frametype, f->subclass);
1131                         else if (!f || (f->frametype != AST_FRAME_VOICE))
1132                                 printf("Hangup received on %s\n", in->name);
1133 #endif
1134                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
1135                                 /* Got hung up */
1136                                 *to = -1;
1137                                 strcpy(pa->status, "CANCEL");
1138                                 ast_cdr_noanswer(in->cdr);
1139                                 if (f) {
1140                                         if (f->data.uint32) {
1141                                                 in->hangupcause = f->data.uint32;
1142                                         }
1143                                         ast_frfree(f);
1144                                 }
1145                                 return NULL;
1146                         }
1147
1148                         /* now f is guaranteed non-NULL */
1149                         if (f->frametype == AST_FRAME_DTMF) {
1150                                 if (ast_test_flag64(peerflags, OPT_DTMF_EXIT)) {
1151                                         const char *context;
1152                                         ast_channel_lock(in);
1153                                         context = pbx_builtin_getvar_helper(in, "EXITCONTEXT");
1154                                         if (onedigit_goto(in, context, (char) f->subclass, 1)) {
1155                                                 ast_verb(3, "User hit %c to disconnect call.\n", f->subclass);
1156                                                 *to = 0;
1157                                                 ast_cdr_noanswer(in->cdr);
1158                                                 *result = f->subclass;
1159                                                 strcpy(pa->status, "CANCEL");
1160                                                 ast_frfree(f);
1161                                                 ast_channel_unlock(in);
1162                                                 return NULL;
1163                                         }
1164                                         ast_channel_unlock(in);
1165                                 }
1166
1167                                 if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP) &&
1168                                         detect_disconnect(in, f->subclass, featurecode)) {
1169                                         ast_verb(3, "User requested call disconnect.\n");
1170                                         *to = 0;
1171                                         strcpy(pa->status, "CANCEL");
1172                                         ast_cdr_noanswer(in->cdr);
1173                                         ast_frfree(f);
1174                                         return NULL;
1175                                 }
1176                         }
1177
1178                         /* Forward HTML stuff */
1179                         if (single && (f->frametype == AST_FRAME_HTML) && !ast_test_flag64(outgoing, DIAL_NOFORWARDHTML))
1180                                 if (ast_channel_sendhtml(outgoing->chan, f->subclass, f->data.ptr, f->datalen) == -1)
1181                                         ast_log(LOG_WARNING, "Unable to send URL\n");
1182
1183                         if (single && ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_DTMF_BEGIN) || (f->frametype == AST_FRAME_DTMF_END)))  {
1184                                 if (ast_write(outgoing->chan, f))
1185                                         ast_log(LOG_WARNING, "Unable to forward voice or dtmf\n");
1186                         }
1187                         if (single && (f->frametype == AST_FRAME_CONTROL) &&
1188                                 ((f->subclass == AST_CONTROL_HOLD) ||
1189                                 (f->subclass == AST_CONTROL_UNHOLD) ||
1190                                 (f->subclass == AST_CONTROL_VIDUPDATE) ||
1191                                 (f->subclass == AST_CONTROL_SRCUPDATE) ||
1192                                 (f->subclass == AST_CONTROL_CONNECTED_LINE) ||
1193                                 (f->subclass == AST_CONTROL_REDIRECTING))) {
1194                                 ast_verb(3, "%s requested special control %d, passing it to %s\n", in->name, f->subclass, outgoing->chan->name);
1195                                 ast_indicate_data(outgoing->chan, f->subclass, f->data.ptr, f->datalen);
1196                         }
1197                         ast_frfree(f);
1198                 }
1199                 if (!*to)
1200                         ast_verb(3, "Nobody picked up in %d ms\n", orig);
1201                 if (!*to || ast_check_hangup(in))
1202                         ast_cdr_noanswer(in->cdr);
1203         }
1204
1205 #ifdef HAVE_EPOLL
1206         for (epollo = outgoing; epollo; epollo = epollo->next) {
1207                 if (epollo->chan)
1208                         ast_poll_channel_del(in, epollo->chan);
1209         }
1210 #endif
1211
1212         return peer;
1213 }
1214
1215 static int detect_disconnect(struct ast_channel *chan, char code, struct ast_str *featurecode)
1216 {
1217         struct ast_flags features = { AST_FEATURE_DISCONNECT }; /* only concerned with disconnect feature */
1218         struct ast_call_feature feature = { 0, };
1219         int res;
1220
1221         ast_str_append(&featurecode, 1, "%c", code);
1222
1223         res = ast_feature_detect(chan, &features, ast_str_buffer(featurecode), &feature);
1224
1225         if (res != AST_FEATURE_RETURN_STOREDIGITS) {
1226                 ast_str_reset(featurecode);
1227         }
1228         if (feature.feature_mask & AST_FEATURE_DISCONNECT) {
1229                 return 1;
1230         }
1231
1232         return 0;
1233 }
1234
1235 static void replace_macro_delimiter(char *s)
1236 {
1237         for (; *s; s++)
1238                 if (*s == '^')
1239                         *s = ',';
1240 }
1241
1242 /* returns true if there is a valid privacy reply */
1243 static int valid_priv_reply(struct ast_flags64 *opts, int res)
1244 {
1245         if (res < '1')
1246                 return 0;
1247         if (ast_test_flag64(opts, OPT_PRIVACY) && res <= '5')
1248                 return 1;
1249         if (ast_test_flag64(opts, OPT_SCREENING) && res <= '4')
1250                 return 1;
1251         return 0;
1252 }
1253
1254 static int do_timelimit(struct ast_channel *chan, struct ast_bridge_config *config,
1255         char *parse, struct timeval *calldurationlimit)
1256 {
1257         char *stringp = ast_strdupa(parse);
1258         char *limit_str, *warning_str, *warnfreq_str;
1259         const char *var;
1260         int play_to_caller = 0, play_to_callee = 0;
1261         int delta;
1262
1263         limit_str = strsep(&stringp, ":");
1264         warning_str = strsep(&stringp, ":");
1265         warnfreq_str = strsep(&stringp, ":");
1266
1267         config->timelimit = atol(limit_str);
1268         if (warning_str)
1269                 config->play_warning = atol(warning_str);
1270         if (warnfreq_str)
1271                 config->warning_freq = atol(warnfreq_str);
1272
1273         if (!config->timelimit) {
1274                 ast_log(LOG_WARNING, "Dial does not accept L(%s), hanging up.\n", limit_str);
1275                 config->timelimit = config->play_warning = config->warning_freq = 0;
1276                 config->warning_sound = NULL;
1277                 return -1; /* error */
1278         } else if ( (delta = config->play_warning - config->timelimit) > 0) {
1279                 int w = config->warning_freq;
1280
1281                 /* If the first warning is requested _after_ the entire call would end,
1282                    and no warning frequency is requested, then turn off the warning. If
1283                    a warning frequency is requested, reduce the 'first warning' time by
1284                    that frequency until it falls within the call's total time limit.
1285                    Graphically:
1286                                   timelim->|    delta        |<-playwarning
1287                         0__________________|_________________|
1288                                          | w  |    |    |    |
1289
1290                    so the number of intervals to cut is 1+(delta-1)/w
1291                 */
1292
1293                 if (w == 0) {
1294                         config->play_warning = 0;
1295                 } else {
1296                         config->play_warning -= w * ( 1 + (delta-1)/w );
1297                         if (config->play_warning < 1)
1298                                 config->play_warning = config->warning_freq = 0;
1299                 }
1300         }
1301         
1302         ast_channel_lock(chan);
1303
1304         var = pbx_builtin_getvar_helper(chan, "LIMIT_PLAYAUDIO_CALLER");
1305
1306         play_to_caller = var ? ast_true(var) : 1;
1307
1308         var = pbx_builtin_getvar_helper(chan, "LIMIT_PLAYAUDIO_CALLEE");
1309         play_to_callee = var ? ast_true(var) : 0;
1310
1311         if (!play_to_caller && !play_to_callee)
1312                 play_to_caller = 1;
1313
1314         var = pbx_builtin_getvar_helper(chan, "LIMIT_WARNING_FILE");
1315         config->warning_sound = !ast_strlen_zero(var) ? ast_strdup(var) : ast_strdup("timeleft");
1316
1317         /* The code looking at config wants a NULL, not just "", to decide
1318          * that the message should not be played, so we replace "" with NULL.
1319          * Note, pbx_builtin_getvar_helper _can_ return NULL if the variable is
1320          * not found.
1321          */
1322
1323         var = pbx_builtin_getvar_helper(chan, "LIMIT_TIMEOUT_FILE");
1324         config->end_sound = !ast_strlen_zero(var) ? ast_strdup(var) : NULL;
1325
1326         var = pbx_builtin_getvar_helper(chan, "LIMIT_CONNECT_FILE");
1327         config->start_sound = !ast_strlen_zero(var) ? ast_strdup(var) : NULL;
1328
1329         ast_channel_unlock(chan);
1330
1331         /* undo effect of S(x) in case they are both used */
1332         calldurationlimit->tv_sec = 0;
1333         calldurationlimit->tv_usec = 0;
1334
1335         /* more efficient to do it like S(x) does since no advanced opts */
1336         if (!config->play_warning && !config->start_sound && !config->end_sound && config->timelimit) {
1337                 calldurationlimit->tv_sec = config->timelimit / 1000;
1338                 calldurationlimit->tv_usec = (config->timelimit % 1000) * 1000;
1339                 ast_verb(3, "Setting call duration limit to %.3lf seconds.\n",
1340                         calldurationlimit->tv_sec + calldurationlimit->tv_usec / 1000000.0);
1341                 config->timelimit = play_to_caller = play_to_callee =
1342                 config->play_warning = config->warning_freq = 0;
1343         } else {
1344                 ast_verb(3, "Limit Data for this call:\n");
1345                 ast_verb(4, "timelimit      = %ld\n", config->timelimit);
1346                 ast_verb(4, "play_warning   = %ld\n", config->play_warning);
1347                 ast_verb(4, "play_to_caller = %s\n", play_to_caller ? "yes" : "no");
1348                 ast_verb(4, "play_to_callee = %s\n", play_to_callee ? "yes" : "no");
1349                 ast_verb(4, "warning_freq   = %ld\n", config->warning_freq);
1350                 ast_verb(4, "start_sound    = %s\n", S_OR(config->start_sound, ""));
1351                 ast_verb(4, "warning_sound  = %s\n", config->warning_sound);
1352                 ast_verb(4, "end_sound      = %s\n", S_OR(config->end_sound, ""));
1353         }
1354         if (play_to_caller)
1355                 ast_set_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
1356         if (play_to_callee)
1357                 ast_set_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
1358         return 0;
1359 }
1360
1361 static int do_privacy(struct ast_channel *chan, struct ast_channel *peer,
1362         struct ast_flags64 *opts, char **opt_args, struct privacy_args *pa)
1363 {
1364
1365         int res2;
1366         int loopcount = 0;
1367
1368         /* Get the user's intro, store it in priv-callerintros/$CID,
1369            unless it is already there-- this should be done before the
1370            call is actually dialed  */
1371
1372         /* all ring indications and moh for the caller has been halted as soon as the
1373            target extension was picked up. We are going to have to kill some
1374            time and make the caller believe the peer hasn't picked up yet */
1375
1376         if (ast_test_flag64(opts, OPT_MUSICBACK) && !ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
1377                 char *original_moh = ast_strdupa(chan->musicclass);
1378                 ast_indicate(chan, -1);
1379                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
1380                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
1381                 ast_string_field_set(chan, musicclass, original_moh);
1382         } else if (ast_test_flag64(opts, OPT_RINGBACK)) {
1383                 ast_indicate(chan, AST_CONTROL_RINGING);
1384                 pa->sentringing++;
1385         }
1386
1387         /* Start autoservice on the other chan ?? */
1388         res2 = ast_autoservice_start(chan);
1389         /* Now Stream the File */
1390         for (loopcount = 0; loopcount < 3; loopcount++) {
1391                 if (res2 && loopcount == 0) /* error in ast_autoservice_start() */
1392                         break;
1393                 if (!res2) /* on timeout, play the message again */
1394                         res2 = ast_play_and_wait(peer, "priv-callpending");
1395                 if (!valid_priv_reply(opts, res2))
1396                         res2 = 0;
1397                 /* priv-callpending script:
1398                    "I have a caller waiting, who introduces themselves as:"
1399                 */
1400                 if (!res2)
1401                         res2 = ast_play_and_wait(peer, pa->privintro);
1402                 if (!valid_priv_reply(opts, res2))
1403                         res2 = 0;
1404                 /* now get input from the called party, as to their choice */
1405                 if (!res2) {
1406                         /* XXX can we have both, or they are mutually exclusive ? */
1407                         if (ast_test_flag64(opts, OPT_PRIVACY))
1408                                 res2 = ast_play_and_wait(peer, "priv-callee-options");
1409                         if (ast_test_flag64(opts, OPT_SCREENING))
1410                                 res2 = ast_play_and_wait(peer, "screen-callee-options");
1411                 }
1412                 /*! \page DialPrivacy Dial Privacy scripts
1413                 \par priv-callee-options script:
1414                         "Dial 1 if you wish this caller to reach you directly in the future,
1415                                 and immediately connect to their incoming call
1416                          Dial 2 if you wish to send this caller to voicemail now and
1417                                 forevermore.
1418                          Dial 3 to send this caller to the torture menus, now and forevermore.
1419                          Dial 4 to send this caller to a simple "go away" menu, now and forevermore.
1420                          Dial 5 to allow this caller to come straight thru to you in the future,
1421                                 but right now, just this once, send them to voicemail."
1422                 \par screen-callee-options script:
1423                         "Dial 1 if you wish to immediately connect to the incoming call
1424                          Dial 2 if you wish to send this caller to voicemail.
1425                          Dial 3 to send this caller to the torture menus.
1426                          Dial 4 to send this caller to a simple "go away" menu.
1427                 */
1428                 if (valid_priv_reply(opts, res2))
1429                         break;
1430                 /* invalid option */
1431                 res2 = ast_play_and_wait(peer, "vm-sorry");
1432         }
1433
1434         if (ast_test_flag64(opts, OPT_MUSICBACK)) {
1435                 ast_moh_stop(chan);
1436         } else if (ast_test_flag64(opts, OPT_RINGBACK)) {
1437                 ast_indicate(chan, -1);
1438                 pa->sentringing = 0;
1439         }
1440         ast_autoservice_stop(chan);
1441         if (ast_test_flag64(opts, OPT_PRIVACY) && (res2 >= '1' && res2 <= '5')) {
1442                 /* map keypresses to various things, the index is res2 - '1' */
1443                 static const char *_val[] = { "ALLOW", "DENY", "TORTURE", "KILL", "ALLOW" };
1444                 static const int _flag[] = { AST_PRIVACY_ALLOW, AST_PRIVACY_DENY, AST_PRIVACY_TORTURE, AST_PRIVACY_KILL, AST_PRIVACY_ALLOW};
1445                 int i = res2 - '1';
1446                 ast_verb(3, "--Set privacy database entry %s/%s to %s\n",
1447                         opt_args[OPT_ARG_PRIVACY], pa->privcid, _val[i]);
1448                 ast_privacy_set(opt_args[OPT_ARG_PRIVACY], pa->privcid, _flag[i]);
1449         }
1450         switch (res2) {
1451         case '1':
1452                 break;
1453         case '2':
1454                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1455                 break;
1456         case '3':
1457                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1458                 break;
1459         case '4':
1460                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1461                 break;
1462         case '5':
1463                 /* XXX should we set status to DENY ? */
1464                 if (ast_test_flag64(opts, OPT_PRIVACY))
1465                         break;
1466                 /* if not privacy, then 5 is the same as "default" case */
1467         default: /* bad input or -1 if failure to start autoservice */
1468                 /* well, if the user messes up, ... he had his chance... What Is The Best Thing To Do?  */
1469                 /* well, there seems basically two choices. Just patch the caller thru immediately,
1470                           or,... put 'em thru to voicemail. */
1471                 /* since the callee may have hung up, let's do the voicemail thing, no database decision */
1472                 ast_log(LOG_NOTICE, "privacy: no valid response from the callee. Sending the caller to voicemail, the callee isn't responding\n");
1473                 /* XXX should we set status to DENY ? */
1474                 /* XXX what about the privacy flags ? */
1475                 break;
1476         }
1477
1478         if (res2 == '1') { /* the only case where we actually connect */
1479                 /* if the intro is NOCALLERID, then there's no reason to leave it on disk, it'll
1480                    just clog things up, and it's not useful information, not being tied to a CID */
1481                 if (strncmp(pa->privcid, "NOCALLERID", 10) == 0 || ast_test_flag64(opts, OPT_SCREEN_NOINTRO)) {
1482                         ast_filedelete(pa->privintro, NULL);
1483                         if (ast_fileexists(pa->privintro, NULL, NULL) > 0)
1484                                 ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1485                         else
1486                                 ast_verb(3, "Successfully deleted %s intro file\n", pa->privintro);
1487                 }
1488                 return 0; /* the good exit path */
1489         } else {
1490                 ast_hangup(peer); /* hang up on the callee -- he didn't want to talk anyway! */
1491                 return -1;
1492         }
1493 }
1494
1495 /*! \brief returns 1 if successful, 0 or <0 if the caller should 'goto out' */
1496 static int setup_privacy_args(struct privacy_args *pa,
1497         struct ast_flags64 *opts, char *opt_args[], struct ast_channel *chan)
1498 {
1499         char callerid[60];
1500         int res;
1501         char *l;
1502         int silencethreshold;
1503
1504         if (!ast_strlen_zero(chan->cid.cid_num)) {
1505                 l = ast_strdupa(chan->cid.cid_num);
1506                 ast_shrink_phone_number(l);
1507                 if (ast_test_flag64(opts, OPT_PRIVACY) ) {
1508                         ast_verb(3, "Privacy DB is '%s', clid is '%s'\n", opt_args[OPT_ARG_PRIVACY], l);
1509                         pa->privdb_val = ast_privacy_check(opt_args[OPT_ARG_PRIVACY], l);
1510                 } else {
1511                         ast_verb(3, "Privacy Screening, clid is '%s'\n", l);
1512                         pa->privdb_val = AST_PRIVACY_UNKNOWN;
1513                 }
1514         } else {
1515                 char *tnam, *tn2;
1516
1517                 tnam = ast_strdupa(chan->name);
1518                 /* clean the channel name so slashes don't try to end up in disk file name */
1519                 for (tn2 = tnam; *tn2; tn2++) {
1520                         if (*tn2 == '/')  /* any other chars to be afraid of? */
1521                                 *tn2 = '=';
1522                 }
1523                 ast_verb(3, "Privacy-- callerid is empty\n");
1524
1525                 snprintf(callerid, sizeof(callerid), "NOCALLERID_%s%s", chan->exten, tnam);
1526                 l = callerid;
1527                 pa->privdb_val = AST_PRIVACY_UNKNOWN;
1528         }
1529
1530         ast_copy_string(pa->privcid, l, sizeof(pa->privcid));
1531
1532         if (strncmp(pa->privcid, "NOCALLERID", 10) != 0 && ast_test_flag64(opts, OPT_SCREEN_NOCALLERID)) {
1533                 /* if callerid is set and OPT_SCREEN_NOCALLERID is set also */
1534                 ast_verb(3, "CallerID set (%s); N option set; Screening should be off\n", pa->privcid);
1535                 pa->privdb_val = AST_PRIVACY_ALLOW;
1536         } else if (ast_test_flag64(opts, OPT_SCREEN_NOCALLERID) && strncmp(pa->privcid, "NOCALLERID", 10) == 0) {
1537                 ast_verb(3, "CallerID blank; N option set; Screening should happen; dbval is %d\n", pa->privdb_val);
1538         }
1539         
1540         if (pa->privdb_val == AST_PRIVACY_DENY) {
1541                 ast_verb(3, "Privacy DB reports PRIVACY_DENY for this callerid. Dial reports unavailable\n");
1542                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1543                 return 0;
1544         } else if (pa->privdb_val == AST_PRIVACY_KILL) {
1545                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1546                 return 0; /* Is this right? */
1547         } else if (pa->privdb_val == AST_PRIVACY_TORTURE) {
1548                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1549                 return 0; /* is this right??? */
1550         } else if (pa->privdb_val == AST_PRIVACY_UNKNOWN) {
1551                 /* Get the user's intro, store it in priv-callerintros/$CID,
1552                    unless it is already there-- this should be done before the
1553                    call is actually dialed  */
1554
1555                 /* make sure the priv-callerintros dir actually exists */
1556                 snprintf(pa->privintro, sizeof(pa->privintro), "%s/sounds/priv-callerintros", ast_config_AST_DATA_DIR);
1557                 if ((res = ast_mkdir(pa->privintro, 0755))) {
1558                         ast_log(LOG_WARNING, "privacy: can't create directory priv-callerintros: %s\n", strerror(res));
1559                         return -1;
1560                 }
1561
1562                 snprintf(pa->privintro, sizeof(pa->privintro), "priv-callerintros/%s", pa->privcid);
1563                 if (ast_fileexists(pa->privintro, NULL, NULL ) > 0 && strncmp(pa->privcid, "NOCALLERID", 10) != 0) {
1564                         /* the DELUX version of this code would allow this caller the
1565                            option to hear and retape their previously recorded intro.
1566                         */
1567                 } else {
1568                         int duration; /* for feedback from play_and_wait */
1569                         /* the file doesn't exist yet. Let the caller submit his
1570                            vocal intro for posterity */
1571                         /* priv-recordintro script:
1572
1573                            "At the tone, please say your name:"
1574
1575                         */
1576                         silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
1577                         ast_answer(chan);
1578                         res = ast_play_and_record(chan, "priv-recordintro", pa->privintro, 4, "gsm", &duration, silencethreshold, 2000, 0);  /* NOTE: I've reduced the total time to 4 sec */
1579                                                                         /* don't think we'll need a lock removed, we took care of
1580                                                                            conflicts by naming the pa.privintro file */
1581                         if (res == -1) {
1582                                 /* Delete the file regardless since they hung up during recording */
1583                                 ast_filedelete(pa->privintro, NULL);
1584                                 if (ast_fileexists(pa->privintro, NULL, NULL) > 0)
1585                                         ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1586                                 else
1587                                         ast_verb(3, "Successfully deleted %s intro file\n", pa->privintro);
1588                                 return -1;
1589                         }
1590                         if (!ast_streamfile(chan, "vm-dialout", chan->language) )
1591                                 ast_waitstream(chan, "");
1592                 }
1593         }
1594         return 1; /* success */
1595 }
1596
1597 static void end_bridge_callback(void *data)
1598 {
1599         char buf[80];
1600         time_t end;
1601         struct ast_channel *chan = data;
1602
1603         if (!chan->cdr) {
1604                 return;
1605         }
1606
1607         time(&end);
1608
1609         ast_channel_lock(chan);
1610         if (chan->cdr->answer.tv_sec) {
1611                 snprintf(buf, sizeof(buf), "%ld", end - chan->cdr->answer.tv_sec);
1612                 pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", buf);
1613         }
1614
1615         if (chan->cdr->start.tv_sec) {
1616                 snprintf(buf, sizeof(buf), "%ld", end - chan->cdr->start.tv_sec);
1617                 pbx_builtin_setvar_helper(chan, "DIALEDTIME", buf);
1618         }
1619         ast_channel_unlock(chan);
1620 }
1621
1622 static void end_bridge_callback_data_fixup(struct ast_bridge_config *bconfig, struct ast_channel *originator, struct ast_channel *terminator) {
1623         bconfig->end_bridge_callback_data = originator;
1624 }
1625
1626 static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags64 *peerflags, int *continue_exec)
1627 {
1628         int res = -1; /* default: error */
1629         char *rest, *cur; /* scan the list of destinations */
1630         struct chanlist *outgoing = NULL; /* list of destinations */
1631         struct ast_channel *peer;
1632         int to; /* timeout */
1633         struct cause_args num = { chan, 0, 0, 0 };
1634         int cause;
1635         char numsubst[256];
1636         char cidname[AST_MAX_EXTENSION] = "";
1637
1638         struct ast_bridge_config config = { { 0, } };
1639         struct timeval calldurationlimit = { 0, };
1640         char *dtmfcalled = NULL, *dtmfcalling = NULL, *dtmf_progress=NULL;
1641         struct privacy_args pa = {
1642                 .sentringing = 0,
1643                 .privdb_val = 0,
1644                 .status = "INVALIDARGS",
1645         };
1646         int sentringing = 0, moh = 0;
1647         const char *outbound_group = NULL;
1648         int result = 0;
1649         char *parse;
1650         int opermode = 0;
1651         AST_DECLARE_APP_ARGS(args,
1652                 AST_APP_ARG(peers);
1653                 AST_APP_ARG(timeout);
1654                 AST_APP_ARG(options);
1655                 AST_APP_ARG(url);
1656         );
1657         struct ast_flags64 opts = { 0, };
1658         char *opt_args[OPT_ARG_ARRAY_SIZE];
1659         struct ast_datastore *datastore = NULL;
1660         int fulldial = 0, num_dialed = 0;
1661
1662         /* Reset all DIAL variables back to blank, to prevent confusion (in case we don't reset all of them). */
1663         pbx_builtin_setvar_helper(chan, "DIALSTATUS", "");
1664         pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", "");
1665         pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", "");
1666         pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", "");
1667         pbx_builtin_setvar_helper(chan, "DIALEDTIME", "");
1668
1669         if (ast_strlen_zero(data)) {
1670                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1671                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1672                 return -1;
1673         }
1674
1675         parse = ast_strdupa(data);
1676
1677         AST_STANDARD_APP_ARGS(args, parse);
1678
1679         if (!ast_strlen_zero(args.options) &&
1680                 ast_app_parse_options64(dial_exec_options, &opts, opt_args, args.options)) {
1681                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1682                 goto done;
1683         }
1684
1685         if (ast_strlen_zero(args.peers)) {
1686                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1687                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1688                 goto done;
1689         }
1690
1691         if (ast_test_flag64(&opts, OPT_OPERMODE)) {
1692                 opermode = ast_strlen_zero(opt_args[OPT_ARG_OPERMODE]) ? 1 : atoi(opt_args[OPT_ARG_OPERMODE]);
1693                 ast_verb(3, "Setting operator services mode to %d.\n", opermode);
1694         }
1695
1696         if (ast_test_flag64(&opts, OPT_DURATION_STOP) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_STOP])) {
1697                 calldurationlimit.tv_sec = atoi(opt_args[OPT_ARG_DURATION_STOP]);
1698                 if (!calldurationlimit.tv_sec) {
1699                         ast_log(LOG_WARNING, "Dial does not accept S(%s), hanging up.\n", opt_args[OPT_ARG_DURATION_STOP]);
1700                         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1701                         goto done;
1702                 }
1703                 ast_verb(3, "Setting call duration limit to %.3lf seconds.\n", calldurationlimit.tv_sec + calldurationlimit.tv_usec / 1000000.0);
1704         }
1705
1706         if (ast_test_flag64(&opts, OPT_SENDDTMF) && !ast_strlen_zero(opt_args[OPT_ARG_SENDDTMF])) {
1707                 dtmf_progress = opt_args[OPT_ARG_SENDDTMF];
1708                 dtmfcalled = strsep(&dtmf_progress, ":");
1709                 dtmfcalling = strsep(&dtmf_progress, ":");
1710         }
1711
1712         if (ast_test_flag64(&opts, OPT_DURATION_LIMIT) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_LIMIT])) {
1713                 if (do_timelimit(chan, &config, opt_args[OPT_ARG_DURATION_LIMIT], &calldurationlimit))
1714                         goto done;
1715         }
1716
1717         if (ast_test_flag64(&opts, OPT_RESETCDR) && chan->cdr)
1718                 ast_cdr_reset(chan->cdr, NULL);
1719         if (ast_test_flag64(&opts, OPT_PRIVACY) && ast_strlen_zero(opt_args[OPT_ARG_PRIVACY]))
1720                 opt_args[OPT_ARG_PRIVACY] = ast_strdupa(chan->exten);
1721
1722         if (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) {
1723                 res = setup_privacy_args(&pa, &opts, opt_args, chan);
1724                 if (res <= 0)
1725                         goto out;
1726                 res = -1; /* reset default */
1727         }
1728
1729         if (ast_test_flag64(&opts, OPT_DTMF_EXIT) || ast_test_flag64(&opts, OPT_CALLER_HANGUP)) {
1730                 __ast_answer(chan, 0, 0);
1731         }
1732
1733         if (continue_exec)
1734                 *continue_exec = 0;
1735
1736         /* If a channel group has been specified, get it for use when we create peer channels */
1737
1738         ast_channel_lock(chan);
1739         if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP_ONCE"))) {
1740                 outbound_group = ast_strdupa(outbound_group);   
1741                 pbx_builtin_setvar_helper(chan, "OUTBOUND_GROUP_ONCE", NULL);
1742         } else if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP"))) {
1743                 outbound_group = ast_strdupa(outbound_group);
1744         }
1745         ast_channel_unlock(chan);       
1746         ast_copy_flags64(peerflags, &opts, OPT_DTMF_EXIT | OPT_GO_ON | OPT_ORIGINAL_CLID | OPT_CALLER_HANGUP | OPT_IGNORE_FORWARDING | OPT_IGNORE_CONNECTEDLINE | OPT_CANCEL_TIMEOUT);
1747
1748         /* loop through the list of dial destinations */
1749         rest = args.peers;
1750         while ((cur = strsep(&rest, "&")) ) {
1751                 struct chanlist *tmp;
1752                 struct ast_channel *tc; /* channel for this destination */
1753                 /* Get a technology/[device:]number pair */
1754                 char *number = cur;
1755                 char *interface = ast_strdupa(number);
1756                 char *tech = strsep(&number, "/");
1757                 /* find if we already dialed this interface */
1758                 struct ast_dialed_interface *di;
1759                 AST_LIST_HEAD(, ast_dialed_interface) *dialed_interfaces;
1760                 num_dialed++;
1761                 if (!number) {
1762                         ast_log(LOG_WARNING, "Dial argument takes format (technology/[device:]number1)\n");
1763                         goto out;
1764                 }
1765                 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1766                         goto out;
1767                 if (opts.flags) {
1768                         ast_copy_flags64(tmp, &opts,
1769                                 OPT_CANCEL_ELSEWHERE |
1770                                 OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
1771                                 OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
1772                                 OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
1773                                 OPT_CALLEE_PARK | OPT_CALLER_PARK |
1774                                 OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
1775                                 OPT_RINGBACK | OPT_MUSICBACK | OPT_FORCECLID);
1776                         ast_set2_flag64(tmp, args.url, DIAL_NOFORWARDHTML);
1777                 }
1778                 ast_copy_string(numsubst, number, sizeof(numsubst));
1779                 /* Request the peer */
1780
1781                 ast_channel_lock(chan);
1782                 datastore = ast_channel_datastore_find(chan, &dialed_interface_info, NULL);
1783                 /* If the incoming channel has previously had connected line information
1784                  * set on it (perhaps through the CONNECTED_LINE dialplan function) then
1785                  * seed the calllist's connected line information with this previously
1786                  * acquired info
1787                  */
1788                 if (chan->connected.id.number) {
1789                         ast_party_connected_line_copy(&tmp->connected, &chan->connected);
1790                 }
1791                 ast_channel_unlock(chan);
1792
1793                 if (datastore)
1794                         dialed_interfaces = datastore->data;
1795                 else {
1796                         if (!(datastore = ast_datastore_alloc(&dialed_interface_info, NULL))) {
1797                                 ast_log(LOG_WARNING, "Unable to create channel datastore for dialed interfaces. Aborting!\n");
1798                                 ast_free(tmp);
1799                                 goto out;
1800                         }
1801
1802                         datastore->inheritance = DATASTORE_INHERIT_FOREVER;
1803
1804                         if (!(dialed_interfaces = ast_calloc(1, sizeof(*dialed_interfaces)))) {
1805                                 ast_free(tmp);
1806                                 goto out;
1807                         }
1808
1809                         datastore->data = dialed_interfaces;
1810                         AST_LIST_HEAD_INIT(dialed_interfaces);
1811
1812                         ast_channel_lock(chan);
1813                         ast_channel_datastore_add(chan, datastore);
1814                         ast_channel_unlock(chan);
1815                 }
1816
1817                 AST_LIST_LOCK(dialed_interfaces);
1818                 AST_LIST_TRAVERSE(dialed_interfaces, di, list) {
1819                         if (!strcasecmp(di->interface, interface)) {
1820                                 ast_log(LOG_WARNING, "Skipping dialing interface '%s' again since it has already been dialed\n",
1821                                         di->interface);
1822                                 break;
1823                         }
1824                 }
1825                 AST_LIST_UNLOCK(dialed_interfaces);
1826
1827                 if (di) {
1828                         fulldial++;
1829                         ast_free(tmp);
1830                         continue;
1831                 }
1832
1833                 /* It is always ok to dial a Local interface.  We only keep track of
1834                  * which "real" interfaces have been dialed.  The Local channel will
1835                  * inherit this list so that if it ends up dialing a real interface,
1836                  * it won't call one that has already been called. */
1837                 if (strcasecmp(tech, "Local")) {
1838                         if (!(di = ast_calloc(1, sizeof(*di) + strlen(interface)))) {
1839                                 AST_LIST_UNLOCK(dialed_interfaces);
1840                                 ast_free(tmp);
1841                                 goto out;
1842                         }
1843                         strcpy(di->interface, interface);
1844
1845                         AST_LIST_LOCK(dialed_interfaces);
1846                         AST_LIST_INSERT_TAIL(dialed_interfaces, di, list);
1847                         AST_LIST_UNLOCK(dialed_interfaces);
1848                 }
1849
1850                 tc = ast_request(tech, chan->nativeformats, numsubst, &cause);
1851                 if (!tc) {
1852                         /* If we can't, just go on to the next call */
1853                         ast_log(LOG_WARNING, "Unable to create channel of type '%s' (cause %d - %s)\n",
1854                                 tech, cause, ast_cause2str(cause));
1855                         handle_cause(cause, &num);
1856                         if (!rest) /* we are on the last destination */
1857                                 chan->hangupcause = cause;
1858                         ast_free(tmp);
1859                         continue;
1860                 }
1861                 pbx_builtin_setvar_helper(tc, "DIALEDPEERNUMBER", numsubst);
1862
1863                 ast_channel_lock(tc);
1864                 while (ast_channel_trylock(chan)) {
1865                         CHANNEL_DEADLOCK_AVOIDANCE(tc);
1866                 }
1867                 /* Setup outgoing SDP to match incoming one */
1868                 if (!outgoing && !rest) {
1869                         ast_rtp_instance_early_bridge_make_compatible(tc, chan);
1870                 }
1871                 
1872                 /* Inherit specially named variables from parent channel */
1873                 ast_channel_inherit_variables(chan, tc);
1874                 ast_channel_datastore_inherit(chan, tc);
1875
1876                 tc->appl = "AppDial";
1877                 tc->data = "(Outgoing Line)";
1878                 memset(&tc->whentohangup, 0, sizeof(tc->whentohangup));
1879
1880                 /* If the new channel has no callerid, try to guess what it should be */
1881                 if (ast_strlen_zero(tc->cid.cid_num)) {
1882                         if (!ast_strlen_zero(chan->connected.id.number)) {
1883                                 ast_set_callerid(tc, chan->connected.id.number, chan->connected.id.name, chan->connected.ani);
1884                         } else if (!ast_strlen_zero(chan->cid.cid_dnid)) {
1885                                 ast_set_callerid(tc, chan->cid.cid_dnid, NULL, NULL);
1886                         } else if (!ast_strlen_zero(S_OR(chan->macroexten, chan->exten))) {
1887                                 ast_set_callerid(tc, S_OR(chan->macroexten, chan->exten), NULL, NULL);
1888                         }
1889                         ast_set_flag64(tmp, DIAL_NOCONNECTEDLINE);
1890                 }
1891                 
1892                 ast_connected_line_copy_from_caller(&tc->connected, &chan->cid);
1893
1894                 S_REPLACE(tc->cid.cid_rdnis, ast_strdup(chan->cid.cid_rdnis));
1895                 ast_party_redirecting_copy(&tc->redirecting, &chan->redirecting);
1896
1897                 tc->cid.cid_tns = chan->cid.cid_tns;
1898
1899                 ast_string_field_set(tc, accountcode, chan->accountcode);
1900                 tc->cdrflags = chan->cdrflags;
1901                 if (ast_strlen_zero(tc->musicclass))
1902                         ast_string_field_set(tc, musicclass, chan->musicclass);
1903
1904                 /* Pass ADSI CPE and transfer capability */
1905                 tc->adsicpe = chan->adsicpe;
1906                 tc->transfercapability = chan->transfercapability;
1907
1908                 /* If we have an outbound group, set this peer channel to it */
1909                 if (outbound_group)
1910                         ast_app_group_set_channel(tc, outbound_group);
1911                 /* If the calling channel has the ANSWERED_ELSEWHERE flag set, inherit it. This is to support local channels */
1912                 if (ast_test_flag(chan, AST_FLAG_ANSWERED_ELSEWHERE))
1913                         ast_set_flag(tc, AST_FLAG_ANSWERED_ELSEWHERE);
1914
1915                 /* Check if we're forced by configuration */
1916                 if (ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE))
1917                          ast_set_flag(tc, AST_FLAG_ANSWERED_ELSEWHERE);
1918
1919
1920                 /* Inherit context and extension */
1921                 ast_string_field_set(tc, dialcontext, ast_strlen_zero(chan->macrocontext) ? chan->context : chan->macrocontext);
1922                 if (!ast_strlen_zero(chan->macroexten))
1923                         ast_copy_string(tc->exten, chan->macroexten, sizeof(tc->exten));
1924                 else
1925                         ast_copy_string(tc->exten, chan->exten, sizeof(tc->exten));
1926
1927                 ast_channel_unlock(tc);
1928                 res = ast_call(tc, numsubst, 0); /* Place the call, but don't wait on the answer */
1929
1930                 /* Save the info in cdr's that we called them */
1931                 if (chan->cdr)
1932                         ast_cdr_setdestchan(chan->cdr, tc->name);
1933
1934                 /* check the results of ast_call */
1935                 if (res) {
1936                         /* Again, keep going even if there's an error */
1937                         ast_debug(1, "ast call on peer returned %d\n", res);
1938                         ast_verb(3, "Couldn't call %s\n", numsubst);
1939                         if (tc->hangupcause) {
1940                                 chan->hangupcause = tc->hangupcause;
1941                         }
1942                         ast_channel_unlock(chan);
1943                         ast_hangup(tc);
1944                         tc = NULL;
1945                         ast_free(tmp);
1946                         continue;
1947                 } else {
1948                         const char *tmpexten = ast_strdupa(S_OR(chan->macroexten, chan->exten));
1949                         senddialevent(chan, tc, numsubst);
1950                         ast_verb(3, "Called %s\n", numsubst);
1951                         ast_channel_unlock(chan);
1952                         if (!ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
1953                                 ast_set_callerid(tc, tmpexten, get_cid_name(cidname, sizeof(cidname), chan), NULL);
1954                         }
1955                 }
1956                 /* Put them in the list of outgoing thingies...  We're ready now.
1957                    XXX If we're forcibly removed, these outgoing calls won't get
1958                    hung up XXX */
1959                 ast_set_flag64(tmp, DIAL_STILLGOING);
1960                 tmp->chan = tc;
1961                 tmp->next = outgoing;
1962                 outgoing = tmp;
1963                 /* If this line is up, don't try anybody else */
1964                 if (outgoing->chan->_state == AST_STATE_UP)
1965                         break;
1966         }
1967         
1968         if (ast_strlen_zero(args.timeout)) {
1969                 to = -1;
1970         } else {
1971                 to = atoi(args.timeout);
1972                 if (to > 0)
1973                         to *= 1000;
1974                 else {
1975                         ast_log(LOG_WARNING, "Invalid timeout specified: '%s'. Setting timeout to infinite\n", args.timeout);
1976                         to = -1;
1977                 }
1978         }
1979
1980         if (!outgoing) {
1981                 strcpy(pa.status, "CHANUNAVAIL");
1982                 if (fulldial == num_dialed) {
1983                         res = -1;
1984                         goto out;
1985                 }
1986         } else {
1987                 /* Our status will at least be NOANSWER */
1988                 strcpy(pa.status, "NOANSWER");
1989                 if (ast_test_flag64(outgoing, OPT_MUSICBACK)) {
1990                         moh = 1;
1991                         if (!ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
1992                                 char *original_moh = ast_strdupa(chan->musicclass);
1993                                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
1994                                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
1995                                 ast_string_field_set(chan, musicclass, original_moh);
1996                         } else {
1997                                 ast_moh_start(chan, NULL, NULL);
1998                         }
1999                         ast_indicate(chan, AST_CONTROL_PROGRESS);
2000                 } else if (ast_test_flag64(outgoing, OPT_RINGBACK)) {
2001                         ast_indicate(chan, AST_CONTROL_RINGING);
2002                         sentringing++;
2003                 }
2004         }
2005
2006         peer = wait_for_answer(chan, outgoing, &to, peerflags, &pa, &num, &result, dtmf_progress);
2007
2008         /* The ast_channel_datastore_remove() function could fail here if the
2009          * datastore was moved to another channel during a masquerade. If this is
2010          * the case, don't free the datastore here because later, when the channel
2011          * to which the datastore was moved hangs up, it will attempt to free this
2012          * datastore again, causing a crash
2013          */
2014         if (!ast_channel_datastore_remove(chan, datastore))
2015                 ast_datastore_free(datastore);
2016         if (!peer) {
2017                 if (result) {
2018                         res = result;
2019                 } else if (to) { /* Musta gotten hung up */
2020                         res = -1;
2021                 } else { /* Nobody answered, next please? */
2022                         res = 0;
2023                 }
2024
2025                 /* SIP, in particular, sends back this error code to indicate an
2026                  * overlap dialled number needs more digits. */
2027                 if (chan->hangupcause == AST_CAUSE_INVALID_NUMBER_FORMAT) {
2028                         res = AST_PBX_INCOMPLETE;
2029                 }
2030
2031                 /* almost done, although the 'else' block is 400 lines */
2032         } else {
2033                 const char *number;
2034
2035                 strcpy(pa.status, "ANSWER");
2036                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
2037                 /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
2038                    we will always return with -1 so that it is hung up properly after the
2039                    conversation.  */
2040                 hanguptree(outgoing, peer, 1);
2041                 outgoing = NULL;
2042                 /* If appropriate, log that we have a destination channel */
2043                 if (chan->cdr)
2044                         ast_cdr_setdestchan(chan->cdr, peer->name);
2045                 if (peer->name)
2046                         pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", peer->name);
2047                 
2048                 ast_channel_lock(peer);
2049                 number = pbx_builtin_getvar_helper(peer, "DIALEDPEERNUMBER"); 
2050                 if (!number)
2051                         number = numsubst;
2052                 pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", number);
2053                 ast_channel_unlock(peer);
2054
2055                 if (!ast_strlen_zero(args.url) && ast_channel_supports_html(peer) ) {
2056                         ast_debug(1, "app_dial: sendurl=%s.\n", args.url);
2057                         ast_channel_sendurl( peer, args.url );
2058                 }
2059                 if ( (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) && pa.privdb_val == AST_PRIVACY_UNKNOWN) {
2060                         if (do_privacy(chan, peer, &opts, opt_args, &pa)) {
2061                                 res = 0;
2062                                 goto out;
2063                         }
2064                 }
2065                 if (!ast_test_flag64(&opts, OPT_ANNOUNCE) || ast_strlen_zero(opt_args[OPT_ARG_ANNOUNCE])) {
2066                         res = 0;
2067                 } else {
2068                         int digit = 0;
2069                         /* Start autoservice on the other chan */
2070                         res = ast_autoservice_start(chan);
2071                         /* Now Stream the File */
2072                         if (!res)
2073                                 res = ast_streamfile(peer, opt_args[OPT_ARG_ANNOUNCE], peer->language);
2074                         if (!res) {
2075                                 digit = ast_waitstream(peer, AST_DIGIT_ANY);
2076                         }
2077                         /* Ok, done. stop autoservice */
2078                         res = ast_autoservice_stop(chan);
2079                         if (digit > 0 && !res)
2080                                 res = ast_senddigit(chan, digit, 0);
2081                         else
2082                                 res = digit;
2083
2084                 }
2085
2086                 if (chan && peer && ast_test_flag64(&opts, OPT_GOTO) && !ast_strlen_zero(opt_args[OPT_ARG_GOTO])) {
2087                         replace_macro_delimiter(opt_args[OPT_ARG_GOTO]);
2088                         ast_parseable_goto(chan, opt_args[OPT_ARG_GOTO]);
2089                         /* peer goes to the same context and extension as chan, so just copy info from chan*/
2090                         ast_copy_string(peer->context, chan->context, sizeof(peer->context));
2091                         ast_copy_string(peer->exten, chan->exten, sizeof(peer->exten));
2092                         peer->priority = chan->priority + 2;
2093                         ast_pbx_start(peer);
2094                         hanguptree(outgoing, NULL, ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE) ? 1 : 0);
2095                         if (continue_exec)
2096                                 *continue_exec = 1;
2097                         res = 0;
2098                         goto done;
2099                 }
2100
2101                 if (ast_test_flag64(&opts, OPT_CALLEE_MACRO) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_MACRO])) {
2102                         struct ast_app *theapp;
2103                         const char *macro_result;
2104
2105                         res = ast_autoservice_start(chan);
2106                         if (res) {
2107                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
2108                                 res = -1;
2109                         }
2110
2111                         theapp = pbx_findapp("Macro");
2112
2113                         if (theapp && !res) { /* XXX why check res here ? */
2114                                 /* Set peer->exten and peer->context so that MACRO_EXTEN and MACRO_CONTEXT get set */
2115                                 ast_copy_string(peer->context, chan->context, sizeof(peer->context));
2116                                 ast_copy_string(peer->exten, chan->exten, sizeof(peer->exten));
2117
2118                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_MACRO]);
2119                                 res = pbx_exec(peer, theapp, opt_args[OPT_ARG_CALLEE_MACRO]);
2120                                 ast_debug(1, "Macro exited with status %d\n", res);
2121                                 res = 0;
2122                         } else {
2123                                 ast_log(LOG_ERROR, "Could not find application Macro\n");
2124                                 res = -1;
2125                         }
2126
2127                         if (ast_autoservice_stop(chan) < 0) {
2128                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
2129                                 res = -1;
2130                         }
2131
2132                         ast_channel_lock(peer);
2133
2134                         if (!res && (macro_result = pbx_builtin_getvar_helper(peer, "MACRO_RESULT"))) {
2135                                 char *macro_transfer_dest;
2136
2137                                 if (!strcasecmp(macro_result, "BUSY")) {
2138                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
2139                                         ast_set_flag64(peerflags, OPT_GO_ON);
2140                                         res = -1;
2141                                 } else if (!strcasecmp(macro_result, "CONGESTION") || !strcasecmp(macro_result, "CHANUNAVAIL")) {
2142                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
2143                                         ast_set_flag64(peerflags, OPT_GO_ON);
2144                                         res = -1;
2145                                 } else if (!strcasecmp(macro_result, "CONTINUE")) {
2146                                         /* hangup peer and keep chan alive assuming the macro has changed
2147                                            the context / exten / priority or perhaps
2148                                            the next priority in the current exten is desired.
2149                                         */
2150                                         ast_set_flag64(peerflags, OPT_GO_ON);
2151                                         res = -1;
2152                                 } else if (!strcasecmp(macro_result, "ABORT")) {
2153                                         /* Hangup both ends unless the caller has the g flag */
2154                                         res = -1;
2155                                 } else if (!strncasecmp(macro_result, "GOTO:", 5) && (macro_transfer_dest = ast_strdupa(macro_result + 5))) {
2156                                         res = -1;
2157                                         /* perform a transfer to a new extension */
2158                                         if (strchr(macro_transfer_dest, '^')) { /* context^exten^priority*/
2159                                                 replace_macro_delimiter(macro_transfer_dest);
2160                                                 if (!ast_parseable_goto(chan, macro_transfer_dest))
2161                                                         ast_set_flag64(peerflags, OPT_GO_ON);
2162                                         }
2163                                 }
2164                         }
2165
2166                         ast_channel_unlock(peer);
2167                 }
2168
2169                 if (ast_test_flag64(&opts, OPT_CALLEE_GOSUB) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GOSUB])) {
2170                         struct ast_app *theapp;
2171                         const char *gosub_result;
2172                         char *gosub_args, *gosub_argstart;
2173                         int res9 = -1;
2174
2175                         res9 = ast_autoservice_start(chan);
2176                         if (res9) {
2177                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
2178                                 res9 = -1;
2179                         }
2180
2181                         theapp = pbx_findapp("Gosub");
2182
2183                         if (theapp && !res9) {
2184                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_GOSUB]);
2185
2186                                 /* Set where we came from */
2187                                 ast_copy_string(peer->context, "app_dial_gosub_virtual_context", sizeof(peer->context));
2188                                 ast_copy_string(peer->exten, "s", sizeof(peer->exten));
2189                                 peer->priority = 0;
2190
2191                                 gosub_argstart = strchr(opt_args[OPT_ARG_CALLEE_GOSUB], ',');
2192                                 if (gosub_argstart) {
2193                                         *gosub_argstart = 0;
2194                                         if (asprintf(&gosub_args, "%s,s,1(%s)", opt_args[OPT_ARG_CALLEE_GOSUB], gosub_argstart + 1) < 0) {
2195                                                 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
2196                                                 gosub_args = NULL;
2197                                         }
2198                                         *gosub_argstart = ',';
2199                                 } else {
2200                                         if (asprintf(&gosub_args, "%s,s,1", opt_args[OPT_ARG_CALLEE_GOSUB]) < 0) {
2201                                                 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
2202                                                 gosub_args = NULL;
2203                                         }
2204                                 }
2205
2206                                 if (gosub_args) {
2207                                         res9 = pbx_exec(peer, theapp, gosub_args);
2208                                         if (!res9) {
2209                                                 struct ast_pbx_args args;
2210                                                 /* A struct initializer fails to compile for this case ... */
2211                                                 memset(&args, 0, sizeof(args));
2212                                                 args.no_hangup_chan = 1;
2213                                                 ast_pbx_run_args(peer, &args);
2214                                         }
2215                                         ast_free(gosub_args);
2216                                         ast_debug(1, "Gosub exited with status %d\n", res9);
2217                                 } else {
2218                                         ast_log(LOG_ERROR, "Could not Allocate string for Gosub arguments -- Gosub Call Aborted!\n");
2219                                 }
2220
2221                         } else if (!res9) {
2222                                 ast_log(LOG_ERROR, "Could not find application Gosub\n");
2223                                 res9 = -1;
2224                         }
2225
2226                         if (ast_autoservice_stop(chan) < 0) {
2227                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
2228                                 res9 = -1;
2229                         }
2230                         
2231                         ast_channel_lock(peer);
2232
2233                         if (!res9 && (gosub_result = pbx_builtin_getvar_helper(peer, "GOSUB_RESULT"))) {
2234                                 char *gosub_transfer_dest;
2235
2236                                 if (!strcasecmp(gosub_result, "BUSY")) {
2237                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
2238                                         ast_set_flag64(peerflags, OPT_GO_ON);
2239                                         res9 = -1;
2240                                 } else if (!strcasecmp(gosub_result, "CONGESTION") || !strcasecmp(gosub_result, "CHANUNAVAIL")) {
2241                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
2242                                         ast_set_flag64(peerflags, OPT_GO_ON);
2243                                         res9 = -1;
2244                                 } else if (!strcasecmp(gosub_result, "CONTINUE")) {
2245                                         /* hangup peer and keep chan alive assuming the macro has changed
2246                                            the context / exten / priority or perhaps
2247                                            the next priority in the current exten is desired.
2248                                         */
2249                                         ast_set_flag64(peerflags, OPT_GO_ON);
2250                                         res9 = -1;
2251                                 } else if (!strcasecmp(gosub_result, "ABORT")) {
2252                                         /* Hangup both ends unless the caller has the g flag */
2253                                         res9 = -1;
2254                                 } else if (!strncasecmp(gosub_result, "GOTO:", 5) && (gosub_transfer_dest = ast_strdupa(gosub_result + 5))) {
2255                                         res9 = -1;
2256                                         /* perform a transfer to a new extension */
2257                                         if (strchr(gosub_transfer_dest, '^')) { /* context^exten^priority*/
2258                                                 replace_macro_delimiter(gosub_transfer_dest);
2259                                                 if (!ast_parseable_goto(chan, gosub_transfer_dest))
2260                                                         ast_set_flag64(peerflags, OPT_GO_ON);
2261                                         }
2262                                 }
2263                         }
2264
2265                         ast_channel_unlock(peer);       
2266                 }
2267
2268                 if (!res) {
2269                         if (!ast_tvzero(calldurationlimit)) {
2270                                 struct timeval whentohangup = calldurationlimit;
2271                                 peer->whentohangup = ast_tvadd(ast_tvnow(), whentohangup);
2272                         }
2273                         if (!ast_strlen_zero(dtmfcalled)) {
2274                                 ast_verb(3, "Sending DTMF '%s' to the called party.\n", dtmfcalled);
2275                                 res = ast_dtmf_stream(peer, chan, dtmfcalled, 250, 0);
2276                         }
2277                         if (!ast_strlen_zero(dtmfcalling)) {
2278                                 ast_verb(3, "Sending DTMF '%s' to the calling party.\n", dtmfcalling);
2279                                 res = ast_dtmf_stream(chan, peer, dtmfcalling, 250, 0);
2280                         }
2281                 }
2282
2283                 if (res) { /* some error */
2284                         res = -1;
2285                 } else {
2286                         if (ast_test_flag64(peerflags, OPT_CALLEE_TRANSFER))
2287                                 ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
2288                         if (ast_test_flag64(peerflags, OPT_CALLER_TRANSFER))
2289                                 ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
2290                         if (ast_test_flag64(peerflags, OPT_CALLEE_HANGUP))
2291                                 ast_set_flag(&(config.features_callee), AST_FEATURE_DISCONNECT);
2292                         if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP))
2293                                 ast_set_flag(&(config.features_caller), AST_FEATURE_DISCONNECT);
2294                         if (ast_test_flag64(peerflags, OPT_CALLEE_MONITOR))
2295                                 ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMON);
2296                         if (ast_test_flag64(peerflags, OPT_CALLER_MONITOR))
2297                                 ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMON);
2298                         if (ast_test_flag64(peerflags, OPT_CALLEE_PARK))
2299                                 ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
2300                         if (ast_test_flag64(peerflags, OPT_CALLER_PARK))
2301                                 ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
2302                         if (ast_test_flag64(peerflags, OPT_CALLEE_MIXMONITOR))
2303                                 ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMIXMON);
2304                         if (ast_test_flag64(peerflags, OPT_CALLER_MIXMONITOR))
2305                                 ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMIXMON);
2306                         if (ast_test_flag64(peerflags, OPT_GO_ON))
2307                                 ast_set_flag(&(config.features_caller), AST_FEATURE_NO_H_EXTEN);
2308
2309                         config.end_bridge_callback = end_bridge_callback;
2310                         config.end_bridge_callback_data = chan;
2311                         config.end_bridge_callback_data_fixup = end_bridge_callback_data_fixup;
2312                         
2313                         if (moh) {
2314                                 moh = 0;
2315                                 ast_moh_stop(chan);
2316                         } else if (sentringing) {
2317                                 sentringing = 0;
2318                                 ast_indicate(chan, -1);
2319                         }
2320                         /* Be sure no generators are left on it */
2321                         ast_deactivate_generator(chan);
2322                         /* Make sure channels are compatible */
2323                         res = ast_channel_make_compatible(chan, peer);
2324                         if (res < 0) {
2325                                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", chan->name, peer->name);
2326                                 ast_hangup(peer);
2327                                 res = -1;
2328                                 goto done;
2329                         }
2330                         if (opermode) {
2331                                 struct oprmode oprmode;
2332
2333                                 oprmode.peer = peer;
2334                                 oprmode.mode = opermode;
2335
2336                                 ast_channel_setoption(chan, AST_OPTION_OPRMODE, &oprmode, sizeof(oprmode), 0);
2337                         }
2338                         res = ast_bridge_call(chan, peer, &config);
2339                 }
2340
2341                 strcpy(peer->context, chan->context);
2342
2343                 if (ast_test_flag64(&opts, OPT_PEER_H) && ast_exists_extension(peer, peer->context, "h", 1, peer->cid.cid_num)) {
2344                         int autoloopflag;
2345                         int found;
2346                         int res9;
2347                         
2348                         strcpy(peer->exten, "h");
2349                         peer->priority = 1;
2350                         autoloopflag = ast_test_flag(peer, AST_FLAG_IN_AUTOLOOP); /* save value to restore at the end */
2351                         ast_set_flag(peer, AST_FLAG_IN_AUTOLOOP);
2352
2353                         while ((res9 = ast_spawn_extension(peer, peer->context, peer->exten, peer->priority, peer->cid.cid_num, &found, 1)) == 0)
2354                                 peer->priority++;
2355
2356                         if (found && res9) {
2357                                 /* Something bad happened, or a hangup has been requested. */
2358                                 ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", peer->context, peer->exten, peer->priority, peer->name);
2359                                 ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", peer->context, peer->exten, peer->priority, peer->name);
2360                         }
2361                         ast_set2_flag(peer, autoloopflag, AST_FLAG_IN_AUTOLOOP);  /* set it back the way it was */
2362                 }
2363                 if (!ast_check_hangup(peer) && ast_test_flag64(&opts, OPT_CALLEE_GO_ON)) {
2364                         if(!ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GO_ON])) {
2365                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_GO_ON]);
2366                                 ast_parseable_goto(peer, opt_args[OPT_ARG_CALLEE_GO_ON]);
2367                         } else { /* F() */
2368                                 int res;
2369                                 res = ast_goto_if_exists(peer, chan->context, chan->exten, (chan->priority) + 1); 
2370                                 if (res == AST_PBX_GOTO_FAILED) {
2371                                         ast_hangup(peer);
2372                                         goto out;
2373                                 }
2374                         }
2375                         ast_pbx_start(peer);
2376                 } else {
2377                         if (!ast_check_hangup(chan))
2378                                 chan->hangupcause = peer->hangupcause;
2379                         ast_hangup(peer);
2380                 }
2381         }
2382 out:
2383         if (moh) {
2384                 moh = 0;
2385                 ast_moh_stop(chan);
2386         } else if (sentringing) {
2387                 sentringing = 0;
2388                 ast_indicate(chan, -1);
2389         }
2390         ast_channel_early_bridge(chan, NULL);
2391         hanguptree(outgoing, NULL, 0); /* In this case, there's no answer anywhere */
2392         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
2393         senddialendevent(chan, pa.status);
2394         ast_debug(1, "Exiting with DIALSTATUS=%s.\n", pa.status);
2395         
2396         if ((ast_test_flag64(peerflags, OPT_GO_ON)) && !ast_check_hangup(chan) && (res != AST_PBX_INCOMPLETE)) {
2397                 if (!ast_tvzero(calldurationlimit))
2398                         memset(&chan->whentohangup, 0, sizeof(chan->whentohangup));
2399                 res = 0;
2400         }
2401
2402 done:
2403         if (config.warning_sound) {
2404                 ast_free((char *)config.warning_sound);
2405         }
2406         if (config.end_sound) {
2407                 ast_free((char *)config.end_sound);
2408         }
2409         if (config.start_sound) {
2410                 ast_free((char *)config.start_sound);
2411         }
2412         return res;
2413 }
2414
2415 static int dial_exec(struct ast_channel *chan, void *data)
2416 {
2417         struct ast_flags64 peerflags;
2418
2419         memset(&peerflags, 0, sizeof(peerflags));
2420
2421         return dial_exec_full(chan, data, &peerflags, NULL);
2422 }
2423
2424 static int retrydial_exec(struct ast_channel *chan, void *data)
2425 {
2426         char *parse;
2427         const char *context = NULL;
2428         int sleepms = 0, loops = 0, res = -1;
2429         struct ast_flags64 peerflags = { 0, };
2430         AST_DECLARE_APP_ARGS(args,
2431                 AST_APP_ARG(announce);
2432                 AST_APP_ARG(sleep);
2433                 AST_APP_ARG(retries);
2434                 AST_APP_ARG(dialdata);
2435         );
2436
2437         if (ast_strlen_zero(data)) {
2438                 ast_log(LOG_WARNING, "RetryDial requires an argument!\n");
2439                 return -1;
2440         }
2441
2442         parse = ast_strdupa(data);
2443         AST_STANDARD_APP_ARGS(args, parse);
2444
2445         if (!ast_strlen_zero(args.sleep) && (sleepms = atoi(args.sleep)))
2446                 sleepms *= 1000;
2447
2448         if (!ast_strlen_zero(args.retries)) {
2449                 loops = atoi(args.retries);
2450         }
2451
2452         if (!args.dialdata) {
2453                 ast_log(LOG_ERROR, "%s requires a 4th argument (dialdata)\n", rapp);
2454                 goto done;
2455         }
2456
2457         if (sleepms < 1000)
2458                 sleepms = 10000;
2459
2460         if (!loops)
2461                 loops = -1; /* run forever */
2462
2463         ast_channel_lock(chan);
2464         context = pbx_builtin_getvar_helper(chan, "EXITCONTEXT");
2465         context = !ast_strlen_zero(context) ? ast_strdupa(context) : NULL;
2466         ast_channel_unlock(chan);
2467
2468         res = 0;
2469         while (loops) {
2470                 int continue_exec;
2471
2472                 chan->data = "Retrying";
2473                 if (ast_test_flag(chan, AST_FLAG_MOH))
2474                         ast_moh_stop(chan);
2475
2476                 res = dial_exec_full(chan, args.dialdata, &peerflags, &continue_exec);
2477                 if (continue_exec)
2478                         break;
2479
2480                 if (res == 0) {
2481                         if (ast_test_flag64(&peerflags, OPT_DTMF_EXIT)) {
2482                                 if (!ast_strlen_zero(args.announce)) {
2483                                         if (ast_fileexists(args.announce, NULL, chan->language) > 0) {
2484                                                 if (!(res = ast_streamfile(chan, args.announce, chan->language)))
2485                                                         ast_waitstream(chan, AST_DIGIT_ANY);
2486                                         } else
2487                                                 ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
2488                                 }
2489                                 if (!res && sleepms) {
2490                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
2491                                                 ast_moh_start(chan, NULL, NULL);
2492                                         res = ast_waitfordigit(chan, sleepms);
2493                                 }
2494                         } else {
2495                                 if (!ast_strlen_zero(args.announce)) {
2496                                         if (ast_fileexists(args.announce, NULL, chan->language) > 0) {
2497                                                 if (!(res = ast_streamfile(chan, args.announce, chan->language)))
2498                                                         res = ast_waitstream(chan, "");
2499                                         } else
2500                                                 ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
2501                                 }
2502                                 if (sleepms) {
2503                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
2504                                                 ast_moh_start(chan, NULL, NULL);
2505                                         if (!res)
2506                                                 res = ast_waitfordigit(chan, sleepms);
2507                                 }
2508                         }
2509                 }
2510
2511                 if (res < 0 || res == AST_PBX_INCOMPLETE) {
2512                         break;
2513                 } else if (res > 0) { /* Trying to send the call elsewhere (1 digit ext) */
2514                         if (onedigit_goto(chan, context, (char) res, 1)) {
2515                                 res = 0;
2516                                 break;
2517                         }
2518                 }
2519                 loops--;
2520         }
2521         if (loops == 0)
2522                 res = 0;
2523         else if (res == 1)
2524                 res = 0;
2525
2526         if (ast_test_flag(chan, AST_FLAG_MOH))
2527                 ast_moh_stop(chan);
2528  done:
2529         return res;
2530 }
2531
2532 static int unload_module(void)
2533 {
2534         int res;
2535         struct ast_context *con;
2536
2537         res = ast_unregister_application(app);
2538         res |= ast_unregister_application(rapp);
2539
2540         if ((con = ast_context_find("app_dial_gosub_virtual_context"))) {
2541                 ast_context_remove_extension2(con, "s", 1, NULL, 0);
2542                 ast_context_destroy(con, "app_dial"); /* leave nothing behind */
2543         }
2544
2545         return res;
2546 }
2547
2548 static int load_module(void)
2549 {
2550         int res;
2551         struct ast_context *con;
2552
2553         con = ast_context_find_or_create(NULL, NULL, "app_dial_gosub_virtual_context", "app_dial");
2554         if (!con)
2555                 ast_log(LOG_ERROR, "Dial virtual context 'app_dial_gosub_virtual_context' does not exist and unable to create\n");
2556         else
2557                 ast_add_extension2(con, 1, "s", 1, NULL, NULL, "NoOp", ast_strdup(""), ast_free_ptr, "app_dial");
2558
2559         res = ast_register_application_xml(app, dial_exec);
2560         res |= ast_register_application_xml(rapp, retrydial_exec);
2561
2562         return res;
2563 }
2564
2565 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dialing Application");