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