main/config.c File Reference

Configuration File Parser. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include "asterisk/network.h"
#include <string.h>
#include <libgen.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <math.h>
#include <regex.h>
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/channel.h"
#include "asterisk/app.h"
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/netsock2.h"
#include "asterisk/module.h"

Include dependency graph for main/config.c:

Go to the source code of this file.

Data Structures
struct	ast_category
struct	ast_category_template_instance
struct	ast_comment
	Structure to keep comments for rewriting configuration files. More...
struct	ast_config
struct	ast_config_include
struct	ast_config_map
struct	cache_file_include
	Hold the mtime for config files, so if we don't need to reread our config, don't. More...
struct	cache_file_mtime
struct	cfg_hook
struct	cfmtime_head
struct	config_included_file
struct	inclfile
struct	ast_config_include::included_files_list
struct	cache_file_mtime::includes
struct	ast_category::template_instance_list

Macros
#define	AST_MODULE   "extconfig"
#define	CB_SIZE   250 /* initial size of comment buffers */
#define	COMMENT_END   "--;"
#define	COMMENT_META   ';'
#define	COMMENT_START   ";--"
#define	COMMENT_TAG   '-'
#define	MAX_INCLUDE_LEVEL   10
#define	MAX_NESTED_COMMENTS   128
#define	MIN_VARIABLE_FNAME_SPACE   40
#define	realtime_arguments_to_fields(ap, result)   realtime_arguments_to_fields2(ap, 0, result)
#define	UTF8_BOM   "\xEF\xBB\xBF"

Enumerations
enum	config_cache_attribute_enum { ATTRIBUTE_INCLUDE = 0 , ATTRIBUTE_EXEC = 1 }
enum	include_statement_type { CONFIG_STATEMENT_INCLUDE = 0 , CONFIG_STATEMENT_EXEC = 1 , CONFIG_STATEMENT_TRYINCLUDE = 2 }
	Types used for ast_include_new() include_type. More...

Functions
static void	__init_appendbuf (void)
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_variable *	_ast_variable_new (const char *name, const char *value, const char *filename, const char *file, const char *func, int lineno)
static struct ast_comment *	ALLOC_COMMENT (struct ast_str *buffer)
void	ast_category_append (struct ast_config *config, struct ast_category *category)
	Appends a category to a config. More...
char *	ast_category_browse (struct ast_config *config, const char *prev_name)
	Browse categories. More...
struct ast_category *	ast_category_browse_filtered (struct ast_config *config, const char *category_name, struct ast_category *prev, const char *filter)
	Browse categories with filters. More...
struct ast_category *	ast_category_delete (struct ast_config *config, struct ast_category *category)
	Delete a category. More...
void	ast_category_destroy (struct ast_category *cat)
struct ast_variable *	ast_category_detach_variables (struct ast_category *cat)
int	ast_category_empty (struct ast_category *category)
	Removes and destroys all variables in a category. More...
int	ast_category_exist (const struct ast_config *config, const char *category_name, const char *filter)
	Check for category duplicates. More...
struct ast_variable *	ast_category_first (struct ast_category *cat)
	given a pointer to a category, return the root variable. More...
struct ast_category *	ast_category_get (const struct ast_config *config, const char *category_name, const char *filter)
	Retrieve a category if it exists. More...
const char *	ast_category_get_name (const struct ast_category *category)
	Return the name of the category. More...
struct ast_str *	ast_category_get_templates (const struct ast_category *category)
	Return the template names this category inherits from. More...
int	ast_category_inherit (struct ast_category *new, const struct ast_category *base)
	Applies base (template) to category. More...
int	ast_category_insert (struct ast_config *config, struct ast_category *cat, const char *match)
	Inserts new category. More...
int	ast_category_is_template (const struct ast_category *category)
	Check if category is a template. More...
struct ast_category *	ast_category_new (const char *name, const char *in_file, int lineno)
	Create a category. More...
struct ast_category *	ast_category_new_template (const char *name, const char *in_file, int lineno)
	Create a category making it a template. More...
void	ast_category_rename (struct ast_category *cat, const char *name)
struct ast_variable *	ast_category_root (struct ast_config *config, char *cat)
	returns the root ast_variable of a config More...
int	ast_check_realtime (const char *family)
	Check if realtime engine is configured for family. More...
static void	ast_comment_destroy (struct ast_comment **comment)
struct ast_config *	ast_config_copy (const struct ast_config *old)
	Copies the contents of one ast_config into another. More...
void	ast_config_destroy (struct ast_config *cfg)
	Destroys a config. More...
int	ast_config_engine_deregister (struct ast_config_engine *del)
	Deregister config engine. More...
int	ast_config_engine_register (struct ast_config_engine *new)
	Register config engine. More...
struct ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
	Retrieve the current category name being built. More...
int	ast_config_hook_register (const char *name, const char *filename, const char *module, enum config_hook_flags flags, config_hook_cb hook_cb)
	Register a config hook for a particular file and module. More...
void	ast_config_hook_unregister (const char *name)
	Unregister a config hook. More...
struct ast_config *	ast_config_internal_load (const char *filename, struct ast_config *cfg, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)
struct ast_config *	ast_config_load2 (const char *filename, const char *who_asked, struct ast_flags flags)
	Load a config file. More...
struct ast_config *	ast_config_new (void)
	Create a new base configuration structure. More...
const char *	ast_config_option (struct ast_config *cfg, const char *cat, const char *var)
	Retrieve a configuration variable within the configuration set. More...
void	ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
	Set the category within the configuration as being current. More...
void	ast_config_sort_categories (struct ast_config *config, int descending, int(*comparator)(struct ast_category *p, struct ast_category *q))
	Sorts categories in a config in the order of a numerical value contained within them. More...
int	ast_config_text_file_save (const char *configfile, const struct ast_config *cfg, const char *generator)
	Save a config text file preserving the pre 13.2 behavior. More...
int	ast_config_text_file_save2 (const char *configfile, const struct ast_config *cfg, const char *generator, uint32_t flags)
	Save a config text file. More...
int	ast_destroy_realtime (const char *family, const char *keyfield, const char *lookup,...)
	Destroy realtime configuration. More...
int	ast_destroy_realtime_fields (const char *family, const char *keyfield, const char *lookup, const struct ast_variable *fields)
	Destroy realtime configuration. More...
static void	ast_destroy_template_list (struct ast_category *cat)
static void	ast_include_destroy (struct ast_config_include *incl)
struct ast_config_include *	ast_include_find (struct ast_config *conf, const char *included_file)
struct ast_config_include *	ast_include_new (struct ast_config *conf, const char *from_file, const char *included_file, int include_type, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size)
void	ast_include_rename (struct ast_config *conf, const char *from_file, const char *to_file)
static void	ast_includes_destroy (struct ast_config_include *incls)
struct ast_variable *	ast_load_realtime (const char *family,...)
struct ast_variable *	ast_load_realtime_all (const char *family,...)
struct ast_variable *	ast_load_realtime_all_fields (const char *family, const struct ast_variable *fields)
struct ast_variable *	ast_load_realtime_fields (const char *family, const struct ast_variable *fields)
	Retrieve realtime configuration. More...
struct ast_config *	ast_load_realtime_multientry (const char *family,...)
	Retrieve realtime configuration. More...
struct ast_config *	ast_load_realtime_multientry_fields (const char *family, const struct ast_variable *fields)
	Retrieve realtime configuration. More...
struct ast_module *	AST_MODULE_SELF_SYM (void)
int	ast_parse_arg (const char *arg, enum ast_parse_flags flags, void *p_result,...)
	Helper function to parse arguments See documentation in config.h. More...
static int	ast_realtime_append_mapping (const char *name, const char *driver, const char *database, const char *table, int priority)
char *	ast_realtime_decode_chunk (char *chunk)
	Remove standard encoding from realtime values, which ensures that a semicolon embedded within a single value is not treated upon retrieval as multiple values. More...
int	ast_realtime_enabled (void)
	Check if there's any realtime engines loaded. More...
char *	ast_realtime_encode_chunk (struct ast_str **dest, ssize_t maxlen, const char *chunk)
	Encodes a chunk of data for realtime. More...
int	ast_realtime_is_mapping_defined (const char *family)
	Determine if a mapping exists for a given family. More...
int	ast_realtime_require_field (const char *family,...)
	Inform realtime what fields that may be stored. More...
int	ast_store_realtime (const char *family,...)
	Create realtime configuration. More...
int	ast_store_realtime_fields (const char *family, const struct ast_variable *fields)
	Create realtime configuration. More...
int	ast_unload_realtime (const char *family)
	Release any resources cached for a realtime family. More...
int	ast_update2_realtime (const char *family,...)
	Update realtime configuration. More...
int	ast_update2_realtime_fields (const char *family, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
	Update realtime configuration. More...
int	ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...)
	Update realtime configuration. More...
int	ast_update_realtime_fields (const char *family, const char *keyfield, const char *lookup, const struct ast_variable *fields)
	Update realtime configuration. More...
void	ast_variable_append (struct ast_category *category, struct ast_variable *variable)
struct ast_variable *	ast_variable_browse (const struct ast_config *config, const char *category)
int	ast_variable_delete (struct ast_category *category, const char *variable, const char *match, const char *line)
static void	ast_variable_destroy (struct ast_variable *doomed)
const char *	ast_variable_find (const struct ast_category *category, const char *variable)
	Gets a variable value from a specific category structure by name. More...
const char *	ast_variable_find_in_list (const struct ast_variable *list, const char *variable)
	Gets the value of a variable from a variable list by name. More...
const char *	ast_variable_find_last_in_list (const struct ast_variable *list, const char *variable)
	Gets the value of the LAST occurrence of a variable from a variable list. More...
const struct ast_variable *	ast_variable_find_variable_in_list (const struct ast_variable *list, const char *variable_name)
	Gets a variable from a variable list by name. More...
void	ast_variable_insert (struct ast_category *category, struct ast_variable *variable, const char *line)
struct ast_variable *	ast_variable_list_append_hint (struct ast_variable **head, struct ast_variable *search_hint, struct ast_variable *newvar)
	Appends a variable list to the end of another list. More...
struct ast_variable *	ast_variable_list_from_quoted_string (const char *input, const char *item_separator, const char *name_value_separator, const char *quote_str)
	Parse a string into an ast_variable list. The reverse of ast_variable_list_join. More...
struct ast_variable *	ast_variable_list_from_string (const char *input, const char *item_separator, const char *name_value_separator)
	Parse a string into an ast_variable list. The reverse of ast_variable_list_join. More...
struct ast_str *	ast_variable_list_join (const struct ast_variable *head, const char *item_separator, const char *name_value_separator, const char *quote_char, struct ast_str **str)
	Join an ast_variable list with specified separators and quoted values. More...
int	ast_variable_list_replace (struct ast_variable **head, struct ast_variable *replacement)
	Replace a variable in the given list with a new value. More...
int	ast_variable_list_replace_variable (struct ast_variable **head, struct ast_variable *old, struct ast_variable *new)
	Replace a variable in the given list with a new variable. More...
struct ast_variable *	ast_variable_list_sort (struct ast_variable *start)
	Performs an in-place sort on the variable list by ascending name. More...
int	ast_variable_lists_match (const struct ast_variable *left, const struct ast_variable *right, int exact_match)
	Tests 2 variable lists to see if they match. More...
static void	ast_variable_move (struct ast_variable *dst_var, struct ast_variable *src_var)
const char *	ast_variable_retrieve (struct ast_config *config, const char *category, const char *variable)
const char *	ast_variable_retrieve_filtered (struct ast_config *config, const char *category, const char *variable, const char *filter)
	Gets a variable by context and variable names. More...
int	ast_variable_update (struct ast_category *category, const char *variable, const char *value, const char *match, unsigned int object)
	Update variable value within a config. More...
void	ast_variables_destroy (struct ast_variable *var)
	Free variable list. More...
struct ast_variable *	ast_variables_dup (struct ast_variable *var)
	Duplicate variable list. More...
int	ast_variables_match (const struct ast_variable *left, const struct ast_variable *right)
	Tests 2 variable values to see if they match. More...
struct ast_variable *	ast_variables_reverse (struct ast_variable *var)
	Reverse a variable list. More...
static struct ast_category *	category_get_sep (const struct ast_config *config, const char *category_name, const char *filter, char sep, char pointer_match_possible)
static void	CB_ADD (struct ast_str **cb, const char *str)
static void	CB_ADD_LEN (struct ast_str **cb, const char *str, int len)
static void	CB_RESET (struct ast_str *cb, struct ast_str *llb)
static int	cfmstat_cmp (struct cache_file_mtime *cfmtime, struct stat *statbuf)
static void	cfmstat_save (struct cache_file_mtime *cfmtime, struct stat *statbuf)
static struct cache_file_mtime *	cfmtime_new (const char *filename, const char *who_asked)
static void	clear_config_maps (void)
static void	config_cache_attribute (const char *configfile, enum config_cache_attribute_enum attrtype, const char *filename, const char *who_asked)
static void	config_cache_destroy_entry (struct cache_file_mtime *cfmtime)
static void	config_cache_flush_includes (struct cache_file_mtime *cfmtime)
static void	config_cache_remove (const char *filename, const char *who_asked)
static void	config_hook_exec (const char *filename, const char *module, const struct ast_config *cfg)
static void	config_included_files_destroy (struct ast_config_include *incl)
static void	config_shutdown (void)
static struct ast_config *	config_text_file_load (const char *database, const char *table, const char *filename, struct ast_config *cfg, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)
static int	count_linefeeds (char *str)
static int	count_linefeeds_in_comments (struct ast_comment *x)
static int	does_category_match (struct ast_category *cat, const char *category_name, const char *match, char sep)
	Returns true if ALL of the regex expressions and category name match. Both can be NULL (I.E. no predicate) which results in a true return;. More...
static struct ast_config_engine *	find_engine (const char *family, int priority, char *database, int dbsiz, char *table, int tabsiz)
	Find realtime engine for realtime family. More...
static void	gen_header (FILE *f1, const char *configfile, const char *fn, const char *generator)
static char *	handle_cli_config_list (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_config_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_core_show_config_mappings (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	handle_include_exec (const char *command, const char *output_file)
static int	hash_string (const void *obj, const int flags)
static int	hashtab_compare_strings (void *a, void *b, int flags)
static int	hook_cmp (void *obj, void *arg, int flags)
static void	hook_destroy (void *obj)
static int	hook_hash (const void *obj, const int flags)
static void	inclfile_destroy (void *obj)
static int	init_appendbuf (void *data)
static void	insert_leading_blank_lines (FILE *fp, struct inclfile *fi, struct ast_comment *precomments, int lineno)
static int	is_writable (const char *fn)
static int	load_module (void)
static void	make_fn (char *fn, size_t fn_size, const char *file, const char *configfile)
static void	move_variables (struct ast_category *old, struct ast_category *new)
static struct ast_category *	new_category (const char *name, const char *in_file, int lineno, int template)
static struct ast_category *	next_available_category (struct ast_category *cat, const char *name, const char *filter)
static void	print_comment (FILE *f, struct ast_comment *comment)
static void	print_include (FILE *f, struct ast_config_include *incl)
static int	process_text_line (struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile, struct ast_flags flags, struct ast_str *comment_buffer, struct ast_str *lline_buffer, const char *suggested_include_file, struct ast_category **last_cat, struct ast_variable **last_var, struct ast_config_include **last_inc, const char *who_asked)
	parse one line in the configuration. More...
static int	realtime_arguments_to_fields2 (va_list ap, int skip, struct ast_variable **result)
int	register_config_cli (void)
	Exposed initialization method for core process. More...
static int	reload_module (void)
static struct inclfile *	set_fn (char *fn, size_t fn_size, const char *file, const char *configfile, struct ao2_container *fileset)
static int	unload_module (void)
static struct ast_variable *	variable_clone (const struct ast_variable *old)
static struct ast_variable *	variable_list_switch (struct ast_variable *l1, struct ast_variable *l2)

Variables
static struct ast_module_info	__mod_info = { .name = "extconfig" , .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Configuration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = 0, }
static struct ast_threadstorage	appendbuf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_appendbuf , .custom_init = init_appendbuf , }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ao2_container *	cfg_hooks
static struct cfmtime_head	cfmtime_head = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }
static struct ast_cli_entry	cli_config []
static struct ast_config_engine *	config_engine_list
static ast_mutex_t	config_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static struct ast_config_map *	config_maps = NULL
static char *	extconfig_conf = "extconfig.conf"
static struct ast_config_engine	text_file_engine

Detailed Description

Configuration File Parser.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Includes the Asterisk Realtime API - ARA See https://docs.asterisk.org

Definition in file main/config.c.

Macro Definition Documentation

AST_MODULE

#define AST_MODULE   "extconfig"

Definition at line 36 of file main/config.c.

CB_SIZE

#define CB_SIZE   250 /* initial size of comment buffers */

Definition at line 128 of file main/config.c.

COMMENT_END

#define COMMENT_END   "--;"

Definition at line 65 of file main/config.c.

COMMENT_META

#define COMMENT_META   ';'

Definition at line 66 of file main/config.c.

COMMENT_START

#define COMMENT_START   ";--"

Definition at line 64 of file main/config.c.

COMMENT_TAG

#define COMMENT_TAG   '-'

Definition at line 67 of file main/config.c.

MAX_INCLUDE_LEVEL

#define MAX_INCLUDE_LEVEL   10

Definition at line 218 of file main/config.c.

MAX_NESTED_COMMENTS

#define MAX_NESTED_COMMENTS   128

Definition at line 63 of file main/config.c.

MIN_VARIABLE_FNAME_SPACE

#define MIN_VARIABLE_FNAME_SPACE   40

Define the minimum filename space to reserve for each ast_variable in case the filename is renamed later by ast_include_rename().

Definition at line 74 of file main/config.c.

realtime_arguments_to_fields

#define realtime_arguments_to_fields	(		ap,
			result
	)		realtime_arguments_to_fields2(ap, 0, result)

Definition at line 3592 of file main/config.c.

UTF8_BOM

#define UTF8_BOM   "\xEF\xBB\xBF"

Enumeration Type Documentation

config_cache_attribute_enum

enum config_cache_attribute_enum

Enumerator
ATTRIBUTE_INCLUDE
ATTRIBUTE_EXEC

Definition at line 1798 of file main/config.c.

                                 {
    ATTRIBUTE_INCLUDE = 0,
    ATTRIBUTE_EXEC = 1,
};

include_statement_type

enum include_statement_type

Types used for ast_include_new() include_type.

Enumerator
CONFIG_STATEMENT_INCLUDE	#include statements
CONFIG_STATEMENT_EXEC	exec statements
CONFIG_STATEMENT_TRYINCLUDE	#tryinclude statements

Definition at line 275 of file main/config.c.

                            {
    /*! #include statements */
    CONFIG_STATEMENT_INCLUDE    = 0,
    /*! #exec statements */
    CONFIG_STATEMENT_EXEC       = 1,
    /*! #tryinclude statements */
    CONFIG_STATEMENT_TRYINCLUDE = 2,
};

Function Documentation

__init_appendbuf()

static void __init_appendbuf ( void  )

static

Definition at line 125 of file main/config.c.

