Sun Aug 6 15:09:50 2006

Asterisk developer's documentation

---

config.c File Reference

Configuration File Parser. More...

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/stat.h>
#include <glob.h>
#include "asterisk.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/options.h"
#include "asterisk/logger.h"
#include "asterisk/utils.h"
#include "asterisk/channel.h"
#include "asterisk/app.h"

Include dependency graph for config.c:

Go to the source code of this file.

Defines
#define	AST_INCLUDE_GLOB   1
#define	COMMENT_END   "--;"
#define	COMMENT_META   ';'
#define	COMMENT_START   ";--"
#define	COMMENT_TAG   '-'
#define	MAX_INCLUDE_LEVEL   10
#define	MAX_NESTED_COMMENTS   128
Functions
static int	append_mapping (char *name, char *driver, char *database, char *table)
void	ast_category_append (struct ast_config *config, struct ast_category *category)
char *	ast_category_browse (struct ast_config *config, const char *prev)
	Goes through categories.
void	ast_category_destroy (struct ast_category *cat)
ast_variable *	ast_category_detach_variables (struct ast_category *cat)
int	ast_category_exist (const struct ast_config *config, const char *category_name)
	Check for category duplicates.
ast_category *	ast_category_get (const struct ast_config *config, const char *category_name)
	Retrieve a category if it exists.
ast_category *	ast_category_new (const char *name)
void	ast_category_rename (struct ast_category *cat, const char *name)
int	ast_check_realtime (const char *family)
	Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists.
void	ast_config_destroy (struct ast_config *cfg)
	Destroys a config.
int	ast_config_engine_deregister (struct ast_config_engine *del)
	Deegister config engine.
int	ast_config_engine_register (struct ast_config_engine *new)
	Register config engine.
ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
ast_config *	ast_config_internal_load (const char *filename, struct ast_config *cfg)
ast_config *	ast_config_load (const char *filename)
	Load a config file.
ast_config *	ast_config_new (void)
void	ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
ast_variable *	ast_load_realtime (const char *family,...)
	Retrieve realtime configuration.
ast_config *	ast_load_realtime_multientry (const char *family,...)
	Retrieve realtime configuration.
	AST_MUTEX_DEFINE_STATIC (config_lock)
int	ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...)
	Update realtime configuration.
void	ast_variable_append (struct ast_category *category, struct ast_variable *variable)
ast_variable *	ast_variable_browse (const struct ast_config *config, const char *category)
	Goes through variables Somewhat similar in intent as the ast_category_browse. List variables of config file category.
ast_variable *	ast_variable_new (const char *name, const char *value)
char *	ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable)
	Gets a variable.
void	ast_variables_destroy (struct ast_variable *v)
	Free variable list.
static struct ast_category *	category_get (const struct ast_config *config, const char *category_name, int ignored)
static void	clear_config_maps (void)
static int	config_command (int fd, int argc, char **argv)
static struct ast_config *	config_text_file_load (const char *database, const char *table, const char *filename, struct ast_config *cfg)
int	config_text_file_save (const char *configfile, const struct ast_config *cfg, const char *generator)
static struct ast_config_engine *	find_engine (const char *family, char *database, int dbsiz, char *table, int tabsiz)
static void	inherit_category (struct ast_category *new, const struct ast_category *base)
static void	move_variables (struct ast_category *old, struct ast_category *new)
static struct ast_category *	next_available_category (struct ast_category *cat)
static int	process_text_line (struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile)
void	read_config_maps (void)
int	register_config_cli ()
static struct ast_variable *	variable_clone (const struct ast_variable *old)
Variables
static struct ast_cli_entry	config_command_struct
static struct ast_config_engine *	config_engine_list
static struct ast_config_map *	config_maps
static char *	extconfig_conf = "extconfig.conf"
static char	show_config_help []
static struct ast_config_engine	text_file_engine

---

Detailed Description

Configuration File Parser.

Includes the Asterisk Realtime API - ARA See README.realtime

Definition in file config.c.

---

Define Documentation

#define AST_INCLUDE_GLOB   1

Definition at line 34 of file config.c.

#define COMMENT_END   "--;"

Definition at line 57 of file config.c.

#define COMMENT_META   ';'

Definition at line 58 of file config.c. Referenced by config_text_file_load().

#define COMMENT_START   ";--"

Definition at line 56 of file config.c.

#define COMMENT_TAG   '-'

Definition at line 59 of file config.c. Referenced by config_text_file_load().

