[asterisk/asterisk.git] / main / features.c

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2008, 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
        <support_level>core</support_level>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#include "asterisk/_private.h"

#include <pthread.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <netinet/in.h>

#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.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/audiohook.h"
#include "asterisk/global_datastores.h"
#include "asterisk/astobj2.h"
#include "asterisk/cel.h"
#include "asterisk/test.h"

/*
 * Party A - transferee
 * Party B - transferer
 * Party C - target of transfer
 *
 * DTMF attended transfer works within the channel bridge.
 * Unfortunately, when either party A or B in the channel bridge
 * hangs up, that channel is not completely hung up until the
 * transfer completes.  This is a real problem depending upon
 * the channel technology involved.
 *
 * For chan_dahdi, the channel is crippled until the hangup is
 * complete.  Either the channel is not useable (analog) or the
 * protocol disconnect messages are held up (PRI/BRI/SS7) and
 * the media is not released.
 *
 * For chan_sip, a call limit of one is going to block that
 * endpoint from any further calls until the hangup is complete.
 *
 * For party A this is a minor problem.  The party A channel
 * will only be in this condition while party B is dialing and
 * when party B and C are conferring.  The conversation between
 * party B and C is expected to be a short one.  Party B is
 * either asking a question of party C or announcing party A.
 * Also party A does not have much incentive to hangup at this
 * point.
 *
 * For party B this can be a major problem during a blonde
 * transfer.  (A blonde transfer is our term for an attended
 * transfer that is converted into a blind transfer. :))  Party
 * B could be the operator.  When party B hangs up, he assumes
 * that he is out of the original call entirely.  The party B
 * channel will be in this condition while party C is ringing,
 * while attempting to recall party B, and while waiting between
 * call attempts.
 *
 * WARNING:
 * The ATXFER_NULL_TECH conditional is a hack to fix the
 * problem.  It will replace the party B channel technology with
 * a NULL channel driver.  The consequences of this code is that
 * the 'h' extension will not be able to access any channel
 * technology specific information like SIP statistics for the
 * call.
 *
 * Uncomment the ATXFER_NULL_TECH define below to replace the
 * party B channel technology in the channel bridge to complete
 * hanging up the channel technology.
 */
//#define ATXFER_NULL_TECH      1

/*** DOCUMENTATION
        <application name="Bridge" language="en_US">
                <synopsis>
                        Bridge two channels.
                </synopsis>
                <syntax>
                        <parameter name="channel" required="true">
                                <para>The current channel is bridged to the specified <replaceable>channel</replaceable>.</para>
                        </parameter>
                        <parameter name="options">
                                <optionlist>
                                        <option name="p">
                                                <para>Play a courtesy tone to <replaceable>channel</replaceable>.</para>
                                        </option>
                                        <option name="h">
                                                <para>Allow the called party to hang up by sending the
                                                <replaceable>*</replaceable> DTMF digit.</para>
                                        </option>
                                        <option name="H">
                                                <para>Allow the calling party to hang up by pressing the
                                                <replaceable>*</replaceable> DTMF digit.</para>
                                        </option>
                                        <option name="k">
                                                <para>Allow the called party to enable parking of the call by sending
                                                the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="K">
                                                <para>Allow the calling party to enable parking of the call by sending
                                                 the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="L(x[:y][:z])">
                                                <para>Limit the call to <replaceable>x</replaceable> ms. Play a warning
                                                when <replaceable>y</replaceable> ms are left. Repeat the warning every
                                                <replaceable>z</replaceable> ms. The following special variables can be
                                                used with this option:</para>
                                                <variablelist>
                                                        <variable name="LIMIT_PLAYAUDIO_CALLER">
                                                                <para>Play sounds to the caller. yes|no (default yes)</para>
                                                        </variable>
                                                        <variable name="LIMIT_PLAYAUDIO_CALLEE">   
                                                                <para>Play sounds to the callee. yes|no</para>
                                                        </variable>
                                                        <variable name="LIMIT_TIMEOUT_FILE">
                                                                <para>File to play when time is up.</para>
                                                        </variable>
                                                        <variable name="LIMIT_CONNECT_FILE">
                                                                <para>File to play when call begins.</para>
                                                        </variable>
                                                        <variable name="LIMIT_WARNING_FILE">
                                                                <para>File to play as warning if <replaceable>y</replaceable> is
                                                                defined. The default is to say the time remaining.</para>
                                                        </variable>
                                                </variablelist>
                                        </option>
                                        <option name="S(x)">
                                                <para>Hang up the call after <replaceable>x</replaceable> seconds *after* the called party has answered the call.</para>
                                        </option>
                                        <option name="t">
                                                <para>Allow the called party to transfer the calling party by sending the
                                                DTMF sequence defined in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="T">
                                                <para>Allow the calling party to transfer the called party by sending the
                                                DTMF sequence defined in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="w">
                                                <para>Allow the called party to enable recording of the call by sending
                                                the DTMF sequence defined for one-touch recording in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="W">
                                                <para>Allow the calling party to enable recording of the call by sending
                                                the DTMF sequence defined for one-touch recording in <filename>features.conf</filename>.</para>
                                        </option>
                                        <option name="x">
                                                <para>Cause the called party to be hung up after the bridge, instead of being
                                                restarted in the dialplan.</para>
                                        </option>
                                </optionlist>
                        </parameter>
                </syntax>
                <description>
                        <para>Allows the ability to bridge two channels via the dialplan.</para>
                        <para>This application sets the following channel variable upon completion:</para>
                        <variablelist>
                                <variable name="BRIDGERESULT">
                                        <para>The result of the bridge attempt as a text string.</para>
                                        <value name="SUCCESS" />
                                        <value name="FAILURE" />
                                        <value name="LOOP" />
                                        <value name="NONEXISTENT" />
                                        <value name="INCOMPATIBLE" />
                                </variable>
                        </variablelist>
                </description>
        </application>
        <application name="ParkedCall" language="en_US">
                <synopsis>
                        Retrieve a parked call.
                </synopsis>
                <syntax>
                        <parameter name="exten">
                                <para>Parking space extension to retrieve a parked call.
                                If not provided then the first available parked call in the
                                parking lot will be retrieved.</para>
                        </parameter>
                        <parameter name="parking_lot_name">
                                <para>Specify from which parking lot to retrieve a parked call.</para>
                                <para>The parking lot used is selected in the following order:</para>
                                <para>1) parking_lot_name option</para>
                                <para>2) <variable>PARKINGLOT</variable> variable</para>
                                <para>3) <literal>CHANNEL(parkinglot)</literal> function
                                (Possibly preset by the channel driver.)</para>
                                <para>4) Default parking lot.</para>
                        </parameter>
                </syntax>
                <description>
                        <para>Used to retrieve a parked call from a parking lot.</para>
                        <note>
                                <para>Parking lots automatically create and manage dialplan extensions in
                                the parking lot context.  You do not need to explicitly use this
                                application in your dialplan.  Instead, all you should do is include the
                                parking lot context in your dialplan.</para>
                        </note>
                </description>
                <see-also>
                        <ref type="application">Park</ref>
                        <ref type="application">ParkAndAnnounce</ref>
                </see-also>
        </application>
        <application name="Park" language="en_US">
                <synopsis>
                        Park yourself.
                </synopsis>
                <syntax>
                        <parameter name="timeout">
                                <para>A custom parking timeout for this parked call. Value in milliseconds.</para>
                        </parameter>
                        <parameter name="return_context">
                                <para>The context to return the call to after it times out.</para>
                        </parameter>
                        <parameter name="return_exten">
                                <para>The extension to return the call to after it times out.</para>
                        </parameter>
                        <parameter name="return_priority">
                                <para>The priority to return the call to after it times out.</para>
                        </parameter>
                        <parameter name="options">
                                <para>A list of options for this parked call.</para>
                                <optionlist>
                                        <option name="r">
                                                <para>Send ringing instead of MOH to the parked call.</para>
                                        </option>
                                        <option name="R">
                                                <para>Randomize the selection of a parking space.</para>
                                        </option>
                                        <option name="s">
                                                <para>Silence announcement of the parking space number.</para>
                                        </option>
                                </optionlist>
                        </parameter>
                        <parameter name="parking_lot_name">
                                <para>Specify in which parking lot to park a call.</para>
                                <para>The parking lot used is selected in the following order:</para>
                                <para>1) parking_lot_name option</para>
                                <para>2) <variable>PARKINGLOT</variable> variable</para>
                                <para>3) <literal>CHANNEL(parkinglot)</literal> function
                                (Possibly preset by the channel driver.)</para>
                                <para>4) Default parking lot.</para>
                        </parameter>
                </syntax>
                <description>
                        <para>Used to park yourself (typically in combination with a supervised
                        transfer to know the parking space).</para>
                        <para>If you set the <variable>PARKINGEXTEN</variable> variable to a
                        parking space extension in the parking lot, Park() will attempt to park the call
                        on that extension.  If the extension is already is in use then execution
                        will continue at the next priority.</para>
                        <para>If the <literal>parkeddynamic</literal> option is enabled in <filename>features.conf</filename>
                        the following variables can be used to dynamically create new parking lots.</para>
                        <para>If you set the <variable>PARKINGDYNAMIC</variable> variable and this parking lot
                        exists then it will be used as a template for the newly created dynamic lot.  Otherwise,
                        the default parking lot will be used.</para>
                        <para>If you set the <variable>PARKINGDYNCONTEXT</variable> variable then the newly created dynamic
                        parking lot will use this context.</para>
                        <para>If you set the <variable>PARKINGDYNEXTEN</variable> variable then the newly created dynamic
                        parking lot will use this extension to access the parking lot.</para>
                        <para>If you set the <variable>PARKINGDYNPOS</variable> variable then the newly created dynamic parking lot
                        will use those parking postitions.</para>
                        <note>
                                <para>This application must be used as the first extension priority
                                to be recognized as a parking access extension.  DTMF transfers
                                and some channel drivers need this distinction to operate properly.
                                The parking access extension in this case is treated like a dialplan
                                hint.</para>
                        </note>
                        <note>
                                <para>Parking lots automatically create and manage dialplan extensions in
                                the parking lot context.  You do not need to explicitly use this
                                application in your dialplan.  Instead, all you should do is include the
                                parking lot context in your dialplan.</para>
                        </note>
                </description>
                <see-also>
                        <ref type="application">ParkAndAnnounce</ref>
                        <ref type="application">ParkedCall</ref>
                </see-also>
        </application>
        <manager name="ParkedCalls" language="en_US">
                <synopsis>
                        List parked calls.
                </synopsis>
                <syntax>
                        <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
                </syntax>
                <description>
                        <para>List parked calls.</para>
                </description>
        </manager>
        <manager name="Park" language="en_US">
                <synopsis>
                        Park a channel.
                </synopsis>
                <syntax>
                        <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
                        <parameter name="Channel" required="true">
                                <para>Channel name to park.</para>
                        </parameter>
                        <parameter name="Channel2" required="true">
                                <para>Channel to return to if timeout.</para>
                        </parameter>
                        <parameter name="Timeout">
                                <para>Number of milliseconds to wait before callback.</para>
                        </parameter>
                        <parameter name="Parkinglot">
                                <para>Specify in which parking lot to park the channel.</para>
                        </parameter>
                </syntax>
                <description>
                        <para>Park a channel.</para>
                </description>
        </manager>
        <manager name="Bridge" language="en_US">
                <synopsis>
                        Bridge two channels already in the PBX.
                </synopsis>
                <syntax>
                        <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
                        <parameter name="Channel1" required="true">
                                <para>Channel to Bridge to Channel2.</para>
                        </parameter>
                        <parameter name="Channel2" required="true">
                                <para>Channel to Bridge to Channel1.</para>
                        </parameter>
                        <parameter name="Tone">
                                <para>Play courtesy tone to Channel 2.</para>
                                <enumlist>
                                        <enum name="yes" />
                                        <enum name="no" />
                                </enumlist>
                        </parameter>
                </syntax>
                <description>
                        <para>Bridge together two channels already in the PBX.</para>
                </description>
        </manager>
 ***/

#define DEFAULT_PARK_TIME                                                       45000   /*!< ms */
#define DEFAULT_PARK_EXTENSION                                          "700"
#define DEFAULT_TRANSFER_DIGIT_TIMEOUT                          3000    /*!< ms */
#define DEFAULT_FEATURE_DIGIT_TIMEOUT                           1000    /*!< ms */
#define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER      15000   /*!< ms */
#define DEFAULT_ATXFER_DROP_CALL                                        0               /*!< Do not drop call. */
#define DEFAULT_ATXFER_LOOP_DELAY                                       10000   /*!< ms */
#define DEFAULT_ATXFER_CALLBACK_RETRIES                         2
#define DEFAULT_COMEBACK_CONTEXT                                        "parkedcallstimeout"
#define DEFAULT_COMEBACK_TO_ORIGIN                                      1
#define DEFAULT_COMEBACK_DIAL_TIME                                      30

#define AST_MAX_WATCHERS 256
#define MAX_DIAL_FEATURE_OPTIONS 30

struct feature_group_exten {
        AST_LIST_ENTRY(feature_group_exten) entry;
        AST_DECLARE_STRING_FIELDS(
                AST_STRING_FIELD(exten);
        );
        struct ast_call_feature *feature;
};

struct feature_group {
        AST_LIST_ENTRY(feature_group) entry;
        AST_DECLARE_STRING_FIELDS(
                AST_STRING_FIELD(gname);
        );
        AST_LIST_HEAD_NOLOCK(, feature_group_exten) features;
};

static AST_RWLIST_HEAD_STATIC(feature_groups, feature_group);

typedef enum {
        FEATURE_INTERPRET_DETECT, /* Used by ast_feature_detect */
        FEATURE_INTERPRET_DO,     /* Used by feature_interpret */
        FEATURE_INTERPRET_CHECK,  /* Used by feature_check */
} feature_interpret_op;

static const char *parkedcall = "ParkedCall";

static char pickup_ext[AST_MAX_EXTENSION];                 /*!< Call pickup extension */

/*! Parking lot access ramp dialplan usage entry. */
struct parking_dp_ramp {
        /*! Next node in the parking lot spaces dialplan list. */
        AST_LIST_ENTRY(parking_dp_ramp) node;
        /*! TRUE if the parking lot access extension is exclusive. */
        unsigned int exclusive:1;
        /*! Parking lot access extension */
        char exten[1];
};

/*! Parking lot dialplan access ramp map */
AST_LIST_HEAD_NOLOCK(parking_dp_ramp_map, parking_dp_ramp);

/*! Parking lot spaces dialplan usage entry. */
struct parking_dp_spaces {
        /*! Next node in the parking lot spaces dialplan list. */
        AST_LIST_ENTRY(parking_dp_spaces) node;
        /*! First parking space */
        int start;
        /*! Last parking space */
        int stop;
};

/*! Parking lot dialplan context space map */
AST_LIST_HEAD_NOLOCK(parking_dp_space_map, parking_dp_spaces);

/*! Parking lot context dialplan usage entry. */
struct parking_dp_context {
        /*! Next node in the parking lot contexts dialplan list. */
        AST_LIST_ENTRY(parking_dp_context) node;
        /*! Parking access extensions defined in this context. */
        struct parking_dp_ramp_map access_extens;
        /*! Parking spaces defined in this context. */
        struct parking_dp_space_map spaces;
        /*! Parking hints defined in this context. */
        struct parking_dp_space_map hints;
        /*! Parking lot context name */
        char context[1];
};

