Tue Jul 14 23:10:22 2009

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"

Go to the source code of this file.

Data Structures

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

Defines

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

Functions

static struct ast_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.
int ast_realtime_enabled (void)
 Check if realtime engine is enabled returns 1 if realtime is enabled.
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)
ast_variableast_variable_next (struct ast_config *config, char *category, struct ast_variable *prev)
 Iterates through variables.
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 ast_mutex_t config_lock = ((ast_mutex_t) PTHREAD_MUTEX_INITIALIZER )
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 69 of file config.c.

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

#define COMMENT_END   "--;"

Definition at line 56 of file config.c.

#define COMMENT_META   ';'

Definition at line 57 of file config.c.

Referenced by config_text_file_load().

#define COMMENT_START   ";--"

Definition at line 55 of file config.c.

#define COMMENT_TAG   '-'

Definition at line 58 of file config.c.

Referenced by config_text_file_load().

#define MAX_INCLUDE_LEVEL   10

Definition at line 157 of file config.c.

Referenced by ast_config_new().

#define MAX_NESTED_COMMENTS   128

Definition at line 54 of file config.c.

Referenced by config_text_file_load().


Function Documentation

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

Definition at line 137 of file config.c.

References ast_calloc, and ast_comment::cmt.

Referenced by process_text_line().

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

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

Definition at line 1171 of file config.c.

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

Referenced by read_config_maps().

01172 {
01173    struct ast_config_map *map;
01174    int length;
01175 
01176    length = sizeof(*map);
01177    length += strlen(name) + 1;
01178    length += strlen(driver) + 1;
01179    length += strlen(database) + 1;
01180    if (table)
01181       length += strlen(table) + 1;
01182 
01183    if (!(map = ast_calloc(1, length)))
01184       return -1;
01185 
01186    map->name = map->stuff;
01187    strcpy(map->name, name);
01188    map->driver = map->name + strlen(map->name) + 1;
01189    strcpy(map->driver, driver);
01190    map->database = map->driver + strlen(map->driver) + 1;
01191    strcpy(map->database, database);
01192    if (table) {
01193       map->table = map->database + strlen(map->database) + 1;
01194       strcpy(map->table, table);
01195    }
01196    map->next = config_maps;
01197 
01198    if (option_verbose > 1)
01199       ast_verbose(VERBOSE_PREFIX_2 "Binding %s to %s/%s/%s\n",
01200              map->name, map->driver, map->database, map->table ? map->table : map->name);
01201 
01202    config_maps = map;
01203    return 0;
01204 }

void ast_category_append ( struct ast_config config,
struct ast_category category 
)

Definition at line 355 of file config.c.

References config, and ast_category::include_level.

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

00356 {
00357    if (config->last)
00358       config->last->next = category;
00359    else
00360       config->root = category;
00361    category->include_level = config->include_level;
00362    config->last = category;
00363    config->current = category;
00364 }

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

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

Referenced by __queues_show(), 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_dahdi(), sla_load_config(), update_realtime_members(), and vm_change_password().

00415 {  
00416    struct ast_category *cat = NULL;
00417 
00418    if (prev && config->last_browse && (config->last_browse->name == prev))
00419       cat = config->last_browse->next;
00420    else if (!prev && config->root)
00421       cat = config->root;
00422    else if (prev) {
00423       for (cat = config->root; cat; cat = cat->next) {
00424          if (cat->name == prev) {
00425             cat = cat->next;
00426             break;
00427          }
00428       }
00429       if (!cat) {
00430          for (cat = config->root; cat; cat = cat->next) {
00431             if (!strcasecmp(cat->name, prev)) {
00432                cat = cat->next;
00433                break;
00434             }
00435          }
00436       }
00437    }
00438    
00439    if (cat)
00440       cat = next_available_category(cat);
00441 
00442    config->last_browse = cat;
00443    return (cat) ? cat->name : NULL;
00444 }

int ast_category_delete ( struct ast_config cfg,
char *  category 
)

Definition at line 569 of file config.c.

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

Referenced by handle_updates().

