config.c File Reference

Configuration File Parser. More...

#include "asterisk.h"
#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/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.

Data Structures
struct	ast_category
struct	ast_category::template_instance_list
struct	ast_category_template_instance
struct	ast_comment
	Structure to keep comments for rewriting configuration files. More...
struct	ast_config
struct	ast_config_map
Defines
#define	AST_INCLUDE_GLOB   1
#define	CB_INCR   250
#define	COMMENT_END   "--;"
#define	COMMENT_META   ';'
#define	COMMENT_START   ";--"
#define	COMMENT_TAG   '-'
#define	MAX_INCLUDE_LEVEL   10
#define	MAX_NESTED_COMMENTS   128
Functions
static struct ast_comment *	ALLOC_COMMENT (const char *buffer)
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.
int	ast_category_delete (struct ast_config *cfg, char *category)
void	ast_category_destroy (struct ast_category *cat)
struct 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.
struct ast_category *	ast_category_get (const struct ast_config *config, const char *category_name)
	Retrieve a category if it exists.
struct ast_category *	ast_category_new (const char *name)
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
int	ast_check_realtime (const char *family)
	Check if realtime engine is configured for family.
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.
struct ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
struct ast_config *	ast_config_internal_load (const char *filename, struct ast_config *cfg, int withcomments)
struct ast_config *	ast_config_load (const char *filename)
	Load a config file.
struct ast_config *	ast_config_load_with_comments (const char *filename)
struct ast_config *	ast_config_new (void)
const char *	ast_config_option (struct ast_config *cfg, const char *cat, const char *var)
void	ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
static void	ast_destroy_comment (struct ast_comment **comment)
static void	ast_destroy_comments (struct ast_category *cat)
static void	ast_destroy_template_list (struct ast_category *cat)
struct ast_variable *	ast_load_realtime (const char *family,...)
	Retrieve realtime configuration.
struct ast_config *	ast_load_realtime_multientry (const char *family,...)
	Retrieve realtime configuration.
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)
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.
int	ast_variable_delete (struct ast_category *category, char *variable, char *match)
struct ast_variable *	ast_variable_new (const char *name, const char *value)
const char *	ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable)
	Gets a variable.
int	ast_variable_update (struct ast_category *category, const char *variable, const char *value, const char *match, unsigned int object)
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	CB_ADD (char **comment_buffer, int *comment_buffer_size, char *str)
static void	CB_ADD_LEN (char **comment_buffer, int *comment_buffer_size, char *str, int len)
static void	CB_INIT (char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size)
static void	CB_RESET (char **comment_buffer, char **lline_buffer)
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 withcomments)
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)
	Find realtime engine for realtime family.
static void	inherit_category (struct ast_category *new, const struct ast_category *base)
static void	LLB_ADD (char **lline_buffer, int *lline_buffer_size, char *str)
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, int withcomments, char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size)
int	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	cli_config []
static struct ast_cli_entry	cli_show_config_mappings_deprecated
static struct ast_config_engine *	config_engine_list
static ast_mutex_t	config_lock = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER )
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.

Author:

Mark Spencer <markster@digium.com>

Includes the Asterisk Realtime API - ARA See doc/realtime.txt and doc/extconfig.txt

Definition in file config.c.

---

Define Documentation

#define AST_INCLUDE_GLOB   1

Definition at line 40 of file config.c.

#define CB_INCR   250

Definition at line 69 of file config.c.

Referenced by CB_ADD(), CB_ADD_LEN(), CB_INIT(), and LLB_ADD().

#define COMMENT_END   "--;"

Definition at line 56 of file config.c.

#define COMMENT_META   ';'

Definition at line 57 of file config.c.

Referenced by config_text_file_load().

#define COMMENT_START   ";--"

Definition at line 55 of file config.c.

#define COMMENT_TAG   '-'

Definition at line 58 of file config.c.

Referenced by config_text_file_load().

#define MAX_INCLUDE_LEVEL   10

Definition at line 157 of file config.c.

Referenced by ast_config_new().

#define MAX_NESTED_COMMENTS   128

Definition at line 54 of file config.c.

Referenced by config_text_file_load().

---

Function Documentation

static struct ast_comment* ALLOC_COMMENT

(

const char *

buffer

)

[static, read]

Definition at line 137 of file config.c.

References ast_calloc, and ast_comment::cmt.

Referenced by process_text_line().

{ 
   struct ast_comment *x = ast_calloc(1,sizeof(struct ast_comment)+strlen(buffer)+1);
   strcpy(x->cmt, buffer);
   return x;
}

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

Definition at line 1161 of file config.c.