/*! Parking lot dialplan usage map. */
AST_LIST_HEAD_NOLOCK(parking_dp_map, parking_dp_context);

/*!
 * \brief Description of one parked call, added to a list while active, then removed.
 * The list belongs to a parkinglot.
 */
struct parkeduser {
        struct ast_channel *chan;                   /*!< Parked channel */
        struct timeval start;                       /*!< Time the park started */
        int parkingnum;                             /*!< Parking lot space used */
        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 */
        /*! Method to entertain the caller when parked: AST_CONTROL_RINGING, AST_CONTROL_HOLD, or 0(none) */
        enum ast_control_frame_type hold_method;
        unsigned int notquiteyet:1;
        unsigned int options_specified:1;
        char peername[AST_CHANNEL_NAME];
        unsigned char moh_trys;
        /*! Parking lot this entry belongs to.  Holds a parking lot reference. */
        struct ast_parkinglot *parkinglot;
        AST_LIST_ENTRY(parkeduser) list;
};

/*! Parking lot configuration options. */
struct parkinglot_cfg {
        /*! Music class used for parking */
        char mohclass[MAX_MUSICCLASS];
        /*! Extension to park calls in this parking lot. */
        char parkext[AST_MAX_EXTENSION];
        /*! Context for which parking is made accessible */
        char parking_con[AST_MAX_CONTEXT];
        /*! Context that timed-out parked calls are called back on when comebacktoorigin=no */
        char comebackcontext[AST_MAX_CONTEXT];
        /*! First available extension for parking */
        int parking_start;
        /*! Last available extension for parking */
        int parking_stop;
        /*! Default parking time in ms. */
        int parkingtime;
        /*!
         * \brief Enable DTMF based transfers on bridge when picking up parked calls.
         *
         * \details
         * none(0)
         * AST_FEATURE_FLAG_BYCALLEE
         * AST_FEATURE_FLAG_BYCALLER
         * AST_FEATURE_FLAG_BYBOTH
         */
        int parkedcalltransfers;
        /*!
         * \brief Enable DTMF based parking on bridge when picking up parked calls.
         *
         * \details
         * none(0)
         * AST_FEATURE_FLAG_BYCALLEE
         * AST_FEATURE_FLAG_BYCALLER
         * AST_FEATURE_FLAG_BYBOTH
         */
        int parkedcallreparking;
        /*!
         * \brief Enable DTMF based hangup on a bridge when pickup up parked calls.
         *
         * \details
         * none(0)
         * AST_FEATURE_FLAG_BYCALLEE
         * AST_FEATURE_FLAG_BYCALLER
         * AST_FEATURE_FLAG_BYBOTH
         */
        int parkedcallhangup;
        /*!
         * \brief Enable DTMF based recording on a bridge when picking up parked calls.
         *
         * \details
         * none(0)
         * AST_FEATURE_FLAG_BYCALLEE
         * AST_FEATURE_FLAG_BYCALLER
         * AST_FEATURE_FLAG_BYBOTH
         */
        int parkedcallrecording;

        /*! Time in seconds to dial the device that parked a timedout parked call */
        unsigned int comebackdialtime;
        /*! TRUE if findslot is set to next */
        unsigned int parkfindnext:1;
        /*! TRUE if the parking lot is exclusively accessed by parkext */
        unsigned int parkext_exclusive:1;
        /*! Add parking hints automatically */
        unsigned int parkaddhints:1;
        /*! TRUE if configuration is invalid and the parking lot should not be used. */
        unsigned int is_invalid:1;
        /*! TRUE if a timed out parked call goes back to the parker */
        unsigned int comebacktoorigin:1;
};

/*! \brief Structure for parking lots which are put in a container. */
struct ast_parkinglot {
        /*! Name of the parking lot. */
        char name[AST_MAX_CONTEXT];
        /*! Parking lot user configuration. */
        struct parkinglot_cfg cfg;

        /*! Parking space to start next park search. */
        int next_parking_space;

        /*! That which bears the_mark shall be deleted if parking lot empty! (Used during reloads.) */
        unsigned int the_mark:1;
        /*! TRUE if the parking lot is disabled. */
        unsigned int disabled:1;

        /*! List of active parkings in this parkinglot */
        AST_LIST_HEAD(parkinglot_parklist, parkeduser) parkings;
};

/*! \brief The configured parking lots container. Always at least one  - the default parking lot */
static struct ao2_container *parkinglots;

/*!
 * \brief Default parking lot.
 * \note Holds a parkinglot reference.
 * \note Will not be NULL while running.
 */
static struct ast_parkinglot *default_parkinglot;

/*! Force a config reload to reload regardless of config file timestamp. */
static int force_reload_load;

static int parkedplay = 0;                                 /*!< Who to play courtesytone to when someone picks up a parked call. */
static int parkeddynamic = 0;                              /*!< Enable creation of parkinglots dynamically */
static char courtesytone[256];                             /*!< Courtesy tone used to pickup parked calls and on-touch-record */
static char xfersound[256];                                /*!< Call transfer sound */
static char xferfailsound[256];                            /*!< Call transfer failure sound */
static char pickupsound[256];                              /*!< Pickup sound */
static char pickupfailsound[256];                          /*!< Pickup failure sound */

/*!
 * \brief Context for parking dialback to parker.
 * \note The need for the context is a KLUDGE.
 *
 * \todo Might be able to eliminate the parking_con_dial context
 * kludge by running app_dial directly in its own thread to
 * simulate a PBX.
 */
static char parking_con_dial[] = "park-dial";

/*! Ensure that features.conf reloads on one thread at a time. */
AST_MUTEX_DEFINE_STATIC(features_reload_lock);

static int adsipark;

static int transferdigittimeout;
static int featuredigittimeout;

static int atxfernoanswertimeout;
static unsigned int atxferdropcall;
static unsigned int atxferloopdelay;
static unsigned int atxfercallbackretries;

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

/*! PARK_APP_NAME application arguments */
AST_DEFINE_APP_ARGS_TYPE(park_app_args,
        AST_APP_ARG(timeout);           /*!< Time in ms to remain in the parking lot. */
        AST_APP_ARG(return_con);        /*!< Context to return parked call if timeout. */
        AST_APP_ARG(return_ext);        /*!< Exten to return parked call if timeout. */
        AST_APP_ARG(return_pri);        /*!< Priority to return parked call if timeout. */
        AST_APP_ARG(options);           /*!< Parking option flags. */
        AST_APP_ARG(pl_name);           /*!< Parking lot name to use if present. */
        AST_APP_ARG(dummy);                     /*!< Place to put any remaining args string. */
        );

/* module and CLI command definitions */
static const char *parkcall = "Park";

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

static struct ast_app *mixmonitor_app = NULL;
static int mixmonitor_ok = 1;

static struct ast_app *stopmixmonitor_app = NULL;
static int stopmixmonitor_ok = 1;

static pthread_t parking_thread;
struct ast_dial_features {
        struct ast_flags features_caller;
        struct ast_flags features_callee;
        int is_caller;
};

#if defined(ATXFER_NULL_TECH)
/*!
 * \internal
 * \brief Set the channel technology to the kill technology.
 *
 * \param chan Channel to change technology.
 *
 * \return Nothing
 */
static void set_kill_chan_tech(struct ast_channel *chan)
{
        int idx;

        ast_channel_lock(chan);

        /* Hangup the channel's physical side */
        if (ast_channel_tech(chan)->hangup) {
                ast_channel_tech(chan)->hangup(chan);
        }
        if (ast_channel_tech_pvt(chan)) {
                ast_log(LOG_WARNING, "Channel '%s' may not have been hung up properly\n",
                        ast_channel_name(chan));
                ast_free(ast_channel_tech_pvt(chan));
                ast_channel_tech_pvt_set(chan, NULL);
        }

        /* Install the kill technology and wake up anyone waiting on it. */
        ast_channel_tech_set(chan, &ast_kill_tech);
        for (idx = 0; idx < AST_MAX_FDS; ++idx) {
                switch (idx) {
                case AST_ALERT_FD:
                case AST_TIMING_FD:
                case AST_GENERATOR_FD:
                        /* Don't clear these fd's. */
                        break;
                default:
                        ast_channel_set_fd(chan, idx, -1);
                        break;
                }
        }
        ast_queue_frame(chan, &ast_null_frame);

        ast_channel_unlock(chan);
}
#endif  /* defined(ATXFER_NULL_TECH) */

#if defined(ATXFER_NULL_TECH)
/*!
 * \internal
 * \brief Set the channel name to something unique.
 *
 * \param chan Channel to change name.
 *
 * \return Nothing
 */
static void set_new_chan_name(struct ast_channel *chan)
{
        static int seq_num_last;
        int seq_num;
        int len;
        char *chan_name;
        char dummy[1];

        /* Create the new channel name string. */
        ast_channel_lock(chan);
        seq_num = ast_atomic_fetchadd_int(&seq_num_last, +1);
        len = snprintf(dummy, sizeof(dummy), "%s<XFER_%x>", ast_channel_name(chan), seq_num) + 1;
        chan_name = alloca(len);
        snprintf(chan_name, len, "%s<XFER_%x>", ast_channel_name(chan), seq_num);
        ast_channel_unlock(chan);

        ast_change_name(chan, chan_name);
}
#endif  /* defined(ATXFER_NULL_TECH) */

static void *dial_features_duplicate(void *data)
{
        struct ast_dial_features *df = data, *df_copy;
 
        if (!(df_copy = ast_calloc(1, sizeof(*df)))) {
                return NULL;
        }
 
        memcpy(df_copy, df, sizeof(*df));
 
        return df_copy;
}

static void dial_features_destroy(void *data)
{
        struct ast_dial_features *df = data;
        if (df) {
                ast_free(df);
        }
}

static const struct ast_datastore_info dial_features_info = {
        .type = "dial-features",
        .destroy = dial_features_destroy,
        .duplicate = dial_features_duplicate,
};
 
/* Forward declarations */
static struct ast_parkinglot *parkinglot_addref(struct ast_parkinglot *parkinglot);
static void parkinglot_unref(struct ast_parkinglot *parkinglot);
static struct ast_parkinglot *find_parkinglot(const char *name);
static struct ast_parkinglot *create_parkinglot(const char *name);
static struct ast_parkinglot *copy_parkinglot(const char *name, const struct ast_parkinglot *parkinglot);
static int parkinglot_activate(struct ast_parkinglot *parkinglot);
static int play_message_on_chan(struct ast_channel *play_to, struct ast_channel *other, const char *msg, const char *audiofile);

/*!
 * \internal
 * \brief Get the parking extension if it exists.
 *
 * \param exten_str Parking extension to see if exists.
 * \param chan Channel to autoservice while looking for exten.  (Could be NULL)
 * \param context Parking context to look in for exten.
 *
 * \retval exten on success.
 * \retval NULL on error or exten does not exist.
 */
static struct ast_exten *get_parking_exten(const char *exten_str, struct ast_channel *chan, const char *context)
{
        struct ast_exten *exten;
        struct pbx_find_info q = { .stacklen = 0 }; /* the rest is reset in pbx_find_extension */
        const char *app_at_exten;

        exten = pbx_find_extension(chan, NULL, &q, context, exten_str, 1, NULL, NULL,
                E_MATCH);
        if (!exten) {
                return NULL;
        }

        app_at_exten = ast_get_extension_app(exten);
        if (!app_at_exten || strcasecmp(parkcall, app_at_exten)) {
                return NULL;
        }

        return exten;
}

int ast_parking_ext_valid(const char *exten_str, struct ast_channel *chan, const char *context)
{
        return get_parking_exten(exten_str, chan, context) ? 1 : 0;
}

const 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;
        unsigned int return_to_pbx:1;
};

static int parkinglot_hash_cb(const void *obj, const int flags)
{
        const struct ast_parkinglot *parkinglot = obj;

        return ast_str_case_hash(parkinglot->name);
}

static int parkinglot_cmp_cb(void *obj, void *arg, int flags)
{
        struct ast_parkinglot *parkinglot = obj;
        struct ast_parkinglot *parkinglot2 = arg;

        return !strcasecmp(parkinglot->name, parkinglot2->name) ? CMP_MATCH | CMP_STOP : 0;
}

/*!
 * \brief store context, extension and priority 
 * \param chan, context, ext, pri
 */
static void set_c_e_p(struct ast_channel *chan, const char *context, const char *ext, int pri)
{
        ast_channel_context_set(chan, context);
        ast_channel_exten_set(chan, ext);
        ast_channel_priority_set(chan, pri);
}

/*!
 * \brief Check goto on transfer
 * \param chan
 *
 * Check if channel has 'GOTO_ON_BLINDXFR' set, if not exit.
 * When found make sure the types are compatible. Check if channel is valid
 * if so start the new channel else hangup the call. 
 */
static void check_goto_on_transfer(struct ast_channel *chan) 
{
        struct ast_channel *xferchan;
        const char *val;
        char *goto_on_transfer;
        char *x;

        ast_channel_lock(chan);
        val = pbx_builtin_getvar_helper(chan, "GOTO_ON_BLINDXFR");
        if (ast_strlen_zero(val)) {
                ast_channel_unlock(chan);
                return;
        }
        goto_on_transfer = ast_strdupa(val);
        ast_channel_unlock(chan);

        ast_debug(1, "Attempting GOTO_ON_BLINDXFR=%s for %s.\n", val, ast_channel_name(chan));

        xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", ast_channel_linkedid(chan), 0,
                "%s", ast_channel_name(chan));
        if (!xferchan) {
                return;
        }

        /* Make formats okay */
        xferchan->readformat = chan->readformat;
        xferchan->writeformat = chan->writeformat;

        if (ast_channel_masquerade(xferchan, chan)) {
                /* Failed to setup masquerade. */
                ast_hangup(xferchan);
                return;
        }

        for (x = goto_on_transfer; *x; ++x) {
                if (*x == '^') {
                        *x = ',';
                }
        }
        ast_parseable_goto(xferchan, goto_on_transfer);
        ast_channel_state_set(xferchan, AST_STATE_UP);
        ast_clear_flag(xferchan, AST_FLAGS_ALL);        
        ast_channel_clear_softhangup(xferchan, AST_SOFTHANGUP_ALL);

        if (ast_do_masquerade(xferchan) || ast_pbx_start(xferchan)) {
                /* Failed to do masquerade or could not start PBX. */
                ast_hangup(xferchan);
        }
}

static struct ast_channel *feature_request_and_dial(struct ast_channel *caller,
        const char *caller_name, struct ast_channel *requestor,
        struct ast_channel *transferee, const char *type, struct ast_format_cap *cap, const char *addr,
        int timeout, int *outstate, const char *language);

/*!
 * \brief bridge the call 
 * \param data thread bridge.
 *
 * Set Last Data for respective channels, reset cdr for channels
 * bridge call, check if we're going back to dialplan
 * if not hangup both legs of the call
 */
