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