References ast_calloc, ast_verbose(), config_maps, ast_config_map::database, ast_config_map::driver, map, ast_config_map::name, ast_config_map::next, option_verbose, ast_config_map::stuff, ast_config_map::table, 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;

   if (!(map = ast_calloc(1, length)))
      return -1;

   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 340 of file config.c.

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

Referenced by config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_odbc(), and realtime_multi_pgsql().

{
   if (config->last)
      config->last->next = category;
   else
      config->root = category;
   category->include_level = config->include_level;
   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 402 of file config.c.

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

Referenced by __queues_show(), action_getconfig(), aji_load_config(), authenticate(), complete_sipnotify(), do_directory(), find_queue_by_name_rt(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), init_manager(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), odbc_load_module(), osp_load(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_peer(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), 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;
}

int ast_category_delete	(	struct ast_config *	cfg,
		char *	category
	)

Definition at line 557 of file config.c.

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

Referenced by handle_updates().

{
   struct ast_category *prev=NULL, *cat;
   cat = cfg->root;
   while(cat) {
      if (cat->name == category) {
         if (prev) {
            prev->next = cat->next;
            if (cat == cfg->last)
               cfg->last = prev;
         } else {
            cfg->root = cat->next;
            if (cat == cfg->last)
               cfg->last = NULL;
         }
         ast_category_destroy(cat);
         return 0;
      }
      prev = cat;
      cat = cat->next;
   }

   prev = NULL;
   cat = cfg->root;
   while(cat) {
      if (!strcasecmp(cat->name, category)) {
         if (prev) {
            prev->next = cat->next;
            if (cat == cfg->last)
               cfg->last = prev;
         } else {
            cfg->root = cat->next;
            if (cat == cfg->last)
               cfg->last = NULL;
         }
         ast_category_destroy(cat);
         return 0;
      }
      prev = cat;
      cat = cat->next;
   }
   return -1;
}

void ast_category_destroy

(

struct ast_category *

cat

)

Definition at line 379 of file config.c.

References ast_destroy_comments(), ast_destroy_template_list(), ast_variables_destroy(), free, and ast_category::root.

Referenced by ast_category_delete(), ast_config_destroy(), process_text_line(), and realtime_multi_odbc().

{
   ast_variables_destroy(cat->root);
   ast_destroy_comments(cat);
   ast_destroy_template_list(cat);
   free(cat);
}

struct ast_variable* ast_category_detach_variables

(

struct ast_category *

cat

)

[read]

Definition at line 434 of file config.c.

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

Referenced by realtime_switch_common().

{
   struct ast_variable *v;

   v = cat->root;
   cat->root = NULL;
   cat->last = 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 335 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
	)			[read]

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 330 of file config.c.

References category_get().

Referenced by ast_category_exist(), ast_category_root(), ast_variable_browse(), handle_updates(), realtime_directory(), realtime_switch_common(), vm_change_password(), and vm_forwardoptions().

{
   return category_get(config, category_name, 0);
}

struct ast_category* ast_category_new

(

const char *

name

)

[read]

Definition at line 303 of file config.c.

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

Referenced by config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_odbc(), and realtime_multi_pgsql().

{
   struct ast_category *category;

   if ((category = ast_calloc(1, sizeof(*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 445 of file config.c.

References ast_copy_string(), and ast_category::name.

Referenced by handle_updates(), realtime_multi_odbc(), and realtime_multi_pgsql().

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

struct ast_variable* ast_category_root	(	struct ast_config *	config,
		char *	cat
	)			[read]

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 394 of file config.c.

References ast_category_get(), and ast_category::root.

Referenced by realtime_peer().

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

int ast_check_realtime

(

const char *

family

)

Check if realtime engine is configured for family.

Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists.

Definition at line 1435 of file config.c.

References find_engine().

Referenced by __queues_show(), _sip_show_peer(), _sip_show_peers(), and 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 601 of file config.c.

References ast_category_destroy(), free, ast_category::next, and ast_config::root.

Referenced by __ast_http_load(), __queues_show(), action_getconfig(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_config_load(), ast_config_load_with_comments(), ast_enum_init(), ast_plc_reload(), ast_readconfig(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_realtime_queue(), load_rpt_vars(), loadconfigurationfile(), make_email_file(), my_load_module(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), privacy_exec(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_peer(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().

{
   struct ast_category *cat, *catn;

   if (!cfg)
      return;

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

int ast_config_engine_deregister

(

struct ast_config_engine *

del

)

Deegister config engine.

Definition at line 1283 of file config.c.

References ast_mutex_lock(), ast_mutex_unlock(), config_lock, 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 1264 of file config.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_lock, LOG_NOTICE, 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

)

[read]

Definition at line 617 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,
		int	withcomments
	)			[read]

Definition at line 1345 of file config.c.

References ast_log(), db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, and table.

Referenced by ast_config_load(), ast_config_load_with_comments(), config_odbc(), config_pgsql(), 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; 

   /* 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 (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, withcomments);

   if (result)
      result->include_level--;
   else
      cfg->include_level--;

   return result;
}

struct ast_config* ast_config_load

(

const char *

filename

)

[read]

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 1385 of file config.c.

References ast_config_destroy(), ast_config_internal_load(), and ast_config_new().

Referenced by __ast_http_load(), __say_init(), adsi_load(), advanced_options(), aji_load_config(), ast_enum_init(), ast_plc_reload(), ast_readconfig(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), make_email_file(), my_load_module(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), privacy_exec(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), tds_load_module(), and vm_forwardoptions().

{
   struct ast_config *cfg;
   struct ast_config *result;

   cfg = ast_config_new();
   if (!cfg)
      return NULL;

   result = ast_config_internal_load(filename, cfg, 0);
   if (!result)
      ast_config_destroy(cfg);

   return result;
}

struct ast_config* ast_config_load_with_comments

(

const char *

filename

)

[read]

Definition at line 1401 of file config.c.

References ast_config_destroy(), ast_config_internal_load(), and ast_config_new().

Referenced by action_getconfig(), action_updateconfig(), and vm_change_password().

{
   struct ast_config *cfg;
   struct ast_config *result;

   cfg = ast_config_new();
   if (!cfg)
      return NULL;

   result = ast_config_internal_load(filename, cfg, 1);
   if (!result)
      ast_config_destroy(cfg);

   return result;
}

struct ast_config* ast_config_new

(

void

)

[read]

Definition at line 461 of file config.c.

References ast_calloc, config, MAX_INCLUDE_LEVEL, and ast_config::max_include_level.

Referenced by ast_config_load(), ast_config_load_with_comments(), read_config_maps(), realtime_multi_odbc(), and realtime_multi_pgsql().

{
   struct ast_config *config;

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

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

Definition at line 241 of file config.c.

References ast_variable_retrieve().

Referenced by do_directory(), load_config(), and pbx_load_users().

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

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

Definition at line 622 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;
}

static void ast_destroy_comment

(

struct ast_comment **

comment

)

[static]

Definition at line 351 of file config.c.

References free, and ast_comment::next.

Referenced by ast_destroy_comments(), and ast_variables_destroy().

{
   struct ast_comment *n, *p;

   for (p = *comment; p; p = n) {
      n = p->next;
      free(p);
   }

   *comment = NULL;
}

static void ast_destroy_comments

(

struct ast_category *

cat

)

[static]

Definition at line 363 of file config.c.

References ast_destroy_comment(), ast_category::precomments, and ast_category::sameline.

Referenced by ast_category_destroy().

{
   ast_destroy_comment(&cat->precomments);
   ast_destroy_comment(&cat->sameline);
}

static void ast_destroy_template_list

(

struct ast_category *

cat

)

[static]

Definition at line 369 of file config.c.

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, free, and ast_category::template_instances.

Referenced by ast_category_destroy().

{
   struct ast_category_template_instance *x;
   AST_LIST_TRAVERSE_SAFE_BEGIN(&cat->template_instances, x, next) {
      AST_LIST_REMOVE_CURRENT(&cat->template_instances, next);
      free(x);
   }
   AST_LIST_TRAVERSE_SAFE_END;
}

struct ast_variable* ast_load_realtime	(	const char *	family,
			...
	)			[read]

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 freed with ast_variables_destroy() as there is no container.

Definition at line 1417 of file config.c.

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

Referenced by cli_realtime_load(), find_conf_realtime(), find_user_realtime(), function_realtime_read(), load_realtime_queue(), queue_function_queuewaitingcount(), realtime_alias(), realtime_exec(), realtime_peer(), realtime_switch_common(), realtime_user(), and update_realtime_member_field().

{
   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,
			...
	)			[read]

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 1446 of file config.c.

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

Referenced by __queues_show(), load_realtime_queue(), realtime_directory(), realtime_peer(), realtime_switch_common(), and update_realtime_members().

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

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.

Definition at line 1463 of file config.c.

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

Referenced by change_password_realtime(), cli_realtime_update(), conf_run(), destroy_association(), function_realtime_write(), handle_response_peerpoke(), realtime_update_exec(), realtime_update_peer(), sip_poke_noanswer(), and update_realtime_member_field().

{
   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 203 of file config.c.

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

Referenced by config_odbc(), config_pgsql(), handle_updates(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_odbc(), realtime_multi_pgsql(), and vm_change_password().

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

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

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 229 of file config.c.

References ast_category_get(), ast_config::last_browse, ast_category::name, and ast_category::root.

Referenced by __ast_http_load(), action_getconfig(), adsi_load(), aji_load_config(), ast_enum_init(), ast_plc_reload(), ast_readconfig(), ast_variable_retrieve(), authenticate(), check_tx_freq(), collect_function_digits(), conf_exec(), do_directory(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), process_my_load_module(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queues(), set_config(), setup_dahdi(), sip_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), 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);

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

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

Definition at line 470 of file config.c.

References ast_strlen_zero(), ast_variables_destroy(), ast_category::last, ast_variable::name, ast_variable::next, ast_category::root, and ast_variable::value.

Referenced by handle_updates().

{
   struct ast_variable *cur, *prev=NULL, *curn;
   int res = -1;
   cur = category->root;
   while (cur) {
      if (cur->name == variable) {
         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;
         }
         cur->next = NULL;
         ast_variables_destroy(cur);
         return 0;
      }
      prev = cur;
      cur = cur->next;
   }

   prev = NULL;
   cur = category->root;
   while (cur) {
      curn = cur->next;
      if (!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;
         }
         cur->next = NULL;
         ast_variables_destroy(cur);
         res = 0;
      } else
         prev = cur;

      cur = curn;
   }
   return res;
}

struct ast_variable* ast_variable_new	(	const char *	name,
		const char *	value
	)			[read]

Definition at line 188 of file config.c.

References ast_calloc, ast_variable::name, ast_variable::stuff, and ast_variable::value.

Referenced by apply_outgoing(), ast_channeltype_list(), ast_variable_update(), astman_get_variables(), build_peer(), build_user(), check_access(), check_user_full(), config_odbc(), config_pgsql(), handle_updates(), handle_uri(), parkandannounce_exec(), parse_cookies(), process_text_line(), realtime_directory(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_odbc(), realtime_pgsql(), variable_clone(), and vm_change_password().

{
   struct ast_variable *variable;
   int name_len = strlen(name) + 1; 

   if ((variable = ast_calloc(1, name_len + strlen(value) + 1 + sizeof(*variable)))) {
      variable->name = variable->stuff;
      variable->value = variable->stuff + name_len;      
      strcpy(variable->name,name);
      strcpy(variable->value,value);
   }

   return variable;
}

const 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 251 of file config.c.

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

Referenced by advanced_options(), aji_load_config(), ast_config_option(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), directory_exec(), do_directory(), do_reload(), do_scheduler(), festival_exec(), find_queue_by_name_rt(), function_macro(), get_wait_interval(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_rpt_vars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), privacy_exec(), process_my_load_module(), read_agent_config(), realtime_directory(), realtime_peer(), reload_config(), reload_followme(), reload_queues(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), set_config(), setup_dahdi(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), update_realtime_members(), vm_change_password(), and vm_forwardoptions().

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

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

Definition at line 519 of file config.c.

References ast_strlen_zero(), ast_variable_new(), ast_variables_destroy(), ast_category::last, ast_variable::name, ast_variable::next, ast_variable::object, ast_category::root, and ast_variable::value.

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

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

   if (!(newer = ast_variable_new(variable, value)))
      return -1;
   
   newer->object = object;

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

      newer->next = cur->next;
      newer->object = cur->object || object;
      if (prev)
         prev->next = newer;
      else
         category->root = newer;
      if (category->last == cur)
         category->last = newer;

      cur->next = NULL;
      ast_variables_destroy(cur);

      return 0;
   }

   if (prev)
      prev->next = newer;
   else
      category->root = newer;

   return 0;
}

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 216 of file config.c.

References ast_destroy_comment(), ast_free, ast_variable::next, ast_variable::precomments, and ast_variable::sameline.

Referenced by __sip_destroy(), action_originate(), ast_category_destroy(), ast_httpd_helper_thread(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), check_user_full(), cli_realtime_load(), find_conf_realtime(), find_user_realtime(), free_outgoing(), function_realtime_read(), handle_uri(), load_realtime_queue(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), update_realtime_member_field(), and user_destructor().

{
   struct ast_variable *vn;

   while(v) {
      vn = v;
      v = v->next;
      ast_destroy_comment(&vn->precomments);
      ast_destroy_comment(&vn->sameline);
      ast_free(vn);
   }
}

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

Definition at line 312 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;

   /* try exact match first, then case-insensitive match */
   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 CB_ADD	(	char **	comment_buffer,
		int *	comment_buffer_size,
		char *	str
	)			[static]

Definition at line 90 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

{
   int rem = *comment_buffer_size - strlen(*comment_buffer) - 1;
   int siz = strlen(str);
   if (rem < siz+1) {
      *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + siz + 1);
      if (!(*comment_buffer))
         return;
      *comment_buffer_size += CB_INCR+siz+1;
   }
   strcat(*comment_buffer,str);
}

static void CB_ADD_LEN	(	char **	comment_buffer,
		int *	comment_buffer_size,
		char *	str,
		int	len
	)			[static]

Definition at line 103 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

{
   int cbl = strlen(*comment_buffer) + 1;
   int rem = *comment_buffer_size - cbl;
   if (rem < len+1) {
      *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + len + 1);
      if (!(*comment_buffer))
         return;
      *comment_buffer_size += CB_INCR+len+1;
   }
   strncat(*comment_buffer,str,len);
   (*comment_buffer)[cbl+len-1] = 0;
}

static void CB_INIT	(	char **	comment_buffer,
		int *	comment_buffer_size,
		char **	lline_buffer,
		int *	lline_buffer_size
	)			[static]

Definition at line 71 of file config.c.

References ast_malloc, and CB_INCR.

Referenced by config_text_file_load().

{
   if (!(*comment_buffer)) {
      *comment_buffer = ast_malloc(CB_INCR);
      if (!(*comment_buffer))
         return;
      (*comment_buffer)[0] = 0;
      *comment_buffer_size = CB_INCR;
      *lline_buffer = ast_malloc(CB_INCR);
      if (!(*lline_buffer))
         return;
      (*lline_buffer)[0] = 0;
      *lline_buffer_size = CB_INCR;
   } else {
      (*comment_buffer)[0] = 0;
      (*lline_buffer)[0] = 0;
   }
}

static void CB_RESET	(	char **	comment_buffer,
		char **	lline_buffer
	)			[static]

Definition at line 130 of file config.c.

Referenced by process_text_line().

{ 
   (*comment_buffer)[0] = 0; 
   (*lline_buffer)[0] = 0;
}

static void clear_config_maps

(

void

)

[static]

Definition at line 1146 of file config.c.

References ast_mutex_lock(), ast_mutex_unlock(), config_lock, config_maps, free, map, 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 1480 of file config.c.

References ast_cli(), ast_mutex_lock(), ast_mutex_unlock(), config_lock, config_maps, ast_config_map::database, ast_config_map::driver, map, 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);

   for (eng = config_engine_list; eng; eng = eng->next) {
      ast_cli(fd, "Config 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_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,
		int	withcomments
	)			[static, read]

Growable string buffer

< this will be a comment collector.

< the amount of storage so far alloc'd for the comment_buffer

< A buffer for stuff behind the ;

Definition at line 818 of file config.c.

References ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_copy_string(), ast_log(), ast_strip(), ast_strlen_zero(), ast_verbose(), CB_ADD(), CB_ADD_LEN(), CB_INIT(), COMMENT_META, COMMENT_TAG, errno, f, free, ast_config::include_level, LLB_ADD(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, MY_GLOB_FLAGS, option_debug, option_verbose, process_text_line(), and VERBOSE_PREFIX_2.

{
   char fn[256];
#if defined(LOW_MEMORY)
   char buf[512];
#else
   char buf[8192];
#endif
   char *new_buf, *comment_p, *process_buf;
   FILE *f;
   int lineno=0;
   int comment = 0, nest[MAX_NESTED_COMMENTS];
   struct ast_category *cat = NULL;
   int count = 0;
   struct stat statbuf;
   /*! Growable string buffer */
   char *comment_buffer=0;   /*!< this will be a comment collector.*/
   int   comment_buffer_size=0;  /*!< the amount of storage so far alloc'd for the comment_buffer */

   char *lline_buffer=0;    /*!< A buffer for stuff behind the ; */
   int  lline_buffer_size=0;

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

   if (withcomments) {
      CB_INIT(&comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size);
      if (!lline_buffer || !comment_buffer) {
         ast_log(LOG_ERROR, "Failed to initialize the comment buffer!\n");
         return NULL;
      }
   }
#ifdef AST_INCLUDE_GLOB
   {
      int glob_ret;
      glob_t globbuf;
      globbuf.gl_offs = 0; /* initialize it to silence gcc */
      glob_ret = glob(fn, MY_GLOB_FLAGS, NULL, &globbuf);
      if (glob_ret == GLOB_NOSPACE)
         ast_log(LOG_WARNING,
            "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn);
      else if (glob_ret  == GLOB_ABORTED)
         ast_log(LOG_WARNING,
            "Glob Expansion of pattern '%s' failed: Read error\n", fn);
      else  {
         /* loop over expanded files */
         int i;
         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) {
         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);
         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);
      if (option_verbose > 1)
         ast_verbose("Found\n");
      while(!feof(f)) {
         lineno++;
         if (fgets(buf, sizeof(buf), f)) {
            if ( withcomments ) {
               CB_ADD(&comment_buffer, &comment_buffer_size, lline_buffer);       /* add the current lline buffer to the comment buffer */
               lline_buffer[0] = 0;        /* erase the lline buffer */
            }
            
            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) == '\\')) {
                  /* Escaped semicolons aren't comments. */
                  new_buf = comment_p + 1;
               } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) {
                  /* Meta-Comment start detected ";--" */
                  if (comment < MAX_NESTED_COMMENTS) {
                     *comment_p = '\0';
                     new_buf = comment_p + 3;
                     comment++;
                     nest[comment-1] = lineno;
                  } else {
                     ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS);
                  }
               } else if ((comment_p >= new_buf + 2) &&
                     (*(comment_p - 1) == COMMENT_TAG) &&
                     (*(comment_p - 2) == COMMENT_TAG)) {
                  /* Meta-Comment end detected */
                  comment--;
                  new_buf = comment_p + 1;
                  if (!comment) {
                     /* Back to non-comment now */
                     if (process_buf) {
                        /* Actually have to move what's left over the top, then continue */
                        char *oldptr;
                        oldptr = process_buf + strlen(process_buf);
                        if ( withcomments ) {
                           CB_ADD(&comment_buffer, &comment_buffer_size, ";");
                           CB_ADD_LEN(&comment_buffer, &comment_buffer_size, oldptr+1, new_buf-oldptr-1);
                        }
                        
                        memmove(oldptr, new_buf, strlen(new_buf) + 1);
                        new_buf = oldptr;
                     } else
                        process_buf = new_buf;
                  }
               } else {
                  if (!comment) {
                     /* If ; is found, and we are not nested in a comment, 
                        we immediately stop all comment processing */
                     if ( withcomments ) {
                        LLB_ADD(&lline_buffer, &lline_buffer_size, comment_p);
                     }
                     *comment_p = '\0'; 
                     new_buf = comment_p;
                  } else
                     new_buf = comment_p + 1;
               }
            }
            if( withcomments && comment && !process_buf )
            {
               CB_ADD(&comment_buffer, &comment_buffer_size, buf);  /* the whole line is a comment, store it */
            }
            
            if (process_buf) {
               char *buf = ast_strip(process_buf);
               if (!ast_strlen_zero(buf)) {
                  if (process_text_line(cfg, &cat, buf, lineno, fn, withcomments, &comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size)) {
                     cfg = NULL;
                     break;
                  }
               }
            }
         }
      }
      fclose(f);     
   } while(0);
   if (comment) {
      ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment - 1]);
   }
#ifdef AST_INCLUDE_GLOB
               if (!cfg)
                  break;
            }
            globfree(&globbuf);
         }
      }
