Thu Oct 11 06:48:39 2012

Asterisk developer's documentation


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_FILEINVALID   (void *)-2
#define CONFIG_STATUS_FILEMISSING   (void *)0
#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1
#define CV_BOOL(__x, __dst)   CV_F(__x, (__dst) = ast_true(__val) )
 helper macros to assign the value to a BOOL, UINT, static string and dynamic string
#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_configconfig_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_configrealtime_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 int realtime_update2 (const char *database, const char *table, va_list ap)
typedef struct ast_variablerealtime_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_variableast_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_variableast_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_categoryast_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_categoryast_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_variableast_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_categoryast_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_configast_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_configast_config_load2 (const char *filename, const char *who_asked, struct ast_flags flags)
 Load a config file.
struct ast_configast_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_config_text_file_save (const char *filename, const struct ast_config *cfg, const char *generator)
int ast_destroy_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel
 Destroy realtime configuration.
struct ast_config_includeast_include_find (struct ast_config *conf, const char *included_file)
struct ast_config_includeast_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_variableast_load_realtime (const char *family,...) attribute_sentinel
 Retrieve realtime configuration.
struct ast_variableast_load_realtime_all (const char *family,...) attribute_sentinel
struct ast_configast_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_rq_is_int (require_type type)
 Check if require type is an integer type.
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_update2_realtime (const char *family,...) attribute_sentinel
 Update realtime configuration.
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_variableast_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_variableast_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)

#define CONFIG_STATUS_FILEINVALID   (void *)-2

#define CONFIG_STATUS_FILEMISSING   (void *)0

#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1

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

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

Definition at line 581 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 584 of file config.h.

#define CV_END   } while (0)

close a variable parsing block

Definition at line 573 of file config.h.

Referenced by store_config_core(), and store_config_tone_zone().

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

call a generic function if the name matches.

Definition at line 576 of file config.h.

Referenced by store_config_core(), and store_config_tone_zone().

#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 567 of file config.h.

Referenced by store_config_core(), and store_config_tone_zone().

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

Definition at line 583 of file config.h.

Referenced by store_config_core(), and store_config_tone_zone().

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

Definition at line 585 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 582 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 90 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 96 of file config.h.

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

Definition at line 92 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 102 of file config.h.

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

Definition at line 95 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 108 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 93 of file config.h.

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

Definition at line 94 of file config.h.

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

Definition at line 91 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.

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

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 472 of file config.h.

00472                      {
00473    /* low 4 bits of flags are used for the operand type */
00474    PARSE_TYPE  =  0x000f,
00475    /* numeric types, with optional default value and bound checks.
00476     * Additional arguments are passed by value.
00477     */
00478    PARSE_INT32 =  0x0001,
00479    PARSE_UINT32   =  0x0002,
00480    PARSE_DOUBLE   =  0x0003,
00481 #if 0 /* not supported yet */
00482    PARSE_INT16 =  0x0004,
00483    PARSE_UINT16   =  0x0005,
00484 #endif
00485    /* Returns a struct sockaddr_in, with optional default value
00486     * (passed by reference) and port handling (accept, ignore,
00487     * require, forbid). The format is 'host.name[:port]'
00488     */
00489    PARSE_INADDR   =  0x000f,
00490 
00491    /* Other data types can be added as needed */
00492 
00493    /* If PARSE_DEFAULT is set, next argument is a default value
00494     * which is returned in case of error. The argument is passed
00495     * by value in case of numeric types, by reference in other cases.
00496     */
00497    PARSE_DEFAULT  =  0x0010,  /* assign default on error */
00498 
00499    /* Request a range check, applicable to numbers. Two additional
00500     * arguments are passed by value, specifying the low-high end of
00501     * the range (inclusive). An error is returned if the value
00502     * is outside or inside the range, respectively.
00503     */
00504    PARSE_IN_RANGE =  0x0020,  /* accept values inside a range */
00505    PARSE_OUT_RANGE = 0x0040,  /* accept values outside a range */
00506 
00507    /* Port handling, for sockaddr_in. accept/ignore/require/forbid
00508     * port number after the hostname or address.
00509     */
00510    PARSE_PORT_MASK = 0x0300, /* 0x000: accept port if present */
00511    PARSE_PORT_IGNORE =  0x0100, /* 0x100: ignore port if present */
00512    PARSE_PORT_REQUIRE = 0x0200, /* 0x200: require port number */
00513    PARSE_PORT_FORBID =  0x0300, /* 0x100: forbid port number */
00514 };

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 55 of file config.h.

00055              {
00056    RQ_INTEGER1,
00057    RQ_UINTEGER1,
00058    RQ_INTEGER2,
00059    RQ_UINTEGER2,
00060    RQ_INTEGER3,
00061    RQ_UINTEGER3,
00062    RQ_INTEGER4,
00063    RQ_UINTEGER4,
00064    RQ_INTEGER8,
00065    RQ_UINTEGER8,
00066    RQ_CHAR,
00067    RQ_FLOAT,
00068    RQ_DATE,
00069    RQ_DATETIME,
00070 } require_type;


Function Documentation

void ast_category_append ( struct ast_config config,
struct ast_category cat 
)

Definition at line 522 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 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().

00523 {
00524    if (config->last)
00525       config->last->next = category;
00526    else
00527       config->root = category;
00528    category->include_level = config->include_level;
00529    config->last = category;
00530    config->current = category;
00531 }

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

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

Referenced by __init_manager(), __queues_show(), action_getconfig(), action_getconfigjson(), action_listcategories(), aji_load_config(), ast_cli_perms_init(), complete_sipnotify(), conf_exec(), config_load(), find_queue_by_name_rt(), find_realtime(), get_insecure_variable_from_config(), gtalk_load_config(), iax_provision_reload(), jingle_load_config(), load_config(), load_indications(), 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(), search_directory_sub(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), update_realtime_members(), and vm_change_password().

