Mon Mar 31 07:40:25 2008

Asterisk developer's documentation


config.c File Reference

Configuration File Parser. More...

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

Include dependency graph for config.c:

Go to the source code of this file.

Data Structures

struct  ast_category
struct  ast_category_template_instance
struct  ast_comment
 Structure to keep comments for rewriting configuration files. More...
struct  ast_config
struct  ast_config_map

Defines

#define AST_INCLUDE_GLOB   1
#define CB_INCR   250
#define COMMENT_END   "--;"
#define COMMENT_META   ';'
#define COMMENT_START   ";--"
#define COMMENT_TAG   '-'
#define MAX_INCLUDE_LEVEL   10
#define MAX_NESTED_COMMENTS   128

Functions

static struct ast_commentALLOC_COMMENT (const char *buffer)
static int append_mapping (char *name, char *driver, char *database, char *table)
void ast_category_append (struct ast_config *config, struct ast_category *category)
char * ast_category_browse (struct ast_config *config, const char *prev)
 Goes through categories.
int ast_category_delete (struct ast_config *cfg, char *category)
void ast_category_destroy (struct ast_category *cat)
ast_variableast_category_detach_variables (struct ast_category *cat)
int ast_category_exist (const struct ast_config *config, const char *category_name)
 Check for category duplicates.
ast_categoryast_category_get (const struct ast_config *config, const char *category_name)
 Retrieve a category if it exists.
ast_categoryast_category_new (const char *name)
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 returns 1 if family is configured in realtime and engine exists.
void ast_config_destroy (struct ast_config *cfg)
 Destroys a config.
int ast_config_engine_deregister (struct ast_config_engine *del)
 Deegister config engine.
int ast_config_engine_register (struct ast_config_engine *new)
 Register config engine.
ast_categoryast_config_get_current_category (const struct ast_config *cfg)
ast_configast_config_internal_load (const char *filename, struct ast_config *cfg, int withcomments)
ast_configast_config_load (const char *filename)
 Load a config file.
ast_configast_config_load_with_comments (const char *filename)
ast_configast_config_new (void)
const char * ast_config_option (struct ast_config *cfg, const char *cat, const char *var)
void ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat)
static void ast_destroy_comments (struct ast_category *cat)
static void ast_destroy_template_list (struct ast_category *cat)
ast_variableast_load_realtime (const char *family,...)
 Retrieve realtime configuration.
ast_configast_load_realtime_multientry (const char *family,...)
 Retrieve realtime configuration.
 AST_MUTEX_DEFINE_STATIC (config_lock)
int ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...)
 Update realtime configuration.
void ast_variable_append (struct ast_category *category, struct ast_variable *variable)
ast_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, char *variable, char *match)
ast_variableast_variable_new (const char *name, const char *value)
const char * ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable)
 Gets a variable.
int ast_variable_update (struct ast_category *category, const char *variable, const char *value, const char *match, unsigned int object)
void ast_variables_destroy (struct ast_variable *v)
 Free variable list.
static struct ast_categorycategory_get (const struct ast_config *config, const char *category_name, int ignored)
static void CB_ADD (char **comment_buffer, int *comment_buffer_size, char *str)
static void CB_ADD_LEN (char **comment_buffer, int *comment_buffer_size, char *str, int len)
static void CB_INIT (char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size)
static void CB_RESET (char **comment_buffer, char **lline_buffer)
static void clear_config_maps (void)
static int config_command (int fd, int argc, char **argv)
static struct ast_configconfig_text_file_load (const char *database, const char *table, const char *filename, struct ast_config *cfg, int withcomments)
int config_text_file_save (const char *configfile, const struct ast_config *cfg, const char *generator)
static struct ast_config_enginefind_engine (const char *family, char *database, int dbsiz, char *table, int tabsiz)
 Find realtime engine for realtime family.
static void inherit_category (struct ast_category *new, const struct ast_category *base)
static void LLB_ADD (char **lline_buffer, int *lline_buffer_size, char *str)
static void move_variables (struct ast_category *old, struct ast_category *new)
static struct ast_categorynext_available_category (struct ast_category *cat)
static int process_text_line (struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile, int withcomments, char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size)
int read_config_maps (void)
int register_config_cli ()
static struct ast_variablevariable_clone (const struct ast_variable *old)

Variables

static struct ast_cli_entry cli_config []
static struct ast_cli_entry cli_show_config_mappings_deprecated
static struct ast_config_engineconfig_engine_list
static struct ast_config_mapconfig_maps
static char * extconfig_conf = "extconfig.conf"
static char show_config_help []
static struct ast_config_engine text_file_engine


Detailed Description

Configuration File Parser.

Author:
Mark Spencer <markster@digium.com>
Includes the Asterisk Realtime API - ARA See doc/realtime.txt and doc/extconfig.txt

Definition in file config.c.


Define Documentation

#define AST_INCLUDE_GLOB   1

Definition at line 40 of file config.c.

#define CB_INCR   250

Definition at line 72 of file config.c.

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

#define COMMENT_END   "--;"

Definition at line 59 of file config.c.

#define COMMENT_META   ';'

Definition at line 60 of file config.c.

Referenced by config_text_file_load().

#define COMMENT_START   ";--"

Definition at line 58 of file config.c.

#define COMMENT_TAG   '-'

Definition at line 61 of file config.c.

Referenced by config_text_file_load().

#define MAX_INCLUDE_LEVEL   10

Definition at line 160 of file config.c.

Referenced by ast_config_new().

#define MAX_NESTED_COMMENTS   128

Definition at line 57 of file config.c.

Referenced by config_text_file_load().


Function Documentation

static struct ast_comment* ALLOC_COMMENT ( const char *  buffer  )  [static]

Definition at line 140 of file config.c.

References ast_calloc, and ast_comment::cmt.

Referenced by process_text_line().

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

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

Definition at line 1153 of file config.c.

References ast_calloc, ast_verbose(), config_maps, map, option_verbose, and VERBOSE_PREFIX_2.

Referenced by read_config_maps().

01154 {
01155    struct ast_config_map *map;
01156    int length;
01157 
01158    length = sizeof(*map);
01159    length += strlen(name) + 1;
01160    length += strlen(driver) + 1;
01161    length += strlen(database) + 1;
01162    if (table)
01163       length += strlen(table) + 1;
01164 
01165    if (!(map = ast_calloc(1, length)))
01166       return -1;
01167 
01168    map->name = map->stuff;
01169    strcpy(map->name, name);
01170    map->driver = map->name + strlen(map->name) + 1;
01171    strcpy(map->driver, driver);
01172    map->database = map->driver + strlen(map->driver) + 1;
01173    strcpy(map->database, database);
01174    if (table) {
01175       map->table = map->database + strlen(map->database) + 1;
01176       strcpy(map->table, table);
01177    }
01178    map->next = config_maps;
01179 
01180    if (option_verbose > 1)
01181       ast_verbose(VERBOSE_PREFIX_2 "Binding %s to %s/%s/%s\n",
01182              map->name, map->driver, map->database, map->table ? map->table : map->name);
01183 
01184    config_maps = map;
01185    return 0;
01186 }