#endif

   if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) {
      free(comment_buffer);
      free(lline_buffer);
      comment_buffer = NULL;
      lline_buffer = NULL;
      comment_buffer_size = 0;
      lline_buffer_size = 0;
   }
   
   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 1006 of file config.c.

References ast_config_AST_CONFIG_DIR, ast_copy_string(), AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_log(), ast_verbose(), ast_variable::blanklines, ast_comment::cmt, errno, f, ast_category::ignored, ast_category_template_instance::inst, LOG_DEBUG, ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_category::next, ast_variable::next, ast_comment::next, ast_variable::object, option_debug, option_verbose, ast_variable::precomments, ast_category::precomments, ast_category::root, ast_config::root, ast_variable::sameline, ast_category::sameline, t, ast_category::template_instances, ast_variable::value, var, and VERBOSE_PREFIX_2.

Referenced by action_updateconfig(), vm_change_password(), and vm_forwardoptions().

{
   FILE *f = NULL;
   int fd = -1;
   char fn[256], fntmp[256];
   char date[256]="";
   time_t t;
   struct ast_variable *var;
   struct ast_category *cat;
   struct ast_comment *cmt;
   struct stat s;
   int blanklines = 0;
   int stat_result = 0;

   if (configfile[0] == '/') {
      snprintf(fntmp, sizeof(fntmp), "%s.XXXXXX", configfile);
      ast_copy_string(fn, configfile, sizeof(fn));
   } else {
      snprintf(fntmp, sizeof(fntmp), "%s/%s.XXXXXX", ast_config_AST_CONFIG_DIR, configfile);
      snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
   }
   time(&t);
   ast_copy_string(date, ctime(&t), sizeof(date));
   if ((fd = mkstemp(fntmp)) > 0 && (f = fdopen(fd, "w")) != NULL) {
      if (option_verbose > 1)
         ast_verbose(VERBOSE_PREFIX_2 "Saving '%s': ", fn);
      fprintf(f, ";!\n");
      fprintf(f, ";! Automatically generated configuration file\n");
      if (strcmp(configfile, fn))
         fprintf(f, ";! Filename: %s (%s)\n", configfile, fn);
      else
         fprintf(f, ";! Filename: %s\n", configfile);
      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 */
         for (cmt = cat->precomments; cmt; cmt=cmt->next)
         {
            if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
               fprintf(f,"%s", cmt->cmt);
         }
         if (!cat->precomments)
            fprintf(f,"\n");
         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");
         var = cat->root;
         while(var) {
            struct ast_category_template_instance *x;
            struct ast_variable *v2;
            int found = 0;
            AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
               
               for (v2 = x->inst->root; v2; v2 = v2->next) {
                  if (!strcasecmp(var->name, v2->name))
                     break;
               }
               if (v2 && v2->value && !strcmp(v2->value, var->value)) {
                  found = 1;
                  break;
               }
            }
            if (found) {
               var = var->next;
               continue;
            }
            for (cmt = var->precomments; cmt; cmt=cmt->next)
            {
               if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                  fprintf(f,"%s", cmt->cmt);
            }
            if (var->sameline) 
               fprintf(f, "%s %s %s  %s", 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;
      }
      if ((option_verbose > 1) && !option_debug)
         ast_verbose("Saved\n");
   } else {
      if (option_debug)
         ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno));
      if (option_verbose > 1)
         ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
      if (fd > -1)
         close(fd);
      return -1;
   }
   if (!(stat_result = stat(fn, &s))) {
      fchmod(fd, s.st_mode);
   }
   fclose(f);
   if ((!stat_result && unlink(fn)) || link(fntmp, fn)) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno));
      if (option_verbose > 1)
         ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
      unlink(fntmp);
      return -1;
   }
   unlink(fntmp);
   return 0;
}

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

