Sat Nov 1 06:28:36 2008

Asterisk developer's documentation

---

res_features.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Routines implementing call features as call pickup, parking and transfer
 *
 * \author Mark Spencer <markster@digium.com> 
 */

/*** MODULEINFO
        <depend>chan_local</depend>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 153270 $")

#include <pthread.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <netinet/in.h>

#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/causes.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/app.h"
#include "asterisk/say.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/utils.h"
#include "asterisk/adsi.h"
#include "asterisk/devicestate.h"
#include "asterisk/monitor.h"
#include "asterisk/global_datastores.h"

#define DEFAULT_PARK_TIME 45000
#define DEFAULT_TRANSFER_DIGIT_TIMEOUT 3000
#define DEFAULT_FEATURE_DIGIT_TIMEOUT 500
#define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER 15000

#define AST_MAX_WATCHERS 256

enum {
   AST_FEATURE_FLAG_NEEDSDTMF = (1 << 0),
   AST_FEATURE_FLAG_ONPEER =    (1 << 1),
   AST_FEATURE_FLAG_ONSELF =    (1 << 2),
   AST_FEATURE_FLAG_BYCALLEE =  (1 << 3),
   AST_FEATURE_FLAG_BYCALLER =  (1 << 4),
   AST_FEATURE_FLAG_BYBOTH  =   (3 << 3),
};

static char *parkedcall = "ParkedCall";

static int parkaddhints = 0;                               /*!< Add parking hints automatically */
static int parkingtime = DEFAULT_PARK_TIME;                /*!< No more than 45 seconds parked before you do something with them */
static char parking_con[AST_MAX_EXTENSION];                /*!< Context for which parking is made accessible */
static char parking_con_dial[AST_MAX_EXTENSION];           /*!< Context for dialback for parking (KLUDGE) */
static char parking_ext[AST_MAX_EXTENSION];                /*!< Extension you type to park the call */
static char pickup_ext[AST_MAX_EXTENSION];                 /*!< Call pickup extension */
static char parkmohclass[MAX_MUSICCLASS];                  /*!< Music class used for parking */
static int parking_start;                                  /*!< First available extension for parking */
static int parking_stop;                                   /*!< Last available extension for parking */

static int parkedcalltransfers;                            /*!< Who can REDIRECT after picking up a parked a call */

static char courtesytone[256];                             /*!< Courtesy tone */
static int parkedplay = 0;                                 /*!< Who to play the courtesy tone to */
static char xfersound[256];                                /*!< Call transfer sound */
static char xferfailsound[256];                            /*!< Call transfer failure sound */

static int parking_offset;
static int parkfindnext;

static int adsipark;

static int transferdigittimeout;
static int featuredigittimeout;

static int atxfernoanswertimeout;

static char *registrar = "res_features";        /*!< Registrar for operations */

/* module and CLI command definitions */
static char *synopsis = "Answer a parked call";

static char *descrip = "ParkedCall(exten):"
"Used to connect to a parked call.  This application is always\n"
"registered internally and does not need to be explicitly added\n"
"into the dialplan, although you should include the 'parkedcalls'\n"
"context.\n";

static char *parkcall = PARK_APP_NAME;

static char *synopsis2 = "Park yourself";

static char *descrip2 = "Park():"
"Used to park yourself (typically in combination with a supervised\n"
"transfer to know the parking space). This application is always\n"
"registered internally and does not need to be explicitly added\n"
"into the dialplan, although you should include the 'parkedcalls'\n"
"context (or the context specified in features.conf).\n\n"
"If you set the PARKINGEXTEN variable to an extension in your\n"
"parking context, park() will park the call on that extension, unless\n"
"it already exists. In that case, execution will continue at next\n"
"priority.\n" ;

static struct ast_app *monitor_app = NULL;
static int monitor_ok = 1;