void ast_category_append ( struct ast_config config,
struct ast_category category 
)

Definition at line 339 of file config.c.

References config, and ast_category::include_level.

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

00340 {
00341    if (config->last)
00342       config->last->next = category;
00343    else
00344       config->root = category;
00345    category->include_level = config->include_level;
00346    config->last = category;
00347    config->current = category;
00348 }

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

Goes through categories.

Parameters:
config Which config structure you wish to "browse"
prev A pointer to a previous category. This funtion is kind of non-intuitive in it's use. To begin, one passes NULL as the second arguement. It will return a pointer to the string of the first category in the file. From here on after, one must then pass the previous usage's return value as the second pointer, and it will return a pointer to the category name afterwards.
Returns a category on success, or NULL on failure/no-more-categories

Definition at line 398 of file config.c.

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

Referenced by action_getconfig(), aji_load_config(), authenticate(), complete_sipnotify(), do_directory(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), init_manager(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), odbc_load_module(), osp_load(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_zap(), sla_load_config(), update_realtime_members(), and vm_change_password().

00399 {  
00400    struct ast_category *cat = NULL;
00401 
00402    if (prev && config->last_browse && (config->last_browse->name == prev))
00403       cat = config->last_browse->next;
00404    else if (!prev && config->root)
00405       cat = config->root;
00406    else if (prev) {
00407       for (cat = config->root; cat; cat = cat->next) {
00408          if (cat->name == prev) {
00409             cat = cat->next;
00410             break;
00411          }
00412       }
00413       if (!cat) {
00414          for (cat = config->root; cat; cat = cat->next) {
00415             if (!strcasecmp(cat->name, prev)) {
00416                cat = cat->next;
00417                break;
00418             }
00419          }
00420       }
00421    }
00422    
00423    if (cat)
00424       cat = next_available_category(cat);
00425 
00426    config->last_browse = cat;
00427    return (cat) ? cat->name : NULL;
00428 }

int ast_category_delete ( struct ast_config cfg,
char *  category 
)

Definition at line 553 of file config.c.

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

Referenced by handle_updates().

00554 {
00555    struct ast_category *prev=NULL, *cat;
00556    cat = cfg->root;
00557    while(cat) {
00558       if (cat->name == category) {
00559          if (prev) {
00560             prev->next = cat->next;
00561             if (cat == cfg->last)
00562                cfg->last = prev;
00563          } else {
00564             cfg->root = cat->next;
00565             if (cat == cfg->last)
00566                cfg->last = NULL;
00567          }
00568          ast_category_destroy(cat);
00569          return 0;
00570       }
00571       prev = cat;
00572       cat = cat->next;
00573    }
00574 
00575    prev = NULL;
00576    cat = cfg->root;
00577    while(cat) {
00578       if (!strcasecmp(cat->name, category)) {
00579          if (prev) {
00580             prev->next = cat->next;
00581             if (cat == cfg->last)
00582                cfg->last = prev;
00583          } else {
00584             cfg->root = cat->next;
00585             if (cat == cfg->last)
00586                cfg->last = NULL;
00587          }
00588          ast_category_destroy(cat);
00589          return 0;
00590       }
00591       prev = cat;
00592       cat = cat->next;
00593    }
00594    return -1;
00595 }

void ast_category_destroy ( struct ast_category cat  ) 

Definition at line 375 of file config.c.

References ast_destroy_comments(), ast_destroy_template_list(), ast_variables_destroy(), and free.

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

00376 {
00377    ast_variables_destroy(cat->root);
00378    ast_destroy_comments(cat);
00379    ast_destroy_template_list(cat);
00380    free(cat);
00381 }

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 430 of file config.c.

Referenced by realtime_switch_common().

00431 {
00432    struct ast_variable *v;
00433 
00434    v = cat->root;
00435    cat->root = NULL;
00436    cat->last = NULL;
00437 
00438    return v;
00439 }

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

Check for category duplicates.

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

Definition at line 334 of file config.c.

References ast_category_get(), and config.

00335 {
00336    return !!ast_category_get(config, category_name);
00337 }

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

Retrieve a category if it exists.

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

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

00330 {
00331    return category_get(config, category_name, 0);
00332 }

struct ast_category* ast_category_new ( const char *  name  ) 

Definition at line 302 of file config.c.

References ast_calloc.

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

00303 {
00304    struct ast_category *category;
00305 
00306    if ((category = ast_calloc(1, sizeof(*category))))
00307       ast_copy_string(category->name, name, sizeof(category->name));
00308    return category;
00309 }

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

Definition at line 441 of file config.c.

References ast_category::name.

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

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

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

References ast_category_get(), and config.

00391 {
00392    struct ast_category *category = ast_category_get(config, cat);
00393    if (category)
00394       return category->root;
00395    return NULL;
00396 }

int ast_check_realtime ( const char *  family  ) 

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

Parameters:
family which family/config to be checked

Definition at line 1427 of file config.c.

References find_engine().

Referenced by _sip_show_peer(), _sip_show_peers(), and sip_show_settings().

01428 {
01429    struct ast_config_engine *eng;
01430 
01431    eng = find_engine(family, NULL, 0, NULL, 0);
01432    if (eng)
01433       return 1;
01434    return 0;
01435 
01436 }

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

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

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

00598 {
00599    struct ast_category *cat, *catn;
00600 
00601    if (!cfg)
00602       return;
00603 
00604    cat = cfg->root;
00605    while(cat) {
00606       catn = cat;
00607       cat = cat->next;
00608       ast_category_destroy(catn);
00609    }
00610    free(cfg);
00611 }

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deegister config engine.

Definition at line 1275 of file config.c.

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

Referenced by unload_module().

01276 {
01277    struct ast_config_engine *ptr, *last=NULL;
01278 
01279    ast_mutex_lock(&config_lock);
01280 
01281    for (ptr = config_engine_list; ptr; ptr=ptr->next) {
01282       if (ptr == del) {
01283          if (last)
01284             last->next = ptr->next;
01285          else
01286             config_engine_list = ptr->next;
01287          break;
01288       }
01289       last = ptr;
01290    }
01291 
01292    ast_mutex_unlock(&config_lock);
01293 
01294    return 0;
01295 }

int ast_config_engine_register ( struct ast_config_engine new  ) 

Register config engine.

Definition at line 1256 of file config.c.

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

Referenced by load_module().

01257 {
01258    struct ast_config_engine *ptr;
01259 
01260    ast_mutex_lock(&config_lock);
01261 
01262    if (!config_engine_list) {
01263       config_engine_list = new;
01264    } else {
01265       for (ptr = config_engine_list; ptr->next; ptr=ptr->next);
01266       ptr->next = new;
01267    }
01268 
01269    ast_mutex_unlock(&config_lock);
01270    ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name);
01271 
01272    return 1;
01273 }

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