Find realtime engine for realtime family.

Definition at line 1306 of file config.c.

References ast_copy_string(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_lock, config_maps, ast_config_map::database, ast_config_map::driver, LOG_WARNING, map, 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(), ast_speech_new(), ast_speech_register(), 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 450 of file config.c.

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

Referenced by process_text_line().

{
   struct ast_variable *var;
   struct ast_category_template_instance *x = ast_calloc(1,sizeof(struct ast_category_template_instance));
   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)
      ast_variable_append(new, variable_clone(var));
}

static void LLB_ADD	(	char **	lline_buffer,
		int *	lline_buffer_size,
		char *	str
	)			[static]

Definition at line 117 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

{
   int rem = *lline_buffer_size - strlen(*lline_buffer) - 1;
   int siz = strlen(str);
   if (rem < siz+1) {
      *lline_buffer = ast_realloc(*lline_buffer, *lline_buffer_size + CB_INCR + siz + 1);
      if (!(*lline_buffer)) 
         return;
      *lline_buffer_size += CB_INCR + siz + 1;
   }
   strcat(*lline_buffer,str);
}

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

Definition at line 286 of file config.c.

References ast_variable_append(), ast_variable::next, ast_category::root, and var.

Referenced by process_text_line().

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

static struct ast_category* next_available_category