00570 {
00571    struct ast_category *prev=NULL, *cat;
00572    cat = cfg->root;
00573    while(cat) {
00574       if (cat->name == category) {
00575          if (prev) {
00576             prev->next = cat->next;
00577             if (cat == cfg->last)
00578                cfg->last = prev;
00579          } else {
00580             cfg->root = cat->next;
00581             if (cat == cfg->last)
00582                cfg->last = NULL;
00583          }
00584          ast_category_destroy(cat);
00585          return 0;
00586       }
00587       prev = cat;
00588       cat = cat->next;
00589    }
00590 
00591    prev = NULL;
00592    cat = cfg->root;
00593    while(cat) {
00594       if (!strcasecmp(cat->name, category)) {
00595          if (prev) {
00596             prev->next = cat->next;
00597             if (cat == cfg->last)
00598                cfg->last = prev;
00599          } else {
00600             cfg->root = cat->next;
00601             if (cat == cfg->last)
00602                cfg->last = NULL;
00603          }
00604          ast_category_destroy(cat);
00605          return 0;
00606       }
00607       prev = cat;
00608       cat = cat->next;
00609    }
00610    return -1;
00611 }

void ast_category_destroy ( struct ast_category cat  ) 

Definition at line 391 of file config.c.

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

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

00392 {
00393    ast_variables_destroy(cat->root);
00394    ast_destroy_comments(cat);
00395    ast_destroy_template_list(cat);
00396    free(cat);
00397 }

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 446 of file config.c.

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

Referenced by realtime_switch_common().

00447 {
00448    struct ast_variable *v;
00449 
00450    v = cat->root;
00451    cat->root = NULL;
00452    cat->last = NULL;
00453 
00454    return v;
00455 }

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

References ast_category_get(), and config.

00351 {
00352    return !!ast_category_get(config, category_name);
00353 }

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

00346 {
00347    return category_get(config, category_name, 0);
00348 }

struct ast_category* ast_category_new ( const char *  name  ) 

Definition at line 318 of file config.c.

References ast_calloc, and ast_copy_string().

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

00319 {
00320    struct ast_category *category;
00321 
00322    if ((category = ast_calloc(1, sizeof(*category))))
00323       ast_copy_string(category->name, name, sizeof(category->name));
00324    return category;
00325 }

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

Definition at line 457 of file config.c.

References ast_copy_string(), and ast_category::name.

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

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

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

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

00407 {
00408    struct ast_category *category = ast_category_get(config, cat);
00409    if (category)
00410       return category->root;
00411    return NULL;
00412 }

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

References find_engine().

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

01446 {
01447    struct ast_config_engine *eng;
01448 
01449    eng = find_engine(family, NULL, 0, NULL, 0);
01450    if (eng)
01451       return 1;
01452    return 0;
01453 
01454 }

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

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

Referenced by __ast_http_load(), __queues_show(), action_getconfig(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_config_load(), ast_config_load_with_comments(), ast_enum_init(), ast_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(), load_config(), load_config_meetme(), load_module(), load_realtime_queue(), load_rpt_vars(), loadconfigurationfile(), make_email_file(), my_load_module(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), privacy_exec(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().

00614 {
00615    struct ast_category *cat, *catn;
00616 
00617    if (!cfg)
00618       return;
00619 
00620    cat = cfg->root;
00621    while(cat) {
00622       catn = cat;
00623       cat = cat->next;
00624       ast_category_destroy(catn);
00625    }
00626    free(cfg);
00627 }

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deegister config engine.

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

01294 {
01295    struct ast_config_engine *ptr, *last=NULL;
01296 
01297    ast_mutex_lock(&config_lock);
01298 
01299    for (ptr = config_engine_list; ptr; ptr=ptr->next) {
01300       if (ptr == del) {
01301          if (last)
01302             last->next = ptr->next;
01303          else
01304             config_engine_list = ptr->next;
01305          break;
01306       }
01307       last = ptr;
01308    }
01309 
01310    ast_mutex_unlock(&config_lock);
01311 
01312    return 0;
01313 }

int ast_config_engine_register ( struct ast_config_engine new  ) 

Register config engine.

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

01275 {
01276    struct ast_config_engine *ptr;
01277 
01278    ast_mutex_lock(&config_lock);
01279 
01280    if (!config_engine_list) {
01281       config_engine_list = new;
01282    } else {
01283       for (ptr = config_engine_list; ptr->next; ptr=ptr->next);
01284       ptr->next = new;
01285    }
01286 
01287    ast_mutex_unlock(&config_lock);
01288    ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name);
01289 
01290    return 1;
01291 }

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

Definition at line 629 of file config.c.

References ast_config::current.

Referenced by config_odbc(), and config_text_file_load().

00630 {
00631    return cfg->current;
00632 }

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

Definition at line 1355 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, table, and text_file_engine.

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

01356 {
01357    char db[256];
01358    char table[256];
01359    struct ast_config_engine *loader = &text_file_engine;
01360    struct ast_config *result; 
01361 
01362    /* The config file itself bumps include_level by 1 */
01363    if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) {
01364       ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level);
01365       return NULL;
01366    }
01367 
01368    cfg->include_level++;
01369 
01370    if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) {
01371       struct ast_config_engine *eng;
01372 
01373       eng = find_engine(filename, db, sizeof(db), table, sizeof(table));
01374 
01375 
01376       if (eng && eng->load_func) {
01377          loader = eng;
01378       } else {
01379          eng = find_engine("global", db, sizeof(db), table, sizeof(table));
01380          if (eng && eng->load_func)
01381             loader = eng;
01382       }
01383    }
01384 
01385    result = loader->load_func(db, table, filename, cfg, withcomments);
01386 
01387    if (result)
01388       result->include_level--;
01389    else
01390       cfg->include_level--;
01391 
01392    return result;
01393 }

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

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

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

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

