include/asterisk/config.h File Reference

Configuration File Parser. More...

#include "asterisk/utils.h"
#include "asterisk/inline_api.h"

Include dependency graph for include/asterisk/config.h:

Go to the source code of this file.

Data Structures
struct	ast_config_engine
	Configuration engine structure, used to define realtime drivers. More...
struct	ast_variable
	Structure for variables, used for configurations and for channel variables. More...

Macros
#define	ast_category_new_anonymous()   ast_category_new_dynamic("")
	Create a nameless category that is not backed by a file. More...
#define	ast_category_new_dynamic(name)   ast_category_new(name, "", -1)
	Create a category that is not backed by a file. More...
#define	ast_config_load(filename, flags)   ast_config_load2(filename, AST_MODULE, flags)
	Load a config file. More...
#define	ast_variable_list_append(head, new_var)   ast_variable_list_append_hint(head, NULL, new_var)
#define	ast_variable_new(name, value, filename)   _ast_variable_new(name, value, filename, __FILE__, __PRETTY_FUNCTION__, __LINE__)
#define	CONFIG_STATUS_FILEINVALID   (void *)-2
#define	CONFIG_STATUS_FILEMISSING   (void *)0
#define	CONFIG_STATUS_FILEUNCHANGED   (void *)-1
#define	CV_BOOL(__x, __dst)   CV_F(__x, (__dst) = ast_true(__val) )
	helper macros to assign the value to a BOOL, UINT, static string and dynamic string More...
#define	CV_DSTR(__x, __dst)   CV_F(__x, ast_free(__dst); __dst = ast_strdup(__val))
#define	CV_END   } while (0)
	close a variable parsing block More...
#define	CV_F(__pattern, __body)   if (!strcasecmp((__var), __pattern)) { __body; break; }
	call a generic function if the name matches. More...
#define	CV_START(__in_var, __in_val)
	the macro to open a block for variable parsing More...
#define	CV_STR(__x, __dst)   CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))
#define	CV_STRFIELD(__x, __obj, __field)   CV_F(__x, ast_string_field_set(__obj, __field, __val))
#define	CV_UINT(__x, __dst)   CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )

Typedefs
typedef int(*	config_hook_cb) (struct ast_config *cfg)
typedef struct ast_config *	config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)
typedef int	realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
typedef struct ast_config *	realtime_multi_get(const char *database, const char *table, const struct ast_variable *fields)
typedef int	realtime_require(const char *database, const char *table, va_list ap)
	Function pointer called to ensure database schema is properly configured for realtime use. More...
typedef int	realtime_store(const char *database, const char *table, const struct ast_variable *fields)
typedef int	realtime_unload(const char *database, const char *table)
	Function pointer called to clear the database cache and free resources used for such. More...
typedef int	realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)
typedef int	realtime_update2(const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)
typedef struct ast_variable *	realtime_var_get(const char *database, const char *table, const struct ast_variable *fields)

Enumerations
enum	{ CONFIG_FLAG_WITHCOMMENTS = (1 << 0), CONFIG_FLAG_FILEUNCHANGED = (1 << 1), CONFIG_FLAG_NOCACHE = (1 << 2), CONFIG_FLAG_NOREALTIME = (1 << 3) }
enum	ast_parse_flags {   PARSE_TYPE = 0x000f, PARSE_INT32 = 0x0001, PARSE_UINT32 = 0x0002, PARSE_DOUBLE = 0x0003,   PARSE_TIMELEN = 0x0006, PARSE_ADDR = 0x000e, PARSE_INADDR = 0x000f, PARSE_DEFAULT = 0x0010,   PARSE_IN_RANGE = 0x0020, PARSE_OUT_RANGE = 0x0040, PARSE_RANGE_DEFAULTS = 0x0080, PARSE_PORT_MASK = 0x0300,   PARSE_PORT_IGNORE = 0x0100, PARSE_PORT_REQUIRE = 0x0200, PARSE_PORT_FORBID = 0x0300 }
	Support code to parse config file arguments. More...
enum	config_hook_flags { butt }
	Flags that affect the behaviour of config hooks. More...
enum	config_save_flags { CONFIG_SAVE_FLAG_NONE = (0), CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT = (1 << 0) }
enum	require_type {   RQ_INTEGER1, RQ_UINTEGER1, RQ_INTEGER2, RQ_UINTEGER2,   RQ_INTEGER3, RQ_UINTEGER3, RQ_INTEGER4, RQ_UINTEGER4,   RQ_INTEGER8, RQ_UINTEGER8, RQ_CHAR, RQ_FLOAT,   RQ_DATE, RQ_DATETIME }
	Types used in ast_realtime_require_field. More...

Functions
struct ast_variable *	_ast_variable_new (const char *name, const char *value, const char *filename, const char *file, const char *function, int lineno)
void	ast_category_append (struct ast_config *config, struct ast_category *cat)
	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 *cfg, 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 *existing, 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...
struct ast_config *	ast_config_copy (const struct ast_config *orig)
	Copies the contents of one ast_config into another. More...
void	ast_config_destroy (struct ast_config *config)
	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 *newconfig)
	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)
	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 *configfile, struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl_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 *filename, 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 *filename, 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,...) attribute_sentinel
	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...
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 is_exec, 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)
struct ast_variable *	ast_load_realtime (const char *family,...) attribute_sentinel
struct ast_variable *	ast_load_realtime_all (const char *family,...) attribute_sentinel
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,...) attribute_sentinel
	Retrieve realtime configuration. More...
struct ast_config *	ast_load_realtime_multientry_fields (const char *family, const struct ast_variable *fields)
	Retrieve realtime configuration. More...
int	ast_parse_arg (const char *arg, enum ast_parse_flags flags, void *result,...)
	The argument parsing routine. More...
int	ast_realtime_append_mapping (const char *name, const char *driver, const char *database, const char *table, int priority)
	Add an explicit mapping for a family. More...
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,...) attribute_sentinel
	Inform realtime what fields that may be stored. More...
int	ast_rq_is_int (require_type type)
	Check if require type is an integer type. More...
int	ast_store_realtime (const char *family,...) attribute_sentinel
	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,...) attribute_sentinel
	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,...) attribute_sentinel
	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_name)
struct ast_variable *	ast_variable_browse_filtered (const struct ast_config *config, const char *category_name, const char *filter)
	Browse variables. More...
int	ast_variable_delete (struct ast_category *category, const char *variable, const char *match, const char *line)
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 *new_var)
	Appends a variable list to the end of another list. 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...
struct ast_variable *	ast_variable_list_sort (struct ast_variable *head)
	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...
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...
int	register_config_cli (void)
	Exposed initialization method for core process. More...

Detailed Description

Configuration File Parser.

Definition in file include/asterisk/config.h.

Macro Definition Documentation

ast_category_new_anonymous

#define ast_category_new_anonymous

(

)

ast_category_new_dynamic("")

Create a nameless category that is not backed by a file.

Definition at line 837 of file include/asterisk/config.h.

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

ast_category_new_dynamic

#define ast_category_new_dynamic

(

name

)

ast_category_new(name, "", -1)

Create a category that is not backed by a file.

Parameters