Definition at line 613 of file config.c.

References ast_config::current.

Referenced by config_odbc(), and config_text_file_load().

00614 {
00615    return cfg->current;
00616 }

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

Definition at line 1337 of file config.c.

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

Referenced by ast_config_load(), ast_config_load_with_comments(), config_mysql(), config_odbc(), config_pgsql(), process_text_line(), and read_config_maps().

01338 {
01339    char db[256];
01340    char table[256];
01341    struct ast_config_engine *loader = &text_file_engine;
01342    struct ast_config *result; 
01343 
01344    /* The config file itself bumps include_level by 1 */
01345    if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) {
01346       ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
01347       return NULL;
01348    }
01349 
01350    cfg->include_level++;
01351 
01352    if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) {
01353       struct ast_config_engine *eng;
01354 
01355       eng = find_engine(filename, db, sizeof(db), table, sizeof(table));
01356 
01357 
01358       if (eng && eng->load_func) {
01359          loader = eng;
01360       } else {
01361          eng = find_engine("global", db, sizeof(db), table, sizeof(table));
01362          if (eng && eng->load_func)
01363             loader = eng;
01364       }
01365    }
01366 
01367    result = loader->load_func(db, table, filename, cfg, withcomments);
01368 
01369    if (result)
01370       result->include_level--;
01371    else
01372       cfg->include_level--;
01373 
01374    return result;
01375 }

struct ast_config* ast_config_load ( const char *  filename  ) 

Load a config file.

Parameters:
filename path of file to open. If no preceding '/' character, path is considered relative to AST_CONFIG_DIR Create a config structure from a given configuration file.
Returns NULL on error, or an ast_config data structure on success

Definition at line 1377 of file config.c.

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

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

01378 {
01379    struct ast_config *cfg;
01380    struct ast_config *result;
01381 
01382    cfg = ast_config_new();
01383    if (!cfg)
01384       return NULL;
01385 
01386    result = ast_config_internal_load(filename, cfg, 0);
01387    if (!result)
01388       ast_config_destroy(cfg);
01389 
01390    return result;
01391 }

struct ast_config* ast_config_load_with_comments ( const char *  filename  ) 

Definition at line 1393 of file config.c.

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

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

01394 {
01395    struct ast_config *cfg;
01396    struct ast_config *result;
01397 
01398    cfg = ast_config_new();
01399    if (!cfg)
01400       return NULL;
01401 
01402    result = ast_config_internal_load(filename, cfg, 1);
01403    if (!result)
01404       ast_config_destroy(cfg);
01405 
01406    return result;
01407 }

struct ast_config* ast_config_new ( void   ) 

Definition at line 457 of file config.c.

References ast_calloc, config, and MAX_INCLUDE_LEVEL.

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

00458 {
00459    struct ast_config *config;
00460 
00461    if ((config = ast_calloc(1, sizeof(*config))))
00462       config->max_include_level = MAX_INCLUDE_LEVEL;
00463    return config;
00464 }

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

Definition at line 240 of file config.c.

References ast_variable_retrieve().

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

00241 {
00242    const char *tmp;
00243    tmp = ast_variable_retrieve(cfg, cat, var);
00244    if (!tmp)
00245       tmp = ast_variable_retrieve(cfg, "general", var);
00246    return tmp;
00247 }

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

Definition at line 618 of file config.c.

References ast_config::current.

00619 {
00620    /* cast below is just to silence compiler warning about dropping "const" */
00621    cfg->current = (struct ast_category *) cat;
00622 }

static void ast_destroy_comments ( struct ast_category cat  )  [static]

Definition at line 350 of file config.c.

References free, and ast_comment::next.

Referenced by ast_category_destroy().

00351 {
00352    struct ast_comment *n, *p;
00353    for (p=cat->precomments; p; p=n) {
00354       n = p->next;
00355       free(p);
00356    }
00357    for (p=cat->sameline; p; p=n) {
00358       n = p->next;
00359       free(p);
00360    }
00361    cat->precomments = NULL;
00362    cat->sameline = NULL;
00363 }

static void ast_destroy_template_list ( struct ast_category cat  )  [static]

Definition at line 365 of file config.c.

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, and free.

Referenced by ast_category_destroy().

00366 {
00367    struct ast_category_template_instance *x;
00368    AST_LIST_TRAVERSE_SAFE_BEGIN(&cat->template_instances, x, next) {
00369       AST_LIST_REMOVE_CURRENT(&cat->template_instances, next);
00370       free(x);
00371    }
00372    AST_LIST_TRAVERSE_SAFE_END;
00373 }

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.

Definition at line 1409 of file config.c.

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

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

01410 {
01411    struct ast_config_engine *eng;
01412    char db[256]="";
01413    char table[256]="";
01414    struct ast_variable *res=NULL;
01415    va_list ap;
01416 
01417    va_start(ap, family);
01418    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01419    if (eng && eng->realtime_func) 
01420       res = eng->realtime_func(db, table, ap);
01421    va_end(ap);
01422 
01423    return res;
01424 }

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

Retrieve realtime configuration.

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

Definition at line 1438 of file config.c.

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

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

01439 {
01440    struct ast_config_engine *eng;
01441    char db[256]="";
01442    char table[256]="";
01443    struct ast_config *res=NULL;
01444    va_list ap;
01445 
01446    va_start(ap, family);
01447    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01448    if (eng && eng->realtime_multi_func) 
01449       res = eng->realtime_multi_func(db, table, ap);
01450    va_end(ap);
01451 
01452    return res;
01453 }

AST_MUTEX_DEFINE_STATIC ( config_lock   ) 

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

Update realtime configuration.

Parameters:
family which family/config to be updated
keyfield which field to use as the key
lookup which value to look for in the key field to match the entry. This function is used to update a parameter in realtime configuration space.

Definition at line 1455 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(), realtime_update_exec(), realtime_update_peer(), and update_realtime_member_field().

01456 {
01457    struct ast_config_engine *eng;
01458    int res = -1;
01459    char db[256]="";
01460    char table[256]="";
01461    va_list ap;
01462 
01463    va_start(ap, lookup);
01464    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01465    if (eng && eng->update_func) 
01466       res = eng->update_func(db, table, keyfield, lookup, ap);
01467    va_end(ap);
01468 
01469    return res;
01470 }

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

Definition at line 204 of file config.c.

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

00205 {
00206    if (!variable)
00207       return;
00208    if (category->last)
00209       category->last->next = variable;
00210    else
00211       category->root = variable;
00212    category->last = variable;
00213    while (category->last->next)
00214       category->last = category->last->next;
00215 }

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

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

Returns ast_variable list on success, or NULL on failure

Definition at line 228 of file config.c.