{

__reg_module()

static void __reg_module ( void  )

static

Definition at line 4619 of file main/config.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 4619 of file main/config.c.

_ast_variable_new()

struct ast_variable * _ast_variable_new	(	const char *	name,
		const char *	value,
		const char *	filename,
		const char *	file,
		const char *	func,
		int	lineno
	)

Definition at line 315 of file main/config.c.

{
    struct ast_variable *variable;
    int name_len = strlen(name) + 1;
    int val_len = strlen(value) + 1;
    int fn_len = strlen(filename) + 1;
 
    /* Ensure a minimum length in case the filename is changed later. */
    if (fn_len < MIN_VARIABLE_FNAME_SPACE) {
        fn_len = MIN_VARIABLE_FNAME_SPACE;
    }
 
    variable = __ast_calloc(1, fn_len + name_len + val_len + sizeof(*variable),
        file, lineno, func);
    if (variable) {
        char *dst = variable->stuff;    /* writable space starts here */
 
        /* Put file first so ast_include_rename() can calculate space available. */
        variable->file = strcpy(dst, filename);
        dst += fn_len;
        variable->name = strcpy(dst, name);
        dst += name_len;
        variable->value = strcpy(dst, value);
    }
    return variable;
}

References __ast_calloc(), ast_variable::file, make_ari_stubs::file, ast_variable::lineno, MIN_VARIABLE_FNAME_SPACE, name, ast_variable::name, ast_variable::stuff, ast_variable::value, and value.

ALLOC_COMMENT()

static struct ast_comment * ALLOC_COMMENT ( struct ast_str *  buffer )

static

Definition at line 154 of file main/config.c.

{
    struct ast_comment *x = NULL;
    if (!buffer || !ast_str_strlen(buffer)) {
        return NULL;
    }
    if ((x = ast_calloc(1, sizeof(*x) + ast_str_strlen(buffer) + 1))) {
        strcpy(x->cmt, ast_str_buffer(buffer)); /* SAFE */
    }
    return x;
}

References ast_calloc, ast_str_buffer(), ast_str_strlen(), ast_comment::cmt, and NULL.

Referenced by config_text_file_load(), and process_text_line().

ast_category_append()

void ast_category_append	(	struct ast_config *	config,
		struct ast_category *	category
	)

Appends a category to a config.

Parameters

config	which config to use
category	category to insert

Definition at line 1251 of file main/config.c.

{
    if (config->last) {
        config->last->next = category;
        category->prev = config->last;
    } else {
        config->root = category;
        category->prev = NULL;
    }
    category->next = NULL;
    category->include_level = config->include_level;
 
    config->last = category;
    config->current = category;
}

References config, ast_category::include_level, ast_category::next, NULL, and ast_category::prev.

Referenced by append_row_to_cfg(), ast_config_copy(), AST_TEST_DEFINE(), build_cfg(), config_curl(), config_ldap(), config_mysql(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_sorcery_multi(), realtime_sorcery_store(), realtime_sorcery_update(), static_realtime_cb(), and write_password_to_file().

ast_category_browse()

char * ast_category_browse	(	struct ast_config *	config,
		const char *	prev_name
	)

Browse categories.

Parameters

config	Which config structure you wish to "browse"
prev_name	A pointer to a previous category name.

This function is kind of non-intuitive in it's use. To begin, one passes NULL as the second argument. It will return a pointer to the string of the first category in the file. From here on after, one must then pass the previous usage's return value as the second pointer, and it will return a pointer to the category name afterwards.

Return values

a	category name on success
NULL	on failure/no-more-categories

Note

ast_category_browse maintains internal state. Therefore is not thread safe, cannot be called recursively, and it is not safe to add or remove categories while browsing. ast_category_browse_filtered does not have these restrictions.

Definition at line 1491 of file main/config.c.

{
    struct ast_category *cat;
 
    if (!prev_name) {
        /* First time browse. */
        cat = config->root;
    } else if (config->last_browse && (config->last_browse->name == prev_name)) {
        /* Simple last browse found. */
        cat = config->last_browse->next;
    } else {
        /*
         * Config changed since last browse.
         *
         * First try cheap last browse search. (Rebrowsing a different
         * previous category?)
         */
        for (cat = config->root; cat; cat = cat->next) {
            if (cat->name == prev_name) {
                /* Found it. */
                cat = cat->next;
                break;
            }
        }
        if (!cat) {
            /*
             * Have to do it the hard way. (Last category was deleted and
             * re-added?)
             */
            for (cat = config->root; cat; cat = cat->next) {
                if (!strcasecmp(cat->name, prev_name)) {
                    /* Found it. */
                    cat = cat->next;
                    break;
                }
            }
        }
    }
 
    if (cat)
        cat = next_available_category(cat, NULL, NULL);
 
    config->last_browse = cat;
    return (cat) ? cat->name : NULL;
}

References config, ast_category::name, ast_category::next, next_available_category(), NULL, and ast_category::prev.

Referenced by __init_manager(), __queues_show(), ast_cli_perms_init(), AST_TEST_DEFINE(), check_for_old_config(), conf_exec(), find_queue_by_name_rt(), find_realtime(), iax_provision_reload(), internal_process_ast_config(), load_common(), load_config(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_realtime_musiconhold(), load_realtime_queues(), load_realtime_rules(), load_tech_calendars(), load_users(), mbl_load_config(), named_acl_find_realtime(), parse_config(), pbx_load_config(), realtime_directory(), realtime_sorcery(), realtime_sorcery_multi(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), search_directory(), set_config(), set_member_value(), setup_dahdi_int(), show_users_realtime(), sla_load_config(), test_config_validity(), update_realtime_members(), and vm_change_password().

ast_category_browse_filtered()

struct ast_category * ast_category_browse_filtered	(	struct ast_config *	config,
		const char *	category_name,
		struct ast_category *	prev,
		const char *	filter
	)

Browse categories with filters.

Parameters

config	Which config structure you wish to "browse"
category_name	An optional category name. Pass NULL to not restrict by category name.
prev	A pointer to the starting category structure. Pass NULL to start at the beginning.
filter	An optional comma-separated list of <name_regex>=<value_regex> pairs. Only categories with matching variables will be returned. The special name 'TEMPLATES' can be used with the special values 'include' or 'restrict' to include templates in the result or restrict the result to only templates.

Return values

a	category on success
NULL	on failure/no-more-categories

Definition at line 1537 of file main/config.c.

{
    struct ast_category *cat;
 
    if (!prev) {
        prev = config->root;
    } else {
        prev = prev->next;
    }
 
    cat = next_available_category(prev, category_name, filter);
 
    return cat;
}

References config, filter(), ast_category::next, next_available_category(), and ast_category::prev.

Referenced by action_getconfig(), action_getconfigjson(), action_listcategories(), AST_TEST_DEFINE(), ast_variable_retrieve_filtered(), handle_updates(), object_type_loaded_observer(), sorcery_config_internal_load(), and sorcery_realtime_retrieve_multiple().

ast_category_delete()

struct ast_category * ast_category_delete	(	struct ast_config *	cfg,
		struct ast_category *	cat
	)

Delete a category.

Parameters

cfg	which config to use
cat	category to delete

Returns

the category after the deleted one which could be NULL.

Note

It is not safe to call ast_category_delete while browsing with ast_category_browse. It is safe with ast_category_browse_filtered.

Definition at line 1696 of file main/config.c.

{
    struct ast_category *prev;
 
    if (!config || !category) {
        return NULL;
    }
 
    if (category->prev) {
        category->prev->next = category->next;
    } else {
        config->root = category->next;
    }
 
    if (category->next) {
        category->next->prev = category->prev;
    } else {
        config->last = category->prev;
    }
 
    prev = category->prev;
 
    if (config->last_browse == category) {
        config->last_browse = prev;
    }
 
    ast_category_destroy(category);
 
    return prev;
}

References ast_category_destroy(), config, ast_category::next, NULL, and ast_category::prev.

Referenced by AST_TEST_DEFINE(), handle_updates(), object_type_loaded_observer(), realtime_sorcery_destroy(), and realtime_sorcery_update().

ast_category_destroy()

void ast_category_destroy

(

struct ast_category *

cat

)

Definition at line 1306 of file main/config.c.

{
    ast_variables_destroy(cat->root);
    cat->root = NULL;
    cat->last = NULL;
    ast_comment_destroy(&cat->precomments);
    ast_comment_destroy(&cat->sameline);
    ast_comment_destroy(&cat->trailing);
    ast_destroy_template_list(cat);
    ast_free(cat->file);
    ast_free(cat);
}

References ast_comment_destroy(), ast_destroy_template_list(), ast_free, ast_variables_destroy(), ast_category::file, free(), ast_category::last, NULL, ast_category::precomments, ast_category::root, ast_category::sameline, and ast_category::trailing.

Referenced by ast_category_delete(), ast_config_destroy(), handle_updates(), new_category(), process_text_line(), realtime_multi_odbc(), static_realtime_cb(), and write_password_to_file().

ast_category_detach_variables()

struct ast_variable * ast_category_detach_variables

(

struct ast_category *

cat

)

Definition at line 1553 of file main/config.c.

{
    struct ast_variable *v;
 
    v = cat->root;
    cat->root = NULL;
    cat->last = NULL;
 
    return v;
}

References ast_category::last, NULL, and ast_category::root.

Referenced by realtime_switch_common(), and sorcery_realtime_retrieve_multiple().

ast_category_empty()

int ast_category_empty

(

struct ast_category *

category

)

Removes and destroys all variables in a category.

Parameters

category

category to empty

Return values

0	if succeeded
-1	if category is NULL

Definition at line 1728 of file main/config.c.

{
    if (!category) {
        return -1;
    }
 
    ast_variables_destroy(category->root);
    category->root = NULL;
    category->last = NULL;
 
    return 0;
}

References ast_variables_destroy(), ast_category::last, NULL, and ast_category::root.

Referenced by AST_TEST_DEFINE(), and handle_updates().

ast_category_exist()

int ast_category_exist	(	const struct ast_config *	config,
		const char *	category_name,
		const char *	filter
	)

Check for category duplicates.

Parameters

config	which config to use
category_name	name of the category you're looking for
filter	an optional comma-separated list of <name_regex>=<value_regex> pairs. Only categories with matching variables will be returned. The special name 'TEMPLATES' can be used with the special values 'include' or 'restrict' to include templates in the result or restrict the result to only templates.

This will search through the categories within a given config file for a match.

Returns

non-zero if found

Definition at line 1245 of file main/config.c.

{
    return !!ast_category_get(config, category_name, filter);
}

References ast_category_get(), config, and filter().

Referenced by realtime_sorcery_store().

ast_category_first()

struct ast_variable * ast_category_first

(

struct ast_category *

cat

)

given a pointer to a category, return the root variable.

return the first var of a category

Definition at line 1359 of file main/config.c.

{
    return (cat) ? cat->root : NULL;
}

References NULL, and ast_category::root.

Referenced by acl_order_comparator(), action_getconfig(), action_getconfigjson(), handle_aor(), handle_auth(), handle_endpoint(), handle_identify(), handle_phoneprov(), handle_registrations(), object_type_loaded_observer(), process_text_line(), sorcery_config_internal_load(), sorcery_is_criteria_met(), sorcery_is_explicit_name_met(), and wizard_apply_handler().

ast_category_get()

struct ast_category * ast_category_get	(	const struct ast_config *	config,
		const char *	category_name,
		const char *	filter
	)

Retrieve a category if it exists.

Parameters

config	which config to use
category_name	name of the category you're looking for
filter	If a config contains more than 1 category with the same name, you can specify a filter to narrow the search. The filter is a comma-separated list of <name_regex>=<value_regex> pairs. Only a category with matching variables will be returned. The special name 'TEMPLATES' can be used with the special values 'include' or 'restrict' to include templates in the result or restrict the result to only templates.

This will search through the categories within a given config file for a match.

Return values

pointer	to category if found
NULL	if not.

Definition at line 1206 of file main/config.c.

{
    return category_get_sep(config, category_name, filter, ',', 1);
}

References category_get_sep(), config, and filter().

Referenced by add_message_id(), ast_category_exist(), ast_category_root(), AST_TEST_DEFINE(), ast_variable_browse(), handle_updates(), object_type_loaded_observer(), realtime_directory(), realtime_sorcery_destroy(), realtime_sorcery_update(), realtime_switch_common(), vm_change_password(), and vm_forwardoptions().

ast_category_get_name()

const char * ast_category_get_name

(

const struct ast_category *

category

)

Return the name of the category.

Parameters

category

category structure

Return values

pointer	to category name if found
NULL	if not.

Definition at line 1212 of file main/config.c.

{
    return category->name;
}

References ast_category::name.

Referenced by action_getconfig(), action_getconfigjson(), action_listcategories(), AST_TEST_DEFINE(), handle_aor(), handle_auth(), handle_endpoint(), handle_identify(), handle_phoneprov(), handle_registrations(), object_type_loaded_observer(), sorcery_config_internal_load(), and sorcery_is_explicit_name_met().

ast_category_get_templates()

struct ast_str * ast_category_get_templates

(

const struct ast_category *

category

)

Return the template names this category inherits from.

Parameters

category

category structure

Returns

an ast_str (which must be freed after use) with a comma separated list of templates names or NULL if there were no templates.

Definition at line 1222 of file main/config.c.

{
    struct ast_category_template_instance *template;
    struct ast_str *str;
    int first = 1;
 
    if (AST_LIST_EMPTY(&category->template_instances)) {
        return NULL;
    }
 
    str = ast_str_create(128);
    if (!str) {
        return NULL;
    }
 
    AST_LIST_TRAVERSE(&category->template_instances, template, next) {
        ast_str_append(&str, 0, "%s%s", first ? "" : ",", template->name);
        first = 0;
    }
 
    return str;
}

References AST_LIST_EMPTY, AST_LIST_TRAVERSE, ast_str_append(), ast_str_create, first, ast_category::next, NULL, str, and ast_category::template_instances.

Referenced by action_getconfig(), and action_getconfigjson().

ast_category_inherit()

int ast_category_inherit	(	struct ast_category *	existing,
		const struct ast_category *	base
	)

Applies base (template) to category.

Parameters

existing	existing category
base	base category

This function is used to apply a base (template) to an existing category

Return values

0	if succeeded
-1	if the memory allocation failed

Definition at line 1569 of file main/config.c.

{
    struct ast_variable *var;
    struct ast_category_template_instance *x;
 
    x = ast_calloc(1, sizeof(*x));
    if (!x) {
        return -1;
    }
    strcpy(x->name, base->name);
    x->inst = base;
    AST_LIST_INSERT_TAIL(&new->template_instances, x, next);
    for (var = base->root; var; var = var->next) {
        struct ast_variable *cloned = variable_clone(var);
        if (!cloned) {
            return -1;
        }
        cloned->inherited = 1;
        ast_variable_append(new, cloned);
    }
    return 0;
}

References ast_calloc, AST_LIST_INSERT_TAIL, ast_variable_append(), ast_variable::inherited, ast_category_template_instance::inst, ast_category_template_instance::name, ast_category::name, ast_category::next, ast_category::root, var, and variable_clone().

Referenced by handle_updates(), and process_text_line().

ast_category_insert()

int ast_category_insert	(	struct ast_config *	config,
		struct ast_category *	cat,
		const char *	match
	)

Inserts new category.

Parameters

config	which config to use
cat	newly created category to insert
match	which category to insert above

This function is used to insert a new category above another category matching the match parameter.

Return values

0	if succeeded
-1	if the specified match category wasn't found

Definition at line 1267 of file main/config.c.

{
    struct ast_category *cur_category;
 
    if (!config || !config->root || !cat || !match) {
        return -1;
    }
 
    if (!strcasecmp(config->root->name, match)) {
        cat->next = config->root;
        cat->prev = NULL;
        config->root->prev = cat;
        config->root = cat;
        return 0;
    }
 
    for (cur_category = config->root->next; cur_category; cur_category = cur_category->next) {
        if (!strcasecmp(cur_category->name, match)) {
            cat->prev = cur_category->prev;
            cat->prev->next = cat;
 
            cat->next = cur_category;
            cur_category->prev = cat;
 
            return 0;
        }
    }
 
    return -1;
}

References config, match(), ast_category::name, ast_category::next, NULL, and ast_category::prev.

Referenced by AST_TEST_DEFINE(), and handle_updates().

ast_category_is_template()

int ast_category_is_template

(

const struct ast_category *

category

)

Check if category is a template.

Parameters

category

category structure

Return values

1	if a template.
0	if not.

Definition at line 1217 of file main/config.c.

{
    return category->ignored;
}

References ast_category::ignored.

Referenced by action_getconfig(), and action_getconfigjson().

ast_category_new()

struct ast_category * ast_category_new	(	const char *	name,
		const char *	in_file,
		int	lineno
	)

Create a category.

Parameters

name	name of new category
in_file	filename which contained the new config
lineno	line number

Definition at line 1174 of file main/config.c.

{
    return new_category(name, in_file, lineno, 0);
}

References ast_calloc, ast_copy_string(), ast_category::file, ast_category::lineno, ast_category::name, name, new_category(), and strdup.

Referenced by ast_config_copy(), AST_TEST_DEFINE(), build_cfg(), handle_updates(), process_text_line(), realtime_sorcery_multi(), realtime_sorcery_store(), realtime_sorcery_update(), and write_password_to_file().

ast_category_new_template()

struct ast_category * ast_category_new_template	(	const char *	name,
		const char *	in_file,
		int	lineno
	)

Create a category making it a template.

Parameters

name	name of new template
in_file	filename which contained the new config
lineno	line number

Definition at line 1179 of file main/config.c.

{
    return new_category(name, in_file, lineno, 1);
}

References ast_category::lineno, name, and new_category().

Referenced by AST_TEST_DEFINE(), and handle_updates().

ast_category_rename()

void ast_category_rename	(	struct ast_category *	cat,
		const char *	name
	)

Definition at line 1564 of file main/config.c.

{
    ast_copy_string(cat->name, name, sizeof(cat->name));
}

References ast_copy_string(), ast_category::name, and name.

Referenced by handle_updates(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_mysql(), realtime_multi_odbc(), and realtime_multi_pgsql().

ast_category_root()

struct ast_variable * ast_category_root	(	struct ast_config *	config,
		char *	cat
	)

returns the root ast_variable of a config

Parameters

config	pointer to an ast_config data structure
cat	name of the category for which you want the root

Returns

the category specified

Definition at line 1364 of file main/config.c.

{
    struct ast_category *category = ast_category_get(config, cat, NULL);
 
    if (category)
        return category->root;
    return NULL;
}

References ast_category_get(), config, NULL, and ast_category::root.

Referenced by config_function_read(), realtime_sorcery(), and realtime_sorcery_multi().

ast_check_realtime()

int ast_check_realtime

(

const char *

family

)

Check if realtime engine is configured for family.

Parameters

family

which family/config to be checked

Returns

1 if family is configured in realtime and engine exists

Definition at line 3797 of file main/config.c.

{
    struct ast_config_engine *eng;
    if (!ast_realtime_enabled()) {
        return 0;   /* There are no engines at all so fail early */
    }
 
    eng = find_engine(family, 1, NULL, 0, NULL, 0);
    if (eng)
        return 1;
    return 0;
}

References ast_realtime_enabled(), find_engine(), and NULL.

Referenced by __queues_show(), ast_named_acl_find(), ast_queue_log(), close_mailbox(), copy_plain_file(), handle_voicemail_show_users(), leave_voicemail(), load_module(), load_moh_classes(), load_realtime_queues(), load_realtime_rules(), local_ast_moh_start(), logger_queue_rt_start(), manager_queues_status(), manager_queues_summary(), msg_create_from_file(), rename_file(), set_member_paused(), set_member_value(), and vm_delete().

ast_comment_destroy()

static void ast_comment_destroy ( struct ast_comment **  comment )

static

Definition at line 610 of file main/config.c.

{
    struct ast_comment *n, *p;
 
    for (p = *comment; p; p = n) {
        n = p->next;
        ast_free(p);
    }
 
    *comment = NULL;
}

References ast_free, comment, ast_comment::next, and NULL.

Referenced by ast_category_destroy(), ast_include_destroy(), and ast_variable_destroy().

ast_config_copy()

struct ast_config * ast_config_copy

(

const struct ast_config *

orig

)

Copies the contents of one ast_config into another.

Note

This creates a config on the heap. The caller of this must be prepared to free the memory returned.

Parameters

orig	the config to copy

Returns

The new config on success, NULL on failure.

Definition at line 3501 of file main/config.c.

{
    struct ast_config *new_config = ast_config_new();
    struct ast_category *cat_iter;
 
    if (!new_config) {
        return NULL;
    }
 
    for (cat_iter = old->root; cat_iter; cat_iter = cat_iter->next) {
        struct ast_category *new_cat =
            ast_category_new(cat_iter->name, cat_iter->file, cat_iter->lineno);
        if (!new_cat) {
            goto fail;
        }
        ast_category_append(new_config, new_cat);
        if (cat_iter->root) {
            new_cat->root = ast_variables_dup(cat_iter->root);
            if (!new_cat->root) {
                goto fail;
            }
            new_cat->last = cat_iter->last;
        }
    }
 
    return new_config;
 
fail:
    ast_config_destroy(new_config);
    return NULL;
}

References ast_category_append(), ast_category_new(), ast_config_destroy(), ast_config_new(), ast_variables_dup(), ast_category::file, ast_category::last, ast_category::lineno, ast_category::name, ast_category::next, NULL, ast_category::root, and ast_config::root.

Referenced by AST_TEST_DEFINE(), and config_hook_exec().

ast_config_destroy()

void ast_config_destroy

(

struct ast_config *

cfg

)

Destroys a config.

Parameters

cfg	pointer to config data structure

Free memory associated with a given config

Definition at line 1741 of file main/config.c.

{
    struct ast_category *cat, *catn;
 
    if (!cfg)
        return;
 
    ast_includes_destroy(cfg->includes_root);
 
    cat = cfg->root;
    while (cat) {
        catn = cat;
        cat = cat->next;
        ast_category_destroy(catn);
    }
    ast_free(cfg);
}

References ast_category_destroy(), ast_free, ast_includes_destroy(), ast_variables_destroy(), free(), ast_config::includes, ast_config::includes_root, ast_category::next, ast_category::root, and ast_config::root.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_sorcery_apply_config(), __init_manager(), __queues_show(), _dsp_init(), aco_process_config(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), adsi_load(), advanced_options(), ast_cli_perms_init(), ast_config_copy(), ast_config_load2(), ast_init_logger_for_socket_console(), ast_load_realtime_multientry_fields(), AST_TEST_DEFINE(), build_cfg(), check_for_old_config(), conf_exec(), config_function_read(), config_module(), deinitialize_sorcery(), directory_exec(), do_reload(), festival_exec(), find_conf(), find_load_queue_rt_friendly(), find_realtime(), forward_message(), get_defaults(), handle_cli_dialplan_save(), hook_cb(), iax_provision_reload(), init_logger_chain(), initialize_cc_devstate_map(), initialize_cc_max_requests(), load_asterisk_conf(), load_common(), load_config(), load_config_force(), load_config_meetme(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_realtime_musiconhold(), load_realtime_queues(), load_realtime_rules(), load_users(), loader_config_init(), make_email_file(), mbl_load_config(), message_range_and_existence_check(), my_load_module(), named_acl_find_realtime(), notify_new_message(), object_type_loaded_observer(), odbc_load_module(), parse_config(), parse_general_options(), pbx_load_config(), play_message(), prep_email_sub_vars(), private_enum_init(), process_config(), read_password_from_file(), read_pjproject_startup_options(), realtime_directory(), realtime_multi_mysql(), realtime_multi_pgsql(), realtime_sorcery_multi(), realtime_sqlite3_multi(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_queues(), rtp_reload(), run_startup_commands(), set_config(), set_member_value(), setup_dahdi_int(), show_users_realtime(), sla_load_config(), smdi_load(), sorcery_config_internal_load(), sorcery_realtime_retrieve_multiple(), tds_load_module(), unload_module(), update_realtime_members(), vm_change_password(), vm_forwardoptions(), vm_msg_forward(), vm_msg_play(), vm_msg_snapshot_create(), write_password_to_file(), and xmldoc_load_documentation().

ast_config_engine_deregister()

int ast_config_engine_deregister

(

struct ast_config_engine *

del

)

Deregister config engine.

Return values

0

Always

Definition at line 3428 of file main/config.c.

{
    struct ast_config_engine *ptr, *last=NULL;
 
    SCOPED_MUTEX(lock, &config_lock);
 
    for (ptr = config_engine_list; ptr; ptr=ptr->next) {
        if (ptr == del) {
            if (last)
                last->next = ptr->next;
            else
                config_engine_list = ptr->next;
            break;
        }
        last = ptr;
    }
 
    return 0;
}

References config_engine_list, config_lock, last, lock, sla_ringing_trunk::next, ast_config_engine::next, NULL, and SCOPED_MUTEX.

Referenced by unload_module().

ast_config_engine_register()

int ast_config_engine_register

(

struct ast_config_engine *

newconfig

)

Register config engine.

Return values

1

Always

Definition at line 3412 of file main/config.c.

{
    struct ast_config_engine *ptr;
 
    SCOPED_MUTEX(lock, &config_lock);
 
    if (!config_engine_list) {
        config_engine_list = new;
    } else {
        for (ptr = config_engine_list; ptr->next; ptr=ptr->next);
        ptr->next = new;
    }
 
    return 1;
}

References config_engine_list, config_lock, lock, ast_config_engine::next, and SCOPED_MUTEX.

Referenced by load_module().

ast_config_get_current_category()

struct ast_category * ast_config_get_current_category

(

const struct ast_config *

cfg

)

Retrieve the current category name being built.

API for backend configuration engines while building a configuration set.

Definition at line 1759 of file main/config.c.

{
    return cfg->current;
}

References ast_config::current.

Referenced by config_text_file_load().

ast_config_hook_register()

int ast_config_hook_register	(	const char *	name,
		const char *	filename,
		const char *	module,
		enum config_hook_flags	flags,
		config_hook_cb	hook
	)

Register a config hook for a particular file and module.

Parameters

name	The name of the hook you are registering.
filename	The file whose config you wish to hook into.
module	The module that is reloading the config. This can be useful if multiple modules may possibly reload the same file, but you are only interested when a specific module reloads the file
flags	Flags that affect the way hooks work.
hook	The callback to be called when config is loaded. return 0 Success return -1 Unsuccess, also known as UTTER AND COMPLETE FAILURE

Definition at line 4569 of file main/config.c.

{
    struct cfg_hook *hook;
    if (!cfg_hooks) {
        cfg_hooks = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 17,
            hook_hash, NULL, hook_cmp);
        if (!cfg_hooks) {
            return -1;
        }
    }
 
    if (!(hook = ao2_alloc(sizeof(*hook), hook_destroy))) {
        return -1;
    }
 
    hook->hook_cb = hook_cb;
    hook->filename = ast_strdup(filename);
    hook->name = ast_strdup(name);
    hook->module = ast_strdup(module);
 
    ao2_link(cfg_hooks, hook);
    ao2_ref(hook, -1);
    return 0;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_link, ao2_ref, ast_strdup, cfg_hooks, cfg_hook::filename, cfg_hook::hook_cb, hook_cb(), hook_cmp(), hook_destroy(), hook_hash(), cfg_hook::module, name, cfg_hook::name, and NULL.

Referenced by AST_TEST_DEFINE().

ast_config_hook_unregister()

void ast_config_hook_unregister

(

const char *

name

)

Unregister a config hook.

Parameters

name	The name of the hook to unregister

Definition at line 4541 of file main/config.c.

{
    struct cfg_hook tmp;
 
    tmp.name = ast_strdupa(name);
 
    ao2_find(cfg_hooks, &tmp, OBJ_POINTER | OBJ_UNLINK | OBJ_NODATA);
}

References ao2_find, ast_strdupa, cfg_hooks, name, cfg_hook::name, OBJ_NODATA, OBJ_POINTER, and OBJ_UNLINK.

Referenced by AST_TEST_DEFINE().

ast_config_internal_load()

struct ast_config * ast_config_internal_load	(	const char *	filename,
		struct ast_config *	cfg,
		struct ast_flags	flags,
		const char *	suggested_include_file,
		const char *	who_asked
	)

Definition at line 3534 of file main/config.c.

{
    char db[256];
    char table[256];
    struct ast_config_engine *loader = &text_file_engine;
    struct ast_config *result;
 
    /* The config file itself bumps include_level by 1 */
    if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) {
        ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
        return NULL;
    }
 
    cfg->include_level++;
 
    if (!ast_test_flag(&flags, CONFIG_FLAG_NOREALTIME) && config_engine_list) {
        struct ast_config_engine *eng;
 
        eng = find_engine(filename, 1, db, sizeof(db), table, sizeof(table));
 
 
        if (eng && eng->load_func) {
            loader = eng;
        } else {
            eng = find_engine("global", 1, db, sizeof(db), table, sizeof(table));
            if (eng && eng->load_func)
                loader = eng;
        }
    }
 
    result = loader->load_func(db, table, filename, cfg, flags, suggested_include_file, who_asked);
 
    if (result && result != CONFIG_STATUS_FILEINVALID && result != CONFIG_STATUS_FILEUNCHANGED) {
        result->include_level--;
        config_hook_exec(filename, who_asked, result);
    } else if (result != CONFIG_STATUS_FILEINVALID) {
        cfg->include_level--;
    }
 
    return result;
}

References ast_log, ast_test_flag, config_engine_list, CONFIG_FLAG_NOREALTIME, config_hook_exec(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, NULL, result, table, and text_file_engine.

Referenced by ast_config_load2(), config_curl(), config_ldap(), config_mysql(), config_odbc(), config_pgsql(), process_text_line(), reload_module(), and static_realtime_cb().

ast_config_load2()

struct ast_config * ast_config_load2	(	const char *	filename,
		const char *	who_asked,
		struct ast_flags	flags
	)

Load a config file.

Parameters

filename	path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR
who_asked	The module which is making this request.
flags	Optional flags: CONFIG_FLAG_WITHCOMMENTS - load the file with comments intact; CONFIG_FLAG_FILEUNCHANGED - check the file mtime and return CONFIG_STATUS_FILEUNCHANGED if the mtime is the same; or CONFIG_FLAG_NOCACHE - don't cache file mtime (main purpose of this option is to save memory on temporary files).

Create a config structure from a given configuration file.

Returns

an ast_config data structure on success

Return values

NULL

on error

Definition at line 3576 of file main/config.c.

{
    struct ast_config *cfg;
    struct ast_config *result;
 
    cfg = ast_config_new();
    if (!cfg)
        return NULL;
 
    result = ast_config_internal_load(filename, cfg, flags, "", who_asked);
    if (!result || result == CONFIG_STATUS_FILEUNCHANGED || result == CONFIG_STATUS_FILEINVALID)
        ast_config_destroy(cfg);
 
    return result;
}

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, NULL, and result.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_sorcery_apply_config(), __init_manager(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), ast_cli_perms_init(), ast_init_logger_for_socket_console(), AST_TEST_DEFINE(), do_reload(), iax_provision_reload(), init_logger_chain(), initialize_cc_devstate_map(), initialize_cc_max_requests(), load_asterisk_conf(), load_config(), load_indications(), loader_config_init(), object_type_loaded_observer(), parse_general_options(), private_enum_init(), read_pjproject_startup_options(), rtp_reload(), run_startup_commands(), set_config(), sorcery_config_internal_load(), and xmldoc_load_documentation().

ast_config_new()

struct ast_config * ast_config_new

(

void

)

Create a new base configuration structure.

Definition at line 1592 of file main/config.c.

{
    struct ast_config *config;
 
    if ((config = ast_calloc(1, sizeof(*config))))
        config->max_include_level = MAX_INCLUDE_LEVEL;
    return config;
}

References ast_calloc, config, and MAX_INCLUDE_LEVEL.

Referenced by alloc_and_initialize_sorcery(), ast_config_copy(), ast_config_load2(), AST_TEST_DEFINE(), build_cfg(), find_load_queue_rt_friendly(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_sorcery_multi(), realtime_sqlite3_multi(), reload_module(), setup_dahdi_int(), and write_password_to_file().

ast_config_option()

const char * ast_config_option	(	struct ast_config *	cfg,
		const char *	cat,
		const char *	var
	)

Retrieve a configuration variable within the configuration set.

Retrieves the named variable var within category cat of configuration set cfg. If not found, attempts to retrieve the named variable var from within category general.

Returns

Value of var, or NULL if not found.

Definition at line 860 of file main/config.c.

{
    const char *tmp;
    tmp = ast_variable_retrieve(cfg, cat, var);
    if (!tmp) {
        tmp = ast_variable_retrieve(cfg, "general", var);
    }
    return tmp;
}

References ast_variable_retrieve(), and var.

Referenced by process_config().

ast_config_set_current_category()

void ast_config_set_current_category	(	struct ast_config *	cfg,
		const struct ast_category *	cat
	)

Set the category within the configuration as being current.

API for backend configuration engines while building a configuration set.

Definition at line 1764 of file main/config.c.

{
    /* cast below is just to silence compiler warning about dropping "const" */
    cfg->current = (struct ast_category *) cat;
}

References ast_config::current.

Referenced by process_text_line().

ast_config_sort_categories()

void ast_config_sort_categories	(	struct ast_config *	config,
		int	descending,
		int(*)(struct ast_category *p, struct ast_category *q)	comparator
	)

Sorts categories in a config in the order of a numerical value contained within them.

Parameters

config	The config structure you wish to sort
comparator	variable Which numerical value you wish to sort by
descending	If true, we sort highest to lowest instead of lowest to highest

This function will assume a value of 0 for any non-numerical strings and NULL fields.

Definition at line 1373 of file main/config.c.

{
    /*
     * The contents of this function are adapted from
     * an example of linked list merge sorting
     * copyright 2001 Simon Tatham.
     *
     * Permission is hereby granted, free of charge, to any person
     * obtaining a copy of this software and associated documentation
     * files (the "Software"), to deal in the Software without
     * restriction, including without limitation the rights to use,
     * copy, modify, merge, publish, distribute, sublicense, and/or
     * sell copies of the Software, and to permit persons to whom the
     * Software is furnished to do so, subject to the following
     * conditions:
     *
     * The above copyright notice and this permission notice shall be
     * included in all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
     * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
     * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
     * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
     * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
     * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
     * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     * SOFTWARE.
     */
 
    int insize = 1;
    struct ast_category *p, *q, *e, *tail;
    int nmerges, psize, qsize, i;
 
    /* If the descending flag was sent, we'll apply inversion to the comparison function's return. */
    if (descending) {
        descending = -1;
    } else {
        descending = 1;
    }
 
    if (!config->root) {
        return;
    }
 
    while (1) {
        p = config->root;
        config->root = NULL;
        tail = NULL;
 
        nmerges = 0; /* count number of merges we do in this pass */
 
        while (p) {
            nmerges++; /* there exists a merge to be done */
 
            /* step `insize' places along from p */
            q = p;
            psize = 0;
            for (i = 0; i < insize; i++) {
                psize++;
                q = q->next;
                if (!q) {
                    break;
                }
            }
 
            /* if q hasn't fallen off end, we have two lists to merge */
            qsize = insize;
 
            /* now we have two lists; merge them */
            while (psize > 0 || (qsize > 0 && q)) {
                /* decide whether next element of merge comes from p or q */
                if (psize == 0) {
                    /* p is empty; e must come from q. */
                    e = q;
                    q = q->next;
                    qsize--;
                } else if (qsize == 0 || !q) {
                    /* q is empty; e must come from p. */
                    e = p; p = p->next; psize--;
                } else if ((comparator(p, q) * descending) <= 0) {
                    /* First element of p is lower (or same) e must come from p. */
                    e = p;
                    p = p->next;
                    psize--;
                } else {
                    /* First element of q is lower; e must come from q. */
                    e = q;
                    q = q->next;
                    qsize--;
                }
 
                /* add the next element to the merged list */
                if (tail) {
                    tail->next = e;
                } else {
                    config->root = e;
                }
                tail = e;
            }
 
            /* now p has stepped `insize' places along, and q has too */
            p = q;
        }
 
        tail->next = NULL;
 
        /* If we have done only one merge, we're finished. */
        if (nmerges <= 1) { /* allow for nmerges==0, the empty list case */
            return;
        }
 
        /* Otherwise repeat, merging lists twice the size */
        insize *= 2;
    }
 
}

References config, ast_category::next, and NULL.

Referenced by named_acl_find_realtime(), and realtime_switch_common().

ast_config_text_file_save()

int ast_config_text_file_save	(	const char *	filename,
		const struct ast_config *	cfg,
		const char *	generator
	)

Save a config text file preserving the pre 13.2 behavior.

Parameters

filename	Filename
cfg	ast_config
generator	generator

Return values

0	on success.
-1	on failure.

Definition at line 2870 of file main/config.c.

{
    return ast_config_text_file_save2(configfile, cfg, generator, CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT);
}

References ast_config_text_file_save2(), and CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT.

Referenced by add_message_id(), AST_TEST_DEFINE(), vm_change_password(), vm_forwardoptions(), and write_password_to_file().

ast_config_text_file_save2()

int ast_config_text_file_save2	(	const char *	filename,
		const struct ast_config *	cfg,
		const char *	generator,
		uint32_t	flags
	)

Save a config text file.

Since

13.2.0

Parameters

filename	Filename
cfg	ast_config
generator	generator
flags	List of config_save_flags

Return values

0	on success.
-1	on failure.

Definition at line 2929 of file main/config.c.

{
    FILE *f;
    char fn[PATH_MAX];
    struct ast_variable *var;
    struct ast_category *cat;
    struct ast_comment *cmt;
    struct ast_config_include *incl;
    int blanklines = 0;
    struct ao2_container *fileset;
    struct inclfile *fi;
 
    /* Check all the files for write access before attempting to modify any of them */
    for (incl = cfg->includes_root; incl; incl = incl->next) {
        /* reset all the output flags in case this isn't our first time saving this data */
        incl->output = 0;
 
        if (incl->include_type != CONFIG_STATEMENT_EXEC) {
            struct config_included_file *included_file;
            int ok = 1;
 
            /* Not a #exec. */
            /* For #include, make sure we have write access to the include file
               file or its parent directory.  If the file itself doesn't exist,
               make sure we have write access to the directory. */
            /* For #tryinclude, we check the file(s) that match the pattern. */
 
            AST_LIST_TRAVERSE(&incl->included_files, included_file, next) {
                if (!is_writable(included_file->path)) {
                    /* the #tryinclude path exists but is not writable */
                    ok = 0;
                    break;
                }
            }
 
            if (!ok) {
                /* at least one include file is not writable */
                return -1;
            }
        }
    }
 
    /* now make sure we have write access to the main config file or its parent directory */
    make_fn(fn, sizeof(fn), 0, configfile);
    if (!is_writable(fn)) {
        return -1;
    }
 
    fileset = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 1023,
        hash_string, NULL, hashtab_compare_strings);
    if (!fileset) {
        /* Container creation failed. */
        return -1;
    }
 
    /* Now that we know we have write access to all files, it's safe to start truncating them */
 
    /* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions)
       are all truncated to zero bytes and have that nice header*/
    /* Note: for #exec, we write out the directives but don't zero out the exec files */
    for (incl = cfg->includes_root; incl; incl = incl->next) {
        if (incl->include_type != CONFIG_STATEMENT_EXEC) {
            struct config_included_file *included_file;
 
            AST_LIST_TRAVERSE(&incl->included_files, included_file, next) {
                fi = set_fn(fn, sizeof(fn), included_file->path, configfile, fileset);
                f = fopen(fn, "w");
                if (f) {
                    ast_verb(2, "Saving tryinclude '%s'\n", fn);
                    gen_header(f, configfile, fn, generator);
                    fclose(f);
                } else {
                    ast_log(LOG_ERROR, "Unable to write %s (%s)\n", fn, strerror(errno));
                }
                if (fi) {
                    ao2_ref(fi, -1);
                }
            }
        }
    }
 
    /* just set fn to absolute ver of configfile */
    fi = set_fn(fn, sizeof(fn), 0, configfile, fileset);
    if (
#ifdef __CYGWIN__
        (f = fopen(fn, "w+"))
#else
        (f = fopen(fn, "w"))
#endif
        ) {
        ast_verb(2, "Saving '%s'\n", fn);
        gen_header(f, configfile, fn, generator);
        cat = cfg->root;
        fclose(f);
        if (fi) {
            ao2_ref(fi, -1);
        }
 
        /* from here out, we open each involved file and concat the stuff we need to add to the end and immediately close... */
        /* since each var, cat, and associated comments can come from any file, we have to be
           mobile, and open each file, print, and close it on an entry-by-entry basis */
 
        while (cat) {
            fi = set_fn(fn, sizeof(fn), cat->file, configfile, fileset);
            f = fopen(fn, "a");
            if (!f) {
                ast_log(LOG_ERROR, "Unable to write %s (%s)\n", fn, strerror(errno));
                if (fi) {
                    ao2_ref(fi, -1);
                }
                ao2_ref(fileset, -1);
                return -1;
            }
 
            /* dump any includes that happen before this category header */
            for (incl = cfg->includes_root; incl; incl = incl->next) {
                if (strcmp(incl->include_location_file, cat->file) == 0) {
                    if (cat->lineno > incl->include_location_lineno && !incl->output) {
                        /* add the precomments */
                        insert_leading_blank_lines(f, fi, incl->precomments, incl->include_location_lineno);
                        print_comment(f, incl->precomments);
                        /* and the include */
                        print_include(f, incl);
                        incl->output = 1;
                    }
                }
            }
 
            /* dump any comments that happen before this category header */
            insert_leading_blank_lines(f, fi, cat->precomments, cat->lineno);
            print_comment(f, cat->precomments);
 
            /* dump the category header */
            fprintf(f, "[%s]", cat->name);
            if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) {
                fprintf(f, "(");
                if (cat->ignored) {
                    fprintf(f, "!");
                }
                if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) {
                    fprintf(f, ",");
                }
                if (!AST_LIST_EMPTY(&cat->template_instances)) {
                    struct ast_category_template_instance *x;
                    AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
                        fprintf(f, "%s",x->name);
                        if (x != AST_LIST_LAST(&cat->template_instances))
                            fprintf(f, ",");
                    }
                }
                fprintf(f, ")");
            }
            for(cmt = cat->sameline; cmt; cmt = cmt->next)
            {
                fprintf(f, "%s", cmt->cmt);
            }
            if (!cat->sameline)
                fprintf(f, "\n");
 
            /* dump any trailing comments */
            print_comment(f, cat->trailing);
 
            /* and we're all done */
            fclose(f);
            if (fi) {
                ao2_ref(fi, -1);
            }
 
            var = cat->root;
            while (var) {
                struct ast_category_template_instance *x;
                struct ast_variable *parent = NULL; /* last occurrence matching variable name */
 
                /*
                 * When saving the configuration we have the option to preserve
                 * the effective category contents.  If enabled, the template
                 * variables are materialized into the leaf categories.  Here,
                 * we check to see if a variable is also present in the leaf
                 * and, if so, we do not keep just the leaf value (no point in
                 * duplicate "var = value" lines in the .conf.
                 */
                if ((flags & CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT) && cat->loaded) {
                    if (var->inherited) {
                        struct ast_variable *v;
                        int skip = 0;
 
                        for (v = var->next; v; v = v->next) {
                            if (!strcasecmp(var->name, v->name)) {
                                /* skip earlier inherited duplicate */
                                skip = 1;
                                break;
                            }
                        }
                        if (skip) {
                            var = var->next;
                            continue;
                        }
                    }
                }
 
                /*
                 * Walk every template instance in the order Asterisk applies
                 * them, letting later templates override earlier ones.
                 */
                AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
                    struct ast_variable *v;
                    struct ast_variable *last = NULL;
 
                    /* Within a template, capture the last occurrence of the key. */
                    for (v = x->inst->root; v; v = v->next) {
                        if (!strcasecmp(var->name, v->name)) {
                            last = v;
                        }
                    }
 
                    if (last) {
                        parent = last;
                    }
                }
 
                /* decide whether to write the variable */
                if ((flags & CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT) && cat->loaded) {
                    /* materialize inherited vars; suppress only explicit exact dups */
                    if (!var->inherited && parent && !strcmp(var->value, parent->value)) {
                        var = var->next;
                        continue;
                    }
                } else {
                    /* skip inherited, explicit exact dups */
                    if (var->inherited || (parent && !strcmp(var->value, parent->value))) {
                        var = var->next;
                        continue;
                    }
                }
 
                fi = set_fn(fn, sizeof(fn), var->file, configfile, fileset);
                f = fopen(fn, "a");
                if (!f) {
                    ast_debug(1, "Unable to open for writing: %s\n", fn);
                    ast_verb(2, "Unable to write %s (%s)\n", fn, strerror(errno));
                    if (fi) {
                        ao2_ref(fi, -1);
                    }
                    ao2_ref(fileset, -1);
                    return -1;
                }
 
                /* dump any includes that happen before this variable */
                for (incl = cfg->includes_root; incl; incl = incl->next) {
                    if (strcmp(incl->include_location_file, var->file) == 0) {
                        if (var->lineno > incl->include_location_lineno && !incl->output) {
                            /* add the precomments */
                            insert_leading_blank_lines(f, fi, incl->precomments, incl->include_location_lineno);
                            print_comment(f, incl->precomments);
                            /* and the include */
                            print_include(f, incl);
                            incl->output = 1;
                        }
                    }
                }
 
                /* dump any comments that happen before this variable */
                insert_leading_blank_lines(f, fi, var->precomments, var->lineno);
                print_comment(f, var->precomments);
 
                { /* Block for 'escaped' scope */
                    int escaped_len = 2 * strlen(var->value) + 1;
                    char escaped[escaped_len];
 
                    ast_escape_semicolons(var->value, escaped, escaped_len);
 
                    if (var->sameline) {
                        fprintf(f, "%s %s %s  %s", var->name, (var->object ? "=>" : "="),
                            escaped, var->sameline->cmt);
                    } else {
                        fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="),
                            escaped);
                    }
                }
 
                /* dump any trailing comments */
                print_comment(f, var->trailing);
                if (var->blanklines) {
                    blanklines = var->blanklines;
                    while (blanklines--)
                        fprintf(f, "\n");
                }
 
                fclose(f);
                if (fi) {
                    ao2_ref(fi, -1);
                }
 
                var = var->next;
            }
            cat = cat->next;
        }
 
 
        /* Now, for files with trailing #include/#exec statements,
           we have to make sure every entry is output */
        for (incl = cfg->includes_root; incl; incl = incl->next) {
            if (!incl->output) {
                /* open the respective file */
                fi = set_fn(fn, sizeof(fn), incl->include_location_file, configfile, fileset);
                f = fopen(fn, "a");
                if (!f) {
                    ast_debug(1, "Unable to open for writing: %s\n", fn);
                    ast_verb(2, "Unable to write %s (%s)\n", fn, strerror(errno));
                    if (fi) {
                        ao2_ref(fi, -1);
                    }
                    ao2_ref(fileset, -1);
                    return -1;
                }
 
                /* add the precomments */
                insert_leading_blank_lines(f, fi, incl->precomments, incl->include_location_lineno);
                print_comment(f, incl->precomments);
                /* and the include */
                print_include(f, incl);
                /* and any trailing comments */
                print_comment(f, incl->trailing);
 
                incl->output = 1;
                fclose(f);
                if (fi) {
                    ao2_ref(fi, -1);
                }
            }
        }
 
 
        ast_verb(2, "Saving '%s': saved\n", fn);
    } else {
        ast_debug(1, "Unable to open for writing: %s\n", fn);
        ast_verb(2, "Unable to write '%s' (%s)\n", fn, strerror(errno));
        if (fi) {
            ao2_ref(fi, -1);
        }
        ao2_ref(fileset, -1);
        return -1;
    }
 
    ao2_ref(fileset, -1); /* this should destroy the hash container */
 
    /* pass new configuration to any config hooks */
    config_hook_exec(configfile, generator, cfg);
 
    return 0;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, ast_debug, ast_escape_semicolons(), AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_log, ast_verb, ast_comment::cmt, config_hook_exec(), CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT, CONFIG_STATEMENT_EXEC, errno, ast_category::file, gen_header(), hash_string(), hashtab_compare_strings(), ast_category::ignored, ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::include_type, ast_config_include::included_files, ast_config::includes_root, insert_leading_blank_lines(), ast_category_template_instance::inst, is_writable(), last, ast_category::lineno, ast_category::loaded, LOG_ERROR, make_fn(), ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_variable::next, ast_comment::next, ast_category::next, ast_config_include::next, NULL, ast_config_include::output, config_included_file::path, PATH_MAX, ast_category::precomments, ast_config_include::precomments, print_comment(), print_include(), ast_category::root, ast_config::root, ast_category::sameline, set_fn(), ast_category::template_instances, ast_category::trailing, ast_config_include::trailing, ast_variable::value, and var.

Referenced by action_updateconfig(), and ast_config_text_file_save().

ast_destroy_realtime()

int ast_destroy_realtime	(	const char *	family,
		const char *	keyfield,
		const char *	lookup,
			...
	)

Destroy realtime configuration.

Parameters

family	which family/config to be destroyed
keyfield	which field to use as the key
lookup	which value to look for in the key field to match the entry.

This function is used to destroy an entry in realtime configuration space. Additional params are used as keys.

Returns

Number of rows affected, or -1 on error.

Note

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 4043 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    int res = 0;
    va_list ap;
 
    va_start(ap, lookup);
    if (realtime_arguments_to_fields(ap, &fields)) {
        res = -1;
    }
    va_end(ap);
 
    if (res) {
        return -1;
    }
 
    return ast_destroy_realtime_fields(family, keyfield, lookup, fields);
}

References ast_destroy_realtime_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by cli_realtime_destroy(), function_realtime_readdestroy(), leave_voicemail(), msg_create_from_file(), and vm_delete().

ast_destroy_realtime_fields()

int ast_destroy_realtime_fields	(	const char *	family,
		const char *	keyfield,
		const char *	lookup,
		const struct ast_variable *	fields
	)

Destroy realtime configuration.

Parameters

family	which family/config to be destroyed
keyfield	which field to use as the key
lookup	which value to look for in the key field to match the entry.
fields	fields themselves

This function is used to destroy an entry in realtime configuration space. Additional params are used as keys.

Returns

Number of rows affected, or -1 on error.

Definition at line 4023 of file main/config.c.

{
    struct ast_config_engine *eng;
    int res = -1, i;
    char db[256];
    char table[256];
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            if (eng->destroy_func && ((res = eng->destroy_func(db, table, keyfield, lookup, fields)) >= 0)) {
                break;
            }
        } else {
            break;
        }
    }
 
    return res;
}