name	name of new category

Definition at line 832 of file include/asterisk/config.h.

Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_mysql(), config_odbc(), config_pgsql(), realtime_directory(), and static_realtime_cb().

ast_config_load

#define ast_config_load	(		filename,
			flags
	)		ast_config_load2(filename, AST_MODULE, flags)

Load a config file.

Parameters

filename	path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR
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 179 of file include/asterisk/config.h.

Referenced by aco_process_config(), adsi_load(), advanced_options(), AST_TEST_DEFINE(), conf_exec(), config_function_read(), config_load(), config_module(), directory_exec(), festival_exec(), find_conf(), forward_message(), get_defaults(), handle_cli_dialplan_save(), ineligible_configuration(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), load_pktccops_config(), load_values_config(), make_email_file(), mbl_load_config(), message_range_and_existence_check(), my_load_module(), notify_new_message(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), process_config(), read_password_from_file(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_queues(), set_config(), setup_dahdi_int(), sla_load_config(), smdi_load(), tds_load_module(), vm_change_password(), vm_forwardoptions(), vm_msg_forward(), vm_msg_play(), and vm_msg_snapshot_create().

ast_variable_list_append

#define ast_variable_list_append	(		head,
			new_var
	)		ast_variable_list_append_hint(head, NULL, new_var)

Definition at line 949 of file include/asterisk/config.h.

Referenced by append_variable(), ast_ari_asterisk_update_object(), ast_stream_get_metadata_list(), ast_stream_set_metadata(), AST_TEST_DEFINE(), contact_to_var_list(), jack_handler(), jim_handler(), load_realtime_musiconhold(), localnet_to_vl_append(), match_to_var_list_append(), originate_exec(), outbound_auths_to_var_list(), set_var_handler(), variable_list_append(), and verify_user_event_fields().

ast_variable_new

#define ast_variable_new	(		name,
			value,
			filename
	)		_ast_variable_new(name, value, filename, __FILE__, __PRETTY_FUNCTION__, __LINE__)

Definition at line 914 of file include/asterisk/config.h.

Referenced by __init_manager(), aco_set_defaults(), add_cfg_entry(), add_message_id(), add_rt_cfg_entry(), add_rt_multi_cfg_entry(), add_var(), announce_to_dial(), append_row_to_cfg(), append_variable(), ast_ari_asterisk_update_object(), ast_ari_invoke(), ast_channeltype_list(), ast_http_get_post_vars(), ast_include_rename(), ast_json_to_ast_variables(), ast_sorcery_changeset_create(), ast_sorcery_object_set_extended(), ast_stream_get_metadata_list(), ast_stream_set_metadata(), AST_TEST_DEFINE(), ast_variable_update(), ast_variables_dup(), build_calendar(), build_cfg(), build_user(), check_access(), check_expiration_thread(), cli_contact_get_container(), config_curl(), config_ldap(), config_mysql(), config_odbc(), config_pgsql(), contact_to_var_list(), copy_vars(), create_mwi_subscriptions(), create_vmaccount(), dup_vars(), fields_handler(), get_single_field_as_var_list(), handle_registrations(), handle_updates(), handle_uri(), http_request_headers_get(), iax_parse_ies(), inherit_channel_vars_from_id(), jack_handler(), ldap_table_config_add_attribute(), load_realtime_musiconhold(), localnet_to_vl_append(), man_do_variable_value(), manager_sipnotify(), match_to_var_list_append(), mkintf(), object_type_loaded_observer(), originate_exec(), outbound_auths_to_var_list(), parse_cookies(), process_dahdi(), process_text_line(), realtime_arguments_to_fields(), realtime_arguments_to_fields2(), realtime_curl(), realtime_directory(), realtime_ldap_entry_to_var(), realtime_ldap_result_to_vars(), realtime_multi_curl(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_mysql(), realtime_odbc(), realtime_pgsql(), realtime_sorcery_update(), resource_event_handler(), row_to_varlist(), set_var_handler(), sip_cli_notify(), sorcery_config_open(), sorcery_realtime_create(), sorcery_realtime_retrieve_id(), sorcery_realtime_retrieve_multiple(), sorcery_realtime_retrieve_prefix(), sorcery_realtime_retrieve_regex(), static_realtime_cb(), test_sorcery_copy(), test_sorcery_diff(), test_sorcery_regex_fields(), test_sorcery_transform(), update_ldap(), variable_clone(), variable_list_append(), verify_user_event_fields(), vm_change_password(), and write_password_to_file().

CONFIG_STATUS_FILEINVALID

#define CONFIG_STATUS_FILEINVALID   (void *)-2

Definition at line 60 of file include/asterisk/config.h.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_sorcery_apply_config(), __init_manager(), _dsp_init(), aco_process_config(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), adsi_load(), ast_config_internal_load(), ast_config_load2(), ast_init_logger_for_socket_console(), ast_xmldoc_load_documentation(), conf_exec(), config_function_read(), config_load(), config_module(), config_text_file_load(), directory_exec(), do_reload(), festival_exec(), find_conf(), forward_message(), get_defaults(), iax_provision_reload(), init_logger_chain(), initialize_cc_devstate_map(), initialize_cc_max_requests(), load_asterisk_conf(), load_config(), load_config_meetme(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_values_config(), loader_config_init(), message_range_and_existence_check(), misdn_cfg_init(), my_load_module(), notify_new_message(), object_type_loaded_observer(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), private_enum_init(), process_config(), read_pjproject_startup_options(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_queues(), rtp_reload(), run_startup_commands(), set_config(), setup_dahdi_int(), sla_load_config(), smdi_load(), sorcery_config_internal_load(), tds_load_module(), valid_config(), vm_forwardoptions(), vm_msg_forward(), vm_msg_play(), and vm_msg_snapshot_create().

CONFIG_STATUS_FILEMISSING

#define CONFIG_STATUS_FILEMISSING   (void *)0

Definition at line 58 of file include/asterisk/config.h.

Referenced by _dsp_init(), aco_process_config(), action_getconfig(), adsi_load(), do_reload(), load_asterisk_conf(), load_config(), load_indications(), load_moh_classes(), load_odbc_config(), load_values_config(), loader_config_init(), my_load_module(), parse_config(), private_enum_init(), reload_module(), and run_startup_commands().

CONFIG_STATUS_FILEUNCHANGED

#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1

Definition at line 59 of file include/asterisk/config.h.

Referenced by __ast_http_load(), __ast_http_post_load(), __init_manager(), _dsp_init(), aco_process_config(), adsi_load(), ast_cli_perms_init(), ast_config_internal_load(), ast_config_load2(), AST_TEST_DEFINE(), config_function_read(), config_module(), config_text_file_load(), do_reload(), iax_provision_reload(), load_asterisk_conf(), load_config(), load_indications(), load_moh_classes(), load_values_config(), misdn_cfg_init(), my_load_module(), object_type_loaded_observer(), odbc_load_module(), osp_load(), parse_config(), private_enum_init(), process_config(), read_pjproject_startup_options(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_queues(), rtp_reload(), run_startup_commands(), set_config(), setup_dahdi_int(), sla_load_config(), smdi_load(), sorcery_config_internal_load(), and tds_load_module().

CV_BOOL

#define CV_BOOL	(		__x,
			__dst
	)		CV_F(__x, (__dst) = ast_true(__val) )

helper macros to assign the value to a BOOL, UINT, static string and dynamic string

Definition at line 1214 of file include/asterisk/config.h.

Referenced by store_config_core().

CV_DSTR

#define CV_DSTR	(		__x,
			__dst
	)		CV_F(__x, ast_free(__dst); __dst = ast_strdup(__val))

Definition at line 1217 of file include/asterisk/config.h.

CV_END

#define CV_END   } while (0)

close a variable parsing block

Definition at line 1205 of file include/asterisk/config.h.

Referenced by store_config_core(), and store_config_tone_zone().

CV_F

#define CV_F	(		__pattern,
			__body
	)		if (!strcasecmp((__var), __pattern)) { __body; break; }

call a generic function if the name matches.

Definition at line 1208 of file include/asterisk/config.h.

Referenced by store_config_core(), and store_config_tone_zone().

CV_START

#define CV_START	(		__in_var,
			__in_val
	)

