Asterisk - The Open Source Telephony Project GIT-master-0bf3178
Data Structures | Macros | Functions | Variables
config_options.c File Reference

Configuration Option-handling. More...

#include "asterisk.h"
#include <regex.h>
#include "asterisk/_private.h"
#include "asterisk/config.h"
#include "asterisk/config_options.h"
#include "asterisk/stringfields.h"
#include "asterisk/acl.h"
#include "asterisk/app.h"
#include "asterisk/frame.h"
#include "asterisk/xmldoc.h"
#include "asterisk/cli.h"
#include "asterisk/term.h"
#include "asterisk/format_cap.h"
Include dependency graph for config_options.c:

Go to the source code of this file.

Data Structures

struct  aco_info_internal
 Bits of aco_info that shouldn't be assigned outside this file. More...
 
struct  aco_option
 
struct  aco_type_internal
 

Macros

#define CONFIG_OPT_BUCKETS   53
 
#define XMLDOC_STRICT   1
 

Functions

int __aco_option_register (struct aco_info *info, const char *name, enum aco_matchtype matchtype, struct aco_type **types, const char *default_val, enum aco_option_type kind, aco_option_handler handler, unsigned int flags, unsigned int no_doc, size_t argc,...)
 register a config option More...
 
static int acl_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default handler for ACLs. More...
 
static void aco_deinit (void)
 
void aco_info_destroy (struct aco_info *info)
 Destroy an initialized aco_info struct. More...
 
int aco_info_init (struct aco_info *info)
 Initialize an aco_info structure. More...
 
int aco_init (void)
 
struct ao2_containeraco_option_container_alloc (void)
 Allocate a container to hold config options. More...
 
static struct aco_optionaco_option_find (struct aco_type *type, const char *name)
 
intptr_t aco_option_get_argument (const struct aco_option *option, unsigned int position)
 Get the offset position for an argument within a config option. More...
 
unsigned int aco_option_get_flags (const struct aco_option *option)
 Read the flags of a config option - useful when using a custom callback for a config option. More...
 
int aco_option_register_deprecated (struct aco_info *info, const char *name, struct aco_type **types, const char *aliased_to)
 Register a deprecated (and aliased) config option. More...
 
void * aco_pending_config (struct aco_info *info)
 Get pending config changes. More...
 
enum aco_process_status aco_process_ast_config (struct aco_info *info, struct aco_file *file, struct ast_config *cfg)
 Process config info from an ast_config via options registered with an aco_info. More...
 
int aco_process_category_options (struct aco_type *type, struct ast_config *cfg, const char *cat, void *obj)
 Parse each option defined in a config category. More...
 
enum aco_process_status aco_process_config (struct aco_info *info, int reload)
 Process a config info via the options registered with an aco_info. More...
 
int aco_process_var (struct aco_type *type, const char *cat, struct ast_variable *var, void *obj)
 Parse a single ast_variable and apply it to an object. More...
 
int aco_set_defaults (struct aco_type *type, const char *category, void *obj)
 Set all default options of obj. More...
 
static int apply_config (struct aco_info *info)
 
static aco_option_handler ast_config_option_default_handler (enum aco_option_type type)
 
static int bool_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for bools (ast_true/ast_false) More...
 
static int boolflag_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for bools (ast_true/ast_false) that are stored as flags. More...
 
static regex_t * build_regex (const char *text)
 
static int chararray_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default handler for character arrays. More...
 
