config.h File Reference

Configuration File Parser. More...

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

Include dependency graph for config.h:

Go to the source code of this file.

Data Structures
struct	ast_config_engine
	Configuration engine structure, used to define realtime drivers. More...
struct	ast_variable
	Structure for variables, used for configurations and for channel variables. More...
Defines
#define	ast_config_load(filename, flags)   ast_config_load2(filename, AST_MODULE, flags)
#define	CONFIG_STATUS_FILEUNCHANGED   (void *)-1
#define	CV_BOOL(__x, __dst)   CV_F(__x, (__dst) = ast_true(__val) )
	helper macros to assign the value to a BOOL, UINT, static string and dynamic string
#define	CV_DSTR(__x, __dst)   CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val))
#define	CV_END   } while (0)
	close a variable parsing block
#define	CV_F(__pattern, __body)   if (!strcasecmp((__var), __pattern)) { __body; break; }
	call a generic function if the name matches.
#define	CV_START(__in_var, __in_val)
	the macro to open a block for variable parsing
#define	CV_STR(__x, __dst)   CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))
#define	CV_STRFIELD(__x, __obj, __field)   CV_F(__x, ast_string_field_set(__obj, __field, __val))
#define	CV_UINT(__x, __dst)   CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )
Typedefs
typedef struct ast_config *	config_load_func (const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked)
typedef int	realtime_destroy (const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)
typedef struct ast_config *	realtime_multi_get (const char *database, const char *table, va_list ap)
typedef int	realtime_require (const char *database, const char *table, va_list ap)
	Function pointer called to ensure database schema is properly configured for realtime use.
typedef int	realtime_store (const char *database, const char *table, va_list ap)
typedef int	realtime_unload (const char *database, const char *table)
	Function pointer called to clear the database cache and free resources used for such.
typedef int	realtime_update (const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)
typedef struct ast_variable *	realtime_var_get (const char *database, const char *table, va_list ap)
Enumerations
enum	{ CONFIG_FLAG_WITHCOMMENTS = (1 << 0), CONFIG_FLAG_FILEUNCHANGED = (1 << 1), CONFIG_FLAG_NOCACHE = (1 << 2) }
enum	ast_parse_flags {   PARSE_TYPE = 0x000f, PARSE_INT32 = 0x0001, PARSE_UINT32 = 0x0002, PARSE_DOUBLE = 0x0003,   PARSE_INADDR = 0x000f, PARSE_DEFAULT = 0x0010, PARSE_IN_RANGE = 0x0020, PARSE_OUT_RANGE = 0x0040,   PARSE_PORT_MASK = 0x0300, PARSE_PORT_IGNORE = 0x0100, PARSE_PORT_REQUIRE = 0x0200, PARSE_PORT_FORBID = 0x0300 }
	Support code to parse config file arguments. More...
enum	require_type {   RQ_INTEGER1, RQ_UINTEGER1, RQ_INTEGER2, RQ_UINTEGER2,   RQ_INTEGER3, RQ_UINTEGER3, RQ_INTEGER4, RQ_UINTEGER4,   RQ_INTEGER8, RQ_UINTEGER8, RQ_CHAR, RQ_FLOAT,   RQ_DATE, RQ_DATETIME }
	Types used in ast_realtime_require_field. More...
Functions
void	ast_category_append (struct ast_config *config, struct ast_category *cat)
char *	ast_category_browse (struct ast_config *config, const char *prev)
	Goes through categories.
int	ast_category_delete (struct ast_config *cfg, const char *category)
void	ast_category_destroy (struct ast_category *cat)
struct ast_variable *	ast_category_detach_variables (struct ast_category *cat)
int	ast_category_empty (struct ast_config *cfg, const char *category)
	Removes and destroys all variables within a category.
int	ast_category_exist (const struct ast_config *config, const char *category_name)
	Check for category duplicates.
struct ast_variable *	ast_category_first (struct ast_category *cat)
	given a pointer to a category, return the root variable. This is equivalent to ast_variable_browse(), but more efficient if we already have the struct ast_category * (e.g. from ast_category_get())
struct ast_category *	ast_category_get (const struct ast_config *config, const char *category_name)
	Retrieve a category if it exists.
void	ast_category_insert (struct ast_config *config, struct ast_category *cat, const char *match)
	Inserts new category.
struct ast_category *	ast_category_new (const char *name, const char *in_file, int lineno)
	Create a category structure.
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 *config)
	Destroys a config.
int	ast_config_engine_deregister (struct ast_config_engine *del)
	Deregister config engine.
int	ast_config_engine_register (struct ast_config_engine *newconfig)
	Register config engine.
struct ast_category *	ast_config_get_current_category (const struct ast_config *cfg)
	Retrieve the current category name being built. API for backend configuration engines while building a configuration set.
struct ast_config *	ast_config_internal_load (const char *configfile, struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl_file, const char *who_asked)
struct ast_config *	ast_config_load2 (const char *filename, const char *who_asked, struct ast_flags flags)
	Load a config file.
struct ast_config *	ast_config_new (void)
	Create a new base configuration structure.
const char *	ast_config_option (struct ast_config *cfg, const char *cat, const char *var)
	Retrieve a configuration variable within the configuration set. Retrieves the named variable var within category cat of configuration set cfg. If not found, attempts to retrieve the named variable var from within category general.
void	ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
	Set the category within the configuration as being current. API for backend configuration engines while building a configuration set.
int	ast_destroy_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel
	Destroy realtime configuration.