00614 {  
00615    struct ast_category *cat = NULL;
00616 
00617    if (prev && config->last_browse && (config->last_browse->name == prev))
00618       cat = config->last_browse->next;
00619    else if (!prev && config->root)
00620       cat = config->root;
00621    else if (prev) {
00622       for (cat = config->root; cat; cat = cat->next) {
00623          if (cat->name == prev) {
00624             cat = cat->next;
00625             break;
00626          }
00627       }
00628       if (!cat) {
00629          for (cat = config->root; cat; cat = cat->next) {
00630             if (!strcasecmp(cat->name, prev)) {
00631                cat = cat->next;
00632                break;
00633             }
00634          }
00635       }
00636    }
00637    
00638    if (cat)
00639       cat = next_available_category(cat);
00640 
00641    config->last_browse = cat;
00642    return (cat) ? cat->name : NULL;
00643 }

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

Definition at line 766 of file config.c.

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

Referenced by handle_updates().

00767 {
00768    struct ast_category *prev=NULL, *cat;
00769 
00770    cat = cfg->root;
00771    while (cat) {
00772       if (cat->name == category) {
00773          if (prev) {
00774             prev->next = cat->next;
00775             if (cat == cfg->last)
00776                cfg->last = prev;
00777          } else {
00778             cfg->root = cat->next;
00779             if (cat == cfg->last)
00780                cfg->last = NULL;
00781          }
00782          ast_category_destroy(cat);
00783          return 0;
00784       }
00785       prev = cat;
00786       cat = cat->next;
00787    }
00788 
00789    prev = NULL;
00790    cat = cfg->root;
00791    while (cat) {
00792       if (!strcasecmp(cat->name, category)) {
00793          if (prev) {
00794             prev->next = cat->next;
00795             if (cat == cfg->last)
00796                cfg->last = prev;
00797          } else {
00798             cfg->root = cat->next;
00799             if (cat == cfg->last)
00800                cfg->last = NULL;
00801          }
00802          ast_category_destroy(cat);
00803          return 0;
00804       }
00805       prev = cat;
00806       cat = cat->next;
00807    }
00808    return -1;
00809 }

void ast_category_destroy ( struct ast_category cat  ) 

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  )  [read]

Definition at line 645 of file config.c.

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

Referenced by realtime_switch_common().

00646 {
00647    struct ast_variable *v;
00648 
00649    v = cat->root;
00650    cat->root = NULL;
00651    cat->last = NULL;
00652 
00653    return v;
00654 }

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

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

Referenced by handle_updates().

00812 {
00813    struct ast_category *cat;
00814 
00815    for (cat = cfg->root; cat; cat = cat->next) {
00816       if (!strcasecmp(cat->name, category))
00817          continue;
00818       ast_variables_destroy(cat->root);
00819       cat->root = NULL;
00820       cat->last = NULL;
00821       return 0;
00822    }
00823 
00824    return -1;
00825 }

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

References ast_category_get().

00518 {
00519    return !!ast_category_get(config, category_name);
00520 }

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

References ast_category::root.

Referenced by process_text_line().

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

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

00513 {
00514    return category_get(config, category_name, 0);
00515 }

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

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

Referenced by handle_updates().

00534 {
00535    struct ast_category *cur_category;
00536 
00537    if (!cat || !match)
00538       return;
00539    if (!strcasecmp(config->root->name, match)) {
00540       cat->next = config->root;
00541       config->root = cat;
00542       return;
00543    } 
00544    for (cur_category = config->root; cur_category; cur_category = cur_category->next) {
00545       if (!strcasecmp(cur_category->next->name, match)) {
00546          cat->next = cur_category->next;
00547          cur_category->next = cat;
00548          break;
00549       }
00550    }
00551 }

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

Create a category structure.

Definition at line 483 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().

00484 {
00485    struct ast_category *category;
00486 
00487    if ((category = ast_calloc(1, sizeof(*category))))
00488       ast_copy_string(category->name, name, sizeof(category->name));
00489    category->file = strdup(in_file);
00490    category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
00491    return category;
00492 }

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

Definition at line 656 of file config.c.

References ast_copy_string(), and ast_category::name.

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

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

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

References ast_category_get(), and ast_category::root.

Referenced by get_insecure_variable_from_config().

00605 {
00606    struct ast_category *category = ast_category_get(config, cat);
00607 
00608    if (category)
00609       return category->root;
00610    return NULL;
00611 }

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

References ast_realtime_enabled(), and 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(), load_moh_classes(), local_ast_moh_start(), realtime_peer(), realtime_update_peer(), rename_file(), sip_poke_noanswer(), sip_show_settings(), and vm_delete().

02145 {
02146    struct ast_config_engine *eng;
02147    if (!ast_realtime_enabled()) {
02148       return 0;   /* There are no engines at all so fail early */
02149    }
02150 
02151    eng = find_engine(family, NULL, 0, NULL, 0);
02152    if (eng)
02153       return 1;
02154    return 0;
02155 }

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

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

Referenced by __ast_http_load(), __ast_http_post_load(), __ast_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_cli_perms_init(), ast_config_load2(), ast_plc_reload(), ast_readconfig(), conf_exec(), config_function_read(), config_load(), config_module(), directory_exec(), do_reload(), festival_exec(), find_conf(), find_realtime(), handle_cli_dialplan_save(), iax_provision_reload(), init_logger_chain(), load_config(), load_config_meetme(), load_indications(), 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().

00828 {
00829    struct ast_category *cat, *catn;
00830 
00831    if (!cfg)
00832       return;
00833 
00834    ast_includes_destroy(cfg->includes);
00835 
00836    cat = cfg->root;
00837    while (cat) {
00838       catn = cat;
00839       cat = cat->next;
00840       ast_category_destroy(catn);
00841    }
00842    ast_free(cfg);
00843 }

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deregister config engine.

Return values:
0 Always

Definition at line 1966 of file config.c.

References ast_mutex_lock(), ast_mutex_unlock(), config_lock, last, and ast_config_engine::next.

Referenced by unload_module().

01967 {
01968    struct ast_config_engine *ptr, *last=NULL;
01969 
01970    ast_mutex_lock(&config_lock);
01971 
01972    for (ptr = config_engine_list; ptr; ptr=ptr->next) {
01973       if (ptr == del) {
01974          if (last)
01975             last->next = ptr->next;
01976          else
01977             config_engine_list = ptr->next;
01978          break;
01979       }
01980       last = ptr;
01981    }
01982 
01983    ast_mutex_unlock(&config_lock);
01984 
01985    return 0;
01986 }

