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