Merged revisions 172517 via svnmerge from
authorTerry Wilson <twilson@digium.com>
Fri, 30 Jan 2009 21:29:12 +0000 (21:29 +0000)
committerTerry Wilson <twilson@digium.com>
Fri, 30 Jan 2009 21:29:12 +0000 (21:29 +0000)
https://origsvn.digium.com/svn/asterisk/branches/1.4

........
  r172517 | twilson | 2009-01-30 11:47:41 -0600 (Fri, 30 Jan 2009) | 37 lines

  Fix feature inheritance with builtin features

  When using builtin features like parking and transfers, the AST_FEATURE_* flags
  would not be set correctly for all instances when either performing a builtin
  attended transfer, or parking a call and getting the timeout callback.  Also,
  there was no way on a per-call basis to specify what features someone should
  have on picking up a parked call (since that doesn't involve the Dial() command).
  There was a global option for setting whether or not all users who pickup a
  parked call should have AST_FEATURE_REDIRECT set, but nothing for DISCONNECT,
  AUTOMON, or PARKCALL.

  This patch:
  1) adds the BRIDGE_FEATURES dialplan variable which can be set either in the
  dialplan or with setvar in channels that support it.  This variable can be set
  to any combination of 't', 'k', 'w', and 'h' (case insensitive matching of the
  equivalent dial options), to set what features should be activated on this
  channel.  The patch moves the setting of the features datastores into the
  bridging code instead of app_dial to help facilitate this.

  2) adds global options parkedcallparking, parkedcallhangup, and
  parkedcallrecording to be similar to the parkedcalltransfers option for
  globally setting features.

  3) has builtin_atxfer call builtin_parkcall if being transfered to the parking
  extension since tracking everything through multiple masquerades, etc. is
  difficult and error-prone

  4) attempts to fix all cases of return calls from parking and completed builtin
  transfers not having the correct permissions
  (closes issue #14274)
  Reported by: aragon
  Patches:
        fix_feature_inheritence.diff.txt uploaded by otherwiseguy (license 396)
  Tested by: aragon, otherwiseguy

  Review http://reviewboard.digium.com/r/138/
........

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@172580 65c4cc65-6c06-0410-ace0-fbb531ad65f3

CHANGES
apps/app_dial.c
configs/features.conf.sample
include/asterisk/global_datastores.h
main/features.c
main/global_datastores.c

diff --git a/CHANGES b/CHANGES
index 807caed..cb8b7e5 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -863,6 +863,13 @@ AEL Changes
 Call Features (res_features) Changes
 ------------------------------------
   * Added the parkedcalltransfers option to features.conf
+  * Added parkedcallparking option to control one touch parking w/ parking
+    pickup
+  * Added parkedcallhangup option to control disconnect feature w/ parking
+    pickup
+  * Added parkedcallrecording option to control one-touch record w/ parking
+    pickup
+  * Added BRIDGE_FEATURES variable to set available features for a channel
   * The built-in method for doing attended transfers has been updated to
      include some new options that allow you to have the transferee sent
      back to the person that did the transfer if the transfer is not successful.
index 41c85d5..849c0c5 100644 (file)
@@ -1461,19 +1461,6 @@ static int setup_privacy_args(struct privacy_args *pa,
        return 1; /* success */
 }
 
-static void set_dial_features(struct ast_flags64 *opts, struct ast_dial_features *features)
-{
-       struct ast_flags64 perm_opts = {.flags = 0};
-
-       ast_copy_flags64(&perm_opts, opts,
-               OPT_CALLER_TRANSFER | OPT_CALLER_PARK | OPT_CALLER_MONITOR | OPT_CALLER_MIXMONITOR | OPT_CALLER_HANGUP |
-               OPT_CALLEE_TRANSFER | OPT_CALLEE_PARK | OPT_CALLEE_MONITOR | OPT_CALLEE_MIXMONITOR | OPT_CALLEE_HANGUP);
-
-       memset(features->options, 0, sizeof(features->options));
-
-       ast_app_options2str64(dial_exec_options, &perm_opts, features->options, sizeof(features->options));
-}
-
 static void end_bridge_callback(void *data)
 {
        char buf[80];
@@ -1537,9 +1524,6 @@ static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags
        struct ast_flags64 opts = { 0, };
        char *opt_args[OPT_ARG_ARRAY_SIZE];
        struct ast_datastore *datastore = NULL;
-       struct ast_datastore *ds_caller_features = NULL;
-       struct ast_datastore *ds_callee_features = NULL;
-       struct ast_dial_features *caller_features;
        int fulldial = 0, num_dialed = 0;
 
        /* Reset all DIAL variables back to blank, to prevent confusion (in case we don't reset all of them). */
@@ -1624,28 +1608,6 @@ static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags
        ast_channel_unlock(chan);       
        ast_copy_flags64(peerflags, &opts, OPT_DTMF_EXIT | OPT_GO_ON | OPT_ORIGINAL_CLID | OPT_CALLER_HANGUP | OPT_IGNORE_FORWARDING);
 
-       /* Create datastore for channel dial features for caller */
-       if (!(ds_caller_features = ast_datastore_alloc(&dial_features_info, NULL))) {
-               ast_log(LOG_WARNING, "Unable to create channel datastore for dial features. Aborting!\n");
-               goto out;
-       }
-
-       if (!(caller_features = ast_malloc(sizeof(*caller_features)))) {
-               ast_log(LOG_WARNING, "Unable to allocate memory for feature flags. Aborting!\n");
-               goto out;
-       }
-
-       ast_copy_flags(&(caller_features->features_callee), &(config.features_caller), AST_FLAGS_ALL);
-       caller_features->is_caller = 1;
-       set_dial_features(&opts, caller_features);
-
-       ds_caller_features->inheritance = DATASTORE_INHERIT_FOREVER;
-       ds_caller_features->data = caller_features;
-
-       ast_channel_lock(chan);
-       ast_channel_datastore_add(chan, ds_caller_features);
-       ast_channel_unlock(chan);
-
        /* loop through the list of dial destinations */
        rest = args.peers;
        while ((cur = strsep(&rest, "&")) ) {
@@ -1657,7 +1619,6 @@ static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags
                char *tech = strsep(&number, "/");
                /* find if we already dialed this interface */
                struct ast_dialed_interface *di;
-               struct ast_dial_features *callee_features;
                AST_LIST_HEAD(, ast_dialed_interface) *dialed_interfaces;
                num_dialed++;
                if (!number) {
@@ -1801,30 +1762,6 @@ static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags
                else
                        ast_copy_string(tc->exten, chan->exten, sizeof(tc->exten));
 
-               /* Save callee features */
-               if (!(ds_callee_features = ast_datastore_alloc(&dial_features_info, NULL))) {
-                       ast_log(LOG_WARNING, "Unable to create channel datastore for dial features. Aborting!\n");
-                       ast_free(tmp);
-                       goto out;
-               }
-
-               if (!(callee_features = ast_malloc(sizeof(*callee_features)))) {
-                       ast_log(LOG_WARNING, "Unable to allocate memory for feature flags. Aborting!\n");
-                       ast_free(tmp);
-                       goto out;
-               }
-
-               ast_copy_flags(&(callee_features->features_callee), &(config.features_callee), AST_FLAGS_ALL);
-               callee_features->is_caller = 0;
-               set_dial_features(&opts, callee_features);
-
-               ds_callee_features->inheritance = DATASTORE_INHERIT_FOREVER;
-               ds_callee_features->data = callee_features;
-
-               ast_channel_lock(chan);
-               ast_channel_datastore_add(tc, ds_callee_features);
-               ast_channel_unlock(chan);
-
                res = ast_call(tc, numsubst, 0); /* Place the call, but don't wait on the answer */
 
                /* Save the info in cdr's that we called them */
index 9246476..0cebd22 100644 (file)
@@ -23,6 +23,12 @@ context => parkedcalls               ; Which context parked calls are in (default parking lot
                                 ; one of: callee, caller, both, no (default is no)
 ;parkedcallreparking = caller   ; Enables or disables DTMF based parking when picking up a parked call.
                                 ; one of: callee, caller, both, no (default is no)
+;parkedcallparking = caller     ; Enables or disables DTMF based one-touch parking when picking up a parked call.
+                                ; one of: callee, caller, both, no (default is no)
+;parkedcallhangup = caller      ; Enables or disables DTMF based hangups when picking up a parked call.
+                                ; one of: callee, caller, both, no (default is no)
+;parkedcallrecording = caller   ; Enables or disables DTMF based one-touch recording when picking up a parked call.
+                                ; one of: callee, caller, both, no (default is no)
 ;adsipark = yes                        ; if you want ADSI parking announcements
 ;findslot => next              ; Continue to the 'next' free parking space. 
                                ; Defaults to 'first' available
index 510034b..72edaba 100644 (file)
 
 #include "asterisk/channel.h"
 
-#define MAX_DIAL_FEATURE_OPTIONS 30
-
 extern const struct ast_datastore_info dialed_interface_info;
 
-extern const struct ast_datastore_info dial_features_info;
-
 struct ast_dialed_interface {
        AST_LIST_ENTRY(ast_dialed_interface) list;
        char interface[1];
 };
 
-struct ast_dial_features {
-       struct ast_flags features_caller;
-       struct ast_flags features_callee;
-       char options[MAX_DIAL_FEATURE_OPTIONS];
-       int is_caller;
-};
-
 #endif
index b486116..6ad1c12 100644 (file)
@@ -166,6 +166,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
 #define DEFAULT_ATXFER_CALLBACK_RETRIES 2
 
 #define AST_MAX_WATCHERS 256
+#define MAX_DIAL_FEATURE_OPTIONS 30
 
 struct feature_group_exten {
        AST_LIST_ENTRY(feature_group_exten) entry;
@@ -222,6 +223,8 @@ struct ast_parkinglot {
        int parkaddhints;                               /*!< Add parking hints automatically */
        int parkedcalltransfers;                        /*!< Enable DTMF based transfers on bridge when picking up parked calls */
        int parkedcallreparking;                        /*!< Enable DTMF based parking on bridge when picking up parked calls */
+       int parkedcallhangup;                           /*!< Enable DTMF based hangup on a bridge when pickup up parked calls */
+       int parkedcallrecording;                        /*!< Enable DTMF based recording on a bridge when picking up parked calls */
        AST_LIST_HEAD(parkinglot_parklist, parkeduser) parkings; /*!< List of active parkings in this parkinglot */
 };
 
@@ -262,7 +265,39 @@ 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;
+};
 
+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);
+       }
+ }
+ 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);
@@ -368,7 +403,7 @@ static struct ast_channel *ast_feature_request_and_dial(struct ast_channel *call
  * bridge call, check if we're going back to dialplan
  * if not hangup both legs of the call
 */
-static void *ast_bridge_call_thread(void *data) 
+static void *ast_bridge_call_thread(void *data)
 {
        struct ast_bridge_thread_obj *tobj = data;
        int res;
@@ -880,7 +915,6 @@ static int builtin_parkcall(struct ast_channel *chan, struct ast_channel *peer,
        }
 
        return res;
-
 }
 
 /*! \brief Play message to both caller and callee in bridged call, plays synchronously, autoservicing the
@@ -1193,7 +1227,7 @@ static int builtin_blindtransfer(struct ast_channel *chan, struct ast_channel *p
        ast_indicate(transferee, AST_CONTROL_HOLD);
 
        memset(xferto, 0, sizeof(xferto));
-       
+
        /* Transfer */
        res = ast_stream_and_wait(transferer, "pbx-transfer", AST_DIGIT_ANY);
        if (res < 0) {
@@ -1323,6 +1357,8 @@ static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, st
        struct ast_bridge_config bconfig;
        struct ast_frame *f;
        int l;
+       struct ast_datastore *features_datastore;
+       struct ast_dial_features *dialfeatures = NULL;
 
        ast_debug(1, "Executing Attended Transfer %s, %s (sense=%d) \n", chan->name, peer->name, sense);
        set_peers(&transferer, &transferee, peer, chan, sense);
@@ -1363,6 +1399,13 @@ static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, st
                return AST_FEATURE_RETURN_SUCCESS;
        }
 
+       /* If we are attended transfering to parking, just use builtin_parkcall instead of trying to track all of
+        * the different variables for handling this properly with a builtin_atxfer */
+       if (!strcmp(xferto, ast_parking_ext())) {
+               finishup(transferee);
+               return builtin_parkcall(chan, peer, config, code, sense, data);
+       }
+
        l = strlen(xferto);
        snprintf(xferto + l, sizeof(xferto) - l, "@%s/n", transferer_real_context);     /* append context */
 
@@ -1452,6 +1495,30 @@ static int builtin_atxfer(struct ast_channel *chan, struct ast_channel *peer, st
                        ast_hangup(newchan);
                        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;
@@ -2201,6 +2268,92 @@ static struct ast_cdr *pick_unlocked_cdr(struct ast_cdr *cdr)
        return cdr_orig; /* everybody LOCKED or some other weirdness, like a NULL */
 }
 
+static void set_bridge_features_on_config(struct ast_bridge_config *config, const char *features)
+{
+       const char *feature;
+
+       if (ast_strlen_zero(features)) {
+               return;
+       }
+
+       for (feature = features; *feature; feature++) {
+               switch (*feature) {
+               case 'T' :
+               case 't' :
+                       ast_set_flag(&(config->features_caller), AST_FEATURE_REDIRECT);
+                       break;
+               case 'K' :
+               case 'k' :
+                       ast_set_flag(&(config->features_caller), AST_FEATURE_PARKCALL);
+                       break;
+               case 'H' :
+               case 'h' :
+                       ast_set_flag(&(config->features_caller), AST_FEATURE_DISCONNECT);
+                       break;
+               case 'W' :
+               case 'w' :
+                       ast_set_flag(&(config->features_caller), AST_FEATURE_AUTOMON);
+                       break;
+               default :
+                       ast_log(LOG_WARNING, "Skipping unknown feature code '%c'\n", *feature);
+               }
+       }
+}
+
+static void add_features_datastores(struct ast_channel *caller, struct ast_channel *callee, struct ast_bridge_config *config)
+{
+       struct ast_datastore *ds_callee_features = NULL, *ds_caller_features = NULL;
+       struct ast_dial_features *callee_features = NULL, *caller_features = NULL;
+
+       ast_channel_lock(caller);
+       ds_caller_features = ast_channel_datastore_find(caller, &dial_features_info, NULL);
+       ast_channel_unlock(caller);
+       if (!ds_caller_features) {
+               if (!(ds_caller_features = ast_datastore_alloc(&dial_features_info, NULL))) {
+                       ast_log(LOG_WARNING, "Unable to create channel datastore for caller features. Aborting!\n");
+                       return;
+               }
+               if (!(caller_features = ast_calloc(1, sizeof(*caller_features)))) {
+                       ast_log(LOG_WARNING, "Unable to allocate memory for callee feature flags. Aborting!\n");
+                       ast_datastore_free(ds_caller_features);
+                       return;
+               }
+               ds_caller_features->inheritance = DATASTORE_INHERIT_FOREVER;
+               caller_features->is_caller = 1;
+               ast_copy_flags(&(caller_features->features_callee), &(config->features_callee), AST_FLAGS_ALL);
+               ast_copy_flags(&(caller_features->features_caller), &(config->features_caller), AST_FLAGS_ALL);
+               ds_caller_features->data = caller_features;
+               ast_channel_lock(caller);
+               ast_channel_datastore_add(caller, ds_caller_features);
+               ast_channel_unlock(caller);
+       }
+
+       ast_channel_lock(callee);
+       ds_callee_features = ast_channel_datastore_find(callee, &dial_features_info, NULL);
+       ast_channel_unlock(callee);
+       if (!ds_callee_features) {
+               if (!(ds_callee_features = ast_datastore_alloc(&dial_features_info, NULL))) {
+                       ast_log(LOG_WARNING, "Unable to create channel datastore for callee features. Aborting!\n");
+                       return;
+               }
+               if (!(callee_features = ast_calloc(1, sizeof(*callee_features)))) {
+                       ast_log(LOG_WARNING, "Unable to allocate memory for callee feature flags. Aborting!\n");
+                       ast_datastore_free(ds_callee_features);
+                       return;
+               }
+               ds_callee_features->inheritance = DATASTORE_INHERIT_FOREVER;
+               callee_features->is_caller = 0;
+               ast_copy_flags(&(callee_features->features_callee), &(config->features_caller), AST_FLAGS_ALL);
+               ast_copy_flags(&(callee_features->features_caller), &(config->features_callee), AST_FLAGS_ALL);
+               ds_callee_features->data = callee_features;
+               ast_channel_lock(callee);
+               ast_channel_datastore_add(callee, ds_callee_features);
+               ast_channel_unlock(callee);
+       }
+
+       return;
+}
+
 /*!
  * \brief bridge the call and set CDR
  * \param chan,peer,config
@@ -2245,6 +2398,9 @@ int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast
                pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", NULL);
        }
 
+       set_bridge_features_on_config(config, pbx_builtin_getvar_helper(chan, "BRIDGE_FEATURES"));
+       add_features_datastores(chan, peer, config);
+
        /* This is an interesting case.  One example is if a ringing channel gets redirected to
         * an extension that picks up a parked call.  This will make sure that the call taken
         * out of parking gets told that the channel it just got bridged to is still ringing. */
@@ -2268,7 +2424,7 @@ int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast
                        pbx_exec(src, monitor_app, tmp);
                }
        }
