e243e2c55dcc3394c17d1ce969e87abe00d405ac
[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, 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, "%s", 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         /* we used to set chan's exten and priority to "s" and 1
836            here, but this generates (in some cases) an invalid
837            extension, and if "s" exists, could errantly
838            cause execution of extensions you don't expect. It
839            makes more sense to let nature take its course
840            when chan finishes, and let the pbx do its thing
841            and hang up when the park is over.
842         */
843         if (chan->_state != AST_STATE_UP)
844                 res = ast_answer(chan);
845         if (!res)
846                 res = ast_safe_sleep(chan, 1000);
847
848         if (!res) { /* one direction used to call park_call.... */
849                 masq_park_call_announce(parkee, parker, 0, NULL);
850                 res = 0; /* PBX should hangup zombie channel */
851         }
852
853         return res;
854
855 }
856
857 /*! \brief Play message to both caller and callee in bridged call, plays synchronously, autoservicing the
858         other channel during the message, so please don't use this for very long messages
859  */
860 static int play_message_in_bridged_call(struct ast_channel *caller_chan, struct ast_channel *callee_chan, const char *audiofile)
861 {
862         /* First play for caller, put other channel on auto service */
863         if (ast_autoservice_start(callee_chan))
864                 return -1;
865         if (ast_stream_and_wait(caller_chan, audiofile, "")) {
866                 ast_log(LOG_WARNING, "Failed to play automon message!\n");
867                 ast_autoservice_stop(callee_chan);
868                 return -1;
869         }
870         if (ast_autoservice_stop(callee_chan))
871                 return -1;
872         /* Then play for callee, put other channel on auto service */
873         if (ast_autoservice_start(caller_chan))
874                 return -1;
875         if (ast_stream_and_wait(callee_chan, audiofile, "")) {
876                 ast_log(LOG_WARNING, "Failed to play automon message !\n");
877                 ast_autoservice_stop(caller_chan);
878                 return -1;
879         }
880         if (ast_autoservice_stop(caller_chan))
881                 return -1;
882         return(0);
883 }
884
885 /*!
886  * \brief Monitor a channel by DTMF
887  * \param chan channel requesting monitor
888  * \param peer channel to be monitored
889  * \param config
890  * \param code
891  * \param sense feature options
892  *
893  * \param data
894  * Check monitor app enabled, setup channels, both caller/callee chans not null
895  * get TOUCH_MONITOR variable for filename if exists, exec monitor app.
896  * \retval AST_FEATURE_RETURN_SUCCESS on success.
897  * \retval -1 on error.
898 */
899 static int builtin_automonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
900 {
901         char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
902         int x = 0;
903         size_t len;
904         struct ast_channel *caller_chan, *callee_chan;
905         const char *automon_message_start = NULL;
906         const char *automon_message_stop = NULL;
907
908         if (!monitor_ok) {
909                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
910                 return -1;
911         }
912
913         if (!monitor_app && !(monitor_app = pbx_findapp("Monitor"))) {
914                 monitor_ok = 0;
915                 ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
916                 return -1;
917         }
918
919         set_peers(&caller_chan, &callee_chan, peer, chan, sense);
920         if (caller_chan) {      /* Find extra messages */
921                 automon_message_start = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_START");
922                 automon_message_stop = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_STOP");
923         }
924
925         if (!ast_strlen_zero(courtesytone)) {   /* Play courtesy tone if configured */
926                 if(play_message_in_bridged_call(caller_chan, callee_chan, courtesytone) == -1) {
927                         return -1;
928                 }
929         }
930         
931         if (callee_chan->monitor) {
932                 ast_verb(4, "User hit '%s' to stop recording call.\n", code);
933                 if (!ast_strlen_zero(automon_message_stop)) {
934                         play_message_in_bridged_call(caller_chan, callee_chan, automon_message_stop);
935                 }
936                 callee_chan->monitor->stop(callee_chan, 1);
937                 return AST_FEATURE_RETURN_SUCCESS;
938         }
939
940         if (caller_chan && callee_chan) {
941                 const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_FORMAT");
942                 const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR");
943                 const char *touch_monitor_prefix = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_PREFIX");
944
945                 if (!touch_format)
946                         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_FORMAT");
947
948                 if (!touch_monitor)
949                         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR");
950         
951                 if (!touch_monitor_prefix)
952                         touch_monitor_prefix = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_PREFIX");
953         
954                 if (touch_monitor) {
955                         len = strlen(touch_monitor) + 50;
956                         args = alloca(len);
957                         touch_filename = alloca(len);
958                         snprintf(touch_filename, len, "%s-%ld-%s", S_OR(touch_monitor_prefix, "auto"), (long)time(NULL), touch_monitor);
959                         snprintf(args, len, "%s,%s,m", S_OR(touch_format, "wav"), touch_filename);
960                 } else {
961                         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
962                         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
963                         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
964                         args = alloca(len);
965                         touch_filename = alloca(len);
966                         snprintf(touch_filename, len, "%s-%ld-%s-%s", S_OR(touch_monitor_prefix, "auto"), (long)time(NULL), caller_chan_id, callee_chan_id);
967                         snprintf(args, len, "%s,%s,m", S_OR(touch_format, "wav"), touch_filename);
968                 }
969
970                 for(x = 0; x < strlen(args); x++) {
971                         if (args[x] == '/')
972                                 args[x] = '-';
973                 }
974                 
975                 ast_verb(4, "User hit '%s' to record call. filename: %s\n", code, args);
976
977                 pbx_exec(callee_chan, monitor_app, args);
978                 pbx_builtin_setvar_helper(callee_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
979                 pbx_builtin_setvar_helper(caller_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
980
981                 if (!ast_strlen_zero(automon_message_start)) {  /* Play start message for both channels */
982                         play_message_in_bridged_call(caller_chan, callee_chan, automon_message_start);
983                 }
984         
985                 return AST_FEATURE_RETURN_SUCCESS;
986         }
987         
988         ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");   
989         return -1;
990 }
991
992 static int builtin_automixmonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
993 {
994         char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
995         int x = 0;
996         size_t len;
997         struct ast_channel *caller_chan, *callee_chan;
998         const char *mixmonitor_spy_type = "MixMonitor";
999         int count = 0;
1000
1001         if (!mixmonitor_ok) {
1002                 ast_log(LOG_ERROR,"Cannot record the call. The mixmonitor application is disabled.\n");
1003                 return -1;
1004         }
1005
1006         if (!(mixmonitor_app = pbx_findapp("MixMonitor"))) {
1007                 mixmonitor_ok = 0;
1008                 ast_log(LOG_ERROR,"Cannot record the call. The mixmonitor application is disabled.\n");
1009                 return -1;
1010         }
1011
1012         set_peers(&caller_chan, &callee_chan, peer, chan, sense);
1013
1014         if (!ast_strlen_zero(courtesytone)) {
1015                 if (ast_autoservice_start(callee_chan))
1016                         return -1;
1017                 if (ast_stream_and_wait(caller_chan, courtesytone, "")) {
1018                         ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
1019                         ast_autoservice_stop(callee_chan);
1020                         return -1;
1021                 }
1022                 if (ast_autoservice_stop(callee_chan))
1023                         return -1;
1024         }
1025
1026         ast_channel_lock(callee_chan);
1027         count = ast_channel_audiohook_count_by_source(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
1028         ast_channel_unlock(callee_chan);
1029
1030         /* This means a mixmonitor is attached to the channel, running or not is unknown. */
1031         if (count > 0) {
1032                 
1033                 ast_verb(3, "User hit '%s' to stop recording call.\n", code);
1034
1035                 /* Make sure they are running */
1036                 ast_channel_lock(callee_chan);
1037                 count = ast_channel_audiohook_count_by_source_running(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
1038                 ast_channel_unlock(callee_chan);
1039                 if (count > 0) {
1040                         if (!stopmixmonitor_ok) {
1041                                 ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
1042                                 return -1;
1043                         }
1044                         if (!(stopmixmonitor_app = pbx_findapp("StopMixMonitor"))) {
1045                                 stopmixmonitor_ok = 0;
1046                                 ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
1047                                 return -1;
1048                         } else {
1049                                 pbx_exec(callee_chan, stopmixmonitor_app, "");
1050                                 return AST_FEATURE_RETURN_SUCCESS;
1051                         }
1052                 }
1053                 
1054                 ast_log(LOG_WARNING,"Stopped MixMonitors are attached to the channel.\n");      
1055         }                       
1056
1057         if (caller_chan && callee_chan) {
1058                 const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MIXMONITOR_FORMAT");
1059                 const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MIXMONITOR");
1060
1061                 if (!touch_format)
1062                         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MIXMONITOR_FORMAT");
1063
1064                 if (!touch_monitor)
1065                         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MIXMONITOR");
1066
1067                 if (touch_monitor) {
1068                         len = strlen(touch_monitor) + 50;
1069                         args = alloca(len);
1070                         touch_filename = alloca(len);
1071                         snprintf(touch_filename, len, "auto-%ld-%s", (long)time(NULL), touch_monitor);
1072                         snprintf(args, len, "%s.%s,b", touch_filename, (touch_format) ? touch_format : "wav");
1073                 } else {
1074                         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
1075                         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
1076                         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
1077                         args = alloca(len);
1078                         touch_filename = alloca(len);
1079                         snprintf(touch_filename, len, "auto-%ld-%s-%s", (long)time(NULL), caller_chan_id, callee_chan_id);
1080                         snprintf(args, len, "%s.%s,b", touch_filename, S_OR(touch_format, "wav"));
1081                 }
1082
1083                 for( x = 0; x < strlen(args); x++) {
1084                         if (args[x] == '/')
1085                                 args[x] = '-';
1086                 }
1087
1088                 ast_verb(3, "User hit '%s' to record call. filename: %s\n", code, touch_filename);
1089
1090                 pbx_exec(callee_chan, mixmonitor_app, args);
1091                 pbx_builtin_setvar_helper(callee_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
1092                 pbx_builtin_setvar_helper(caller_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
1093                 return AST_FEATURE_RETURN_SUCCESS;
1094         
1095         }
1096
1097         ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");
1098         return -1;
1099
1100 }
1101
1102 static int builtin_disconnect(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1103 {
1104         ast_verb(4, "User hit '%s' to disconnect call.\n", code);
1105         return AST_FEATURE_RETURN_HANGUP;
1106 }
1107
1108 static int finishup(struct ast_channel *chan)
1109 {
1110         ast_indicate(chan, AST_CONTROL_UNHOLD);
1111
1112         return ast_autoservice_stop(chan);
1113 }
1114
1115 /*!
1116  * \brief Find the context for the transfer
1117  * \param transferer
1118  * \param transferee
1119  * 
1120  * Grab the TRANSFER_CONTEXT, if fails try grabbing macrocontext.
1121  * \return a context string
1122 */
1123 static const char *real_ctx(struct ast_channel *transferer, struct ast_channel *transferee)
1124 {
1125         const char *s = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
1126         if (ast_strlen_zero(s)) {
1127                 s = pbx_builtin_getvar_helper(transferee, "TRANSFER_CONTEXT");
1128         }
1129         if (ast_strlen_zero(s)) { /* Use the non-macro context to transfer the call XXX ? */
1130                 s = transferer->macrocontext;
1131         }
1132         if (ast_strlen_zero(s)) {
1133                 s = transferer->context;
1134         }
1135         return s;  
1136 }
1137
1138 /*!
1139  * \brief Blind transfer user to another extension
1140  * \param chan channel to be transfered
1141  * \param peer channel initiated blind transfer
1142  * \param config
1143  * \param code
1144  * \param data
1145  * \param sense  feature options
1146  * 
1147  * Place chan on hold, check if transferred to parkinglot extension,
1148  * otherwise check extension exists and transfer caller.
1149  * \retval AST_FEATURE_RETURN_SUCCESS.
1150  * \retval -1 on failure.
1151 */
1152 static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1153 {
1154         struct ast_channel *transferer;
1155         struct ast_channel *transferee;
1156         const char *transferer_real_context;
1157         char xferto[256];
1158         int res;
1159
1160         set_peers(&transferer, &transferee, peer, chan, sense);
1161         transferer_real_context = real_ctx(transferer, transferee);
1162         /* Start autoservice on chan while we talk to the originator */
1163         ast_autoservice_start(transferee);
1164         ast_indicate(transferee, AST_CONTROL_HOLD);
1165
1166         memset(xferto, 0, sizeof(xferto));
1167         
1168         /* Transfer */
1169         res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
1170         if (res < 0) {
1171                 finishup(transferee);
1172                 return -1; /* error ? */
1173         }
1174         if (res > 0)    /* If they've typed a digit already, handle it */
1175                 xferto[0] = (char) res;
1176
1177         ast_stopstream(transferer);
1178         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
1179         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
1180                 finishup(transferee);
1181                 return res;
1182         }
1183         if (!strcmp(xferto, ast_parking_ext())) {
1184                 res = finishup(transferee);
1185                 if (res)
1186                         res = -1;
1187                 else if (!masq_park_call_announce(transferee, transferer, 0, NULL)) {   /* success */
1188                         /* We return non-zero, but tell the PBX not to hang the channel when
1189                            the thread dies -- We have to be careful now though.  We are responsible for 
1190                            hanging up the channel, else it will never be hung up! */
1191
1192                         return 0;
1193                 } else {
1194                         ast_log(LOG_WARNING, "Unable to park call %s\n", transferee->name);
1195                 }
1196                 /*! \todo XXX Maybe we should have another message here instead of invalid extension XXX */
1197         } else if (ast_exists_extension(transferee, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
1198                 pbx_builtin_setvar_helper(transferer, "BLINDTRANSFER", transferee->name);
1199                 pbx_builtin_setvar_helper(transferee, "BLINDTRANSFER", transferer->name);
1200                 res=finishup(transferee);
1201                 if (!transferer->cdr) {
1202                         transferer->cdr=ast_cdr_alloc();
1203                         if (transferer) {
1204                                 ast_cdr_init(transferer->cdr, transferer); /* initilize our channel's cdr */
1205                                 ast_cdr_start(transferer->cdr);
1206                         }
1207                 }
1208                 if (transferer->cdr) {
1209                         ast_cdr_setdestchan(transferer->cdr, transferee->name);
1210                         ast_cdr_setapp(transferer->cdr, "BLINDTRANSFER","");
1211                 }
1212                 if (!transferee->pbx) {
1213                         /* Doh!  Use our handy async_goto functions */
1214                         ast_verb(3, "Transferring %s to '%s' (context %s) priority 1\n"
1215                                                                 ,transferee->name, xferto, transferer_real_context);
1216                         if (ast_async_goto(transferee, transferer_real_context, xferto, 1))
1217                                 ast_log(LOG_WARNING, "Async goto failed :-(\n");
1218                 } else {
1219                         /* Set the channel's new extension, since it exists, using transferer context */
1220                         set_c_e_p(transferee, transferer_real_context, xferto, 0);
1221                 }
1222                 check_goto_on_transfer(transferer);
1223                 return res;
1224         } else {
1225                 ast_verb(3, "Unable to find extension '%s' in context '%s'\n", xferto, transferer_real_context);
1226         }
1227         if (ast_stream_and_wait(transferer, xferfailsound, AST_DIGIT_ANY) < 0) {
1228                 finishup(transferee);
1229                 return -1;
1230         }
1231         ast_stopstream(transferer);
1232         res = finishup(transferee);
1233         if (res) {
1234                 ast_verb(2, "Hungup during autoservice stop on '%s'\n", transferee->name);
1235                 return res;
1236         }
1237         return AST_FEATURE_RETURN_SUCCESS;
1238 }
1239
1240 /*!
1241  * \brief make channels compatible
1242  * \param c
1243  * \param newchan
1244  * \retval 0 on success.
1245  * \retval -1 on failure.
1246 */
1247 static int check_compat(struct ast_channel *c, struct ast_channel *newchan)
1248 {
1249         if (ast_channel_make_compatible(c, newchan) < 0) {
1250                 ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n",
1251                         c->name, newchan->name);
1252                 ast_hangup(newchan);
1253                 return -1;
1254         }
1255         return 0;
1256 }
1257
1258 /*!
1259  * \brief Attended transfer
1260  * \param chan transfered user
1261  * \param peer person transfering call
1262  * \param config
1263  * \param code
1264  * \param sense feature options
1265  * 
1266  * \param data
1267  * Get extension to transfer to, if you cannot generate channel (or find extension) 
1268  * return to host channel. After called channel answered wait for hangup of transferer,
1269  * bridge call between transfer peer (taking them off hold) to attended transfer channel.
1270  *
1271  * \return -1 on failure
1272 */
1273 static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1274 {
1275         struct ast_channel *transferer;
1276         struct ast_channel *transferee;
1277         const char *transferer_real_context;
1278         char xferto[256] = "";
1279         int res;
1280         int outstate=0;
1281         struct ast_channel *newchan;
1282         struct ast_channel *xferchan;
1283         struct ast_bridge_thread_obj *tobj;
1284         struct ast_bridge_config bconfig;
1285         struct ast_frame *f;
1286         int l;
1287
1288         ast_debug(1, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense);
1289         set_peers(&transferer, &transferee, peer, chan, sense);
1290         transferer_real_context = real_ctx(transferer, transferee);
1291         /* Start autoservice on chan while we talk to the originator */
1292         ast_autoservice_start(transferee);
1293         ast_indicate(transferee, AST_CONTROL_HOLD);
1294         
1295         /* Transfer */
1296         res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
1297         if (res < 0) {
1298                 finishup(transferee);
1299                 return res;
1300         }
1301         if (res > 0) /* If they've typed a digit already, handle it */
1302                 xferto[0] = (char) res;
1303
1304         /* this is specific of atxfer */
1305         res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
1306         if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
1307                 finishup(transferee);
1308                 return res;
1309         }
1310         if (res == 0) {
1311                 ast_log(LOG_WARNING, "Did not read data.\n");
1312                 finishup(transferee);
1313                 if (ast_stream_and_wait(transferer, "beeperr", ""))
1314                         return -1;
1315                 return AST_FEATURE_RETURN_SUCCESS;
1316         }
1317
1318         /* valid extension, res == 1 */
1319         if (!ast_exists_extension(transferer, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
1320                 ast_log(LOG_WARNING, "Extension %s does not exist in context %s\n",xferto,transferer_real_context);
1321                 finishup(transferee);
1322                 if (ast_stream_and_wait(transferer, "beeperr", ""))
1323                         return -1;
1324                 return AST_FEATURE_RETURN_SUCCESS;
1325         }
1326
1327         l = strlen(xferto);
1328         snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context);     /* append context */
1329
1330         /* If we are performing an attended transfer and we have two channels involved then
1331            copy sound file information to play upon attended transfer completion */
1332         if (transferee) {
1333                 const char *chan1_attended_sound = pbx_builtin_getvar_helper(transferer, "ATTENDED_TRANSFER_COMPLETE_SOUND");
1334                 const char *chan2_attended_sound = pbx_builtin_getvar_helper(transferee, "ATTENDED_TRANSFER_COMPLETE_SOUND");
1335
1336                 if (!ast_strlen_zero(chan1_attended_sound)) {
1337                         pbx_builtin_setvar_helper(transferer, "BRIDGE_PLAY_SOUND", chan1_attended_sound);
1338                 }
1339                 if (!ast_strlen_zero(chan2_attended_sound)) {
1340                         pbx_builtin_setvar_helper(transferee, "BRIDGE_PLAY_SOUND", chan2_attended_sound);
1341                 }
1342         }
1343
1344         newchan = ast_feature_request_and_dial(transferer, transferee, "Local", ast_best_codec(transferer->nativeformats),
1345                 xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name, 1, transferer->language);
1346
1347         if (!ast_check_hangup(transferer)) {
1348                 /* Transferer is up - old behaviour */
1349                 ast_indicate(transferer, -1);
1350                 if (!newchan) {
1351                         finishup(transferee);
1352                         /* any reason besides user requested cancel and busy triggers the failed sound */
1353                         if (outstate != AST_CONTROL_UNHOLD && outstate != AST_CONTROL_BUSY &&
1354                                 ast_stream_and_wait(transferer, xferfailsound, ""))
1355                                 return -1;
1356                         if (ast_stream_and_wait(transferer, xfersound, ""))
1357                                 ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1358                         return AST_FEATURE_RETURN_SUCCESS;
1359                 }
1360
1361                 if (check_compat(transferer, newchan)) {
1362                         /* we do mean transferee here, NOT transferer */
1363                         finishup(transferee);
1364                         return -1;
1365                 }
1366                 memset(&bconfig,0,sizeof(struct ast_bridge_config));
1367                 ast_set_flag(&(bconfig.features_caller), AST_FEATURE_DISCONNECT);
1368                 ast_set_flag(&(bconfig.features_callee), AST_FEATURE_DISCONNECT);
1369                 res = ast_bridge_call(transferer, newchan, &bconfig);
1370                 if (ast_check_hangup(newchan) || !ast_check_hangup(transferer)) {
1371                         ast_hangup(newchan);
1372                         if (ast_stream_and_wait(transferer, xfersound, ""))
1373                                 ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1374                         finishup(transferee);
1375                         transferer->_softhangup = 0;
1376                         return AST_FEATURE_RETURN_SUCCESS;
1377                 }
1378                 if (check_compat(transferee, newchan)) {
1379                         finishup(transferee);
1380                         return -1;
1381                 }
1382                 ast_indicate(transferee, AST_CONTROL_UNHOLD);
1383
1384                 if ((ast_autoservice_stop(transferee) < 0)
1385                  || (ast_waitfordigit(transferee, 100) < 0)
1386                  || (ast_waitfordigit(newchan, 100) < 0)
1387                  || ast_check_hangup(transferee)
1388                  || ast_check_hangup(newchan)) {
1389                         ast_hangup(newchan);
1390                         return -1;
1391                 }
1392                 xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, "Transfered/%s", transferee->name);
1393                 if (!xferchan) {
1394                         ast_hangup(newchan);
1395                         return -1;
1396                 }
1397                 /* Make formats okay */
1398                 xferchan->visible_indication = transferer->visible_indication;
1399                 xferchan->readformat = transferee->readformat;
1400                 xferchan->writeformat = transferee->writeformat;
1401                 ast_channel_masquerade(xferchan, transferee);
1402                 ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority);
1403                 xferchan->_state = AST_STATE_UP;
1404                 ast_clear_flag(xferchan, AST_FLAGS_ALL);
1405                 xferchan->_softhangup = 0;
1406                 if ((f = ast_read(xferchan)))
1407                         ast_frfree(f);
1408                 newchan->_state = AST_STATE_UP;
1409                 ast_clear_flag(newchan, AST_FLAGS_ALL);
1410                 newchan->_softhangup = 0;
1411                 if (!(tobj = ast_calloc(1, sizeof(*tobj)))) {
1412                         ast_hangup(xferchan);
1413                         ast_hangup(newchan);
1414                         return -1;
1415                 }
1416                 tobj->chan = newchan;
1417                 tobj->peer = xferchan;
1418                 tobj->bconfig = *config;
1419
1420                 if (tobj->bconfig.end_bridge_callback_data_fixup) {
1421                         tobj->bconfig.end_bridge_callback_data_fixup(&tobj->bconfig, tobj->peer, tobj->chan);
1422                 }
1423
1424                 if (ast_stream_and_wait(newchan, xfersound, ""))
1425                         ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1426                 ast_bridge_call_thread_launch(tobj);
1427                 return -1;      /* XXX meaning the channel is bridged ? */
1428         } else if (!ast_check_hangup(transferee)) {
1429                 /* act as blind transfer */
1430                 if (ast_autoservice_stop(transferee) < 0) {
1431                         ast_hangup(newchan);
1432                         return -1;
1433                 }
1434
1435                 if (!newchan) {
1436                         unsigned int tries = 0;
1437                         char *transferer_tech, *transferer_name = ast_strdupa(transferer->name);
1438
1439                         transferer_tech = strsep(&transferer_name, "/");
1440                         transferer_name = strsep(&transferer_name, "-");
1441
1442                         if (ast_strlen_zero(transferer_name) || ast_strlen_zero(transferer_tech)) {
1443                                 ast_log(LOG_WARNING, "Transferer has invalid channel name: '%s'\n", transferer->name);
1444                                 if (ast_stream_and_wait(transferee, "beeperr", ""))
1445                                         return -1;
1446                                 return AST_FEATURE_RETURN_SUCCESS;
1447                         }
1448
1449                         ast_log(LOG_NOTICE, "We're trying to call %s/%s\n", transferer_tech, transferer_name);
1450                         newchan = ast_feature_request_and_dial(transferee, NULL, transferer_tech, ast_best_codec(transferee->nativeformats),
1451                                 transferer_name, atxfernoanswertimeout, &outstate, transferee->cid.cid_num, transferee->cid.cid_name, 0, transferer->language);
1452                         while (!newchan && !atxferdropcall && tries < atxfercallbackretries) {
1453                                 /* Trying to transfer again */
1454                                 ast_autoservice_start(transferee);
1455                                 ast_indicate(transferee, AST_CONTROL_HOLD);
1456
1457                                 newchan = ast_feature_request_and_dial(transferer, transferee, "Local", ast_best_codec(transferer->nativeformats),
1458                                         xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name, 1, transferer->language);
1459                                 if (ast_autoservice_stop(transferee) < 0) {
1460                                         if (newchan)
1461                                                 ast_hangup(newchan);
1462                                         return -1;
1463                                 }
1464                                 if (!newchan) {
1465                                         /* Transfer failed, sleeping */
1466                                         ast_debug(1, "Sleeping for %d ms before callback.\n", atxferloopdelay);
1467                                         ast_safe_sleep(transferee, atxferloopdelay);
1468                                         ast_debug(1, "Trying to callback...\n");
1469                                         newchan = ast_feature_request_and_dial(transferee, NULL, transferer_tech, ast_best_codec(transferee->nativeformats),
1470                                                 transferer_name, atxfernoanswertimeout, &outstate, transferee->cid.cid_num, transferee->cid.cid_name, 0, transferer->language);
1471                                 }
1472                                 tries++;
1473                         }
1474                 }
1475                 if (!newchan)
1476                         return -1;
1477
1478                 /* newchan is up, we should prepare transferee and bridge them */
1479                 if (check_compat(transferee, newchan)) {
1480                         finishup(transferee);
1481                         return -1;
1482                 }
1483                 ast_indicate(transferee, AST_CONTROL_UNHOLD);
1484
1485                 if ((ast_waitfordigit(transferee, 100) < 0)
1486                    || (ast_waitfordigit(newchan, 100) < 0)
1487                    || ast_check_hangup(transferee)
1488                    || ast_check_hangup(newchan)) {
1489                         ast_hangup(newchan);
1490                         return -1;
1491                 }
1492
1493                 xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, "Transfered/%s", transferee->name);
1494                 if (!xferchan) {
1495                         ast_hangup(newchan);
1496                         return -1;
1497                 }
1498                 /* Make formats okay */
1499                 xferchan->visible_indication = transferer->visible_indication;
1500                 xferchan->readformat = transferee->readformat;
1501                 xferchan->writeformat = transferee->writeformat;
1502                 ast_channel_masquerade(xferchan, transferee);
1503                 ast_explicit_goto(xferchan, transferee->context, transferee->exten, transferee->priority);
1504                 xferchan->_state = AST_STATE_UP;
1505                 ast_clear_flag(xferchan, AST_FLAGS_ALL);
1506                 xferchan->_softhangup = 0;
1507                 if ((f = ast_read(xferchan)))
1508                         ast_frfree(f);
1509                 newchan->_state = AST_STATE_UP;
1510                 ast_clear_flag(newchan, AST_FLAGS_ALL);
1511                 newchan->_softhangup = 0;
1512                 if (!(tobj = ast_calloc(1, sizeof(*tobj)))) {
1513                         ast_hangup(xferchan);
1514                         ast_hangup(newchan);
1515                         return -1;
1516                 }
1517                 tobj->chan = newchan;
1518                 tobj->peer = xferchan;
1519                 tobj->bconfig = *config;
1520
1521                 if (tobj->bconfig.end_bridge_callback_data_fixup) {
1522                         tobj->bconfig.end_bridge_callback_data_fixup(&tobj->bconfig, tobj->peer, tobj->chan);
1523                 }
1524
1525                 if (ast_stream_and_wait(newchan, xfersound, ""))
1526                         ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
1527                 ast_bridge_call_thread_launch(tobj);
1528                 return -1;      /* XXX meaning the channel is bridged ? */
1529         } else {
1530                 /* Transferee hung up */
1531                 finishup(transferee);
1532                 return -1;
1533         }
1534 }
1535
1536 /* add atxfer and automon as undefined so you can only use em if you configure them */
1537 #define FEATURES_COUNT ARRAY_LEN(builtin_features)
1538
1539 AST_RWLOCK_DEFINE_STATIC(features_lock);
1540
1541 static struct ast_call_feature builtin_features[] = 
1542 {
1543         { AST_FEATURE_REDIRECT, "Blind Transfer", "blindxfer", "#", "#", builtin_blindtransfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1544         { AST_FEATURE_REDIRECT, "Attended Transfer", "atxfer", "", "", builtin_atxfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1545         { AST_FEATURE_AUTOMON, "One Touch Monitor", "automon", "", "", builtin_automonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1546         { AST_FEATURE_DISCONNECT, "Disconnect Call", "disconnect", "*", "*", builtin_disconnect, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1547         { AST_FEATURE_PARKCALL, "Park Call", "parkcall", "", "", builtin_parkcall, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1548         { AST_FEATURE_AUTOMIXMON, "One Touch MixMonitor", "automixmon", "", "", builtin_automixmonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
1549 };
1550
1551
1552 static AST_RWLIST_HEAD_STATIC(feature_list, ast_call_feature);
1553
1554 /*! \brief register new feature into feature_list*/
1555 void ast_register_feature(struct ast_call_feature *feature)
1556 {
1557         if (!feature) {
1558                 ast_log(LOG_NOTICE,"You didn't pass a feature!\n");
1559                 return;
1560         }
1561   
1562         AST_RWLIST_WRLOCK(&feature_list);
1563         AST_RWLIST_INSERT_HEAD(&feature_list,feature,feature_entry);
1564         AST_RWLIST_UNLOCK(&feature_list);
1565
1566         ast_verb(2, "Registered Feature '%s'\n",feature->sname);
1567 }
1568
1569 /*! 
1570  * \brief Add new feature group
1571  * \param fgname feature group name.
1572  *
1573  * Add new feature group to the feature group list insert at head of list.
1574  * \note This function MUST be called while feature_groups is locked.
1575 */
1576 static struct feature_group* register_group(const char *fgname)
1577 {
1578         struct feature_group *fg;
1579
1580         if (!fgname) {
1581                 ast_log(LOG_NOTICE, "You didn't pass a new group name!\n");
1582                 return NULL;
1583         }
1584
1585         if (!(fg = ast_calloc(1, sizeof(*fg))))
1586                 return NULL;
1587
1588         if (ast_string_field_init(fg, 128)) {
1589                 ast_free(fg);
1590                 return NULL;
1591         }
1592
1593         ast_string_field_set(fg, gname, fgname);
1594
1595         AST_LIST_INSERT_HEAD(&feature_groups, fg, entry);
1596
1597         ast_verb(2, "Registered group '%s'\n", fg->gname);
1598
1599         return fg;
1600 }
1601
1602 /*! 
1603  * \brief Add feature to group
1604  * \param fg feature group
1605  * \param exten
1606  * \param feature feature to add.
1607  *
1608  * Check fg and feature specified, add feature to list
1609  * \note This function MUST be called while feature_groups is locked. 
1610 */
1611 static void register_group_feature(struct feature_group *fg, const char *exten, struct ast_call_feature *feature) 
1612 {
1613         struct feature_group_exten *fge;
1614
1615         if (!fg) {
1616                 ast_log(LOG_NOTICE, "You didn't pass a group!\n");
1617                 return;
1618         }
1619
1620         if (!feature) {
1621                 ast_log(LOG_NOTICE, "You didn't pass a feature!\n");
1622                 return;
1623         }
1624
1625         if (!(fge = ast_calloc(1, sizeof(*fge))))
1626                 return;
1627
1628         if (ast_string_field_init(fge, 128)) {
1629                 ast_free(fge);
1630                 return;
1631         }
1632
1633         ast_string_field_set(fge, exten, S_OR(exten, feature->exten));
1634
1635         fge->feature = feature;
1636
1637         AST_LIST_INSERT_HEAD(&fg->features, fge, entry);                
1638
1639         ast_verb(2, "Registered feature '%s' for group '%s' at exten '%s'\n",
1640                                         feature->sname, fg->gname, exten);
1641 }
1642
1643 void ast_unregister_feature(struct ast_call_feature *feature)
1644 {
1645         if (!feature) {
1646                 return;
1647         }
1648
1649         AST_RWLIST_WRLOCK(&feature_list);
1650         AST_RWLIST_REMOVE(&feature_list, feature, feature_entry);
1651         AST_RWLIST_UNLOCK(&feature_list);
1652
1653         ast_free(feature);
1654 }
1655
1656 /*! \brief Remove all features in the list */
1657 static void ast_unregister_features(void)
1658 {
1659         struct ast_call_feature *feature;
1660
1661         AST_RWLIST_WRLOCK(&feature_list);
1662         while ((feature = AST_RWLIST_REMOVE_HEAD(&feature_list, feature_entry))) {
1663                 ast_free(feature);
1664         }
1665         AST_RWLIST_UNLOCK(&feature_list);
1666 }
1667
1668 /*! \brief find a call feature by name */
1669 static struct ast_call_feature *find_dynamic_feature(const char *name)
1670 {
1671         struct ast_call_feature *tmp;
1672
1673         AST_RWLIST_TRAVERSE(&feature_list, tmp, feature_entry) {
1674                 if (!strcasecmp(tmp->sname, name)) {
1675                         break;
1676                 }
1677         }
1678
1679         return tmp;
1680 }
1681
1682 /*! \brief Remove all feature groups in the list */
1683 static void ast_unregister_groups(void)
1684 {
1685         struct feature_group *fg;
1686         struct feature_group_exten *fge;
1687
1688         AST_RWLIST_WRLOCK(&feature_groups);
1689         while ((fg = AST_LIST_REMOVE_HEAD(&feature_groups, entry))) {
1690                 while ((fge = AST_LIST_REMOVE_HEAD(&fg->features, entry))) {
1691                         ast_string_field_free_memory(fge);
1692                         ast_free(fge);
1693                 }
1694
1695                 ast_string_field_free_memory(fg);
1696                 ast_free(fg);
1697         }
1698         AST_RWLIST_UNLOCK(&feature_groups);
1699 }
1700
1701 /*! 
1702  * \brief Find a group by name 
1703  * \param name feature name
1704  * \retval feature group on success.
1705  * \retval NULL on failure.
1706 */
1707 static struct feature_group *find_group(const char *name) {
1708         struct feature_group *fg = NULL;
1709
1710         AST_LIST_TRAVERSE(&feature_groups, fg, entry) {
1711                 if (!strcasecmp(fg->gname, name))
1712                         break;
1713         }
1714
1715         return fg;
1716 }
1717
1718 void ast_rdlock_call_features(void)
1719 {
1720         ast_rwlock_rdlock(&features_lock);
1721 }
1722
1723 void ast_unlock_call_features(void)
1724 {
1725         ast_rwlock_unlock(&features_lock);
1726 }
1727
1728 struct ast_call_feature *ast_find_call_feature(const char *name)
1729 {
1730         int x;
1731         for (x = 0; x < FEATURES_COUNT; x++) {
1732                 if (!strcasecmp(name, builtin_features[x].sname))
1733                         return &builtin_features[x];
1734         }
1735         return NULL;
1736 }
1737
1738 /*!
1739  * \brief exec an app by feature 
1740  * \param chan,peer,config,code,sense,data
1741  *
1742  * Find a feature, determine which channel activated
1743  * \retval AST_FEATURE_RETURN_NO_HANGUP_PEER
1744  * \retval -1 error.
1745  * \retval -2 when an application cannot be found.
1746 */
1747 static int feature_exec_app(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
1748 {
1749         struct ast_app *app;
1750         struct ast_call_feature *feature = data;
1751         struct ast_channel *work, *idle;
1752         int res;
1753
1754         if (!feature) { /* shouldn't ever happen! */
1755                 ast_log(LOG_NOTICE, "Found feature before, but at execing we've lost it??\n");
1756                 return -1; 
1757         }
1758
1759         if (sense == FEATURE_SENSE_CHAN) {
1760                 if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER))
1761                         return AST_FEATURE_RETURN_KEEPTRYING;
1762                 if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
1763                         work = chan;
1764                         idle = peer;
1765                 } else {
1766                         work = peer;
1767                         idle = chan;
1768                 }
1769         } else {
1770                 if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE))
1771                         return AST_FEATURE_RETURN_KEEPTRYING;
1772                 if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
1773                         work = peer;
1774                         idle = chan;
1775                 } else {
1776                         work = chan;
1777                         idle = peer;
1778                 }
1779         }
1780
1781         if (!(app = pbx_findapp(feature->app))) {
1782                 ast_log(LOG_WARNING, "Could not find application (%s)\n", feature->app);
1783                 return -2;
1784         }
1785
1786         ast_autoservice_start(idle);
1787         
1788         if (!ast_strlen_zero(feature->moh_class))
1789                 ast_moh_start(idle, feature->moh_class, NULL);
1790
1791         res = pbx_exec(work, app, feature->app_args);
1792
1793         if (!ast_strlen_zero(feature->moh_class))
1794                 ast_moh_stop(idle);
1795
1796         ast_autoservice_stop(idle);
1797
1798         if (res) {
1799                 return AST_FEATURE_RETURN_SUCCESSBREAK;
1800         }
1801         return AST_FEATURE_RETURN_SUCCESS;      /*! \todo XXX should probably return res */
1802 }
1803
1804 static void unmap_features(void)
1805 {
1806         int x;
1807
1808         ast_rwlock_wrlock(&features_lock);
1809         for (x = 0; x < FEATURES_COUNT; x++)
1810                 strcpy(builtin_features[x].exten, builtin_features[x].default_exten);
1811         ast_rwlock_unlock(&features_lock);
1812 }
1813
1814 static int remap_feature(const char *name, const char *value)
1815 {
1816         int x, res = -1;
1817
1818         ast_rwlock_wrlock(&features_lock);
1819         for (x = 0; x < FEATURES_COUNT; x++) {
1820                 if (strcasecmp(builtin_features[x].sname, name))
1821                         continue;
1822
1823                 ast_copy_string(builtin_features[x].exten, value, sizeof(builtin_features[x].exten));
1824                 res = 0;
1825                 break;
1826         }
1827         ast_rwlock_unlock(&features_lock);
1828
1829         return res;
1830 }
1831
1832 /*!
1833  * \brief Check the dynamic features
1834  * \param chan,peer,config,code,sense
1835  *
1836  * Lock features list, browse for code, unlock list
1837  * \retval res on success.
1838  * \retval -1 on failure.
1839 */
1840 static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense)
1841 {
1842         int x;
1843         struct ast_flags features;
1844         struct ast_call_feature *feature;
1845         struct feature_group *fg = NULL;
1846         struct feature_group_exten *fge;
1847         const char *dynamic_features;
1848         char *tmp, *tok;
1849         int res = AST_FEATURE_RETURN_PASSDIGITS;
1850         int feature_detected = 0;
1851
1852         if (sense == FEATURE_SENSE_CHAN) {
1853                 ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL);
1854                 dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");
1855         }
1856         else {
1857                 ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL);
1858                 dynamic_features = pbx_builtin_getvar_helper(peer, "DYNAMIC_FEATURES");
1859         }
1860         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);
1861
1862         ast_rwlock_rdlock(&features_lock);
1863         for (x = 0; x < FEATURES_COUNT; x++) {
1864                 if ((ast_test_flag(&features, builtin_features[x].feature_mask)) &&
1865                     !ast_strlen_zero(builtin_features[x].exten)) {
1866                         /* Feature is up for consideration */
1867                         if (!strcmp(builtin_features[x].exten, code)) {
1868                                 res = builtin_features[x].operation(chan, peer, config, code, sense, NULL);
1869                                 feature_detected = 1;
1870                                 break;
1871                         } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) {
1872                                 if (res == AST_FEATURE_RETURN_PASSDIGITS)
1873                                         res = AST_FEATURE_RETURN_STOREDIGITS;
1874                         }
1875                 }
1876         }
1877         ast_rwlock_unlock(&features_lock);
1878
1879         if (ast_strlen_zero(dynamic_features) || feature_detected)
1880                 return res;
1881
1882         tmp = ast_strdupa(dynamic_features);
1883
1884         while ((tok = strsep(&tmp, "#"))) {
1885                 AST_RWLIST_RDLOCK(&feature_groups);
1886
1887                 fg = find_group(tok);
1888
1889                 if (fg) {
1890                         AST_LIST_TRAVERSE(&fg->features, fge, entry) {
1891                                 if (strcasecmp(fge->exten, code))
1892                                         continue;
1893
1894                                 res = fge->feature->operation(chan, peer, config, code, sense, fge->feature);
1895                                 if (res != AST_FEATURE_RETURN_KEEPTRYING) {
1896                                         AST_RWLIST_UNLOCK(&feature_groups);
1897                                         break;
1898                                 }
1899                                 res = AST_FEATURE_RETURN_PASSDIGITS;
1900                         }
1901                         if (fge)
1902                                 break;
1903                 }
1904
1905                 AST_RWLIST_UNLOCK(&feature_groups);
1906
1907                 AST_RWLIST_RDLOCK(&feature_list);
1908
1909                 if (!(feature = find_dynamic_feature(tok))) {
1910                         AST_RWLIST_UNLOCK(&feature_list);
1911                         continue;
1912                 }
1913                         
1914                 /* Feature is up for consideration */
1915                 if (!strcmp(feature->exten, code)) {
1916                         ast_verb(3, " Feature Found: %s exten: %s\n",feature->sname, tok);
1917                         res = feature->operation(chan, peer, config, code, sense, feature);
1918                         if (res != AST_FEATURE_RETURN_KEEPTRYING) {
1919                                 AST_RWLIST_UNLOCK(&feature_list);
1920                                 break;
1921                         }
1922                         res = AST_FEATURE_RETURN_PASSDIGITS;
1923                 } else if (!strncmp(feature->exten, code, strlen(code)))
1924                         res = AST_FEATURE_RETURN_STOREDIGITS;
1925
1926                 AST_RWLIST_UNLOCK(&feature_list);
1927         }
1928         
1929         return res;
1930 }
1931
1932 static void set_config_flags(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config)
1933 {
1934         int x;
1935         
1936         ast_clear_flag(config, AST_FLAGS_ALL);
1937
1938         ast_rwlock_rdlock(&features_lock);
1939         for (x = 0; x < FEATURES_COUNT; x++) {
1940                 if (!ast_test_flag(builtin_features + x, AST_FEATURE_FLAG_NEEDSDTMF))
1941                         continue;
1942
1943                 if (ast_test_flag(&(config->features_caller), builtin_features[x].feature_mask))
1944                         ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
1945
1946                 if (ast_test_flag(&(config->features_callee), builtin_features[x].feature_mask))
1947                         ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
1948         }
1949         ast_rwlock_unlock(&features_lock);
1950         
1951         if (chan && peer && !(ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_0) && ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_1))) {
1952                 const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");
1953
1954                 if (dynamic_features) {
1955                         char *tmp = ast_strdupa(dynamic_features);
1956                         char *tok;
1957                         struct ast_call_feature *feature;
1958
1959                         /* while we have a feature */
1960                         while ((tok = strsep(&tmp, "#"))) {
1961                                 AST_RWLIST_RDLOCK(&feature_list);
1962                                 if ((feature = find_dynamic_feature(tok)) && ast_test_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF)) {
1963                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER))
1964                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
1965                                         if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE))
1966                                                 ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
1967                                 }
1968                                 AST_RWLIST_UNLOCK(&feature_list);
1969                         }
1970                 }
1971         }
1972 }
1973
1974 /*! 
1975  * \brief Get feature and dial
1976  * \param caller,transferee,type,format,data,timeout,outstate,cid_num,cid_name,igncallerstate
1977  *
1978  * Request channel, set channel variables, initiate call,check if they want to disconnect
1979  * go into loop, check if timeout has elapsed, check if person to be transfered hung up,
1980  * check for answer break loop, set cdr return channel.
1981  *
1982  * \todo XXX Check - this is very similar to the code in channel.c 
1983  * \return always a channel
1984 */
1985 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)
1986 {
1987         int state = 0;
1988         int cause = 0;
1989         int to;
1990         struct ast_channel *chan;
1991         struct ast_channel *monitor_chans[2];
1992         struct ast_channel *active_channel;
1993         int res = 0, ready = 0;
1994         struct timeval started;
1995         int x, len = 0;
1996         char *disconnect_code = NULL, *dialed_code = NULL;
1997
1998         if (!(chan = ast_request(type, format, data, &cause))) {
1999                 ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, (char *)data);
2000                 switch(cause) {
2001                 case AST_CAUSE_BUSY:
2002                         state = AST_CONTROL_BUSY;
2003                         break;
2004                 case AST_CAUSE_CONGESTION:
2005                         state = AST_CONTROL_CONGESTION;
2006                         break;
2007                 }
2008                 goto done;
2009         }
2010
2011         ast_set_callerid(chan, cid_num, cid_name, cid_num);
2012         ast_string_field_set(chan, language, language);
2013         ast_channel_inherit_variables(caller, chan);    
2014         pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", caller->name);
2015                 
2016         if (ast_call(chan, data, timeout)) {
2017                 ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, (char *)data);
2018                 goto done;
2019         }
2020         
2021         ast_indicate(caller, AST_CONTROL_RINGING);
2022         /* support dialing of the featuremap disconnect code while performing an attended tranfer */
2023         ast_rwlock_rdlock(&features_lock);
2024         for (x = 0; x < FEATURES_COUNT; x++) {
2025                 if (strcasecmp(builtin_features[x].sname, "disconnect"))
2026                         continue;
2027
2028                 disconnect_code = builtin_features[x].exten;
2029                 len = strlen(disconnect_code) + 1;
2030                 dialed_code = alloca(len);
2031                 memset(dialed_code, 0, len);
2032                 break;
2033         }
2034         ast_rwlock_unlock(&features_lock);
2035         x = 0;
2036         started = ast_tvnow();
2037         to = timeout;
2038
2039         ast_poll_channel_add(caller, chan);
2040
2041         while (!((transferee && ast_check_hangup(transferee)) && (!igncallerstate && ast_check_hangup(caller))) && timeout && (chan->_state != AST_STATE_UP)) {
2042                 struct ast_frame *f = NULL;
2043
2044                 monitor_chans[0] = caller;
2045                 monitor_chans[1] = chan;
2046                 active_channel = ast_waitfor_n(monitor_chans, 2, &to);
2047
2048                 /* see if the timeout has been violated */
2049                 if(ast_tvdiff_ms(ast_tvnow(), started) > timeout) {
2050                         state = AST_CONTROL_UNHOLD;
2051                         ast_log(LOG_NOTICE, "We exceeded our AT-timeout\n");
2052                         break; /*doh! timeout*/
2053                 }
2054
2055                 if (!active_channel)
2056                         continue;
2057
2058                 if (chan && (chan == active_channel)){
2059                         f = ast_read(chan);
2060                         if (f == NULL) { /*doh! where'd he go?*/
2061                                 state = AST_CONTROL_HANGUP;
2062                                 res = 0;
2063                                 break;
2064                         }
2065                         
2066                         if (f->frametype == AST_FRAME_CONTROL || f->frametype == AST_FRAME_DTMF || f->frametype == AST_FRAME_TEXT) {
2067                                 if (f->subclass == AST_CONTROL_RINGING) {
2068                                         state = f->subclass;
2069                                         ast_verb(3, "%s is ringing\n", chan->name);
2070                                         ast_indicate(caller, AST_CONTROL_RINGING);
2071                                 } else if ((f->subclass == AST_CONTROL_BUSY) || (f->subclass == AST_CONTROL_CONGESTION)) {
2072                                         state = f->subclass;
2073                                         ast_verb(3, "%s is busy\n", chan->name);
2074                                         ast_indicate(caller, AST_CONTROL_BUSY);
2075                                         ast_frfree(f);
2076                                         f = NULL;
2077                                         break;
2078                                 } else if (f->subclass == AST_CONTROL_ANSWER) {
2079                                         /* This is what we are hoping for */
2080                                         state = f->subclass;
2081                                         ast_frfree(f);
2082                                         f = NULL;
2083                                         ready=1;
2084                                         break;
2085                                 } else if (f->subclass != -1) {
2086                                         ast_log(LOG_NOTICE, "Don't know what to do about control frame: %d\n", f->subclass);
2087                                 }
2088                                 /* else who cares */
2089                         }
2090
2091                 } else if (caller && (active_channel == caller)) {
2092                         f = ast_read(caller);
2093                         if (f == NULL) { /*doh! where'd he go?*/
2094                                 if (!igncallerstate) {
2095                                         if (ast_check_hangup(caller) && !ast_check_hangup(chan)) {
2096                                                 /* make this a blind transfer */
2097                                                 ready = 1;
2098                                                 break;
2099                                         }
2100                                         state = AST_CONTROL_HANGUP;
2101                                         res = 0;
2102                                         break;
2103                                 }
2104                         } else {
2105                         
2106                                 if (f->frametype == AST_FRAME_DTMF) {
2107                                         dialed_code[x++] = f->subclass;
2108                                         dialed_code[x] = '\0';
2109                                         if (strlen(dialed_code) == len) {
2110                                                 x = 0;
2111                                         } else if (x && strncmp(dialed_code, disconnect_code, x)) {
2112                                                 x = 0;
2113                                                 dialed_code[x] = '\0';
2114                                         }
2115                                         if (*dialed_code && !strcmp(dialed_code, disconnect_code)) {
2116                                                 /* Caller Canceled the call */
2117                                                 state = AST_CONTROL_UNHOLD;
2118                                                 ast_frfree(f);
2119                                                 f = NULL;
2120                                                 break;
2121                                         }
2122                                 }
2123                         }
2124                 }
2125                 if (f)
2126                         ast_frfree(f);
2127         } /* end while */
2128
2129         ast_poll_channel_del(caller, chan);
2130                 
2131 done:
2132         ast_indicate(caller, -1);
2133         if (chan && ready) {
2134                 if (chan->_state == AST_STATE_UP) 
2135                         state = AST_CONTROL_ANSWER;
2136                 res = 0;
2137         } else if (chan) {
2138                 res = -1;
2139                 ast_hangup(chan);
2140                 chan = NULL;
2141         } else {
2142                 res = -1;
2143         }
2144         
2145         if (outstate)
2146                 *outstate = state;
2147
2148         return chan;
2149 }
2150
2151 /*!
2152  * \brief return the first unlocked cdr in a possible chain
2153 */
2154 static struct ast_cdr *pick_unlocked_cdr(struct ast_cdr *cdr)
2155 {
2156         struct ast_cdr *cdr_orig = cdr;
2157         while (cdr) {
2158                 if (!ast_test_flag(cdr,AST_CDR_FLAG_LOCKED))
2159                         return cdr;
2160                 cdr = cdr->next;
2161         }
2162         return cdr_orig; /* everybody LOCKED or some other weirdness, like a NULL */
2163 }
2164
2165 /*!
2166  * \brief bridge the call and set CDR
2167  * \param chan,peer,config
2168  * 
2169  * Set start time, check for two channels,check if monitor on
2170  * check for feature activation, create new CDR
2171  * \retval res on success.
2172  * \retval -1 on failure to bridge.
2173 */
2174 int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast_bridge_config *config)
2175 {
2176         /* Copy voice back and forth between the two channels.  Give the peer
2177            the ability to transfer calls with '#<extension' syntax. */
2178         struct ast_frame *f;
2179         struct ast_channel *who;
2180         char chan_featurecode[FEATURE_MAX_LEN + 1]="";
2181         char peer_featurecode[FEATURE_MAX_LEN + 1]="";
2182         char orig_channame[AST_MAX_EXTENSION];
2183         char orig_peername[AST_MAX_EXTENSION];
2184         int res;
2185         int diff;
2186         int hasfeatures=0;
2187         int hadfeatures=0;
2188         int autoloopflag;
2189         struct ast_option_header *aoh;
2190         struct ast_bridge_config backup_config;
2191         struct ast_cdr *bridge_cdr = NULL;
2192         struct ast_cdr *orig_peer_cdr = NULL;
2193         struct ast_cdr *chan_cdr = pick_unlocked_cdr(chan->cdr); /* the proper chan cdr, if there are forked cdrs */
2194         struct ast_cdr *peer_cdr = pick_unlocked_cdr(peer->cdr); /* the proper chan cdr, if there are forked cdrs */
2195         struct ast_cdr *new_chan_cdr = NULL; /* the proper chan cdr, if there are forked cdrs */
2196         struct ast_cdr *new_peer_cdr = NULL; /* the proper chan cdr, if there are forked cdrs */
2197
2198         memset(&backup_config, 0, sizeof(backup_config));
2199
2200         config->start_time = ast_tvnow();
2201
2202         if (chan && peer) {
2203                 pbx_builtin_setvar_helper(chan, "BRIDGEPEER", peer->name);
2204                 pbx_builtin_setvar_helper(peer, "BRIDGEPEER", chan->name);
2205         } else if (chan) {
2206                 pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", NULL);
2207         }
2208
2209         /* This is an interesting case.  One example is if a ringing channel gets redirected to
2210          * an extension that picks up a parked call.  This will make sure that the call taken
2211          * out of parking gets told that the channel it just got bridged to is still ringing. */
2212         if (chan->_state == AST_STATE_RINGING && peer->visible_indication != AST_CONTROL_RINGING) {
2213                 ast_indicate(peer, AST_CONTROL_RINGING);
2214         }
2215
2216         if (monitor_ok) {
2217                 const char *monitor_exec;
2218                 struct ast_channel *src = NULL;
2219                 if (!monitor_app) { 
2220                         if (!(monitor_app = pbx_findapp("Monitor")))
2221                                 monitor_ok=0;
2222                 }
2223                 if ((monitor_exec = pbx_builtin_getvar_helper(chan, "AUTO_MONITOR"))) 
2224                         src = chan;
2225                 else if ((monitor_exec = pbx_builtin_getvar_helper(peer, "AUTO_MONITOR")))
2226                         src = peer;
2227                 if (monitor_app && src) {
2228                         char *tmp = ast_strdupa(monitor_exec);
2229                         pbx_exec(src, monitor_app, tmp);
2230                 }
2231         }
2232         
2233         set_config_flags(chan, peer, config);
2234         config->firstpass = 1;
2235
2236         /* Answer if need be */
2237         if (ast_answer(chan))
2238                 return -1;
2239
2240         ast_copy_string(orig_channame,chan->name,sizeof(orig_channame));
2241         ast_copy_string(orig_peername,peer->name,sizeof(orig_peername));
2242         orig_peer_cdr = peer_cdr;
2243         
2244         if (!chan_cdr || (chan_cdr && !ast_test_flag(chan_cdr, AST_CDR_FLAG_POST_DISABLED))) {
2245                 
2246                 if (chan_cdr) {
2247                         ast_set_flag(chan_cdr, AST_CDR_FLAG_MAIN);
2248                         ast_cdr_update(chan);
2249                         bridge_cdr = ast_cdr_dup(chan_cdr);
2250                         ast_copy_string(bridge_cdr->lastapp, chan->appl, sizeof(bridge_cdr->lastapp));
2251                         ast_copy_string(bridge_cdr->lastdata, chan->data, sizeof(bridge_cdr->lastdata));
2252                 } else {
2253                         /* better yet, in a xfer situation, find out why the chan cdr got zapped (pun unintentional) */
2254                         bridge_cdr = ast_cdr_alloc(); /* this should be really, really rare/impossible? */
2255                         ast_copy_string(bridge_cdr->channel, chan->name, sizeof(bridge_cdr->channel));
2256                         ast_copy_string(bridge_cdr->dstchannel, peer->name, sizeof(bridge_cdr->dstchannel));
2257                         ast_copy_string(bridge_cdr->uniqueid, chan->uniqueid, sizeof(bridge_cdr->uniqueid));
2258                         ast_copy_string(bridge_cdr->lastapp, chan->appl, sizeof(bridge_cdr->lastapp));
2259                         ast_copy_string(bridge_cdr->lastdata, chan->data, sizeof(bridge_cdr->lastdata));
2260                         ast_cdr_setcid(bridge_cdr, chan);
2261                         bridge_cdr->disposition = (chan->_state == AST_STATE_UP) ?  AST_CDR_ANSWERED : AST_CDR_NULL;
2262                         bridge_cdr->amaflags = chan->amaflags ? chan->amaflags :  ast_default_amaflags;
2263                         ast_copy_string(bridge_cdr->accountcode, chan->accountcode, sizeof(bridge_cdr->accountcode));
2264                         /* Destination information */
2265                         ast_copy_string(bridge_cdr->dst, chan->exten, sizeof(bridge_cdr->dst));
2266                         ast_copy_string(bridge_cdr->dcontext, chan->context, sizeof(bridge_cdr->dcontext));
2267                         if (peer_cdr) {
2268                                 bridge_cdr->start = peer_cdr->start;
2269                                 ast_copy_string(bridge_cdr->userfield, peer_cdr->userfield, sizeof(bridge_cdr->userfield));
2270                         } else {
2271                                 ast_cdr_start(bridge_cdr);
2272                         }
2273                 }
2274                 ast_debug(4,"bridge answer set, chan answer set\n");
2275                 /* peer_cdr->answer will be set when a macro runs on the peer;
2276                    in that case, the bridge answer will be delayed while the
2277                    macro plays on the peer channel. The peer answered the call
2278                    before the macro started playing. To the phone system,
2279                    this is billable time for the call, even tho the caller
2280                    hears nothing but ringing while the macro does its thing. */
2281                 if (peer_cdr && !ast_tvzero(peer_cdr->answer)) {
2282                         bridge_cdr->answer = peer_cdr->answer;
2283                         chan_cdr->answer = peer_cdr->answer;
2284                         bridge_cdr->disposition = peer_cdr->disposition;
2285                         chan_cdr->disposition = peer_cdr->disposition;
2286                 } else {
2287                         ast_cdr_answer(bridge_cdr);
2288                         ast_cdr_answer(chan_cdr); /* for the sake of cli status checks */
2289                 }
2290                 ast_set_flag(chan_cdr, AST_CDR_FLAG_BRIDGED);
2291                 if (peer_cdr) {
2292                         ast_set_flag(peer_cdr, AST_CDR_FLAG_BRIDGED);
2293                 }
2294         }
2295         for (;;) {
2296                 struct ast_channel *other;      /* used later */
2297                 
2298                 res = ast_channel_bridge(chan, peer, config, &f, &who);
2299
2300                 if (config->feature_timer) {
2301                         /* Update time limit for next pass */
2302                         diff = ast_tvdiff_ms(ast_tvnow(), config->start_time);
2303                         config->feature_timer -= diff;
2304                         if (hasfeatures) {
2305                                 /* Running on backup config, meaning a feature might be being
2306                                    activated, but that's no excuse to keep things going 
2307                                    indefinitely! */
2308                                 if (backup_config.feature_timer && ((backup_config.feature_timer -= diff) <= 0)) {
2309                                         ast_debug(1, "Timed out, realtime this time!\n");
2310                                         config->feature_timer = 0;
2311                                         who = chan;
2312                                         if (f)
2313                                                 ast_frfree(f);
2314                                         f = NULL;
2315                                         res = 0;
2316                                 } else if (config->feature_timer <= 0) {
2317                                         /* Not *really* out of time, just out of time for
2318                                            digits to come in for features. */
2319                                         ast_debug(1, "Timed out for feature!\n");
2320                                         if (!ast_strlen_zero(peer_featurecode)) {
2321                                                 ast_dtmf_stream(chan, peer, peer_featurecode, 0, 0);
2322                                                 memset(peer_featurecode, 0, sizeof(peer_featurecode));
2323                                         }
2324                                         if (!ast_strlen_zero(chan_featurecode)) {
2325                                                 ast_dtmf_stream(peer, chan, chan_featurecode, 0, 0);
2326                                                 memset(chan_featurecode, 0, sizeof(chan_featurecode));
2327                                         }
2328                                         if (f)
2329                                                 ast_frfree(f);
2330                                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
2331                                         if (!hasfeatures) {
2332                                                 /* Restore original (possibly time modified) bridge config */
2333                                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
2334                                                 memset(&backup_config, 0, sizeof(backup_config));
2335                                         }
2336                                         hadfeatures = hasfeatures;
2337                                         /* Continue as we were */
2338                                         continue;
2339                                 } else if (!f) {
2340                                         /* The bridge returned without a frame and there is a feature in progress.
2341                                          * However, we don't think the feature has quite yet timed out, so just
2342                                          * go back into the bridge. */
2343                                         continue;
2344                                 }
2345                         } else {
2346                                 if (config->feature_timer <=0) {
2347                                         /* We ran out of time */
2348                                         config->feature_timer = 0;
2349                                         who = chan;
2350                                         if (f)
2351                                                 ast_frfree(f);
2352                                         f = NULL;
2353                                         res = 0;
2354                                 }
2355                         }
2356                 }
2357                 if (res < 0) {
2358                         if (!ast_test_flag(chan, AST_FLAG_ZOMBIE) && !ast_test_flag(peer, AST_FLAG_ZOMBIE) && !ast_check_hangup(chan) && !ast_check_hangup(peer))
2359                                 ast_log(LOG_WARNING, "Bridge failed on channels %s and %s\n", chan->name, peer->name);
2360                         goto before_you_go;
2361                 }
2362                 
2363                 if (!f || (f->frametype == AST_FRAME_CONTROL &&
2364                                 (f->subclass == AST_CONTROL_HANGUP || f->subclass == AST_CONTROL_BUSY || 
2365                                         f->subclass == AST_CONTROL_CONGESTION))) {
2366                         res = -1;
2367                         break;
2368                 }
2369                 /* many things should be sent to the 'other' channel */
2370                 other = (who == chan) ? peer : chan;
2371                 if (f->frametype == AST_FRAME_CONTROL) {
2372                         switch (f->subclass) {
2373                         case AST_CONTROL_RINGING:
2374                         case AST_CONTROL_FLASH:
2375                         case -1:
2376                                 ast_indicate(other, f->subclass);
2377                                 break;
2378                         case AST_CONTROL_HOLD:
2379                         case AST_CONTROL_UNHOLD:
2380                                 ast_indicate_data(other, f->subclass, f->data.ptr, f->datalen);
2381                                 break;
2382                         case AST_CONTROL_OPTION:
2383                                 aoh = f->data.ptr;
2384                                 /* Forward option Requests */
2385                                 if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
2386                                         ast_channel_setoption(other, ntohs(aoh->option), aoh->data, 
2387                                                 f->datalen - sizeof(struct ast_option_header), 0);
2388                                 }
2389                                 break;
2390                         }
2391                 } else if (f->frametype == AST_FRAME_DTMF_BEGIN) {
2392                         /* eat it */
2393                 } else if (f->frametype == AST_FRAME_DTMF) {
2394                         char *featurecode;
2395                         int sense;
2396
2397                         hadfeatures = hasfeatures;
2398                         /* This cannot overrun because the longest feature is one shorter than our buffer */
2399                         if (who == chan) {
2400                                 sense = FEATURE_SENSE_CHAN;
2401                                 featurecode = chan_featurecode;
2402                         } else  {
2403                                 sense = FEATURE_SENSE_PEER;
2404                                 featurecode = peer_featurecode;
2405                         }
2406                         /*! append the event to featurecode. we rely on the string being zero-filled, and
2407                          * not overflowing it. 
2408                          * \todo XXX how do we guarantee the latter ?
2409                          */
2410                         featurecode[strlen(featurecode)] = f->subclass;
2411                         /* Get rid of the frame before we start doing "stuff" with the channels */
2412                         ast_frfree(f);
2413                         f = NULL;
2414                         config->feature_timer = backup_config.feature_timer;
2415                         res = ast_feature_interpret(chan, peer, config, featurecode, sense);
2416                         switch(res) {
2417                         case AST_FEATURE_RETURN_PASSDIGITS:
2418                                 ast_dtmf_stream(other, who, featurecode, 0, 0);
2419                                 /* Fall through */
2420                         case AST_FEATURE_RETURN_SUCCESS:
2421                                 memset(featurecode, 0, sizeof(chan_featurecode));
2422                                 break;
2423                         }
2424                         if (res >= AST_FEATURE_RETURN_PASSDIGITS) {
2425                                 res = 0;
2426                         } else 
2427                                 break;
2428                         hasfeatures = !ast_strlen_zero(chan_featurecode) || !ast_strlen_zero(peer_featurecode);
2429                         if (hadfeatures && !hasfeatures) {
2430                                 /* Restore backup */
2431                                 memcpy(config, &backup_config, sizeof(struct ast_bridge_config));
2432                                 memset(&backup_config, 0, sizeof(struct ast_bridge_config));
2433                         } else if (hasfeatures) {
2434                                 if (!hadfeatures) {
2435                                         /* Backup configuration */
2436                                         memcpy(&backup_config, config, sizeof(struct ast_bridge_config));
2437                                         /* Setup temporary config options */
2438                                         config->play_warning = 0;
2439                                         ast_clear_flag(&(config->features_caller), AST_FEATURE_PLAY_WARNING);
2440                                         ast_clear_flag(&(config->features_callee), AST_FEATURE_PLAY_WARNING);
2441                                         config->warning_freq = 0;
2442                                         config->warning_sound = NULL;
2443                                         config->end_sound = NULL;
2444                                         config->start_sound = NULL;
2445                                         config->firstpass = 0;
2446                                 }
2447                                 config->start_time = ast_tvnow();
2448                                 config->feature_timer = featuredigittimeout;
2449                                 ast_debug(1, "Set time limit to %ld\n", config->feature_timer);
2450                         }
2451                 }
2452                 if (f)
2453                         ast_frfree(f);
2454
2455         }
2456    before_you_go:
2457         if (config->end_bridge_callback) {
2458                 config->end_bridge_callback(config->end_bridge_callback_data);
2459         }
2460
2461         /* run the hangup exten on the chan object IFF it was NOT involved in a parking situation 
2462          * if it were, then chan belongs to a different thread now, and might have been hung up long
2463      * ago.
2464          */
2465         autoloopflag = ast_test_flag(chan, AST_FLAG_IN_AUTOLOOP);
2466         ast_set_flag(chan, AST_FLAG_IN_AUTOLOOP);
2467         if (!ast_test_flag(&(config->features_caller),AST_FEATURE_NO_H_EXTEN) && ast_exists_extension(chan, chan->context, "h", 1, chan->cid.cid_num)) {
2468                 struct ast_cdr *swapper = NULL;
2469                 char savelastapp[AST_MAX_EXTENSION];
2470                 char savelastdata[AST_MAX_EXTENSION];
2471                 char save_exten[AST_MAX_EXTENSION];
2472                 int  save_prio;
2473                 int  found = 0; /* set if we find at least one match */
2474                 int  spawn_error = 0;
2475                 
2476                 if (bridge_cdr && ast_opt_end_cdr_before_h_exten) {
2477                         ast_cdr_end(bridge_cdr);
2478                 }
2479                 /* swap the bridge cdr and the chan cdr for a moment, and let the endbridge
2480                    dialplan code operate on it */
2481                 ast_channel_lock(chan);
2482                 if (bridge_cdr) {
2483                         swapper = chan->cdr;
2484                         ast_copy_string(savelastapp, bridge_cdr->lastapp, sizeof(bridge_cdr->lastapp));
2485                         ast_copy_string(savelastdata, bridge_cdr->lastdata, sizeof(bridge_cdr->lastdata));
2486                         chan->cdr = bridge_cdr;
2487                 }
2488                 ast_copy_string(save_exten, chan->exten, sizeof(save_exten));
2489                 save_prio = chan->priority;
2490                 ast_copy_string(chan->exten, "h", sizeof(chan->exten));
2491                 chan->priority = 1;
2492                 ast_channel_unlock(chan);
2493                 while ((spawn_error = ast_spawn_extension(chan, chan->context, chan->exten, chan->priority, chan->cid.cid_num, &found, 1)) == 0) {
2494                         chan->priority++;
2495                 }
2496                 if (found && spawn_error) {
2497                         /* Something bad happened, or a hangup has been requested. */
2498                         ast_debug(1, "Spawn extension (%s,%s,%d) exited non-zero on '%s'\n", chan->context, chan->exten, chan->priority, chan->name);
2499                         ast_verb(2, "Spawn extension (%s, %s, %d) exited non-zero on '%s'\n", chan->context, chan->exten, chan->priority, chan->name);
2500                 }
2501                 /* swap it back */
2502                 ast_channel_lock(chan);
2503                 ast_copy_string(chan->exten, save_exten, sizeof(chan->exten));
2504                 chan->priority = save_prio;
2505                 if (bridge_cdr)
2506                         chan->cdr = swapper;
2507                 ast_set_flag(chan, AST_FLAG_BRIDGE_HANGUP_RUN);
2508                 ast_channel_unlock(chan);
2509                 /* protect the lastapp/lastdata against the effects of the hangup/dialplan code */
2510                 if (bridge_cdr) {
2511                         ast_copy_string(bridge_cdr->lastapp, savelastapp, sizeof(bridge_cdr->lastapp));
2512                         ast_copy_string(bridge_cdr->lastdata, savelastdata, sizeof(bridge_cdr->lastdata));
2513                 }
2514         }
2515         ast_set2_flag(chan, autoloopflag, AST_FLAG_IN_AUTOLOOP);
2516
2517         /* obey the NoCDR() wishes. -- move the DISABLED flag to the bridge CDR if it was set on the channel during the bridge... */
2518         new_chan_cdr = pick_unlocked_cdr(chan->cdr); /* the proper chan cdr, if there are forked cdrs */
2519         if (bridge_cdr && new_chan_cdr && ast_test_flag(new_chan_cdr, AST_CDR_FLAG_POST_DISABLED))
2520                 ast_set_flag(bridge_cdr, AST_CDR_FLAG_POST_DISABLED);
2521
2522         /* we can post the bridge CDR at this point */
2523         if (bridge_cdr) {
2524                 ast_cdr_end(bridge_cdr);
2525                 ast_cdr_detach(bridge_cdr);
2526         }
2527         
2528         /* do a specialized reset on the beginning channel
2529            CDR's, if they still exist, so as not to mess up
2530            issues in future bridges;
2531            
2532            Here are the rules of the game:
2533            1. The chan and peer channel pointers will not change
2534               during the life of the bridge.
2535            2. But, in transfers, the channel names will change.
2536               between the time the bridge is started, and the
2537               time the channel ends. 
2538               Usually, when a channel changes names, it will
2539               also change CDR pointers.
2540            3. Usually, only one of the two channels (chan or peer)
2541               will change names.
2542            4. Usually, if a channel changes names during a bridge,
2543               it is because of a transfer. Usually, in these situations,
2544               it is normal to see 2 bridges running simultaneously, and
2545               it is not unusual to see the two channels that change
2546               swapped between bridges.
2547            5. After a bridge occurs, we have 2 or 3 channels' CDRs
2548               to attend to; if the chan or peer changed names,
2549               we have the before and after attached CDR's.
2550         */
2551         
2552         if (new_chan_cdr) {
2553                 struct ast_channel *chan_ptr = NULL;
2554  
2555                 if (strcasecmp(orig_channame, chan->name) != 0) { 
2556                         /* old channel */
2557                         chan_ptr = ast_get_channel_by_name_locked(orig_channame);
2558                         if (chan_ptr) {
2559                                 if (!ast_bridged_channel(chan_ptr)) {
2560                                         struct ast_cdr *cur;
2561                                         for (cur = chan_ptr->cdr; cur; cur = cur->next) {
2562                                                 if (cur == chan_cdr) {
2563                                                         break;
2564                                                 }
2565                                         }
2566                                         if (cur)
2567                                                 ast_cdr_specialized_reset(chan_cdr,0);
2568                                 }
2569                                 ast_channel_unlock(chan_ptr);
2570                         }
2571                         /* new channel */
2572                         ast_cdr_specialized_reset(new_chan_cdr,0);
2573                 } else {
2574                         ast_cdr_specialized_reset(chan_cdr,0); /* nothing changed, reset the chan_cdr  */
2575                 }
2576         }
2577         
2578         {
2579                 struct ast_channel *chan_ptr = NULL;
2580                 new_peer_cdr = pick_unlocked_cdr(peer->cdr); /* the proper chan cdr, if there are forked cdrs */
2581                 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))
2582                         ast_set_flag(new_peer_cdr, AST_CDR_FLAG_POST_DISABLED); /* DISABLED is viral-- it will propagate across a bridge */
2583                 if (strcasecmp(orig_peername, peer->name) != 0) { 
2584                         /* old channel */
2585                         chan_ptr = ast_get_channel_by_name_locked(orig_peername);
2586                         if (chan_ptr) {
2587                                 if (!ast_bridged_channel(chan_ptr)) {
2588                                         struct ast_cdr *cur;
2589                                         for (cur = chan_ptr->cdr; cur; cur = cur->next) {
2590                                                 if (cur == peer_cdr) {
2591                                                         break;
2592                                                 }
2593                                         }
2594                                         if (cur)
2595                                                 ast_cdr_specialized_reset(peer_cdr,0);
2596                                 }
2597                                 ast_channel_unlock(chan_ptr);
2598                         }
2599                         /* new channel */
2600                         ast_cdr_specialized_reset(new_peer_cdr,0);
2601                 } else {
2602                         ast_cdr_specialized_reset(peer_cdr,0); /* nothing changed, reset the peer_cdr  */
2603                 }
2604         }
2605         return res;
2606 }
2607
2608 /*! \brief Output parking event to manager */
2609 static void post_manager_event(const char *s, struct parkeduser *pu)
2610 {
2611         manager_event(EVENT_FLAG_CALL, s,
2612                 "Exten: %s\r\n"
2613                 "Channel: %s\r\n"
2614                 "Parkinglot: %s\r\n"
2615                 "CallerIDNum: %s\r\n"
2616                 "CallerIDName: %s\r\n"
2617                 "UniqueID: %s\r\n\r\n",
2618                 pu->parkingexten, 
2619                 pu->chan->name,
2620                 pu->parkinglot->name,
2621                 S_OR(pu->chan->cid.cid_num, "<unknown>"),
2622                 S_OR(pu->chan->cid.cid_name, "<unknown>"),
2623                 pu->chan->uniqueid
2624                 );
2625 }
2626
2627 /*! \brief Run management on parkinglots, called once per parkinglot */
2628 int manage_parkinglot(struct ast_parkinglot *curlot, fd_set *rfds, fd_set *efds, fd_set *nrfds, fd_set *nefds, int *ms, int *max)
2629 {
2630
2631         struct parkeduser *pu;
2632         int res = 0;
2633         char parkingslot[AST_MAX_EXTENSION];
2634
2635         /* Lock parking list */
2636         AST_LIST_LOCK(&curlot->parkings);
2637         AST_LIST_TRAVERSE_SAFE_BEGIN(&curlot->parkings, pu, list) {
2638                 struct ast_channel *chan = pu->chan;    /* shorthand */
2639                 int tms;        /* timeout for this item */
2640                 int x;          /* fd index in channel */
2641                 struct ast_context *con;
2642
2643                 if (pu->notquiteyet) { /* Pretend this one isn't here yet */
2644                         continue;
2645                 }
2646                 tms = ast_tvdiff_ms(ast_tvnow(), pu->start);
2647                 if (tms > pu->parkingtime) {
2648                         /* Stop music on hold */
2649                         ast_indicate(pu->chan, AST_CONTROL_UNHOLD);
2650                         /* Get chan, exten from derived kludge */
2651                         if (pu->peername[0]) {
2652                                 char *peername = ast_strdupa(pu->peername);
2653                                 char *cp = strrchr(peername, '-');
2654                                 char peername_flat[AST_MAX_EXTENSION]; /* using something like DAHDI/52 for an extension name is NOT a good idea */
2655                                 int i;
2656
2657                                 if (cp) 
2658                                         *cp = 0;
2659                                 ast_copy_string(peername_flat,peername,sizeof(peername_flat));
2660                                 for(i=0; peername_flat[i] && i < AST_MAX_EXTENSION; i++) {
2661                                         if (peername_flat[i] == '/') 
2662                                                 peername_flat[i]= '0';
2663                                 }
2664                                 con = ast_context_find_or_create(NULL, NULL, pu->parkinglot->parking_con_dial, registrar);
2665                                 if (!con) {
2666                                         ast_log(LOG_ERROR, "Parking dial context '%s' does not exist and unable to create\n", pu->parkinglot->parking_con_dial);
2667                                 }
2668                                 if (con) {
2669                                         char returnexten[AST_MAX_EXTENSION];
2670                                         struct ast_datastore *features_datastore;
2671                                         struct ast_dial_features *dialfeatures = NULL;
2672
2673                                         ast_channel_lock(chan);
2674
2675                                         if ((features_datastore = ast_channel_datastore_find(chan, &dial_features_info, NULL)))
2676                                                 dialfeatures = features_datastore->data;
2677
2678                                         ast_channel_unlock(chan);
2679
2680                                         if (dialfeatures)
2681                                                 snprintf(returnexten, sizeof(returnexten), "%s,,%s", peername, dialfeatures->options);
2682                                         else /* Existing default */
2683                                                 snprintf(returnexten, sizeof(returnexten), "%s,,t", peername);
2684
2685                                         ast_add_extension2(con, 1, peername_flat, 1, NULL, NULL, "Dial", ast_strdup(returnexten), ast_free_ptr, registrar);
2686                                 }
2687                                 if (comebacktoorigin) {
2688                                         set_c_e_p(chan, pu->parkinglot->parking_con_dial, peername_flat, 1);
2689                                 } else {
2690                                         ast_log(LOG_WARNING, "now going to parkedcallstimeout,s,1 | ps is %d\n",pu->parkingnum);
2691                                         snprintf(parkingslot, sizeof(parkingslot), "%d", pu->parkingnum);
2692                                         pbx_builtin_setvar_helper(chan, "PARKINGSLOT", parkingslot);
2693                                         set_c_e_p(chan, "parkedcallstimeout", peername_flat, 1);
2694                                 }
2695                         } else {
2696                                 /* They've been waiting too long, send them back to where they came.  Theoretically they
2697                                    should have their original extensions and such, but we copy to be on the safe side */
2698                                 set_c_e_p(chan, pu->context, pu->exten, pu->priority);
2699                         }
2700                         post_manager_event("ParkedCallTimeOut", pu);
2701
2702                         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);
2703                         /* Start up the PBX, or hang them up */
2704                         if (ast_pbx_start(chan))  {
2705                                 ast_log(LOG_WARNING, "Unable to restart the PBX for user on '%s', hanging them up...\n", pu->chan->name);
2706                                 ast_hangup(chan);
2707                         }
2708                         /* And take them out of the parking lot */
2709                         con = ast_context_find(pu->parkinglot->parking_con);
2710                         if (con) {
2711                                 if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL, 0))
2712                                         ast_log(LOG_WARNING, "Whoa, failed to remove the parking extension!\n");
2713                                 else
2714                                         notify_metermaids(pu->parkingexten, curlot->parking_con, AST_DEVICE_NOT_INUSE);
2715                         } else
2716                                 ast_log(LOG_WARNING, "Whoa, no parking context?\n");
2717                         AST_LIST_REMOVE_CURRENT(list);
2718                 } else {        /* still within parking time, process descriptors */
2719                         for (x = 0; x < AST_MAX_FDS; x++) {
2720                                 struct ast_frame *f;
2721
2722                                 if ((chan->fds[x] == -1) || (!FD_ISSET(chan->fds[x], rfds) && !FD_ISSET(pu->chan->fds[x], efds))) 
2723                                         continue;
2724                                 
2725                                 if (FD_ISSET(chan->fds[x], efds))
2726                                         ast_set_flag(chan, AST_FLAG_EXCEPTION);
2727                                 else
2728                                         ast_clear_flag(chan, AST_FLAG_EXCEPTION);
2729                                 chan->fdno = x;
2730
2731                                 /* See if they need servicing */
2732                                 f = ast_read(pu->chan);
2733                                 /* Hangup? */
2734                                 if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass ==  AST_CONTROL_HANGUP))) {
2735                                         if (f)
2736                                                 ast_frfree(f);
2737                                         post_manager_event("ParkedCallGiveUp", pu);
2738
2739                                         /* There's a problem, hang them up*/
2740                                         ast_verb(2, "%s got tired of being parked\n", chan->name);
2741                                         ast_hangup(chan);
2742                                         /* And take them out of the parking lot */
2743                                         con = ast_context_find(curlot->parking_con);
2744                                         if (con) {
2745                                                 if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL, 0))
2746                                                         ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
2747                                                 else
2748                                                         notify_metermaids(pu->parkingexten, curlot->parking_con, AST_DEVICE_NOT_INUSE);
2749                                         } else
2750                                                 ast_log(LOG_WARNING, "Whoa, no parking context for parking lot %s?\n", curlot->name);
2751                                         AST_LIST_REMOVE_CURRENT(list);
2752                                         break;
2753                                 } else {
2754                                         /* XXX Maybe we could do something with packets, like dial "0" for operator or something XXX */
2755                                         ast_frfree(f);
2756                                         if (pu->moh_trys < 3 && !chan->generatordata) {
2757                                                 ast_debug(1, "MOH on parked call stopped by outside source.  Restarting on channel %s.\n", chan->name);
2758                                                 ast_indicate_data(chan, AST_CONTROL_HOLD, 
2759                                                         S_OR(curlot->mohclass, NULL),
2760                                                         (!ast_strlen_zero(curlot->mohclass) ? strlen(curlot->mohclass) + 1 : 0));
2761                                                 pu->moh_trys++;
2762                                         }
2763                                         goto std;       /* XXX Ick: jumping into an else statement??? XXX */
2764                                 }
2765                         } /* End for */
2766                         if (x >= AST_MAX_FDS) {
2767 std:                            for (x=0; x<AST_MAX_FDS; x++) { /* mark fds for next round */
2768                                         if (chan->fds[x] > -1) {
2769                                                 FD_SET(chan->fds[x], nrfds);
2770                                                 FD_SET(chan->fds[x], nefds);
2771                                                 if (chan->fds[x] > *max)
2772                                                         *max = chan->fds[x];
2773                                         }
2774                                 }
2775                                 /* Keep track of our shortest wait */
2776                                 if (tms < *ms || *ms < 0)
2777                                         *ms = tms;
2778                         }
2779                 }
2780         }
2781         AST_LIST_TRAVERSE_SAFE_END;
2782         AST_LIST_UNLOCK(&curlot->parkings);
2783         return res;
2784 }
2785
2786 /*! 
2787  * \brief Take care of parked calls and unpark them if needed 
2788  * \param ignore unused var.
2789  * 
2790  * Start inf loop, lock parking lot, check if any parked channels have gone above timeout
2791  * if so, remove channel from parking lot and return it to the extension that parked it.
2792  * Check if parked channel decided to hangup, wait until next FD via select().
2793 */
2794 static void *do_parking_thread(void *ignore)
2795 {
2796         fd_set rfds, efds;      /* results from previous select, to be preserved across loops. */
2797         fd_set nrfds, nefds;    /* args for the next select */
2798         FD_ZERO(&rfds);
2799         FD_ZERO(&efds);
2800
2801         for (;;) {
2802                 int res = 0;
2803                 int ms = -1;    /* select timeout, uninitialized */
2804                 int max = -1;   /* max fd, none there yet */
2805                 struct ao2_iterator iter;
2806                 struct ast_parkinglot *curlot;
2807                 FD_ZERO(&nrfds);
2808                 FD_ZERO(&nefds);
2809                 iter = ao2_iterator_init(parkinglots, 0);
2810
2811                 while ((curlot = ao2_iterator_next(&iter))) {
2812                         res = manage_parkinglot(curlot, &rfds, &efds, &nrfds, &nefds, &ms, &max);
2813                         ao2_ref(curlot, -1);
2814                 }
2815
2816                 rfds = nrfds;
2817                 efds = nefds;
2818                 {
2819                         struct timeval wait = ast_samp2tv(ms, 1000);
2820                         /* Wait for something to happen */
2821                         ast_select(max + 1, &rfds, NULL, &efds, (ms > -1) ? &wait : NULL);
2822                 }
2823                 pthread_testcancel();
2824         }
2825         return NULL;    /* Never reached */
2826 }
2827
2828 /*! \brief Find parkinglot by name */
2829 struct ast_parkinglot *find_parkinglot(const char *name)
2830 {
2831         struct ast_parkinglot *parkinglot = NULL;
2832         struct ast_parkinglot tmp_parkinglot;
2833         
2834         if (ast_strlen_zero(name))
2835                 return NULL;
2836
2837         ast_copy_string(tmp_parkinglot.name, name, sizeof(tmp_parkinglot.name));
2838
2839         parkinglot = ao2_find(parkinglots, &tmp_parkinglot, OBJ_POINTER);
2840
2841         if (parkinglot && option_debug)
2842                 ast_log(LOG_DEBUG, "Found Parkinglot: %s\n", parkinglot->name);
2843
2844         return parkinglot;
2845 }
2846
2847 AST_APP_OPTIONS(park_call_options, BEGIN_OPTIONS
2848         AST_APP_OPTION('r', AST_PARK_OPT_RINGING),
2849         AST_APP_OPTION('R', AST_PARK_OPT_RANDOMIZE),
2850         AST_APP_OPTION('s', AST_PARK_OPT_SILENCE),
2851 END_OPTIONS );
2852
2853 /*! \brief Park a call */
2854 static int park_call_exec(struct ast_channel *chan, void *data)
2855 {
2856         /* Cache the original channel name in case we get masqueraded in the middle
2857          * of a park--it is still theoretically possible for a transfer to happen before
2858          * we get here, but it is _really_ unlikely */
2859         char *orig_chan_name = ast_strdupa(chan->name);
2860         char orig_exten[AST_MAX_EXTENSION];
2861         int orig_priority = chan->priority;
2862
2863         /* Data is unused at the moment but could contain a parking
2864            lot context eventually */
2865         int res = 0;
2866
2867         char *parse = NULL;
2868         AST_DECLARE_APP_ARGS(app_args,
2869                 AST_APP_ARG(timeout);
2870                 AST_APP_ARG(return_con);
2871                 AST_APP_ARG(return_ext);
2872                 AST_APP_ARG(return_pri);
2873                 AST_APP_ARG(options);
2874         );
2875
2876         parse = ast_strdupa(data);
2877         AST_STANDARD_APP_ARGS(app_args, parse);
2878
2879         ast_copy_string(orig_exten, chan->exten, sizeof(orig_exten));
2880
2881         /* Setup the exten/priority to be s/1 since we don't know
2882            where this call should return */
2883         strcpy(chan->exten, "s");
2884         chan->priority = 1;
2885
2886         /* Answer if call is not up */
2887         if (chan->_state != AST_STATE_UP)
2888                 res = ast_answer(chan);
2889
2890         /* Sleep to allow VoIP streams to settle down */
2891         if (!res)
2892                 res = ast_safe_sleep(chan, 1000);
2893
2894         /* Park the call */
2895         if (!res) {
2896                 struct ast_park_call_args args = {
2897                         .orig_chan_name = orig_chan_name,
2898                 };
2899                 struct ast_flags flags = { 0 };
2900
2901                 if (parse) {
2902                         if (!ast_strlen_zero(app_args.timeout)) {
2903                                 if (sscanf(app_args.timeout, "%d", &args.timeout) != 1) {
2904                                         ast_log(LOG_WARNING, "Invalid timeout '%s' provided\n", app_args.timeout);
2905                                         args.timeout = 0;
2906                                 }
2907                         }
2908                         if (!ast_strlen_zero(app_args.return_con)) {
2909                                 args.return_con = app_args.return_con;
2910                         }
2911                         if (!ast_strlen_zero(app_args.return_ext)) {
2912                                 args.return_ext = app_args.return_ext;
2913                         }
2914                         if (!ast_strlen_zero(app_args.return_pri)) {
2915                                 if (sscanf(app_args.return_pri, "%d", &args.return_pri) != 1) {
2916                                         ast_log(LOG_WARNING, "Invalid priority '%s' specified\n", app_args.return_pri);
2917                                         args.return_pri = 0;
2918                                 }
2919                         }
2920                 }
2921
2922                 ast_app_parse_options(park_call_options, &flags, NULL, app_args.options);
2923                 args.flags = flags.flags;
2924
2925                 res = ast_park_call_full(chan, chan, &args); /* In experiments, using the masq_park_call
2926                                                                                                            func here yielded no difference with 
2927                                                                                                            current implementation. I saw no advantage
2928                                                                                                            in calling it instead.
2929                                                                                                          */
2930                 /* Continue on in the dialplan */
2931                 if (res == 1) {
2932                         ast_copy_string(chan->exten, orig_exten, sizeof(chan->exten));
2933                         chan->priority = orig_priority;
2934                         res = 0;
2935                 } else if (!res) {
2936                         res = 1;
2937                 }
2938         }
2939
2940         return res;
2941 }
2942
2943 /*! \brief Pickup parked call */
2944 static int park_exec_full(struct ast_channel *chan, void *data, struct ast_parkinglot *parkinglot)
2945 {
2946         int res = 0;
2947         struct ast_channel *peer=NULL;
2948         struct parkeduser *pu;
2949         struct ast_context *con;
2950         int park = 0;
2951         struct ast_bridge_config config;
2952
2953         if (data)
2954                 park = atoi((char *)data);
2955
2956         parkinglot = find_parkinglot(findparkinglotname(chan));         
2957         if (!parkinglot)
2958                 parkinglot = default_parkinglot;
2959
2960         AST_LIST_LOCK(&parkinglot->parkings);
2961         AST_LIST_TRAVERSE_SAFE_BEGIN(&parkinglot->parkings, pu, list) {
2962                 if (!data || pu->parkingnum == park) {
2963                         if (pu->chan->pbx) { /* do not allow call to be picked up until the PBX thread is finished */
2964                                 AST_LIST_UNLOCK(&parkinglot->parkings);
2965                                 return -1;
2966                         }
2967                         AST_LIST_REMOVE_CURRENT(list);
2968                         break;
2969                 }
2970         }
2971         AST_LIST_TRAVERSE_SAFE_END
2972         AST_LIST_UNLOCK(&parkinglot->parkings);
2973
2974         if (pu) {
2975                 peer = pu->chan;
2976                 con = ast_context_find(parkinglot->parking_con);
2977                 if (con) {
2978                         if (ast_context_remove_extension2(con, pu->parkingexten, 1, NULL, 0))
2979                                 ast_log(LOG_WARNING, "Whoa, failed to remove the extension!\n");
2980                         else
2981                                 notify_metermaids(pu->parkingexten, parkinglot->parking_con, AST_DEVICE_NOT_INUSE);
2982                 } else
2983                         ast_log(LOG_WARNING, "Whoa, no parking context?\n");
2984
2985                 manager_event(EVENT_FLAG_CALL, "UnParkedCall",
2986                         "Exten: %s\r\n"
2987                         "Channel: %s\r\n"
2988                         "From: %s\r\n"
2989                         "CallerIDNum: %s\r\n"
2990                         "CallerIDName: %s\r\n",
2991                         pu->parkingexten, pu->chan->name, chan->name,
2992                         S_OR(pu->chan->cid.cid_num, "<unknown>"),
2993                         S_OR(pu->chan->cid.cid_name, "<unknown>")
2994                         );
2995
2996                 ast_free(pu);
2997         }
2998         /* JK02: it helps to answer the channel if not already up */
2999         if (chan->_state != AST_STATE_UP)
3000                 ast_answer(chan);
3001
3002         //XXX Why do we unlock here ?
3003         // uncomment it for now, till my setup with debug_threads and detect_deadlocks starts to complain
3004         //ASTOBJ_UNLOCK(parkinglot);
3005
3006         if (peer) {
3007                 /* Play a courtesy to the source(s) configured to prefix the bridge connecting */
3008                 
3009                 if (!ast_strlen_zero(courtesytone)) {
3010                         int error = 0;
3011                         ast_indicate(peer, AST_CONTROL_UNHOLD);
3012                         if (parkedplay == 0) {
3013                                 error = ast_stream_and_wait(chan, courtesytone, "");
3014                         } else if (parkedplay == 1) {
3015                                 error = ast_stream_and_wait(peer, courtesytone, "");
3016                         } else if (parkedplay == 2) {
3017                                 if (!ast_streamfile(chan, courtesytone, chan->language) &&
3018                                                 !ast_streamfile(peer, courtesytone, chan->language)) {
3019                                         /*! \todo XXX we would like to wait on both! */
3020                                         res = ast_waitstream(chan, "");
3021                                         if (res >= 0)
3022                                                 res = ast_waitstream(peer, "");
3023                                         if (res < 0)
3024                                                 error = 1;
3025                                 }
3026                         }
3027                         if (error) {
3028                                 ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
3029                                 ast_hangup(peer);
3030                                 return -1;
3031                         }
3032                 } else
3033                         ast_indicate(peer, AST_CONTROL_UNHOLD); 
3034
3035                 res = ast_channel_make_compatible(chan, peer);
3036                 if (res < 0) {
3037                         ast_log(LOG_WARNING, "Could not make channels %s and %s compatible for bridge\n", chan->name, peer->name);
3038                         ast_hangup(peer);
3039                         return -1;
3040                 }
3041                 /* This runs sorta backwards, since we give the incoming channel control, as if it
3042                    were the person called. */
3043                 ast_verb(3, "Channel %s connected to parked call %d\n", chan->name, park);
3044
3045                 pbx_builtin_setvar_helper(chan, "PARKEDCHANNEL", peer->name);
3046                 ast_cdr_setdestchan(chan->cdr, peer->name);
3047                 memset(&config, 0, sizeof(struct ast_bridge_config));
3048                 if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH))
3049                         ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
3050                 if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH))
3051                         ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
3052                 if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH))
3053                         ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
3054                 if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH))
3055                         ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
3056                 res = ast_bridge_call(chan, peer, &config);
3057
3058                 pbx_builtin_setvar_helper(chan, "PARKEDCHANNEL", peer->name);
3059                 ast_cdr_setdestchan(chan->cdr, peer->name);
3060
3061                 /* Simulate the PBX hanging up */
3062                 ast_hangup(peer);
3063                 return res;
3064         } else {
3065                 /*! \todo XXX Play a message XXX */
3066                 if (ast_stream_and_wait(chan, "pbx-invalidpark", ""))
3067                         ast_log(LOG_WARNING, "ast_streamfile of %s failed on %s\n", "pbx-invalidpark", chan->name);
3068                 ast_verb(3, "Channel %s tried to talk to nonexistent parked call %d\n", chan->name, park);
3069                 res = -1;
3070         }
3071
3072         return res;
3073 }
3074
3075 static int park_exec(struct ast_channel *chan, void *data) 
3076 {
3077         return park_exec_full(chan, data, default_parkinglot);
3078 }
3079
3080 /*! \brief Unreference parkinglot object. If no more references,
3081         then go ahead and delete it */
3082 static void parkinglot_unref(struct ast_parkinglot *parkinglot) 
3083 {
3084         int refcount = ao2_ref(parkinglot, -1);
3085         if (option_debug > 2)
3086                 ast_log(LOG_DEBUG, "Multiparking: %s refcount now %d\n", parkinglot->name, refcount - 1);
3087 }
3088
3089 static struct ast_parkinglot *parkinglot_addref(struct ast_parkinglot *parkinglot)
3090 {
3091         int refcount = ao2_ref(parkinglot, +1);
3092         if (option_debug > 2)
3093                 ast_log(LOG_DEBUG, "Multiparking: %s refcount now %d\n", parkinglot->name, refcount + 1);
3094         return parkinglot;
3095 }
3096
3097 /*! \brief Allocate parking lot structure */
3098 static struct ast_parkinglot *create_parkinglot(char *name)
3099 {
3100         struct ast_parkinglot *newlot = (struct ast_parkinglot *) NULL;
3101
3102         if (!name)
3103                 return NULL;
3104
3105         newlot = ao2_alloc(sizeof(*newlot), parkinglot_destroy);
3106         if (!newlot)
3107                 return NULL;
3108         
3109         ast_copy_string(newlot->name, name, sizeof(newlot->name));
3110
3111         return newlot;
3112 }
3113
3114 /*! \brief Destroy a parking lot */
3115 static void parkinglot_destroy(void *obj)
3116 {
3117         struct ast_parkinglot *ruin = obj;
3118         struct ast_context *con;
3119         con = ast_context_find(ruin->parking_con);
3120         if (con)
3121                 ast_context_destroy(con, registrar);
3122         ao2_unlink(parkinglots, ruin);
3123 }
3124
3125 /*! \brief Build parkinglot from configuration and chain it in */
3126 static struct ast_parkinglot *build_parkinglot(char *name, struct ast_variable *var)
3127 {
3128         struct ast_parkinglot *parkinglot;
3129         struct ast_context *con = NULL;
3130
3131         struct ast_variable *confvar = var;
3132         int error = 0;
3133         int start = 0, end = 0;
3134         int oldparkinglot = 0;
3135
3136         parkinglot = find_parkinglot(name);
3137         if (parkinglot)
3138                 oldparkinglot = 1;
3139         else
3140                 parkinglot = create_parkinglot(name);
3141
3142         if (!parkinglot)
3143                 return NULL;
3144
3145         ao2_lock(parkinglot);
3146
3147         if (option_debug)
3148                 ast_log(LOG_DEBUG, "Building parking lot %s\n", name);
3149         
3150         /* Do some config stuff */
3151         while(confvar) {
3152                 if (!strcasecmp(confvar->name, "context")) {
3153                         ast_copy_string(parkinglot->parking_con, confvar->value, sizeof(parkinglot->parking_con));
3154                 } else if (!strcasecmp(confvar->name, "parkingtime")) {
3155                         if ((sscanf(confvar->value, "%d", &parkinglot->parkingtime) != 1) || (parkinglot->parkingtime < 1)) {
3156                                 ast_log(LOG_WARNING, "%s is not a valid parkingtime\n", confvar->value);
3157                                 parkinglot->parkingtime = DEFAULT_PARK_TIME;
3158                         } else
3159                                 parkinglot->parkingtime = parkinglot->parkingtime * 1000;
3160                 } else if (!strcasecmp(confvar->name, "parkpos")) {
3161                         if (sscanf(confvar->value, "%d-%d", &start, &end) != 2) {
3162                                 ast_log(LOG_WARNING, "Format for parking positions is a-b, where a and b are numbers at line %d of parking.conf\n", confvar->lineno);
3163                                 error = 1;
3164                         } else {
3165                                 parkinglot->parking_start = start;
3166                                 parkinglot->parking_stop = end;
3167                         }
3168                 } else if (!strcasecmp(confvar->name, "findslot")) {
3169                         parkinglot->parkfindnext = (!strcasecmp(confvar->value, "next"));
3170                 }
3171                 confvar = confvar->next;
3172         }
3173         /* make sure parkingtime is set if not specified */
3174         if (parkinglot->parkingtime == 0) {
3175                 parkinglot->parkingtime = DEFAULT_PARK_TIME;
3176         }
3177
3178         if (!var) {     /* Default parking lot */
3179                 ast_copy_string(parkinglot->parking_con, "parkedcalls", sizeof(parkinglot->parking_con));
3180                 ast_copy_string(parkinglot->parking_con_dial, "park-dial", sizeof(parkinglot->parking_con_dial));
3181                 ast_copy_string(parkinglot->mohclass, "default", sizeof(parkinglot->mohclass));
3182         }
3183
3184         /* Check for errors */
3185         if (ast_strlen_zero(parkinglot->parking_con)) {
3186                 ast_log(LOG_WARNING, "Parking lot %s lacks context\n", name);
3187                 error = 1;
3188         }
3189
3190         /* Create context */
3191         if (!error && !(con = ast_context_find_or_create(NULL, NULL, parkinglot->parking_con, registrar))) {
3192                 ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parkinglot->parking_con);
3193                 error = 1;
3194         }
3195
3196         /* Add a parking extension into the context */
3197         if (!oldparkinglot) {
3198                 if (!ast_strlen_zero(ast_parking_ext())) {
3199                         if (ast_add_extension2(con, 1, ast_parking_ext(), 1, NULL, NULL, parkcall, strdup(""), ast_free, registrar) == -1)
3200                                 error = 1;
3201                 }
3202         }
3203
3204         ao2_unlock(parkinglot);
3205
3206         if (error) {
3207                 ast_log(LOG_WARNING, "Parking %s not open for business. Configuration error.\n", name);
3208                 parkinglot_destroy(parkinglot);
3209                 return NULL;
3210         }
3211         if (option_debug)
3212                 ast_log(LOG_DEBUG, "Parking %s now open for business. (start exten %d end %d)\n", name, start, end);
3213
3214
3215         /* Move it into the list, if it wasn't already there */
3216         if (!oldparkinglot) {
3217                 ao2_link(parkinglots, parkinglot);
3218         }
3219         parkinglot_unref(parkinglot);
3220
3221         return parkinglot;
3222 }
3223
3224
3225 /*! 
3226  * \brief Add parking hints for all defined parking lots 
3227  * \param context
3228  * \param start starting parkinglot number
3229  * \param stop ending parkinglot number
3230 */
3231 static void park_add_hints(char *context, int start, int stop)
3232 {
3233         int numext;
3234         char device[AST_MAX_EXTENSION];
3235         char exten[10];
3236
3237         for (numext = start; numext <= stop; numext++) {
3238                 snprintf(exten, sizeof(exten), "%d", numext);
3239                 snprintf(device, sizeof(device), "park:%s@%s", exten, context);
3240                 ast_add_extension(context, 1, exten, PRIORITY_HINT, NULL, NULL, device, NULL, NULL, registrar);
3241         }
3242 }
3243
3244 static int load_config(void) 
3245 {
3246         int start = 0, end = 0;
3247         int res;
3248         int i;
3249         struct ast_context *con = NULL;
3250         struct ast_config *cfg = NULL;
3251         struct ast_variable *var = NULL;
3252         struct feature_group *fg = NULL;
3253         struct ast_flags config_flags = { 0 };
3254         char old_parking_ext[AST_MAX_EXTENSION];
3255         char old_parking_con[AST_MAX_EXTENSION] = "";
3256         char *ctg; 
3257         static const char *categories[] = { 
3258                 /* Categories in features.conf that are not
3259                  * to be parsed as group categories
3260                  */
3261                 "general",
3262                 "featuremap",
3263                 "applicationmap"
3264         };
3265
3266         if (default_parkinglot) {
3267                 strcpy(old_parking_con, default_parkinglot->parking_con);
3268                 strcpy(old_parking_ext, parking_ext);
3269         } else {
3270                 default_parkinglot = build_parkinglot(DEFAULT_PARKINGLOT, NULL);
3271                 if (default_parkinglot) {
3272                         ao2_lock(default_parkinglot);
3273                         default_parkinglot->parking_start = 701;
3274                         default_parkinglot->parking_stop = 750;
3275                         default_parkinglot->parking_offset = 0;
3276                         default_parkinglot->parkfindnext = 0;
3277                         default_parkinglot->parkingtime = DEFAULT_PARK_TIME;
3278                         ao2_unlock(default_parkinglot);
3279                 }
3280         }
3281         if (default_parkinglot) {
3282                 if (option_debug)
3283                         ast_log(LOG_DEBUG, "Configuration of default parkinglot done.\n");
3284         } else {
3285                 ast_log(LOG_ERROR, "Configuration of default parkinglot failed.\n");
3286                 return -1;
3287         }
3288         
3289
3290         /* Reset to defaults */
3291         strcpy(parking_ext, "700");
3292         strcpy(pickup_ext, "*8");
3293         courtesytone[0] = '\0';
3294         strcpy(xfersound, "beep");
3295         strcpy(xferfailsound, "pbx-invalid");
3296         adsipark = 0;
3297         comebacktoorigin = 1;
3298
3299         default_parkinglot->parkaddhints = 0;
3300         default_parkinglot->parkedcalltransfers = 0;
3301         default_parkinglot->parkedcallreparking = 0;
3302
3303         transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT;
3304         featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT;
3305         atxfernoanswertimeout = DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER;
3306         atxferloopdelay = DEFAULT_ATXFER_LOOP_DELAY;
3307         atxferdropcall = DEFAULT_ATXFER_DROP_CALL;
3308         atxfercallbackretries = DEFAULT_ATXFER_CALLBACK_RETRIES;
3309
3310         cfg = ast_config_load2("features.conf", "features", config_flags);
3311         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
3312                 ast_log(LOG_WARNING,"Could not load features.conf\n");
3313                 return 0;
3314         }
3315         for (var = ast_variable_browse(cfg, "general"); var; var = var->next) {
3316                 if (!strcasecmp(var->name, "parkext")) {
3317                         ast_copy_string(parking_ext, var->value, sizeof(parking_ext));
3318                 } else if (!strcasecmp(var->name, "context")) {
3319                         ast_copy_string(default_parkinglot->parking_con, var->value, sizeof(default_parkinglot->parking_con));
3320                 } else if (!strcasecmp(var->name, "parkingtime")) {
3321                         if ((sscanf(var->value, "%d", &default_parkinglot->parkingtime) != 1) || (default_parkinglot->parkingtime < 1)) {
3322                                 ast_log(LOG_WARNING, "%s is not a valid parkingtime\n", var->value);
3323                                 default_parkinglot->parkingtime = DEFAULT_PARK_TIME;
3324                         } else
3325                                 default_parkinglot->parkingtime = default_parkinglot->parkingtime * 1000;
3326                 } else if (!strcasecmp(var->name, "parkpos")) {
3327                         if (sscanf(var->value, "%d-%d", &start, &end) != 2) {
3328                                 ast_log(LOG_WARNING, "Format for parking positions is a-b, where a and b are numbers at line %d of features.conf\n", var->lineno);
3329                         } else if (default_parkinglot) {
3330                                 default_parkinglot->parking_start = start;
3331                                 default_parkinglot->parking_stop = end;
3332                         } else {
3333                                 ast_log(LOG_WARNING, "No default parking lot!\n");
3334                         }
3335                 } else if (!strcasecmp(var->name, "findslot")) {
3336                         default_parkinglot->parkfindnext = (!strcasecmp(var->value, "next"));
3337                 } else if (!strcasecmp(var->name, "parkinghints")) {
3338                         default_parkinglot->parkaddhints = ast_true(var->value);
3339                 } else if (!strcasecmp(var->name, "parkedcalltransfers")) {
3340                         if (!strcasecmp(var->value, "both"))
3341                                 default_parkinglot->parkedcalltransfers = AST_FEATURE_FLAG_BYBOTH;
3342                         else if (!strcasecmp(var->value, "caller"))
3343                                 default_parkinglot->parkedcalltransfers = AST_FEATURE_FLAG_BYCALLER;
3344                         else if (!strcasecmp(var->value, "callee"))
3345                                 default_parkinglot->parkedcalltransfers = AST_FEATURE_FLAG_BYCALLEE;
3346                 } else if (!strcasecmp(var->name, "parkedcallreparking")) {
3347                         if (!strcasecmp(var->value, "both"))
3348                                 default_parkinglot->parkedcallreparking = AST_FEATURE_FLAG_BYBOTH;
3349                         else if (!strcasecmp(var->value, "caller"))
3350                                 default_parkinglot->parkedcallreparking = AST_FEATURE_FLAG_BYCALLER;
3351                         else if (!strcasecmp(var->value, "callee"))
3352                                 default_parkinglot->parkedcallreparking = AST_FEATURE_FLAG_BYCALLEE;
3353                 } else if (!strcasecmp(var->name, "adsipark")) {
3354                         adsipark = ast_true(var->value);
3355                 } else if (!strcasecmp(var->name, "transferdigittimeout")) {
3356                         if ((sscanf(var->value, "%d", &transferdigittimeout) != 1) || (transferdigittimeout < 1)) {
3357                                 ast_log(LOG_WARNING, "%s is not a valid transferdigittimeout\n", var->value);
3358                                 transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT;
3359                         } else
3360                                 transferdigittimeout = transferdigittimeout * 1000;
3361                 } else if (!strcasecmp(var->name, "featuredigittimeout")) {
3362                         if ((sscanf(var->value, "%d", &featuredigittimeout) != 1) || (featuredigittimeout < 1)) {
3363                                 ast_log(LOG_WARNING, "%s is not a valid featuredigittimeout\n", var->value);
3364                                 featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT;
3365                         }
3366                 } else if (!strcasecmp(var->name, "atxfernoanswertimeout")) {
3367                         if ((sscanf(var->value, "%d", &atxfernoanswertimeout) != 1) || (atxfernoanswertimeout < 1)) {
3368                                 ast_log(LOG_WARNING, "%s is not a valid atxfernoanswertimeout\n", var->value);
3369                                 atxfernoanswertimeout = DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER;
3370                         } else
3371                                 atxfernoanswertimeout = atxfernoanswertimeout * 1000;
3372                 } else if (!strcasecmp(var->name, "atxferloopdelay")) {
3373                         if ((sscanf(var->value, "%u", &atxferloopdelay) != 1)) {
3374                                 ast_log(LOG_WARNING, "%s is not a valid atxferloopdelay\n", var->value);
3375                                 atxferloopdelay = DEFAULT_ATXFER_LOOP_DELAY;
3376                         } else 
3377                                 atxferloopdelay *= 1000;
3378                 } else if (!strcasecmp(var->name, "atxferdropcall")) {
3379                         atxferdropcall = ast_true(var->value);
3380                 } else if (!strcasecmp(var->name, "atxfercallbackretries")) {
3381                         if ((sscanf(var->value, "%u", &atxferloopdelay) != 1)) {
3382                                 ast_log(LOG_WARNING, "%s is not a valid atxfercallbackretries\n", var->value);
3383                                 atxfercallbackretries = DEFAULT_ATXFER_CALLBACK_RETRIES;
3384                         }
3385                 } else if (!strcasecmp(var->name, "courtesytone")) {
3386                         ast_copy_string(courtesytone, var->value, sizeof(courtesytone));
3387                 }  else if (!strcasecmp(var->name, "parkedplay")) {
3388                         if (!strcasecmp(var->value, "both"))
3389                                 parkedplay = 2;
3390                         else if (!strcasecmp(var->value, "parked"))
3391                                 parkedplay = 1;
3392                         else
3393                                 parkedplay = 0;
3394                 } else if (!strcasecmp(var->name, "xfersound")) {
3395                         ast_copy_string(xfersound, var->value, sizeof(xfersound));
3396                 } else if (!strcasecmp(var->name, "xferfailsound")) {
3397                         ast_copy_string(xferfailsound, var->value, sizeof(xferfailsound));
3398                 } else if (!strcasecmp(var->name, "pickupexten")) {
3399                         ast_copy_string(pickup_ext, var->value, sizeof(pickup_ext));
3400                 } else if (!strcasecmp(var->name, "comebacktoorigin")) {
3401                         comebacktoorigin = ast_true(var->value);
3402