static void *bridge_call_thread(void *data)
{
        struct ast_bridge_thread_obj *tobj = data;
        int res;

        ast_channel_appl_set(tobj->chan, !tobj->return_to_pbx ? "Transferred Call" : "ManagerBridge");
        ast_channel_data_set(tobj->chan, ast_channel_name(tobj->peer));
        ast_channel_appl_set(tobj->peer, !tobj->return_to_pbx ? "Transferred Call" : "ManagerBridge");
        ast_channel_data_set(tobj->peer, ast_channel_name(tobj->chan));

        ast_bridge_call(tobj->peer, tobj->chan, &tobj->bconfig);

        if (tobj->return_to_pbx) {
                if (!ast_check_hangup(tobj->peer)) {
                        ast_log(LOG_VERBOSE, "putting peer %s into PBX again\n", ast_channel_name(tobj->peer));
                        res = ast_pbx_start(tobj->peer);
                        if (res != AST_PBX_SUCCESS)
                                ast_log(LOG_WARNING, "FAILED continuing PBX on peer %s\n", ast_channel_name(tobj->peer));
                } else
                        ast_hangup(tobj->peer);
                if (!ast_check_hangup(tobj->chan)) {
                        ast_log(LOG_VERBOSE, "putting chan %s into PBX again\n", ast_channel_name(tobj->chan));
                        res = ast_pbx_start(tobj->chan);
                        if (res != AST_PBX_SUCCESS)
                                ast_log(LOG_WARNING, "FAILED continuing PBX on chan %s\n", ast_channel_name(tobj->chan));
                } else
                        ast_hangup(tobj->chan);
        } else {
                ast_hangup(tobj->chan);
                ast_hangup(tobj->peer);
        }

        ast_free(tobj);

        return NULL;
}

/*!
 * \brief create thread for the parked call
 * \param data
 *
 * Create thread and attributes, call bridge_call_thread
 */
static void 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, bridge_call_thread, data);
        pthread_attr_destroy(&attr);
        memset(&sched, 0, sizeof(sched));
        pthread_setschedparam(thread, SCHED_RR, &sched);
}

/*!
 * \brief Announce call parking by ADSI
 * \param chan .
 * \param parkingexten .
 * Create message to show for ADSI, display message.
 * \retval 0 on success.
 * \retval -1 on failure.
 */
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 Find parking lot name from channel
 * \note Channel needs to be locked while the returned string is in use.
 */
static const char *findparkinglotname(struct ast_channel *chan)
{
        const char *name;

        /* The channel variable overrides everything */
        name = pbx_builtin_getvar_helper(chan, "PARKINGLOT");
        if (!name && !ast_strlen_zero(ast_channel_parkinglot(chan))) {
                /* Use the channel's parking lot. */
                name = ast_channel_parkinglot(chan);
        }
        return name;
}

/*! \brief Notify metermaids that we've changed an extension */
static void notify_metermaids(const char *exten, char *context, enum ast_device_state state)
{
        ast_debug(4, "Notification of state change to metermaids %s@%s\n to state '%s'",
                exten, context, ast_devstate2str(state));

        ast_devstate_changed(state, "park:%s@%s", exten, context);
}

/*! \brief metermaids callback from devicestate.c */
static enum ast_device_state metermaidstate(const char *data)
{
        char *context;
        char *exten;

        context = ast_strdupa(data);

        exten = strsep(&context, "@");
        if (!context)
                return AST_DEVICE_INVALID;

        ast_debug(4, "Checking state of exten %s in context %s\n", exten, context);

        if (!ast_exists_extension(NULL, context, exten, 1, NULL))
                return AST_DEVICE_NOT_INUSE;

        return AST_DEVICE_INUSE;
}

/*! Options to pass to park_call_full */
enum ast_park_call_options {
        /*! Provide ringing to the parked caller instead of music on hold */
        AST_PARK_OPT_RINGING =   (1 << 0),
        /*! Randomly choose a parking spot for the caller instead of choosing
         *  the first one that is available. */
        AST_PARK_OPT_RANDOMIZE = (1 << 1),
        /*! Do not announce the parking number */
        AST_PARK_OPT_SILENCE = (1 << 2),
};

/*! Optional additional parking options when parking a call. */
struct ast_park_call_args {
        /*! How long to wait in the parking lot before the call gets sent back
         *  to the specified return extension (or a best guess at where it came
         *  from if not explicitly specified). */
        int timeout;
        /*! An output parameter to store the parking space where the parked caller
         *  was placed. */
        int *extout;
        const char *orig_chan_name;
        const char *return_con;
        const char *return_ext;
        int return_pri;
        uint32_t flags;
        /*! Parked user that has already obtained a parking space */
        struct parkeduser *pu;
        /*! \brief Parkinglot to be parked in */
        struct ast_parkinglot *parkinglot;
};

/*!
 * \internal
 * \brief Create a dynamic parking lot.
 *
 * \param name Dynamic parking lot name to create.
 * \param chan Channel to get dynamic parking lot parameters.
 *
 * \retval parkinglot on success.
 * \retval NULL on error.
 */
static struct ast_parkinglot *create_dynamic_parkinglot(const char *name, struct ast_channel *chan)
{
        const char *dyn_context;
        const char *dyn_exten;
        const char *dyn_range;
        const char *template_name;
        struct ast_parkinglot *template_parkinglot = NULL;
        struct ast_parkinglot *parkinglot;
        int dyn_start;
        int dyn_end;

        ast_channel_lock(chan);
        template_name = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNAMIC"), ""));
        dyn_context = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNCONTEXT"), ""));
        dyn_exten = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNEXTEN"), ""));
        dyn_range = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNPOS"), ""));
        ast_channel_unlock(chan);

        if (!ast_strlen_zero(template_name)) {
                template_parkinglot = find_parkinglot(template_name);
                if (!template_parkinglot) {
                        ast_debug(1, "PARKINGDYNAMIC lot %s does not exist.\n",
                                template_name);
                } else if (template_parkinglot->cfg.is_invalid) {
                        ast_debug(1, "PARKINGDYNAMIC lot %s has invalid config.\n",
                                template_name);
                        parkinglot_unref(template_parkinglot);
                        template_parkinglot = NULL;
                }
        }
        if (!template_parkinglot) {
                template_parkinglot = parkinglot_addref(default_parkinglot);
                ast_debug(1, "Using default parking lot for template\n");
        }

        parkinglot = copy_parkinglot(name, template_parkinglot);
        if (!parkinglot) {
                ast_log(LOG_ERROR, "Could not build dynamic parking lot!\n");
        } else {
                /* Configure the dynamic parking lot. */
                if (!ast_strlen_zero(dyn_context)) {
                        ast_copy_string(parkinglot->cfg.parking_con, dyn_context,
                                sizeof(parkinglot->cfg.parking_con));
                }
                if (!ast_strlen_zero(dyn_exten)) {
                        ast_copy_string(parkinglot->cfg.parkext, dyn_exten,
                                sizeof(parkinglot->cfg.parkext));
                }
                if (!ast_strlen_zero(dyn_range)) {
                        if (sscanf(dyn_range, "%30d-%30d", &dyn_start, &dyn_end) != 2) {
                                ast_log(LOG_WARNING,
                                        "Format for parking positions is a-b, where a and b are numbers\n");
                        } else if (dyn_end < dyn_start || dyn_start <= 0 || dyn_end <= 0) {
                                ast_log(LOG_WARNING,
                                        "Format for parking positions is a-b, where a <= b\n");
                        } else {
                                parkinglot->cfg.parking_start = dyn_start;
                                parkinglot->cfg.parking_stop = dyn_end;
                        }
                }

                /*
                 * Sanity check for dynamic parking lot configuration.
                 *
                 * XXX It may be desirable to instead check if the dynamic
                 * parking lot overlaps any existing lots like what is done for
                 * a reload.
                 */
                if (!strcmp(parkinglot->cfg.parking_con, template_parkinglot->cfg.parking_con)) {
                        if (!strcmp(parkinglot->cfg.parkext, template_parkinglot->cfg.parkext)
                                && parkinglot->cfg.parkext_exclusive) {
                                ast_log(LOG_WARNING,
                                        "Parking lot '%s' conflicts with template parking lot '%s'!\n"
                                        "Change either PARKINGDYNCONTEXT or PARKINGDYNEXTEN.\n",
                                        parkinglot->name, template_parkinglot->name);
                        }
                        if ((template_parkinglot->cfg.parking_start <= parkinglot->cfg.parking_start
                                        && parkinglot->cfg.parking_start <= template_parkinglot->cfg.parking_stop)
                                || (template_parkinglot->cfg.parking_start <= parkinglot->cfg.parking_stop
                                        && parkinglot->cfg.parking_stop <= template_parkinglot->cfg.parking_stop)
                                || (parkinglot->cfg.parking_start < template_parkinglot->cfg.parking_start
                                        && template_parkinglot->cfg.parking_stop < parkinglot->cfg.parking_stop)) {
                                ast_log(LOG_WARNING,
                                        "Parking lot '%s' parking spaces overlap template parking lot '%s'!\n"
                                        "Change PARKINGDYNPOS.\n",
                                        parkinglot->name, template_parkinglot->name);
                        }
                }

                parkinglot_activate(parkinglot);
                ao2_link(parkinglots, parkinglot);
        }
        parkinglot_unref(template_parkinglot);

        return parkinglot;
}

/*!
 * \internal
 * \brief Abort parking a call that has not completed parking yet.
 *
 * \param pu Parked user item to clean up.
 *
 * \note The parking lot parkings list is locked on entry.
 *
 * \return Nothing
 */
static void park_space_abort(struct parkeduser *pu)
{
        struct ast_parkinglot *parkinglot;

        parkinglot = pu->parkinglot;

        /* Put back the parking space just allocated. */
        --parkinglot->next_parking_space;

        AST_LIST_REMOVE(&parkinglot->parkings, pu, list);

        AST_LIST_UNLOCK(&parkinglot->parkings);
        parkinglot_unref(parkinglot);
        ast_free(pu);
}

/*!
 * \internal
 * \brief Reserve a parking space in a parking lot for a call being parked.
 *
 * \param park_me Channel being parked.
 * \param parker Channel parking the call.
 * \param args Optional additional parking options when parking a call.
 *
 * \return Parked call descriptor or NULL if failed.
 * \note The parking lot list is locked if successful.
 */
static struct parkeduser *park_space_reserve(struct ast_channel *park_me, struct ast_channel *parker, struct ast_park_call_args *args)
{
        struct parkeduser *pu;
        int i;
        int parking_space = -1;
        const char *parkinglotname;
        const char *parkingexten;
        struct parkeduser *cur;
        struct ast_parkinglot *parkinglot = NULL;

        if (args->parkinglot) {
                parkinglot = parkinglot_addref(args->parkinglot);
                parkinglotname = parkinglot->name;
        } else {
                if (parker) {
                        parkinglotname = findparkinglotname(parker);
                } else { /* parker was NULL, check park_me (ParkAndAnnounce / res_agi) */
                        parkinglotname = findparkinglotname(park_me);
                }
                if (!ast_strlen_zero(parkinglotname)) {
                        parkinglot = find_parkinglot(parkinglotname);
                } else {
                        /* Parking lot is not specified, so use the default parking lot. */
                        ast_debug(4, "This could be an indication channel driver needs updating, using default lot.\n");
                        parkinglot = parkinglot_addref(default_parkinglot);
                }
        }

        /* Dynamically create parkinglot */
        if (!parkinglot && parkeddynamic && !ast_strlen_zero(parkinglotname)) {
                parkinglot = create_dynamic_parkinglot(parkinglotname, park_me);
        }

        if (!parkinglot) {
                ast_log(LOG_WARNING, "Parking lot not available to park %s.\n", ast_channel_name(park_me));
                return NULL;
        }

        ast_debug(1, "Parking lot: %s\n", parkinglot->name);
        if (parkinglot->disabled || parkinglot->cfg.is_invalid) {
                ast_log(LOG_WARNING, "Parking lot %s is not in a useable state.\n",
                        parkinglot->name);
                parkinglot_unref(parkinglot);
                return NULL;
        }

        /* Allocate memory for parking data */
        if (!(pu = ast_calloc(1, sizeof(*pu)))) {
                parkinglot_unref(parkinglot);
                return NULL;
        }

        /* Lock parking list */
        AST_LIST_LOCK(&parkinglot->parkings);

        /* Check for channel variable PARKINGEXTEN */
        parkingexten = ast_strdupa(S_OR(pbx_builtin_getvar_helper(park_me, "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, "%30d", &parking_space) != 1 || parking_space <= 0) {
                        ast_log(LOG_WARNING, "PARKINGEXTEN='%s' is not a valid parking space.\n",
                                parkingexten);
                        AST_LIST_UNLOCK(&parkinglot->parkings);
                        parkinglot_unref(parkinglot);
                        ast_free(pu);
                        return NULL;
                }

                if (parking_space < parkinglot->cfg.parking_start
                        || parkinglot->cfg.parking_stop < parking_space) {
                        /*
                         * Cannot allow park because parking lots are not setup for
                         * spaces outside of the lot.  (Things like dialplan hints don't
                         * exist for outside lot space.)
                         */
                        ast_log(LOG_WARNING, "PARKINGEXTEN=%d is not in %s (%d-%d).\n",
                                parking_space, parkinglot->name, parkinglot->cfg.parking_start,
                                parkinglot->cfg.parking_stop);
                        AST_LIST_UNLOCK(&parkinglot->parkings);
                        parkinglot_unref(parkinglot);
                        ast_free(pu);
                        return NULL;
                }

                /* Check if requested parking space is in use. */
                AST_LIST_TRAVERSE(&parkinglot->parkings, cur, list) {
                        if (cur->parkingnum == parking_space) {
                                ast_log(LOG_WARNING, "PARKINGEXTEN=%d is already in use in %s\n",
                                        parking_space, parkinglot->name);
                                AST_LIST_UNLOCK(&parkinglot->parkings);
                                parkinglot_unref(parkinglot);
                                ast_free(pu);
                                return NULL;
                        }
                }
        } else {
                /* PARKINGEXTEN is empty, so find a usable extension in the lot to park the call */
                int start; /* The first slot we look in the parkinglot. It can be randomized. */
                int start_checked = 0; /* flag raised once the first slot is checked */

                /* If using randomize mode, set start to random position on parking range */
                if (ast_test_flag(args, AST_PARK_OPT_RANDOMIZE)) {
                        start = ast_random() % (parkinglot->cfg.parking_stop - parkinglot->cfg.parking_start + 1);
                        start += parkinglot->cfg.parking_start;
                } else if (parkinglot->cfg.parkfindnext
                        && parkinglot->cfg.parking_start <= parkinglot->next_parking_space
                        && parkinglot->next_parking_space <= parkinglot->cfg.parking_stop) {
                        /* Start looking with the next parking space in the lot. */
                        start = parkinglot->next_parking_space;
                } else {
                        /* Otherwise, just set it to the start position. */
                        start = parkinglot->cfg.parking_start;
                }

                /* free parking extension linear search: O(n^2) */
                for (i = start; ; i++) {
                        /* If we are past the end, wrap around to the first parking slot*/
                        if (i == parkinglot->cfg.parking_stop + 1) {
                                i = parkinglot->cfg.parking_start;
                        }

                        if (i == start) {
                                /* At this point, if start_checked, we've exhausted all the possible slots. */
                                if (start_checked) {
                                        break;
                                } else {
                                        start_checked = 1;
                                }
                        }

                        /* Search the list of parked calls already in use for i. If we find it, it's in use. */
                        AST_LIST_TRAVERSE(&parkinglot->parkings, cur, list) {
                                if (cur->parkingnum == i) {
                                        break;
                                }
                        }
                        if (!cur) {
                                /* We found a parking space. */
                                parking_space = i;
                                break;
                        }
                }
                if (parking_space == -1) {
                        /* We did not find a parking space.  Lot is full. */
                        ast_log(LOG_WARNING, "No more parking spaces in %s\n", parkinglot->name);
                        AST_LIST_UNLOCK(&parkinglot->parkings);
                        parkinglot_unref(parkinglot);
                        ast_free(pu);
                        return NULL;
                }
        }

        /* Prepare for next parking space search. */
        parkinglot->next_parking_space = parking_space + 1;

        snprintf(pu->parkingexten, sizeof(pu->parkingexten), "%d", parking_space);
        pu->notquiteyet = 1;
        pu->parkingnum = parking_space;
        pu->parkinglot = parkinglot;
        AST_LIST_INSERT_TAIL(&parkinglot->parkings, pu, list);

        return pu;
}

/* Park a call */
static int park_call_full(struct ast_channel *chan, struct ast_channel *peer, struct ast_park_call_args *args)
{
        struct parkeduser *pu = args->pu;
        const char *event_from;
        char app_data[AST_MAX_EXTENSION + AST_MAX_CONTEXT];

        if (pu == NULL) {
                args->pu = pu = park_space_reserve(chan, peer, args);
                if (pu == NULL) {
                        return -1;
                }
        }

        ast_channel_appl_set(chan, "Parked Call");
        ast_channel_data_set(chan, NULL);

        pu->chan = chan;

        /* Put the parked channel on hold if we have two different channels */
        if (chan != peer) {
                if (ast_test_flag(args, AST_PARK_OPT_RINGING)) {
                        pu->hold_method = AST_CONTROL_RINGING;
                        ast_indicate(pu->chan, AST_CONTROL_RINGING);
                } else {
                        pu->hold_method = AST_CONTROL_HOLD;
                        ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
                                S_OR(pu->parkinglot->cfg.mohclass, NULL),
                                !ast_strlen_zero(pu->parkinglot->cfg.mohclass) ? strlen(pu->parkinglot->cfg.mohclass) + 1 : 0);
                }
        }
        