static char * cli_show_help (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static void cli_show_module_options (struct ast_cli_args *a)
 
static void cli_show_module_type (struct ast_cli_args *a)
 
static void cli_show_module_types (struct ast_cli_args *a)
 
static void cli_show_modules (struct ast_cli_args *a)
 
static int codec_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for codec preferences/capabilities. More...
 
static char * complete_config_module (const char *word)
 
static char * complete_config_option (const char *module, const char *option, const char *word)
 
static char * complete_config_type (const char *module, const char *word)
 
static int config_opt_cmp (void *obj, void *arg, int flags)
 
static int config_opt_hash (const void *obj, const int flags)
 
static void config_option_destroy (void *obj)
 
static struct ast_strderive_category_text (enum aco_category_op category_match, const char *category)
 
static int double_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for doubles. More...
 
static int find_option_cb (void *obj, void *arg, int flags)
 
static struct ast_xml_doc_itemfind_xmldoc_option (struct ast_xml_doc_item *config_info, struct aco_type **types, const char *name)
 
static struct ast_xml_doc_itemfind_xmldoc_type (struct ast_xml_doc_item *config_info, const char *name)
 
static int int_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for signed integers. More...
 
static int internal_aco_type_category_check (struct aco_type *match, const char *category)
 
static struct aco_typeinternal_aco_type_find (struct aco_file *file, struct ast_config *cfg, const char *category)
 
static void internal_file_types_destroy (struct aco_file *file)
 
static enum aco_process_status internal_process_ast_config (struct aco_info *info, struct aco_file *file, struct ast_config *cfg)
 
static void internal_type_destroy (struct aco_type *type)
 
static int internal_type_init (struct aco_type *type)
 
static int is_preload (struct aco_file *file, const char *cat)
 
static int link_option_to_types (struct aco_info *info, struct aco_type **types, struct aco_option *opt)
 
static int noop_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default handler for doing nothing. More...
 
static int process_category (struct ast_config *cfg, struct aco_info *info, struct aco_file *file, const char *cat, int preload)
 
static int sockaddr_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default handler for ast_sockaddrs. More...
 
static int stringfield_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for stringfields. More...
 
static int timelen_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for timelen signed integers. More...
 
static int uint_handler_fn (const struct aco_option *opt, struct ast_variable *var, void *obj)
 Default option handler for unsigned integers. More...
 
static int xmldoc_update_config_option (struct aco_type **types, const char *module, const char *name, const char *object_name, const char *default_value, unsigned int regex, enum aco_option_type type)
 
static int xmldoc_update_config_type (const char *module, const char *name, const char *category, const char *matchfield, const char *matchvalue, enum aco_category_op category_match)
 

Variables

static char * aco_option_type_string []
 Value of the aco_option_type enum as strings. More...
 
static struct ast_cli_entry cli_aco []
 
static struct ao2_containerxmldocs
 

Detailed Description

Configuration Option-handling.

Author
Terry Wilson twils.nosp@m.on@d.nosp@m.igium.nosp@m..com

Definition in file config_options.c.

Macro Definition Documentation

◆ CONFIG_OPT_BUCKETS

#define CONFIG_OPT_BUCKETS   53

Definition at line 47 of file config_options.c.

◆ XMLDOC_STRICT

#define XMLDOC_STRICT   1

Definition at line 1082 of file config_options.c.

Function Documentation

◆ __aco_option_register()

int __aco_option_register ( struct aco_info info,
const char *  name,
enum aco_matchtype  match_type,
struct aco_type **  types,
const char *  default_val,
enum aco_option_type  type,
aco_option_handler  handler,
unsigned int  flags,
unsigned int  no_doc,
size_t  argc,
  ... 
)

register a config option

Note
this should probably only be called by one of the aco_option_register* macros
Parameters
infoThe aco_info holding this module's config information
nameThe name of the option
match_type
typesAn array of valid option types for matching categories to the correct struct type
default_valThe default value of the option in the same format as defined in a config file
typeThe option type (only for default handlers)
handlerThe handler function for the option (only for non-default types)
flagsa type specific flags, stored in the option and available to the handler
no_docif non-zero, this option should not have documentation
argcThe number for variadic arguments
...field offsets to store for default handlers
Return values
0success
-1failure

Definition at line 300 of file config_options.c.

303{
304 struct aco_option *opt;
305 va_list ap;
306 int tmp;
307
308 /* Custom option types require a handler */
309 if (!handler && kind == OPT_CUSTOM_T) {
310 return -1;
311 }
312
313 if (!(types && types[0])) {
314 return -1;
315 }
316
317 opt = ao2_alloc_options(sizeof(*opt) + argc * sizeof(opt->args[0]),
319 if (!opt) {
320 return -1;
321 }
322
323 if (matchtype == ACO_REGEX && !(opt->name_regex = build_regex(name))) {
324 ao2_ref(opt, -1);
325 return -1;
326 }
327
328 va_start(ap, argc);
329 for (tmp = 0; tmp < argc; tmp++) {
330 opt->args[tmp] = va_arg(ap, size_t);
331 }
332 va_end(ap);
333
334 opt->name = name;
335 opt->match_type = matchtype;
337 opt->type = kind;
338 opt->handler = handler;
339 opt->flags = flags;
340 opt->argc = argc;
341 opt->no_doc = no_doc;
342
343 if (!opt->handler && !(opt->handler = ast_config_option_default_handler(opt->type))) {
344 /* This should never happen */
345 ast_log(LOG_ERROR, "No handler provided, and no default handler exists for type %u\n", opt->type);
346 ao2_ref(opt, -1);
347 return -1;
348 };
349
350 if (link_option_to_types(info, types, opt)) {
351 ao2_ref(opt, -1);
352 return -1;
353 }
354
355 return 0;
356}
#define ast_log
Definition: astobj2.c:42
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition: astobj2.h:367
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition: astobj2.h:404
static int tmp()
Definition: bt_open.c:389
static void config_option_destroy(void *obj)
static int link_option_to_types(struct aco_info *info, struct aco_type **types, struct aco_option *opt)
static regex_t * build_regex(const char *text)
static aco_option_handler ast_config_option_default_handler(enum aco_option_type type)
@ ACO_REGEX
@ OPT_CUSTOM_T
Type for a custom (user-defined) option handler.
static const char name[]
Definition: format_mp3.c:68
#define LOG_ERROR
def info(msg)
regex_t * name_regex
unsigned int no_doc
const char * name
const char * default_val
unsigned int flags
intptr_t args[0]
enum aco_matchtype match_type
aco_option_handler handler
enum aco_option_type type
static void handler(const char *name, int response_code, struct ast_variable *get_params, struct ast_variable *path_vars, struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
Definition: test_ari.c:59

References ACO_REGEX, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, aco_option::argc, aco_option::args, ast_config_option_default_handler(), ast_log, build_regex(), config_option_destroy(), aco_option::default_val, aco_option::flags, aco_option::handler, handler(), sip_to_pjsip::info(), link_option_to_types(), LOG_ERROR, aco_option::match_type, name, aco_option::name, aco_option::name_regex, aco_option::no_doc, OPT_CUSTOM_T, tmp(), and aco_option::type.

Referenced by __ast_sorcery_object_field_register(), and ast_sorcery_object_fields_register().

◆ acl_handler_fn()

static int acl_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default handler for ACLs.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1549 of file config_options.c.

1549 {
1550 struct ast_ha **ha = (struct ast_ha **)(obj + opt->args[0]);
1551 int error = 0;
1552 *ha = ast_append_ha(opt->flags ? "permit" : "deny", var->value, *ha, &error);
1553 return error;
1554}
struct ast_ha * ast_append_ha(const char *sense, const char *stuff, struct ast_ha *path, int *error)
Add a new rule to a list of HAs.
Definition: acl.c:712
#define var
Definition: ast_expr2f.c:605
internal representation of ACL entries In principle user applications would have no need for this,...
Definition: acl.h:51
int error(const char *format,...)
Definition: utils/frame.c:999

References aco_option::args, ast_append_ha(), error(), aco_option::flags, and var.

Referenced by ast_config_option_default_handler().

◆ aco_deinit()

static void aco_deinit ( void  )
static

Definition at line 1421 of file config_options.c.

1422{
1425}
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
int ast_cli_unregister(struct ast_cli_entry *e)
Unregisters a command or an array of commands.
Definition: main/cli.c:2439
static struct ao2_container * xmldocs
static struct ast_cli_entry cli_aco[]

References ao2_cleanup, ast_cli_unregister(), cli_aco, and xmldocs.

Referenced by aco_init().

◆ aco_info_destroy()

void aco_info_destroy ( struct aco_info info)

Destroy an initialized aco_info struct.

Parameters
infoThe address of the aco_info struct to destroy

Definition at line 910 of file config_options.c.

911{
912 int x;
913 /* It shouldn't be possible for internal->pending to be in use when this is called because
914 * of the locks in loader.c around reloads and unloads and the fact that internal->pending
915 * only exists while those locks are held */
916 ast_free(info->internal);
917 info->internal = NULL;
918
919 for (x = 0; info->files[x]; x++) {
921 }
922}
#define ast_free(a)
Definition: astmm.h:180
static void internal_file_types_destroy(struct aco_file *file)
#define NULL
Definition: resample.c:96

References ast_free, sip_to_pjsip::info(), internal_file_types_destroy(), and NULL.

Referenced by aco_info_init(), ast_ari_config_destroy(), ast_ari_config_init(), AST_TEST_DEFINE(), cdr_engine_shutdown(), conf_destroy_config(), destroy_config(), load_module(), sorcery_object_type_destructor(), stasis_cleanup(), unload_features_config(), and unload_module().

◆ aco_info_init()

int aco_info_init ( struct aco_info info)

Initialize an aco_info structure.

Note
aco_info_destroy must be called if this succeeds
Parameters
infoThe address of an aco_info struct to initialize
Return values
0Success
non-zeroFailure

Definition at line 877 of file config_options.c.

878{
879 size_t x = 0, y = 0;
880 struct aco_file *file;
881 struct aco_type *type;
882
883 if (!(info->internal = ast_calloc(1, sizeof(*info->internal)))) {
884 return -1;
885 }
886
887 while ((file = info->files[x++])) {
888 while ((type = file->types[y++])) {
890 goto error;
891 }
892#ifdef AST_XML_DOCS
893 if (!info->hidden &&
894 !type->hidden &&
895 type->type != ACO_IGNORE &&
896 xmldoc_update_config_type(info->module, type->name, type->category, type->matchfield, type->matchvalue, type->category_match)) {
897 goto error;
898 }
899#endif /* AST_XML_DOCS */
900 }
901 y = 0;
902 }
903
904 return 0;
905error:
907 return -1;
908}
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
static const char type[]
Definition: chan_ooh323.c:109
void aco_info_destroy(struct aco_info *info)
Destroy an initialized aco_info struct.
static int internal_type_init(struct aco_type *type)
static int xmldoc_update_config_type(const char *module, const char *name, const char *category, const char *matchfield, const char *matchvalue, enum aco_category_op category_match)
@ ACO_IGNORE
The representation of a single configuration file to be processed.
Type information about a category-level configurable object.

References ACO_IGNORE, aco_info_destroy(), ast_calloc, error(), make_ari_stubs::file, sip_to_pjsip::info(), internal_type_init(), type, and xmldoc_update_config_type().

Referenced by __ast_sorcery_object_register(), ast_ari_config_init(), AST_TEST_DEFINE(), conf_load_config(), load_config(), load_module(), process_config(), and stasis_init().

◆ aco_init()

int aco_init ( void  )

Provided by config_options.c

Definition at line 1428 of file config_options.c.

1429{
1430#ifdef AST_XML_DOCS
1432 if (!(xmldocs = ast_xmldoc_build_documentation("configInfo"))) {
1433 ast_log(LOG_ERROR, "Couldn't build config documentation\n");
1434 return -1;
1435 }
1437#endif /* AST_XML_DOCS */
1438 return 0;
1439}
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
static void aco_deinit(void)
#define ARRAY_LEN(a)
Definition: utils.h:666
struct ao2_container * ast_xmldoc_build_documentation(const char *type)
Build the documentation for a particular source type.
Definition: xmldoc.c:2684

References aco_deinit(), ARRAY_LEN, ast_cli_register_multiple, ast_log, ast_register_cleanup(), ast_xmldoc_build_documentation(), cli_aco, LOG_ERROR, and xmldocs.

Referenced by asterisk_daemon().

◆ aco_option_container_alloc()

struct ao2_container * aco_option_container_alloc ( void  )

Allocate a container to hold config options.

Definition at line 406 of file config_options.c.

407{
410}
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
#define CONFIG_OPT_BUCKETS
static int config_opt_hash(const void *obj, const int flags)
static int config_opt_cmp(void *obj, void *arg, int flags)

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, CONFIG_OPT_BUCKETS, config_opt_cmp(), config_opt_hash(), and NULL.

Referenced by internal_type_init().

◆ aco_option_find()

static struct aco_option * aco_option_find ( struct aco_type type,
const char *  name 
)
static

Definition at line 389 of file config_options.c.

390{
391 struct aco_option *opt;
392
393 if (!type || !type->internal || !type->internal->opts) {
394 ast_log(LOG_NOTICE, "Attempting to use NULL or unitialized config type\n");
395 return NULL;
396 }
397
398 /* Try an exact match with OBJ_KEY for the common/fast case, then iterate through
399 * all options for the regex cases */
400 if (!(opt = ao2_callback(type->internal->opts, OBJ_KEY, find_option_cb, (void *) name))) {
401 opt = ao2_callback(type->internal->opts, 0, find_option_cb, (void *) name);
402 }
403 return opt;
404}
#define OBJ_KEY
Definition: astobj2.h:1151
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition: astobj2.h:1693
static int find_option_cb(void *obj, void *arg, int flags)
#define LOG_NOTICE

References ao2_callback, ast_log, find_option_cb(), LOG_NOTICE, name, NULL, OBJ_KEY, and type.

Referenced by aco_process_var().

◆ aco_option_get_argument()

intptr_t aco_option_get_argument ( const struct aco_option option,
unsigned int  position 
)

Get the offset position for an argument within a config option.

Parameters
optionPointer to the aco_option struct
positionArgument number
Return values
positionof the argument

Definition at line 248 of file config_options.c.

249{
250 return option->args[position];
251}

References aco_option::args.

Referenced by timeval_str2struct().

◆ aco_option_get_flags()

unsigned int aco_option_get_flags ( const struct aco_option option)

Read the flags of a config option - useful when using a custom callback for a config option.

Since
12
Parameters
optionPointer to the aco_option struct
Return values
valueof the flags on the config option

Definition at line 243 of file config_options.c.

244{
245 return option->flags;
246}

References aco_option::flags.

Referenced by option_handler_parkedfeature().

◆ aco_option_register_deprecated()

int aco_option_register_deprecated ( struct aco_info info,
const char *  name,
struct aco_type **  types,
const char *  aliased_to 
)

Register a deprecated (and aliased) config option.

Parameters
infoA pointer to the aco_info struct
nameThe name of the deprecated option
typesAn array of valid option types for matching categories to the correct struct type
aliased_toThe name of the option that this deprecated option matches to
Return values
0Success
-1Failure

Definition at line 217 of file config_options.c.

218{
219 struct aco_option *opt;
220
222 return -1;
223 }
224
226 if (!opt) {
227 return -1;
228 }
229
230 opt->name = name;
231 opt->aliased_to = aliased_to;
232 opt->deprecated = 1;
233 opt->match_type = ACO_EXACT;
234
235 if (link_option_to_types(info, types, opt)) {
236 ao2_ref(opt, -1);
237 return -1;
238 }
239
240 return 0;
241}
@ ACO_EXACT
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
unsigned char deprecated
const char * aliased_to

References ACO_EXACT, aco_option::aliased_to, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_strlen_zero(), config_option_destroy(), aco_option::deprecated, sip_to_pjsip::info(), link_option_to_types(), aco_option::match_type, name, and aco_option::name.

Referenced by AST_TEST_DEFINE().

◆ aco_pending_config()

void * aco_pending_config ( struct aco_info info)

Get pending config changes.

Note
This will most likely be called from the pre_apply_config callback function
Parameters
infoAn initialized aco_info
Return values
NULLerror
non-NULLA pointer to the user-defined config object with un-applied changes

Definition at line 103 of file config_options.c.

104{
105 if (!(info && info->internal)) {
106 ast_log(LOG_ERROR, "This may not be called without an initialized aco_info!\n");
107 return NULL;
108 }
109 return info->internal->pending;
110}

References ast_log, sip_to_pjsip::info(), LOG_ERROR, and NULL.

Referenced by cel_pre_apply_config(), configure_parking_extensions(), features_pre_apply_config(), hepv3_config_pre_apply(), http_media_cache_config_pre_apply(), prometheus_config_pre_apply(), udptl_pre_apply_config(), unbound_config_preapply_callback(), verify_default_parking_lot(), and verify_default_profiles().

◆ aco_process_ast_config()

enum aco_process_status aco_process_ast_config ( struct aco_info info,
struct aco_file file,
struct ast_config cfg 
)

Process config info from an ast_config via options registered with an aco_info.

Parameters
infoThe aco_info to be used for handling the config
fileThe file attached to aco_info that the config represents
cfgA pointer to a loaded ast_config to parse
Return values
ACO_PROCESS_OKSuccess
ACO_PROCESS_ERRORFailure

Definition at line 617 of file config_options.c.

618{
619 if (!info->internal) {
620 ast_log(LOG_ERROR, "Attempt to process %s with uninitialized aco_info\n", file->filename);
621 return ACO_PROCESS_ERROR;
622 }
623
624 if (!(info->internal->pending = info->snapshot_alloc())) {
625 ast_log(LOG_ERROR, "In %s: Could not allocate temporary objects\n", file->filename);
626 goto error;
627 }
628
630 goto error;
631 }
632
633 if (info->pre_apply_config && info->pre_apply_config()) {
634 goto error;
635 }
636
637 if (apply_config(info)) {
638 goto error;
639 };
640
641 ao2_cleanup(info->internal->pending);
642 info->internal->pending = NULL;
643 return ACO_PROCESS_OK;
644
645error:
646 ao2_cleanup(info->internal->pending);
647 info->internal->pending = NULL;
648
649 return ACO_PROCESS_ERROR;
650}
static int apply_config(struct aco_info *info)
static enum aco_process_status internal_process_ast_config(struct aco_info *info, struct aco_file *file, struct ast_config *cfg)
@ ACO_PROCESS_ERROR
Their was an error and no changes were applied.
@ ACO_PROCESS_OK
The config was processed and applied.

References ACO_PROCESS_ERROR, ACO_PROCESS_OK, ao2_cleanup, apply_config(), ast_log, error(), make_ari_stubs::file, sip_to_pjsip::info(), internal_process_ast_config(), LOG_ERROR, and NULL.

◆ aco_process_category_options()

int aco_process_category_options ( struct aco_type type,
struct ast_config cfg,
const char *  cat,
void *  obj 
)

Parse each option defined in a config category.

Parameters
typeThe aco_type with the options for parsing
cfgThe ast_config being parsed
catThe config category being parsed
objThe user-defined config object that will store the parsed config items
Return values
0Success
-1Failure

Definition at line 805 of file config_options.c.