(

struct ast_category *

cat

)

[static, read]

Definition at line 387 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,
		int	withcomments,
		char **	comment_buffer,
		int *	comment_buffer_size,
		char **	lline_buffer,
		int *	lline_buffer_size
	)			[static]

Definition at line 628 of file config.c.

References ALLOC_COMMENT(), ast_category_append(), ast_category_destroy(), ast_category_new(), ast_config_internal_load(), ast_log(), ast_opt_exec_includes, ast_safe_system(), ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), ast_variable::blanklines, category_get(), CB_RESET(), inherit_category(), ast_variable::lineno, LOG_ERROR, LOG_WARNING, move_variables(), ast_variable::object, ast_variable::precomments, ast_category::precomments, ast_variable::sameline, and ast_category::sameline.

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;
      if (!(*cat = newcat = ast_category_new(catname))) {
         return -1;
      }
      /* add comments */
      if (withcomments && *comment_buffer && (*comment_buffer)[0] ) {
         newcat->precomments = ALLOC_COMMENT(*comment_buffer);
      }
      if (withcomments && *lline_buffer && (*lline_buffer)[0] ) {
         newcat->sameline = ALLOC_COMMENT(*lline_buffer);
      }
      if( withcomments )
         CB_RESET(comment_buffer, lline_buffer);
      
      /* If there are options or categories to inherit from, process them now */
      if (c) {
         if (!(cur = strchr(c, ')'))) {
            ast_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)) {
                  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';
         /* Find real argument */
         c = ast_strip(c + 1);
         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 && !ast_opt_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) {
            cur = c;
            /* Strip off leading and trailing "'s and <>'s */
            if ((*c == '"') || (*c == '<')) {
               char quote_char = *c;
               if (quote_char == '<') {
                  quote_char = '>';
               }

               if (*(c + strlen(c) - 1) == quote_char) {
                  cur++;
                  *(c + strlen(c) - 1) = '\0';
               }
            }
            /* #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, withcomments) ? 1 : 0;
            if(!ast_strlen_zero(exec_file))
               unlink(exec_file);
            if (!do_include) {
               ast_log(LOG_ERROR, "*********************************************************\n");
               ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n");
               ast_log(LOG_ERROR, "Future versions of Asterisk will treat a #include of a "
                                  "file that does not exist as an error, and will fail to "
                                  "load that configuration file.  Please ensure that the "
                                  "file '%s' exists, even if it is empty.\n", cur);
               ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n");
               ast_log(LOG_ERROR, "*********************************************************\n");
               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;
         if ((v = ast_variable_new(ast_strip(cur), ast_strip(c)))) {
            v->lineno = lineno;
            v->object = object;
            /* Put and reset comments */
            v->blanklines = 0;
            ast_variable_append(*cat, v);
            /* add comments */
            if (withcomments && *comment_buffer && (*comment_buffer)[0] ) {
               v->precomments = ALLOC_COMMENT(*comment_buffer);
            }
            if (withcomments && *lline_buffer && (*lline_buffer)[0] ) {
               v->sameline = ALLOC_COMMENT(*lline_buffer);
            }
            if( withcomments )
               CB_RESET(comment_buffer, lline_buffer);
            
         } else {
            return -1;
         }
      } else {
         ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile);
      }
   }
   return 0;
}