        pu->start = ast_tvnow();
        pu->parkingtime = (args->timeout > 0) ? args->timeout : pu->parkinglot->cfg.parkingtime;
        if (args->extout)
                *(args->extout) = pu->parkingnum;

        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(ast_channel_tech(peer)->type, "Local")) {
                        struct ast_channel *tmpchan, *base_peer;
                        char other_side[AST_CHANNEL_NAME];
                        char *c;

                        ast_copy_string(other_side, S_OR(args->orig_chan_name, ast_channel_name(peer)), sizeof(other_side));
                        if ((c = strrchr(other_side, ';'))) {
                                *++c = '1';
                        }
                        if ((tmpchan = ast_channel_get_by_name(other_side))) {
                                ast_channel_lock(tmpchan);
                                if ((base_peer = ast_bridged_channel(tmpchan))) {
                                        ast_copy_string(pu->peername, ast_channel_name(base_peer), sizeof(pu->peername));
                                }
                                ast_channel_unlock(tmpchan);
                                tmpchan = ast_channel_unref(tmpchan);
                        }
                } else {
                        ast_copy_string(pu->peername, S_OR(args->orig_chan_name, ast_channel_name(peer)), sizeof(pu->peername));
                }
        }

        /*
         * Remember what had been dialed, so that if the parking
         * expires, we try to come back to the same place
         */
        pu->options_specified = (!ast_strlen_zero(args->return_con) || !ast_strlen_zero(args->return_ext) || args->return_pri);

        /*
         * If extension has options specified, they override all other
         * possibilities such as the returntoorigin flag and transferred
         * context.  Information on extension options is lost here, so
         * we set a flag
         */
        ast_copy_string(pu->context, 
                S_OR(args->return_con, S_OR(ast_channel_macrocontext(chan), ast_channel_context(chan))), 
                sizeof(pu->context));
        ast_copy_string(pu->exten, 
                S_OR(args->return_ext, S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan))), 
                sizeof(pu->exten));
        pu->priority = args->return_pri ? args->return_pri : 
                (ast_channel_macropriority(chan) ? ast_channel_macropriority(chan) : ast_channel_priority(chan));

        /*
         * If parking a channel directly, don't quite yet get parking
         * running on it.  All parking lot entries are put into the
         * parking lot with notquiteyet on.
         */
        if (peer != chan) {
                pu->notquiteyet = 0;
        }

        /* Wake up the (presumably select()ing) thread */
        pthread_kill(parking_thread, SIGURG);
        ast_verb(2, "Parked %s on %d (lot %s). Will timeout back to extension [%s] %s, %d in %d seconds\n",
                ast_channel_name(pu->chan), pu->parkingnum, pu->parkinglot->name,
                pu->context, pu->exten, pu->priority, (pu->parkingtime / 1000));

        ast_cel_report_event(pu->chan, AST_CEL_PARK_START, NULL, pu->parkinglot->name, peer);

        if (peer) {
                event_from = ast_channel_name(peer);
        } else {
                event_from = pbx_builtin_getvar_helper(chan, "BLINDTRANSFER");
        }

        ast_manager_event(pu->chan, EVENT_FLAG_CALL, "ParkedCall",
                "Exten: %s\r\n"
                "Channel: %s\r\n"
                "Parkinglot: %s\r\n"
                "From: %s\r\n"
                "Timeout: %ld\r\n"
                "CallerIDNum: %s\r\n"
                "CallerIDName: %s\r\n"
                "ConnectedLineNum: %s\r\n"
                "ConnectedLineName: %s\r\n"
                "Uniqueid: %s\r\n",
                pu->parkingexten, ast_channel_name(pu->chan), pu->parkinglot->name, event_from ? event_from : "",
                (long)pu->start.tv_sec + (long)(pu->parkingtime/1000) - (long)time(NULL),
                S_COR(pu->chan->caller.id.number.valid, pu->chan->caller.id.number.str, "<unknown>"),
                S_COR(pu->chan->caller.id.name.valid, pu->chan->caller.id.name.str, "<unknown>"),
                S_COR(pu->chan->connected.id.number.valid, pu->chan->connected.id.number.str, "<unknown>"),
                S_COR(pu->chan->connected.id.name.valid, pu->chan->connected.id.name.str, "<unknown>"),
                ast_channel_uniqueid(pu->chan)
                );

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

        snprintf(app_data, sizeof(app_data), "%s,%s", pu->parkingexten,
                pu->parkinglot->name);
        if (ast_add_extension(pu->parkinglot->cfg.parking_con, 1, pu->parkingexten, 1,
                NULL, NULL, parkedcall, ast_strdup(app_data), ast_free_ptr, registrar)) {
                ast_log(LOG_ERROR, "Could not create parked call exten: %s@%s\n",
                        pu->parkingexten, pu->parkinglot->cfg.parking_con);
        } else {
                notify_metermaids(pu->parkingexten, pu->parkinglot->cfg.parking_con, AST_DEVICE_INUSE);
        }

        AST_LIST_UNLOCK(&pu->parkinglot->parkings);

        /* Only say number if it's a number and the channel hasn't been masqueraded away */
        if (peer && !ast_test_flag(args, AST_PARK_OPT_SILENCE)
                && (ast_strlen_zero(args->orig_chan_name) || !strcasecmp(ast_channel_name(peer), args->orig_chan_name))) {
                /*
                 * If a channel is masqueraded into peer while playing back the
                 * parking space number do not continue playing it back.  This
                 * is the case if an attended transfer occurs.
                 */
                ast_set_flag(peer, AST_FLAG_MASQ_NOSTREAM);
                /* Tell the peer channel the number of the parking space */
                ast_say_digits(peer, pu->parkingnum, "", ast_channel_language(peer));
                ast_clear_flag(peer, AST_FLAG_MASQ_NOSTREAM);
        }
        if (peer == chan) { /* pu->notquiteyet = 1 */
                /* Wake up parking thread if we're really done */
                pu->hold_method = AST_CONTROL_HOLD;
                ast_indicate_data(pu->chan, AST_CONTROL_HOLD, 
                        S_OR(pu->parkinglot->cfg.mohclass, NULL),
                        !ast_strlen_zero(pu->parkinglot->cfg.mohclass) ? strlen(pu->parkinglot->cfg.mohclass) + 1 : 0);
                pu->notquiteyet = 0;
                pthread_kill(parking_thread, SIGURG);
        }
        return 0;
}

int ast_park_call_exten(struct ast_channel *park_me, struct ast_channel *parker, const char *park_exten, const char *park_context, int timeout, int *extout)
{
        int res;
        char *parse;
        const char *app_data;
        struct ast_exten *exten;
        struct park_app_args app_args;
        struct ast_park_call_args args = {
                .timeout = timeout,
                .extout = extout,
        };

        if (!park_exten || !park_context) {
                return park_call_full(park_me, parker, &args);
        }

        /*
         * Determiine if the specified park extension has an exclusive
         * parking lot to use.
         */
        if (parker && parker != park_me) {
                ast_autoservice_start(park_me);
        }
        exten = get_parking_exten(park_exten, parker, park_context);
        if (exten) {
                app_data = ast_get_extension_app_data(exten);
                if (!app_data) {
                        app_data = "";
                }
                parse = ast_strdupa(app_data);
                AST_STANDARD_APP_ARGS(app_args, parse);
        
                if (!ast_strlen_zero(app_args.pl_name)) {
                        /* Find the specified exclusive parking lot */
                        args.parkinglot = find_parkinglot(app_args.pl_name);
                        if (!args.parkinglot && parkeddynamic) {
                                args.parkinglot = create_dynamic_parkinglot(app_args.pl_name, park_me);
                        }
                }
        }
        if (parker && parker != park_me) {
                ast_autoservice_stop(park_me);
        }

        res = park_call_full(park_me, parker, &args);
        if (args.parkinglot) {
                parkinglot_unref(args.parkinglot);
        }
        return res;
}

int ast_park_call(struct ast_channel *park_me, struct ast_channel *parker, int timeout, const char *park_exten, int *extout)
{
        struct ast_park_call_args args = {
                .timeout = timeout,
                .extout = extout,
        };

        return park_call_full(park_me, parker, &args);
}

/*!
 * \brief Park call via masqueraded channel and announce parking spot on peer channel.
 *
 * \param rchan the real channel to be parked
 * \param peer the channel to have the parking read to.
 * \param args Additional parking options when parking a call.
 *
 * \retval 0 on success.
 * \retval -1 on failure.
 */
static int masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, struct ast_park_call_args *args)
{
        struct ast_channel *chan;

        /* Make a new, channel that we'll use to masquerade in the real one */
        chan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, ast_channel_accountcode(rchan), ast_channel_exten(rchan),
                ast_channel_context(rchan), ast_channel_linkedid(rchan), ast_channel_amaflags(rchan), "Parked/%s", ast_channel_name(rchan));
        if (!chan) {
                ast_log(LOG_WARNING, "Unable to create parked channel\n");
                if (!ast_test_flag(args, AST_PARK_OPT_SILENCE)) {
                        if (peer == rchan) {
                                /* Only have one channel to worry about. */
                                ast_stream_and_wait(peer, "pbx-parkingfailed", "");
                        } else if (peer) {
                                /* Have two different channels to worry about. */
                                play_message_on_chan(peer, rchan, "failure message", "pbx-parkingfailed");
                        }
                }
                return -1;
        }

        args->pu = park_space_reserve(rchan, peer, args);
        if (!args->pu) {
                ast_hangup(chan);
                if (!ast_test_flag(args, AST_PARK_OPT_SILENCE)) {
                        if (peer == rchan) {
                                /* Only have one channel to worry about. */
                                ast_stream_and_wait(peer, "pbx-parkingfailed", "");
                        } else if (peer) {
                                /* Have two different channels to worry about. */
                                play_message_on_chan(peer, rchan, "failure message", "pbx-parkingfailed");
                        }
                }
                return -1;
        }

        /* Make formats okay */
        chan->readformat = rchan->readformat;
        chan->writeformat = rchan->writeformat;

        if (ast_channel_masquerade(chan, rchan)) {
                park_space_abort(args->pu);
                args->pu = NULL;
                ast_hangup(chan);
                if (!ast_test_flag(args, AST_PARK_OPT_SILENCE)) {
                        if (peer == rchan) {
                                /* Only have one channel to worry about. */
                                ast_stream_and_wait(peer, "pbx-parkingfailed", "");
                        } else if (peer) {
                                /* Have two different channels to worry about. */
                                play_message_on_chan(peer, rchan, "failure message", "pbx-parkingfailed");
                        }
                }
                return -1;
        }

        /* Setup the extensions and such */
        set_c_e_p(chan, ast_channel_context(rchan), ast_channel_exten(rchan), ast_channel_priority(rchan));

        /* Setup the macro extension and such */
        ast_channel_macrocontext_set(chan, ast_channel_macrocontext(rchan));
        ast_channel_macroexten_set(chan, ast_channel_macroexten(rchan));
        ast_channel_macropriority_set(chan, ast_channel_macropriority(rchan));

        /* Manually do the masquerade to make sure it is complete. */
        ast_do_masquerade(chan);

        if (peer == rchan) {
                peer = chan;
        }

        /* parking space reserved, return code check unnecessary */
        park_call_full(chan, peer, args);

        return 0;
}

int ast_masq_park_call_exten(struct ast_channel *park_me, struct ast_channel *parker, const char *park_exten, const char *park_context, int timeout, int *extout)
{
        int res;
        char *parse;
        const char *app_data;
        struct ast_exten *exten;
        struct park_app_args app_args;
        struct ast_park_call_args args = {
                .timeout = timeout,
                .extout = extout,
        };

        if (parker) {
                args.orig_chan_name = ast_strdupa(ast_channel_name(parker));
        }
        if (!park_exten || !park_context) {
                return masq_park_call(park_me, parker, &args);
        }

        /*
         * Determiine if the specified park extension has an exclusive
         * parking lot to use.
         */
        if (parker && parker != park_me) {
                ast_autoservice_start(park_me);
        }
        exten = get_parking_exten(park_exten, parker, park_context);
        if (exten) {
                app_data = ast_get_extension_app_data(exten);
                if (!app_data) {
                        app_data = "";
                }
                parse = ast_strdupa(app_data);
                AST_STANDARD_APP_ARGS(app_args, parse);
        
                if (!ast_strlen_zero(app_args.pl_name)) {
                        /* Find the specified exclusive parking lot */
                        args.parkinglot = find_parkinglot(app_args.pl_name);
                        if (!args.parkinglot && parkeddynamic) {
                                args.parkinglot = create_dynamic_parkinglot(app_args.pl_name, park_me);
                        }
                }
        }
        if (parker && parker != park_me) {
                ast_autoservice_stop(park_me);
        }

        res = masq_park_call(park_me, parker, &args);
        if (args.parkinglot) {
                parkinglot_unref(args.parkinglot);
        }
        return res;
}