#define MAX_INCLUDE_LEVEL   10

Definition at line 75 of file config.c. Referenced by ast_config_new().

#define MAX_NESTED_COMMENTS   128

Definition at line 55 of file config.c. Referenced by config_text_file_load().

---

Function Documentation

static int append_mapping (  char *  name, char *  driver, char *  database, char *  table )  [static]

Definition at line 758 of file config.c. References ast_verbose(), config_maps, malloc, option_verbose, and VERBOSE_PREFIX_2. Referenced by read_config_maps(). { struct ast_config_map *map; int length; length = sizeof(*map); length += strlen(name) + 1; length += strlen(driver) + 1; length += strlen(database) + 1; if (table) length += strlen(table) + 1; map = malloc(length); if (!map) return -1; memset(map, 0, length); map->name = map->stuff; strcpy(map->name, name); map->driver = map->name + strlen(map->name) + 1; strcpy(map->driver, driver); map->database = map->driver + strlen(map->driver) + 1; strcpy(map->database, database); if (table) { map->table = map->database + strlen(map->database) + 1; strcpy(map->table, table); } map->next = config_maps; if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Binding %s to %s/%s/%s\n", map->name, map->driver, map->database, map->table ? map->table : map->name); config_maps = map; return 0; }

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

Definition at line 240 of file config.c. References ast_config::current, ast_config::last, ast_category::next, and ast_config::root. Referenced by config_odbc(), process_text_line(), realtime_directory(), and realtime_multi_odbc(). { if (config->last) config->last->next = category; else config->root = category; config->last = category; config->current = category; }

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

Goes through categories. Parameters: config  Which config structure you wish to "browse" prev  A pointer to a previous category. This funtion is kind of non-intuitive in it's use. To begin, one passes NULL as the second arguement. 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. Returns a category on success, or NULL on failure/no-more-categories Definition at line 263 of file config.c. References ast_config::last_browse, ast_category::name, ast_category::next, next_available_category(), and ast_config::root. Referenced by authenticate(), complete_sipnotify(), config_load(), find_queue_by_name_rt(), iax_provision_reload(), ind_load_module(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), odbc_load_module(), pbx_load_module(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_queues(), rpt_master(), and set_config(). { 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; if (cat) return cat->name; else return NULL; }

void ast_category_destroy (  struct ast_category *  cat  )

Definition at line 250 of file config.c. References ast_variables_destroy(), free, and ast_category::root. Referenced by process_text_line(), and realtime_multi_odbc(). { ast_variables_destroy(cat->root); free(cat); }

struct ast_variable* ast_category_detach_variables (  struct ast_category *  cat  )

Definition at line 298 of file config.c. Referenced by realtime_switch_common(). { struct ast_variable *v; v = cat->root; cat->root = NULL; return v; }

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

Check for category duplicates. Parameters: config  which config to use category_name  name of the category you're looking for This will search through the categories within a given config file for a match. Return non-zero if found Definition at line 235 of file config.c. References ast_category_get(). { return !!ast_category_get(config, category_name); }

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

Retrieve a category if it exists. Parameters: config  which config to use category_name  name of the category you're looking for This will search through the categories within a given config file for a match. Returns pointer to category if found, NULL if not. Definition at line 230 of file config.c. References category_get(). Referenced by ast_category_exist(), ast_variable_browse(), realtime_directory(), and realtime_switch_common(). { return category_get(config, category_name, 0); }

struct ast_category* ast_category_new (  const char *  name  )

Definition at line 200 of file config.c. References malloc. Referenced by config_odbc(), process_text_line(), realtime_directory(), and realtime_multi_odbc(). { struct ast_category *category; category = malloc(sizeof(struct ast_category)); if (category) { memset(category, 0, sizeof(struct ast_category)); ast_copy_string(category->name, name, sizeof(category->name)); } return category; }

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

Definition at line 308 of file config.c. References ast_category::name. Referenced by realtime_multi_odbc(). { ast_copy_string(cat->name, name, sizeof(cat->name)); }

int ast_check_realtime (  const char *  family  )

Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists. Parameters: family  which family/config to be checked Definition at line 1001 of file config.c. References find_engine(). Referenced by sip_show_settings(). { struct ast_config_engine *eng; eng = find_engine(family, NULL, 0, NULL, 0); if (eng) return 1; return 0; }

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 339 of file config.c. References ast_variables_destroy(), free, ast_category::next, ast_config::root, and ast_category::root. Referenced by adsi_load(), advanced_options(), ast_config_load(), ast_enum_init(), ast_load_resource(), ast_readconfig(), ast_rtp_reload(), authenticate(), conf_exec(), config_load(), directory_exec(), do_reload(), festival_exec(), find_conf(), forward_message(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_realtime_queue(), loadconfigurationfile(), my_load_module(), odbc_load_module(), parse_config(), pbx_load_module(), play_message(), process_text_line(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_queues(), rpt_master(), set_config(), setup_zap(), and tds_load_module(). { struct ast_category *cat, *catn; if (!cfg) return; cat = cfg->root; while(cat) { ast_variables_destroy(cat->root); catn = cat; cat = cat->next; free(catn); } free(cfg); }

int ast_config_engine_deregister (  struct ast_config_engine *  del  )

Deegister config engine. Definition at line 868 of file config.c. References ast_mutex_lock(), ast_mutex_unlock(), last, and ast_config_engine::next. Referenced by unload_module(). { struct ast_config_engine *ptr, *last=NULL; ast_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; } ast_mutex_unlock(&config_lock); return 0; }

int ast_config_engine_register (  struct ast_config_engine *  new  )

Register config engine. Definition at line 849 of file config.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), LOG_NOTICE, ast_config_engine::name, and ast_config_engine::next. Referenced by load_module(). { struct ast_config_engine *ptr; ast_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; } ast_mutex_unlock(&config_lock); ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name); return 1; }