806{
807 struct ast_variable *var;
808
809 for (var = ast_variable_browse(cfg, cat); var; var = var->next) {
810 if (aco_process_var(type, cat, var, obj)) {
811 return -1;
812 }
813 }
814
815 return 0;
816}
int aco_process_var(struct aco_type *type, const char *cat, struct ast_variable *var, void *obj)
Parse a single ast_variable and apply it to an object.
struct ast_variable * ast_variable_browse(const struct ast_config *config, const char *category_name)
Definition: extconf.c:1215
Structure for variables, used for configurations and for channel variables.

References aco_process_var(), ast_variable_browse(), type, and var.

Referenced by process_category().

◆ aco_process_config()

enum aco_process_status aco_process_config ( struct aco_info info,
int  reload 
)

Process a config info via the options registered with an aco_info.

Parameters
infoThe config_options_info to be used for handling the config
reloadNon-zero if this is for a reload.
Return values
ACO_PROCESS_OKSuccess
ACO_PROCESS_ERRORFailure
ACO_PROCESS_UNCHANGEDNo change due to unedited config file

Definition at line 652 of file config_options.c.

653{
654 struct ast_config *cfg;
655 struct ast_flags cfg_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0, };
656 int res = ACO_PROCESS_OK;
657 int file_count = 0;
658 struct aco_file *file;
659
660 if (!info->internal) {
661 ast_log(LOG_ERROR, "Attempting to process uninitialized aco_info\n");
662 return ACO_PROCESS_ERROR;
663 }
664
665 if (!(info->files[0])) {
666 ast_log(LOG_ERROR, "No filename given, cannot proceed!\n");
667 return ACO_PROCESS_ERROR;
668 }
669
670 if (!(info->internal->pending = info->snapshot_alloc())) {
671 ast_log(LOG_ERROR, "In %s: Could not allocate temporary objects\n", info->module);
672 return ACO_PROCESS_ERROR;
673 }
674
675 while (res != ACO_PROCESS_ERROR && (file = info->files[file_count++])) {
676 const char *filename = file->filename;
677 struct aco_type *match;
678 int i;
679
680 /* set defaults for global objects */
681 for (i = 0, match = file->types[i]; match; match = file->types[++i]) {
682 void **field = info->internal->pending + match->item_offset;
683
684 if (match->type == ACO_IGNORE) {
685 continue;
686 }
687
688 if (match->type != ACO_GLOBAL || !*field) {
689 continue;
690 }
691
692 if (aco_set_defaults(match, match->category, *field)) {
693 ast_log(LOG_ERROR, "In %s: Setting defaults for %s failed\n", file->filename, match->category);
694 res = ACO_PROCESS_ERROR;
695 break;
696 }
697 }
698
699 if (res == ACO_PROCESS_ERROR) {
700 break;
701 }
702
703try_alias:
704 cfg = ast_config_load(filename, cfg_flags);
705 if (!cfg || cfg == CONFIG_STATUS_FILEMISSING) {
706 if (file->alias && strcmp(file->alias, filename)) {
707 filename = file->alias;
708 goto try_alias;
709 }
710 ast_log(LOG_ERROR, "Unable to load config file '%s'\n", file->filename);
711 res = ACO_PROCESS_ERROR;
712 break;
713 } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
714 ast_debug(1, "%s was unchanged\n", file->filename);
716 continue;
717 } else if (cfg == CONFIG_STATUS_FILEINVALID) {
718 ast_log(LOG_ERROR, "Contents of %s are invalid and cannot be parsed\n",
719 file->filename);
720 res = ACO_PROCESS_ERROR;
721 break;
722 }
723
724 /* A file got loaded. */
725 if (reload) {
726 /* Must do any subsequent file loads unconditionally. */
727 reload = 0;
729
730 if (file_count != 1) {
731 /*
732 * Must restart loading to load all config files since a file
733 * after the first one changed.
734 */
735 file_count = 0;
736 } else {
738 }
739 } else {
741 }
743 }
744
745 if (res != ACO_PROCESS_OK) {
746 goto end;
747 }
748
749 if (info->pre_apply_config && info->pre_apply_config()) {
750 res = ACO_PROCESS_ERROR;
751 goto end;
752 }
753
754 if (apply_config(info)) {
755 res = ACO_PROCESS_ERROR;
756 goto end;
757 }
758
759 if (info->post_apply_config) {
760 info->post_apply_config();
761 }
762
763end:
764 ao2_cleanup(info->internal->pending);
765 info->internal->pending = NULL;
766
767 return res;
768}
static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
Definition: chan_iax2.c:2362
int aco_set_defaults(struct aco_type *type, const char *category, void *obj)
Set all default options of obj.
@ ACO_PROCESS_UNCHANGED
The config had not been edited and no changes applied.
@ ACO_GLOBAL
char * end
Definition: eagi_proxy.c:73
#define ast_config_load(filename, flags)
Load a config file.
#define CONFIG_STATUS_FILEMISSING
#define CONFIG_STATUS_FILEUNCHANGED
#define CONFIG_STATUS_FILEINVALID
void ast_config_destroy(struct ast_config *cfg)
Destroys a config.
Definition: extconf.c:1289
@ CONFIG_FLAG_FILEUNCHANGED
#define ast_debug(level,...)
Log a DEBUG message.
static int reload(void)
const char * filename
Structure used to handle boolean flags.
Definition: utils.h:199
#define ast_clear_flag(p, flag)
Definition: utils.h:77

References ACO_GLOBAL, ACO_IGNORE, ACO_PROCESS_ERROR, ACO_PROCESS_OK, ACO_PROCESS_UNCHANGED, aco_set_defaults(), ao2_cleanup, apply_config(), ast_clear_flag, ast_config_destroy(), ast_config_load, ast_debug, ast_log, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, end, make_ari_stubs::file, aco_file::filename, sip_to_pjsip::info(), internal_process_ast_config(), LOG_ERROR, match(), NULL, and reload().

Referenced by __ast_udptl_reload(), AST_TEST_DEFINE(), conf_load_config(), conf_reload_config(), load_config(), load_module(), process_config(), reload(), reload_features_config(), reload_module(), and stasis_init().

◆ aco_process_var()

int aco_process_var ( struct aco_type type,
const char *  cat,
struct ast_variable var,
void *  obj 
)

Parse a single ast_variable and apply it to an object.

Note
This function can be used to build up an object by repeatedly passing in the config variable name and values that would be found in a config file. This can be useful if the object is to be populated by a dialplan function, for example.
Parameters
typeThe aco_type associated with the object
catThe category to use
varA variable to apply to the object
objA pointer to the object to be configured
Return values
0Success
-1Failure

Definition at line 769 of file config_options.c.

770{
771 RAII_VAR(struct aco_option *, opt, aco_option_find(type, var->name), ao2_cleanup);
772 if (opt && opt->deprecated && !ast_strlen_zero(opt->aliased_to)) {
773 const char *alias = ast_strdupa(opt->aliased_to);
774 ast_log(LOG_WARNING, "At line %d of %s option '%s' is deprecated. Use '%s' instead\n", var->lineno, var->file, var->name, alias);
775 ao2_ref(opt, -1);
776 opt = aco_option_find(type, alias);
777 }
778
779 if (!opt) {
780 ast_log(LOG_ERROR, "Could not find option suitable for category '%s' named '%s' at line %d of %s\n", cat, var->name, var->lineno, var->file);
781 return -1;
782 }
783
784 if (!opt->handler) {
785 /* It should be impossible for an option to not have a handler */
786 ast_log(LOG_ERROR, "BUG! Somehow a config option for %s/%s was created with no handler!\n", cat, var->name);
787 return -1;
788 }
789
790#ifdef AST_DEVMODE
791 if (opt->doc_unavailable) {
792 ast_log(LOG_ERROR, "Config option '%s' of type '%s' is not completely documented and can not be set\n", var->name, type->name);
793 return -1;
794 }
795#endif
796
797 if (opt->handler(opt, var, obj)) {
798 ast_log(LOG_ERROR, "Error parsing %s=%s at line %d of %s\n", var->name, var->value, var->lineno, var->file);
799 return -1;
800 }
801
802 return 0;
803}
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
static struct aco_option * aco_option_find(struct aco_type *type, const char *name)
#define LOG_WARNING
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941

References aco_option_find(), ao2_cleanup, ao2_ref, ast_log, ast_strdupa, ast_strlen_zero(), LOG_ERROR, LOG_WARNING, RAII_VAR, type, and var.

Referenced by aco_process_category_options(), ast_sorcery_objectset_apply(), and func_confbridge_helper().

◆ aco_set_defaults()

int aco_set_defaults ( struct aco_type type,
const char *  category,
void *  obj 
)

Set all default options of obj.

Parameters
typeThe aco_type with the options
categoryThe configuration category from which obj is being configured
objThe object being configured
Return values
0Success
-1Failure

Definition at line 924 of file config_options.c.

925{
926 struct aco_option *opt;
927 struct ao2_iterator iter;
928
929 if (!type->internal) {
930 return -1;
931 }
932
933 iter = ao2_iterator_init(type->internal->opts, 0);
934
935 while ((opt = ao2_iterator_next(&iter))) {
937
938 if (ast_strlen_zero(opt->default_val)) {
939 ao2_ref(opt, -1);
940 continue;
941 }
942 if (!(var = ast_variable_new(opt->name, opt->default_val, ""))) {
943 ao2_ref(opt, -1);
945 return -1;
946 }
947 if (opt->handler(opt, var, obj)) {
948 ast_log(LOG_ERROR, "Unable to set default for %s, %s=%s\n", category, var->name, var->value);
949 ao2_ref(opt, -1);
951 return -1;
952 }
953 ao2_ref(opt, -1);
954 }
956
957 return 0;
958}
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
#define ast_variable_new(name, value, filename)
void ast_variables_destroy(struct ast_variable *var)
Free variable list.
Definition: extconf.c:1262
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, ast_strlen_zero(), ast_variable_new, ast_variables_destroy(), aco_option::default_val, aco_option::handler, LOG_ERROR, aco_option::name, NULL, RAII_VAR, type, and var.

Referenced by __ast_udptl_reload(), aco_process_config(), ast_sorcery_alloc(), conf_alloc(), load_config(), load_module(), process_category(), process_config(), stasis_init(), unbound_config_apply_default(), verify_default_parking_lot(), and verify_default_profiles().

◆ apply_config()

static int apply_config ( struct aco_info info)
static

Definition at line 589 of file config_options.c.

590{
591 ao2_global_obj_replace_unref(*info->global_obj, info->internal->pending);
592
593 return 0;
594}
#define ao2_global_obj_replace_unref(holder, obj)
Replace an ao2 object in the global holder, throwing away any old object.
Definition: astobj2.h:901

References ao2_global_obj_replace_unref, and sip_to_pjsip::info().

Referenced by aco_process_ast_config(), aco_process_config(), load_module(), and unload_module().

◆ ast_config_option_default_handler()

static aco_option_handler ast_config_option_default_handler ( enum aco_option_type  type)
static

Definition at line 139 of file config_options.c.