int ast_masq_park_call(struct ast_channel *rchan, struct ast_channel *peer, int timeout, int *extout)
{
        struct ast_park_call_args args = {
                .timeout = timeout,
                .extout = extout,
        };

        if (peer) {
                args.orig_chan_name = ast_strdupa(ast_channel_name(peer));
        }
        return masq_park_call(rchan, peer, &args);
}

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

        return ast_autoservice_stop(chan);
}

/*!
 * \internal
 * \brief Builtin transfer park call helper.
 *
 * \param park_me Channel to be parked.
 * \param parker Channel parking the call.
 * \param park_exten Parking lot dialplan access ramp extension.
 *
 * \note Assumes park_me is on hold and in autoservice.
 *
 * \retval -1 on successful park.
 * \retval -1 on park_me hangup.
 * \retval AST_FEATURE_RETURN_SUCCESS on error to keep the bridge connected.
 */
static int xfer_park_call_helper(struct ast_channel *park_me, struct ast_channel *parker, struct ast_exten *park_exten)
{
        char *parse;
        const char *app_data;
        const char *pl_name;
        struct ast_park_call_args args = { 0, };
        struct park_app_args app_args;
        int res;

        app_data = ast_get_extension_app_data(park_exten);
        if (!app_data) {
                app_data = "";
        }
        parse = ast_strdupa(app_data);
        AST_STANDARD_APP_ARGS(app_args, parse);

        /* Find the parking lot */
        if (!ast_strlen_zero(app_args.pl_name)) {
                pl_name = app_args.pl_name;
        } else {
                pl_name = findparkinglotname(parker);
        }
        if (ast_strlen_zero(pl_name)) {
                /* Parking lot is not specified, so use the default parking lot. */
                args.parkinglot = parkinglot_addref(default_parkinglot);
        } else {
                args.parkinglot = find_parkinglot(pl_name);
                if (!args.parkinglot && parkeddynamic) {
                        args.parkinglot = create_dynamic_parkinglot(pl_name, park_me);
                }
        }

        if (args.parkinglot) {
                /* Park the call */
                res = finishup(park_me);
                if (res) {
                        /* park_me hungup on us. */
                        parkinglot_unref(args.parkinglot);
                        return -1;
                }
                res = masq_park_call(park_me, parker, &args);
                parkinglot_unref(args.parkinglot);
        } else {
                /* Parking failed because parking lot does not exist. */
                if (!ast_test_flag(&args, AST_PARK_OPT_SILENCE)) {
                        ast_stream_and_wait(parker, "pbx-parkingfailed", "");
                }
                finishup(park_me);
                res = -1;
        }

        return res ? AST_FEATURE_RETURN_SUCCESS : -1;
}

/*!
 * \brief set caller and callee according to the direction
 * \param caller, callee, peer, chan, sense
 *
 * Detect who triggered feature and set callee/caller variables accordingly
 */
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
 * \param chan channel parking call
 * \param peer channel to be parked
 * \param config unsed
 * \param code unused
 * \param sense feature options
 * \param data unused
 *
 * \retval -1 on successful park.
 * \retval -1 on chan hangup.
 * \retval AST_FEATURE_RETURN_SUCCESS on error to keep the bridge connected.
 */
static int builtin_parkcall(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const char *code, int sense, void *data)
{
        struct ast_channel *parker;
        struct ast_channel *parkee;
        struct ast_park_call_args args = { 0, };

        /*
         * We used to set chan's exten and priority to "s" and 1 here,
         * but this generates (in some cases) an invalid extension, and
         * if "s" exists, could errantly cause execution of extensions
         * you don't expect.  It makes more sense to let nature take its
         * course when chan finishes, and let the pbx do its thing and
         * hang up when the park is over.
         */

        /* Answer if call is not up */
        if (ast_channel_state(chan) != AST_STATE_UP) {
                /*
                 * XXX Why are we doing this?  Both of the channels should be up
                 * since you cannot do DTMF features unless you are bridged.
                 */
                if (ast_answer(chan)) {
                        return -1;
                }

                /* Sleep to allow VoIP streams to settle down */
                if (ast_safe_sleep(chan, 1000)) {
                        return -1;
                }
        }

        /* one direction used to call park_call.... */
        set_peers(&parker, &parkee, peer, chan, sense);
        return masq_park_call(parkee, parker, &args) ? AST_FEATURE_RETURN_SUCCESS : -1;
}

/*!
 * \internal
 * \brief Play file to specified channel.
 *
 * \param play_to Channel to play audiofile to.
 * \param other Channel to put in autoservice while playing file.
 * \param msg Descriptive name of message type being played.
 * \param audiofile Audio file to play.
 *
 * \retval 0 on success.
 * \retval -1 on error. (Couldn't play file, a channel hung up,...)
 */
static int play_message_on_chan(struct ast_channel *play_to, struct ast_channel *other, const char *msg, const char *audiofile)
{
        /* Put other channel in autoservice. */
        if (ast_autoservice_start(other)) {
                return -1;
        }
        ast_autoservice_ignore(other, AST_FRAME_DTMF_BEGIN);
        ast_autoservice_ignore(other, AST_FRAME_DTMF_END);
        if (ast_stream_and_wait(play_to, audiofile, "")) {
                ast_log(LOG_WARNING, "Failed to play %s '%s'!\n", msg, audiofile);
                ast_autoservice_stop(other);
                return -1;
        }
        if (ast_autoservice_stop(other)) {
                return -1;
        }
        return 0;
}

/*!
 * \internal
 * \brief Play file to specified channels.
 *
 * \param left Channel on left to play file.
 * \param right Channel on right to play file.
 * \param which Play file on indicated channels: which < 0 play left, which == 0 play both, which > 0 play right
 * \param msg Descriptive name of message type being played.
 * \param audiofile Audio file to play to channels.
 *
 * \note Plays file to the indicated channels in turn so please
 * don't use this for very long messages.
 *
 * \retval 0 on success.
 * \retval -1 on error. (Couldn't play file, channel hung up,...)
 */
static int play_message_to_chans(struct ast_channel *left, struct ast_channel *right, int which, const char *msg, const char *audiofile)
{
        /* First play the file to the left channel if requested. */
        if (which <= 0 && play_message_on_chan(left, right, msg, audiofile)) {
                return -1;
        }

        /* Then play the file to the right channel if requested. */
        if (which >= 0 && play_message_on_chan(right, left, msg, audiofile)) {
                return -1;
        }

        return 0;
}

/*!
 * \brief Play message to both caller and callee in bridged call, plays synchronously, autoservicing the
 * other channel during the message, so please don't use this for very long messages
 */
static int play_message_in_bridged_call(struct ast_channel *caller_chan, struct ast_channel *callee_chan, const char *audiofile)
{
        return play_message_to_chans(caller_chan, callee_chan, 0, "automon message",
                audiofile);
}

/*!
 * \brief Monitor a channel by DTMF
 * \param chan channel requesting monitor
 * \param peer channel to be monitored
 * \param config
 * \param code
 * \param sense feature options
 *
 * \param data
 * Check monitor app enabled, setup channels, both caller/callee chans not null
 * get TOUCH_MONITOR variable for filename if exists, exec monitor app.
 * \retval AST_FEATURE_RETURN_SUCCESS on success.
 * \retval -1 on error.
 */
static int builtin_automonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const 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;
        const char *automon_message_start = NULL;
        const char *automon_message_stop = NULL;

        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 (caller_chan) {      /* Find extra messages */
                automon_message_start = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_START");
                automon_message_stop = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_MESSAGE_STOP");
        }

        if (!ast_strlen_zero(courtesytone)) {   /* Play courtesy tone if configured */
                if(play_message_in_bridged_call(caller_chan, callee_chan, courtesytone) == -1) {
                        return -1;
                }
        }
        
        if (ast_channel_monitor(callee_chan)) {
                ast_verb(4, "User hit '%s' to stop recording call.\n", code);
                if (!ast_strlen_zero(automon_message_stop)) {
                        play_message_in_bridged_call(caller_chan, callee_chan, automon_message_stop);
                }
                ast_channel_monitor(callee_chan)->stop(callee_chan, 1);
                return AST_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");
                const char *touch_monitor_prefix = pbx_builtin_getvar_helper(caller_chan, "TOUCH_MONITOR_PREFIX");

                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_prefix)
                        touch_monitor_prefix = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MONITOR_PREFIX");
        
                if (touch_monitor) {
                        len = strlen(touch_monitor) + 50;
                        args = alloca(len);
                        touch_filename = alloca(len);
                        snprintf(touch_filename, len, "%s-%ld-%s", S_OR(touch_monitor_prefix, "auto"), (long)time(NULL), touch_monitor);
                        snprintf(args, len, "%s,%s,m", S_OR(touch_format, "wav"), touch_filename);
                } else {
                        caller_chan_id = ast_strdupa(S_COR(caller_chan->caller.id.number.valid,
                                caller_chan->caller.id.number.str, ast_channel_name(caller_chan)));
                        callee_chan_id = ast_strdupa(S_COR(callee_chan->caller.id.number.valid,
                                callee_chan->caller.id.number.str, ast_channel_name(callee_chan)));
                        len = strlen(caller_chan_id) + strlen(callee_chan_id) + 50;
                        args = alloca(len);
                        touch_filename = alloca(len);
                        snprintf(touch_filename, len, "%s-%ld-%s-%s", S_OR(touch_monitor_prefix, "auto"), (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] = '-';
                }
                
                ast_verb(4, "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);

                if (!ast_strlen_zero(automon_message_start)) {  /* Play start message for both channels */
                        play_message_in_bridged_call(caller_chan, callee_chan, automon_message_start);
                }
        
                return AST_FEATURE_RETURN_SUCCESS;
        }
        
        ast_log(LOG_NOTICE,"Cannot record the call. One or both channels have gone away.\n");   
        return -1;
}

static int builtin_automixmonitor(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const 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;
        const char *mixmonitor_spy_type = "MixMonitor";
        int count = 0;

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

        if (!(mixmonitor_app = pbx_findapp("MixMonitor"))) {
                mixmonitor_ok = 0;
                ast_log(LOG_ERROR,"Cannot record the call. The mixmonitor 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;
                ast_autoservice_ignore(callee_chan, AST_FRAME_DTMF_END);
                if (ast_stream_and_wait(caller_chan, courtesytone, "")) {
                        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;
        }

        ast_channel_lock(callee_chan);
        count = ast_channel_audiohook_count_by_source(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
        ast_channel_unlock(callee_chan);

        /* This means a mixmonitor is attached to the channel, running or not is unknown. */
        if (count > 0) {
                
                ast_verb(3, "User hit '%s' to stop recording call.\n", code);

                /* Make sure they are running */
                ast_channel_lock(callee_chan);
                count = ast_channel_audiohook_count_by_source_running(callee_chan, mixmonitor_spy_type, AST_AUDIOHOOK_TYPE_SPY);
                ast_channel_unlock(callee_chan);
                if (count > 0) {
                        if (!stopmixmonitor_ok) {
                                ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
                                return -1;
                        }
                        if (!(stopmixmonitor_app = pbx_findapp("StopMixMonitor"))) {
                                stopmixmonitor_ok = 0;
                                ast_log(LOG_ERROR,"Cannot stop recording the call. The stopmixmonitor application is disabled.\n");
                                return -1;
                        } else {
                                pbx_exec(callee_chan, stopmixmonitor_app, "");
                                return AST_FEATURE_RETURN_SUCCESS;
                        }
                }
                
                ast_log(LOG_WARNING,"Stopped MixMonitors are attached to the channel.\n");      
        }                       

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

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

                if (!touch_monitor)
                        touch_monitor = pbx_builtin_getvar_helper(callee_chan, "TOUCH_MIXMONITOR");

                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,b", touch_filename, (touch_format) ? touch_format : "wav");
                } else {
                        caller_chan_id = ast_strdupa(S_COR(caller_chan->caller.id.number.valid,
                                caller_chan->caller.id.number.str, ast_channel_name(caller_chan)));
                        callee_chan_id = ast_strdupa(S_COR(callee_chan->caller.id.number.valid,
                                callee_chan->caller.id.number.str, ast_channel_name(callee_chan)));
                        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,b", touch_filename, S_OR(touch_format, "wav"));
                }

                for( x = 0; x < strlen(args); x++) {
                        if (args[x] == '/')
                                args[x] = '-';
                }

                ast_verb(3, "User hit '%s' to record call. filename: %s\n", code, touch_filename);

                pbx_exec(callee_chan, mixmonitor_app, args);
                pbx_builtin_setvar_helper(callee_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
                pbx_builtin_setvar_helper(caller_chan, "TOUCH_MIXMONITOR_OUTPUT", touch_filename);
                return AST_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, const char *code, int sense, void *data)
{
        ast_verb(4, "User hit '%s' to disconnect call.\n", code);
        return AST_FEATURE_RETURN_HANGUP;
}

/*!
 * \brief Find the context for the transfer
 * \param transferer
 * \param transferee
 * 
 * Grab the TRANSFER_CONTEXT, if fails try grabbing macrocontext.
 * \return a context string
 */
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 = ast_channel_macrocontext(transferer);
        }
        if (ast_strlen_zero(s)) {
                s = ast_channel_context(transferer);
        }
        return s;  
}

/*!
 * \brief Blind transfer user to another extension
 * \param chan channel to be transfered
 * \param peer channel initiated blind transfer
 * \param config
 * \param code
 * \param data
 * \param sense  feature options
 * 
 * Place chan on hold, check if transferred to parkinglot extension,
 * otherwise check extension exists and transfer caller.
 * \retval AST_FEATURE_RETURN_SUCCESS.
 * \retval -1 on failure.
 */
static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const char *code, int sense, void *data)
{
        struct ast_channel *transferer;
        struct ast_channel *transferee;
        struct ast_exten *park_exten;
        const char *transferer_real_context;
        char xferto[256] = "";
        int res;

        ast_debug(1, "Executing Blind Transfer %s, %s (sense=%d) \n", ast_channel_name(chan), ast_channel_name(peer), sense);
        set_peers(&transferer, &transferee, peer, chan, sense);
        transferer_real_context = real_ctx(transferer, transferee);

        /* Start autoservice on transferee while we talk to the transferer */
        ast_autoservice_start(transferee);
        ast_indicate(transferee, AST_CONTROL_HOLD);

        /* Transfer */
        res = ast_stream_and_wait(transferer, "pbx-transfer", 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;
        }

        res = ast_app_dtget(transferer, transferer_real_context, xferto, sizeof(xferto), 100, transferdigittimeout);
        if (res < 0) {  /* hangup or error, (would be 0 for invalid and 1 for valid) */
                finishup(transferee);
                return -1;
        }
        if (res == 0) {
                if (xferto[0]) {
                        ast_log(LOG_WARNING, "Extension '%s' does not exist in context '%s'\n",
                                xferto, transferer_real_context);
                } else {
                        /* Does anyone care about this case? */
                        ast_log(LOG_WARNING, "No digits dialed.\n");
                }
                ast_stream_and_wait(transferer, "pbx-invalid", "");
                finishup(transferee);
                return AST_FEATURE_RETURN_SUCCESS;
        }

        park_exten = get_parking_exten(xferto, transferer, transferer_real_context);
        if (park_exten) {
                /* We are transfering the transferee to a parking lot. */
                return xfer_park_call_helper(transferee, transferer, park_exten);
        }

        /* Do blind transfer. */
        ast_verb(3, "Blind transferring %s to '%s' (context %s) priority 1\n",
                ast_channel_name(transferee), xferto, transferer_real_context);
        ast_cel_report_event(transferer, AST_CEL_BLINDTRANSFER, NULL, xferto, transferee);
        pbx_builtin_setvar_helper(transferer, "BLINDTRANSFER", ast_channel_name(transferee));
        pbx_builtin_setvar_helper(transferee, "BLINDTRANSFER", ast_channel_name(transferer));
        finishup(transferee);
        ast_channel_lock(transferer);
        if (!ast_channel_cdr(transferer)) { /* this code should never get called (in a perfect world) */
                ast_channel_cdr_set(transferer, ast_cdr_alloc());
                if (ast_channel_cdr(transferer)) {
                        ast_cdr_init(ast_channel_cdr(transferer), transferer); /* initialize our channel's cdr */
                        ast_cdr_start(ast_channel_cdr(transferer));
                }
        }
        ast_channel_unlock(transferer);
        if (ast_channel_cdr(transferer)) {
                struct ast_cdr *swap = ast_channel_cdr(transferer);

                ast_debug(1,
                        "transferer=%s; transferee=%s; lastapp=%s; lastdata=%s; chan=%s; dstchan=%s\n",
                        ast_channel_name(transferer), ast_channel_name(transferee), ast_channel_cdr(transferer)->lastapp,
                        ast_channel_cdr(transferer)->lastdata, ast_channel_cdr(transferer)->channel,
                        ast_channel_cdr(transferer)->dstchannel);
                ast_debug(1, "TRANSFEREE; lastapp=%s; lastdata=%s, chan=%s; dstchan=%s\n",
                        ast_channel_cdr(transferee)->lastapp, ast_channel_cdr(transferee)->lastdata, ast_channel_cdr(transferee)->channel,
                        ast_channel_cdr(transferee)->dstchannel);
                ast_debug(1, "transferer_real_context=%s; xferto=%s\n",
                        transferer_real_context, xferto);
                /* swap cdrs-- it will save us some time & work */
                ast_channel_cdr_set(transferer, ast_channel_cdr(transferee));
                ast_channel_cdr_set(transferee, swap);
        }
        if (!ast_channel_pbx(transferee)) {
                /* Doh!  Use our handy async_goto functions */
                ast_debug(1, "About to ast_async_goto %s.\n", ast_channel_name(transferee));
                if (ast_async_goto(transferee, transferer_real_context, xferto, 1)) {
                        ast_log(LOG_WARNING, "Async goto failed :-(\n");
                }

                /* The transferee is masqueraded and the original bridged channels can be hungup. */
                res = -1;
        } else {
                /* Set the transferee's new extension, since it exists, using transferer context */
                ast_debug(1, "About to explicit goto %s, it has a PBX.\n", ast_channel_name(transferee));
                ast_set_flag(transferee, AST_FLAG_BRIDGE_HANGUP_DONT); /* don't let the after-bridge code run the h-exten */
                set_c_e_p(transferee, transferer_real_context, xferto, 0);

                /*
                 * Break the bridge.  The transferee needs to resume executing
                 * dialplan at the xferto location.
                 */
                res = AST_FEATURE_RETURN_SUCCESSBREAK;
        }
        check_goto_on_transfer(transferer);
        return res;
}