Value:

do {              \
      const char *__var = __in_var; \
      const char *__val = __in_val;

the macro to open a block for variable parsing

Definition at line 1199 of file include/asterisk/config.h.

Referenced by store_config_core(), and store_config_tone_zone().

CV_STR

#define CV_STR	(		__x,
			__dst
	)		CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))

Definition at line 1216 of file include/asterisk/config.h.

Referenced by store_config_core(), and store_config_tone_zone().

CV_STRFIELD

#define CV_STRFIELD	(		__x,
			__obj,
			__field
	)		CV_F(__x, ast_string_field_set(__obj, __field, __val))

Definition at line 1218 of file include/asterisk/config.h.

Referenced by store_config_core().

CV_UINT

#define CV_UINT	(		__x,
			__dst
	)		CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )

Definition at line 1215 of file include/asterisk/config.h.

Referenced by store_config_core().

Typedef Documentation

config_hook_cb

typedef int(* config_hook_cb) (struct ast_config *cfg)

Definition at line 1035 of file include/asterisk/config.h.

config_load_func

typedef struct ast_config* config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)

Definition at line 109 of file include/asterisk/config.h.

realtime_destroy

typedef int realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)

Definition at line 115 of file include/asterisk/config.h.

realtime_multi_get

typedef struct ast_config* realtime_multi_get(const char *database, const char *table, const struct ast_variable *fields)

Definition at line 111 of file include/asterisk/config.h.

realtime_require

typedef int realtime_require(const char *database, const char *table, va_list ap)

Function pointer called to ensure database schema is properly configured for realtime use.

Since

1.6.1

Definition at line 121 of file include/asterisk/config.h.

realtime_store

typedef int realtime_store(const char *database, const char *table, const struct ast_variable *fields)

Definition at line 114 of file include/asterisk/config.h.

realtime_unload

typedef int realtime_unload(const char *database, const char *table)

Function pointer called to clear the database cache and free resources used for such.

Since

1.6.1

Definition at line 127 of file include/asterisk/config.h.

realtime_update

typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, const struct ast_variable *fields)

Definition at line 112 of file include/asterisk/config.h.

realtime_update2

typedef int realtime_update2(const char *database, const char *table, const struct ast_variable *lookup_fields, const struct ast_variable *update_fields)

Definition at line 113 of file include/asterisk/config.h.

realtime_var_get

typedef struct ast_variable* realtime_var_get(const char *database, const char *table, const struct ast_variable *fields)

Definition at line 110 of file include/asterisk/config.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Options for ast_config_load()

Enumerator
CONFIG_FLAG_WITHCOMMENTS	Load the configuration, including comments
CONFIG_FLAG_FILEUNCHANGED	On a reload, give us a -1 if the file hasn't changed.
CONFIG_FLAG_NOCACHE	Don't attempt to cache mtime on this config file.
CONFIG_FLAG_NOREALTIME	Don't attempt to load from realtime (typically called from a realtime driver dependency)

Definition at line 39 of file include/asterisk/config.h.

     {
   /*! Load the configuration, including comments */
   CONFIG_FLAG_WITHCOMMENTS  = (1 << 0),
   /*! On a reload, give us a -1 if the file hasn't changed. */
   CONFIG_FLAG_FILEUNCHANGED = (1 << 1),
   /*! Don't attempt to cache mtime on this config file. */
   CONFIG_FLAG_NOCACHE       = (1 << 2),
   /*! Don't attempt to load from realtime (typically called from a realtime driver dependency) */
   CONFIG_FLAG_NOREALTIME    = (1 << 3),
};

ast_parse_flags

enum ast_parse_flags

Support code to parse config file arguments.

The function ast_parse_arg() provides a generic interface to parse strings (e.g. numbers, network addresses and so on) in a flexible way, e.g. by doing proper error and bound checks, provide default values, and so on. The function (described later) takes a string as an argument, a set of flags to specify the result format and checks to perform, a pointer to the result, and optionally some additional arguments.

Returns

It returns 0 on success, != 0 otherwise.

Enumerator
PARSE_TYPE
PARSE_INT32
PARSE_UINT32
PARSE_DOUBLE
PARSE_TIMELEN
PARSE_ADDR
PARSE_INADDR
PARSE_DEFAULT
PARSE_IN_RANGE
PARSE_OUT_RANGE
PARSE_RANGE_DEFAULTS
PARSE_PORT_MASK
PARSE_PORT_IGNORE
PARSE_PORT_REQUIRE
PARSE_PORT_FORBID

Definition at line 1080 of file include/asterisk/config.h.

                     {
   /* low 4 bits of flags are used for the operand type */
   PARSE_TYPE  =  0x000f,
   /* numeric types, with optional default value and bound checks.
    * Additional arguments are passed by value.
    */
   PARSE_INT32 =  0x0001,
   PARSE_UINT32   =  0x0002,
   PARSE_DOUBLE   =  0x0003,
#if 0 /* not supported yet */
   PARSE_INT16 =  0x0004,
   PARSE_UINT16   =  0x0005,
#endif

   /* Returns an int processed by ast_app_parse_timelen.
    * The first argument is an enum ast_timelen value (required).
    */
   PARSE_TIMELEN  =  0x0006,

   /* Returns a struct ast_sockaddr, with optional default value
    * (passed by reference) and port handling (accept, ignore,
    * require, forbid). The format is 'ipaddress[:port]'. IPv6 address
    * literals need square brackets around them if a port is specified.
    */
   PARSE_ADDR  =  0x000e,

   /* Returns a struct sockaddr_in, with optional default value
    * (passed by reference) and port handling (accept, ignore,
    * require, forbid). The format is 'host.name[:port]'
    */
   PARSE_INADDR   =  0x000f,

   /* Other data types can be added as needed */

   /* If PARSE_DEFAULT is set, next argument is a default value
    * which is returned in case of error. The argument is passed
    * by value in case of numeric types, by reference in other cases.
    */
   PARSE_DEFAULT  =  0x0010,  /* assign default on error */

   /* Request a range check, applicable to numbers. Two additional
    * arguments are passed by value, specifying the low-high end of
    * the range (inclusive). An error is returned if the value
    * is outside or inside the range, respectively.
    */
   PARSE_IN_RANGE =       0x0020, /* accept values inside a range */
   PARSE_OUT_RANGE =      0x0040, /* accept values outside a range */
   PARSE_RANGE_DEFAULTS = 0x0080, /* default to range min/max on range error */

   /* Port handling, for ast_sockaddr. accept/ignore/require/forbid
    * port number after the hostname or address.
    */
   PARSE_PORT_MASK = 0x0300, /* 0x000: accept port if present */
   PARSE_PORT_IGNORE =  0x0100, /* 0x100: ignore port if present */
   PARSE_PORT_REQUIRE = 0x0200, /* 0x200: require port number */
   PARSE_PORT_FORBID =  0x0300, /* 0x100: forbid port number */
};