References ast_category_get(), and config.

Referenced by __ast_http_load(), action_getconfig(), adsi_load(), aji_load_config(), ast_enum_init(), ast_readconfig(), ast_variable_retrieve(), authenticate(), check_tx_freq(), collect_function_digits(), conf_exec(), database_first_connect(), do_directory(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), misdn_cfg_init(), my_load_module(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), process_my_load_module(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queues(), set_config(), setup_zap(), sip_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().

00229 {
00230    struct ast_category *cat = NULL;
00231 
00232    if (category && config->last_browse && (config->last_browse->name == category))
00233       cat = config->last_browse;
00234    else
00235       cat = ast_category_get(config, category);
00236 
00237    return (cat) ? cat->root : NULL;
00238 }

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

Definition at line 466 of file config.c.

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

Referenced by handle_updates().

00467 {
00468    struct ast_variable *cur, *prev=NULL, *curn;
00469    int res = -1;
00470    cur = category->root;
00471    while (cur) {
00472       if (cur->name == variable) {
00473          if (prev) {
00474             prev->next = cur->next;
00475             if (cur == category->last)
00476                category->last = prev;
00477          } else {
00478             category->root = cur->next;
00479             if (cur == category->last)
00480                category->last = NULL;
00481          }
00482          cur->next = NULL;
00483          ast_variables_destroy(cur);
00484          return 0;
00485       }
00486       prev = cur;
00487       cur = cur->next;
00488    }
00489 
00490    prev = NULL;
00491    cur = category->root;
00492    while (cur) {
00493       curn = cur->next;
00494       if (!strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match))) {
00495          if (prev) {
00496             prev->next = cur->next;
00497             if (cur == category->last)
00498                category->last = prev;
00499          } else {
00500             category->root = cur->next;
00501             if (cur == category->last)
00502                category->last = NULL;
00503          }
00504          cur->next = NULL;
00505          ast_variables_destroy(cur);
00506          res = 0;
00507       } else
00508          prev = cur;
00509 
00510       cur = curn;
00511    }
00512    return res;
00513 }

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

Definition at line 189 of file config.c.

References ast_calloc, and ast_variable::name.

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

00190 {
00191    struct ast_variable *variable;
00192    int name_len = strlen(name) + 1; 
00193 
00194    if ((variable = ast_calloc(1, name_len + strlen(value) + 1 + sizeof(*variable)))) {
00195       variable->name = variable->stuff;
00196       variable->value = variable->stuff + name_len;      
00197       strcpy(variable->name,name);
00198       strcpy(variable->value,value);
00199    }
00200 
00201    return variable;
00202 }

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

Gets a variable.

Parameters:
config which (opened) config to use
category category under which the variable lies
variable which variable you wish to get the data for Goes through a given config file in the given category and searches for the given variable
Returns the variable value on success, or NULL if unable to find it.

Definition at line 250 of file config.c.

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

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

00251 {
00252    struct ast_variable *v;
00253 
00254    if (category) {
00255       for (v = ast_variable_browse(config, category); v; v = v->next) {
00256          if (!strcasecmp(variable, v->name))
00257             return v->value;
00258       }
00259    } else {
00260       struct ast_category *cat;
00261 
00262       for (cat = config->root; cat; cat = cat->next)
00263          for (v = cat->root; v; v = v->next)
00264             if (!strcasecmp(variable, v->name))
00265                return v->value;
00266    }
00267 
00268    return NULL;
00269 }

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

Definition at line 515 of file config.c.

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

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

00517 {
00518    struct ast_variable *cur, *prev=NULL, *newer;
00519 
00520    if (!(newer = ast_variable_new(variable, value)))
00521       return -1;
00522    
00523    newer->object = object;
00524 
00525    for (cur = category->root; cur; prev = cur, cur = cur->next) {
00526       if (strcasecmp(cur->name, variable) ||
00527          (!ast_strlen_zero(match) && strcasecmp(cur->value, match)))
00528          continue;
00529 
00530       newer->next = cur->next;
00531       newer->object = cur->object || object;
00532       if (prev)
00533          prev->next = newer;
00534       else
00535          category->root = newer;
00536       if (category->last == cur)
00537          category->last = newer;
00538 
00539       cur->next = NULL;
00540       ast_variables_destroy(cur);
00541 
00542       return 0;
00543    }
00544 
00545    if (prev)
00546       prev->next = newer;
00547    else
00548       category->root = newer;
00549 
00550    return 0;
00551 }

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

References free, and ast_variable::next.

Referenced by ast_category_destroy(), ast_httpd_helper_thread(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), find_conf_realtime(), find_user_realtime(), handle_uri(), iax2_destroy(), load_realtime_queue(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), and user_destructor().

00218 {
00219    struct ast_variable *vn;
00220 
00221    while(v) {
00222       vn = v;
00223       v = v->next;
00224       free(vn);
00225    }
00226 }

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

Definition at line 311 of file config.c.

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

Referenced by ast_category_get(), and process_text_line().

00312 {
00313    struct ast_category *cat;
00314 
00315    /* try exact match first, then case-insensitive match */
00316    for (cat = config->root; cat; cat = cat->next) {
00317       if (cat->name == category_name && (ignored || !cat->ignored))
00318          return cat;
00319    }
00320 
00321    for (cat = config->root; cat; cat = cat->next) {
00322       if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored))
00323          return cat;
00324    }
00325 
00326    return NULL;
00327 }

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

Definition at line 93 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

00094 {
00095    int rem = *comment_buffer_size - strlen(*comment_buffer) - 1;
00096    int siz = strlen(str);
00097    if (rem < siz+1) {
00098       *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + siz + 1);
00099       if (!(*comment_buffer))
00100          return;
00101       *comment_buffer_size += CB_INCR+siz+1;
00102    }
00103    strcat(*comment_buffer,str);
00104 }

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

Definition at line 106 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

00107 {
00108    int cbl = strlen(*comment_buffer) + 1;
00109    int rem = *comment_buffer_size - cbl;
00110    if (rem < len+1) {
00111       *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + len + 1);
00112       if (!(*comment_buffer))
00113          return;
00114       *comment_buffer_size += CB_INCR+len+1;
00115    }
00116    strncat(*comment_buffer,str,len);
00117    (*comment_buffer)[cbl+len-1] = 0;
00118 }

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

Definition at line 74 of file config.c.

References ast_malloc, and CB_INCR.

Referenced by config_text_file_load().

00075 {
00076    if (!(*comment_buffer)) {
00077       *comment_buffer = ast_malloc(CB_INCR);
00078       if (!(*comment_buffer))
00079          return;
00080       (*comment_buffer)[0] = 0;
00081       *comment_buffer_size = CB_INCR;
00082       *lline_buffer = ast_malloc(CB_INCR);
00083       if (!(*lline_buffer))
00084          return;
00085       (*lline_buffer)[0] = 0;
00086       *lline_buffer_size = CB_INCR;
00087    } else {
00088       (*comment_buffer)[0] = 0;
00089       (*lline_buffer)[0] = 0;
00090    }
00091 }

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