/*!
 * \brief make channels compatible
 * \param c
 * \param newchan
 * \retval 0 on success.
 * \retval -1 on failure.
 */
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",
                        ast_channel_name(c), ast_channel_name(newchan));
                ast_hangup(newchan);
                return -1;
        }
        return 0;
}

/*!
 * \internal
 * \brief Builtin attended transfer failed cleanup.
 * \since 10.0
 *
 * \param transferee Party A in the transfer.
 * \param transferer Party B in the transfer.
 * \param connected_line Saved connected line info about party A.
 *
 * \note The connected_line data is freed.
 *
 * \return Nothing
 */
static void atxfer_fail_cleanup(struct ast_channel *transferee, struct ast_channel *transferer, struct ast_party_connected_line *connected_line)
{
        finishup(transferee);

        /*
         * Restore party B connected line info about party A.
         *
         * Party B was the caller to party C and is the last known mode
         * for party B.
         */
        if (ast_channel_connected_line_macro(transferee, transferer, connected_line, 1, 0)) {
                ast_channel_update_connected_line(transferer, connected_line, NULL);
        }
        ast_party_connected_line_free(connected_line);
}

/*!
 * \brief Attended transfer
 * \param chan transfered user
 * \param peer person transfering call
 * \param config
 * \param code
 * \param sense feature options
 *
 * \param data
 * Get extension to transfer to, if you cannot generate channel (or find extension)
 * return to host channel. After called channel answered wait for hangup of transferer,
 * bridge call between transfer peer (taking them off hold) to attended transfer channel.
 *
 * \return -1 on failure
 */
static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const char *code, int sense, void *data)
{
        struct ast_channel *transferer;/* Party B */
        struct ast_channel *transferee;/* Party A */
        struct ast_exten *park_exten;
        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;
        int l;
        struct ast_party_connected_line connected_line;
        struct ast_datastore *features_datastore;
        struct ast_dial_features *dialfeatures = NULL;
        char *transferer_tech;
        char *transferer_name;
        char *transferer_name_orig;
        char *dash;

        ast_debug(1, "Executing Attended Transfer %s, %s (sense=%d) \n", ast_channel_name(chan), ast_channel_name(peer), sense);
        set_peers(&transferer, &transferee, peer, chan, sense);
        transferer_real_context = real_ctx(transferer, transferee);

        /* Start autoservice on transferee while we talk to the transferer */
        ast_autoservice_start(transferee);
        ast_indicate(transferee, AST_CONTROL_HOLD);

        /* Transfer */
        res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
        if (res < 0) {
                finishup(transferee);
                return -1;
        }
        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 or error, (would be 0 for invalid and 1 for valid) */
                finishup(transferee);
                return -1;
        }
        l = strlen(xferto);
        if (res == 0) {
                if (l) {
                        ast_log(LOG_WARNING, "Extension '%s' does not exist in context '%s'\n",
                                xferto, transferer_real_context);
                } else {
                        /* Does anyone care about this case? */
                        ast_log(LOG_WARNING, "No digits dialed for atxfer.\n");
                }
                ast_stream_and_wait(transferer, "pbx-invalid", "");
                finishup(transferee);
                return AST_FEATURE_RETURN_SUCCESS;
        }

        park_exten = get_parking_exten(xferto, transferer, transferer_real_context);
        if (park_exten) {
                /* We are transfering the transferee to a parking lot. */
                return xfer_park_call_helper(transferee, transferer, park_exten);
        }

        /* Append context to dialed transfer number. */
        snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context);

        /* If we are performing an attended transfer and we have two channels involved then
           copy sound file information to play upon attended transfer completion */
        if (transferee) {
                const char *chan1_attended_sound = pbx_builtin_getvar_helper(transferer, "ATTENDED_TRANSFER_COMPLETE_SOUND");
                const char *chan2_attended_sound = pbx_builtin_getvar_helper(transferee, "ATTENDED_TRANSFER_COMPLETE_SOUND");

                if (!ast_strlen_zero(chan1_attended_sound)) {
                        pbx_builtin_setvar_helper(transferer, "BRIDGE_PLAY_SOUND", chan1_attended_sound);
                }
                if (!ast_strlen_zero(chan2_attended_sound)) {
                        pbx_builtin_setvar_helper(transferee, "BRIDGE_PLAY_SOUND", chan2_attended_sound);
                }
        }

        /* Extract redial transferer information from the channel name. */
        transferer_name_orig = ast_strdupa(ast_channel_name(transferer));
        transferer_name = ast_strdupa(transferer_name_orig);
        transferer_tech = strsep(&transferer_name, "/");
        dash = strrchr(transferer_name, '-');
        if (dash) {
                /* Trim off channel name sequence/serial number. */
                *dash = '\0';
        }

        /* Stop autoservice so we can monitor all parties involved in the transfer. */
        if (ast_autoservice_stop(transferee) < 0) {
                ast_indicate(transferee, AST_CONTROL_UNHOLD);
                return -1;
        }

        /* Save connected line info for party B about party A in case transfer fails. */
        ast_party_connected_line_init(&connected_line);
        ast_channel_lock(transferer);
        ast_party_connected_line_copy(&connected_line, &transferer->connected);
        ast_channel_unlock(transferer);
        connected_line.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;

        /* Dial party C */
        newchan = feature_request_and_dial(transferer, transferer_name_orig, transferer,
                transferee, "Local", ast_channel_nativeformats(transferer), xferto,
                atxfernoanswertimeout, &outstate, ast_channel_language(transferer));
        ast_debug(2, "Dial party C result: newchan:%d, outstate:%d\n", !!newchan, outstate);

        if (!ast_check_hangup(transferer)) {
                int hangup_dont = 0;

                /* Transferer (party B) is up */
                ast_debug(1, "Actually doing an attended transfer.\n");

                /* Start autoservice on transferee while the transferer deals with party C. */
                ast_autoservice_start(transferee);

                ast_indicate(transferer, -1);
                if (!newchan) {
                        /* any reason besides user requested cancel and busy triggers the failed sound */
                        switch (outstate) {
                        case AST_CONTROL_UNHOLD:/* Caller requested cancel or party C answer timeout. */
                        case AST_CONTROL_BUSY:
                        case AST_CONTROL_CONGESTION:
                                if (ast_stream_and_wait(transferer, xfersound, "")) {
                                        ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
                                }
                                break;
                        default:
                                if (ast_stream_and_wait(transferer, xferfailsound, "")) {
                                        ast_log(LOG_WARNING, "Failed to play transfer failed sound!\n");
                                }
                                break;
                        }
                        atxfer_fail_cleanup(transferee, transferer, &connected_line);
                        return AST_FEATURE_RETURN_SUCCESS;
                }

                if (check_compat(transferer, newchan)) {
                        if (ast_stream_and_wait(transferer, xferfailsound, "")) {
                                ast_log(LOG_WARNING, "Failed to play transfer failed sound!\n");
                        }
                        atxfer_fail_cleanup(transferee, transferer, &connected_line);
                        return AST_FEATURE_RETURN_SUCCESS;
                }
                memset(&bconfig,0,sizeof(struct ast_bridge_config));
                ast_set_flag(&(bconfig.features_caller), AST_FEATURE_DISCONNECT);
                ast_set_flag(&(bconfig.features_callee), AST_FEATURE_DISCONNECT);

                /* ast_bridge_call clears AST_FLAG_BRIDGE_HANGUP_DONT, but we don't
                   want that to happen here because we're also in another bridge already
                 */
                if (ast_test_flag(chan, AST_FLAG_BRIDGE_HANGUP_DONT)) {
                        hangup_dont = 1;
                }
                /* Let party B and party C talk as long as they want. */
                ast_bridge_call(transferer, newchan, &bconfig);
                if (hangup_dont) {
                        ast_set_flag(chan, AST_FLAG_BRIDGE_HANGUP_DONT);
                }

                if (ast_check_hangup(newchan) || !ast_check_hangup(transferer)) {
                        ast_hangup(newchan);
                        if (ast_stream_and_wait(transferer, xfersound, "")) {
                                ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
                        }
                        atxfer_fail_cleanup(transferee, transferer, &connected_line);
                        return AST_FEATURE_RETURN_SUCCESS;
                }

                /* Transferer (party B) is confirmed hung up at this point. */
                if (check_compat(transferee, newchan)) {
                        finishup(transferee);
                        ast_party_connected_line_free(&connected_line);
                        return -1;
                }

                ast_indicate(transferee, AST_CONTROL_UNHOLD);
                if ((ast_autoservice_stop(transferee) < 0)
                        || (ast_waitfordigit(transferee, 100) < 0)
                        || (ast_waitfordigit(newchan, 100) < 0)
                        || ast_check_hangup(transferee)
                        || ast_check_hangup(newchan)) {
                        ast_hangup(newchan);
                        ast_party_connected_line_free(&connected_line);
                        return -1;
                }
        } else if (!ast_check_hangup(transferee)) {
                /* Transferer (party B) has hung up at this point.  Doing blonde transfer. */
                ast_debug(1, "Actually doing a blonde transfer.\n");

                if (!newchan && !atxferdropcall) {
                        /* Party C is not available, try to call party B back. */
                        unsigned int tries = 0;

                        if (ast_strlen_zero(transferer_name) || ast_strlen_zero(transferer_tech)) {
                                ast_log(LOG_WARNING,
                                        "Transferer channel name: '%s' cannot be used for callback.\n",
                                        transferer_name_orig);
                                ast_indicate(transferee, AST_CONTROL_UNHOLD);
                                ast_party_connected_line_free(&connected_line);
                                return -1;
                        }

                        tries = 0;
                        for (;;) {
                                /* Try to get party B back. */
                                ast_debug(1, "We're trying to callback %s/%s\n",
                                        transferer_tech, transferer_name);
                                newchan = feature_request_and_dial(transferer, transferer_name_orig,
                                        transferee, transferee, transferer_tech,
                                        ast_channel_nativeformats(transferee), transferer_name,
                                        atxfernoanswertimeout, &outstate, ast_channel_language(transferer));
                                ast_debug(2, "Dial party B result: newchan:%d, outstate:%d\n",
                                        !!newchan, outstate);
                                if (newchan || ast_check_hangup(transferee)) {
                                        break;
                                }

                                ++tries;
                                if (atxfercallbackretries <= tries) {
                                        /* No more callback tries remaining. */
                                        break;
                                }

                                if (atxferloopdelay) {
                                        /* Transfer failed, sleeping */
                                        ast_debug(1, "Sleeping for %d ms before retrying atxfer.\n",
                                                atxferloopdelay);
                                        ast_safe_sleep(transferee, atxferloopdelay);
                                        if (ast_check_hangup(transferee)) {
                                                ast_party_connected_line_free(&connected_line);
                                                return -1;
                                        }
                                }

                                /* Retry dialing party C. */
                                ast_debug(1, "We're retrying to call %s/%s\n", "Local", xferto);
                                newchan = feature_request_and_dial(transferer, transferer_name_orig,
                                        transferer, transferee, "Local",
                                        ast_channel_nativeformats(transferee), xferto,
                                        atxfernoanswertimeout, &outstate, ast_channel_language(transferer));
                                ast_debug(2, "Redial party C result: newchan:%d, outstate:%d\n",
                                        !!newchan, outstate);
                                if (newchan || ast_check_hangup(transferee)) {
                                        break;
                                }
                        }
                }
                ast_indicate(transferee, AST_CONTROL_UNHOLD);
                if (!newchan) {
                        /* No party C or could not callback party B. */
                        ast_party_connected_line_free(&connected_line);
                        return -1;
                }

                /* newchan is up, we should prepare transferee and bridge them */
                if (ast_check_hangup(newchan)) {
                        ast_hangup(newchan);
                        ast_party_connected_line_free(&connected_line);
                        return -1;
                }
                if (check_compat(transferee, newchan)) {
                        ast_party_connected_line_free(&connected_line);
                        return -1;
                }
        } else {
                /*
                 * Both the transferer and transferee have hungup.  If newchan
                 * is up, hang it up as it has no one to talk to.
                 */
                ast_debug(1, "Everyone is hungup.\n");
                if (newchan) {
                        ast_hangup(newchan);
                }
                ast_party_connected_line_free(&connected_line);
                return -1;
        }

        /* Initiate the channel transfer of party A to party C (or recalled party B). */
        ast_cel_report_event(transferee, AST_CEL_ATTENDEDTRANSFER, NULL, NULL, newchan);

        xferchan = ast_channel_alloc(0, AST_STATE_DOWN, 0, 0, "", "", "", ast_channel_linkedid(transferee), 0, "Transfered/%s", ast_channel_name(transferee));
        if (!xferchan) {
                ast_hangup(newchan);
                ast_party_connected_line_free(&connected_line);
                return -1;
        }

        /* Give party A a momentary ringback tone during transfer. */
        ast_channel_visible_indication_set(xferchan, AST_CONTROL_RINGING);

        /* Make formats okay */
        xferchan->readformat = transferee->readformat;
        xferchan->writeformat = transferee->writeformat;

        ast_channel_masquerade(xferchan, transferee);
        ast_explicit_goto(xferchan, ast_channel_context(transferee), ast_channel_exten(transferee), ast_channel_priority(transferee));
        ast_channel_state_set(xferchan, AST_STATE_UP);
        ast_clear_flag(xferchan, AST_FLAGS_ALL);

        /* Do the masquerade manually to make sure that is is completed. */
        ast_do_masquerade(xferchan);

        ast_channel_state_set(newchan, AST_STATE_UP);
        ast_clear_flag(newchan, AST_FLAGS_ALL);
        tobj = ast_calloc(1, sizeof(*tobj));
        if (!tobj) {
                ast_hangup(xferchan);
                ast_hangup(newchan);
                ast_party_connected_line_free(&connected_line);
                return -1;
        }

        ast_channel_lock(newchan);
        if ((features_datastore = ast_channel_datastore_find(newchan, &dial_features_info, NULL))) {
                dialfeatures = features_datastore->data;
        }
        ast_channel_unlock(newchan);

        if (dialfeatures) {
                /* newchan should always be the callee and shows up as callee in dialfeatures, but for some reason
                   I don't currently understand, the abilities of newchan seem to be stored on the caller side */
                ast_copy_flags(&(config->features_callee), &(dialfeatures->features_caller), AST_FLAGS_ALL);
                dialfeatures = NULL;
        }

        ast_channel_lock(xferchan);
        if ((features_datastore = ast_channel_datastore_find(xferchan, &dial_features_info, NULL))) {
                dialfeatures = features_datastore->data;
        }
        ast_channel_unlock(xferchan);

        if (dialfeatures) {
                ast_copy_flags(&(config->features_caller), &(dialfeatures->features_caller), AST_FLAGS_ALL);
        }

        tobj->chan = newchan;
        tobj->peer = xferchan;
        tobj->bconfig = *config;

        if (tobj->bconfig.end_bridge_callback_data_fixup) {
                tobj->bconfig.end_bridge_callback_data_fixup(&tobj->bconfig, tobj->peer, tobj->chan);
        }

        /*
         * xferchan is transferee, and newchan is the transfer target
         * So...in a transfer, who is the caller and who is the callee?
         *
         * When the call is originally made, it is clear who is caller and callee.
         * When a transfer occurs, it is my humble opinion that the transferee becomes
         * the caller, and the transfer target is the callee.
         *
         * The problem is that these macros were set with the intention of the original
         * caller and callee taking those roles.  A transfer can totally mess things up,
         * to be technical.  What sucks even more is that you can't effectively change
         * the macros in the dialplan during the call from the transferer to the transfer
         * target because the transferee is stuck with whatever role he originally had.
         *
         * I think the answer here is just to make sure that it is well documented that
         * during a transfer, the transferee is the "caller" and the transfer target
         * is the "callee."
         *
         * This means that if party B calls party A, and party B transfers party A to
         * party C, then A has switched roles for the call.  Now party A will have the
         * caller macro called on his channel instead of the callee macro.
         *
         * Luckily, the method by which the party B to party C bridge is
         * launched above ensures that the transferee is the "chan" on
         * the bridge and the transfer target is the "peer," so my idea
         * for the roles post-transfer does not require extensive code
         * changes.
         */

        /* Transfer party C connected line to party A */
        ast_channel_lock(transferer);
        /*
         * Due to a limitation regarding when callerID is set on a Local channel,
         * we use the transferer's connected line information here.
         */
        ast_party_connected_line_copy(&connected_line, &transferer->connected);
        ast_channel_unlock(transferer);
        connected_line.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
        if (ast_channel_connected_line_macro(newchan, xferchan, &connected_line, 1, 0)) {
                ast_channel_update_connected_line(xferchan, &connected_line, NULL);
        }

        /* Transfer party A connected line to party C */
        ast_channel_lock(xferchan);
        ast_connected_line_copy_from_caller(&connected_line, &xferchan->caller);
        ast_channel_unlock(xferchan);
        connected_line.source = AST_CONNECTED_LINE_UPDATE_SOURCE_TRANSFER;
        if (ast_channel_connected_line_macro(xferchan, newchan, &connected_line, 0, 0)) {
                ast_channel_update_connected_line(newchan, &connected_line, NULL);
        }

        if (ast_stream_and_wait(newchan, xfersound, ""))
                ast_log(LOG_WARNING, "Failed to play transfer sound!\n");
        bridge_call_thread_launch(tobj);

        ast_party_connected_line_free(&connected_line);
        return -1;/* The transferee is masqueraded and the original bridged channels can be hungup. */
}

