Refactor the features configuration scheme.

Features configuration is handled in its own API in
features_config.h and features_config.c. This way, features
configuration is accessible to anything that needs it.

In addition, features configuration has been altered to
be more channel-oriented. Most callers of features API
code will be supplying a channel so that the individual
channel's settings will be acquired rather than the global
setting.

Missing from this commit is XML documentation for the
features configuration. That will be handled in a separate
commit.

Review: https://reviewboard.asterisk.org/r/2578/

(issue ASTERISK-21542)



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

1 files changed, 1534 insertions, 0 deletions

diff --git a/main/features_config.c b/main/features_config.c
new file mode 100644
index 000000000..f8bdb1c3c
--- /dev/null
+++ b/main/features_config.c
@@ -0,0 +1,1534 @@
+/*
+* Asterisk -- An open source telephony toolkit.
+*
+* Copyright (C) 2013, Digium, Inc.
+*
+* Mark Michelson <mmichelson@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.
+*/
+
+#include "asterisk.h"
+
+#include "asterisk/features_config.h"
+#include "asterisk/config_options.h"
+#include "asterisk/datastore.h"
+#include "asterisk/channel.h"
+#include "asterisk/pbx.h"
+#include "asterisk/app.h"
+#include "asterisk/cli.h"
+
+/* BUGBUG XML Documentation is still needed for configuration options */
+/*** DOCUMENTATION
+	<function name="FEATURE" language="en_US">
+		<synopsis>
+			Get or set a feature option on a channel.
+		</synopsis>
+		<syntax>
+			<parameter name="option_name" required="true">
+				<para>The allowed values are:</para>
+				<enumlist>
+					<enum name="inherit"><para>Inherit feature settings made in FEATURE or FEATUREMAP to child channels.</para></enum>
+					<enum name="featuredigittimeout"><para>Milliseconds allowed between digits when entering a feature code.</para></enum>
+					<enum name="transferdigittimeout"><para>Milliseconds allowed between digits when dialing a transfer destination</para></enum>
+					<enum name="atxfernoanswertimeout"><para>Milliseconds to wait for transfer destination to answer</para></enum>
+					<enum name="atxferdropcall"><para>Hang up the call entirely if the attended transfer fails</para></enum>
+					<enum name="atxferloopdelay"><para>Milliseconds to wait between attempts to re-dial transfer destination</para></enum>
+					<enum name="atxfercallbackretries"><para>Number of times to re-attempt dialing a transfer destination</para></enum>
+					<enum name="xfersound"><para>Sound to play to a transferee when a transfer completes</para></enum>
+					<enum name="xferfailsound"><para>Sound to play to a transferee when a transfer fails</para></enum>
+					<enum name="atxferabort"><para>Digits to dial to abort an attended transfer attempt</para></enum>
+					<enum name="atxfercomplete"><para>Digits to dial to complete an attended transfer</para></enum>
+					<enum name="atxferthreeway"><para>Digits to dial to change an attended transfer into a three-way call</para></enum>
+					<enum name="pickupexten"><para>Digits used for picking up ringing calls</para></enum>
+					<enum name="pickupsound"><para>Sound to play to picker when a call is picked up</para></enum>
+					<enum name="pickupfailsound"><para>Sound to play to picker when a call cannot be picked up</para></enum>
+					<enum name="courtesytone"><para>Sound to play when automon or automixmon is activated</para></enum>
+				</enumlist>
+			</parameter>
+		</syntax>
+		<description>
+			<para>When this function is used as a read, it will get the current
+			value of the specified feature option for this channel.  It will be
+			the value of this option configured in features.conf if a channel specific
+			value has not been set.  This function can also be used to set a channel
+			specific value for the supported feature options.</para>
+		</description>
+		<see-also>
+			<ref type="function">FEATUREMAP</ref>
+		</see-also>
+	</function>
+	<function name="FEATUREMAP" language="en_US">
+		<synopsis>
+			Get or set a feature map to a given value on a specific channel.
+		</synopsis>
+		<syntax>
+			<parameter name="feature_name" required="true">
+				<para>The allowed values are:</para>
+				<enumlist>
+					<enum name="atxfer"><para>Attended Transfer</para></enum>
+					<enum name="blindxfer"><para>Blind Transfer</para></enum>
+					<enum name="automon"><para>Auto Monitor</para></enum>
+					<enum name="disconnect"><para>Call Disconnect</para></enum>
+					<enum name="parkcall"><para>Park Call</para></enum>
+					<enum name="automixmon"><para>Auto MixMonitor</para></enum>
+				</enumlist>
+			</parameter>
+		</syntax>
+		<description>
+			<para>When this function is used as a read, it will get the current
+			digit sequence mapped to the specified feature for this channel.  This
+			value will be the one configured in features.conf if a channel specific
+			value has not been set.  This function can also be used to set a channel
+			specific value for a feature mapping.</para>
+		</description>
+		<see-also>
+			<ref type="function">FEATURE</ref>
+		</see-also>
+	</function>
+ ***/
+/*! Default general options */
+#define DEFAULT_FEATURE_DIGIT_TIMEOUT               1000
+
+/*! Default xfer options */
+#define DEFAULT_TRANSFER_DIGIT_TIMEOUT              3000
+#define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER  15000
+#define DEFAULT_ATXFER_DROP_CALL                    0
+#define DEFAULT_ATXFER_LOOP_DELAY                   10000
+#define DEFAULT_ATXFER_CALLBACK_RETRIES             2
+#define DEFAULT_XFERSOUND                           "beep"
+#define DEFAULT_XFERFAILSOUND                       "beeperr"
+#define DEFAULT_ATXFER_ABORT                        "*1"
+#define DEFAULT_ATXFER_COMPLETE                     "*2"
+#define DEFAULT_ATXFER_THREEWAY                     "*3"
+
+/*! Default pickup options */
+#define DEFAULT_PICKUPEXTEN                         "*8"
+#define DEFAULT_PICKUPSOUND                         ""
+#define DEFAULT_PICKUPFAILSOUND                     ""
+
+/*! Default featuremap options */
+#define DEFAULT_FEATUREMAP_BLINDXFER                "#"
+#define DEFAULT_FEATUREMAP_DISCONNECT               "*"
+#define DEFAULT_FEATUREMAP_AUTOMON                  ""
+#define DEFAULT_FEATUREMAP_ATXFER                   ""
+#define DEFAULT_FEATUREMAP_PARKCALL                 ""
+#define DEFAULT_FEATUREMAP_AUTOMIXMON               ""
+
+/*!
+ * \brief Configuration from the "general" section of features.conf
+ */
+struct features_global_config {
+	struct ast_features_general_config *general;
+	struct ast_features_xfer_config *xfer;
+	struct ast_features_pickup_config *pickup;
+};
+
+static void ast_applicationmap_item_destructor(void *obj)
+{
+	struct ast_applicationmap_item *item = obj;
+
+	ast_string_field_free_memory(item);
+}
+
+static int applicationmap_sort(const void *obj, const void *arg, int flags)
+{
+	const struct ast_applicationmap_item *item1 = obj;
+	const struct ast_applicationmap_item *item2;
+	const char *key2;
+
+	switch(flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
+	case OBJ_KEY:
+		key2 = arg;
+		return strcasecmp(item1->name, key2);
+	case OBJ_PARTIAL_KEY:
+		key2 = arg;
+		return strncasecmp(item1->name, key2, strlen(key2));
+	default:
+	case OBJ_POINTER:
+		item2 = arg;
+		return strcasecmp(item1->name, item2->name);
+	}
+}
+
+/*!
+ * \brief Entry in the container of featuregroups
+ */
+struct featuregroup_item {
+	AST_DECLARE_STRING_FIELDS(
+		/*! The name of the applicationmap item that we are referring to */
+		AST_STRING_FIELD(appmap_item_name);
+		/*! Custom DTMF override to use instead of the default for the applicationmap item */
+		AST_STRING_FIELD(dtmf_override);
+	);
+	/*! The applicationmap item that is being referred to */
+	struct ast_applicationmap_item *appmap_item;
+};
+
+static void featuregroup_item_destructor(void *obj)
+{
+	struct featuregroup_item *item = obj;
+
+	ast_string_field_free_memory(item);
+	ao2_cleanup(item->appmap_item);
+}
+
+static int group_item_sort(const void *obj, const void *arg, int flags)
+{
+	const struct featuregroup_item *item1 = obj;
+	const struct featuregroup_item *item2;
+	const char *key2;
+
+	switch(flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
+	case OBJ_KEY:
+		key2 = arg;
+		return strcasecmp(item1->appmap_item_name, key2);
+	case OBJ_PARTIAL_KEY:
+		key2 = arg;
+		return strncasecmp(item1->appmap_item_name, key2, strlen(key2));
+	case OBJ_POINTER:
+		item2 = arg;
+		return strcasecmp(item1->appmap_item_name, item2->appmap_item_name);
+	default:
+		return CMP_STOP;
+	}
+}
+
+/*!
+ * \brief Featuregroup representation
+ */
+struct featuregroup {
+	/*! The name of the featuregroup */
+	const char *name;
+	/*! A container of featuregroup_items */
+	struct ao2_container *items;
+};
+
+static int featuregroup_hash(const void *obj, int flags)
+{
+	const struct featuregroup *group;
+	const char *key;
+
+	switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
+	case OBJ_KEY:
+		key = obj;
+		return ast_str_case_hash(key);
+	case OBJ_PARTIAL_KEY:
+		ast_assert(0);
+		return 0;
+	case OBJ_POINTER:
+	default:
+		group = obj;
+		return ast_str_case_hash(group->name);
+	}
+}
+
+static int featuregroup_cmp(void *obj, void *arg, int flags)
+{
+	struct featuregroup *group1 = obj;
+	struct featuregroup *group2;
+	const char *key2;
+
+	switch(flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
+	case OBJ_KEY:
+		key2 = arg;
+		return strcasecmp(group1->name, key2) ? 0 : CMP_MATCH;
+	case OBJ_PARTIAL_KEY:
+		key2 = arg;
+		return strncasecmp(group1->name, key2, strlen(key2)) ? 0 : CMP_MATCH;
+	case OBJ_POINTER:
+		group2 = arg;
+		return strcasecmp(group1->name, group2->name) ? 0 : CMP_MATCH;
+	default:
+		return CMP_STOP;
+	}
+}
+
+static void *featuregroup_find(struct ao2_container *group_container, const char *category)
+{
+	return ao2_find(group_container, category, OBJ_KEY);
+}
+
+static void featuregroup_destructor(void *obj)
+{
+	struct featuregroup *group = obj;
+
+	ast_free((char *) group->name);
+	ao2_cleanup(group->items);
+}
+
+static void *featuregroup_alloc(const char *cat)
+{
+	struct featuregroup *group;
+
+	group = ao2_alloc(sizeof(*group), featuregroup_destructor);
+	if (!group) {
+		return NULL;
+	}
+
+	group->name = ast_strdup(cat);
+	if (!group->name) {
+		ao2_cleanup(group);
+		return NULL;
+	}
+
+	group->items = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK,
+			AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, group_item_sort, NULL);
+	if (!group->items) {
+		ao2_cleanup(group);
+		return NULL;
+	}
+
+	return group;
+}
+
+struct features_config {
+	struct features_global_config *global;
+	struct ast_featuremap_config *featuremap;
+	struct ao2_container *applicationmap;
+	struct ao2_container *featuregroups;
+};
+
+static struct aco_type global_option = {
+	.type = ACO_GLOBAL,
+	.name = "globals",
+	.category_match = ACO_WHITELIST,
+	.category = "^general$",
+	.item_offset = offsetof(struct features_config, global),
+};
+
+static struct aco_type featuremap_option = {
+	.type = ACO_GLOBAL,
+	.name = "featuremap",
+	.category_match = ACO_WHITELIST,
+	.category = "^featuremap$",
+	.item_offset = offsetof(struct features_config, featuremap),
+};
+
+static struct aco_type applicationmap_option = {
+	.type = ACO_GLOBAL,
+	.name = "applicationmap",
+	.category_match = ACO_WHITELIST,
+	.category = "^applicationmap$",
+	.item_offset = offsetof(struct features_config, applicationmap),
+};
+
+static struct aco_type featuregroup_option = {
+	.type = ACO_ITEM,
+	.name = "featuregroup",
+	.category_match = ACO_BLACKLIST,
+	.category = "^(general|featuremap|applicationmap|parkinglot_.*)$",
+	.item_offset = offsetof(struct features_config, featuregroups),
+	.item_alloc = featuregroup_alloc,
+	.item_find = featuregroup_find,
+};
+
+static struct aco_type *global_options[] = ACO_TYPES(&global_option);
+static struct aco_type *featuremap_options[] = ACO_TYPES(&featuremap_option);
+static struct aco_type *applicationmap_options[] = ACO_TYPES(&applicationmap_option);
+static struct aco_type *featuregroup_options[] = ACO_TYPES(&featuregroup_option);
+
+static struct aco_file features_conf = {
+	.filename = "features.conf",
+	.types = ACO_TYPES(&global_option, &featuremap_option, &applicationmap_option, &featuregroup_option),
+};
+
+AO2_GLOBAL_OBJ_STATIC(globals);
+
+static void features_config_destructor(void *obj)
+{
+	struct features_config *cfg = obj;
+
+	ao2_cleanup(cfg->global);
+	ao2_cleanup(cfg->featuremap);
+	ao2_cleanup(cfg->applicationmap);
+	ao2_cleanup(cfg->featuregroups);
+}
+
+static void featuremap_config_destructor(void *obj)
+{
+	struct ast_featuremap_config *cfg = obj;
+
+	ast_string_field_free_memory(cfg);
+}
+
+static void global_config_destructor(void *obj)
+{
+	struct features_global_config *cfg = obj;
+
+	ao2_cleanup(cfg->general);
+	ao2_cleanup(cfg->xfer);
+	ao2_cleanup(cfg->pickup);
+}
+
+static void general_destructor(void *obj)
+{
+	struct ast_features_general_config *cfg = obj;
+
+	ast_string_field_free_memory(cfg);
+}
+
+static void xfer_destructor(void *obj)
+{
+	struct ast_features_xfer_config *cfg = obj;
+
+	ast_string_field_free_memory(cfg);
+}
+
+static void pickup_destructor(void *obj)
+{
+	struct ast_features_pickup_config *cfg = obj;
+
+	ast_string_field_free_memory(cfg);
+}
+
+static struct features_global_config *global_config_alloc(void)
+{
+	RAII_VAR(struct features_global_config *, cfg, NULL, ao2_cleanup);
+
+	cfg = ao2_alloc(sizeof(*cfg), global_config_destructor);
+	if (!cfg) {
+		return NULL;
+	}
+
+	cfg->general = ao2_alloc(sizeof(*cfg->general), general_destructor);
+	if (!cfg->general || ast_string_field_init(cfg->general, 32)) {
+		return NULL;
+	}
+
+	cfg->xfer = ao2_alloc(sizeof(*cfg->xfer), xfer_destructor);
+	if (!cfg->xfer || ast_string_field_init(cfg->xfer, 32)) {
+		return NULL;
+	}
+
+	cfg->pickup = ao2_alloc(sizeof(*cfg->pickup), pickup_destructor);
+	if (!cfg->pickup || ast_string_field_init(cfg->pickup, 32)) {
+		return NULL;
+	}
+
+	ao2_ref(cfg, +1);
+	return cfg;
+}
+
+static struct ao2_container *applicationmap_alloc(void)
+{
+	return ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK,
+			AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, applicationmap_sort, NULL);
+}
+
+/*!
+ * \internal
+ * \brief Allocate the major configuration structure
+ *
+ * The parameter is used to determine if the applicationmap and featuregroup
+ * structures should be allocated. We only want to allocate these structures for
+ * the global features_config structure. For the datastores on channels, we don't
+ * need to allocate these structures because they are not used.
+ *
+ * \param allocate_applicationmap See previous explanation
+ * \retval NULL Failed to alloate configuration
+ * \retval non-NULL Allocated configuration
+ */
+static struct features_config *__features_config_alloc(int allocate_applicationmap)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	cfg = ao2_alloc(sizeof(*cfg), features_config_destructor);
+	if (!cfg) {
+		return NULL;
+	}
+
+	cfg->global = global_config_alloc();;
+	if (!cfg->global) {
+		return NULL;
+	}
+
+	cfg->featuremap = ao2_alloc(sizeof(*cfg->featuremap), featuremap_config_destructor);
+	if (!cfg->featuremap || ast_string_field_init(cfg->featuremap, 32)) {
+		return NULL;
+	}
+
+	if (allocate_applicationmap) {
+		cfg->applicationmap = applicationmap_alloc();
+		if (!cfg->applicationmap) {
+			return NULL;
+		}
+
+		cfg->featuregroups = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 11, featuregroup_hash,
+			featuregroup_cmp);
+		if (!cfg->featuregroups) {
+			return NULL;
+		}
+	}
+
+	ao2_ref(cfg, +1);
+	return cfg;
+
+}
+
+static void *features_config_alloc(void)
+{
+	return __features_config_alloc(1);
+}
+
+static void general_copy(struct ast_features_general_config *dest, const struct ast_features_general_config *src)
+{
+	ast_string_fields_copy(dest, src);
+	dest->featuredigittimeout = src->featuredigittimeout;
+}
+
+static void xfer_copy(struct ast_features_xfer_config *dest, const struct ast_features_xfer_config *src)
+{
+	ast_string_fields_copy(dest, src);
+	dest->transferdigittimeout = src->transferdigittimeout;
+	dest->atxfernoanswertimeout = src->atxfernoanswertimeout;
+	dest->atxferloopdelay = src->atxferloopdelay;
+	dest->atxfercallbackretries = src->atxfercallbackretries;
+	dest->atxferdropcall = src->atxferdropcall;
+}
+
+static void pickup_copy(struct ast_features_pickup_config *dest, const struct ast_features_pickup_config *src)
+{
+	ast_string_fields_copy(dest, src);
+}
+
+static void global_copy(struct features_global_config *dest, const struct features_global_config *src)
+{
+	general_copy(dest->general, src->general);
+	xfer_copy(dest->xfer, src->xfer);
+	pickup_copy(dest->pickup, src->pickup);
+}
+
+static void featuremap_copy(struct ast_featuremap_config *dest, const struct ast_featuremap_config *src)
+{
+	ast_string_fields_copy(dest, src);
+}
+
+static void features_copy(struct features_config *dest, const struct features_config *src)
+{
+	global_copy(dest->global, src->global);
+	featuremap_copy(dest->featuremap, src->featuremap);
+
+	/* applicationmap and featuregroups are purposely not copied. A channel's applicationmap
+	 * is produced on the fly when ast_get_chan_applicationmap() is called
+	 */
+}
+
+static struct features_config *features_config_dup(const struct features_config *orig)
+{
+	struct features_config *dup;
+
+	dup = __features_config_alloc(0);
+	if (!dup) {
+		return NULL;
+	}
+
+	features_copy(dup, orig);
+
+	return dup;
+}
+
+static int general_set(struct ast_features_general_config *general, const char *name,
+		const char *value)
+{
+	int res = 0;
+
+	if (!strcasecmp(name, "featuredigittimeout")) {
+		res = ast_parse_arg(value, PARSE_INT32, &general->featuredigittimeout);
+	} else if (!strcasecmp(name, "courtesytone")) {
+		ast_string_field_set(general, courtesytone, value);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int general_get(struct ast_features_general_config *general, const char *field,
+		char *buf, size_t len)
+{
+	int res = 0;
+
+	if (!strcasecmp(field, "featuredigittimeout")) {
+		snprintf(buf, len, "%u", general->featuredigittimeout);
+	} else if (!strcasecmp(field, "courtesytone")) {
+		ast_copy_string(buf, general->courtesytone, len);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int xfer_set(struct ast_features_xfer_config *xfer, const char *name,
+		const char *value)
+{
+	int res = 0;
+
+	if (!strcasecmp(name, "transferdigittimeout")) {
+		res = ast_parse_arg(value, PARSE_INT32, &xfer->transferdigittimeout);
+	} else if (!strcasecmp(name, "atxfernoanswertimeout")) {
+		res = ast_parse_arg(value, PARSE_INT32, &xfer->atxfernoanswertimeout);
+	} else if (!strcasecmp(name, "atxferloopdelay")) {
+		res = ast_parse_arg(value, PARSE_INT32, &xfer->atxferloopdelay);
+	} else if (!strcasecmp(name, "atxfercallbackretries")) {
+		res = ast_parse_arg(value, PARSE_INT32, &xfer->atxfercallbackretries);
+	} else if (!strcasecmp(name, "atxferdropcall")) {
+		xfer->atxferdropcall = ast_true(value);
+	} else if (!strcasecmp(name, "xfersound")) {
+		ast_string_field_set(xfer, xfersound, value);
+	} else if (!strcasecmp(name, "xferfailsound")) {
+		ast_string_field_set(xfer, xferfailsound, value);
+	} else if (!strcasecmp(name, "atxferabort")) {
+		ast_string_field_set(xfer, atxferabort, value);
+	} else if (!strcasecmp(name, "atxfercomplete")) {
+		ast_string_field_set(xfer, atxfercomplete, value);
+	} else if (!strcasecmp(name, "atxferthreeway")) {
+		ast_string_field_set(xfer, atxferthreeway, value);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int xfer_get(struct ast_features_xfer_config *xfer, const char *field,
+		char *buf, size_t len)
+{
+	int res = 0;
+
+	if (!strcasecmp(field, "transferdigittimeout")) {
+		snprintf(buf, len, "%u", xfer->transferdigittimeout);
+	} else if (!strcasecmp(field, "atxfernoanswertimeout")) {
+		snprintf(buf, len, "%u", xfer->atxfernoanswertimeout);
+	} else if (!strcasecmp(field, "atxferloopdelay")) {
+		snprintf(buf, len, "%u", xfer->atxferloopdelay);
+	} else if (!strcasecmp(field, "atxfercallbackretries")) {
+		snprintf(buf, len, "%u", xfer->atxfercallbackretries);
+	} else if (!strcasecmp(field, "atxferdropcall")) {
+		snprintf(buf, len, "%u", xfer->atxferdropcall);
+	} else if (!strcasecmp(field, "xfersound")) {
+		ast_copy_string(buf, xfer->xfersound, len);
+	} else if (!strcasecmp(field, "xferfailsound")) {
+		ast_copy_string(buf, xfer->xferfailsound, len);
+	} else if (!strcasecmp(field, "atxferabort")) {
+		ast_copy_string(buf, xfer->atxferabort, len);
+	} else if (!strcasecmp(field, "atxfercomplete")) {
+		ast_copy_string(buf, xfer->atxfercomplete, len);
+	} else if (!strcasecmp(field, "atxferthreeway")) {
+		ast_copy_string(buf, xfer->atxferthreeway, len);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int pickup_set(struct ast_features_pickup_config *pickup, const char *name,
+		const char *value)
+{
+	int res = 0;
+
+	if (!strcasecmp(name, "pickupsound")) {
+		ast_string_field_set(pickup, pickupsound, value);
+	} else if (!strcasecmp(name, "pickupfailsound")) {
+		ast_string_field_set(pickup, pickupfailsound, value);
+	} else if (!strcasecmp(name, "pickupexten")) {
+		ast_string_field_set(pickup, pickupexten, value);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int pickup_get(struct ast_features_pickup_config *pickup, const char *field,
+		char *buf, size_t len)
+{
+	int res = 0;
+
+	if (!strcasecmp(field, "pickupsound")) {
+		ast_copy_string(buf, pickup->pickupsound, len);
+	} else if (!strcasecmp(field, "pickupfailsound")) {
+		ast_copy_string(buf, pickup->pickupfailsound, len);
+	} else if (!strcasecmp(field, "pickupexten")) {
+		ast_copy_string(buf, pickup->pickupexten, len);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int featuremap_set(struct ast_featuremap_config *featuremap, const char *name,
+		const char *value)
+{
+	int res = 0;
+
+	if (!strcasecmp(name, "blindxfer")) {
+		ast_string_field_set(featuremap, blindxfer, value);
+	} else if (!strcasecmp(name, "disconnect")) {
+		ast_string_field_set(featuremap, disconnect, value);
+	} else if (!strcasecmp(name, "automon")) {
+		ast_string_field_set(featuremap, automon, value);
+	} else if (!strcasecmp(name, "atxfer")) {
+		ast_string_field_set(featuremap, atxfer, value);
+	} else if (!strcasecmp(name, "automixmon")) {
+		ast_string_field_set(featuremap, automixmon, value);
+	} else if (!strcasecmp(name, "parkcall")) {
+		ast_string_field_set(featuremap, parkcall, value);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static int featuremap_get(struct ast_featuremap_config *featuremap, const char *field,
+		char *buf, size_t len)
+{
+	int res = 0;
+
+	if (!strcasecmp(field, "blindxfer")) {
+		ast_copy_string(buf, featuremap->blindxfer, len);
+	} else if (!strcasecmp(field, "disconnect")) {
+		ast_copy_string(buf, featuremap->disconnect, len);
+	} else if (!strcasecmp(field, "automon")) {
+		ast_copy_string(buf, featuremap->automon, len);
+	} else if (!strcasecmp(field, "atxfer")) {
+		ast_copy_string(buf, featuremap->atxfer, len);
+	} else if (!strcasecmp(field, "automixmon")) {
+		ast_copy_string(buf, featuremap->automixmon, len);
+	} else if (!strcasecmp(field, "parkcall")) {
+		ast_copy_string(buf, featuremap->parkcall, len);
+	} else {
+		/* Unrecognized option */
+		res = -1;
+	}
+
+	return res;
+}
+
+static void feature_ds_destroy(void *data)
+{
+	struct features_config *cfg = data;
+	ao2_cleanup(cfg);
+}
+
+static void *feature_ds_duplicate(void *data)
+{
+	struct features_config *old_cfg = data;
+
+	return features_config_dup(old_cfg);
+}
+
+static const struct ast_datastore_info feature_ds_info = {
+	.type = "FEATURE",
+	.destroy = feature_ds_destroy,
+	.duplicate = feature_ds_duplicate,
+};
+
+/*!
+ * \internal
+ * \brief Find or create feature datastore on a channel
+ *
+ * \pre chan is locked
+ *
+ * \return the data on the FEATURE datastore, or NULL on error
+ */
+static struct features_config *get_feature_ds(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, orig, NULL, ao2_cleanup);
+	struct features_config *cfg;
+	struct ast_datastore *ds;
+
+	if ((ds = ast_channel_datastore_find(chan, &feature_ds_info, NULL))) {
+		cfg = ds->data;
+		ao2_ref(cfg, +1);
+		return cfg;
+	}
+
+	orig = ao2_global_obj_ref(globals);
+	if (!orig) {
+		return NULL;
+	}
+
+	cfg = features_config_dup(orig);
+	if (!cfg) {
+		return NULL;
+	}
+
+	if (!(ds = ast_datastore_alloc(&feature_ds_info, NULL))) {
+		ao2_cleanup(cfg);
+		return NULL;
+	}
+
+	/* Give the datastore a reference to the config */
+	ao2_ref(cfg, +1);
+	ds->data = cfg;
+
+	ast_channel_datastore_add(chan, ds);
+
+	return cfg;
+}
+
+static struct ast_datastore *get_feature_chan_ds(struct ast_channel *chan)
+{
+	struct ast_datastore *ds;
+
+	if (!(ds = ast_channel_datastore_find(chan, &feature_ds_info, NULL))) {
+		/* Hasn't been created yet.  Trigger creation. */
+		RAII_VAR(struct features_config *, cfg, get_feature_ds(chan), ao2_cleanup);
+		ds = ast_channel_datastore_find(chan, &feature_ds_info, NULL);
+	}
+
+	return ds;
+}
+
+struct ast_features_general_config *ast_get_chan_features_general_config(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	if (chan) {
+		cfg = get_feature_ds(chan);
+	} else {
+		cfg = ao2_global_obj_ref(globals);
+	}
+
+	if (!cfg) {
+		return NULL;
+	}
+
+	ast_assert(cfg->global && cfg->global->general);
+
+	ao2_ref(cfg->global->general, +1);
+	return cfg->global->general;
+}
+
+struct ast_features_xfer_config *ast_get_chan_features_xfer_config(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	if (chan) {
+		cfg = get_feature_ds(chan);
+	} else {
+		cfg = ao2_global_obj_ref(globals);
+	}
+
+	if (!cfg) {
+		return NULL;
+	}
+
+	ast_assert(cfg->global && cfg->global->xfer);
+
+	ao2_ref(cfg->global->xfer, +1);
+	return cfg->global->xfer;
+}
+
+struct ast_features_pickup_config *ast_get_chan_features_pickup_config(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	if (chan) {
+		cfg = get_feature_ds(chan);
+	} else {
+		cfg = ao2_global_obj_ref(globals);
+	}
+
+	if (!cfg) {
+		return NULL;
+	}
+
+	ast_assert(cfg->global && cfg->global->pickup);
+
+	ao2_ref(cfg->global->pickup, +1);
+	return cfg->global->pickup;
+}
+
+struct ast_featuremap_config *ast_get_chan_featuremap_config(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	if (chan) {
+		cfg = get_feature_ds(chan);
+	} else {
+		cfg = ao2_global_obj_ref(globals);
+	}
+
+	if (!cfg) {
+		return NULL;
+	}
+
+	ast_assert(cfg->featuremap != NULL);
+
+	ao2_ref(cfg->featuremap, +1);
+	return cfg->featuremap;
+}
+
+int ast_get_builtin_feature(struct ast_channel *chan, const char *feature, char *buf, size_t len)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	if (chan) {
+		cfg = get_feature_ds(chan);
+	} else {
+		cfg = ao2_global_obj_ref(globals);
+	}
+
+	if (!cfg) {
+		return -1;
+	}
+
+	return featuremap_get(cfg->featuremap, feature, buf, len);
+}
+
+int ast_get_feature(struct ast_channel *chan, const char *feature, char *buf, size_t len)
+{
+	RAII_VAR(struct ao2_container *, applicationmap, NULL, ao2_cleanup);
+	RAII_VAR(struct ast_applicationmap_item *, item, NULL, ao2_cleanup);
+	if (!ast_get_builtin_feature(chan, feature, buf, len)) {
+		return 0;
+	}
+
+	/* Dang, must be in the application map */
+	applicationmap = ast_get_chan_applicationmap(chan);
+
+	if (!applicationmap) {
+		return -1;
+	}
+
+	item = ao2_find(applicationmap, feature, OBJ_KEY);
+	if (!item) {
+		return -1;
+	}
+
+	ast_copy_string(buf, item->dtmf, len);
+	return 0;
+}
+
+static struct ast_applicationmap_item *applicationmap_item_alloc(const char *name,
+		const char *app, const char *app_data, const char *moh_class, const char *dtmf,
+		unsigned int activate_on_self)
+{
+	struct ast_applicationmap_item *item;
+
+	item = ao2_alloc(sizeof(*item), ast_applicationmap_item_destructor);
+
+	if (!item || ast_string_field_init(item, 64)) {
+		return NULL;
+	}
+
+	ast_string_field_set(item, name, name);
+	ast_string_field_set(item, app, app);
+	ast_string_field_set(item, app_data, app_data);
+	ast_string_field_set(item, moh_class, moh_class);
+	ast_copy_string(item->dtmf, dtmf, sizeof(item->dtmf));
+	item->activate_on_self = activate_on_self;
+
+	return item;
+}
+
+static int add_item(void *obj, void *arg, int flags)
+{
+	struct featuregroup_item *fg_item = obj;
+	struct ao2_container *applicationmap = arg;
+	RAII_VAR(struct ast_applicationmap_item *, appmap_item, NULL, ao2_cleanup);
+
+	/* If there's no DTMF override, then we can just link
+	 * the applicationmap item directly. Otherwise, we need
+	 * to create a copy with the DTMF override in place and
+	 * link that instead
+	 */
+	if (ast_strlen_zero(fg_item->dtmf_override)) {
+		ao2_ref(fg_item->appmap_item, +1);
+		appmap_item = fg_item->appmap_item;
+	} else {
+		appmap_item = applicationmap_item_alloc(fg_item->appmap_item_name,
+				fg_item->appmap_item->app, fg_item->appmap_item->app_data,
+				fg_item->appmap_item->moh_class, fg_item->dtmf_override,
+				fg_item->appmap_item->activate_on_self);
+	}
+
+	if (!appmap_item) {
+		return 0;
+	}
+
+	if (!ao2_link(applicationmap, appmap_item)) {
+		ast_log(LOG_WARNING, "Unable to add applicationmap item %s. Possible duplicate\n",
+				fg_item->appmap_item_name);
+	}
+	return 0;
+}
+
+struct ao2_container *ast_get_chan_applicationmap(struct ast_channel *chan)
+{
+	RAII_VAR(struct features_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
+	struct ao2_container *applicationmap;
+	char *group_names;
+	char *name;
+
+	if (!cfg) {
+		return NULL;
+	}
+
+	if (!chan) {
+		if (!cfg->applicationmap || ao2_container_count(cfg->applicationmap) == 0) {
+			return NULL;
+		}
+		ao2_ref(cfg->applicationmap, +1);
+		return cfg->applicationmap;
+	}
+
+	group_names = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "DYNAMIC_FEATURES"), ""));
+	if (ast_strlen_zero(group_names)) {
+		return NULL;
+	}
+
+	applicationmap = applicationmap_alloc();
+	if (!applicationmap) {
+		return NULL;
+	}
+
+	while ((name = strsep(&group_names, "#"))) {
+		RAII_VAR(struct featuregroup *, group, ao2_find(cfg->featuregroups, name, OBJ_KEY), ao2_cleanup);
+		if (!group) {
+			RAII_VAR(struct ast_applicationmap_item *, item, ao2_find(cfg->applicationmap, name, OBJ_KEY), ao2_cleanup);
+			if (item && !ao2_link(applicationmap, item)) {
+				ast_log(LOG_WARNING, "Unable to add applicationmap item %s. Possible duplicate.\n", item->name);
+			}
+		} else {
+			ao2_callback(group->items, 0, add_item, applicationmap);
+		}
+	}
+
+	if (ao2_container_count(applicationmap) == 0) {
+		ao2_cleanup(applicationmap);
+		return NULL;
+	}
+
+	return applicationmap;
+}
+
+static int applicationmap_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	RAII_VAR(struct ast_applicationmap_item *, item, NULL, ao2_cleanup);
+	struct ao2_container *applicationmap = obj;
+	AST_DECLARE_APP_ARGS(args,
+		AST_APP_ARG(dtmf);
+		AST_APP_ARG(activate_on);
+		AST_APP_ARG(app);
+		AST_APP_ARG(app_data);
+		AST_APP_ARG(moh_class);
+	);
+	char *parse = ast_strdupa(var->value);
+	char *slash;
+	char *paren;
+	unsigned int activate_on_self;
+
+	AST_STANDARD_APP_ARGS(args, parse);
+
+	if (ast_strlen_zero(args.dtmf) ||
+			ast_strlen_zero(args.activate_on) ||
+			ast_strlen_zero(args.app)) {
+		ast_log(LOG_WARNING, "Invalid applicationmap syntax for '%s'. Missing required argument\n", var->name);
+		return -1;
+	}
+
+	/* features.conf used to have an "activated_by" portion
+	 * in addition to activate_on. Get rid of whatever may be
+	 * there
+	 */
+	slash = strchr(args.activate_on, '/');
+	if (slash) {
+		*slash = '\0';
+	}
+
+	/* Two syntaxes allowed for applicationmap:
+	 * Old: foo = *1,self,NoOp,Boo!,default
+	 * New: foo = *1,self,NoOp(Boo!),default
+	 *
+	 * We need to handle both
+	 */
+	paren = strchr(args.app, '(');
+	if (paren) {
+		/* New syntax */
+		char *close_paren;
+
+		args.moh_class = args.app_data;
+		*paren++ = '\0';
+		close_paren = strrchr(paren, ')');
+		if (close_paren) {
+			*close_paren = '\0';
+		}
+		args.app_data = paren;
+
+		/* Re-check that the application is not empty */
+		if (ast_strlen_zero(args.app)) {
+			ast_log(LOG_WARNING, "Applicationmap item '%s' does not contain an application name.\n", var->name);
+			return -1;
+		}
+	} else if (strchr(args.app_data, '"')) {
+		args.app_data = ast_strip_quoted(args.app_data, "\"", "\"");
+	}
+
+	/* Allow caller and callee to be specified for backwards compatibility */
+	if (!strcasecmp(args.activate_on, "self") || !strcasecmp(args.activate_on, "caller")) {
+		activate_on_self = 1;
+	} else if (!strcasecmp(args.activate_on, "peer") || !strcasecmp(args.activate_on, "callee")) {
+		activate_on_self = 0;
+	} else {
+		ast_log(LOG_WARNING, "Invalid 'activate_on' value %s for applicationmap item %s\n",
+			args.activate_on, var->name);
+		return -1;
+	}
+
+	ast_debug(1, "Allocating applicationmap item: dtmf = %s, app = %s, app_data = %s, moh_class = %s\n",
+			args.dtmf, args.app, args.app_data, args.moh_class);
+
+	item = applicationmap_item_alloc(var->name, args.app, args.app_data,
+			args.moh_class, args.dtmf, activate_on_self);
+
+	if (!item) {
+		return -1;
+	}
+
+	if (!ao2_link(applicationmap, item)) {
+		ast_log(LOG_WARNING, "Unable to add applicationmap item %s. Possible duplicate\n", item->name);
+	}
+
+	return 0;
+}
+
+static int featuregroup_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	RAII_VAR(struct featuregroup_item *, item, NULL, ao2_cleanup);
+	struct featuregroup *group = obj;
+
+	item = ao2_alloc(sizeof(*item), featuregroup_item_destructor);
+	if (!item || ast_string_field_init(item, 32)) {
+		return -1;
+	}
+
+	ast_string_field_set(item, appmap_item_name, var->name);
+	ast_string_field_set(item, dtmf_override, var->value);
+
+	if (!ao2_link(group->items, item)) {
+		ast_log(LOG_WARNING, "Unable to add featuregroup item %s. Possible duplicate\n", item->appmap_item_name);
+	}
+
+	/* We wait to look up the application map item in the preapply callback */
+
+	return 0;
+}
+
+static int general_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	struct features_global_config *global = obj;
+	struct ast_features_general_config *general = global->general;
+
+	return general_set(general, var->name, var->value);
+}
+
+static int xfer_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	struct features_global_config *global = obj;
+	struct ast_features_xfer_config *xfer = global->xfer;
+
+	return xfer_set(xfer, var->name, var->value);
+}
+
+static int pickup_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	struct features_global_config *global = obj;
+	struct ast_features_pickup_config *pickup = global->pickup;
+
+	return pickup_set(pickup, var->name, var->value);
+}
+
+static int featuremap_handler(const struct aco_option *opt,
+		struct ast_variable *var, void *obj)
+{
+	struct ast_featuremap_config *featuremap = obj;
+
+	return featuremap_set(featuremap, var->name, var->value);
+}
+
+static int check_featuregroup_item(void *obj, void *arg, void *data, int flags)
+{
+	struct ast_applicationmap_item *appmap_item;
+	struct featuregroup_item *fg_item = obj;
+	int *err = arg;
+	struct ao2_container *applicationmap = data;
+
+	appmap_item = ao2_find(applicationmap, fg_item->appmap_item_name, OBJ_KEY);
+	if (!appmap_item) {
+		*err = 1;
+		return CMP_STOP;
+	}
+
+	fg_item->appmap_item = appmap_item;
+
+	return 0;
+}
+
+static int check_featuregroup(void *obj, void *arg, void *data, int flags)
+{
+	struct featuregroup *group = obj;
+	int *err = arg;
+
+	ao2_callback_data(group->items, 0, check_featuregroup_item, arg, data);
+
+	if (*err) {
+		ast_log(LOG_WARNING, "Featuregroup %s refers to non-existent applicationmap item\n",
+				group->name);
+	}
+
+	return *err ? CMP_STOP : 0;
+}
+
+static int features_pre_apply_config(void);
+
+CONFIG_INFO_CORE("features", cfg_info, globals, features_config_alloc,
+	.files = ACO_FILES(&features_conf),
+	.pre_apply_config = features_pre_apply_config,
+);
+
+static int features_pre_apply_config(void)
+{
+	struct features_config *cfg = aco_pending_config(&cfg_info);
+	int err = 0;
+
+	/* Now that the entire config has been processed, we can check that the featuregroup
+	 * items refer to actual applicationmap items.
+	 */
+
+	ao2_callback_data(cfg->featuregroups, 0, check_featuregroup, &err, cfg->applicationmap);
+
+	return err;
+}
+
+static int feature_read(struct ast_channel *chan, const char *cmd, char *data,
+	       char *buf, size_t len)
+{
+	int res;
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+	SCOPED_CHANNELLOCK(lock, chan);
+
+	if (!strcasecmp(data, "inherit")) {
+		struct ast_datastore *ds = get_feature_chan_ds(chan);
+		unsigned int inherit = ds ? ds->inheritance : 0;
+
+		snprintf(buf, len, "%s", inherit ? "yes" : "no");
+		return 0;
+	}
+
+	cfg = get_feature_ds(chan);
+	if (!cfg) {
+		return -1;
+	}
+
+	res = general_get(cfg->global->general, data, buf, len) &&
+		xfer_get(cfg->global->xfer, data, buf, len) &&
+		pickup_get(cfg->global->pickup, data, buf, len);
+
+	if (res) {
+		ast_log(LOG_WARNING, "Invalid argument '%s' to FEATURE()\n", data);
+	}
+
+	return res;
+}
+
+static int feature_write(struct ast_channel *chan, const char *cmd, char *data,
+		const char *value)
+{
+	int res;
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+	SCOPED_CHANNELLOCK(lock, chan);
+
+	if (!strcasecmp(data, "inherit")) {
+		struct ast_datastore *ds = get_feature_chan_ds(chan);
+		if (ds) {
+			ds->inheritance = ast_true(value) ? DATASTORE_INHERIT_FOREVER : 0;
+		}
+		return 0;
+	}
+
+	if (!(cfg = get_feature_ds(chan))) {
+		return -1;
+	}
+
+	res = general_set(cfg->global->general, data, value) &&
+		xfer_set(cfg->global->xfer, data, value) &&
+		pickup_set(cfg->global->pickup, data, value);
+
+	if (res) {
+		ast_log(LOG_WARNING, "Invalid argument '%s' to FEATURE()\n", data);
+	}
+
+	return res;
+}
+
+static int featuremap_read(struct ast_channel *chan, const char *cmd, char *data,
+	       char *buf, size_t len)
+{
+	int res;
+	SCOPED_CHANNELLOCK(lock, chan);
+
+	res = ast_get_builtin_feature(chan, data, buf, len);
+
+	if (res) {
+		ast_log(LOG_WARNING, "Invalid argument '%s' to FEATUREMAP()\n", data);
+	}
+
+	return res;
+}
+
+static int featuremap_write(struct ast_channel *chan, const char *cmd, char *data,
+		const char *value)
+{
+	int res;
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+	SCOPED_CHANNELLOCK(lock, chan);
+
+	if (!(cfg = get_feature_ds(chan))) {
+		return -1;
+	}
+
+	res = featuremap_set(cfg->featuremap, data, value);
+	if (res) {
+		ast_log(LOG_WARNING, "Invalid argument '%s' to FEATUREMAP()\n", data);
+		return -1;
+	}
+
+	return 0;
+}
+
+static struct ast_custom_function feature_function = {
+	.name = "FEATURE",
+	.read = feature_read,
+	.write = feature_write
+};
+
+static struct ast_custom_function featuremap_function = {
+	.name = "FEATUREMAP",
+	.read = featuremap_read,
+	.write = featuremap_write
+};
+
+static int load_config(int reload)
+{
+	if (!reload && aco_info_init(&cfg_info)) {
+		ast_log(LOG_ERROR, "Unable to initialize configuration info for features\n");
+		return -1;
+	}
+
+	aco_option_register_custom(&cfg_info, "featuredigittimeout", ACO_EXACT, global_options,
+			__stringify(DEFAULT_FEATURE_DIGIT_TIMEOUT), general_handler, 0);
+	aco_option_register_custom(&cfg_info, "courtesytone", ACO_EXACT, global_options,
+			__stringify(DEFAULT_COURTESY_TONE), general_handler, 0);
+
+	aco_option_register_custom(&cfg_info, "transferdigittimeout", ACO_EXACT, global_options,
+			__stringify(DEFAULT_TRANSFER_DIGIT_TIMEOUT), xfer_handler, 0)
+	aco_option_register_custom(&cfg_info, "atxfernoanswertimeout", ACO_EXACT, global_options,
+			__stringify(DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER), xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxferdropcall", ACO_EXACT, global_options,
+			__stringify(DEFAULT_ATXFER_DROP_CALL), xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxferloopdelay", ACO_EXACT, global_options,
+			__stringify(DEFAULT_ATXFER_LOOP_DELAY), xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxfercallbackretries", ACO_EXACT, global_options,
+			__stringify(DEFAULT_ATXFER_CALLBACK_RETRIES), xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "xfersound", ACO_EXACT, global_options,
+			DEFAULT_XFERSOUND, xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "xferfailsound", ACO_EXACT, global_options,
+			DEFAULT_XFERFAILSOUND, xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxferabort", ACO_EXACT, global_options,
+			DEFAULT_ATXFER_ABORT, xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxfercomplete", ACO_EXACT, global_options,
+			DEFAULT_ATXFER_COMPLETE, xfer_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxferthreeway", ACO_EXACT, global_options,
+			DEFAULT_ATXFER_THREEWAY, xfer_handler, 0);
+
+	aco_option_register_custom(&cfg_info, "pickupexten", ACO_EXACT, global_options,
+			DEFAULT_PICKUPEXTEN, pickup_handler, 0);
+	aco_option_register_custom(&cfg_info, "pickupsound", ACO_EXACT, global_options,
+			DEFAULT_PICKUPSOUND, pickup_handler, 0);
+	aco_option_register_custom(&cfg_info, "pickupfailsound", ACO_EXACT, global_options,
+			DEFAULT_PICKUPFAILSOUND, pickup_handler, 0);
+
+	aco_option_register_custom(&cfg_info, "blindxfer", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_BLINDXFER, featuremap_handler, 0);
+	aco_option_register_custom(&cfg_info, "disconnect", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_DISCONNECT, featuremap_handler, 0);
+	aco_option_register_custom(&cfg_info, "automon", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_AUTOMON, featuremap_handler, 0);
+	aco_option_register_custom(&cfg_info, "atxfer", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_ATXFER, featuremap_handler, 0);
+	aco_option_register_custom(&cfg_info, "parkcall", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_PARKCALL, featuremap_handler, 0);
+	aco_option_register_custom(&cfg_info, "automixmon", ACO_EXACT, featuremap_options,
+			DEFAULT_FEATUREMAP_AUTOMIXMON, featuremap_handler, 0);
+
+	aco_option_register_custom(&cfg_info, "^.*$", ACO_REGEX, applicationmap_options,
+			"", applicationmap_handler, 0);
+
+	aco_option_register_custom(&cfg_info, "^.*$", ACO_REGEX, featuregroup_options,
+			"", featuregroup_handler, 0);
+
+	if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
+		ast_log(LOG_ERROR, "Failed to process features.conf configuration!\n");
+		if (!reload) {
+			aco_info_destroy(&cfg_info);
+			ao2_global_obj_release(globals);
+		}
+		return -1;
+	}
+
+	return 0;
+}
+
+static int print_featuregroup(void *obj, void *arg, int flags)
+{
+	struct featuregroup_item *item = obj;
+	struct ast_cli_args *a = arg;
+
+	ast_cli(a->fd, "===> --> %s (%s)\n", item->appmap_item_name,
+			S_OR(item->dtmf_override, item->appmap_item->dtmf));
+
+	return 0;
+}
+
+static int print_featuregroups(void *obj, void *arg, int flags)
+{
+	struct featuregroup *group = obj;
+	struct ast_cli_args *a = arg;
+
+	ast_cli(a->fd, "===> Group: %s\n", group->name);
+
+	ao2_callback(group->items, 0, print_featuregroup, a);
+	return 0;
+}
+
+#define HFS_FORMAT "%-25s %-7s %-7s\n"
+
+static int print_applicationmap(void *obj, void *arg, int flags)
+{
+	struct ast_applicationmap_item *item = obj;
+	struct ast_cli_args *a = arg;
+
+	ast_cli(a->fd, HFS_FORMAT, item->name, "no def", item->dtmf);
+	return 0;
+}
+
+/*!
+ * \brief CLI command to list configured features
+ * \param e
+ * \param cmd
+ * \param a
+ *
+ * \retval CLI_SUCCESS on success.
+ * \retval NULL when tab completion is used.
+ */
+static char *handle_feature_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+{
+	RAII_VAR(struct features_config *, cfg, NULL, ao2_cleanup);
+
+	switch (cmd) {
+
+	case CLI_INIT:
+		e->command = "features show";
+		e->usage =
+			"Usage: features show\n"
+			"       Lists configured features\n";
+		return NULL;
+	case CLI_GENERATE:
+		return NULL;
+	}
+
+	cfg = ao2_global_obj_ref(globals);
+
+	ast_cli(a->fd, HFS_FORMAT, "Builtin Feature", "Default", "Current");
+	ast_cli(a->fd, HFS_FORMAT, "---------------", "-------", "-------");
+
+	ast_cli(a->fd, HFS_FORMAT, "Pickup", DEFAULT_PICKUPEXTEN, cfg->global->pickup->pickupexten);
+	ast_cli(a->fd, HFS_FORMAT, "Blind Transfer", DEFAULT_FEATUREMAP_BLINDXFER, cfg->featuremap->blindxfer);
+	ast_cli(a->fd, HFS_FORMAT, "Attended Transfer", DEFAULT_FEATUREMAP_ATXFER, cfg->featuremap->atxfer);
+	ast_cli(a->fd, HFS_FORMAT, "One Touch Monitor", DEFAULT_FEATUREMAP_AUTOMON, cfg->featuremap->automon);
+	ast_cli(a->fd, HFS_FORMAT, "Disconnect Call", DEFAULT_FEATUREMAP_DISCONNECT, cfg->featuremap->disconnect);
+	ast_cli(a->fd, HFS_FORMAT, "Park Call", DEFAULT_FEATUREMAP_PARKCALL, cfg->featuremap->parkcall);
+	ast_cli(a->fd, HFS_FORMAT, "One Touch MixMonitor", DEFAULT_FEATUREMAP_AUTOMIXMON, cfg->featuremap->automixmon);
+
+	ast_cli(a->fd, "\n");
+	ast_cli(a->fd, HFS_FORMAT, "Dynamic Feature", "Default", "Current");
+	ast_cli(a->fd, HFS_FORMAT, "---------------", "-------", "-------");
+	if (!cfg->applicationmap || ao2_container_count(cfg->applicationmap) == 0) {
+		ast_cli(a->fd, "(none)\n");
+	} else {
+		ao2_callback(cfg->applicationmap, 0, print_applicationmap, a);
+	}
+
+	ast_cli(a->fd, "\nFeature Groups:\n");
+	ast_cli(a->fd, "---------------\n");
+	if (!cfg->featuregroups || ao2_container_count(cfg->featuregroups) == 0) {
+		ast_cli(a->fd, "(none)\n");
+	} else {
+		ao2_callback(cfg->featuregroups, 0, print_featuregroups, a);
+	}
+
+	ast_cli(a->fd, "\n");
+
+	return CLI_SUCCESS;
+}
+
+static struct ast_cli_entry cli_features_config[] = {
+	AST_CLI_DEFINE(handle_feature_show, "Lists configured features"),
+};
+
+void ast_features_config_shutdown(void)
+{
+	ast_custom_function_unregister(&featuremap_function);
+	ast_custom_function_unregister(&feature_function);
+	ast_cli_unregister_multiple(cli_features_config, ARRAY_LEN(cli_features_config));
+	aco_info_destroy(&cfg_info);
+	ao2_global_obj_release(globals);
+}
+
+int ast_features_config_reload(void)
+{
+	return load_config(1);
+}
+
+int ast_features_config_init(void)
+{
+	int res;
+
+	res = load_config(0);
+	res |= __ast_custom_function_register(&feature_function, NULL);
+	res |= __ast_custom_function_register(&featuremap_function, NULL);
+	res |= ast_cli_register_multiple(cli_features_config, ARRAY_LEN(cli_features_config));
+
+	if (res) {
+		ast_features_config_shutdown();
+	}
+
+	return res;
+}