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