int ast_config_engine_register ( struct ast_config_engine newconfig  ) 

Register config engine.

Return values:
1 Always

Definition at line 1947 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().

01948 {
01949    struct ast_config_engine *ptr;
01950 
01951    ast_mutex_lock(&config_lock);
01952 
01953    if (!config_engine_list) {
01954       config_engine_list = new;
01955    } else {
01956       for (ptr = config_engine_list; ptr->next; ptr=ptr->next);
01957       ptr->next = new;
01958    }
01959 
01960    ast_mutex_unlock(&config_lock);
01961    ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name);
01962 
01963    return 1;
01964 }

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

References ast_config::current.

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

00846 {
00847    return cfg->current;
00848 }

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

References ast_log(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, 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().

02029 {
02030    char db[256];
02031    char table[256];
02032    struct ast_config_engine *loader = &text_file_engine;
02033    struct ast_config *result; 
02034 
02035    /* The config file itself bumps include_level by 1 */
02036    if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) {
02037       ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
02038       return NULL;
02039    }
02040 
02041    cfg->include_level++;
02042 
02043    if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) {
02044       struct ast_config_engine *eng;
02045 
02046       eng = find_engine(filename, db, sizeof(db), table, sizeof(table));
02047 
02048 
02049       if (eng && eng->load_func) {
02050          loader = eng;
02051       } else {
02052          eng = find_engine("global", db, sizeof(db), table, sizeof(table));
02053          if (eng && eng->load_func)
02054             loader = eng;
02055       }
02056    }
02057 
02058    result = loader->load_func(db, table, filename, cfg, flags, suggested_include_file, who_asked);
02059 
02060    if (result && result != CONFIG_STATUS_FILEINVALID && result != CONFIG_STATUS_FILEUNCHANGED)
02061       result->include_level--;
02062    else if (result != CONFIG_STATUS_FILEINVALID)
02063       cfg->include_level--;
02064 
02065    return result;
02066 }

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

References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), CONFIG_STATUS_FILEINVALID, 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_cli_perms_init(), ast_plc_reload(), ast_readconfig(), do_reload(), iax_provision_reload(), init_logger_chain(), load_config(), load_indications(), load_modules(), misdn_cfg_init(), private_enum_init(), and run_startup_commands().

02069 {
02070    struct ast_config *cfg;
02071    struct ast_config *result;
02072 
02073    cfg = ast_config_new();
02074    if (!cfg)
02075       return NULL;
02076 
02077    result = ast_config_internal_load(filename, cfg, flags, "", who_asked);
02078    if (!result || result == CONFIG_STATUS_FILEUNCHANGED || result == CONFIG_STATUS_FILEINVALID)
02079       ast_config_destroy(cfg);
02080 
02081    return result;
02082 }

struct ast_config* ast_config_new ( void   )  [read]

Create a new base configuration structure.

Definition at line 673 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().

00674 {
00675    struct ast_config *config;
00676 
00677    if ((config = ast_calloc(1, sizeof(*config))))
00678       config->max_include_level = MAX_INCLUDE_LEVEL;
00679    return config;
00680 }

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

References ast_variable_retrieve().

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

00425 {
00426    const char *tmp;
00427    tmp = ast_variable_retrieve(cfg, cat, var);
00428    if (!tmp) {
00429       tmp = ast_variable_retrieve(cfg, "general", var);
00430    }
00431    return tmp;
00432 }

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

References ast_config::current.

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

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

Definition at line 1586 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_category::next, ast_variable::next, ast_comment::next, ast_config_include::next, ast_variable::object, option_debug, ast_config_include::output, ast_variable::precomments, ast_category::precomments, ast_category::root, ast_config::root, ast_variable::sameline, ast_category::sameline, set_fn(), ast_category::template_instances, ast_variable::trailing, ast_category::trailing, ast_variable::value, and var.

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