struct parkeduser {
   struct ast_channel *chan;                   /*!< Parking channel */
   struct timeval start;                       /*!< Time the parking started */
   int parkingnum;                             /*!< Parking lot */
   char parkingexten[AST_MAX_EXTENSION];       /*!< If set beforehand, parking extension used for this call */
   char context[AST_MAX_CONTEXT];              /*!< Where to go if our parking time expires */
   char exten[AST_MAX_EXTENSION];
   int priority;
   int parkingtime;                            /*!< Maximum length in parking lot before return */
   int notquiteyet;
   char peername[1024];
   unsigned char moh_trys;
   struct parkeduser *next;
};

static struct parkeduser *parkinglot;

AST_MUTEX_DEFINE_STATIC(parking_lock); /*!< protects all static variables above */

static pthread_t parking_thread;

char *ast_parking_ext(void)
{
   return parking_ext;
}

char *ast_pickup_ext(void)
{
   return pickup_ext;
}

struct ast_bridge_thread_obj 
{
   struct ast_bridge_config bconfig;
   struct ast_channel *chan;
   struct ast_channel *peer;
};



/*! \brief store context, priority and extension */
static void set_c_e_p(struct ast_channel *chan, const char *context, const char *ext, int pri)
{
   ast_copy_string(chan->context, context, sizeof(chan->context));
   ast_copy_string(chan->exten, ext, sizeof(chan->exten));
   chan->priority = pri;
}

static void check_goto_on_transfer(struct ast_channel *chan) 
{
   struct ast_channel *xferchan;
   const char *val = pbx_builtin_getvar_helper(chan, "GOTO_ON_BLINDXFR");
   char *x, *goto_on_transfer;
   struct ast_frame *f;

   if (ast_strlen_zero(val))
      return;

   goto_on_transfer = ast_strdupa(val);

   if (!(xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", 0, chan->name)))
      return;

   for (x = goto_on_transfer; x && *x; x++) {
      if (*x == '^')
         *x = '|';
   }
   /* Make formats okay */
   xferchan->readformat = chan->readformat;
   xferchan->writeformat = chan->writeformat;
   ast_channel_masquerade(xferchan, chan);
   ast_parseable_goto(xferchan, goto_on_transfer);
   xferchan->_state = AST_STATE_UP;
   ast_clear_flag(xferchan, AST_FLAGS_ALL);  
   xferchan->_softhangup = 0;
   if ((f = ast_read(xferchan))) {
      ast_frfree(f);
      f = NULL;
      ast_pbx_start(xferchan);
   } else {
      ast_hangup(xferchan);
   }
}

static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *caller, const char *type, int format, void *data, int timeout, int *outstate, const char *cid_num, const char *cid_name, const char *language);


static void *ast_bridge_call_thread(void *data) 
{
   struct ast_bridge_thread_obj *tobj = data;

   tobj->chan->appl = "Transferred Call";
   tobj->chan->data = tobj->peer->name;
   tobj->peer->appl = "Transferred Call";
   tobj->peer->data = tobj->chan->name;

   ast_bridge_call(tobj->peer, tobj->chan, &tobj->bconfig);
   ast_hangup(tobj->chan);
   ast_hangup(tobj->peer);
   bzero(tobj, sizeof(*tobj)); /*! \todo XXX for safety */
   free(tobj);
   return NULL;
}

static void ast_bridge_call_thread_launch(void *data) 
{
   pthread_t thread;
   pthread_attr_t attr;
   struct sched_param sched;

   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   ast_pthread_create(&thread, &attr,ast_bridge_call_thread, data);
   pthread_attr_destroy(&attr);
   memset(&sched, 0, sizeof(sched));
   pthread_setschedparam(thread, SCHED_RR, &sched);
}

static int adsi_announce_park(struct ast_channel *chan, char *parkingexten)
{
   int res;
   int justify[5] = {ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT, ADSI_JUST_CENT};
   char tmp[256];
   char *message[5] = {NULL, NULL, NULL, NULL, NULL};

   snprintf(tmp, sizeof(tmp), "Parked on %s", parkingexten);
   message[0] = tmp;
   res = ast_adsi_load_session(chan, NULL, 0, 1);
   if (res == -1)
      return res;
   return ast_adsi_print(chan, message, justify, 1);
}

/*! \brief Notify metermaids that we've changed an extension */
static void notify_metermaids(char *exten, char *context)
{
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "Notification of state change to metermaids %s@%s\n", exten, context);

   /* Send notification to devicestate subsystem */
   ast_device_state_changed("park:%s@%s", exten, context);
   return;
}