140{
141 switch(type) {
142 case OPT_ACL_T: return acl_handler_fn;
143 case OPT_BOOL_T: return bool_handler_fn;
144 /* Reading from config files, BOOL and YESNO are handled exactly the
145 * same. Their difference is in how they are rendered to users
146 */
147 case OPT_YESNO_T: return bool_handler_fn;
150 case OPT_CODEC_T: return codec_handler_fn;
151 case OPT_DOUBLE_T: return double_handler_fn;
152 case OPT_INT_T: return int_handler_fn;
153 case OPT_NOOP_T: return noop_handler_fn;
156 case OPT_UINT_T: return uint_handler_fn;
158
159 case OPT_CUSTOM_T: return NULL;
160 }
161
162 return NULL;
163}
static int chararray_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default handler for character arrays.
static int sockaddr_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default handler for ast_sockaddrs.
static int stringfield_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for stringfields.
static int codec_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for codec preferences/capabilities.
static int boolflag_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for bools (ast_true/ast_false) that are stored as flags.
static int timelen_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for timelen signed integers.
static int uint_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for unsigned integers.
static int double_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for doubles.
static int bool_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for bools (ast_true/ast_false)
static int acl_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default handler for ACLs.
static int noop_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default handler for doing nothing.
static int int_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj)
Default option handler for signed integers.
@ OPT_UINT_T
Type for default option handler for unsigned integers.
@ OPT_NOOP_T
Type for a default handler that should do nothing.
@ OPT_CODEC_T
Type for default option handler for format capabilities.
@ OPT_BOOL_T
Type for default option handler for bools (ast_true/ast_false)
@ OPT_BOOLFLAG_T
Type for default option handler for bools (ast_true/ast_false) that are stored in a flag.
@ OPT_CHAR_ARRAY_T
Type for default option handler for character array strings.
@ OPT_ACL_T
Type for default option handler for ACLs.
@ OPT_SOCKADDR_T
Type for default handler for ast_sockaddrs.
@ OPT_YESNO_T
Type for default option handler for bools (ast_true/ast_false)
@ OPT_INT_T
Type for default option handler for signed integers.
@ OPT_TIMELEN_T
Type for default option handler for time length signed integers.
@ OPT_DOUBLE_T
Type for default option handler for doubles.
@ OPT_STRINGFIELD_T
Type for default option handler for stringfields.

References acl_handler_fn(), bool_handler_fn(), boolflag_handler_fn(), chararray_handler_fn(), codec_handler_fn(), double_handler_fn(), int_handler_fn(), noop_handler_fn(), NULL, OPT_ACL_T, OPT_BOOL_T, OPT_BOOLFLAG_T, OPT_CHAR_ARRAY_T, OPT_CODEC_T, OPT_CUSTOM_T, OPT_DOUBLE_T, OPT_INT_T, OPT_NOOP_T, OPT_SOCKADDR_T, OPT_STRINGFIELD_T, OPT_TIMELEN_T, OPT_UINT_T, OPT_YESNO_T, sockaddr_handler_fn(), stringfield_handler_fn(), timelen_handler_fn(), type, and uint_handler_fn().

Referenced by __aco_option_register().

◆ bool_handler_fn()

static int bool_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for bools (ast_true/ast_false)

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1586 of file config_options.c.

1587{
1588 unsigned int *field = (unsigned int *)(obj + opt->args[0]);
1589 *field = opt->flags ? ast_true(var->value) : ast_false(var->value);
1590 return 0;
1591}
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition: utils.c:2199
int attribute_pure ast_false(const char *val)
Make sure something is false. Determine if a string containing a boolean value is "false"....
Definition: utils.c:2216
int value
Definition: syslog.c:37

References aco_option::args, ast_false(), ast_true(), aco_option::flags, and var.

Referenced by ast_config_option_default_handler().

◆ boolflag_handler_fn()

static int boolflag_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for bools (ast_true/ast_false) that are stored as flags.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1597 of file config_options.c.

1598{
1599 unsigned int *flags_field = (unsigned int *)(obj + opt->args[0]);
1600 unsigned int val = opt->flags ? ast_true(var->value) : ast_false(var->value);
1601 unsigned int flag = opt->args[1];
1602 if (val) {
1603 *flags_field |= flag;
1604 } else {
1605 *flags_field &= ~flag;
1606 }
1607 return 0;
1608}
long int flag
Definition: f2c.h:83
Definition: ast_expr2.c:325

References aco_option::args, ast_false(), ast_true(), aco_option::flags, and var.

Referenced by ast_config_option_default_handler().

◆ build_regex()

static regex_t * build_regex ( const char *  text)
static

Definition at line 165 of file config_options.c.

166{
167 int res;
168 regex_t *regex;
169
170 if (!(regex = ast_malloc(sizeof(*regex)))) {
171 return NULL;
172 }
173
174 if ((res = regcomp(regex, text, REG_EXTENDED | REG_ICASE | REG_NOSUB))) {
175 size_t len = regerror(res, regex, NULL, 0);
176 char buf[len];
177 regerror(res, regex, buf, len);
178 ast_log(LOG_ERROR, "Could not compile regex '%s': %s\n", text, buf);
180 return NULL;
181 }
182
183 return regex;
184}
char * text
Definition: app_queue.c:1668
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
static int regex(struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)

References ast_free, ast_log, ast_malloc, buf, len(), LOG_ERROR, NULL, regex(), and text.

Referenced by __aco_option_register(), internal_type_init(), and process_category().

◆ chararray_handler_fn()

static int chararray_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default handler for character arrays.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1631 of file config_options.c.

1632{
1633 char *field = (char *)(obj + opt->args[0]);
1634 size_t len = opt->args[1];
1635
1636 if (opt->flags && ast_strlen_zero(var->value)) {
1637 return -1;
1638 }
1639 ast_copy_string(field, var->value, len);
1640 return 0;
1641}
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425

References aco_option::args, ast_copy_string(), ast_strlen_zero(), aco_option::flags, len(), and var.

Referenced by ast_config_option_default_handler().

◆ cli_show_help()

static char * cli_show_help ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
)
static

Definition at line 1361 of file config_options.c.

1362{
1363 switch (cmd) {
1364 case CLI_INIT:
1365 e->command = "config show help";
1366 e->usage =
1367 "Usage: config show help [<module> [<type> [<option>]]]\n"
1368 " Display detailed information about module configuration.\n"
1369 " * If nothing is specified, the modules that have\n"
1370 " configuration information are listed.\n"
1371 " * If <module> is specified, the configuration types\n"
1372 " for that module will be listed, along with brief\n"
1373 " information about that type.\n"
1374 " * If <module> and <type> are specified, detailed\n"
1375 " information about the type is displayed, as well\n"
1376 " as the available options.\n"
1377 " * If <module>, <type>, and <option> are specified,\n"
1378 " detailed information will be displayed about that\n"
1379 " option.\n"
1380 " NOTE: the help documentation is partially generated at run\n"
1381 " time when a module is loaded. If a module is not loaded,\n"
1382 " configuration help for that module may be incomplete.\n";
1383 return NULL;
1384 case CLI_GENERATE:
1385 switch(a->pos) {
1386 case 3:
1387 return complete_config_module(a->word);
1388 case 4:
1389 return complete_config_type(a->argv[3], a->word);
1390 case 5:
1391 return complete_config_option(a->argv[3], a->argv[4], a->word);
1392 default:
1393 return NULL;
1394 }
1395 }
1396
1397 switch (a->argc) {
1398 case 3:
1400 break;
1401 case 4:
1403 break;
1404 case 5:
1406 break;
1407 case 6:
1409 break;
1410 default:
1411 return CLI_SHOWUSAGE;
1412 }
1413
1414 return CLI_SUCCESS;
1415}
#define CLI_SHOWUSAGE
Definition: cli.h:45
#define CLI_SUCCESS
Definition: cli.h:44
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
static void cli_show_modules(struct ast_cli_args *a)
static char * complete_config_module(const char *word)
static void cli_show_module_types(struct ast_cli_args *a)
static char * complete_config_option(const char *module, const char *option, const char *word)
static void cli_show_module_options(struct ast_cli_args *a)
static char * complete_config_type(const char *module, const char *word)
static void cli_show_module_type(struct ast_cli_args *a)
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
static struct test_val a

References a, CLI_GENERATE, CLI_INIT, cli_show_module_options(), cli_show_module_type(), cli_show_module_types(), cli_show_modules(), CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_config_module(), complete_config_option(), complete_config_type(), NULL, and ast_cli_entry::usage.

◆ cli_show_module_options()

static void cli_show_module_options ( struct ast_cli_args a)
static

Definition at line 1318 of file config_options.c.

1319{
1321 struct ast_xml_doc_item *tmp;
1322 char option_name[64];
1323 int match = 0;
1324
1325 ast_assert(a->argc == 6);
1326
1327 if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) {
1328 ast_cli(a->fd, "Unknown module %s\n", a->argv[3]);
1329 return;
1330 }
1331 tmp = item;
1332 while ((tmp = AST_LIST_NEXT(tmp, next))) {
1333 if (!strcasecmp(tmp->type, "configOption") && !strcasecmp(tmp->ref, a->argv[4]) && !strcasecmp(tmp->name, a->argv[5])) {
1334 if (match) {
1335 ast_cli(a->fd, "\n");
1336 }
1337 term_color(option_name, tmp->ref, COLOR_MAGENTA, COLOR_BLACK, sizeof(option_name));
1338 ast_cli(a->fd, "[%s%s]\n", option_name, ast_term_reset());
1339 if (ast_str_strlen(tmp->syntax)) {
1340 ast_cli(a->fd, "%s\n", ast_xmldoc_printable(ast_str_buffer(tmp->syntax), 1));
1341 }
1342 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(AS_OR(tmp->synopsis, "No information available"), 1));
1343 if (ast_str_strlen(tmp->description)) {
1344 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->description), 1));
1345 }
1346
1347 if (ast_str_strlen(tmp->seealso)) {
1348 ast_cli(a->fd, "See Also:\n");
1349 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->seealso), 1));
1350 }
1351
1352 match = 1;
1353 }
1354 }
1355
1356 if (!match) {
1357 ast_cli(a->fd, "No option %s found for %s:%s\n", a->argv[5], a->argv[3], a->argv[4]);
1358 }
1359}
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
Definition: linkedlists.h:439
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761
size_t ast_str_strlen(const struct ast_str *buf)
Returns the current length of the string stored within buf.
Definition: strings.h:730
#define AS_OR(a, b)
Definition: strings.h:49
Struct that contains the XML documentation for a particular item. Note that this is an ao2 ref counte...
Definition: xmldoc.h:56
struct ast_xml_doc_item * next
Definition: xmldoc.h:80
const char * ast_term_reset(void)
Returns the terminal reset code.
Definition: term.c:357
#define COLOR_MAGENTA
Definition: term.h:60
#define COLOR_BLACK
Definition: term.h:50
char * term_color(char *outbuf, const char *inbuf, int fgcolor, int bgcolor, int maxout)
Colorize a specified string by adding terminal color codes.
Definition: term.c:235
static struct aco_type item
Definition: test_config.c:1463
#define ast_assert(a)
Definition: utils.h:739
char * ast_xmldoc_printable(const char *bwinput, int withcolors)
Colorize and put delimiters (instead of tags) to the xmldoc output.
Definition: xmldoc.c:241

References a, ao2_cleanup, ao2_find, AS_OR, ast_assert, ast_cli(), AST_LIST_NEXT, ast_str_buffer(), ast_str_strlen(), ast_term_reset(), ast_xmldoc_printable(), COLOR_BLACK, COLOR_MAGENTA, item, match(), ast_xml_doc_item::next, NULL, OBJ_KEY, RAII_VAR, term_color(), tmp(), and xmldocs.

