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