/* add atxfer and automon as undefined so you can only use em if you configure them */
#define FEATURES_COUNT ARRAY_LEN(builtin_features)

AST_RWLOCK_DEFINE_STATIC(features_lock);

static struct ast_call_feature builtin_features[] = {
        { AST_FEATURE_REDIRECT, "Blind Transfer", "blindxfer", "#", "#", builtin_blindtransfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
        { AST_FEATURE_REDIRECT, "Attended Transfer", "atxfer", "", "", builtin_atxfer, AST_FEATURE_FLAG_NEEDSDTMF, "" },
        { AST_FEATURE_AUTOMON, "One Touch Monitor", "automon", "", "", builtin_automonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
        { AST_FEATURE_DISCONNECT, "Disconnect Call", "disconnect", "*", "*", builtin_disconnect, AST_FEATURE_FLAG_NEEDSDTMF, "" },
        { AST_FEATURE_PARKCALL, "Park Call", "parkcall", "", "", builtin_parkcall, AST_FEATURE_FLAG_NEEDSDTMF, "" },
        { AST_FEATURE_AUTOMIXMON, "One Touch MixMonitor", "automixmon", "", "", builtin_automixmonitor, AST_FEATURE_FLAG_NEEDSDTMF, "" },
};


static AST_RWLIST_HEAD_STATIC(feature_list, ast_call_feature);

/*! \brief register new feature into feature_list*/
void ast_register_feature(struct ast_call_feature *feature)
{
        if (!feature) {
                ast_log(LOG_NOTICE,"You didn't pass a feature!\n");
                return;
        }
  
        AST_RWLIST_WRLOCK(&feature_list);
        AST_RWLIST_INSERT_HEAD(&feature_list,feature,feature_entry);
        AST_RWLIST_UNLOCK(&feature_list);

        ast_verb(2, "Registered Feature '%s'\n",feature->sname);
}

/*! 
 * \brief Add new feature group
 * \param fgname feature group name.
 *
 * Add new feature group to the feature group list insert at head of list.
 * \note This function MUST be called while feature_groups is locked.
 */
static struct feature_group *register_group(const char *fgname)
{
        struct feature_group *fg;

        if (!fgname) {
                ast_log(LOG_NOTICE, "You didn't pass a new group name!\n");
                return NULL;
        }

        if (!(fg = ast_calloc_with_stringfields(1, struct feature_group, 128))) {
                return NULL;
        }

        ast_string_field_set(fg, gname, fgname);

        AST_LIST_INSERT_HEAD(&feature_groups, fg, entry);

        ast_verb(2, "Registered group '%s'\n", fg->gname);

        return fg;
}

/*! 
 * \brief Add feature to group
 * \param fg feature group
 * \param exten
 * \param feature feature to add.
 *
 * Check fg and feature specified, add feature to list
 * \note This function MUST be called while feature_groups is locked. 
 */
static void register_group_feature(struct feature_group *fg, const char *exten, struct ast_call_feature *feature)
{
        struct feature_group_exten *fge;

        if (!fg) {
                ast_log(LOG_NOTICE, "You didn't pass a group!\n");
                return;
        }

        if (!feature) {
                ast_log(LOG_NOTICE, "You didn't pass a feature!\n");
                return;
        }

        if (!(fge = ast_calloc_with_stringfields(1, struct feature_group_exten, 128))) {
                return;
        }

        ast_string_field_set(fge, exten, S_OR(exten, feature->exten));

        fge->feature = feature;

        AST_LIST_INSERT_HEAD(&fg->features, fge, entry);

        ast_verb(2, "Registered feature '%s' for group '%s' at exten '%s'\n",
                                        feature->sname, fg->gname, fge->exten);
}

void ast_unregister_feature(struct ast_call_feature *feature)
{
        if (!feature) {
                return;
        }

        AST_RWLIST_WRLOCK(&feature_list);
        AST_RWLIST_REMOVE(&feature_list, feature, feature_entry);
        AST_RWLIST_UNLOCK(&feature_list);

        ast_free(feature);
}

/*! \brief Remove all features in the list */
static void ast_unregister_features(void)
{
        struct ast_call_feature *feature;

        AST_RWLIST_WRLOCK(&feature_list);
        while ((feature = AST_RWLIST_REMOVE_HEAD(&feature_list, feature_entry))) {
                ast_free(feature);
        }
        AST_RWLIST_UNLOCK(&feature_list);
}

/*! \brief find a call feature by name */
static struct ast_call_feature *find_dynamic_feature(const char *name)
{
        struct ast_call_feature *tmp;

        AST_RWLIST_TRAVERSE(&feature_list, tmp, feature_entry) {
                if (!strcasecmp(tmp->sname, name)) {
                        break;
                }
        }

        return tmp;
}

/*! \brief Remove all feature groups in the list */
static void ast_unregister_groups(void)
{
        struct feature_group *fg;
        struct feature_group_exten *fge;

        AST_RWLIST_WRLOCK(&feature_groups);
        while ((fg = AST_LIST_REMOVE_HEAD(&feature_groups, entry))) {
                while ((fge = AST_LIST_REMOVE_HEAD(&fg->features, entry))) {
                        ast_string_field_free_memory(fge);
                        ast_free(fge);
                }

                ast_string_field_free_memory(fg);
                ast_free(fg);
        }
        AST_RWLIST_UNLOCK(&feature_groups);
}

/*! 
 * \brief Find a group by name 
 * \param name feature name
 * \retval feature group on success.
 * \retval NULL on failure.
 */
static struct feature_group *find_group(const char *name)
{
        struct feature_group *fg = NULL;

        AST_LIST_TRAVERSE(&feature_groups, fg, entry) {
                if (!strcasecmp(fg->gname, name))
                        break;
        }

        return fg;
}

void ast_rdlock_call_features(void)
{
        ast_rwlock_rdlock(&features_lock);
}

void ast_unlock_call_features(void)
{
        ast_rwlock_unlock(&features_lock);
}

struct ast_call_feature *ast_find_call_feature(const char *name)
{
        int x;
        for (x = 0; x < FEATURES_COUNT; x++) {
                if (!strcasecmp(name, builtin_features[x].sname))
                        return &builtin_features[x];
        }

        return find_dynamic_feature(name);
}

/*!
 * \brief exec an app by feature 
 * \param chan,peer,config,code,sense,data
 *
 * Find a feature, determine which channel activated
 * \retval AST_FEATURE_RETURN_NO_HANGUP_PEER
 * \retval -1 error.
 * \retval -2 when an application cannot be found.
 */
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)
{
        struct ast_app *app;
        struct ast_call_feature *feature = data;
        struct ast_channel *work, *idle;
        int res;

        if (!feature) { /* shouldn't ever happen! */
                ast_log(LOG_NOTICE, "Found feature before, but at execing we've lost it??\n");
                return -1; 
        }

        if (sense == FEATURE_SENSE_CHAN) {
                if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER))
                        return AST_FEATURE_RETURN_KEEPTRYING;
                if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
                        work = chan;
                        idle = peer;
                } else {
                        work = peer;
                        idle = chan;
                }
        } else {
                if (!ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE))
                        return AST_FEATURE_RETURN_KEEPTRYING;
                if (ast_test_flag(feature, AST_FEATURE_FLAG_ONSELF)) {
                        work = peer;
                        idle = chan;
                } else {
                        work = chan;
                        idle = peer;
                }
        }

        if (!(app = pbx_findapp(feature->app))) {
                ast_log(LOG_WARNING, "Could not find application (%s)\n", feature->app);
                return -2;
        }

        ast_autoservice_start(idle);
        ast_autoservice_ignore(idle, AST_FRAME_DTMF_END);
        
        if(work && idle) {
                pbx_builtin_setvar_helper(work, "DYNAMIC_PEERNAME", ast_channel_name(idle));
                pbx_builtin_setvar_helper(idle, "DYNAMIC_PEERNAME", ast_channel_name(work));
                pbx_builtin_setvar_helper(work, "DYNAMIC_FEATURENAME", feature->sname);
                pbx_builtin_setvar_helper(idle, "DYNAMIC_FEATURENAME", feature->sname);
        }

        if (!ast_strlen_zero(feature->moh_class))
                ast_moh_start(idle, feature->moh_class, NULL);

        res = pbx_exec(work, app, feature->app_args);

        if (!ast_strlen_zero(feature->moh_class))
                ast_moh_stop(idle);

        ast_autoservice_stop(idle);

        if (res) {
                return AST_FEATURE_RETURN_SUCCESSBREAK;
        }
        return AST_FEATURE_RETURN_SUCCESS;      /*! \todo XXX should probably return res */
}

static void unmap_features(void)
{
        int x;

        ast_rwlock_wrlock(&features_lock);
        for (x = 0; x < FEATURES_COUNT; x++)
                strcpy(builtin_features[x].exten, builtin_features[x].default_exten);
        ast_rwlock_unlock(&features_lock);
}

static int remap_feature(const char *name, const char *value)
{
        int x, res = -1;

        ast_rwlock_wrlock(&features_lock);
        for (x = 0; x < FEATURES_COUNT; x++) {
                if (strcasecmp(builtin_features[x].sname, name))
                        continue;

                ast_copy_string(builtin_features[x].exten, value, sizeof(builtin_features[x].exten));
                res = 0;
                break;
        }
        ast_rwlock_unlock(&features_lock);

        return res;
}

/*!
 * \brief Helper function for feature_interpret and ast_feature_detect
 * \param chan,peer,config,code,sense,dynamic_features_buf,features,operation,feature
 *
 * Lock features list, browse for code, unlock list
 * If a feature is found and the operation variable is set, that feature's
 * operation is executed.  The first feature found is copied to the feature parameter.
 * \retval res on success.
 * \retval -1 on failure.
 */