-       
+
        set_config_flags(chan, peer, config);
        config->firstpass = 1;
 
@@ -2335,7 +2491,7 @@ int ast_bridge_call(struct ast_channel *chan,struct ast_channel *peer,struct ast
        }
        for (;;) {
                struct ast_channel *other;      /* used later */
-               
+       
                res = ast_channel_bridge(chan, peer, config, &f, &who);
 
                if (config->feature_timer) {
@@ -2677,6 +2833,50 @@ static void post_manager_event(const char *s, struct parkeduser *pu)
                );
 }
 
+static char *callback_dialoptions(struct ast_flags *features_callee, struct ast_flags *features_caller, char *options, size_t len)
+{
+       int i = 0;
+       enum {
+               OPT_CALLEE_REDIRECT   = 't',
+               OPT_CALLER_REDIRECT   = 'T',
+               OPT_CALLEE_AUTOMON    = 'w',
+               OPT_CALLER_AUTOMON    = 'W',
+               OPT_CALLEE_DISCONNECT = 'h',
+               OPT_CALLER_DISCONNECT = 'H',
+               OPT_CALLEE_PARKCALL   = 'k',
+               OPT_CALLER_PARKCALL   = 'K',
+       };
+
+       memset(options, 0, len);
+       if (ast_test_flag(features_caller, AST_FEATURE_REDIRECT) && i < len) {
+               options[i++] = OPT_CALLER_REDIRECT;
+       }
+       if (ast_test_flag(features_caller, AST_FEATURE_AUTOMON) && i < len) {
+               options[i++] = OPT_CALLER_AUTOMON;
+       }
+       if (ast_test_flag(features_caller, AST_FEATURE_DISCONNECT) && i < len) {
+               options[i++] = OPT_CALLER_DISCONNECT;
+       }
+       if (ast_test_flag(features_caller, AST_FEATURE_PARKCALL) && i < len) {
+               options[i++] = OPT_CALLER_PARKCALL;
+       }
+
+       if (ast_test_flag(features_callee, AST_FEATURE_REDIRECT) && i < len) {
+               options[i++] = OPT_CALLEE_REDIRECT;
+       }
+       if (ast_test_flag(features_callee, AST_FEATURE_AUTOMON) && i < len) {
+               options[i++] = OPT_CALLEE_AUTOMON;
+       }
+       if (ast_test_flag(features_callee, AST_FEATURE_DISCONNECT) && i < len) {
+               options[i++] = OPT_CALLEE_DISCONNECT;
+       }
+       if (ast_test_flag(features_callee, AST_FEATURE_PARKCALL) && i < len) {
+               options[i++] = OPT_CALLEE_PARKCALL;
+       }
+
+       return options;
+}
+
 /*! \brief Run management on parkinglots, called once per parkinglot */
 int manage_parkinglot(struct ast_parkinglot *curlot, fd_set *rfds, fd_set *efds, fd_set *nrfds, fd_set *nefds, int *ms, int *max)
 {
@@ -2734,10 +2934,13 @@ int manage_parkinglot(struct ast_parkinglot *curlot, fd_set *rfds, fd_set *efds,
                                                peername += 7;
                                        }
 
-                                       if (dialfeatures)
-                                               snprintf(returnexten, sizeof(returnexten), "%s,,%s", peername, dialfeatures->options);
-                                       else /* Existing default */
-                                               snprintf(returnexten, sizeof(returnexten), "%s,,t", peername);
+                                       if (dialfeatures) {
+                                               char buf[MAX_DIAL_FEATURE_OPTIONS] = {0,};
+                                               snprintf(returnexten, sizeof(returnexten), "%s|30|%s", peername, callback_dialoptions(&(dialfeatures->features_callee), &(dialfeatures->features_caller), buf, sizeof(buf)));
+                                       } else { /* Existing default */
+                                               ast_log(LOG_WARNING, "Dialfeatures not found on %s, using default!\n", chan->name);
+                                               snprintf(returnexten, sizeof(returnexten), "%s|30|t", peername);
+                                       }
 
                                        ast_add_extension2(con, 1, peername_flat, 1, NULL, NULL, "Dial", ast_strdup(returnexten), ast_free_ptr, registrar);
                                }