struct ast_config_include *	ast_include_find (struct ast_config *conf, const char *included_file)
struct ast_config_include *	ast_include_new (struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size)
void	ast_include_rename (struct ast_config *conf, const char *from_file, const char *to_file)
struct ast_variable *	ast_load_realtime (const char *family,...) attribute_sentinel
	Retrieve realtime configuration.
struct ast_variable *	ast_load_realtime_all (const char *family,...) attribute_sentinel
struct ast_config *	ast_load_realtime_multientry (const char *family,...) attribute_sentinel
	Retrieve realtime configuration.
int	ast_parse_arg (const char *arg, enum ast_parse_flags flags, void *result,...)
	The argument parsing routine.
int	ast_realtime_enabled (void)
	Check if there's any realtime engines loaded.
int	ast_realtime_require_field (const char *family,...) attribute_sentinel
	Inform realtime what fields that may be stored.
int	ast_store_realtime (const char *family,...) attribute_sentinel
	Create realtime configuration.
int	ast_unload_realtime (const char *family)
	Release any resources cached for a realtime family.
int	ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel
	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, const char *variable, const char *match, const char *line)
void	ast_variable_insert (struct ast_category *category, struct ast_variable *variable, const char *line)
struct ast_variable *	ast_variable_new (const char *name, const char *value, const char *filename)
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)
	Update variable value within a config.
void	ast_variables_destroy (struct ast_variable *var)
	Free variable list.
int	config_text_file_save (const char *filename, const struct ast_config *cfg, const char *generator)
int	read_config_maps (void)
	Exposed re-initialization method for core process This method is intended for use only with the core re-initialization and is not designed to be called from any user applications.
int	register_config_cli (void)
	Exposed initialization method for core process This method is intended for use only with the core initialization and is not designed to be called from any user applications.

---

Detailed Description

Configuration File Parser.

Definition in file config.h.

---

Define Documentation

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

Definition at line 135 of file config.h.

Referenced by adsi_load(), advanced_options(), aji_load_config(), conf_exec(), config_function_read(), config_module(), directory_exec(), festival_exec(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), ind_load_module(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), 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(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), vm_change_password(), and vm_forwardoptions().

#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1

Definition at line 48 of file config.h.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _dsp_init(), adsi_load(), aji_load_config(), ast_config_internal_load(), ast_config_load2(), config_function_read(), config_module(), config_text_file_load(), do_reload(), iax_provision_reload(), ind_load_module(), load_config(), load_moh_classes(), misdn_cfg_init(), odbc_load_module(), osp_load(), parse_config(), private_enum_init(), read_agent_config(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), and tds_load_module().

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

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

Definition at line 552 of file config.h.

Referenced by store_config_core().

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

Definition at line 555 of file config.h.

#define CV_END   } while (0)

close a variable parsing block

Definition at line 544 of file config.h.

Referenced by store_config_core().

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

call a generic function if the name matches.

Definition at line 547 of file config.h.

Referenced by store_config_core().

#define CV_START	(	__in_var,
		__in_val		)

Value:

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

the macro to open a block for variable parsing

Definition at line 538 of file config.h.

Referenced by store_config_core().

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

Definition at line 554 of file config.h.

Referenced by store_config_core().

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

Definition at line 556 of file config.h.

Referenced by store_config_core().

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

Definition at line 553 of file config.h.

Referenced by store_config_core().

---

Typedef Documentation

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

Definition at line 88 of file config.h.

typedef int realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)

Definition at line 93 of file config.h.

typedef struct ast_config* realtime_multi_get(const char *database, const char *table, va_list ap)

Definition at line 90 of file config.h.

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

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

Since:

1.6.1

Definition at line 99 of file config.h.

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

Definition at line 92 of file config.h.

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

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

Since:

1.6.1

Definition at line 105 of file config.h.

typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)

Definition at line 91 of file config.h.

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

Definition at line 89 of file config.h.

---

Enumeration Type Documentation

anonymous enum

Options for ast_config_load()

Enumerator:

CONFIG_FLAG_WITHCOMMENTS	Load the configuration, including comments
CONFIG_FLAG_FILEUNCHANGED	On a reload, give us a -1 if the file hasn't changed.
CONFIG_FLAG_NOCACHE	Don't attempt to cache mtime on this config file.

Definition at line 39 of file config.h.

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

enum ast_parse_flags

Support code to parse config file arguments.

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

Enumerator:

PARSE_TYPE
PARSE_INT32
PARSE_UINT32
PARSE_DOUBLE
PARSE_INADDR
PARSE_DEFAULT
PARSE_IN_RANGE
PARSE_OUT_RANGE
PARSE_PORT_MASK
PARSE_PORT_IGNORE
PARSE_PORT_REQUIRE
PARSE_PORT_FORBID

Definition at line 443 of file config.h.

                     {
   /* low 4 bits of flags are used for the operand type */
   PARSE_TYPE  =  0x000f,
   /* numeric types, with optional default value and bound checks.
    * Additional arguments are passed by value.
    */
   PARSE_INT32 =  0x0001,
   PARSE_UINT32   =  0x0002,
   PARSE_DOUBLE   =  0x0003,
#if 0 /* not supported yet */
   PARSE_INT16 =  0x0004,
   PARSE_UINT16   =  0x0005,
#endif
   /* Returns a struct sockaddr_in, with optional default value
    * (passed by reference) and port handling (accept, ignore,
    * require, forbid). The format is 'host.name[:port]'
    */
   PARSE_INADDR   =  0x000f,

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

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

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

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

enum require_type

Types used in ast_realtime_require_field.

Enumerator:

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

Definition at line 53 of file config.h.

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

---

Function Documentation

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

Definition at line 494 of file config.c.

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

Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), 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 function is kind of non-intuitive in it's use. To begin, one passes NULL as the second argument. It will return a pointer to the string of the first category in the file. From here on after, one must then pass the previous usage's return value as the second pointer, and it will return a pointer to the category name afterwards.