References db, ast_config_engine::destroy_func, find_engine(), and table.

Referenced by ast_destroy_realtime(), and sorcery_realtime_delete().

ast_destroy_template_list()

static void ast_destroy_template_list ( struct ast_category *  cat )

static

Definition at line 1298 of file main/config.c.

{
    struct ast_category_template_instance *x;
 
    while ((x = AST_LIST_REMOVE_HEAD(&cat->template_instances, next)))
        ast_free(x);
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_category::next, and ast_category::template_instances.

Referenced by ast_category_destroy().

ast_include_destroy()

static void ast_include_destroy ( struct ast_config_include *  incl )

static

Definition at line 1328 of file main/config.c.

{
    ast_free(incl->include_location_file);
    ast_free(incl->exec_file);
    ast_free(incl->included_file);
    config_included_files_destroy(incl);
    ast_comment_destroy(&incl->precomments);
    ast_comment_destroy(&incl->sameline);
    ast_comment_destroy(&incl->trailing);
    ast_free(incl);
}

References ast_comment_destroy(), ast_free, config_included_files_destroy(), ast_config_include::exec_file, ast_config_include::include_location_file, ast_config_include::included_file, ast_config_include::precomments, ast_config_include::sameline, and ast_config_include::trailing.

Referenced by ast_includes_destroy().

ast_include_find()

struct ast_config_include * ast_include_find	(	struct ast_config *	conf,
		const char *	included_file
	)

Definition at line 562 of file main/config.c.

{
    struct ast_config_include *x;
    for (x = conf->includes_root; x; x = x->next) {
        if (strcmp(x->included_file, included_file) == 0)
            return x;
    }
    return 0;
}

References ast_config_include::included_file, and ast_config_include::next.

Referenced by ast_include_new().

ast_include_new()

struct ast_config_include * ast_include_new	(	struct ast_config *	conf,
		const char *	from_file,
		const char *	included_file,
		int	include_type,
		const char *	exec_file,
		int	from_lineno,
		char *	real_included_file_name,
		int	real_included_file_name_size
	)

Definition at line 364 of file main/config.c.

{
    /* a file should be included ONCE. Otherwise, if one of the instances is changed,
     * then all be changed. -- how do we know to include it? -- Handling modified
     * instances is possible, I'd have
     * to create a new master for each instance. */
    struct ast_config_include *inc;
    struct config_included_file *inc_file;
    struct stat statbuf;
    char fn[PATH_MAX];
 
    inc = ast_include_find(conf, included_file);
    if (inc) {
        do {
            inc->inclusion_count++;
            snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
        } while (stat(real_included_file_name, &statbuf) == 0);
        ast_log(LOG_WARNING, "'%s', line %d:  Same File included more than once! This data will be saved in %s if saved back to disk.\n", from_file, from_lineno, real_included_file_name);
    } else
        *real_included_file_name = 0;
 
    inc = ast_calloc(1,sizeof(struct ast_config_include));
    if (!inc) {
        return NULL;
    }
    inc->include_location_file = ast_strdup(from_file);
    if (!inc->include_location_file) {
        ast_includes_destroy(inc);
        return NULL;
    }
    inc->include_location_lineno = from_lineno;
    if (!ast_strlen_zero(real_included_file_name)) {
        inc->included_file = ast_strdup(real_included_file_name);
    } else {
        inc->included_file = ast_strdup(included_file);
    }
    if (!inc->included_file) {
        ast_includes_destroy(inc);
        return NULL;
    }
 
    inc->include_type = include_type;
 
    make_fn(fn, sizeof(fn), inc->included_file, from_file);
    switch (inc->include_type) {
    case CONFIG_STATEMENT_INCLUDE:
        inc_file = ast_calloc(1, sizeof(*inc_file) + strlen(fn) + 1);
        if (!inc_file) {
            ast_includes_destroy(inc);
            return NULL;
        }
        strcpy(inc_file->path, fn); /* safe */
        AST_LIST_INSERT_TAIL(&inc->included_files, inc_file, next);
        break;
    case CONFIG_STATEMENT_TRYINCLUDE:
        {
        int glob_ret;
        glob_t globbuf;
 
        /* add files that match the pattern */
        globbuf.gl_offs = 0;
        glob_ret = glob(fn, MY_GLOB_FLAGS, NULL, &globbuf);
        if (glob_ret == 0) {
            int i;
 
            for (i = 0; i < globbuf.gl_pathc; i++) {
                char *matched_path = globbuf.gl_pathv[i];
 
                if (access(matched_path, F_OK) != 0) {
                    /* skip #tryinclude paths that do not already exist. */
                    continue;
                }
 
                inc_file = ast_calloc(1, sizeof(*inc_file) + strlen(matched_path) + 1);
                if (!inc_file) {
                    ast_includes_destroy(inc);
                    globfree(&globbuf);
                    return NULL;
                }
                strcpy(inc_file->path, matched_path);   /* safe */
                AST_LIST_INSERT_TAIL(&inc->included_files, inc_file, next);
            }
        }
        globfree(&globbuf);
        break;
        }
    case CONFIG_STATEMENT_EXEC:
        inc->exec_file = ast_strdup(exec_file);
        if (!inc->exec_file) {
            ast_includes_destroy(inc);
            return NULL;
        }
        break;
    }
 
    /* attach this new struct to the conf struct */
    if (conf->includes_root && conf->includes_last) {
        conf->includes_last->next = inc;
    } else {
        conf->includes_root = inc;
    }
    conf->includes_last = inc;
 
    return inc;
}

References ast_calloc, ast_include_find(), ast_includes_destroy(), AST_LIST_INSERT_TAIL, ast_log, ast_strdup, ast_strlen_zero(), CONFIG_STATEMENT_EXEC, CONFIG_STATEMENT_INCLUDE, CONFIG_STATEMENT_TRYINCLUDE, ast_config_include::exec, ast_config_include::exec_file, ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::include_type, ast_config_include::included_file, ast_config_include::included_files, ast_config_include::inclusion_count, LOG_WARNING, make_fn(), MY_GLOB_FLAGS, ast_config_include::next, NULL, config_included_file::path, and PATH_MAX.

Referenced by AST_TEST_DEFINE(), and process_text_line().

ast_include_rename()

void ast_include_rename	(	struct ast_config *	conf,
		const char *	from_file,
		const char *	to_file
	)

Definition at line 470 of file main/config.c.

{
    struct ast_config_include *incl;
    struct ast_category *cat;
    char *str;
 
    int from_len = strlen(from_file);
    int to_len = strlen(to_file);
 
    if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */
        return;
 
    /* the manager code allows you to read in one config file, then
     * write it back out under a different name. But, the new arrangement
     * ties output lines to the file name. So, before you try to write
     * the config file to disk, better riffle thru the data and make sure
     * the file names are changed.
     */
    /* file names are on categories, includes (of course), and on variables. So,
     * traverse all this and swap names */
 
    for (incl = conf->includes_root; incl; incl = incl->next) {
        if (strcmp(incl->include_location_file, from_file) == 0) {
            if (from_len >= to_len)
                strcpy(incl->include_location_file, to_file);
            else {
                /* Keep the old filename if the allocation fails. */
                str = ast_strdup(to_file);
                if (str) {
                    ast_free(incl->include_location_file);
                    incl->include_location_file = str;
                }
            }
        }
    }
    for (cat = conf->root; cat; cat = cat->next) {
        struct ast_variable **prev;
        struct ast_variable *v;
        struct ast_variable *new_var;
 
        if (strcmp(cat->file, from_file) == 0) {
            if (from_len >= to_len)
                strcpy(cat->file, to_file);
            else {
                /* Keep the old filename if the allocation fails. */
                str = ast_strdup(to_file);
                if (str) {
                    ast_free(cat->file);
                    cat->file = str;
                }
            }
        }
        for (prev = &cat->root, v = cat->root; v; prev = &v->next, v = v->next) {
            if (strcmp(v->file, from_file)) {
                continue;
            }
 
            /*
             * Calculate actual space available.  The file string is
             * intentionally stuffed before the name string just so we can
             * do this.
             */
            if (to_len < v->name - v->file) {
                /* The new name will fit in the available space. */
                str = (char *) v->file;/* Stupid compiler complains about discarding qualifiers even though I used a cast. */
                strcpy(str, to_file);/* SAFE */
                continue;
            }
 
            /* Keep the old filename if the allocation fails. */
            new_var = ast_variable_new(v->name, v->value, to_file);
            if (!new_var) {
                continue;
            }
 
            /* Move items from the old list node to the replacement node. */
            ast_variable_move(new_var, v);
 
            /* Replace the old node in the list with the new node. */
            new_var->next = v->next;
            if (cat->last == v) {
                cat->last = new_var;
            }
            *prev = new_var;
 
            ast_variable_destroy(v);
 
            v = new_var;
        }
    }
}

References ast_free, ast_strdup, ast_variable_destroy(), ast_variable_move(), ast_variable_new, ast_variable::file, ast_category::file, ast_config_include::include_location_file, ast_category::last, name, ast_variable::name, ast_variable::next, ast_category::next, ast_config_include::next, ast_category::root, str, and ast_variable::value.

Referenced by action_updateconfig().

ast_includes_destroy()

static void ast_includes_destroy ( struct ast_config_include *  incls )

static

Definition at line 1340 of file main/config.c.

{
    struct ast_config_include *incl, *inclnext;
 
    for (incl = incls; incl; incl = inclnext) {
        inclnext = incl->next;
        ast_include_destroy(incl);
    }
}

References ast_include_destroy(), and ast_config_include::next.

Referenced by ast_config_destroy(), and ast_include_new().

ast_load_realtime()

struct ast_variable * ast_load_realtime	(	const char *	family,
			...
	)

Definition at line 3773 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    int field_res = 0;
    va_list ap;
 
    va_start(ap, family);
    if (realtime_arguments_to_fields(ap, &fields)) {
        field_res = -1;
    }
    va_end(ap);
 
    if (field_res) {
        return NULL;
    }
 
    if (!fields) {
        return NULL;
    }
 
    return ast_load_realtime_fields(family, fields);
}

References ast_load_realtime_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by conf_run(), copy_plain_file(), find_conf_realtime(), find_load_queue_rt_friendly(), find_realtime(), find_user_realtime(), leave_queue(), load_realtime_musiconhold(), queue_function_queuegetchannel(), queue_function_queuewaitingcount(), realtime_peer(), realtime_switch_common(), realtime_user(), and rt_extend_conf().

