/* * Asterisk -- An open source telephony toolkit. * * Copyright (C) 2013, Digium, Inc. * * Mark Michelson * * 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" #include "features_config.h" /*** DOCUMENTATION Features Configuration Milliseconds allowed between digit presses when entering a feature code. Sound to play when automon or automixmon is activated Sound to play when automon or automixmon is attempted but fails to start Seconds allowed between digit presses when dialing a transfer destination Seconds to wait for attended transfer destination to answer Hang up the call entirely if the attended transfer fails When this option is set to no, then Asterisk will attempt to re-call the transferrer if the call to the transfer target fails. If the call to the transferrer fails, then Asterisk will wait atxferloopdelay milliseconds and then attempt to dial the transfer target again. This process will repeat until atxfercallbackretries attempts to re-call the transferrer have occurred. When this option is set to yes, then Asterisk will not attempt to re-call the transferrer if the call to the transfer target fails. Asterisk will instead hang up all channels involved in the transfer. Seconds to wait between attempts to re-dial transfer destination

atxferdropcall

Number of times to re-attempt dialing a transfer destination

atxferdropcall

Sound to play to during transfer and transfer-like operations. This sound will play to the transferrer and transfer target channels when an attended transfer completes. This sound is also played to channels when performing an AMI Bridge action. Sound to play to a transferee when a transfer fails Digits to dial to abort an attended transfer attempt This option is only available to the transferrer during an attended transfer operation. Aborting a transfer results in the transfer being cancelled and the original parties in the call being re-bridged. Digits to dial to complete an attended transfer This option is only available to the transferrer during an attended transfer operation. Completing the transfer with a DTMF sequence is functionally equivalent to hanging up the transferrer channel during an attended transfer. The result is that the transfer target and transferees are bridged. Digits to dial to change an attended transfer into a three-way call This option is only available to the transferrer during an attended transfer operation. Pressing this DTMF sequence will result in the transferrer, the transferees, and the transfer target all being in a single bridge together. Digits to dial to toggle who the transferrer is currently bridged to during an attended transfer This option is only available to the transferrer during an attended transfer operation. Pressing this DTMF sequence will result in the transferrer swapping which party he is bridged with. For instance, if the transferrer is currently bridged with the transfer target, then pressing this DTMF sequence will cause the transferrer to be bridged with the transferees. Digits used for picking up ringing calls In order for the pickup attempt to be successful, the party attempting to pick up the call must either have a namedpickupgroup in common with a ringing party's namedcallgroup or must have a pickupgroup in common with a ringing party's callgroup. Sound to play to picker when a call is picked up Sound to play to picker when a call cannot be picked up Number of dial attempts allowed when attempting a transfer Sound that is played when an incorrect extension is dialed and the transferer should try again. Sound that is played when an incorrect extension is dialed and the transferer has no attempts remaining. DTMF options that can be triggered during bridged calls DTMF sequence to initiate an attended transfer The transferee parties will be placed on hold and the transferrer may dial an extension to reach a transfer target. During an attended transfer, the transferrer may consult with the transfer target before completing the transfer. Once the transferrer has hung up or pressed the atxfercomplete DTMF sequence, then the transferees and transfer target will be bridged. DTMF sequence to initiate a blind transfer The transferee parties will be placed on hold and the transferrer may dial an extension to reach a transfer target. During a blind transfer, as soon as the transfer target is dialed, the transferrer is hung up. DTMF sequence to disconnect the current call Entering this DTMF sequence will cause the bridge to end, no matter the number of parties present DTMF sequence to park a call The parking lot used to park the call is determined by using either the PARKINGLOT channel variable or a configured value on the channel (provided by the channel driver) if the variable is not present. If no configured value on the channel is present, then "default" is used. The call is parked in the next available space in the parking lot. DTMF sequence to start or stop monitoring a call This will cause the channel that pressed the DTMF sequence to be monitored by the Monitor application. The format for the recording is determined by the TOUCH_MONITOR_FORMAT channel variable. If this variable is not specified, then wav is the default. The filename is constructed in the following manner: prefix-timestamp-filename where prefix is either the value of the TOUCH_MONITOR_PREFIX channel variable or auto if the variable is not set. The timestamp is a UNIX timestamp. The filename is either the value of the TOUCH_MONITOR channel variable or the callerID of the channels if the variable is not set. DTMF sequence to start or stop mixmonitoring a call Operation of the automixmon is similar to the automon feature, with the following exceptions: TOUCH_MIXMONITOR is used in place of TOUCH_MONITOR TOUCH_MIXMONITOR_FORMAT is used in place of TOUCH_MIXMONITOR There is no equivalent for TOUCH_MONITOR_PREFIX. "auto" is always how the filename begins.

automon

Section for defining custom feature invocations during a call The applicationmap is an area where new custom features can be created. Items defined in the applicationmap are not automatically accessible to bridged parties. Access to the individual items is controled using the DYNAMIC_FEATURES channel variable. The DYNAMIC_FEATURES is a # separated list of either applicationmap item names or featuregroup names. A custom feature to invoke during a bridged call Each item listed here is a comma-separated list of parameters that determine how a feature may be invoked during a call Example: eggs = *5,self,Playback(hello-world),default This would create a feature called eggs that could be invoked during a call by pressing the *5. The party that presses the DTMF sequence would then trigger the Playback application to play the hello-world file. The application invocation would happen on the party that pressed the DTMF sequence since self is specified. The other parties in the bridge would hear the default music on hold class during the playback. In addition to the syntax outlined in this documentation, a backwards-compatible alternative is also allowed. The following applicationmap lines are functionally identical: eggs = *5,self,Playback(hello-world),default eggs = *5,self,Playback,hello-world,default eggs = *5,self,Playback,"hello-world",default The DTMF sequence used to trigger the option The party that the feature will be invoked on The dialplan application to run when the DTMF sequence is pressed The arguments to the dialplan application to run Music on hold class to play to bridge participants that are not the target of the application invocation Groupings of items from the applicationmap Feature groups allow for multiple applicationmap items to be grouped together. Like with individual applicationmap items, feature groups can be part of the DYNAMIC_FEATURES channel variable. In addition to creating groupings, the feature group section allows for the DTMF sequence used to invoke an applicationmap item to be overridden with a different sequence. Applicationmap item to place in the feature group Each item here must be a name of an item in the applicationmap. The argument may either be a new DTMF sequence to use for the item or it may be left blank in order to use the DTMF sequence specified in the applicationmap. For example: eggs => *1 bacon => would result in the applicationmap items eggs and bacon being in the featuregroup. The former would have its default DTMF trigger overridden with *1 and the latter would have the DTMF value specified in the applicationmap. Get or set a feature option on a channel. The allowed values are: Inherit feature settings made in FEATURE or FEATUREMAP to child channels. 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.

FEATUREMAP

Get or set a feature map to a given value on a specific channel. The allowed values are: Attended Transfer Blind Transfer Auto Monitor Call Disconnect Park Call Auto MixMonitor 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.

FEATURE

***/ /*! Default general options */ #define DEFAULT_FEATURE_DIGIT_TIMEOUT 1000 #define DEFAULT_COURTESY_TONE "" #define DEFAULT_RECORDING_FAIL_SOUND "" /*! Default xfer options */ #define DEFAULT_TRANSFER_DIGIT_TIMEOUT 3 #define DEFAULT_NOANSWER_TIMEOUT_ATTENDED_TRANSFER 15 #define DEFAULT_ATXFER_DROP_CALL 0 #define DEFAULT_ATXFER_LOOP_DELAY 10 #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" #define DEFAULT_ATXFER_SWAP "*4" #define DEFAULT_TRANSFER_DIAL_ATTEMPTS 3 #define DEFAULT_TRANSFER_RETRY_SOUND "pbx-invalid" #define DEFAULT_TRANSFER_INVALID_SOUND "privacy-incorrect" /*! 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_REPLACE, group_item_sort, NULL); if (!group->items) { ao2_cleanup(group); return NULL; } return group; } /* Used for deprecated parking configuration */ struct dummy_config { char dummy; }; struct features_config { struct features_global_config *global; struct ast_featuremap_config *featuremap; struct dummy_config *parkinglots; struct ao2_container *applicationmap; struct ao2_container *featuregroups; }; static struct aco_type global_option = { .type = ACO_GLOBAL, .name = "globals", .category_match = ACO_WHITELIST_EXACT, .category = "general", .item_offset = offsetof(struct features_config, global), }; static struct aco_type featuremap_option = { .type = ACO_GLOBAL, .name = "featuremap", .category_match = ACO_WHITELIST_EXACT, .category = "featuremap", .item_offset = offsetof(struct features_config, featuremap), }; static struct aco_type applicationmap_option = { .type = ACO_GLOBAL, .name = "applicationmap", .category_match = ACO_WHITELIST_EXACT, .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 parkinglot_option = { .type = ACO_GLOBAL, .name = "parkinglot", .category_match = ACO_WHITELIST, .category = "^parkinglot_.*$", .item_offset = offsetof(struct features_config, parkinglots), .hidden = 1, }; 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_type *parkinglot_options[] = ACO_TYPES(&parkinglot_option); static struct aco_file features_conf = { .filename = "features.conf", .types = ACO_TYPES(&global_option, &featuremap_option, &applicationmap_option, &featuregroup_option, &parkinglot_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->parkinglots); 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(int replace_duplicates) { return ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, replace_duplicates ? AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE : AO2_CONTAINER_ALLOC_OPT_DUPS_ALLOW, 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; } cfg->parkinglots = ao2_alloc(sizeof(*cfg->parkinglots), NULL); if (!cfg->parkinglots) { return NULL; } if (allocate_applicationmap) { cfg->applicationmap = applicationmap_alloc(1); 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; dest->transferdialattempts = src->transferdialattempts; } 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 * NOTE: This does not apply to the global cfg->applicationmap and cfg->featuresgroups */ } 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 if (!strcasecmp(name, "recordingfailsound")) { ast_string_field_set(general, recordingfailsound, 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 if (!strcasecmp(field, "recordingfailsound")) { ast_copy_string(buf, general->recordingfailsound, 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 if (!strcasecmp(name, "atxferswap")) { ast_string_field_set(xfer, atxferswap, value); } else if (!strcasecmp(name, "transferdialattempts")) { res = ast_parse_arg(value, PARSE_INT32, &xfer->transferdialattempts); } else if (!strcasecmp(name, "transferretrysound")) { ast_string_field_set(xfer, transferretrysound, value); } else if (!strcasecmp(name, "transferinvalidsound")) { ast_string_field_set(xfer, transferinvalidsound, 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 if (!strcasecmp(field, "atxferswap")) { ast_copy_string(buf, xfer->atxferswap, len); } else if (!strcasecmp(field, "transferdialattempts")) { snprintf(buf, len, "%u", xfer->transferdialattempts); } else if (!strcasecmp(field, "transferretrysound")) { ast_copy_string(buf, xfer->transferretrysound, len); } else if (!strcasecmp(field, "transferinvalidsound")) { ast_copy_string(buf, xfer->transferinvalidsound, 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. */ ao2_cleanup(get_feature_ds(chan)); 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; } char *ast_get_chan_features_xferfailsound(struct ast_channel *chan) { char *res; struct ast_features_xfer_config *cfg = ast_get_chan_features_xfer_config(chan); if (!cfg) { return NULL; } res = ast_strdup(cfg->xferfailsound); ao2_ref(cfg, -1); return res; } char *ast_get_chan_features_atxferabort(struct ast_channel *chan) { char *res; struct ast_features_xfer_config *cfg = ast_get_chan_features_xfer_config(chan); if (!cfg) { return NULL; } res = ast_strdup(cfg->atxferabort); ao2_ref(cfg, -1); return res; } 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; } ao2_link(applicationmap, appmap_item); 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(0); if (!applicationmap) { return NULL; } /* global config must be initialized */ ast_assert(cfg->featuregroups != NULL); ast_assert(cfg->applicationmap != 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); } else { ast_log(LOG_WARNING, "Unknown DYNAMIC_FEATURES item '%s' on channel %s.\n", name, ast_channel_name(chan)); } } 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'; } /* Some applications do not require arguments. */ if (!args.app_data) { args.app_data = ""; } /* 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)) { return -1; } 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)) { return -1; } /* 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 parking_warning = 0; static int unsupported_handler(const struct aco_option *opt, struct ast_variable *var, void *obj) { if (!parking_warning) { ast_log(LOG_WARNING, "Parkinglots are no longer configurable in features.conf; " "parking is now handled by res_parking.conf\n"); parking_warning = 1; } ast_log(LOG_WARNING, "The option '%s' is no longer configurable in features.conf.\n", var->name); return 0; } 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. */ /* global config must be initialized */ ast_assert(cfg->featuregroups != NULL); ast_assert(cfg->applicationmap != NULL); ao2_callback_data(cfg->featuregroups, 0, check_featuregroup, &err, cfg->applicationmap); return err; } static int internal_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 internal_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 internal_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 internal_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 int feature_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) { if (!chan) { ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd); return -1; } return internal_feature_read(chan, cmd, data, buf, len); } static int feature_write(struct ast_channel *chan, const char *cmd, char *data, const char *value) { if (!chan) { ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd); return -1; } return internal_feature_write(chan, cmd, data, value); } static int featuremap_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) { if (!chan) { ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd); return -1; } return internal_featuremap_read(chan, cmd, data, buf, len); } static int featuremap_write(struct ast_channel *chan, const char *cmd, char *data, const char *value) { if (!chan) { ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd); return -1; } return internal_featuremap_write(chan, cmd, data, value); } 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(void) { if (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, "recordingfailsound", ACO_EXACT, global_options, DEFAULT_RECORDING_FAIL_SOUND, general_handler, 0); aco_option_register_custom(&cfg_info, "courtesytone", ACO_EXACT, global_options, 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, "atxferswap", ACO_EXACT, global_options, DEFAULT_ATXFER_SWAP, xfer_handler, 0); aco_option_register_custom(&cfg_info, "transferdialattempts", ACO_EXACT, global_options, __stringify(DEFAULT_TRANSFER_DIAL_ATTEMPTS), xfer_handler, 0); aco_option_register_custom(&cfg_info, "transferretrysound", ACO_EXACT, global_options, DEFAULT_TRANSFER_RETRY_SOUND, xfer_handler, 0); aco_option_register_custom(&cfg_info, "transferinvalidsound", ACO_EXACT, global_options, DEFAULT_TRANSFER_INVALID_SOUND, 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_nodoc(&cfg_info, "context", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkext", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkext_exclusive", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkinghints", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkedmusicclass", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkingtime", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkpos", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "findslot", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkedcalltransfers", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkedcallreparking", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkedcallhangup", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkedcallrecording", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "comebackcontext", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "comebacktoorigin", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "comebackdialtime", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "parkeddynamic", ACO_EXACT, global_options, "", unsupported_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "adsipark", ACO_EXACT, global_options, "", unsupported_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_PREFIX, applicationmap_options, "", applicationmap_handler, 0); aco_option_register_custom(&cfg_info, "", ACO_PREFIX, featuregroup_options, "", featuregroup_handler, 0); aco_option_register_custom_nodoc(&cfg_info, "", ACO_PREFIX, parkinglot_options, "", unsupported_handler, 0); if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) { RAII_VAR(struct features_config *, features_cfg, features_config_alloc(), ao2_cleanup); if (aco_set_defaults(&global_option, "general", features_cfg->global) || aco_set_defaults(&featuremap_option, "featuremap", features_cfg->featuremap)) { ast_log(LOG_ERROR, "Failed to load features.conf and failed to initialize defaults.\n"); return -1; } ast_log(LOG_NOTICE, "Could not load features config; using defaults\n"); ao2_global_obj_replace_unref(globals, features_cfg); } 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); } return CLI_SUCCESS; } static struct ast_cli_entry cli_features_config[] = { AST_CLI_DEFINE(handle_feature_show, "Lists configured features"), }; void unload_features_config(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 reload_features_config(void) { /* Rearm the parking config options have moved warning. */ parking_warning = 0; if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) { return -1; } return 0; } int load_features_config(void) { int res; res = load_config(); 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)); return res; }