int read_config_maps

(

void

)

Definition at line 1196 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, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, table, and ast_variable::value.

Referenced by main().

{
   struct ast_config *config, *configtmp;
   struct ast_variable *v;
   char *driver, *table, *database, *stringp, *tmp;

   clear_config_maps();

   configtmp = ast_config_new();
   configtmp->max_include_level = 1;
   config = ast_config_internal_load(extconfig_conf, configtmp, 0);
   if (!config) {
      ast_config_destroy(configtmp);
      return 0;
   }

   for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
      stringp = v->value;
      driver = strsep(&stringp, ",");

      if ((tmp = strchr(stringp, '\"')))
         stringp = tmp;

      /* check if the database text starts with a double quote */
      if (*stringp == '"') {
         stringp++;
         database = strsep(&stringp, "\"");
         strsep(&stringp, ",");
      } else {
         /* apparently this text has no quotes */
         database = strsep(&stringp, ",");
      }

      table = strsep(&stringp, ",");

      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);
   return 0;
}

int register_config_cli

(

void

)

Definition at line 1516 of file config.c.

References ast_cli_register_multiple().

Referenced by main().

{
   ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry));
   return 0;
}

static struct ast_variable* variable_clone

(

const struct ast_variable *

old

)

[static, read]

Definition at line 272 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 cli_config[] [static]

Initial value:

 {
   { { "core", "show", "config", "mappings", NULL },
   config_command, "Display config mappings (file names to config engines)",
   show_config_help, NULL, &cli_show_config_mappings_deprecated },
}

Definition at line 1510 of file config.c.

struct ast_cli_entry cli_show_config_mappings_deprecated [static]

Initial value:

 {
   { "show", "config", "mappings", NULL },
   config_command, NULL,
   NULL }

Definition at line 1505 of file config.c.

struct ast_config_engine* config_engine_list [static]

Definition at line 155 of file config.c.

ast_mutex_t config_lock = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER ) [static]

Definition at line 154 of file config.c.

Referenced by ast_config_engine_deregister(), ast_config_engine_register(), clear_config_maps(), config_command(), and find_engine().

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 60 of file config.c.

char show_config_help[] [static]

Initial value:

   "Usage: core show config mappings\n"
   "  Shows the filenames to config engines.\n"

Definition at line 1501 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 1340 of file config.c.