config_hook_flags

enum config_hook_flags

Flags that affect the behaviour of config hooks.

Enumerator
butt

Definition at line 1025 of file include/asterisk/config.h.

                       {
   butt,
};

config_save_flags

enum config_save_flags

Flags for ast_config_text_file_save2()

Enumerator
CONFIG_SAVE_FLAG_NONE
CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT	Insure a context doesn't effectively change if a template changes (pre 13.2 behavior)

Definition at line 52 of file include/asterisk/config.h.

                       {
   CONFIG_SAVE_FLAG_NONE = (0),
   /*! Insure a context doesn't effectively change if a template changes (pre 13.2 behavior) */
   CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT = (1 << 0),
};

require_type

enum require_type

Types used in ast_realtime_require_field.

Enumerator
RQ_INTEGER1
RQ_UINTEGER1
RQ_INTEGER2
RQ_UINTEGER2
RQ_INTEGER3
RQ_UINTEGER3
RQ_INTEGER4
RQ_UINTEGER4
RQ_INTEGER8
RQ_UINTEGER8
RQ_CHAR
RQ_FLOAT
RQ_DATE
RQ_DATETIME

Definition at line 65 of file include/asterisk/config.h.

             {
   RQ_INTEGER1,
   RQ_UINTEGER1,
   RQ_INTEGER2,
   RQ_UINTEGER2,
   RQ_INTEGER3,
   RQ_UINTEGER3,
   RQ_INTEGER4,
   RQ_UINTEGER4,
   RQ_INTEGER8,
   RQ_UINTEGER8,
   RQ_CHAR,
   RQ_FLOAT,
   RQ_DATE,
   RQ_DATETIME,
} require_type;

Function Documentation

_ast_variable_new()

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

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

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

{
   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;
}

ast_category_append()

static void ast_category_append	(	struct ast_config *	config,
		struct ast_category *	cat
	)

Appends a category to a config.

Parameters

config	which config to use
cat	category to insert

Definition at line 2835 of file extconf.c.

References ast_config::current, ast_category::include_level, ast_config::include_level, ast_config::last, ast_category::next, NULL, ast_category::prev, and ast_config::root.

Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), 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().

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

ast_category_browse()

static 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 3328 of file extconf.c.

References ast_config::last_browse, ast_category::name, ast_category::next, next_available_category(), NULL, and ast_config::root.

Referenced by __init_manager(), __queues_show(), actual_load_config(), ast_cli_perms_init(), AST_TEST_DEFINE(), complete_sip_notify(), conf_exec(), config_load(), find_queue_by_name_rt(), find_realtime(), get_insecure_variable_from_config(), get_insecure_variable_from_sipregs(), iax_provision_reload(), internal_process_ast_config(), load_config(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_pktccops_config(), load_realtime_musiconhold(), load_realtime_rules(), load_tech_calendars(), load_users(), mbl_load_config(), misdn_cfg_init(), named_acl_find_realtime(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), realtime_directory(), realtime_sorcery(), realtime_sorcery_multi(), realtime_switch_common(), register_realtime_peers_with_callbackextens(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), search_directory(), search_directory_sub(), set_config(), set_member_value(), setup_dahdi_int(), show_users_realtime(), sla_load_config(), test_config_validity(), update_realtime_members(), and vm_change_password().

{
   struct ast_category *cat = NULL;

   if (prev && config->last_browse && (config->last_browse->name == prev))
      cat = config->last_browse->next;
   else if (!prev && config->root)
      cat = config->root;
   else if (prev) {
      for (cat = config->root; cat; cat = cat->next) {
         if (cat->name == prev) {
            cat = cat->next;
            break;
         }
      }
      if (!cat) {
         for (cat = config->root; cat; cat = cat->next) {
            if (!strcasecmp(cat->name, prev)) {
               cat = cat->next;
               break;
            }
         }
      }
   }

   if (cat)
      cat = next_available_category(cat);

   config->last_browse = cat;
   return (cat) ? cat->name : NULL;
}

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 1335 of file main/config.c.

References ast_category::next, next_available_category(), and ast_config::root.

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().

{
   struct ast_category *cat;

   if (!prev) {
      prev = config->root;
   } else {
      prev = prev->next;
   }

   cat = next_available_category(prev, category_name, filter);

   return cat;
}

ast_category_delete()

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

Delete a category.

Parameters

config	which config to use
category	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 1478 of file main/config.c.

References ast_category_destroy(), ast_config::last, ast_config::last_browse, ast_category::next, NULL, ast_category::prev, and ast_config::root.

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

{
   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;
}

ast_category_destroy()

static void ast_category_destroy

(

struct ast_category *

cat

)

Definition at line 2847 of file extconf.c.

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

Referenced by add_cfg_entry(), 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_variables_destroy(cat->root);
   if (cat->file)
      free(cat->file);

   free(cat);
}

ast_category_detach_variables()

struct ast_variable* ast_category_detach_variables

(

struct ast_category *

cat

)

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

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

Referenced by realtime_switch_common(), and sorcery_realtime_retrieve_multiple().

{
   struct ast_variable *v;

   v = cat->root;
   cat->root = NULL;
   cat->last = NULL;

   return v;
}

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 categopry is NULL

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

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

Referenced by AST_TEST_DEFINE(), and handle_updates().

{
   if (!category) {
      return -1;
   }

   ast_variables_destroy(category->root);
   category->root = NULL;
   category->last = NULL;

   return 0;
}

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 1061 of file main/config.c.

References ast_category_get().

Referenced by realtime_sorcery_store().

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

ast_category_first()

struct ast_variable* ast_category_first

(

struct ast_category *

cat

)

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

This is equivalent to ast_variable_browse(), but more efficient if we already have the struct ast_category * (e.g. from ast_category_get())

return the first var of a category

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

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().

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

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 1022 of file main/config.c.

References category_get_sep().

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().

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

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 1028 of file main/config.c.

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().

{
   return category->name;
}

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 1038 of file main/config.c.

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

Referenced by action_getconfig(), and action_getconfigjson().

{
   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;
}

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 1367 of file main/config.c.

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_comment::next, ast_variable::next, ast_category::root, var, and variable_clone().

Referenced by handle_updates(), and process_text_line().

{
   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;
}

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 1083 of file main/config.c.