Referenced by cli_show_help().

◆ cli_show_module_type()

static void cli_show_module_type ( struct ast_cli_args a)
static

Definition at line 1266 of file config_options.c.

1267{
1269 struct ast_xml_doc_item *tmp;
1270 char option_type[64];
1271 int match = 0;
1272
1273 ast_assert(a->argc == 5);
1274
1275 if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) {
1276 ast_cli(a->fd, "Unknown module %s\n", a->argv[3]);
1277 return;
1278 }
1279
1280 tmp = item;
1281 while ((tmp = AST_LIST_NEXT(tmp, next))) {
1282 if (!strcasecmp(tmp->type, "configObject") && !strcasecmp(tmp->name, a->argv[4])) {
1283 match = 1;
1284 term_color(option_type, tmp->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(option_type));
1285 ast_cli(a->fd, "%s", option_type);
1286 if (ast_str_strlen(tmp->syntax)) {
1287 ast_cli(a->fd, ": [%s]\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->syntax), 1));
1288 } else {
1289 ast_cli(a->fd, "\n\n");
1290 }
1291 if (ast_str_strlen(tmp->synopsis)) {
1292 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->synopsis), 1));
1293 }
1294 if (ast_str_strlen(tmp->description)) {
1295 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->description), 1));
1296 }
1297 }
1298 }
1299
1300 if (!match) {
1301 ast_cli(a->fd, "Unknown configuration type %s\n", a->argv[4]);
1302 return;
1303 }
1304
1305 /* Now iterate over the options for the type */
1306 tmp = item;
1307 while ((tmp = AST_LIST_NEXT(tmp, next))) {
1308 if (!strcasecmp(tmp->type, "configOption") && !strcasecmp(tmp->ref, a->argv[4])) {
1309 ast_cli(a->fd, "%-25s -- %-120.120s\n", tmp->name,
1310 ast_str_buffer(tmp->synopsis));
1311 }
1312 }
1313}

References a, ao2_cleanup, ao2_find, ast_assert, ast_cli(), AST_LIST_NEXT, ast_str_buffer(), ast_str_strlen(), ast_xmldoc_printable(), COLOR_BLACK, COLOR_MAGENTA, item, match(), ast_xml_doc_item::next, NULL, OBJ_KEY, RAII_VAR, term_color(), tmp(), and xmldocs.

Referenced by cli_show_help().

◆ cli_show_module_types()

static void cli_show_module_types ( struct ast_cli_args a)
static

Definition at line 1234 of file config_options.c.

1235{
1237 struct ast_xml_doc_item *tmp;
1238
1239 ast_assert(a->argc == 4);
1240
1241 if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) {
1242 ast_cli(a->fd, "Module %s not found.\n", a->argv[3]);
1243 return;
1244 }
1245
1246 if (ast_str_strlen(item->synopsis)) {
1247 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(item->synopsis), 1));
1248 }
1249 if (ast_str_strlen(item->description)) {
1250 ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(item->description), 1));
1251 }
1252
1253 tmp = item;
1254 ast_cli(a->fd, "Configuration option types for %s:\n", tmp->name);
1255 while ((tmp = AST_LIST_NEXT(tmp, next))) {
1256 if (!strcasecmp(tmp->type, "configObject")) {
1257 ast_cli(a->fd, "%-25s -- %-65.65s\n", tmp->name,
1258 ast_str_buffer(tmp->synopsis));
1259 }
1260 }
1261}

References a, ao2_cleanup, ao2_find, ast_assert, ast_cli(), AST_LIST_NEXT, ast_str_buffer(), ast_str_strlen(), ast_xmldoc_printable(), item, ast_xml_doc_item::next, NULL, OBJ_KEY, RAII_VAR, tmp(), and xmldocs.

Referenced by cli_show_help().

◆ cli_show_modules()

static void cli_show_modules ( struct ast_cli_args a)
static

Definition at line 1210 of file config_options.c.

1211{
1212 struct ast_xml_doc_item *item;
1213 struct ao2_iterator it_items;
1214
1215 ast_assert(a->argc == 3);
1216
1217 if (ao2_container_count(xmldocs) == 0) {
1218 ast_cli(a->fd, "No modules found.\n");
1219 return;
1220 }
1221
1222 it_items = ao2_iterator_init(xmldocs, 0);
1223 ast_cli(a->fd, "The following modules have configuration information:\n");
1224 while ((item = ao2_iterator_next(&it_items))) {
1225 ast_cli(a->fd, "\t%s\n", item->name);
1226 ao2_ref(item, -1);
1227 }
1228 ao2_iterator_destroy(&it_items);
1229}
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
const char * name

References a, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_assert, ast_cli(), item, aco_type::name, and xmldocs.

Referenced by cli_show_help().

◆ codec_handler_fn()

static int codec_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for codec preferences/capabilities.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1560 of file config_options.c.

1560 {
1561 struct ast_format_cap **cap = (struct ast_format_cap **)(obj + opt->args[0]);
1562 return ast_format_cap_update_by_allow_disallow(*cap, var->value, opt->flags);
1563}
int ast_format_cap_update_by_allow_disallow(struct ast_format_cap *cap, const char *list, int allowing)
Parse an "allow" or "deny" list and modify a format capabilities structure accordingly.
Definition: format_cap.c:320
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54

References aco_option::args, ast_format_cap_update_by_allow_disallow(), aco_option::flags, and var.

Referenced by ast_config_option_default_handler().

◆ complete_config_module()

static char * complete_config_module ( const char *  word)
static

Definition at line 965 of file config_options.c.

966{
967 size_t wordlen = strlen(word);
968 struct ao2_iterator i;
969 struct ast_xml_doc_item *cur;
970
972 while ((cur = ao2_iterator_next(&i))) {
973 if (!strncasecmp(word, cur->name, wordlen)) {
975 ao2_ref(cur, -1);
976 break;
977 }
978 }
979 ao2_ref(cur, -1);
980 }
982
983 return NULL;
984}
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
Definition: main/cli.c:2768
short word
const ast_string_field name
Definition: xmldoc.h:74

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_completion_add(), ast_strdup, ast_xml_doc_item::name, NULL, and xmldocs.

Referenced by cli_show_help().

◆ complete_config_option()

static char * complete_config_option ( const char *  module,
const char *  option,
const char *  word 
)
static

Definition at line 1016 of file config_options.c.

1017{
1018 size_t wordlen = strlen(word);
1019 struct ast_xml_doc_item *info;
1020 struct ast_xml_doc_item *cur;
1021
1022 info = ao2_find(xmldocs, module, OBJ_KEY);
1023 if (!info) {
1024 return NULL;
1025 }
1026
1027 cur = info;
1028 while ((cur = AST_LIST_NEXT(cur, next))) {
1029 if (!strcasecmp(cur->type, "configOption") && !strcasecmp(cur->ref, option) && !strncasecmp(word, cur->name, wordlen)) {
1031 break;
1032 }
1033 }
1034 }
1035 ao2_ref(info, -1);
1036
1037 return NULL;
1038}
const ast_string_field ref
Definition: xmldoc.h:74
const ast_string_field type
Definition: xmldoc.h:74

References ao2_find, ao2_ref, ast_cli_completion_add(), AST_LIST_NEXT, ast_strdup, sip_to_pjsip::info(), ast_xml_doc_item::name, ast_xml_doc_item::next, NULL, OBJ_KEY, ast_xml_doc_item::ref, ast_xml_doc_item::type, and xmldocs.

Referenced by cli_show_help().

◆ complete_config_type()

static char * complete_config_type ( const char *  module,
const char *  word 
)
static

Definition at line 989 of file config_options.c.

990{
991 size_t wordlen = strlen(word);
992 struct ast_xml_doc_item *info;
993 struct ast_xml_doc_item *cur;
994
995 info = ao2_find(xmldocs, module, OBJ_KEY);
996 if (!info) {
997 return NULL;
998 }
999
1000 cur = info;
1001 while ((cur = AST_LIST_NEXT(cur, next))) {
1002 if (!strcasecmp(cur->type, "configObject") && !strncasecmp(word, cur->name, wordlen)) {
1004 break;
1005 }
1006 }
1007 }
1008 ao2_ref(info, -1);
1009
1010 return NULL;
1011}

References ao2_find, ao2_ref, ast_cli_completion_add(), AST_LIST_NEXT, ast_strdup, sip_to_pjsip::info(), ast_xml_doc_item::name, ast_xml_doc_item::next, NULL, OBJ_KEY, ast_xml_doc_item::type, and xmldocs.

Referenced by cli_show_help().

◆ config_opt_cmp()

static int config_opt_cmp ( void *  obj,
void *  arg,
int  flags 
)
static

Definition at line 365 of file config_options.c.

366{
367 struct aco_option *opt1 = obj, *opt2 = arg;
368 const char *name = (flags & OBJ_KEY) ? arg : opt2->name;
369 return strcasecmp(opt1->name, name) ? 0 : CMP_MATCH | CMP_STOP;
370}
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028
struct aco_type ** obj

References CMP_MATCH, CMP_STOP, aco_option::flags, name, aco_option::name, aco_option::obj, and OBJ_KEY.

Referenced by aco_option_container_alloc().

◆ config_opt_hash()

static int config_opt_hash ( const void *  obj,
const int  flags 
)
static

Definition at line 358 of file config_options.c.

359{
360 const struct aco_option *opt = obj;
361 const char *name = (flags & OBJ_KEY) ? obj : opt->name;
362 return ast_str_case_hash(name);
363}
static force_inline int attribute_pure ast_str_case_hash(const char *str)
Compute a hash value on a case-insensitive string.
Definition: strings.h:1303

References ast_str_case_hash(), aco_option::flags, name, aco_option::name, aco_option::obj, and OBJ_KEY.

Referenced by aco_option_container_alloc().

◆ config_option_destroy()

static void config_option_destroy ( void *  obj)
static

Definition at line 112 of file config_options.c.

113{
114 struct aco_option *opt = obj;
115 if (opt->match_type == ACO_REGEX && opt->name_regex) {
116 regfree(opt->name_regex);
117 ast_free(opt->name_regex);
118 }
119}

References ACO_REGEX, ast_free, aco_option::match_type, aco_option::name_regex, and aco_option::obj.

Referenced by __aco_option_register(), and aco_option_register_deprecated().

◆ derive_category_text()

static struct ast_str * derive_category_text ( enum aco_category_op  category_match,
const char *  category 
)
static

Definition at line 1043 of file config_options.c.

1044{
1045 struct ast_str *s = ast_str_create(128);
1046
1047 if (!s) {
1048 return NULL;
1049 }
1050
1051 switch (category_match) {
1053 case ACO_BLACKLIST_ARRAY: {
1054 size_t i;
1055 const char **matches = (const char **) category;
1056 ast_str_append(&s, 0, "^(");
1057 for (i = 0; matches[i]; i++) {
1058 ast_str_append(&s, 0, "%s%s",
1059 i ? "|" : "",
1060 matches[i]);
1061 }
1062 ast_str_append(&s, 0, ")$");
1063 break;
1064 }
1067 ast_str_set(&s, 0, "^%s$", category);
1068 break;
1069 case ACO_WHITELIST:
1070 case ACO_BLACKLIST:
1071 default:
1072 ast_str_set(&s, 0, "%s", category);
1073 break;
1074 }
1075
1076 return s;
1077}
@ ACO_WHITELIST_ARRAY
@ ACO_BLACKLIST
@ ACO_WHITELIST_EXACT
@ ACO_WHITELIST
@ ACO_BLACKLIST_ARRAY
@ ACO_BLACKLIST_EXACT
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition: strings.h:1113
Support for dynamic strings.
Definition: strings.h:623