@@ -3057,8 +3260,11 @@ static int park_exec_full(struct ast_channel *chan, void *data, struct ast_parki
        //ASTOBJ_UNLOCK(parkinglot);
 
        if (peer) {
+               struct ast_datastore *features_datastore;
+               struct ast_dial_features *dialfeatures = NULL;
+
                /* Play a courtesy to the source(s) configured to prefix the bridge connecting */
-               
+
                if (!ast_strlen_zero(courtesytone)) {
                        int error = 0;
                        ast_indicate(peer, AST_CONTROL_UNHOLD);
@@ -3083,7 +3289,7 @@ static int park_exec_full(struct ast_channel *chan, void *data, struct ast_parki
                                return -1;
                        }
                } else
-                       ast_indicate(peer, AST_CONTROL_UNHOLD); 
+                       ast_indicate(peer, AST_CONTROL_UNHOLD);
 
                res = ast_channel_make_compatible(chan, peer);
                if (res < 0) {
@@ -3098,14 +3304,43 @@ static int park_exec_full(struct ast_channel *chan, void *data, struct ast_parki
                pbx_builtin_setvar_helper(chan, "PARKEDCHANNEL", peer->name);
                ast_cdr_setdestchan(chan->cdr, peer->name);
                memset(&config, 0, sizeof(struct ast_bridge_config));
-               if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH))
+
+               /* Get datastore for peer and apply it's features to the callee side of the bridge config */
+               ast_channel_lock(peer);
+               if ((features_datastore = ast_channel_datastore_find(peer, &dial_features_info, NULL))) {
+                       dialfeatures = features_datastore->data;
+               }
+               ast_channel_unlock(peer);
+
+               if (dialfeatures) {
+                       ast_copy_flags(&(config.features_callee), dialfeatures->is_caller ? &(dialfeatures->features_caller) : &(dialfeatures->features_callee), AST_FLAGS_ALL);
+               }
+
+               if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH)) {
                        ast_set_flag(&(config.features_callee), AST_FEATURE_REDIRECT);
-               if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH))
+               }
+               if ((parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcalltransfers == AST_FEATURE_FLAG_BYBOTH)) {
                        ast_set_flag(&(config.features_caller), AST_FEATURE_REDIRECT);
-               if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH))
+               }
+               if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH)) {
                        ast_set_flag(&(config.features_callee), AST_FEATURE_PARKCALL);
-               if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH))
+               }
+               if ((parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcallreparking == AST_FEATURE_FLAG_BYBOTH)) {
                        ast_set_flag(&(config.features_caller), AST_FEATURE_PARKCALL);
+               }
+               if ((parkinglot->parkedcallhangup == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcallhangup == AST_FEATURE_FLAG_BYBOTH)) {
+                       ast_set_flag(&(config.features_callee), AST_FEATURE_DISCONNECT);
+               }
+               if ((parkinglot->parkedcallhangup == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcallhangup == AST_FEATURE_FLAG_BYBOTH)) {
+                       ast_set_flag(&(config.features_caller), AST_FEATURE_DISCONNECT);
+               }
+               if ((parkinglot->parkedcallrecording == AST_FEATURE_FLAG_BYCALLEE) || (parkinglot->parkedcallrecording == AST_FEATURE_FLAG_BYBOTH)) {
+                       ast_set_flag(&(config.features_callee), AST_FEATURE_AUTOMON);
+               }
+               if ((parkinglot->parkedcallrecording == AST_FEATURE_FLAG_BYCALLER) || (parkinglot->parkedcallrecording == AST_FEATURE_FLAG_BYBOTH)) {
+                       ast_set_flag(&(config.features_caller), AST_FEATURE_AUTOMON);
+               }
+
                res = ast_bridge_call(chan, peer, &config);
 
                pbx_builtin_setvar_helper(chan, "PARKEDCHANNEL", peer->name);
