Fix a few more places where the case insensitive hash should be used since
[asterisk/asterisk.git] / main / features.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Routines implementing call features as call pickup, parking and transfer
22  *
23  * \author Mark Spencer <markster@digium.com> 
24  */
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/_private.h"
31
32 #include <pthread.h>
33 #include <sys/time.h>
34 #include <sys/signal.h>
35 #include <netinet/in.h>
36
37 #include "asterisk/lock.h"
38 #include "asterisk/file.h"
39 #include "asterisk/channel.h"
40 #include "asterisk/pbx.h"
41 #include "asterisk/causes.h"
42 #include "asterisk/module.h"
43 #include "asterisk/translate.h"
44 #include "asterisk/app.h"
45 #include "asterisk/say.h"
46 #include "asterisk/features.h"
47 #include "asterisk/musiconhold.h"
48 #include "asterisk/config.h"
49 #include "asterisk/cli.h"
50 #include "asterisk/manager.h"
51 #include "asterisk/utils.h"
52 #include "asterisk/adsi.h"
53 #include "asterisk/devicestate.h"
54 #include "asterisk/monitor.h"
55 #include "asterisk/audiohook.h"
56 #include "asterisk/global_datastores.h"
57 #include "asterisk/astobj2.h"
58
59 /*** DOCUMENTATION
60         <application name="Bridge" language="en_US">
61                 <synopsis>
62                         Bridge two channels.
63                 </synopsis>
64                 <syntax>
65                         <parameter name="channel" required="true">
66                                 <para>The current channel is bridged to the specified <replaceable>channel</replaceable>.</para>
67                         </parameter>
68                         <parameter name="options">
69                                 <optionlist>
70                                         <option name="p">
71                                                 <para>Play a courtesy tone to <replaceable>channel</replaceable>.</para>
72                                         </option>
73                                 </optionlist>
74                         </parameter>
75                 </syntax>
76                 <description>
77                         <para>Allows the ability to bridge two channels via the dialplan.</para>
78                         <para>This application sets the following channel variable upon completion:</para>
79                         <variablelist>
80                                 <variable name="BRIDGERESULT">
81                                         <para>The result of the bridge attempt as a text string.</para>
82                                         <value name="SUCCESS" />
83                                         <value name="FAILURE" />
84                                         <value name="LOOP" />
85                                         <value name="NONEXISTENT" />
86                                         <value name="INCOMPATIBLE" />
87                                 </variable>
88                         </variablelist>
89                 </description>
90         </application>
91         <application name="ParkedCall" language="en_US">
92                 <synopsis>
93                         Answer a parked call.
94                 </synopsis>
95                 <syntax>
96                         <parameter name="exten" required="true" />
97                 </syntax>
98                 <description>
99                         <para>Used to connect to a parked call. This application is always
100                         registered internally and does not need to be explicitly added
101                         into the dialplan, although you should include the <literal>parkedcalls</literal>
102                         context. If no extension is provided, then the first available
103                         parked call will be acquired.</para>
104                 </description>
105                 <see-also>
106                         <ref type="application">Park</ref>
107                         <ref type="application">ParkAndAnnounce</ref>
108                 </see-also>
109         </application>
110         <application name="Park" language="en_US">
111                 <synopsis>
112                         Park yourself.
113                 </synopsis>
114                 <syntax>
115                         <parameter name="timeout">
116                                 <para>A custom parking timeout for this parked call.</para>
117                         </parameter>
118                         <parameter name="return_context">
119                                 <para>The context to return the call to after it times out.</para>
120                         </parameter>
121                         <parameter name="return_exten">
122                                 <para>The extension to return the call to after it times out.</para>
123                         </parameter>
124                         <parameter name="return_priority">
125                                 <para>The priority to return the call to after it times out.</para>
126                         </parameter>
127                         <parameter name="options">
128                                 <para>A list of options for this parked call.</para>
129                                 <optionlist>
130                                         <option name="r">
131                                                 <para>Send ringing instead of MOH to the parked call.</para>
132                                         </option>
133                                         <option name="R">
134                                                 <para>Randomize the selection of a parking space.</para>
135                                         </option>
136                                         <option name="s">
137                                                 <para>Silence announcement of the parking space number.</para>
138                                         </option>
139                                 </optionlist>
140                         </parameter>
141                 </syntax>
142                 <description>
143                         <para>Used to park yourself (typically in combination with a supervised
144                         transfer to know the parking space). This application is always
145                         registered internally and does not need to be explicitly added
146                         into the dialplan, although you should include the <literal>parkedcalls</literal>
147                         context (or the context specified in <filename>features.conf</filename>).</para>
148                         <para>If you set the <variable>PARKINGEXTEN</variable> variable to an extension in your
149                         parking context, Park() will park the call on that extension, unless
150                         it already exists. In that case, execution will continue at next priority.</para>
151                 </description>
152                 <see-also>
153                         <ref type="application">ParkAndAnnounce</ref>
154                         <ref type="application">ParkedCall</ref>
155                 </see-also>
156         </application>
157  ***/
158
159 #define DEFAULT_PARK_TIME 45000
160 #define DEFAULT_TRANSFER_DIGIT_TIMEOUT 3000
161 #define DEFAULT_FEATURE_DIGIT_TIMEOUT 2000
162 #define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER 15000
163 #define DEFAULT_PARKINGLOT "default"                    /*!< Default parking lot */
164 #define DEFAULT_ATXFER_DROP_CALL 0
165 #define DEFAULT_ATXFER_LOOP_DELAY 10000
166 #define DEFAULT_ATXFER_CALLBACK_RETRIES 2
167
168 #define AST_MAX_WATCHERS 256
169
170 struct feature_group_exten {
171         AST_LIST_ENTRY(feature_group_exten) entry;
172         AST_DECLARE_STRING_FIELDS(
173                 AST_STRING_FIELD(exten);
174         );
175         struct ast_call_feature *feature;
176 };
177
178 struct feature_group {
179         AST_LIST_ENTRY(feature_group) entry;
180         AST_DECLARE_STRING_FIELDS(
181                 AST_STRING_FIELD(gname);
182         );
183         AST_LIST_HEAD_NOLOCK(, feature_group_exten) features;
184 };
185
186 static AST_RWLIST_HEAD_STATIC(feature_groups, feature_group);
187
188 static char *parkedcall = "ParkedCall";
189
190 static char pickup_ext[AST_MAX_EXTENSION];                 /*!< Call pickup extension */
191
192 /*! \brief Description of one parked call, added to a list while active, then removed.
193         The list belongs to a parkinglot 
194 */
195 struct parkeduser {
196         struct ast_channel *chan;                   /*!< Parking channel */
197         struct timeval start;                       /*!< Time the parking started */
198         int parkingnum;                             /*!< Parking lot */
199         char parkingexten[AST_MAX_EXTENSION];       /*!< If set beforehand, parking extension used for this call */
200         char context[AST_MAX_CONTEXT];              /*!< Where to go if our parking time expires */
201         char exten[AST_MAX_EXTENSION];
202         int priority;
203         int parkingtime;                            /*!< Maximum length in parking lot before return */
204         int notquiteyet;
205         char peername[1024];
206         unsigned char moh_trys;
207         struct ast_parkinglot *parkinglot;
208         AST_LIST_ENTRY(parkeduser) list;
209 };
210
211 /*! \brief Structure for parking lots which are put in a container. */
212 struct ast_parkinglot {
213         char name[AST_MAX_CONTEXT];
214         char parking_con[AST_MAX_EXTENSION];            /*!< Context for which parking is made accessible */
215         char parking_con_dial[AST_MAX_EXTENSION];       /*!< Context for dialback for parking (KLUDGE) */
216         int parking_start;                              /*!< First available extension for parking */
217         int parking_stop;                               /*!< Last available extension for parking */
218         int parking_offset;
219         int parkfindnext;
220         int parkingtime;                                /*!< Default parking time */
221         char mohclass[MAX_MUSICCLASS];                  /*!< Music class used for parking */
222         int parkaddhints;                               /*!< Add parking hints automatically */
223         int parkedcalltransfers;                        /*!< Enable DTMF based transfers on bridge when picking up parked calls */
224         int parkedcallreparking;                        /*!< Enable DTMF based parking on bridge when picking up parked calls */
225         AST_LIST_HEAD(parkinglot_parklist, parkeduser) parkings; /*!< List of active parkings in this parkinglot */
226 };
227
228 /*! \brief The list of parking lots configured. Always at least one  - the default parking lot */
229 static struct ao2_container *parkinglots;
230  
231 struct ast_parkinglot *default_parkinglot;
232 char parking_ext[AST_MAX_EXTENSION];            /*!< Extension you type to park the call */
233
234 static char courtesytone[256];                             /*!< Courtesy tone */
235 static int parkedplay = 0;                                 /*!< Who to play the courtesy tone to */
236 static char xfersound[256];                                /*!< Call transfer sound */
237 static char xferfailsound[256];                            /*!< Call transfer failure sound */
238
239 static int adsipark;
240
241 static int transferdigittimeout;
242 static int featuredigittimeout;
243 static int comebacktoorigin = 1;
244
245 static int atxfernoanswertimeout;
246 static unsigned int atxferdropcall;
247 static unsigned int atxferloopdelay;
248 static unsigned int atxfercallbackretries;
249
250 static char *registrar = "features";               /*!< Registrar for operations */
251
252 /* module and CLI command definitions */
253 static char *parkcall = PARK_APP_NAME;
254
255 static struct ast_app *monitor_app = NULL;
256 static int monitor_ok = 1;
257
258 static struct ast_app *mixmonitor_app = NULL;
259 static int mixmonitor_ok = 1;
260
261 static struct ast_app *stopmixmonitor_app = NULL;
262 static int stopmixmonitor_ok = 1;
263
264 static pthread_t parking_thread;
265
266 /* Forward declarations */
267 static struct ast_parkinglot *parkinglot_addref(struct ast_parkinglot *parkinglot);
268 static void parkinglot_unref(struct ast_parkinglot *parkinglot);
269 static void parkinglot_destroy(void *obj);
270 int manage_parkinglot(struct ast_parkinglot *curlot, fd_set *rfds, fd_set *efds, fd_set *nrfds, fd_set *nefds, int *fs, int *max);
271 struct ast_parkinglot *find_parkinglot(const char *name);
272
273
274 const char *ast_parking_ext(void)
275 {
276         return parking_ext;
277 }
278
279 const char *ast_pickup_ext(void)
280 {
281         return pickup_ext;
282 }
283
284 struct ast_bridge_thread_obj 
285 {
286         struct ast_bridge_config bconfig;
287         struct ast_channel *chan;
288         struct ast_channel *peer;
289         unsigned int return_to_pbx:1;
290 };
291
292 static int parkinglot_hash_cb(const void *obj, const int flags)
293 {
294         const struct ast_parkinglot *parkinglot = obj;
295
296         return ast_str_case_hash(parkinglot->name);
297 }
298
299 static int parkinglot_cmp_cb(void *obj, void *arg, void *data, int flags)
300 {
301         struct ast_parkinglot *parkinglot = obj, *parkinglot2 = arg;
302
303         return !strcasecmp(parkinglot->name, parkinglot2->name) ? CMP_MATCH | CMP_STOP : 0;
304 }
305
306 /*!
307  * \brief store context, extension and priority 
308  * \param chan, context, ext, pri
309 */
310 static void set_c_e_p(struct ast_channel *chan, const char *context, const char *ext, int pri)
311 {
312         ast_copy_string(chan->context, context, sizeof(chan->context));
313         ast_copy_string(chan->exten, ext, sizeof(chan->exten));
314         chan->priority = pri;
315 }
316
317 /*!
318  * \brief Check goto on transfer
319  * \param chan
320  *
321  * Check if channel has 'GOTO_ON_BLINDXFR' set, if not exit.
322  * When found make sure the types are compatible. Check if channel is valid
323  * if so start the new channel else hangup the call. 
324 */
325 static void check_goto_on_transfer(struct ast_channel *chan) 
326 {
327         struct ast_channel *xferchan;
328         const char *val = pbx_builtin_getvar_helper(chan, "GOTO_ON_BLINDXFR");
329         char *x, *goto_on_transfer;
330         struct ast_frame *f;
331
332         if (ast_strlen_zero(val))
333                 return;
334
335         goto_on_transfer = ast_strdupa(val);
336
337         if (!(xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, chan->name)))
338                 return;
339
340         for (x = goto_on_transfer; x && *x; x++) {
341                 if (*x == '^')
342                         *x = '|';
343         }
344         /* Make formats okay */
345         xferchan->readformat = chan->readformat;
346         xferchan->writeformat = chan->writeformat;
347         ast_channel_masquerade(xferchan, chan);
348         ast_parseable_goto(xferchan, goto_on_transfer);
349         xferchan->_state = AST_STATE_UP;
350         ast_clear_flag(xferchan, AST_FLAGS_ALL);        
351         xferchan->_softhangup = 0;
352         if ((f = ast_read(xferchan))) {
353                 ast_frfree(f);
354                 f = NULL;
355                 ast_pbx_start(xferchan);
356         } else {
357                 ast_hangup(xferchan);
358         }
359 }
360
361 static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *caller, struct ast_channel *transferee, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, int igncallerstate, const char *language);
362
363 /*!
364  * \brief bridge the call 
365  * \param data thread bridge.
366  *
367  * Set Last Data for respective channels, reset cdr for channels
368  * bridge call, check if we're going back to dialplan
369  * if not hangup both legs of the call
370 */
371 static void *ast_bridge_call_thread(void *data) 
372 {
373         struct ast_bridge_thread_obj *tobj = data;
374         int res;
375
376         tobj->chan->appl = !tobj->return_to_pbx ? "Transferred Call" : "ManagerBridge";
377         tobj->chan->data = tobj->peer->name;
378         tobj->peer->appl = !tobj->return_to_pbx ? "Transferred Call" : "ManagerBridge";
379         tobj->peer->data = tobj->chan->name;
380
381         ast_bridge_call(tobj->peer, tobj->chan, &tobj->bconfig);
382
383         if (tobj->return_to_pbx) {
384                 if (!ast_check_hangup(tobj->peer)) {
385                         ast_log(LOG_VERBOSE, "putting peer %s into PBX again\n", tobj->peer->name);
386                         res = ast_pbx_start(tobj->peer);
387                         if (res != AST_PBX_SUCCESS)
388                                 ast_log(LOG_WARNING, "FAILED continuing PBX on peer %s\n", tobj->peer->name);
389                 } else
390                         ast_hangup(tobj->peer);
391                 if (!ast_check_hangup(tobj->chan)) {
392                         ast_log(LOG_VERBOSE, "putting chan %s into PBX again\n", tobj->chan->name);
393                         res = ast_pbx_start(tobj->chan);
394                         if (res != AST_PBX_SUCCESS)
395                                 ast_log(LOG_WARNING, "FAILED continuing PBX on chan %s\n", tobj->chan->name);
396                 } else
397                         ast_hangup(tobj->chan);
398         } else {
399                 ast_hangup(tobj->chan);
400                 ast_hangup(tobj->peer);
401         }
402
403         ast_free(tobj);
404
405         return NULL;
406 }
407
408 /*!
409  * \brief create thread for the parked call
410  * \param data
411  *
412  * Create thread and attributes, call ast_bridge_call_thread
413 */
414 static void ast_bridge_call_thread_launch(void *data) 
415 {
416         pthread_t thread;
417         pthread_attr_t attr;
418         struct sched_param sched;
419
420         pthread_attr_init(&attr);
421         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
422         ast_pthread_create(&thread, &attr,ast_bridge_call_thread, data);
423         pthread_attr_destroy(&attr);
424         memset(&sched, 0, sizeof(sched));
425         pthread_setschedparam(thread, SCHED_RR, &sched);
426 }
427
428 /*!
429  * \brief Announce call parking by ADSI
430  * \param chan .
431  * \param parkingexten .
432  * Create message to show for ADSI, display message.
433  * \retval 0 on success.
434  * \retval -1 on failure.
435 */
436 static int adsi_announce_park(struct ast_channel *chan, char *parkingexten)
437 {
438         int res;
439         int justify[5] = {ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT};
440         char tmp[256];
441         char *message[5] = {NULL, NULL, NULL, NULL, NULL};
442
443         snprintf(tmp, sizeof(tmp), "Parked on %s", parkingexten);
444         message[0] = tmp;
445         res = ast_adsi_load_session(chan, NULL, 0, 1);
446         if (res == -1)
447                 return res;
448         return ast_adsi_print(chan, message, justify, 1);
449 }
450
451 /*! \brief Find parking lot name from channel */
452 static const char *findparkinglotname(struct ast_channel *chan)
453 {
454         const char *temp, *parkinglot = NULL;
455
456         /* Check if the channel has a parking lot */
457         if (!ast_strlen_zero(chan->parkinglot))
458                 parkinglot = chan->parkinglot;
459
460         /* Channel variables override everything */
461
462         if ((temp  = pbx_builtin_getvar_helper(chan, "PARKINGLOT")))
463                 return temp;
464
465         return parkinglot;
466 }
467
468 /*! \brief Notify metermaids that we've changed an extension */
469 static void notify_metermaids(const char *exten, char *context, enum ast_device_state state)
470 {
471         ast_debug(4, "Notification of state change to metermaids %s@%s\n to state '%s'", 
472                 exten, context, ast_devstate2str(state));
473
474         ast_devstate_changed(state, "park:%s@%s", exten, context);
475 }
476
477 /*! \brief metermaids callback from devicestate.c */
478 static enum ast_device_state metermaidstate(const char *data)
479 {
480         char *context;
481         char *exten;
482
483         context = ast_strdupa(data);
484
485         exten = strsep(&context, "@");
486         if (!context)
487                 return AST_DEVICE_INVALID;
488         
489         ast_debug(4, "Checking state of exten %s in context %s\n", exten, context);
490
491         if (!ast_exists_extension(NULL, context, exten, 1, NULL))
492                 return AST_DEVICE_NOT_INUSE;
493
494         return AST_DEVICE_INUSE;
495 }
496
497 /*! Options to pass to ast_park_call_full */
498 enum ast_park_call_options {
499         /*! Provide ringing to the parked caller instead of music on hold */
500         AST_PARK_OPT_RINGING =   (1 << 0),
501         /*! Randomly choose a parking spot for the caller instead of choosing
502          *  the first one that is available. */
503         AST_PARK_OPT_RANDOMIZE = (1 << 1),
504         /*! Do not announce the parking number */
505         AST_PARK_OPT_SILENCE = (1 << 2),
506 };
507
508 struct ast_park_call_args {
509         /*! How long to wait in the parking lot before the call gets sent back
510          *  to the specified return extension (or a best guess at where it came
511          *  from if not explicitly specified). */
512         int timeout;
513         /*! An output parameter to store the parking space where the parked caller
514          *  was placed. */
515         int *extout;
516         const char *orig_chan_name;
517         const char *return_con;
518         const char *return_ext;
519         int return_pri;
520         uint32_t flags;
521 };
522
523 /* Park a call */
524 static int ast_park_call_full(struct ast_channel *chan, struct ast_channel *peer, 
525         struct ast_park_call_args *args)
526 {
527         struct parkeduser *pu;
528         int i, x = -1, parking_range, parkingnum_copy;
529         struct ast_context *con;
530         const char *parkinglotname = NULL;
531         const char *parkingexten;
532         struct ast_parkinglot *parkinglot = NULL;
533         
534         if (peer)
535                 parkinglotname = findparkinglotname(peer);
536
537         if (parkinglotname) {
538                 if (option_debug)
539                         ast_log(LOG_DEBUG, "Found chanvar Parkinglot: %s\n", parkinglotname);
540                 parkinglot = find_parkinglot(parkinglotname);   
541         }
542         if (!parkinglot)
543                 parkinglot = default_parkinglot;
544
545         parkinglot_addref(parkinglot);
546         if (option_debug)
547                 ast_log(LOG_DEBUG, "Parkinglot: %s\n", parkinglot->name);
548
549         /* Allocate memory for parking data */
550         if (!(pu = ast_calloc(1, sizeof(*pu)))) {
551                 parkinglot_unref(parkinglot);
552                 return -1;
553         }
554
555         /* Lock parking list */
556         AST_LIST_LOCK(&parkinglot->parkings);
557         /* Check for channel variable PARKINGEXTEN */
558         parkingexten = pbx_builtin_getvar_helper(chan, "PARKINGEXTEN");
559         if (!ast_strlen_zero(parkingexten)) {
560                 /*!\note The API forces us to specify a numeric parking slot, even
561                  * though the architecture would tend to support non-numeric extensions
562                  * (as are possible with SIP, for example).  Hence, we enforce that
563                  * limitation here.  If extout was not numeric, we could permit
564                  * arbitrary non-numeric extensions.
565                  */
566         if (sscanf(parkingexten, "%d", &x) != 1 || x < 0) {
567                         AST_LIST_UNLOCK(&parkinglot->parkings);
568                         parkinglot_unref(parkinglot);
569             free(pu);
570             ast_log(LOG_WARNING, "PARKINGEXTEN does not indicate a valid parking slot: '%s'.\n", parkingexten);
571             return 1;   /* Continue execution if possible */
572         }
573         snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", x);
574
575                 if (ast_exists_extension(NULL, parkinglot->parking_con, pu->parkingexten, 1, NULL)) {
576                         AST_LIST_UNLOCK(&parkinglot->parkings);
577                         parkinglot_unref(parkinglot);
578                         ast_free(pu);
579                         ast_log(LOG_WARNING, "Requested parking extension already exists: %s@%s\n", parkingexten, parkinglot->parking_con);
580                         return 1;       /* Continue execution if possible */
581                 }
582         } else {
583                 int start;
584                 struct parkeduser *cur = NULL;
585
586                 /* Select parking space within range */
587                 parking_range = parkinglot->parking_stop - parkinglot->parking_start + 1;
588
589                 if (ast_test_flag(args, AST_PARK_OPT_RANDOMIZE)) {
590                         start = ast_random() % (parkinglot->parking_stop - parkinglot->parking_start + 1);
591                 } else {
592                         start = parkinglot->parking_start;
593                 }
594
595                 for (i = start; 1; i++) {
596                         if (i == parkinglot->parking_stop + 1) {
597                                 i = parkinglot->parking_start - 1;
598                                 continue;
599                         }
600
601                         AST_LIST_TRAVERSE(&parkinglot->parkings, cur, list) {
602                                 if (cur->parkingnum == i) {
603                                         break;
604                                 }
605                         }
606
607                         if (!cur || i == start - 1) {
608                                 x = i;
609                                 break;
610                         }
611                 }
612
613                 if (i == start - 1 && cur) {
614                         ast_log(LOG_WARNING, "No more parking spaces\n");
615                         ast_free(pu);
616                         AST_LIST_UNLOCK(&parkinglot->parkings);
617                         parkinglot_unref(parkinglot);
618                         return -1;
619                 }
620                 /* Set pointer for next parking */
621                 if (parkinglot->parkfindnext) 
622                         parkinglot->parking_offset = x - parkinglot->parking_start + 1;
623                 snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", x);
624         }
625         
626         chan->appl = "Parked Call";
627         chan->data = NULL; 
628
629         pu->chan = chan;
630         
631         /* Put the parked channel on hold if we have two different channels */
632         if (chan != peer) {
633                 if (ast_test_flag(args, AST_PARK_OPT_RINGING)) {
634                         ast_indicate(pu->chan, AST_CONTROL_RINGING);
635                 } else {
636                         ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
637                                 S_OR(parkinglot->mohclass, NULL),
638                                 !ast_strlen_zero(parkinglot->mohclass) ? strlen(parkinglot->mohclass) + 1 : 0);
639                 }
640         }
641         
642         pu->start = ast_tvnow();
643         pu->parkingnum = x;
644         pu->parkinglot = parkinglot;
645         pu->parkingtime = (args->timeout > 0) ? args->timeout : parkinglot->parkingtime;
646         parkingnum_copy = pu->parkingnum;
647         if (args->extout)
648                 *(args->extout) = x;
649
650         if (peer) 
651                 ast_copy_string(pu->peername, peer->name, sizeof(pu->peername));
652
653         /* Remember what had been dialed, so that if the parking
654            expires, we try to come back to the same place */
655         ast_copy_string(pu->context, 
656                 S_OR(args->return_con, S_OR(chan->macrocontext, chan->context)), 
657                 sizeof(pu->context));
658         ast_copy_string(pu->exten, 
659                 S_OR(args->return_ext, S_OR(chan->macroexten, chan->exten)), 
660                 sizeof(pu->exten));
661         pu->priority = pu->priority ? pu->priority : 
662                 (chan->macropriority ? chan->macropriority : chan->priority);
663
664         AST_LIST_INSERT_TAIL(&parkinglot->parkings, pu, list);
665
666         /* If parking a channel directly, don't quiet yet get parking running on it */
667         if (peer == chan) 
668                 pu->notquiteyet = 1;
669
670         /* Wake up the (presumably select()ing) thread */
671         pthread_kill(parking_thread, SIGURG);
672         ast_verb(2, "Parked %s on %d (lot %s). Will timeout back to extension [%s] %s, %d in %d seconds\n", pu->chan->name, pu->parkingnum, parkinglot->name, pu->context, pu->exten, pu->priority, (pu->parkingtime/1000));
673
674         manager_event(EVENT_FLAG_CALL, "ParkedCall",
675                 "Exten: %s\r\n"
676                 "Channel: %s\r\n"
677                 "Parkinglot: %s\r\n"
678                 "From: %s\r\n"
679                 "Timeout: %ld\r\n"
680                 "CallerIDNum: %s\r\n"
681                 "CallerIDName: %s\r\n"
682                 "Uniqueid: %s\r\n",
683                 pu->parkingexten, pu->chan->name, pu->parkinglot->name, peer ? peer->name : "",
684                 (long)pu->start.tv_sec + (long)(pu->parkingtime/1000) - (long)time(NULL),
685                 S_OR(pu->chan->cid.cid_num, "<unknown>"),
686                 S_OR(pu->chan->cid.cid_name, "<unknown>"),
687                 pu->chan->uniqueid
688                 );
689
690         if (peer && adsipark && ast_adsi_available(peer)) {
691                 adsi_announce_park(peer, pu->parkingexten);     /* Only supports parking numbers */
692                 ast_adsi_unload_session(peer);
693         }
694
695         con = ast_context_find_or_create(NULL, NULL, parkinglot->parking_con, registrar);
696         if (!con)       /* Still no context? Bad */
697                 ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parkinglot->parking_con);
698         if (con) {
699                 if (!ast_add_extension2(con, 1, pu->parkingexten, 1, NULL, NULL, parkedcall, ast_strdup(pu->parkingexten), ast_free_ptr, registrar))
700                         notify_metermaids(pu->parkingexten, parkinglot->parking_con, AST_DEVICE_INUSE);
701         }
702
703         AST_LIST_UNLOCK(&parkinglot->parkings);
704
705         /* Only say number if it's a number and the channel hasn't been masqueraded away */
706         if (peer && !ast_test_flag(args, AST_PARK_OPT_SILENCE) && (ast_strlen_zero(args->orig_chan_name) || !strcasecmp(peer->name, args->orig_chan_name))) {
707                 /* If a channel is masqueraded into peer while playing back the parking slot number do not continue playing it back. This is the case if an attended transfer occurs. */
708                 ast_set_flag(peer, AST_FLAG_MASQ_NOSTREAM);
709                 /* Tell the peer channel the number of the parking space */
710                 ast_say_digits(peer, pu->parkingnum, "", peer->language);
711                 ast_clear_flag(peer, AST_FLAG_MASQ_NOSTREAM);
712         }
713         if (peer == chan) { /* pu->notquiteyet = 1 */
714                 /* Wake up parking thread if we're really done */
715                 ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
716                         S_OR(parkinglot->mohclass, NULL),
717                         !ast_strlen_zero(parkinglot->mohclass) ? strlen(parkinglot->mohclass) + 1 : 0);
718                 pu->notquiteyet = 0;
719                 pthread_kill(parking_thread, SIGURG);
720         }
721         return 0;
722 }
723
724 /*! \brief Park a call */
725 int ast_park_call(struct ast_channel *chan, struct ast_channel *peer, int timeout, int *extout)
726 {
727         struct ast_park_call_args args = {
728                 .timeout = timeout,
729                 .extout = extout,
730         };
731
732         return ast_park_call_full(chan, peer, &args);
733 }
734
735 static int masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout, int play_announcement)
736 {
737         struct ast_channel *chan;
738         struct ast_frame *f;
739         char *orig_chan_name = NULL;
740         int park_status;
741
742         /* Make a new, fake channel that we'll use to masquerade in the real one */
743         if (!(chan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, rchan->accountcode, rchan->exten, rchan->context, rchan->amaflags, "Parked/%s",rchan->name))) {
744                 ast_log(LOG_WARNING, "Unable to create parked channel\n");
745                 return -1;
746         }
747
748         /* Make formats okay */
749         chan->readformat = rchan->readformat;
750         chan->writeformat = rchan->writeformat;
751         ast_channel_masquerade(chan, rchan);
752
753         /* Setup the extensions and such */
754         set_c_e_p(chan, rchan->context, rchan->exten, rchan->priority);
755
756         /* Make the masq execute */
757         if ((f = ast_read(chan)))
758                 ast_frfree(f);
759
760         if (!play_announcement) {
761                 orig_chan_name = ast_strdupa(chan->name);
762         }
763
764         {
765                 struct ast_park_call_args args = {
766                         .timeout = timeout,
767                         .extout = extout,
768                         .orig_chan_name = orig_chan_name,
769                 };
770
771                 park_status = ast_park_call_full(chan, peer, &args);
772                 if (park_status == 1) {
773                 /* would be nice to play "invalid parking extension" */
774                         ast_hangup(chan);
775                         return -1;
776                 }
777         }
778
779         return 0;
780 }
781
782 /* Park call via masquraded channel */
783 int ast_masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
784 {
785         return masq_park_call(rchan, peer, timeout, extout, 0);
786 }
787
788 static int masq_park_call_announce(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
789 {
790         return masq_park_call(rchan, peer, timeout, extout, 1);
791 }
792
793
794
795 #define FEATURE_SENSE_CHAN      (1 << 0)
796 #define FEATURE_SENSE_PEER      (1 << 1)
797
798 /*! 
799  * \brief set caller and callee according to the direction 
800  * \param caller, callee, peer, chan, sense
801  *
802  * Detect who triggered feature and set callee/caller variables accordingly
803 */
804 static void set_peers(struct ast_channel **caller, struct ast_channel **callee,
805         struct ast_channel *peer, struct ast_channel *chan, int sense)
806 {
807         if (sense == FEATURE_SENSE_PEER) {
808                 *caller = peer;
809                 *callee = chan;
810         } else {
811                 *callee = peer;
812                 *caller = chan;
813         }
814 }
815
816 /*! 
817  * \brief support routing for one touch call parking
818  * \param chan channel parking call
819  * \param peer channel to be parked
820  * \param config unsed
821  * \param code unused
822  * \param sense feature options
823  *
824  * \param data
825  * Setup channel, set return exten,priority to 's,1'
826  * answer chan, sleep chan, park call
827 */
828 static int builtin_parkcall(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
829 {
830         struct ast_channel *parker;
831         struct ast_channel *parkee;
832         int res = 0;
833
834         set_peers(&parker, &parkee, peer, chan, sense);
835         /* Setup the exten/priority to be s/1 since we don't know
836            where this call should return */
837         strcpy(chan->exten, "s");
838         chan->priority = 1;
839         if (chan->_state != AST_STATE_UP)
840                 res = ast_answer(chan);
841         if (!res)
842                 res = ast_safe_sleep(chan, 1000);
843
844         if (!res) {
845                 if (sense == FEATURE_SENSE_CHAN) {
846                         res = ast_park_call(parkee, parker, 0, NULL);
847                         if (!res) {
848                                 if (sense == FEATURE_SENSE_CHAN) {
849                                         res = AST_PBX_NO_HANGUP_PEER_PARKED;
850                                 } else {
851                                         res = AST_PBX_KEEPALIVE;
852                                 }
853                         }
854                 } else if (sense == FEATURE_SENSE_PEER) {
855                         masq_park_call_announce(parkee, parker, 0, NULL);
856                         res = 0; /* PBX should hangup zombie channel */
857                 }
858         }
859
860         return res;
861
862 }
863
864 /*! \brief Play message to both caller and callee in bridged call, plays synchronously, autoservicing the
865         other channel during the message, so please don't use this for very long messages
866  */
867 static int play_message_in_bridged_call(struct ast_channel *caller_chan, struct ast_channel *callee_chan, const char *audiofile)
868 {
869         /* First play for caller, put other channel on auto service */
870         if (ast_autoservice_start(callee_chan))
871                 return -1;
872         if (ast_stream_and_wait(caller_chan, audiofile, "")) {
873                 ast_log(LOG_WARNING, "Failed to play automon message!\n");
874                 ast_autoservice_stop(callee_chan);
875                 return -1;
876         }
877         if (ast_autoservice_stop(callee_chan))
878                 return -1;
879         /* Then play for callee, put other channel on auto service */
880         if (ast_autoservice_start(caller_chan))
881                 return -1;
882         if (ast_stream_and_wait(callee_chan, audiofile, "")) {
883                 ast_log(LOG_WARNING, "Failed to play automon message !\n");
884                 ast_autoservice_stop(caller_chan);
885                 return -1;
886         }
887         if (ast_autoservice_stop(caller_chan))
888                 return -1;
889         return(0);
890 }
891
892 /*!
893  * \brief Monitor a channel by DTMF
894  * \param chan channel requesting monitor
895  * \param peer channel to be monitored
896  * \param config
897  * \param code
898  * \param sense feature options
899  *
900  * \param data
901  * Check monitor app enabled, setup channels, both caller/callee chans not null
902  * get TOUCH_MONITOR variable for filename if exists, exec monitor app.
903  * \retval AST_FEATURE_RETURN_SUCCESS on success.
904  * \retval -1 on error.
905 */
906 static int builtin_automonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
907 {
908         char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
909         int x = 0;
910         size_t len;
911         struct ast_channel *caller_chan, *callee_chan;
912         const char *automon_message_start = NULL;
913         const char *automon_message_stop = NULL;
914
915         if (!monitor_ok) {
916                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
917                 return -1;
918         }
919
920         if (!monitor_app && !(monitor_app = pbx_findapp("Monitor"))) {
921                 monitor_ok = 0;
922                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
923                 return -1;
924         }
925
926         set_peers(&caller_chan, &callee_chan, peer, chan, sense);
927         if (caller_chan) {      /* Find extra messages */
928                 automon_message_start = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_START");
929                 automon_message_stop = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_STOP");
930         }
931
932         if (!ast_strlen_zero(courtesytone)) {   /* Play courtesy tone if configured */
933                 if(play_message_in_bridged_call(caller_chan, callee_chan, courtesytone) == -1) {
934                         return -1;
935                 }
936         }
937         
938         if (callee_chan->monitor) {
939                 ast_verb(4, "User hit '%s' to stop recording call.\n", code);
940                 if (!ast_strlen_zero(automon_message_stop)) {
941                         play_message_in_bridged_call(caller_chan, callee_chan, automon_message_stop);
942                 }
943                 callee_chan->monitor->stop(callee_chan, 1);
944                 return AST_FEATURE_RETURN_SUCCESS;
945         }
946
947         if (caller_chan && callee_chan) {
948                 const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_FORMAT");
949                 const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR");
950                 const char *touch_monitor_prefix = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_PREFIX");
951
952                 if (!touch_format)
953                         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_FORMAT");
954
955                 if (!touch_monitor)
956                         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR");
957         
958                 if (!touch_monitor_prefix)
959                         touch_monitor_prefix = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_PREFIX");
960         
961                 if (touch_monitor) {
962                         len = strlen(touch_monitor) + 50;
963                         args = alloca(len);
964                         touch_filename = alloca(len);
965                         snprintf(touch_filename, len, "%s-%ld-%s", S_OR(touch_monitor_prefix, "auto"), (long)time(NULL), touch_monitor);
966                         snprintf(args, len, "%s,%s,m", S_OR(touch_format, "wav"), touch_filename);
967                 } else {
968                         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
969                         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
970                         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
971                         args = alloca(len);
972                         touch_filename = alloca(len);
973                         snprintf(touch_filename, len, "%s-%ld-%s-%s", S_OR(touch_monitor_prefix, "auto"), (long)time(NULL), caller_chan_id, callee_chan_id);
974                         snprintf(args, len, "%s,%s,m", S_OR(touch_format, "wav"), touch_filename);
975                 }
976
977                 for(x = 0; x < strlen(args); x++) {
978                         if (args[x] == '/')
979                                 args[x] = '-';
980                 }
981                 
982                 ast_verb(4, "User hit '%s' to record call. filename: %s\n", code, args);
983
984                 pbx_exec(callee_chan, monitor_app, args);
985                 pbx_builtin_setvar_helper(callee_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
986                 pbx_builtin_setvar_helper(caller_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
987
988                 if (!ast_strlen_zero(automon_message_start)) {  /* Play start message for both channels */
989                         play_message_in_bridged_call(caller_chan, callee_chan, automon_message_start);
990                 }
991         
992                 return AST_FEATURE_RETURN_SUCCESS;
993         }
994         
995         ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");   
996         return -1;
997 }
998
999 static int builtin_automixmonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1000 {
1001         char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
1002         int x = 0;
1003         size_t len;
1004         struct ast_channel *caller_chan, *callee_chan;
1005         const char *mixmonitor_spy_type = "MixMonitor";
1006         int count = 0;
1007
1008         if (!mixmonitor_ok) {
1009                 ast_log(LOG_ERROR,"Cannot record the call. The mixmonitor application is disabled.\n");
1010                 return -1;
1011         }
1012
1013         if (!(mixmonitor_app = pbx_findapp("MixMonitor"))) {
1014                 mixmonitor_ok = 0;
1015                 ast_log(LOG_ERROR,"Cannot record the call. The mixmonitor application is disabled.\n");
1016                 return -1;
1017         }
1018
1019         set_peers(&caller_chan, &callee_chan, peer, chan, sense);
1020
1021         if (!ast_strlen_zero(courtesytone)) {
1022                 if (ast_autoservice_start(callee_chan))
1023                         return -1;
1024                 if (ast_stream_and_wait(caller_chan, courtesytone, "")) {
1025                         ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
1026                         ast_autoservice_stop(callee_chan);
1027                         return -1;
1028                 }
1029                 if (ast_autoservice_stop(callee_chan))
1030                         return -1;
1031         }
1032
1033         ast_channel_lock(callee_chan);
1034         count = ast_channel_audiohook_count_by_source(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
1035         ast_channel_unlock(callee_chan);
1036
1037         /* This means a mixmonitor is attached to the channel, running or not is unknown. */
1038         if (count > 0) {
1039                 
1040                 ast_verb(3, "User hit '%s' to stop recording call.\n", code);
1041
1042                 /* Make sure they are running */
1043                 ast_channel_lock(callee_chan);
1044                 count = ast_channel_audiohook_count_by_source_running(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
1045                 ast_channel_unlock(callee_chan);
1046                 if (count > 0) {
1047                         if (!stopmixmonitor_ok) {
1048                                 ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
1049                                 return -1;
1050                         }
1051                         if (!(stopmixmonitor_app = pbx_findapp("StopMixMonitor"))) {
1052                                 stopmixmonitor_ok = 0;
1053                                 ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
1054                                 return -1;
1055                         } else {
1056                                 pbx_exec(callee_chan, stopmixmonitor_app, "");
1057                                 return AST_FEATURE_RETURN_SUCCESS;
1058                         }
1059                 }
1060                 
1061                 ast_log(LOG_WARNING,"Stopped MixMonitors are attached to the channel.\n");      
1062         }                       
1063
1064         if (caller_chan && callee_chan) {
1065                 const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MIXMONITOR_FORMAT");
1066                 const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MIXMONITOR");
1067
1068                 if (!touch_format)
1069                         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MIXMONITOR_FORMAT");
1070
1071                 if (!touch_monitor)
1072                         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MIXMONITOR");
1073
1074                 if (touch_monitor) {
1075                         len = strlen(touch_monitor) + 50;
1076                         args = alloca(len);
1077                         touch_filename = alloca(len);
1078                         snprintf(touch_filename, len, "auto-%ld-%s", (long)time(NULL), touch_monitor);
1079                         snprintf(args, len, "%s.%s,b", touch_filename, (touch_format) ? touch_format : "wav");
1080                 } else {
1081                         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
1082                         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
1083                         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
1084                         args = alloca(len);
1085                         touch_filename = alloca(len);
1086                         snprintf(touch_filename, len, "auto-%ld-%s-%s", (long)time(NULL), caller_chan_id, callee_chan_id);
1087                         snprintf(args, len, "%s.%s,b", touch_filename, S_OR(touch_format, "wav"));
1088                 }
1089
1090                 for( x = 0; x < strlen(args); x++) {
1091                         if (args[x] == '/')
1092                                 args[x] = '-';
1093                 }
1094
1095                 ast_verb(3, "User hit '%s' to record call. filename: %s\n", code, touch_filename);
1096
1097                 pbx_exec(callee_chan, mixmonitor_app, args);
1098                 pbx_builtin_setvar_helper(callee_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
1099                 pbx_builtin_setvar_helper(caller_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
1100                 return AST_FEATURE_RETURN_SUCCESS;
1101         
1102         }
1103
1104         ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");
1105         return -1;
1106
1107 }
1108
1109 static int builtin_disconnect(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1110 {
1111         ast_verb(4, "User hit '%s' to disconnect call.\n", code);
1112         return AST_FEATURE_RETURN_HANGUP;
1113 }
1114
1115 static int finishup(struct ast_channel *chan)
1116 {
1117         ast_indicate(chan, AST_CONTROL_UNHOLD);
1118
1119         return ast_autoservice_stop(chan);
1120 }
1121
1122 /*!
1123  * \brief Find the context for the transfer
1124  * \param transferer
1125  * \param transferee
1126  * 
1127  * Grab the TRANSFER_CONTEXT, if fails try grabbing macrocontext.
1128  * \return a context string
1129 */
1130 static const char *real_ctx(struct ast_channel *transferer, struct ast_channel *transferee)
1131 {
1132         const char *s = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
1133         if (ast_strlen_zero(s)) {
1134                 s = pbx_builtin_getvar_helper(transferee, "TRANSFER_CONTEXT");
1135         }
1136         if (ast_strlen_zero(s)) { /* Use the non-macro context to transfer the call XXX ? */
1137                 s = transferer->macrocontext;
1138         }
1139         if (ast_strlen_zero(s)) {
1140                 s = transferer->context;
1141         }
1142         return s;  
1143 }
1144
1145 /*!
1146  * \brief Blind transfer user to another extension
1147  * \param chan channel to be transfered
1148  * \param peer channel initiated blind transfer
1149  * \param config
1150  * \param code
1151  * \param data
1152  * \param sense  feature options
1153  * 
1154  * Place chan on hold, check if transferred to parkinglot extension,
1155  * otherwise check extension exists and transfer caller.
1156  * \retval AST_FEATURE_RETURN_SUCCESS.
1157  * \retval -1 on failure.
1158 */
1159 static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1160 {
1161         struct ast_channel *transferer;
1162         struct ast_channel *transferee;
1163         const char *transferer_real_context;
1164         char xferto[256];
1165         int res;
1166
1167         set_peers(&transferer, &transferee, peer, chan, sense);
1168         transferer_real_context = real_ctx(transferer, transferee);
1169         /* Start autoservice on chan while we talk to the originator */
1170         ast_autoservice_start(transferee);
1171         ast_indicate(transferee, AST_CONTROL_HOLD);
1172
1173         memset(xferto, 0, sizeof(xferto));
1174         
1175         /* Transfer */
1176         res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
1177         if (res < 0) {
1178                 finishup(transferee);
1179                 return -1; /* error ? */
1180         }
1181         if (res > 0)    /* If they've typed a digit already, handle it */
1182                 xferto[0] = (char) res;
1183
1184         ast_stopstream(transferer);
1185         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
1186         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
1187                 finishup(transferee);
1188                 return res;
1189         }
1190         if (!strcmp(xferto, ast_parking_ext())) {
1191                 res = finishup(transferee);
1192                 if (res)
1193                         res = -1;
1194                 else if (!ast_park_call(transferee, transferer, 0, NULL)) {     /* success */
1195                         /* We return non-zero, but tell the PBX not to hang the channel when
1196                            the thread dies -- We have to be careful now though.  We are responsible for 
1197                            hanging up the channel, else it will never be hung up! */
1198
1199                         return (transferer == peer) ? AST_PBX_KEEPALIVE : AST_PBX_NO_HANGUP_PEER_PARKED;
1200                 } else {
1201                         ast_log(LOG_WARNING, "Unable to park call %s\n", transferee->name);
1202                 }
1203                 /*! \todo XXX Maybe we should have another message here instead of invalid extension XXX */
1204         } else if (ast_exists_extension(transferee, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
1205                 pbx_builtin_setvar_helper(transferer, "BLINDTRANSFER", transferee->name);
1206                 pbx_builtin_setvar_helper(transferee, "BLINDTRANSFER", transferer->name);
1207                 res=finishup(transferee);
1208                 if (!transferer->cdr) {
1209                         transferer->cdr=ast_cdr_alloc();
1210                         if (transferer) {
1211                                 ast_cdr_init(transferer->cdr, transferer); /* initilize our channel's cdr */
1212                                 ast_cdr_start(transferer->cdr);
1213                         }
1214                 }
1215                 if (transferer->cdr) {
1216                         ast_cdr_setdestchan(transferer->cdr, transferee->name);
1217                         ast_cdr_setapp(transferer->cdr, "BLINDTRANSFER","");
1218                 }
1219                 if (!transferee->pbx) {
1220                         /* Doh!  Use our handy async_goto functions */
1221                         ast_verb(3, "Transferring %s to '%s' (context %s) priority 1\n"
1222                                                                 ,transferee->name, xferto, transferer_real_context);
1223                         if (ast_async_goto(transferee, transferer_real_context, xferto, 1))
1224                                 ast_log(LOG_WARNING, "Async goto failed :-(\n");
1225                 } else {
1226                         /* Set the channel's new extension, since it exists, using transferer context */
1227                         set_c_e_p(transferee, transferer_real_context, xferto, 0);
1228                 }
1229                 check_goto_on_transfer(transferer);
1230                 return res;
1231         } else {
1232                 ast_verb(3, "Unable to find extension '%s' in context '%s'\n", xferto, transferer_real_context);
1233         }
1234         if (ast_stream_and_wait(transferer, xferfailsound, AST_DIGIT_ANY) < 0) {
1235                 finishup(transferee);
1236                 return -1;
1237         }
1238         ast_stopstream(transferer);
1239         res = finishup(transferee);
1240         if (res) {
1241                 ast_verb(2, "Hungup during autoservice stop on '%s'\n", transferee->name);
1242                 return res;
1243         }
1244         return AST_FEATURE_RETURN_SUCCESS;
1245 }
1246
1247 /*!
1248  * \brief make channels compatible
1249  * \param c
1250  * \param newchan
1251  * \retval 0 on success.
1252  * \retval -1 on failure.
1253 */
1254 static int check_compat(struct ast_channel *c, struct ast_channel *newchan)
1255 {
1256         if (ast_channel_make_compatible(c, newchan) < 0) {
1257                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n",
1258                         c->name, newchan->name);
1259                 ast_hangup(newchan);
1260                 return -1;
1261         }
1262         return 0;
1263 }
1264
1265 /*!
1266  * \brief Attended transfer
1267  * \param chan transfered user
1268  * \param peer person transfering call
1269  * \param config
1270  * \param code
1271  * \param sense feature options
1272  * 
1273  * \param data
1274  * Get extension to transfer to, if you cannot generate channel (or find extension) 
1275  * return to host channel. After called channel answered wait for hangup of transferer,
1276  * bridge call between transfer peer (taking them off hold) to attended transfer channel.
1277  *
1278  * \return -1 on failure
1279 */
1280 static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1281 {
1282         struct ast_channel *transferer;
1283         struct ast_channel *transferee;
1284         const char *transferer_real_context;
1285         char xferto[256] = "";
1286         int res;
1287         int outstate=0;
1288         struct ast_channel *newchan;
1289         struct ast_channel *xferchan;
1290         struct ast_bridge_thread_obj *tobj;
1291         struct ast_bridge_config bconfig;
1292         struct ast_frame *f;
1293         int l;
1294
1295         ast_debug(1, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense);
1296         set_peers(&transferer, &transferee, peer, chan, sense);
1297         transferer_real_context = real_ctx(transferer, transferee);
1298         /* Start autoservice on chan while we talk to the originator */
1299         ast_autoservice_start(transferee);
1300         ast_indicate(transferee, AST_CONTROL_HOLD);
1301         
1302         /* Transfer */
1303         res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
1304         if (res < 0) {
1305                 finishup(transferee);
1306                 return res;
1307         }
1308         if (res > 0) /* If they've typed a digit already, handle it */
1309                 xferto[0] = (char) res;
1310
1311         /* this is specific of atxfer */
1312         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
1313         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
1314                 finishup(transferee);
1315                 return res;
1316         }
1317         if (res == 0) {
1318                 ast_log(LOG_WARNING, "Did not read data.\n");
1319                 finishup(transferee);
1320                 if (ast_stream_and_wait(transferer, "beeperr", ""))
1321                         return -1;
1322                 return AST_FEATURE_RETURN_SUCCESS;
1323         }
1324
1325         /* valid extension, res == 1 */
1326         if (!ast_exists_extension(transferer, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
1327                 ast_log(LOG_WARNING, "Extension %s does not exist in context %s\n",xferto,transferer_real_context);
1328                 finishup(transferee);
1329                 if (ast_stream_and_wait(transferer, "beeperr", ""))
1330                         return -1;
1331                 return AST_FEATURE_RETURN_SUCCESS;
1332         }
1333
1334         l = strlen(xferto);
1335         snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context);     /* append context */
1336
1337         /* If we are performing an attended transfer and we have two channels involved then
1338            copy sound file information to play upon attended transfer completion */
1339         if (transferee) {
1340                 const char *chan1_attended_sound = pbx_builtin_getvar_helper(transferer, "ATTENDED_TRANSFER_COMPLETE_SOUND");
1341                 const char *chan2_attended_sound = pbx_builtin_getvar_helper(transferee, "ATTENDED_TRANSFER_COMPLETE_SOUND");
1342
1343                 if (!ast_strlen_zero(chan1_attended_sound)) {
1344                         pbx_builtin_setvar_helper(transferer, "BRIDGE_PLAY_SOUND", chan1_attended_sound);
1345                 }
1346                 if (!ast_strlen_zero(chan2_attended_sound)) {
1347                         pbx_builtin_setvar_helper(transferee, "BRIDGE_PLAY_SOUND", chan2_attended_sound);
1348                 }
1349         }
1350
1351         newchan = ast_feature_request_and_dial(transferer, transferee, "Local", ast_best_codec(transferer->nativeformats),
1352                 xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name, 1, transferer->language);
1353
1354         if (!ast_check_hangup(transferer)) {
1355                 /* Transferer is up - old behaviour */
1356                 ast_indicate(transferer, -1);
1357                 if (!newchan) {
1358                         finishup(transferee);
1359                         /* any reason besides user requested cancel and busy triggers the failed sound */
1360                         if (outstate != AST_CONTROL_UNHOLD && outstate != AST_CONTROL_BUSY &&
1361                                 ast_stream_and_wait(transferer, xferfailsound, ""))
1362                                 return -1;
1363                         if (ast_stream_and_wait(transferer, xfersound, ""))
1364                                 ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1365                         return AST_FEATURE_RETURN_SUCCESS;
1366                 }
1367
1368                 if (check_compat(transferer, newchan)) {
1369                         /* we do mean transferee here, NOT transferer */
1370                         finishup(transferee);
1371                         return -1;
1372                 }
1373                 memset(&bconfig,0,sizeof(struct ast_bridge_config));
1374                 ast_set_flag(&(bconfig.features_caller), AST_FEATURE_DISCONNECT);
1375                 ast_set_flag(&(bconfig.features_callee), AST_FEATURE_DISCONNECT);
1376                 res = ast_bridge_call(transferer, newchan, &bconfig);
1377                 if (ast_check_hangup(newchan) || !ast_check_hangup(transferer)) {
1378                         ast_hangup(newchan);
1379                         if (ast_stream_and_wait(transferer, xfersound, ""))
1380                                 ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1381                         finishup(transferee);
1382                         transferer->_softhangup = 0;
1383                         return AST_FEATURE_RETURN_SUCCESS;
1384                 }
1385                 if (check_compat(transferee, newchan)) {
1386                         finishup(transferee);
1387                         return -1;
1388                 }
1389                 ast_indicate(transferee, AST_CONTROL_UNHOLD);
1390
1391                 if ((ast_autoservice_stop(transferee) < 0)
1392                  || (ast_waitfordigit(transferee, 100) < 0)
1393                  || (ast_waitfordigit(newchan, 100) < 0)
1394                  || ast_check_hangup(transferee)
1395                  || ast_check_hangup(newchan)) {
1396                         ast_hangup(newchan);
1397                         return -1;
1398                 }
1399                 xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, "Transfered/%s", transferee->name);
1400                 if (!xferchan) {
1401                         ast_hangup(newchan);
1402                         return -1;
1403                 }
1404                 /* Make formats okay */
1405                 xferchan->visible_indication = transferer->visible_indication;
1406                 xferchan->readformat = transferee->readformat;
1407                 xferchan->writeformat = transferee->writeformat;
1408                 ast_channel_masquerade(xferchan, transferee);
1409                 ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority);
1410                 xferchan->_state = AST_STATE_UP;
1411                 ast_clear_flag(xferchan, AST_FLAGS_ALL);
1412                 xferchan->_softhangup = 0;
1413                 if ((f = ast_read(xferchan)))
1414                         ast_frfree(f);
1415                 newchan->_state = AST_STATE_UP;
1416                 ast_clear_flag(newchan, AST_FLAGS_ALL);
1417                 newchan->_softhangup = 0;
1418                 if (!(tobj = ast_calloc(1, sizeof(*tobj)))) {
1419                         ast_hangup(xferchan);
1420                         ast_hangup(newchan);
1421                         return -1;
1422                 }
1423                 tobj->chan = newchan;
1424                 tobj->peer = xferchan;
1425                 tobj->bconfig = *config;
1426
1427                 if (ast_stream_and_wait(newchan, xfersound, ""))
1428                         ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1429                 ast_bridge_call_thread_launch(tobj);
1430                 return -1;      /* XXX meaning the channel is bridged ? */
1431         } else if (!ast_check_hangup(transferee)) {
1432                 /* act as blind transfer */
1433                 if (ast_autoservice_stop(transferee) < 0) {
1434                         ast_hangup(newchan);
1435                         return -1;
1436                 }
1437
1438                 if (!newchan) {
1439                         unsigned int tries = 0;
1440                         char *transferer_tech, *transferer_name = ast_strdupa(transferer->name);
1441
1442                         transferer_tech = strsep(&transferer_name, "/");
1443                         transferer_name = strsep(&transferer_name, "-");
1444
1445                         if (ast_strlen_zero(transferer_name) || ast_strlen_zero(transferer_tech)) {
1446                                 ast_log(LOG_WARNING, "Transferer has invalid channel name: '%s'\n", transferer->name);
1447                                 if (ast_stream_and_wait(transferee, "beeperr", ""))
1448                                         return -1;
1449                                 return AST_FEATURE_RETURN_SUCCESS;
1450                         }
1451
1452                         ast_log(LOG_NOTICE, "We're trying to call %s/%s\n", transferer_tech, transferer_name);
1453                         newchan = ast_feature_request_and_dial(transferee, NULL, transferer_tech, ast_best_codec(transferee->nativeformats),
1454                                 transferer_name, atxfernoanswertimeout, &outstate, transferee->cid.cid_num, transferee->cid.cid_name, 0, transferer->language);
1455                         while (!newchan && !atxferdropcall && tries < atxfercallbackretries) {
1456                                 /* Trying to transfer again */
1457                                 ast_autoservice_start(transferee);
1458                                 ast_indicate(transferee, AST_CONTROL_HOLD);
1459
1460                                 newchan = ast_feature_request_and_dial(transferer, transferee, "Local", ast_best_codec(transferer->nativeformats),
1461                                         xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name, 1, transferer->language);
1462                                 if (ast_autoservice_stop(transferee) < 0) {
1463                                         if (newchan)
1464                                                 ast_hangup(newchan);
1465                                         return -1;
1466                                 }
1467                                 if (!newchan) {
1468                                         /* Transfer failed, sleeping */
1469                                         ast_debug(1, "Sleeping for %d ms before callback.\n", atxferloopdelay);
1470                                         ast_safe_sleep(transferee, atxferloopdelay);
1471                                         ast_debug(1, "Trying to callback...\n");
1472                                         newchan = ast_feature_request_and_dial(transferee, NULL, transferer_tech, ast_best_codec(transferee->nativeformats),
1473                                                 transferer_name, atxfernoanswertimeout, &outstate, transferee->cid.cid_num, transferee->cid.cid_name, 0, transferer->language);
1474                                 }
1475                                 tries++;
1476                         }
1477                 }
1478                 if (!newchan)
1479                         return -1;
1480
1481                 /* newchan is up, we should prepare transferee and bridge them */
1482                 if (check_compat(transferee, newchan)) {
1483                         finishup(transferee);
1484                         return -1;
1485                 }
1486                 ast_indicate(transferee, AST_CONTROL_UNHOLD);
1487
1488                 if ((ast_waitfordigit(transferee, 100) < 0)
1489                    || (ast_waitfordigit(newchan, 100) < 0)
1490                    || ast_check_hangup(transferee)
1491                    || ast_check_hangup(newchan)) {
1492                         ast_hangup(newchan);
1493                         return -1;
1494                 }
1495
1496                 xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, "Transfered/%s", transferee->name);
1497                 if (!xferchan) {
1498                         ast_hangup(newchan);
1499                         return -1;
1500                 }
1501                 /* Make formats okay */
1502                 xferchan->visible_indication = transferer->visible_indication;
1503                 xferchan->readformat = transferee->readformat;
1504                 xferchan->writeformat = transferee->writeformat;
1505                 ast_channel_masquerade(xferchan, transferee);
1506                 ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority);
1507                 xferchan->_state = AST_STATE_UP;
1508                 ast_clear_flag(xferchan, AST_FLAGS_ALL);
1509                 xferchan->_softhangup = 0;
1510                 if ((f = ast_read(xferchan)))
1511                         ast_frfree(f);
1512                 newchan->_state = AST_STATE_UP;
1513                 ast_clear_flag(newchan, AST_FLAGS_ALL);
1514                 newchan->_softhangup = 0;
1515                 if (!(tobj = ast_calloc(1, sizeof(*tobj)))) {
1516                         ast_hangup(xferchan);
1517                         ast_hangup(newchan);
1518                         return -1;
1519                 }
1520                 tobj->chan = newchan;
1521                 tobj->peer = xferchan;
1522                 tobj->bconfig = *config;
1523
1524                 if (ast_stream_and_wait(newchan, xfersound, ""))
1525                         ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1526                 ast_bridge_call_thread_launch(tobj);
1527                 return -1;      /* XXX meaning the channel is bridged ? */
1528         } else {
1529                 /* Transferee hung up */
1530                 finishup(transferee);
1531                 return -1;
1532         }
1533 }
1534
1535 /* add atxfer and automon as undefined so you can only use em if you configure them */
1536 #define FEATURES_COUNT ARRAY_LEN(builtin_features)
1537
1538 AST_RWLOCK_DEFINE_STATIC(features_lock);
1539
1540 static struct ast_call_feature builtin_features[] = 
1541 {
1542         { AST_FEATURE_REDIRECT, "Blind Transfer", "blindxfer", "#", "#", builtin_blindtransfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1543         { AST_FEATURE_REDIRECT, "Attended Transfer", "atxfer", "", "", builtin_atxfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1544         { AST_FEATURE_AUTOMON, "One Touch Monitor", "automon", "", "", builtin_automonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1545         { AST_FEATURE_DISCONNECT, "Disconnect Call", "disconnect", "*", "*", builtin_disconnect, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1546         { AST_FEATURE_PARKCALL, "Park Call", "parkcall", "", "", builtin_parkcall, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1547         { AST_FEATURE_AUTOMIXMON, "One Touch MixMonitor", "automixmon", "", "", builtin_automixmonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1548 };
1549
1550
1551 static AST_LIST_HEAD_STATIC(feature_list,ast_call_feature);
1552
1553 /*! \brief register new feature into feature_list*/
1554 void ast_register_feature(struct ast_call_feature *feature)
1555 {
1556         if (!feature) {
1557                 ast_log(LOG_NOTICE,"You didn't pass a feature!\n");
1558                 return;
1559         }
1560   
1561         AST_LIST_LOCK(&feature_list);
1562         AST_LIST_INSERT_HEAD(&feature_list,feature,feature_entry);
1563         AST_LIST_UNLOCK(&feature_list);
1564
1565         ast_verb(2, "Registered Feature '%s'\n",feature->sname);
1566 }
1567
1568 /*! 
1569  * \brief Add new feature group
1570  * \param fgname feature group name.
1571  *
1572  * Add new feature group to the feature group list insert at head of list.
1573  * \note This function MUST be called while feature_groups is locked.
1574 */
1575 static struct feature_group* register_group(const char *fgname)
1576 {
1577         struct feature_group *fg;
1578
1579         if (!fgname) {
1580                 ast_log(LOG_NOTICE, "You didn't pass a new group name!\n");
1581                 return NULL;
1582         }
1583
1584         if (!(fg = ast_calloc(1, sizeof(*fg))))
1585                 return NULL;
1586
1587         if (ast_string_field_init(fg, 128)) {
1588                 ast_free(fg);
1589                 return NULL;
1590         }
1591
1592         ast_string_field_set(fg, gname, fgname);
1593
1594         AST_LIST_INSERT_HEAD(&feature_groups, fg, entry);
1595
1596         ast_verb(2, "Registered group '%s'\n", fg->gname);
1597
1598         return fg;
1599 }
1600
1601 /*! 
1602  * \brief Add feature to group
1603  * \param fg feature group
1604  * \param exten
1605  * \param feature feature to add.
1606  *
1607  * Check fg and feature specified, add feature to list
1608  * \note This function MUST be called while feature_groups is locked. 
1609 */
1610 static void register_group_feature(struct feature_group *fg, const char *exten, struct ast_call_feature *feature) 
1611 {
1612         struct feature_group_exten *fge;
1613
1614         if (!fg) {
1615                 ast_log(LOG_NOTICE, "You didn't pass a group!\n");
1616                 return;
1617         }
1618
1619         if (!feature) {
1620                 ast_log(LOG_NOTICE, "You didn't pass a feature!\n");
1621                 return;
1622         }
1623
1624         if (!(fge = ast_calloc(1, sizeof(*fge))))
1625                 return;
1626
1627         if (ast_string_field_init(fge, 128)) {
1628                 ast_free(fge);
1629                 return;
1630         }
1631
1632         ast_string_field_set(fge, exten, S_OR(exten, feature->exten));
1633
1634         fge->feature = feature;
1635
1636         AST_LIST_INSERT_HEAD(&fg->features, fge, entry);                
1637
1638         ast_verb(2, "Registered feature '%s' for group '%s' at exten '%s'\n",
1639                                         feature->sname, fg->gname, exten);
1640 }
1641
1642 void ast_unregister_feature(struct ast_call_feature *feature)
1643 {
1644         if (!feature)
1645                 return;
1646
1647         AST_LIST_LOCK(&feature_list);
1648         AST_LIST_REMOVE(&feature_list,feature,feature_entry);
1649         AST_LIST_UNLOCK(&feature_list);
1650         ast_free(feature);
1651 }
1652
1653 /*! \brief Remove all features in the list */
1654 static void ast_unregister_features(void)
1655 {
1656         struct ast_call_feature *feature;
1657
1658         AST_LIST_LOCK(&feature_list);
1659         while ((feature = AST_LIST_REMOVE_HEAD(&feature_list,feature_entry)))
1660                 ast_free(feature);
1661         AST_LIST_UNLOCK(&feature_list);
1662 }
1663
1664 /*! \brief find a call feature by name */
1665 static struct ast_call_feature *find_dynamic_feature(const char *name)
1666 {
1667         struct ast_call_feature *tmp;
1668
1669         AST_LIST_TRAVERSE(&feature_list, tmp, feature_entry) {
1670                 if (!strcasecmp(tmp->sname, name))
1671                         break;
1672         }
1673
1674         return tmp;
1675 }
1676
1677 /*! \brief Remove all feature groups in the list */
1678 static void ast_unregister_groups(void)
1679 {
1680         struct feature_group *fg;
1681         struct feature_group_exten *fge;
1682
1683         AST_RWLIST_WRLOCK(&feature_groups);
1684         while ((fg = AST_LIST_REMOVE_HEAD(&feature_groups, entry))) {
1685                 while ((fge = AST_LIST_REMOVE_HEAD(&fg->features, entry))) {
1686                         ast_string_field_free_memory(fge);
1687                         ast_free(fge);
1688                 }
1689
1690                 ast_string_field_free_memory(fg);
1691                 ast_free(fg);
1692         }
1693         AST_RWLIST_UNLOCK(&feature_groups);
1694 }
1695
1696 /*! 
1697  * \brief Find a group by name 
1698  * \param name feature name
1699  * \retval feature group on success.
1700  * \retval NULL on failure.
1701 */
1702 static struct feature_group *find_group(const char *name) {
1703         struct feature_group *fg = NULL;
1704
1705         AST_LIST_TRAVERSE(&feature_groups, fg, entry) {
1706                 if (!strcasecmp(fg->gname, name))
1707                         break;
1708         }
1709
1710         return fg;
1711 }
1712
1713 void ast_rdlock_call_features(void)
1714 {
1715         ast_rwlock_rdlock(&features_lock);
1716 }
1717
1718 void ast_unlock_call_features(void)
1719 {
1720         ast_rwlock_unlock(&features_lock);
1721 }
1722
1723 struct ast_call_feature *ast_find_call_feature(const char *name)
1724 {
1725         int x;
1726         for (x = 0; x < FEATURES_COUNT; x++) {
1727                 if (!strcasecmp(name, builtin_features[x].sname))
1728                         return &builtin_features[x];
1729         }
1730         return NULL;
1731 }
1732
1733 /*!
1734  * \brief exec an app by feature 
1735  * \param chan,peer,config,code,sense,data
1736  *
1737  * Find a feature, determine which channel activated
1738  * \retval AST_FEATURE_RETURN_PBX_KEEPALIVE,AST_FEATURE_RETURN_NO_HANGUP_PEER
1739  * \retval -1 error.
1740  * \retval -2 when an application cannot be found.
1741 */
1742 static int feature_exec_app(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1743 {
1744         struct ast_app *app;
1745         struct ast_call_feature *feature = data;
1746         struct ast_channel *work, *idle;
1747         int res;
1748
1749         if (!feature) { /* shouldn't ever happen! */
1750                 ast_log(LOG_NOTICE, "Found feature before, but at execing we've lost it??\n");
1751                 return -1; 
1752         }
1753
1754         if (sense == FEATURE_SENSE_CHAN) {
1755                 if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER))
1756                         return AST_FEATURE_RETURN_KEEPTRYING;
1757                 if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
1758                         work = chan;
1759                         idle = peer;
1760                 } else {
1761                         work = peer;
1762                         idle = chan;
1763                 }
1764         } else {
1765                 if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE))
1766                         return AST_FEATURE_RETURN_KEEPTRYING;
1767                 if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
1768                         work = peer;
1769                         idle = chan;
1770                 } else {
1771                         work = chan;
1772                         idle = peer;
1773                 }
1774         }
1775
1776         if (!(app = pbx_findapp(feature->app))) {
1777                 ast_log(LOG_WARNING, "Could not find application (%s)\n", feature->app);
1778                 return -2;
1779         }
1780
1781         ast_autoservice_start(idle);
1782         
1783         if (!ast_strlen_zero(feature->moh_class))
1784                 ast_moh_start(idle, feature->moh_class, NULL);
1785
1786         res = pbx_exec(work, app, feature->app_args);
1787
1788         if (!ast_strlen_zero(feature->moh_class))
1789                 ast_moh_stop(idle);
1790
1791         ast_autoservice_stop(idle);
1792
1793         if (res == AST_PBX_KEEPALIVE) {
1794                 /* do not hangup peer if feature is to be activated on it */
1795                 if ((ast_test_flag(feature, AST_FEATURE_FLAG_ONPEER) && sense == FEATURE_SENSE_CHAN) || (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF) && sense == FEATURE_SENSE_PEER))
1796                         return AST_FEATURE_RETURN_NO_HANGUP_PEER;
1797                 else
1798                         return AST_FEATURE_RETURN_PBX_KEEPALIVE;
1799         }
1800         else if (res == AST_PBX_NO_HANGUP_PEER)
1801                 return AST_FEATURE_RETURN_NO_HANGUP_PEER;
1802         else if (res == AST_PBX_NO_HANGUP_PEER_PARKED)
1803                 return AST_FEATURE_RETURN_NO_HANGUP_PEER_PARKED;
1804         else if (res)
1805                 return AST_FEATURE_RETURN_SUCCESSBREAK;
1806         
1807         return AST_FEATURE_RETURN_SUCCESS;      /*! \todo XXX should probably return res */
1808 }
1809
1810 static void unmap_features(void)
1811 {
1812         int x;
1813
1814         ast_rwlock_wrlock(&features_lock);
1815         for (x = 0; x < FEATURES_COUNT; x++)
1816                 strcpy(builtin_features[x].exten, builtin_features[x].default_exten);
1817         ast_rwlock_unlock(&features_lock);
1818 }
1819
1820 static int remap_feature(const char *name, const char *value)
1821 {
1822         int x, res = -1;
1823
1824         ast_rwlock_wrlock(&features_lock);
1825         for (x = 0; x < FEATURES_COUNT; x++) {
1826                 if (strcasecmp(builtin_features[x].sname, name))
1827                         continue;
1828
1829                 ast_copy_string(builtin_features[x].exten, value, sizeof(builtin_features[x].exten));
1830                 res = 0;
1831                 break;
1832         }
1833         ast_rwlock_unlock(&features_lock);
1834
1835         return res;
1836 }
1837
1838 /*!
1839  * \brief Check the dynamic features
1840  * \param chan,peer,config,code,sense
1841  *
1842  * Lock features list, browse for code, unlock list
1843  * \retval res on success.
1844  * \retval -1 on failure.
1845 */
1846 static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
1847 {
1848         int x;
1849         struct ast_flags features;
1850         struct ast_call_feature *feature;
1851         struct feature_group *fg = NULL;
1852         struct feature_group_exten *fge;
1853         const char *dynamic_features;
1854         char *tmp, *tok;
1855         int res = AST_FEATURE_RETURN_PASSDIGITS;
1856         int feature_detected = 0;
1857
1858         if (sense == FEATURE_SENSE_CHAN) {
1859                 ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL);
1860                 dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");
1861         }
1862         else {
1863                 ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL);
1864                 dynamic_features = pbx_builtin_getvar_helper(peer, "DYNAMIC_FEATURES");
1865         }
1866         ast_debug(3, "Feature interpret: chan=%s, peer=%s, code=%s, sense=%d, features=%d, dynamic=%s\n", chan->name, peer->name, code, sense, features.flags, dynamic_features);
1867
1868         ast_rwlock_rdlock(&features_lock);
1869         for (x = 0; x < FEATURES_COUNT; x++) {
1870                 if ((ast_test_flag(&features, builtin_features[x].feature_mask)) &&
1871                     !ast_strlen_zero(builtin_features[x].exten)) {
1872                         /* Feature is up for consideration */
1873                         if (!strcmp(builtin_features[x].exten, code)) {
1874                                 res = builtin_features[x].operation(chan, peer, config, code, sense, NULL);
1875                                 feature_detected = 1;
1876                                 break;
1877                         } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) {
1878                                 if (res == AST_FEATURE_RETURN_PASSDIGITS)
1879                                         res = AST_FEATURE_RETURN_STOREDIGITS;
1880                         }
1881                 }
1882         }
1883         ast_rwlock_unlock(&features_lock);
1884
1885         if (ast_strlen_zero(dynamic_features) || feature_detected)
1886                 return res;
1887
1888         tmp = ast_strdupa(dynamic_features);
1889
1890         while ((tok = strsep(&tmp, "#"))) {
1891                 AST_RWLIST_RDLOCK(&feature_groups);
1892
1893                 fg = find_group(tok);
1894
1895                 if (fg) {
1896                         AST_LIST_TRAVERSE(&fg->features, fge, entry) {
1897                                 if (strcasecmp(fge->exten, code))
1898                                         continue;
1899
1900                                 res = fge->feature->operation(chan, peer, config, code, sense, fge->feature);
1901                                 if (res != AST_FEATURE_RETURN_KEEPTRYING) {
1902                                         AST_RWLIST_UNLOCK(&feature_groups);
1903                                         break;
1904                                 }
1905                                 res = AST_FEATURE_RETURN_PASSDIGITS;
1906                         }
1907                         if (fge)
1908                                 break;
1909                 }
1910
1911                 AST_RWLIST_UNLOCK(&feature_groups);
1912                 AST_LIST_LOCK(&feature_list);
1913
1914                 if(!(feature = find_dynamic_feature(tok))) {
1915                         AST_LIST_UNLOCK(&feature_list);
1916                         continue;
1917                 }
1918                         
1919                 /* Feature is up for consideration */
1920                 if (!strcmp(feature->exten, code)) {
1921                         ast_verb(3, " Feature Found: %s exten: %s\n",feature->sname, tok);
1922                         res = feature->operation(chan, peer, config, code, sense, feature);
1923                         if (res != AST_FEATURE_RETURN_KEEPTRYING) {
1924                                 AST_LIST_UNLOCK(&feature_list);
1925                                 break;
1926                         }
1927                         res = AST_FEATURE_RETURN_PASSDIGITS;
1928                 } else if (!strncmp(feature->exten, code, strlen(code)))
1929                         res = AST_FEATURE_RETURN_STOREDIGITS;
1930
1931                 AST_LIST_UNLOCK(&feature_list);
1932         }
1933         
1934         return res;
1935 }
1936
1937 static void set_config_flags(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config)
1938 {
1939         int x;
1940         
1941         ast_clear_flag(config, AST_FLAGS_ALL);
1942
1943         ast_rwlock_rdlock(&features_lock);
1944         for (x = 0; x < FEATURES_COUNT; x++) {
1945                 if (!ast_test_flag(builtin_features + x, AST_FEATURE_FLAG_NEEDSDTMF))
1946                         continue;
1947
1948                 if (ast_test_flag(&(config->features_caller), builtin_features[x].feature_mask))
1949                         ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
1950
1951                 if (ast_test_flag(&(config->features_callee), builtin_features[x].feature_mask))
1952                         ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
1953         }
1954         ast_rwlock_unlock(&features_lock);
1955         
1956         if (chan && peer && !(ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_0) && ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_1))) {
1957                 const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");
1958
1959                 if (dynamic_features) {
1960                         char *tmp = ast_strdupa(dynamic_features);
1961                         char *tok;
1962                         struct ast_call_feature *feature;
1963
1964                         /* while we have a feature */
1965                         while ((tok = strsep(&tmp, "#"))) {
1966                                 AST_LIST_LOCK(&feature_list);
1967                                 if ((feature = find_dynamic_feature(tok)) && ast_test_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF)) {
1968                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER))
1969                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
1970                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE))
1971                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
1972                                 }
1973                                 AST_LIST_UNLOCK(&feature_list);
1974                         }
1975                 }
1976         }
1977 }
1978
1979 /*! 
1980  * \brief Get feature and dial
1981  * \param caller,transferee,type,format,data,timeout,outstate,cid_num,cid_name,igncallerstate
1982  *
1983  * Request channel, set channel variables, initiate call,check if they want to disconnect
1984  * go into loop, check if timeout has elapsed, check if person to be transfered hung up,
1985  * check for answer break loop, set cdr return channel.
1986  *
1987  * \todo XXX Check - this is very similar to the code in channel.c 
1988  * \return always a channel
1989 */
1990 static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *caller, struct ast_channel *transferee, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, int igncallerstate, const char *language)
1991 {
1992         int state = 0;
1993         int cause = 0;
1994         int to;
1995         struct ast_channel *chan;
1996         struct ast_channel *monitor_chans[2];
1997         struct ast_channel *active_channel;
1998         int res = 0, ready = 0;
1999
2000         if ((chan = ast_request(type, format, data, &cause))) {
2001                 ast_set_callerid(chan, cid_num, cid_name, cid_num);
2002                 ast_string_field_set(chan, language, language);
2003                 ast_channel_inherit_variables(caller, chan);    
2004                 pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", caller->name);
2005                         
2006                 if (!ast_call(chan, data, timeout)) {
2007                         struct timeval started;
2008                         int x, len = 0;
2009                         char *disconnect_code = NULL, *dialed_code = NULL;
2010
2011                         ast_indicate(caller, AST_CONTROL_RINGING);
2012                         /* support dialing of the featuremap disconnect code while performing an attended tranfer */
2013                         ast_rwlock_rdlock(&features_lock);
2014                         for (x = 0; x < FEATURES_COUNT; x++) {
2015                                 if (strcasecmp(builtin_features[x].sname, "disconnect"))
2016                                         continue;
2017
2018                                 disconnect_code = builtin_features[x].exten;
2019                                 len = strlen(disconnect_code) + 1;
2020                                 dialed_code = alloca(len);
2021                                 memset(dialed_code, 0, len);
2022                                 break;
2023                         }
2024                         ast_rwlock_unlock(&features_lock);
2025                         x = 0;
2026                         started = ast_tvnow();
2027                         to = timeout;
2028
2029                         ast_poll_channel_add(caller, chan);
2030
2031                         while (!((transferee && ast_check_hangup(transferee)) && (!igncallerstate && ast_check_hangup(caller))) && timeout && (chan->_state != AST_STATE_UP)) {
2032                                 struct ast_frame *f = NULL;
2033
2034                                 monitor_chans[0] = caller;
2035                                 monitor_chans[1] = chan;
2036                                 active_channel = ast_waitfor_n(monitor_chans, 2, &to);
2037
2038                                 /* see if the timeout has been violated */
2039                                 if(ast_tvdiff_ms(ast_tvnow(), started) > timeout) {
2040                                         state = AST_CONTROL_UNHOLD;
2041                                         ast_log(LOG_NOTICE, "We exceeded our AT-timeout\n");
2042                                         break; /*doh! timeout*/
2043                                 }
2044
2045                                 if (!active_channel)
2046                                         continue;
2047
2048                                 if (chan && (chan == active_channel)){
2049                                         f = ast_read(chan);
2050                                         if (f == NULL) { /*doh! where'd he go?*/
2051                                                 state = AST_CONTROL_HANGUP;
2052                                                 res = 0;
2053                                                 break;
2054                                         }
2055                                         
2056                                         if (f->frametype == AST_FRAME_CONTROL || f->frametype == AST_FRAME_DTMF || f->frametype == AST_FRAME_TEXT) {
2057                                                 if (f->subclass == AST_CONTROL_RINGING) {
2058                                                         state = f->subclass;
2059                                                         ast_verb(3, "%s is ringing\n", chan->name);
2060                                                         ast_indicate(caller, AST_CONTROL_RINGING);
2061                                                 } else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) {
2062                                                         state = f->subclass;
2063                                                         ast_verb(3, "%s is busy\n", chan->name);
2064                                                         ast_indicate(caller, AST_CONTROL_BUSY);
2065                                                         ast_frfree(f);
2066                                                         f = NULL;
2067                                                         break;
2068                                                 } else if (f->subclass == AST_CONTROL_ANSWER) {
2069                                                         /* This is what we are hoping for */
2070                                                         state = f->subclass;
2071                                                         ast_frfree(f);
2072                                                         f = NULL;
2073                                                         ready=1;
2074                                                         break;
2075                                                 } else if (f->subclass != -1) {
2076                                                         ast_log(LOG_NOTICE, "Don't know what to do about control frame: %d\n", f->subclass);
2077                                                 }
2078                                                 /* else who cares */
2079                                         }
2080
2081                                 } else if (caller && (active_channel == caller)) {
2082                                         f = ast_read(caller);
2083                                         if (f == NULL) { /*doh! where'd he go?*/
2084                                                 if (!igncallerstate) {
2085                                                         if (ast_check_hangup(caller) && !ast_check_hangup(chan)) {
2086                                                                 /* make this a blind transfer */
2087                                                                 ready = 1;
2088                                                                 break;
2089                                                         }
2090                                                         state = AST_CONTROL_HANGUP;
2091                                                         res = 0;
2092                                                         break;
2093                                                 }
2094                                         } else {
2095                                         
2096                                                 if (f->frametype == AST_FRAME_DTMF) {
2097                                                         dialed_code[x++] = f->subclass;
2098                                                         dialed_code[x] = '\0';
2099                                                         if (strlen(dialed_code) == len) {
2100                                                                 x = 0;
2101                                                         } else if (x && strncmp(dialed_code, disconnect_code, x)) {
2102                                                                 x = 0;
2103                                                                 dialed_code[x] = '\0';
2104                                                         }
2105                                                         if (*dialed_code && !strcmp(dialed_code, disconnect_code)) {
2106                                                                 /* Caller Canceled the call */
2107                                                                 state = AST_CONTROL_UNHOLD;
2108                                                                 ast_frfree(f);
2109                                                                 f = NULL;
2110                                                                 break;
2111                                                         }
2112                                                 }
2113                                         }
2114                                 }
2115                                 if (f)
2116                                         ast_frfree(f);
2117                         } /* end while */
2118
2119                         ast_poll_channel_del(caller, chan);
2120
2121                 } else
2122                         ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2123         } else {
2124                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2125                 switch(cause) {
2126                 case AST_CAUSE_BUSY:
2127                         state = AST_CONTROL_BUSY;
2128                         break;
2129                 case AST_CAUSE_CONGESTION:
2130                         state = AST_CONTROL_CONGESTION;
2131                         break;
2132                 }
2133         }
2134         
2135         ast_indicate(caller, -1);
2136         if (chan && ready) {
2137                 if (chan->_state == AST_STATE_UP) 
2138                         state = AST_CONTROL_ANSWER;
2139                 res = 0;
2140         } else if(chan) {
2141                 res = -1;
2142                 ast_hangup(chan);
2143                 chan = NULL;
2144         } else {
2145                 res = -1;
2146         }
2147         
2148         if (outstate)
2149                 *outstate = state;
2150
2151         return chan;
2152 }
2153
2154 /*!
2155  * \brief return the first unlocked cdr in a possible chain
2156 */
2157 static struct ast_cdr *pick_unlocked_cdr(struct ast_cdr *cdr)
2158 {
2159         struct ast_cdr *cdr_orig = cdr;
2160         while (cdr) {
2161                 if (!ast_test_flag(cdr,AST_CDR_FLAG_LOCKED))
2162                         return cdr;
2163                 cdr = cdr->next;
2164         }
2165         return cdr_orig; /* everybody LOCKED or some other weirdness, like a NULL */
2166 }
2167
2168 /*!
2169  * \brief bridge the call and set CDR
2170  * \param chan,peer,config
2171  * 
2172  * Set start time, check for two channels,check if monitor on
2173  * check for feature activation, create new CDR
2174  * \retval res on success.
2175  * \retval -1 on failure to bridge.
2176 */
2177 int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast_bridge_config *config)
2178 {
2179         /* Copy voice back and forth between the two channels.  Give the peer
2180            the ability to transfer calls with '#<extension' syntax. */
2181         struct ast_frame *f;
2182         struct ast_channel *who;
2183         char chan_featurecode[FEATURE_MAX_LEN + 1]="";
2184         char peer_featurecode[FEATURE_MAX_LEN + 1]="";
2185         char orig_channame[AST_MAX_EXTENSION];
2186         char orig_peername[AST_MAX_EXTENSION];
2187         int res;
2188         int diff;
2189         int hasfeatures=0;
2190         int hadfeatures=0;
2191         int autoloopflag;
2192         struct ast_option_header *aoh;
2193         struct ast_bridge_config backup_config;
2194         struct ast_cdr *bridge_cdr = NULL;
2195         struct ast_cdr *orig_peer_cdr = NULL;
2196         struct ast_cdr *chan_cdr = pick_unlocked_cdr(chan->cdr); /* the proper chan cdr, if there are forked cdrs */
2197         struct ast_cdr *peer_cdr = pick_unlocked_cdr(peer->cdr); /* the proper chan cdr, if there are forked cdrs */
2198         struct ast_cdr *new_chan_cdr = NULL; /* the proper chan cdr, if there are forked cdrs */
2199         struct ast_cdr *new_peer_cdr = NULL; /* the proper chan cdr, if there are forked cdrs */
2200
2201         memset(&backup_config, 0, sizeof(backup_config));
2202
2203         config->start_time = ast_tvnow();
2204
2205         if (chan && peer) {
2206                 pbx_builtin_setvar_helper(chan, "BRIDGEPEER", peer->name);
2207                 pbx_builtin_setvar_helper(peer, "BRIDGEPEER", chan->name);
2208         } else if (chan)
2209                 pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", NULL);
2210
2211         if (monitor_ok) {
2212                 const char *monitor_exec;
2213                 struct ast_channel *src = NULL;
2214                 if (!monitor_app) { 
2215                         if (!(monitor_app = pbx_findapp("Monitor")))
2216                                 monitor_ok=0;
2217                 }
2218                 if ((monitor_exec = pbx_builtin_getvar_helper(chan, "AUTO_MONITOR"))) 
2219                         src = chan;
2220                 else if ((monitor_exec = pbx_builtin_getvar_helper(peer, "AUTO_MONITOR")))
2221                         src = peer;
2222                 if (monitor_app && src) {
2223                         char *tmp = ast_strdupa(monitor_exec);
2224                         pbx_exec(src, monitor_app, tmp);
2225                 }
2226         }
2227         
2228         set_config_flags(chan, peer, config);
2229         config->firstpass = 1;
2230
2231         /* Answer if need be */
2232         if (ast_answer(chan))
2233                 return -1;
2234
2235         ast_copy_string(orig_channame,chan->name,sizeof(orig_channame));
2236         ast_copy_string(orig_peername,peer->name,sizeof(orig_peername));
2237         orig_peer_cdr = peer_cdr;
2238         
2239         if (!chan_cdr || (chan_cdr && !ast_test_flag(chan_cdr, AST_CDR_FLAG_POST_DISABLED))) {
2240                 
2241                 if (chan_cdr) {
2242                         ast_set_flag(chan_cdr, AST_CDR_FLAG_MAIN);
2243                         ast_cdr_update(chan);
2244                         bridge_cdr = ast_cdr_dup(chan_cdr);
2245                         ast_copy_string(bridge_cdr->lastapp, chan->appl, sizeof(bridge_cdr->lastapp));
2246                         ast_copy_string(bridge_cdr->lastdata, chan->data, sizeof(bridge_cdr->lastdata));
2247                 } else {
2248                         /* better yet, in a xfer situation, find out why the chan cdr got zapped (pun unintentional) */
2249                         bridge_cdr = ast_cdr_alloc(); /* this should be really, really rare/impossible? */
2250                         ast_copy_string(bridge_cdr->channel, chan->name, sizeof(bridge_cdr->channel));
2251                         ast_copy_string(bridge_cdr->dstchannel, peer->name, sizeof(bridge_cdr->dstchannel));
2252                         ast_copy_string(bridge_cdr->uniqueid, chan->uniqueid, sizeof(bridge_cdr->uniqueid));
2253                         ast_copy_string(bridge_cdr->lastapp, chan->appl, sizeof(bridge_cdr->lastapp));
2254                         ast_copy_string(bridge_cdr->lastdata, chan->data, sizeof(bridge_cdr->lastdata));
2255                         ast_cdr_setcid(bridge_cdr, chan);
2256                         bridge_cdr->disposition = (chan->_state == AST_STATE_UP) ?  AST_CDR_ANSWERED : AST_CDR_NULL;
2257                         bridge_cdr->amaflags = chan->amaflags ? chan->amaflags :  ast_default_amaflags;
2258                         ast_copy_string(bridge_cdr->accountcode, chan->accountcode, sizeof(bridge_cdr->accountcode));
2259                         /* Destination information */
2260                         ast_copy_string(bridge_cdr->dst, chan->exten, sizeof(bridge_cdr->dst));
2261                         ast_copy_string(bridge_cdr->dcontext, chan->context, sizeof(bridge_cdr->dcontext));
2262                         if (peer_cdr) {
2263                                 bridge_cdr->start = peer_cdr->start;
2264                                 ast_copy_string(bridge_cdr->userfield, peer_cdr->userfield, sizeof(bridge_cdr->userfield));
2265                         } else {
2266                                 ast_cdr_start(bridge_cdr);
2267                         }
2268                 }
2269                 ast_debug(4,"bridge answer set, chan answer set\n");
2270                 /* peer_cdr->answer will be set when a macro runs on the peer;
2271                    in that case, the bridge answer will be delayed while the
2272                    macro plays on the peer channel. The peer answered the call
2273                    before the macro started playing. To the phone system,
2274                    this is billable time for the call, even tho the caller
2275                    hears nothing but ringing while the macro does its thing. */
2276                 if (peer_cdr && !ast_tvzero(peer_cdr->answer)) {
2277                         bridge_cdr->answer = peer_cdr->answer;
2278                         chan_cdr->answer = peer_cdr->answer;
2279                         bridge_cdr->disposition = peer_cdr->disposition;
2280                         chan_cdr->disposition = peer_cdr->disposition;
2281                 } else {
2282                         ast_cdr_answer(bridge_cdr);
2283                         ast_cdr_answer(chan_cdr); /* for the sake of cli status checks */
2284                 }
2285                 ast_set_flag(chan_cdr, AST_CDR_FLAG_BRIDGED);
2286                 if (peer_cdr) {
2287                         ast_set_flag(peer_cdr, AST_CDR_FLAG_BRIDGED);
2288                 }
2289         }
2290         for (;;) {
2291                 struct ast_channel *other;      /* used later */
2292                 
2293                 res = ast_channel_bridge(chan, peer, config, &f, &who);
2294
2295                 if (config->feature_timer) {
2296                         /* Update time limit for next pass */
2297                         diff = ast_tvdiff_ms(ast_tvnow(), config->start_time);
2298                         config->feature_timer -= diff;
2299                         if (hasfeatures) {
2300                                 /* Running on backup config, meaning a feature might be being
2301                                    activated, but that's no excuse to keep things going 
2302                                    indefinitely! */
2303                                 if (backup_config.feature_timer && ((backup_config.feature_timer -= diff) <= 0)) {
2304                                         ast_debug(1, "Timed out, realtime this time!\n");
2305                                         config->feature_timer = 0;
2306                                         who = chan;
2307                                         if (f)
2308                                                 ast_frfree(f);
2309                                         f = NULL;
2310                                         res = 0;
2311                                 } else if (config->feature_timer <= 0) {
2312                                         /* Not *really* out of time, just out of time for
2313                                            digits to come in for features. */
2314                                         ast_debug(1, "Timed out for feature!\n");
2315                                         if (!ast_strlen_zero(peer_featurecode)) {
2316                                                 ast_dtmf_stream(chan, peer, peer_featurecode, 0, 0);
2317                                                 memset(peer_featurecode, 0, sizeof(peer_featurecode));
2318                                         }
2319                                         if (!ast_strlen_zero(chan_featurecode)) {
2320                                                 ast_dtmf_stream(peer, chan, chan_featurecode, 0, 0);
2321                                                 memset(chan_featurecode, 0, sizeof(chan_featurecode));
2322                                         }
2323                                         if (f)
2324                                                 ast_frfree(f);
2325                                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
2326                                         if (!hasfeatures) {
2327                                                 /* Restore original (possibly time modified) bridge config */
2328                                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
2329                                                 memset(&backup_config, 0, sizeof(backup_config));
2330                                         }
2331                                         hadfeatures = hasfeatures;
2332                                         /* Continue as we were */
2333                                         continue;
2334                                 } else if (!f) {
2335                                         /* The bridge returned without a frame and there is a feature in progress.
2336                                          * However, we don't think the feature has quite yet timed out, so just
2337                                          * go back into the bridge. */
2338                                         continue;
2339                                 }
2340                         } else {
2341                                 if (config->feature_timer <=0) {
2342                                         /* We ran out of time */
2343                                         config->feature_timer = 0;
2344                                         who = chan;
2345                                         if (f)
2346                                                 ast_frfree(f);
2347                                         f = NULL;
2348                                         res = 0;
2349                                 }
2350                         }
2351                 }
2352                 if (res < 0) {
2353                         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_test_flag(peer, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan) && !ast_check_hangup(peer))
2354                                 ast_log(LOG_WARNING, "Bridge failed on channels %s and %s\n", chan->name, peer->name);
2355                         goto before_you_go;
2356                 }
2357                 
2358                 if (!f || (f->frametype == AST_FRAME_CONTROL &&
2359                                 (f->subclass == AST_CONTROL_HANGUP || f->subclass == AST_CONTROL_BUSY || 
2360                                         f->subclass == AST_CONTROL_CONGESTION))) {
2361                         res = -1;
2362                         break;
2363                 }
2364                 /* many things should be sent to the 'other' channel */
2365                 other = (who == chan) ? peer : chan;
2366                 if (f->frametype == AST_FRAME_CONTROL) {
2367                         switch (f->subclass) {
2368                         case AST_CONTROL_RINGING:
2369                         case AST_CONTROL_FLASH:
2370                         case -1:
2371                                 ast_indicate(other, f->subclass);
2372                                 break;
2373                         case AST_CONTROL_HOLD:
2374                         case AST_CONTROL_UNHOLD:
2375                                 ast_indicate_data(other, f->subclass, f->data.ptr, f->datalen);
2376                                 break;
2377                         case AST_CONTROL_OPTION:
2378                                 aoh = f->data.ptr;
2379                                 /* Forward option Requests */
2380                                 if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
2381                                         ast_channel_setoption(other, ntohs(aoh->option), aoh->data, 
2382                                                 f->datalen - sizeof(struct ast_option_header), 0);
2383                                 }
2384                                 break;
2385                         }
2386                 } else if (f->frametype == AST_FRAME_DTMF_BEGIN) {
2387                         /* eat it */
2388                 } else if (f->frametype == AST_FRAME_DTMF) {
2389                         char *featurecode;
2390                         int sense;
2391
2392                         hadfeatures = hasfeatures;
2393                         /* This cannot overrun because the longest feature is one shorter than our buffer */
2394                         if (who == chan) {
2395                                 sense = FEATURE_SENSE_CHAN;
2396                                 featurecode = chan_featurecode;
2397                         } else  {
2398                                 sense = FEATURE_SENSE_PEER;
2399                                 featurecode = peer_featurecode;
2400                         }
2401                         /*! append the event to featurecode. we rely on the string being zero-filled, and
2402                          * not overflowing it. 
2403                          * \todo XXX how do we guarantee the latter ?
2404                          */
2405                         featurecode[strlen(featurecode)] = f->subclass;
2406                         /* Get rid of the frame before we start doing "stuff" with the channels */
2407                         ast_frfree(f);
2408                         f = NULL;
2409                         config->feature_timer = backup_config.feature_timer;
2410                         res = ast_feature_interpret(chan, peer, config, featurecode, sense);
2411                         switch(res) {
2412                         case AST_FEATURE_RETURN_PASSDIGITS:
2413                                 ast_dtmf_stream(other, who, featurecode, 0, 0);
2414                                 /* Fall through */
2415                         case AST_FEATURE_RETURN_SUCCESS:
2416                                 memset(featurecode, 0, sizeof(chan_featurecode));
2417                                 break;
2418                         }
2419                         if (res >= AST_FEATURE_RETURN_PASSDIGITS) {
2420                                 res = 0;
2421                         } else 
2422                                 break;
2423                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
2424                         if (hadfeatures && !hasfeatures) {
2425                                 /* Restore backup */
2426                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
2427                                 memset(&backup_config, 0, sizeof(struct ast_bridge_config));
2428                         } else if (hasfeatures) {
2429                                 if (!hadfeatures) {
2430                                         /* Backup configuration */
2431                                         memcpy(&backup_config, config, sizeof(struct ast_bridge_config));
2432                                         /* Setup temporary config options */
2433                                         config->play_warning = 0;
2434                                         ast_clear_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
2435                                         ast_clear_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
2436                                         config->warning_freq = 0;
2437                                         config->warning_sound = NULL;
2438                                         config->end_sound = NULL;
2439                                         config->start_sound = NULL;
2440                                         config->firstpass = 0;
2441                                 }
2442                                 config->start_time = ast_tvnow();
2443                                 config->feature_timer = featuredigittimeout;
2444                                 ast_debug(1, "Set time limit to %ld\n", config->feature_timer);
2445                         }
2446                 }
2447                 if (f)
2448                         ast_frfree(f);
2449
2450         }
2451    before_you_go:
2452         if (res != AST_PBX_KEEPALIVE && config->end_bridge_callback) {
2453                 config->end_bridge_callback(config->end_bridge_callback_data);
2454         }
2455
2456         /* run the hangup exten on the chan object IFF it was NOT involved in a parking situation 
2457          * if it were, then chan belongs to a different thread now, and might have been hung up long
2458      * ago.
2459          */
2460         autoloopflag = ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP);
2461         ast_set_flag(chan, AST_FLAG_IN_AUTOLOOP);
2462         if (res != AST_PBX_KEEPALIVE && !ast_test_flag(&(config->features_caller),AST_FEATURE_NO_H_EXTEN) && ast_exists_extension(chan, chan->context, "h", 1, chan->cid.cid_num)) {
2463                 struct ast_cdr *swapper;
2464                 char savelastapp[AST_MAX_EXTENSION];
2465                 char savelastdata[AST_MAX_EXTENSION];
2466                 char save_exten[AST_MAX_EXTENSION];
2467                 int  save_prio;
2468                 int  found = 0; /* set if we find at least one match */
2469                 int  spawn_error = 0;
2470                 
2471                 if (ast_opt_end_cdr_before_h_exten) {
2472                         ast_cdr_end(bridge_cdr);
2473                 }
2474                 /* swap the bridge cdr and the chan cdr for a moment, and let the endbridge
2475                    dialplan code operate on it */
2476                 swapper = chan->cdr;
2477                 ast_copy_string(savelastapp, bridge_cdr->lastapp, sizeof(bridge_cdr->lastapp));
2478                 ast_copy_string(savelastdata, bridge_cdr->lastdata, sizeof(bridge_cdr->lastdata));
2479                 ast_channel_lock(chan);
2480                 chan->cdr = bridge_cdr;
2481                 ast_copy_string(save_exten, chan->exten, sizeof(save_exten));
2482                 save_prio = chan->priority;
2483                 ast_copy_string(chan->exten, "h", sizeof(chan->exten));
2484                 chan->priority = 1;
2485                 ast_channel_unlock(chan);
2486                 while ((spawn_error = ast_spawn_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num, &found, 1)) == 0) {
2487                         chan->priority++;
2488                 }
2489                 if (found && spawn_error) {
2490                         /* Something bad happened, or a hangup has been requested. */
2491                         ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", chan->context, chan->exten, chan->priority, chan->name);
2492                         ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", chan->context, chan->exten, chan->priority, chan->name);
2493                 }
2494                 /* swap it back */
2495                 ast_channel_lock(chan);
2496                 ast_copy_string(chan->exten, save_exten, sizeof(chan->exten));
2497                 chan->priority = save_prio;
2498                 chan->cdr = swapper;
2499                 ast_set_flag(chan, AST_FLAG_BRIDGE_HANGUP_RUN);
2500                 ast_channel_unlock(chan);
2501                 /* protect the lastapp/lastdata against the effects of the hangup/dialplan code */
2502                 ast_copy_string(bridge_cdr->lastapp, savelastapp, sizeof(bridge_cdr->lastapp));
2503                 ast_copy_string(bridge_cdr->lastdata, savelastdata, sizeof(bridge_cdr->lastdata));
2504         }
2505         ast_set2_flag(chan, autoloopflag, AST_FLAG_IN_AUTOLOOP);
2506
2507         /* obey the NoCDR() wishes. -- move the DISABLED flag to the bridge CDR if it was set on the channel during the bridge... */
2508         if (res != AST_PBX_KEEPALIVE) {
2509                 new_chan_cdr = pick_unlocked_cdr(chan->cdr); /* the proper chan cdr, if there are forked cdrs */
2510                 if (new_chan_cdr && ast_test_flag(new_chan_cdr, AST_CDR_FLAG_POST_DISABLED))
2511                         ast_set_flag(bridge_cdr, AST_CDR_FLAG_POST_DISABLED);
2512         }
2513
2514         /* we can post the bridge CDR at this point */
2515         ast_cdr_end(bridge_cdr);
2516         ast_cdr_detach(bridge_cdr);
2517         
2518         /* do a specialized reset on the beginning channel
2519            CDR's, if they still exist, so as not to mess up
2520            issues in future bridges;
2521            
2522            Here are the rules of the game:
2523            1. The chan and peer channel pointers will not change
2524               during the life of the bridge.
2525            2. But, in transfers, the channel names will change.
2526               between the time the bridge is started, and the
2527               time the channel ends. 
2528               Usually, when a channel changes names, it will
2529               also change CDR pointers.
2530            3. Usually, only one of the two channels (chan or peer)
2531               will change names.
2532            4. Usually, if a channel changes names during a bridge,
2533               it is because of a transfer. Usually, in these situations,
2534               it is normal to see 2 bridges running simultaneously, and
2535               it is not unusual to see the two channels that change
2536               swapped between bridges.
2537            5. After a bridge occurs, we have 2 or 3 channels' CDRs
2538               to attend to; if the chan or peer changed names,
2539               we have the before and after attached CDR's.
2540            6. Parking has to be accounted for in the code:
2541               a. Parking will cause ast_bridge_call to return
2542                  either AST_PBX_NO_HANGUP_PEER or AST_PBX_NO_HANGUP_PEER_PARKED;
2543                          in the latter case, peer is (most likely) a bad
2544                          pointer, you can no longer deref it. If it does still
2545                          exist, it is under another's thread control, and
2546                          could be destroyed at any time.
2547           b. The same applies to AST_PBX_KEEPALIVE, in which
2548                      case, the chan ptr cannot be used, as another thread
2549                          owns it and may have destroyed the channel.
2550               c. In the former case, you need to check peer to see if it 
2551                  still exists before you deref it, and obtain a lock.
2552               d. In neither case should you do an ast_hangup(peer).
2553                   e. Do not overwrite the result code from ast_bridge_call.
2554         */
2555         
2556         if (res != AST_PBX_KEEPALIVE && new_chan_cdr) {
2557                 struct ast_channel *chan_ptr = NULL;
2558  
2559                 if (strcasecmp(orig_channame, chan->name) != 0) { 
2560                         /* old channel */
2561                         chan_ptr = ast_get_channel_by_name_locked(orig_channame);
2562                         if (chan_ptr) {
2563                                 if (!ast_bridged_channel(chan_ptr)) {
2564                                         struct ast_cdr *cur;
2565                                         for (cur = chan_ptr->cdr; cur; cur = cur->next) {
2566                                                 if (cur == chan_cdr) {
2567                                                         break;
2568                                                 }
2569                                         }
2570                                         if (cur)
2571                                                 ast_cdr_specialized_reset(chan_cdr,0);
2572                                 }
2573                                 ast_channel_unlock(chan_ptr);
2574                         }
2575                         /* new channel */
2576                         ast_cdr_specialized_reset(new_chan_cdr,0);
2577                 } else {
2578                         ast_cdr_specialized_reset(chan_cdr,0); /* nothing changed, reset the chan_cdr  */
2579                 }
2580         }
2581         
2582         if (res != AST_PBX_NO_HANGUP_PEER_PARKED) { /* if the peer was involved in a park, don't even touch it; it's probably gone */
2583                 struct ast_channel *chan_ptr = NULL;
2584                 new_peer_cdr = pick_unlocked_cdr(peer->cdr); /* the proper chan cdr, if there are forked cdrs */
2585                 if (new_chan_cdr && ast_test_flag(new_chan_cdr, AST_CDR_FLAG_POST_DISABLED) && new_peer_cdr && !ast_test_flag(new_peer_cdr, AST_CDR_FLAG_POST_DISABLED))
2586                         ast_set_flag(new_peer_cdr, AST_CDR_FLAG_POST_DISABLED); /* DISABLED is viral-- it will propagate across a bridge */
2587                 if (strcasecmp(orig_peername, peer->name) != 0) { 
2588                         /* old channel */
2589                         chan_ptr = ast_get_channel_by_name_locked(orig_peername);
2590                         if (chan_ptr) {
2591                                 if (!ast_bridged_channel(chan_ptr)) {
2592                                         struct ast_cdr *cur;
2593                                         for (cur = chan_ptr->cdr; cur; cur = cur->next) {
2594                                                 if (cur == peer_cdr) {
2595                                                         break;
2596                                                 }
2597                                         }
2598                                         if (cur)
2599                                                 ast_cdr_specialized_reset(peer_cdr,0);
2600                                 }
2601                                 ast_channel_unlock(chan_ptr);
2602                         }
2603                         /* new channel */
2604                         ast_cdr_specialized_reset(new_peer_cdr,0);
2605                 } else {
2606                         ast_cdr_specialized_reset(peer_cdr,0); /* nothing changed, reset the peer_cdr  */
2607                 }
2608         }
2609         return res;
2610 }
2611
2612 /*! \brief Output parking event to manager */
2613 static void post_manager_event(const char *s, struct parkeduser *pu)
2614 {
2615         manager_event(EVENT_FLAG_CALL, s,
2616                 "Exten: %s\r\n"
2617                 "Channel: %s\r\n"
2618                 "Parkinglot: %s\r\n"
2619                 "CallerIDNum: %s\r\n"
2620                 "CallerIDName: %s\r\n"
2621                 "UniqueID: %s\r\n\r\n",
2622                 pu->parkingexten, 
2623                 pu->chan->name,
2624                 pu->parkinglot->name,
2625                 S_OR(pu->chan->cid.cid_num, "<unknown>"),
2626                 S_OR(pu->chan->cid.cid_name, "<unknown>"),
2627                 pu->chan->uniqueid
2628                 );
2629 }
2630
2631 /*! \brief Run management on parkinglots, called once per parkinglot */
2632 int manage_parkinglot(struct ast_parkinglot *curlot, fd_set *rfds, fd_set *efds, fd_set *nrfds, fd_set *nefds, int *ms, int *max)
2633 {
2634
2635         struct parkeduser *pu;
2636         int res = 0;
2637         char parkingslot[AST_MAX_EXTENSION];
2638
2639         /* Lock parking list */
2640         AST_LIST_LOCK(&curlot->parkings);
2641         AST_LIST_TRAVERSE_SAFE_BEGIN(&curlot->parkings, pu, list) {
2642                 struct ast_channel *chan = pu->chan;    /* shorthand */
2643                 int tms;        /* timeout for this item */
2644                 int x;          /* fd index in channel */
2645                 struct ast_context *con;
2646
2647                 if (pu->notquiteyet) { /* Pretend this one isn't here yet */
2648                         continue;
2649                 }
2650                 tms = ast_tvdiff_ms(ast_tvnow(), pu->start);
2651                 if (tms > pu->parkingtime) {
2652                         /* Stop music on hold */
2653                         ast_indicate(pu->chan, AST_CONTROL_UNHOLD);
2654                         /* Get chan, exten from derived kludge */
2655                         if (pu->peername[0]) {
2656                                 char *peername = ast_strdupa(pu->peername);
2657                                 char *cp = strrchr(peername, '-');
2658                                 char peername_flat[AST_MAX_EXTENSION]; /* using something like DAHDI/52 for an extension name is NOT a good idea */
2659                                 int i;
2660
2661                                 if (cp) 
2662                                         *cp = 0;
2663                                 ast_copy_string(peername_flat,peername,sizeof(peername_flat));
2664                                 for(i=0; peername_flat[i] && i < AST_MAX_EXTENSION; i++) {
2665                                         if (peername_flat[i] == '/') 
2666                                                 peername_flat[i]= '0';
2667                                 }
2668                                 con = ast_context_find_or_create(NULL, NULL, pu->parkinglot->parking_con_dial, registrar);
2669                                 if (!con) {
2670                                         ast_log(LOG_ERROR, "Parking dial context '%s' does not exist and unable to create\n", pu->parkinglot->parking_con_dial);
2671                                 }
2672                                 if (con) {
2673                                         char returnexten[AST_MAX_EXTENSION];
2674                                         struct ast_datastore *features_datastore;
2675                                         struct ast_dial_features *dialfeatures = NULL;
2676
2677                                         ast_channel_lock(chan);
2678
2679                                         if ((features_datastore = ast_channel_datastore_find(chan, &dial_features_info, NULL)))
2680                                                 dialfeatures = features_datastore->data;
2681
2682                                         ast_channel_unlock(chan);
2683
2684                                         if (dialfeatures)
2685                                                 snprintf(returnexten, sizeof(returnexten), "%s,,%s", peername, dialfeatures->options);
2686                                         else /* Existing default */
2687                                                 snprintf(returnexten, sizeof(returnexten), "%s,,t", peername);
2688
2689                                         ast_add_extension2(con, 1, peername_flat, 1, NULL, NULL, "Dial", ast_strdup(returnexten), ast_free_ptr, registrar);
2690                                 }
2691                                 if (comebacktoorigin) {
2692                                         set_c_e_p(chan, pu->parkinglot->parking_con_dial, peername_flat, 1);
2693                                 } else {
2694                                         ast_log(LOG_WARNING, "now going to parkedcallstimeout,s,1 | ps is %d\n",pu->parkingnum);
2695                                         snprintf(parkingslot, sizeof(parkingslot), "%d", pu->parkingnum);
2696                                         pbx_builtin_setvar_helper(chan, "PARKINGSLOT", parkingslot);
2697                                         set_c_e_p(chan, "parkedcallstimeout", peername_flat, 1);
2698                                 }
2699                         } else {
2700                                 /* They've been waiting too long, send them back to where they came.  Theoretically they
2701                                    should have their original extensions and such, but we copy to be on the safe side */
2702                                 set_c_e_p(chan, pu->context, pu->exten, pu->priority);
2703                         }
2704                         post_manager_event("ParkedCallTimeOut", pu);
2705
2706                         ast_verb(2, "Timeout for %s parked on %d (%s). Returning to %s,%s,%d\n", pu->chan->name, pu->parkingnum, pu->parkinglot->name, pu->chan->context, pu->chan->exten, pu->chan->priority);
2707                         /* Start up the PBX, or hang them up */
2708                         if (ast_pbx_start(chan))  {
2709                                 ast_log(LOG_WARNING, "Unable to restart the PBX for user on '%s', hanging them up...\n", pu->chan->name);
2710                                 ast_hangup(chan);
2711                         }
2712                         /* And take them out of the parking lot */
2713                         con = ast_context_find(pu->parkinglot->parking_con);
2714                         if (con) {
2715                                 if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL, 0))
2716                                         ast_log(LOG_WARNING, "Whoa, failed to remove the parking extension!\n");
2717                                 else
2718                                         notify_metermaids(pu->parkingexten, curlot->parking_con, AST_DEVICE_NOT_INUSE);
2719                         } else
2720                                 ast_log(LOG_WARNING, "Whoa, no parking context?\n");
2721                         AST_LIST_REMOVE_CURRENT(list);
2722                 } else {        /* still within parking time, process descriptors */
2723                         for (x = 0; x < AST_MAX_FDS; x++) {
2724                                 struct ast_frame *f;
2725
2726                                 if ((chan->fds[x] == -1) || (!FD_ISSET(chan->fds[x], rfds) && !FD_ISSET(pu->chan->fds[x], efds))) 
2727                                         continue;
2728                                 
2729                                 if (FD_ISSET(chan->fds[x], efds))
2730                                         ast_set_flag(chan, AST_FLAG_EXCEPTION);
2731                                 else
2732                                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2733                                 chan->fdno = x;
2734
2735                                 /* See if they need servicing */
2736                                 f = ast_read(pu->chan);
2737                                 /* Hangup? */
2738                                 if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass ==  AST_CONTROL_HANGUP))) {
2739                                         if (f)
2740                                                 ast_frfree(f);
2741                                         post_manager_event("ParkedCallGiveUp", pu);
2742
2743                                         /* There's a problem, hang them up*/
2744                                         ast_verb(2, "%s got tired of being parked\n", chan->name);
2745                                         ast_hangup(chan);
2746                                         /* And take them out of the parking lot */
2747                                         con = ast_context_find(curlot->parking_con);
2748                                         if (con) {
2749                                                 if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL, 0))
2750                                                         ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
2751                                                 else
2752                                                         notify_metermaids(pu->parkingexten, curlot->parking_con, AST_DEVICE_NOT_INUSE);
2753                                         } else
2754                                                 ast_log(LOG_WARNING, "Whoa, no parking context for parking lot %s?\n", curlot->name);
2755                                         AST_LIST_REMOVE_CURRENT(list);
2756                                         break;
2757                                 } else {
2758                                         /* XXX Maybe we could do something with packets, like dial "0" for operator or something XXX */
2759                                         ast_frfree(f);
2760                                         if (pu->moh_trys < 3 && !chan->generatordata) {
2761                                                 ast_debug(1, "MOH on parked call stopped by outside source.  Restarting on channel %s.\n", chan->name);
2762                                                 ast_indicate_data(chan, AST_CONTROL_HOLD, 
2763                                                         S_OR(curlot->mohclass, NULL),
2764                                                         (!ast_strlen_zero(curlot->mohclass) ? strlen(curlot->mohclass) + 1 : 0));
2765                                                 pu->moh_trys++;
2766                                         }
2767                                         goto std;       /* XXX Ick: jumping into an else statement??? XXX */
2768                                 }
2769                         } /* End for */
2770                         if (x >= AST_MAX_FDS) {
2771 std:                            for (x=0; x<AST_MAX_FDS; x++) { /* mark fds for next round */
2772                                         if (chan->fds[x] > -1) {
2773                                                 FD_SET(chan->fds[x], nrfds);
2774                                                 FD_SET(chan->fds[x], nefds);
2775                                                 if (chan->fds[x] > *max)
2776                                                         *max = chan->fds[x];
2777                                         }
2778                                 }
2779                                 /* Keep track of our shortest wait */
2780                                 if (tms < *ms || *ms < 0)
2781                                         *ms = tms;
2782                         }
2783                 }
2784         }
2785         AST_LIST_TRAVERSE_SAFE_END;
2786         AST_LIST_UNLOCK(&curlot->parkings);
2787         return res;
2788 }
2789
2790 /*! 
2791  * \brief Take care of parked calls and unpark them if needed 
2792  * \param ignore unused var.
2793  * 
2794  * Start inf loop, lock parking lot, check if any parked channels have gone above timeout
2795  * if so, remove channel from parking lot and return it to the extension that parked it.
2796  * Check if parked channel decided to hangup, wait until next FD via select().
2797 */
2798 static void *do_parking_thread(void *ignore)
2799 {
2800         fd_set rfds, efds;      /* results from previous select, to be preserved across loops. */
2801         fd_set nrfds, nefds;    /* args for the next select */
2802         FD_ZERO(&rfds);
2803         FD_ZERO(&efds);
2804
2805         for (;;) {
2806                 int res = 0;
2807                 int ms = -1;    /* select timeout, uninitialized */
2808                 int max = -1;   /* max fd, none there yet */
2809                 struct ao2_iterator iter;
2810                 struct ast_parkinglot *curlot;
2811                 FD_ZERO(&nrfds);
2812                 FD_ZERO(&nefds);
2813                 iter = ao2_iterator_init(parkinglots, 0);
2814
2815                 while ((curlot = ao2_iterator_next(&iter))) {
2816                         res = manage_parkinglot(curlot, &rfds, &efds, &nrfds, &nefds, &ms, &max);
2817                         ao2_ref(curlot, -1);
2818                 }
2819
2820                 rfds = nrfds;
2821                 efds = nefds;
2822                 {
2823                         struct timeval wait = ast_samp2tv(ms, 1000);
2824                         /* Wait for something to happen */
2825                         ast_select(max + 1, &rfds, NULL, &efds, (ms > -1) ? &wait : NULL);
2826                 }
2827                 pthread_testcancel();
2828         }
2829         return NULL;    /* Never reached */
2830 }
2831
2832 /*! \brief Find parkinglot by name */
2833 struct ast_parkinglot *find_parkinglot(const char *name)
2834 {
2835         struct ast_parkinglot *parkinglot = NULL;
2836         struct ast_parkinglot tmp_parkinglot;
2837         
2838         if (ast_strlen_zero(name))
2839                 return NULL;
2840
2841         ast_copy_string(tmp_parkinglot.name, name, sizeof(tmp_parkinglot.name));
2842
2843         parkinglot = ao2_find(parkinglots, &tmp_parkinglot, NULL, OBJ_POINTER);
2844
2845         if (parkinglot && option_debug)
2846                 ast_log(LOG_DEBUG, "Found Parkinglot: %s\n", parkinglot->name);
2847
2848         return parkinglot;
2849 }
2850
2851 AST_APP_OPTIONS(park_call_options, BEGIN_OPTIONS
2852         AST_APP_OPTION('r', AST_PARK_OPT_RINGING),
2853         AST_APP_OPTION('R', AST_PARK_OPT_RANDOMIZE),
2854         AST_APP_OPTION('s', AST_PARK_OPT_SILENCE),
2855 END_OPTIONS );
2856
2857 /*! \brief Park a call */
2858 static int park_call_exec(struct ast_channel *chan, void *data)
2859 {
2860         /* Cache the original channel name in case we get masqueraded in the middle
2861          * of a park--it is still theoretically possible for a transfer to happen before
2862          * we get here, but it is _really_ unlikely */
2863         char *orig_chan_name = ast_strdupa(chan->name);
2864         char orig_exten[AST_MAX_EXTENSION];
2865         int orig_priority = chan->priority;
2866
2867         /* Data is unused at the moment but could contain a parking
2868            lot context eventually */
2869         int res = 0;
2870
2871         char *parse = NULL;
2872         AST_DECLARE_APP_ARGS(app_args,
2873                 AST_APP_ARG(timeout);
2874                 AST_APP_ARG(return_con);
2875                 AST_APP_ARG(return_ext);
2876                 AST_APP_ARG(return_pri);
2877                 AST_APP_ARG(options);
2878         );
2879
2880         if (!ast_strlen_zero(data)) {
2881                 parse = ast_strdupa(data);
2882                 AST_STANDARD_APP_ARGS(app_args, parse);
2883         }
2884
2885         ast_copy_string(orig_exten, chan->exten, sizeof(orig_exten));
2886
2887         /* Setup the exten/priority to be s/1 since we don't know
2888            where this call should return */
2889         strcpy(chan->exten, "s");
2890         chan->priority = 1;
2891
2892         /* Answer if call is not up */
2893         if (chan->_state != AST_STATE_UP)
2894                 res = ast_answer(chan);
2895
2896         /* Sleep to allow VoIP streams to settle down */
2897         if (!res)
2898                 res = ast_safe_sleep(chan, 1000);
2899
2900         /* Park the call */
2901         if (!res) {
2902                 struct ast_park_call_args args = {
2903                         .orig_chan_name = orig_chan_name,
2904                 };
2905                 struct ast_flags flags = { 0 };
2906
2907                 if (parse) {
2908                         if (!ast_strlen_zero(app_args.timeout)) {
2909                                 if (sscanf(app_args.timeout, "%d", &args.timeout) != 1) {
2910                                         ast_log(LOG_WARNING, "Invalid timeout '%s' provided\n", app_args.timeout);
2911                                         args.timeout = 0;
2912                                 }
2913                         }
2914                         if (!ast_strlen_zero(app_args.return_con)) {
2915                                 args.return_con = app_args.return_con;
2916                         }
2917                         if (!ast_strlen_zero(app_args.return_ext)) {
2918                                 args.return_ext = app_args.return_ext;
2919                         }
2920                         if (!ast_strlen_zero(app_args.return_pri)) {
2921                                 if (sscanf(app_args.return_pri, "%d", &args.return_pri) != 1) {
2922                                         ast_log(LOG_WARNING, "Invalid priority '%s' specified\n", app_args.return_pri);
2923                                         args.return_pri = 0;
2924                                 }
2925                         }
2926                 }
2927
2928                 ast_app_parse_options(park_call_options, &flags, NULL, app_args.options);
2929                 args.flags = flags.flags;
2930
2931                 res = ast_park_call_full(chan, chan, &args);
2932                 /* Continue on in the dialplan */
2933                 if (res == 1) {
2934                         ast_copy_string(chan->exten, orig_exten, sizeof(chan->exten));
2935                         chan->priority = orig_priority;
2936                         res = 0;
2937                 } else if (!res)
2938                         res = AST_PBX_KEEPALIVE;
2939         }
2940
2941         return res;
2942 }
2943
2944 /*! \brief Pickup parked call */
2945 static int park_exec_full(struct ast_channel *chan, void *data, struct ast_parkinglot *parkinglot)
2946 {
2947         int res = 0;
2948         struct ast_channel *peer=NULL;
2949         struct parkeduser *pu;
2950         struct ast_context *con;
2951         int park = 0;
2952         struct ast_bridge_config config;
2953