struct ast_category* ast_config_get_current_category (  const struct ast_config *  cfg  )

Definition at line 356 of file config.c. References ast_config::current. Referenced by config_odbc(), and config_text_file_load(). { return cfg->current; }

struct ast_config* ast_config_internal_load (  const char *  filename, struct ast_config *  cfg )

Definition at line 930 of file config.c. References ast_log(), db, extconfig_conf, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, result, and table. Referenced by ast_config_load(), config_odbc(), process_text_line(), and read_config_maps(). { char db[256]; char table[256]; struct ast_config_engine *loader = &text_file_engine; struct ast_config *result; if (cfg->include_level == cfg->max_include_level) { ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level); return NULL; } cfg->include_level++; if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) { struct ast_config_engine *eng; eng = find_engine(filename, db, sizeof(db), table, sizeof(table)); if (eng && eng->load_func) { loader = eng; } else { eng = find_engine("global", db, sizeof(db), table, sizeof(table)); if (eng && eng->load_func) loader = eng; } } result = loader->load_func(db, table, filename, cfg); if (result) result->include_level--; return result; }

struct ast_config* ast_config_load (  const char *  filename  )

Load a config file. Parameters: filename  path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR Create a config structure from a given configuration file. Returns NULL on error, or an ast_config data structure on success Definition at line 967 of file config.c. References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), and result. Referenced by adsi_load(), advanced_options(), ast_enum_init(), ast_load_resource(), ast_readconfig(), ast_rtp_reload(), authenticate(), conf_exec(), config_load(), do_reload(), festival_exec(), find_conf(), forward_message(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), my_load_module(), odbc_load_module(), parse_config(), pbx_load_module(), play_message(), privacy_exec(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_queues(), rpt_master(), set_config(), setup_zap(), and tds_load_module(). { struct ast_config *cfg; struct ast_config *result; cfg = ast_config_new(); if (!cfg) return NULL; result = ast_config_internal_load(filename, cfg); if (!result) ast_config_destroy(cfg); return result; }

struct ast_config* ast_config_new (  void   )

Definition at line 326 of file config.c. References config, malloc, and MAX_INCLUDE_LEVEL. Referenced by ast_config_load(), read_config_maps(), and realtime_multi_odbc(). { struct ast_config *config; config = malloc(sizeof(*config)); if (config) { memset(config, 0, sizeof(*config)); config->max_include_level = MAX_INCLUDE_LEVEL; } return config; }

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

Definition at line 361 of file config.c. References ast_config::current. { /* cast below is just to silence compiler warning about dropping "const" */ cfg->current = (struct ast_category *) cat; }

struct ast_variable* ast_load_realtime (  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. Note that unlike the variables in ast_config, the resulting list of variables MUST be fred with ast_free_runtime() as there is no container. Definition at line 983 of file config.c. References db, find_engine(), ast_config_engine::realtime_func, and table. Referenced by cli_load_realtime(), find_user_realtime(), load_realtime_queue(), realtime_exec(), realtime_peer(), realtime_switch_common(), and realtime_user(). { struct ast_config_engine *eng; char db[256]=""; char table[256]=""; struct ast_variable *res=NULL; va_list ap; va_start(ap, family); eng = find_engine(family, db, sizeof(db), table, sizeof(table)); if (eng && eng->realtime_func) res = eng->realtime_func(db, table, ap); va_end(ap); return res; }

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 taditional ast_config structure rather than just returning a linked list of variables. Definition at line 1012 of file config.c. References db, find_engine(), ast_config_engine::realtime_multi_func, and table. Referenced by load_realtime_queue(), realtime_directory(), and realtime_switch_common(). { struct ast_config_engine *eng; char db[256]=""; char table[256]=""; struct ast_config *res=NULL; va_list ap; va_start(ap, family); eng = find_engine(family, db, sizeof(db), table, sizeof(table)); if (eng && eng->realtime_multi_func) res = eng->realtime_multi_func(db, table, ap); va_end(ap); return res; }

AST_MUTEX_DEFINE_STATIC (  config_lock   )

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. Definition at line 1029 of file config.c. References db, find_engine(), table, and ast_config_engine::update_func. Referenced by change_password_realtime(), cli_update_realtime(), destroy_association(), realtime_update_exec(), and realtime_update_peer(). { struct ast_config_engine *eng; int res = -1; char db[256]=""; char table[256]=""; va_list ap; va_start(ap, lookup); eng = find_engine(family, db, sizeof(db), table, sizeof(table)); if (eng && eng->update_func) res = eng->update_func(db, table, keyfield, lookup, ap); va_end(ap); return res; }

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

Definition at line 116 of file config.c. References ast_category::last, ast_variable::next, and ast_category::root. Referenced by config_odbc(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), and realtime_multi_odbc(). { if (category->last) category->last->next = variable; else category->root = variable; category->last = variable; }

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

Goes through variables Somewhat similar in intent as the ast_category_browse. List variables of config file category. Returns ast_variable list on success, or NULL on failure Definition at line 136 of file config.c. References ast_category_get(), ast_config::last_browse, ast_category::name, and ast_category::root. Referenced by adsi_load(), ast_enum_init(), ast_readconfig(), ast_variable_retrieve(), authenticate(), collect_function_digits(), conf_exec(), do_directory(), find_conf(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_logger_chain(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), odbc_load_module(), osp_build(), parse_config(), pbx_load_module(), process_my_load_module(), read_agent_config(), read_config_maps(), reload_config(), reload_queues(), rpt_master(), set_config(), setup_zap(), sip_notify(), store_config(), and tds_load_module(). { 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); if (cat) return cat->root; else return NULL; }

struct ast_variable* ast_variable_new (  const char *  name, const char *  value )

Definition at line 99 of file config.c. References malloc. Referenced by apply_outgoing(), astman_get_variables(), build_peer(), build_user(), check_access(), check_user_full(), config_odbc(), launch_page(), process_text_line(), realtime_directory(), realtime_multi_odbc(), realtime_odbc(), and variable_clone(). { struct ast_variable *variable; int length = strlen(name) + strlen(value) + 2 + sizeof(struct ast_variable); variable = malloc(length); if (variable) { memset(variable, 0, length); variable->name = variable->stuff; variable->value = variable->stuff + strlen(name) + 1; strcpy(variable->name,name); strcpy(variable->value,value); } return variable; }

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

Gets a variable. Parameters: config  which (opened) config to use category  category under which the variable lies variable  which variable you wish to get the data for Goes through a given config file in the given category and searches for the given variable Returns the variable value on success, or NULL if unable to find it. Definition at line 151 of file config.c. References ast_variable_browse(), ast_variable::name, ast_variable::next, ast_category::next, ast_category::root, and ast_variable::value. Referenced by __load_resource(), advanced_options(), ast_rtp_reload(), attempt_reconnect(), authenticate(), config_load(), directory_exec(), do_reload(), festival_exec(), find_queue_by_name_rt(), forward_message(), function_ilink(), function_remote(), get_wait_interval(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), odbc_load_module(), pbx_load_module(), play_message(), privacy_exec(), process_my_load_module(), read_agent_config(), realtime_directory(), reload_config(), reload_queues(), retrieve_astcfgint(), rpt(), rpt_exec(), rpt_master(), rpt_tele_thread(), set_config(), tds_load_module(), and telem_lookup(). { 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; }

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 125 of file config.c. References free, and ast_variable::next. Referenced by __sip_destroy(), ast_category_destroy(), ast_config_destroy(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), build_peer(), destroy_user(), find_user_realtime(), iax2_destroy(), load_realtime_queue(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), and unload_module(). { struct ast_variable *vn; while(v) { vn = v; v = v->next; free(vn); } }

static struct ast_category* category_get (  const struct ast_config *  config, const char *  category_name, int  ignored )  [static]

Definition at line 213 of file config.c. References ast_category::ignored, ast_category::name, ast_category::next, and ast_config::root. Referenced by ast_category_get(), and process_text_line(). { struct ast_category *cat; for (cat = config->root; cat; cat = cat->next) { if (cat->name == category_name && (ignored || !cat->ignored)) return cat; } for (cat = config->root; cat; cat = cat->next) { if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored)) return cat; } return NULL; }