Definition at line 133 of file config.c.

Referenced by process_text_line().

00134 { 
00135    (*comment_buffer)[0] = 0; 
00136    (*lline_buffer)[0] = 0;
00137 }

static void clear_config_maps ( void   )  [static]

Definition at line 1138 of file config.c.

References ast_mutex_lock(), ast_mutex_unlock(), config_maps, free, map, and ast_config_map::next.

Referenced by read_config_maps().

01139 {
01140    struct ast_config_map *map;
01141 
01142    ast_mutex_lock(&config_lock);
01143 
01144    while (config_maps) {
01145       map = config_maps;
01146       config_maps = config_maps->next;
01147       free(map);
01148    }
01149       
01150    ast_mutex_unlock(&config_lock);
01151 }

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

Definition at line 1472 of file config.c.

References ast_cli(), ast_mutex_lock(), config_engine_list, config_maps, map, ast_config_engine::name, and ast_config_engine::next.

01473 {
01474    struct ast_config_engine *eng;
01475    struct ast_config_map *map;
01476    
01477    ast_mutex_lock(&config_lock);
01478 
01479    ast_cli(fd, "\n\n");
01480    for (eng = config_engine_list; eng; eng = eng->next) {
01481       ast_cli(fd, "\nConfig Engine: %s\n", eng->name);
01482       for (map = config_maps; map; map = map->next)
01483          if (!strcasecmp(map->driver, eng->name)) {
01484             ast_cli(fd, "===> %s (db=%s, table=%s)\n", map->name, map->database,
01485                map->table ? map->table : map->name);
01486          }
01487    }
01488    ast_cli(fd,"\n\n");
01489    
01490    ast_mutex_unlock(&config_lock);
01491 
01492    return 0;
01493 }

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

Definition at line 812 of file config.c.

References ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_log(), ast_strlen_zero(), ast_verbose(), CB_ADD(), CB_ADD_LEN(), CB_INIT(), COMMENT_META, COMMENT_TAG, errno, f, lineno, LLB_ADD(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, option_debug, option_verbose, process_text_line(), and VERBOSE_PREFIX_2.

00813 {
00814    char fn[256];
00815    char buf[8192];
00816    char *new_buf, *comment_p, *process_buf;
00817    FILE *f;
00818    int lineno=0;
00819    int comment = 0, nest[MAX_NESTED_COMMENTS];
00820    struct ast_category *cat = NULL;
00821    int count = 0;
00822    struct stat statbuf;
00823    /*! Growable string buffer */
00824    char *comment_buffer=0;   /*!< this will be a comment collector.*/
00825    int   comment_buffer_size=0;  /*!< the amount of storage so far alloc'd for the comment_buffer */
00826 
00827    char *lline_buffer=0;    /*!< A buffer for stuff behind the ; */
00828    int  lline_buffer_size=0;
00829 
00830    
00831    cat = ast_config_get_current_category(cfg);
00832 
00833    if (filename[0] == '/') {
00834       ast_copy_string(fn, filename, sizeof(fn));
00835    } else {
00836       snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, filename);
00837    }
00838 
00839    if (withcomments) {
00840       CB_INIT(&comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size);
00841       if (!lline_buffer || !comment_buffer) {
00842          ast_log(LOG_ERROR, "Failed to initialize the comment buffer!\n");
00843          return NULL;
00844       }
00845    }
00846 #ifdef AST_INCLUDE_GLOB
00847    {
00848       int glob_ret;
00849       glob_t globbuf;
00850       globbuf.gl_offs = 0; /* initialize it to silence gcc */
00851 #ifdef SOLARIS
00852       glob_ret = glob(fn, GLOB_NOCHECK, NULL, &globbuf);
00853 #else
00854       glob_ret = glob(fn, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf);
00855 #endif
00856       if (glob_ret == GLOB_NOSPACE)
00857          ast_log(LOG_WARNING,
00858             "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn);
00859       else if (glob_ret  == GLOB_ABORTED)
00860          ast_log(LOG_WARNING,
00861             "Glob Expansion of pattern '%s' failed: Read error\n", fn);
00862       else  {
00863          /* loop over expanded files */
00864          int i;
00865          for (i=0; i<globbuf.gl_pathc; i++) {
00866             ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn));
00867 #endif
00868    do {
00869       if (stat(fn, &statbuf))
00870          continue;
00871 
00872       if (!S_ISREG(statbuf.st_mode)) {
00873          ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn);
00874          continue;
00875       }
00876       if (option_verbose > 1) {
00877          ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn);
00878          fflush(stdout);
00879       }
00880       if (!(f = fopen(fn, "r"))) {
00881          if (option_debug)
00882             ast_log(LOG_DEBUG, "No file to parse: %s\n", fn);
00883          if (option_verbose > 1)
00884             ast_verbose( "Not found (%s)\n", strerror(errno));
00885          continue;
00886       }
00887       count++;
00888       if (option_debug)
00889          ast_log(LOG_DEBUG, "Parsing %s\n", fn);
00890       if (option_verbose > 1)
00891          ast_verbose("Found\n");
00892       while(!feof(f)) {
00893          lineno++;
00894          if (fgets(buf, sizeof(buf), f)) {
00895             if ( withcomments ) {
00896                CB_ADD(&comment_buffer, &comment_buffer_size, lline_buffer);       /* add the current lline buffer to the comment buffer */
00897                lline_buffer[0] = 0;        /* erase the lline buffer */
00898             }
00899             
00900             new_buf = buf;
00901             if (comment) 
00902                process_buf = NULL;
00903             else
00904                process_buf = buf;
00905             
00906             while ((comment_p = strchr(new_buf, COMMENT_META))) {
00907                if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) {
00908                   /* Escaped semicolons aren't comments. */
00909                   new_buf = comment_p + 1;
00910                } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) {
00911                   /* Meta-Comment start detected ";--" */
00912                   if (comment < MAX_NESTED_COMMENTS) {
00913                      *comment_p = '\0';
00914                      new_buf = comment_p + 3;
00915                      comment++;
00916                      nest[comment-1] = lineno;
00917                   } else {
00918                      ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS);
00919                   }
00920                } else if ((comment_p >= new_buf + 2) &&
00921                      (*(comment_p - 1) == COMMENT_TAG) &&
00922                      (*(comment_p - 2) == COMMENT_TAG)) {
00923                   /* Meta-Comment end detected */
00924                   comment--;
00925                   new_buf = comment_p + 1;
00926                   if (!comment) {
00927                      /* Back to non-comment now */
00928                      if (process_buf) {
00929                         /* Actually have to move what's left over the top, then continue */
00930                         char *oldptr;
00931                         oldptr = process_buf + strlen(process_buf);
00932                         if ( withcomments ) {
00933                            CB_ADD(&comment_buffer, &comment_buffer_size, ";");
00934                            CB_ADD_LEN(&comment_buffer, &comment_buffer_size, oldptr+1, new_buf-oldptr-1);
00935                         }
00936                         
00937                         memmove(oldptr, new_buf, strlen(new_buf) + 1);
00938                         new_buf = oldptr;
00939                      } else
00940                         process_buf = new_buf;
00941                   }
00942                } else {
00943                   if (!comment) {
00944                      /* If ; is found, and we are not nested in a comment, 
00945                         we immediately stop all comment processing */
00946                      if ( withcomments ) {
00947                         LLB_ADD(&lline_buffer, &lline_buffer_size, comment_p);
00948                      }
00949                      *comment_p = '\0'; 
00950                      new_buf = comment_p;
00951                   } else
00952                      new_buf = comment_p + 1;
00953                }
00954             }
00955             if( withcomments && comment && !process_buf )
00956             {
00957                CB_ADD(&comment_buffer, &comment_buffer_size, buf);  /* the whole line is a comment, store it */
00958             }
00959             
00960             if (process_buf) {
00961                char *buf = ast_strip(process_buf);
00962                if (!ast_strlen_zero(buf)) {
00963                   if (process_text_line(cfg, &cat, buf, lineno, fn, withcomments, &comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size)) {
00964                      cfg = NULL;
00965                      break;
00966                   }
00967                }
00968             }
00969          }
00970       }
00971       fclose(f);     
00972    } while(0);
00973    if (comment) {
00974       ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment - 1]);
00975    }
00976 #ifdef AST_INCLUDE_GLOB
00977                if (!cfg)
00978                   break;
00979             }
00980             globfree(&globbuf);
00981          }
00982       }
00983 #endif
00984 
00985    if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) {
00986       free(comment_buffer);
00987       free(lline_buffer);
00988       comment_buffer = NULL;
00989       lline_buffer = NULL;
00990       comment_buffer_size = 0;
00991       lline_buffer_size = 0;
00992    }
00993    
00994    if (count == 0)
00995       return NULL;
00996 
00997    return cfg;
00998 }

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