01587 {
01588    FILE *f;
01589    char fn[256];
01590    struct ast_variable *var;
01591    struct ast_category *cat;
01592    struct ast_comment *cmt;
01593    struct ast_config_include *incl;
01594    int blanklines = 0;
01595    struct ao2_container *fileset = ao2_container_alloc(180000, hash_string, hashtab_compare_strings);
01596    struct inclfile *fi = 0;
01597 
01598    /* reset all the output flags, in case this isn't our first time saving this data */
01599 
01600    for (incl=cfg->includes; incl; incl = incl->next)
01601       incl->output = 0;
01602 
01603    /* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions)
01604       are all truncated to zero bytes and have that nice header*/
01605 
01606    for (incl=cfg->includes; incl; incl = incl->next)
01607    {
01608       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*/
01609          FILE *f1;
01610 
01611          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 */
01612          f1 = fopen(fn,"w");
01613          if (f1) {
01614             gen_header(f1, configfile, fn, generator);
01615             fclose(f1); /* this should zero out the file */
01616          } else {
01617             ast_debug(1, "Unable to open for writing: %s\n", fn);
01618             ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
01619          }
01620          ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01621          fi = 0;
01622       }
01623    }
01624 
01625    set_fn(fn, sizeof(fn), 0, configfile, fileset, &fi); /* just set fn to absolute ver of configfile */
01626 #ifdef __CYGWIN__ 
01627    if ((f = fopen(fn, "w+"))) {
01628 #else
01629    if ((f = fopen(fn, "w"))) {
01630 #endif       
01631       ast_verb(2, "Saving '%s': ", fn);
01632       gen_header(f, configfile, fn, generator);
01633       cat = cfg->root;
01634       fclose(f);
01635       ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01636       
01637       /* from here out, we open each involved file and concat the stuff we need to add to the end and immediately close... */
01638       /* since each var, cat, and associated comments can come from any file, we have to be 
01639          mobile, and open each file, print, and close it on an entry-by-entry basis */
01640 
01641       while (cat) {
01642          set_fn(fn, sizeof(fn), cat->file, configfile, fileset, &fi);
01643          f = fopen(fn, "a");
01644          if (!f)
01645          {
01646             ast_debug(1, "Unable to open for writing: %s\n", fn);
01647             ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
01648             ao2_ref(fileset, -1);
01649             return -1;
01650          }
01651 
01652          /* dump any includes that happen before this category header */
01653          for (incl=cfg->includes; incl; incl = incl->next) {
01654             if (strcmp(incl->include_location_file, cat->file) == 0){
01655                if (cat->lineno > incl->include_location_lineno && !incl->output) {
01656                   if (incl->exec)
01657                      fprintf(f,"#exec \"%s\"\n", incl->exec_file);
01658                   else
01659                      fprintf(f,"#include \"%s\"\n", incl->included_file);
01660                   incl->output = 1;
01661                }
01662             }
01663          }
01664 
01665          insert_leading_blank_lines(f, fi, cat->precomments, cat->lineno);
01666          /* Dump section with any appropriate comment */
01667          for (cmt = cat->precomments; cmt; cmt=cmt->next) {
01668             char *cmtp = cmt->cmt;
01669             while (*cmtp == ';' && *(cmtp+1) == '!') {
01670                char *cmtp2 = strchr(cmtp+1, '\n');
01671                if (cmtp2)
01672                   cmtp = cmtp2+1;
01673                else cmtp = 0;
01674             }
01675             if (cmtp)
01676                fprintf(f,"%s", cmtp);
01677          }
01678          fprintf(f, "[%s]", cat->name);
01679          if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) {
01680             fprintf(f, "(");
01681             if (cat->ignored) {
01682                fprintf(f, "!");
01683             }
01684             if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) {
01685                fprintf(f, ",");
01686             }
01687             if (!AST_LIST_EMPTY(&cat->template_instances)) {
01688                struct ast_category_template_instance *x;
01689                AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
01690                   fprintf(f,"%s",x->name);
01691                   if (x != AST_LIST_LAST(&cat->template_instances))
01692                      fprintf(f,",");
01693                }
01694             }
01695             fprintf(f, ")");
01696          }
01697          for(cmt = cat->sameline; cmt; cmt=cmt->next)
01698          {
01699             fprintf(f,"%s", cmt->cmt);
01700          }
01701          if (!cat->sameline)
01702             fprintf(f,"\n");
01703          for (cmt = cat->trailing; cmt; cmt=cmt->next) {
01704             if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
01705                fprintf(f,"%s", cmt->cmt);
01706          }
01707          fclose(f);
01708          ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01709          fi = 0;
01710          
01711          var = cat->root;
01712          while (var) {
01713             struct ast_category_template_instance *x;
01714             int found = 0;
01715             AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
01716                struct ast_variable *v;
01717                for (v = x->inst->root; v; v = v->next) {
01718                   if (!strcasecmp(var->name, v->name) && !strcmp(var->value, v->value)) {
01719                      found = 1;
01720                      break;
01721                   }
01722                }
01723                if (found)
01724                   break;
01725             }
01726             if (found) {
01727                var = var->next;
01728                continue;
01729             }
01730             set_fn(fn, sizeof(fn), var->file, configfile, fileset, &fi);
01731             f = fopen(fn, "a");
01732             if (!f)
01733             {
01734                ast_debug(1, "Unable to open for writing: %s\n", fn);
01735                ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
01736                ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01737                fi = 0;
01738                ao2_ref(fileset, -1);
01739                return -1;
01740             }
01741             
01742             /* dump any includes that happen before this category header */
01743             for (incl=cfg->includes; incl; incl = incl->next) {
01744                if (strcmp(incl->include_location_file, var->file) == 0){
01745                   if (var->lineno > incl->include_location_lineno && !incl->output) {
01746                      if (incl->exec)
01747                         fprintf(f,"#exec \"%s\"\n", incl->exec_file);
01748                      else
01749                         fprintf(f,"#include \"%s\"\n", incl->included_file);
01750                      incl->output = 1;
01751                   }
01752                }
01753             }
01754             
01755             insert_leading_blank_lines(f, fi, var->precomments, var->lineno);
01756             for (cmt = var->precomments; cmt; cmt=cmt->next) {
01757                if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
01758                   fprintf(f,"%s", cmt->cmt);
01759             }
01760             if (var->sameline) 
01761                fprintf(f, "%s %s %s  %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt);
01762             else  
01763                fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value);
01764             for (cmt = var->trailing; cmt; cmt=cmt->next) {
01765                if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
01766                   fprintf(f,"%s", cmt->cmt);
01767             }
01768             if (var->blanklines) {
01769                blanklines = var->blanklines;
01770                while (blanklines--)
01771                   fprintf(f, "\n");
01772             }
01773             
01774             fclose(f);
01775             ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01776             fi = 0;
01777             
01778             var = var->next;
01779          }
01780          cat = cat->next;
01781       }
01782       if (!option_debug)
01783          ast_verb(2, "Saved\n");
01784    } else {
01785       ast_debug(1, "Unable to open for writing: %s\n", fn);
01786       ast_verb(2, "Unable to write (%s)", strerror(errno));
01787       ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01788       ao2_ref(fileset, -1);
01789       return -1;
01790    }
01791 
01792    /* Now, for files with trailing #include/#exec statements,
01793       we have to make sure every entry is output */
01794 
01795    for (incl=cfg->includes; incl; incl = incl->next) {
01796       if (!incl->output) {
01797          /* open the respective file */
01798          set_fn(fn, sizeof(fn), incl->include_location_file, configfile, fileset, &fi);
01799          f = fopen(fn, "a");
01800          if (!f)
01801          {
01802             ast_debug(1, "Unable to open for writing: %s\n", fn);
01803             ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno));
01804             ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01805             fi = 0;
01806             ao2_ref(fileset, -1);
01807             return -1;
01808          }
01809          
01810          /* output the respective include */
01811          if (incl->exec)
01812             fprintf(f,"#exec \"%s\"\n", incl->exec_file);
01813          else
01814             fprintf(f,"#include \"%s\"\n", incl->included_file);
01815          fclose(f);
01816          incl->output = 1;
01817          ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */
01818          fi = 0;
01819       }
01820    }
01821    ao2_ref(fileset, -1); /* this should destroy the hash container */
01822             
01823    return 0;
01824 }

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

