Fri Jun 19 12:10:31 2009

Asterisk developer's documentation


config.h File Reference

Configuration File Parser. More...

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

Go to the source code of this file.

Data Structures

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

Defines

#define ast_config_load(filename, flags)   ast_config_load2(filename, AST_MODULE, flags)
#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1
#define CV_BOOL(__x, __dst)   CV_F(__x, (__dst) = ast_true(__val) )
 helper macros to assign the value to a BOOL, UINT, static string and dynamic string
#define CV_DSTR(__x, __dst)   CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val))
#define CV_END   } while (0)
 close a variable parsing block
#define CV_F(__pattern, __body)   if (!strcasecmp((__var), __pattern)) { __body; break; }
 call a generic function if the name matches.
#define CV_START(__in_var, __in_val)
 the macro to open a block for variable parsing
#define CV_STR(__x, __dst)   CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst)))
#define CV_STRFIELD(__x, __obj, __field)   CV_F(__x, ast_string_field_set(__obj, __field, __val))
#define CV_UINT(__x, __dst)   CV_F(__x, (__dst) = strtoul(__val, NULL, 0) )

Typedefs

typedef 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 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 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)
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.
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())
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.
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)
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.
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.
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)
ast_configast_config_load2 (const char *filename, const char *who_asked, struct ast_flags flags)
 Load a config file.
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_destroy_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel
 Destroy realtime configuration.
ast_config_includeast_include_find (struct ast_config *conf, const char *included_file)
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)
ast_variableast_load_realtime (const char *family,...) attribute_sentinel
 Retrieve realtime configuration.
ast_variableast_load_realtime_all (const char *family,...) attribute_sentinel
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_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)
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)
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)

Definition at line 135 of file config.h.

Referenced by adsi_load(), advanced_options(), aji_load_config(), conf_exec(), config_function_read(), config_module(), directory_exec(), festival_exec(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), ind_load_module(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), vm_change_password(), and vm_forwardoptions().

#define CONFIG_STATUS_FILEUNCHANGED   (void *)-1

Definition at line 48 of file config.h.

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

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

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

Definition at line 552 of file config.h.

Referenced by store_config_core().

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

Definition at line 555 of file config.h.

#define CV_END   } while (0)

close a variable parsing block

Definition at line 544 of file config.h.

Referenced by store_config_core().

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

call a generic function if the name matches.

Definition at line 547 of file config.h.

Referenced by store_config_core().

#define CV_START ( __in_var,
__in_val   ) 

Value:

do {              \
      const char *__var = __in_var; \
      const char *__val = __in_val;
the macro to open a block for variable parsing

Definition at line 538 of file config.h.

Referenced by store_config_core().

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

Definition at line 554 of file config.h.

Referenced by store_config_core().

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

Definition at line 556 of file config.h.

Referenced by store_config_core().

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

Definition at line 553 of file config.h.

Referenced by store_config_core().


Typedef Documentation

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

Definition at line 88 of file config.h.

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

Definition at line 93 of file config.h.

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

Definition at line 90 of file config.h.

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

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

Since:
1.6.1

Definition at line 99 of file config.h.

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

Definition at line 92 of file config.h.

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

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

Since:
1.6.1

Definition at line 105 of file config.h.

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

Definition at line 91 of file config.h.

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

Definition at line 89 of file config.h.


Enumeration Type Documentation

anonymous enum

Options for ast_config_load()

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

Definition at line 39 of file config.h.

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

enum ast_parse_flags

Support code to parse config file arguments.

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

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

Definition at line 443 of file config.h.

00443                      {
00444    /* low 4 bits of flags are used for the operand type */
00445    PARSE_TYPE  =  0x000f,
00446    /* numeric types, with optional default value and bound checks.
00447     * Additional arguments are passed by value.
00448     */
00449    PARSE_INT32 =  0x0001,
00450    PARSE_UINT32   =  0x0002,
00451    PARSE_DOUBLE   =  0x0003,
00452 #if 0 /* not supported yet */
00453    PARSE_INT16 =  0x0004,
00454    PARSE_UINT16   =  0x0005,
00455 #endif
00456    /* Returns a struct sockaddr_in, with optional default value
00457     * (passed by reference) and port handling (accept, ignore,
00458     * require, forbid). The format is 'host.name[:port]'
00459     */
00460    PARSE_INADDR   =  0x000f,
00461 
00462    /* Other data types can be added as needed */
00463 
00464    /* If PARSE_DEFAULT is set, next argument is a default value
00465     * which is returned in case of error. The argument is passed
00466     * by value in case of numeric types, by reference in other cases.
00467     */
00468    PARSE_DEFAULT  =  0x0010,  /* assign default on error */
00469 
00470    /* Request a range check, applicable to numbers. Two additional
00471     * arguments are passed by value, specifying the low-high end of
00472     * the range (inclusive). An error is returned if the value
00473     * is outside or inside the range, respectively.
00474     */
00475    PARSE_IN_RANGE =  0x0020,  /* accept values inside a range */
00476    PARSE_OUT_RANGE = 0x0040,  /* accept values outside a range */
00477 
00478    /* Port handling, for sockaddr_in. accept/ignore/require/forbid
00479     * port number after the hostname or address.
00480     */
00481    PARSE_PORT_MASK = 0x0300, /* 0x000: accept port if present */
00482    PARSE_PORT_IGNORE =  0x0100, /* 0x100: ignore port if present */
00483    PARSE_PORT_REQUIRE = 0x0200, /* 0x200: require port number */
00484    PARSE_PORT_FORBID =  0x0300, /* 0x100: forbid port number */
00485 };

enum require_type

Types used in ast_realtime_require_field.

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

Definition at line 53 of file config.h.

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


Function Documentation

void ast_category_append ( struct ast_config config,
struct ast_category cat 
)

Definition at line 512 of file config.c.

References config, and ast_category::include_level.

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

00513 {
00514    if (config->last)
00515       config->last->next = category;
00516    else
00517       config->root = category;
00518    category->include_level = config->include_level;
00519    config->last = category;
00520    config->current = category;
00521 }

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

References config, ast_category::name, ast_category::next, and next_available_category().

Referenced by __queues_show(), action_getconfig(), action_getconfigjson(), action_listcategories(), aji_load_config(), complete_sipnotify(), get_insecure_variable_from_config(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), jingle_load_config(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), misdn_cfg_init(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), search_directory(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), update_realtime_members(), and vm_change_password().

00623 {  
00624    struct ast_category *cat = NULL;
00625 
00626    if (prev && config->last_browse && (config->last_browse->name == prev))
00627       cat = config->last_browse->next;
00628    else if (!prev && config->root)
00629       cat = config->root;
00630    else if (prev) {
00631       for (cat = config->root; cat; cat = cat->next) {
00632          if (cat->name == prev) {
00633             cat = cat->next;
00634             break;
00635          }
00636       }
00637       if (!cat) {
00638          for (cat = config->root; cat; cat = cat->next) {
00639             if (!strcasecmp(cat->name, prev)) {
00640                cat = cat->next;
00641                break;
00642             }
00643          }
00644       }
00645    }
00646    
00647    if (cat)
00648       cat = next_available_category(cat);
00649 
00650    config->last_browse = cat;
00651    return (cat) ? cat->name : NULL;
00652 }

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

Definition at line 775 of file config.c.

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

Referenced by handle_updates().

00776 {
00777    struct ast_category *prev=NULL, *cat;
00778 
00779    cat = cfg->root;
00780    while (cat) {
00781       if (cat->name == category) {
00782          if (prev) {
00783             prev->next = cat->next;
00784             if (cat == cfg->last)
00785                cfg->last = prev;
00786          } else {
00787             cfg->root = cat->next;
00788             if (cat == cfg->last)
00789                cfg->last = NULL;
00790          }
00791          ast_category_destroy(cat);
00792          return 0;
00793       }
00794       prev = cat;
00795       cat = cat->next;
00796    }
00797 
00798    prev = NULL;
00799    cat = cfg->root;
00800    while (cat) {
00801       if (!strcasecmp(cat->name, category)) {
00802          if (prev) {
00803             prev->next = cat->next;
00804             if (cat == cfg->last)
00805                cfg->last = prev;
00806          } else {
00807             cfg->root = cat->next;
00808             if (cat == cfg->last)
00809                cfg->last = NULL;
00810          }
00811          ast_category_destroy(cat);
00812          return 0;
00813       }
00814       prev = cat;
00815       cat = cat->next;
00816    }
00817    return -1;
00818 }

void ast_category_destroy ( struct ast_category cat  ) 

Definition at line 572 of file config.c.

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

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

00573 {
00574    ast_variables_destroy(cat->root);
00575    if (cat->file) {
00576       free(cat->file);
00577       cat->file = 0;
00578    }
00579    ast_destroy_comments(cat);
00580    ast_destroy_template_list(cat);
00581    ast_free(cat);
00582 }

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 654 of file config.c.

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

Referenced by realtime_switch_common().

00655 {
00656    struct ast_variable *v;
00657 
00658    v = cat->root;
00659    cat->root = NULL;
00660    cat->last = NULL;
00661 
00662    return v;
00663 }

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

00821 {
00822    struct ast_category *cat;
00823 
00824    for (cat = cfg->root; cat; cat = cat->next) {
00825       if (!strcasecmp(cat->name, category))
00826          continue;
00827       ast_variables_destroy(cat->root);
00828       cat->root = NULL;
00829       cat->last = NULL;
00830       return 0;
00831    }
00832 
00833    return -1;
00834 }

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

References ast_category_get(), and config.

00508 {
00509    return !!ast_category_get(config, category_name);
00510 }

struct ast_variable* ast_category_first ( struct ast_category cat  ) 

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

return the first var of a category

Definition at line 608 of file config.c.

References ast_category::root.

Referenced by process_text_line().

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

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

Retrieve a category if it exists.

Parameters:
config which config to use
category_name name of the category you're looking for This will search through the categories within a given config file for a match.
Return values:
pointer to category if found
NULL if not.

Definition at line 502 of file config.c.

References category_get(), and config.

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

00503 {
00504    return category_get(config, category_name, 0);
00505 }

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

References config, ast_category::name, and ast_category::next.

Referenced by handle_updates().

00524 {
00525    struct ast_category *cur_category;
00526 
00527    if (!cat || !match)
00528       return;
00529    if (!strcasecmp(config->root->name, match)) {
00530       cat->next = config->root;
00531       config->root = cat;
00532       return;
00533    } 
00534    for (cur_category = config->root; cur_category; cur_category = cur_category->next) {
00535       if (!strcasecmp(cur_category->next->name, match)) {
00536          cat->next = cur_category->next;
00537          cur_category->next = cat;
00538          break;
00539       }
00540    }
00541 }

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

Create a category structure.

Definition at line 473 of file config.c.

References ast_calloc, ast_copy_string(), 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().

00474 {
00475    struct ast_category *category;
00476 
00477    if ((category = ast_calloc(1, sizeof(*category))))
00478       ast_copy_string(category->name, name, sizeof(category->name));
00479    category->file = strdup(in_file);
00480    category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */
00481    return category;
00482 }

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

Definition at line 665 of file config.c.

References ast_copy_string(), and ast_category::name.

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

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

struct ast_variable* ast_category_root ( struct ast_config config,
char *  cat 
)

returns the root ast_variable of a config

Parameters:
config pointer to an ast_config data structure
cat name of the category for which you want the root
Returns the category specified

Definition at line 613 of file config.c.

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

Referenced by get_insecure_variable_from_config().

00614 {
00615    struct ast_category *category = ast_category_get(config, cat);
00616 
00617    if (category)
00618       return category->root;
00619    return NULL;
00620 }

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

References find_engine().

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

02132 {
02133    struct ast_config_engine *eng;
02134 
02135    eng = find_engine(family, NULL, 0, NULL, 0);
02136    if (eng)
02137       return 1;
02138    return 0;
02139 }

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 836 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_post_load(), __ast_rtp_reload(), __ast_udptl_reload(), __queues_show(), _dsp_init(), action_getconfig(), action_listcategories(), action_updateconfig(), advanced_options(), aji_load_config(), ast_config_load2(), conf_exec(), config_function_read(), config_module(), directory_exec(), do_reload(), festival_exec(), find_conf(), handle_cli_dialplan_save(), iax_provision_reload(), ind_load_module(), init_logger_chain(), load_config(), load_config_meetme(), load_module(), load_realtime_queue(), load_rpt_vars(), make_email_file(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_load(), parse_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_switch_common(), reload(), reload_config(), reload_followme(), rpt_master(), run_startup_commands(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), store_config(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().

00837 {
00838    struct ast_category *cat, *catn;
00839 
00840    if (!cfg)
00841       return;
00842 
00843    ast_includes_destroy(cfg->includes);
00844 
00845    cat = cfg->root;
00846    while (cat) {
00847       catn = cat;
00848       cat = cat->next;
00849       ast_category_destroy(catn);
00850    }
00851    ast_free(cfg);
00852 }

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deregister config engine.

Return values:
0 Always

Definition at line 1957 of file config.c.

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

Referenced by unload_module().

01958 {
01959    struct ast_config_engine *ptr, *last=NULL;
01960 
01961    ast_mutex_lock(&config_lock);
01962 
01963    for (ptr = config_engine_list; ptr; ptr=ptr->next) {
01964       if (ptr == del) {
01965          if (last)
01966             last->next = ptr->next;
01967          else
01968             config_engine_list = ptr->next;
01969          break;
01970       }
01971       last = ptr;
01972    }
01973 
01974    ast_mutex_unlock(&config_lock);
01975 
01976    return 0;
01977 }

int ast_config_engine_register ( struct ast_config_engine newconfig  ) 

Register config engine.

Return values:
1 Always

Definition at line 1938 of file config.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_engine_list, config_lock, LOG_NOTICE, ast_config_engine::name, and ast_config_engine::next.

Referenced by load_module().

01939 {
01940    struct ast_config_engine *ptr;
01941 
01942    ast_mutex_lock(&config_lock);
01943 
01944    if (!config_engine_list) {
01945       config_engine_list = new;
01946    } else {
01947       for (ptr = config_engine_list; ptr->next; ptr=ptr->next);
01948       ptr->next = new;
01949    }
01950 
01951    ast_mutex_unlock(&config_lock);
01952    ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name);
01953 
01954    return 1;
01955 }

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

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

Definition at line 854 of file config.c.

References ast_config::current.

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

00855 {
00856    return cfg->current;
00857 }

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

Definition at line 2019 of file config.c.

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

Referenced by add_cfg_entry(), ast_config_load2(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), process_text_line(), and read_config_maps().

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

struct ast_config* ast_config_load2 ( const char *  filename,
const char *  who_asked,
struct ast_flags  flags 
)

Load a config file.

Parameters:
filename path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR 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 2059 of file config.c.

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

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

02060 {
02061    struct ast_config *cfg;
02062    struct ast_config *result;
02063 
02064    cfg = ast_config_new();
02065    if (!cfg)
02066       return NULL;
02067 
02068    result = ast_config_internal_load(filename, cfg, flags, "", who_asked);
02069    if (!result || result == CONFIG_STATUS_FILEUNCHANGED)
02070       ast_config_destroy(cfg);
02071 
02072    return result;
02073 }

struct ast_config* ast_config_new ( void   ) 

Create a new base configuration structure.

Definition at line 682 of file config.c.

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

00683 {
00684    struct ast_config *config;
00685 
00686    if ((config = ast_calloc(1, sizeof(*config))))
00687       config->max_include_level = MAX_INCLUDE_LEVEL;
00688    return config;
00689 }

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

References ast_variable_retrieve().

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

00420 {
00421    const char *tmp;
00422    tmp = ast_variable_retrieve(cfg, cat, var);
00423    if (!tmp)
00424       tmp = ast_variable_retrieve(cfg, "general", var);
00425    return tmp;
00426 }

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

References ast_config::current.

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

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

Destroy realtime configuration.

Parameters:
family which family/config to be destroyed
keyfield which field to use as the key
lookup which value to look for in the key field to match the entry. This function is used to destroy an entry in realtime configuration space. Additional params are used as keys.
Returns:
Number of rows affected, or -1 on error.

Definition at line 2230 of file config.c.

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

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

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

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

Definition at line 350 of file config.c.

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

Referenced by ast_include_new().

00351 {
00352    struct ast_config_include *x;
00353    for (x=conf->includes;x;x=x->next) {
00354       if (strcmp(x->included_file,included_file) == 0)
00355          return x;
00356    }
00357    return 0;
00358 }

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

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

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

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

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

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

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

Retrieve realtime configuration.

Parameters:
family which family/config to lookup This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Note that unlike the variables in ast_config, the resulting list of variables MUST be 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 2101 of file config.c.

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

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

02102 {
02103    struct ast_variable *res, *cur, *prev = NULL, *freeme = NULL;
02104    va_list ap;
02105 
02106    va_start(ap, family);
02107    res = ast_load_realtime_helper(family, ap);
02108    va_end(ap);
02109 
02110    /* Eliminate blank entries */
02111    for (cur = res; cur; cur = cur->next) {
02112       if (freeme) {
02113          ast_free(freeme);
02114          freeme = NULL;
02115       }
02116 
02117       if (ast_strlen_zero(cur->value)) {
02118          if (prev)
02119             prev->next = cur->next;
02120          else
02121             res = cur->next;
02122          freeme = cur;
02123       } else {
02124          prev = cur;
02125       }
02126    }
02127    return res;
02128 }

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

Definition at line 2089 of file config.c.

References ast_load_realtime_helper().

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

02090 {
02091    struct ast_variable *res;
02092    va_list ap;
02093 
02094    va_start(ap, family);
02095    res = ast_load_realtime_helper(family, ap);
02096    va_end(ap);
02097 
02098    return res;
02099 }

struct ast_config* ast_load_realtime_multientry ( const char *  family,
  ... 
)

Retrieve realtime configuration.

Parameters:
family which family/config to lookup This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Unlike the ast_load_realtime, this function can return more than one entry and is thus stored inside a traditional ast_config structure rather than just returning a linked list of variables.

Definition at line 2179 of file config.c.

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

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

02180 {
02181    struct ast_config_engine *eng;
02182    char db[256]="";
02183    char table[256]="";
02184    struct ast_config *res=NULL;
02185    va_list ap;
02186 
02187    va_start(ap, family);
02188    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02189    if (eng && eng->realtime_multi_func) 
02190       res = eng->realtime_multi_func(db, table, ap);
02191    va_end(ap);
02192 
02193    return res;
02194 }

int ast_parse_arg ( const char *  arg,
enum ast_parse_flags  flags,
void *  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 2250 of file config.c.

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

Referenced by ast_sip_ouraddrfor(), and check_via_response().

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

int ast_realtime_enabled ( void   ) 

Check if there's any realtime engines loaded.

Definition at line 2142 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

02143 {
02144    return config_maps ? 1 : 0;
02145 }

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

02148 {
02149    struct ast_config_engine *eng;
02150    char db[256] = "";
02151    char table[256] = "";
02152    va_list ap;
02153    int res = -1;
02154 
02155    va_start(ap, family);
02156    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02157    if (eng && eng->require_func) {
02158       res = eng->require_func(db, table, ap);
02159    }
02160    va_end(ap);
02161 
02162    return res;
02163 }

int ast_rq_is_int ( require_type  type  )  [inline]

Check if require type is an integer type.

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

Definition at line 2213 of file config.c.

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

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

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

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

02166 {
02167    struct ast_config_engine *eng;
02168    char db[256] = "";
02169    char table[256] = "";
02170    int res = -1;
02171 
02172    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
02173    if (eng && eng->unload_func) {
02174       res = eng->unload_func(db, table);
02175    }
02176    return res;
02177 }

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

Update realtime configuration.

Parameters:
family which family/config to be updated
keyfield which field to use as the key
lookup which value to look for in the key field to match the entry. This function is used to update a parameter in realtime configuration space.
Returns:
Number of rows affected, or -1 on error.

Definition at line 2196 of file config.c.

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

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

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

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

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

00362 {
00363    if (!variable)
00364       return;
00365    if (category->last)
00366       category->last->next = variable;
00367    else
00368       category->root = variable;
00369    category->last = variable;
00370    while (category->last->next)
00371       category->last = category->last->next;
00372 }

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

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

Return values:
ast_variable list on success
NULL on failure

Definition at line 407 of file config.c.

References ast_category_get(), config, 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_readconfig(), ast_variable_retrieve(), build_device(), check_tx_freq(), collect_function_digits(), conf_exec(), config_module(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), iax_template_parse(), ind_load_module(), init_logger_chain(), jingle_load_config(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), run_startup_commands(), search_directory(), set_config(), setup_dahdi(), show_users_realtime(), sip_cli_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().

00408 {
00409    struct ast_category *cat = NULL;
00410 
00411    if (category && config->last_browse && (config->last_browse->name == category))
00412       cat = config->last_browse;
00413    else
00414       cat = ast_category_get(config, category);
00415 
00416    return (cat) ? cat->root : NULL;
00417 }

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

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

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

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

Definition at line 374 of file config.c.

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

Referenced by handle_updates().

00375 {
00376    struct ast_variable *cur = category->root;
00377    int lineno;
00378    int insertline;
00379 
00380    if (!variable || sscanf(line, "%d", &insertline) != 1)
00381       return;
00382    if (!insertline) {
00383       variable->next = category->root;
00384       category->root = variable;
00385    } else {
00386       for (lineno = 1; lineno < insertline; lineno++) {
00387          cur = cur->next;
00388          if (!cur->next)
00389             break;
00390       }
00391       variable->next = cur->next;
00392       cur->next = variable;
00393    }
00394 }

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

Definition at line 236 of file config.c.

References __ast_calloc(), ast_calloc, and ast_variable::stuff.

Referenced by add_cfg_entry(), add_rt_cfg_entry(), add_rt_multi_cfg_entry(), add_var(), apply_outgoing(), ast_channeltype_list(), ast_variable_update(), astman_get_variables(), build_user(), check_access(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), copy_vars(), create_vmaccount(), handle_updates(), handle_uri(), httpd_helper_thread(), iax_parse_ies(), ldap_table_config_add_attribute(), parkandannounce_exec(), parse_cookies(), process_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().

00238 {
00239    struct ast_variable *variable;
00240    int name_len = strlen(name) + 1; 
00241    int val_len = strlen(value) + 1; 
00242    int fn_len = strlen(filename) + 1;  
00243 
00244 #ifdef MALLOC_DEBUG
00245    if ((variable = __ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable), file, lineno, func))) {
00246 #else
00247    if ((variable = ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable)))) {
00248 #endif
00249       char *dst = variable->stuff;  /* writable space starts here */
00250       variable->name = strcpy(dst, name);
00251       dst += name_len;
00252       variable->value = strcpy(dst, value);
00253       dst += val_len;
00254       variable->file = strcpy(dst, filename);
00255    }
00256    return variable;
00257 }

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

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