static void clear_config_maps (  void   )  [static]

Definition at line 743 of file config.c. References ast_mutex_lock(), ast_mutex_unlock(), config_maps, free, and ast_config_map::next. Referenced by read_config_maps(). { struct ast_config_map *map; ast_mutex_lock(&config_lock); while (config_maps) { map = config_maps; config_maps = config_maps->next; free(map); } ast_mutex_unlock(&config_lock); }

static int config_command (  int  fd, int  argc, char **  argv )  [static]

Definition at line 1046 of file config.c. References ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), config_maps, ast_config_map::database, ast_config_map::driver, ast_config_map::name, ast_config_engine::name, ast_config_map::next, ast_config_engine::next, and ast_config_map::table. { struct ast_config_engine *eng; struct ast_config_map *map; ast_mutex_lock(&config_lock); ast_cli(fd, "\n\n"); for (eng = config_engine_list; eng; eng = eng->next) { ast_cli(fd, "\nConfig Engine: %s\n", eng->name); for (map = config_maps; map; map = map->next) if (!strcasecmp(map->driver, eng->name)) { ast_cli(fd, "===> %s (db=%s, table=%s)\n", map->name, map->database, map->table ? map->table : map->name); } } ast_cli(fd,"\n\n"); ast_mutex_unlock(&config_lock); return 0; }