Destroy realtime configuration.

Parameters:
family which family/config to be destroyed
keyfield which field to use as the key
lookup which value to look for in the key field to match the entry. This function is used to destroy an entry in realtime configuration space. Additional params are used as keys.
Returns:
Number of rows affected, or -1 on error.
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 2263 of file config.c.

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

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

02264 {
02265    struct ast_config_engine *eng;
02266    int res = -1;
02267    char db[256];
02268    char table[256];
02269    va_list ap;
02270 
02271    va_start(ap, lookup);
02272    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02273    if (eng && eng->destroy_func) 
02274       res = eng->destroy_func(db, table, keyfield, lookup, ap);
02275    va_end(ap);
02276 
02277    return res;
02278 }

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

Definition at line 337 of file config.c.

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

Referenced by ast_include_new().

00338 {
00339    struct ast_config_include *x;
00340    for (x=conf->includes;x;x=x->next) {
00341       if (strcmp(x->included_file,included_file) == 0)
00342          return x;
00343    }
00344    return 0;
00345 }

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

00247 {
00248    /* a file should be included ONCE. Otherwise, if one of the instances is changed,
00249     * then all be changed. -- how do we know to include it? -- Handling modified 
00250     * instances is possible, I'd have
00251     * to create a new master for each instance. */
00252    struct ast_config_include *inc;
00253    struct stat statbuf;
00254    
00255    inc = ast_include_find(conf, included_file);
00256    if (inc) {
00257       do {
00258          inc->inclusion_count++;
00259          snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count);
00260       } while (stat(real_included_file_name, &statbuf) == 0);
00261       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);
00262    } else
00263       *real_included_file_name = 0;
00264    
00265    inc = ast_calloc(1,sizeof(struct ast_config_include));
00266    inc->include_location_file = ast_strdup(from_file);
00267    inc->include_location_lineno = from_lineno;
00268    if (!ast_strlen_zero(real_included_file_name))
00269       inc->included_file = ast_strdup(real_included_file_name);
00270    else
00271       inc->included_file = ast_strdup(included_file);
00272    
00273    inc->exec = is_exec;
00274    if (is_exec)
00275       inc->exec_file = ast_strdup(exec_file);
00276    
00277    /* attach this new struct to the conf struct */
00278    inc->next = conf->includes;
00279    conf->includes = inc;
00280    
00281    return inc;
00282 }

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

Definition at line 284 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_category::next, ast_config_include::next, ast_category::root, ast_config::root, and strdup.

Referenced by action_updateconfig().

00285 {
00286    struct ast_config_include *incl;
00287    struct ast_category *cat;
00288    struct ast_variable *v;
00289    
00290    int from_len = strlen(from_file);
00291    int to_len = strlen(to_file);
00292    
00293    if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */
00294       return;
00295    
00296    /* the manager code allows you to read in one config file, then
00297     * write it back out under a different name. But, the new arrangement
00298     * ties output lines to the file name. So, before you try to write
00299     * the config file to disk, better riffle thru the data and make sure
00300     * the file names are changed.
00301     */
00302    /* file names are on categories, includes (of course), and on variables. So,
00303     * traverse all this and swap names */
00304 
00305    for (incl = conf->includes; incl; incl=incl->next) {
00306       if (strcmp(incl->include_location_file,from_file) == 0) {
00307          if (from_len >= to_len)
00308             strcpy(incl->include_location_file, to_file);
00309          else {
00310             free(incl->include_location_file);
00311             incl->include_location_file = strdup(to_file);
00312          }
00313       }
00314    }
00315    for (cat = conf->root; cat; cat = cat->next) {
00316       if (strcmp(cat->file,from_file) == 0) {
00317          if (from_len >= to_len)
00318             strcpy(cat->file, to_file);
00319          else {
00320             free(cat->file);
00321             cat->file = strdup(to_file);
00322          }
00323       }
00324       for (v = cat->root; v; v = v->next) {
00325          if (strcmp(v->file,from_file) == 0) {
00326             if (from_len >= to_len)
00327                strcpy(v->file, to_file);
00328             else {
00329                free(v->file);
00330                v->file = strdup(to_file);
00331             }
00332          }
00333       }
00334    }
00335 }

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

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

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

02111 {
02112    struct ast_variable *res, *cur, *prev = NULL, *freeme = NULL;
02113    va_list ap;
02114 
02115    va_start(ap, family);
02116    res = ast_load_realtime_helper(family, ap);
02117    va_end(ap);
02118 
02119    /* Eliminate blank entries */
02120    for (cur = res; cur; cur = cur->next) {
02121       if (freeme) {
02122          ast_free(freeme);
02123          freeme = NULL;
02124       }
02125 
02126       if (ast_strlen_zero(cur->value)) {
02127          if (prev)
02128             prev->next = cur->next;
02129          else
02130             res = cur->next;
02131          freeme = cur;
02132       } else if (cur->value[0] == ' ' && cur->value[1] == '\0') {
02133          char *vptr = (char *) cur->value;
02134          vptr[0] = '\0';
02135          prev = cur;
02136       } else {
02137          prev = cur;
02138       }
02139    }
02140    return res;
02141 }

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

Definition at line 2098 of file config.c.

References ast_load_realtime_helper().

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

02099 {
02100    struct ast_variable *res;
02101    va_list ap;
02102 
02103    va_start(ap, family);
02104    res = ast_load_realtime_helper(family, ap);
02105    va_end(ap);
02106 
02107    return res;
02108 }

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.

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

Definition at line 2195 of file config.c.

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

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

02196 {
02197    struct ast_config_engine *eng;
02198    char db[256];
02199    char table[256];
02200    struct ast_config *res = NULL;
02201    va_list ap;
02202 
02203    va_start(ap, family);
02204    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02205    if (eng && eng->realtime_multi_func) 
02206       res = eng->realtime_multi_func(db, table, ap);
02207    va_end(ap);
02208 
02209    return res;
02210 }

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 2283 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_http_load(), ast_sip_ouraddrfor(), check_via_response(), and reload_config().