References ACO_BLACKLIST, ACO_BLACKLIST_ARRAY, ACO_BLACKLIST_EXACT, ACO_WHITELIST, ACO_WHITELIST_ARRAY, ACO_WHITELIST_EXACT, ast_str_append(), ast_str_create, ast_str_set(), and NULL.

Referenced by xmldoc_update_config_type().

◆ double_handler_fn()

static int double_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for doubles.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1540 of file config_options.c.

1540 {
1541 double *field = (double *)(obj + opt->args[0]);
1542 return ast_parse_arg(var->value, PARSE_DOUBLE | opt->flags, field);
1543}
int ast_parse_arg(const char *arg, enum ast_parse_flags flags, void *p_result,...)
The argument parsing routine.
Definition: main/config.c:3842

References aco_option::args, ast_parse_arg(), aco_option::flags, PARSE_DOUBLE, and var.

Referenced by ast_config_option_default_handler().

◆ find_option_cb()

static int find_option_cb ( void *  obj,
void *  arg,
int  flags 
)
static

Definition at line 372 of file config_options.c.

373{
374 struct aco_option *match = obj;
375 const char *name = arg;
376
377 switch (match->match_type) {
378 case ACO_EXACT:
379 return strcasecmp(name, match->name) ? 0 : CMP_MATCH | CMP_STOP;
380 case ACO_PREFIX:
381 return strncasecmp(name, match->name, strlen(match->name)) ? 0 : CMP_MATCH | CMP_STOP;
382 case ACO_REGEX:
383 return regexec(match->name_regex, name, 0, NULL, 0) ? 0 : CMP_MATCH | CMP_STOP;
384 }
385 ast_log(LOG_ERROR, "Unknown match type. This should not be possible.\n");
386 return CMP_STOP;
387}
@ ACO_PREFIX

References ACO_EXACT, ACO_PREFIX, ACO_REGEX, ast_log, CMP_MATCH, CMP_STOP, LOG_ERROR, match(), name, NULL, and aco_option::obj.

Referenced by aco_option_find().

◆ find_xmldoc_option()

static struct ast_xml_doc_item * find_xmldoc_option ( struct ast_xml_doc_item config_info,
struct aco_type **  types,
const char *  name 
)
static

Definition at line 257 of file config_options.c.

258{
259 struct ast_xml_doc_item *iter = config_info;
260
261 if (!iter) {
262 return NULL;
263 }
264 /* First is just the configInfo, we can skip it */
265 while ((iter = AST_LIST_NEXT(iter, next))) {
266 size_t x;
267 if (strcasecmp(iter->name, name)) {
268 continue;
269 }
270 for (x = 0; types[x]; x++) {
271 /* All we care about is that at least one type has the option */
272 if (!strcasecmp(types[x]->name, iter->ref)) {
273 return iter;
274 }
275 }
276 }
277 return NULL;
278}

References AST_LIST_NEXT, name, ast_xml_doc_item::name, ast_xml_doc_item::next, NULL, and ast_xml_doc_item::ref.

Referenced by xmldoc_update_config_option().

◆ find_xmldoc_type()

static struct ast_xml_doc_item * find_xmldoc_type ( struct ast_xml_doc_item config_info,
const char *  name 
)
static

Definition at line 283 of file config_options.c.

284{
285 struct ast_xml_doc_item *iter = config_info;
286 if (!iter) {
287 return NULL;
288 }
289 /* First is just the config Info, skip it */
290 while ((iter = AST_LIST_NEXT(iter, next))) {
291 if (!strcasecmp(iter->type, "configObject") && !strcasecmp(iter->name, name)) {
292 break;
293 }
294 }
295 return iter;
296}

References AST_LIST_NEXT, name, ast_xml_doc_item::name, ast_xml_doc_item::next, NULL, and ast_xml_doc_item::type.

Referenced by xmldoc_update_config_type().

◆ int_handler_fn()

static int int_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for signed integers.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1447 of file config_options.c.

1447 {
1448 int *field = (int *)(obj + opt->args[0]);
1449 unsigned int flags = PARSE_INT32 | opt->flags;
1450 int res = 0;
1451 if (opt->flags & PARSE_IN_RANGE) {
1452 res = opt->flags & PARSE_DEFAULT ?
1453 ast_parse_arg(var->value, flags, field, (int) opt->args[1], (int) opt->args[2], opt->args[3]) :
1454 ast_parse_arg(var->value, flags, field, (int) opt->args[1], (int) opt->args[2]);
1455 if (res) {
1456 if (opt->flags & PARSE_RANGE_DEFAULTS) {
1457 ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]);
1458 res = 0;
1459 } else if (opt->flags & PARSE_DEFAULT) {
1460 ast_log(LOG_WARNING, "Failed to set %s=%s, Set to default value %d instead.\n", var->name, var->value, *field);
1461 res = 0;
1462 }
1463 }
1464 } else if ((opt->flags & PARSE_DEFAULT) && ast_parse_arg(var->value, flags, field, (int) opt->args[1])) {
1465 ast_log(LOG_WARNING, "Attempted to set %s=%s, but set it to %d instead due to default)\n", var->name, var->value, *field);
1466 } else {
1467 res = ast_parse_arg(var->value, flags, field);
1468 }
1469
1470 return res;
1471}
@ PARSE_RANGE_DEFAULTS
const char * args

References aco_option::args, ast_log, ast_parse_arg(), aco_option::flags, LOG_WARNING, PARSE_DEFAULT, PARSE_IN_RANGE, PARSE_INT32, PARSE_RANGE_DEFAULTS, and var.

Referenced by ast_config_option_default_handler().

◆ internal_aco_type_category_check()

static int internal_aco_type_category_check ( struct aco_type match,
const char *  category 
)
static

Definition at line 412 of file config_options.c.

413{
414 const char **categories = (const char **)match->category;
415
416 switch (match->category_match) {
417 case ACO_WHITELIST:
418 return regexec(match->internal->regex, category, 0, NULL, 0);
419
420 case ACO_BLACKLIST:
421 return !regexec(match->internal->regex, category, 0, NULL, 0);
422
424 return strcasecmp(match->category, category);
425
427 return !strcasecmp(match->category, category);
428
430 while (*categories) {
431 if (!strcasecmp(*categories, category)) {
432 return 0;
433 }
434 categories++;
435 }
436 return -1;
437
439 while (*categories) {
440 if (!strcasecmp(*categories, category)) {
441 return -1;
442 }
443 categories++;
444 }
445 return 0;
446 }
447
448 return -1;
449}
struct association categories[]

References ACO_BLACKLIST, ACO_BLACKLIST_ARRAY, ACO_BLACKLIST_EXACT, ACO_WHITELIST, ACO_WHITELIST_ARRAY, ACO_WHITELIST_EXACT, categories, match(), and NULL.

Referenced by internal_aco_type_find().

◆ internal_aco_type_find()

static struct aco_type * internal_aco_type_find ( struct aco_file file,
struct ast_config cfg,
const char *  category 
)
static

Definition at line 451 of file config_options.c.

452{
453 size_t x;
454 struct aco_type *match;
455 const char *val;
456
457 for (x = 0, match = file->types[x]; match; match = file->types[++x]) {
458 /* First make sure we are an object that can service this category */
460 continue;
461 }
462
463 /* Then, see if we need to match a particular field */
464 if (!ast_strlen_zero(match->matchfield) && (!ast_strlen_zero(match->matchvalue) || match->matchfunc)) {
465 if (!(val = ast_variable_retrieve(cfg, category, match->matchfield))) {
466 ast_log(LOG_ERROR, "Required match field '%s' not found\n", match->matchfield);
467 return NULL;
468 }
469 if (match->matchfunc) {
470 if (!match->matchfunc(val)) {
471 continue;
472 }
473 } else if (strcasecmp(val, match->matchvalue)) {
474 continue;
475 }
476 }
477 /* If we get this far, we're a match */
478 break;
479 }
480
481 return match;
482}
static int internal_aco_type_category_check(struct aco_type *match, const char *category)
const char * ast_variable_retrieve(struct ast_config *config, const char *category, const char *variable)
Definition: main/config.c:784
const char * category

References ast_log, ast_strlen_zero(), ast_variable_retrieve(), aco_type::category, make_ari_stubs::file, internal_aco_type_category_check(), LOG_ERROR, match(), and NULL.

Referenced by process_category().

◆ internal_file_types_destroy()

static void internal_file_types_destroy ( struct aco_file file)
static

Definition at line 837 of file config_options.c.

838{
839 size_t x;
840 struct aco_type *t;
841
842 for (x = 0, t = file->types[x]; t; t = file->types[++x]) {
844 t = NULL;
845 }
846}
static void internal_type_destroy(struct aco_type *type)

References make_ari_stubs::file, internal_type_destroy(), and NULL.

Referenced by aco_info_destroy().

◆ internal_process_ast_config()

static enum aco_process_status internal_process_ast_config ( struct aco_info info,
struct aco_file file,
struct ast_config cfg 
)
static

Definition at line 596 of file config_options.c.

597{
598 const char *cat = NULL;
599
600 if (file->preload) {
601 int i;
602 for (i = 0; !ast_strlen_zero(file->preload[i]); i++) {
603 if (process_category(cfg, info, file, file->preload[i], 1)) {
604 return ACO_PROCESS_ERROR;
605 }
606 }
607 }
608
609 while ((cat = ast_category_browse(cfg, cat))) {
610 if (process_category(cfg, info, file, cat, 0)) {
611 return ACO_PROCESS_ERROR;
612 }
613 }
614 return ACO_PROCESS_OK;
615}
static int process_category(struct ast_config *cfg, struct aco_info *info, struct aco_file *file, const char *cat, int preload)
char * ast_category_browse(struct ast_config *config, const char *prev_name)
Browse categories.
Definition: extconf.c:3326

References ACO_PROCESS_ERROR, ACO_PROCESS_OK, ast_category_browse(), ast_strlen_zero(), make_ari_stubs::file, sip_to_pjsip::info(), NULL, and process_category().

Referenced by aco_process_ast_config(), and aco_process_config().

◆ internal_type_destroy()

static void internal_type_destroy ( struct aco_type type)
static

Definition at line 818 of file config_options.c.

819{
820 /* If we've already had all our internal data cleared out,
821 * then there's no need to proceed further
822 */
823 if (!type->internal) {
824 return;
825 }
826
827 if (type->internal->regex) {
828 regfree(type->internal->regex);
829 ast_free(type->internal->regex);
830 }
831 ao2_cleanup(type->internal->opts);
832 type->internal->opts = NULL;
833 ast_free(type->internal);
834 type->internal = NULL;
835}

References ao2_cleanup, ast_free, NULL, and type.

Referenced by internal_file_types_destroy(), and internal_type_init().

◆ internal_type_init()

static int internal_type_init ( struct aco_type type)
static

Definition at line 848 of file config_options.c.

