Sat Aug 6 00:39:54 2011

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

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

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

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

int ast_category_delete ( struct ast_config cfg,
char *  category 
)

Definition at line 576 of file config.c.

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

Referenced by handle_updates().

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

void ast_category_destroy ( struct ast_category cat  ) 

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

00399 {
00400    ast_variables_destroy(cat->root);
00401    ast_destroy_comments(cat);
00402    ast_destroy_template_list(cat);
00403    free(cat);
00404 }

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 453 of file config.c.

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

Referenced by realtime_switch_common().

00454 {
00455    struct ast_variable *v;
00456 
00457    v = cat->root;
00458    cat->root = NULL;
00459    cat->last = NULL;
00460 
00461    return v;
00462 }

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

References ast_category_get(), and config.

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

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

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

struct ast_category* ast_category_new ( const char *  name  ) 

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

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

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

Definition at line 464 of file config.c.

References ast_copy_string(), and ast_category::name.

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

00465 {
00466    ast_copy_string(cat->name, name, sizeof(cat->name));
00467 }

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

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

00414 {
00415    struct ast_category *category = ast_category_get(config, cat);
00416    if (category)
00417       return category->root;
00418    return NULL;
00419 }

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

References find_engine().

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

01455 {
01456    struct ast_config_engine *eng;
01457 
01458    eng = find_engine(family, NULL, 0, NULL, 0);
01459    if (eng)
01460       return 1;
01461    return 0;
01462 
01463 }

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

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

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deegister config engine.

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

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

int ast_config_engine_register ( struct ast_config_engine newconfig  ) 

Register config engine.

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

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

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

Definition at line 636 of file config.c.

References ast_config::current.

Referenced by config_odbc(), and config_text_file_load().

00637 {
00638    return cfg->current;
00639 }

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

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

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

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

01405 {
01406    struct ast_config *cfg;
01407    struct ast_config *result;
01408 
01409    cfg = ast_config_new();
01410    if (!cfg)
01411       return NULL;
01412 
01413    result = ast_config_internal_load(filename, cfg, 0);
01414    if (!result)
01415       ast_config_destroy(cfg);
01416 
01417    return result;
01418 }

struct ast_config* ast_config_load_with_comments ( const char *  filename  ) 

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

01421 {
01422    struct ast_config *cfg;
01423    struct ast_config *result;
01424 
01425    cfg = ast_config_new();
01426    if (!cfg)
01427       return NULL;
01428 
01429    result = ast_config_internal_load(filename, cfg, 1);
01430    if (!result)
01431       ast_config_destroy(cfg);
01432 
01433    return result;
01434 }

struct ast_config* ast_config_new ( void   ) 

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

00481 {
00482    struct ast_config *config;
00483 
00484    if ((config = ast_calloc(1, sizeof(*config))))
00485       config->max_include_level = MAX_INCLUDE_LEVEL;
00486    return config;
00487 }

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

Definition at line 241 of file config.c.

References ast_variable_retrieve().

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

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

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

Definition at line 641 of file config.c.

References ast_config::current.

00642 {
00643    /* cast below is just to silence compiler warning about dropping "const" */
00644    cfg->current = (struct ast_category *) cat;
00645 }

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

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

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

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

int ast_realtime_enabled ( void   ) 

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

Definition at line 1466 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

01467 {
01468    return config_maps ? 1 : 0;
01469 }

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

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

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

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

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

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

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

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

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

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

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

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

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

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

References ast_variable_browse(), and config.

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

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

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

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

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

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

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

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

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

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

Referenced by action_originate(), 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(), check_user_full(), cli_realtime_load(), find_conf_realtime(), find_user_realtime(), free_outgoing(), function_realtime_read(), 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().

00217 {
00218    struct ast_variable *vn;
00219 
00220    while(v) {
00221       vn = v;
00222       v = v->next;
00223       ast_destroy_comment(&vn->precomments);
00224       ast_destroy_comment(&vn->sameline);
00225       ast_free(vn);
00226    }
00227 }

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

Definition at line 1025 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_variable::name, ast_category_template_instance::name, ast_category::name, ast_category::next, ast_variable::next, ast_category_template_instance::next, ast_comment::next, option_debug, option_verbose, ast_category::precomments, ast_category::root, ast_config::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().

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

int read_config_maps ( void   ) 

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

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

int register_config_cli ( void   ) 

Definition at line 1541 of file config.c.

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

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


Generated on Sat Aug 6 00:39:55 2011 for Asterisk - the Open Source PBX by  doxygen 1.4.7