02285 {
02286    va_list ap;
02287    int error = 0;
02288 
02289    va_start(ap, p_result);
02290    switch (flags & PARSE_TYPE) {
02291    case PARSE_INT32:
02292        {
02293       int32_t *result = p_result;
02294       int32_t x, def = result ? *result : 0,
02295          high = (int32_t)0x7fffffff,
02296          low  = (int32_t)0x80000000;
02297       /* optional argument: first default value, then range */
02298       if (flags & PARSE_DEFAULT)
02299          def = va_arg(ap, int32_t);
02300       if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
02301          /* range requested, update bounds */
02302          low = va_arg(ap, int32_t);
02303          high = va_arg(ap, int32_t);
02304       }
02305       x = strtol(arg, NULL, 0);
02306       error = (x < low) || (x > high);
02307       if (flags & PARSE_OUT_RANGE)
02308          error = !error;
02309       if (result)
02310          *result  = error ? def : x;
02311       ast_debug(3,
02312          "extract int from [%s] in [%d, %d] gives [%d](%d)\n",
02313          arg, low, high,
02314          result ? *result : x, error);
02315       break;
02316        }
02317 
02318    case PARSE_UINT32:
02319        {
02320       uint32_t *result = p_result;
02321       uint32_t x, def = result ? *result : 0,
02322          low = 0, high = (uint32_t)~0;
02323       /* optional argument: first default value, then range */
02324       if (flags & PARSE_DEFAULT)
02325          def = va_arg(ap, uint32_t);
02326       if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
02327          /* range requested, update bounds */
02328          low = va_arg(ap, uint32_t);
02329          high = va_arg(ap, uint32_t);
02330       }
02331       x = strtoul(arg, NULL, 0);
02332       error = (x < low) || (x > high);
02333       if (flags & PARSE_OUT_RANGE)
02334          error = !error;
02335       if (result)
02336          *result  = error ? def : x;
02337       ast_debug(3,
02338          "extract uint from [%s] in [%u, %u] gives [%u](%d)\n",
02339          arg, low, high,
02340          result ? *result : x, error);
02341       break;
02342        }
02343 
02344    case PARSE_DOUBLE:
02345        {
02346       double *result = p_result;
02347       double x, def = result ? *result : 0,
02348          low = -HUGE_VAL, high = HUGE_VAL;
02349 
02350       /* optional argument: first default value, then range */
02351       if (flags & PARSE_DEFAULT)
02352          def = va_arg(ap, double);
02353       if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) {
02354          /* range requested, update bounds */
02355          low = va_arg(ap, double);
02356          high = va_arg(ap, double);
02357       }
02358       x = strtod(arg, NULL);
02359       error = (x < low) || (x > high);
02360       if (flags & PARSE_OUT_RANGE)
02361          error = !error;
02362       if (result)
02363          *result  = error ? def : x;
02364       ast_debug(3,
02365          "extract double from [%s] in [%f, %f] gives [%f](%d)\n",
02366          arg, low, high,
02367          result ? *result : x, error);
02368       break;
02369        }
02370    case PARSE_INADDR:
02371        {
02372       char *port, *buf;
02373       struct sockaddr_in _sa_buf;   /* buffer for the result */
02374       struct sockaddr_in *sa = p_result ?
02375          (struct sockaddr_in *)p_result : &_sa_buf;
02376       /* default is either the supplied value or the result itself */
02377       struct sockaddr_in *def = (flags & PARSE_DEFAULT) ?
02378          va_arg(ap, struct sockaddr_in *) : sa;
02379       struct hostent *hp;
02380       struct ast_hostent ahp;
02381 
02382       memset(&_sa_buf, '\0', sizeof(_sa_buf)); /* clear buffer */
02383       /* duplicate the string to strip away the :port */
02384       port = ast_strdupa(arg);
02385       buf = strsep(&port, ":");
02386       sa->sin_family = AF_INET;  /* assign family */
02387       /*
02388        * honor the ports flag setting, assign default value
02389        * in case of errors or field unset.
02390        */
02391       flags &= PARSE_PORT_MASK; /* the only flags left to process */
02392       if (port) {
02393          if (flags == PARSE_PORT_FORBID) {
02394             error = 1;  /* port was forbidden */
02395             sa->sin_port = def->sin_port;
02396          } else if (flags == PARSE_PORT_IGNORE)
02397             sa->sin_port = def->sin_port;
02398          else /* accept or require */
02399             sa->sin_port = htons(strtol(port, NULL, 0));
02400       } else {
02401          sa->sin_port = def->sin_port;
02402          if (flags == PARSE_PORT_REQUIRE)
02403             error = 1;
02404       }
02405       /* Now deal with host part, even if we have errors before. */
02406       hp = ast_gethostbyname(buf, &ahp);
02407       if (hp)  /* resolved successfully */
02408          memcpy(&sa->sin_addr, hp->h_addr, sizeof(sa->sin_addr));
02409       else {
02410          error = 1;
02411          sa->sin_addr = def->sin_addr;
02412       }
02413       ast_debug(3,
02414          "extract inaddr from [%s] gives [%s:%d](%d)\n",
02415          arg, ast_inet_ntoa(sa->sin_addr),
02416          ntohs(sa->sin_port), error);
02417          break;
02418        }
02419    }
02420    va_end(ap);
02421    return error;
02422 }

int ast_realtime_enabled ( void   ) 

Check if there's any realtime engines loaded.

Definition at line 2158 of file config.c.

References config_maps.

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

02159 {
02160    return config_maps ? 1 : 0;
02161 }

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

02164 {
02165    struct ast_config_engine *eng;
02166    char db[256];
02167    char table[256];
02168    va_list ap;
02169    int res = -1;
02170 
02171    va_start(ap, family);
02172    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02173    if (eng && eng->require_func) {
02174       res = eng->require_func(db, table, ap);
02175    }
02176    va_end(ap);
02177 
02178    return res;
02179 }

int ast_rq_is_int ( require_type  type  )  [inline]

Check if require type is an integer type.

Definition at line 607 of file config.h.

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

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.
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 2246 of file config.c.

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

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

