Tue Nov 4 13:20:37 2008

Asterisk developer's documentation


config.h File Reference

Configuration File Parser. More...

#include <stdarg.h>

Go to the source code of this file.

Data Structures

struct  ast_config_engine
struct  ast_variable

Typedefs

typedef ast_configconfig_load_func (const char *database, const char *table, const char *configfile, struct ast_config *config, int withcomments)
typedef ast_configrealtime_multi_get (const char *database, const char *table, va_list ap)
typedef int realtime_update (const char *database, const char *table, const char *keyfield, const char *entity, va_list ap)
typedef ast_variablerealtime_var_get (const char *database, const char *table, va_list ap)

Functions

void ast_category_append (struct ast_config *config, struct ast_category *cat)
char * ast_category_browse (struct ast_config *config, const char *prev)
 Goes through categories.
int ast_category_delete (struct ast_config *cfg, 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 *config)
 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 *newconfig)
 Register config engine.
ast_categoryast_config_get_current_category (const struct ast_config *cfg)
ast_configast_config_internal_load (const char *configfile, 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)
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 *var)
 Free variable list.
int config_text_file_save (const char *filename, const struct ast_config *cfg, const char *generator)
int read_config_maps (void)
int register_config_cli (void)


Detailed Description

Configuration File Parser.

Definition in file config.h.


Typedef Documentation

typedef struct ast_config* config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, int withcomments)

Definition at line 48 of file config.h.

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

Definition at line 50 of file config.h.

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

Definition at line 51 of file config.h.

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

Definition at line 49 of file config.h.


Function Documentation

void ast_category_append ( struct ast_config config,
struct ast_category cat 
)

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

00359 {
00360    if (config->last)
00361       config->last->next = category;
00362    else
00363       config->root = category;
00364    category->include_level = config->include_level;
00365    config->last = category;
00366    config->current = category;
00367 }

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

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

int ast_category_delete ( struct ast_config cfg,
char *  category 
)

Definition at line 572 of file config.c.

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

Referenced by handle_updates().

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

void ast_category_destroy ( struct ast_category cat  ) 

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

00395 {
00396    ast_variables_destroy(cat->root);
00397    ast_destroy_comments(cat);
00398    ast_destroy_template_list(cat);
00399    free(cat);
00400 }

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 449 of file config.c.

Referenced by realtime_switch_common().

00450 {
00451    struct ast_variable *v;
00452 
00453    v = cat->root;
00454    cat->root = NULL;
00455    cat->last = NULL;
00456 
00457    return v;
00458 }

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

References ast_category_get(), and config.

00354 {
00355    return !!ast_category_get(config, category_name);
00356 }

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

00349 {
00350    return category_get(config, category_name, 0);
00351 }

struct ast_category* ast_category_new ( const char *  name  ) 

Definition at line 321 of file config.c.

References ast_calloc.

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

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

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

Definition at line 460 of file config.c.

References ast_category::name.

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

00461 {
00462    ast_copy_string(cat->name, name, sizeof(cat->name));
00463 }

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

References ast_category_get(), and config.

00410 {
00411    struct ast_category *category = ast_category_get(config, cat);
00412    if (category)
00413       return category->root;
00414    return NULL;
00415 }

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

References find_engine().

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

01451 {
01452    struct ast_config_engine *eng;
01453 
01454    eng = find_engine(family, NULL, 0, NULL, 0);
01455    if (eng)
01456       return 1;
01457    return 0;
01458 
01459 }

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 616 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(), 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_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().

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

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deegister config engine.

Definition at line 1298 of file config.c.

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

Referenced by unload_module().

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

int ast_config_engine_register ( struct ast_config_engine newconfig  ) 

Register config engine.

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

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

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

Definition at line 632 of file config.c.

References ast_config::current.

Referenced by config_odbc(), and config_text_file_load().

00633 {
00634    return cfg->current;
00635 }

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

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

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

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

01401 {
01402    struct ast_config *cfg;
01403    struct ast_config *result;
01404 
01405    cfg = ast_config_new();
01406    if (!cfg)
01407       return NULL;
01408 
01409    result = ast_config_internal_load(filename, cfg, 0);
01410    if (!result)
01411       ast_config_destroy(cfg);
01412 
01413    return result;
01414 }

struct ast_config* ast_config_load_with_comments ( const char *  filename  ) 

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

01417 {
01418    struct ast_config *cfg;
01419    struct ast_config *result;
01420 
01421    cfg = ast_config_new();
01422    if (!cfg)
01423       return NULL;
01424 
01425    result = ast_config_internal_load(filename, cfg, 1);
01426    if (!result)
01427       ast_config_destroy(cfg);
01428 
01429    return result;
01430 }

struct ast_config* ast_config_new ( void   ) 

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

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

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

References ast_config::current.

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

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

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

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

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

int ast_realtime_enabled ( void   ) 

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

Definition at line 1462 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

01463 {
01464    return config_maps ? 1 : 0;
01465 }

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

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

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

Definition at line 204 of file config.c.

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

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

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

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

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 }

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

References ast_variable_browse(), and config.

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

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

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

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

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

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

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(), 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(), 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 }

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

Definition at line 1023 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_variable::name, ast_category_template_instance::name, ast_category::name, ast_variable::next, ast_comment::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().

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

int read_config_maps ( void   ) 

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

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

int register_config_cli ( void   ) 

Definition at line 1539 of file config.c.

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

01540 {
01541    ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry));
01542    return 0;
01543 }


Generated on Tue Nov 4 13:20:37 2008 for Asterisk - the Open Source PBX by  doxygen 1.4.7