ast_load_realtime_all()

struct ast_variable * ast_load_realtime_all	(	const char *	family,
			...
	)

Definition at line 3721 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    struct ast_variable *res = NULL;
    va_list ap;
 
    va_start(ap, family);
    realtime_arguments_to_fields(ap, &fields);
    va_end(ap);
 
    if (fields) {
        res = ast_load_realtime_all_fields(family, fields);
    }
 
    return res;
}

References ast_load_realtime_all_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by cli_realtime_load(), function_realtime_read(), function_realtime_readdestroy(), and realtimefield_read().

ast_load_realtime_all_fields()

struct ast_variable * ast_load_realtime_all_fields	(	const char *	family,
		const struct ast_variable *	fields
	)

Definition at line 3688 of file main/config.c.

{
    struct ast_config_engine *eng;
    char db[256];
    char table[256];
    struct ast_variable *res=NULL;
    int i;
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            if (eng->realtime_func) {
                res = eng->realtime_func(db, table, fields);
 
                /* If a backend returns CONFIG_RT_NOT_FOUND, stop iteration and return NULL,
                 * indicating that the requested record does not exist and no failover should occur.
                 * Only continue iteration if the result is NULL and not CONFIG_RT_NOT_FOUND,
                 * which signals a backend failure.
                 */
                if (res == CONFIG_RT_NOT_FOUND) {
                    return NULL;
                }
                if (res) {
                    return res;
                }
            }
        } else {
            return NULL;
        }
    }
 
    return res;
}

References CONFIG_RT_NOT_FOUND, db, find_engine(), NULL, ast_config_engine::realtime_func, and table.

Referenced by ast_load_realtime_all(), and ast_load_realtime_fields().

ast_load_realtime_fields()

struct ast_variable * ast_load_realtime_fields	(	const char *	family,
		const struct ast_variable *	fields
	)

Retrieve realtime configuration.

Parameters

family	which family/config to lookup
fields	which fields to lookup

This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters.

Note

Unlike the variables in ast_config, the resulting list of variables MUST be freed with ast_variables_destroy() as there is no container.

The difference between these two calls is that ast_load_realtime excludes fields whose values are NULL, while ast_load_realtime_all loads all columns.

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 3738 of file main/config.c.

{
    struct ast_variable *res;
    struct ast_variable *cur;
    struct ast_variable **prev;
 
    res = ast_load_realtime_all_fields(family, fields);
 
    /* Filter the list. */
    prev = &res;
    cur = res;
    while (cur) {
        if (ast_strlen_zero(cur->value)) {
            /* Eliminate empty entries */
            struct ast_variable *next;
 
            next = cur->next;
            *prev = next;
            ast_variable_destroy(cur);
            cur = next;
        } else {
            /* Make blank entries empty and keep them. */
            if (cur->value[0] == ' ' && cur->value[1] == '\0') {
                char *vptr = (char *) cur->value;
 
                vptr[0] = '\0';
            }
 
            prev = &cur->next;
            cur = cur->next;
        }
    }
    return res;
}

References ast_load_realtime_all_fields(), ast_strlen_zero(), ast_variable_destroy(), ast_variable::next, ast_category::next, ast_category::prev, and ast_variable::value.

Referenced by ast_load_realtime(), and sorcery_realtime_retrieve_fields().

ast_load_realtime_multientry()

struct ast_config * ast_load_realtime_multientry	(	const char *	family,
			...
	)

Retrieve realtime configuration.

Parameters

family

which family/config to lookup

This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Unlike the ast_load_realtime, this function can return more than one entry and is thus stored inside a traditional ast_config structure rather than just returning a linked list of variables.

Returns

An ast_config with one or more results

Return values

NULL	Error or no results returned

Note

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 3889 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    va_list ap;
 
    va_start(ap, family);
    realtime_arguments_to_fields(ap, &fields);
    va_end(ap);
 
    if (!fields) {
        return NULL;
    }
 
    return ast_load_realtime_multientry_fields(family, fields);
}

References ast_load_realtime_multientry_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by __queues_show(), conf_exec(), find_load_queue_rt_friendly(), find_realtime(), load_module(), load_realtime_musiconhold(), load_realtime_queues(), load_realtime_rules(), named_acl_find_realtime(), realtime_directory(), realtime_switch_common(), set_member_value(), show_users_realtime(), and update_realtime_members().

ast_load_realtime_multientry_fields()

struct ast_config * ast_load_realtime_multientry_fields	(	const char *	family,
		const struct ast_variable *	fields
	)

Retrieve realtime configuration.

Parameters

family	which family/config to lookup
fields	list of fields

This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Unlike the ast_load_realtime, this function can return more than one entry and is thus stored inside a traditional ast_config structure rather than just returning a linked list of variables.

Returns

An ast_config with one or more results

Return values

NULL	Error or no results returned

Definition at line 3863 of file main/config.c.

{
    struct ast_config_engine *eng;
    char db[256];
    char table[256];
    struct ast_config *res = NULL;
    int i;
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            if (eng->realtime_multi_func && (res = eng->realtime_multi_func(db, table, fields))) {
                /* If we were returned an empty cfg, destroy it and return NULL */
                if (!res->root) {
                    ast_config_destroy(res);
                    res = NULL;
                }
                break;
            }
        } else {
            break;
        }
    }
 
    return res;
}

References ast_config_destroy(), db, find_engine(), NULL, ast_config_engine::realtime_multi_func, ast_config::root, and table.

Referenced by ast_load_realtime_multientry(), and sorcery_realtime_retrieve_multiple().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 4619 of file main/config.c.

ast_parse_arg()

int ast_parse_arg	(	const char *	arg,
		enum ast_parse_flags	flags,
		void *	p_result,
			...
	)

Helper function to parse arguments See documentation in config.h.

The argument parsing routine.

Definition at line 4094 of file main/config.c.

{
    va_list ap;
    int error = 0;
 
    va_start(ap, p_result);
    switch (flags & PARSE_TYPE) {
    case PARSE_INT32:
    {
        long int x = 0;
        int32_t *result = p_result;
        int32_t def = result ? *result : 0, high = INT32_MAX, low = INT32_MIN;
        char *endptr = NULL;
 
        /* optional arguments: default value and/or (low, high) */
        if (flags & PARSE_DEFAULT) {
            def = va_arg(ap, int32_t);
        }
        if (flags & (PARSE_IN_RANGE | PARSE_OUT_RANGE)) {
            low = va_arg(ap, int32_t);
            high = va_arg(ap, int32_t);
        }
        if (ast_strlen_zero(arg)) {
            error = 1;
            goto int32_done;
        }
        errno = 0;
        x = strtol(arg, &endptr, 0);
        if (*endptr || errno || x < INT32_MIN || x > INT32_MAX) {
            /* Parse error, or type out of int32_t bounds */
            error = 1;
            goto int32_done;
        }
        error = (x < low) || (x > high);
        if (flags & PARSE_RANGE_DEFAULTS) {
            if (x < low) {
                def = low;
            } else if (x > high) {
                def = high;
            }
        }
        if (flags & PARSE_OUT_RANGE) {
            error = !error;
        }
int32_done:
        if (result) {
            *result  = error ? def : x;
        }
 
        ast_debug(3, "extract int from [%s] in [%d, %d] gives [%ld](%d)\n",
                arg, low, high, result ? *result : x, error);
        break;
    }
 
    case PARSE_UINT32:
    {
        unsigned long int x = 0;
        uint32_t *result = p_result;
        uint32_t def = result ? *result : 0, low = 0, high = UINT32_MAX;
        char *endptr = NULL;
 
        /* optional argument: first default value, then range */
        if (flags & PARSE_DEFAULT) {
            def = va_arg(ap, uint32_t);
        }
        if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
            /* range requested, update bounds */
            low = va_arg(ap, uint32_t);
            high = va_arg(ap, uint32_t);
        }
 
        if (ast_strlen_zero(arg)) {
            error = 1;
            goto uint32_done;
        }
        /* strtoul will happily and silently negate negative numbers */
        arg = ast_skip_blanks(arg);
        if (*arg == '-') {
            error = 1;
            goto uint32_done;
        }
        errno = 0;
        x = strtoul(arg, &endptr, 0);
        if (*endptr || errno || x > UINT32_MAX) {
            error = 1;
            goto uint32_done;
        }
        error = (x < low) || (x > high);
        if (flags & PARSE_RANGE_DEFAULTS) {
            if (x < low) {
                def = low;
            } else if (x > high) {
                def = high;
            }
        }
        if (flags & PARSE_OUT_RANGE) {
            error = !error;
        }
uint32_done:
        if (result) {
            *result  = error ? def : x;
        }
        ast_debug(3, "extract uint from [%s] in [%u, %u] gives [%lu](%d)\n",
                arg, low, high, result ? *result : x, error);
        break;
    }
 
    case PARSE_TIMELEN:
    {
        int x = 0;
        int *result = p_result;
        int def = result ? *result : 0;
        int high = INT_MAX;
        int low = INT_MIN;
        enum ast_timelen defunit;
 
        defunit = va_arg(ap, enum ast_timelen);
        /* optional arguments: default value and/or (low, high) */
        if (flags & PARSE_DEFAULT) {
            def = va_arg(ap, int);
        }
        if (flags & (PARSE_IN_RANGE | PARSE_OUT_RANGE)) {
            low = va_arg(ap, int);
            high = va_arg(ap, int);
        }
        if (ast_strlen_zero(arg)) {
            error = 1;
            goto timelen_done;
        }
        error = ast_app_parse_timelen(arg, &x, defunit);
        if (error || x < INT_MIN || x > INT_MAX) {
            /* Parse error, or type out of int bounds */
            error = 1;
            goto timelen_done;
        }
        error = (x < low) || (x > high);
        if (flags & PARSE_RANGE_DEFAULTS) {
            if (x < low) {
                def = low;
            } else if (x > high) {
                def = high;
            }
        }
        if (flags & PARSE_OUT_RANGE) {
            error = !error;
        }
timelen_done:
        if (result) {
            *result  = error ? def : x;
        }
 
        ast_debug(3, "extract timelen from [%s] in [%d, %d] gives [%d](%d)\n",
                arg, low, high, result ? *result : x, error);
        break;
    }
 
    case PARSE_DOUBLE:
    {
        double *result = p_result;
        double x = 0, def = result ? *result : 0, low = -HUGE_VAL, high = HUGE_VAL;
        char *endptr = NULL;
 
        /* optional argument: first default value, then range */
        if (flags & PARSE_DEFAULT) {
            def = va_arg(ap, double);
        }
        if (flags & (PARSE_IN_RANGE | PARSE_OUT_RANGE)) {
            /* range requested, update bounds */
            low = va_arg(ap, double);
            high = va_arg(ap, double);
        }
        if (ast_strlen_zero(arg)) {
            error = 1;
            goto double_done;
        }
        errno = 0;
        x = strtod(arg, &endptr);
        if (*endptr || errno == ERANGE) {
            error = 1;
            goto double_done;
        }
        error = (x < low) || (x > high);
        if (flags & PARSE_OUT_RANGE) {
            error = !error;
        }
double_done:
        if (result) {
            *result = error ? def : x;
        }
        ast_debug(3, "extract double from [%s] in [%f, %f] gives [%f](%d)\n",
                arg, low, high, result ? *result : x, error);
        break;
    }
    case PARSE_ADDR:
        {
        struct ast_sockaddr *addr = (struct ast_sockaddr *)p_result;
 
        if (!ast_sockaddr_parse(addr, arg, flags & PARSE_PORT_MASK)) {
            error = 1;
        }
 
        ast_debug(3, "extract addr from %s gives %s(%d)\n",
              arg, ast_sockaddr_stringify(addr), error);
 
        break;
        }
    case PARSE_INADDR:  /* TODO Remove this (use PARSE_ADDR instead). */
        {
        char *port, *buf;
        struct sockaddr_in _sa_buf; /* buffer for the result */
        struct sockaddr_in *sa = p_result ?
            (struct sockaddr_in *)p_result : &_sa_buf;
        /* default is either the supplied value or the result itself */
        struct sockaddr_in *def = (flags & PARSE_DEFAULT) ?
            va_arg(ap, struct sockaddr_in *) : sa;
        struct ast_sockaddr addr = { {0,} };
 
        memset(&_sa_buf, '\0', sizeof(_sa_buf)); /* clear buffer */
        /* duplicate the string to strip away the :port */
        port = ast_strdupa(arg);
        buf = strsep(&port, ":");
        sa->sin_family = AF_INET;   /* assign family */
        /*
         * honor the ports flag setting, assign default value
         * in case of errors or field unset.
         */
        flags &= PARSE_PORT_MASK; /* the only flags left to process */
        if (port) {
            if (flags == PARSE_PORT_FORBID) {
                error = 1;  /* port was forbidden */
                sa->sin_port = def->sin_port;
            } else if (flags == PARSE_PORT_IGNORE)
                sa->sin_port = def->sin_port;
            else /* accept or require */
                sa->sin_port = htons(strtol(port, NULL, 0));
        } else {
            sa->sin_port = def->sin_port;
            if (flags == PARSE_PORT_REQUIRE)
                error = 1;
        }
        /* Now deal with host part, even if we have errors before. */
        if (ast_sockaddr_resolve_first_af(&addr, buf, PARSE_PORT_FORBID, AF_INET)) {
            error = 1;
            sa->sin_addr = def->sin_addr;
        } else {
            struct sockaddr_in tmp;
            ast_sockaddr_to_sin(&addr, &tmp);
            sa->sin_addr = tmp.sin_addr;
        }
        ast_debug(3,
            "extract inaddr from [%s] gives [%s:%d](%d)\n",
            arg, ast_inet_ntoa(sa->sin_addr),
            ntohs(sa->sin_port), error);
        break;
        }
    }
    va_end(ap);
    return error;
}

References ast_app_parse_timelen(), ast_debug, ast_inet_ntoa(), ast_skip_blanks(), ast_sockaddr_parse(), ast_sockaddr_resolve_first_af(), ast_sockaddr_stringify(), ast_sockaddr_to_sin, ast_strdupa, ast_strlen_zero(), buf, errno, error(), INT32_MAX, INT32_MIN, NULL, PARSE_ADDR, PARSE_DEFAULT, PARSE_DOUBLE, PARSE_IN_RANGE, PARSE_INADDR, PARSE_INT32, PARSE_OUT_RANGE, PARSE_PORT_FORBID, PARSE_PORT_IGNORE, PARSE_PORT_MASK, PARSE_PORT_REQUIRE, PARSE_RANGE_DEFAULTS, PARSE_TIMELEN, PARSE_TYPE, PARSE_UINT32, result, strsep(), and UINT32_MAX.

Referenced by __ast_http_load(), __init_manager(), app_exec(), AST_TEST_DEFINE(), ast_tls_read_conf(), build_peer(), build_user(), configure_local_rtp(), double_handler_fn(), general_set(), iax2_call(), iax2_request(), int_handler_fn(), load_asterisk_conf(), load_config(), new_realtime_sqlite3_db(), realtime_peer(), reload_config(), rtp_reload(), sample_rate_handler(), set_config(), setup_rtp_connection(), setup_rtp_remote(), setup_udptl_connection(), sockaddr_handler_fn(), timelen_handler_fn(), uint_handler_fn(), and xfer_set().

ast_realtime_append_mapping()

static int ast_realtime_append_mapping ( const char *  name, const char *  driver, const char *  database, const char *  table, int  priority  )

static

Definition at line 3295 of file main/config.c.

{
    struct ast_config_map *map;
    char *dst;
    int length;
 
    length = sizeof(*map);
    length += strlen(name) + 1;
    length += strlen(driver) + 1;
    length += strlen(database) + 1;
    if (table)
        length += strlen(table) + 1;
 
    if (!(map = ast_calloc(1, length)))
        return -1;
 
    dst = map->stuff;   /* writable space starts here */
    map->name = strcpy(dst, name);
    dst += strlen(dst) + 1;
    map->driver = strcpy(dst, driver);
    dst += strlen(dst) + 1;
    map->database = strcpy(dst, database);
    if (table) {
        dst += strlen(dst) + 1;
        map->table = strcpy(dst, table);
    }
    map->priority = priority;
    map->next = config_maps;
    config_maps = map;
 
    ast_verb(5, "Binding %s to %s/%s/%s\n", map->name, map->driver, map->database, map->table ? map->table : map->name);
 
    return 0;
}

References ast_calloc, ast_verb, config_maps, ast_config_map::database, ast_config_map::driver, name, ast_config_map::name, ast_config_map::next, priority, ast_config_map::priority, ast_config_map::stuff, table, and ast_config_map::table.

Referenced by load_module(), and reload_module().

ast_realtime_decode_chunk()

char * ast_realtime_decode_chunk

(

char *

chunk

)

Remove standard encoding from realtime values, which ensures that a semicolon embedded within a single value is not treated upon retrieval as multiple values.

Parameters

chunk

Data to be decoded

Returns

The decoded data, in the original buffer

Since

1.8

Warning

This function modifies the original buffer

Definition at line 4062 of file main/config.c.

{
    char *orig = chunk;
    for (; *chunk; chunk++) {
        if (*chunk == '^' && strchr("0123456789ABCDEFabcdef", chunk[1]) && strchr("0123456789ABCDEFabcdef", chunk[2])) {
            sscanf(chunk + 1, "%02hhX", (unsigned char *)chunk);
            memmove(chunk + 1, chunk + 3, strlen(chunk + 3) + 1);
        }
    }
    return orig;
}

Referenced by realtime_multi_pgsql(), and realtime_pgsql().

ast_realtime_enabled()

int ast_realtime_enabled

(

void

)

Check if there's any realtime engines loaded.

Definition at line 3811 of file main/config.c.

{
    return config_maps ? 1 : 0;
}

References config_maps.

Referenced by action_coresettings(), ast_check_realtime(), and handle_show_settings().

ast_realtime_encode_chunk()

char * ast_realtime_encode_chunk	(	struct ast_str **	dest,
		ssize_t	maxlen,
		const char *	chunk
	)

Encodes a chunk of data for realtime.

Parameters

dest	Destination buffer
maxlen	Length passed through to ast_str_* functions
chunk	Source data to be encoded

Returns

Buffer within dest

Since

1.8

Definition at line 4074 of file main/config.c.

{
    if (!strchr(chunk, ';') && !strchr(chunk, '^')) {
        ast_str_set(dest, maxlen, "%s", chunk);
    } else {
        ast_str_reset(*dest);
        for (; *chunk; chunk++) {
            if (strchr(";^", *chunk)) {
                ast_str_append(dest, maxlen, "^%02hhX", *chunk);
            } else {
                ast_str_append(dest, maxlen, "%c", *chunk);
            }
        }
    }
    return ast_str_buffer(*dest);
}

References ast_str_append(), ast_str_buffer(), ast_str_reset(), and ast_str_set().

ast_realtime_is_mapping_defined()

int ast_realtime_is_mapping_defined

(

const char *

family

)

Determine if a mapping exists for a given family.

Parameters

family

which family you are looking to see if a mapping exists for

Return values

1	if it is mapped
0	if it is not

Definition at line 3448 of file main/config.c.

{
    struct ast_config_map *map;
    SCOPED_MUTEX(lock, &config_lock);
 
    for (map = config_maps; map; map = map->next) {
        if (!strcasecmp(family, map->name)) {
            return 1;
        }
    }
    ast_debug(5, "Failed to find a realtime mapping for %s\n", family);
 
    return 0;
}

References ast_debug, config_lock, config_maps, lock, ast_config_map::name, ast_config_map::next, and SCOPED_MUTEX.

Referenced by ast_named_acl_find(), and sorcery_realtime_open().

ast_realtime_require_field()

int ast_realtime_require_field	(	const char *	family,
			...
	)

Inform realtime what fields that may be stored.

Since

1.6.1

Parameters

family

which family/config is referenced

This will inform builtin configuration backends that particular fields may be updated during the use of that configuration section. This is mainly to be used during startup routines, to ensure that various fields exist in the backend. The backends may take various actions, such as creating new fields in the data store or warning the administrator that new fields may need to be created, in order to ensure proper function.

The arguments are specified in groups of 3: column name, column type, and column size. The column types are specified as integer constants, defined by the enum require_type. Note that the size is specified as the number of equivalent character fields that a field may take up, even if a field is otherwise specified as an integer type. This is due to the fact that some fields have historically been specified as character types, even if they contained integer values.

A family should always specify its fields to the minimum necessary requirements to fulfill all possible values (within reason; for example, a timeout value may reasonably be specified as an INTEGER2, with size 5. Even though values above 32767 seconds are possible, they are unlikely to be useful, and we should not complain about that size).

Return values

0	Required fields met specified standards
-1	One or more fields was missing or insufficient

Note

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

TODO The return value of this function is routinely ignored. Ignoring the return value means that it's mostly pointless to be calling this. You'll see some warning messages potentially, but that's it.

XXX This function is super useful for detecting configuration problems early, but unfortunately, the latest in configuration management, sorcery, doesn't work well with this. Users of sorcery are familiar with the fields they will need to write but don't know if realtime is being used. Sorcery knows what storage mechanism is being used but has no high-level knowledge of what sort of data is going to be written.

Definition at line 3816 of file main/config.c.

{
    struct ast_config_engine *eng;
    char db[256];
    char table[256];
    va_list ap, aq;
    int res = -1, i;
 
    va_start(ap, family);
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            va_copy(aq, ap);
            /* If the require succeeds, it returns 0. */
            if (eng->require_func && !(res = eng->require_func(db, table, aq))) {
                va_end(aq);
                break;
            }
            va_end(aq);
        } else {
            break;
        }
    }
    va_end(ap);
 
    return res;
}

References db, find_engine(), ast_config_engine::require_func, and table.

Referenced by ast_queue_log(), change_password_realtime(), conf_run(), load_module(), and logger_queue_rt_start().

ast_store_realtime()

int ast_store_realtime	(	const char *	family,
			...
	)

Create realtime configuration.

Parameters

family

which family/config to be created

This function is used to create a parameter in realtime configuration space.

Returns

Number of rows affected, or -1 on error.

Note

On the MySQL engine only, for reasons of backwards compatibility, the return value is the insert ID. This value is nonportable and may be changed in a future version to match the other engines.

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 4007 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    va_list ap;
 
    va_start(ap, family);
    realtime_arguments_to_fields(ap, &fields);
    va_end(ap);
 
    if (!fields) {
        return -1;
    }
 
    return ast_store_realtime_fields(family, fields);
}

References ast_store_realtime_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by ast_queue_log(), cli_realtime_store(), copy_plain_file(), function_realtime_store(), leave_voicemail(), and msg_create_from_file().

ast_store_realtime_fields()

int ast_store_realtime_fields	(	const char *	family,
		const struct ast_variable *	fields
	)

Create realtime configuration.

Parameters

family	which family/config to be created
fields	fields themselves

This function is used to create a parameter in realtime configuration space.

Returns

Number of rows affected, or -1 on error.

Note

On the MySQL engine only, for reasons of backwards compatibility, the return value is the insert ID. This value is nonportable and may be changed in a future version to match the other engines.

Definition at line 3986 of file main/config.c.

{
    struct ast_config_engine *eng;
    int res = -1, i;
    char db[256];
    char table[256];
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            /* If the store succeeds, it returns >= 0*/
            if (eng->store_func && ((res = eng->store_func(db, table, fields)) >= 0)) {
                break;
            }
        } else {
            break;
        }
    }
 
    return res;
}

References db, find_engine(), ast_config_engine::store_func, and table.

Referenced by ast_store_realtime(), sorcery_realtime_create(), and sorcery_realtime_update().

ast_unload_realtime()

int ast_unload_realtime

(

const char *

family

)

Release any resources cached for a realtime family.

Since

1.6.1

Parameters

family

which family/config to destroy

Various backends may cache attributes about a realtime data storage facility; on reload, a front end resource may request to purge that cache.

Return values

0	If any cache was purged
-1	If no cache was found

Definition at line 3843 of file main/config.c.

{
    struct ast_config_engine *eng;
    char db[256];
    char table[256];
    int res = -1, i;
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            if (eng->unload_func) {
                /* Do this for ALL engines */
                res = eng->unload_func(db, table);
            }
        } else {
            break;
        }
    }
    return res;
}

References db, find_engine(), table, and ast_config_engine::unload_func.

Referenced by __unload_module(), load_config_force(), logger_queue_init(), reload(), reload_config(), reload_logger(), and unload_module().

ast_update2_realtime()

int ast_update2_realtime	(	const char *	family,
			...
	)

Update realtime configuration.

Parameters

family

which family/config to be updated

This function is used to update a parameter in realtime configuration space. It includes the ability to lookup a row based upon multiple key criteria. As a result, this function includes two sentinel values, one to terminate lookup values and the other to terminate the listing of fields to update.

Returns

Number of rows affected, or -1 on error.

Note

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 3962 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, lookup_fields, NULL, ast_variables_destroy);
    RAII_VAR(struct ast_variable *, update_fields, NULL, ast_variables_destroy);
    va_list ap;
 
    va_start(ap, family);
    /* XXX: If we wanted to pass no lookup fields (select all), we'd be
     * out of luck. realtime_arguments_to_fields expects at least one key
     * value pair. */
    realtime_arguments_to_fields(ap, &lookup_fields);
    va_end(ap);
 
    va_start(ap, family);
    realtime_arguments_to_fields2(ap, 1, &update_fields);
    va_end(ap);
 
    if (!lookup_fields || !update_fields) {
        return -1;
    }
 
    return ast_update2_realtime_fields(family, lookup_fields, update_fields);
}

References ast_update2_realtime_fields(), ast_variables_destroy(), NULL, RAII_VAR, realtime_arguments_to_fields, and realtime_arguments_to_fields2().

Referenced by change_password_realtime(), and cli_realtime_update2().

ast_update2_realtime_fields()

int ast_update2_realtime_fields	(	const char *	family,
		const struct ast_variable *	lookup_fields,
		const struct ast_variable *	update_fields
	)

Update realtime configuration.

Parameters

family	which family/config to be updated
lookup_fields	fields used to look up entries
update_fields	fields to update

This function is used to update a parameter in realtime configuration space. It includes the ability to lookup a row based upon multiple key criteria. As a result, this function includes two sentinel values, one to terminate lookup values and the other to terminate the listing of fields to update.

Returns

Number of rows affected, or -1 on error.

Definition at line 3942 of file main/config.c.

{
    struct ast_config_engine *eng;
    int res = -1, i;
    char db[256];
    char table[256];
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            if (eng->update2_func && !(res = eng->update2_func(db, table, lookup_fields, update_fields))) {
                break;
            }
        } else {
            break;
        }
    }
 
    return res;
}

References db, find_engine(), table, and ast_config_engine::update2_func.

Referenced by ast_update2_realtime().

ast_update_realtime()