static int feature_interpret_helper(struct ast_channel *chan, struct ast_channel *peer,
        struct ast_bridge_config *config, const char *code, int sense, char *dynamic_features_buf,
        struct ast_flags *features, feature_interpret_op operation, struct ast_call_feature *feature)
{
        int x;
        struct feature_group *fg = NULL;
        struct feature_group_exten *fge;
        struct ast_call_feature *tmpfeature;
        char *tmp, *tok;
        int res = AST_FEATURE_RETURN_PASSDIGITS;
        int feature_detected = 0;

        if (!(peer && chan && config) && operation == FEATURE_INTERPRET_DO) {
                return -1; /* can not run feature operation */
        }

        ast_rwlock_rdlock(&features_lock);
        for (x = 0; x < FEATURES_COUNT; x++) {
                if ((ast_test_flag(features, builtin_features[x].feature_mask)) &&
                    !ast_strlen_zero(builtin_features[x].exten)) {
                        /* Feature is up for consideration */
                        if (!strcmp(builtin_features[x].exten, code)) {
                                ast_debug(3, "Feature detected: fname=%s sname=%s exten=%s\n", builtin_features[x].fname, builtin_features[x].sname, builtin_features[x].exten);
                                if (operation == FEATURE_INTERPRET_CHECK) {
                                        res = AST_FEATURE_RETURN_SUCCESS; /* We found something */
                                } else if (operation == FEATURE_INTERPRET_DO) {
                                        res = builtin_features[x].operation(chan, peer, config, code, sense, NULL);
                                }
                                if (feature) {
                                        memcpy(feature, &builtin_features[x], sizeof(feature));
                                }
                                feature_detected = 1;
                                break;
                        } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) {
                                if (res == AST_FEATURE_RETURN_PASSDIGITS) {
                                        res = AST_FEATURE_RETURN_STOREDIGITS;
                                }
                        }
                }
        }
        ast_rwlock_unlock(&features_lock);

        if (ast_strlen_zero(dynamic_features_buf) || feature_detected) {
                return res;
        }

        tmp = dynamic_features_buf;

        while ((tok = strsep(&tmp, "#"))) {
                AST_RWLIST_RDLOCK(&feature_groups);

                fg = find_group(tok);

                if (fg) {
                        AST_LIST_TRAVERSE(&fg->features, fge, entry) {
                                if (!strcmp(fge->exten, code)) {
                                        if (operation) {
                                                res = fge->feature->operation(chan, peer, config, code, sense, fge->feature);
                                        }
                                        memcpy(feature, fge->feature, sizeof(feature));
                                        if (res != AST_FEATURE_RETURN_KEEPTRYING) {
                                                AST_RWLIST_UNLOCK(&feature_groups);
                                                break;
                                        }
                                        res = AST_FEATURE_RETURN_PASSDIGITS;
                                } else if (!strncmp(fge->exten, code, strlen(code))) {
                                        res = AST_FEATURE_RETURN_STOREDIGITS;
                                }
                        }
                        if (fge) {
                                break;
                        }
                }

                AST_RWLIST_UNLOCK(&feature_groups);

                AST_RWLIST_RDLOCK(&feature_list);

                if (!(tmpfeature = find_dynamic_feature(tok))) {
                        AST_RWLIST_UNLOCK(&feature_list);
                        continue;
                }

                /* Feature is up for consideration */
                if (!strcmp(tmpfeature->exten, code)) {
                        ast_verb(3, " Feature Found: %s exten: %s\n",tmpfeature->sname, tok);
                        if (operation == FEATURE_INTERPRET_CHECK) {
                                res = AST_FEATURE_RETURN_SUCCESS; /* We found something */
                        } else if (operation == FEATURE_INTERPRET_DO) {
                                res = tmpfeature->operation(chan, peer, config, code, sense, tmpfeature);
                        }
                        if (feature) {
                                memcpy(feature, tmpfeature, sizeof(feature));
                        }
                        if (res != AST_FEATURE_RETURN_KEEPTRYING) {
                                AST_RWLIST_UNLOCK(&feature_list);
                                break;
                        }
                        res = AST_FEATURE_RETURN_PASSDIGITS;
                } else if (!strncmp(tmpfeature->exten, code, strlen(code)))
                        res = AST_FEATURE_RETURN_STOREDIGITS;

                AST_RWLIST_UNLOCK(&feature_list);
        }

        return res;
}

/*!
 * \brief Check the dynamic features
 * \param chan,peer,config,code,sense
 *
 * \retval res on success.
 * \retval -1 on failure.
 */
static int feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, const char *code, int sense) {

        char dynamic_features_buf[128];
        const char *peer_dynamic_features, *chan_dynamic_features;
        struct ast_flags features;
        struct ast_call_feature feature;
        if (sense == FEATURE_SENSE_CHAN) {
                ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL);
        }
        else {
                ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL);
        }

        ast_channel_lock(peer);
        peer_dynamic_features = ast_strdupa(S_OR(pbx_builtin_getvar_helper(peer, "DYNAMIC_FEATURES"),""));
        ast_channel_unlock(peer);

        ast_channel_lock(chan);
        chan_dynamic_features = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"),""));
        ast_channel_unlock(chan);

        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,""));

        ast_debug(3, "Feature interpret: chan=%s, peer=%s, code=%s, sense=%d, features=%d, dynamic=%s\n", ast_channel_name(chan), ast_channel_name(peer), code, sense, features.flags, dynamic_features_buf);

        return feature_interpret_helper(chan, peer, config, code, sense, dynamic_features_buf, &features, FEATURE_INTERPRET_DO, &feature);
}


int ast_feature_detect(struct ast_channel *chan, struct ast_flags *features, const char *code, struct ast_call_feature *feature) {

        return feature_interpret_helper(chan, NULL, NULL, code, 0, NULL, features, FEATURE_INTERPRET_DETECT, feature);
}

/*! \brief Check if a feature exists */
static int feature_check(struct ast_channel *chan, struct ast_flags *features, char *code) {
        char *chan_dynamic_features;
        ast_channel_lock(chan);
        chan_dynamic_features = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"),""));
        ast_channel_unlock(chan);

        return feature_interpret_helper(chan, NULL, NULL, code, 0, chan_dynamic_features, features, FEATURE_INTERPRET_CHECK, NULL);
}

static void set_config_flags(struct ast_channel *chan, struct ast_bridge_config *config)
{
        int x;

        ast_clear_flag(config, AST_FLAGS_ALL);

        ast_rwlock_rdlock(&features_lock);
        for (x = 0; x < FEATURES_COUNT; x++) {
                if (!ast_test_flag(builtin_features + x, AST_FEATURE_FLAG_NEEDSDTMF))
                        continue;

                if (ast_test_flag(&(config->features_caller), builtin_features[x].feature_mask))
                        ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);

                if (ast_test_flag(&(config->features_callee), builtin_features[x].feature_mask))
                        ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
        }
        ast_rwlock_unlock(&features_lock);

        if (!(ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_0) && ast_test_flag(config, AST_BRIDGE_DTMF_CHANNEL_1))) {
                const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES");

                if (dynamic_features) {
                        char *tmp = ast_strdupa(dynamic_features);
                        char *tok;
                        struct ast_call_feature *feature;

                        /* while we have a feature */
                        while ((tok = strsep(&tmp, "#"))) {
                                struct feature_group *fg;

                                AST_RWLIST_RDLOCK(&feature_groups);
                                AST_RWLIST_TRAVERSE(&feature_groups, fg, entry) {
                                        struct feature_group_exten *fge;

                                        AST_LIST_TRAVERSE(&fg->features, fge, entry) {
                                                if (ast_test_flag(fge->feature, AST_FEATURE_FLAG_BYCALLER)) {
                                                        ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
                                                }
                                                if (ast_test_flag(fge->feature, AST_FEATURE_FLAG_BYCALLEE)) {
                                                        ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
                                                }
                                        }
                                }
                                AST_RWLIST_UNLOCK(&feature_groups);

                                AST_RWLIST_RDLOCK(&feature_list);
                                if ((feature = find_dynamic_feature(tok)) && ast_test_flag(feature, AST_FEATURE_FLAG_NEEDSDTMF)) {
                                        if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLER)) {
                                                ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_0);
                                        }
                                        if (ast_test_flag(feature, AST_FEATURE_FLAG_BYCALLEE)) {
                                                ast_set_flag(config, AST_BRIDGE_DTMF_CHANNEL_1);
                                        }
                                }
                                AST_RWLIST_UNLOCK(&feature_list);
                        }
                }
        }
}

/*!
 * \internal
 * \brief Get feature and dial.
 *
 * \param caller Channel to represent as the calling channel for the dialed channel.
 * \param caller_name Original caller channel name.
 * \param requestor Channel to say is requesting the dial (usually the caller).
 * \param transferee Channel that the dialed channel will be transferred to.
 * \param type Channel technology type to dial.
 * \param format Codec formats for dialed channel.
 * \param addr destination of the call
 * \param timeout Time limit for dialed channel to answer in ms. Must be greater than zero.
 * \param outstate Status of dialed channel if unsuccessful.
 * \param language Language of the caller.
 *
 * \note
 * outstate can be:
 * 0, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION,
 * AST_CONTROL_ANSWER, or AST_CONTROL_UNHOLD.  If
 * AST_CONTROL_UNHOLD then the caller channel cancelled the
 * transfer or the dialed channel did not answer before the
 * timeout.
 *
 * \details
 * Request channel, set channel variables, initiate call,
 * check if they want to disconnect, go into loop, check if timeout has elapsed,
 * check if person to be transfered hung up, check for answer break loop,
 * set cdr return channel.
 *
 * \retval Channel Connected channel for transfer.
 * \retval NULL on failure to get third party connected.
 *
 * \note This is similar to __ast_request_and_dial() in channel.c
 */
static struct ast_channel *feature_request_and_dial(struct ast_channel *caller,
        const char *caller_name, struct ast_channel *requestor,
        struct ast_channel *transferee, const char *type, struct ast_format_cap *cap, const char *addr,
        int timeout, int *outstate, const char *language)
{
        int state = 0;
        int cause = 0;
        int to;
        int caller_hungup;
        int transferee_hungup;
        struct ast_channel *chan;
        struct ast_channel *monitor_chans[3];
        struct ast_channel *active_channel;
        int res;
        int ready = 0;
        struct timeval started;
        int x, len = 0;
        char *disconnect_code = NULL, *dialed_code = NULL;
        struct ast_format_cap *tmp_cap;
        struct ast_format best_audio_fmt;
        struct ast_frame *f;
        AST_LIST_HEAD_NOLOCK(, ast_frame) deferred_frames;

        tmp_cap = ast_format_cap_alloc_nolock();
        if (!tmp_cap) {
                if (outstate) {
                        *outstate = 0;
                }
                return NULL;
        }
        ast_best_codec(cap, &best_audio_fmt);
        ast_format_cap_add(tmp_cap, &best_audio_fmt);

        caller_hungup = ast_check_hangup(caller);

        if (!(chan = ast_request(type, tmp_cap, requestor, addr, &cause))) {
                ast_log(LOG_NOTICE, "Unable to request channel %s/%s\n", type, addr);
                switch (cause) {
                case AST_CAUSE_BUSY:
                        state = AST_CONTROL_BUSY;
                        break;
                case AST_CAUSE_CONGESTION:
                        state = AST_CONTROL_CONGESTION;
                        break;
                default:
                        state = 0;
                        break;
                }
                goto done;
        }

        ast_channel_language_set(chan, language);
        ast_channel_inherit_variables(caller, chan);
        pbx_builtin_setvar_helper(chan, "TRANSFERERNAME", caller_name);

        ast_channel_lock(chan);
        ast_connected_line_copy_from_caller(&chan->connected, &requestor->caller);
        ast_channel_unlock(chan);

        if (ast_call(chan, addr, timeout)) {
                ast_log(LOG_NOTICE, "Unable to call channel %s/%s\n", type, addr);
                switch (ast_channel_hangupcause(chan)) {
                case AST_CAUSE_BUSY:
                        state = AST_CONTROL_BUSY;
                        break;
                case AST_CAUSE_CONGESTION:
                        state = AST_CONTROL_CONGESTION;
                        break;
                default:
                        state = 0;
                        break;
                }
                goto done;
        }

        /* support dialing of the featuremap disconnect code while performing an attended tranfer */
        ast_rwlock_rdlock(&features_lock);
        for (x = 0; x < FEATURES_COUNT; x++) {
                if (strcasecmp(builtin_features[x].sname, "disconnect"))
                        continue;

                disconnect_code = builtin_features[x].exten;
                len = strlen(disconnect_code) + 1;
                dialed_code = alloca(len);
                memset(dialed_code, 0, len);
                break;
        }
        ast_rwlock_unlock(&features_lock);
        x = 0;
        started = ast_tvnow();
        to = timeout;
        AST_LIST_HEAD_INIT_NOLOCK(&deferred_frames);

        ast_poll_channel_add(caller, chan);

        transferee_hungup = 0;
        while (!ast_check_hangup(transferee) && (ast_channel_state(chan) != AST_STATE_UP)) {
                int num_chans = 0;

                monitor_chans[num_chans++] = transferee;
                monitor_chans[num_chans++] = chan;
                if (!caller_hungup) {
                        if (ast_check_hangup(caller)) {
                                caller_hungup = 1;

#if defined(ATXFER_NULL_TECH)
                                /* Change caller's name to ensure that it will remain unique. */
                                set_new_chan_name(caller);

                                /*
                                 * Get rid of caller's physical technology so it is free for
                                 * other calls.
                                 */
                                set_kill_chan_tech(caller);
#endif  /* defined(ATXFER_NULL_TECH) */
                        } else {
                                /* caller is not hungup so monitor it. */
                                monitor_chans[num_chans++] = caller;
                        }
                }

                /* see if the timeout has been violated */
                if (ast_tvdiff_ms(ast_tvnow(), started) > timeout) {
                        state = AST_CONTROL_UNHOLD;
                        ast_log(LOG_NOTICE, "We exceeded our AT-timeout for %s\n", ast_channel_name(chan));
                        break; /*doh! timeout*/
                }

                active_channel = ast_waitfor_n(monitor_chans, num_chans, &to);
                if (!active_channel)
                        continue;

                f = NULL;
                if (transferee == active_channel) {
                        struct ast_frame *dup_f;

                        f = ast_read(transferee);
                        if (f == NULL) { /*doh! where'd he go?*/
                                transferee_hungup = 1;
                                state = 0;
                                break;
                        }
                        if (ast_is_deferrable_frame(f)) {
                                dup_f = ast_frisolate(f);
                                if (dup_f) {
                                        if (dup_f == f) {
                                                f = NULL;
                                        }
                                        AST_LIST_INSERT_HEAD(&deferred_frames, dup_f, frame_list);
                                }
                        }
                } else if (chan == active_channel) {
                        if (!ast_strlen_zero(ast_channel_call_forward(chan))) {
                                state = 0;
                                ast_autoservice_start(transferee);
                                chan = ast_call_forward(caller, chan, NULL, tmp_cap, NULL, &state);
                                ast_autoservice_stop(transferee);
                                if (!chan) {
                                        break;
                                }
                                continue;
                        }
                        f = ast_read(chan);