Return values:

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

Definition at line 604 of file config.c.

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

Referenced by __init_manager(), __queues_show(), action_getconfig(), action_getconfigjson(), action_listcategories(), aji_load_config(), complete_sipnotify(), find_queue_by_name_rt(), get_insecure_variable_from_config(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), jingle_load_config(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), misdn_cfg_init(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), search_directory(), set_config(), setup_dahdi(), show_users_realtime(), 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,
		const char *	category
	)

Definition at line 765 of file config.c.

References ast_category_destroy(), ast_config::last, 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 554 of file config.c.

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

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

{
   ast_variables_destroy(cat->root);
   if (cat->file) {
      free(cat->file);
      cat->file = 0;
   }
   ast_destroy_comments(cat);
   ast_destroy_template_list(cat);
   ast_free(cat);
}

struct ast_variable* ast_category_detach_variables

(

struct ast_category *

cat

)

[read]

Definition at line 636 of file config.c.

Referenced by realtime_switch_common().

{
   struct ast_variable *v;

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

   return v;
}

int ast_category_empty	(	struct ast_config *	cfg,
		const char *	category
	)

Removes and destroys all variables within a category.

Return values:

	0	if the category was found and emptied
	-1	if the category was not found

Definition at line 810 of file config.c.

References ast_variables_destroy(), ast_category::name, and ast_config::root.

Referenced by handle_updates().

{
   struct ast_category *cat;

   for (cat = cfg->root; cat; cat = cat->next) {
      if (!strcasecmp(cat->name, category))
         continue;
      ast_variables_destroy(cat->root);
      cat->root = NULL;
      cat->last = NULL;
      return 0;
   }

   return -1;
}

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.

Returns:

non-zero if found

Definition at line 489 of file config.c.

References ast_category_get().

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

struct ast_variable* ast_category_first

(

struct ast_category *

cat

)

[read]

given a pointer to a category, return the root variable. This is equivalent to ast_variable_browse(), but more efficient if we already have the struct ast_category * (e.g. from ast_category_get())

return the first var of a category

Definition at line 590 of file config.c.

Referenced by process_text_line().

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

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.

Return values:

	pointer	to category if found
	NULL	if not.

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

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

Inserts new category.

Parameters:

	config	which config to use
	cat	newly created category to insert
	match	which category to insert above This function is used to insert a new category above another category matching the match parameter.

Definition at line 505 of file config.c.

References ast_category::name, and ast_config::root.

Referenced by handle_updates().

{
   struct ast_category *cur_category;

   if (!cat || !match)
      return;
   if (!strcasecmp(config->root->name, match)) {
      cat->next = config->root;
      config->root = cat;
      return;
   } 
   for (cur_category = config->root; cur_category; cur_category = cur_category->next) {
      if (!strcasecmp(cur_category->next->name, match)) {
         cat->next = cur_category->next;
         cur_category->next = cat;
         break;
      }
   }
}

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

Create a category structure.

Definition at line 455 of file config.c.

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

Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), 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));
   category->file = strdup(in_file);
   category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
   return category;
}

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

Definition at line 647 of file config.c.

References ast_copy_string(), and ast_category::name.

Referenced by handle_updates(), realtime_multi_curl(), 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 595 of file config.c.

References ast_category_get().

Referenced by get_insecure_variable_from_config().

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

Parameters:

family

which family/config to be checked

Returns:

1 if family is configured in realtime and engine exists

Definition at line 2132 of file config.c.

References find_engine().

Referenced by __queues_show(), _sip_show_peer(), _sip_show_peers(), ast_queue_log(), close_mailbox(), copy_plain_file(), destroy_association(), handle_response_peerpoke(), handle_voicemail_show_users(), leave_voicemail(), load_module(), local_ast_moh_start(), realtime_peer(), realtime_update_peer(), rename_file(), sip_poke_noanswer(), sip_show_settings(), and vm_delete().

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