int ast_update_realtime	(	const char *	family,
		const char *	keyfield,
		const char *	lookup,
			...
	)

Update realtime configuration.

Parameters

family	which family/config to be updated
keyfield	which field to use as the key
lookup	which value to look for in the key field to match the entry.

This function is used to update a parameter in realtime configuration space.

Returns

Number of rows affected, or -1 on error.

Note

You should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 3926 of file main/config.c.

{
    RAII_VAR(struct ast_variable *, fields, NULL, ast_variables_destroy);
    va_list ap;
 
    va_start(ap, lookup);
    realtime_arguments_to_fields(ap, &fields);
    va_end(ap);
 
    if (!fields) {
        return -1;
    }
 
    return ast_update_realtime_fields(family, keyfield, lookup, fields);
}

References ast_update_realtime_fields(), ast_variables_destroy(), NULL, RAII_VAR, and realtime_arguments_to_fields.

Referenced by cli_realtime_update(), conf_run(), function_realtime_write(), leave_voicemail(), realtime_update_peer(), rename_file(), rt_extend_conf(), set_queue_member_pause(), and update_realtime_member_field().

ast_update_realtime_fields()

int ast_update_realtime_fields	(	const char *	family,
		const char *	keyfield,
		const char *	lookup,
		const struct ast_variable *	fields
	)

Update realtime configuration.

Parameters

family	which family/config to be updated
keyfield	which field to use as the key
lookup	which value to look for in the key field to match the entry.
fields	fields to update

This function is used to update a parameter in realtime configuration space.

Returns

Number of rows affected, or -1 on error.

Definition at line 3905 of file main/config.c.

{
    struct ast_config_engine *eng;
    int res = -1, i;
    char db[256];
    char table[256];
 
    for (i = 1; ; i++) {
        if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
            /* If the update succeeds, it returns >= 0. */
            if (eng->update_func && ((res = eng->update_func(db, table, keyfield, lookup, fields)) >= 0)) {
                break;
            }
        } else {
            break;
        }
    }
 
    return res;
}

References db, find_engine(), table, and ast_config_engine::update_func.

Referenced by ast_update_realtime(), and sorcery_realtime_update().

ast_variable_append()

void ast_variable_append	(	struct ast_category *	category,
		struct ast_variable *	variable
	)

Definition at line 573 of file main/config.c.

{
    if (!variable)
        return;
    if (category->last)
        category->last->next = variable;
    else
        category->root = variable;
    category->last = variable;
    while (category->last->next)
        category->last = category->last->next;
}

References ast_category::last, ast_variable::next, and ast_category::root.