References ast_category::name, ast_category::next, NULL, ast_category::prev, and ast_config::root.

Referenced by AST_TEST_DEFINE(), and handle_updates().

{
   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;
}

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 1033 of file main/config.c.

References ast_category::ignored.

Referenced by action_getconfig(), and action_getconfigjson().

{
   return category->ignored;
}

ast_category_new()

static 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 2790 of file extconf.c.

References new_category().

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().

{
   struct ast_category *category;

   if ((category = ast_calloc(1, sizeof(*category))))
      ast_copy_string(category->name, name, sizeof(category->name));
   category->file = strdup(in_file);
   category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
   return category;
}

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 995 of file main/config.c.

References new_category().

Referenced by AST_TEST_DEFINE(), and handle_updates().

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

ast_category_rename()

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

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

References ast_copy_string(), and ast_category::name.

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

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

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 1162 of file main/config.c.

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

Referenced by config_function_read(), get_insecure_variable_from_config(), get_insecure_variable_from_sipregs(), realtime_sorcery(), realtime_sorcery_multi(), and register_realtime_peers_with_callbackextens().

{
   struct ast_category *category = ast_category_get(config, cat, NULL);

   if (category)
      return category->root;
   return NULL;
}

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 3363 of file main/config.c.

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

Referenced by __queues_show(), _sip_show_peer(), _sip_show_peers(), ast_named_acl_find(), ast_queue_log(), close_mailbox(), copy_plain_file(), destroy_association(), find_realtime_gw(), handle_response_peerpoke(), handle_voicemail_show_users(), leave_voicemail(), load_module(), load_moh_classes(), load_realtime_rules(), local_ast_moh_start(), logger_queue_rt_start(), msg_create_from_file(), realtime_peer(), realtime_update_peer(), register_realtime_peers_with_callbackextens(), rename_file(), set_member_value(), sip_poke_noanswer(), sip_show_settings(), and vm_delete().

{
   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;
}

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 3079 of file main/config.c.

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().

{
   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;
}

ast_config_destroy()

static void ast_config_destroy

(

struct ast_config *

config

)

Destroys a config.

Parameters

config

pointer to config data structure

Free memory associated with a given config

Definition at line 1290 of file extconf.c.