struct ast_config* ast_config_load_with_comments ( const char *  filename  ) 

Definition at line 1411 of file config.c.

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

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

01412 {
01413    struct ast_config *cfg;
01414    struct ast_config *result;
01415 
01416    cfg = ast_config_new();
01417    if (!cfg)
01418       return NULL;
01419 
01420    result = ast_config_internal_load(filename, cfg, 1);
01421    if (!result)
01422       ast_config_destroy(cfg);
01423 
01424    return result;
01425 }

struct ast_config* ast_config_new ( void   ) 

Definition at line 473 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_odbc(), and realtime_multi_pgsql().

00474 {
00475    struct ast_config *config;
00476 
00477    if ((config = ast_calloc(1, sizeof(*config))))
00478       config->max_include_level = MAX_INCLUDE_LEVEL;
00479    return config;
00480 }

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

Definition at line 237 of file config.c.

References ast_variable_retrieve().

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

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

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

Definition at line 634 of file config.c.

References ast_config::current.

00635 {
00636    /* cast below is just to silence compiler warning about dropping "const" */
00637    cfg->current = (struct ast_category *) cat;
00638 }

static void ast_destroy_comments ( struct ast_category cat  )  [static]

Definition at line 366 of file config.c.

References free, ast_comment::next, ast_category::precomments, and ast_category::sameline.

Referenced by ast_category_destroy().

00367 {
00368    struct ast_comment *n, *p;
00369    for (p=cat->precomments; p; p=n) {
00370       n = p->next;
00371       free(p);
00372    }
00373    for (p=cat->sameline; p; p=n) {
00374       n = p->next;
00375       free(p);
00376    }
00377    cat->precomments = NULL;
00378    cat->sameline = NULL;
00379 }

static void ast_destroy_template_list ( struct ast_category cat  )  [static]

Definition at line 381 of file config.c.

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

Referenced by ast_category_destroy().

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

01428 {
01429    struct ast_config_engine *eng;
01430    char db[256]="";
01431    char table[256]="";
01432    struct ast_variable *res=NULL;
01433    va_list ap;
01434 
01435    va_start(ap, family);
01436    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01437    if (eng && eng->realtime_func) 
01438       res = eng->realtime_func(db, table, ap);
01439    va_end(ap);
01440 
01441    return res;
01442 }

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 1462 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(), and update_realtime_members().

01463 {
01464    struct ast_config_engine *eng;
01465    char db[256]="";
01466    char table[256]="";
01467    struct ast_config *res=NULL;
01468    va_list ap;
01469 
01470    va_start(ap, family);
01471    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01472    if (eng && eng->realtime_multi_func) 
01473       res = eng->realtime_multi_func(db, table, ap);
01474    va_end(ap);
01475 
01476    return res;
01477 }

int ast_realtime_enabled ( void   ) 

Check if realtime engine is enabled returns 1 if realtime is enabled.

Definition at line 1457 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

01458 {
01459    return config_maps ? 1 : 0;
01460 }

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

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

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

01480 {
01481    struct ast_config_engine *eng;
01482    int res = -1;
01483    char db[256]="";
01484    char table[256]="";
01485    va_list ap;
01486 
01487    va_start(ap, lookup);
01488    eng = find_engine(family, db, sizeof(db), table, sizeof(table));
01489    if (eng && eng->update_func) 
01490       res = eng->update_func(db, table, keyfield, lookup, ap);
01491    va_end(ap);
01492 
01493    return res;
01494 }

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