Referenced by add_message_id(), append_row_to_cfg(), ast_category_inherit(), AST_TEST_DEFINE(), build_cfg(), config_curl(), config_ldap(), config_mysql(), config_odbc(), config_pgsql(), handle_updates(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_sorcery_multi(), realtime_sorcery_store(), realtime_sorcery_update(), static_realtime_cb(), and write_password_to_file().

ast_variable_browse()

struct ast_variable * ast_variable_browse	(	const struct ast_config *	config,
		const char *	category
	)

Definition at line 687 of file main/config.c.

{
    struct ast_category *cat;
 
    if (config->last_browse && (config->last_browse->name == category)) {
        cat = config->last_browse;
    } else {
        cat = ast_category_get(config, category, NULL);
    }
 
    return (cat) ? cat->root : NULL;
}

References ast_category_get(), config, NULL, and ast_category::root.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_sorcery_apply_config(), __init_manager(), _dsp_init(), aco_process_category_options(), adsi_load(), ast_cli_perms_init(), AST_TEST_DEFINE(), ast_variable_retrieve(), build_calendar(), build_device(), caldav_load_calendar(), conf_exec(), config_module(), do_reload(), do_say(), ewscal_load_calendar(), exchangecal_load_calendar(), find_conf(), get_defaults(), handle_cli_dialplan_save(), iax_template_parse(), ical_load_calendar(), init_logger_chain(), load_aliases(), load_asterisk_conf(), load_common(), load_config(), load_general_config(), load_module(), load_moh_classes(), load_odbc_config(), load_users(), load_zonemessages(), loader_config_init(), mbl_load_adapter(), mbl_load_config(), mbl_load_device(), new_realtime_sqlite3_db(), odbc_load_module(), parse_config(), parse_general_options(), parse_tone_zone(), pbx_load_config(), process_my_load_module(), read_pjproject_startup_options(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_single_queue(), rtp_reload(), run_startup_commands(), search_directory_sub(), set_config(), setup_dahdi_int(), show_users_realtime(), sla_build_station(), sla_build_trunk(), smdi_load(), tds_load_module(), test_config_validity(), and xmldoc_load_documentation().

ast_variable_delete()

int ast_variable_delete	(	struct ast_category *	category,
		const char *	variable,
		const char *	match,
		const char *	line
	)

Definition at line 1601 of file main/config.c.

{
    struct ast_variable *cur, *prev=NULL, *curn;
    int res = -1;
    int num_item = 0;
    int req_item;
 
    req_item = -1;
    if (!ast_strlen_zero(line)) {
        /* Requesting to delete by item number. */
        if (sscanf(line, "%30d", &req_item) != 1
            || req_item < 0) {
            /* Invalid item number to delete. */
            return -1;
        }
    }
 
    prev = NULL;
    cur = category->root;
    while (cur) {
        curn = cur->next;
        /* Delete by item number or by variable name with optional value. */
        if ((0 <= req_item && num_item == req_item)
            || (req_item < 0 && !strcasecmp(cur->name, variable)
                && (ast_strlen_zero(match) || !strcasecmp(cur->value, match)))) {
            if (prev) {
                prev->next = cur->next;
                if (cur == category->last)
                    category->last = prev;
            } else {
                category->root = cur->next;
                if (cur == category->last)
                    category->last = NULL;
            }
            ast_variable_destroy(cur);
            res = 0;
        } else
            prev = cur;
 
        cur = curn;
        ++num_item;
    }
    return res;
}

References ast_strlen_zero(), ast_variable_destroy(), ast_category::last, match(), ast_variable::name, ast_variable::next, ast_category::next, NULL, ast_category::prev, ast_category::root, and ast_variable::value.

Referenced by handle_updates().

ast_variable_destroy()

static void ast_variable_destroy ( struct ast_variable *  doomed )

static

Definition at line 622 of file main/config.c.

{
    ast_comment_destroy(&doomed->precomments);
    ast_comment_destroy(&doomed->sameline);
    ast_comment_destroy(&doomed->trailing);
    ast_free(doomed);
}

References ast_comment_destroy(), ast_free, ast_variable::precomments, ast_variable::sameline, and ast_variable::trailing.

Referenced by ast_include_rename(), ast_load_realtime_fields(), ast_variable_delete(), ast_variable_update(), and ast_variables_destroy().

ast_variable_find()

const char * ast_variable_find	(	const struct ast_category *	category,
		const char *	variable
	)

Gets a variable value from a specific category structure by name.

Parameters

category	category structure under which the variable lies
variable	which variable you wish to get the data for

Goes through a given category and searches for the given variable

Return values

The	variable value on success
NULL	if unable to find it.

Definition at line 919 of file main/config.c.

{
    return ast_variable_find_in_list(category->root, variable);
}

References ast_variable_find_in_list(), and ast_category::root.

Referenced by AST_TEST_DEFINE(), ast_variable_retrieve_filtered(), and extension_length_comparator().

ast_variable_find_in_list()

const char * ast_variable_find_in_list	(	const struct ast_variable *	list,
		const char *	variable
	)

Gets the value of a variable from a variable list by name.

Parameters

list	variable list to search
variable	which variable you wish to get the data for

Goes through a given variable list and searches for the given variable

Return values

The	variable value on success
NULL	if unable to find it.

Definition at line 1014 of file main/config.c.

{
    const struct ast_variable *v;
 
    for (v = list; v; v = v->next) {
        if (!strcasecmp(variable, v->name)) {
            return v->value;
        }
    }
    return NULL;
}

References ast_variable::name, ast_variable::next, NULL, and ast_variable::value.

Referenced by ast_ari_callback(), ast_geoloc_eprofile_to_uri(), ast_geoloc_gml_validate_varlist(), ast_sorcery_changeset_create(), AST_TEST_DEFINE(), ast_variable_find(), geoloc_civicaddr_list_to_xml(), geoloc_eprofile_to_intermediate(), geoloc_gml_list_to_xml(), handle_export_primitives(), incoming_ws_established_cb(), load_realtime_musiconhold(), retrieve_cert_from_url(), validate_location_info(), and websocket_attempted_cb().

ast_variable_find_last_in_list()

const char * ast_variable_find_last_in_list	(	const struct ast_variable *	list,
		const char *	variable
	)

Gets the value of the LAST occurrence of a variable from a variable list.

Parameters

list	The ast_variable list to search
variable	The name of the ast_variable you wish to fetch data for

Iterates over a given ast_variable list to search for the last occurrence of an ast_variable entry with a name attribute matching the given name (variable). This is useful if the list has duplicate entries (such as in cases where entries are created by a template)

Return values

The	variable value on success
NULL	if unable to find it.

Definition at line 1026 of file main/config.c.

{
    const struct ast_variable *v;
    const char *found = NULL;
 
    for (v = list; v; v = v->next) {
        if (!strcasecmp(variable, v->name)) {
            found = v->value;
        }
    }
    return found;
}

References ast_variable::name, ast_variable::next, NULL, and ast_variable::value.

Referenced by AST_TEST_DEFINE(), handle_aor(), handle_auth(), handle_endpoint(), handle_identify(), handle_phoneprov(), handle_registrations(), is_variable_true(), and wizard_apply_handler().

ast_variable_find_variable_in_list()

const struct ast_variable * ast_variable_find_variable_in_list	(	const struct ast_variable *	list,
		const char *	variable_name
	)

Gets a variable from a variable list by name.

Since

13.9.0

Parameters

list	variable list to search
variable_name	name you wish to get the data for

Goes through a given variable list and searches for the given variable

Return values

The	variable (not the value) on success
NULL	if unable to find it.

Definition at line 924 of file main/config.c.

{
    const struct ast_variable *v;
 
    for (v = list; v; v = v->next) {
        if (!strcasecmp(variable_name, v->name)) {
            return v;
        }
    }
    return NULL;
}

References ast_variable::name, ast_variable::next, and NULL.

Referenced by ast_variable_lists_match(), and realtime_sorcery_store().

ast_variable_insert()

void ast_variable_insert	(	struct ast_category *	category,
		struct ast_variable *	variable,
		const char *	line
	)

Definition at line 586 of file main/config.c.

{
    struct ast_variable *cur = category->root;
    int lineno;
    int insertline;
 
    if (!variable || sscanf(line, "%30d", &insertline) != 1) {
        return;
    }
    if (!insertline) {
        variable->next = category->root;
        category->root = variable;
    } else {
        for (lineno = 1; lineno < insertline; lineno++) {
            cur = cur->next;
            if (!cur->next) {
                break;
            }
        }
        variable->next = cur->next;
        cur->next = variable;
    }
}

References ast_variable::lineno, ast_variable::next, and ast_category::root.

Referenced by AST_TEST_DEFINE(), and handle_updates().

ast_variable_list_append_hint()

struct ast_variable * ast_variable_list_append_hint	(	struct ast_variable **	head,
		struct ast_variable *	search_hint,
		struct ast_variable *	new_var
	)

Appends a variable list to the end of another list.

Parameters

head	A pointer to an ast_variable * of the existing variable list head. May NOT be NULL but the content may be to initialize a new list. If so, upon return, this parameter will be updated with a pointer to the new list head.
search_hint	The place in the current list to start searching for the end of the list. Might help performance on longer lists. If NULL, it defaults to head.
new_var	The head of the new variable list to be appended

Returns

The tail of the resulting list.

Note

If the existing *head is NULL, it will be updated to new_var. This allows you to call ast_variable_list_append in a loop or callback without initializing the list first.

Definition at line 733 of file main/config.c.

{
    struct ast_variable *curr;
    struct ast_variable *sh = search_hint;
    ast_assert(head != NULL);
 
    if (!*head) {
        *head = newvar;
    } else {
        if (sh == NULL) {
            sh = *head;
        }
        for (curr = sh; curr->next; curr = curr->next);
        curr->next = newvar;
    }
 
    for (curr = newvar; curr->next; curr = curr->next);
 
    return curr;
}

References ast_assert, ast_variable::next, and NULL.

Referenced by ast_json_nvp_array_to_ast_variables(), ast_json_to_ast_variables(), ast_sorcery_objectset_create2(), and AST_TEST_DEFINE().

ast_variable_list_from_quoted_string()

struct ast_variable * ast_variable_list_from_quoted_string	(	const char *	input,
		const char *	item_separator,
		const char *	name_value_separator,
		const char *	quote_str
	)

Parse a string into an ast_variable list. The reverse of ast_variable_list_join.

Parameters

input	The name-value pair string to parse.
item_separator	The string used to separate the list items. Only the first character in the string will be used. If NULL, "," will be used.
name_value_separator	The string used to separate each item's name and value. Only the first character in the string will be used. If NULL, "=" will be used.
quote_str	The string used to quote values. Only the first character in the string will be used. If NULL, '"' will be used.

Return values

A	pointer to a list of ast_variables.
NULL	if there was an error or no variables could be parsed.

Definition at line 813 of file main/config.c.

{
    char item_sep;
    char nv_sep;
    char quote;
    struct ast_variable *new_list = NULL;
    struct ast_variable *new_var = NULL;
    char *item_string;
    char *item;
    char *item_name;
    char *item_value;
 
    if (ast_strlen_zero(input)) {
        return NULL;
    }
 
    item_sep = ast_strlen_zero(item_separator) ? ',' : item_separator[0];
    nv_sep = ast_strlen_zero(name_value_separator) ? '=' : name_value_separator[0];
    quote = ast_strlen_zero(quote_str) ? '"' : quote_str[0];
    item_string = ast_strip(ast_strdupa(input));
 
    while ((item = ast_strsep_quoted(&item_string, item_sep, quote, AST_STRSEP_ALL))) {
        item_name = ast_strsep_quoted(&item, nv_sep, quote, AST_STRSEP_ALL);
        if (!item_name) {
            ast_variables_destroy(new_list);
            return NULL;
        }
 
        item_value = ast_strsep_quoted(&item, nv_sep, quote, AST_STRSEP_ALL);
 
        new_var = ast_variable_new(item_name, item_value ?: "", "");
        if (!new_var) {
            ast_variables_destroy(new_list);
            return NULL;
        }
        ast_variable_list_append(&new_list, new_var);
    }
    return new_list;
}

References ast_strdupa, ast_strip(), ast_strlen_zero(), AST_STRSEP_ALL, ast_strsep_quoted(), ast_variable_list_append, ast_variable_new, ast_variables_destroy(), input(), item, NULL, and quote().

Referenced by AST_TEST_DEFINE(), and ast_variable_list_from_string().

ast_variable_list_from_string()

struct ast_variable * ast_variable_list_from_string	(	const char *	input,
		const char *	item_separator,
		const char *	name_value_separator
	)

Parse a string into an ast_variable list. The reverse of ast_variable_list_join.

Parameters

input	The name-value pair string to parse.
item_separator	The string used to separate the list items. Only the first character in the string will be used. If NULL, "," will be used.
name_value_separator	The string used to separate each item's name and value. Only the first character in the string will be used. If NULL, "=" will be used.

Return values

A	pointer to a list of ast_variables.
NULL	if there was an error or no variables could be parsed.

Definition at line 854 of file main/config.c.

{
    return ast_variable_list_from_quoted_string(input, item_separator, name_value_separator, NULL);
}

References ast_variable_list_from_quoted_string(), input(), and NULL.

ast_variable_list_join()

struct ast_str * ast_variable_list_join	(	const struct ast_variable *	head,
		const char *	item_separator,
		const char *	name_value_separator,
		const char *	quote_char,
		struct ast_str **	str
	)

Join an ast_variable list with specified separators and quoted values.

Parameters

head	A pointer to an ast_variable list head.
item_separator	The string to use to separate the list items. If NULL, "," will be used.
name_value_separator	The string to use to separate each item's name and value. If NULL, "=" will be used.
str	A pointer to a pre-allocated ast_str in which to put the results. If NULL, one will be allocated and returned.
quote_char	The quote char to use for the values. May be NULL or empty for no quoting.

Return values

A	pointer to the result ast_str. This may NOT be the same as the pointer passed in if the original ast_str wasn't large enough to hold the result. Regardless, the pointer MUST be freed after use.
NULL	if there was an error.

Definition at line 787 of file main/config.c.

{
    struct ast_variable *var = (struct ast_variable *)head;
    struct ast_str *local_str = NULL;
 
    if (str == NULL || *str == NULL) {
        local_str = ast_str_create(AST_MAX_USER_FIELD);
        if (!local_str) {
            return NULL;
        }
    } else {
        local_str = *str;
    }
 
    for (; var; var = var->next) {
        ast_str_append(&local_str, 0, "%s%s%s%s%s%s", var->name, name_value_separator, S_OR(quote_char, ""),
            var->value, S_OR(quote_char, ""), var->next ? item_separator : "");
    }
 
    if (str != NULL) {
        *str = local_str;
    }
    return local_str;
}

References AST_MAX_USER_FIELD, ast_str_append(), ast_str_create, NULL, S_OR, str, and var.

Referenced by add_eprofile_to_channel(), AST_TEST_DEFINE(), geoloc_config_list_locations(), geoloc_config_show_profiles(), validate_location_info(), var_list_from_confidence(), var_list_from_loc_info(), and var_list_from_node().

ast_variable_list_replace()

int ast_variable_list_replace	(	struct ast_variable **	head,
		struct ast_variable *	replacement
	)

Replace a variable in the given list with a new value.

Since

13.30.0

Parameters

head	A pointer to an ast_variable * of the existing variable list head. May NOT be NULL but the content may be to initialize a new list. If so, upon return, this parameter will be updated with a pointer to the new list head.
replacement	The variable that replaces another variable in the list with the same name.

Return values

0	if a variable was replaced in the list
-1	if no replacement occured

Note

The variable name comparison is performed case-sensitively

If a variable is replaced, its memory is freed.

Definition at line 754 of file main/config.c.

{
    struct ast_variable *v, **prev = head;
 
    for (v = *head; v; prev = &v->next, v = v->next) {
        if (!strcmp(v->name, replacement->name)) {
            replacement->next = v->next;
            *prev = replacement;
            ast_free(v);
            return 0;
        }
    }
 
    return -1;
}

References ast_free, ast_variable::name, and ast_variable::next.

Referenced by ast_geoloc_eprofile_refresh_location(), build_user(), check_access(), mkintf(), process_dahdi(), and set_var_handler().

ast_variable_list_replace_variable()

int ast_variable_list_replace_variable	(	struct ast_variable **	head,
		struct ast_variable *	oldvar,
		struct ast_variable *	newvar
	)

Replace a variable in the given list with a new variable.

Parameters

head	A pointer to the current variable list head. Since the variable to be replaced, this pointer may be updated with the new head.
oldvar	A pointer to the existing variable to be replaced.
newvar	A pointer to the new variable that will replace the old one.

Return values

0	if a variable was replaced in the list
-1	if no replacement occured

Note

The search for the old variable is done simply on the pointer.

If a variable is replaced, its memory is freed.

Definition at line 770 of file main/config.c.

{
    struct ast_variable *v, **prev = head;
 
    for (v = *head; v; prev = &v->next, v = v->next) {
        if (v == old) {
            new->next = v->next;
            *prev = new;
            ast_free(v);
            return 0;
        }
    }
 
    return -1;
}

References ast_free, and ast_variable::next.

Referenced by AST_TEST_DEFINE().

ast_variable_list_sort()

struct ast_variable * ast_variable_list_sort

(

struct ast_variable *

head

)

Performs an in-place sort on the variable list by ascending name.

Parameters

head	The variable list head

Returns

The new list head

Definition at line 707 of file main/config.c.

{
    struct ast_variable *p, *q;
    struct ast_variable top;
    int changed = 1;
    memset(&top, 0, sizeof(top));
    top.next = start;
    if (start != NULL && start->next != NULL) {
        while (changed) {
            changed = 0;
            q = ⊤
            p = top.next;
            while (p->next != NULL) {
                if (p->next != NULL && strcmp(p->name, p->next->name) > 0) {
                    q->next = variable_list_switch(p, p->next);
                    changed = 1;
                }
                q = p;
                if (p->next != NULL)
                    p = p->next;
            }
        }
    }
    return top.next;
}

References ast_variable::name, ast_variable::next, NULL, and variable_list_switch().

Referenced by aeap_cli_show(), ast_sip_cli_print_sorcery_objectset(), and config_object_cli_show().

ast_variable_lists_match()

int ast_variable_lists_match	(	const struct ast_variable *	left,
		const struct ast_variable *	right,
		int	exact_match
	)

Tests 2 variable lists to see if they match.

Since

13.9.0

Parameters

left	Variable list to test
right	Variable list with an optional realtime-style operator in the names
exact_match	If true, all variables in left must match all variables in right and vice versa. This does exact value matches only. Operators aren't supported. Except for order, the left and right lists must be equal.

If false, every variable in the right list must match some variable in the left list using the operators supplied. Variables in the left list that aren't in the right list are ignored for matching purposes.

Return values

1	matches
0	doesn't match

Iterates over the variable lists calling ast_variables_match. If any match fails or a variable in the right list isn't in the left list, 0 is returned.

Definition at line 956 of file main/config.c.

{
    const struct ast_variable *field;
    int right_count = 0;
    int left_count = 0;
 
    if (left == right) {
        return 1;
    }
 
    if (!(left && right)) {
        return 0;
    }
 
    for (field = right; field; field = field->next) {
        char *space = strrchr(field->name, ' ');
        const struct ast_variable *old;
        char * name = (char *)field->name;
 
        if (space) {
            name = ast_strdup(field->name);
            if (!name) {
                return 0;
            }
            name[space - field->name] = '\0';
        }
 
        old = ast_variable_find_variable_in_list(left, name);
        if (name != field->name) {
            ast_free(name);
        }
 
        if (exact_match) {
            if (!old || strcmp(old->value, field->value)) {
                return 0;
            }
        } else {
            if (!ast_variables_match(old, field)) {
                return 0;
            }
        }
 
        right_count++;
    }
 
    if (exact_match) {
        for (field = left; field; field = field->next) {
            left_count++;
        }
 
        if (right_count != left_count) {
            return 0;
        }
    }
 
    return 1;
}

References ast_free, ast_strdup, ast_variable_find_variable_in_list(), ast_variables_match(), if(), name, ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by AST_TEST_DEFINE(), object_type_loaded_observer(), realtime_sorcery(), realtime_sorcery_multi(), sorcery_astdb_retrieve_fields_common(), sorcery_config_fields_cmp(), sorcery_memory_cache_fields_cmp(), and sorcery_memory_fields_cmp().

ast_variable_move()

static void ast_variable_move ( struct ast_variable *  dst_var, struct ast_variable *  src_var  )

static

Definition at line 349 of file main/config.c.

{
    dst_var->lineno = src_var->lineno;
    dst_var->object = src_var->object;
    dst_var->blanklines = src_var->blanklines;
    dst_var->precomments = src_var->precomments;
    src_var->precomments = NULL;
    dst_var->sameline = src_var->sameline;
    src_var->sameline = NULL;
    dst_var->trailing = src_var->trailing;
    src_var->trailing = NULL;
}

References ast_variable::blanklines, ast_variable::lineno, NULL, ast_variable::object, ast_variable::precomments, ast_variable::sameline, and ast_variable::trailing.

Referenced by ast_include_rename(), and ast_variable_update().

ast_variable_retrieve()

const char * ast_variable_retrieve	(	struct ast_config *	config,
		const char *	category,
		const char *	variable
	)

Definition at line 870 of file main/config.c.

{
    struct ast_variable *v;
    const char *match = NULL;
 
    /* We can't return as soon as we find a match, because if a config section overrides
     * something specified in a template, then the actual effective value is the last
     * one encountered, not the first one.
     * (This is like using the -1 index for the AST_CONFIG function.)
     * Also see ast_variable_find_last_in_list
     */
 
    if (category) {
        for (v = ast_variable_browse(config, category); v; v = v->next) {
            if (!strcasecmp(variable, v->name)) {
                match = v->value;
            }
        }
    } else {
        struct ast_category *cat;
 
        for (cat = config->root; cat; cat = cat->next) {
            for (v = cat->root; v; v = v->next) {
                if (!strcasecmp(variable, v->name)) {
                    match = v->value;
                }
            }
        }
    }
 
    return match;
}

References ast_variable_browse(), config, match(), ast_variable::name, ast_variable::next, ast_category::next, NULL, ast_category::root, and ast_variable::value.

Referenced by __queues_show(), actual_load_config(), advanced_options(), ast_config_option(), ast_init_logger_for_socket_console(), AST_TEST_DEFINE(), check_for_old_config(), conf_exec(), config_module(), directory_exec(), festival_exec(), find_realtime(), forward_message(), get_defaults(), iax_template_parse(), init_acf_query(), init_logger_chain(), initialize_cc_devstate_map_helper(), initialize_cc_max_requests(), internal_aco_type_find(), load_config(), load_config_meetme(), load_indications(), load_module(), load_mysql_config(), load_realtime_musiconhold(), load_realtime_queues(), load_realtime_rules(), load_tech_calendars(), load_users(), loader_config_init(), make_email_file(), mbl_load_adapter(), mbl_load_device(), message_range_and_existence_check(), named_acl_find_realtime(), notify_new_message(), odbc_load_module(), parse_config(), pbx_load_config(), play_message(), prep_email_sub_vars(), private_enum_init(), process_my_load_module(), queue_rules_set_global_params(), queue_set_global_params(), read_password_from_file(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_single_queue(), rt_handle_member_record(), rtp_reload(), search_directory(), set_config(), set_member_value(), setup_dahdi_int(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), vm_change_password(), vm_forwardoptions(), vm_msg_forward(), vm_msg_play(), and vm_msg_snapshot_create().

ast_variable_retrieve_filtered()

const char * ast_variable_retrieve_filtered	(	struct ast_config *	config,
		const char *	category,
		const char *	variable,
		const char *	filter
	)

Gets a variable by context and variable names.

Parameters

config	which (opened) config to use
category	category under which the variable lies
variable	which variable you wish to get the data for
filter	an optional comma-separated list of <name_regex>=<value_regex> pairs. Only categories with matching variables will be searched. The special name 'TEMPLATES' can be used with the special values 'include' or 'restrict' to include templates in the result or restrict the result to only templates.

Return values

The	variable value on success
NULL	if unable to find it.

Definition at line 903 of file main/config.c.

{
    struct ast_category *cat = NULL;
    const char *value;
 
    while ((cat = ast_category_browse_filtered(config, category, cat, filter))) {
        value = ast_variable_find(cat, variable);
        if (value) {
            return value;
        }
    }
 
    return NULL;
}

References ast_category_browse_filtered(), ast_variable_find(), config, filter(), NULL, and value.

ast_variable_update()

int ast_variable_update	(	struct ast_category *	category,
		const char *	variable,
		const char *	value,
		const char *	match,
		unsigned int	object
	)

Update variable value within a config.

Parameters

category	Category element within the config
variable	Name of the variable to change
value	New value of the variable
match	If set, previous value of the variable (if NULL or zero-length, no matching will be done)
object	Boolean of whether to make the new variable an object

Returns

0 on success or -1 on failure.

Definition at line 1646 of file main/config.c.

{
    struct ast_variable *cur, *prev = NULL, *newer = NULL;
    struct ast_variable *matchcur = NULL, *matchprev = NULL;
 
    /* Find the last match. See comments in ast_variable_retrieve,
     * but this ensures updating config sections that inherit from
     * templates works properly. */
    for (cur = category->root; cur; prev = cur, cur = cur->next) {
        if (strcasecmp(cur->name, variable) || (!ast_strlen_zero(match) && strcasecmp(cur->value, match))) {
            /* Not the same variable,
             * or its value doesn't match. */
            continue;
        }
        matchprev = prev;
        matchcur = cur;
    }
 
    if (!matchcur) {
        /* Could not find variable to update */
        return -1;
    }
 
    /* Restore pointers from the matching var */
    prev = matchprev;
    cur = matchcur;
 
    if (!(newer = ast_variable_new(variable, value, cur->file))) {
        return -1;
    }
 
    ast_variable_move(newer, cur);
    newer->object = newer->object || object;
 
    /* Replace the old node in the list with the new node. */
    newer->next = cur->next;
    if (prev) {
        prev->next = newer;
    } else {
        category->root = newer;
    }
    if (category->last == cur) {
        category->last = newer;
    }
 
    ast_variable_destroy(cur);
    return 0;
}

References ast_strlen_zero(), ast_variable_destroy(), ast_variable_move(), ast_variable_new, ast_variable::file, ast_category::last, match(), ast_variable::name, ast_variable::next, ast_category::next, NULL, ast_category::prev, ast_category::root, ast_variable::value, and value.

Referenced by handle_updates(), process_text_line(), vm_change_password(), and vm_forwardoptions().

ast_variables_destroy()

void ast_variables_destroy

(

struct ast_variable *

var

)

Free variable list.

Parameters

var	the linked list of variables to free

This function frees a list of variables.

Definition at line 676 of file main/config.c.

{
    struct ast_variable *vn;
 
    while (var) {
        vn = var;
        var = var->next;
        ast_variable_destroy(vn);
    }
}

References ast_variable_destroy(), free(), ast_variable::next, and var.

Referenced by __init_manager(), aco_set_defaults(), action_messagesend(), action_originate(), add_message_id(), aeap_cli_show(), announce_to_dial(), app_notify(), ari_conf_owc_detect_changes(), ast_aeap_client_configs_get(), ast_ari_asterisk_update_object(), ast_ari_callback(), ast_ari_channels_create(), ast_ari_channels_external_media(), ast_ari_channels_originate(), ast_ari_channels_originate_with_id(), ast_ari_endpoints_refer(), ast_ari_endpoints_refer_to_endpoint(), ast_ari_endpoints_send_message(), ast_ari_endpoints_send_message_to_endpoint(), ast_ari_invoke(), ast_category_destroy(), ast_category_empty(), ast_destroy_realtime(), ast_geoloc_eprofile_refresh_location(), ast_geoloc_eprofile_to_uri(), ast_http_get_cookies(), ast_http_manid_from_vars(), ast_json_to_ast_variables(), ast_load_realtime(), ast_load_realtime_all(), ast_load_realtime_multientry(), ast_sip_cli_print_sorcery_objectset(), ast_sip_sorcery_object_to_ami(), ast_sorcery_changeset_create(), ast_sorcery_copy(), ast_sorcery_diff(), ast_sorcery_object_set_extended(), ast_sorcery_objectset_apply(), ast_sorcery_objectset_json_create(), ast_store_realtime(), ast_stream_free(), ast_stream_get_metadata_list(), AST_TEST_DEFINE(), ast_update2_realtime(), ast_update_realtime(), ast_var_channel_types(), ast_var_channel_types_table(), ast_variable_list_from_quoted_string(), ast_variables_dup(), ast_websocket_client_get_field_diff(), auth_http_callback(), calendar_destructor(), can_reuse_registration(), check_expiration_thread(), cli_contact_get_container(), cli_realtime_load(), conf_run(), config_object_cli_show(), copy_plain_file(), create_mwi_subscriptions(), curl_header_data_free(), destroy_dahdi_pvt(), destroy_fast_originate_helper(), dup_vars(), endpoint_destructor(), fields_handler(), find_conf_realtime(), find_load_queue_rt_friendly(), find_realtime(), find_user_realtime(), free_entry(), free_outgoing(), free_user(), function_realtime_read(), function_realtime_readdestroy(), generic_http_callback(), geoloc_eprofile_destructor(), geoloc_eprofile_resolve_varlist(), geoloc_eprofile_to_intermediate(), geoloc_location_destructor(), geoloc_profile_destructor(), get_multiple_fields_as_var_list(), get_object_variables(), handle_aor(), handle_auth(), handle_endpoint(), handle_export_primitives(), handle_identify(), handle_phoneprov(), handle_pjproject_show_log_mappings(), handle_registrations(), handle_showchan(), handle_uri(), http_request_headers_get(), httpd_process_request(), httpstatus_callback(), incoming_ws_http_callback(), ldap_loadentry(), leave_queue(), load_realtime_musiconhold(), local_ast_moh_start(), manager_free_user(), manager_send_response(), mkintf(), notify_ami_channel_data_destroy(), notify_ami_data_destroy(), notify_ami_uri_data_destroy(), object_type_loaded_observer(), originate_exec(), outbound_session_handler_thread(), pjsip_aor_function_read(), pjsip_contact_function_read(), pjsip_endpoint_function_read(), process_dahdi(), publication_resource_destroy(), pvt_destructor(), queue_function_queuegetchannel(), queue_function_queuewaitingcount(), realtime_arguments_to_fields(), realtime_arguments_to_fields2(), realtime_canmatch(), realtime_common(), realtime_exec(), realtime_exists(), realtime_ldap_base(), realtime_ldap_base_ap(), realtime_ldap_result_to_vars(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), realtimefield_read(), request_destroy(), return_sorcery_object(), row_to_varlist(), rt_extend_conf(), session_destructor(), sip_aor_to_ami(), socket_process_helper(), sorcery_astdb_filter_objectset(), sorcery_astdb_retrieve_fields_common(), sorcery_astdb_retrieve_id(), sorcery_astdb_retrieve_prefix(), sorcery_astdb_retrieve_regex(), sorcery_config_destructor(), sorcery_config_fields_cmp(), sorcery_function_read(), sorcery_is_criteria_met(), sorcery_memory_cache_fields_cmp(), sorcery_memory_cached_object_destructor(), sorcery_memory_fields_cmp(), sorcery_object_destructor(), sorcery_realtime_create(), sorcery_realtime_filter_objectset(), sorcery_realtime_retrieve_fields(), sorcery_realtime_retrieve_id(), sorcery_realtime_retrieve_multiple(), sorcery_realtime_retrieve_prefix(), sorcery_realtime_retrieve_regex(), sorcery_realtime_update(), speech_aeap_engine_create(), table_configs_free(), test_sorcery_object_destroy(), test_sorcery_transform(), transport_apply(), update_ldap(), user_destructor(), var_list_from_confidence(), var_list_from_loc_info(), var_list_from_node(), and websocket_client_handshake().

ast_variables_dup()

struct ast_variable * ast_variables_dup

(

struct ast_variable *

var

)

Duplicate variable list.

Parameters

var	the linked list of variables to clone

Returns

A duplicated list which you'll need to free with ast_variables_destroy or NULL when out of memory.

Note

Do not depend on this to copy more than just name, value and filename (the arguments to ast_variables_new).

Definition at line 630 of file main/config.c.

{
    struct ast_variable *cloned;
    struct ast_variable *tmp;
 
    if (!(cloned = ast_variable_new(var->name, var->value, var->file))) {
        return NULL;
    }
 
    tmp = cloned;
 
    while ((var = var->next)) {
        if (!(tmp->next = ast_variable_new(var->name, var->value, var->file))) {
            ast_variables_destroy(cloned);
            return NULL;
        }
        tmp = tmp->next;
    }
 
    return cloned;
}

References ast_variable_new, ast_variables_destroy(), ast_variable::next, NULL, and var.

Referenced by action_originate(), ast_ari_callback(), ast_config_copy(), authenticate(), handle_registrations(), jim_handler(), jim_vl(), realtime_sorcery(), realtime_sorcery_multi(), realtime_sorcery_store(), realtime_sorcery_update(), set_var_to_vl(), and sorcery_extended_fields_handler().

ast_variables_match()

int ast_variables_match	(	const struct ast_variable *	left,
		const struct ast_variable *	right
	)

Tests 2 variable values to see if they match.

Since

13.9.0

Parameters

left	Variable to test
right	Variable to match against with an optional realtime-style operator in the name

Return values

1	matches
0	doesn't match

The values of the variables are passed to ast_strings_match. If right->name is suffixed with a space and an operator, that operator is also passed to ast_strings_match.

Examples:

left->name = "id" (ignored) left->value = "abc" right->name = "id regex" (id is ignored) right->value = "a[bdef]c"

will result in ast_strings_match("abc", "regex", "a[bdef]c") which will return 1.

left->name = "id" (ignored) left->value = "abc" right->name = "id" (ignored) right->value = "abc"

will result in ast_strings_match("abc", NULL, "abc") which will return 1.

See the documentation for ast_strings_match for the valid operators.

Definition at line 936 of file main/config.c.

{
    char *op;
 
    if (left == right) {
        return 1;
    }
 
    if (!(left && right)) {
        return 0;
    }
 
    op = strrchr(right->name, ' ');
    if (op) {
        op++;
    }
 
    return ast_strings_match(left->value, op ? ast_strdupa(op) : NULL, right->value);
}

References ast_strdupa, ast_strings_match(), ast_variable::name, NULL, and ast_variable::value.

Referenced by ast_variable_lists_match().

ast_variables_reverse()

struct ast_variable * ast_variables_reverse

(

struct ast_variable *

var

)

Reverse a variable list.

Parameters

var	the linked list of variables to reverse

Returns

The head of the reversed variable list

Note

The variable list var is not preserved in this function and should not be used after reversing it.

Definition at line 652 of file main/config.c.

{
    struct ast_variable *var1, *var2;
 
    var1 = var;
 
    if (!var1 || !var1->next) {
        return var1;
    }
 
    var2 = var1->next;
    var1->next = NULL;
 
    while (var2) {
        struct ast_variable *next = var2->next;
 
        var2->next = var1;
        var1 = var2;
        var2 = next;
    }
 
    return var1;
}

References ast_variable::next, NULL, and var.

Referenced by astman_get_variables_order().

category_get_sep()

static struct ast_category * category_get_sep ( const struct ast_config *  config, const char *  category_name, const char *  filter, char  sep, char  pointer_match_possible  )

static

Definition at line 1184 of file main/config.c.

{
    struct ast_category *cat;
 
    if (pointer_match_possible) {
        for (cat = config->root; cat; cat = cat->next) {
            if (cat->name == category_name && does_category_match(cat, category_name, filter, sep)) {
                return cat;
            }
        }
    }
 
    for (cat = config->root; cat; cat = cat->next) {
        if (does_category_match(cat, category_name, filter, sep)) {
            return cat;
        }
    }
 
    return NULL;
}

References config, does_category_match(), filter(), ast_category::name, ast_category::next, and NULL.

Referenced by ast_category_get(), and process_text_line().

CB_ADD()

static void CB_ADD ( struct ast_str **  cb, const char *  str  )

static

Definition at line 130 of file main/config.c.

{
    ast_str_append(cb, 0, "%s", str);
}

References ast_str_append(), and str.

Referenced by config_text_file_load().

CB_ADD_LEN()

static void CB_ADD_LEN ( struct ast_str **  cb, const char *  str, int  len  )

static

Definition at line 135 of file main/config.c.

{
    char *s = ast_alloca(len + 1);
 
    memcpy(s, str, len);
    s[len] = '\0';
    ast_str_append(cb, 0, "%s", s);
}

References ast_alloca, ast_str_append(), len(), and str.

Referenced by config_text_file_load().

CB_RESET()

static void CB_RESET ( struct ast_str *  cb, struct ast_str *  llb  )

static

Definition at line 144 of file main/config.c.

{
    if (cb) {
        ast_str_reset(cb);
    }
    if (llb) {
        ast_str_reset(llb);
    }
}

References ast_str_reset().

Referenced by config_text_file_load(), and process_text_line().

cfmstat_cmp()

static int cfmstat_cmp ( struct cache_file_mtime *  cfmtime, struct stat *  statbuf  )

static

Definition at line 1834 of file main/config.c.

{
    struct cache_file_mtime cfm_buf;
 
    cfmstat_save(&cfm_buf, statbuf);
 
    return cfmtime->stat_size != cfm_buf.stat_size
        || cfmtime->stat_mtime != cfm_buf.stat_mtime
        || cfmtime->stat_mtime_nsec != cfm_buf.stat_mtime_nsec;
}

References cfmstat_save(), cache_file_mtime::stat_mtime, cache_file_mtime::stat_mtime_nsec, and cache_file_mtime::stat_size.

Referenced by config_text_file_load().

cfmstat_save()

static void cfmstat_save ( struct cache_file_mtime *  cfmtime, struct stat *  statbuf  )

static

Definition at line 1810 of file main/config.c.

{
    cfmtime->stat_size = statbuf->st_size;
#if defined(HAVE_STRUCT_STAT_ST_MTIM)
    cfmtime->stat_mtime_nsec = statbuf->st_mtim.tv_nsec;
#elif defined(HAVE_STRUCT_STAT_ST_MTIMENSEC)
    cfmtime->stat_mtime_nsec = statbuf->st_mtimensec;
#elif defined(HAVE_STRUCT_STAT_ST_MTIMESPEC)
    cfmtime->stat_mtime_nsec = statbuf->st_mtimespec.tv_nsec;
#else
    cfmtime->stat_mtime_nsec = 0;
#endif
    cfmtime->stat_mtime = statbuf->st_mtime;
}

References cache_file_mtime::stat_mtime, cache_file_mtime::stat_mtime_nsec, and cache_file_mtime::stat_size.

Referenced by cfmstat_cmp(), and config_text_file_load().

cfmtime_new()

static struct cache_file_mtime * cfmtime_new ( const char *  filename, const char *  who_asked  )

static

Definition at line 1780 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
    char *dst;
 
    cfmtime = ast_calloc(1,
        sizeof(*cfmtime) + strlen(filename) + 1 + strlen(who_asked) + 1);
    if (!cfmtime) {
        return NULL;
    }
    dst = cfmtime->filename;    /* writable space starts here */
    strcpy(dst, filename); /* Safe */
    dst += strlen(dst) + 1;
    cfmtime->who_asked = strcpy(dst, who_asked); /* Safe */
 
    return cfmtime;
}

References ast_calloc, cache_file_mtime::filename, NULL, and cache_file_mtime::who_asked.

Referenced by config_cache_attribute(), and config_text_file_load().

clear_config_maps()

static void clear_config_maps ( void  )

static

Definition at line 3281 of file main/config.c.

{
    struct ast_config_map *map;
 
    while (config_maps) {
        map = config_maps;
        config_maps = config_maps->next;
        ast_free(map);
    }
}

References ast_free, config_maps, and ast_config_map::next.

Referenced by config_shutdown(), and reload_module().

config_cache_attribute()

static void config_cache_attribute ( const char *  configfile, enum config_cache_attribute_enum  attrtype, const char *  filename, const char *  who_asked  )

static

Definition at line 1900 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
    struct cache_file_include *cfinclude;
 
    /* Find our cached entry for this configuration file */
    AST_LIST_LOCK(&cfmtime_head);
    AST_LIST_TRAVERSE(&cfmtime_head, cfmtime, list) {
        if (!strcmp(cfmtime->filename, configfile) && !strcmp(cfmtime->who_asked, who_asked))
            break;
    }
    if (!cfmtime) {
        cfmtime = cfmtime_new(configfile, who_asked);
        if (!cfmtime) {
            AST_LIST_UNLOCK(&cfmtime_head);
            return;
        }
        /* Note that the file mtime is initialized to 0, i.e. 1970 */
        AST_LIST_INSERT_SORTALPHA(&cfmtime_head, cfmtime, list, filename);
    }
 
    switch (attrtype) {
    case ATTRIBUTE_INCLUDE:
        AST_LIST_TRAVERSE(&cfmtime->includes, cfinclude, list) {
            if (!strcmp(cfinclude->include, filename)) {
                AST_LIST_UNLOCK(&cfmtime_head);
                return;
            }
        }
        cfinclude = ast_calloc(1, sizeof(*cfinclude) + strlen(filename) + 1);
        if (!cfinclude) {
            AST_LIST_UNLOCK(&cfmtime_head);
            return;
        }
        strcpy(cfinclude->include, filename); /* Safe */
        AST_LIST_INSERT_TAIL(&cfmtime->includes, cfinclude, list);
        break;
    case ATTRIBUTE_EXEC:
        cfmtime->has_exec = 1;
        break;
    }
    AST_LIST_UNLOCK(&cfmtime_head);
}

References ast_calloc, AST_LIST_INSERT_SORTALPHA, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ATTRIBUTE_EXEC, ATTRIBUTE_INCLUDE, cfmtime_new(), cache_file_mtime::filename, cache_file_mtime::has_exec, cache_file_include::include, cache_file_mtime::includes, and cache_file_mtime::who_asked.

Referenced by process_text_line().

config_cache_destroy_entry()

static void config_cache_destroy_entry ( struct cache_file_mtime *  cfmtime )

static

Definition at line 1870 of file main/config.c.

{
    config_cache_flush_includes(cfmtime);
    ast_free(cfmtime);
}

References ast_free, and config_cache_flush_includes().

Referenced by config_cache_remove(), and config_shutdown().

config_cache_flush_includes()

static void config_cache_flush_includes ( struct cache_file_mtime *  cfmtime )

static

Definition at line 1853 of file main/config.c.

{
    struct cache_file_include *cfinclude;
 
    while ((cfinclude = AST_LIST_REMOVE_HEAD(&cfmtime->includes, list))) {
        ast_free(cfinclude);
    }
}

References ast_free, AST_LIST_REMOVE_HEAD, and cache_file_mtime::includes.

Referenced by config_cache_destroy_entry(), and config_text_file_load().

config_cache_remove()

static void config_cache_remove ( const char *  filename, const char *  who_asked  )

static

Definition at line 1883 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
 
    AST_LIST_LOCK(&cfmtime_head);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&cfmtime_head, cfmtime, list) {
        if (!strcmp(cfmtime->filename, filename)
            && !strcmp(cfmtime->who_asked, who_asked)) {
            AST_LIST_REMOVE_CURRENT(list);
            config_cache_destroy_entry(cfmtime);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
    AST_LIST_UNLOCK(&cfmtime_head);
}

References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, config_cache_destroy_entry(), cache_file_mtime::filename, and cache_file_mtime::who_asked.

Referenced by config_text_file_load().

config_hook_exec()

static void config_hook_exec ( const char *  filename, const char *  module, const struct ast_config *  cfg  )

static

Definition at line 4550 of file main/config.c.

{
    struct ao2_iterator it;
    struct cfg_hook *hook;
    if (!(cfg_hooks)) {
        return;
    }
    it = ao2_iterator_init(cfg_hooks, 0);
    while ((hook = ao2_iterator_next(&it))) {
        if (!strcasecmp(hook->filename, filename) &&
                !strcasecmp(hook->module, module)) {
            struct ast_config *copy = ast_config_copy(cfg);
            hook->hook_cb(copy);
        }
        ao2_ref(hook, -1);
    }
    ao2_iterator_destroy(&it);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_config_copy(), cfg_hooks, copy(), cfg_hook::filename, cfg_hook::hook_cb, and cfg_hook::module.

Referenced by ast_config_internal_load(), and ast_config_text_file_save2().

config_included_files_destroy()

static void config_included_files_destroy ( struct ast_config_include *  incl )

static

Definition at line 1319 of file main/config.c.

{
    struct config_included_file *x;
 
    while ((x = AST_LIST_REMOVE_HEAD(&incl->included_files, next))) {
        ast_free(x);
    }
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_config_include::included_files, and ast_category::next.

Referenced by ast_include_destroy().

config_shutdown()

static void config_shutdown ( void  )

static

Definition at line 4485 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
 
    AST_LIST_LOCK(&cfmtime_head);
    while ((cfmtime = AST_LIST_REMOVE_HEAD(&cfmtime_head, list))) {
        config_cache_destroy_entry(cfmtime);
    }
    AST_LIST_UNLOCK(&cfmtime_head);
 
    ast_cli_unregister_multiple(cli_config, ARRAY_LEN(cli_config));
 
    clear_config_maps();
 
    ao2_cleanup(cfg_hooks);
    cfg_hooks = NULL;
}

References ao2_cleanup, ARRAY_LEN, ast_cli_unregister_multiple(), AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, cfg_hooks, clear_config_maps(), cli_config, config_cache_destroy_entry(), and NULL.

Referenced by register_config_cli().

config_text_file_load()

static struct ast_config * config_text_file_load ( const char *  database, const char *  table, const char *  filename, struct ast_config *  cfg, struct ast_flags  flags, const char *  suggested_include_file, const char *  who_asked  )

static

Growable string buffer

< this will be a comment collector.

< A buffer for stuff behind the ;

Definition at line 2362 of file main/config.c.

{
    char fn[256];
#if defined(LOW_MEMORY)
    char buf[512];
#else
    char buf[8192];
#endif
    char *new_buf, *comment_p, *process_buf;
    FILE *f;
    int lineno=0;
    int comment = 0, nest[MAX_NESTED_COMMENTS];
    struct ast_category *cat = NULL;
    int count = 0;
    struct stat statbuf;
    struct cache_file_mtime *cfmtime = NULL;
    struct cache_file_include *cfinclude;
    struct ast_category *last_cat = NULL;
    struct ast_variable *last_var = NULL;
    struct ast_config_include *last_inc = NULL;
    /*! Growable string buffer */
    struct ast_str *comment_buffer = NULL;  /*!< this will be a comment collector.*/
    struct ast_str *lline_buffer = NULL;    /*!< A buffer for stuff behind the ; */
    int glob_ret;
    glob_t globbuf;
 
    if (cfg) {
        cat = ast_config_get_current_category(cfg);
    }
 
    if (filename[0] == '/') {
        ast_copy_string(fn, filename, sizeof(fn));
    } else {
        snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, filename);
    }
 
    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
        comment_buffer = ast_str_create(CB_SIZE);
        if (comment_buffer) {
            lline_buffer = ast_str_create(CB_SIZE);
        }
        if (!lline_buffer) {
            ast_free(comment_buffer);
            ast_log(LOG_ERROR, "Failed to initialize the comment buffer!\n");
            return NULL;
        }
    }
 
    globbuf.gl_offs = 0;    /* initialize it to silence gcc */
    glob_ret = glob(fn, MY_GLOB_FLAGS, NULL, &globbuf);
    if (glob_ret == GLOB_NOSPACE) {
        ast_log(LOG_WARNING,
            "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn);
    } else if (glob_ret  == GLOB_ABORTED) {
        ast_log(LOG_WARNING,
            "Glob Expansion of pattern '%s' failed: Read error\n", fn);
    } else {
        /* loop over expanded files */
        int i;
 
        if (!cfg && (globbuf.gl_pathc != 1 || strcmp(fn, globbuf.gl_pathv[0]))) {
            /*
             * We just want a file changed answer and since we cannot
             * tell if a file was deleted with wildcard matching we will
             * assume that something has always changed.  Also without
             * a lot of refactoring we couldn't check more than one file
             * for changes in the glob loop anyway.
             */
            globfree(&globbuf);
            ast_free(comment_buffer);
            ast_free(lline_buffer);
            return NULL;
        }
        for (i = 0; i < globbuf.gl_pathc; i++) {
            ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn));
 
            /*
             * The following is not a loop, but just a convenient way to define a block
             * (using do { } while(0) ), and be able to exit from it with 'continue'
             * or 'break' in case of errors. Nice trick.
             */
            do {
                if (stat(fn, &statbuf)) {
                    if (!ast_test_flag(&flags, CONFIG_FLAG_NOCACHE)) {
                        config_cache_remove(fn, who_asked);
                    }
                    continue;
                }
 
                if (!S_ISREG(statbuf.st_mode)) {
                    ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn);
                    if (!ast_test_flag(&flags, CONFIG_FLAG_NOCACHE)) {
                        config_cache_remove(fn, who_asked);
                    }
                    continue;
                }
 
                if (!ast_test_flag(&flags, CONFIG_FLAG_NOCACHE)) {
                    /* Find our cached entry for this configuration file */
                    AST_LIST_LOCK(&cfmtime_head);
                    AST_LIST_TRAVERSE(&cfmtime_head, cfmtime, list) {
                        if (!strcmp(cfmtime->filename, fn) && !strcmp(cfmtime->who_asked, who_asked)) {
                            break;
                        }
                    }
                    if (!cfmtime) {
                        cfmtime = cfmtime_new(fn, who_asked);
                        if (!cfmtime) {
                            AST_LIST_UNLOCK(&cfmtime_head);
                            continue;
                        }
                        /* Note that the file mtime is initialized to 0, i.e. 1970 */
                        AST_LIST_INSERT_SORTALPHA(&cfmtime_head, cfmtime, list, filename);
                    }
                }
 
                if (cfmtime
                    && !cfmtime->has_exec
                    && !cfmstat_cmp(cfmtime, &statbuf)
                    && ast_test_flag(&flags, CONFIG_FLAG_FILEUNCHANGED)) {
                    int unchanged = 1;
 
                    /* File is unchanged, what about the (cached) includes (if any)? */
                    AST_LIST_TRAVERSE(&cfmtime->includes, cfinclude, list) {
                        if (!config_text_file_load(NULL, NULL, cfinclude->include,
                            NULL, flags, "", who_asked)) {
                            /* One change is enough to short-circuit and reload the whole shebang */
                            unchanged = 0;
                            break;
                        }
                    }
 
                    if (unchanged) {
                        AST_LIST_UNLOCK(&cfmtime_head);
                        globfree(&globbuf);
                        ast_free(comment_buffer);
                        ast_free(lline_buffer);
                        return CONFIG_STATUS_FILEUNCHANGED;
                    }
                }
 
                /* If cfg is NULL, then we just want a file changed answer. */
                if (cfg == NULL) {
                    if (cfmtime) {
                        AST_LIST_UNLOCK(&cfmtime_head);
                    }
                    continue;
                }
 
                if (cfmtime) {
                    /* Forget about what we thought we knew about this file's includes. */
                    cfmtime->has_exec = 0;
                    config_cache_flush_includes(cfmtime);
 
                    cfmstat_save(cfmtime, &statbuf);
                    AST_LIST_UNLOCK(&cfmtime_head);
                }
 
                if (!(f = fopen(fn, "r"))) {
                    ast_debug(1, "No file to parse: %s\n", fn);
                    ast_verb(2, "Parsing '%s': Not found (%s)\n", fn, strerror(errno));
                    continue;
                }
                count++;
                /* If we get to this point, then we're loading regardless */
                ast_clear_flag(&flags, CONFIG_FLAG_FILEUNCHANGED);
                ast_debug(1, "Parsing %s\n", fn);
                while (!feof(f)) {
                    lineno++;
                    if (fgets(buf, sizeof(buf), f)) {
                        /* Skip lines that are too long */
                        if (strlen(buf) == sizeof(buf) - 1 && buf[sizeof(buf) - 2] != '\n') {
                            ast_log(LOG_WARNING, "Line %d too long, skipping. It begins with: %.32s...\n", lineno, buf);
                            while (fgets(buf, sizeof(buf), f)) {
                                if (strlen(buf) != sizeof(buf) - 1 || buf[sizeof(buf) - 2] == '\n') {
                                    break;
                                }
                            }
                            continue;
                        }
 
                        /* If there is a UTF-8 BOM, skip over it */
                        if (lineno == 1) {
#define UTF8_BOM "\xEF\xBB\xBF"
                            size_t line_bytes = strlen(buf);
                            size_t bom_bytes = sizeof(UTF8_BOM) - 1;
                            if (line_bytes >= bom_bytes
                               && !memcmp(buf, UTF8_BOM, bom_bytes)) {
                                memmove(buf, &buf[bom_bytes], line_bytes - bom_bytes + 1);
                            }
#undef UTF8_BOM
                        }
 
                        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)
                            && lline_buffer
                            && ast_str_strlen(lline_buffer)) {
                            CB_ADD(&comment_buffer, ast_str_buffer(lline_buffer)); /* add the current lline buffer to the comment buffer */
                            ast_str_reset(lline_buffer);        /* erase the lline buffer */
                        }
 
                        new_buf = buf;
                        if (comment) {
                            process_buf = NULL;
                        } else {
                            process_buf = buf;
                        }
 
                        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)
                            && (ast_strlen_zero(buf) || strlen(buf) == strspn(buf, " \t\n\r"))) {
                            /* keep blank lines as comments */
                            CB_ADD(&comment_buffer, "\n"); /* add newline to the comment buffer */
                            continue; /* go get a new line, then */
                        }
 
                        while ((comment_p = strchr(new_buf, COMMENT_META))) {
                            if ((comment_p > new_buf) && (*(comment_p - 1) == '\\')) {
                                /* Escaped semicolons aren't comments. */
                                new_buf = comment_p;
                                /* write over the \ and bring the null terminator with us */
                                memmove(comment_p - 1, comment_p, strlen(comment_p) + 1);
                            } else if (comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) {
                                /* Meta-Comment start detected ";--" */
                                if (comment < MAX_NESTED_COMMENTS) {
                                    *comment_p = '\0';
                                    new_buf = comment_p + 3;
                                    comment++;
                                    nest[comment-1] = lineno;
                                } else {
                                    ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS);
                                }
                            } else if ((comment_p >= new_buf + 2) &&
                                   (*(comment_p - 1) == COMMENT_TAG) &&
                                   (*(comment_p - 2) == COMMENT_TAG)) {
                                /* Meta-Comment end detected "--;" */
                                comment--;
                                new_buf = comment_p + 1;
                                if (!comment) {
                                    /* Back to non-comment now */
                                    if (process_buf) {
                                        /* Actually have to move what's left over the top, then continue */
                                        char *oldptr;
 
                                        oldptr = process_buf + strlen(process_buf);
                                        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
                                            CB_ADD(&comment_buffer, ";");
                                            CB_ADD_LEN(&comment_buffer, oldptr+1, new_buf-oldptr-1);
                                        }
 
                                        memmove(oldptr, new_buf, strlen(new_buf) + 1);
                                        new_buf = oldptr;
                                    } else {
                                        process_buf = new_buf;
                                    }
                                }
                            } else {
                                if (!comment) {
                                    /* If ; is found, and we are not nested in a comment,
                                       we immediately stop all comment processing */
                                    while ((comment_p > new_buf) && isspace(*(comment_p - 1))) {
                                        /* To preserve comment formatting we want to include any
                                           whitespace before the ";" */
                                        comment_p--;
                                    }
                                    if ((comment_p != new_buf) && (*comment_p == ' ') && (*(comment_p + 1) == ' ')) {
                                        /* If the comment (w/whitespace) does not start in column 1
                                           then, when written out, the preceeding variable/value will
                                           be separated from the comment by two spaces. To preserve
                                           comment formatting we should also take this into account. */
                                        comment_p += 2;
                                    }
                                    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
                                        CB_ADD(&lline_buffer, comment_p);
                                    }
                                    *comment_p = '\0';
                                    new_buf = comment_p;
                                } else {
                                    new_buf = comment_p + 1;
                                }
                            }
                        }
                        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS) && comment && !process_buf ) {
                            CB_ADD(&comment_buffer, buf); /* the whole line is a comment, store it */
                        }
 
                        if (process_buf) {
                            char *buffer = ast_strip(process_buf);
 
                            if (!ast_strlen_zero(buffer)) {
                                if (process_text_line(cfg, &cat, buffer, lineno, fn,
                                    flags, comment_buffer, lline_buffer,
                                    suggested_include_file, &last_cat, &last_var, &last_inc,
                                    who_asked)) {
                                    cfg = CONFIG_STATUS_FILEINVALID;
                                    break;
                                }
                            }
                        }
                    }
                }
                /* end of file-- anything in a comment buffer? */
                if (last_cat) {
                    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS) && comment_buffer && ast_str_strlen(comment_buffer)) {
                        if (lline_buffer && ast_str_strlen(lline_buffer)) {
                            CB_ADD(&comment_buffer, ast_str_buffer(lline_buffer)); /* add the current lline buffer to the comment buffer */
                            ast_str_reset(lline_buffer); /* erase the lline buffer */
                        }
                        last_cat->trailing = ALLOC_COMMENT(comment_buffer);
                    }
                } else if (last_var) {
                    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS) && comment_buffer && ast_str_strlen(comment_buffer)) {
                        if (lline_buffer && ast_str_strlen(lline_buffer)) {
                            CB_ADD(&comment_buffer, ast_str_buffer(lline_buffer)); /* add the current lline buffer to the comment buffer */
                            ast_str_reset(lline_buffer); /* erase the lline buffer */
                        }
                        last_var->trailing = ALLOC_COMMENT(comment_buffer);
                    }
                } else if (last_inc) {
                    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS) && comment_buffer && ast_str_strlen(comment_buffer)) {
                        if (lline_buffer && ast_str_strlen(lline_buffer)) {
                            CB_ADD(&comment_buffer, ast_str_buffer(lline_buffer)); /* add the current lline buffer to the comment buffer */
                            ast_str_reset(lline_buffer); /* erase the lline buffer */
                        }
                        last_inc->trailing = ALLOC_COMMENT(comment_buffer);
                    }
                } else {
                    if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS) && comment_buffer && ast_str_strlen(comment_buffer)) {
                        ast_debug(1, "Nothing to attach comments to, discarded: %s\n", ast_str_buffer(comment_buffer));
                    }
                }
                if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
                    CB_RESET(comment_buffer, lline_buffer);
                }
 
                fclose(f);
            } while (0);
            if (comment) {
                ast_log(LOG_WARNING, "Unterminated comment detected beginning on line %d\n", nest[comment - 1]);
            }
            if (cfg == NULL || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) {
                break;
            }
        }
        globfree(&globbuf);
    }
 
    ast_free(comment_buffer);
    ast_free(lline_buffer);
 
    if (count == 0) {
        return NULL;
    }
 
    return cfg;
}

