From c61e8a7865ae0e7c134922677700a40678490d4d Mon Sep 17 00:00:00 2001 From: Steve Murphy Date: Mon, 2 Feb 2009 17:37:15 +0000 Subject: [PATCH] This change allows the disconnect feature (as in "one-touch" in features.c) to be used within the dial app, before a call is bridged. Many thanks to sobomax for submitting this patch. Quoting from bug 11582: "So the goal of the patch was to use the user configured feature code during the call setup phase. The original ast_feature_interpret() function is not well suited for this purpose as it uses much call bridge specific data and doesn't separate a detection of feature from a feature handler call. So a new function ast_feature_detect() has been extracted off the ast_feature_interpret() function but keeping the original logic intact except some insignificant changes to locking. "Having created the ast_feature_detect() function the possibility to use feature detection in almost any place of the asterisk code. So a call to this function has been added to wait_for_answer() function of app_dial.so module. This code doesn't call the feature handler however and uses old call leg disconnect logic to make the changes as small and simple as possible to prevent unexpected problems. A disconnect feature currently is the only one supported during call setup as other features as call parking and call transfer don't make much sense during call setup. However if need in some of the features would arise it is much easier to implement as the infrastructure changes are already in place with this patch." I have cleaned up the patch somewhat, and verified that the existing functionality is not harmed, and that the new functionality works. Terry has committed his stuff, and there were no conflicts (see 14274). (closes issue #11583) Reported by: sobomax Patches: patch-apps__app_dial.c uploaded by sobomax (license 359) patch-include__asterisk__features.h uploaded by sobomax (license 359) patch-res__res_features.c uploaded by sobomax (license 359) enable-features-during-call-setup.diff uploaded by sobomax (license 359) 11583.newdiff uploaded by murf (license 17) enable-features-during-call-setup-1.diff uploaded by sobomax (license 359) 11583.latest-patch uploaded by murf (license 17) Tested by: sobomax, murf git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@172890 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- CHANGES | 2 + apps/app_dial.c | 57 +++++++++++++++- include/asterisk/features.h | 37 ++++++++-- main/features.c | 132 +++++++++++++++++++++++------------- 4 files changed, 172 insertions(+), 56 deletions(-) diff --git a/CHANGES b/CHANGES index cb8b7e5e38..6db7a98125 100644 --- a/CHANGES +++ b/CHANGES @@ -128,6 +128,8 @@ Miscellaneous * The contrib/scripts/ directory now has a script called sip_nat_settings that will give you the correct output for an asterisk box behind nat. It will give you the externhost and localnet settings. + * The 'one-touch' disconnect feature is now available during Dial, + instead of just when a call is connected. Asterisk Manager Interface -------------------------- diff --git a/apps/app_dial.c b/apps/app_dial.c index 849c0c5279..3fff300cac 100644 --- a/apps/app_dial.c +++ b/apps/app_dial.c @@ -560,6 +560,7 @@ struct chanlist { uint64_t flags; }; +static int detect_disconnect(struct ast_channel *chan, char code); static void hanguptree(struct chanlist *outgoing, struct ast_channel *exception, int answered_elsewhere) { @@ -1054,8 +1055,8 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in, } if (ast_test_flag64(peerflags, OPT_CALLER_HANGUP) && - (f->subclass == '*')) { /* hmm it it not guaranteed to be '*' anymore. */ - ast_verb(3, "User hit %c to disconnect call.\n", f->subclass); + detect_disconnect(in, f->subclass)) { + ast_verb(3, "User requested call disconnect.\n"); *to = 0; strcpy(pa->status, "CANCEL"); ast_cdr_noanswer(in->cdr); @@ -1099,6 +1100,58 @@ static struct ast_channel *wait_for_answer(struct ast_channel *in, return peer; } +static char featurecode[FEATURE_MAX_LEN + 1] = ""; + +static int detect_disconnect(struct ast_channel *chan, char code) +{ + struct feature_interpret_result result; + int x; + struct ast_flags features; + int res = FEATURE_RETURN_PASSDIGITS; + struct ast_call_feature *feature; + char *cptr; + const char *dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"); + int len; + + len = strlen(featurecode); + if (len >= FEATURE_MAX_LEN) { + featurecode[0] = '\0'; + } + cptr = &featurecode[strlen(featurecode)]; + cptr[0] = code; + cptr[1] = '\0'; + + memset(&features, 0, sizeof(struct ast_flags)); + ast_set_flag(&features, AST_FEATURE_DISCONNECT); + + ast_features_lock(); + + res = ast_feature_detect(chan, &features, featurecode, &result, dynamic_features); + + if (res != FEATURE_RETURN_STOREDIGITS) + featurecode[0] = '\0'; + + + if (result.builtin_feature && result.builtin_feature->feature_mask & AST_FEATURE_DISCONNECT) { + ast_features_unlock(); + return 1; + } + + for (x = 0; x < result.num_dyn_features; ++x) { + feature = result.dynamic_features[x]; + if (feature->feature_mask & AST_FEATURE_DISCONNECT) { + ast_features_unlock(); + return 1; + } + } + + ast_features_unlock(); + + return 0; +} + + + static void replace_macro_delimiter(char *s) { for (; *s; s++) diff --git a/include/asterisk/features.h b/include/asterisk/features.h index 4d581885dc..f0e54a73b7 100644 --- a/include/asterisk/features.h +++ b/include/asterisk/features.h @@ -36,6 +36,15 @@ #define PARK_APP_NAME "Park" +#define FEATURE_RETURN_HANGUP -1 +#define FEATURE_RETURN_SUCCESSBREAK 0 +#define FEATURE_RETURN_PASSDIGITS 21 +#define FEATURE_RETURN_STOREDIGITS 22 +#define FEATURE_RETURN_SUCCESS 23 +#define FEATURE_RETURN_KEEPTRYING 24 + +typedef int (*feature_operation)(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data); + /*! \brief main call feature structure */ enum { @@ -53,7 +62,7 @@ struct ast_call_feature { char sname[FEATURE_SNAME_LEN]; char exten[FEATURE_MAX_LEN]; char default_exten[FEATURE_MAX_LEN]; - int (*operation)(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense, void *data); + feature_operation operation; unsigned int flags; char app[FEATURE_APP_LEN]; char app_args[FEATURE_APP_ARGS_LEN]; @@ -61,12 +70,20 @@ struct ast_call_feature { AST_LIST_ENTRY(ast_call_feature) feature_entry; }; -#define AST_FEATURE_RETURN_HANGUP -1 -#define AST_FEATURE_RETURN_SUCCESSBREAK 0 -#define AST_FEATURE_RETURN_PASSDIGITS 21 -#define AST_FEATURE_RETURN_STOREDIGITS 22 -#define AST_FEATURE_RETURN_SUCCESS 23 -#define AST_FEATURE_RETURN_KEEPTRYING 24 +#define AST_FEATURE_RETURN_HANGUP FEATURE_RETURN_HANGUP +#define AST_FEATURE_RETURN_SUCCESSBREAK FEATURE_RETURN_SUCCESSBREAK +#define AST_FEATURE_RETURN_PASSDIGITS FEATURE_RETURN_PASSDIGITS +#define AST_FEATURE_RETURN_STOREDIGITS FEATURE_RETURN_STOREDIGITS +#define AST_FEATURE_RETURN_SUCCESS FEATURE_RETURN_SUCCESS +#define AST_FEATURE_RETURN_KEEPTRYING FEATURE_RETURN_KEEPTRYING + +struct feature_interpret_result { + struct ast_call_feature *builtin_feature; + struct ast_call_feature *dynamic_features[20]; + struct ast_call_feature *group_features[20]; + int num_dyn_features; + int num_grp_features; +}; /*! * \brief Park a call and read back parked location @@ -122,6 +139,12 @@ void ast_register_feature(struct ast_call_feature *feature); \param feature the ast_call_feature object which was registered before*/ void ast_unregister_feature(struct ast_call_feature *feature); +int ast_feature_detect(struct ast_channel *chan, const struct ast_flags *features, char *code, struct feature_interpret_result *result, const char *dynamic_features); + +void ast_features_lock(void); +void ast_features_unlock(void); + + /*! \brief look for a call feature entry by its sname \param name a string ptr, should match "automon", "blindxfer", "atxfer", etc. */ struct ast_call_feature *ast_find_call_feature(const char *name); diff --git a/main/features.c b/main/features.c index 6ad1c12a9b..9d463c2111 100644 --- a/main/features.c +++ b/main/features.c @@ -856,8 +856,8 @@ static int masq_park_call_announce(struct ast_channel *rchan, struct ast_channel return masq_park_call(rchan, peer, timeout, extout, 1, NULL); } -#define FEATURE_SENSE_CHAN (1 << 0) -#define FEATURE_SENSE_PEER (1 << 1) +#define FEATURE_SENSE_CHAN (1 << 0) +#define FEATURE_SENSE_PEER (1 << 1) /*! * \brief set caller and callee according to the direction @@ -1935,44 +1935,40 @@ static int remap_feature(const char *name, const char *value) return res; } -/*! - * \brief Check the dynamic features - * \param chan,peer,config,code,sense - * - * Lock features list, browse for code, unlock list - * \retval res on success. - * \retval -1 on failure. -*/ -static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense) +void ast_features_lock(void) +{ + ast_rwlock_rdlock(&features_lock); + AST_RWLIST_WRLOCK(&feature_list); + AST_RWLIST_RDLOCK(&feature_groups); +} + +void ast_features_unlock(void) +{ + AST_RWLIST_UNLOCK(&feature_groups); + AST_RWLIST_UNLOCK(&feature_list); + ast_rwlock_unlock(&features_lock); +} + +int ast_feature_detect(struct ast_channel *chan, const struct ast_flags *features, char *code, struct feature_interpret_result *result, const char *dynamic_features) { int x; - struct ast_flags features; + int res = FEATURE_RETURN_PASSDIGITS; struct ast_call_feature *feature; struct feature_group *fg = NULL; struct feature_group_exten *fge; - const char *dynamic_features; char *tmp, *tok; - int res = AST_FEATURE_RETURN_PASSDIGITS; - int feature_detected = 0; - - if (sense == FEATURE_SENSE_CHAN) { - ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL); - dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"); - } - else { - ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL); - dynamic_features = pbx_builtin_getvar_helper(peer, "DYNAMIC_FEATURES"); - } - ast_debug(3, "Feature interpret: chan=%s, peer=%s, code=%s, sense=%d, features=%d, dynamic=%s\n", chan->name, peer->name, code, sense, features.flags, dynamic_features); - - ast_rwlock_rdlock(&features_lock); + + result->builtin_feature = NULL; + result->num_dyn_features = 0; + result->num_grp_features = 0; + + for (x = 0; x < FEATURES_COUNT; x++) { - if ((ast_test_flag(&features, builtin_features[x].feature_mask)) && + 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)) { - res = builtin_features[x].operation(chan, peer, config, code, sense, NULL); - feature_detected = 1; + result->builtin_feature = &builtin_features[x]; break; } else if (!strncmp(builtin_features[x].exten, code, strlen(code))) { if (res == AST_FEATURE_RETURN_PASSDIGITS) @@ -1980,15 +1976,13 @@ static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *p } } } - ast_rwlock_unlock(&features_lock); - if (ast_strlen_zero(dynamic_features) || feature_detected) + if (ast_strlen_zero(dynamic_features)) return res; tmp = ast_strdupa(dynamic_features); while ((tok = strsep(&tmp, "#"))) { - AST_RWLIST_RDLOCK(&feature_groups); fg = find_group(tok); @@ -1996,10 +1990,9 @@ static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *p AST_LIST_TRAVERSE(&fg->features, fge, entry) { if (strcasecmp(fge->exten, code)) continue; - - res = fge->feature->operation(chan, peer, config, code, sense, fge->feature); - if (res != AST_FEATURE_RETURN_KEEPTRYING) { - AST_RWLIST_UNLOCK(&feature_groups); + + result->group_features[result->num_grp_features++] = fge->feature; + if (result->num_grp_features >= (sizeof(result->group_features) / sizeof(result->group_features[0]))) { break; } res = AST_FEATURE_RETURN_PASSDIGITS; @@ -2008,29 +2001,74 @@ static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *p break; } - AST_RWLIST_UNLOCK(&feature_groups); - - AST_RWLIST_RDLOCK(&feature_list); - if (!(feature = find_dynamic_feature(tok))) { - AST_RWLIST_UNLOCK(&feature_list); continue; } /* Feature is up for consideration */ if (!strcmp(feature->exten, code)) { ast_verb(3, " Feature Found: %s exten: %s\n",feature->sname, tok); - res = feature->operation(chan, peer, config, code, sense, feature); - if (res != AST_FEATURE_RETURN_KEEPTRYING) { - AST_RWLIST_UNLOCK(&feature_list); + result->dynamic_features[result->num_dyn_features++] = feature; + if (result->num_dyn_features >= (sizeof(result->dynamic_features) / sizeof(result->dynamic_features[0]))) { break; } res = AST_FEATURE_RETURN_PASSDIGITS; } else if (!strncmp(feature->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 + * + * Lock features list, browse for code, unlock list + * \retval res on success. + * \retval -1 on failure. + */ +static int ast_feature_interpret(struct ast_channel *chan, struct ast_channel *peer, struct ast_bridge_config *config, char *code, int sense) +{ + struct feature_interpret_result result; + int x; + struct ast_flags features; + int res = AST_FEATURE_RETURN_PASSDIGITS; + struct ast_call_feature *feature; + const char *dynamic_features; + + if (sense == FEATURE_SENSE_CHAN) { + ast_copy_flags(&features, &(config->features_caller), AST_FLAGS_ALL); + dynamic_features = pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"); + } else { + ast_copy_flags(&features, &(config->features_callee), AST_FLAGS_ALL); + dynamic_features = pbx_builtin_getvar_helper(peer, "DYNAMIC_FEATURES"); + } + ast_debug(3, "Feature interpret: chan=%s, peer=%s, code=%s, sense=%d, features=%d, dynamic=%s\n", chan->name, peer->name, code, sense, features.flags, dynamic_features); + + ast_features_lock(); + res = ast_feature_detect(chan, &features, code, &result, dynamic_features); + + if (result.builtin_feature) { + res = result.builtin_feature->operation(chan, peer, config, code, sense, NULL); + } + + for (x = 0; x < result.num_grp_features; ++x) { + feature = result.group_features[x]; + res = feature->operation(chan, peer, config, code, sense, feature); + if (res != FEATURE_RETURN_KEEPTRYING) { + break; + } + res = FEATURE_RETURN_PASSDIGITS; + } + for (x = 0; x < result.num_dyn_features; ++x) { + feature = result.dynamic_features[x]; + res = feature->operation(chan, peer, config, code, sense, feature); + if (res != FEATURE_RETURN_KEEPTRYING) { + break; + } + res = FEATURE_RETURN_PASSDIGITS; + } + ast_features_unlock(); return res; }