@@ -3352,6 +3587,8 @@ static int load_config(void)
        default_parkinglot->parkaddhints = 0;
        default_parkinglot->parkedcalltransfers = 0;
        default_parkinglot->parkedcallreparking = 0;
+       default_parkinglot->parkedcallrecording = 0;
+       default_parkinglot->parkedcallhangup = 0;
 
        transferdigittimeout = DEFAULT_TRANSFER_DIGIT_TIMEOUT;
        featuredigittimeout = DEFAULT_FEATURE_DIGIT_TIMEOUT;
@@ -3403,6 +3640,20 @@ static int load_config(void)
                                default_parkinglot->parkedcallreparking = AST_FEATURE_FLAG_BYCALLER;
                        else if (!strcasecmp(var->value, "callee"))
                                default_parkinglot->parkedcallreparking = AST_FEATURE_FLAG_BYCALLEE;
+               } else if (!strcasecmp(var->name, "parkedcallhangup")) {
+                       if (!strcasecmp(var->value, "both"))
+                               default_parkinglot->parkedcallhangup = AST_FEATURE_FLAG_BYBOTH;
+                       else if (!strcasecmp(var->value, "caller"))
+                               default_parkinglot->parkedcallhangup = AST_FEATURE_FLAG_BYCALLER;
+                       else if (!strcasecmp(var->value, "callee"))
+                               default_parkinglot->parkedcallhangup = AST_FEATURE_FLAG_BYCALLEE;
+               } else if (!strcasecmp(var->name, "parkedcallrecording")) {
+                       if (!strcasecmp(var->value, "both"))
+                               default_parkinglot->parkedcallrecording = AST_FEATURE_FLAG_BYBOTH;
+                       else if (!strcasecmp(var->value, "caller"))
+                               default_parkinglot->parkedcallrecording = AST_FEATURE_FLAG_BYCALLER;
+                       else if (!strcasecmp(var->value, "callee"))
+                               default_parkinglot->parkedcallrecording = AST_FEATURE_FLAG_BYCALLEE;
                } else if (!strcasecmp(var->name, "adsipark")) {
                        adsipark = ast_true(var->value);
                } else if (!strcasecmp(var->name, "transferdigittimeout")) {
index ca04a0f..5b96302 100644 (file)
@@ -79,35 +79,8 @@ static void *dialed_interface_duplicate(void *data)
        return new_list;
 }
 
-
-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);
-       }
-}
-
 const struct ast_datastore_info dialed_interface_info = {
        .type = "dialed-interface",
        .destroy = dialed_interface_destroy,
        .duplicate = dialed_interface_duplicate,
 };
-
-const struct ast_datastore_info dial_features_info = {
-       .type = "dial-features",
-       .destroy = dial_features_destroy,
-       .duplicate = dial_features_duplicate,
-};