References ast_category_destroy(), ast_free, ast_includes_destroy(), ast_config::includes, ast_category::next, 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(), ast_xmldoc_load_documentation(), build_cfg(), conf_exec(), config_function_read(), config_load(), config_module(), deinitialize_sorcery(), directory_exec(), do_reload(), festival_exec(), find_conf(), find_load_queue_rt_friendly(), find_realtime(), forward_message(), get_defaults(), get_insecure_variable_from_sippeers(), get_insecure_variable_from_sipregs(), handle_cli_dialplan_save(), hook_cb(), iax_provision_reload(), ineligible_configuration(), init_logger_chain(), initialize_cc_devstate_map(), initialize_cc_max_requests(), load_asterisk_conf(), load_config(), load_config_meetme(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_pktccops_config(), load_realtime_musiconhold(), load_realtime_rules(), load_values_config(), loader_config_init(), make_email_file(), mbl_load_config(), message_range_and_existence_check(), misdn_cfg_init(), my_load_module(), named_acl_find_realtime(), notify_new_message(), object_type_loaded_observer(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), private_enum_init(), process_config(), read_password_from_file(), read_pjproject_startup_options(), realtime_directory(), realtime_multi_handler(), realtime_multi_mysql(), realtime_multi_pgsql(), realtime_sorcery_multi(), realtime_sqlite3_multi(), realtime_switch_common(), register_realtime_peers_with_callbackextens(), reload(), reload_config(), reload_followme(), reload_module(), reload_queue_rules(), reload_queues(), rtp_reload(), run_startup_commands(), set_config(), 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(), and write_password_to_file().

{
   struct ast_category *cat, *catn;

   if (!cfg)
      return;

   ast_includes_destroy(cfg->includes);

   cat = cfg->root;
   while (cat) {
      ast_variables_destroy(cat->root);
      catn = cat;
      cat = cat->next;
      free(catn);
   }
   free(cfg);
}

ast_config_engine_deregister()

int ast_config_engine_deregister

(

struct ast_config_engine *

del

)

Deregister config engine.

Return values

0

Always

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

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

Referenced by unload_module().

{
   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;
}

ast_config_engine_register()

int ast_config_engine_register

(

struct ast_config_engine *

newconfig

)

Register config engine.

Return values

1

Always

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

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

Referenced by load_module().

{
   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;
}

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 2783 of file extconf.c.

References ast_category_new(), ast_config::current, and ast_channel::name.

Referenced by config_curl(), config_odbc(), config_text_file_load(), and find_engine().

{
   return cfg->current;
}

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 4132 of file main/config.c.

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

Referenced by AST_TEST_DEFINE().

{
   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;
}

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 4104 of file main/config.c.

References ao2_find, ast_strdupa, cfg_hook::name, OBJ_NODATA, OBJ_POINTER, OBJ_UNLINK, and tmp().

Referenced by AST_TEST_DEFINE().

{
   struct cfg_hook tmp;

   tmp.name = ast_strdupa(name);

   ao2_find(cfg_hooks, &tmp, OBJ_POINTER | OBJ_UNLINK | OBJ_NODATA);
}

ast_config_internal_load()

struct ast_config* ast_config_internal_load	(	const char *	configfile,
		struct ast_config *	cfg,
		struct ast_flags	flags,
		const char *	suggested_incl_file,
		const char *	who_asked
	)

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

References ast_log, ast_test_flag, 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, and text_file_engine.

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

{
   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;
}

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 3154 of file main/config.c.

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(), ast_xmldoc_load_documentation(), 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(), misdn_cfg_init(), object_type_loaded_observer(), private_enum_init(), read_pjproject_startup_options(), rtp_reload(), run_startup_commands(), set_config(), and sorcery_config_internal_load().

{
   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;
}

ast_config_new()

static struct ast_config * ast_config_new

(

void

)

Create a new base configuration structure.

Definition at line 3276 of file extconf.c.

References ast_calloc, config, MAX_INCLUDE_LEVEL, and ast_config::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_handler(), 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().

{
   struct ast_config *config;

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

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 684 of file main/config.c.

References ast_variable_retrieve(), and tmp().

Referenced by actual_load_config(), pbx_load_users(), process_config(), and search_directory_sub().

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

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 3364 of file extconf.c.

References ast_config::current.

Referenced by ast_category_browse(), and process_text_line().

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

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 1171 of file main/config.c.

References ast_category::next, NULL, and ast_config::root.

Referenced by named_acl_find_realtime(), and realtime_switch_common().

{
   /*
    * 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;
   }

}

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

Returns

0 on success or -1 on failure.

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

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().

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

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

Returns

0 on success or -1 on failure.

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

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_variable::blanklines, ast_comment::cmt, config_hook_exec(), CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT, errno, ast_config_include::exec, ast_config_include::exec_file, ast_variable::file, 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::included_file, ast_config::includes, ast_variable::inherited, insert_leading_blank_lines(), ast_category_template_instance::inst, is_writable(), ast_variable::lineno, ast_category::lineno, LOG_ERROR, make_fn(), ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_comment::next, ast_variable::next, ast_category::next, ast_config_include::next, NULL, ast_variable::object, ast_config_include::output, PATH_MAX, ast_variable::precomments, ast_category::precomments, ast_category::root, ast_config::root, ast_variable::sameline, ast_category::sameline, set_fn(), ast_category::template_instances, ast_variable::trailing, ast_category::trailing, ast_variable::value, and var.

Referenced by action_updateconfig(), and ast_config_text_file_save().

{
   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;

   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;
   }

   /* Check all the files for write access before attempting to modify any of them */
   for (incl = cfg->includes; 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->exec) {
         /* now make sure we have write access to the include file or its parent directory */
         make_fn(fn, sizeof(fn), incl->included_file, configfile);
         /* If the file itself doesn't exist, make sure we have write access to the directory */
         if (!is_writable(fn)) {
            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;
   }

   /* 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*/
   for (incl = cfg->includes; incl; incl = incl->next) {
      if (!incl->exec) { /* leave the execs alone -- we'll write out the #exec directives, but won't zero out the include files or exec files*/
         /* normally, fn is just set to incl->included_file, prepended with config dir if relative */
         fi = set_fn(fn, sizeof(fn), incl->included_file, configfile, fileset);
         f = fopen(fn, "w");
         if (f) {
            gen_header(f, configfile, fn, generator);
            fclose(f); /* this should zero out the file */
         } 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; incl; incl = incl->next) {
            if (strcmp(incl->include_location_file, cat->file) == 0){
               if (cat->lineno > incl->include_location_lineno && !incl->output) {
                  if (incl->exec)
                     fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                  else
                     fprintf(f,"#include \"%s\"\n", incl->included_file);
                  incl->output = 1;
               }
            }
         }

         insert_leading_blank_lines(f, fi, cat->precomments, cat->lineno);
         /* Dump section with any appropriate comment */
         for (cmt = cat->precomments; cmt; cmt=cmt->next) {
            char *cmtp = cmt->cmt;
            while (cmtp && *cmtp == ';' && *(cmtp+1) == '!') {
               char *cmtp2 = strchr(cmtp+1, '\n');
               if (cmtp2)
                  cmtp = cmtp2+1;
               else cmtp = 0;
            }
            if (cmtp)
               fprintf(f,"%s", cmtp);
         }
         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");
         for (cmt = cat->trailing; cmt; cmt=cmt->next) {
            if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
               fprintf(f,"%s", cmt->cmt);
         }
         fclose(f);
         if (fi) {
            ao2_ref(fi, -1);
         }

         var = cat->root;
         while (var) {
            struct ast_category_template_instance *x;
            int found = 0;

            AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
               struct ast_variable *v;
               for (v = x->inst->root; v; v = v->next) {

                  if (flags & CONFIG_SAVE_FLAG_PRESERVE_EFFECTIVE_CONTEXT) {
                     if (!strcasecmp(var->name, v->name) && !strcmp(var->value, v->value)) {
                        found = 1;
                        break;
                     }
                  } else {
                     if (var->inherited) {
                        found = 1;
                        break;
                     } else {
                        if (!strcasecmp(var->name, v->name) && !strcmp(var->value, v->value)) {
                           found = 1;
                           break;
                        }
                     }
                  }
               }
               if (found) {
                  break;
               }
            }
            if (found) {
               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 category header */
            for (incl=cfg->includes; incl; incl = incl->next) {
               if (strcmp(incl->include_location_file, var->file) == 0){
                  if (var->lineno > incl->include_location_lineno && !incl->output) {
                     if (incl->exec)
                        fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                     else
                        fprintf(f,"#include \"%s\"\n", incl->included_file);
                     incl->output = 1;
                  }
               }
            }

            insert_leading_blank_lines(f, fi, var->precomments, var->lineno);
            for (cmt = var->precomments; cmt; cmt=cmt->next) {
               if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                  fprintf(f,"%s", cmt->cmt);
            }

            { /* 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);
               }
            }

            for (cmt = var->trailing; cmt; cmt=cmt->next) {
               if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                  fprintf(f,"%s", cmt->cmt);
            }
            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;
      }
      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;
   }

   /* Now, for files with trailing #include/#exec statements,
      we have to make sure every entry is output */
   for (incl=cfg->includes; 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;
         }

         /* output the respective include */
         if (incl->exec)
            fprintf(f,"#exec \"%s\"\n", incl->exec_file);
         else
            fprintf(f,"#include \"%s\"\n", incl->included_file);
         fclose(f);
         incl->output = 1;
         if (fi) {
            ao2_ref(fi, -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;
}

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 3606 of file main/config.c.

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().

{
   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);
}

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 3586 of file main/config.c.

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

Referenced by ast_destroy_realtime(), and sorcery_realtime_delete().

{
   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;
}

ast_include_find()

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

Definition at line 1164 of file extconf.c.

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

Referenced by ast_include_new().

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

ast_include_new()

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

Definition at line 1075 of file extconf.c.

References ast_calloc, ast_include_find(), ast_includes_destroy(), ast_log, ast_strdup, ast_strlen_zero, ast_config::includes, LOG_WARNING, and NULL.

Referenced by AST_TEST_DEFINE(), and process_text_line().

{
   /* 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;

   inc = ast_include_find(conf, included_file);
   if (inc)
   {
      inc->inclusion_count++;
      snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
      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));
   inc->include_location_file = ast_strdup(from_file);
   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);

   inc->exec = is_exec;
   if (is_exec)
      inc->exec_file = ast_strdup(exec_file);

   /* attach this new struct to the conf struct */
   inc->next = conf->includes;
   conf->includes = inc;

   return inc;
}

ast_include_rename()

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

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

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_config::includes, ast_category::last, name, ast_variable::name, ast_variable::next, ast_category::next, ast_config_include::next, ast_category::root, ast_config::root, str, and ast_variable::value.

Referenced by action_updateconfig().

{
   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; 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;
      }
   }
}

ast_load_realtime()

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

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

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_realtime_gw(), find_user_realtime(), leave_queue(), load_realtime_musiconhold(), queue_function_queuegetchannel(), queue_function_queuewaitingcount(), realtime_peer(), realtime_peer_by_addr(), realtime_peer_by_name(), realtime_peer_get_sippeer_helper(), realtime_switch_common(), realtime_user(), rt_extend_conf(), and vm_allocate_dh().

{
   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);
}

ast_load_realtime_all()

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

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

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().

{
   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;
}

ast_load_realtime_all_fields()

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

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

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

Referenced by ast_load_realtime_all(), and ast_load_realtime_fields().

{
   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))) {
            return res;
         }
      } else {
         return NULL;
      }
   }

   return res;
}

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

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 3304 of file main/config.c.

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

Referenced by ast_load_realtime(), and sorcery_realtime_retrieve_fields().

{
   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;
}

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 3452 of file main/config.c.

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(), get_insecure_variable_from_sippeers(), get_insecure_variable_from_sipregs(), load_module(), load_realtime_musiconhold(), load_realtime_rules(), named_acl_find_realtime(), realtime_directory(), realtime_switch_common(), register_realtime_peers_with_callbackextens(), set_member_value(), show_users_realtime(), and update_realtime_members().