Definition at line 201 of file config.c.

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

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

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

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

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

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

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

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

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

00483 {
00484    struct ast_variable *cur, *prev=NULL, *curn;
00485    int res = -1;
00486    cur = category->root;
00487    while (cur) {
00488       if (cur->name == variable) {
00489          if (prev) {
00490             prev->next = cur->next;
00491             if (cur == category->last)
00492                category->last = prev;
00493          } else {
00494             category->root = cur->next;
00495             if (cur == category->last)
00496                category->last = NULL;
00497          }
00498          cur->next = NULL;
00499          ast_variables_destroy(cur);
00500          return 0;
00501       }
00502       prev = cur;
00503       cur = cur->next;
00504    }
00505 
00506    prev = NULL;
00507    cur = category->root;
00508    while (cur) {
00509       curn = cur->next;
00510       if (!strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match))) {
00511          if (prev) {
00512             prev->next = cur->next;
00513             if (cur == category->last)
00514                category->last = prev;
00515          } else {
00516             category->root = cur->next;
00517             if (cur == category->last)
00518                category->last = NULL;
00519          }
00520          cur->next = NULL;
00521          ast_variables_destroy(cur);
00522          res = 0;
00523       } else
00524          prev = cur;
00525 
00526       cur = curn;
00527    }
00528    return res;
00529 }

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

Definition at line 186 of file config.c.

References ast_calloc, and ast_variable::name.

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

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

struct ast_variable* ast_variable_next ( struct ast_config config,
char *  category,
struct ast_variable prev 
)

Iterates through variables.

Somewhat similar in intent as the ast_category_browse. The prev variable MUST be an actual pointer to an actual variable (such as one obtained by using ast_variable_browse() or ast_variable_next() itself). List variables of config file Returns next variable on the list, or NULL on failure

Definition at line 247 of file config.c.

References ast_variable_browse(), and config.

00248 {
00249    struct ast_variable *v = NULL;
00250    v = ast_variable_browse(config, category);
00251    if(v) {
00252      if(prev) {
00253       while (v) {
00254         if (v == prev)
00255          return v->next;
00256         v=v->next;
00257       }
00258      } else {
00259       return v;
00260      }
00261    }
00262    return NULL;
00263 }

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

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

Referenced by advanced_options(), aji_load_config(), ast_config_option(), ast_rtp_reload(), ast_udptl_reload(), 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_rpt_vars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), privacy_exec(), process_my_load_module(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_queues(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), set_config(), setup_dahdi(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), update_realtime_members(), vm_change_password(), and vm_forwardoptions().

00267 {
00268    struct ast_variable *v;
00269 
00270    if (category) {
00271       for (v = ast_variable_browse(config, category); v; v = v->next) {
00272          if (!strcasecmp(variable, v->name))
00273             return v->value;
00274       }
00275    } else {
00276       struct ast_category *cat;
00277 
00278       for (cat = config->root; cat; cat = cat->next)
00279          for (v = cat->root; v; v = v->next)
00280             if (!strcasecmp(variable, v->name))
00281                return v->value;
00282    }
00283 
00284    return NULL;
00285 }

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

Definition at line 531 of file config.c.

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

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

00533 {
00534    struct ast_variable *cur, *prev=NULL, *newer;
00535 
00536    if (!(newer = ast_variable_new(variable, value)))
00537       return -1;
00538    
00539    newer->object = object;
00540 
00541    for (cur = category->root; cur; prev = cur, cur = cur->next) {
00542       if (strcasecmp(cur->name, variable) ||
00543          (!ast_strlen_zero(match) && strcasecmp(cur->value, match)))
00544          continue;
00545 
00546       newer->next = cur->next;
00547       newer->object = cur->object || object;
00548       if (prev)
00549          prev->next = newer;
00550       else
00551          category->root = newer;
00552       if (category->last == cur)
00553          category->last = newer;
00554 
00555       cur->next = NULL;
00556       ast_variables_destroy(cur);
00557 
00558       return 0;
00559    }
00560 
00561    if (prev)
00562       prev->next = newer;
00563    else
00564       category->root = newer;
00565 
00566    return 0;
00567 }

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 214 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(), cli_realtime_load(), find_conf_realtime(), find_user_realtime(), handle_uri(), load_realtime_queue(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), update_realtime_member_field(), and user_destructor().

00215 {
00216    struct ast_variable *vn;
00217 
00218    while(v) {
00219       vn = v;
00220       v = v->next;
00221       free(vn);
00222    }
00223 }

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

Definition at line 327 of file config.c.

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

Referenced by ast_category_get(), and process_text_line().

00328 {
00329    struct ast_category *cat;
00330 
00331    /* try exact match first, then case-insensitive match */
00332    for (cat = config->root; cat; cat = cat->next) {
00333       if (cat->name == category_name && (ignored || !cat->ignored))
00334          return cat;
00335    }
00336 
00337    for (cat = config->root; cat; cat = cat->next) {
00338       if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored))
00339          return cat;
00340    }
00341 
00342    return NULL;
00343 }

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