02247 {
02248    struct ast_config_engine *eng;
02249    int res = -1;
02250    char db[256];
02251    char table[256];
02252    va_list ap;
02253 
02254    va_start(ap, family);
02255    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02256    if (eng && eng->store_func) 
02257       res = eng->store_func(db, table, ap);
02258    va_end(ap);
02259 
02260    return res;
02261 }

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

02182 {
02183    struct ast_config_engine *eng;
02184    char db[256];
02185    char table[256];
02186    int res = -1;
02187 
02188    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02189    if (eng && eng->unload_func) {
02190       res = eng->unload_func(db, table);
02191    }
02192    return res;
02193 }

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

Update realtime configuration.

Parameters:
family which family/config to be updated This function is used to update a parameter in realtime configuration space. It includes the ability to lookup a row based upon multiple key criteria. As a result, this function includes two sentinel values, one to terminate lookup values and the other to terminate the listing of fields to update.
Returns:
Number of rows affected, or -1 on error.
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 2229 of file config.c.

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

Referenced by change_password_realtime(), and cli_realtime_update2().

02230 {
02231    struct ast_config_engine *eng;
02232    int res = -1;
02233    char db[256];
02234    char table[256];
02235    va_list ap;
02236 
02237    va_start(ap, family);
02238    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02239    if (eng && eng->update2_func) 
02240       res = eng->update2_func(db, table, ap);
02241    va_end(ap);
02242 
02243    return res;
02244 }

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

Update realtime configuration.

Parameters:
family which family/config to be updated
keyfield which field to use as the key
lookup which value to look for in the key field to match the entry. This function is used to update a parameter in realtime configuration space.
Returns:
Number of rows affected, or -1 on error.
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.

Definition at line 2212 of file config.c.

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

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

02213 {
02214    struct ast_config_engine *eng;
02215    int res = -1;
02216    char db[256];
02217    char table[256];
02218    va_list ap;
02219 
02220    va_start(ap, lookup);
02221    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02222    if (eng && eng->update_func) 
02223       res = eng->update_func(db, table, keyfield, lookup, ap);
02224    va_end(ap);
02225 
02226    return res;
02227 }

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

Definition at line 348 of file config.c.

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

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

00349 {
00350    if (!variable)
00351       return;
00352    if (category->last)
00353       category->last->next = variable;
00354    else
00355       category->root = variable;
00356    category->last = variable;
00357    while (category->last->next)
00358       category->last = category->last->next;
00359 }

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

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

Referenced by __ast_http_load(), __ast_http_post_load(), __init_manager(), action_getconfig(), action_getconfigjson(), adsi_load(), aji_load_config(), ast_cli_perms_init(), ast_plc_reload(), ast_readconfig(), ast_variable_retrieve(), build_device(), build_event_channel(), check_tx_freq(), collect_function_digits(), conf_exec(), config_load(), config_module(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), iax_template_parse(), 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(), parse_tone_zone(), pbx_load_config(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_single_queue(), run_startup_commands(), search_directory_sub(), set_config(), setup_dahdi(), show_users_realtime(), sip_cli_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().

00412 {
00413    struct ast_category *cat = NULL;
00414 
00415    if (category && config->last_browse && (config->last_browse->name == category)) {
00416       cat = config->last_browse;
00417    } else {
00418       cat = ast_category_get(config, category);
00419    }
00420 
00421    return (cat) ? cat->root : NULL;
00422 }

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

Definition at line 682 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().

00683 {
00684    struct ast_variable *cur, *prev=NULL, *curn;
00685    int res = -1;
00686    int lineno = 0;
00687 
00688    cur = category->root;
00689    while (cur) {
00690       if (cur->name == variable) {
00691          if (prev) {
00692             prev->next = cur->next;
00693             if (cur == category->last)
00694                category->last = prev;
00695          } else {
00696             category->root = cur->next;
00697             if (cur == category->last)
00698                category->last = NULL;
00699          }
00700          cur->next = NULL;
00701          ast_variables_destroy(cur);
00702          return 0;
00703       }
00704       prev = cur;
00705       cur = cur->next;
00706    }
00707 
00708    prev = NULL;
00709    cur = category->root;
00710    while (cur) {
00711       curn = cur->next;
00712       if ((!ast_strlen_zero(line) && lineno == atoi(line)) || (ast_strlen_zero(line) && !strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match)))) {
00713          if (prev) {
00714             prev->next = cur->next;
00715             if (cur == category->last)
00716                category->last = prev;
00717          } else {
00718             category->root = cur->next;
00719             if (cur == category->last)
00720                category->last = NULL;
00721          }
00722          cur->next = NULL;
00723          ast_variables_destroy(cur);
00724          res = 0;
00725       } else
00726          prev = cur;
00727 
00728       cur = curn;
00729       lineno++;
00730    }
00731    return res;
00732 }

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

Definition at line 361 of file config.c.

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

Referenced by handle_updates().

00362 {
00363    struct ast_variable *cur = category->root;
00364    int lineno;
00365    int insertline;
00366 
00367    if (!variable || sscanf(line, "%30d", &insertline) != 1) {
00368       return;
00369    }
00370    if (!insertline) {
00371       variable->next = category->root;
00372       category->root = variable;
00373    } else {
00374       for (lineno = 1; lineno < insertline; lineno++) {
00375          cur = cur->next;
00376          if (!cur->next) {
00377             break;
00378          }
00379       }
00380       variable->next = cur->next;
00381       cur->next = variable;
00382    }
00383 }

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

Definition at line 223 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(), mkintf(), 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().