/*! \brief metermaids callback from devicestate.c */
static int metermaidstate(const char *data)
{
   int res = AST_DEVICE_INVALID;
   char *context = ast_strdupa(data);
   char *exten;

   exten = strsep(&context, "@");
   if (!context)
      return res;
   
   if (option_debug > 3)
      ast_log(LOG_DEBUG, "Checking state of exten %s in context %s\n", exten, context);

   res = ast_exists_extension(NULL, context, exten, 1, NULL);

   if (!res)
      return AST_DEVICE_NOT_INUSE;
   else
      return AST_DEVICE_INUSE;
}

static int park_call_full(struct ast_channel *chan, struct ast_channel *peer, int timeout, int *extout, char *orig_chan_name)
{
   struct parkeduser *pu, *cur;
   int i, x = -1, parking_range, parkingnum_copy;
   struct ast_context *con;
   const char *parkingexten;
   
   /* Allocate memory for parking data */
   if (!(pu = ast_calloc(1, sizeof(*pu)))) 
      return -1;

   /* Lock parking lot */
   ast_mutex_lock(&parking_lock);
   /* Check for channel variable PARKINGEXTEN */
   parkingexten = pbx_builtin_getvar_helper(chan, "PARKINGEXTEN");
   if (!ast_strlen_zero(parkingexten)) {
      /*!\note The API forces us to specify a numeric parking slot, even
       * though the architecture would tend to support non-numeric extensions
       * (as are possible with SIP, for example).  Hence, we enforce that
       * limitation here.  If extout was not numeric, we could permit
       * arbitrary non-numeric extensions.
       */
      if (sscanf(parkingexten, "%d", &x) != 1 || x < 0) {
         ast_log(LOG_WARNING, "PARKINGEXTEN does not indicate a valid parking slot: '%s'.\n", parkingexten);
         ast_mutex_unlock(&parking_lock);
         free(pu);
         return 1;   /* Continue execution if possible */
      }
      snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", x);

      if (ast_exists_extension(NULL, parking_con, pu->parkingexten, 1, NULL)) {
         ast_mutex_unlock(&parking_lock);
         free(pu);
         ast_log(LOG_WARNING, "Requested parking extension already exists: %s@%s\n", parkingexten, parking_con);
         return 1;   /* Continue execution if possible */
      }
   } else {
      /* Select parking space within range */
      parking_range = parking_stop - parking_start+1;
      for (i = 0; i < parking_range; i++) {
         x = (i + parking_offset) % parking_range + parking_start;
         cur = parkinglot;
         while(cur) {
            if (cur->parkingnum == x) 
               break;
            cur = cur->next;
         }
         if (!cur)
            break;
      }

      if (!(i < parking_range)) {
         ast_log(LOG_WARNING, "No more parking spaces\n");
         free(pu);
         ast_mutex_unlock(&parking_lock);
         return -1;
      }
      /* Set pointer for next parking */
      if (parkfindnext) 
         parking_offset = x - parking_start + 1;
      snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", x);
   }
   
   chan->appl = "Parked Call";
   chan->data = NULL; 

   pu->chan = chan;
   
   /* Put the parked channel on hold if we have two different channels */
   if (chan != peer) {
      ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
         S_OR(parkmohclass, NULL),
         !ast_strlen_zero(parkmohclass) ? strlen(parkmohclass) + 1 : 0);
   }
   
   pu->start = ast_tvnow();
   pu->parkingnum = x;
   pu->parkingtime = (timeout > 0) ? timeout : parkingtime;
   if (extout)
      *extout = x;

   if (peer) { 
      /* This is so ugly that it hurts, but implementing get_base_channel() on local channels
         could have ugly side effects.  We could have transferer<->local,1<->local,2<->parking
         and we need the callback name to be that of transferer.  Since local,1/2 have the same
         name we can be tricky and just grab the bridged channel from the other side of the local
      */
      if (!strcasecmp(peer->tech->type, "Local")) {
         struct ast_channel *tmpchan, *base_peer;
         char other_side[AST_CHANNEL_NAME];
         char *c;
         ast_copy_string(other_side, peer->name, sizeof(other_side));
         if ((c = strrchr(other_side, ','))) {
            *++c = '1';
         }
         if ((tmpchan = ast_get_channel_by_name_locked(other_side))) {
            if ((base_peer = ast_bridged_channel(tmpchan))) {
               ast_copy_string(pu->peername, base_peer->name, sizeof(pu->peername));
            }
            ast_channel_unlock(tmpchan);
         }
      } else {
         ast_copy_string(pu->peername, peer->name, sizeof(pu->peername));
      }
   }

   /* Remember what had been dialed, so that if the parking
      expires, we try to come back to the same place */
   ast_copy_string(pu->context, S_OR(chan->macrocontext, chan->context), sizeof(pu->context));
   ast_copy_string(pu->exten, S_OR(chan->macroexten, chan->exten), sizeof(pu->exten));
   pu->priority = chan->macropriority ? chan->macropriority : chan->priority;
   pu->next = parkinglot;
   parkinglot = pu;
   parkingnum_copy = pu->parkingnum;
   /* If parking a channel directly, don't quite yet get parking running on it */
   if (peer == chan) 
      pu->notquiteyet = 1;

   if (option_verbose > 1) 
      ast_verbose(VERBOSE_PREFIX_2 "Parked %s on %d@%s. Will timeout back to extension [%s] %s, %d in %d seconds\n", pu->chan->name, pu->parkingnum, parking_con, pu->context, pu->exten, pu->priority, (pu->parkingtime/1000));

   manager_event(EVENT_FLAG_CALL, "ParkedCall",
      "Exten: %s\r\n"
      "Channel: %s\r\n"
      "From: %s\r\n"
      "Timeout: %ld\r\n"
      "CallerID: %s\r\n"
      "CallerIDName: %s\r\n",
      pu->parkingexten, pu->chan->name, peer ? peer->name : "",
      (long)pu->start.tv_sec + (long)(pu->parkingtime/1000) - (long)time(NULL),
      S_OR(pu->chan->cid.cid_num, "<unknown>"),
      S_OR(pu->chan->cid.cid_name, "<unknown>")
      );

   if (peer && adsipark && ast_adsi_available(peer)) {
      adsi_announce_park(peer, pu->parkingexten);  /* Only supports parking numbers */
      ast_adsi_unload_session(peer);
   }

   con = ast_context_find(parking_con);
   if (!con) 
      con = ast_context_create(NULL, parking_con, registrar);
   if (!con)   /* Still no context? Bad */
      ast_log(LOG_ERROR, "Parking context '%s' does not exist and unable to create\n", parking_con);
   if (con) {
      if (!ast_add_extension2(con, 1, pu->parkingexten, 1, NULL, NULL, parkedcall, strdup(pu->parkingexten), ast_free, registrar)) {
         notify_metermaids(pu->parkingexten, parking_con);
      }
   }

   ast_mutex_unlock(&parking_lock);
   /* Wake up the (presumably select()ing) thread */
   pthread_kill(parking_thread, SIGURG);

   /* Only say number if it's a number and the channel hasn't been masqueraded away */
   if (peer && (ast_strlen_zero(orig_chan_name) || !strcasecmp(peer->name, orig_chan_name))) {
      /* Make sure we don't start saying digits to the channel being parked */
      ast_set_flag(peer, AST_FLAG_MASQ_NOSTREAM);
      /* Tell the peer channel the number of the parking space */
      ast_say_digits(peer, parkingnum_copy, "", peer->language);
      ast_clear_flag(peer, AST_FLAG_MASQ_NOSTREAM);
   }

   if (peer == chan) { /* pu->notquiteyet = 1 */
      /* Wake up parking thread if we're really done */
      ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
         S_OR(parkmohclass, NULL),
         !ast_strlen_zero(parkmohclass) ? strlen(parkmohclass) + 1 : 0);
      pu->notquiteyet = 0;
      pthread_kill(parking_thread, SIGURG);
   }
   return 0;
}

