Incorrect log statement when playing transfer sounds (issue #7008 reported and fixed...
[asterisk/asterisk.git] / res / res_features.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 Routines implementing call features as call pickup, parking and transfer
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  */
25
26 #include <pthread.h>
27 #include <stdlib.h>
28 #include <errno.h>
29 #include <unistd.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <sys/time.h>
34 #include <sys/signal.h>
35 #include <netinet/in.h>
36
37 #include "asterisk.h"
38
39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40
41 #include "asterisk/lock.h"
42 #include "asterisk/file.h"
43 #include "asterisk/logger.h"
44 #include "asterisk/channel.h"
45 #include "asterisk/pbx.h"
46 #include "asterisk/options.h"
47 #include "asterisk/causes.h"
48 #include "asterisk/module.h"
49 #include "asterisk/translate.h"
50 #include "asterisk/app.h"
51 #include "asterisk/say.h"
52 #include "asterisk/features.h"
53 #include "asterisk/musiconhold.h"
54 #include "asterisk/config.h"
55 #include "asterisk/cli.h"
56 #include "asterisk/manager.h"
57 #include "asterisk/utils.h"
58 #include "asterisk/adsi.h"
59 #include "asterisk/monitor.h"
60
61 #ifdef __AST_DEBUG_MALLOC
62 static void FREE(void *ptr)
63 {
64         free(ptr);
65 }
66 #else
67 #define FREE free
68 #endif
69
70 #define DEFAULT_PARK_TIME 45000
71 #define DEFAULT_TRANSFER_DIGIT_TIMEOUT 3000
72 #define DEFAULT_FEATURE_DIGIT_TIMEOUT 500
73
74 #define AST_MAX_WATCHERS 256
75
76 static char *parkedcall = "ParkedCall";
77
78 static int parkingtime = DEFAULT_PARK_TIME;             /*!< No more than 45 seconds parked before you do something with them */
79 static char parking_con[AST_MAX_EXTENSION];             /*!< Context for which parking is made accessible */
80 static char parking_con_dial[AST_MAX_EXTENSION];        /*!< Context for dialback for parking (KLUDGE) */
81 static char parking_ext[AST_MAX_EXTENSION];             /*!< Extension you type to park the call */
82 static char pickup_ext[AST_MAX_EXTENSION];              /*!< Call pickup extension */
83 static int parking_start;                               /*!< First available extension for parking */
84 static int parking_stop;                                /*!< Last available extension for parking */
85
86 static char courtesytone[256];                          /*!< Courtesy tone */
87 static int parkedplay = 0;                              /*!< Who to play the courtesy tone to */
88 static char xfersound[256];                             /*!< Call transfer sound */
89 static char xferfailsound[256];                         /*!< Call transfer failure sound */
90
91 static int parking_offset;
92 static int parkfindnext;
93
94 static int adsipark;
95
96 static int transferdigittimeout;
97 static int featuredigittimeout;
98
99 static char *registrar = "res_features";                /*!< Registrar for operations */
100
101 /* module and CLI command definitions */
102 static char *synopsis = "Answer a parked call";
103
104 static char *descrip = "ParkedCall(exten):"
105 "Used to connect to a parked call.  This application is always\n"
106 "registered internally and does not need to be explicitly added\n"
107 "into the dialplan, although you should include the 'parkedcalls'\n"
108 "context.\n";
109
110 static char *parkcall = "Park";
111
112 static char *synopsis2 = "Park yourself";
113
114 static char *descrip2 = "Park():"
115 "Used to park yourself (typically in combination with a supervised\n"
116 "transfer to know the parking space). This application is always\n"
117 "registered internally and does not need to be explicitly added\n"
118 "into the dialplan, although you should include the 'parkedcalls'\n"
119 "context.\n";
120
121 static struct ast_app *monitor_app = NULL;
122 static int monitor_ok = 1;
123
124 struct parkeduser {
125         struct ast_channel *chan;
126         struct timeval start;
127         int parkingnum;
128         /* Where to go if our parking time expires */
129         char context[AST_MAX_CONTEXT];
130         char exten[AST_MAX_EXTENSION];
131         int priority;
132         int parkingtime;
133         int notquiteyet;
134         char peername[1024];
135         unsigned char moh_trys;
136         struct parkeduser *next;
137 };
138
139 static struct parkeduser *parkinglot;
140
141 AST_MUTEX_DEFINE_STATIC(parking_lock);  /*!< protects all static variables above */
142
143 static pthread_t parking_thread;
144
145 char *ast_parking_ext(void)
146 {
147         return parking_ext;
148 }
149
150 char *ast_pickup_ext(void)
151 {
152         return pickup_ext;
153 }
154
155 struct ast_bridge_thread_obj 
156 {
157         struct ast_bridge_config bconfig;
158         struct ast_channel *chan;
159         struct ast_channel *peer;
160 };
161
162 /*! \brief store context, priority and extension */
163 static void set_c_e_p(struct ast_channel *chan, const char *context, const char *ext, int pri)
164 {
165         ast_copy_string(chan->context, context, sizeof(chan->context));
166         ast_copy_string(chan->exten, ext, sizeof(chan->exten));
167         chan->priority = pri;
168 }
169
170 static void check_goto_on_transfer(struct ast_channel *chan) 
171 {
172         struct ast_channel *xferchan;
173         const char *val = pbx_builtin_getvar_helper(chan, "GOTO_ON_BLINDXFR");
174         char *x, *goto_on_transfer;
175         struct ast_frame *f;
176
177         if (!ast_strlen_zero(val) && (goto_on_transfer = ast_strdupa(val)) && (xferchan = ast_channel_alloc(0))) {
178                 for (x = goto_on_transfer; x && *x; x++)
179                         if (*x == '^')
180                                 *x = '|';
181                 ast_string_field_set(xferchan, name, chan->name);
182                 /* Make formats okay */
183                 xferchan->readformat = chan->readformat;
184                 xferchan->writeformat = chan->writeformat;
185                 ast_channel_masquerade(xferchan, chan);
186                 ast_parseable_goto(xferchan, goto_on_transfer);
187                 xferchan->_state = AST_STATE_UP;
188                 ast_clear_flag(xferchan, AST_FLAGS_ALL);        
189                 xferchan->_softhangup = 0;
190                 if ((f = ast_read(xferchan))) {
191                         ast_frfree(f);
192                         f = NULL;
193                         ast_pbx_start(xferchan);
194                 } else {
195                         ast_hangup(xferchan);
196                 }
197         }
198 }
199
200 static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *caller, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name);
201
202
203 static void *ast_bridge_call_thread(void *data) 
204 {
205         struct ast_bridge_thread_obj *tobj = data;
206
207         tobj->chan->appl = "Transferred Call";
208         tobj->chan->data = tobj->peer->name;
209         tobj->peer->appl = "Transferred Call";
210         tobj->peer->data = tobj->chan->name;
211         if (tobj->chan->cdr) {
212                 ast_cdr_reset(tobj->chan->cdr, NULL);
213                 ast_cdr_setdestchan(tobj->chan->cdr, tobj->peer->name);
214         }
215         if (tobj->peer->cdr) {
216                 ast_cdr_reset(tobj->peer->cdr, NULL);
217                 ast_cdr_setdestchan(tobj->peer->cdr, tobj->chan->name);
218         }
219
220         ast_bridge_call(tobj->peer, tobj->chan, &tobj->bconfig);
221         ast_hangup(tobj->chan);
222         ast_hangup(tobj->peer);
223         bzero(tobj, sizeof(*tobj)); /*! \todo XXX for safety */
224         free(tobj);
225         return NULL;
226 }
227
228 static void ast_bridge_call_thread_launch(void *data) 
229 {
230         pthread_t thread;
231         pthread_attr_t attr;
232         struct sched_param sched;
233
234         pthread_attr_init(&attr);
235         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
236         ast_pthread_create(&thread, &attr,ast_bridge_call_thread, data);
237         pthread_attr_destroy(&attr);
238         memset(&sched, 0, sizeof(sched));
239         pthread_setschedparam(thread, SCHED_RR, &sched);
240 }
241
242 static int adsi_announce_park(struct ast_channel *chan, int parkingnum)
243 {
244         int res;
245         int justify[5] = {ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT};
246         char tmp[256];
247         char *message[5] = {NULL, NULL, NULL, NULL, NULL};
248
249         snprintf(tmp, sizeof(tmp), "Parked on %d", parkingnum);
250         message[0] = tmp;
251         res = adsi_load_session(chan, NULL, 0, 1);
252         if (res == -1)
253                 return res;
254         return adsi_print(chan, message, justify, 1);
255 }
256
257 /*! \brief Park a call 
258         We put the user in the parking list, then wake up the parking thread to be sure it looks
259         after these channels too */
260 int ast_park_call(struct ast_channel *chan, struct ast_channel *peer, int timeout, int *extout)
261 {
262         struct parkeduser *pu, *cur;
263         int i,x,parking_range;
264         char exten[AST_MAX_EXTENSION];
265         struct ast_context *con;
266         
267         if (!(pu = ast_calloc(1, sizeof(*pu)))) {
268                 return -1;
269         }
270         ast_mutex_lock(&parking_lock);
271         parking_range = parking_stop - parking_start+1;
272         for (i = 0; i < parking_range; i++) {
273                 x = (i + parking_offset) % parking_range + parking_start;
274                 cur = parkinglot;
275                 while(cur) {
276                         if (cur->parkingnum == x) 
277                                 break;
278                         cur = cur->next;
279                 }
280                 if (!cur)
281                         break;
282         }
283
284         if (!(i < parking_range)) {
285                 ast_log(LOG_WARNING, "No more parking spaces\n");
286                 free(pu);
287                 ast_mutex_unlock(&parking_lock);
288                 return -1;
289         }
290         if (parkfindnext) 
291                 parking_offset = x - parking_start + 1;
292         chan->appl = "Parked Call";
293         chan->data = NULL; 
294
295         pu->chan = chan;
296         /* Start music on hold */
297         if (chan != peer) {
298                 ast_indicate(pu->chan, AST_CONTROL_HOLD);
299                 ast_moh_start(pu->chan, NULL);
300         }
301         pu->start = ast_tvnow();
302         pu->parkingnum = x;
303         pu->parkingtime = (timeout > 0) ? timeout : parkingtime;
304         if (extout)
305                 *extout = x;
306         if (peer) 
307                 ast_copy_string(pu->peername, peer->name, sizeof(pu->peername));
308
309         /* Remember what had been dialed, so that if the parking
310            expires, we try to come back to the same place */
311         ast_copy_string(pu->context, S_OR(chan->macrocontext, chan->context), sizeof(pu->context));
312         ast_copy_string(pu->exten, S_OR(chan->macroexten, chan->exten), sizeof(pu->exten));
313         pu->priority = chan->macropriority ? chan->macropriority : chan->priority;
314         pu->next = parkinglot;
315         parkinglot = pu;
316         /* If parking a channel directly, don't quiet yet get parking running on it */
317         if (peer == chan) 
318                 pu->notquiteyet = 1;
319         ast_mutex_unlock(&parking_lock);
320         /* Wake up the (presumably select()ing) thread */
321         pthread_kill(parking_thread, SIGURG);
322         if (option_verbose > 1) 
323                 ast_verbose(VERBOSE_PREFIX_2 "Parked %s on %d. Will timeout back to extension [%s] %s, %d in %d seconds\n", pu->chan->name, pu->parkingnum, pu->context, pu->exten, pu->priority, (pu->parkingtime/1000));
324
325         manager_event(EVENT_FLAG_CALL, "ParkedCall",
326                 "Exten: %d\r\n"
327                 "Channel: %s\r\n"
328                 "From: %s\r\n"
329                 "Timeout: %ld\r\n"
330                 "CallerID: %s\r\n"
331                 "CallerIDName: %s\r\n",
332                 pu->parkingnum, pu->chan->name, peer ? peer->name : "",
333                 (long)pu->start.tv_sec + (long)(pu->parkingtime/1000) - (long)time(NULL),
334                 S_OR(pu->chan->cid.cid_num, "<unknown>"),
335                 S_OR(pu->chan->cid.cid_name, "<unknown>")
336                 );
337
338         if (peer) {
339                 if (adsipark && adsi_available(peer))
340                         adsi_announce_park(peer, pu->parkingnum);
341                 if (adsipark && adsi_available(peer))
342                         adsi_unload_session(peer);
343         }
344         con = ast_context_find(parking_con);
345         if (!con) {
346                 con = ast_context_create(NULL, parking_con, registrar);
347                 if (!con)
348                         ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parking_con);
349         }
350         if (con) {
351                 snprintf(exten, sizeof(exten), "%d", x);
352                 ast_add_extension2(con, 1, exten, 1, NULL, NULL, parkedcall, strdup(exten), FREE, registrar);
353         }
354         if (peer) 
355                 ast_say_digits(peer, pu->parkingnum, "", peer->language);
356         if (pu->notquiteyet) {
357                 /* Wake up parking thread if we're really done */
358                 ast_moh_start(pu->chan, NULL);
359                 pu->notquiteyet = 0;
360                 pthread_kill(parking_thread, SIGURG);
361         }
362         return 0;
363 }
364
365 int ast_masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
366 {
367         struct ast_channel *chan;
368         struct ast_frame *f;
369
370         /* Make a new, fake channel that we'll use to masquerade in the real one */
371         if ((chan = ast_channel_alloc(0))) {
372                 /* Let us keep track of the channel name */
373                 ast_string_field_build(chan, name, "Parked/%s",rchan->name);
374
375                 /* Make formats okay */
376                 chan->readformat = rchan->readformat;
377                 chan->writeformat = rchan->writeformat;
378                 ast_channel_masquerade(chan, rchan);
379
380                 /* Setup the extensions and such */
381                 set_c_e_p(chan, rchan->context, rchan->exten, rchan->priority);
382
383                 /* Make the masq execute */
384                 f = ast_read(chan);
385                 if (f)
386                         ast_frfree(f);
387                 ast_park_call(chan, peer, timeout, extout);
388         } else {
389                 ast_log(LOG_WARNING, "Unable to create parked channel\n");
390                 return -1;
391         }
392         return 0;
393 }
394
395
396 #define FEATURE_RETURN_HANGUP           -1
397 #define FEATURE_RETURN_SUCCESSBREAK      0
398 #define FEATURE_RETURN_PBX_KEEPALIVE    AST_PBX_KEEPALIVE
399 #define FEATURE_RETURN_NO_HANGUP_PEER   AST_PBX_NO_HANGUP_PEER
400 #define FEATURE_RETURN_PASSDIGITS        21
401 #define FEATURE_RETURN_STOREDIGITS       22
402 #define FEATURE_RETURN_SUCCESS           23
403
404 #define FEATURE_SENSE_CHAN      (1 << 0)
405 #define FEATURE_SENSE_PEER      (1 << 1)
406
407 /*
408  * set caller and callee according to the direction
409  */
410 static void set_peers(struct ast_channel **caller, struct ast_channel **callee,
411         struct ast_channel *peer, struct ast_channel *chan, int sense)
412 {
413         if (sense == FEATURE_SENSE_PEER) {
414                 *caller = peer;
415                 *callee = chan;
416         } else {
417                 *callee = peer;
418                 *caller = chan;
419         }
420 }
421
422 static int builtin_automonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
423 {
424         char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
425         int x = 0;
426         size_t len;
427         struct ast_channel *caller_chan, *callee_chan;
428
429         if (!monitor_ok) {
430                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
431                 return -1;
432         }
433
434         if (!monitor_app && !(monitor_app = pbx_findapp("Monitor"))) {
435                 monitor_ok=0;
436                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
437                 return -1;
438         }
439
440         set_peers(&caller_chan, &callee_chan, peer, chan, sense);
441
442         if (!ast_strlen_zero(courtesytone)) {
443                 if (ast_autoservice_start(callee_chan))
444                         return -1;
445                 if (ast_stream_and_wait(caller_chan, courtesytone, caller_chan->language, "")) {
446                         ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
447                         ast_autoservice_stop(callee_chan);
448                         return -1;
449                 }
450                 if (ast_autoservice_stop(callee_chan))
451                         return -1;
452         }
453         
454         if (callee_chan->monitor) {
455                 if (option_verbose > 3)
456                         ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to stop recording call.\n", code);
457                 ast_monitor_stop(callee_chan, 1);
458                 return FEATURE_RETURN_SUCCESS;
459         }
460
461         if (caller_chan && callee_chan) {
462                 const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_FORMAT");
463                 const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR");
464
465                 if (!touch_format)
466                         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_FORMAT");
467
468                 if (!touch_monitor)
469                         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR");
470         
471                 if (touch_monitor) {
472                         len = strlen(touch_monitor) + 50;
473                         args = alloca(len);
474                         touch_filename = alloca(len);
475                         snprintf(touch_filename, len, "auto-%ld-%s", (long)time(NULL), touch_monitor);
476                         snprintf(args, len, "%s|%s|m", (touch_format) ? touch_format : "wav", touch_filename);
477                 } else {
478                         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
479                         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
480                         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
481                         args = alloca(len);
482                         touch_filename = alloca(len);
483                         snprintf(touch_filename, len, "auto-%ld-%s-%s", (long)time(NULL), caller_chan_id, callee_chan_id);
484                         snprintf(args, len, "%s|%s|m", S_OR(touch_format, "wav"), touch_filename);
485                 }
486
487                 for( x = 0; x < strlen(args); x++) {
488                         if (args[x] == '/')
489                                 args[x] = '-';
490                 }
491                 
492                 if (option_verbose > 3)
493                         ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to record call. filename: %s\n", code, args);
494
495                 pbx_exec(callee_chan, monitor_app, args);
496                 pbx_builtin_setvar_helper(callee_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
497                 pbx_builtin_setvar_helper(caller_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
498         
499                 return FEATURE_RETURN_SUCCESS;
500         }
501         
502         ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");   
503         return -1;
504 }
505
506 static int builtin_disconnect(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
507 {
508         if (option_verbose > 3)
509                 ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to disconnect call.\n", code);
510         return FEATURE_RETURN_HANGUP;
511 }
512
513 static int finishup(struct ast_channel *chan)
514 {
515         int res;
516   
517         ast_moh_stop(chan);
518         res = ast_autoservice_stop(chan);
519         ast_indicate(chan, AST_CONTROL_UNHOLD);
520         return res;
521 }
522
523 static const char *real_ctx(struct ast_channel *transferer, struct ast_channel *transferee)
524 {
525         const char *s = pbx_builtin_getvar_helper(transferee, "TRANSFER_CONTEXT");
526         if (ast_strlen_zero(s))
527                 s = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
528         if (ast_strlen_zero(s)) /* Use the non-macro context to transfer the call XXX ? */
529                 s = transferer->macrocontext;
530         if (ast_strlen_zero(s))
531                 s = transferer->context;
532         return s;  
533 }
534
535 static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
536 {
537         struct ast_channel *transferer;
538         struct ast_channel *transferee;
539         const char *transferer_real_context;
540         char xferto[256];
541         int res;
542
543         set_peers(&transferer, &transferee, peer, chan, sense);
544         transferer_real_context = real_ctx(transferer, transferee);
545         /* Start autoservice on chan while we talk to the originator */
546         ast_indicate(transferee, AST_CONTROL_HOLD);
547         ast_autoservice_start(transferee);
548         ast_moh_start(transferee, NULL);
549
550         memset(xferto, 0, sizeof(xferto));
551         
552         /* Transfer */
553         res = ast_stream_and_wait(transferer, "pbx-transfer", transferer->language, AST_DIGIT_ANY);
554         if (res < 0) {
555                 finishup(transferee);
556                 return -1; /* error ? */
557         }
558         if (res > 0)    /* If they've typed a digit already, handle it */
559                 xferto[0] = (char) res;
560
561         ast_stopstream(transferer);
562         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
563         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
564                 finishup(transferee);
565                 return res;
566         }
567         if (!strcmp(xferto, ast_parking_ext())) {
568                 res = finishup(transferee);
569                 if (res)
570                         res = -1;
571                 else if (!ast_park_call(transferee, transferer, 0, NULL)) {     /* success */
572                         /* We return non-zero, but tell the PBX not to hang the channel when
573                            the thread dies -- We have to be careful now though.  We are responsible for 
574                            hanging up the channel, else it will never be hung up! */
575
576                         return (transferer == peer) ? AST_PBX_KEEPALIVE : AST_PBX_NO_HANGUP_PEER;
577                 } else {
578                         ast_log(LOG_WARNING, "Unable to park call %s\n", transferee->name);
579                 }
580                 /*! \todo XXX Maybe we should have another message here instead of invalid extension XXX */
581         } else if (ast_exists_extension(transferee, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
582                 pbx_builtin_setvar_helper(peer, "BLINDTRANSFER", chan->name);
583                 pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", peer->name);
584                 res=finishup(transferee);
585                 if (!transferee->pbx) {
586                         /* Doh!  Use our handy async_goto functions */
587                         if (option_verbose > 2) 
588                                 ast_verbose(VERBOSE_PREFIX_3 "Transferring %s to '%s' (context %s) priority 1\n"
589                                                                 ,transferee->name, xferto, transferer_real_context);
590                         if (ast_async_goto(transferee, transferer_real_context, xferto, 1))
591                                 ast_log(LOG_WARNING, "Async goto failed :-(\n");
592                         res = -1;
593                 } else {
594                         /* Set the channel's new extension, since it exists, using transferer context */
595                         set_c_e_p(transferee, transferer_real_context, xferto, 0);
596                 }
597                 check_goto_on_transfer(transferer);
598                 return res;
599         } else {
600                 if (option_verbose > 2) 
601                         ast_verbose(VERBOSE_PREFIX_3 "Unable to find extension '%s' in context '%s'\n", xferto, transferer_real_context);
602         }
603         if (ast_stream_and_wait(transferer, xferfailsound, transferee->language, AST_DIGIT_ANY) < 0 ) {
604                 finishup(transferee);
605                 return -1;
606         }
607         ast_stopstream(transferer);
608         res = finishup(transferee);
609         if (res) {
610                 if (option_verbose > 1)
611                         ast_verbose(VERBOSE_PREFIX_2 "Hungup during autoservice stop on '%s'\n", transferee->name);
612                 return res;
613         }
614         return FEATURE_RETURN_SUCCESS;
615 }
616
617 static int check_compat(struct ast_channel *c, struct ast_channel *newchan)
618 {
619         if (ast_channel_make_compatible(c, newchan) < 0) {
620                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n",
621                         c->name, newchan->name);
622                 ast_hangup(newchan);
623                 return -1;
624         }
625         return 0;
626 }
627
628 static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
629 {
630         struct ast_channel *transferer;
631         struct ast_channel *transferee;
632         const char *transferer_real_context;
633         char xferto[256];
634         int res;
635         int outstate=0;
636         struct ast_channel *newchan;
637         struct ast_channel *xferchan;
638         struct ast_bridge_thread_obj *tobj;
639         struct ast_bridge_config bconfig;
640         struct ast_frame *f;
641         int l;
642
643         if (option_debug)
644                 ast_log(LOG_DEBUG, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense);
645         set_peers(&transferer, &transferee, peer, chan, sense);
646         transferer_real_context = real_ctx(transferer, transferee);
647         /* Start autoservice on chan while we talk to the originator */
648         ast_indicate(transferee, AST_CONTROL_HOLD);
649         ast_autoservice_start(transferee);
650         ast_moh_start(transferee, NULL);
651         memset(xferto, 0, sizeof(xferto));
652         /* Transfer */
653         res = ast_stream_and_wait(transferer, "pbx-transfer", transferer->language, AST_DIGIT_ANY);
654         if (res < 0) {
655                 finishup(transferee);
656                 return res;
657         }
658         if (res > 0) /* If they've typed a digit already, handle it */
659                 xferto[0] = (char) res;
660
661         /* this is specific of atxfer */
662         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
663         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
664                 finishup(transferee);
665                 return res;
666         }
667         if (res == 0) {
668                 ast_log(LOG_WARNING, "Did not read data.\n");
669                 finishup(transferee);
670                 if (ast_stream_and_wait(transferer, "beeperr", transferer->language, ""))
671                         return -1;
672                 return FEATURE_RETURN_SUCCESS;
673         }
674
675         /* valid extension, res == 1 */
676         if (!ast_exists_extension(transferer, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
677                 ast_log(LOG_WARNING, "Extension %s does not exist in context %s\n",xferto,transferer_real_context);
678                 finishup(transferee);
679                 if (ast_stream_and_wait(transferer, "beeperr", transferer->language, ""))
680                         return -1;
681                 return FEATURE_RETURN_SUCCESS;
682         }
683
684         l = strlen(xferto);
685         snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context);     /* append context */
686         newchan = ast_feature_request_and_dial(transferer, "Local", ast_best_codec(transferer->nativeformats),
687                 xferto, 15000, &outstate, transferer->cid.cid_num, transferer->cid.cid_name);
688         ast_indicate(transferer, -1);
689         if (!newchan) {
690                 finishup(transferee);
691                 /* any reason besides user requested cancel and busy triggers the failed sound */
692                 if (outstate != AST_CONTROL_UNHOLD && outstate != AST_CONTROL_BUSY &&
693                                 ast_stream_and_wait(transferer, xferfailsound, transferer->language, ""))
694                         return -1;
695                 return FEATURE_RETURN_SUCCESS;
696         }
697
698         if (check_compat(transferer, newchan))
699                 return -1;
700         memset(&bconfig,0,sizeof(struct ast_bridge_config));
701         ast_set_flag(&(bconfig.features_caller), AST_FEATURE_DISCONNECT);
702         ast_set_flag(&(bconfig.features_callee), AST_FEATURE_DISCONNECT);
703         res = ast_bridge_call(transferer, newchan, &bconfig);
704         if (newchan->_softhangup || newchan->_state != AST_STATE_UP || !transferer->_softhangup) {
705                 ast_hangup(newchan);
706                 if (ast_stream_and_wait(transferer, xfersound, transferer->language, ""))
707                         ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
708                 finishup(transferee);
709                 transferer->_softhangup = 0;
710                 return FEATURE_RETURN_SUCCESS;
711         }
712         
713         if (check_compat(transferee, newchan))
714                 return -1;
715
716         ast_moh_stop(transferee);
717         
718         if ((ast_autoservice_stop(transferee) < 0)
719            || (ast_waitfordigit(transferee, 100) < 0)
720            || (ast_waitfordigit(newchan, 100) < 0) 
721            || ast_check_hangup(transferee) 
722            || ast_check_hangup(newchan)) {
723                 ast_hangup(newchan);
724                 return -1;
725         }
726
727         xferchan = ast_channel_alloc(0);
728         if (!xferchan) {
729                 ast_hangup(newchan);
730                 return -1;
731         }
732         ast_string_field_build(xferchan, name, "Transfered/%s", transferee->name);
733         /* Make formats okay */
734         xferchan->readformat = transferee->readformat;
735         xferchan->writeformat = transferee->writeformat;
736         ast_channel_masquerade(xferchan, transferee);
737         ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority);
738         xferchan->_state = AST_STATE_UP;
739         ast_clear_flag(xferchan, AST_FLAGS_ALL);        
740         xferchan->_softhangup = 0;
741
742         if ((f = ast_read(xferchan)))
743                 ast_frfree(f);
744
745         newchan->_state = AST_STATE_UP;
746         ast_clear_flag(newchan, AST_FLAGS_ALL); 
747         newchan->_softhangup = 0;
748
749         tobj = ast_calloc(1, sizeof(struct ast_bridge_thread_obj));
750         if (!tobj) {
751                 ast_hangup(xferchan);
752                 ast_hangup(newchan);
753                 return -1;
754         }
755         tobj->chan = xferchan;
756         tobj->peer = newchan;
757         tobj->bconfig = *config;
758
759         if (ast_stream_and_wait(newchan, xfersound, newchan->language, ""))
760                 ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
761         ast_bridge_call_thread_launch(tobj);
762         return -1;      /* XXX meaning the channel is bridged ? */
763 }
764
765
766 /* add atxfer and automon as undefined so you can only use em if you configure them */
767 #define FEATURES_COUNT (sizeof(builtin_features) / sizeof(builtin_features[0]))
768
769 struct ast_call_feature builtin_features[] = 
770  {
771         { AST_FEATURE_REDIRECT, "Blind Transfer", "blindxfer", "#", "#", builtin_blindtransfer, AST_FEATURE_FLAG_NEEDSDTMF },
772         { AST_FEATURE_REDIRECT, "Attended Transfer", "atxfer", "", "", builtin_atxfer, AST_FEATURE_FLAG_NEEDSDTMF },
773         { AST_FEATURE_AUTOMON, "One Touch Monitor", "automon", "", "", builtin_automonitor, AST_FEATURE_FLAG_NEEDSDTMF },
774         { AST_FEATURE_DISCONNECT, "Disconnect Call", "disconnect", "*", "*", builtin_disconnect, AST_FEATURE_FLAG_NEEDSDTMF },
775 };
776
777
778 static AST_LIST_HEAD(feature_list,ast_call_feature) feature_list;
779
780 /*! \brief register new feature into feature_list*/
781 void ast_register_feature(struct ast_call_feature *feature)
782 {
783         if (!feature) {
784                 ast_log(LOG_NOTICE,"You didn't pass a feature!\n");
785                 return;
786         }
787   
788         AST_LIST_LOCK(&feature_list);
789         AST_LIST_INSERT_HEAD(&feature_list,feature,feature_entry);
790         AST_LIST_UNLOCK(&feature_list);
791
792         if (option_verbose >= 2) 
793                 ast_verbose(VERBOSE_PREFIX_2 "Registered Feature '%s'\n",feature->sname);
794 }
795
796 /*! \brief unregister feature from feature_list */
797 void ast_unregister_feature(struct ast_call_feature *feature)
798 {
799         if (!feature)
800                 return;
801
802         AST_LIST_LOCK(&feature_list);
803         AST_LIST_REMOVE(&feature_list,feature,feature_entry);
804         AST_LIST_UNLOCK(&feature_list);
805         free(feature);
806 }
807
808 static void ast_unregister_features(void)
809 {
810         struct ast_call_feature *feature;
811
812         AST_LIST_LOCK(&feature_list);
813         while ((feature = AST_LIST_REMOVE_HEAD(&feature_list,feature_entry)))
814                 free(feature);
815         AST_LIST_UNLOCK(&feature_list);
816 }
817
818 /*! \brief find a feature by name */
819 static struct ast_call_feature *find_feature(char *name)
820 {
821         struct ast_call_feature *tmp;
822
823         AST_LIST_LOCK(&feature_list);
824         AST_LIST_TRAVERSE(&feature_list, tmp, feature_entry) {
825                 if (!strcasecmp(tmp->sname, name))
826                         break;
827         }
828         AST_LIST_UNLOCK(&feature_list);
829
830         return tmp;
831 }
832
833 /*! \brief exec an app by feature */
834 static int feature_exec_app(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
835 {
836         struct ast_app *app;
837         struct ast_call_feature *feature;
838         int res;
839
840         AST_LIST_LOCK(&feature_list);
841         AST_LIST_TRAVERSE(&feature_list,feature,feature_entry) {
842                 if (!strcasecmp(feature->exten,code))
843                         break;
844         }
845         AST_LIST_UNLOCK(&feature_list);
846
847         if (!feature) { /* shouldn't ever happen! */
848                 ast_log(LOG_NOTICE, "Found feature before, but at execing we've lost it??\n");
849                 return -1; 
850         }
851         
852         app = pbx_findapp(feature->app);
853         if (app) {
854                 struct ast_channel *work = ast_test_flag(feature,AST_FEATURE_FLAG_CALLEE) ? peer : chan;
855                 res = pbx_exec(work, app, feature->app_args);
856                 if (res < 0)
857                         return res; 
858         } else {
859                 ast_log(LOG_WARNING, "Could not find application (%s)\n", feature->app);
860                 return -2;
861         }
862         
863         return FEATURE_RETURN_SUCCESS;  /*! \todo XXX should probably return res */
864 }
865
866 static void unmap_features(void)
867 {
868         int x;
869         for (x = 0; x < FEATURES_COUNT; x++)
870                 strcpy(builtin_features[x].exten, builtin_features[x].default_exten);
871 }
872
873 static int remap_feature(const char *name, const char *value)
874 {
875         int x;
876         int res = -1;
877         for (x = 0; x < FEATURES_COUNT; x++) {
878                 if (!strcasecmp(name, builtin_features[x].sname)) {
879                         ast_copy_string(builtin_features[x].exten, value, sizeof(builtin_features[x].exten));
880                         if (option_verbose > 1)
881                                 ast_verbose(VERBOSE_PREFIX_2 "Remapping feature %s (%s) to sequence '%s'\n", builtin_features[x].fname, builtin_features[x].sname, builtin_features[x].exten);
882                         res = 0;
883                 } else if (!strcmp(value, builtin_features[x].exten)) 
884                         ast_log(LOG_WARNING, "Sequence '%s' already mapped to function %s (%s) while assigning to %s\n", value, builtin_features[x].fname, builtin_features[x].sname, name);
885         }
886         return res;
887 }
888
889 static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
890 {
891         int x;
892         struct ast_flags features;
893         int res = FEATURE_RETURN_PASSDIGITS;
894         struct ast_call_feature *feature;
895         const char *dynamic_features=pbx_builtin_getvar_helper(chan,"DYNAMIC_FEATURES");
896
897         if (sense == FEATURE_SENSE_CHAN)
898                 ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL);   
899         else
900                 ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL);   
901         if (option_debug > 2)
902                 ast_log(LOG_DEBUG, "Feature interpret: chan=%s, peer=%s, sense=%d, features=%d\n", chan->name, peer->name, sense, features.flags);
903
904         for (x=0; x < FEATURES_COUNT; x++) {
905                 if ((ast_test_flag(&features, builtin_features[x].feature_mask)) &&
906                     !ast_strlen_zero(builtin_features[x].exten)) {
907                         /* Feature is up for consideration */
908                         if (!strcmp(builtin_features[x].exten, code)) {
909                                 res = builtin_features[x].operation(chan, peer, config, code, sense);
910                                 break;
911                         } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) {
912                                 if (res == FEATURE_RETURN_PASSDIGITS)
913                                         res = FEATURE_RETURN_STOREDIGITS;
914                         }
915                 }
916         }
917
918
919         if (!ast_strlen_zero(dynamic_features)) {
920                 char *tmp = ast_strdupa(dynamic_features);
921                 char *tok;
922
923                 if (!tmp)
924                         return res;
925                 
926                 while ((tok = strsep(&tmp, "#")) != NULL) {
927                         feature = find_feature(tok);
928                         
929                         if (feature) {
930                                 /* Feature is up for consideration */
931                                 if (!strcmp(feature->exten, code)) {
932                                         if (option_verbose > 2)
933                                                 ast_verbose(VERBOSE_PREFIX_3 " Feature Found: %s exten: %s\n",feature->sname, tok);
934                                         res = feature->operation(chan, peer, config, code, sense);
935                                         break;
936                                 } else if (!strncmp(feature->exten, code, strlen(code))) {
937                                         res = FEATURE_RETURN_STOREDIGITS;
938                                 }
939                         }
940                 }
941         }
942         
943         return res;
944 }
945
946 static void set_config_flags(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config)
947 {
948         int x;
949         
950         ast_clear_flag(config, AST_FLAGS_ALL);  
951         for (x = 0; x < FEATURES_COUNT; x++) {
952                 if (ast_test_flag(builtin_features + x, AST_FEATURE_FLAG_NEEDSDTMF)) {
953                         if (ast_test_flag(&(config->features_caller), builtin_features[x].feature_mask))
954                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
955
956                         if (ast_test_flag(&(config->features_callee), builtin_features[x].feature_mask))
957                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
958                 }
959         }
960         
961         if (chan && peer && !(ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_0) && ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_1))) {
962                 const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");
963
964                 if (dynamic_features) {
965                         char *tmp = ast_strdupa(dynamic_features);
966                         char *tok;
967                         struct ast_call_feature *feature;
968
969                         if (!tmp)       /* no memory */
970                                 return;
971
972                         /* while we have a feature */
973                         while (NULL != (tok = strsep(&tmp, "#"))) {
974                                 if ((feature = find_feature(tok)) && ast_test_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF)) {
975                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_CALLER))
976                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
977                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_CALLEE))
978                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
979                                 }
980                         }
981                 }
982         }
983 }
984
985 /*! \todo XXX Check - this is very similar to the code in channel.c */
986 static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *caller, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name)
987 {
988         int state = 0;
989         int cause = 0;
990         int to;
991         struct ast_channel *chan;
992         struct ast_channel *monitor_chans[2];
993         struct ast_channel *active_channel;
994         int res = 0, ready = 0;
995         
996         if ((chan = ast_request(type, format, data, &cause))) {
997                 ast_set_callerid(chan, cid_num, cid_name, cid_num);
998                 ast_channel_inherit_variables(caller, chan);    
999                 if (!ast_call(chan, data, timeout)) {
1000                         struct timeval started;
1001                         int x, len = 0;
1002                         char *disconnect_code = NULL, *dialed_code = NULL;
1003
1004                         ast_indicate(caller, AST_CONTROL_RINGING);
1005                         /* support dialing of the featuremap disconnect code while performing an attended tranfer */
1006                         for (x=0; x < FEATURES_COUNT; x++) {
1007                                 if (strcasecmp(builtin_features[x].sname, "disconnect"))
1008                                         continue;
1009
1010                                 disconnect_code = builtin_features[x].exten;
1011                                 len = strlen(disconnect_code) + 1;
1012                                 dialed_code = alloca(len);
1013                                 memset(dialed_code, 0, len);
1014                                 break;
1015                         }
1016                         x = 0;
1017                         started = ast_tvnow();
1018                         to = timeout;
1019                         while (!ast_check_hangup(caller) && timeout && (chan->_state != AST_STATE_UP)) {
1020                                 struct ast_frame *f = NULL;
1021
1022                                 monitor_chans[0] = caller;
1023                                 monitor_chans[1] = chan;
1024                                 active_channel = ast_waitfor_n(monitor_chans, 2, &to);
1025
1026                                 /* see if the timeout has been violated */
1027                                 if(ast_tvdiff_ms(ast_tvnow(), started) > timeout) {
1028                                         state = AST_CONTROL_UNHOLD;
1029                                         ast_log(LOG_NOTICE, "We exceeded our AT-timeout\n");
1030                                         break; /*doh! timeout*/
1031                                 }
1032
1033                                 if (!active_channel)
1034                                         continue;
1035
1036                                 if (chan && (chan == active_channel)){
1037                                         f = ast_read(chan);
1038                                         if (f == NULL) { /*doh! where'd he go?*/
1039                                                 state = AST_CONTROL_HANGUP;
1040                                                 res = 0;
1041                                                 break;
1042                                         }
1043                                         
1044                                         if (f->frametype == AST_FRAME_CONTROL || f->frametype == AST_FRAME_DTMF || f->frametype == AST_FRAME_TEXT) {
1045                                                 if (f->subclass == AST_CONTROL_RINGING) {
1046                                                         state = f->subclass;
1047                                                         if (option_verbose > 2)
1048                                                                 ast_verbose( VERBOSE_PREFIX_3 "%s is ringing\n", chan->name);
1049                                                         ast_indicate(caller, AST_CONTROL_RINGING);
1050                                                 } else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) {
1051                                                         state = f->subclass;
1052                                                         if (option_verbose > 2)
1053                                                                 ast_verbose( VERBOSE_PREFIX_3 "%s is busy\n", chan->name);
1054                                                         ast_indicate(caller, AST_CONTROL_BUSY);
1055                                                         ast_frfree(f);
1056                                                         f = NULL;
1057                                                         break;
1058                                                 } else if (f->subclass == AST_CONTROL_ANSWER) {
1059                                                         /* This is what we are hoping for */
1060                                                         state = f->subclass;
1061                                                         ast_frfree(f);
1062                                                         f = NULL;
1063                                                         ready=1;
1064                                                         break;
1065                                                 } else {
1066                                                         ast_log(LOG_NOTICE, "Don't know what to do about control frame: %d\n", f->subclass);
1067                                                 }
1068                                                 /* else who cares */
1069                                         }
1070
1071                                 } else if (caller && (active_channel == caller)) {
1072                                         f = ast_read(caller);
1073                                         if (f == NULL) { /*doh! where'd he go?*/
1074                                                 if (caller->_softhangup && !chan->_softhangup) {
1075                                                         /* make this a blind transfer */
1076                                                         ready = 1;
1077                                                         break;
1078                                                 }
1079                                                 state = AST_CONTROL_HANGUP;
1080                                                 res = 0;
1081                                                 break;
1082                                         }
1083                                         
1084                                         if (f->frametype == AST_FRAME_DTMF) {
1085                                                 dialed_code[x++] = f->subclass;
1086                                                 dialed_code[x] = '\0';
1087                                                 if (strlen(dialed_code) == len) {
1088                                                         x = 0;
1089                                                 } else if (x && strncmp(dialed_code, disconnect_code, x)) {
1090                                                         x = 0;
1091                                                         dialed_code[x] = '\0';
1092                                                 }
1093                                                 if (*dialed_code && !strcmp(dialed_code, disconnect_code)) {
1094                                                         /* Caller Canceled the call */
1095                                                         state = AST_CONTROL_UNHOLD;
1096                                                         ast_frfree(f);
1097                                                         f = NULL;
1098                                                         break;
1099                                                 }
1100                                         }
1101                                 }
1102                                 if (f)
1103                                         ast_frfree(f);
1104                         } /* end while */
1105                 } else
1106                         ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
1107         } else {
1108                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
1109                 switch(cause) {
1110                 case AST_CAUSE_BUSY:
1111                         state = AST_CONTROL_BUSY;
1112                         break;
1113                 case AST_CAUSE_CONGESTION:
1114                         state = AST_CONTROL_CONGESTION;
1115                         break;
1116                 }
1117         }
1118         
1119         ast_indicate(caller, -1);
1120         if (chan && ready) {
1121                 if (chan->_state == AST_STATE_UP) 
1122                         state = AST_CONTROL_ANSWER;
1123                 res = 0;
1124         } else if(chan) {
1125                 res = -1;
1126                 ast_hangup(chan);
1127                 chan = NULL;
1128         } else {
1129                 res = -1;
1130         }
1131         
1132         if (outstate)
1133                 *outstate = state;
1134
1135         if (chan && res <= 0) {
1136                 if (chan->cdr || (chan->cdr = ast_cdr_alloc())) {
1137                         char tmp[256];
1138                         ast_cdr_init(chan->cdr, chan);
1139                         snprintf(tmp, 256, "%s/%s", type, (char *)data);
1140                         ast_cdr_setapp(chan->cdr,"Dial",tmp);
1141                         ast_cdr_update(chan);
1142                         ast_cdr_start(chan->cdr);
1143                         ast_cdr_end(chan->cdr);
1144                         /* If the cause wasn't handled properly */
1145                         if (ast_cdr_disposition(chan->cdr,chan->hangupcause))
1146                                 ast_cdr_failed(chan->cdr);
1147                 } else {
1148                         ast_log(LOG_WARNING, "Unable to create Call Detail Record\n");
1149                 }
1150         }
1151         
1152         return chan;
1153 }
1154
1155 int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast_bridge_config *config)
1156 {
1157         /* Copy voice back and forth between the two channels.  Give the peer
1158            the ability to transfer calls with '#<extension' syntax. */
1159         struct ast_frame *f;
1160         struct ast_channel *who;
1161         char chan_featurecode[FEATURE_MAX_LEN + 1]="";
1162         char peer_featurecode[FEATURE_MAX_LEN + 1]="";
1163         int res;
1164         int diff;
1165         int hasfeatures=0;
1166         int hadfeatures=0;
1167         struct ast_option_header *aoh;
1168         struct timeval start = { 0 , 0 };
1169         struct ast_bridge_config backup_config;
1170
1171         memset(&backup_config, 0, sizeof(backup_config));
1172
1173         config->start_time = ast_tvnow();
1174
1175         if (chan && peer) {
1176                 pbx_builtin_setvar_helper(chan, "BRIDGEPEER", peer->name);
1177                 pbx_builtin_setvar_helper(peer, "BRIDGEPEER", chan->name);
1178         } else if (chan)
1179                 pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", NULL);
1180
1181         if (monitor_ok) {
1182                 const char *monitor_exec;
1183                 struct ast_channel *src = NULL;
1184                 if (!monitor_app) { 
1185                         if (!(monitor_app = pbx_findapp("Monitor")))
1186                                 monitor_ok=0;
1187                 }
1188                 if ((monitor_exec = pbx_builtin_getvar_helper(chan, "AUTO_MONITOR"))) 
1189                         src = chan;
1190                 else if ((monitor_exec = pbx_builtin_getvar_helper(peer, "AUTO_MONITOR")))
1191                         src = peer;
1192                 if (monitor_app && src) {
1193                         char *tmp = ast_strdupa(monitor_exec);
1194                         if (tmp) {
1195                                 pbx_exec(src, monitor_app, tmp);
1196                         } else {
1197                                 ast_log(LOG_ERROR, "Monitor failed: out of memory\n");
1198                         }
1199                 }
1200         }
1201         
1202         set_config_flags(chan, peer, config);
1203         config->firstpass = 1;
1204
1205         /* Answer if need be */
1206         if (ast_answer(chan))
1207                 return -1;
1208         peer->appl = "Bridged Call";
1209         peer->data = chan->name;
1210
1211         /* copy the userfield from the B-leg to A-leg if applicable */
1212         if (chan->cdr && peer->cdr && !ast_strlen_zero(peer->cdr->userfield)) {
1213                 char tmp[256];
1214                 if (!ast_strlen_zero(chan->cdr->userfield)) {
1215                         snprintf(tmp, sizeof(tmp), "%s;%s", chan->cdr->userfield, peer->cdr->userfield);
1216                         ast_cdr_appenduserfield(chan, tmp);
1217                 } else
1218                         ast_cdr_setuserfield(chan, peer->cdr->userfield);
1219                 /* free the peer's cdr without ast_cdr_free complaining */
1220                 free(peer->cdr);
1221                 peer->cdr = NULL;
1222         }
1223         for (;;) {
1224                 struct ast_channel *other;      /* used later */
1225                 if (config->feature_timer)
1226                         start = ast_tvnow();
1227
1228                 res = ast_channel_bridge(chan, peer, config, &f, &who);
1229
1230                 if (config->feature_timer) {
1231                         /* Update time limit for next pass */
1232                         diff = ast_tvdiff_ms(ast_tvnow(), start);
1233                         config->feature_timer -= diff;
1234                         if (hasfeatures) {
1235                                 /* Running on backup config, meaning a feature might be being
1236                                    activated, but that's no excuse to keep things going 
1237                                    indefinitely! */
1238                                 if (backup_config.feature_timer && ((backup_config.feature_timer -= diff) <= 0)) {
1239                                         if (option_debug)
1240                                                 ast_log(LOG_DEBUG, "Timed out, realtime this time!\n");
1241                                         config->feature_timer = 0;
1242                                         who = chan;
1243                                         if (f)
1244                                                 ast_frfree(f);
1245                                         f = NULL;
1246                                         res = 0;
1247                                 } else if (config->feature_timer <= 0) {
1248                                         /* Not *really* out of time, just out of time for
1249                                            digits to come in for features. */
1250                                         if (option_debug)
1251                                                 ast_log(LOG_DEBUG, "Timed out for feature!\n");
1252                                         if (!ast_strlen_zero(peer_featurecode)) {
1253                                                 ast_dtmf_stream(chan, peer, peer_featurecode, 0);
1254                                                 memset(peer_featurecode, 0, sizeof(peer_featurecode));
1255                                         }
1256                                         if (!ast_strlen_zero(chan_featurecode)) {
1257                                                 ast_dtmf_stream(peer, chan, chan_featurecode, 0);
1258                                                 memset(chan_featurecode, 0, sizeof(chan_featurecode));
1259                                         }
1260                                         if (f)
1261                                                 ast_frfree(f);
1262                                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
1263                                         if (!hasfeatures) {
1264                                                 /* Restore original (possibly time modified) bridge config */
1265                                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
1266                                                 memset(&backup_config, 0, sizeof(backup_config));
1267                                         }
1268                                         hadfeatures = hasfeatures;
1269                                         /* Continue as we were */
1270                                         continue;
1271                                 }
1272                         } else {
1273                                 if (config->feature_timer <=0) {
1274                                         /* We ran out of time */
1275                                         config->feature_timer = 0;
1276                                         who = chan;
1277                                         if (f)
1278                                                 ast_frfree(f);
1279                                         f = NULL;
1280                                         res = 0;
1281                                 }
1282                         }
1283                 }
1284                 if (res < 0) {
1285                         ast_log(LOG_WARNING, "Bridge failed on channels %s and %s\n", chan->name, peer->name);
1286                         return -1;
1287                 }
1288                 
1289                 if (!f || (f->frametype == AST_FRAME_CONTROL &&
1290                                 (f->subclass == AST_CONTROL_HANGUP || f->subclass == AST_CONTROL_BUSY || 
1291                                         f->subclass == AST_CONTROL_CONGESTION ) ) ) {
1292                         res = -1;
1293                         break;
1294                 }
1295                 /* many things should be sent to the 'other' channel */
1296                 other = (who == chan) ? peer : chan;
1297                 if (f->frametype == AST_FRAME_CONTROL) {
1298                         if (f->subclass == AST_CONTROL_RINGING)
1299                                 ast_indicate(other, AST_CONTROL_RINGING);
1300                         else if (f->subclass == -1)
1301                                 ast_indicate(other, -1);
1302                         else if (f->subclass == AST_CONTROL_FLASH)
1303                                 ast_indicate(other, AST_CONTROL_FLASH);
1304                         else if (f->subclass == AST_CONTROL_OPTION) {
1305                                 aoh = f->data;
1306                                 /* Forward option Requests */
1307                                 if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST)
1308                                         ast_channel_setoption(other, ntohs(aoh->option), aoh->data, f->datalen - sizeof(struct ast_option_header), 0);
1309                         }
1310                 }
1311                 /* check for '*', if we find it it's time to disconnect */
1312                 if (f->frametype == AST_FRAME_DTMF) {
1313                         char *featurecode;
1314                         int sense;
1315
1316                         hadfeatures = hasfeatures;
1317                         /* This cannot overrun because the longest feature is one shorter than our buffer */
1318                         if (who == chan) {
1319                                 sense = FEATURE_SENSE_CHAN;
1320                                 featurecode = chan_featurecode;
1321                         } else  {
1322                                 sense = FEATURE_SENSE_PEER;
1323                                 featurecode = peer_featurecode;
1324                         }
1325                         /*! append the event to featurecode. we rely on the string being zero-filled, and
1326                          * not overflowing it. 
1327                          * \todo XXX how do we guarantee the latter ?
1328                          */
1329                         featurecode[strlen(featurecode)] = f->subclass;
1330                         config->feature_timer = backup_config.feature_timer;
1331                         res = ast_feature_interpret(chan, peer, config, featurecode, sense);
1332                         switch(res) {
1333                         case FEATURE_RETURN_PASSDIGITS:
1334                                 ast_dtmf_stream(other, who, featurecode, 0);
1335                                 /* Fall through */
1336                         case FEATURE_RETURN_SUCCESS:
1337                                 memset(featurecode, 0, sizeof(chan_featurecode));
1338                                 break;
1339                         }
1340                         if (res >= FEATURE_RETURN_PASSDIGITS) {
1341                                 res = 0;
1342                         } else {
1343                                 ast_frfree(f);
1344                                 break;
1345                         }
1346                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
1347                         if (hadfeatures && !hasfeatures) {
1348                                 /* Restore backup */
1349                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
1350                                 memset(&backup_config, 0, sizeof(struct ast_bridge_config));
1351                         } else if (hasfeatures) {
1352                                 if (!hadfeatures) {
1353                                         /* Backup configuration */
1354                                         memcpy(&backup_config, config, sizeof(struct ast_bridge_config));
1355                                         /* Setup temporary config options */
1356                                         config->play_warning = 0;
1357                                         ast_clear_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
1358                                         ast_clear_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
1359                                         config->warning_freq = 0;
1360                                         config->warning_sound = NULL;
1361                                         config->end_sound = NULL;
1362                                         config->start_sound = NULL;
1363                                         config->firstpass = 0;
1364                                 }
1365                                 config->feature_timer = featuredigittimeout;
1366                                 if (option_debug)
1367                                         ast_log(LOG_DEBUG, "Set time limit to %ld\n", config->feature_timer);
1368                         }
1369                 }
1370                 if (f)
1371                         ast_frfree(f);
1372         }
1373         return res;
1374 }
1375
1376 static void post_manager_event(const char *s, int num, struct ast_channel *chan)
1377 {
1378         manager_event(EVENT_FLAG_CALL, s,
1379                 "Exten: %d\r\n"
1380                 "Channel: %s\r\n"
1381                 "CallerID: %s\r\n"
1382                 "CallerIDName: %s\r\n\r\n",
1383                 num, chan->name,
1384                 S_OR(chan->cid.cid_num, "<unknown>"),
1385                 S_OR(chan->cid.cid_name, "<unknown>")
1386                 );
1387 }
1388
1389 /*! \brief Take care of parked calls and unpark them if needed */
1390 static void *do_parking_thread(void *ignore)
1391 {
1392         fd_set rfds, efds;      /* results from previous select, to be preserved across loops. */
1393         FD_ZERO(&rfds);
1394         FD_ZERO(&efds);
1395
1396         for (;;) {
1397                 struct parkeduser *pu, *pl, *pt = NULL;
1398                 int ms = -1;    /* select timeout, uninitialized */
1399                 int max = -1;   /* max fd, none there yet */
1400                 fd_set nrfds, nefds;    /* args for the next select */
1401                 FD_ZERO(&nrfds);
1402                 FD_ZERO(&nefds);
1403
1404                 ast_mutex_lock(&parking_lock);
1405                 pl = NULL;
1406                 pu = parkinglot;
1407                 /* navigate the list with prev-cur pointers to support removals */
1408                 while(pu) {
1409                         struct ast_channel *chan = pu->chan;    /* shorthand */
1410                         int tms;        /* timeout for this item */
1411                         int x;          /* fd index in channel */
1412                         struct ast_context *con;
1413
1414                         if (pu->notquiteyet) { /* Pretend this one isn't here yet */
1415                                 pl = pu;
1416                                 pu = pu->next;
1417                                 continue;
1418                         }
1419                         tms = ast_tvdiff_ms(ast_tvnow(), pu->start);
1420                         if (tms > pu->parkingtime) {
1421                                 /* Stop music on hold */
1422                                 ast_moh_stop(chan);
1423                                 ast_indicate(chan, AST_CONTROL_UNHOLD);
1424                                 /* Get chan, exten from derived kludge */
1425                                 if (pu->peername[0]) {
1426                                         char *peername = ast_strdupa(pu->peername);
1427                                         char *cp = strrchr(peername, '-');
1428                                         if (cp) 
1429                                                 *cp = 0;
1430                                         con = ast_context_find(parking_con_dial);
1431                                         if (!con) {
1432                                                 con = ast_context_create(NULL, parking_con_dial, registrar);
1433                                                 if (!con) {
1434                                                         ast_log(LOG_ERROR, "Parking dial context '%s' does not exist and unable to create\n", parking_con_dial);
1435                                                 }
1436                                         }
1437                                         if (con) {
1438                                                 char returnexten[AST_MAX_EXTENSION];
1439                                                 snprintf(returnexten, sizeof(returnexten), "%s||t", peername);
1440                                                 ast_add_extension2(con, 1, peername, 1, NULL, NULL, "Dial", strdup(returnexten), FREE, registrar);
1441                                         }
1442                                         set_c_e_p(chan, parking_con_dial, peername, 1);
1443                                 } else {
1444                                         /* They've been waiting too long, send them back to where they came.  Theoretically they
1445                                            should have their original extensions and such, but we copy to be on the safe side */
1446                                         set_c_e_p(chan, pu->context, pu->exten, pu->priority);
1447                                 }
1448
1449                                 post_manager_event("ParkedCallTimeOut", pu->parkingnum, chan);
1450
1451                                 if (option_verbose > 1) 
1452                                         ast_verbose(VERBOSE_PREFIX_2 "Timeout for %s parked on %d. Returning to %s,%s,%d\n", chan->name, pu->parkingnum, chan->context, chan->exten, chan->priority);
1453                                 /* Start up the PBX, or hang them up */
1454                                 if (ast_pbx_start(chan))  {
1455                                         ast_log(LOG_WARNING, "Unable to restart the PBX for user on '%s', hanging them up...\n", chan->name);
1456                                         ast_hangup(chan);
1457                                 }
1458                                 /* And take them out of the parking lot */
1459                                 if (pl) 
1460                                         pl->next = pu->next;
1461                                 else
1462                                         parkinglot = pu->next;
1463                                 pt = pu;
1464                                 pu = pu->next;
1465                                 con = ast_context_find(parking_con);
1466                                 if (con) {
1467                                         char exten[AST_MAX_EXTENSION];
1468                                         snprintf(exten, sizeof(exten), "%d", pt->parkingnum);
1469                                         if (ast_context_remove_extension2(con, exten, 1, NULL))
1470                                                 ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
1471                                 } else
1472                                         ast_log(LOG_WARNING, "Whoa, no parking context?\n");
1473                                 free(pt);
1474                         } else {        /* still within parking time, process descriptors */
1475                                 for (x = 0; x < AST_MAX_FDS; x++) {
1476                                         struct ast_frame *f;
1477
1478                                         if (chan->fds[x] == -1 || (!FD_ISSET(chan->fds[x], &rfds) && !FD_ISSET(chan->fds[x], &efds)))
1479                                                 continue;       /* nothing on this descriptor */
1480
1481                                         if (FD_ISSET(chan->fds[x], &efds))
1482                                                 ast_set_flag(chan, AST_FLAG_EXCEPTION);
1483                                         else
1484                                                 ast_clear_flag(chan, AST_FLAG_EXCEPTION);
1485                                         chan->fdno = x;
1486                                         /* See if they need servicing */
1487                                         f = ast_read(chan);
1488                                         if (!f || (f->frametype == AST_FRAME_CONTROL && f->subclass ==  AST_CONTROL_HANGUP)) {
1489                                                 if (f)
1490                                                         ast_frfree(f);
1491                                                 post_manager_event("ParkedCallGiveUp", pu->parkingnum, chan);
1492
1493                                                 /* There's a problem, hang them up*/
1494                                                 if (option_verbose > 1) 
1495                                                         ast_verbose(VERBOSE_PREFIX_2 "%s got tired of being parked\n", chan->name);
1496                                                 ast_hangup(chan);
1497                                                 /* And take them out of the parking lot */
1498                                                 if (pl) 
1499                                                         pl->next = pu->next;
1500                                                 else
1501                                                         parkinglot = pu->next;
1502                                                 pt = pu;
1503                                                 pu = pu->next;
1504                                                 con = ast_context_find(parking_con);
1505                                                 if (con) {
1506                                                         char exten[AST_MAX_EXTENSION];
1507                                                         snprintf(exten, sizeof(exten), "%d", pt->parkingnum);
1508                                                         if (ast_context_remove_extension2(con, exten, 1, NULL))
1509                                                                 ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
1510                                                 } else
1511                                                         ast_log(LOG_WARNING, "Whoa, no parking context?\n");
1512                                                 free(pt);
1513                                                 break;
1514                                         } else {
1515                                                 /*! \todo XXX Maybe we could do something with packets, like dial "0" for operator or something XXX */
1516                                                 ast_frfree(f);
1517                                                 if (pu->moh_trys < 3 && !chan->generatordata) {
1518                                                         if (option_debug)
1519                                                                 ast_log(LOG_DEBUG, "MOH on parked call stopped by outside source.  Restarting.\n");
1520                                                         ast_moh_start(chan, NULL);
1521                                                         pu->moh_trys++;
1522                                                 }
1523                                                 goto std;       /*! \todo XXX Ick: jumping into an else statement??? XXX */
1524                                         }
1525
1526                                 } /* end for */
1527                                 if (x >= AST_MAX_FDS) {
1528 std:                                    for (x=0; x<AST_MAX_FDS; x++) { /* mark fds for next round */
1529                                                 if (chan->fds[x] > -1) {
1530                                                         FD_SET(chan->fds[x], &nrfds);
1531                                                         FD_SET(chan->fds[x], &nefds);
1532                                                         if (chan->fds[x] > max)
1533                                                                 max = chan->fds[x];
1534                                                 }
1535                                         }
1536                                         /* Keep track of our shortest wait */
1537                                         if (tms < ms || ms < 0)
1538                                                 ms = tms;
1539                                         pl = pu;
1540                                         pu = pu->next;
1541                                 }
1542                         }
1543                 } /* end while */
1544                 ast_mutex_unlock(&parking_lock);
1545                 rfds = nrfds;
1546                 efds = nefds;
1547                 {
1548                         struct timeval tv = ast_samp2tv(ms, 1000);
1549                         /* Wait for something to happen */
1550                         ast_select(max + 1, &rfds, NULL, &efds, (ms > -1) ? &tv : NULL);
1551                 }
1552                 pthread_testcancel();
1553         }
1554         return NULL;    /* Never reached */
1555 }
1556
1557 static int park_call_exec(struct ast_channel *chan, void *data)
1558 {
1559         /* Data is unused at the moment but could contain a parking
1560            lot context eventually */
1561         int res=0;
1562         struct localuser *u;
1563         LOCAL_USER_ADD(u);
1564         /* Setup the exten/priority to be s/1 since we don't know
1565            where this call should return */
1566         strcpy(chan->exten, "s");
1567         chan->priority = 1;
1568         if (chan->_state != AST_STATE_UP)
1569                 res = ast_answer(chan);
1570         if (!res)
1571                 res = ast_safe_sleep(chan, 1000);
1572         if (!res)
1573                 res = ast_park_call(chan, chan, 0, NULL);
1574         LOCAL_USER_REMOVE(u);
1575         if (!res)
1576                 res = AST_PBX_KEEPALIVE;
1577         return res;
1578 }
1579
1580 static int park_exec(struct ast_channel *chan, void *data)
1581 {
1582         int res=0;
1583         struct localuser *u;
1584         struct ast_channel *peer=NULL;
1585         struct parkeduser *pu, *pl=NULL;
1586         struct ast_context *con;
1587         int park;
1588         struct ast_bridge_config config;
1589
1590         if (!data) {
1591                 ast_log(LOG_WARNING, "Park requires an argument (extension number)\n");
1592                 return -1;
1593         }
1594         LOCAL_USER_ADD(u);
1595         park = atoi((char *)data);
1596         ast_mutex_lock(&parking_lock);
1597         pu = parkinglot;
1598         while(pu) {
1599                 if (pu->parkingnum == park) {
1600                         if (pl)
1601                                 pl->next = pu->next;
1602                         else
1603                                 parkinglot = pu->next;
1604                         break;
1605                 }
1606                 pl = pu;
1607                 pu = pu->next;
1608         }
1609         ast_mutex_unlock(&parking_lock);
1610         if (pu) {
1611                 peer = pu->chan;
1612                 con = ast_context_find(parking_con);
1613                 if (con) {
1614                         char exten[AST_MAX_EXTENSION];
1615                         snprintf(exten, sizeof(exten), "%d", pu->parkingnum);
1616                         if (ast_context_remove_extension2(con, exten, 1, NULL))
1617                                 ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
1618                 } else
1619                         ast_log(LOG_WARNING, "Whoa, no parking context?\n");
1620
1621                 manager_event(EVENT_FLAG_CALL, "UnParkedCall",
1622                         "Exten: %d\r\n"
1623                         "Channel: %s\r\n"
1624                         "From: %s\r\n"
1625                         "CallerID: %s\r\n"
1626                         "CallerIDName: %s\r\n",
1627                         pu->parkingnum, pu->chan->name, chan->name,
1628                         S_OR(pu->chan->cid.cid_num, "<unknown>"),
1629                         S_OR(pu->chan->cid.cid_name, "<unknown>")
1630                         );
1631
1632                 free(pu);
1633         }
1634         /* JK02: it helps to answer the channel if not already up */
1635         if (chan->_state != AST_STATE_UP)
1636                 ast_answer(chan);
1637
1638         if (peer) {
1639                 /* Play a courtesy to the source(s) configured to prefix the bridge connecting */
1640                 
1641                 if (!ast_strlen_zero(courtesytone)) {
1642                         int error = 0;
1643                         ast_moh_stop(peer);
1644                         ast_indicate(peer, AST_CONTROL_UNHOLD);
1645                         if (parkedplay == 0) {
1646                                 error = ast_stream_and_wait(chan, courtesytone, chan->language, "");
1647                         } else if (parkedplay == 1) {
1648                                 error = ast_stream_and_wait(peer, courtesytone, chan->language, "");
1649                         } else if (parkedplay == 2) {
1650                                 if (!ast_streamfile(chan, courtesytone, chan->language) &&
1651                                                 !ast_streamfile(peer, courtesytone, chan->language)) {
1652                                         /*! \todo XXX we would like to wait on both! */
1653                                         res = ast_waitstream(chan, "");
1654                                         if (res >= 0)
1655                                                 res = ast_waitstream(peer, "");
1656                                         if (res < 0)
1657                                                 error = 1;
1658                                 }
1659                         }
1660                         if (error) {
1661                                 ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
1662                                 ast_hangup(peer);
1663                                 return -1;
1664                         }
1665                 } else {
1666                         ast_moh_stop(peer);
1667                         ast_indicate(peer, AST_CONTROL_UNHOLD); 
1668                 }
1669
1670                 res = ast_channel_make_compatible(chan, peer);
1671                 if (res < 0) {
1672                         ast_log(LOG_WARNING, "Could not make channels %s and %s compatible for bridge\n", chan->name, peer->name);
1673                         ast_hangup(peer);
1674                         return -1;
1675                 }
1676                 /* This runs sorta backwards, since we give the incoming channel control, as if it
1677                    were the person called. */
1678                 if (option_verbose > 2) 
1679                         ast_verbose(VERBOSE_PREFIX_3 "Channel %s connected to parked call %d\n", chan->name, park);
1680
1681                 memset(&config, 0, sizeof(struct ast_bridge_config));
1682                 ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
1683                 ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
1684                 config.timelimit = 0;
1685                 config.play_warning = 0;
1686                 config.warning_freq = 0;
1687                 config.warning_sound=NULL;
1688                 res = ast_bridge_call(chan, peer, &config);
1689
1690                 /* Simulate the PBX hanging up */
1691                 if (res != AST_PBX_NO_HANGUP_PEER)
1692                         ast_hangup(peer);
1693                 return res;
1694         } else {
1695                 /*! \todo XXX Play a message XXX */
1696                 if (ast_stream_and_wait(chan, "pbx-invalidpark", chan->language, ""))
1697                         ast_log(LOG_WARNING, "ast_streamfile of %s failed on %s\n", "pbx-invalidpark", chan->name);
1698                 if (option_verbose > 2) 
1699                         ast_verbose(VERBOSE_PREFIX_3 "Channel %s tried to talk to nonexistent parked call %d\n", chan->name, park);
1700                 res = -1;
1701         }
1702         LOCAL_USER_REMOVE(u);
1703         return res;
1704 }
1705
1706 static int handle_showfeatures(int fd, int argc, char *argv[])
1707 {
1708         int i;
1709         int fcount;
1710         struct ast_call_feature *feature;
1711         char format[] = "%-25s %-7s %-7s\n";
1712
1713         ast_cli(fd, format, "Builtin Feature", "Default", "Current");
1714         ast_cli(fd, format, "---------------", "-------", "-------");
1715
1716         ast_cli(fd, format, "Pickup", "*8", ast_pickup_ext());          /* default hardcoded above, so we'll hardcode it here */
1717
1718         fcount = sizeof(builtin_features) / sizeof(builtin_features[0]);
1719
1720         for (i = 0; i < fcount; i++)
1721         {
1722                 ast_cli(fd, format, builtin_features[i].fname, builtin_features[i].default_exten, builtin_features[i].exten);
1723         }
1724         ast_cli(fd, "\n");
1725         ast_cli(fd, format, "Dynamic Feature", "Default", "Current");
1726         ast_cli(fd, format, "---------------", "-------", "-------");
1727         if (AST_LIST_EMPTY(&feature_list)) {
1728                 ast_cli(fd, "(none)\n");
1729         }
1730         else {
1731                 AST_LIST_LOCK(&feature_list);
1732                 AST_LIST_TRAVERSE(&feature_list, feature, feature_entry) {
1733                         ast_cli(fd, format, feature->sname, "no def", feature->exten);  
1734                 }
1735                 AST_LIST_UNLOCK(&feature_list);
1736         }
1737         ast_cli(fd, "\nCall parking\n");
1738         ast_cli(fd, "------------\n");
1739         ast_cli(fd,"%-20s:      %s\n", "Parking extension", parking_ext);
1740         ast_cli(fd,"%-20s:      %s\n", "Parking context", parking_con);
1741         ast_cli(fd,"%-20s:      %d-%d\n", "Parked call extensions", parking_start, parking_stop);
1742         ast_cli(fd,"\n");
1743         
1744         return RESULT_SUCCESS;
1745 }
1746
1747 static char showfeatures_help[] =
1748 "Usage: show features\n"
1749 "       Lists currently configured features.\n";
1750
1751 static struct ast_cli_entry showfeatures =
1752 { { "show", "features", NULL }, handle_showfeatures, "Lists configured features", showfeatures_help };
1753
1754 static int handle_parkedcalls(int fd, int argc, char *argv[])
1755 {
1756         struct parkeduser *cur;
1757         int numparked = 0;
1758
1759         ast_cli(fd, "%4s %25s (%-15s %-12s %-4s) %-6s \n", "Num", "Channel"
1760                 , "Context", "Extension", "Pri", "Timeout");
1761
1762         ast_mutex_lock(&parking_lock);
1763
1764         for (cur = parkinglot; cur; cur = cur->next) {
1765                 ast_cli(fd, "%4d %25s (%-15s %-12s %-4d) %6lds\n"
1766                         ,cur->parkingnum, cur->chan->name, cur->context, cur->exten
1767                         ,cur->priority, cur->start.tv_sec + (cur->parkingtime/1000) - time(NULL));
1768
1769                 numparked++;
1770         }
1771         ast_mutex_unlock(&parking_lock);
1772         ast_cli(fd, "%d parked call%s.\n", numparked, (numparked != 1) ? "s" : "");
1773
1774
1775         return RESULT_SUCCESS;
1776 }
1777
1778 static char showparked_help[] =
1779 "Usage: show parkedcalls\n"
1780 "       Lists currently parked calls.\n";
1781
1782 static struct ast_cli_entry showparked =
1783 { { "show", "parkedcalls", NULL }, handle_parkedcalls, "Lists parked calls", showparked_help };
1784
1785 /*! \brief Dump lot status */
1786 static int manager_parking_status( struct mansession *s, struct message *m )
1787 {
1788         struct parkeduser *cur;
1789         char *id = astman_get_header(m,"ActionID");
1790         char idText[256] = "";
1791
1792         if (!ast_strlen_zero(id))
1793                 snprintf(idText,256,"ActionID: %s\r\n",id);
1794
1795         astman_send_ack(s, m, "Parked calls will follow");
1796
1797         ast_mutex_lock(&parking_lock);
1798
1799         for (cur=parkinglot; cur; cur = cur->next) {
1800                 astman_append(s, "Event: ParkedCall\r\n"
1801                         "Exten: %d\r\n"
1802                         "Channel: %s\r\n"
1803                         "From: %s\r\n"
1804                         "Timeout: %ld\r\n"
1805                         "CallerID: %s\r\n"
1806                         "CallerIDName: %s\r\n"
1807                         "%s"
1808                         "\r\n",
1809                         cur->parkingnum, cur->chan->name, cur->peername,
1810                         (long)cur->start.tv_sec + (long)(cur->parkingtime/1000) - (long)time(NULL),
1811                         S_OR(cur->chan->cid.cid_num, ""),       /* XXX in other places it is <unknown> */
1812                         S_OR(cur->chan->cid.cid_name, ""),
1813                         idText);
1814         }
1815
1816         astman_append(s,
1817                 "Event: ParkedCallsComplete\r\n"
1818                 "%s"
1819                 "\r\n",idText);
1820
1821         ast_mutex_unlock(&parking_lock);
1822
1823         return RESULT_SUCCESS;
1824 }
1825
1826 static char mandescr_park[] =
1827 "Description: Park a channel.\n"
1828 "Variables: (Names marked with * are required)\n"
1829 "       *Channel: Channel name to park\n"
1830 "       *Channel2: Channel to announce park info to (and return to if timeout)\n"
1831 "       Timeout: Number of milliseconds to wait before callback.\n";  
1832
1833 static int manager_park(struct mansession *s, struct message *m)
1834 {
1835         char *channel = astman_get_header(m, "Channel");
1836         char *channel2 = astman_get_header(m, "Channel2");
1837         char *timeout = astman_get_header(m, "Timeout");
1838         char buf[BUFSIZ];
1839         int to = 0;
1840         int res = 0;
1841         int parkExt = 0;
1842         struct ast_channel *ch1, *ch2;
1843
1844         if (ast_strlen_zero(channel)) {
1845                 astman_send_error(s, m, "Channel not specified");
1846                 return 0;
1847         }
1848
1849         if (ast_strlen_zero(channel2)) {
1850                 astman_send_error(s, m, "Channel2 not specified");
1851                 return 0;
1852         }
1853
1854         ch1 = ast_get_channel_by_name_locked(channel);
1855         if (!ch1) {
1856                 snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel);
1857                 astman_send_error(s, m, buf);
1858                 return 0;
1859         }
1860
1861         ch2 = ast_get_channel_by_name_locked(channel2);
1862         if (!ch2) {
1863                 snprintf(buf, sizeof(buf), "Channel does not exist: %s", channel2);
1864                 astman_send_error(s, m, buf);
1865                 ast_channel_unlock(ch1);
1866                 return 0;
1867         }
1868
1869         if (!ast_strlen_zero(timeout)) {
1870                 sscanf(timeout, "%d", &to);
1871         }
1872
1873         res = ast_masq_park_call(ch1, ch2, to, &parkExt);
1874         if (!res) {
1875                 ast_softhangup(ch2, AST_SOFTHANGUP_EXPLICIT);
1876                 astman_send_ack(s, m, "Park successful");
1877         } else {
1878                 astman_send_error(s, m, "Park failure");
1879         }
1880
1881         ast_channel_unlock(ch1);
1882         ast_channel_unlock(ch2);
1883
1884         return 0;
1885 }
1886
1887
1888 int ast_pickup_call(struct ast_channel *chan)
1889 {
1890         struct ast_channel *cur = NULL;
1891         int res = -1;
1892
1893         while ( (cur = ast_channel_walk_locked(cur)) != NULL) {
1894                 if (!cur->pbx && 
1895                         (cur != chan) &&
1896                         (chan->pickupgroup & cur->callgroup) &&
1897                         ((cur->_state == AST_STATE_RINGING) ||
1898                          (cur->_state == AST_STATE_RING))) {
1899                                 break;
1900                 }
1901                 ast_channel_unlock(cur);
1902         }
1903         if (cur) {
1904                 if (option_debug)
1905                         ast_log(LOG_DEBUG, "Call pickup on chan '%s' by '%s'\n",cur->name, chan->name);
1906                 res = ast_answer(chan);
1907                 if (res)
1908                         ast_log(LOG_WARNING, "Unable to answer '%s'\n", chan->name);
1909                 res = ast_queue_control(chan, AST_CONTROL_ANSWER);
1910                 if (res)
1911                         ast_log(LOG_WARNING, "Unable to queue answer on '%s'\n", chan->name);
1912                 res = ast_channel_masquerade(cur, chan);
1913                 if (res)
1914                         ast_log(LOG_WARNING, "Unable to masquerade '%s' into '%s'\n", chan->name, cur->name);           /* Done */
1915                 ast_channel_unlock(cur);
1916         } else  {
1917                 if (option_debug)
1918                         ast_log(LOG_DEBUG, "No call pickup possible...\n");
1919         }
1920         return res;
1921 }
1922
1923 static int load_config(void) 
1924 {
1925         int start = 0, end = 0;
1926         struct ast_context *con = NULL;
1927         struct ast_config *cfg = NULL;
1928         struct ast_variable *var = NULL;
1929         char old_parking_ext[AST_MAX_EXTENSION];
1930         char old_parking_con[AST_MAX_EXTENSION] = "";
1931
1932         if (!ast_strlen_zero(parking_con)) {
1933                 strcpy(old_parking_ext, parking_ext);
1934                 strcpy(old_parking_con, parking_con);
1935         } 
1936
1937         /* Reset to defaults */
1938         strcpy(parking_con, "parkedcalls");
1939         strcpy(parking_con_dial, "park-dial");
1940         strcpy(parking_ext, "700");
1941         strcpy(pickup_ext, "*8");
1942         courtesytone[0] = '\0';
1943         strcpy(xfersound, "beep");
1944         strcpy(xferfailsound, "pbx-invalid");
1945         parking_start = 701;
1946         parking_stop = 750;
1947         parkfindnext = 0;
1948         adsipark = 0;
1949
1950         transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT;
1951         featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT;
1952
1953         cfg = ast_config_load("features.conf");
1954         if (cfg) {
1955                 for (var = ast_variable_browse(cfg, "general"); var; var = var->next) {
1956                         if (!strcasecmp(var->name, "parkext")) {
1957                                 ast_copy_string(parking_ext, var->value, sizeof(parking_ext));
1958                         } else if (!strcasecmp(var->name, "context")) {
1959                                 ast_copy_string(parking_con, var->value, sizeof(parking_con));
1960                         } else if (!strcasecmp(var->name, "parkingtime")) {
1961                                 if ((sscanf(var->value, "%d", &parkingtime) != 1) || (parkingtime < 1)) {
1962                                         ast_log(LOG_WARNING, "%s is not a valid parkingtime\n", var->value);
1963                                         parkingtime = DEFAULT_PARK_TIME;
1964                                 } else
1965                                         parkingtime = parkingtime * 1000;
1966                         } else if (!strcasecmp(var->name, "parkpos")) {
1967                                 if (sscanf(var->value, "%d-%d", &start, &end) != 2) {
1968                                         ast_log(LOG_WARNING, "Format for parking positions is a-b, where a and b are numbers at line %d of parking.conf\n", var->lineno);
1969                                 } else {
1970                                         parking_start = start;
1971                                         parking_stop = end;
1972                                 }
1973                         } else if (!strcasecmp(var->name, "findslot")) {
1974                                 parkfindnext = (!strcasecmp(var->value, "next"));
1975                         } else if (!strcasecmp(var->name, "adsipark")) {
1976                                 adsipark = ast_true(var->value);
1977                         } else if (!strcasecmp(var->name, "transferdigittimeout")) {
1978                                 if ((sscanf(var->value, "%d", &transferdigittimeout) != 1) || (transferdigittimeout < 1)) {
1979                                         ast_log(LOG_WARNING, "%s is not a valid transferdigittimeout\n", var->value);
1980                                         transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT;
1981                                 } else
1982                                         transferdigittimeout = transferdigittimeout * 1000;
1983                         } else if (!strcasecmp(var->name, "featuredigittimeout")) {
1984                                 if ((sscanf(var->value, "%d", &featuredigittimeout) != 1) || (featuredigittimeout < 1)) {
1985                                         ast_log(LOG_WARNING, "%s is not a valid featuredigittimeout\n", var->value);
1986                                         featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT;
1987                                 }
1988                         } else if (!strcasecmp(var->name, "courtesytone")) {
1989                                 ast_copy_string(courtesytone, var->value, sizeof(courtesytone));
1990                         }  else if (!strcasecmp(var->name, "parkedplay")) {
1991                                 if (!strcasecmp(var->value, "both"))
1992                                         parkedplay = 2;
1993                                 else if (!strcasecmp(var->value, "parked"))
1994                                         parkedplay = 1;
1995                                 else
1996                                         parkedplay = 0;
1997                         } else if (!strcasecmp(var->name, "xfersound")) {
1998                                 ast_copy_string(xfersound, var->value, sizeof(xfersound));
1999                         } else if (!strcasecmp(var->name, "xferfailsound")) {
2000                                 ast_copy_string(xferfailsound, var->value, sizeof(xferfailsound));
2001                         } else if (!strcasecmp(var->name, "pickupexten")) {
2002                                 ast_copy_string(pickup_ext, var->value, sizeof(pickup_ext));
2003                         }
2004                 }
2005
2006                 unmap_features();
2007                 for (var = ast_variable_browse(cfg, "featuremap"); var; var = var->next) {
2008                         if (remap_feature(var->name, var->value))
2009                                 ast_log(LOG_NOTICE, "Unknown feature '%s'\n", var->name);
2010                 }
2011
2012                 /* Map a key combination to an application*/
2013                 ast_unregister_features();
2014                 for (var = ast_variable_browse(cfg, "applicationmap"); var; var = var->next) {
2015                         char *tmp_val = ast_strdup(var->value);
2016                         char *exten, *party=NULL, *app=NULL, *app_args=NULL; 
2017
2018                         if (!tmp_val) { 
2019                                 /*! \todo XXX No memory. We should probably break, but at least we do not
2020                                  * insist on this entry or we could be stuck in an
2021                                  * infinite loop.
2022                                  */
2023                                 continue;
2024                         }
2025
2026                         /* strsep() sets the argument to NULL if match not found, and it
2027                          * is safe to use it with a NULL argument, so we don't check
2028                          * between calls.
2029                          */
2030                         exten = strsep(&tmp_val,",");
2031                         party = strsep(&tmp_val,",");
2032                         app = strsep(&tmp_val,",");
2033                         app_args = strsep(&tmp_val,",");
2034
2035                         /*! \todo XXX var_name or app_args ? */
2036                         if (ast_strlen_zero(app) || ast_strlen_zero(exten) || ast_strlen_zero(party) || ast_strlen_zero(var->name)) {
2037                                 ast_log(LOG_NOTICE, "Please check the feature Mapping Syntax, either extension, name, or app aren't provided %s %s %s %s\n",app,exten,party,var->name);
2038                                 free(tmp_val);
2039                                 continue;
2040                         }
2041
2042                         {
2043                                 struct ast_call_feature *feature;
2044                                 int mallocd = 0;
2045                                 
2046                                 if (!(feature = find_feature(var->name))) {
2047                                         mallocd = 1;
2048                                         
2049                                         if (!(feature = ast_calloc(1, sizeof(*feature)))) {
2050                                                 free(tmp_val);
2051                                                 continue;                                       
2052                                         }
2053                                 }
2054
2055                                 ast_copy_string(feature->sname,var->name,FEATURE_SNAME_LEN);
2056                                 ast_copy_string(feature->app,app,FEATURE_APP_LEN);
2057                                 ast_copy_string(feature->exten, exten,FEATURE_EXTEN_LEN);
2058                                 free(tmp_val);
2059                                 
2060                                 if (app_args) 
2061                                         ast_copy_string(feature->app_args,app_args,FEATURE_APP_ARGS_LEN);
2062                                 
2063                                 ast_copy_string(feature->exten, exten,sizeof(feature->exten));
2064                                 feature->operation=feature_exec_app;
2065                                 ast_set_flag(feature,AST_FEATURE_FLAG_NEEDSDTMF);
2066                                 
2067                                 if (!strcasecmp(party,"caller"))
2068                                         ast_set_flag(feature,AST_FEATURE_FLAG_CALLER);
2069                                 else if (!strcasecmp(party, "callee"))
2070                                         ast_set_flag(feature,AST_FEATURE_FLAG_CALLEE);
2071                                 else {
2072                                         ast_log(LOG_NOTICE, "Invalid party specification for feature '%s', must be caller, or callee\n", var->name);
2073                                         continue;
2074                                 }
2075
2076                                 ast_register_feature(feature);
2077                                 /* XXX do we need to free it if mallocd ? */
2078                                 
2079                                 if (option_verbose >=1)
2080                                         ast_verbose(VERBOSE_PREFIX_2 "Mapping Feature '%s' to app '%s' with code '%s'\n", var->name, app, exten);  
2081                         }
2082                 }        
2083         }
2084         ast_config_destroy(cfg);
2085
2086         /* Remove the old parking extension */
2087         if (!ast_strlen_zero(old_parking_con) && (con = ast_context_find(old_parking_con)))     {
2088                 ast_context_remove_extension2(con, old_parking_ext, 1, registrar);
2089                 if (option_debug)
2090                         ast_log(LOG_DEBUG, "Removed old parking extension %s@%s\n", old_parking_ext, old_parking_con);
2091         }
2092         
2093         if (!(con = ast_context_find(parking_con)) && !(con = ast_context_create(NULL, parking_con, registrar))) {
2094                 ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parking_con);
2095                 return -1;
2096         }
2097         return ast_add_extension2(con, 1, ast_parking_ext(), 1, NULL, NULL, parkcall, strdup(""), FREE, registrar);
2098 }
2099
2100 static int reload(void *mod)
2101 {
2102         return load_config();
2103 }
2104
2105 static int load_module(void *mod)
2106 {
2107         int res;
2108         
2109         __mod_desc = mod;
2110         AST_LIST_HEAD_INIT(&feature_list);
2111         memset(parking_ext, 0, sizeof(parking_ext));
2112         memset(parking_con, 0, sizeof(parking_con));
2113
2114         if ((res = load_config()))
2115                 return res;
2116         ast_cli_register(&showparked);
2117         ast_cli_register(&showfeatures);
2118         ast_pthread_create(&parking_thread, NULL, do_parking_thread, NULL);
2119         res = ast_register_application(parkedcall, park_exec, synopsis, descrip);
2120         if (!res)
2121                 res = ast_register_application(parkcall, park_call_exec, synopsis2, descrip2);
2122         if (!res) {
2123                 ast_manager_register("ParkedCalls", 0, manager_parking_status, "List parked calls" );
2124                 ast_manager_register2("Park", EVENT_FLAG_CALL, manager_park,
2125                         "Park a channel", mandescr_park); 
2126         }
2127         return res;
2128 }
2129
2130
2131 static int unload_module(void *mod)
2132 {
2133         STANDARD_HANGUP_LOCALUSERS;
2134
2135         ast_manager_unregister("ParkedCalls");
2136         ast_manager_unregister("Park");
2137         ast_cli_unregister(&showfeatures);
2138         ast_cli_unregister(&showparked);
2139         ast_unregister_application(parkcall);
2140         return ast_unregister_application(parkedcall);
2141 }
2142
2143 static const char *description(void)
2144 {
2145         return "Call Features Resource";
2146 }
2147
2148 static const char *key(void)
2149 {
2150         return ASTERISK_GPL_KEY;
2151 }
2152
2153 STD_MOD(MOD_0 | NO_UNLOAD, reload, NULL, NULL);