00225 {
00226    struct ast_variable *variable;
00227    int name_len = strlen(name) + 1; 
00228    int val_len = strlen(value) + 1; 
00229    int fn_len = strlen(filename) + 1;  
00230 
00231 #ifdef MALLOC_DEBUG
00232    if ((variable = __ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable), file, lineno, func))) {
00233 #else
00234    if ((variable = ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable)))) {
00235 #endif
00236       char *dst = variable->stuff;  /* writable space starts here */
00237       variable->name = strcpy(dst, name);
00238       dst += name_len;
00239       variable->value = strcpy(dst, value);
00240       dst += val_len;
00241       variable->file = strcpy(dst, filename);
00242    }
00243    return variable;
00244 }

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 435 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 __ast_rtp_reload(), __ast_udptl_reload(), __init_manager(), _dsp_init(), advanced_options(), aji_load_config(), ast_config_option(), build_extension(), conf_exec(), config_function_read(), config_module(), directory_exec(), do_reload(), do_scheduler(), festival_exec(), find_queue_by_name_rt(), find_realtime(), function_macro(), get_insecure_variable_from_config(), get_wait_interval(), gtalk_load_config(), iax_template_parse(), init_acf_query(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_indications(), 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(), queue_set_global_params(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_single_queue(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), rpt_telemetry(), saynode(), search_directory(), search_directory_sub(), 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().

00436 {
00437    struct ast_variable *v;
00438 
00439    if (category) {
00440       for (v = ast_variable_browse(config, category); v; v = v->next) {
00441          if (!strcasecmp(variable, v->name)) {
00442             return v->value;
00443          }
00444       }
00445    } else {
00446       struct ast_category *cat;
00447 
00448       for (cat = config->root; cat; cat = cat->next) {
00449          for (v = cat->root; v; v = v->next) {
00450             if (!strcasecmp(variable, v->name)) {
00451                return v->value;
00452             }
00453          }
00454       }
00455    }
00456 
00457    return NULL;
00458 }

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

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

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

00736 {
00737    struct ast_variable *cur, *prev=NULL, *newer=NULL;
00738 
00739    for (cur = category->root; cur; prev = cur, cur = cur->next) {
00740       if (strcasecmp(cur->name, variable) ||
00741          (!ast_strlen_zero(match) && strcasecmp(cur->value, match)))
00742          continue;
00743 
00744       if (!(newer = ast_variable_new(variable, value, cur->file)))
00745          return -1;
00746    
00747       newer->next = cur->next;
00748       newer->object = cur->object || object;
00749       if (prev)
00750          prev->next = newer;
00751       else
00752          category->root = newer;
00753       if (category->last == cur)
00754          category->last = newer;
00755 
00756       cur->next = NULL;
00757       ast_variables_destroy(cur);
00758 
00759       return 0;
00760    }
00761 
00762    /* Could not find variable to update */
00763    return -1;
00764 }

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

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

Referenced by __sip_destroy(), action_originate(), ast_category_destroy(), ast_category_empty(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_var_channel_types(), ast_var_channel_types_table(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), cli_realtime_load(), conf_run(), copy_plain_file(), destroy_dahdi_pvt(), find_conf_realtime(), find_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(), mkintf(), process_dahdi(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_handler(), realtime_ldap_base_ap(), realtime_ldap_result_to_vars(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), realtimefield_read(), rt_extend_conf(), sip_alloc(), sip_destroy_peer(), socket_process(), table_configs_free(), and user_destructor().

00398 {
00399    struct ast_variable *vn;
00400 
00401    while (v) {
00402       vn = v;
00403       v = v->next;
00404       ast_comment_destroy(&vn->precomments);
00405       ast_comment_destroy(&vn->sameline);
00406       ast_comment_destroy(&vn->trailing);
00407       ast_free(vn);
00408    }
00409 }

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

Definition at line 1581 of file config.c.

References ast_config_text_file_save().

01582 {
01583    return ast_config_text_file_save(configfile, cfg, generator);
01584 }

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 1874 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, CONFIG_STATUS_FILEINVALID, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, strsep(), table, and ast_variable::value.

Referenced by main().

01875 {
01876    struct ast_config *config, *configtmp;
01877    struct ast_variable *v;
01878    char *driver, *table, *database, *stringp, *tmp;
01879    struct ast_flags flags = { 0 };
01880 
01881    clear_config_maps();
01882 
01883    configtmp = ast_config_new();
01884    configtmp->max_include_level = 1;
01885    config = ast_config_internal_load(extconfig_conf, configtmp, flags, "", "extconfig");
01886    if (config == CONFIG_STATUS_FILEINVALID) {
01887       return -1;
01888    } else if (!config) {
01889       ast_config_destroy(configtmp);
01890       return 0;
01891    }
01892 
01893    for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
01894       char buf[512];
01895       ast_copy_string(buf, v->value, sizeof(buf));
01896       stringp = buf;
01897       driver = strsep(&stringp, ",");
01898 
01899       if ((tmp = strchr(stringp, '\"')))
01900          stringp = tmp;
01901 
01902       /* check if the database text starts with a double quote */
01903       if (*stringp == '"') {
01904          stringp++;
01905          database = strsep(&stringp, "\"");
01906          strsep(&stringp, ",");
01907       } else {
01908          /* apparently this text has no quotes */
01909          database = strsep(&stringp, ",");
01910       }
01911 
01912       table = strsep(&stringp, ",");
01913 
01914       if (!strcmp(v->name, extconfig_conf)) {
01915          ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf);
01916          continue;
01917       }
01918 
01919       if (!strcmp(v->name, "asterisk.conf")) {
01920          ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n");
01921          continue;
01922       }
01923 
01924       if (!strcmp(v->name, "logger.conf")) {
01925          ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n");
01926          continue;
01927       }
01928 
01929       if (!driver || !database)
01930          continue;
01931       if (!strcasecmp(v->name, "sipfriends")) {
01932          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");
01933          append_mapping("sipusers", driver, database, table ? table : "sipfriends");
01934          append_mapping("sippeers", driver, database, table ? table : "sipfriends");
01935       } else if (!strcasecmp(v->name, "iaxfriends")) {
01936          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");
01937          append_mapping("iaxusers", driver, database, table ? table : "iaxfriends");
01938          append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends");
01939       } else 
01940          append_mapping(v->name, driver, database, table);
01941    }
01942       
01943    ast_config_destroy(config);
01944    return 0;
01945 }

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

References ARRAY_LEN, and ast_cli_register_multiple().

Referenced by main().

02554 {
02555    ast_cli_register_multiple(cli_config, ARRAY_LEN(cli_config));
02556    return 0;
02557 }


Generated on Thu Oct 11 06:48:39 2012 for Asterisk - the Open Source PBX by  doxygen 1.5.6