/*! \brief Park a call 
   \note We put the user in the parking list, then wake up the parking thread to be sure it looks
   after these channels too */
int ast_park_call(struct ast_channel *chan, struct ast_channel *peer, int timeout, int *extout)
{
   return park_call_full(chan, peer, timeout, extout, NULL);
}

static int masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout, int play_announcement)
{
   struct ast_channel *chan;
   struct ast_frame *f;
   char *orig_chan_name = NULL;
   int park_status;

   /* Make a new, fake channel that we'll use to masquerade in the real one */
   if (!(chan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, rchan->accountcode, rchan->exten, rchan->context, rchan->amaflags, "Parked/%s",rchan->name))) {
      ast_log(LOG_WARNING, "Unable to create parked channel\n");
      return -1;
   }

   /* Make formats okay */
   chan->readformat = rchan->readformat;
   chan->writeformat = rchan->writeformat;
   ast_channel_masquerade(chan, rchan);

   /* Setup the extensions and such */
   set_c_e_p(chan, rchan->context, rchan->exten, rchan->priority);

   /* Make the masq execute */
   if ((f = ast_read(chan))) {
      ast_frfree(f);
   }

   if (!play_announcement) {
      orig_chan_name = ast_strdupa(chan->name);
   }

   park_status = park_call_full(chan, peer, timeout, extout, orig_chan_name);
   if (park_status == 1) {
      /* would be nice to play: "invalid parking extension" */
      ast_hangup(chan);
      return -1;
   }

   return 0;
}