References ast_category_destroy(), ast_free, ast_includes_destroy(), ast_config::includes, and ast_config::root.

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), __queues_show(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_config_load2(), ast_readconfig(), conf_exec(), config_function_read(), config_module(), directory_exec(), do_reload(), festival_exec(), find_conf(), handle_cli_dialplan_save(), iax_provision_reload(), ind_load_module(), init_logger_chain(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_realtime_queue(), load_rpt_vars(), make_email_file(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), private_enum_init(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_multi_handler(), realtime_peer(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), run_startup_commands(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().

{
   struct ast_category *cat, *catn;

   if (!cfg)
      return;

   ast_includes_destroy(cfg->includes);

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

int ast_config_engine_deregister

(

struct ast_config_engine *

del

)

Deregister config engine.

Return values:

0

Always

Definition at line 1958 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 *

newconfig

)

Register config engine.

Return values:

1

Always

Definition at line 1939 of file config.c.

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

Retrieve the current category name being built. API for backend configuration engines while building a configuration set.

Definition at line 844 of file config.c.

References ast_config::current.

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

{
   return cfg->current;
}

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

Definition at line 2020 of file config.c.

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

Referenced by add_cfg_entry(), ast_config_load2(), config_curl(), config_ldap(), 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, flags, suggested_include_file, who_asked);

   if (result && result != CONFIG_STATUS_FILEUNCHANGED)
      result->include_level--;
   else
      cfg->include_level--;

   return result;
}

struct ast_config* ast_config_load2	(	const char *	filename,
		const char *	who_asked,
		struct ast_flags	flags
	)			[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.
	who_asked	The module which is making this request.
	flags	Optional flags: CONFIG_FLAG_WITHCOMMENTS - load the file with comments intact; CONFIG_FLAG_FILEUNCHANGED - check the file mtime and return CONFIG_STATUS_FILEUNCHANGED if the mtime is the same; or CONFIG_FLAG_NOCACHE - don't cache file mtime (main purpose of this option is to save memory on temporary files).

Returns:

an ast_config data structure on success

Return values:

NULL

on error

Definition at line 2060 of file config.c.

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

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), ast_readconfig(), do_reload(), iax_provision_reload(), init_logger_chain(), load_config(), load_modules(), misdn_cfg_init(), private_enum_init(), and run_startup_commands().

{
   struct ast_config *cfg;
   struct ast_config *result;

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

   result = ast_config_internal_load(filename, cfg, flags, "", who_asked);
   if (!result || result == CONFIG_STATUS_FILEUNCHANGED)
      ast_config_destroy(cfg);

   return result;
}

struct ast_config* ast_config_new

(

void

)

[read]

Create a new base configuration structure.

Definition at line 664 of file config.c.

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

Referenced by ast_config_load2(), read_config_maps(), realtime_multi_curl(), realtime_multi_handler(), realtime_multi_ldap(), 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
	)

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

Returns:

Value of var, or NULL if not found.

Definition at line 401 of file config.c.

References ast_variable_retrieve().

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

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

Set the category within the configuration as being current. API for backend configuration engines while building a configuration set.

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

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

Destroy realtime configuration.

Parameters:

	family	which family/config to be destroyed
	keyfield	which field to use as the key
	lookup	which value to look for in the key field to match the entry. This function is used to destroy an entry in realtime configuration space. Additional params are used as keys.

Returns:

Number of rows affected, or -1 on error.

Definition at line 2231 of file config.c.

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

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

{
   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->destroy_func) 
      res = eng->destroy_func(db, table, keyfield, lookup, ap);
   va_end(ap);

   return res;
}

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

Definition at line 332 of file config.c.

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

Referenced by ast_include_new().

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

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

Definition at line 241 of file config.c.

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

Referenced by process_text_line().

{
   /* a file should be included ONCE. Otherwise, if one of the instances is changed,
    * then all be changed. -- how do we know to include it? -- Handling modified 
    * instances is possible, I'd have
    * to create a new master for each instance. */
   struct ast_config_include *inc;
   struct stat statbuf;
   
   inc = ast_include_find(conf, included_file);
   if (inc) {
      do {
         inc->inclusion_count++;
         snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
      } while (stat(real_included_file_name, &statbuf) == 0);
      ast_log(LOG_WARNING,"'%s', line %d:  Same File included more than once! This data will be saved in %s if saved back to disk.\n", from_file, from_lineno, real_included_file_name);
   } else
      *real_included_file_name = 0;
   
   inc = ast_calloc(1,sizeof(struct ast_config_include));
   inc->include_location_file = ast_strdup(from_file);
   inc->include_location_lineno = from_lineno;
   if (!ast_strlen_zero(real_included_file_name))
      inc->included_file = ast_strdup(real_included_file_name);
   else
      inc->included_file = ast_strdup(included_file);
   
   inc->exec = is_exec;
   if (is_exec)
      inc->exec_file = ast_strdup(exec_file);
   
   /* attach this new struct to the conf struct */
   inc->next = conf->includes;
   conf->includes = inc;
   
   return inc;
}

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

Definition at line 279 of file config.c.

References ast_variable::file, ast_category::file, free, ast_config_include::include_location_file, ast_config::includes, ast_variable::next, ast_config_include::next, ast_config::root, and strdup.

Referenced by action_updateconfig().

{
   struct ast_config_include *incl;
   struct ast_category *cat;
   struct ast_variable *v;
   
   int from_len = strlen(from_file);
   int to_len = strlen(to_file);
   
   if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */
      return;
   
   /* the manager code allows you to read in one config file, then
    * write it back out under a different name. But, the new arrangement
    * ties output lines to the file name. So, before you try to write
    * the config file to disk, better riffle thru the data and make sure
    * the file names are changed.
    */
   /* file names are on categories, includes (of course), and on variables. So,
    * traverse all this and swap names */

   for (incl = conf->includes; incl; incl=incl->next) {
      if (strcmp(incl->include_location_file,from_file) == 0) {
         if (from_len >= to_len)
            strcpy(incl->include_location_file, to_file);
         else {
            free(incl->include_location_file);
            incl->include_location_file = strdup(to_file);
         }
      }
   }
   for (cat = conf->root; cat; cat = cat->next) {
      if (strcmp(cat->file,from_file) == 0) {
         if (from_len >= to_len)
            strcpy(cat->file, to_file);
         else {
            free(cat->file);
            cat->file = strdup(to_file);
         }
      }
      for (v = cat->root; v; v = v->next) {
         if (strcmp(v->file,from_file) == 0) {
            if (from_len >= to_len)
               strcpy(v->file, to_file);
            else {
               free(v->file);
               v->file = strdup(to_file);
            }
         }
      }
   }
}

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.

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

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