849{
850 if (!(type->internal = ast_calloc(1, sizeof(*type->internal)))) {
851 return -1;
852 }
853
854 switch (type->category_match) {
855 case ACO_BLACKLIST:
856 case ACO_WHITELIST:
857 if (!(type->internal->regex = build_regex(type->category))) {
859 return -1;
860 }
861 break;
866 break;
867 }
868
869 if (!(type->internal->opts = aco_option_container_alloc())) {
871 return -1;
872 }
873
874 return 0;
875}
struct ao2_container * aco_option_container_alloc(void)
Allocate a container to hold config options.

References ACO_BLACKLIST, ACO_BLACKLIST_ARRAY, ACO_BLACKLIST_EXACT, aco_option_container_alloc(), ACO_WHITELIST, ACO_WHITELIST_ARRAY, ACO_WHITELIST_EXACT, ast_calloc, build_regex(), internal_type_destroy(), and type.

Referenced by aco_info_init().

◆ is_preload()

static int is_preload ( struct aco_file file,
const char *  cat 
)
static

Definition at line 484 of file config_options.c.

485{
486 int i;
487
488 if (!file->preload) {
489 return 0;
490 }
491
492 for (i = 0; !ast_strlen_zero(file->preload[i]); i++) {
493 if (!strcasecmp(cat, file->preload[i])) {
494 return 1;
495 }
496 }
497 return 0;
498}

References ast_strlen_zero(), and make_ari_stubs::file.

Referenced by process_category().

◆ link_option_to_types()

static int link_option_to_types ( struct aco_info info,
struct aco_type **  types,
struct aco_option opt 
)
static

Definition at line 186 of file config_options.c.

187{
188 size_t idx = 0;
189 struct aco_type *type;
190
191 while ((type = types[idx++])) {
192 if (!type->internal) {
193 ast_log(LOG_ERROR, "Attempting to register option using uninitialized type\n");
194 return -1;
195 }
196 if (!ao2_link(type->internal->opts, opt)) {
197 do {
198 ao2_unlink(types[idx - 1]->internal->opts, opt);
199 } while (--idx);
200 return -1;
201 }
202#ifdef AST_XML_DOCS
203 if (!info->hidden && !opt->no_doc &&
204 xmldoc_update_config_option(types, info->module, opt->name, type->name, opt->default_val, opt->match_type == ACO_REGEX, opt->type)) {
205#ifdef AST_DEVMODE
206 opt->doc_unavailable = 1;
207#endif
208 }
209#endif
210 }
211 /* The container(s) should hold the only ref to opt */
212 ao2_ref(opt, -1);
213
214 return 0;
215}
#define ao2_link(container, obj)
Add an object to a container.
Definition: astobj2.h:1532
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578
static int xmldoc_update_config_option(struct aco_type **types, const char *module, const char *name, const char *object_name, const char *default_value, unsigned int regex, enum aco_option_type type)
struct ao2_container * opts
struct aco_type_internal * internal

References ACO_REGEX, ao2_link, ao2_ref, ao2_unlink, ast_log, aco_option::default_val, sip_to_pjsip::info(), aco_type::internal, LOG_ERROR, aco_option::match_type, aco_option::name, aco_option::no_doc, aco_type_internal::opts, type, aco_option::type, and xmldoc_update_config_option().

Referenced by __aco_option_register(), and aco_option_register_deprecated().

◆ noop_handler_fn()

static int noop_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default handler for doing nothing.

Definition at line 1622 of file config_options.c.

1623{
1624 return 0;
1625}

Referenced by ast_config_option_default_handler().

◆ process_category()

static int process_category ( struct ast_config cfg,
struct aco_info info,
struct aco_file file,
const char *  cat,
int  preload 
)
static

Definition at line 500 of file config_options.c.

500 {
501 RAII_VAR(void *, new_item, NULL, ao2_cleanup);
502 struct aco_type *type;
503 /* For global types, field is the global option struct. For non-global, it is the container for items.
504 * We do not grab a reference to these objects, as the info already holds references to them. This
505 * pointer is just a convenience. Do not actually store it somewhere. */
506 void **field;
507 regex_t *regex_skip;
508
509 /* Skip preloaded categories if we aren't preloading */
510 if (!preload && is_preload(file, cat)) {
511 return 0;
512 }
513
514 /* Skip the category if we've been told to ignore it */
515 if (!ast_strlen_zero(file->skip_category)) {
516 regex_skip = build_regex(file->skip_category);
517 if (!regexec(regex_skip, cat, 0, NULL, 0)) {
518 regfree(regex_skip);
519 ast_free(regex_skip);
520 return 0;
521 }
522 regfree(regex_skip);
523 ast_free(regex_skip);
524 }
525
526 /* Find aco_type by category, if not found it is an error */
527 if (!(type = internal_aco_type_find(file, cfg, cat))) {
528 ast_log(LOG_ERROR, "Could not find config type for category '%s' in '%s'\n", cat, file->filename);
529 return -1;
530 }
531
532 if (type->type == ACO_IGNORE) {
533 return 0;
534 }
535
536 field = info->internal->pending + type->item_offset;
537 if (!*field) {
538 ast_log(LOG_ERROR, "In %s: %s - No object to update!\n", file->filename, cat);
539 return -1;
540 }
541
542 if (type->type == ACO_GLOBAL && *field) {
543 if (aco_process_category_options(type, cfg, cat, *field)) {
544 ast_log(LOG_ERROR, "In %s: Processing options for %s failed\n", file->filename, cat);
545 return -1;
546 }
547 } else if (type->type == ACO_ITEM) {
548 int new = 0;
549 /* If we have multiple definitions of a category in a file, or can set the values from multiple
550 * files, look up the entry if we've already added it so we can merge the values together.
551 * Otherwise, alloc a new item. */
552 if (*field) {
553 if (!(new_item = type->item_find(*field, cat))) {
554 if (!(new_item = type->item_alloc(cat))) {
555 ast_log(LOG_ERROR, "In %s: Could not create item for %s\n", file->filename, cat);
556 return -1;
557 }
558 if (aco_set_defaults(type, cat, new_item)) {
559 ast_log(LOG_ERROR, "In %s: Setting defaults for %s failed\n", file->filename, cat);
560 return -1;
561 }
562 new = 1;
563 }
564 }
565
566 if (type->item_pre_process && type->item_pre_process(new_item)) {
567 ast_log(LOG_ERROR, "In %s: Preprocess callback for %s failed\n", file->filename, cat);
568 return -1;
569 }
570
571 if (aco_process_category_options(type, cfg, cat, new_item)) {
572 ast_log(LOG_ERROR, "In %s: Processing options for %s failed\n", file->filename, cat);
573 return -1;
574 }
575
576 if (type->item_prelink && type->item_prelink(new_item)) {
577 ast_log(LOG_ERROR, "In %s: Pre-link callback for %s failed\n", file->filename, cat);
578 return -1;
579 }
580
581 if (new && !ao2_link(*field, new_item)) {
582 ast_log(LOG_ERROR, "In %s: Linking config for %s failed\n", file->filename, cat);
583 return -1;
584 }
585 }
586 return 0;
587}
int aco_process_category_options(struct aco_type *type, struct ast_config *cfg, const char *cat, void *obj)
Parse each option defined in a config category.
static int is_preload(struct aco_file *file, const char *cat)
static struct aco_type * internal_aco_type_find(struct aco_file *file, struct ast_config *cfg, const char *category)
@ ACO_ITEM

References ACO_GLOBAL, ACO_IGNORE, ACO_ITEM, aco_process_category_options(), aco_set_defaults(), ao2_cleanup, ao2_link, ast_free, ast_log, ast_strlen_zero(), build_regex(), make_ari_stubs::file, sip_to_pjsip::info(), internal_aco_type_find(), is_preload(), LOG_ERROR, NULL, RAII_VAR, and type.

Referenced by internal_process_ast_config().

◆ sockaddr_handler_fn()

static int sockaddr_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default handler for ast_sockaddrs.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1614 of file config_options.c.

1615{
1616 struct ast_sockaddr *field = (struct ast_sockaddr *)(obj + opt->args[0]);
1617 return ast_parse_arg(var->value, PARSE_ADDR | opt->flags, field);
1618}
Socket address structure.
Definition: netsock2.h:97

References aco_option::args, ast_parse_arg(), aco_option::flags, PARSE_ADDR, and var.

Referenced by ast_config_option_default_handler().

◆ stringfield_handler_fn()

static int stringfield_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for stringfields.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1569 of file config_options.c.

1570{
1571 ast_string_field *field = (const char **)(obj + opt->args[0]);
1572 struct ast_string_field_pool **pool = (struct ast_string_field_pool **)(obj + opt->args[1]);
1573 struct ast_string_field_mgr *mgr = (struct ast_string_field_mgr *)(obj + opt->args[2]);
1574
1575 if (opt->flags && ast_strlen_zero(var->value)) {
1576 return -1;
1577 }
1578 ast_string_field_ptr_set_by_fields(*pool, *mgr, field, var->value);
1579 return 0;
1580}
const char * ast_string_field
Definition: stringfields.h:190
#define ast_string_field_ptr_set_by_fields(field_mgr_pool, field_mgr, ptr, data)
Definition: stringfields.h:510

References aco_option::args, ast_string_field_ptr_set_by_fields, ast_strlen_zero(), aco_option::flags, and var.

Referenced by ast_config_option_default_handler().

◆ timelen_handler_fn()

static int timelen_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for timelen signed integers.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1507 of file config_options.c.

1508{
1509 int *field = (int *)(obj + opt->args[0]);
1510 unsigned int flags = PARSE_TIMELEN | opt->flags;
1511 int res = 0;
1512 if (opt->flags & PARSE_IN_RANGE) {
1513 if (opt->flags & PARSE_DEFAULT) {
1514 res = ast_parse_arg(var->value, flags, field, (enum ast_timelen) opt->args[1], (int) opt->args[2], (int) opt->args[3], opt->args[4]);
1515 } else {
1516 res = ast_parse_arg(var->value, flags, field, (enum ast_timelen) opt->args[1], (int) opt->args[2], (int) opt->args[3]);
1517 }
1518 if (res) {
1519 if (opt->flags & PARSE_RANGE_DEFAULTS) {
1520 ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[2], (int) opt->args[3]);
1521 res = 0;
1522 } else if (opt->flags & PARSE_DEFAULT) {
1523 ast_log(LOG_WARNING, "Failed to set %s=%s, Set to default value %d instead.\n", var->name, var->value, *field);
1524 res = 0;
1525 }
1526 }
1527 } else if ((opt->flags & PARSE_DEFAULT) && ast_parse_arg(var->value, flags, field, (enum ast_timelen) opt->args[1], (int) opt->args[2])) {
1528 ast_log(LOG_WARNING, "Attempted to set %s=%s, but set it to %d instead due to default)\n", var->name, var->value, *field);
1529 } else {
1530 res = ast_parse_arg(var->value, flags, field, (enum ast_timelen) opt->args[1]);
1531 }
1532
1533 return res;
1534}

References aco_option::args, ast_log, ast_parse_arg(), aco_option::flags, LOG_WARNING, PARSE_DEFAULT, PARSE_IN_RANGE, PARSE_RANGE_DEFAULTS, PARSE_TIMELEN, and var.

Referenced by ast_config_option_default_handler().

◆ uint_handler_fn()

static int uint_handler_fn ( const struct aco_option opt,
struct ast_variable var,
void *  obj 
)
static

Default option handler for unsigned integers.

Note
For a description of the opt->flags and opt->args values, see the documentation for enum aco_option_type in config_options.h