Definition at line 90 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

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

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

Definition at line 103 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

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

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

Definition at line 71 of file config.c.

References ast_malloc, and CB_INCR.

Referenced by config_text_file_load().

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

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

Definition at line 130 of file config.c.

Referenced by process_text_line().

00131 { 
00132    (*comment_buffer)[0] = 0; 
00133    (*lline_buffer)[0] = 0;
00134 }

static void clear_config_maps ( void   )  [static]

Definition at line 1156 of file config.c.

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

Referenced by read_config_maps().

01157 {
01158    struct ast_config_map *map;
01159 
01160    ast_mutex_lock(&config_lock);
01161 
01162    while (config_maps) {
01163       map = config_maps;
01164       config_maps = config_maps->next;
01165       free(map);
01166    }
01167       
01168    ast_mutex_unlock(&config_lock);
01169 }

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

Definition at line 1496 of file config.c.

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

01497 {
01498    struct ast_config_engine *eng;
01499    struct ast_config_map *map;
01500    
01501    ast_mutex_lock(&config_lock);
01502 
01503    ast_cli(fd, "\n\n");
01504    for (eng = config_engine_list; eng; eng = eng->next) {
01505       ast_cli(fd, "\nConfig Engine: %s\n", eng->name);
01506       for (map = config_maps; map; map = map->next)
01507          if (!strcasecmp(map->driver, eng->name)) {
01508             ast_cli(fd, "===> %s (db=%s, table=%s)\n", map->name, map->database,
01509                map->table ? map->table : map->name);
01510          }
01511    }
01512    ast_cli(fd,"\n\n");
01513    
01514    ast_mutex_unlock(&config_lock);
01515 
01516    return 0;
01517 }

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

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

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

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

Definition at line 1016 of file config.c.

References ast_config_AST_CONFIG_DIR, ast_copy_string(), AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_log(), ast_verbose(), ast_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_category_template_instance::next, ast_variable::next, ast_category::next, option_debug, option_verbose, ast_category::precomments, ast_config::root, ast_category::root, ast_category::sameline, t, ast_category::template_instances, ast_variable::value, var, and VERBOSE_PREFIX_2.

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

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

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

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

01317 {
01318    struct ast_config_engine *eng, *ret = NULL;
01319    struct ast_config_map *map;
01320 
01321    ast_mutex_lock(&config_lock);
01322 
01323    for (map = config_maps; map; map = map->next) {
01324       if (!strcasecmp(family, map->name)) {
01325          if (database)
01326             ast_copy_string(database, map->database, dbsiz);
01327          if (table)
01328             ast_copy_string(table, map->table ? map->table : family, tabsiz);
01329          break;
01330       }
01331    }
01332 
01333    /* Check if the required driver (engine) exist */
01334    if (map) {
01335       for (eng = config_engine_list; !ret && eng; eng = eng->next) {
01336          if (!strcasecmp(eng->name, map->driver))
01337             ret = eng;
01338       }
01339    }
01340 
01341    ast_mutex_unlock(&config_lock);
01342    
01343    /* if we found a mapping, but the engine is not available, then issue a warning */
01344    if (map && !ret)
01345       ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver);
01346 
01347    return ret;
01348 }

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

Definition at line 462 of file config.c.

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

Referenced by process_text_line().

00463 {
00464    struct ast_variable *var;
00465    struct ast_category_template_instance *x = ast_calloc(1,sizeof(struct ast_category_template_instance));
00466    strcpy(x->name, base->name);
00467    x->inst = base;
00468    AST_LIST_INSERT_TAIL(&new->template_instances, x, next);
00469    for (var = base->root; var; var = var->next)
00470       ast_variable_append(new, variable_clone(var));
00471 }

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