Definition at line 1000 of file config.c.

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

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

01001 {
01002    FILE *f = NULL;
01003    int fd = -1;
01004    char fn[256], fntmp[256];
01005    char date[256]="";
01006    time_t t;
01007    struct ast_variable *var;
01008    struct ast_category *cat;
01009    struct ast_comment *cmt;
01010    struct stat s;
01011    int blanklines = 0;
01012 
01013    if (configfile[0] == '/') {
01014       snprintf(fntmp, sizeof(fntmp), "%s.XXXXXX", configfile);
01015       ast_copy_string(fn, configfile, sizeof(fn));
01016    } else {
01017       snprintf(fntmp, sizeof(fntmp), "%s/%s.XXXXXX", ast_config_AST_CONFIG_DIR, configfile);
01018       snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile);
01019    }
01020    time(&t);
01021    ast_copy_string(date, ctime(&t), sizeof(date));
01022    if ((fd = mkstemp(fntmp)) > 0 && (f = fdopen(fd, "w")) != NULL) {
01023       if (option_verbose > 1)
01024          ast_verbose(VERBOSE_PREFIX_2 "Saving '%s': ", fn);
01025       fprintf(f, ";!\n");
01026       fprintf(f, ";! Automatically generated configuration file\n");
01027       if (strcmp(configfile, fn))
01028          fprintf(f, ";! Filename: %s (%s)\n", configfile, fn);
01029       else
01030          fprintf(f, ";! Filename: %s\n", configfile);
01031       fprintf(f, ";! Generator: %s\n", generator);
01032       fprintf(f, ";! Creation Date: %s", date);
01033       fprintf(f, ";!\n");
01034       cat = cfg->root;
01035       while(cat) {
01036          /* Dump section with any appropriate comment */
01037          for (cmt = cat->precomments; cmt; cmt=cmt->next)
01038          {
01039             if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
01040                fprintf(f,"%s", cmt->cmt);
01041          }
01042          if (!cat->precomments)
01043             fprintf(f,"\n");
01044          fprintf(f, "[%s]", cat->name);
01045          if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) {
01046             fprintf(f, "(");
01047             if (cat->ignored) {
01048                fprintf(f, "!");
01049             }
01050             if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) {
01051                fprintf(f, ",");
01052             }
01053             if (!AST_LIST_EMPTY(&cat->template_instances)) {
01054                struct ast_category_template_instance *x;
01055                AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
01056                   fprintf(f,"%s",x->name);
01057                   if (x != AST_LIST_LAST(&cat->template_instances))
01058                      fprintf(f,",");
01059                }
01060             }
01061             fprintf(f, ")");
01062          }
01063          for(cmt = cat->sameline; cmt; cmt=cmt->next)
01064          {
01065             fprintf(f,"%s", cmt->cmt);
01066          }
01067          if (!cat->sameline)
01068             fprintf(f,"\n");
01069          var = cat->root;
01070          while(var) {
01071             struct ast_category_template_instance *x;
01072             struct ast_variable *v2;
01073             int found = 0;
01074             AST_LIST_TRAVERSE(&cat->template_instances, x, next) {
01075                
01076                for (v2 = x->inst->root; v2; v2 = v2->next) {
01077                   if (!strcasecmp(var->name, v2->name))
01078                      break;
01079                }
01080                if (v2 && v2->value && !strcmp(v2->value, var->value)) {
01081                   found = 1;
01082                   break;
01083                }
01084             }
01085             if (found) {
01086                var = var->next;
01087                continue;
01088             }
01089             for (cmt = var->precomments; cmt; cmt=cmt->next)
01090             {
01091                if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!')
01092                   fprintf(f,"%s", cmt->cmt);
01093             }
01094             if (var->sameline) 
01095                fprintf(f, "%s %s %s  %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt);
01096             else  
01097                fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value);
01098             if (var->blanklines) {
01099                blanklines = var->blanklines;
01100                while (blanklines--)
01101                   fprintf(f, "\n");
01102             }
01103                
01104             var = var->next;
01105          }
01106 #if 0
01107          /* Put an empty line */
01108          fprintf(f, "\n");
01109 #endif
01110          cat = cat->next;
01111       }
01112       if ((option_verbose > 1) && !option_debug)
01113          ast_verbose("Saved\n");
01114    } else {
01115       if (option_debug)
01116          ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno));
01117       if (option_verbose > 1)
01118          ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
01119       if (fd > -1)
01120          close(fd);
01121       return -1;
01122    }
01123    stat(fn, &s);
01124    fchmod(fd, s.st_mode);
01125    fclose(f);
01126    if (unlink(fn) || link(fntmp, fn)) {
01127       if (option_debug)
01128          ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno));
01129       if (option_verbose > 1)
01130          ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno));
01131       unlink(fntmp);
01132       return -1;
01133    }
01134    unlink(fntmp);
01135    return 0;
01136 }

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