References ALLOC_COMMENT(), ast_clear_flag, ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_copy_string(), ast_debug, ast_free, AST_LIST_INSERT_SORTALPHA, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log, ast_str_buffer(), ast_str_create, ast_str_reset(), ast_str_strlen(), ast_strip(), ast_strlen_zero(), ast_test_flag, ast_verb, buf, CB_ADD(), CB_ADD_LEN(), CB_RESET(), CB_SIZE, cfmstat_cmp(), cfmstat_save(), cfmtime_new(), comment, comment_buffer, COMMENT_META, COMMENT_TAG, config_cache_flush_includes(), config_cache_remove(), CONFIG_FLAG_FILEUNCHANGED, CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, config_text_file_load(), errno, cache_file_mtime::filename, GLOB_ABORTED, cache_file_mtime::has_exec, cache_file_include::include, cache_file_mtime::includes, ast_category::lineno, lline_buffer, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, MY_GLOB_FLAGS, NULL, process_text_line(), ast_variable::trailing, ast_category::trailing, ast_config_include::trailing, UTF8_BOM, and cache_file_mtime::who_asked.

Referenced by config_text_file_load().

count_linefeeds()

static int count_linefeeds ( char *  str )

static

Definition at line 2811 of file main/config.c.

{
    int count = 0;
 
    while (*str) {
        if (*str =='\n')
            count++;
        str++;
    }
    return count;
}

References str.

Referenced by count_linefeeds_in_comments().

count_linefeeds_in_comments()

static int count_linefeeds_in_comments ( struct ast_comment *  x )

static

Definition at line 2823 of file main/config.c.

{
    int count = 0;
 
    while (x) {
        count += count_linefeeds(x->cmt);
        x = x->next;
    }
    return count;
}

References ast_comment::cmt, count_linefeeds(), and ast_comment::next.

Referenced by insert_leading_blank_lines().

does_category_match()

static int does_category_match ( struct ast_category *  cat, const char *  category_name, const char *  match, char  sep  )

static

Returns true if ALL of the regex expressions and category name match. Both can be NULL (I.E. no predicate) which results in a true return;.

Definition at line 1065 of file main/config.c.

{
    char *dupmatch;
    char *nvp = NULL;
    int match_found = 0, match_expressions = 0;
    int template_ok = 0;
 
    /* Only match on category name if it's not a NULL or empty string */
    if (!ast_strlen_zero(category_name) && strcasecmp(cat->name, category_name)) {
        return 0;
    }
 
    /* If match is NULL or empty, automatically match if not a template */
    if (ast_strlen_zero(match)) {
        return !cat->ignored;
    }
 
    dupmatch = ast_strdupa(match);
 
    while ((nvp = ast_strsep(&dupmatch, sep, AST_STRSEP_STRIP))) {
        struct ast_variable *v;
        char *match_name;
        char *match_value = NULL;
        char *regerr;
        int rc;
        regex_t r_name, r_value;
 
        match_expressions++;
 
        match_name = ast_strsep(&nvp, '=', AST_STRSEP_STRIP);
        match_value = ast_strsep(&nvp, '=', AST_STRSEP_STRIP);
 
        /* an empty match value is OK.  A NULL match value (no =) is NOT. */
        if (match_value == NULL) {
            break;
        }
 
        if (!strcmp("TEMPLATES", match_name)) {
            if (!strcasecmp("include", match_value)) {
                if (cat->ignored) {
                    template_ok = 1;
                }
                match_found++;
            } else if (!strcasecmp("restrict", match_value)) {
                if (cat->ignored) {
                    match_found++;
                    template_ok = 1;
                } else {
                    break;
                }
            }
            continue;
        }
 
        if ((rc = regcomp(&r_name, match_name, REG_EXTENDED | REG_NOSUB))) {
            regerr = ast_alloca(128);
            regerror(rc, &r_name, regerr, 128);
            ast_log(LOG_ERROR, "Regular expression '%s' failed to compile: %s\n",
                match_name, regerr);
            regfree(&r_name);
            return 0;
        }
        if ((rc = regcomp(&r_value, match_value, REG_EXTENDED | REG_NOSUB))) {
            regerr = ast_alloca(128);
            regerror(rc, &r_value, regerr, 128);
            ast_log(LOG_ERROR, "Regular expression '%s' failed to compile: %s\n",
                match_value, regerr);
            regfree(&r_name);
            regfree(&r_value);
            return 0;
        }
 
        for (v = cat->root; v; v = v->next) {
            if (!regexec(&r_name, v->name, 0, NULL, 0)
                && !regexec(&r_value, v->value, 0, NULL, 0)) {
                match_found++;
                break;
            }
        }
        regfree(&r_name);
        regfree(&r_value);
    }
    if (match_found == match_expressions && (!cat->ignored || template_ok)) {
        return 1;
    }
    return 0;
}

References ast_alloca, ast_log, ast_strdupa, ast_strlen_zero(), ast_strsep(), AST_STRSEP_STRIP, ast_category::ignored, LOG_ERROR, match(), ast_variable::name, ast_category::name, ast_variable::next, NULL, ast_category::root, and ast_variable::value.

Referenced by category_get_sep(), and next_available_category().

find_engine()

static struct ast_config_engine * find_engine ( const char *  family, int  priority, char *  database, int  dbsiz, char *  table, int  tabsiz  )

static

Find realtime engine for realtime family.

Definition at line 3464 of file main/config.c.

{
    struct ast_config_engine *eng, *ret = NULL;
    struct ast_config_map *map;
 
    SCOPED_MUTEX(lock, &config_lock);
 
    for (map = config_maps; map; map = map->next) {
        if (!strcasecmp(family, map->name) && (priority == map->priority)) {
            if (database)
                ast_copy_string(database, map->database, dbsiz);
            if (table)
                ast_copy_string(table, map->table ? map->table : family, tabsiz);
            break;
        }
    }
 
    /* Check if the required driver (engine) exist */
    if (map) {
        for (eng = config_engine_list; !ret && eng; eng = eng->next) {
            if (!strcasecmp(eng->name, map->driver))
                ret = eng;
        }
    }
 
    /* if we found a mapping, but the engine is not available, then issue a warning */
    if (map && !ret)
        ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver);
 
    return ret;
}

References ast_copy_string(), ast_log, config_engine_list, config_lock, config_maps, ast_config_map::database, ast_config_map::driver, lock, LOG_WARNING, ast_config_map::name, ast_config_engine::next, ast_config_map::next, NULL, priority, ast_config_map::priority, SCOPED_MUTEX, table, and ast_config_map::table.

Referenced by ast_check_realtime(), ast_config_internal_load(), ast_destroy_realtime_fields(), ast_load_realtime_all_fields(), ast_load_realtime_multientry_fields(), ast_realtime_require_field(), ast_store_realtime_fields(), ast_unload_realtime(), ast_update2_realtime_fields(), and ast_update_realtime_fields().

gen_header()

static void gen_header ( FILE *  f1, const char *  configfile, const char *  fn, const char *  generator  )

static

Definition at line 2738 of file main/config.c.

{
    char date[256]="";
    time_t t;
 
    time(&t);
    ast_copy_string(date, ctime(&t), sizeof(date));
 
    fprintf(f1, ";!\n");
    fprintf(f1, ";! Automatically generated configuration file\n");
    if (strcmp(configfile, fn))
        fprintf(f1, ";! Filename: %s (%s)\n", configfile, fn);
    else
        fprintf(f1, ";! Filename: %s\n", configfile);
    fprintf(f1, ";! Generator: %s\n", generator);
    fprintf(f1, ";! Creation Date: %s", date);
    fprintf(f1, ";!\n");
}

References ast_copy_string().

Referenced by ast_config_text_file_save2().

handle_cli_config_list()

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

static

Definition at line 4455 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "config list";
        e->usage =
            "Usage: config list\n"
            "   Show all modules that have loaded a configuration file\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    AST_LIST_LOCK(&cfmtime_head);
    AST_LIST_TRAVERSE(&cfmtime_head, cfmtime, list) {
        ast_cli(a->fd, "%-20.20s %-50s\n", S_OR(cfmtime->who_asked, "core"), cfmtime->filename);
    }
    AST_LIST_UNLOCK(&cfmtime_head);
 
    return CLI_SUCCESS;
}

References a, ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, cache_file_mtime::filename, NULL, S_OR, ast_cli_entry::usage, and cache_file_mtime::who_asked.

handle_cli_config_reload()

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

static

Definition at line 4392 of file main/config.c.

{
    struct cache_file_mtime *cfmtime;
    char *prev = "";
    int wordlen;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "config reload";
        e->usage =
            "Usage: config reload <filename.conf>\n"
            "   Reloads all modules that reference <filename.conf>\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos > 2) {
            return NULL;
        }
 
        wordlen = strlen(a->word);
 
        AST_LIST_LOCK(&cfmtime_head);
        AST_LIST_TRAVERSE(&cfmtime_head, cfmtime, list) {
            /* Core configs cannot be reloaded */
            if (ast_strlen_zero(cfmtime->who_asked)) {
                continue;
            }
 
            /* Skip duplicates - this only works because the list is sorted by filename */
            if (!strcmp(cfmtime->filename, prev)) {
                continue;
            }
 
            if (!strncmp(cfmtime->filename, a->word, wordlen)) {
                if (ast_cli_completion_add(ast_strdup(cfmtime->filename))) {
                    break;
                }
            }
 
            /* Otherwise save that we've seen this filename */
            prev = cfmtime->filename;
        }
        AST_LIST_UNLOCK(&cfmtime_head);
 
        return NULL;
    }
 
    if (a->argc != 3) {
        return CLI_SHOWUSAGE;
    }
 
    AST_LIST_LOCK(&cfmtime_head);
    AST_LIST_TRAVERSE(&cfmtime_head, cfmtime, list) {
        if (!strcmp(cfmtime->filename, a->argv[2])) {
            char *buf = ast_alloca(strlen("module reload ") + strlen(cfmtime->who_asked) + 1);
            sprintf(buf, "module reload %s", cfmtime->who_asked);
            ast_cli_command(a->fd, buf);
        }
    }
    AST_LIST_UNLOCK(&cfmtime_head);
 
    return CLI_SUCCESS;
}

References a, ast_alloca, ast_cli_completion_add(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strdup, ast_strlen_zero(), buf, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, cache_file_mtime::filename, NULL, ast_category::prev, ast_cli_entry::usage, and cache_file_mtime::who_asked.

handle_cli_core_show_config_mappings()

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

static

Definition at line 4355 of file main/config.c.

{
    struct ast_config_engine *eng;
    struct ast_config_map *map;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show config mappings";
        e->usage =
            "Usage: core show config mappings\n"
            "   Shows the filenames to config engines.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    {
        SCOPED_MUTEX(lock, &config_lock);
 
        if (!config_engine_list) {
            ast_cli(a->fd, "No config mappings found.\n");
        } else {
            for (eng = config_engine_list; eng; eng = eng->next) {
                ast_cli(a->fd, "Config Engine: %s\n", eng->name);
                for (map = config_maps; map; map = map->next) {
                    if (!strcasecmp(map->driver, eng->name)) {
                        ast_cli(a->fd, "===> %s (db=%s, table=%s)\n", map->name, map->database,
                                map->table ? map->table : map->name);
                    }
                }
            }
        }
    }
 
    return CLI_SUCCESS;
}

References a, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, config_engine_list, config_lock, config_maps, ast_config_map::database, ast_config_map::driver, lock, ast_config_engine::name, ast_config_map::name, ast_config_engine::next, ast_config_map::next, NULL, SCOPED_MUTEX, ast_config_map::table, and ast_cli_entry::usage.

handle_include_exec()

static int handle_include_exec ( const char *  command, const char *  output_file  )

static

Definition at line 1958 of file main/config.c.

{
    char buf[1024];
    FILE *fp;
    int status;
    struct stat output_file_info;
 
    /* stderr to stdout, stdout to file */
    if (snprintf(buf, sizeof(buf), "%s 2>&1 > %s", command, output_file) >= sizeof(buf)) {
        ast_log(LOG_ERROR, "Failed to construct command string to execute %s.\n", command);
        return -1;
    }
 
    ast_replace_sigchld();
 
    errno = 0;
 
    fp = popen(buf, "r");
    if (!fp) {
        ast_log(LOG_ERROR, "#exec <%s>: Failed to execute: %s\n",
            command,
            strerror(errno));
        ast_unreplace_sigchld();
        return 0;
    }
 
    while (fgets(buf, sizeof(buf), fp)) {
        /* Ensure we have a \n at the end */
        if (strlen(buf) == sizeof(buf) - 1 && buf[sizeof(buf) - 2] != '\n') {
            ast_log(LOG_ERROR, "#exec <%s>: %s... <truncated>\n",
                command,
                buf);
 
            /* Consume the rest of the line */
            while (fgets(buf, sizeof(buf), fp)) {
                if (strlen(buf) != sizeof(buf) - 1 || buf[sizeof(buf) - 2] == '\n') {
                    break;
                }
            }
 
            continue;
        }
 
        /* `buf` has the newline, so we don't need to print it ourselves */
        ast_log(LOG_ERROR, "#exec <%s>: %s",
            command,
            buf);
    }
 
    status = pclose(fp);
    if (status == -1) {
        ast_log(LOG_ERROR, "#exec <%s>: Failed to retrieve exit status: %s\n",
            command,
            strerror(errno));
    } else {
        status = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
        if (status) {
            ast_log(LOG_ERROR, "#exec <%s>: Exited with return value %d\n",
                command,
                status);
        }
    }
 
    ast_unreplace_sigchld();
 
    /* Check that the output file contains something */
    if (stat(output_file, &output_file_info) == -1) {
        ast_log(LOG_ERROR, "#exec <%s>: Unable to stat() temporary file `%s': %s\n",
            command,
            output_file,
            strerror(errno));
    } else if (output_file_info.st_size == 0) {
        ast_log(LOG_WARNING, "#exec <%s>: The program generated no usable output.\n",
            command);
    }
 
    return 0;
}

References ast_log, ast_replace_sigchld(), ast_unreplace_sigchld(), buf, errno, LOG_ERROR, LOG_WARNING, status, WEXITSTATUS, and WIFEXITED.

Referenced by process_text_line().

hash_string()

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

static

Definition at line 174 of file main/config.c.

{
    char *str = ((struct inclfile *) obj)->fname;
    int total;
 
    for (total = 0; *str; str++) {
        unsigned int tmp = total;
        total <<= 1; /* multiply by 2 */
        total += tmp; /* multiply by 3 */
        total <<= 2; /* multiply by 12 */
        total += tmp; /* multiply by 13 */
 
        total += ((unsigned int) (*str));
    }
    if (total < 0) {
        total = -total;
    }
    return total;
}

References str, and total.

Referenced by ast_config_text_file_save2().

hashtab_compare_strings()

static int hashtab_compare_strings ( void *  a, void *  b, int  flags  )

static

Definition at line 194 of file main/config.c.

{
    const struct inclfile *ae = a, *be = b;
    return !strcmp(ae->fname, be->fname) ? CMP_MATCH | CMP_STOP : 0;
}

References a, b, be, CMP_MATCH, CMP_STOP, and inclfile::fname.

Referenced by ast_config_text_file_save2().

hook_cmp()

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

static

Definition at line 4526 of file main/config.c.