Definition at line 117 of file config.c.

References ast_realloc, and CB_INCR.

Referenced by config_text_file_load().

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

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

Definition at line 301 of file config.c.

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

Referenced by process_text_line().

00302 {
00303    struct ast_variable *var = old->root;
00304    old->root = NULL;
00305 #if 1
00306    /* we can just move the entire list in a single op */
00307    ast_variable_append(new, var);
00308 #else
00309    while (var) {
00310       struct ast_variable *next = var->next;
00311       var->next = NULL;
00312       ast_variable_append(new, var);
00313       var = next;
00314    }
00315 #endif
00316 }

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

Definition at line 399 of file config.c.

References ast_category::ignored, and ast_category::next.

Referenced by ast_category_browse().

00400 {
00401    for (; cat && cat->ignored; cat = cat->next);
00402 
00403    return cat;
00404 }

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 640 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_skip_blanks(), ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), ast_variable::blanklines, category_get(), CB_RESET(), inherit_category(), ast_variable::lineno, LOG_ERROR, LOG_WARNING, move_variables(), ast_variable::object, ast_variable::precomments, ast_category::precomments, ast_variable::sameline, and ast_category::sameline.

Referenced by config_text_file_load().

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

int read_config_maps ( void   ) 

Definition at line 1206 of file config.c.

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

Referenced by main().

01207 {
01208    struct ast_config *config, *configtmp;
01209    struct ast_variable *v;
01210    char *driver, *table, *database, *stringp, *tmp;
01211 
01212    clear_config_maps();
01213 
01214    configtmp = ast_config_new();
01215    configtmp->max_include_level = 1;
01216    config = ast_config_internal_load(extconfig_conf, configtmp, 0);
01217    if (!config) {
01218       ast_config_destroy(configtmp);
01219       return 0;
01220    }
01221 
01222    for (v = ast_variable_browse(config, "settings"); v; v = v->next) {
01223       stringp = v->value;
01224       driver = strsep(&stringp, ",");
01225 
01226       if ((tmp = strchr(stringp, '\"')))
01227          stringp = tmp;
01228 
01229       /* check if the database text starts with a double quote */
01230       if (*stringp == '"') {
01231          stringp++;
01232          database = strsep(&stringp, "\"");
01233          strsep(&stringp, ",");
01234       } else {
01235          /* apparently this text has no quotes */
01236          database = strsep(&stringp, ",");
01237       }
01238 
01239       table = strsep(&stringp, ",");
01240 
01241       if (!strcmp(v->name, extconfig_conf)) {
01242          ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf);
01243          continue;
01244       }
01245 
01246       if (!strcmp(v->name, "asterisk.conf")) {
01247          ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n");
01248          continue;
01249       }
01250 
01251       if (!strcmp(v->name, "logger.conf")) {
01252          ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n");
01253          continue;
01254       }
01255 
01256       if (!driver || !database)
01257          continue;
01258       if (!strcasecmp(v->name, "sipfriends")) {
01259          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");
01260          append_mapping("sipusers", driver, database, table ? table : "sipfriends");
01261          append_mapping("sippeers", driver, database, table ? table : "sipfriends");
01262       } else if (!strcasecmp(v->name, "iaxfriends")) {
01263          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");
01264          append_mapping("iaxusers", driver, database, table ? table : "iaxfriends");
01265          append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends");
01266       } else 
01267          append_mapping(v->name, driver, database, table);
01268    }
01269       
01270    ast_config_destroy(config);
01271    return 0;
01272 }

int register_config_cli ( void   ) 

Definition at line 1534 of file config.c.

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

01535 {
01536    ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry));
01537    return 0;
01538 }

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

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

00288 {
00289    struct ast_variable *new = ast_variable_new(old->name, old->value);
00290 
00291    if (new) {
00292       new->lineno = old->lineno;
00293       new->object = old->object;
00294       new->blanklines = old->blanklines;
00295       /* TODO: clone comments? */
00296    }
00297 
00298    return new;
00299 }


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

struct ast_config_engine* config_engine_list [static]

Definition at line 155 of file config.c.

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

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

Definition at line 154 of file config.c.

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

struct ast_config_map * config_maps [static]

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

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

Definition at line 60 of file config.c.

char show_config_help[] [static]

Initial value:

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

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

Referenced by ast_config_internal_load().


Generated on Tue Jul 14 23:10:22 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7