static struct ast_config* config_text_file_load (  const char *  database, const char *  table, const char *  filename, struct ast_config *  cfg )  [static]

Definition at line 532 of file config.c. References ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_log(), ast_strlen_zero(), ast_verbose(), COMMENT_META, COMMENT_TAG, LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, option_debug, option_verbose, process_text_line(), and VERBOSE_PREFIX_2. { char fn[256]; char buf[8192]; char *new_buf, *comment_p, *process_buf; FILE *f; int lineno=0; int comment = 0, nest[MAX_NESTED_COMMENTS]; struct ast_category *cat = NULL; int count = 0; struct stat statbuf; cat = ast_config_get_current_category(cfg); if (filename[0] == '/') { ast_copy_string(fn, filename, sizeof(fn)); } else { snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, filename); } #ifdef AST_INCLUDE_GLOB { int glob_ret; glob_t globbuf; globbuf.gl_offs = 0; /* initialize it to silence gcc */ #ifdef SOLARIS glob_ret = glob(fn, GLOB_NOCHECK, NULL, &globbuf); #else glob_ret = glob(fn, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf); #endif if (glob_ret == GLOB_NOSPACE) ast_log(LOG_WARNING, "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn); else if (glob_ret == GLOB_ABORTED) ast_log(LOG_WARNING, "Glob Expansion of pattern '%s' failed: Read error\n", fn); else { /* loop over expanded files */ int i; for (i=0; i<globbuf.gl_pathc; i++) { ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn)); #endif do { if (stat(fn, &statbuf)) continue; if (!S_ISREG(statbuf.st_mode)) { ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn); continue; } if ((option_verbose > 1) && !option_debug) { ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn); fflush(stdout); } if (!(f = fopen(fn, "r"))) { if (option_debug) ast_log(LOG_DEBUG, "No file to parse: %s\n", fn); else if (option_verbose > 1) ast_verbose( "Not found (%s)\n", strerror(errno)); continue; } count++; if (option_debug) ast_log(LOG_DEBUG, "Parsing %s\n", fn); else if (option_verbose > 1) ast_verbose("Found\n"); while(!feof(f)) { lineno++; if (fgets(buf, sizeof(buf), f)) { new_buf = buf; if (comment) process_buf = NULL; else process_buf = buf; while ((comment_p = strchr(new_buf, COMMENT_META))) { if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) { /* Yuck, gotta memmove */ memmove(comment_p - 1, comment_p, strlen(comment_p) + 1); new_buf = comment_p; } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) { /* Meta-Comment start detected ";--" */ if (comment < MAX_NESTED_COMMENTS) { *comment_p = '\0'; new_buf = comment_p + 3; comment++; nest[comment-1] = lineno; } else { ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS); } } else if ((comment_p >= new_buf + 2) && (*(comment_p - 1) == COMMENT_TAG) && (*(comment_p - 2) == COMMENT_TAG)) { /* Meta-Comment end detected */ comment--; new_buf = comment_p + 1; if (!comment) { /* Back to non-comment now */ if (process_buf) { /* Actually have to move what's left over the top, then continue */ char *oldptr; oldptr = process_buf + strlen(process_buf); memmove(oldptr, new_buf, strlen(new_buf) + 1); new_buf = oldptr; } else process_buf = new_buf; } } else { if (!comment) { /* If ; is found, and we are not nested in a comment, we immediately stop all comment processing */ *comment_p = '\0'; new_buf = comment_p; } else new_buf = comment_p + 1; } } if (process_buf) { char *buf = ast_strip(process_buf); if (!ast_strlen_zero(buf)) { if (process_text_line(cfg, &cat, buf, lineno, filename)) { cfg = NULL; break; } } } } } fclose(f); } while(0); if (comment) { ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment]); } #ifdef AST_INCLUDE_GLOB if (!cfg) break; } globfree(&globbuf); } } #endif if (count == 0) return NULL; return cfg; }