{
    struct cfg_hook *hook1 = obj;
    struct cfg_hook *hook2 = arg;
 
    return !(strcasecmp(hook1->name, hook2->name)) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, and cfg_hook::name.

Referenced by ast_config_hook_register().

hook_destroy()

static void hook_destroy ( void *  obj )

static

Definition at line 4518 of file main/config.c.

{
    struct cfg_hook *hook = obj;
    ast_free((void *) hook->name);
    ast_free((void *) hook->filename);
    ast_free((void *) hook->module);
}

References ast_free, cfg_hook::filename, cfg_hook::module, and cfg_hook::name.

Referenced by ast_config_hook_register().

hook_hash()

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

static

Definition at line 4534 of file main/config.c.

{
    const struct cfg_hook *hook = obj;
 
    return ast_str_hash(hook->name);
}

References ast_str_hash(), and cfg_hook::name.

Referenced by ast_config_hook_register().

inclfile_destroy()

static void inclfile_destroy ( void *  obj )

static

Definition at line 2757 of file main/config.c.

{
    const struct inclfile *o = obj;
 
    ast_free(o->fname);
}

References ast_free, and inclfile::fname.

Referenced by set_fn().

init_appendbuf()

static int init_appendbuf ( void *  data )

static

Definition at line 118 of file main/config.c.

{
    struct ast_str **str = data;
    *str = ast_str_create(16);
    return *str ? 0 : -1;
}

References ast_str_create, and str.

insert_leading_blank_lines()

static void insert_leading_blank_lines ( FILE *  fp, struct inclfile *  fi, struct ast_comment *  precomments, int  lineno  )

static

Definition at line 2834 of file main/config.c.

{
    int precomment_lines;
    int i;
 
    if (!fi) {
        /* No file scratch pad object so insert no blank lines. */
        return;
    }
 
    precomment_lines = count_linefeeds_in_comments(precomments);
 
    /* I don't have to worry about those ;! comments, they are
       stored in the precomments, but not printed back out.
       I did have to make sure that comments following
       the ;! header comments were not also deleted in the process */
    if (lineno - precomment_lines - fi->lineno < 0) { /* insertions can mess up the line numbering and produce negative numbers that mess things up */
        return;
    } else if (lineno == 0) {
        /* Line replacements also mess things up */
        return;
    } else if (lineno - precomment_lines - fi->lineno < 5) {
        /* Only insert less than 5 blank lines; if anything more occurs,
         * it's probably due to context deletion. */
        for (i = fi->lineno; i < lineno - precomment_lines; i++) {
            fprintf(fp, "\n");
        }
    } else {
        /* Deletion occurred - insert a single blank line, for separation of
         * contexts. */
        fprintf(fp, "\n");
    }
 
    fi->lineno = lineno + 1; /* Advance the file lineno */
}

References count_linefeeds_in_comments(), inclfile::lineno, ast_category::lineno, and ast_category::precomments.

Referenced by ast_config_text_file_save2().

is_writable()

static int is_writable ( const char *  fn )

static

Definition at line 2875 of file main/config.c.

{
    if (access(fn, F_OK)) {
        char *dn = dirname(ast_strdupa(fn));
 
        if (access(dn, R_OK | W_OK)) {
            ast_log(LOG_ERROR, "Unable to write to directory %s (%s)\n", dn, strerror(errno));
            return 0;
        }
    } else {
        if (access(fn, R_OK | W_OK)) {
            ast_log(LOG_ERROR, "Unable to write %s (%s)\n", fn, strerror(errno));
            return 0;
        }
    }
 
    return 1;
}

References ast_log, ast_strdupa, errno, and LOG_ERROR.

Referenced by ast_config_text_file_save2().

load_module()

static int load_module ( void  )

static

Definition at line 4603 of file main/config.c.

{
    if (ast_opt_console) {
        ast_verb(0, "[ Initializing Custom Configuration Options ]\n");
    }
 
    return reload_module() ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_opt_console, ast_verb, and reload_module().

make_fn()

static void make_fn ( char *  fn, size_t  fn_size, const char *  file, const char *  configfile  )

static

Definition at line 2764 of file main/config.c.

{
    if (ast_strlen_zero(file)) {
        if (configfile[0] == '/') {
            ast_copy_string(fn, configfile, fn_size);
        } else {
            snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
        }
    } else if (file[0] == '/') {
        ast_copy_string(fn, file, fn_size);
    } else {
        snprintf(fn, fn_size, "%s/%s", ast_config_AST_CONFIG_DIR, file);
    }
}

References ast_config_AST_CONFIG_DIR, ast_copy_string(), ast_strlen_zero(), and make_ari_stubs::file.

Referenced by ast_config_text_file_save2(), ast_include_new(), and set_fn().

move_variables()

static void move_variables ( struct ast_category *  old, struct ast_category *  new  )

static

Definition at line 1053 of file main/config.c.

{
    struct ast_variable *var = old->root;
 
    old->root = NULL;
    /* we can just move the entire list in a single op */
    ast_variable_append(new, var);
}

References ast_variable_append(), NULL, ast_category::root, and var.

Referenced by process_text_line().

new_category()

static struct ast_category * new_category ( const char *  name, const char *  in_file, int  lineno, int  template  )

static

Definition at line 1155 of file main/config.c.

{
    struct ast_category *category;
 
    category = ast_calloc(1, sizeof(*category));
    if (!category) {
        return NULL;
    }
    category->file = ast_strdup(in_file);
    if (!category->file) {
        ast_category_destroy(category);
        return NULL;
    }
    ast_copy_string(category->name, name, sizeof(category->name));
    category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
    category->ignored = template;
    return category;
}

References ast_calloc, ast_category_destroy(), ast_copy_string(), ast_strdup, ast_category::file, ast_category::ignored, ast_category::lineno, ast_category::name, name, and NULL.

Referenced by ast_category_new(), and ast_category_new_template().

next_available_category()

static struct ast_category * next_available_category ( struct ast_category *  cat, const char *  name, const char *  filter  )

static

Definition at line 1350 of file main/config.c.

{
    for (; cat && !does_category_match(cat, name, filter, ','); cat = cat->next);
 
    return cat;
}

References does_category_match(), filter(), name, and ast_category::next.

Referenced by ast_category_browse(), and ast_category_browse_filtered().

print_comment()

static void print_comment ( FILE *  f, struct ast_comment *  comment  )

static

Definition at line 2894 of file main/config.c.

{
    struct ast_comment *cmt;
 
    for (cmt = comment; cmt; cmt = cmt->next) {
        const char *line = cmt->cmt;
        char *nl;
 
        while ((nl = strchr(line, '\n')) != NULL) {
            *nl = '\0';
            if (line[0] != ';' || line[1] != '!') {
                /* if not one of our generated header comments */
                fprintf(f, "%s\n", line);
            }
 
            line = nl + 1;
        }
    }
}

References ast_comment::cmt, comment, ast_comment::next, and NULL.

Referenced by ast_config_text_file_save2().

print_include()

static void print_include ( FILE *  f, struct ast_config_include *  incl  )

static

Definition at line 2914 of file main/config.c.

{
    switch (incl->include_type) {
    case CONFIG_STATEMENT_INCLUDE:
        fprintf(f, "#include \"%s\"\n", incl->included_file);
        break;
    case CONFIG_STATEMENT_TRYINCLUDE:
        fprintf(f, "#tryinclude \"%s\"\n", incl->included_file);
        break;
    case CONFIG_STATEMENT_EXEC:
        fprintf(f, "#exec \"%s\"\n", incl->exec_file);
        break;
    }
}

References CONFIG_STATEMENT_EXEC, CONFIG_STATEMENT_INCLUDE, CONFIG_STATEMENT_TRYINCLUDE, ast_config_include::exec_file, ast_config_include::include_type, and ast_config_include::included_file.

Referenced by ast_config_text_file_save2().

process_text_line()

static int process_text_line ( struct ast_config *  cfg, struct ast_category **  cat, char *  buf, int  lineno, const char *  configfile, struct ast_flags  flags, struct ast_str *  comment_buffer, struct ast_str *  lline_buffer, const char *  suggested_include_file, struct ast_category **  last_cat, struct ast_variable **  last_var, struct ast_config_include **  last_inc, const char *  who_asked  )

static

parse one line in the configuration.

* We can have a category header [foo](...)
* a directive               #include, #tryinclude, #exec
* or a regular line         name = value
* 

Definition at line 2044 of file main/config.c.

{
    char *c;
    char *cur = buf;
    struct ast_variable *v;
    char exec_file[512];
 
    /* Actually parse the entry */
    if (cur[0] == '[') { /* A category header */
        /* format is one of the following:
         * [foo]    define a new category named 'foo'
         * [foo](!) define a new template category named 'foo'
         * [foo](+) append to category 'foo', error if foo does not exist.
         * [foo](a) define a new category and inherit from category or template a.
         *      You can put a comma-separated list of categories and templates
         *      and '!' and '+' between parentheses, with obvious meaning.
         */
        struct ast_category *newcat;
        char *catname;
 
        c = strchr(cur, ']');
        if (!c) {
            ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile);
            return -1;
        }
        *c++ = '\0';
        cur++;
        if (*c++ != '(')
            c = NULL;
        catname = cur;
        *cat = newcat = ast_category_new(catname,
            S_OR(suggested_include_file, cfg->include_level == 1 ? "" : configfile),
            lineno);
        if (!newcat) {
            return -1;
        }
        (*cat)->loaded = 1;
        (*cat)->lineno = lineno;
 
        /* add comments */
        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
            newcat->precomments = ALLOC_COMMENT(comment_buffer);
            newcat->sameline = ALLOC_COMMENT(lline_buffer);
            CB_RESET(comment_buffer, lline_buffer);
        }
 
        /* If there are options or categories to inherit from, process them now */
        if (c) {
            if (!(cur = strchr(c, ')'))) {
                ast_category_destroy(newcat);
                ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile);
                return -1;
            }
            *cur = '\0';
            while ((cur = strsep(&c, ","))) {
                if (!strcasecmp(cur, "!")) {
                    (*cat)->ignored = 1;
                } else if (cur[0] == '+') {
                    char *filter = NULL;
 
                    if (cur[1] != ',') {
                        filter = &cur[1];
                    }
                    *cat = category_get_sep(cfg, catname, filter, '&', 0);
                    if (!(*cat)) {
                        if (newcat) {
                            ast_category_destroy(newcat);
                        }
                        ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile);
                        return -1;
                    }
                    if (newcat) {
                        ast_config_set_current_category(cfg, *cat);
                        (*cat)->ignored |= newcat->ignored;
                        move_variables(newcat, *cat);
                        ast_category_destroy(newcat);
                        newcat = NULL;
                    }
                } else {
                    struct ast_category *base;
 
                    base = category_get_sep(cfg, cur, "TEMPLATES=include", ',', 0);
                    if (!base) {
                        if (newcat) {
                            ast_category_destroy(newcat);
                        }
                        ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile);
                        return -1;
                    }
                    if (ast_category_inherit(*cat, base)) {
                        if (newcat) {
                            ast_category_destroy(newcat);
                        }
                        ast_log(LOG_ERROR, "Inheritance requested, but allocation failed\n");
                        return -1;
                    }
                }
            }
        }
 
        /*
         * We need to set *last_cat to newcat here regardless.  If the
         * category is being appended to we have no place for trailing
         * comments on the appended category.  The appended category
         * may be in another file or it already has trailing comments
         * that we would then leak.
         */
        *last_cat = newcat;
        *last_var = NULL;
        *last_inc = NULL;
        if (newcat) {
            ast_category_append(cfg, newcat);
        }
    } else if (cur[0] == '#') { /* A directive - #include, #tryinclude, or #exec */
        char *cur2;
        char real_inclusion_name[256];
        int include_type;
        struct ast_config_include *newinclude;
        struct ast_config *result;
 
        cur++;
        c = cur;
        while (*c && (*c > 32)) {
            c++;
        }
 
        if (*c) {
            *c = '\0';
            /* Find real argument */
            c = ast_strip(c + 1);
            if (!(*c)) {
                c = NULL;
            }
        } else {
            c = NULL;
        }
        if (!strcasecmp(cur, "include")) {
            include_type = CONFIG_STATEMENT_INCLUDE;
        } else if (!strcasecmp(cur, "tryinclude")) {
            include_type = CONFIG_STATEMENT_TRYINCLUDE;
        } else if (!strcasecmp(cur, "exec")) {
            if (!ast_opt_exec_includes) {
                ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n");
                return 0;   /* XXX is this correct ? or we should return -1 ? */
            }
            include_type = CONFIG_STATEMENT_EXEC;
        } else {
            ast_log(LOG_WARNING, "Unknown directive '#%s' at line %d of %s\n", cur, lineno, configfile);
            return 0;   /* XXX is this correct ? or we should return -1 ? */
        }
 
        if (c == NULL) {
            ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n",
                    cur,
                    (include_type != CONFIG_STATEMENT_EXEC) ? "filename" : "/path/to/executable",
                    lineno,
                    configfile);
            return 0;   /* XXX is this correct ? or we should return -1 ? */
        }
 
        cur = c;
        /* Strip off leading and trailing "'s and <>'s */
        /* Dequote */
        if ((*c == '"') || (*c == '<')) {
            char quote_char = *c;
            if (quote_char == '<') {
                quote_char = '>';
            }
 
            if (*(c + strlen(c) - 1) == quote_char) {
                cur++;
                *(c + strlen(c) - 1) = '\0';
            }
        }
        cur2 = cur;
 
        if (include_type == CONFIG_STATEMENT_EXEC) {
            /* #exec </path/to/executable>
               We create a tmp file, then we #include it, then we delete it. */
            struct timeval now = ast_tvnow();
 
            if (!ast_test_flag(&flags, CONFIG_FLAG_NOCACHE))
                config_cache_attribute(configfile, ATTRIBUTE_EXEC, NULL, who_asked);
            snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d%d.%ld", (int)now.tv_sec, (int)now.tv_usec, (long)pthread_self());
            if (handle_include_exec(cur, exec_file)) {
                return -1;
            }
            cur = exec_file;
        } else {
            if (!ast_test_flag(&flags, CONFIG_FLAG_NOCACHE))
                config_cache_attribute(configfile, ATTRIBUTE_INCLUDE, cur, who_asked);
            exec_file[0] = '\0';
        }
        /* A #include */
        /* record this inclusion */
        newinclude = ast_include_new(cfg, cfg->include_level == 1 ? "" : configfile, cur, include_type, cur2, lineno, real_inclusion_name, sizeof(real_inclusion_name));
        if (!newinclude) {
            if (!ast_strlen_zero(exec_file)) {
                unlink(exec_file);
            }
            return -1;
        }
 
        result = ast_config_internal_load(cur, cfg, flags, real_inclusion_name, who_asked);
        if (!ast_strlen_zero(exec_file)) {
            unlink(exec_file);
        }
        if (!result && (include_type != CONFIG_STATEMENT_TRYINCLUDE)) {
            ast_log(LOG_ERROR, "The file '%s' was listed as a #include but it does not exist.\n", cur);
            return -1;
        }
 
        /* add comments */
        if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
            newinclude->precomments = ALLOC_COMMENT(comment_buffer);
            newinclude->sameline = ALLOC_COMMENT(lline_buffer);
            CB_RESET(comment_buffer, lline_buffer);
        }
 
        /* for now, any end-of-file (trailing) comments are after this #include */
        *last_cat = NULL;
        *last_var = NULL;
        *last_inc = newinclude;
    } else {
        /* Just a line (variable = value) */
        int object = 0;
        int is_escaped;
 
        if (!(*cat)) {
            ast_log(LOG_WARNING,
                "parse error: No category context for line %d of %s\n", lineno, configfile);
            return -1;
        }
 
        is_escaped = cur[0] == '\\';
        if (is_escaped) {
            /* First character is escaped. */
            ++cur;
            if (cur[0] < 33) {
                ast_log(LOG_ERROR, "Invalid escape in line %d of %s\n", lineno, configfile);
                return -1;
            }
        }
        c = strchr(cur + is_escaped, '=');
 
        if (c && c > cur + is_escaped && (*(c - 1) == '+')) {
            struct ast_variable *var, *replace = NULL;
            struct ast_str **str = ast_threadstorage_get(&appendbuf, sizeof(*str));
 
            if (!str || !*str) {
                return -1;
            }
 
            *(c - 1) = '\0';
            c++;
            cur = ast_strip(cur);
 
            /* Must iterate through category until we find last variable of same name (since there could be multiple) */
            for (var = ast_category_first(*cat); var; var = var->next) {
                if (!strcmp(var->name, cur)) {
                    replace = var;
                }
            }
 
            if (!replace) {
                /* Nothing to replace; just set a variable normally. */
                goto set_new_variable;
            }
 
            ast_str_set(str, 0, "%s", replace->value);
            ast_str_append(str, 0, "%s", c);
            ast_str_trim_blanks(*str);
            ast_variable_update(*cat, replace->name, ast_skip_blanks(ast_str_buffer(*str)), replace->value, object);
        } else if (c) {
            *c = 0;
            c++;
            /* Ignore > in => */
            if (*c== '>') {
                object = 1;
                c++;
            }
            cur = ast_strip(cur);
set_new_variable:
            if (ast_strlen_zero(cur)) {
                ast_log(LOG_WARNING, "No variable name in line %d of %s\n", lineno, configfile);
            } else if ((v = ast_variable_new(cur, ast_strip(c), S_OR(suggested_include_file, cfg->include_level == 1 ? "" : configfile)))) {
                v->lineno = lineno;
                v->object = object;
                *last_cat = NULL;
                *last_var = v;
                *last_inc = NULL;
                /* Put and reset comments */
                v->blanklines = 0;
                ast_variable_append(*cat, v);
                /* add comments */
                if (ast_test_flag(&flags, CONFIG_FLAG_WITHCOMMENTS)) {
                    v->precomments = ALLOC_COMMENT(comment_buffer);
                    v->sameline = ALLOC_COMMENT(lline_buffer);
                    CB_RESET(comment_buffer, lline_buffer);
                }
            } else {
                return -1;
            }
        } else {
            ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile);
        }
    }
    return 0;
}

References ALLOC_COMMENT(), appendbuf, ast_category_append(), ast_category_destroy(), ast_category_first(), ast_category_inherit(), ast_category_new(), ast_config_internal_load(), ast_config_set_current_category(), ast_include_new(), ast_log, ast_opt_exec_includes, ast_skip_blanks(), ast_str_append(), ast_str_buffer(), ast_str_set(), ast_str_trim_blanks(), ast_strip(), ast_strlen_zero(), ast_test_flag, ast_threadstorage_get(), ast_tvnow(), ast_variable_append(), ast_variable_new, ast_variable_update(), ATTRIBUTE_EXEC, ATTRIBUTE_INCLUDE, ast_variable::blanklines, buf, c, category_get_sep(), CB_RESET(), comment_buffer, config_cache_attribute(), CONFIG_FLAG_NOCACHE, CONFIG_FLAG_WITHCOMMENTS, CONFIG_STATEMENT_EXEC, CONFIG_STATEMENT_INCLUDE, CONFIG_STATEMENT_TRYINCLUDE, filter(), handle_include_exec(), ast_category::ignored, ast_config::include_level, ast_variable::lineno, ast_category::lineno, lline_buffer, LOG_ERROR, LOG_WARNING, move_variables(), NULL, ast_variable::object, ast_variable::precomments, ast_category::precomments, ast_config_include::precomments, replace(), result, S_OR, ast_variable::sameline, ast_category::sameline, ast_config_include::sameline, str, strsep(), and var.

Referenced by config_text_file_load().

realtime_arguments_to_fields2()

static int realtime_arguments_to_fields2 ( va_list  ap, int  skip, struct ast_variable **  result  )

static

Definition at line 3607 of file main/config.c.

{
    struct ast_variable *first, *fields = NULL;
    const char *newparam;
    const char *newval;
 
    /*
     * Previously we would do:
     *
     *     va_start(ap, last);
     *     x = realtime_arguments_to_fields(ap);
     *     y = realtime_arguments_to_fields(ap);
     *     va_end(ap);
     *
     * While this works on generic amd64 machines (2014), it doesn't on the
     * raspberry PI. The va_arg() manpage says:
     *
     *     If ap is passed to a function that uses va_arg(ap, type) then
     *     the value of ap is undefined after the return of that function.
     *
     * On the raspberry, ap seems to get reset after the call: the contents
     * of y would be equal to the contents of x.
     *
     * So, instead we allow the caller to skip past earlier argument sets
     * using the skip parameter:
     *
     *     va_start(ap, last);
     *     if (realtime_arguments_to_fields(ap, &x)) {
     *         // FAILURE CONDITIONS
     *     }
     *     va_end(ap);
     *     va_start(ap, last);
     *     if (realtime_arguments_to_fields2(ap, 1, &y)) {
     *         // FAILURE CONDITIONS
     *     }
     *     va_end(ap);
     */
    while (skip--) {
        /* There must be at least one argument. */
        newparam = va_arg(ap, const char *);
        newval = va_arg(ap, const char *);
        while ((newparam = va_arg(ap, const char *))) {
            newval = va_arg(ap, const char *);
        }
    }
 
    /* Load up the first vars. */
    newparam = va_arg(ap, const char *);
    if (!newparam) {
        *result = NULL;
        return 0;
    }
    newval = va_arg(ap, const char *);
 
    if (!(first = ast_variable_new(newparam, newval, ""))) {
        *result = NULL;
        return -1;
    }
 
    while ((newparam = va_arg(ap, const char *))) {
        struct ast_variable *field;
 
        newval = va_arg(ap, const char *);
        if (!(field = ast_variable_new(newparam, newval, ""))) {
            ast_variables_destroy(fields);
            ast_variables_destroy(first);
            *result = NULL;
            return -1;
        }
 
        field->next = fields;
        fields = field;
    }
 
    first->next = fields;
    fields = first;
 
    *result = fields;
    return 0;
}

References ast_variable_new, ast_variables_destroy(), first, sla_ringing_trunk::next, ast_variable::next, NULL, and result.

Referenced by ast_update2_realtime().

register_config_cli()

int register_config_cli

(

void

)

Exposed initialization method for core process.

This method is intended for use only with the core initialization and is not designed to be called from any user applications.

Definition at line 4503 of file main/config.c.

{
    ast_cli_register_multiple(cli_config, ARRAY_LEN(cli_config));
    /* This is separate from the module load so cleanup can happen very late. */
    ast_register_cleanup(config_shutdown);
    return 0;
}

References ARRAY_LEN, ast_cli_register_multiple, ast_register_cleanup(), cli_config, and config_shutdown().

Referenced by asterisk_daemon().

reload_module()

static int reload_module ( void  )

static

Definition at line 3331 of file main/config.c.

{
    struct ast_config *config, *configtmp;
    struct ast_variable *v;
    char *driver, *table, *database, *textpri, *stringp, *tmp;
    struct ast_flags flags = { CONFIG_FLAG_NOREALTIME };
    int pri;
    SCOPED_MUTEX(lock, &config_lock);
 
    clear_config_maps();
 
    configtmp = ast_config_new();
    if (!configtmp) {
        ast_log(LOG_ERROR, "Unable to allocate memory for new config\n");
        return -1;
    }
    config = ast_config_internal_load(extconfig_conf, configtmp, flags, "", "extconfig");
    if (config == CONFIG_STATUS_FILEINVALID) {
        return -1;
    } else if (!config) {
        ast_config_destroy(configtmp);
        return 0;
    }
 
    for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
        char buf[512];
        ast_copy_string(buf, v->value, sizeof(buf));
        stringp = buf;
        driver = strsep(&stringp, ",");
        if (!stringp) {
            ast_log(LOG_WARNING, "extconfig.conf: value '%s' ignored due to wrong format\n", v->value);
            continue;
        }
        if ((tmp = strchr(stringp, '\"')))
            stringp = tmp;
 
        /* check if the database text starts with a double quote */
        if (*stringp == '"') {
            stringp++;
            database = strsep(&stringp, "\"");
            strsep(&stringp, ",");
        } else {
            /* apparently this text has no quotes */
            database = strsep(&stringp, ",");
        }
 
        table = strsep(&stringp, ",");
        textpri = strsep(&stringp, ",");
        if (!textpri || !(pri = atoi(textpri))) {
            pri = 1;
        }
 
        if (!strcmp(v->name, extconfig_conf)) {
            ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf);
            continue;
        }
 
        if (!strcmp(v->name, "asterisk.conf")) {
            ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n");
            continue;
        }
 
        if (!strcmp(v->name, "logger.conf")) {
            ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n");
            continue;
        }
 
        if (!driver || !database)
            continue;
        if (!strcasecmp(v->name, "iaxfriends")) {
            ast_log(LOG_WARNING, "The 'iaxfriends' table is obsolete, update your config to use iaxusers and iaxpeers, though they can point to the same table.\n");
            ast_realtime_append_mapping("iaxusers", driver, database, table ? table : "iaxfriends", pri);
            ast_realtime_append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends", pri);
        } else
            ast_realtime_append_mapping(v->name, driver, database, table, pri);
    }
 
    ast_config_destroy(config);
    return 0;
}

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), ast_copy_string(), ast_log, ast_realtime_append_mapping(), ast_variable_browse(), buf, clear_config_maps(), config, CONFIG_FLAG_NOREALTIME, config_lock, CONFIG_STATUS_FILEINVALID, extconfig_conf, lock, LOG_ERROR, LOG_WARNING, ast_variable::name, ast_variable::next, SCOPED_MUTEX, strsep(), table, and ast_variable::value.

Referenced by load_module().

set_fn()

static struct inclfile * set_fn ( char *  fn, size_t  fn_size, const char *  file, const char *  configfile, struct ao2_container *  fileset  )

static

Definition at line 2779 of file main/config.c.

{
    struct inclfile lookup;
    struct inclfile *fi;
 
    make_fn(fn, fn_size, file, configfile);
    lookup.fname = fn;
    fi = ao2_find(fileset, &lookup, OBJ_POINTER);
    if (fi) {
        /* Found existing include file scratch pad. */
        return fi;
    }
 
    /* set up a file scratch pad */
    fi = ao2_alloc(sizeof(struct inclfile), inclfile_destroy);
    if (!fi) {
        /* Scratch pad creation failed. */
        return NULL;
    }
    fi->fname = ast_strdup(fn);
    if (!fi->fname) {
        /* Scratch pad creation failed. */
        ao2_ref(fi, -1);
        return NULL;
    }
    fi->lineno = 1;
 
    ao2_link(fileset, fi);
 
    return fi;
}

References ao2_alloc, ao2_find, ao2_link, ao2_ref, ast_strdup, make_ari_stubs::file, inclfile::fname, inclfile_destroy(), inclfile::lineno, make_fn(), NULL, and OBJ_POINTER.

Referenced by ast_config_text_file_save2().

unload_module()

static int unload_module ( void  )

static

Definition at line 4598 of file main/config.c.

{
    return 0;
}

variable_clone()

static struct ast_variable * variable_clone ( const struct ast_variable *  old )

static

Definition at line 1039 of file main/config.c.

{
    struct ast_variable *new = ast_variable_new(old->name, old->value, old->file);
 
    if (new) {
        new->lineno = old->lineno;
        new->object = old->object;
        new->blanklines = old->blanklines;
        /* TODO: clone comments? */
    }
 
    return new;
}

References ast_variable_new, ast_variable::blanklines, ast_variable::file, ast_variable::lineno, ast_variable::name, ast_variable::object, and ast_variable::value.

Referenced by ast_category_inherit().

variable_list_switch()

static struct ast_variable * variable_list_switch ( struct ast_variable *  l1, struct ast_variable *  l2  )

inlinestatic

Definition at line 700 of file main/config.c.

{
    l1->next = l2->next;
    l2->next = l1;
    return l2;
}

References ast_variable::next.

Referenced by ast_variable_list_sort().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = "extconfig" , .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Configuration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = 0, }

static

Definition at line 4619 of file main/config.c.

appendbuf

struct ast_threadstorage appendbuf = { .once = PTHREAD_ONCE_INIT , .key_init = __init_appendbuf , .custom_init = init_appendbuf , }

static

Definition at line 125 of file main/config.c.

Referenced by process_text_line().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4619 of file main/config.c.

cfg_hooks

struct ao2_container* cfg_hooks

static

Definition at line 78 of file main/config.c.

Referenced by ast_config_hook_register(), ast_config_hook_unregister(), config_hook_exec(), and config_shutdown().

cfmtime_head

struct cfmtime_head cfmtime_head = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static

cli_config

struct ast_cli_entry cli_config[]

static

Initial value:

= {
    { .handler =  handle_cli_core_show_config_mappings , .summary =  "Display config mappings (file names to config engines)" ,},
    { .handler =  handle_cli_config_reload , .summary =  "Force a reload on modules using a particular configuration file" ,},
    { .handler =  handle_cli_config_list , .summary =  "Show all files that have loaded a configuration file" ,},
}

Definition at line 4479 of file main/config.c.

Referenced by config_shutdown(), and register_config_cli().

config_engine_list

struct ast_config_engine* config_engine_list

static

Definition at line 216 of file main/config.c.

Referenced by ast_config_engine_deregister(), ast_config_engine_register(), ast_config_internal_load(), find_engine(), and handle_cli_core_show_config_mappings().

config_lock

ast_mutex_t config_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 215 of file main/config.c.

Referenced by ast_config_engine_deregister(), ast_config_engine_register(), ast_realtime_is_mapping_defined(), find_engine(), handle_cli_core_show_config_mappings(), and reload_module().

config_maps

struct ast_config_map * config_maps = NULL

static

Referenced by ast_realtime_append_mapping(), ast_realtime_enabled(), ast_realtime_is_mapping_defined(), clear_config_maps(), find_engine(), and handle_cli_core_show_config_mappings().

extconfig_conf

char* extconfig_conf = "extconfig.conf"

static

Definition at line 76 of file main/config.c.

Referenced by reload_module().

text_file_engine

struct ast_config_engine text_file_engine

static

Initial value:

= {
    .name = "text",
    .load_func = config_text_file_load,
}

Definition at line 3496 of file main/config.c.

Referenced by ast_config_internal_load().