Find realtime engine for realtime family.

Definition at line 1298 of file config.c.

References ast_mutex_lock(), config_maps, and map.

Referenced by ast_check_realtime(), ast_config_internal_load(), ast_load_realtime(), ast_load_realtime_multientry(), ast_speech_new(), ast_speech_register(), and ast_update_realtime().

01299 {
01300    struct ast_config_engine *eng, *ret = NULL;
01301    struct ast_config_map *map;
01302 
01303    ast_mutex_lock(&config_lock);
01304 
01305    for (map = config_maps; map; map = map->next) {
01306       if (!strcasecmp(family, map->name)) {
01307          if (database)
01308             ast_copy_string(database, map->database, dbsiz);
01309          if (table)
01310             ast_copy_string(table, map->table ? map->table : family, tabsiz);
01311          break;
01312       }
01313    }
01314 
01315    /* Check if the required driver (engine) exist */
01316    if (map) {
01317       for (eng = config_engine_list; !ret && eng; eng = eng->next) {
01318          if (!strcasecmp(eng->name, map->driver))
01319             ret = eng;
01320       }
01321    }
01322 
01323    ast_mutex_unlock(&config_lock);
01324    
01325    /* if we found a mapping, but the engine is not available, then issue a warning */
01326    if (map && !ret)
01327       ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver);
01328 
01329    return ret;
01330 }

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

Definition at line 446 of file config.c.

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

Referenced by process_text_line().

00447 {
00448    struct ast_variable *var;
00449    struct ast_category_template_instance *x = ast_calloc(1,sizeof(struct ast_category_template_instance));
00450    strcpy(x->name, base->name);
00451    x->inst = base;
00452    AST_LIST_INSERT_TAIL(&new->template_instances, x, next);
00453    for (var = base->root; var; var = var->next)
00454       ast_variable_append(new, variable_clone(var));
00455 }

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

Definition at line 120 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

00121 {
00122    int rem = *lline_buffer_size - strlen(*lline_buffer) - 1;
00123    int siz = strlen(str);
00124    if (rem < siz+1) {
00125       *lline_buffer = ast_realloc(*lline_buffer, *lline_buffer_size + CB_INCR + siz + 1);
00126       if (!(*lline_buffer)) 
00127          return;
00128       *lline_buffer_size += CB_INCR + siz + 1;
00129    }
00130    strcat(*lline_buffer,str);
00131 }

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

Definition at line 285 of file config.c.

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

Referenced by process_text_line().

00286 {
00287    struct ast_variable *var = old->root;
00288    old->root = NULL;
00289 #if 1
00290    /* we can just move the entire list in a single op */
00291    ast_variable_append(new, var);
00292 #else
00293    while (var) {
00294       struct ast_variable *next = var->next;
00295       var->next = NULL;
00296       ast_variable_append(new, var);
00297       var = next;
00298    }
00299 #endif
00300 }

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

Definition at line 383 of file config.c.

References ast_category::ignored.

Referenced by ast_category_browse().

00384 {
00385    for (; cat && cat->ignored; cat = cat->next);
00386 
00387    return cat;
00388 }

static int process_text_line ( struct ast_config cfg,
struct ast_category **  cat,
char *  buf,
int  lineno,
const char *  configfile,
int  withcomments,
char **  comment_buffer,
int *  comment_buffer_size,
char **  lline_buffer,
int *  lline_buffer_size 
) [static]

Definition at line 624 of file config.c.

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

Referenced by config_text_file_load().

00626 {
00627    char *c;
00628    char *cur = buf;
00629    struct ast_variable *v;
00630    char cmd[512], exec_file[512];
00631    int object, do_exec, do_include;
00632 
00633    /* Actually parse the entry */
00634    if (cur[0] == '[') {
00635       struct ast_category *newcat = NULL;
00636       char *catname;
00637 
00638       /* A category header */
00639       c = strchr(cur, ']');
00640       if (!c) {
00641          ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile);
00642          return -1;
00643       }
00644       *c++ = '\0';
00645       cur++;
00646       if (*c++ != '(')
00647          c = NULL;
00648       catname = cur;
00649       if (!(*cat = newcat = ast_category_new(catname))) {
00650          return -1;
00651       }
00652       /* add comments */
00653       if (withcomments && *comment_buffer && (*comment_buffer)[0] ) {
00654          newcat->precomments = ALLOC_COMMENT(*comment_buffer);
00655       }
00656       if (withcomments && *lline_buffer && (*lline_buffer)[0] ) {
00657          newcat->sameline = ALLOC_COMMENT(*lline_buffer);
00658       }
00659       if( withcomments )
00660          CB_RESET(comment_buffer, lline_buffer);
00661       
00662       /* If there are options or categories to inherit from, process them now */
00663       if (c) {
00664          if (!(cur = strchr(c, ')'))) {
00665             ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile);
00666             return -1;
00667          }
00668          *cur = '\0';
00669          while ((cur = strsep(&c, ","))) {
00670             if (!strcasecmp(cur, "!")) {
00671                (*cat)->ignored = 1;
00672             } else if (!strcasecmp(cur, "+")) {
00673                *cat = category_get(cfg, catname, 1);
00674                if (!(*cat)) {
00675                   if (newcat)
00676                      ast_category_destroy(newcat);
00677                   ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile);
00678                   return -1;
00679                }
00680                if (newcat) {
00681                   move_variables(newcat, *cat);
00682                   ast_category_destroy(newcat);
00683                   newcat = NULL;
00684                }
00685             } else {
00686                struct ast_category *base;
00687             
00688                base = category_get(cfg, cur, 1);
00689                if (!base) {
00690                   ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile);
00691                   return -1;
00692                }
00693                inherit_category(*cat, base);
00694             }
00695          }
00696       }
00697       if (newcat)
00698          ast_category_append(cfg, *cat);
00699    } else if (cur[0] == '#') {
00700       /* A directive */
00701       cur++;
00702       c = cur;
00703       while(*c && (*c > 32)) c++;
00704       if (*c) {
00705          *c = '\0';
00706          /* Find real argument */
00707          c = ast_skip_blanks(c + 1);
00708          if (!(*c))
00709             c = NULL;
00710       } else 
00711          c = NULL;
00712       do_include = !strcasecmp(cur, "include");
00713       if(!do_include)
00714          do_exec = !strcasecmp(cur, "exec");
00715       else
00716          do_exec = 0;
00717       if (do_exec && !ast_opt_exec_includes) {
00718          ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n");
00719          do_exec = 0;
00720       }
00721       if (do_include || do_exec) {
00722          if (c) {
00723             /* Strip off leading and trailing "'s and <>'s */
00724             while((*c == '<') || (*c == '>') || (*c == '\"')) c++;
00725             /* Get rid of leading mess */
00726             cur = c;
00727             while (!ast_strlen_zero(cur)) {
00728                c = cur + strlen(cur) - 1;
00729                if ((*c == '>') || (*c == '<') || (*c == '\"'))
00730                   *c = '\0';
00731                else
00732                   break;
00733             }
00734             /* #exec </path/to/executable>
00735                We create a tmp file, then we #include it, then we delete it. */
00736             if (do_exec) { 
00737                snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self());
00738                snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file);
00739                ast_safe_system(cmd);
00740                cur = exec_file;
00741             } else
00742                exec_file[0] = '\0';
00743             /* A #include */
00744             do_include = ast_config_internal_load(cur, cfg, withcomments) ? 1 : 0;
00745             if(!ast_strlen_zero(exec_file))
00746                unlink(exec_file);
00747             if (!do_include) {
00748                ast_log(LOG_ERROR, "*********************************************************\n");
00749                ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n");
00750                ast_log(LOG_ERROR, "Future versions of Asterisk will treat a #include of a "
00751                                   "file that does not exist as an error, and will fail to "
00752                                   "load that configuration file.  Please ensure that the "
00753                                   "file '%s' exists, even if it is empty.\n", cur);
00754                ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n");
00755                ast_log(LOG_ERROR, "*********************************************************\n");
00756                return 0;
00757             }
00758 
00759          } else {
00760             ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n", 
00761                   do_exec ? "exec" : "include",
00762                   do_exec ? "/path/to/executable" : "filename",
00763                   lineno,
00764                   configfile);
00765          }
00766       }
00767       else 
00768          ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile);
00769    } else {
00770       /* Just a line (variable = value) */
00771       if (!(*cat)) {
00772          ast_log(LOG_WARNING,
00773             "parse error: No category context for line %d of %s\n", lineno, configfile);
00774          return -1;
00775       }
00776       c = strchr(cur, '=');
00777       if (c) {
00778          *c = 0;
00779          c++;
00780          /* Ignore > in => */
00781          if (*c== '>') {
00782             object = 1;
00783             c++;
00784          } else
00785             object = 0;
00786          if ((v = ast_variable_new(ast_strip(cur), ast_strip(c)))) {
00787             v->lineno = lineno;
00788             v->object = object;
00789             /* Put and reset comments */
00790             v->blanklines = 0;
00791             ast_variable_append(*cat, v);
00792             /* add comments */
00793             if (withcomments && *comment_buffer && (*comment_buffer)[0] ) {
00794                v->precomments = ALLOC_COMMENT(*comment_buffer);
00795             }
00796             if (withcomments && *lline_buffer && (*lline_buffer)[0] ) {
00797                v->sameline = ALLOC_COMMENT(*lline_buffer);
00798             }
00799             if( withcomments )
00800                CB_RESET(comment_buffer, lline_buffer);
00801             
00802          } else {
00803             return -1;
00804          }
00805       } else {
00806          ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile);
00807       }
00808    }
00809    return 0;
00810 }