int ast_masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
{
   return masq_park_call(rchan, peer, timeout, extout, 0);
}

static int masq_park_call_announce(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
{
   return masq_park_call(rchan, peer, timeout, extout, 1);
}

#define FEATURE_RETURN_HANGUP                  -1
#define FEATURE_RETURN_SUCCESSBREAK             0
#define FEATURE_RETURN_PBX_KEEPALIVE            AST_PBX_KEEPALIVE
#define FEATURE_RETURN_NO_HANGUP_PEER           AST_PBX_NO_HANGUP_PEER
#define FEATURE_RETURN_NO_HANGUP_PEER_PARKED    AST_PBX_NO_HANGUP_PEER_PARKED
#define FEATURE_RETURN_PASSDIGITS               21
#define FEATURE_RETURN_STOREDIGITS              22
#define FEATURE_RETURN_SUCCESS                  23
#define FEATURE_RETURN_KEEPTRYING               24

#define FEATURE_SENSE_CHAN (1 << 0)
#define FEATURE_SENSE_PEER (1 << 1)

/*! \brief
 * set caller and callee according to the direction
 */
static void set_peers(struct ast_channel **caller, struct ast_channel **callee,
   struct ast_channel *peer, struct ast_channel *chan, int sense)
{
   if (sense == FEATURE_SENSE_PEER) {
      *caller = peer;
      *callee = chan;
   } else {
      *callee = peer;
      *caller = chan;
   }
}

/*! \brief support routing for one touch call parking */
static int builtin_parkcall(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
{
   struct ast_channel *parker;
   struct ast_channel *parkee;
   int res = 0;
   struct ast_module_user *u;

   u = ast_module_user_add(chan);

   set_peers(&parker, &parkee, peer, chan, sense);
   /* Setup the exten/priority to be s/1 since we don't know
      where this call should return */
   strcpy(chan->exten, "s");
   chan->priority = 1;
   if (chan->_state != AST_STATE_UP)
      res = ast_answer(chan);
   if (!res)
      res = ast_safe_sleep(chan, 1000);

   if (!res) {
      if (sense == FEATURE_SENSE_CHAN) {
         res = ast_park_call(parkee, parker, 0, NULL);
         if (!res) {
            if (sense == FEATURE_SENSE_CHAN) {
               res = AST_PBX_NO_HANGUP_PEER_PARKED;
            } else {
               res = AST_PBX_KEEPALIVE;
            }
         }
      }
      else if (sense == FEATURE_SENSE_PEER) {
         masq_park_call_announce(parkee, parker, 0, NULL);
         res = 0; /* PBX should hangup zombie channel */
      }
   }

   ast_module_user_remove(u);
   return res;

}

static int builtin_automonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
{
   char *caller_chan_id = NULL, *callee_chan_id = NULL, *args = NULL, *touch_filename = NULL;
   int x = 0;
   size_t len;
   struct ast_channel *caller_chan, *callee_chan;

   if (!monitor_ok) {
      ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
      return -1;
   }

   if (!monitor_app && !(monitor_app = pbx_findapp("Monitor"))) {
      monitor_ok = 0;
      ast_log(LOG_ERROR,"Cannot record the call. The monitor application is disabled.\n");
      return -1;
   }

   set_peers(&caller_chan, &callee_chan, peer, chan, sense);

   if (!ast_strlen_zero(courtesytone)) {
      if (ast_autoservice_start(callee_chan))
         return -1;
      if (ast_stream_and_wait(caller_chan, courtesytone, caller_chan->language, "")) {
         ast_log(LOG_WARNING, "Failed to play courtesy tone!\n");
         ast_autoservice_stop(callee_chan);
         return -1;
      }
      if (ast_autoservice_stop(callee_chan))
         return -1;
   }
   
   if (callee_chan->monitor) {
      if (option_verbose > 3)
         ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to stop recording call.\n", code);
      ast_monitor_stop(callee_chan, 1);
      return FEATURE_RETURN_SUCCESS;
   }

   if (caller_chan && callee_chan) {
      const char *touch_format = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_FORMAT");
      const char *touch_monitor = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR");

      if (!touch_format)
         touch_format = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_FORMAT");

      if (!touch_monitor)
         touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR");
   
      if (touch_monitor) {
         len = strlen(touch_monitor) + 50;
         args = alloca(len);
         touch_filename = alloca(len);
         snprintf(touch_filename, len, "auto-%ld-%s", (long)time(NULL), touch_monitor);
         snprintf(args, len, "%s|%s|m", (touch_format) ? touch_format : "wav", touch_filename);
      } else {
         caller_chan_id = ast_strdupa(S_OR(caller_chan->cid.cid_num, caller_chan->name));
         callee_chan_id = ast_strdupa(S_OR(callee_chan->cid.cid_num, callee_chan->name));
         len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
         args = alloca(len);
         touch_filename = alloca(len);
         snprintf(touch_filename, len, "auto-%ld-%s-%s", (long)time(NULL), caller_chan_id, callee_chan_id);
         snprintf(args, len, "%s|%s|m", S_OR(touch_format, "wav"), touch_filename);
      }

      for( x = 0; x < strlen(args); x++) {
         if (args[x] == '/')
            args[x] = '-';
      }
      
      if (option_verbose > 3)
         ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to record call. filename: %s\n", code, args);

      pbx_exec(callee_chan, monitor_app, args);
      pbx_builtin_setvar_helper(callee_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
      pbx_builtin_setvar_helper(caller_chan, "TOUCH_MONITOR_OUTPUT", touch_filename);
   
      return FEATURE_RETURN_SUCCESS;
   }
   
   ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");  
   return -1;
}

static int builtin_disconnect(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
{
   if (option_verbose > 3)
      ast_verbose(VERBOSE_PREFIX_3 "User hit '%s' to disconnect call.\n", code);
   return FEATURE_RETURN_HANGUP;
}

static int finishup(struct ast_channel *chan)
{
        ast_indicate(chan, AST_CONTROL_UNHOLD);
  
        return ast_autoservice_stop(chan);
}

/*! \brief Find the context for the transfer */
static const char *real_ctx(struct ast_channel *transferer, struct ast_channel *transferee)
{
        const char *s = pbx_builtin_getvar_helper(transferer, "TRANSFER_CONTEXT");
        if (ast_strlen_zero(s))
                s = pbx_builtin_getvar_helper(transferee, "TRANSFER_CONTEXT");
        if (ast_strlen_zero(s)) /* Use the non-macro context to transfer the call XXX ? */
                s = transferer->macrocontext;
        if (ast_strlen_zero(s))
                s = transferer->context;
        return s;  
}

static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
{
   struct ast_channel *transferer;
   struct ast_channel *transferee;
   const char *transferer_real_context;
   char xferto[256];
   int res;

   set_peers(&transferer, &transferee, peer, chan, sense);
   transferer_real_context = real_ctx(transferer, transferee);
   /* Start autoservice on chan while we talk to the originator */
   ast_autoservice_start(transferee);
   ast_indicate(transferee, AST_CONTROL_HOLD);

   memset(xferto, 0, sizeof(xferto));
   
   /* Transfer */
   res = ast_stream_and_wait(transferer, "pbx-transfer", transferer->language, AST_DIGIT_ANY);
   if (res < 0) {
      finishup(transferee);
      return -1; /* error ? */
   }
   if (res > 0)   /* If they've typed a digit already, handle it */
      xferto[0] = (char) res;

   ast_stopstream(transferer);
   res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
   if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
      finishup(transferee);
      return res;
   }
   if (!strcmp(xferto, ast_parking_ext())) {
      res = finishup(transferee);
      if (res)
         res = -1;
      else if (!ast_park_call(transferee, transferer, 0, NULL)) { /* success */
         /* We return non-zero, but tell the PBX not to hang the channel when
            the thread dies -- We have to be careful now though.  We are responsible for 
            hanging up the channel, else it will never be hung up! */
         return (transferer == peer) ? AST_PBX_KEEPALIVE : AST_PBX_NO_HANGUP_PEER_PARKED;
      } else {
         ast_log(LOG_WARNING, "Unable to park call %s\n", transferee->name);
      }
      /*! \todo XXX Maybe we should have another message here instead of invalid extension XXX */
   } else if (ast_exists_extension(transferee, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
      pbx_builtin_setvar_helper(transferer, "BLINDTRANSFER", transferee->name);
      pbx_builtin_setvar_helper(transferee, "BLINDTRANSFER", transferer->name);
      res=finishup(transferee);
      if (!transferer->cdr) {
         transferer->cdr=ast_cdr_alloc();
         if (transferer) {
            ast_cdr_init(transferer->cdr, transferer); /* initilize our channel's cdr */
            ast_cdr_start(transferer->cdr);
         }
      }
      if (transferer->cdr) {
         ast_cdr_setdestchan(transferer->cdr, transferee->name);
         ast_cdr_setapp(transferer->cdr, "BLINDTRANSFER","");
      }
      if (!transferee->pbx) {
         /* Doh!  Use our handy async_goto functions */
         if (option_verbose > 2) 
            ast_verbose(VERBOSE_PREFIX_3 "Transferring %s to '%s' (context %s) priority 1\n"
                        ,transferee->name, xferto, transferer_real_context);
         if (ast_async_goto(transferee, transferer_real_context, xferto, 1))
            ast_log(LOG_WARNING, "Async goto failed :-(\n");
         res = -1;
      } else {
         /* Set the channel's new extension, since it exists, using transferer context */
         set_c_e_p(transferee, transferer_real_context, xferto, 0);
      }
      check_goto_on_transfer(transferer);
      return res;
   } else {
      if (option_verbose > 2) 
         ast_verbose(VERBOSE_PREFIX_3 "Unable to find extension '%s' in context '%s'\n", xferto, transferer_real_context);
   }
   if (ast_stream_and_wait(transferer, xferfailsound, transferer->language, AST_DIGIT_ANY) < 0 ) {
      finishup(transferee);
      return -1;
   }
   ast_stopstream(transferer);
   res = finishup(transferee);
   if (res) {
      if (option_verbose > 1)
         ast_verbose(VERBOSE_PREFIX_2 "Hungup during autoservice stop on '%s'\n", transferee->name);
      return res;
   }
   return FEATURE_RETURN_SUCCESS;
}

static int check_compat(struct ast_channel *c, struct ast_channel *newchan)
{
   if (ast_channel_make_compatible(c, newchan) < 0) {
      ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n",
         c->name, newchan->name);
      ast_hangup(newchan);
      return -1;
   }
   return 0;
}

static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data)
{
   struct ast_channel *transferer;
   struct ast_channel *transferee;
   const char *transferer_real_context;
   char xferto[256] = "";
   int res;
   int outstate=0;
   struct ast_channel *newchan;
   struct ast_channel *xferchan;
   struct ast_bridge_thread_obj *tobj;
   struct ast_bridge_config bconfig;
   struct ast_frame *f;
   int l;
   struct ast_datastore *features_datastore;
   struct ast_dial_features *dialfeatures = NULL;

   if (option_debug)
      ast_log(LOG_DEBUG, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense);
   set_peers(&transferer, &transferee, peer, chan, sense);
        transferer_real_context = real_ctx(transferer, transferee);
   /* Start autoservice on chan while we talk to the originator */
   ast_autoservice_start(transferee);
   ast_indicate(transferee, AST_CONTROL_HOLD);
   
   /* Transfer */
   res = ast_stream_and_wait(transferer, "pbx-transfer", transferer->language, AST_DIGIT_ANY);
   if (res < 0) {
      finishup(transferee);
      return res;
   }
   if (res > 0) /* If they've typed a digit already, handle it */
      xferto[0] = (char) res;

   /* this is specific of atxfer */
   res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
        if (res < 0) {  /* hangup, would be 0 for invalid and 1 for valid */
                finishup(transferee);
                return res;
        }
   if (res == 0) {
      ast_log(LOG_WARNING, "Did not read data.\n");
      finishup(transferee);
      if (ast_stream_and_wait(transferer, "beeperr", transferer->language, ""))
         return -1;
      return FEATURE_RETURN_SUCCESS;
   }

   /* valid extension, res == 1 */
   if (!ast_exists_extension(transferer, transferer_real_context, xferto, 1, transferer->cid.cid_num)) {
      ast_log(LOG_WARNING, "Extension %s does not exist in context %s\n",xferto,transferer_real_context);
      finishup(transferee);
      if (ast_stream_and_wait(transferer, "beeperr", transferer->language, ""))
         return -1;
      return FEATURE_RETURN_SUCCESS;
   }

   l = strlen(xferto);
   snprintf(xferto + l, sizeof(xferto) - l, "@%s", transferer_real_context);  /* append context */
   newchan = ast_feature_request_and_dial(transferer, "Local", ast_best_codec(transferer->nativeformats),
      xferto, atxfernoanswertimeout, &outstate, transferer->cid.cid_num, transferer->cid.cid_name, transferer->language);

   /* If we are the callee and we are being transferred, after the masquerade
   * caller features will really be the original callee features */
   ast_channel_lock(transferee);
   if ((features_datastore = ast_channel_datastore_find(transferee, &