Referenced by __ast_rtp_reload(), __ast_udptl_reload(), _dsp_init(), advanced_options(), aji_load_config(), ast_config_option(), build_extension(), config_function_read(), config_module(), directory_exec(), do_reload(), do_scheduler(), festival_exec(), function_macro(), get_insecure_variable_from_config(), get_wait_interval(), gtalk_load_config(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_rpt_vars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), private_enum_init(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_queues(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), rpt_telemetry(), saynode(), search_directory(), set_config(), setup_dahdi(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), update_realtime_members(), vm_change_password(), and vm_forwardoptions().

00430 {
00431    struct ast_variable *v;
00432 
00433    if (category) {
00434       for (v = ast_variable_browse(config, category); v; v = v->next) {
00435          if (!strcasecmp(variable, v->name))
00436             return v->value;
00437       }
00438    } else {
00439       struct ast_category *cat;
00440 
00441       for (cat = config->root; cat; cat = cat->next)
00442          for (v = cat->root; v; v = v->next)
00443             if (!strcasecmp(variable, v->name))
00444                return v->value;
00445    }
00446 
00447    return NULL;
00448 }

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

00745 {
00746    struct ast_variable *cur, *prev=NULL, *newer=NULL;
00747 
00748    for (cur = category->root; cur; prev = cur, cur = cur->next) {
00749       if (strcasecmp(cur->name, variable) ||
00750          (!ast_strlen_zero(match) && strcasecmp(cur->value, match)))
00751          continue;
00752 
00753       if (!(newer = ast_variable_new(variable, value, cur->file)))
00754          return -1;
00755    
00756       newer->next = cur->next;
00757       newer->object = cur->object || object;
00758       if (prev)
00759          prev->next = newer;
00760       else
00761          category->root = newer;
00762       if (category->last == cur)
00763          category->last = newer;
00764 
00765       cur->next = NULL;
00766       ast_variables_destroy(cur);
00767 
00768       return 0;
00769    }
00770 
00771    /* Could not find variable to update */
00772    return -1;
00773 }

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

References ast_free, and ast_variable::next.

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

00397 {
00398    struct ast_variable *vn;
00399 
00400    while (v) {
00401       vn = v;
00402       v = v->next;
00403       ast_free(vn);
00404    }
00405 }

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

Definition at line 1579 of file config.c.

References ao2_container_alloc, ao2_ref, ast_debug, AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_verb, ast_comment::cmt, errno, ast_config_include::exec, ast_config_include::exec_file, f, 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_category::lineno, ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_category::next, ast_variable::next, cache_file_include::next, ast_comment::next, ast_config_include::next, option_debug, ast_config_include::output, ast_category::precomments, ast_category::root, ast_config::root, ast_category::sameline, set_fn(), ast_category::template_instances, ast_category::trailing, ast_variable::value, and var.

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

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

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

Referenced by main().

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

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

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

02523 {
02524    ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry));
02525    return 0;
02526 }


Generated on Fri Jun 19 12:10:31 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7