int config_text_file_save (  const char *  configfile, const struct ast_config *  cfg, const char *  generator )

Definition at line 678 of file config.c. References ast_config_AST_CONFIG_DIR, ast_verbose(), ast_variable::blanklines, ast_comment::cmt, ast_category::name, ast_variable::name, ast_variable::next, ast_category::next, ast_variable::object, option_debug, option_verbose, ast_config::root, ast_category::root, ast_variable::sameline, t, ast_variable::value, var, and VERBOSE_PREFIX_2. { FILE *f; char fn[256]; char date[256]=""; time_t t; struct ast_variable *var; struct ast_category *cat; int blanklines = 0; if (configfile[0] == '/') { ast_copy_string(fn, configfile, sizeof(fn)); } else { snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile); } time(&t); ast_copy_string(date, ctime(&t), sizeof(date)); #ifdef __CYGWIN__ if ((f = fopen(fn, "w+"))) { #else if ((f = fopen(fn, "w"))) { #endif if ((option_verbose > 1) && !option_debug) ast_verbose( VERBOSE_PREFIX_2 "Saving '%s': ", fn); fprintf(f, ";!\n"); fprintf(f, ";! Automatically generated configuration file\n"); fprintf(f, ";! Filename: %s (%s)\n", configfile, fn); fprintf(f, ";! Generator: %s\n", generator); fprintf(f, ";! Creation Date: %s", date); fprintf(f, ";!\n"); cat = cfg->root; while(cat) { /* Dump section with any appropriate comment */ fprintf(f, "[%s]\n", cat->name); var = cat->root; while(var) { if (var->sameline) fprintf(f, "%s %s %s ; %s\n", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt); else fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value); if (var->blanklines) { blanklines = var->blanklines; while (blanklines--) fprintf(f, "\n"); } var = var->next; } #if 0 /* Put an empty line */ fprintf(f, "\n"); #endif cat = cat->next; } } else { if (option_debug) printf("Unable to open for writing: %s\n", fn); else if (option_verbose > 1) printf( "Unable to write (%s)", strerror(errno)); return -1; } fclose(f); return 0; }

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

Definition at line 891 of file config.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_maps, ast_config_map::database, ast_config_map::driver, LOG_WARNING, ast_config_engine::name, ast_config_map::name, ast_config_engine::next, ast_config_map::next, and ast_config_map::table. Referenced by ast_check_realtime(), ast_config_internal_load(), ast_load_realtime(), ast_load_realtime_multientry(), and ast_update_realtime(). { struct ast_config_engine *eng, *ret = NULL; struct ast_config_map *map; ast_mutex_lock(&config_lock); for (map = config_maps; map; map = map->next) { if (!strcasecmp(family, map->name)) { if (database) ast_copy_string(database, map->database, dbsiz); if (table) ast_copy_string(table, map->table ? map->table : family, tabsiz); break; } } /* Check if the required driver (engine) exist */ if (map) { for (eng = config_engine_list; !ret && eng; eng = eng->next) { if (!strcasecmp(eng->name, map->driver)) ret = eng; } } ast_mutex_unlock(&config_lock); /* if we found a mapping, but the engine is not available, then issue a warning */ if (map && !ret) ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver); return ret; }

