Thu Oct 1 13:09:56 2009

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

References config, and ast_category::include_level.

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

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

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

Goes through categories.

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

Definition at line 414 of file config.c.

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

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

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

int ast_category_delete ( struct ast_config cfg,
char *  category 
)

Definition at line 569 of file config.c.

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

Referenced by handle_updates().

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

void ast_category_destroy ( struct ast_category cat  ) 

Definition at line 391 of file config.c.

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

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

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

struct ast_variable* ast_category_detach_variables ( struct ast_category cat  ) 

Definition at line 446 of file config.c.

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

Referenced by realtime_switch_common().

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

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

Check for category duplicates.

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

Definition at line 350 of file config.c.

References ast_category_get(), and config.

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

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

Retrieve a category if it exists.

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

Definition at line 345 of file config.c.

References category_get(), and config.

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

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

struct ast_category* ast_category_new ( const char *  name  ) 

Definition at line 318 of file config.c.

References ast_calloc, and ast_copy_string().

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

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

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

Definition at line 457 of file config.c.

References ast_copy_string(), and ast_category::name.

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

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

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

returns the root ast_variable of a config

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

Definition at line 406 of file config.c.

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

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

int ast_check_realtime ( const char *  family  ) 

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

Parameters:
family which family/config to be checked

Definition at line 1445 of file config.c.

References find_engine().

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

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

void ast_config_destroy ( struct ast_config config  ) 

Destroys a config.

Parameters:
config pointer to config data structure Free memory associated with a given config

Definition at line 613 of file config.c.

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

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

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

int ast_config_engine_deregister ( struct ast_config_engine del  ) 

Deegister config engine.

Definition at line 1293 of file config.c.

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

Referenced by unload_module().

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

int ast_config_engine_register ( struct ast_config_engine newconfig  ) 

Register config engine.

Definition at line 1274 of file config.c.

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

Referenced by load_module().

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

struct ast_category* ast_config_get_current_category ( const struct ast_config cfg  ) 

Definition at line 629 of file config.c.

References ast_config::current.

Referenced by config_odbc(), and config_text_file_load().

00630 {
00631    return cfg->current;
00632 }

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

Definition at line 1355 of file config.c.

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

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

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

struct ast_config* ast_config_load ( const char *  filename  ) 

Load a config file.

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

Definition at line 1395 of file config.c.

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

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

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

struct ast_config* ast_config_load_with_comments ( const char *  filename  ) 

Definition at line 1411 of file config.c.

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

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

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

struct ast_config* ast_config_new ( void   ) 

Definition at line 473 of file config.c.

References ast_calloc, config, and MAX_INCLUDE_LEVEL.

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

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

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

Definition at line 237 of file config.c.

References ast_variable_retrieve().

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

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

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

Definition at line 634 of file config.c.

References ast_config::current.

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

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

Retrieve realtime configuration.

Parameters:
family which family/config to lookup This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Note that unlike the variables in ast_config, the resulting list of variables MUST be freed with ast_variables_destroy() as there is no container.

Definition at line 1427 of file config.c.

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

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

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

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

Retrieve realtime configuration.

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

Definition at line 1462 of file config.c.

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

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

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

int ast_realtime_enabled ( void   ) 

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

Definition at line 1457 of file config.c.

References config_maps.

Referenced by action_coresettings(), and handle_show_settings().

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

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

Update realtime configuration.

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

Definition at line 1479 of file config.c.

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

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

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

void ast_variable_append ( struct ast_category category,
struct ast_variable variable 
)

Definition at line 201 of file config.c.

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

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

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

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

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

Returns ast_variable list on success, or NULL on failure

Definition at line 225 of file config.c.

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

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

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

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

Definition at line 482 of file config.c.

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

Referenced by handle_updates().

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

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

Definition at line 186 of file config.c.

References ast_calloc, and ast_variable::name.

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

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

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

Iterates through variables.

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

Definition at line 247 of file config.c.

References ast_variable_browse(), and config.

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

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

Gets a variable.

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

Definition at line 266 of file config.c.

References ast_variable_browse(), config, ast_variable::name, ast_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().

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

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

Definition at line 531 of file config.c.

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

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

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

void ast_variables_destroy ( struct ast_variable var  ) 

Free variable list.

Parameters:
var the linked list of variables to free This function frees a list of variables.

Definition at line 214 of file config.c.

References free, and ast_variable::next.

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

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

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

Definition at line 1016 of file config.c.

References ast_config_AST_CONFIG_DIR, ast_copy_string(), AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_log(), ast_verbose(), ast_comment::cmt, errno, f, ast_category::ignored, ast_category_template_instance::inst, LOG_DEBUG, ast_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().

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

int read_config_maps ( void   ) 

Definition at line 1206 of file config.c.

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

Referenced by main().

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

int register_config_cli ( void   ) 

Definition at line 1534 of file config.c.

References ast_cli_register_multiple(), and cli_config.

Referenced by main().

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


Generated on Thu Oct 1 13:09:56 2009 for Asterisk - the Open Source PBX by  doxygen 1.4.7