Definition at line 2102 of file config.c.

References ast_free, ast_load_realtime_helper(), ast_strlen_zero(), ast_variable::next, and ast_variable::value.

Referenced by copy_plain_file(), find_conf_realtime(), find_user_realtime(), leave_queue(), load_realtime_queue(), local_ast_moh_start(), queue_function_queuewaitingcount(), realtime_alias(), realtime_peer(), realtime_switch_common(), and realtime_user().

{
   struct ast_variable *res, *cur, *prev = NULL, *freeme = NULL;
   va_list ap;

   va_start(ap, family);
   res = ast_load_realtime_helper(family, ap);
   va_end(ap);

   /* Eliminate blank entries */
   for (cur = res; cur; cur = cur->next) {
      if (freeme) {
         ast_free(freeme);
         freeme = NULL;
      }

      if (ast_strlen_zero(cur->value)) {
         if (prev)
            prev->next = cur->next;
         else
            res = cur->next;
         freeme = cur;
      } else {
         prev = cur;
      }
   }
   return res;
}

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

Definition at line 2090 of file config.c.

References ast_load_realtime_helper().

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

{
   struct ast_variable *res;
   va_list ap;

   va_start(ap, family);
   res = ast_load_realtime_helper(family, 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 traditional ast_config structure rather than just returning a linked list of variables.

Definition at line 2180 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(), show_users_realtime(), 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_parse_arg	(	const char *	arg,
		enum ast_parse_flags	flags,
		void *	p_result,
			...
	)

The argument parsing routine.

Parameters:

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

Return values:

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

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

Definition at line 2251 of file config.c.

References ast_debug, ast_gethostbyname(), ast_inet_ntoa(), ast_strdupa, buf, hp, PARSE_DEFAULT, PARSE_DOUBLE, PARSE_IN_RANGE, PARSE_INADDR, PARSE_INT32, PARSE_OUT_RANGE, PARSE_PORT_FORBID, PARSE_PORT_IGNORE, PARSE_PORT_MASK, PARSE_PORT_REQUIRE, PARSE_TYPE, PARSE_UINT32, and strsep().

Referenced by ast_sip_ouraddrfor(), check_via_response(), and reload_config().

{
   va_list ap;
   int error = 0;

   va_start(ap, p_result);
   switch (flags & PARSE_TYPE) {
   case PARSE_INT32:
       {
      int32_t *result = p_result;
      int32_t x, def = result ? *result : 0,
         high = (int32_t)0x7fffffff,
         low  = (int32_t)0x80000000;
      /* optional argument: first default value, then range */
      if (flags & PARSE_DEFAULT)
         def = va_arg(ap, int32_t);
      if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
         /* range requested, update bounds */
         low = va_arg(ap, int32_t);
         high = va_arg(ap, int32_t);
      }
      x = strtol(arg, NULL, 0);
      error = (x < low) || (x > high);
      if (flags & PARSE_OUT_RANGE)
         error = !error;
      if (result)
         *result  = error ? def : x;
      ast_debug(3,
         "extract int from [%s] in [%d, %d] gives [%d](%d)\n",
         arg, low, high,
         result ? *result : x, error);
      break;
       }

   case PARSE_UINT32:
       {
      uint32_t *result = p_result;
      uint32_t x, def = result ? *result : 0,
         low = 0, high = (uint32_t)~0;
      /* optional argument: first default value, then range */
      if (flags & PARSE_DEFAULT)
         def = va_arg(ap, uint32_t);
      if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
         /* range requested, update bounds */
         low = va_arg(ap, uint32_t);
         high = va_arg(ap, uint32_t);
      }
      x = strtoul(arg, NULL, 0);
      error = (x < low) || (x > high);
      if (flags & PARSE_OUT_RANGE)
         error = !error;
      if (result)
         *result  = error ? def : x;
      ast_debug(3,
         "extract uint from [%s] in [%u, %u] gives [%u](%d)\n",
         arg, low, high,
         result ? *result : x, error);
      break;
       }

   case PARSE_DOUBLE:
       {
      double *result = p_result;
      double x, def = result ? *result : 0,
         low = -HUGE_VAL, high = HUGE_VAL;

      /* optional argument: first default value, then range */
      if (flags & PARSE_DEFAULT)
         def = va_arg(ap, double);
      if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
         /* range requested, update bounds */
         low = va_arg(ap, double);
         high = va_arg(ap, double);
      }
      x = strtod(arg, NULL);
      error = (x < low) || (x > high);
      if (flags & PARSE_OUT_RANGE)
         error = !error;
      if (result)
         *result  = error ? def : x;
      ast_debug(3,
         "extract double from [%s] in [%f, %f] gives [%f](%d)\n",
         arg, low, high,
         result ? *result : x, error);
      break;
       }
   case PARSE_INADDR:
       {
      char *port, *buf;
      struct sockaddr_in _sa_buf;   /* buffer for the result */
      struct sockaddr_in *sa = p_result ?
         (struct sockaddr_in *)p_result : &_sa_buf;
      /* default is either the supplied value or the result itself */
      struct sockaddr_in *def = (flags & PARSE_DEFAULT) ?
         va_arg(ap, struct sockaddr_in *) : sa;
      struct hostent *hp;
      struct ast_hostent ahp;

      memset(&_sa_buf, '\0', sizeof(_sa_buf)); /* clear buffer */
      /* duplicate the string to strip away the :port */
      port = ast_strdupa(arg);
      buf = strsep(&port, ":");
      sa->sin_family = AF_INET;  /* assign family */
      /*
       * honor the ports flag setting, assign default value
       * in case of errors or field unset.
       */
      flags &= PARSE_PORT_MASK; /* the only flags left to process */
      if (port) {
         if (flags == PARSE_PORT_FORBID) {
            error = 1;  /* port was forbidden */
            sa->sin_port = def->sin_port;
         } else if (flags == PARSE_PORT_IGNORE)
            sa->sin_port = def->sin_port;
         else /* accept or require */
            sa->sin_port = htons(strtol(port, NULL, 0));
      } else {
         sa->sin_port = def->sin_port;
         if (flags == PARSE_PORT_REQUIRE)
            error = 1;
      }
      /* Now deal with host part, even if we have errors before. */
      hp = ast_gethostbyname(buf, &ahp);
      if (hp)  /* resolved successfully */
         memcpy(&sa->sin_addr, hp->h_addr, sizeof(sa->sin_addr));
      else {
         error = 1;
         sa->sin_addr = def->sin_addr;
      }
      ast_debug(3,
         "extract inaddr from [%s] gives [%s:%d](%d)\n",
         arg, ast_inet_ntoa(sa->sin_addr),
         ntohs(sa->sin_port), error);
         break;
       }
   }
   va_end(ap);
   return error;
}