{
   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);
}

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 3426 of file main/config.c.

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

Referenced by ast_load_realtime_multientry(), and sorcery_realtime_retrieve_multiple().

{
   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;
}

ast_parse_arg()

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

The argument parsing routine.

Parameters

arg	the string to parse. It is not modified.
flags	combination of ast_parse_flags to specify the return type and additional checks.
result	pointer to the result. NULL is valid here, and can be used to perform only the validity checks.
...	extra arguments are required according to flags.

Return values

0	in case of success, != 0 otherwise.
result	returns the parsed value in case of success, the default value in case of error, or it is left unchanged in case of error and no default specified. Note that in certain cases (e.g. sockaddr_in, with multi-field return values) some of the fields in result may be changed even if an error occurs.

Examples of use: ast_parse_arg("223", PARSE_INT32|PARSE_IN_RANGE, &a, -1000, 1000); returns 0, a = 223 ast_parse_arg("22345", PARSE_INT32|PARSE_IN_RANGE|PARSE_DEFAULT, &a, 9999, 10, 100); returns 1, a = 9999 ast_parse_arg("22345ssf", PARSE_UINT32|PARSE_IN_RANGE, &b, 10, 100); returns 1, b unchanged ast_parse_arg("12", PARSE_UINT32|PARSE_IN_RANGE|PARSE_RANGE_DEFAULTS, &a, 1, 10); returns 1, a = 10 ast_parse_arg("223", PARSE_TIMELEN|PARSE_IN_RANGE, &a, TIMELEN_SECONDS, -1000, 1000); returns 0, a = 1000 ast_parse_arg("223", PARSE_TIMELEN|PARSE_IN_RANGE, &a, TIMELEN_SECONDS, -1000, 250000); returns 0, a = 223000 ast_parse_arg("223", PARSE_TIMELEN|PARSE_IN_RANGE|PARSE_DEFAULT, &a, TIMELEN_SECONDS, 9999, -1000, 250000); returns 0, a = 9999 ast_parse_arg("www.foo.biz:44", PARSE_INADDR, &sa); returns 0, sa contains address and port ast_parse_arg("www.foo.biz", PARSE_INADDR|PARSE_PORT_REQUIRE, &sa); returns 1 because port is missing, sa contains address

The argument parsing routine.

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

References ahp, ast_app_parse_timelen(), ast_debug, ast_gethostbyname(), ast_inet_ntoa(), ast_skip_blanks(), ast_sockaddr_parse(), ast_sockaddr_stringify(), ast_strdupa, ast_strlen_zero, buf, errno, error(), hp, 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(), load_values_config(), new_realtime_sqlite3_db(), realtime_peer(), reload_config(), rtp_reload(), set_config(), setup_rtp_connection(), setup_rtp_remote(), setup_udptl_connection(), sockaddr_handler_fn(), timelen_handler_fn(), uint_handler_fn(), and xfer_set().

{
   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 happilly 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 hostent *hp;
      struct ast_hostent ahp;

      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. */
      hp = ast_gethostbyname(buf, &ahp);
      if (hp)  /* resolved successfully */
         memcpy(&sa->sin_addr, hp->h_addr, sizeof(sa->sin_addr));
      else {
         error = 1;
         sa->sin_addr = def->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;
}

ast_realtime_append_mapping()

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

Add an explicit mapping for a family.

Parameters

name	Family name
driver	Driver to use
database	Database to access
table	Table to use
priority	Priority of this mapping

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

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

Referenced by load_module(), and reload_module().

{
   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(2, "Binding %s to %s/%s/%s\n", map->name, map->driver, map->database, map->table ? map->table : map->name);

   return 0;
}

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 3625 of file main/config.c.

Referenced by realtime_multi_pgsql(), and realtime_pgsql().

{
   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;
}

ast_realtime_enabled()

int ast_realtime_enabled

(

void

)

Check if there's any realtime engines loaded.

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

References config_maps.

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

{
   return config_maps ? 1 : 0;
}

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 3637 of file main/config.c.

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

{
   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);
}

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 3026 of file main/config.c.

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

Referenced by ast_named_acl_find(), and sorcery_realtime_open().

{
   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;
}

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 3382 of file main/config.c.

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

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

{
   struct ast_config_engine *eng;
   char db[256];
   char table[256];
   va_list ap;
   int res = -1, i;

   va_start(ap, family);
   for (i = 1; ; i++) {
      if ((eng = find_engine(family, i, db, sizeof(db), table, sizeof(table)))) {
         /* If the require succeeds, it returns 0. */
         if (eng->require_func && !(res = eng->require_func(db, table, ap))) {
            break;
         }
      } else {
         break;
      }
   }
   va_end(ap);

   return res;
}

ast_rq_is_int()

int ast_rq_is_int ( require_type  type )

inline

Check if require type is an integer type.

Definition at line 1240 of file include/asterisk/config.h.

Referenced by realtime_require_handler(), require_mysql(), require_odbc(), and require_pgsql().

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 3570 of file main/config.c.

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().

{
   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);
}

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 3549 of file main/config.c.

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

Referenced by ast_store_realtime(), and sorcery_realtime_create().

{
   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;
}

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 3406 of file main/config.c.

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

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

{
   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;
}

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 3525 of file main/config.c.

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().

{
   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);
}

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 3505 of file main/config.c.

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

Referenced by ast_update2_realtime().

{
   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;
}

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 3489 of file main/config.c.

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

Referenced by cli_realtime_update(), conf_run(), destroy_association(), function_realtime_write(), handle_response_peerpoke(), leave_voicemail(), realtime_update_peer(), rename_file(), rt_extend_conf(), sip_poke_noanswer(), and update_realtime_member_field().

{
   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);
}

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 3468 of file main/config.c.

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

Referenced by ast_update_realtime(), and sorcery_realtime_update().

{
   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;
}

ast_variable_append()

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

Definition at line 1178 of file extconf.c.

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

Referenced by add_cfg_entry(), add_message_id(), add_rt_multi_cfg_entry(), 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(), vm_change_password(), and write_password_to_file().

{
   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;
}

ast_variable_browse()

static struct ast_variable * ast_variable_browse	(	const struct ast_config *	config,
		const char *	category_name
	)

Definition at line 1216 of file extconf.c.

References ast_category_get(), ast_config::last_browse, ast_category::name, 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(), actual_load_config(), adsi_load(), ast_cli_perms_init(), AST_TEST_DEFINE(), ast_variable_retrieve(), ast_xmldoc_load_documentation(), build_calendar(), build_device(), caldav_load_calendar(), conf_exec(), config_load(), 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_config(), load_general_config(), load_module(), load_moh_classes(), load_odbc_config(), load_pktccops_config(), load_users(), load_values_config(), load_zonemessages(), loader_config_init(), mbl_load_adapter(), mbl_load_config(), mbl_load_device(), misdn_cfg_init(), my_connect_db(), my_load_module(), new_realtime_sqlite3_db(), odbc_load_module(), osp_create_provider(), parse_config(), 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(), sip_cli_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), tds_load_module(), and test_config_validity().

