Merged revisions 73053 via svnmerge from
[asterisk/asterisk.git] / apps / app_dial.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief 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 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <stdlib.h>
33 #include <errno.h>
34 #include <unistd.h>
35 #include <string.h>
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <sys/time.h>
39 #include <sys/signal.h>
40 #include <sys/stat.h>
41 #include <netinet/in.h>
42
43 #include "asterisk/lock.h"
44 #include "asterisk/file.h"
45 #include "asterisk/logger.h"
46 #include "asterisk/channel.h"
47 #include "asterisk/pbx.h"
48 #include "asterisk/options.h"
49 #include "asterisk/module.h"
50 #include "asterisk/translate.h"
51 #include "asterisk/say.h"
52 #include "asterisk/config.h"
53 #include "asterisk/features.h"
54 #include "asterisk/musiconhold.h"
55 #include "asterisk/callerid.h"
56 #include "asterisk/utils.h"
57 #include "asterisk/app.h"
58 #include "asterisk/causes.h"
59 #include "asterisk/rtp.h"
60 #include "asterisk/manager.h"
61 #include "asterisk/privacy.h"
62 #include "asterisk/stringfields.h"
63
64 static char *app = "Dial";
65
66 static char *synopsis = "Place a call and connect to the current channel";
67
68 static char *descrip =
69 "  Dial(Technology/resource[&Tech2/resource2...][|timeout][|options][|URL]):\n"
70 "This application will place calls to one or more specified channels. As soon\n"
71 "as one of the requested channels answers, the originating channel will be\n"
72 "answered, if it has not already been answered. These two channels will then\n"
73 "be active in a bridged call. All other channels that were requested will then\n"
74 "be hung up.\n"
75 "  Unless there is a timeout specified, the Dial application will wait\n"
76 "indefinitely until one of the called channels answers, the user hangs up, or\n"
77 "if all of the called channels are busy or unavailable. Dialplan executing will\n"
78 "continue if no requested channels can be called, or if the timeout expires.\n\n"
79 "  This application sets the following channel variables upon completion:\n"
80 "    DIALEDTIME   - This is the time from dialing a channel until when it\n"
81 "                   is disconnected.\n" 
82 "    ANSWEREDTIME - This is the amount of time for actual call.\n"
83 "    DIALSTATUS   - This is the status of the call:\n"
84 "                   CHANUNAVAIL | CONGESTION | NOANSWER | BUSY | ANSWER | CANCEL\n" 
85 "                   DONTCALL | TORTURE | INVALIDARGS\n"
86 "  For the Privacy and Screening Modes, the DIALSTATUS variable will be set to\n"
87 "DONTCALL if the called party chooses to send the calling party to the 'Go Away'\n"
88 "script. The DIALSTATUS variable will be set to TORTURE if the called party\n"
89 "wants to send the caller to the 'torture' script.\n"
90 "  This application will report normal termination if the originating channel\n"
91 "hangs up, or if the call is bridged and either of the parties in the bridge\n"
92 "ends the call.\n"
93 "  The optional URL will be sent to the called party if the channel supports it.\n"
94 "  If the OUTBOUND_GROUP variable is set, all peer channels created by this\n"
95 "application will be put into that group (as in Set(GROUP()=...).\n"
96 "  If the OUTBOUND_GROUP_ONCE variable is set, all peer channels created by this\n"
97 "application will be put into that group (as in Set(GROUP()=...). Unlike OUTBOUND_GROUP,\n"
98 "however, the variable will be unset after use.\n\n"
99 "  Options:\n"
100 "    A(x) - Play an announcement to the called party, using 'x' as the file.\n"
101 "    C    - Reset the CDR for this call.\n"
102 "    d    - Allow the calling user to dial a 1 digit extension while waiting for\n"
103 "           a call to be answered. Exit to that extension if it exists in the\n"
104 "           current context, or the context defined in the EXITCONTEXT variable,\n"
105 "           if it exists.\n"
106 "    D([called][:calling]) - Send the specified DTMF strings *after* the called\n"
107 "           party has answered, but before the call gets bridged. The 'called'\n"
108 "           DTMF string is sent to the called party, and the 'calling' DTMF\n"
109 "           string is sent to the calling party. Both parameters can be used\n"
110 "           alone.\n"   
111 "    f    - Force the callerid of the *calling* channel to be set as the\n"
112 "           extension associated with the channel using a dialplan 'hint'.\n"
113 "           For example, some PSTNs do not allow CallerID to be set to anything\n"
114 "           other than the number assigned to the caller.\n"
115 "    g    - Proceed with dialplan execution at the current extension if the\n"
116 "           destination channel hangs up.\n"
117 "    G(context^exten^pri) - If the call is answered, transfer the calling party to\n"
118 "           the specified priority and the called party to the specified priority+1.\n"
119 "           Optionally, an extension, or extension and context may be specified. \n"
120 "           Otherwise, the current extension is used. You cannot use any additional\n"
121 "           action post answer options in conjunction with this option.\n" 
122 "    h    - Allow the called party to hang up by sending the '*' DTMF digit.\n"
123 "    H    - Allow the calling party to hang up by hitting the '*' DTMF digit.\n"
124 "    i    - Asterisk will ignore any forwarding requests it may receive on this\n"
125 "           dial attempt.\n"
126 "    k    - Allow the called party to enable parking of the call by sending\n"
127 "           the DTMF sequence defined for call parking in features.conf.\n"
128 "    K    - Allow the calling party to enable parking of the call by sending\n"
129 "           the DTMF sequence defined for call parking in features.conf.\n"
130 "    L(x[:y][:z]) - Limit the call to 'x' ms. Play a warning when 'y' ms are\n"
131 "           left. Repeat the warning every 'z' ms. The following special\n"
132 "           variables can be used with this option:\n"
133 "           * LIMIT_PLAYAUDIO_CALLER   yes|no (default yes)\n"
134 "                                      Play sounds to the caller.\n"
135 "           * LIMIT_PLAYAUDIO_CALLEE   yes|no\n"
136 "                                      Play sounds to the callee.\n"
137 "           * LIMIT_TIMEOUT_FILE       File to play when time is up.\n"
138 "           * LIMIT_CONNECT_FILE       File to play when call begins.\n"
139 "           * LIMIT_WARNING_FILE       File to play as warning if 'y' is defined.\n"
140 "                                      The default is to say the time remaining.\n"
141 "    m([class]) - Provide hold music to the calling party until a requested\n"
142 "           channel answers. A specific MusicOnHold class can be\n"
143 "           specified.\n"
144 "    M(x[^arg]) - Execute the Macro for the *called* channel before connecting\n"
145 "           to the calling channel. Arguments can be specified to the Macro\n"
146 "           using '^' as a delimeter. The Macro can set the variable\n"
147 "           MACRO_RESULT to specify the following actions after the Macro is\n" 
148 "           finished executing.\n"
149 "           * ABORT        Hangup both legs of the call.\n"
150 "           * CONGESTION   Behave as if line congestion was encountered.\n"
151 "           * BUSY         Behave as if a busy signal was encountered.\n"
152 "           * CONTINUE     Hangup the called party and allow the calling party\n"
153 "                          to continue dialplan execution at the next priority.\n"
154 "           * GOTO:<context>^<exten>^<priority> - Transfer the call to the\n"
155 "                          specified priority. Optionally, an extension, or\n"
156 "                          extension and priority can be specified.\n"
157 "           You cannot use any additional action post answer options in conjunction\n"
158 "           with this option. Also, pbx services are not run on the peer (called) channel,\n"
159 "           so you will not be able to set timeouts via the TIMEOUT() function in this macro.\n"
160 "    n    - This option is a modifier for the screen/privacy mode. It specifies\n"
161 "           that no introductions are to be saved in the priv-callerintros\n"
162 "           directory.\n"
163 "    N    - This option is a modifier for the screen/privacy mode. It specifies\n"
164 "           that if callerID is present, do not screen the call.\n"
165 "    o    - Specify that the CallerID that was present on the *calling* channel\n"
166 "           be set as the CallerID on the *called* channel. This was the\n"
167 "           behavior of Asterisk 1.0 and earlier.\n"
168 "    O([x]) - \"Operator Services\" mode (Zaptel channel to Zaptel channel\n"
169 "             only, if specified on non-Zaptel interface, it will be ignored).\n"
170 "             When the destination answers (presumably an operator services\n"
171 "             station), the originator no longer has control of their line.\n"
172 "             They may hang up, but the switch will not release their line\n"
173 "             until the destination party hangs up (the operator). Specified\n"
174 "             without an arg, or with 1 as an arg, the originator hanging up\n"
175 "             will cause the phone to ring back immediately. With a 2 specified,\n"
176 "             when the \"operator\" flashes the trunk, it will ring their phone\n"
177 "             back.\n"
178 "    p    - This option enables screening mode. This is basically Privacy mode\n"
179 "           without memory.\n"
180 "    P([x]) - Enable privacy mode. Use 'x' as the family/key in the database if\n"
181 "           it is provided. The current extension is used if a database\n"
182 "           family/key is not specified.\n"
183 "    r    - Indicate ringing to the calling party. Pass no audio to the calling\n"
184 "           party until the called channel has answered.\n"
185 "    S(x) - Hang up the call after 'x' seconds *after* the called party has\n"
186 "           answered the call.\n"       
187 "    t    - Allow the called party to transfer the calling party by sending the\n"
188 "           DTMF sequence defined in features.conf.\n"
189 "    T    - Allow the calling party to transfer the called party by sending the\n"
190 "           DTMF sequence defined in features.conf.\n"
191 "    U(x[^arg]) - Execute via Gosub the routine 'x' for the *called* channel before connecting\n"
192 "           to the calling channel. Arguments can be specified to the Gosub\n"
193 "           using '^' as a delimeter. The Gosub routine can set the variable\n"
194 "           GOSUB_RESULT to specify the following actions after the Gosub returns.\n" 
195 "           * ABORT        Hangup both legs of the call.\n"
196 "           * CONGESTION   Behave as if line congestion was encountered.\n"
197 "           * BUSY         Behave as if a busy signal was encountered.\n"
198 "           * CONTINUE     Hangup the called party and allow the calling party\n"
199 "                          to continue dialplan execution at the next priority.\n"
200 "           * GOTO:<context>^<exten>^<priority> - Transfer the call to the\n"
201 "                          specified priority. Optionally, an extension, or\n"
202 "                          extension and priority can be specified.\n"
203 "           You cannot use any additional action post answer options in conjunction\n"
204 "           with this option. Also, pbx services are not run on the peer (called) channel,\n"
205 "           so you will not be able to set timeouts via the TIMEOUT() function in this routine.\n"
206 "    w    - Allow the called party to enable recording of the call by sending\n"
207 "           the DTMF sequence defined for one-touch recording in features.conf.\n"
208 "    W    - Allow the calling party to enable recording of the call by sending\n"
209 "           the DTMF sequence defined for one-touch recording in features.conf.\n";
210
211 /* RetryDial App by Anthony Minessale II <anthmct@yahoo.com> Jan/2005 */
212 static char *rapp = "RetryDial";
213 static char *rsynopsis = "Place a call, retrying on failure allowing optional exit extension.";
214 static char *rdescrip =
215 "  RetryDial(announce|sleep|retries|dialargs): This application will attempt to\n"
216 "place a call using the normal Dial application. If no channel can be reached,\n"
217 "the 'announce' file will be played. Then, it will wait 'sleep' number of\n"
218 "seconds before retying the call. After 'retires' number of attempts, the\n"
219 "calling channel will continue at the next priority in the dialplan. If the\n"
220 "'retries' setting is set to 0, this application will retry endlessly.\n"
221 "  While waiting to retry a call, a 1 digit extension may be dialed. If that\n"
222 "extension exists in either the context defined in ${EXITCONTEXT} or the current\n"
223 "one, The call will jump to that extension immediately.\n"
224 "  The 'dialargs' are specified in the same format that arguments are provided\n"
225 "to the Dial application.\n";
226
227 enum {
228         OPT_ANNOUNCE =          (1 << 0),
229         OPT_RESETCDR =          (1 << 1),
230         OPT_DTMF_EXIT =         (1 << 2),
231         OPT_SENDDTMF =          (1 << 3),
232         OPT_FORCECLID =         (1 << 4),
233         OPT_GO_ON =             (1 << 5),
234         OPT_CALLEE_HANGUP =     (1 << 6),
235         OPT_CALLER_HANGUP =     (1 << 7),
236         OPT_DURATION_LIMIT =    (1 << 9),
237         OPT_MUSICBACK =         (1 << 10),
238         OPT_CALLEE_MACRO =      (1 << 11),
239         OPT_SCREEN_NOINTRO =    (1 << 12),
240         OPT_SCREEN_NOCLID =     (1 << 13),
241         OPT_ORIGINAL_CLID =     (1 << 14),
242         OPT_SCREENING =         (1 << 15),
243         OPT_PRIVACY =           (1 << 16),
244         OPT_RINGBACK =          (1 << 17),
245         OPT_DURATION_STOP =     (1 << 18),
246         OPT_CALLEE_TRANSFER =   (1 << 19),
247         OPT_CALLER_TRANSFER =   (1 << 20),
248         OPT_CALLEE_MONITOR =    (1 << 21),
249         OPT_CALLER_MONITOR =    (1 << 22),
250         OPT_GOTO =              (1 << 23),
251         OPT_OPERMODE =          (1 << 24),
252         OPT_CALLEE_PARK =       (1 << 25),
253         OPT_CALLER_PARK =       (1 << 26),
254         OPT_IGNORE_FORWARDING = (1 << 27),
255         OPT_CALLEE_GOSUB =      (1 << 28),
256 };
257
258 #define DIAL_STILLGOING                 (1 << 30)
259 #define DIAL_NOFORWARDHTML              (1 << 31)
260
261 enum {
262         OPT_ARG_ANNOUNCE = 0,
263         OPT_ARG_SENDDTMF,
264         OPT_ARG_GOTO,
265         OPT_ARG_DURATION_LIMIT,
266         OPT_ARG_MUSICBACK,
267         OPT_ARG_CALLEE_MACRO,
268         OPT_ARG_CALLEE_GOSUB,
269         OPT_ARG_PRIVACY,
270         OPT_ARG_DURATION_STOP,
271         OPT_ARG_OPERMODE,
272         /* note: this entry _MUST_ be the last one in the enum */
273         OPT_ARG_ARRAY_SIZE,
274 };
275
276 AST_APP_OPTIONS(dial_exec_options, {
277         AST_APP_OPTION_ARG('A', OPT_ANNOUNCE, OPT_ARG_ANNOUNCE),
278         AST_APP_OPTION('C', OPT_RESETCDR),
279         AST_APP_OPTION('d', OPT_DTMF_EXIT),
280         AST_APP_OPTION_ARG('D', OPT_SENDDTMF, OPT_ARG_SENDDTMF),
281         AST_APP_OPTION('f', OPT_FORCECLID),
282         AST_APP_OPTION('g', OPT_GO_ON),
283         AST_APP_OPTION_ARG('G', OPT_GOTO, OPT_ARG_GOTO),
284         AST_APP_OPTION('h', OPT_CALLEE_HANGUP),
285         AST_APP_OPTION('H', OPT_CALLER_HANGUP),
286         AST_APP_OPTION('i', OPT_IGNORE_FORWARDING),
287         AST_APP_OPTION('k', OPT_CALLEE_PARK),
288         AST_APP_OPTION('K', OPT_CALLER_PARK),
289         AST_APP_OPTION_ARG('L', OPT_DURATION_LIMIT, OPT_ARG_DURATION_LIMIT),
290         AST_APP_OPTION_ARG('m', OPT_MUSICBACK, OPT_ARG_MUSICBACK),
291         AST_APP_OPTION_ARG('M', OPT_CALLEE_MACRO, OPT_ARG_CALLEE_MACRO),
292         AST_APP_OPTION('n', OPT_SCREEN_NOINTRO),
293         AST_APP_OPTION('N', OPT_SCREEN_NOCLID),
294         AST_APP_OPTION_ARG('O', OPT_OPERMODE,OPT_ARG_OPERMODE),
295         AST_APP_OPTION('o', OPT_ORIGINAL_CLID),
296         AST_APP_OPTION('p', OPT_SCREENING),
297         AST_APP_OPTION_ARG('P', OPT_PRIVACY, OPT_ARG_PRIVACY),
298         AST_APP_OPTION('r', OPT_RINGBACK),
299         AST_APP_OPTION_ARG('S', OPT_DURATION_STOP, OPT_ARG_DURATION_STOP),
300         AST_APP_OPTION('t', OPT_CALLEE_TRANSFER),
301         AST_APP_OPTION('T', OPT_CALLER_TRANSFER),
302         AST_APP_OPTION_ARG('U', OPT_CALLEE_GOSUB, OPT_ARG_CALLEE_GOSUB),
303         AST_APP_OPTION('w', OPT_CALLEE_MONITOR),
304         AST_APP_OPTION('W', OPT_CALLER_MONITOR),
305 });
306
307 /*
308  * The list of active channels
309  */
310 struct chanlist {
311         struct chanlist *next;
312         struct ast_channel *chan;
313         unsigned int flags;
314         int forwards;
315 };
316
317
318 static void hanguptree(struct chanlist *outgoing, struct ast_channel *exception)
319 {
320         /* Hang up a tree of stuff */
321         struct chanlist *oo;
322         while (outgoing) {
323                 /* Hangup any existing lines we have open */
324                 if (outgoing->chan && (outgoing->chan != exception))
325                         ast_hangup(outgoing->chan);
326                 oo = outgoing;
327                 outgoing=outgoing->next;
328                 ast_free(oo);
329         }
330 }
331
332 #define AST_MAX_FORWARDS   8
333
334 #define AST_MAX_WATCHERS 256
335
336 /*
337  * argument to handle_cause() and other functions.
338  */
339 struct cause_args {
340         struct ast_channel *chan;
341         int busy;
342         int congestion;
343         int nochan;
344 };
345
346 static void handle_cause(int cause, struct cause_args *num)
347 {
348         struct ast_cdr *cdr = num->chan->cdr;
349
350         switch(cause) {
351         case AST_CAUSE_BUSY:
352                 if (cdr)
353                         ast_cdr_busy(cdr);
354                 num->busy++;
355                 break;
356
357         case AST_CAUSE_CONGESTION:
358                 if (cdr)
359                         ast_cdr_failed(cdr);
360                 num->congestion++;
361                 break;
362
363         case AST_CAUSE_UNREGISTERED:
364                 if (cdr)
365                         ast_cdr_failed(cdr);
366                 num->nochan++;
367                 break;
368
369         case AST_CAUSE_NORMAL_CLEARING:
370                 break;
371
372         default:
373                 num->nochan++;
374                 break;
375         }
376 }
377
378 /* free the buffer if allocated, and set the pointer to the second arg */
379 #define S_REPLACE(s, new_val)           \
380         do {                            \
381                 if (s)                  \
382                         free(s);        \
383                 s = (new_val);          \
384         } while (0)
385
386 static int onedigit_goto(struct ast_channel *chan, const char *context, char exten, int pri) 
387 {
388         char rexten[2] = { exten, '\0' };
389
390         if (context) {
391                 if (!ast_goto_if_exists(chan, context, rexten, pri))
392                         return 1;
393         } else {
394                 if (!ast_goto_if_exists(chan, chan->context, rexten, pri))
395                         return 1;
396                 else if (!ast_strlen_zero(chan->macrocontext)) {
397                         if (!ast_goto_if_exists(chan, chan->macrocontext, rexten, pri))
398                                 return 1;
399                 }
400         }
401         return 0;
402 }
403
404
405 static const char *get_cid_name(char *name, int namelen, struct ast_channel *chan)
406 {
407         const char *context = S_OR(chan->macrocontext, chan->context);
408         const char *exten = S_OR(chan->macroexten, chan->exten);
409
410         return ast_get_hint(NULL, 0, name, namelen, chan, context, exten) ? name : "";
411 }
412
413 static void senddialevent(struct ast_channel *src, struct ast_channel *dst)
414 {
415         manager_event(EVENT_FLAG_CALL, "Dial", 
416                            "SubEvent: Begin\r\n"
417                            "Source: %s\r\n"
418                            "Destination: %s\r\n"
419                            "CallerIDNum: %s\r\n"
420                            "CallerIDName: %s\r\n"
421                            "SrcUniqueID: %s\r\n"
422                            "DestUniqueID: %s\r\n",
423                            src->name, dst->name, S_OR(src->cid.cid_num, "<unknown>"),
424                            S_OR(src->cid.cid_name, "<unknown>"), src->uniqueid,
425                            dst->uniqueid);
426 }
427
428 static void senddialendevent(const struct ast_channel *src, const char *dialstatus)
429 {
430         manager_event(EVENT_FLAG_CALL, "Dial",
431                                         "SubEvent: End\r\n"
432                                         "Channel: %s\r\n"
433                                         "DialStatus: %s\r\n",
434                                         src->name, dialstatus);
435 }       
436
437 /*!
438  * helper function for wait_for_answer()
439  *
440  * XXX this code is highly suspicious, as it essentially overwrites
441  * the outgoing channel without properly deleting it.
442  */
443 static void do_forward(struct chanlist *o,
444         struct cause_args *num, struct ast_flags *peerflags, int single)
445 {
446         char tmpchan[256];
447         struct ast_channel *original = o->chan;
448         struct ast_channel *c = o->chan; /* the winner */
449         struct ast_channel *in = num->chan; /* the input channel */
450         char *stuff;
451         char *tech;
452         int cause;
453
454         ast_copy_string(tmpchan, c->call_forward, sizeof(tmpchan));
455         if ((stuff = strchr(tmpchan, '/'))) {
456                 *stuff++ = '\0';
457                 tech = tmpchan;
458         } else {
459                 const char *forward_context = pbx_builtin_getvar_helper(c, "FORWARD_CONTEXT");
460                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", c->call_forward, forward_context ? forward_context : c->context);
461                 stuff = tmpchan;
462                 tech = "Local";
463         }
464         /* Before processing channel, go ahead and check for forwarding */
465         o->forwards++;
466         if (o->forwards < AST_MAX_FORWARDS) {
467                 if (option_verbose > 2)
468                         ast_verbose(VERBOSE_PREFIX_3 "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, c->name);
469                 /* If we have been told to ignore forwards, just set this channel to null and continue processing extensions normally */
470                 if (ast_test_flag(peerflags, OPT_IGNORE_FORWARDING)) {
471                         if (option_verbose > 2)
472                                 ast_verbose(VERBOSE_PREFIX_3 "Forwarding %s to '%s/%s' prevented.\n", in->name, tech, stuff);
473                         c = o->chan = NULL;
474                         cause = AST_CAUSE_BUSY;
475                 } else {
476                         /* Setup parameters */
477                         c = o->chan = ast_request(tech, in->nativeformats, stuff, &cause);
478                         if (c) {
479                                 if (single)
480                                         ast_channel_make_compatible(o->chan, in);
481                                 ast_channel_inherit_variables(in, o->chan);
482                         } else
483                                 ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s' (cause = %d)\n", tech, stuff, cause);
484                 }
485         } else {
486                 if (option_verbose > 2)
487                         ast_verbose(VERBOSE_PREFIX_3 "Too many forwards from %s\n", c->name);
488                 cause = AST_CAUSE_CONGESTION;
489                 c = o->chan = NULL;
490         }
491         if (!c) {
492                 ast_clear_flag(o, DIAL_STILLGOING);     
493                 handle_cause(cause, num);
494         } else {
495                 char *new_cid_num, *new_cid_name;
496                 struct ast_channel *src;
497
498                 ast_rtp_make_compatible(c, in, single);
499                 if (ast_test_flag(o, OPT_FORCECLID)) {
500                         new_cid_num = ast_strdup(S_OR(in->macroexten, in->exten));
501                         new_cid_name = NULL; /* XXX no name ? */
502                         src = c;        /* XXX possible bug in previous code, which used 'winner' ? it may have changed */
503                 } else {
504                         new_cid_num = ast_strdup(in->cid.cid_num);
505                         new_cid_name = ast_strdup(in->cid.cid_name);
506                         src = in;
507                 }
508                 ast_string_field_set(c, accountcode, src->accountcode);
509                 c->cdrflags = src->cdrflags;
510                 S_REPLACE(c->cid.cid_num, new_cid_num);
511                 S_REPLACE(c->cid.cid_name, new_cid_name);
512
513                 if (in->cid.cid_ani) { /* XXX or maybe unconditional ? */
514                         S_REPLACE(c->cid.cid_ani, ast_strdup(in->cid.cid_ani));
515                 }
516                 S_REPLACE(c->cid.cid_rdnis, ast_strdup(S_OR(in->macroexten, in->exten)));
517                 if (ast_call(c, tmpchan, 0)) {
518                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
519                         ast_clear_flag(o, DIAL_STILLGOING);     
520                         ast_hangup(original);
521                         c = o->chan = NULL;
522                         num->nochan++;
523                 } else {
524                         senddialevent(in, c);
525                         /* After calling, set callerid to extension */
526                         if (!ast_test_flag(peerflags, OPT_ORIGINAL_CLID)) {
527                                 char cidname[AST_MAX_EXTENSION] = "";
528                                 ast_set_callerid(c, S_OR(in->macroexten, in->exten), get_cid_name(cidname, sizeof(cidname), in), NULL);
529                         }
530                         /* Hangup the original channel now, in case we needed it */
531                         ast_hangup(original);
532                 }
533         }
534 }
535
536 /* argument used for some functions. */
537 struct privacy_args {
538         int sentringing;
539         int privdb_val;
540         char privcid[256];
541         char privintro[1024];
542         char status[256];
543 };
544
545 static struct ast_channel *wait_for_answer(struct ast_channel *in,
546         struct chanlist *outgoing, int *to, struct ast_flags *peerflags,
547         struct privacy_args *pa,
548         const struct cause_args *num_in, int *result)
549 {
550         struct cause_args num = *num_in;
551         int prestart = num.busy + num.congestion + num.nochan;
552         int orig = *to;
553         struct ast_channel *peer = NULL;
554         /* single is set if only one destination is enabled */
555         int single = outgoing && !outgoing->next && !ast_test_flag(outgoing, OPT_MUSICBACK | OPT_RINGBACK);
556         
557         if (single) {
558                 /* Turn off hold music, etc */
559                 ast_deactivate_generator(in);
560                 /* If we are calling a single channel, make them compatible for in-band tone purpose */
561                 ast_channel_make_compatible(outgoing->chan, in);
562         }
563         
564         
565         while (*to && !peer) {
566                 struct chanlist *o;
567                 int pos = 0;    /* how many channels do we handle */
568                 int numlines = prestart;
569                 struct ast_channel *winner;
570                 struct ast_channel *watchers[AST_MAX_WATCHERS];
571
572                 watchers[pos++] = in;
573                 for (o = outgoing; o; o = o->next) {
574                         /* Keep track of important channels */
575                         if (ast_test_flag(o, DIAL_STILLGOING) && o->chan)
576                                 watchers[pos++] = o->chan;
577                         numlines++;
578                 }
579                 if (pos == 1) { /* only the input channel is available */
580                         if (numlines == (num.busy + num.congestion + num.nochan)) {
581                                 if (option_verbose > 2)
582                                         ast_verbose( VERBOSE_PREFIX_2 "Everyone is busy/congested at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
583                                 if (num.busy)
584                                         strcpy(pa->status, "BUSY");     
585                                 else if (num.congestion)
586                                         strcpy(pa->status, "CONGESTION");
587                                 else if (num.nochan)
588                                         strcpy(pa->status, "CHANUNAVAIL");
589                         } else {
590                                 if (option_verbose > 2)
591                                         ast_verbose(VERBOSE_PREFIX_3 "No one is available to answer at this time (%d:%d/%d/%d)\n", numlines, num.busy, num.congestion, num.nochan);
592                         }
593                         *to = 0;
594                         return NULL;
595                 }
596                 winner = ast_waitfor_n(watchers, pos, to);
597                 for (o = outgoing; o; o = o->next) {
598                         struct ast_frame *f;
599                         struct ast_channel *c = o->chan;
600
601                         if (c == NULL)
602                                 continue;
603                         if (ast_test_flag(o, DIAL_STILLGOING) && c->_state == AST_STATE_UP) {
604                                 if (!peer) {
605                                         if (option_verbose > 2)
606                                                 ast_verbose(VERBOSE_PREFIX_3 "%s answered %s\n", c->name, in->name);
607                                         peer = c;
608                                         ast_copy_flags(peerflags, o,
609                                                        OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
610                                                        OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
611                                                        OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
612                                                        OPT_CALLEE_PARK | OPT_CALLER_PARK |
613                                                        DIAL_NOFORWARDHTML);
614                                         ast_copy_string(c->dialcontext, "", sizeof(c->dialcontext));
615                                         ast_copy_string(c->exten, "", sizeof(c->exten));
616                                 }
617                                 continue;
618                         }
619                         if (c != winner)
620                                 continue;
621                         /* here, o->chan == c == winner */
622                         if (!ast_strlen_zero(c->call_forward)) {
623                                 do_forward(o, &num, peerflags, single);
624                                 continue;
625                         }
626                         f = ast_read(winner);
627                         if (!f) {
628                                 in->hangupcause = c->hangupcause;
629                                 ast_hangup(c);
630                                 c = o->chan = NULL;
631                                 ast_clear_flag(o, DIAL_STILLGOING);
632                                 handle_cause(in->hangupcause, &num);
633                                 continue;
634                         }
635                         if (f->frametype == AST_FRAME_CONTROL) {
636                                 switch(f->subclass) {
637                                 case AST_CONTROL_ANSWER:
638                                         /* This is our guy if someone answered. */
639                                         if (!peer) {
640                                                 if (option_verbose > 2)
641                                                         ast_verbose( VERBOSE_PREFIX_3 "%s answered %s\n", c->name, in->name);
642                                                 peer = c;
643                                                 ast_copy_flags(peerflags, o,
644                                                                OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
645                                                                OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
646                                                                OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
647                                                                OPT_CALLEE_PARK | OPT_CALLER_PARK |
648                                                                DIAL_NOFORWARDHTML);
649                                                 ast_copy_string(c->dialcontext, "", sizeof(c->dialcontext));
650                                                 ast_copy_string(c->exten, "", sizeof(c->exten));
651                                                 /* Setup early bridge if appropriate */
652                                                 ast_channel_early_bridge(in, peer);
653                                         }
654                                         /* If call has been answered, then the eventual hangup is likely to be normal hangup */
655                                         in->hangupcause = AST_CAUSE_NORMAL_CLEARING;
656                                         c->hangupcause = AST_CAUSE_NORMAL_CLEARING;
657                                         break;
658                                 case AST_CONTROL_BUSY:
659                                         if (option_verbose > 2)
660                                                 ast_verbose(VERBOSE_PREFIX_3 "%s is busy\n", c->name);
661                                         in->hangupcause = c->hangupcause;
662                                         ast_hangup(c);
663                                         c = o->chan = NULL;
664                                         ast_clear_flag(o, DIAL_STILLGOING);     
665                                         handle_cause(AST_CAUSE_BUSY, &num);
666                                         break;
667                                 case AST_CONTROL_CONGESTION:
668                                         if (option_verbose > 2)
669                                                 ast_verbose(VERBOSE_PREFIX_3 "%s is circuit-busy\n", c->name);
670                                         in->hangupcause = c->hangupcause;
671                                         ast_hangup(c);
672                                         c = o->chan = NULL;
673                                         ast_clear_flag(o, DIAL_STILLGOING);
674                                         handle_cause(AST_CAUSE_CONGESTION, &num);
675                                         break;
676                                 case AST_CONTROL_RINGING:
677                                         if (option_verbose > 2)
678                                                 ast_verbose(VERBOSE_PREFIX_3 "%s is ringing\n", c->name);
679                                         /* Setup early media if appropriate */
680                                         if (single)
681                                                 ast_channel_early_bridge(in, c);
682                                         if (!(pa->sentringing) && !ast_test_flag(outgoing, OPT_MUSICBACK)) {
683                                                 ast_indicate(in, AST_CONTROL_RINGING);
684                                                 pa->sentringing++;
685                                         }
686                                         break;
687                                 case AST_CONTROL_PROGRESS:
688                                         if (option_verbose > 2)
689                                                 ast_verbose (VERBOSE_PREFIX_3 "%s is making progress passing it to %s\n", c->name, in->name);
690                                         /* Setup early media if appropriate */
691                                         if (single)
692                                                 ast_channel_early_bridge(in, c);
693                                         if (!ast_test_flag(outgoing, OPT_RINGBACK))
694                                                 ast_indicate(in, AST_CONTROL_PROGRESS);
695                                         break;
696                                 case AST_CONTROL_VIDUPDATE:
697                                         if (option_verbose > 2)
698                                                 ast_verbose (VERBOSE_PREFIX_3 "%s requested a video update, passing it to %s\n", c->name, in->name);
699                                         ast_indicate(in, AST_CONTROL_VIDUPDATE);
700                                         break;
701                                 case AST_CONTROL_PROCEEDING:
702                                         if (option_verbose > 2)
703                                                 ast_verbose (VERBOSE_PREFIX_3 "%s is proceeding passing it to %s\n", c->name, in->name);
704                                         if (single)
705                                                 ast_channel_early_bridge(in, c);
706                                         if (!ast_test_flag(outgoing, OPT_RINGBACK))
707                                                 ast_indicate(in, AST_CONTROL_PROCEEDING);
708                                         break;
709                                 case AST_CONTROL_HOLD:
710                                         if (option_verbose > 2)
711                                                 ast_verbose(VERBOSE_PREFIX_3 "Call on %s placed on hold\n", c->name);
712                                         ast_indicate(in, AST_CONTROL_HOLD);
713                                         break;
714                                 case AST_CONTROL_UNHOLD:
715                                         if (option_verbose > 2)
716                                                 ast_verbose(VERBOSE_PREFIX_3 "Call on %s left from hold\n", c->name);
717                                         ast_indicate(in, AST_CONTROL_UNHOLD);
718                                         break;
719                                 case AST_CONTROL_OFFHOOK:
720                                 case AST_CONTROL_FLASH:
721                                         /* Ignore going off hook and flash */
722                                         break;
723                                 case -1:
724                                         if (!ast_test_flag(outgoing, OPT_RINGBACK | OPT_MUSICBACK)) {
725                                                 if (option_verbose > 2)
726                                                         ast_verbose(VERBOSE_PREFIX_3 "%s stopped sounds\n", c->name);
727                                                 ast_indicate(in, -1);
728                                                 pa->sentringing = 0;
729                                         }
730                                         break;
731                                 default:
732                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
733                                 }
734                         } else if (single) {
735                                 /* XXX are we sure the logic is correct ? or we should just switch on f->frametype ? */
736                                 if (f->frametype == AST_FRAME_VOICE && !ast_test_flag(outgoing, OPT_RINGBACK|OPT_MUSICBACK)) {
737                                         if (ast_write(in, f)) 
738                                                 ast_log(LOG_WARNING, "Unable to forward voice frame\n");
739                                 } else if (f->frametype == AST_FRAME_IMAGE && !ast_test_flag(outgoing, OPT_RINGBACK|OPT_MUSICBACK)) {
740                                         if (ast_write(in, f))
741                                                 ast_log(LOG_WARNING, "Unable to forward image\n");
742                                 } else if (f->frametype == AST_FRAME_TEXT && !ast_test_flag(outgoing, OPT_RINGBACK|OPT_MUSICBACK)) {
743                                         if (ast_write(in, f))
744                                                 ast_log(LOG_WARNING, "Unable to send text\n");
745                                 } else if (f->frametype == AST_FRAME_HTML && !ast_test_flag(outgoing, DIAL_NOFORWARDHTML)) {
746                                         if (ast_channel_sendhtml(in, f->subclass, f->data, f->datalen) == -1)
747                                                 ast_log(LOG_WARNING, "Unable to send URL\n");
748                                 }
749                         }
750                         ast_frfree(f);
751                 } /* end for */
752                 if (winner == in) {
753                         struct ast_frame *f = ast_read(in);
754 #if 0
755                         if (f && (f->frametype != AST_FRAME_VOICE))
756                                 printf("Frame type: %d, %d\n", f->frametype, f->subclass);
757                         else if (!f || (f->frametype != AST_FRAME_VOICE))
758                                 printf("Hangup received on %s\n", in->name);
759 #endif
760                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
761                                 /* Got hung up */
762                                 *to = -1;
763                                 strcpy(pa->status, "CANCEL");
764                                 ast_cdr_noanswer(in->cdr);
765                                 if (f)
766                                         ast_frfree(f);
767                                 return NULL;
768                         }
769
770                         /* now f is guaranteed non-NULL */
771                         if (f->frametype == AST_FRAME_DTMF) {
772                                 if (ast_test_flag(peerflags, OPT_DTMF_EXIT)) {
773                                         const char *context = pbx_builtin_getvar_helper(in, "EXITCONTEXT");
774                                         if (onedigit_goto(in, context, (char) f->subclass, 1)) {
775                                                 if (option_verbose > 2)
776                                                         ast_verbose(VERBOSE_PREFIX_3 "User hit %c to disconnect call.\n", f->subclass);
777                                                 *to=0;
778                                                 ast_cdr_noanswer(in->cdr);
779                                                 *result = f->subclass;
780                                                 strcpy(pa->status, "CANCEL");
781                                                 ast_frfree(f);
782                                                 return NULL;
783                                         }
784                                 }
785
786                                 if (ast_test_flag(peerflags, OPT_CALLER_HANGUP) && 
787                                                   (f->subclass == '*')) { /* hmm it it not guaranteed to be '*' anymore. */
788                                         if (option_verbose > 2)
789                                                 ast_verbose(VERBOSE_PREFIX_3 "User hit %c to disconnect call.\n", f->subclass);
790                                         *to=0;
791                                         strcpy(pa->status, "CANCEL");
792                                         ast_cdr_noanswer(in->cdr);
793                                         ast_frfree(f);
794                                         return NULL;
795                                 }
796                         }
797
798                         /* Forward HTML stuff */
799                         if (single && (f->frametype == AST_FRAME_HTML) && !ast_test_flag(outgoing, DIAL_NOFORWARDHTML)) 
800                                 if(ast_channel_sendhtml(outgoing->chan, f->subclass, f->data, f->datalen) == -1)
801                                         ast_log(LOG_WARNING, "Unable to send URL\n");
802                         
803
804                         if (single && ((f->frametype == AST_FRAME_VOICE) || (f->frametype == AST_FRAME_DTMF_BEGIN) || (f->frametype == AST_FRAME_DTMF_END)))  {
805                                 if (ast_write(outgoing->chan, f))
806                                         ast_log(LOG_WARNING, "Unable to forward voice or dtmf\n");
807                         }
808                         if (single && (f->frametype == AST_FRAME_CONTROL) && 
809                                 ((f->subclass == AST_CONTROL_HOLD) || 
810                                  (f->subclass == AST_CONTROL_UNHOLD) || 
811                                  (f->subclass == AST_CONTROL_VIDUPDATE))) {
812                                 if (option_verbose > 2)
813                                         ast_verbose(VERBOSE_PREFIX_3 "%s requested special control %d, passing it to %s\n", in->name, f->subclass, outgoing->chan->name);
814                                 ast_indicate_data(outgoing->chan, f->subclass, f->data, f->datalen);
815                         }
816                         ast_frfree(f);
817                 }
818                 if (!*to && (option_verbose > 2))
819                         ast_verbose(VERBOSE_PREFIX_3 "Nobody picked up in %d ms\n", orig);
820                 if (!*to || ast_check_hangup(in)) {
821                         ast_cdr_noanswer(in->cdr);
822                 }
823                 
824         }
825
826         return peer;
827 }
828
829 static void replace_macro_delimiter(char *s)
830 {
831         for (; *s; s++)
832                 if (*s == '^')
833                         *s = '|';
834 }
835
836
837 /* returns true if there is a valid privacy reply */
838 static int valid_priv_reply(struct ast_flags *opts, int res)
839 {
840         if (res < '1')
841                 return 0;
842         if (ast_test_flag(opts, OPT_PRIVACY) && res <= '5')
843                 return 1;
844         if (ast_test_flag(opts, OPT_SCREENING) && res <= '4')
845                 return 1;
846         return 0;
847 }
848
849 static int do_timelimit(struct ast_channel *chan, struct ast_bridge_config *config,
850         char *parse, unsigned int *calldurationlimit)
851 {
852         char *stringp = ast_strdupa(parse);
853         char *limit_str, *warning_str, *warnfreq_str;
854         const char *var;
855         int play_to_caller=0,play_to_callee=0;
856         int delta;
857
858         limit_str = strsep(&stringp, ":");
859         warning_str = strsep(&stringp, ":");
860         warnfreq_str = strsep(&stringp, ":");
861
862         config->timelimit = atol(limit_str);
863         if (warning_str)
864                 config->play_warning = atol(warning_str);
865         if (warnfreq_str)
866                 config->warning_freq = atol(warnfreq_str);
867
868         if (!config->timelimit) {
869                 ast_log(LOG_WARNING, "Dial does not accept L(%s), hanging up.\n", limit_str);
870                 config->timelimit = config->play_warning = config->warning_freq = 0;
871                 config->warning_sound = NULL;
872                 return -1;      /* error */
873         } else if ( (delta = config->play_warning - config->timelimit) > 0) {
874                 int w = config->warning_freq;
875
876                 /* If the first warning is requested _after_ the entire call would end,
877                    and no warning frequency is requested, then turn off the warning. If
878                    a warning frequency is requested, reduce the 'first warning' time by
879                    that frequency until it falls within the call's total time limit.
880                    Graphically:
881                                   timelim->|    delta        |<-playwarning
882                         0__________________|_________________|
883                                          | w  |    |    |    |
884
885                    so the number of intervals to cut is 1+(delta-1)/w
886                 */
887
888                 if (w == 0) {
889                         config->play_warning = 0;
890                 } else {
891                         config->play_warning -= w * ( 1 + (delta-1)/w );
892                         if (config->play_warning < 1)
893                                 config->play_warning = config->warning_freq = 0;
894                 }
895         }
896
897         var = pbx_builtin_getvar_helper(chan,"LIMIT_PLAYAUDIO_CALLER");
898         play_to_caller = var ? ast_true(var) : 1;
899         
900         var = pbx_builtin_getvar_helper(chan,"LIMIT_PLAYAUDIO_CALLEE");
901         play_to_callee = var ? ast_true(var) : 0;
902         
903         if (!play_to_caller && !play_to_callee)
904                 play_to_caller = 1;
905         
906         var = pbx_builtin_getvar_helper(chan,"LIMIT_WARNING_FILE");
907         config->warning_sound = S_OR(var, "timeleft");
908
909         /* The code looking at config wants a NULL, not just "", to decide
910          * that the message should not be played, so we replace "" with NULL.
911          * Note, pbx_builtin_getvar_helper _can_ return NULL if the variable is
912          * not found.
913          */
914         var = pbx_builtin_getvar_helper(chan,"LIMIT_TIMEOUT_FILE");
915         config->end_sound = S_OR(var, NULL);
916         var = pbx_builtin_getvar_helper(chan,"LIMIT_CONNECT_FILE");
917         config->start_sound = S_OR(var, NULL);
918
919         /* undo effect of S(x) in case they are both used */
920         *calldurationlimit = 0;
921         /* more efficient to do it like S(x) does since no advanced opts */
922         if (!config->play_warning && !config->start_sound && !config->end_sound && config->timelimit) {
923                 *calldurationlimit = config->timelimit / 1000;
924                 if (option_verbose > 2)
925                         ast_verbose(VERBOSE_PREFIX_3 "Setting call duration limit to %d seconds.\n",
926                                 *calldurationlimit);
927                 config->timelimit = play_to_caller = play_to_callee =
928                 config->play_warning = config->warning_freq = 0;
929         } else if (option_verbose > 2) {
930                 ast_verbose(VERBOSE_PREFIX_3 "Limit Data for this call:\n");
931                 ast_verbose(VERBOSE_PREFIX_4 "timelimit      = %ld\n", config->timelimit);
932                 ast_verbose(VERBOSE_PREFIX_4 "play_warning   = %ld\n", config->play_warning);
933                 ast_verbose(VERBOSE_PREFIX_4 "play_to_caller = %s\n", play_to_caller ? "yes" : "no");
934                 ast_verbose(VERBOSE_PREFIX_4 "play_to_callee = %s\n", play_to_callee ? "yes" : "no");
935                 ast_verbose(VERBOSE_PREFIX_4 "warning_freq   = %ld\n", config->warning_freq);
936                 ast_verbose(VERBOSE_PREFIX_4 "start_sound    = %s\n", S_OR(config->start_sound, ""));
937                 ast_verbose(VERBOSE_PREFIX_4 "warning_sound  = %s\n", config->warning_sound);
938                 ast_verbose(VERBOSE_PREFIX_4 "end_sound      = %s\n", S_OR(config->end_sound, ""));
939         }
940         if (play_to_caller)
941                 ast_set_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
942         if (play_to_callee)
943                 ast_set_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
944         return 0;
945 }
946
947 static int do_privacy(struct ast_channel *chan, struct ast_channel *peer,
948     struct ast_flags *opts, char **opt_args, struct privacy_args *pa)
949 {
950
951         int res2;
952         int loopcount = 0;
953
954         /* Get the user's intro, store it in priv-callerintros/$CID, 
955            unless it is already there-- this should be done before the 
956            call is actually dialed  */
957
958         /* all ring indications and moh for the caller has been halted as soon as the 
959            target extension was picked up. We are going to have to kill some
960            time and make the caller believe the peer hasn't picked up yet */
961
962         if (ast_test_flag(opts, OPT_MUSICBACK) && !ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
963                 char *original_moh = ast_strdupa(chan->musicclass);
964                 ast_indicate(chan, -1);
965                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
966                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
967                 ast_string_field_set(chan, musicclass, original_moh);
968         } else if (ast_test_flag(opts, OPT_RINGBACK)) {
969                 ast_indicate(chan, AST_CONTROL_RINGING);
970                 pa->sentringing++;
971         }
972
973         /* Start autoservice on the other chan ?? */
974         res2 = ast_autoservice_start(chan);
975         /* Now Stream the File */
976         for (loopcount = 0; loopcount < 3; loopcount++) {
977                 if (res2 && loopcount == 0)     /* error in ast_autoservice_start() */
978                         break;
979                 if (!res2)      /* on timeout, play the message again */
980                         res2 = ast_play_and_wait(peer,"priv-callpending");
981                 if (!valid_priv_reply(opts, res2))
982                         res2 = 0;
983                 /* priv-callpending script: 
984                    "I have a caller waiting, who introduces themselves as:"
985                 */
986                 if (!res2)
987                         res2 = ast_play_and_wait(peer, pa->privintro);
988                 if (!valid_priv_reply(opts, res2))
989                         res2 = 0;
990                 /* now get input from the called party, as to their choice */
991                 if( !res2 ) {
992                         /* XXX can we have both, or they are mutually exclusive ? */
993                         if( ast_test_flag(opts, OPT_PRIVACY) )
994                                 res2 = ast_play_and_wait(peer,"priv-callee-options");
995                         if( ast_test_flag(opts, OPT_SCREENING) )
996                                 res2 = ast_play_and_wait(peer,"screen-callee-options");
997                 }
998                 /*! \page DialPrivacy Dial Privacy scripts
999                 \par priv-callee-options script:
1000                         "Dial 1 if you wish this caller to reach you directly in the future,
1001                                 and immediately connect to their incoming call
1002                          Dial 2 if you wish to send this caller to voicemail now and 
1003                                 forevermore.
1004                          Dial 3 to send this caller to the torture menus, now and forevermore.
1005                          Dial 4 to send this caller to a simple "go away" menu, now and forevermore.
1006                          Dial 5 to allow this caller to come straight thru to you in the future,
1007                                 but right now, just this once, send them to voicemail."
1008                 \par screen-callee-options script:
1009                         "Dial 1 if you wish to immediately connect to the incoming call
1010                          Dial 2 if you wish to send this caller to voicemail.
1011                          Dial 3 to send this caller to the torture menus.
1012                          Dial 4 to send this caller to a simple "go away" menu.
1013                 */
1014                 if (valid_priv_reply(opts, res2))
1015                         break;
1016                 /* invalid option */
1017                 res2 = ast_play_and_wait(peer, "vm-sorry");
1018         }
1019
1020         if (ast_test_flag(opts, OPT_MUSICBACK)) {
1021                 ast_moh_stop(chan);
1022         } else if (ast_test_flag(opts, OPT_RINGBACK)) {
1023                 ast_indicate(chan, -1);
1024                 pa->sentringing=0;
1025         }
1026         ast_autoservice_stop(chan);
1027         if(ast_test_flag(opts, OPT_PRIVACY) && (res2 >= '1' && res2 <= '5')) {
1028                 /* map keypresses to various things, the index is res2 - '1' */
1029                 static const char *_val[] = { "ALLOW", "DENY", "TORTURE", "KILL", "ALLOW" };
1030                 static const int _flag[] = { AST_PRIVACY_ALLOW, AST_PRIVACY_DENY, AST_PRIVACY_TORTURE, AST_PRIVACY_KILL, AST_PRIVACY_ALLOW};
1031                 int i = res2 - '1';
1032                 if (option_verbose > 2)
1033                         ast_verbose(VERBOSE_PREFIX_3 "--Set privacy database entry %s/%s to %s\n",
1034                                              opt_args[OPT_ARG_PRIVACY], pa->privcid, _val[i]);
1035                 ast_privacy_set(opt_args[OPT_ARG_PRIVACY], pa->privcid, _flag[i]);
1036         }
1037         switch (res2) {
1038         case '1':
1039                 break;
1040         case '2':
1041                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1042                 break;
1043         case '3':
1044                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1045                 break;
1046         case '4':
1047                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1048                 break;
1049         case '5':
1050                 /* XXX should we set status to DENY ? */
1051                 if( ast_test_flag(opts, OPT_PRIVACY) )
1052                         break;
1053                 /* if not privacy, then 5 is the same as "default" case */
1054         default:        /* bad input or -1 if failure to start autoservice */
1055                 /* well, if the user messes up, ... he had his chance... What Is The Best Thing To Do?  */
1056                 /* well, there seems basically two choices. Just patch the caller thru immediately,
1057                           or,... put 'em thru to voicemail. */
1058                 /* since the callee may have hung up, let's do the voicemail thing, no database decision */
1059                 ast_log(LOG_NOTICE, "privacy: no valid response from the callee. Sending the caller to voicemail, the callee isn't responding\n");
1060                 /* XXX should we set status to DENY ? */
1061                 /* XXX what about the privacy flags ? */
1062                 break;
1063         }
1064
1065         if (res2 == '1') {      /* the only case where we actually connect */
1066                 /* if the intro is NOCALLERID, then there's no reason to leave it on disk, it'll 
1067                    just clog things up, and it's not useful information, not being tied to a CID */
1068                 if( strncmp(pa->privcid,"NOCALLERID",10) == 0 || ast_test_flag(opts, OPT_SCREEN_NOINTRO) ) {
1069                         ast_filedelete(pa->privintro, NULL);
1070                         if( ast_fileexists(pa->privintro, NULL, NULL ) > 0 )
1071                                 ast_log(LOG_NOTICE, "privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1072                         else if (option_verbose > 2)
1073                                 ast_verbose(VERBOSE_PREFIX_3 "Successfully deleted %s intro file\n", pa->privintro);
1074                 }
1075                 return 0;       /* the good exit path */
1076         } else {
1077                 ast_hangup(peer); /* hang up on the callee -- he didn't want to talk anyway! */
1078                 return -1;
1079         }
1080 }
1081
1082 /*! \brief returns 1 if successful, 0 or <0 if the caller should 'goto out' */
1083 static int setup_privacy_args(struct privacy_args *pa,
1084         struct ast_flags *opts, char *opt_args[], struct ast_channel *chan)
1085 {
1086         char callerid[60];
1087         int res;
1088         char *l;
1089
1090         if (!ast_strlen_zero(chan->cid.cid_num)) {
1091                 l = ast_strdupa(chan->cid.cid_num);
1092                 ast_shrink_phone_number(l);
1093                 if (ast_test_flag(opts, OPT_PRIVACY) ) {
1094                         if (option_verbose > 2)
1095                                 ast_verbose(VERBOSE_PREFIX_3  "Privacy DB is '%s', clid is '%s'\n",
1096                                              opt_args[OPT_ARG_PRIVACY], l);
1097                         pa->privdb_val = ast_privacy_check(opt_args[OPT_ARG_PRIVACY], l);
1098                 } else {
1099                         if (option_verbose > 2)
1100                                 ast_verbose(VERBOSE_PREFIX_3  "Privacy Screening, clid is '%s'\n", l);
1101                         pa->privdb_val = AST_PRIVACY_UNKNOWN;
1102                 }
1103         } else {
1104                 char *tnam, *tn2;
1105
1106                 tnam = ast_strdupa(chan->name);
1107                 /* clean the channel name so slashes don't try to end up in disk file name */
1108                 for (tn2 = tnam; *tn2; tn2++) {
1109                         if (*tn2=='/')  /* any other chars to be afraid of? */
1110                                 *tn2 = '=';
1111                 }
1112                 if (option_verbose > 2)
1113                         ast_verbose(VERBOSE_PREFIX_3  "Privacy-- callerid is empty\n");
1114
1115                 snprintf(callerid, sizeof(callerid), "NOCALLERID_%s%s", chan->exten, tnam);
1116                 l = callerid;
1117                 pa->privdb_val = AST_PRIVACY_UNKNOWN;
1118         }
1119         
1120         ast_copy_string(pa->privcid,l,sizeof(pa->privcid));
1121
1122         if( strncmp(pa->privcid,"NOCALLERID",10) != 0 && ast_test_flag(opts, OPT_SCREEN_NOCLID) ) { /* if callerid is set, and ast_test_flag(&opts, OPT_SCREEN_NOCLID) is set also */  
1123                 if (option_verbose > 2)
1124                         ast_verbose( VERBOSE_PREFIX_3  "CallerID set (%s); N option set; Screening should be off\n", pa->privcid);
1125                 pa->privdb_val = AST_PRIVACY_ALLOW;
1126         } else if (ast_test_flag(opts, OPT_SCREEN_NOCLID) && strncmp(pa->privcid,"NOCALLERID",10) == 0 ) {
1127                 if (option_verbose > 2)
1128                         ast_verbose( VERBOSE_PREFIX_3  "CallerID blank; N option set; Screening should happen; dbval is %d\n", pa->privdb_val);
1129         }
1130         
1131         if (pa->privdb_val == AST_PRIVACY_DENY ) {
1132                 ast_copy_string(pa->status, "NOANSWER", sizeof(pa->status));
1133                 if (option_verbose > 2)
1134                         ast_verbose( VERBOSE_PREFIX_3  "Privacy DB reports PRIVACY_DENY for this callerid. Dial reports unavailable\n");
1135                 return 0;
1136         } else if (pa->privdb_val == AST_PRIVACY_KILL ) {
1137                 ast_copy_string(pa->status, "DONTCALL", sizeof(pa->status));
1138                 return 0; /* Is this right? */
1139         } else if (pa->privdb_val == AST_PRIVACY_TORTURE ) {
1140                 ast_copy_string(pa->status, "TORTURE", sizeof(pa->status));
1141                 return 0; /* is this right??? */
1142         } else if (pa->privdb_val == AST_PRIVACY_UNKNOWN ) {
1143                 /* Get the user's intro, store it in priv-callerintros/$CID, 
1144                    unless it is already there-- this should be done before the 
1145                    call is actually dialed  */
1146
1147                 /* make sure the priv-callerintros dir actually exists */
1148                 snprintf(pa->privintro, sizeof(pa->privintro), "%s/sounds/priv-callerintros", ast_config_AST_DATA_DIR);
1149                 if ((res = ast_mkdir(pa->privintro, 0755))) {
1150                         ast_log(LOG_WARNING, "privacy: can't create directory priv-callerintros: %s\n", strerror(res));
1151                         return -1;
1152                 }
1153
1154                 snprintf(pa->privintro, sizeof(pa->privintro), "priv-callerintros/%s", pa->privcid);
1155                 if (ast_fileexists(pa->privintro, NULL, NULL ) > 0 && strncmp(pa->privcid, "NOCALLERID", 10) != 0) {
1156                         /* the DELUX version of this code would allow this caller the
1157                            option to hear and retape their previously recorded intro.
1158                         */
1159                 } else {
1160                         int duration; /* for feedback from play_and_wait */
1161                         /* the file doesn't exist yet. Let the caller submit his
1162                            vocal intro for posterity */
1163                         /* priv-recordintro script:
1164
1165                            "At the tone, please say your name:"
1166
1167                         */
1168                         ast_answer(chan);
1169                         res = ast_play_and_record(chan, "priv-recordintro", pa->privintro, 4, "gsm", &duration, 128, 2000, 0);  /* NOTE: I've reduced the total time to 4 sec */
1170                                                                         /* don't think we'll need a lock removed, we took care of
1171                                                                            conflicts by naming the pa.privintro file */
1172                         if (res == -1) {
1173                                 /* Delete the file regardless since they hung up during recording */
1174                                 ast_filedelete(pa->privintro, NULL);
1175                                 if (ast_fileexists(pa->privintro,NULL,NULL ) > 0 )
1176                                         ast_log(LOG_NOTICE,"privacy: ast_filedelete didn't do its job on %s\n", pa->privintro);
1177                                 else if (option_verbose > 2)
1178                                         ast_verbose( VERBOSE_PREFIX_3 "Successfully deleted %s intro file\n", pa->privintro);
1179                                 return -1;
1180                         }
1181                         if (!ast_streamfile(chan, "vm-dialout", chan->language) )
1182                                 ast_waitstream(chan, "");
1183                 }
1184         }
1185         return 1;       /* success */
1186 }
1187
1188 static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags *peerflags, int *continue_exec)
1189 {
1190         int res = -1;   /* default: error */
1191         struct ast_module_user *u;
1192         char *rest, *cur;       /* scan the list of destinations */
1193         struct chanlist *outgoing = NULL;       /* list of destinations */
1194         struct ast_channel *peer;
1195         int to; /* timeout */
1196         struct cause_args num = { chan, 0, 0, 0 };
1197         int cause;
1198         char numsubst[256];
1199         char cidname[AST_MAX_EXTENSION] = "";
1200
1201         struct ast_bridge_config config;
1202         unsigned int calldurationlimit = 0;
1203         char *dtmfcalled = NULL, *dtmfcalling = NULL;
1204         struct privacy_args pa = {
1205                 .sentringing = 0,
1206                 .privdb_val = 0,
1207                 .status = "INVALIDARGS",
1208         };
1209         int sentringing = 0, moh = 0;
1210         const char *outbound_group = NULL;
1211         int result = 0;
1212         time_t start_time;
1213         char *parse;
1214         int opermode = 0;
1215         AST_DECLARE_APP_ARGS(args,
1216                              AST_APP_ARG(peers);
1217                              AST_APP_ARG(timeout);
1218                              AST_APP_ARG(options);
1219                              AST_APP_ARG(url);
1220         );
1221         struct ast_flags opts = { 0, };
1222         char *opt_args[OPT_ARG_ARRAY_SIZE];
1223
1224         if (ast_strlen_zero(data)) {
1225                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1226                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1227                 return -1;
1228         }
1229
1230         u = ast_module_user_add(chan);  /* XXX is this the right place ? */
1231
1232         parse = ast_strdupa(data);
1233         
1234         AST_STANDARD_APP_ARGS(args, parse);
1235
1236         memset(&config,0,sizeof(struct ast_bridge_config));
1237
1238         if (!ast_strlen_zero(args.options) &&
1239                         ast_app_parse_options(dial_exec_options, &opts, opt_args, args.options)) {
1240                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1241                 goto done;
1242         }
1243
1244         if (ast_strlen_zero(args.peers)) {
1245                 ast_log(LOG_WARNING, "Dial requires an argument (technology/number)\n");
1246                 pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1247                 goto done;
1248         }
1249
1250         if (ast_test_flag(&opts, OPT_OPERMODE)) {
1251                 opermode = ast_strlen_zero(opt_args[OPT_ARG_OPERMODE]) ? 1 : atoi(opt_args[OPT_ARG_OPERMODE]);
1252                 if (option_verbose > 2)
1253                         ast_verbose(VERBOSE_PREFIX_3 "Setting operator services mode to %d.\n", opermode);
1254         }
1255         
1256         if (ast_test_flag(&opts, OPT_DURATION_STOP) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_STOP])) {
1257                 calldurationlimit = atoi(opt_args[OPT_ARG_DURATION_STOP]);
1258                 if (!calldurationlimit) {
1259                         ast_log(LOG_WARNING, "Dial does not accept S(%s), hanging up.\n", opt_args[OPT_ARG_DURATION_STOP]);
1260                         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1261                         goto done;
1262                 }
1263                 if (option_verbose > 2)
1264                         ast_verbose(VERBOSE_PREFIX_3 "Setting call duration limit to %d seconds.\n", calldurationlimit);
1265         }
1266
1267         if (ast_test_flag(&opts, OPT_SENDDTMF) && !ast_strlen_zero(opt_args[OPT_ARG_SENDDTMF])) {
1268                 dtmfcalling = opt_args[OPT_ARG_SENDDTMF];
1269                 dtmfcalled = strsep(&dtmfcalling, ":");
1270         }
1271
1272         if (ast_test_flag(&opts, OPT_DURATION_LIMIT) && !ast_strlen_zero(opt_args[OPT_ARG_DURATION_LIMIT])) {
1273                 if (do_timelimit(chan, &config, opt_args[OPT_ARG_DURATION_LIMIT], &calldurationlimit))
1274                         goto done;
1275         }
1276
1277         if (ast_test_flag(&opts, OPT_RESETCDR) && chan->cdr)
1278                 ast_cdr_reset(chan->cdr, NULL);
1279         if (ast_test_flag(&opts, OPT_PRIVACY) && ast_strlen_zero(opt_args[OPT_ARG_PRIVACY]))
1280                 opt_args[OPT_ARG_PRIVACY] = ast_strdupa(chan->exten);
1281
1282         if (ast_test_flag(&opts, OPT_PRIVACY) || ast_test_flag(&opts, OPT_SCREENING)) {
1283                 res = setup_privacy_args(&pa, &opts, opt_args, chan);
1284                 if (res <= 0)
1285                         goto out;
1286                 res = -1;       /* reset default */
1287         }
1288
1289         if (continue_exec)
1290                 *continue_exec = 0;
1291         
1292         /* If a channel group has been specified, get it for use when we create peer channels */
1293         if ((outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP_ONCE"))) {
1294                 outbound_group = ast_strdupa(outbound_group);
1295                 pbx_builtin_setvar_helper(chan, "OUTBOUND_GROUP_ONCE", NULL);
1296         } else {
1297                 outbound_group = pbx_builtin_getvar_helper(chan, "OUTBOUND_GROUP");
1298         }
1299             
1300         ast_copy_flags(peerflags, &opts, OPT_DTMF_EXIT | OPT_GO_ON | OPT_ORIGINAL_CLID | OPT_CALLER_HANGUP | OPT_IGNORE_FORWARDING);
1301         /* loop through the list of dial destinations */
1302         rest = args.peers;
1303         while ((cur = strsep(&rest, "&")) ) {
1304                 struct chanlist *tmp;
1305                 struct ast_channel *tc; /* channel for this destination */
1306                 /* Get a technology/[device:]number pair */
1307                 char *number = cur;
1308                 char *tech = strsep(&number, "/");
1309                 if (!number) {
1310                         ast_log(LOG_WARNING, "Dial argument takes format (technology/[device:]number1)\n");
1311                         goto out;
1312                 }
1313                 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1314                         goto out;
1315                 if (opts.flags) {
1316                         ast_copy_flags(tmp, &opts,
1317                                        OPT_CALLEE_TRANSFER | OPT_CALLER_TRANSFER |
1318                                        OPT_CALLEE_HANGUP | OPT_CALLER_HANGUP |
1319                                        OPT_CALLEE_MONITOR | OPT_CALLER_MONITOR |
1320                                        OPT_CALLEE_PARK | OPT_CALLER_PARK |
1321                                        OPT_RINGBACK | OPT_MUSICBACK | OPT_FORCECLID);
1322                         ast_set2_flag(tmp, args.url, DIAL_NOFORWARDHTML);       
1323                 }
1324                 ast_copy_string(numsubst, number, sizeof(numsubst));
1325                 /* Request the peer */
1326                 tc = ast_request(tech, chan->nativeformats, numsubst, &cause);
1327                 if (!tc) {
1328                         /* If we can't, just go on to the next call */
1329                         ast_log(LOG_WARNING, "Unable to create channel of type '%s' (cause %d - %s)\n",
1330                                     tech, cause, ast_cause2str(cause));
1331                         handle_cause(cause, &num);
1332                         if (!rest)      /* we are on the last destination */
1333                                 chan->hangupcause = cause;
1334                         ast_free(tmp);
1335                         continue;
1336                 }
1337                 pbx_builtin_setvar_helper(tc, "DIALEDPEERNUMBER", numsubst);
1338                 if (!ast_strlen_zero(tc->call_forward)) {
1339                         char tmpchan[256];
1340                         char *stuff;
1341                         char *tech;
1342                         ast_copy_string(tmpchan, tc->call_forward, sizeof(tmpchan));
1343                         if ((stuff = strchr(tmpchan, '/'))) {
1344                                 *stuff++ = '\0';
1345                                 tech = tmpchan;
1346                         } else {
1347                                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", tc->call_forward, tc->context);
1348                                 stuff = tmpchan;
1349                                 tech = "Local";
1350                         }
1351                         tmp->forwards++;
1352                         if (tmp->forwards < AST_MAX_FORWARDS) {
1353                                 if (option_verbose > 2)
1354                                         ast_verbose(VERBOSE_PREFIX_3 "Now forwarding %s to '%s/%s' (thanks to %s)\n",
1355                                         chan->name, tech, stuff, tc->name);
1356                                 ast_hangup(tc);
1357                                 /* If we have been told to ignore forwards, just set this channel to null
1358                                  * and continue processing extensions normally */
1359                                 if (ast_test_flag(&opts, OPT_IGNORE_FORWARDING)) {
1360                                         tc = NULL;
1361                                         cause = AST_CAUSE_BUSY;
1362                                         if (option_verbose > 2)
1363                                                 ast_verbose(VERBOSE_PREFIX_3 "Forwarding %s to '%s/%s' prevented.\n",
1364                                                         chan->name, tech, stuff);
1365                                 } else {
1366                                         tc = ast_request(tech, chan->nativeformats, stuff, &cause);
1367                                 }
1368                                 if (!tc)
1369                                         ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s' (cause = %d)\n", tech, stuff, cause);
1370                                 else
1371                                         ast_channel_inherit_variables(chan, tc);
1372                         } else {
1373                                 if (option_verbose > 2)
1374                                         ast_verbose(VERBOSE_PREFIX_3 "Too many forwards from %s\n", tc->name);
1375                                 ast_hangup(tc);
1376                                 tc = NULL;
1377                                 cause = AST_CAUSE_CONGESTION;
1378                         }
1379                         if (!tc) {
1380                                 handle_cause(cause, &num);
1381                                 ast_free(tmp);
1382                                 continue;
1383                         }
1384                 }
1385
1386                 /* Setup outgoing SDP to match incoming one */
1387                 ast_rtp_make_compatible(tc, chan, !outgoing && !rest);
1388                 
1389                 /* Inherit specially named variables from parent channel */
1390                 ast_channel_inherit_variables(chan, tc);
1391
1392                 tc->appl = "AppDial";
1393                 tc->data = "(Outgoing Line)";
1394                 tc->whentohangup = 0;
1395
1396                 S_REPLACE(tc->cid.cid_num, ast_strdup(chan->cid.cid_num));
1397                 S_REPLACE(tc->cid.cid_name, ast_strdup(chan->cid.cid_name));
1398                 S_REPLACE(tc->cid.cid_ani, ast_strdup(chan->cid.cid_ani));
1399                 S_REPLACE(tc->cid.cid_rdnis, ast_strdup(chan->cid.cid_rdnis));
1400                 
1401                 /* Copy language from incoming to outgoing */
1402                 ast_string_field_set(tc, language, chan->language);
1403                 ast_string_field_set(tc, accountcode, chan->accountcode);
1404                 tc->cdrflags = chan->cdrflags;
1405                 if (ast_strlen_zero(tc->musicclass))
1406                         ast_string_field_set(tc, musicclass, chan->musicclass);
1407                 /* Pass callingpres, type of number, tns, ADSI CPE, transfer capability */
1408                 tc->cid.cid_pres = chan->cid.cid_pres;
1409                 tc->cid.cid_ton = chan->cid.cid_ton;
1410                 tc->cid.cid_tns = chan->cid.cid_tns;
1411                 tc->adsicpe = chan->adsicpe;
1412                 tc->transfercapability = chan->transfercapability;
1413
1414                 /* If we have an outbound group, set this peer channel to it */
1415                 if (outbound_group)
1416                         ast_app_group_set_channel(tc, outbound_group);
1417
1418                 /* Inherit context and extension */
1419                 if (!ast_strlen_zero(chan->macrocontext))
1420                         ast_copy_string(tc->dialcontext, chan->macrocontext, sizeof(tc->dialcontext));
1421                 else
1422                         ast_copy_string(tc->dialcontext, chan->context, sizeof(tc->dialcontext));
1423                 if (!ast_strlen_zero(chan->macroexten))
1424                         ast_copy_string(tc->exten, chan->macroexten, sizeof(tc->exten));
1425                 else
1426                         ast_copy_string(tc->exten, chan->exten, sizeof(tc->exten));
1427
1428                 res = ast_call(tc, numsubst, 0);        /* Place the call, but don't wait on the answer */
1429
1430                 /* Save the info in cdr's that we called them */
1431                 if (chan->cdr)
1432                         ast_cdr_setdestchan(chan->cdr, tc->name);
1433
1434                 /* check the results of ast_call */
1435                 if (res) {
1436                         /* Again, keep going even if there's an error */
1437                         ast_debug(1, "ast call on peer returned %d\n", res);
1438                         if (option_verbose > 2)
1439                                 ast_verbose(VERBOSE_PREFIX_3 "Couldn't call %s\n", numsubst);
1440                         ast_hangup(tc);
1441                         tc = NULL;
1442                         ast_free(tmp);
1443                         continue;
1444                 } else {
1445                         senddialevent(chan, tc);
1446                         if (option_verbose > 2)
1447                                 ast_verbose(VERBOSE_PREFIX_3 "Called %s\n", numsubst);
1448                         if (!ast_test_flag(peerflags, OPT_ORIGINAL_CLID))
1449                                 ast_set_callerid(tc, S_OR(chan->macroexten, chan->exten), get_cid_name(cidname, sizeof(cidname), chan), NULL);
1450                 }
1451                 /* Put them in the list of outgoing thingies...  We're ready now. 
1452                    XXX If we're forcibly removed, these outgoing calls won't get
1453                    hung up XXX */
1454                 ast_set_flag(tmp, DIAL_STILLGOING);     
1455                 tmp->chan = tc;
1456                 tmp->next = outgoing;
1457                 outgoing = tmp;
1458                 /* If this line is up, don't try anybody else */
1459                 if (outgoing->chan->_state == AST_STATE_UP)
1460                         break;
1461         }
1462         
1463         if (ast_strlen_zero(args.timeout)) {
1464                 to = -1;
1465         } else {
1466                 to = atoi(args.timeout);
1467                 if (to > 0)
1468                         to *= 1000;
1469                 else
1470                         ast_log(LOG_WARNING, "Invalid timeout specified: '%s'\n", args.timeout);
1471         }
1472
1473         if (!outgoing) {
1474                 strcpy(pa.status, "CHANUNAVAIL");
1475         } else {
1476                 /* Our status will at least be NOANSWER */
1477                 strcpy(pa.status, "NOANSWER");
1478                 if (ast_test_flag(outgoing, OPT_MUSICBACK)) {
1479                         moh = 1;
1480                         if (!ast_strlen_zero(opt_args[OPT_ARG_MUSICBACK])) {
1481                                 char *original_moh = ast_strdupa(chan->musicclass);
1482                                 ast_string_field_set(chan, musicclass, opt_args[OPT_ARG_MUSICBACK]);
1483                                 ast_moh_start(chan, opt_args[OPT_ARG_MUSICBACK], NULL);
1484                                 ast_string_field_set(chan, musicclass, original_moh);
1485                         } else {
1486                                 ast_moh_start(chan, NULL, NULL);
1487                         }
1488                         ast_indicate(chan, AST_CONTROL_PROGRESS);
1489                 } else if (ast_test_flag(outgoing, OPT_RINGBACK)) {
1490                         ast_indicate(chan, AST_CONTROL_RINGING);
1491                         sentringing++;
1492                 }
1493         }
1494
1495         time(&start_time);
1496         peer = wait_for_answer(chan, outgoing, &to, peerflags, &pa, &num, &result);
1497         
1498         if (!peer) {
1499                 if (result) {
1500                         res = result;
1501                 } else if (to) { /* Musta gotten hung up */
1502                         res = -1;
1503                 } else { /* Nobody answered, next please? */
1504                         res = 0;
1505                 }
1506                 /* almost done, although the 'else' block is 400 lines */
1507         } else {
1508                 const char *number;
1509                 time_t end_time, answer_time = time(NULL);
1510                 char toast[80]; /* buffer to set variables */
1511
1512                 strcpy(pa.status, "ANSWER");
1513                 /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
1514                    we will always return with -1 so that it is hung up properly after the 
1515                    conversation.  */
1516                 hanguptree(outgoing, peer);
1517                 outgoing = NULL;
1518                 /* If appropriate, log that we have a destination channel */
1519                 if (chan->cdr)
1520                         ast_cdr_setdestchan(chan->cdr, peer->name);
1521                 if (peer->name)
1522                         pbx_builtin_setvar_helper(chan, "DIALEDPEERNAME", peer->name);
1523
1524                 number = pbx_builtin_getvar_helper(peer, "DIALEDPEERNUMBER");
1525                 if (!number)
1526                         number = numsubst;
1527                 pbx_builtin_setvar_helper(chan, "DIALEDPEERNUMBER", number);
1528                 if (!ast_strlen_zero(args.url) && ast_channel_supports_html(peer) ) {
1529                         ast_debug(1, "app_dial: sendurl=%s.\n", args.url);
1530                         ast_channel_sendurl( peer, args.url );
1531                 }
1532                 if ( (ast_test_flag(&opts, OPT_PRIVACY) || ast_test_flag(&opts, OPT_SCREENING)) && pa.privdb_val == AST_PRIVACY_UNKNOWN) {
1533                         if (do_privacy(chan, peer, &opts, opt_args, &pa)) {
1534                                 res = 0;
1535                                 goto out;
1536                         }
1537                 }
1538                 if (!ast_test_flag(&opts, OPT_ANNOUNCE) || ast_strlen_zero(opt_args[OPT_ARG_ANNOUNCE])) {
1539                         res = 0;
1540                 } else {
1541                         int digit = 0;
1542                         /* Start autoservice on the other chan */
1543                         res = ast_autoservice_start(chan);
1544                         /* Now Stream the File */
1545                         if (!res)
1546                                 res = ast_streamfile(peer, opt_args[OPT_ARG_ANNOUNCE], peer->language);
1547                         if (!res) {
1548                                 digit = ast_waitstream(peer, AST_DIGIT_ANY); 
1549                         }
1550                         /* Ok, done. stop autoservice */
1551                         res = ast_autoservice_stop(chan);
1552                         if (digit > 0 && !res)
1553                                 res = ast_senddigit(chan, digit); 
1554                         else
1555                                 res = digit;
1556
1557                 }
1558
1559                 if (chan && peer && ast_test_flag(&opts, OPT_GOTO) && !ast_strlen_zero(opt_args[OPT_ARG_GOTO])) {
1560                         replace_macro_delimiter(opt_args[OPT_ARG_GOTO]);
1561                         ast_parseable_goto(chan, opt_args[OPT_ARG_GOTO]);
1562                         ast_parseable_goto(peer, opt_args[OPT_ARG_GOTO]);
1563                         peer->priority++;
1564                         ast_pbx_start(peer);
1565                         hanguptree(outgoing, NULL);
1566                         if (continue_exec)
1567                                 *continue_exec = 1;
1568                         res = 0;
1569                         goto done;
1570                 }
1571
1572                 if (ast_test_flag(&opts, OPT_CALLEE_MACRO) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_MACRO])) {
1573                         struct ast_app *theapp;
1574                         const char *macro_result;
1575
1576                         res = ast_autoservice_start(chan);
1577                         if (res) {
1578                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
1579                                 res = -1;
1580                         }
1581
1582                         theapp = pbx_findapp("Macro");
1583
1584                         if (theapp && !res) {   /* XXX why check res here ? */
1585                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_MACRO]);
1586                                 res = pbx_exec(peer, theapp, opt_args[OPT_ARG_CALLEE_MACRO]);
1587                                 ast_debug(1, "Macro exited with status %d\n", res);
1588                                 res = 0;
1589                         } else {
1590                                 ast_log(LOG_ERROR, "Could not find application Macro\n");
1591                                 res = -1;
1592                         }
1593
1594                         if (ast_autoservice_stop(chan) < 0) {
1595                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
1596                                 res = -1;
1597                         }
1598
1599                         if (!res && (macro_result = pbx_builtin_getvar_helper(peer, "MACRO_RESULT"))) {
1600                                 char *macro_transfer_dest;
1601
1602                                 if (!strcasecmp(macro_result, "BUSY")) {
1603                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
1604                                         ast_set_flag(peerflags, OPT_GO_ON);
1605                                         res = -1;
1606                                 } else if (!strcasecmp(macro_result, "CONGESTION") || !strcasecmp(macro_result, "CHANUNAVAIL")) {
1607                                         ast_copy_string(pa.status, macro_result, sizeof(pa.status));
1608                                         ast_set_flag(peerflags, OPT_GO_ON);     
1609                                         res = -1;
1610                                 } else if (!strcasecmp(macro_result, "CONTINUE")) {
1611                                         /* hangup peer and keep chan alive assuming the macro has changed 
1612                                            the context / exten / priority or perhaps 
1613                                            the next priority in the current exten is desired.
1614                                         */
1615                                         ast_set_flag(peerflags, OPT_GO_ON);     
1616                                         res = -1;
1617                                 } else if (!strcasecmp(macro_result, "ABORT")) {
1618                                         /* Hangup both ends unless the caller has the g flag */
1619                                         res = -1;
1620                                 } else if (!strncasecmp(macro_result, "GOTO:", 5) && (macro_transfer_dest = ast_strdupa(macro_result + 5))) {
1621                                         res = -1;
1622                                         /* perform a transfer to a new extension */
1623                                         if (strchr(macro_transfer_dest, '^')) { /* context^exten^priority*/
1624                                                 replace_macro_delimiter(macro_transfer_dest);
1625                                                 if (!ast_parseable_goto(chan, macro_transfer_dest))
1626                                                         ast_set_flag(peerflags, OPT_GO_ON);
1627                                         }
1628                                 }
1629                         }
1630                 }
1631
1632                 if (ast_test_flag(&opts, OPT_CALLEE_GOSUB) && !ast_strlen_zero(opt_args[OPT_ARG_CALLEE_GOSUB])) {
1633                         struct ast_app *theapp;
1634                         const char *gosub_result;
1635                         char *gosub_args, *gosub_argstart;
1636
1637                         res = ast_autoservice_start(chan);
1638                         if (res) {
1639                                 ast_log(LOG_ERROR, "Unable to start autoservice on calling channel\n");
1640                                 res = -1;
1641                         }
1642
1643                         theapp = pbx_findapp("Gosub");
1644
1645                         if (theapp && !res) {   /* XXX why check res here ? */
1646                                 replace_macro_delimiter(opt_args[OPT_ARG_CALLEE_GOSUB]);
1647
1648                                 /* Set where we came from */
1649                                 ast_copy_string(peer->context, "app_dial_gosub_virtual_context", sizeof(peer->context));
1650                                 ast_copy_string(peer->exten, "s", sizeof(peer->exten));
1651                                 peer->priority = 0;
1652
1653                                 gosub_argstart = strchr(opt_args[OPT_ARG_CALLEE_GOSUB], '|');
1654                                 if (gosub_argstart) {
1655                                         *gosub_argstart = 0;
1656                                         asprintf(&gosub_args, "%s|s|1(%s)", opt_args[OPT_ARG_CALLEE_GOSUB], gosub_argstart + 1);
1657                                         *gosub_argstart = '|';
1658                                 } else {
1659                                         asprintf(&gosub_args, "%s|s|1", opt_args[OPT_ARG_CALLEE_GOSUB]);
1660                                 }
1661
1662                                 if (gosub_args) {
1663                                         res = pbx_exec(peer, theapp, gosub_args);
1664                                         ast_pbx_run(peer);
1665                                         free(gosub_args);
1666                                         if (option_debug)
1667                                                 ast_log(LOG_DEBUG, "Gosub exited with status %d\n", res);
1668                                 } else
1669                                         ast_log(LOG_ERROR, "Could not Allocate string for Gosub arguments -- Gosub Call Aborted!\n");
1670                                 
1671                                 res = 0;
1672                         } else {
1673                                 ast_log(LOG_ERROR, "Could not find application Gosub\n");
1674                                 res = -1;
1675                         }
1676
1677                         if (ast_autoservice_stop(chan) < 0) {
1678                                 ast_log(LOG_ERROR, "Could not stop autoservice on calling channel\n");
1679                                 res = -1;
1680                         }
1681
1682                         if (!res && (gosub_result = pbx_builtin_getvar_helper(peer, "GOSUB_RESULT"))) {
1683                                 char *gosub_transfer_dest;
1684
1685                                 if (!strcasecmp(gosub_result, "BUSY")) {
1686                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
1687                                         ast_set_flag(peerflags, OPT_GO_ON);
1688                                         res = -1;
1689                                 } else if (!strcasecmp(gosub_result, "CONGESTION") || !strcasecmp(gosub_result, "CHANUNAVAIL")) {
1690                                         ast_copy_string(pa.status, gosub_result, sizeof(pa.status));
1691                                         ast_set_flag(peerflags, OPT_GO_ON);     
1692                                         res = -1;
1693                                 } else if (!strcasecmp(gosub_result, "CONTINUE")) {
1694                                         /* hangup peer and keep chan alive assuming the macro has changed 
1695                                            the context / exten / priority or perhaps 
1696                                            the next priority in the current exten is desired.
1697                                         */
1698                                         ast_set_flag(peerflags, OPT_GO_ON);     
1699                                         res = -1;
1700                                 } else if (!strcasecmp(gosub_result, "ABORT")) {
1701                                         /* Hangup both ends unless the caller has the g flag */
1702                                         res = -1;
1703                                 } else if (!strncasecmp(gosub_result, "GOTO:", 5) && (gosub_transfer_dest = ast_strdupa(gosub_result + 5))) {
1704                                         res = -1;
1705                                         /* perform a transfer to a new extension */
1706                                         if (strchr(gosub_transfer_dest, '^')) { /* context^exten^priority*/
1707                                                 replace_macro_delimiter(gosub_transfer_dest);
1708                                                 if (!ast_parseable_goto(chan, gosub_transfer_dest))
1709                                                         ast_set_flag(peerflags, OPT_GO_ON);
1710                                         }
1711                                 }
1712                         }
1713                 }
1714
1715                 if (!res) {
1716                         if (calldurationlimit > 0) {
1717                                 peer->whentohangup = time(NULL) + calldurationlimit;
1718                         }
1719                         if (!ast_strlen_zero(dtmfcalled)) { 
1720                                 if (option_verbose > 2)
1721                                         ast_verbose(VERBOSE_PREFIX_3 "Sending DTMF '%s' to the called party.\n", dtmfcalled);
1722                                 res = ast_dtmf_stream(peer,chan,dtmfcalled,250);
1723                         }
1724                         if (!ast_strlen_zero(dtmfcalling)) {
1725                                 if (option_verbose > 2)
1726                                         ast_verbose(VERBOSE_PREFIX_3 "Sending DTMF '%s' to the calling party.\n", dtmfcalling);
1727                                 res = ast_dtmf_stream(chan,peer,dtmfcalling,250);
1728                         }
1729                 }
1730                 
1731                 if (res) {      /* some error */
1732                         res = -1;
1733                         end_time = time(NULL);
1734                 } else {
1735                         if (ast_test_flag(peerflags, OPT_CALLEE_TRANSFER))
1736                                 ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
1737                         if (ast_test_flag(peerflags, OPT_CALLER_TRANSFER))
1738                                 ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
1739                         if (ast_test_flag(peerflags, OPT_CALLEE_HANGUP))
1740                                 ast_set_flag(&(config.features_callee), AST_FEATURE_DISCONNECT);
1741                         if (ast_test_flag(peerflags, OPT_CALLER_HANGUP))
1742                                 ast_set_flag(&(config.features_caller), AST_FEATURE_DISCONNECT);
1743                         if (ast_test_flag(peerflags, OPT_CALLEE_MONITOR))
1744                                 ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMON);
1745                         if (ast_test_flag(peerflags, OPT_CALLER_MONITOR)) 
1746                                 ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMON);
1747                         if (ast_test_flag(peerflags, OPT_CALLEE_PARK))
1748                                 ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
1749                         if (ast_test_flag(peerflags, OPT_CALLER_PARK))
1750                                 ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
1751
1752                         if (moh) {
1753                                 moh = 0;
1754                                 ast_moh_stop(chan);
1755                         } else if (sentringing) {
1756                                 sentringing = 0;
1757                                 ast_indicate(chan, -1);
1758                         }
1759                         /* Be sure no generators are left on it */
1760                         ast_deactivate_generator(chan);
1761                         /* Make sure channels are compatible */
1762                         res = ast_channel_make_compatible(chan, peer);
1763                         if (res < 0) {
1764                                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", chan->name, peer->name);
1765                                 ast_hangup(peer);
1766                                 res = -1;
1767                                 goto done;
1768                         }
1769                         if (opermode && !strncmp(chan->name,"Zap",3) && !strncmp(peer->name,"Zap",3)) {
1770                                 /* XXX what's this special handling for Zap <-> Zap ? */
1771                                 struct oprmode oprmode;
1772
1773                                 oprmode.peer = peer;
1774                                 oprmode.mode = opermode;
1775
1776                                 ast_channel_setoption(chan,
1777                                         AST_OPTION_OPRMODE,&oprmode,sizeof(struct oprmode),0);
1778                         }
1779                         res = ast_bridge_call(chan,peer,&config);
1780                         end_time = time(NULL);
1781                         snprintf(toast, sizeof(toast), "%ld", (long)(end_time - answer_time));
1782                         pbx_builtin_setvar_helper(chan, "ANSWEREDTIME", toast);
1783                 }
1784
1785                 snprintf(toast, sizeof(toast), "%ld", (long)(end_time - start_time));
1786                 pbx_builtin_setvar_helper(chan, "DIALEDTIME", toast);
1787
1788                 if (res != AST_PBX_NO_HANGUP_PEER) {
1789                         if (!chan->_softhangup)
1790                                 chan->hangupcause = peer->hangupcause;
1791                         ast_hangup(peer);
1792                 }
1793         }       
1794 out:
1795         if (moh) {
1796                 moh = 0;
1797                 ast_moh_stop(chan);
1798         } else if (sentringing) {
1799                 sentringing = 0;
1800                 ast_indicate(chan, -1);
1801         }
1802         ast_channel_early_bridge(chan, NULL);
1803         hanguptree(outgoing, NULL);
1804         pbx_builtin_setvar_helper(chan, "DIALSTATUS", pa.status);
1805         senddialendevent(chan, pa.status);
1806         ast_debug(1, "Exiting with DIALSTATUS=%s.\n", pa.status);
1807         
1808         if ((ast_test_flag(peerflags, OPT_GO_ON)) && (!chan->_softhangup) && (res != AST_PBX_KEEPALIVE)) {
1809                 if (calldurationlimit)
1810                         chan->whentohangup = 0;
1811                 res = 0;
1812         }
1813
1814 done:
1815         ast_module_user_remove(u);      /* XXX probably not the right place for this. */
1816         return res;
1817 }
1818
1819 static int dial_exec(struct ast_channel *chan, void *data)
1820 {
1821         struct ast_flags peerflags;
1822
1823         memset(&peerflags, 0, sizeof(peerflags));
1824
1825         return dial_exec_full(chan, data, &peerflags, NULL);
1826 }
1827
1828 static int retrydial_exec(struct ast_channel *chan, void *data)
1829 {
1830         char *announce = NULL, *dialdata = NULL;
1831         const char *context = NULL;
1832         int sleep = 0, loops = 0, res = -1;
1833         struct ast_module_user *u;
1834         struct ast_flags peerflags;
1835         
1836         if (ast_strlen_zero(data)) {
1837                 ast_log(LOG_WARNING, "RetryDial requires an argument!\n");
1838                 return -1;
1839         }       
1840
1841         u = ast_module_user_add(chan);
1842
1843         announce = ast_strdupa(data);
1844
1845         memset(&peerflags, 0, sizeof(peerflags));
1846
1847         if ((dialdata = strchr(announce, '|'))) {
1848                 *dialdata++ = '\0';
1849                 if (sscanf(dialdata, "%d", &sleep) == 1) {
1850                         sleep *= 1000;
1851                 } else {
1852                         ast_log(LOG_ERROR, "%s requires the numerical argument <sleep>\n",rapp);
1853                         goto done;
1854                 }
1855                 if ((dialdata = strchr(dialdata, '|'))) {
1856                         *dialdata++ = '\0';
1857                         if (sscanf(dialdata, "%d", &loops) != 1) {
1858                                 ast_log(LOG_ERROR, "%s requires the numerical argument <loops>\n",rapp);
1859                                 goto done;
1860                         }
1861                 }
1862         }
1863         
1864         if ((dialdata = strchr(dialdata, '|'))) {
1865                 *dialdata++ = '\0';
1866         } else {
1867                 ast_log(LOG_ERROR, "%s requires more arguments\n",rapp);
1868                 goto done;
1869         }
1870                 
1871         if (sleep < 1000)
1872                 sleep = 10000;
1873
1874         if (!loops)
1875                 loops = -1;     /* run forever */
1876         
1877         context = pbx_builtin_getvar_helper(chan, "EXITCONTEXT");
1878
1879         res = 0;
1880         while (loops) {
1881                 int continue_exec;
1882
1883                 chan->data = "Retrying";
1884                 if (ast_test_flag(chan, AST_FLAG_MOH))
1885                         ast_moh_stop(chan);
1886
1887                 res = dial_exec_full(chan, dialdata, &peerflags, &continue_exec);
1888                 if (continue_exec)
1889                         break;
1890                 if (res == 0) {
1891                         if (ast_test_flag(&peerflags, OPT_DTMF_EXIT)) {
1892                                 if (!(res = ast_streamfile(chan, announce, chan->language)))
1893                                         res = ast_waitstream(chan, AST_DIGIT_ANY);
1894                                 if (!res && sleep) {
1895                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
1896                                                 ast_moh_start(chan, NULL, NULL);
1897                                         res = ast_waitfordigit(chan, sleep);
1898                                 }
1899                         } else {
1900                                 if (!(res = ast_streamfile(chan, announce, chan->language)))
1901                                         res = ast_waitstream(chan, "");
1902                                 if (sleep) {
1903                                         if (!ast_test_flag(chan, AST_FLAG_MOH))
1904                                                 ast_moh_start(chan, NULL, NULL);
1905                                         if (!res) 
1906                                                 res = ast_waitfordigit(chan, sleep);
1907                                 }
1908                         }
1909                 }
1910
1911                 if (res < 0)
1912                         break;
1913                 else if (res > 0) { /* Trying to send the call elsewhere (1 digit ext) */
1914                         if (onedigit_goto(chan, context, (char) res, 1)) {
1915                                 res = 0;
1916                                 break;
1917                         }
1918                 }
1919                 loops--;
1920         }
1921         if (loops == 0)
1922                 res = 0;
1923         else if (res == 1)
1924                 res = 0;
1925
1926         if (ast_test_flag(chan, AST_FLAG_MOH))
1927                 ast_moh_stop(chan);
1928  done:
1929         ast_module_user_remove(u);
1930         return res;
1931 }
1932
1933 static int unload_module(void)
1934 {
1935         int res;
1936         struct ast_context *con;
1937
1938         res = ast_unregister_application(app);
1939         res |= ast_unregister_application(rapp);
1940
1941         ast_module_user_hangup_all();
1942
1943         if ((con = ast_context_find("app_dial_gosub_virtual_context"))) {
1944                 ast_context_remove_extension2(con, "s", 1, NULL);
1945         }
1946
1947         return res;
1948 }
1949
1950 static int load_module(void)
1951 {
1952         int res;
1953         struct ast_context *con;
1954
1955         con = ast_context_find("app_dial_gosub_virtual_context");
1956         if (!con)
1957                 con = ast_context_create(NULL, "app_dial_gosub_virtual_context", "app_dial");
1958         if (!con)
1959                 ast_log(LOG_ERROR, "Dial virtual context 'app_dial_gosub_virtual_context' does not exist and unable to create\n");
1960         else
1961                 ast_add_extension2(con, 1, "s", 1, NULL, NULL, "KeepAlive", ast_strdup(""), ast_free, "app_dial");
1962
1963         res = ast_register_application(app, dial_exec, synopsis, descrip);
1964         res |= ast_register_application(rapp, retrydial_exec, rsynopsis, rdescrip);
1965         
1966         return res;
1967 }
1968
1969 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Dialing Application");