int ast_realtime_enabled

(

void

)

Check if there's any realtime engines loaded.

Definition at line 2143 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

{
   return config_maps ? 1 : 0;
}

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

Inform realtime what fields that may be stored.

Parameters:

family

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

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

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

Return values:

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

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

Since:

1.6.1

Definition at line 2148 of file config.c.

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

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

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

   va_start(ap, family);
   eng = find_engine(family, db, sizeof(db), table, sizeof(table));
   if (eng && eng->require_func) {
      res = eng->require_func(db, table, ap);
   }
   va_end(ap);

   return res;
}

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

Create realtime configuration.

Parameters:

family

which family/config to be created This function is used to create a parameter in realtime configuration space.

Returns:

Number of rows affected, or -1 on error. On the MySQL engine only, for reasons of backwards compatibility, the return value is the insert ID. This value is nonportable and may be changed in a future version to match the other engines.

Definition at line 2214 of file config.c.

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

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

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

   va_start(ap, family);
   eng = find_engine(family, db, sizeof(db), table, sizeof(table));
   if (eng && eng->store_func) 
      res = eng->store_func(db, table, ap);
   va_end(ap);

   return res;
}

int ast_unload_realtime

(

const char *

family

)

Release any resources cached for a realtime family.

Parameters:

family

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

Return values:

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

Since:

1.6.1

Definition at line 2166 of file config.c.

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

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

{
   struct ast_config_engine *eng;
   char db[256] = "";
   char table[256] = "";
   int res = -1;

   eng = find_engine(family, db, sizeof(db), table, sizeof(table));
   if (eng && eng->unload_func) {
      res = eng->unload_func(db, table);
   }
   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 2197 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(), leave_voicemail(), realtime_update_peer(), rename_file(), 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 343 of file config.c.

Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), 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.

Return values:

	ast_variable	list on success
	NULL	on failure

Definition at line 389 of file config.c.

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

Referenced by __ast_http_load(), __ast_http_post_load(), __init_manager(), action_getconfig(), action_getconfigjson(), adsi_load(), aji_load_config(), ast_readconfig(), ast_variable_retrieve(), build_device(), check_tx_freq(), collect_function_digits(), conf_exec(), config_module(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), iax_template_parse(), ind_load_module(), init_logger_chain(), jingle_load_config(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), run_startup_commands(), search_directory(), set_config(), setup_dahdi(), show_users_realtime(), sip_cli_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,
		const char *	variable,
		const char *	match,
		const char *	line
	)

Definition at line 673 of file config.c.

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

Referenced by handle_updates().

