Merged revisions 189463 via svnmerge from
[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_NO_ANSWER:
639         case AST_CAUSE_NORMAL_CLEARING:
640                 break;
641
642         default:
643                 num->nochan++;
644                 break;
645         }
646 }
647
648 /* free the buffer if allocated, and set the pointer to the second arg */
649 #define S_REPLACE(s, new_val)           \
650         do {                            \
651                 if (s)                  \
652                         ast_free(s);    \
653                 s = (new_val);          \
654         } while (0)
655
656 static int onedigit_goto(struct ast_channel *chan, const char *context, char exten, int pri)
657 {
658         char rexten[2] = { exten, '\0' };
659
660         if (context) {
661                 if (!ast_goto_if_exists(chan, context, rexten, pri))
662                         return 1;
663         } else {
664                 if (!ast_goto_if_exists(chan, chan->context, rexten, pri))
665                         return 1;
666                 else if (!ast_strlen_zero(chan->macrocontext)) {
667                         if (!ast_goto_if_exists(chan, chan->macrocontext, rexten, pri))
668                                 return 1;
669                 }
670         }
671         return 0;
672 }
673
674 /* do not call with chan lock held */
675 static const char *get_cid_name(char *name, int namelen, struct ast_channel *chan)
676 {
677         const char *context;
678         const char *exten;
679
680         ast_channel_lock(chan);
681         context = ast_strdupa(S_OR(chan->macrocontext, chan->context));
682         exten = ast_strdupa(S_OR(chan->macroexten, chan->exten));
683         ast_channel_unlock(chan);
684
685         return ast_get_hint(NULL, 0, name, namelen, chan, context, exten) ? name : "";
686 }
687
688 static void senddialevent(struct ast_channel *src, struct ast_channel *dst, const char *dialstring)
689 {
690         manager_event(EVENT_FLAG_CALL, "Dial",
691                 "SubEvent: Begin\r\n"
692                 "Channel: %s\r\n"
693                 "Destination: %s\r\n"
694                 "CallerIDNum: %s\r\n"
695                 "CallerIDName: %s\r\n"
696                 "UniqueID: %s\r\n"
697                 "DestUniqueID: %s\r\n"
698                 "Dialstring: %s\r\n",
699                 src->name, dst->name, S_OR(src->cid.cid_num, "<unknown>"),
700                 S_OR(src->cid.cid_name, "<unknown>"), src->uniqueid,
701                 dst->uniqueid, dialstring ? dialstring : "");
702 }
703
704 static void senddialendevent(const struct ast_channel *src, const char *dialstatus)
705 {
706         manager_event(EVENT_FLAG_CALL, "Dial",
707                 "SubEvent: End\r\n"
708                 "Channel: %s\r\n"
709                 "UniqueID: %s\r\n"
710                 "DialStatus: %s\r\n",
711                 src->name, src->uniqueid, dialstatus);
712 }
713
714 /*!
715  * helper function for wait_for_answer()
716  *
717  * XXX this code is highly suspicious, as it essentially overwrites
718  * the outgoing channel without properly deleting it.
719  */
720 static void do_forward(struct chanlist *o,
721         struct cause_args *num, struct ast_flags64 *peerflags, int single, int *to)
722 {
723         char tmpchan[256];
724         struct ast_channel *original = o->chan;
725         struct ast_channel *c = o->chan; /* the winner */
726         struct ast_channel *in = num->chan; /* the input channel */
727         struct ast_party_redirecting *apr = &o->chan->redirecting;
728         struct ast_party_connected_line *apc = &o->chan->connected;
729         char *stuff;
730         char *tech;
731         int cause;
732
733         ast_copy_string(tmpchan, c->call_forward, sizeof(tmpchan));
734         if ((stuff = strchr(tmpchan, '/'))) {
735                 *stuff++ = '\0';
736                 tech = tmpchan;
737         } else {
738                 const char *forward_context;
739                 ast_channel_lock(c);
740                 forward_context = pbx_builtin_getvar_helper(c, "FORWARD_CONTEXT");
741                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", c->call_forward, forward_context ? forward_context : c->context);
742                 ast_channel_unlock(c);
743                 stuff = tmpchan;
744                 tech = "Local";
745         }
746         /* Before processing channel, go ahead and check for forwarding */
747         ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, c->name);
748         /* If we have been told to ignore forwards, just set this channel to null and continue processing extensions normally */
749         if (ast_test_flag64(peerflags, OPT_IGNORE_FORWARDING)) {
750                 ast_verb(3, "Forwarding %s to '%s/%s' prevented.\n", in->name, tech, stuff);
751                 c = o->chan = NULL;
752                 cause = AST_CAUSE_BUSY;
753         } else {
754                 /* Setup parameters */
755                 c = o->chan = ast_request(tech, in->nativeformats, stuff, &cause);
756                 if (c) {
757                         if (single)
758                                 ast_channel_make_compatible(o->chan, in);
759                         ast_channel_inherit_variables(in, o->chan);
760                         ast_channel_datastore_inherit(in, o->chan);
761                 } else
762                         ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s' (cause = %d)\n", tech, stuff, cause);
763         }
764         if (!c) {
765                 ast_clear_flag64(o, DIAL_STILLGOING);
766                 handle_cause(cause, num);
767                 ast_hangup(original);
768         } else {
769                 if (single) {
770                         ast_rtp_instance_early_bridge_make_compatible(c, in);
771                 }
772
773                 c->cdrflags = in->cdrflags;
774
775                 ast_channel_set_redirecting(c, apr);
776                 ast_channel_lock(c);
777                 while (ast_channel_trylock(in)) {
778                         CHANNEL_DEADLOCK_AVOIDANCE(c);
779                 }
780                 S_REPLACE(c->cid.cid_rdnis, ast_strdup(S_OR(original->cid.cid_rdnis, S_OR(in->macroexten, in->exten))));
781
782                 c->cid.cid_tns = in->cid.cid_tns;
783
784                 if (ast_test_flag64(o, OPT_FORCECLID)) {
785                         S_REPLACE(c->cid.cid_num, ast_strdupa(S_OR(in->macroexten, in->exten)));
786                         S_REPLACE(c->cid.cid_name, NULL);
787                         ast_string_field_set(c, accountcode, c->accountcode);
788                 } else {
789                         ast_party_caller_copy(&c->cid, &in->cid);
790                         ast_string_field_set(c, accountcode, in->accountcode);
791                 }
792                 ast_party_connected_line_copy(&c->connected, apc);
793
794                 S_REPLACE(in->cid.cid_rdnis, ast_strdup(c->cid.cid_rdnis));
795                 ast_channel_update_redirecting(in, apr);
796
797                 ast_clear_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE);
798                 if (ast_test_flag64(peerflags, OPT_CANCEL_TIMEOUT)) {
799                         *to = -1;
800                 }
801
802                 ast_channel_unlock(in);
803                 ast_channel_unlock(c);
804
805                 if (ast_call(c, tmpchan, 0)) {
806                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
807                         ast_clear_flag64(o, DIAL_STILLGOING);
808                         ast_hangup(original);
809                         ast_hangup(c);
810                         c = o->chan = NULL;
811                         num->nochan++;
812                 } else {
813                         ast_channel_lock(c);
814                         while (ast_channel_trylock(in)) {
815                                 CHANNEL_DEADLOCK_AVOIDANCE(c);
816                         }
817                         senddialevent(in, c, stuff);
818                         if (!ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
819                                 char cidname[AST_MAX_EXTENSION] = "";
820                                 const char *tmpexten;
821                                 tmpexten = ast_strdupa(S_OR(in->macroexten, in->exten));
822                                 ast_channel_unlock(in);
823                                 ast_channel_unlock(c);
824                                 ast_set_callerid(c, tmpexten, get_cid_name(cidname, sizeof(cidname), in), NULL);
825                         } else {
826                                 ast_channel_unlock(in);
827                                 ast_channel_unlock(c);
828                         }
829                         /* Hangup the original channel now, in case we needed it */
830                         ast_hangup(original);
831                 }
832                 if (single) {
833                         ast_indicate(in, -1);
834                 }
835         }
836 }
837
838 /* argument used for some functions. */
839 struct privacy_args {
840         int sentringing;
841         int privdb_val;
842         char privcid[256];
843         char privintro[1024];
844         char status[256];
845 };
846
847 static struct ast_channel *wait_for_answer(struct ast_channel *in,
848         struct chanlist *outgoing, int *to, struct ast_flags64 *peerflags,
849         struct privacy_args *pa,
850         const struct cause_args *num_in, int *result, char *dtmf_progress)
851 {
852         struct cause_args num = *num_in;
853         int prestart = num.busy + num.congestion + num.nochan;
854         int orig = *to;
855         struct ast_channel *peer = NULL;
856         /* single is set if only one destination is enabled */
857         int single = outgoing && !outgoing->next;
858 #ifdef HAVE_EPOLL
859         struct chanlist *epollo;
860 #endif
861         struct ast_party_connected_line connected_caller;
862         struct ast_str *featurecode = ast_str_alloca(FEATURE_MAX_LEN + 1);
863         if (single) {
864                 /* Turn off hold music, etc */
865                 if (!ast_test_flag64(outgoing, OPT_MUSICBACK | OPT_RINGBACK))
866                         ast_deactivate_generator(in);
867
868                 /* If we are calling a single channel, make them compatible for in-band tone purpose */
869                 ast_channel_make_compatible(outgoing->chan, in);
870
871                 if (!ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE) && !ast_test_flag64(outgoing, DIAL_NOCONNECTEDLINE)) {
872                         ast_channel_lock(outgoing->chan);
873                         ast_connected_line_copy_from_caller(&connected_caller, &outgoing->chan->cid);
874                         ast_channel_unlock(outgoing->chan);
875                         connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
876                         ast_channel_update_connected_line(in, &connected_caller);
877                         ast_party_connected_line_free(&connected_caller);
878                 }
879         }
880
881 #ifdef HAVE_EPOLL
882         for (epollo = outgoing; epollo; epollo = epollo->next)
883                 ast_poll_channel_add(in, epollo->chan);
884 #endif
885
886         while (*to && !peer) {
887                 struct chanlist *o;
888                 int pos = 0; /* how many channels do we handle */
889                 int numlines = prestart;
890                 struct ast_channel *winner;
891                 struct ast_channel *watchers[AST_MAX_WATCHERS];
892
893                 watchers[pos++] = in;
894                 for (o = outgoing; o; o = o->next) {
895                         /* Keep track of important channels */
896                         if (ast_test_flag64(o, DIAL_STILLGOING) && o->chan)
897                                 watchers[pos++] = o->chan;
898                         numlines++;
899                 }
900                 if (pos == 1) { /* only the input channel is available */
901                         if (numlines == (num.busy + num.congestion + num.nochan)) {
902                                 ast_verb(2, "Everyone is busy/congested at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
903                                 if (num.busy)
904                                         strcpy(pa->status, "BUSY");
905                                 else if (num.congestion)
906                                         strcpy(pa->status, "CONGESTION");
907                                 else if (num.nochan)
908                                         strcpy(pa->status, "CHANUNAVAIL");
909                         } else {
910                                 ast_verb(3, "No one is available to answer at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
911                         }
912                         *to = 0;
913                         return NULL;
914                 }
915                 winner = ast_waitfor_n(watchers, pos, to);
916                 for (o = outgoing; o; o = o->next) {
917                         struct ast_frame *f;
918                         struct ast_channel *c = o->chan;
919
920                         if (c == NULL)
921                                 continue;
922                         if (ast_test_flag64(o, DIAL_STILLGOING) && c->_state == AST_STATE_UP) {
923                                 if (!peer) {
924                                         ast_verb(3, "%s answered %s\n", c->name, in->name);
925                                         if (!single && !ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
926                                                 if (o->connected.id.number) {
927                                                         ast_channel_update_connected_line(in, &o->connected);
928                                                 } else if (!ast_test_flag64(o, DIAL_NOCONNECTEDLINE)) {
929                                                         ast_channel_lock(c);
930                                                         ast_connected_line_copy_from_caller(&connected_caller, &c->cid);
931                                                         ast_channel_unlock(c);
932                                                         connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
933                                                         ast_channel_update_connected_line(in, &connected_caller);
934                                                         ast_party_connected_line_free(&connected_caller);
935                                                 }
936                                         }
937                                         peer = c;
938                                         ast_copy_flags64(peerflags, o,
939                                                 OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
940                                                 OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
941                                                 OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
942                                                 OPT_CALLEE_PARK | OPT_CALLER_PARK |
943                                                 OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
944                                                 DIAL_NOFORWARDHTML);
945                                         ast_string_field_set(c, dialcontext, "");
946                                         ast_copy_string(c->exten, "", sizeof(c->exten));
947                                 }
948                                 continue;
949                         }
950                         if (c != winner)
951                                 continue;
952                         /* here, o->chan == c == winner */
953                         if (!ast_strlen_zero(c->call_forward)) {
954                                 do_forward(o, &num, peerflags, single, to);
955                                 continue;
956                         }
957                         f = ast_read(winner);
958                         if (!f) {
959                                 in->hangupcause = c->hangupcause;
960 #ifdef HAVE_EPOLL
961                                 ast_poll_channel_del(in, c);
962 #endif
963                                 ast_hangup(c);
964                                 c = o->chan = NULL;
965                                 ast_clear_flag64(o, DIAL_STILLGOING);
966                                 handle_cause(in->hangupcause, &num);
967                                 continue;
968                         }
969                         if (f->frametype == AST_FRAME_CONTROL) {
970                                 switch(f->subclass) {
971                                 case AST_CONTROL_ANSWER:
972                                         /* This is our guy if someone answered. */
973                                         if (!peer) {
974                                                 ast_verb(3, "%s answered %s\n", c->name, in->name);
975                                                 if (!single && !ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
976                                                         if (o->connected.id.number) {
977                                                                 ast_channel_update_connected_line(in, &o->connected);
978                                                         } else if (!ast_test_flag64(o, DIAL_NOCONNECTEDLINE)) {
979                                                                 ast_channel_lock(c);
980                                                                 ast_connected_line_copy_from_caller(&connected_caller, &c->cid);
981                                                                 ast_channel_unlock(c);
982                                                                 connected_caller.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;
983                                                                 ast_channel_update_connected_line(in, &connected_caller);
984                                                                 ast_party_connected_line_free(&connected_caller);
985                                                         }
986                                                 }
987                                                 peer = c;
988                                                 if (peer->cdr) {
989                                                         peer->cdr->answer = ast_tvnow();
990                                                         peer->cdr->disposition = AST_CDR_ANSWERED;
991                                                 }
992                                                 ast_copy_flags64(peerflags, o,
993                                                         OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
994                                                         OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
995                                                         OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
996                                                         OPT_CALLEE_PARK | OPT_CALLER_PARK |
997                                                         OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
998                                                         DIAL_NOFORWARDHTML);
999                                                 ast_string_field_set(c, dialcontext, "");
1000                                                 ast_copy_string(c->exten, "", sizeof(c->exten));
1001                                                 if (CAN_EARLY_BRIDGE(peerflags, in, peer))
1002                                                         /* Setup early bridge if appropriate */
1003                                                         ast_channel_early_bridge(in, peer);
1004                                         }
1005                                         /* If call has been answered, then the eventual hangup is likely to be normal hangup */
1006                                         in->hangupcause = AST_CAUSE_NORMAL_CLEARING;
1007                                         c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
1008                                         break;
1009                                 case AST_CONTROL_BUSY:
1010                                         ast_verb(3, "%s is busy\n", c->name);
1011                                         in->hangupcause = c->hangupcause;
1012                                         ast_hangup(c);
1013                                         c = o->chan = NULL;
1014                                         ast_clear_flag64(o, DIAL_STILLGOING);
1015                                         handle_cause(AST_CAUSE_BUSY, &num);
1016                                         break;
1017                                 case AST_CONTROL_CONGESTION:
1018                                         ast_verb(3, "%s is circuit-busy\n", c->name);
1019                                         in->hangupcause = c->hangupcause;
1020                                         ast_hangup(c);
1021                                         c = o->chan = NULL;
1022                                         ast_clear_flag64(o, DIAL_STILLGOING);
1023                                         handle_cause(AST_CAUSE_CONGESTION, &num);
1024                                         break;
1025                                 case AST_CONTROL_RINGING:
1026                                         ast_verb(3, "%s is ringing\n", c->name);
1027                                         /* Setup early media if appropriate */
1028                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1029                                                 ast_channel_early_bridge(in, c);
1030                                         if (!(pa->sentringing) && !ast_test_flag64(outgoing, OPT_MUSICBACK)) {
1031                                                 ast_indicate(in, AST_CONTROL_RINGING);
1032                                                 pa->sentringing++;
1033                                         }
1034                                         break;
1035                                 case AST_CONTROL_PROGRESS:
1036                                         ast_verb(3, "%s is making progress passing it to %s\n", c->name, in->name);
1037                                         /* Setup early media if appropriate */
1038                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1039                                                 ast_channel_early_bridge(in, c);
1040                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK))
1041                                                 ast_indicate(in, AST_CONTROL_PROGRESS);
1042                                                 if(!ast_strlen_zero(dtmf_progress)) {
1043                                                         ast_verb(3, "Sending DTMF '%s' to the called party as result of receiving a PROGRESS message.\n", dtmf_progress);
1044                                                         ast_dtmf_stream(c, in, dtmf_progress, 250, 0);
1045                                                 }
1046                                         break;
1047                                 case AST_CONTROL_VIDUPDATE:
1048                                         ast_verb(3, "%s requested a video update, passing it to %s\n", c->name, in->name);
1049                                         ast_indicate(in, AST_CONTROL_VIDUPDATE);
1050                                         break;
1051                                 case AST_CONTROL_SRCUPDATE:
1052                                         ast_verb(3, "%s requested a source update, passing it to %s\n", c->name, in->name);
1053                                         ast_indicate(in, AST_CONTROL_SRCUPDATE);
1054                                         break;
1055                                 case AST_CONTROL_CONNECTED_LINE:
1056                                         if (ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
1057                                                 ast_verb(3, "Connected line update to %s prevented.\n", in->name);
1058                                         } else if (!single) {
1059                                                 struct ast_party_connected_line connected;
1060                                                 ast_verb(3, "%s connected line has changed. Saving it until answer for %s\n", c->name, in->name);
1061                                                 ast_party_connected_line_set_init(&connected, &o->connected);
1062                                                 ast_connected_line_parse_data(f->data.ptr, f->datalen, &connected);
1063                                                 ast_party_connected_line_set(&o->connected, &connected);
1064                                                 ast_party_connected_line_free(&connected);
1065                                         } else {
1066                                                 ast_verb(3, "%s connected line has changed, passing it to %s\n", c->name, in->name);
1067                                                 ast_indicate_data(in, AST_CONTROL_CONNECTED_LINE, f->data.ptr, f->datalen);
1068                                         }
1069                                         break;
1070                                 case AST_CONTROL_REDIRECTING:
1071                                         if (ast_test_flag64(peerflags, OPT_IGNORE_CONNECTEDLINE)) {
1072                                                 ast_verb(3, "Redirecting update to %s prevented.\n", in->name);
1073                                         } else {
1074                                                 ast_verb(3, "%s redirecting info has changed, passing it to %s\n", c->name, in->name);
1075                                                 ast_indicate_data(in, AST_CONTROL_REDIRECTING, f->data.ptr, f->datalen);
1076                                         }
1077                                         break;
1078                                 case AST_CONTROL_PROCEEDING:
1079                                         ast_verb(3, "%s is proceeding passing it to %s\n", c->name, in->name);
1080                                         if (single && CAN_EARLY_BRIDGE(peerflags, in, c))
1081                                                 ast_channel_early_bridge(in, c);
1082                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK))
1083                                                 ast_indicate(in, AST_CONTROL_PROCEEDING);
1084                                         break;
1085                                 case AST_CONTROL_HOLD:
1086                                         ast_verb(3, "Call on %s placed on hold\n", c->name);
1087                                         ast_indicate(in, AST_CONTROL_HOLD);
1088                                         break;
1089                                 case AST_CONTROL_UNHOLD:
1090                                         ast_verb(3, "Call on %s left from hold\n", c->name);
1091                                         ast_indicate(in, AST_CONTROL_UNHOLD);
1092                                         break;
1093                                 case AST_CONTROL_OFFHOOK:
1094                                 case AST_CONTROL_FLASH:
1095                                         /* Ignore going off hook and flash */
1096                                         break;
1097                                 case -1:
1098                                         if (!ast_test_flag64(outgoing, OPT_RINGBACK | OPT_MUSICBACK)) {
1099                                                 ast_verb(3, "%s stopped sounds\n", c->name);
1100                                                 ast_indicate(in, -1);
1101                                                 pa->sentringing = 0;
1102                                         }
1103                                         break;
1104                                 default:
1105                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
1106                                 }
1107                         } else if (single) {
1108                                 switch (f->frametype) {
1109                                         case AST_FRAME_VOICE:
1110                                         case AST_FRAME_IMAGE:
1111                                         case AST_FRAME_TEXT:
1112                                                 if (ast_write(in, f)) {
1113                                                         ast_log(LOG_WARNING, "Unable to write frame\n");
1114                                                 }
1115                                                 break;
1116                                         case AST_FRAME_HTML:
1117                                                 if (!ast_test_flag64(outgoing, DIAL_NOFORWARDHTML) && ast_channel_sendhtml(in, f->subclass, f->data.ptr, f->datalen) == -1) {
1118                                                         ast_log(LOG_WARNING, "Unable to send URL\n");
1119                                                 }
1120                                                 break;
1121                                         default:
1122                                                 break;
1123                                 }
1124                         }
1125                         ast_frfree(f);
1126                 } /* end for */
1127                 if (winner == in) {
1128                         struct ast_frame *f = ast_read(in);
1129 #if 0
1130                         if (f && (f->frametype != AST_FRAME_VOICE))
1131                                 printf("Frame type: %d, %d\n", f->frametype, f->subclass);
1132                         else if (!f || (f->frametype != AST_FRAME_VOICE))
1133                                 printf("Hangup received on %s\n", in->name);
1134 #endif
1135                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
1136                                 /* Got hung up */
1137                                 *to = -1;
1138                                 strcpy(pa->status, "CANCEL");
1139                                 ast_cdr_noanswer(in->cdr);
1140                                 if (f) {
1141                                         if (f->data.uint32) {
1142                                                 in->hangupcause = f->data.uint32;
1143                                         }
1144                                         ast_frfree(f);
1145                                 }
1146                                 return NULL;
1147                         }
1148
1149                         /* now f is guaranteed non-NULL */
1150                         if (f->frametype == AST_FRAME_DTMF) {
1151                                 if (ast_test_flag64(peerflags, OPT_DTMF_EXIT)) {
1152                                         const char *context;
1153                                         ast_channel_lock(in);
1154                                         context = pbx_builtin_getvar_helper(in, "EXITCONTEXT");
1155                                         if (onedigit_goto(in, context, (char) f->subclass, 1)) {
1156                                                 ast_verb(3, "User hit %c to disconnect call.\n", f->subclass);
1157                                                 *to = 0;
1158                                                 ast_cdr_noanswer(in->cdr);
1159                                                 *result = f->subclass;
1160                                                 strcpy(pa->status, "CANCEL");
1161                                                 ast_frfree(f);
1162                                                 ast_channel_unlock(in);
1163                                                 return NULL;
1164                                         }
1165                                         ast_channel_unlock(in);
1166                                 }
1167
1168                                 if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP) &&
1169                                         detect_disconnect(in, f->subclass, featurecode)) {
1170                                         ast_verb(3, "User requested call disconnect.\n");
1171                                         *to = 0;
1172                                         strcpy(pa->status, "CANCEL");
1173                                         ast_cdr_noanswer(in->cdr);
1174                                         ast_frfree(f);
1175                                         return NULL;
1176                                 }
1177                         }
1178
1179                         /* Forward HTML stuff */
1180                         if (single && (f->frametype == AST_FRAME_HTML) && !ast_test_flag64(outgoing, DIAL_NOFORWARDHTML))
1181                                 if (ast_channel_sendhtml(outgoing->chan, f->subclass, f->data.ptr, f->datalen) == -1)
1182                                         ast_log(LOG_WARNING, "Unable to send URL\n");
1183
1184                         if (single && ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_DTMF_BEGIN) || (f->frametype == AST_FRAME_DTMF_END)))  {
1185                                 if (ast_write(outgoing->chan, f))
1186                                         ast_log(LOG_WARNING, "Unable to forward voice or dtmf\n");
1187                         }
1188                         if (single && (f->frametype == AST_FRAME_CONTROL) &&
1189                                 ((f->subclass == AST_CONTROL_HOLD) ||
1190                                 (f->subclass == AST_CONTROL_UNHOLD) ||
1191                                 (f->subclass == AST_CONTROL_VIDUPDATE) ||
1192                                 (f->subclass == AST_CONTROL_SRCUPDATE) ||
1193                                 (f->subclass == AST_CONTROL_CONNECTED_LINE) ||
1194                                 (f->subclass == AST_CONTROL_REDIRECTING))) {
1195                                 ast_verb(3, "%s requested special control %d, passing it to %s\n", in->name, f->subclass, outgoing->chan->name);
1196                                 ast_indicate_data(outgoing->chan, f->subclass, f->data.ptr, f->datalen);
1197                         }
1198                         ast_frfree(f);
1199                 }
1200                 if (!*to)
1201                         ast_verb(3, "Nobody picked up in %d ms\n", orig);
1202                 if (!*to || ast_check_hangup(in))
1203                         ast_cdr_noanswer(in->cdr);
1204         }
1205
1206 #ifdef HAVE_EPOLL
1207         for (epollo = outgoing; epollo; epollo = epollo->next) {
1208                 if (epollo->chan)
1209                         ast_poll_channel_del(in, epollo->chan);
1210         }
1211 #endif
1212
1213         return peer;
1214 }
1215
1216 static int detect_disconnect(struct ast_channel *chan, char code, struct ast_str *featurecode)
1217 {
1218         struct ast_flags features = { AST_FEATURE_DISCONNECT }; /* only concerned with disconnect feature */
1219         struct ast_call_feature feature = { 0, };
1220         int res;
1221
1222         ast_str_append(&featurecode, 1, "%c", code);
1223
1224         res = ast_feature_detect(chan, &features, ast_str_buffer(featurecode), &feature);
1225
1226         if (res != AST_FEATURE_RETURN_STOREDIGITS) {
1227                 ast_str_reset(featurecode);
1228         }
1229         if (feature.feature_mask & AST_FEATURE_DISCONNECT) {
1230                 return 1;
1231         }
1232
1233         return 0;
1234 }
1235
1236 static void replace_macro_delimiter(char *s)
1237 {
1238         for (; *s; s++)
1239                 if (*s == '^')
1240                         *s = ',';
1241 }
1242
1243 /* returns true if there is a valid privacy reply */
1244 static int valid_priv_reply(struct ast_flags64 *opts, int res)
1245 {
1246         if (res < '1')
1247                 return 0;
1248         if (ast_test_flag64(opts, OPT_PRIVACY) && res <= '5')
1249                 return 1;
1250         if (ast_test_flag64(opts, OPT_SCREENING) && res <= '4')
1251                 return 1;
1252         return 0;
1253 }
1254
1255 static int do_timelimit(struct ast_channel *chan, struct ast_bridge_config *config,
1256         char *parse, struct timeval *calldurationlimit)
1257 {
1258         char *stringp = ast_strdupa(parse);
1259         char *limit_str, *warning_str, *warnfreq_str;
1260         const char *var;
1261         int play_to_caller = 0, play_to_callee = 0;
1262         int delta;
1263
1264         limit_str = strsep(&stringp, ":");
1265         warning_str = strsep(&stringp, ":");
1266         warnfreq_str = strsep(&stringp, ":");
1267
1268         config->timelimit = atol(limit_str);
1269         if (warning_str)
1270                 config->play_warning = atol(warning_str);
1271         if (warnfreq_str)
1272                 config->warning_freq = atol(warnfreq_str);
1273
1274         if (!config->timelimit) {
1275                 ast_log(LOG_WARNING, "Dial does not accept L(%s), hanging up.\n", limit_str);
1276                 config->timelimit = config->play_warning = config->warning_freq = 0;
1277                 config->warning_sound = NULL;
1278                 return -1; /* error */
1279         } else if ( (delta = config->play_warning - config->timelimit) > 0) {
1280                 int w = config->warning_freq;
1281
1282                 /* If the first warning is requested _after_ the entire call would end,
1283                    and no warning frequency is requested, then turn off the warning. If
1284                    a warning frequency is requested, reduce the 'first warning' time by
1285                    that frequency until it falls within the call's total time limit.
1286                    Graphically:
1287                                   timelim->|    delta        |<-playwarning
1288                         0__________________|_________________|
1289                                          | w  |    |    |    |
1290
1291                    so the number of intervals to cut is 1+(delta-1)/w
1292                 */
1293
1294                 if (w == 0) {
1295                         config->play_warning = 0;
1296                 } else {
1297                         config->play_warning -= w * ( 1 + (delta-1)/w );
1298                         if (config->play_warning < 1)
1299                                 config->play_warning = config->warning_freq = 0;
1300                 }
1301         }
1302         
1303         ast_channel_lock(chan);
1304
1305         var = pbx_builtin_getvar_helper(chan, "LIMIT_PLAYAUDIO_CALLER");
1306
1307         play_to_caller = var ? ast_true(var) : 1;
1308
1309         var = pbx_builtin_getvar_helper(chan, "LIMIT_PLAYAUDIO_CALLEE");
1310         play_to_callee = var ? ast_true(var) : 0;
1311
1312         if (!play_to_caller && !play_to_callee)
1313                 play_to_caller = 1;
1314
1315         var = pbx_builtin_getvar_helper(chan, "LIMIT_WARNING_FILE");
1316         config->warning_sound = !ast_strlen_zero(var) ? ast_strdup(var) : ast_strdup("timeleft");
1317
1318         /* The code looking at config wants a NULL, not just "", to decide
1319          * that the message should not be played, so we replace "" with NULL.
1320          * Note, pbx_builtin_getvar_helper _can_ return NULL if the variable is
1321          * not found.
1322          */
1323
1324         var = pbx_builtin_getvar_helper(chan, "LIMIT_TIMEOUT_FILE");
1325         config->end_sound = !ast_strlen_zero(var) ? ast_strdup(var) : NULL;
1326
1327         var = pbx_builtin_getvar_helper(chan, "LIMIT_CONNECT_FILE");
1328         config->start_sound = !ast_strlen_zero(var) ? ast_strdup(var) : NULL;
1329
1330         ast_channel_unlock(chan);
1331
1332         /* undo effect of S(x) in case they are both used */
1333         calldurationlimit->tv_sec = 0;
1334         calldurationlimit->tv_usec = 0;
1335
1336         /* more efficient to do it like S(x) does since no advanced opts */
1337         if (!config->play_warning && !config->start_sound && !config->end_sound && config->timelimit) {
1338                 calldurationlimit->tv_sec = config->timelimit / 1000;
1339                 calldurationlimit->tv_usec = (config->timelimit % 1000) * 1000;
1340                 ast_verb(3, "Setting call duration limit to %.3lf seconds.\n",
1341                         calldurationlimit->tv_sec + calldurationlimit->tv_usec / 1000000.0);
1342                 config->timelimit = play_to_caller = play_to_callee =
1343                 config->play_warning = config->warning_freq = 0;
1344         } else {
1345                 ast_verb(3, "Limit Data for this call:\n");
1346                 ast_verb(4, "timelimit      = %ld\n", config->timelimit);
1347                 ast_verb(4, "play_warning   = %ld\n", config->play_warning);
1348                 ast_verb(4, "play_to_caller = %s\n", play_to_caller ? "yes" : "no");
1349                 ast_verb(4, "play_to_callee = %s\n", play_to_callee ? "yes" : "no");
1350                 ast_verb(4, "warning_freq   = %ld\n", config->warning_freq);
1351                 ast_verb(4, "start_sound    = %s\n", S_OR(config->start_sound, ""));
1352                 ast_verb(4, "warning_sound  = %s\n", config->warning_sound);
1353                 ast_verb(4, "end_sound      = %s\n", S_OR(config->end_sound, ""));
1354         }
1355         if (play_to_caller)
1356                 ast_set_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
1357         if (play_to_callee)
1358                 ast_set_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
1359         return 0;
1360 }
1361
1362 static int do_privacy(struct ast_channel *chan, struct ast_channel *peer,
1363         struct ast_flags64 *opts, char **opt_args, struct privacy_args *pa)
1364 {
1365
1366         int res2;
1367         int loopcount = 0;
1368
1369         /* Get the user's intro, store it in priv-callerintros/$CID,
1370            unless it is already there-- this should be done before the
1371            call is actually dialed  */
1372
1373         /* all ring indications and moh for the caller has been halted as soon as the
1374            target extension was picked up. We are going to have to kill some
1375            time and make the caller believe the peer hasn't picked up yet */
1376
1377         if (ast_test_flag64(opts, OPT_MUSICBACK) && !ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
1378                 char *original_moh = ast_strdupa(chan->musicclass);
1379                 ast_indicate(chan, -1);
1380                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
1381                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
1382                 ast_string_field_set(chan, musicclass, original_moh);
1383         } else if (ast_test_flag64(opts, OPT_RINGBACK)) {
1384                 ast_indicate(chan, AST_CONTROL_RINGING);
1385                 pa->sentringing++;
1386         }
1387
1388         /* Start autoservice on the other chan ?? */
1389         res2 = ast_autoservice_start(chan);
1390         /* Now Stream the File */
1391         for (loopcount = 0; loopcount < 3; loopcount++) {
1392                 if (res2 && loopcount == 0) /* error in ast_autoservice_start() */
1393                         break;
1394                 if (!res2) /* on timeout, play the message again */
1395                         res2 = ast_play_and_wait(peer, "priv-callpending");
1396                 if (!valid_priv_reply(opts, res2))
1397                         res2 = 0;
1398                 /* priv-callpending script:
1399                    "I have a caller waiting, who introduces themselves as:"
1400                 */
1401                 if (!res2)
1402                         res2 = ast_play_and_wait(peer, pa->privintro);
1403                 if (!valid_priv_reply(opts, res2))
1404                         res2 = 0;
1405                 /* now get input from the called party, as to their choice */
1406                 if (!res2) {
1407                         /* XXX can we have both, or they are mutually exclusive ? */
1408                         if (ast_test_flag64(opts, OPT_PRIVACY))
1409                                 res2 = ast_play_and_wait(peer, "priv-callee-options");
1410                         if (ast_test_flag64(opts, OPT_SCREENING))
1411                                 res2 = ast_play_and_wait(peer, "screen-callee-options");
1412                 }
1413                 /*! \page DialPrivacy Dial Privacy scripts
1414                 \par priv-callee-options script:
1415                         "Dial 1 if you wish this caller to reach you directly in the future,
1416                                 and immediately connect to their incoming call
1417                          Dial 2 if you wish to send this caller to voicemail now and
1418                                 forevermore.
1419                          Dial 3 to send this caller to the torture menus, now and forevermore.
1420                          Dial 4 to send this caller to a simple "go away" menu, now and forevermore.
1421                          Dial 5 to allow this caller to come straight thru to you in the future,
1422                                 but right now, just this once, send them to voicemail."
1423                 \par screen-callee-options script:
1424                         "Dial 1 if you wish to immediately connect to the incoming call
1425                          Dial 2 if you wish to send this caller to voicemail.
1426                          Dial 3 to send this caller to the torture menus.
1427                          Dial 4 to send this caller to a simple "go away" menu.
1428                 */
1429                 if (valid_priv_reply(opts, res2))
1430                         break;
1431                 /* invalid option */
1432                 res2 = ast_play_and_wait(peer, "vm-sorry");
1433         }
1434
1435         if (ast_test_flag64(opts, OPT_MUSICBACK)) {
1436                 ast_moh_stop(chan);
1437         } else if (ast_test_flag64(opts, OPT_RINGBACK)) {
1438                 ast_indicate(chan, -1);
1439                 pa->sentringing = 0;
1440         }
1441         ast_autoservice_stop(chan);
1442         if (ast_test_flag64(opts, OPT_PRIVACY) && (res2 >= '1' && res2 <= '5')) {
1443                 /* map keypresses to various things, the index is res2 - '1' */
1444                 static const char *_val[] = { "ALLOW", "DENY", "TORTURE", "KILL", "ALLOW" };
1445                 static const int _flag[] = { AST_PRIVACY_ALLOW, AST_PRIVACY_DENY, AST_PRIVACY_TORTURE, AST_PRIVACY_KILL, AST_PRIVACY_ALLOW};
1446                 int i = res2 - '1';
1447                 ast_verb(3, "--Set privacy database entry %s/%s to %s\n",
1448                         opt_args[OPT_ARG_PRIVACY], pa->privcid, _val[i]);
1449                 ast_privacy_set(opt_args[OPT_ARG_PRIVACY], pa->privcid, _flag[i]);
1450         }
1451         switch (res2) {
1452         case '1':
1453                 break;
1454         case '2':
1455                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1456                 break;
1457         case '3':
1458                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1459                 break;
1460         case '4':
1461                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1462                 break;
1463         case '5':
1464                 /* XXX should we set status to DENY ? */
1465                 if (ast_test_flag64(opts, OPT_PRIVACY))
1466                         break;
1467                 /* if not privacy, then 5 is the same as "default" case */
1468         default: /* bad input or -1 if failure to start autoservice */
1469                 /* well, if the user messes up, ... he had his chance... What Is The Best Thing To Do?  */
1470                 /* well, there seems basically two choices. Just patch the caller thru immediately,
1471                           or,... put 'em thru to voicemail. */
1472                 /* since the callee may have hung up, let's do the voicemail thing, no database decision */
1473                 ast_log(LOG_NOTICE, "privacy: no valid response from the callee. Sending the caller to voicemail, the callee isn't responding\n");
1474                 /* XXX should we set status to DENY ? */
1475                 /* XXX what about the privacy flags ? */
1476                 break;
1477         }
1478
1479         if (res2 == '1') { /* the only case where we actually connect */
1480                 /* if the intro is NOCALLERID, then there's no reason to leave it on disk, it'll
1481                    just clog things up, and it's not useful information, not being tied to a CID */
1482                 if (strncmp(pa->privcid, "NOCALLERID", 10) == 0 || ast_test_flag64(opts, OPT_SCREEN_NOINTRO)) {
1483                         ast_filedelete(pa->privintro, NULL);
1484                         if (ast_fileexists(pa->privintro, NULL, NULL) > 0)
1485                                 ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1486                         else
1487                                 ast_verb(3, "Successfully deleted %s intro file\n", pa->privintro);
1488                 }
1489                 return 0; /* the good exit path */
1490         } else {
1491                 ast_hangup(peer); /* hang up on the callee -- he didn't want to talk anyway! */
1492                 return -1;
1493         }
1494 }
1495
1496 /*! \brief returns 1 if successful, 0 or <0 if the caller should 'goto out' */
1497 static int setup_privacy_args(struct privacy_args *pa,
1498         struct ast_flags64 *opts, char *opt_args[], struct ast_channel *chan)
1499 {
1500         char callerid[60];
1501         int res;
1502         char *l;
1503         int silencethreshold;
1504
1505         if (!ast_strlen_zero(chan->cid.cid_num)) {
1506                 l = ast_strdupa(chan->cid.cid_num);
1507                 ast_shrink_phone_number(l);
1508                 if (ast_test_flag64(opts, OPT_PRIVACY) ) {
1509                         ast_verb(3, "Privacy DB is '%s', clid is '%s'\n", opt_args[OPT_ARG_PRIVACY], l);
1510                         pa->privdb_val = ast_privacy_check(opt_args[OPT_ARG_PRIVACY], l);
1511                 } else {
1512                         ast_verb(3, "Privacy Screening, clid is '%s'\n", l);
1513                         pa->privdb_val = AST_PRIVACY_UNKNOWN;
1514                 }
1515         } else {
1516                 char *tnam, *tn2;
1517
1518                 tnam = ast_strdupa(chan->name);
1519                 /* clean the channel name so slashes don't try to end up in disk file name */
1520                 for (tn2 = tnam; *tn2; tn2++) {
1521                         if (*tn2 == '/')  /* any other chars to be afraid of? */
1522                                 *tn2 = '=';
1523                 }
1524                 ast_verb(3, "Privacy-- callerid is empty\n");
1525
1526                 snprintf(callerid, sizeof(callerid), "NOCALLERID_%s%s", chan->exten, tnam);
1527                 l = callerid;
1528                 pa->privdb_val = AST_PRIVACY_UNKNOWN;
1529         }
1530
1531         ast_copy_string(pa->privcid, l, sizeof(pa->privcid));
1532
1533         if (strncmp(pa->privcid, "NOCALLERID", 10) != 0 && ast_test_flag64(opts, OPT_SCREEN_NOCALLERID)) {
1534                 /* if callerid is set and OPT_SCREEN_NOCALLERID is set also */
1535                 ast_verb(3, "CallerID set (%s); N option set; Screening should be off\n", pa->privcid);
1536                 pa->privdb_val = AST_PRIVACY_ALLOW;
1537         } else if (ast_test_flag64(opts, OPT_SCREEN_NOCALLERID) && strncmp(pa->privcid, "NOCALLERID", 10) == 0) {
1538                 ast_verb(3, "CallerID blank; N option set; Screening should happen; dbval is %d\n", pa->privdb_val);
1539         }
1540         
1541         if (pa->privdb_val == AST_PRIVACY_DENY) {
1542                 ast_verb(3, "Privacy DB reports PRIVACY_DENY for this callerid. Dial reports unavailable\n");
1543                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1544                 return 0;
1545         } else if (pa->privdb_val == AST_PRIVACY_KILL) {
1546                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1547                 return 0; /* Is this right? */
1548         } else if (pa->privdb_val == AST_PRIVACY_TORTURE) {
1549                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1550                 return 0; /* is this right??? */
1551         } else if (pa->privdb_val == AST_PRIVACY_UNKNOWN) {
1552                 /* Get the user's intro, store it in priv-callerintros/$CID,
1553                    unless it is already there-- this should be done before the
1554                    call is actually dialed  */
1555
1556                 /* make sure the priv-callerintros dir actually exists */
1557                 snprintf(pa->privintro, sizeof(pa->privintro), "%s/sounds/priv-callerintros", ast_config_AST_DATA_DIR);
1558                 if ((res = ast_mkdir(pa->privintro, 0755))) {
1559                         ast_log(LOG_WARNING, "privacy: can't create directory priv-callerintros: %s\n", strerror(res));
1560                         return -1;
1561                 }
1562
1563                 snprintf(pa->privintro, sizeof(pa->privintro), "priv-callerintros/%s", pa->privcid);
1564                 if (ast_fileexists(pa->privintro, NULL, NULL ) > 0 && strncmp(pa->privcid, "NOCALLERID", 10) != 0) {
1565                         /* the DELUX version of this code would allow this caller the
1566                            option to hear and retape their previously recorded intro.
1567                         */
1568                 } else {
1569                         int duration; /* for feedback from play_and_wait */
1570                         /* the file doesn't exist yet. Let the caller submit his
1571                            vocal intro for posterity */
1572                         /* priv-recordintro script:
1573
1574                            "At the tone, please say your name:"
1575
1576                         */
1577                         silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
1578                         ast_answer(chan);
1579                         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 */
1580                                                                         /* don't think we'll need a lock removed, we took care of
1581                                                                            conflicts by naming the pa.privintro file */
1582                         if (res == -1) {
1583                                 /* Delete the file regardless since they hung up during recording */
1584                                 ast_filedelete(pa->privintro, NULL);
1585                                 if (ast_fileexists(pa->privintro, NULL, NULL) > 0)
1586                                         ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1587                                 else
1588                                         ast_verb(3, "Successfully deleted %s intro file\n", pa->privintro);
1589                                 return -1;
1590                         }
1591                         if (!ast_streamfile(chan, "vm-dialout", chan->language) )
1592                                 ast_waitstream(chan, "");
1593                 }
1594         }
1595         return 1; /* success */
1596 }
1597
1598 static void end_bridge_callback(void *data)
1599 {
1600         char buf[80];
1601         time_t end;
1602         struct ast_channel *chan = data;
1603
1604         if (!chan->cdr) {
1605                 return;
1606         }
1607
1608         time(&end);
1609
1610         ast_channel_lock(chan);
1611         if (chan->cdr->answer.tv_sec) {
1612                 snprintf(buf, sizeof(buf), "%ld", end - chan->cdr->answer.tv_sec);
1613                 pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", buf);
1614         }
1615
1616         if (chan->cdr->start.tv_sec) {
1617                 snprintf(buf, sizeof(buf), "%ld", end - chan->cdr->start.tv_sec);
1618                 pbx_builtin_setvar_helper(chan, "DIALEDTIME", buf);
1619         }
1620         ast_channel_unlock(chan);
1621 }
1622
1623 static void end_bridge_callback_data_fixup(struct ast_bridge_config *bconfig, struct ast_channel *originator, struct ast_channel *terminator) {
1624         bconfig->end_bridge_callback_data = originator;
1625 }
1626
1627 static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags64 *peerflags, int *continue_exec)
1628 {
1629         int res = -1; /* default: error */
1630         char *rest, *cur; /* scan the list of destinations */
1631         struct chanlist *outgoing = NULL; /* list of destinations */
1632         struct ast_channel *peer;
1633         int to; /* timeout */
1634         struct cause_args num = { chan, 0, 0, 0 };
1635         int cause;
1636         char numsubst[256];
1637         char cidname[AST_MAX_EXTENSION] = "";
1638
1639         struct ast_bridge_config config = { { 0, } };
1640         struct timeval calldurationlimit = { 0, };
1641         char *dtmfcalled = NULL, *dtmfcalling = NULL, *dtmf_progress=NULL;
1642         struct privacy_args pa = {
1643                 .sentringing = 0,
1644                 .privdb_val = 0,
1645                 .status = "INVALIDARGS",
1646         };
1647         int sentringing = 0, moh = 0;
1648         const char *outbound_group = NULL;
1649         int result = 0;
1650         char *parse;
1651         int opermode = 0;
1652         AST_DECLARE_APP_ARGS(args,
1653                 AST_APP_ARG(peers);
1654                 AST_APP_ARG(timeout);
1655                 AST_APP_ARG(options);
1656                 AST_APP_ARG(url);
1657         );
1658         struct ast_flags64 opts = { 0, };
1659         char *opt_args[OPT_ARG_ARRAY_SIZE];
1660         struct ast_datastore *datastore = NULL;
1661         int fulldial = 0, num_dialed = 0;
1662
1663         /* Reset all DIAL variables back to blank, to prevent confusion (in case we don't reset all of them). */
1664         pbx_builtin_setvar_helper(chan, "DIALSTATUS", "");
1665         pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", "");
1666         pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", "");
1667         pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", "");
1668         pbx_builtin_setvar_helper(chan, "DIALEDTIME", "");
1669
1670         if (ast_strlen_zero(data)) {
1671                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1672                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1673                 return -1;
1674         }
1675
1676         parse = ast_strdupa(data);
1677
1678         AST_STANDARD_APP_ARGS(args, parse);
1679
1680         if (!ast_strlen_zero(args.options) &&
1681                 ast_app_parse_options64(dial_exec_options, &opts, opt_args, args.options)) {
1682                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1683                 goto done;
1684         }
1685
1686         if (ast_strlen_zero(args.peers)) {
1687                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1688                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1689                 goto done;
1690         }
1691
1692         if (ast_test_flag64(&opts, OPT_OPERMODE)) {
1693                 opermode = ast_strlen_zero(opt_args[OPT_ARG_OPERMODE]) ? 1 : atoi(opt_args[OPT_ARG_OPERMODE]);
1694                 ast_verb(3, "Setting operator services mode to %d.\n", opermode);
1695         }
1696
1697         if (ast_test_flag64(&opts, OPT_DURATION_STOP) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_STOP])) {
1698                 calldurationlimit.tv_sec = atoi(opt_args[OPT_ARG_DURATION_STOP]);
1699                 if (!calldurationlimit.tv_sec) {
1700                         ast_log(LOG_WARNING, "Dial does not accept S(%s), hanging up.\n", opt_args[OPT_ARG_DURATION_STOP]);
1701                         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1702                         goto done;
1703                 }
1704                 ast_verb(3, "Setting call duration limit to %.3lf seconds.\n", calldurationlimit.tv_sec + calldurationlimit.tv_usec / 1000000.0);
1705         }
1706
1707         if (ast_test_flag64(&opts, OPT_SENDDTMF) && !ast_strlen_zero(opt_args[OPT_ARG_SENDDTMF])) {
1708                 dtmf_progress = opt_args[OPT_ARG_SENDDTMF];
1709                 dtmfcalled = strsep(&dtmf_progress, ":");
1710                 dtmfcalling = strsep(&dtmf_progress, ":");
1711         }
1712
1713         if (ast_test_flag64(&opts, OPT_DURATION_LIMIT) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_LIMIT])) {
1714                 if (do_timelimit(chan, &config, opt_args[OPT_ARG_DURATION_LIMIT], &calldurationlimit))
1715                         goto done;
1716         }
1717
1718         if (ast_test_flag64(&opts, OPT_RESETCDR) && chan->cdr)
1719                 ast_cdr_reset(chan->cdr, NULL);
1720         if (ast_test_flag64(&opts, OPT_PRIVACY) && ast_strlen_zero(opt_args[OPT_ARG_PRIVACY]))
1721                 opt_args[OPT_ARG_PRIVACY] = ast_strdupa(chan->exten);
1722
1723         if (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) {
1724                 res = setup_privacy_args(&pa, &opts, opt_args, chan);
1725                 if (res <= 0)
1726                         goto out;
1727                 res = -1; /* reset default */
1728         }
1729
1730         if (ast_test_flag64(&opts, OPT_DTMF_EXIT) || ast_test_flag64(&opts, OPT_CALLER_HANGUP)) {
1731                 __ast_answer(chan, 0, 0);
1732         }
1733
1734         if (continue_exec)
1735                 *continue_exec = 0;
1736
1737         /* If a channel group has been specified, get it for use when we create peer channels */
1738
1739         ast_channel_lock(chan);
1740         if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP_ONCE"))) {
1741                 outbound_group = ast_strdupa(outbound_group);   
1742                 pbx_builtin_setvar_helper(chan, "OUTBOUND_GROUP_ONCE", NULL);
1743         } else if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP"))) {
1744                 outbound_group = ast_strdupa(outbound_group);
1745         }
1746         ast_channel_unlock(chan);       
1747         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);
1748
1749         /* loop through the list of dial destinations */
1750         rest = args.peers;
1751         while ((cur = strsep(&rest, "&")) ) {
1752                 struct chanlist *tmp;
1753                 struct ast_channel *tc; /* channel for this destination */
1754                 /* Get a technology/[device:]number pair */
1755                 char *number = cur;
1756                 char *interface = ast_strdupa(number);
1757                 char *tech = strsep(&number, "/");
1758                 /* find if we already dialed this interface */
1759                 struct ast_dialed_interface *di;
1760                 AST_LIST_HEAD(, ast_dialed_interface) *dialed_interfaces;
1761                 num_dialed++;
1762                 if (!number) {
1763                         ast_log(LOG_WARNING, "Dial argument takes format (technology/[device:]number1)\n");
1764                         goto out;
1765                 }
1766                 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1767                         goto out;
1768                 if (opts.flags) {
1769                         ast_copy_flags64(tmp, &opts,
1770                                 OPT_CANCEL_ELSEWHERE |
1771                                 OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
1772                                 OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
1773                                 OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
1774                                 OPT_CALLEE_PARK | OPT_CALLER_PARK |
1775                                 OPT_CALLEE_MIXMONITOR | OPT_CALLER_MIXMONITOR |
1776                                 OPT_RINGBACK | OPT_MUSICBACK | OPT_FORCECLID);
1777                         ast_set2_flag64(tmp, args.url, DIAL_NOFORWARDHTML);
1778                 }
1779                 ast_copy_string(numsubst, number, sizeof(numsubst));
1780                 /* Request the peer */
1781
1782                 ast_channel_lock(chan);
1783                 datastore = ast_channel_datastore_find(chan, &dialed_interface_info, NULL);
1784                 /* If the incoming channel has previously had connected line information
1785                  * set on it (perhaps through the CONNECTED_LINE dialplan function) then
1786                  * seed the calllist's connected line information with this previously
1787                  * acquired info
1788                  */
1789                 if (chan->connected.id.number) {
1790                         ast_party_connected_line_copy(&tmp->connected, &chan->connected);
1791                 }
1792                 ast_channel_unlock(chan);
1793
1794                 if (datastore)
1795                         dialed_interfaces = datastore->data;
1796                 else {
1797                         if (!(datastore = ast_datastore_alloc(&dialed_interface_info, NULL))) {
1798                                 ast_log(LOG_WARNING, "Unable to create channel datastore for dialed interfaces. Aborting!\n");
1799                                 ast_free(tmp);
1800                                 goto out;
1801                         }
1802
1803                         datastore->inheritance = DATASTORE_INHERIT_FOREVER;
1804
1805                         if (!(dialed_interfaces = ast_calloc(1, sizeof(*dialed_interfaces)))) {
1806                                 ast_free(tmp);
1807                                 goto out;
1808                         }
1809
1810                         datastore->data = dialed_interfaces;
1811                         AST_LIST_HEAD_INIT(dialed_interfaces);
1812
1813                         ast_channel_lock(chan);
1814                         ast_channel_datastore_add(chan, datastore);
1815                         ast_channel_unlock(chan);
1816                 }
1817
1818                 AST_LIST_LOCK(dialed_interfaces);
1819                 AST_LIST_TRAVERSE(dialed_interfaces, di, list) {
1820                         if (!strcasecmp(di->interface, interface)) {
1821                                 ast_log(LOG_WARNING, "Skipping dialing interface '%s' again since it has already been dialed\n",
1822                                         di->interface);
1823                                 break;
1824                         }
1825                 }
1826                 AST_LIST_UNLOCK(dialed_interfaces);
1827
1828                 if (di) {
1829                         fulldial++;
1830                         ast_free(tmp);
1831                         continue;
1832                 }
1833
1834                 /* It is always ok to dial a Local interface.  We only keep track of
1835                  * which "real" interfaces have been dialed.  The Local channel will
1836                  * inherit this list so that if it ends up dialing a real interface,
1837                  * it won't call one that has already been called. */
1838                 if (strcasecmp(tech, "Local")) {
1839                         if (!(di = ast_calloc(1, sizeof(*di) + strlen(interface)))) {
1840                                 AST_LIST_UNLOCK(dialed_interfaces);
1841                                 ast_free(tmp);
1842                                 goto out;
1843                         }
1844                         strcpy(di->interface, interface);
1845
1846                         AST_LIST_LOCK(dialed_interfaces);
1847                         AST_LIST_INSERT_TAIL(dialed_interfaces, di, list);
1848                         AST_LIST_UNLOCK(dialed_interfaces);
1849                 }
1850
1851                 tc = ast_request(tech, chan->nativeformats, numsubst, &cause);
1852                 if (!tc) {
1853                         /* If we can't, just go on to the next call */
1854                         ast_log(LOG_WARNING, "Unable to create channel of type '%s' (cause %d - %s)\n",
1855                                 tech, cause, ast_cause2str(cause));
1856                         handle_cause(cause, &num);
1857                         if (!rest) /* we are on the last destination */
1858                                 chan->hangupcause = cause;
1859                         ast_free(tmp);
1860                         continue;
1861                 }
1862                 pbx_builtin_setvar_helper(tc, "DIALEDPEERNUMBER", numsubst);
1863
1864                 ast_channel_lock(tc);
1865                 while (ast_channel_trylock(chan)) {
1866                         CHANNEL_DEADLOCK_AVOIDANCE(tc);
1867                 }
1868                 /* Setup outgoing SDP to match incoming one */
1869                 if (!outgoing && !rest) {
1870                         ast_rtp_instance_early_bridge_make_compatible(tc, chan);
1871                 }
1872                 
1873                 /* Inherit specially named variables from parent channel */
1874                 ast_channel_inherit_variables(chan, tc);
1875                 ast_channel_datastore_inherit(chan, tc);
1876
1877                 tc->appl = "AppDial";
1878                 tc->data = "(Outgoing Line)";
1879                 memset(&tc->whentohangup, 0, sizeof(tc->whentohangup));
1880
1881                 /* If the new channel has no callerid, try to guess what it should be */
1882                 if (ast_strlen_zero(tc->cid.cid_num)) {
1883                         if (!ast_strlen_zero(chan->connected.id.number)) {
1884                                 ast_set_callerid(tc, chan->connected.id.number, chan->connected.id.name, chan->connected.ani);
1885                         } else if (!ast_strlen_zero(chan->cid.cid_dnid)) {
1886                                 ast_set_callerid(tc, chan->cid.cid_dnid, NULL, NULL);
1887                         } else if (!ast_strlen_zero(S_OR(chan->macroexten, chan->exten))) {
1888                                 ast_set_callerid(tc, S_OR(chan->macroexten, chan->exten), NULL, NULL);
1889                         }
1890                         ast_set_flag64(tmp, DIAL_NOCONNECTEDLINE);
1891                 }
1892                 
1893                 ast_connected_line_copy_from_caller(&tc->connected, &chan->cid);
1894
1895                 S_REPLACE(tc->cid.cid_rdnis, ast_strdup(chan->cid.cid_rdnis));
1896                 ast_party_redirecting_copy(&tc->redirecting, &chan->redirecting);
1897
1898                 tc->cid.cid_tns = chan->cid.cid_tns;
1899
1900                 ast_string_field_set(tc, accountcode, chan->accountcode);
1901                 tc->cdrflags = chan->cdrflags;
1902                 if (ast_strlen_zero(tc->musicclass))
1903                         ast_string_field_set(tc, musicclass, chan->musicclass);
1904
1905                 /* Pass ADSI CPE and transfer capability */
1906                 tc->adsicpe = chan->adsicpe;
1907                 tc->transfercapability = chan->transfercapability;
1908
1909                 /* If we have an outbound group, set this peer channel to it */
1910                 if (outbound_group)
1911                         ast_app_group_set_channel(tc, outbound_group);
1912                 /* If the calling channel has the ANSWERED_ELSEWHERE flag set, inherit it. This is to support local channels */
1913                 if (ast_test_flag(chan, AST_FLAG_ANSWERED_ELSEWHERE))
1914                         ast_set_flag(tc, AST_FLAG_ANSWERED_ELSEWHERE);
1915
1916                 /* Check if we're forced by configuration */
1917                 if (ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE))
1918                          ast_set_flag(tc, AST_FLAG_ANSWERED_ELSEWHERE);
1919
1920
1921                 /* Inherit context and extension */
1922                 ast_string_field_set(tc, dialcontext, ast_strlen_zero(chan->macrocontext) ? chan->context : chan->macrocontext);
1923                 if (!ast_strlen_zero(chan->macroexten))
1924                         ast_copy_string(tc->exten, chan->macroexten, sizeof(tc->exten));
1925                 else
1926                         ast_copy_string(tc->exten, chan->exten, sizeof(tc->exten));
1927
1928                 ast_channel_unlock(tc);
1929                 res = ast_call(tc, numsubst, 0); /* Place the call, but don't wait on the answer */
1930
1931                 /* Save the info in cdr's that we called them */
1932                 if (chan->cdr)
1933                         ast_cdr_setdestchan(chan->cdr, tc->name);
1934
1935                 /* check the results of ast_call */
1936                 if (res) {
1937                         /* Again, keep going even if there's an error */
1938                         ast_debug(1, "ast call on peer returned %d\n", res);
1939                         ast_verb(3, "Couldn't call %s\n", numsubst);
1940                         if (tc->hangupcause) {
1941                                 chan->hangupcause = tc->hangupcause;
1942                         }
1943                         ast_channel_unlock(chan);
1944                         ast_hangup(tc);
1945                         tc = NULL;
1946                         ast_free(tmp);
1947                         continue;
1948                 } else {
1949                         const char *tmpexten = ast_strdupa(S_OR(chan->macroexten, chan->exten));
1950                         senddialevent(chan, tc, numsubst);
1951                         ast_verb(3, "Called %s\n", numsubst);
1952                         ast_channel_unlock(chan);
1953                         if (!ast_test_flag64(peerflags, OPT_ORIGINAL_CLID)) {
1954                                 ast_set_callerid(tc, tmpexten, get_cid_name(cidname, sizeof(cidname), chan), NULL);
1955                         }
1956                 }
1957                 /* Put them in the list of outgoing thingies...  We're ready now.
1958                    XXX If we're forcibly removed, these outgoing calls won't get
1959                    hung up XXX */
1960                 ast_set_flag64(tmp, DIAL_STILLGOING);
1961                 tmp->chan = tc;
1962                 tmp->next = outgoing;
1963                 outgoing = tmp;
1964                 /* If this line is up, don't try anybody else */
1965                 if (outgoing->chan->_state == AST_STATE_UP)
1966                         break;
1967         }
1968         
1969         if (ast_strlen_zero(args.timeout)) {
1970                 to = -1;
1971         } else {
1972                 to = atoi(args.timeout);
1973                 if (to > 0)
1974                         to *= 1000;
1975                 else {
1976                         ast_log(LOG_WARNING, "Invalid timeout specified: '%s'. Setting timeout to infinite\n", args.timeout);
1977                         to = -1;
1978                 }
1979         }
1980
1981         if (!outgoing) {
1982                 strcpy(pa.status, "CHANUNAVAIL");
1983                 if (fulldial == num_dialed) {
1984                         res = -1;
1985                         goto out;
1986                 }
1987         } else {
1988                 /* Our status will at least be NOANSWER */
1989                 strcpy(pa.status, "NOANSWER");
1990                 if (ast_test_flag64(outgoing, OPT_MUSICBACK)) {
1991                         moh = 1;
1992                         if (!ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
1993                                 char *original_moh = ast_strdupa(chan->musicclass);
1994                                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
1995                                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
1996                                 ast_string_field_set(chan, musicclass, original_moh);
1997                         } else {
1998                                 ast_moh_start(chan, NULL, NULL);
1999                         }
2000                         ast_indicate(chan, AST_CONTROL_PROGRESS);
2001                 } else if (ast_test_flag64(outgoing, OPT_RINGBACK)) {
2002                         ast_indicate(chan, AST_CONTROL_RINGING);
2003                         sentringing++;
2004                 }
2005         }
2006
2007         peer = wait_for_answer(chan, outgoing, &to, peerflags, &pa, &num, &result, dtmf_progress);
2008
2009         /* The ast_channel_datastore_remove() function could fail here if the
2010          * datastore was moved to another channel during a masquerade. If this is
2011          * the case, don't free the datastore here because later, when the channel
2012          * to which the datastore was moved hangs up, it will attempt to free this
2013          * datastore again, causing a crash
2014          */
2015         if (!ast_channel_datastore_remove(chan, datastore))
2016                 ast_datastore_free(datastore);
2017         if (!peer) {
2018                 if (result) {
2019                         res = result;
2020                 } else if (to) { /* Musta gotten hung up */
2021                         res = -1;
2022                 } else { /* Nobody answered, next please? */
2023                         res = 0;
2024                 }
2025
2026                 /* SIP, in particular, sends back this error code to indicate an
2027                  * overlap dialled number needs more digits. */
2028                 if (chan->hangupcause == AST_CAUSE_INVALID_NUMBER_FORMAT) {
2029                         res = AST_PBX_INCOMPLETE;
2030                 }
2031
2032                 /* almost done, although the 'else' block is 400 lines */
2033         } else {
2034                 const char *number;
2035
2036                 strcpy(pa.status, "ANSWER");
2037                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
2038                 /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
2039                    we will always return with -1 so that it is hung up properly after the
2040                    conversation.  */
2041                 hanguptree(outgoing, peer, 1);
2042                 outgoing = NULL;
2043                 /* If appropriate, log that we have a destination channel */
2044                 if (chan->cdr)
2045                         ast_cdr_setdestchan(chan->cdr, peer->name);
2046                 if (peer->name)
2047                         pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", peer->name);
2048                 
2049                 ast_channel_lock(peer);
2050                 number = pbx_builtin_getvar_helper(peer, "DIALEDPEERNUMBER"); 
2051                 if (!number)
2052                         number = numsubst;
2053                 pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", number);
2054                 ast_channel_unlock(peer);
2055
2056                 if (!ast_strlen_zero(args.url) && ast_channel_supports_html(peer) ) {
2057                         ast_debug(1, "app_dial: sendurl=%s.\n", args.url);
2058                         ast_channel_sendurl( peer, args.url );
2059                 }
2060                 if ( (ast_test_flag64(&opts, OPT_PRIVACY) || ast_test_flag64(&opts, OPT_SCREENING)) && pa.privdb_val == AST_PRIVACY_UNKNOWN) {
2061                         if (do_privacy(chan, peer, &opts, opt_args, &pa)) {
2062                                 res = 0;
2063                                 goto out;
2064                         }
2065                 }
2066                 if (!ast_test_flag64(&opts, OPT_ANNOUNCE) || ast_strlen_zero(opt_args[OPT_ARG_ANNOUNCE])) {
2067                         res = 0;
2068                 } else {
2069                         int digit = 0;
2070                         /* Start autoservice on the other chan */
2071                         res = ast_autoservice_start(chan);
2072                         /* Now Stream the File */
2073                         if (!res)
2074                                 res = ast_streamfile(peer, opt_args[OPT_ARG_ANNOUNCE], peer->language);
2075                         if (!res) {
2076                                 digit = ast_waitstream(peer, AST_DIGIT_ANY);
2077                         }
2078                         /* Ok, done. stop autoservice */
2079                         res = ast_autoservice_stop(chan);
2080                         if (digit > 0 && !res)
2081                                 res = ast_senddigit(chan, digit, 0);
2082                         else
2083                                 res = digit;
2084
2085                 }
2086
2087                 if (chan && peer && ast_test_flag64(&opts, OPT_GOTO) && !ast_strlen_zero(opt_args[OPT_ARG_GOTO])) {
2088                         replace_macro_delimiter(opt_args[OPT_ARG_GOTO]);
2089                         ast_parseable_goto(chan, opt_args[OPT_ARG_GOTO]);
2090                         /* peer goes to the same context and extension as chan, so just copy info from chan*/
2091                         ast_copy_string(peer->context, chan->context, sizeof(peer->context));
2092                         ast_copy_string(peer->exten, chan->exten, sizeof(peer->exten));
2093                         peer->priority = chan->priority + 2;
2094                         ast_pbx_start(peer);
2095                         hanguptree(outgoing, NULL, ast_test_flag64(&opts, OPT_CANCEL_ELSEWHERE) ? 1 : 0);
2096                         if (continue_exec)
2097                                 *continue_exec = 1;
2098                         res = 0;
2099                         goto done;
2100                 }
2101
2102                 if (ast_test_flag64(&opts, OPT_CALLEE_MACRO) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_MACRO])) {
2103                         struct ast_app *theapp;
2104                         const char *macro_result;
2105
2106                         res = ast_autoservice_start(chan);
2107                         if (res) {
2108                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
2109                                 res = -1;
2110                         }
2111
2112                         theapp = pbx_findapp("Macro");
2113
2114                         if (theapp && !res) { /* XXX why check res here ? */
2115                                 /* Set peer->exten and peer->context so that MACRO_EXTEN and MACRO_CONTEXT get set */
2116                                 ast_copy_string(peer->context, chan->context, sizeof(peer->context));
2117                                 ast_copy_string(peer->exten, chan->exten, sizeof(peer->exten));
2118
2119                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_MACRO]);
2120                                 res = pbx_exec(peer, theapp, opt_args[OPT_ARG_CALLEE_MACRO]);
2121                                 ast_debug(1, "Macro exited with status %d\n", res);
2122                                 res = 0;
2123                         } else {
2124                                 ast_log(LOG_ERROR, "Could not find application Macro\n");
2125                                 res = -1;
2126                         }
2127
2128                         if (ast_autoservice_stop(chan) < 0) {
2129                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
2130                                 res = -1;
2131                         }
2132
2133                         ast_channel_lock(peer);
2134
2135                         if (!res && (macro_result = pbx_builtin_getvar_helper(peer, "MACRO_RESULT"))) {
2136                                 char *macro_transfer_dest;
2137
2138                                 if (!strcasecmp(macro_result, "BUSY")) {
2139                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
2140                                         ast_set_flag64(peerflags, OPT_GO_ON);
2141                                         res = -1;
2142                                 } else if (!strcasecmp(macro_result, "CONGESTION") || !strcasecmp(macro_result, "CHANUNAVAIL")) {
2143                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
2144                                         ast_set_flag64(peerflags, OPT_GO_ON);
2145                                         res = -1;
2146                                 } else if (!strcasecmp(macro_result, "CONTINUE")) {
2147                                         /* hangup peer and keep chan alive assuming the macro has changed
2148                                            the context / exten / priority or perhaps
2149                                            the next priority in the current exten is desired.
2150                                         */
2151                                         ast_set_flag64(peerflags, OPT_GO_ON);
2152                                         res = -1;
2153                                 } else if (!strcasecmp(macro_result, "ABORT")) {
2154                                         /* Hangup both ends unless the caller has the g flag */
2155                                         res = -1;
2156                                 } else if (!strncasecmp(macro_result, "GOTO:", 5) && (macro_transfer_dest = ast_strdupa(macro_result + 5))) {
2157                                         res = -1;
2158                                         /* perform a transfer to a new extension */
2159                                         if (strchr(macro_transfer_dest, '^')) { /* context^exten^priority*/
2160                                                 replace_macro_delimiter(macro_transfer_dest);
2161                                                 if (!ast_parseable_goto(chan, macro_transfer_dest))
2162                                                         ast_set_flag64(peerflags, OPT_GO_ON);
2163                                         }
2164                                 }
2165                         }
2166
2167                         ast_channel_unlock(peer);
2168                 }
2169
2170                 if (ast_test_flag64(&opts, OPT_CALLEE_GOSUB) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GOSUB])) {
2171                         struct ast_app *theapp;
2172                         const char *gosub_result;
2173                         char *gosub_args, *gosub_argstart;
2174                         int res9 = -1;
2175
2176                         res9 = ast_autoservice_start(chan);
2177                         if (res9) {
2178                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
2179                                 res9 = -1;
2180                         }
2181
2182                         theapp = pbx_findapp("Gosub");
2183
2184                         if (theapp && !res9) {
2185                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_GOSUB]);
2186
2187                                 /* Set where we came from */
2188                                 ast_copy_string(peer->context, "app_dial_gosub_virtual_context", sizeof(peer->context));
2189                                 ast_copy_string(peer->exten, "s", sizeof(peer->exten));
2190                                 peer->priority = 0;
2191
2192                                 gosub_argstart = strchr(opt_args[OPT_ARG_CALLEE_GOSUB], ',');
2193                                 if (gosub_argstart) {
2194                                         *gosub_argstart = 0;
2195                                         if (asprintf(&gosub_args, "%s,s,1(%s)", opt_args[OPT_ARG_CALLEE_GOSUB], gosub_argstart + 1) < 0) {
2196                                                 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
2197                                                 gosub_args = NULL;
2198                                         }
2199                                         *gosub_argstart = ',';
2200                                 } else {
2201                                         if (asprintf(&gosub_args, "%s,s,1", opt_args[OPT_ARG_CALLEE_GOSUB]) < 0) {
2202                                                 ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
2203                                                 gosub_args = NULL;
2204                                         }
2205                                 }
2206
2207                                 if (gosub_args) {
2208                                         res9 = pbx_exec(peer, theapp, gosub_args);
2209                                         if (!res9) {
2210                                                 struct ast_pbx_args args;
2211                                                 /* A struct initializer fails to compile for this case ... */
2212                                                 memset(&args, 0, sizeof(args));
2213                                                 args.no_hangup_chan = 1;
2214                                                 ast_pbx_run_args(peer, &args);
2215                                         }
2216                                         ast_free(gosub_args);
2217                                         ast_debug(1, "Gosub exited with status %d\n", res9);
2218                                 } else {
2219                                         ast_log(LOG_ERROR, "Could not Allocate string for Gosub arguments -- Gosub Call Aborted!\n");
2220                                 }
2221
2222                         } else if (!res9) {
2223                                 ast_log(LOG_ERROR, "Could not find application Gosub\n");
2224                                 res9 = -1;
2225                         }
2226
2227                         if (ast_autoservice_stop(chan) < 0) {
2228                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
2229                                 res9 = -1;
2230                         }
2231                         
2232                         ast_channel_lock(peer);
2233
2234                         if (!res9 && (gosub_result = pbx_builtin_getvar_helper(peer, "GOSUB_RESULT"))) {
2235                                 char *gosub_transfer_dest;
2236
2237                                 if (!strcasecmp(gosub_result, "BUSY")) {
2238                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
2239                                         ast_set_flag64(peerflags, OPT_GO_ON);
2240                                         res9 = -1;
2241                                 } else if (!strcasecmp(gosub_result, "CONGESTION") || !strcasecmp(gosub_result, "CHANUNAVAIL")) {
2242                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
2243                                         ast_set_flag64(peerflags, OPT_GO_ON);
2244                                         res9 = -1;
2245                                 } else if (!strcasecmp(gosub_result, "CONTINUE")) {
2246                                         /* hangup peer and keep chan alive assuming the macro has changed
2247                                            the context / exten / priority or perhaps
2248                                            the next priority in the current exten is desired.
2249                                         */
2250                                         ast_set_flag64(peerflags, OPT_GO_ON);
2251                                         res9 = -1;
2252                                 } else if (!strcasecmp(gosub_result, "ABORT")) {
2253                                         /* Hangup both ends unless the caller has the g flag */
2254                                         res9 = -1;
2255                                 } else if (!strncasecmp(gosub_result, "GOTO:", 5) && (gosub_transfer_dest = ast_strdupa(gosub_result + 5))) {
2256                                         res9 = -1;
2257                                         /* perform a transfer to a new extension */
2258                                         if (strchr(gosub_transfer_dest, '^')) { /* context^exten^priority*/
2259                                                 replace_macro_delimiter(gosub_transfer_dest);
2260                                                 if (!ast_parseable_goto(chan, gosub_transfer_dest))
2261                                                         ast_set_flag64(peerflags, OPT_GO_ON);
2262                                         }
2263                                 }
2264                         }
2265
2266                         ast_channel_unlock(peer);       
2267                 }
2268
2269                 if (!res) {
2270                         if (!ast_tvzero(calldurationlimit)) {
2271                                 struct timeval whentohangup = calldurationlimit;
2272                                 peer->whentohangup = ast_tvadd(ast_tvnow(), whentohangup);
2273                         }
2274                         if (!ast_strlen_zero(dtmfcalled)) {
2275                                 ast_verb(3, "Sending DTMF '%s' to the called party.\n", dtmfcalled);
2276                                 res = ast_dtmf_stream(peer, chan, dtmfcalled, 250, 0);
2277                         }
2278                         if (!ast_strlen_zero(dtmfcalling)) {
2279                                 ast_verb(3, "Sending DTMF '%s' to the calling party.\n", dtmfcalling);
2280                                 res = ast_dtmf_stream(chan, peer, dtmfcalling, 250, 0);
2281                         }
2282                 }
2283
2284                 if (res) { /* some error */
2285                         res = -1;
2286                 } else {
2287                         if (ast_test_flag64(peerflags, OPT_CALLEE_TRANSFER))
2288                                 ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
2289                         if (ast_test_flag64(peerflags, OPT_CALLER_TRANSFER))
2290                                 ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
2291                         if (ast_test_flag64(peerflags, OPT_CALLEE_HANGUP))
2292                                 ast_set_flag(&(config.features_callee), AST_FEATURE_DISCONNECT);
2293                         if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP))
2294                                 ast_set_flag(&(config.features_caller), AST_FEATURE_DISCONNECT);
2295                         if (ast_test_flag64(peerflags, OPT_CALLEE_MONITOR))
2296                                 ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMON);
2297                         if (ast_test_flag64(peerflags, OPT_CALLER_MONITOR))
2298                                 ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMON);
2299                         if (ast_test_flag64(peerflags, OPT_CALLEE_PARK))
2300                                 ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
2301                         if (ast_test_flag64(peerflags, OPT_CALLER_PARK))
2302                                 ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
2303                         if (ast_test_flag64(peerflags, OPT_CALLEE_MIXMONITOR))
2304                                 ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMIXMON);
2305                         if (ast_test_flag64(peerflags, OPT_CALLER_MIXMONITOR))
2306                                 ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMIXMON);
2307                         if (ast_test_flag64(peerflags, OPT_GO_ON))
2308                                 ast_set_flag(&(config.features_caller), AST_FEATURE_NO_H_EXTEN);
2309
2310                         config.end_bridge_callback = end_bridge_callback;
2311                         config.end_bridge_callback_data = chan;
2312                         config.end_bridge_callback_data_fixup = end_bridge_callback_data_fixup;
2313                         
2314                         if (moh) {
2315                                 moh = 0;
2316                                 ast_moh_stop(chan);
2317                         } else if (sentringing) {
2318                                 sentringing = 0;
2319                                 ast_indicate(chan, -1);
2320                         }
2321                         /* Be sure no generators are left on it */
2322                         ast_deactivate_generator(chan);
2323                         /* Make sure channels are compatible */
2324                         res = ast_channel_make_compatible(chan, peer);
2325                         if (res < 0) {
2326                                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", chan->name, peer->name);
2327                                 ast_hangup(peer);
2328                                 res = -1;
2329                                 goto done;
2330                         }
2331                         if (opermode) {
2332                                 struct oprmode oprmode;
2333
2334                                 oprmode.peer = peer;
2335                                 oprmode.mode = opermode;
2336
2337                                 ast_channel_setoption(chan, AST_OPTION_OPRMODE, &oprmode, sizeof(oprmode), 0);
2338                         }
2339                         res = ast_bridge_call(chan, peer, &config);
2340                 }
2341
2342                 strcpy(peer->context, chan->context);
2343
2344                 if (ast_test_flag64(&opts, OPT_PEER_H) && ast_exists_extension(peer, peer->context, "h", 1, peer->cid.cid_num)) {
2345                         int autoloopflag;
2346                         int found;
2347                         int res9;
2348                         
2349                         strcpy(peer->exten, "h");
2350                         peer->priority = 1;
2351                         autoloopflag = ast_test_flag(peer, AST_FLAG_IN_AUTOLOOP); /* save value to restore at the end */
2352                         ast_set_flag(peer, AST_FLAG_IN_AUTOLOOP);
2353
2354                         while ((res9 = ast_spawn_extension(peer, peer->context, peer->exten, peer->priority, peer->cid.cid_num, &found, 1)) == 0)
2355                                 peer->priority++;
2356
2357                         if (found && res9) {
2358                                 /* Something bad happened, or a hangup has been requested. */
2359                                 ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", peer->context, peer->exten, peer->priority, peer->name);
2360                                 ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", peer->context, peer->exten, peer->priority, peer->name);
2361                         }
2362                         ast_set2_flag(peer, autoloopflag, AST_FLAG_IN_AUTOLOOP);  /* set it back the way it was */
2363                 }
2364                 if (!ast_check_hangup(peer) && ast_test_flag64(&opts, OPT_CALLEE_GO_ON)) {
2365                         if(!ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GO_ON])) {
2366                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_GO_ON]);
2367                                 ast_parseable_goto(peer, opt_args[OPT_ARG_CALLEE_GO_ON]);
2368                         } else { /* F() */
2369                                 int res;
2370                                 res = ast_goto_if_exists(peer, chan->context, chan->exten, (chan->priority) + 1); 
2371                                 if (res == AST_PBX_GOTO_FAILED) {
2372                                         ast_hangup(peer);
2373                                         goto out;
2374                                 }
2375                         }
2376                         ast_pbx_start(peer);
2377                 } else {
2378                         if (!ast_check_hangup(chan))
2379                                 chan->hangupcause = peer->hangupcause;
2380                         ast_hangup(peer);
2381                 }
2382         }
2383 out:
2384         if (moh) {
2385                 moh = 0;
2386                 ast_moh_stop(chan);
2387         } else if (sentringing) {
2388                 sentringing = 0;
2389                 ast_indicate(chan, -1);
2390         }
2391         ast_channel_early_bridge(chan, NULL);
2392         hanguptree(outgoing, NULL, 0); /* In this case, there's no answer anywhere */
2393         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
2394         senddialendevent(chan, pa.status);
2395         ast_debug(1, "Exiting with DIALSTATUS=%s.\n", pa.status);
2396         
2397         if ((ast_test_flag64(peerflags, OPT_GO_ON)) && !ast_check_hangup(chan) && (res != AST_PBX_INCOMPLETE)) {
2398                 if (!ast_tvzero(calldurationlimit))
2399                         memset(&chan->whentohangup, 0, sizeof(chan->whentohangup));
2400                 res = 0;
2401         }
2402
2403 done:
2404         if (config.warning_sound) {
2405                 ast_free((char *)config.warning_sound);
2406         }
2407         if (config.end_sound) {
2408                 ast_free((char *)config.end_sound);
2409         }
2410         if (config.start_sound) {
2411                 ast_free((char *)config.start_sound);
2412         }
2413         return res;
2414 }
2415
2416 static int dial_exec(struct ast_channel *chan, void *data)
2417 {
2418         struct ast_flags64 peerflags;
2419
2420         memset(&peerflags, 0, sizeof(peerflags));
2421
2422         return dial_exec_full(chan, data, &peerflags, NULL);
2423 }
2424
2425 static int retrydial_exec(struct ast_channel *chan, void *data)
2426 {
2427         char *parse;
2428         const char *context = NULL;
2429         int sleepms = 0, loops = 0, res = -1;
2430         struct ast_flags64 peerflags = { 0, };
2431         AST_DECLARE_APP_ARGS(args,
2432                 AST_APP_ARG(announce);
2433                 AST_APP_ARG(sleep);
2434                 AST_APP_ARG(retries);
2435                 AST_APP_ARG(dialdata);
2436         );
2437
2438         if (ast_strlen_zero(data)) {
2439                 ast_log(LOG_WARNING, "RetryDial requires an argument!\n");
2440                 return -1;
2441         }
2442
2443         parse = ast_strdupa(data);
2444         AST_STANDARD_APP_ARGS(args, parse);
2445
2446         if (!ast_strlen_zero(args.sleep) && (sleepms = atoi(args.sleep)))
2447                 sleepms *= 1000;
2448
2449         if (!ast_strlen_zero(args.retries)) {
2450                 loops = atoi(args.retries);
2451         }
2452
2453         if (!args.dialdata) {
2454                 ast_log(LOG_ERROR, "%s requires a 4th argument (dialdata)\n", rapp);
2455                 goto done;
2456         }
2457
2458         if (sleepms < 1000)
2459                 sleepms = 10000;
2460
2461         if (!loops)
2462                 loops = -1; /* run forever */
2463
2464         ast_channel_lock(chan);
2465         context = pbx_builtin_getvar_helper(chan, "EXITCONTEXT");
2466         context = !ast_strlen_zero(context) ? ast_strdupa(context) : NULL;
2467         ast_channel_unlock(chan);
2468
2469         res = 0;
2470         while (loops) {
2471                 int continue_exec;
2472
2473                 chan->data = "Retrying";
2474                 if (ast_test_flag(chan, AST_FLAG_MOH))
2475                         ast_moh_stop(chan);
2476
2477                 res = dial_exec_full(chan, args.dialdata, &peerflags, &continue_exec);
2478                 if (continue_exec)
2479                         break;
2480
2481                 if (res == 0) {
2482                         if (ast_test_flag64(&peerflags, OPT_DTMF_EXIT)) {
2483                                 if (!ast_strlen_zero(args.announce)) {
2484                                         if (ast_fileexists(args.announce, NULL, chan->language) > 0) {
2485                                                 if (!(res = ast_streamfile(chan, args.announce, chan->language)))
2486                                                         ast_waitstream(chan, AST_DIGIT_ANY);
2487                                         } else
2488                                                 ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
2489                                 }
2490                                 if (!res && sleepms) {
2491                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
2492                                                 ast_moh_start(chan, NULL, NULL);
2493                                         res = ast_waitfordigit(chan, sleepms);
2494                                 }
2495                         } else {
2496                                 if (!ast_strlen_zero(args.announce)) {
2497                                         if (ast_fileexists(args.announce, NULL, chan->language) > 0) {
2498                                                 if (!(res = ast_streamfile(chan, args.announce, chan->language)))
2499                                                         res = ast_waitstream(chan, "");
2500                                         } else
2501                                                 ast_log(LOG_WARNING, "Announce file \"%s\" specified in Retrydial does not exist\n", args.announce);
2502                                 }
2503                                 if (sleepms) {
2504                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
2505                                                 ast_moh_start(chan, NULL, NULL);
2506                                         if (!res)
2507                                                 res = ast_waitfordigit(chan, sleepms);
2508                                 }
2509                         }
2510                 }
2511
2512                 if (res < 0 || res == AST_PBX_INCOMPLETE) {
2513                         break;
2514                 } else if (res > 0) { /* Trying to send the call elsewhere (1 digit ext) */
2515                         if (onedigit_goto(chan, context, (char) res, 1)) {
2516                                 res = 0;
2517                                 break;
2518                         }
2519                 }
2520                 loops--;
2521         }
2522         if (loops == 0)
2523                 res = 0;
2524         else if (res == 1)
2525                 res = 0;
2526
2527         if (ast_test_flag(chan, AST_FLAG_MOH))
2528                 ast_moh_stop(chan);
2529  done:
2530         return res;
2531 }
2532
2533 static int unload_module(void)
2534 {
2535         int res;
2536         struct ast_context *con;
2537
2538         res = ast_unregister_application(app);
2539         res |= ast_unregister_application(rapp);
2540
2541         if ((con = ast_context_find("app_dial_gosub_virtual_context"))) {
2542                 ast_context_remove_extension2(con, "s", 1, NULL, 0);
2543                 ast_context_destroy(con, "app_dial"); /* leave nothing behind */
2544         }
2545
2546         return res;
2547 }
2548
2549 static int load_module(void)
2550 {
2551         int res;
2552         struct ast_context *con;
2553
2554         con = ast_context_find_or_create(NULL, NULL, "app_dial_gosub_virtual_context", "app_dial");
2555         if (!con)
2556                 ast_log(LOG_ERROR, "Dial virtual context 'app_dial_gosub_virtual_context' does not exist and unable to create\n");
2557         else
2558                 ast_add_extension2(con, 1, "s", 1, NULL, NULL, "NoOp", ast_strdup(""), ast_free_ptr, "app_dial");
2559
2560         res = ast_register_application_xml(app, dial_exec);
2561         res |= ast_register_application_xml(rapp, retrydial_exec);
2562
2563         return res;
2564 }
2565
2566 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dialing Application");