{
   struct ast_category *cat = NULL;

   if (category && config->last_browse && (config->last_browse->name == category))
      cat = config->last_browse;
   else
      cat = ast_category_get(config, category);

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

ast_variable_browse_filtered()

struct ast_variable* ast_variable_browse_filtered	(	const struct ast_config *	config,
		const char *	category_name,
		const char *	filter
	)

Browse variables.

Parameters

config	Which config structure you wish to "browse"
category_name	Which category to "browse"
filter	an optional comma-separated list of <name_regex>=<value_regex> pairs. Only categories with matching variables will be browsed. 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.

Somewhat similar in intent as the ast_category_browse. List variables of config file category

Return values

ast_variable	list on success
NULL	on failure

ast_variable_delete()

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

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

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

Referenced by handle_updates().

{
   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;
}

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 735 of file main/config.c.

References ast_variable_find_in_list(), and ast_category::root.

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

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

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 830 of file main/config.c.

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

Referenced by ast_ari_callback(), ast_sorcery_changeset_create(), AST_TEST_DEFINE(), ast_variable_find(), handle_export_primitives(), and load_realtime_musiconhold().

{
   const struct ast_variable *v;

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

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 842 of file main/config.c.

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().

{
   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;
}

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 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 740 of file main/config.c.

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

Referenced by ast_variable_lists_match(), and realtime_sorcery_store().

{
   const struct ast_variable *v;

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

ast_variable_insert()

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

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

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

Referenced by AST_TEST_DEFINE(), and handle_updates().

{
   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;
   }
}

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 648 of file main/config.c.

References ast_assert, ast_variable::next, and NULL.

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

{
   struct ast_variable *curr;
   ast_assert(head != NULL);

   if (!*head) {
      *head = newvar;
   } else {
      if (search_hint == NULL) {
         search_hint = *head;
      }
      for (curr = search_hint; curr->next; curr = curr->next);
      curr->next = newvar;
   }

   for (curr = newvar; curr->next; curr = curr->next);

   return curr;
}

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 668 of file main/config.c.

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

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

{
   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;
}

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 622 of file main/config.c.

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

Referenced by ast_sip_cli_print_sorcery_objectset(), and stir_shaken_cli_show().

{
   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;
}

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 772 of file main/config.c.

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().

{
   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;
}

ast_variable_retrieve()

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

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

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

Referenced by __init_manager(), __queues_show(), actual_load_config(), advanced_options(), ast_config_option(), ast_init_logger_for_socket_console(), AST_TEST_DEFINE(), conf_exec(), config_module(), directory_exec(), festival_exec(), find_realtime(), forward_message(), get_defaults(), get_insecure_variable_from_config(), get_insecure_variable_from_sipregs(), iax_template_parse(), ineligible_configuration(), 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_rules(), load_tech_calendars(), load_values_config(), loader_config_init(), make_email_file(), mbl_load_adapter(), mbl_load_device(), message_range_and_existence_check(), my_load_config_number(), my_load_config_string(), named_acl_find_realtime(), notify_new_message(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), 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(), search_directory_sub(), set_config(), set_member_value(), setup_dahdi_int(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), vm_allocate_dh(), vm_change_password(), vm_forwardoptions(), vm_msg_forward(), vm_msg_play(), and vm_msg_snapshot_create().

{
   struct ast_variable *v;

   if (category) {
      for (v = ast_variable_browse(config, category); v; v = v->next) {
         if (!strcasecmp(variable, v->name)) {
            return 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)) {
               return v->value;
            }
         }
      }
   }

   return NULL;
}

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 719 of file main/config.c.

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

{
   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;
}

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 1444 of file main/config.c.

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

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

{
   struct ast_variable *cur, *prev=NULL, *newer=NULL;

   for (cur = category->root; cur; prev = cur, cur = cur->next) {
      if (strcasecmp(cur->name, variable) ||
         (!ast_strlen_zero(match) && strcasecmp(cur->value, match)))
         continue;

      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;
   }

   /* Could not find variable to update */
   return -1;
}

ast_variables_destroy()

static 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 1263 of file extconf.c.

References ast_variable_destroy(), and ast_variable::next.

Referenced by __init_manager(), aco_set_defaults(), action_messagesend(), action_originate(), add_message_id(), announce_to_dial(), ast_ari_asterisk_update_object(), ast_ari_callback(), ast_ari_channels_originate(), ast_ari_channels_originate_with_id(), 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_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_variables_dup(), auth_http_callback(), build_gateway(), build_peer(), calendar_destructor(), can_reuse_registration(), check_expiration_thread(), check_peer_ok(), cli_contact_get_container(), cli_realtime_load(), conf_run(), copy_plain_file(), create_mwi_subscriptions(), destroy_dahdi_pvt(), destroy_endpoint(), destroy_fast_originate_helper(), dup_vars(), endpoint_destructor(), external_media_audiosocket_tcp(), external_media_rtp_udp(), fields_handler(), find_conf_realtime(), find_load_queue_rt_friendly(), find_realtime(), find_realtime_gw(), find_user_realtime(), free_entry(), free_outgoing(), free_user(), function_realtime_read(), function_realtime_readdestroy(), generic_http_callback(), get_insecure_variable_from_sipregs(), 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(), ldap_loadentry(), leave_queue(), load_realtime_musiconhold(), local_ast_moh_start(), manager_free_user(), manager_notify_channel(), manager_notify_endpoint(), manager_notify_uri(), manager_sipnotify(), mkintf(), notify_ami_channel_data_destroy(), notify_ami_data_destroy(), notify_ami_uri_data_destroy(), object_type_loaded_observer(), originate_exec(), 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_handler(), realtime_ldap_base(), realtime_ldap_base_ap(), realtime_ldap_result_to_vars(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_peer_by_addr(), realtime_peer_by_name(), realtime_peer_get_sippeer_helper(), realtime_user(), realtimefield_read(), registration_deleted_observer(), return_sorcery_object(), row_to_varlist(), rt_extend_conf(), session_destructor(), sip_aor_to_ami(), sip_destroy_peer(), sip_pvt_dtor(), 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(), stir_shaken_cli_show(), table_configs_free(), test_sorcery_object_destroy(), test_sorcery_transform(), transport_apply(), update_ldap(), user_destructor(), and vm_allocate_dh().

{
   struct ast_variable *vn;

   while (v) {
      vn = v;
      v = v->next;
      free(vn);
   }
}

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 545 of file main/config.c.

References ast_variable_new, ast_variables_destroy(), ast_variable::file, ast_variable::name, ast_variable::next, NULL, tmp(), and ast_variable::value.

Referenced by action_originate(), ast_ari_callback(), ast_config_copy(), authenticate(), get_insecure_variable_from_sippeers(), get_insecure_variable_from_sipregs(), 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().

{
   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;
}

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 752 of file main/config.c.

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

Referenced by ast_variable_lists_match().

{
   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);
}

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 567 of file main/config.c.

References ast_comment::next, ast_variable::next, NULL, and var.

Referenced by astman_get_variables_order().

{
   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;
}

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 4066 of file main/config.c.

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

Referenced by asterisk_daemon().

{
   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;
}