{
   struct ast_variable *cur, *prev=NULL, *curn;
   int res = -1;
   int lineno = 0;

   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 ((!ast_strlen_zero(line) && lineno == atoi(line)) || (ast_strlen_zero(line) && !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;
      lineno++;
   }
   return res;
}

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

Definition at line 356 of file config.c.

References ast_variable::next.

Referenced by handle_updates().

{
   struct ast_variable *cur = category->root;
   int lineno;
   int insertline;

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

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

Definition at line 218 of file config.c.

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

Referenced by add_cfg_entry(), add_rt_cfg_entry(), add_rt_multi_cfg_entry(), add_var(), apply_outgoing(), ast_channeltype_list(), ast_variable_update(), astman_get_variables(), build_user(), check_access(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), copy_vars(), create_vmaccount(), handle_updates(), handle_uri(), httpd_helper_thread(), iax_parse_ies(), ldap_table_config_add_attribute(), parkandannounce_exec(), parse_cookies(), process_dahdi(), process_text_line(), realtime_curl(), realtime_directory(), realtime_ldap_entry_to_var(), realtime_ldap_result_to_vars(), realtime_multi_curl(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_odbc(), realtime_pgsql(), transmit_notify_custom(), variable_clone(), and vm_change_password().

{
   struct ast_variable *variable;
   int name_len = strlen(name) + 1; 
   int val_len = strlen(value) + 1; 
   int fn_len = strlen(filename) + 1;  

#ifdef MALLOC_DEBUG
   if ((variable = __ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable), file, lineno, func))) {
#else
   if ((variable = ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable)))) {
#endif
      char *dst = variable->stuff;  /* writable space starts here */
      variable->name = strcpy(dst, name);
      dst += name_len;
      variable->value = strcpy(dst, value);
      dst += val_len;
      variable->file = strcpy(dst, filename);
   }
   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

Return values:

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

Definition at line 411 of file config.c.

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

Referenced by __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _dsp_init(), advanced_options(), aji_load_config(), ast_config_option(), build_extension(), config_function_read(), config_module(), directory_exec(), do_reload(), do_scheduler(), festival_exec(), find_queue_by_name_rt(), function_macro(), get_insecure_variable_from_config(), get_wait_interval(), gtalk_load_config(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), jingle_load_config(), 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(), private_enum_init(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_queues(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), rpt_telemetry(), saynode(), search_directory(), 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
	)

Update variable value within a config.

Parameters:

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

Returns:

0 on success or -1 on failure.

Definition at line 725 of file config.c.

References ast_strlen_zero(), ast_variable_new(), ast_variables_destroy(), ast_variable::blanklines, ast_variable::file, ast_variable::lineno, ast_variable::name, ast_variable::next, ast_variable::object, ast_variable::precomments, ast_variable::sameline, ast_variable::trailing, and ast_variable::value.

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

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

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

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

      /* Preserve everything */
      newer->lineno = cur->lineno;
      newer->blanklines = cur->blanklines;
      newer->precomments = cur->precomments; cur->precomments = NULL;
      newer->sameline = cur->sameline; cur->sameline = NULL;
      newer->trailing = cur->trailing; cur->trailing = NULL;

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

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

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

References ast_free, and ast_variable::next.

Referenced by __sip_destroy(), ast_category_destroy(), ast_category_empty(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), cli_realtime_load(), copy_plain_file(), destroy_dahdi_pvt(), find_conf_realtime(), find_user_realtime(), free_outgoing(), free_user(), function_realtime_read(), function_realtime_readdestroy(), handle_uri(), httpd_helper_thread(), ldap_loadentry(), leave_queue(), load_realtime_queue(), local_ast_moh_start(), manager_sipnotify(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_handler(), realtime_ldap_base_ap(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), socket_process(), table_configs_free(), and user_destructor().

{
   struct ast_variable *vn;

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

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

Definition at line 1580 of file config.c.

References ao2_container_alloc, ao2_ref, ast_debug, AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_verb, ast_variable::blanklines, ast_comment::cmt, errno, ast_config_include::exec, ast_config_include::exec_file, f, ast_variable::file, ast_category::file, gen_header(), hash_string(), hashtab_compare_strings(), ast_category::ignored, ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::included_file, ast_config::includes, insert_leading_blank_lines(), ast_category_template_instance::inst, ast_variable::lineno, ast_category::lineno, ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_variable::next, ast_comment::next, ast_config_include::next, ast_variable::object, option_debug, ast_config_include::output, ast_variable::precomments, ast_config::root, ast_variable::sameline, set_fn(), ast_variable::trailing, ast_variable::value, and var.

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

{
   FILE *f;
   char fn[256];
   struct ast_variable *var;
   struct ast_category *cat;
   struct ast_comment *cmt;
   struct ast_config_include *incl;
   int blanklines = 0;
   struct ao2_container *fileset = ao2_container_alloc(180000, hash_string, hashtab_compare_strings);
   struct inclfile *fi = 0;

   /* reset all the output flags, in case this isn't our first time saving this data */

   for (incl=cfg->includes; incl; incl = incl->next)
      incl->output = 0;

   /* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions)
      are all truncated to zero bytes and have that nice header*/

   for (incl=cfg->includes; incl; incl = incl->next)
   {
      if (!incl->exec) { /* leave the execs alone -- we'll write out the #exec directives, but won't zero out the include files or exec files*/
         FILE *f1;

         set_fn(fn, sizeof(fn), incl->included_file, configfile, fileset, &fi); /* normally, fn is just set to incl->included_file, prepended with config dir if relative */
         f1 = fopen(fn,"w");
         if (f1) {
            gen_header(f1, configfile, fn, generator);
            fclose(f1); /* this should zero out the file */
         } else {
            ast_debug(1, "Unable to open for writing: %s\n", fn);
            ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
         }
         ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
         fi = 0;
      }
   }

   set_fn(fn, sizeof(fn), 0, configfile, fileset, &fi); /* just set fn to absolute ver of configfile */
#ifdef __CYGWIN__ 
   if ((f = fopen(fn, "w+"))) {
#else
   if ((f = fopen(fn, "w"))) {
#endif       
      ast_verb(2, "Saving '%s': ", fn);
      gen_header(f, configfile, fn, generator);
      cat = cfg->root;
      fclose(f);
      ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
      
      /* from here out, we open each involved file and concat the stuff we need to add to the end and immediately close... */
      /* since each var, cat, and associated comments can come from any file, we have to be 
         mobile, and open each file, print, and close it on an entry-by-entry basis */

      while (cat) {
         set_fn(fn, sizeof(fn), cat->file, configfile, fileset, &fi);
         f = fopen(fn, "a");
         if (!f)
         {
            ast_debug(1, "Unable to open for writing: %s\n", fn);
            ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
            ao2_ref(fileset, -1);
            return -1;
         }

         /* dump any includes that happen before this category header */
         for (incl=cfg->includes; incl; incl = incl->next) {
            if (strcmp(incl->include_location_file, cat->file) == 0){
               if (cat->lineno > incl->include_location_lineno && !incl->output) {
                  if (incl->exec)
                     fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                  else
                     fprintf(f,"#include \"%s\"\n", incl->included_file);
                  incl->output = 1;
               }
            }
         }

         insert_leading_blank_lines(f, fi, cat->precomments, cat->lineno);
         /* Dump section with any appropriate comment */
         for (cmt = cat->precomments; cmt; cmt=cmt->next) {
            char *cmtp = cmt->cmt;
            while (*cmtp == ';' && *(cmtp+1) == '!') {
               char *cmtp2 = strchr(cmtp+1, '\n');
               if (cmtp2)
                  cmtp = cmtp2+1;
               else cmtp = 0;
            }
            if (cmtp)
               fprintf(f,"%s", cmtp);
         }
         fprintf(f, "[%s]", cat->name);
         if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) {
            fprintf(f, "(");
            if (cat->ignored) {
               fprintf(f, "!");
            }
            if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) {
               fprintf(f, ",");
            }
            if (!AST_LIST_EMPTY(&cat->template_instances)) {
               struct ast_category_template_instance *x;
               AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
                  fprintf(f,"%s",x->name);
                  if (x != AST_LIST_LAST(&cat->template_instances))
                     fprintf(f,",");
               }
            }
            fprintf(f, ")");
         }
         for(cmt = cat->sameline; cmt; cmt=cmt->next)
         {
            fprintf(f,"%s", cmt->cmt);
         }
         if (!cat->sameline)
            fprintf(f,"\n");
         for (cmt = cat->trailing; cmt; cmt=cmt->next) {
            if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
               fprintf(f,"%s", cmt->cmt);
         }
         fclose(f);
         ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
         fi = 0;
         
         var = cat->root;
         while (var) {
            struct ast_category_template_instance *x;
            int found = 0;
            AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
               struct ast_variable *v;
               for (v = x->inst->root; v; v = v->next) {
                  if (!strcasecmp(var->name, v->name) && !strcmp(var->value, v->value)) {
                     found = 1;
                     break;
                  }
               }
               if (found)
                  break;
            }
            if (found) {
               var = var->next;
               continue;
            }
            set_fn(fn, sizeof(fn), var->file, configfile, fileset, &fi);
            f = fopen(fn, "a");
            if (!f)
            {
               ast_debug(1, "Unable to open for writing: %s\n", fn);
               ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
               ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
               fi = 0;
               ao2_ref(fileset, -1);
               return -1;
            }
            
            /* dump any includes that happen before this category header */
            for (incl=cfg->includes; incl; incl = incl->next) {
               if (strcmp(incl->include_location_file, var->file) == 0){
                  if (var->lineno > incl->include_location_lineno && !incl->output) {
                     if (incl->exec)
                        fprintf(f,"#exec \"%s\"\n", incl->exec_file);
                     else
                        fprintf(f,"#include \"%s\"\n", incl->included_file);
                     incl->output = 1;
                  }
               }
            }
            
            insert_leading_blank_lines(f, fi, var->precomments, var->lineno);
            for (cmt = var->precomments; cmt; cmt=cmt->next) {
               if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                  fprintf(f,"%s", cmt->cmt);
            }
            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);
            for (cmt = var->trailing; cmt; cmt=cmt->next) {
               if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
                  fprintf(f,"%s", cmt->cmt);
            }
            if (var->blanklines) {
               blanklines = var->blanklines;
               while (blanklines--)
                  fprintf(f, "\n");
            }
            
            fclose(f);
            ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
            fi = 0;
            
            var = var->next;
         }
         cat = cat->next;
      }
      if (!option_debug)
         ast_verb(2, "Saved\n");
   } else {
      ast_debug(1, "Unable to open for writing: %s\n", fn);
      ast_verb(2, "Unable to write (%s)", strerror(errno));
      ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
      ao2_ref(fileset, -1);
      return -1;
   }

   /* Now, for files with trailing #include/#exec statements,
      we have to make sure every entry is output */

   for (incl=cfg->includes; incl; incl = incl->next) {
      if (!incl->output) {
         /* open the respective file */
         set_fn(fn, sizeof(fn), incl->include_location_file, configfile, fileset, &fi);
         f = fopen(fn, "a");
         if (!f)
         {
            ast_debug(1, "Unable to open for writing: %s\n", fn);
            ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
            ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
            fi = 0;
            ao2_ref(fileset, -1);
            return -1;
         }
         
         /* output the respective include */
         if (incl->exec)
            fprintf(f,"#exec \"%s\"\n", incl->exec_file);
         else
            fprintf(f,"#include \"%s\"\n", incl->included_file);
         fclose(f);
         incl->output = 1;
         ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
         fi = 0;
      }
   }
   ao2_ref(fileset, -1); /* this should destroy the hash container */
            
   return 0;
}

int read_config_maps

(

void

)

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

Definition at line 1868 of file config.c.

References append_mapping(), ast_config_destroy(), ast_config_internal_load(), ast_config_new(), ast_copy_string(), ast_log(), ast_variable_browse(), buf, clear_config_maps(), config, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, strsep(), table, and ast_variable::value.

Referenced by main().

{
   struct ast_config *config, *configtmp;
   struct ast_variable *v;
   char *driver, *table, *database, *stringp, *tmp;
   struct ast_flags flags = { 0 };

   clear_config_maps();

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

   for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
      char buf[512];
      ast_copy_string(buf, v->value, sizeof(buf));
      stringp = buf;
      driver = strsep(&stringp, ",");

      if ((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

)

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

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