static void inherit_category (  struct ast_category *  new, const struct ast_category *  base )  [static]

Definition at line 313 of file config.c. References ast_variable_append(), ast_variable::next, ast_category::root, var, and variable_clone(). Referenced by process_text_line(). { struct ast_variable *var; for (var = base->root; var; var = var->next) { struct ast_variable *v; v = variable_clone(var); if (v) ast_variable_append(new, v); } }

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

Definition at line 186 of file config.c. References ast_variable_append(), ast_variable::next, and var. Referenced by process_text_line(). { struct ast_variable *var; struct ast_variable *next; next = old->root; old->root = NULL; for (var = next; var; var = next) { next = var->next; var->next = NULL; ast_variable_append(new, var); } }

static struct ast_category* next_available_category (  struct ast_category *  cat  )  [static]

Definition at line 256 of file config.c. References ast_category::ignored, and ast_category::next. Referenced by ast_category_browse(). { for (; cat && cat->ignored; cat = cat->next); return cat; }

static int process_text_line (  struct ast_config *  cfg, struct ast_category **  cat, char *  buf, int  lineno, const char *  configfile )  [static]

Definition at line 367 of file config.c. References ast_category_append(), ast_category_destroy(), ast_category_new(), ast_config_destroy(), ast_config_internal_load(), ast_log(), ast_safe_system(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), ast_variable::blanklines, category_get(), inherit_category(), ast_variable::lineno, LOG_WARNING, move_variables(), ast_variable::object, option_exec_includes, and strsep(). Referenced by config_text_file_load(). { char *c; char *cur = buf; struct ast_variable *v; char cmd[512], exec_file[512]; int object, do_exec, do_include; /* Actually parse the entry */ if (cur[0] == '[') { struct ast_category *newcat = NULL; char *catname; /* A category header */ c = strchr(cur, ']'); if (!c) { ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile); return -1; } *c++ = '\0'; cur++; if (*c++ != '(') c = NULL; catname = cur; *cat = newcat = ast_category_new(catname); if (!newcat) { ast_log(LOG_WARNING, "Out of memory, line %d of %s\n", lineno, configfile); return -1; } /* If there are options or categories to inherit from, process them now */ if (c) { if (!(cur = strchr(c, ')'))) { ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile); return -1; } *cur = '\0'; while ((cur = strsep(&c, ","))) { if (!strcasecmp(cur, "!")) { (*cat)->ignored = 1; } else if (!strcasecmp(cur, "+")) { *cat = category_get(cfg, catname, 1); if (!*cat) { ast_config_destroy(cfg); if (newcat) ast_category_destroy(newcat); ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile); return -1; } if (newcat) { move_variables(newcat, *cat); ast_category_destroy(newcat); newcat = NULL; } } else { struct ast_category *base; base = category_get(cfg, cur, 1); if (!base) { ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile); return -1; } inherit_category(*cat, base); } } } if (newcat) ast_category_append(cfg, *cat); } else if (cur[0] == '#') { /* A directive */ cur++; c = cur; while(*c && (*c > 32)) c++; if (*c) { *c = '\0'; c++; /* Find real argument */ while(*c && (*c < 33)) c++; if (!*c) c = NULL; } else c = NULL; do_include = !strcasecmp(cur, "include"); if(!do_include) do_exec = !strcasecmp(cur, "exec"); else do_exec = 0; if (do_exec && !option_exec_includes) { ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n"); do_exec = 0; } if (do_include || do_exec) { if (c) { /* Strip off leading and trailing "'s and <>'s */ while((*c == '<') || (*c == '>') || (*c == '\"')) c++; /* Get rid of leading mess */ cur = c; while (!ast_strlen_zero(cur)) { c = cur + strlen(cur) - 1; if ((*c == '>') || (*c == '<') || (*c == '\"')) *c = '\0'; else break; } /* #exec </path/to/executable> We create a tmp file, then we #include it, then we delete it. */ if (do_exec) { snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self()); snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file); ast_safe_system(cmd); cur = exec_file; } else exec_file[0] = '\0'; /* A #include */ do_include = ast_config_internal_load(cur, cfg) ? 1 : 0; if(!ast_strlen_zero(exec_file)) unlink(exec_file); if(!do_include) return 0; } else { ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n", do_exec ? "exec" : "include", do_exec ? "/path/to/executable" : "filename", lineno, configfile); } } else ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile); } else { /* Just a line (variable = value) */ if (!*cat) { ast_log(LOG_WARNING, "parse error: No category context for line %d of %s\n", lineno, configfile); return -1; } c = strchr(cur, '='); if (c) { *c = 0; c++; /* Ignore > in => */ if (*c== '>') { object = 1; c++; } else object = 0; v = ast_variable_new(ast_strip(cur), ast_strip(c)); if (v) { v->lineno = lineno; v->object = object; /* Put and reset comments */ v->blanklines = 0; ast_variable_append(*cat, v); } else { ast_log(LOG_WARNING, "Out of memory, line %d\n", lineno); return -1; } } else { ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile); } } return 0; }

void read_config_maps (  void   )

Definition at line 795 of file config.c. References append_mapping(), ast_config_destroy(), ast_config_internal_load(), ast_config_new(), ast_log(), ast_variable_browse(), clear_config_maps(), config, extconfig_conf, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, strsep(), table, and ast_variable::value. Referenced by ast_module_reload(), and main(). { struct ast_config *config, *configtmp; struct ast_variable *v; char *driver, *table, *database, *stringp; clear_config_maps(); configtmp = ast_config_new(); configtmp->max_include_level = 1; config = ast_config_internal_load(extconfig_conf, configtmp); if (!config) { ast_config_destroy(configtmp); return; } for (v = ast_variable_browse(config, "settings"); v; v = v->next) { stringp = v->value; driver = strsep(&stringp, ","); database = strsep(&stringp, ","); table = strsep(&stringp, ","); if (!strcmp(v->name, extconfig_conf)) { ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf); continue; } if (!strcmp(v->name, "asterisk.conf")) { ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n"); continue; } if (!strcmp(v->name, "logger.conf")) { ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n"); continue; } if (!driver || !database) continue; if (!strcasecmp(v->name, "sipfriends")) { ast_log(LOG_WARNING, "The 'sipfriends' table is obsolete, update your config to use sipusers and sippeers, though they can point to the same table.\n"); append_mapping("sipusers", driver, database, table ? table : "sipfriends"); append_mapping("sippeers", driver, database, table ? table : "sipfriends"); } else if (!strcasecmp(v->name, "iaxfriends")) { ast_log(LOG_WARNING, "The 'iaxfriends' table is obsolete, update your config to use iaxusers and iaxpeers, though they can point to the same table.\n"); append_mapping("iaxusers", driver, database, table ? table : "iaxfriends"); append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends"); } else append_mapping(v->name, driver, database, table); } ast_config_destroy(config); }

int register_config_cli (  void   )

Definition at line 1077 of file config.c. References ast_cli_register(). Referenced by main(). { return ast_cli_register(&config_command_struct); }

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

Definition at line 172 of file config.c. References ast_variable_new(), ast_variable::blanklines, ast_variable::lineno, ast_variable::name, ast_variable::object, and ast_variable::value. Referenced by inherit_category(). { struct ast_variable *new = ast_variable_new(old->name, old->value); if (new) { new->lineno = old->lineno; new->object = old->object; new->blanklines = old->blanklines; /* TODO: clone comments? */ } return new; }

---

Variable Documentation

struct ast_cli_entry config_command_struct [static]

Initial value: { { "show", "config", "mappings", NULL }, config_command, "Show Config mappings (file names to config engines)", show_config_help, NULL } Definition at line 1073 of file config.c.

struct ast_config_engine* config_engine_list [static]

Definition at line 73 of file config.c.

struct ast_config_map * config_maps [static]

Referenced by append_mapping(), clear_config_maps(), config_command(), and find_engine().

char* extconfig_conf = "extconfig.conf" [static]

Definition at line 61 of file config.c. Referenced by ast_config_internal_load(), and read_config_maps().

char show_config_help[] [static]

Initial value: "Usage: show config mappings\n" " Shows the filenames to config engines.\n" Definition at line 1069 of file config.c.

struct ast_config_engine text_file_engine [static]

Initial value: { .name = "text", .load_func = config_text_file_load, } Definition at line 925 of file config.c.

---