int read_config_maps ( void   ) 

Definition at line 1188 of file config.c.

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

Referenced by main().

01189 {
01190    struct ast_config *config, *configtmp;
01191    struct ast_variable *v;
01192    char *driver, *table, *database, *stringp, *tmp;
01193 
01194    clear_config_maps();
01195 
01196    configtmp = ast_config_new();
01197    configtmp->max_include_level = 1;
01198    config = ast_config_internal_load(extconfig_conf, configtmp, 0);
01199    if (!config) {
01200       ast_config_destroy(configtmp);
01201       return 0;
01202    }
01203 
01204    for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
01205       stringp = v->value;
01206       driver = strsep(&stringp, ",");
01207 
01208       if ((tmp = strchr(stringp, '\"')))
01209          stringp = tmp;
01210 
01211       /* check if the database text starts with a double quote */
01212       if (*stringp == '"') {
01213          stringp++;
01214          database = strsep(&stringp, "\"");
01215          strsep(&stringp, ",");
01216       } else {
01217          /* apparently this text has no quotes */
01218          database = strsep(&stringp, ",");
01219       }
01220 
01221       table = strsep(&stringp, ",");
01222 
01223       if (!strcmp(v->name, extconfig_conf)) {
01224          ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf);
01225          continue;
01226       }
01227 
01228       if (!strcmp(v->name, "asterisk.conf")) {
01229          ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n");
01230          continue;
01231       }
01232 
01233       if (!strcmp(v->name, "logger.conf")) {
01234          ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n");
01235          continue;
01236       }
01237 
01238       if (!driver || !database)
01239          continue;
01240       if (!strcasecmp(v->name, "sipfriends")) {
01241          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");
01242          append_mapping("sipusers", driver, database, table ? table : "sipfriends");
01243          append_mapping("sippeers", driver, database, table ? table : "sipfriends");
01244       } else if (!strcasecmp(v->name, "iaxfriends")) {
01245          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");
01246          append_mapping("iaxusers", driver, database, table ? table : "iaxfriends");
01247          append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends");
01248       } else 
01249          append_mapping(v->name, driver, database, table);
01250    }
01251       
01252    ast_config_destroy(config);
01253    return 0;
01254 }

int register_config_cli ( void   ) 

Definition at line 1510 of file config.c.

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

01511 {
01512    ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry));
01513    return 0;
01514 }

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

Definition at line 271 of file config.c.

References ast_variable_new(), ast_variable::blanklines, ast_variable::lineno, ast_variable::name, ast_variable::object, and ast_variable::value.

Referenced by inherit_category().

00272 {
00273    struct ast_variable *new = ast_variable_new(old->name, old->value);
00274 
00275    if (new) {
00276       new->lineno = old->lineno;
00277       new->object = old->object;
00278       new->blanklines = old->blanklines;
00279       /* TODO: clone comments? */
00280    }
00281 
00282    return new;
00283 }


Variable Documentation

struct ast_cli_entry cli_config[] [static]

Initial value:

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

Definition at line 1504 of file config.c.

Referenced by register_config_cli().

struct ast_cli_entry cli_show_config_mappings_deprecated [static]

Initial value:

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

Definition at line 1499 of file config.c.

struct ast_config_engine* config_engine_list [static]

Definition at line 158 of file config.c.

Referenced by ast_config_engine_deregister(), ast_config_engine_register(), ast_config_internal_load(), and config_command().

struct ast_config_map * config_maps [static]

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

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

Definition at line 63 of file config.c.

char show_config_help[] [static]

Initial value:

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

Definition at line 1495 of file config.c.

struct ast_config_engine text_file_engine [static]

Initial value:

 {
   .name = "text",
   .load_func = config_text_file_load,
}

Definition at line 1332 of file config.c.

Referenced by ast_config_internal_load().


Generated on Mon Mar 31 07:40:26 2008 for Asterisk - the Open Source PBX by  doxygen 1.5.1