Definition at line 1477 of file config_options.c.

1477 {
1478 unsigned int *field = (unsigned int *)(obj + opt->args[0]);
1479 unsigned int flags = PARSE_UINT32 | opt->flags;
1480 int res = 0;
1481 if (opt->flags & PARSE_IN_RANGE) {
1482 res = opt->flags & PARSE_DEFAULT ?
1483 ast_parse_arg(var->value, flags, field, (unsigned int) opt->args[1], (unsigned int) opt->args[2], opt->args[3]) :
1484 ast_parse_arg(var->value, flags, field, (unsigned int) opt->args[1], (unsigned int) opt->args[2]);
1485 if (res) {
1486 if (opt->flags & PARSE_RANGE_DEFAULTS) {
1487 ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %u instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]);
1488 res = 0;
1489 } else if (opt->flags & PARSE_DEFAULT) {
1490 ast_log(LOG_WARNING, "Failed to set %s=%s, Set to default value %u instead.\n", var->name, var->value, *field);
1491 res = 0;
1492 }
1493 }
1494 } else if ((opt->flags & PARSE_DEFAULT) && ast_parse_arg(var->value, flags, field, (unsigned int) opt->args[1])) {
1495 ast_log(LOG_WARNING, "Attempted to set %s=%s, but set it to %u instead due to default)\n", var->name, var->value, *field);
1496 } else {
1497 res = ast_parse_arg(var->value, flags, field);
1498 }
1499
1500 return res;
1501}

References aco_option::args, ast_log, ast_parse_arg(), aco_option::flags, LOG_WARNING, PARSE_DEFAULT, PARSE_IN_RANGE, PARSE_RANGE_DEFAULTS, PARSE_UINT32, and var.

Referenced by ast_config_option_default_handler().

◆ xmldoc_update_config_option()

static int xmldoc_update_config_option ( struct aco_type **  types,
const char *  module,
const char *  name,
const char *  object_name,
const char *  default_value,
unsigned int  regex,
enum aco_option_type  type 
)
static

Definition at line 1172 of file config_options.c.

1173{
1174 RAII_VAR(struct ast_xml_xpath_results *, results, NULL, ast_xml_xpath_results_free);
1175 RAII_VAR(struct ast_xml_doc_item *, config_info, ao2_find(xmldocs, module, OBJ_KEY), ao2_cleanup);
1176 struct ast_xml_doc_item * config_option;
1177 struct ast_xml_node *option;
1178
1180
1181 if (!config_info || !(config_option = find_xmldoc_option(config_info, types, name))) {
1182 ast_log(LOG_ERROR, "XML Documentation for option '%s' in modules '%s' not found!\n", name, module);
1183 return XMLDOC_STRICT ? -1 : 0;
1184 }
1185
1186 if (!(results = ast_xmldoc_query("/docs/configInfo[@name='%s']/configFile/configObject[@name='%s']/configOption[@name='%s']", module, object_name, name))) {
1187 ast_log(LOG_WARNING, "Could not find option '%s' with type '%s' in module '%s'\n", name, object_name, module);
1188 return XMLDOC_STRICT ? -1 : 0;
1189 }
1190
1191 if (!(option = ast_xml_xpath_get_first_result(results))) {
1192 ast_log(LOG_WARNING, "Could not obtain results for option '%s' with type '%s' in module '%s'\n", name, object_name, module);
1193 return XMLDOC_STRICT ? -1 : 0;
1194 }
1195 ast_xml_set_attribute(option, "regex", regex ? "true" : "false");
1196 ast_xml_set_attribute(option, "default", default_value);
1198
1199 if (ast_xmldoc_regenerate_doc_item(config_option)) {
1200 ast_log(LOG_WARNING, "Could not update option '%s' with values from config option registration\n", name);
1201 return XMLDOC_STRICT ? -1 : 0;
1202 }
1203
1204 return 0;
1205}
static char * aco_option_type_string[]
Value of the aco_option_type enum as strings.
static struct ast_xml_doc_item * find_xmldoc_option(struct ast_xml_doc_item *config_info, struct aco_type **types, const char *name)
#define XMLDOC_STRICT
struct ast_xml_node * ast_xml_xpath_get_first_result(struct ast_xml_xpath_results *results)
Return the first result node of an XPath query.
Definition: xml.c:415
void ast_xml_xpath_results_free(struct ast_xml_xpath_results *results)
Free the XPath results.
Definition: xml.c:425
int ast_xml_set_attribute(struct ast_xml_node *node, const char *name, const char *value)
Set an attribute to a node.
Definition: xml.c:284
struct ast_xml_xpath_results * ast_xmldoc_query(const char *fmt,...)
Execute an XPath query on the loaded XML documentation.
Definition: xmldoc.c:2576
int ast_xmldoc_regenerate_doc_item(struct ast_xml_doc_item *item)
Regenerate the documentation for a particular item.
Definition: xmldoc.c:2635

References aco_option_type_string, ao2_cleanup, ao2_find, ARRAY_LEN, ast_assert, ast_log, ast_xml_set_attribute(), ast_xml_xpath_get_first_result(), ast_xml_xpath_results_free(), ast_xmldoc_query(), ast_xmldoc_regenerate_doc_item(), find_xmldoc_option(), LOG_ERROR, LOG_WARNING, name, NULL, OBJ_KEY, RAII_VAR, regex(), type, XMLDOC_STRICT, and xmldocs.

Referenced by link_option_to_types().

◆ xmldoc_update_config_type()

static int xmldoc_update_config_type ( const char *  module,
const char *  name,
const char *  category,
const char *  matchfield,
const char *  matchvalue,
enum aco_category_op  category_match 
)
static

Definition at line 1087 of file config_options.c.

1088{
1089 RAII_VAR(struct ast_xml_xpath_results *, results, NULL, ast_xml_xpath_results_free);
1090 RAII_VAR(struct ast_xml_doc_item *, config_info, ao2_find(xmldocs, module, OBJ_KEY), ao2_cleanup);
1091 struct ast_xml_doc_item *config_type;
1092 struct ast_xml_node *type, *syntax, *matchinfo, *tmp;
1093 struct ast_str *derived_category = NULL;
1094
1095 /* If we already have a syntax element, bail. This isn't an error, since we may unload a module which
1096 * has updated the docs and then load it again. */
1097 if ((results = ast_xmldoc_query("/docs/configInfo[@name='%s']/configFile/configObject[@name='%s']/syntax", module, name))) {
1098 return 0;
1099 }
1100
1101 if (!(results = ast_xmldoc_query("/docs/configInfo[@name='%s']/configFile/configObject[@name='%s']", module, name))) {
1102 ast_log(LOG_WARNING, "Cannot update type '%s' in module '%s' because it has no existing documentation!"
1103 " If this module was recently built, run 'xmldoc reload' to refresh documentation, then load the module again\n",
1104 name, module);
1105 return XMLDOC_STRICT ? -1 : 0;
1106 }
1107
1108 if (!(type = ast_xml_xpath_get_first_result(results))) {
1109 ast_log(LOG_WARNING, "Could not retrieve documentation for type '%s' in module '%s'\n", name, module);
1110 return XMLDOC_STRICT ? -1 : 0;
1111 }
1112
1113 if (!(syntax = ast_xml_new_child(type, "syntax"))) {
1114 ast_log(LOG_WARNING, "Could not create syntax node for type '%s' in module '%s'\n", name, module);
1115 return XMLDOC_STRICT ? -1 : 0;
1116 }
1117
1118 if (!(matchinfo = ast_xml_new_child(syntax, "matchInfo"))) {
1119 ast_log(LOG_WARNING, "Could not create matchInfo node for type '%s' in module '%s'\n", name, module);
1120 return XMLDOC_STRICT ? -1 : 0;
1121 }
1122
1123 if (!(tmp = ast_xml_new_child(matchinfo, "category"))) {
1124 ast_log(LOG_WARNING, "Could not create category node for type '%s' in module '%s'\n", name, module);
1125 return XMLDOC_STRICT ? -1 : 0;
1126 }
1127
1128 derived_category = derive_category_text(category_match, category);
1129 if (derived_category) {
1130 ast_xml_set_text(tmp, ast_str_buffer(derived_category));
1131 ast_free(derived_category);
1132 }
1133
1134 switch (category_match) {
1135 case ACO_WHITELIST:
1138 ast_xml_set_attribute(tmp, "match", "true");
1139 break;
1140 case ACO_BLACKLIST:
1143 ast_xml_set_attribute(tmp, "match", "false");
1144 break;
1145 }
1146
1147 if (!ast_strlen_zero(matchfield)) {
1148 if (!(tmp = ast_xml_new_child(matchinfo, "field"))) {
1149 ast_log(LOG_WARNING, "Could not add %s attribute for type '%s' in module '%s'\n", matchfield, name, module);
1150 return XMLDOC_STRICT ? -1 : 0;
1151 }
1152 ast_xml_set_attribute(tmp, "name", matchfield);
1153 ast_xml_set_text(tmp, matchvalue);
1154 }
1155
1156 if (!config_info || !(config_type = find_xmldoc_type(config_info, name))) {
1157 ast_log(LOG_WARNING, "Could not obtain XML documentation item for config type %s\n", name);
1158 return XMLDOC_STRICT ? -1 : 0;
1159 }
1160
1161 if (ast_xmldoc_regenerate_doc_item(config_type)) {
1162 ast_log(LOG_WARNING, "Could not update type '%s' with values from config type registration\n", name);
1163 return XMLDOC_STRICT ? -1 : 0;
1164 }
1165
1166 return 0;
1167}
static struct ast_xml_doc_item * find_xmldoc_type(struct ast_xml_doc_item *config_info, const char *name)
static struct ast_str * derive_category_text(enum aco_category_op category_match, const char *category)
struct ast_xml_node * ast_xml_new_child(struct ast_xml_node *parent, const char *child_name)
Add a child node inside a passed parent node.
Definition: xml.c:156
void ast_xml_set_text(struct ast_xml_node *node, const char *content)
Set an element content string.
Definition: xml.c:362

References ACO_BLACKLIST, ACO_BLACKLIST_ARRAY, ACO_BLACKLIST_EXACT, ACO_WHITELIST, ACO_WHITELIST_ARRAY, ACO_WHITELIST_EXACT, ao2_cleanup, ao2_find, ast_free, ast_log, ast_str_buffer(), ast_strlen_zero(), ast_xml_new_child(), ast_xml_set_attribute(), ast_xml_set_text(), ast_xml_xpath_get_first_result(), ast_xml_xpath_results_free(), ast_xmldoc_query(), ast_xmldoc_regenerate_doc_item(), derive_category_text(), find_xmldoc_type(), LOG_WARNING, name, NULL, OBJ_KEY, RAII_VAR, tmp(), type, XMLDOC_STRICT, and xmldocs.

Referenced by aco_info_init().

Variable Documentation

◆ aco_option_type_string

char* aco_option_type_string[]
static

Value of the aco_option_type enum as strings.

Definition at line 85 of file config_options.c.

Referenced by xmldoc_update_config_option().

◆ cli_aco

struct ast_cli_entry cli_aco[]
static
Initial value:
= {
{ .handler = cli_show_help , .summary = "Show configuration help for a module" ,},
}
static char * cli_show_help(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)

Definition at line 1417 of file config_options.c.

Referenced by aco_deinit(), and aco_init().

◆ xmldocs

struct ao2_container* xmldocs
static