#include "asterisk.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/stat.h>
#include <glob.h>
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/options.h"
#include "asterisk/logger.h"
#include "asterisk/utils.h"
#include "asterisk/channel.h"
#include "asterisk/app.h"
Include dependency graph for config.c:
Go to the source code of this file.
Data Structures | |
struct | ast_category |
struct | ast_comment |
Structure to keep comments for rewriting configuration files. More... | |
struct | ast_config |
struct | ast_config_map |
Defines | |
#define | AST_INCLUDE_GLOB 1 |
#define | CB_INCR 250 |
#define | COMMENT_END "--;" |
#define | COMMENT_META ';' |
#define | COMMENT_START ";--" |
#define | COMMENT_TAG '-' |
#define | MAX_INCLUDE_LEVEL 10 |
#define | MAX_NESTED_COMMENTS 128 |
Functions | |
static struct ast_comment * | ALLOC_COMMENT (const char *buffer) |
static int | append_mapping (char *name, char *driver, char *database, char *table) |
void | ast_category_append (struct ast_config *config, struct ast_category *category) |
char * | ast_category_browse (struct ast_config *config, const char *prev) |
Goes through categories. | |
int | ast_category_delete (struct ast_config *cfg, char *category) |
void | ast_category_destroy (struct ast_category *cat) |
ast_variable * | ast_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_category * | ast_category_get (const struct ast_config *config, const char *category_name) |
Retrieve a category if it exists. | |
ast_category * | ast_category_new (const char *name) |
void | ast_category_rename (struct ast_category *cat, const char *name) |
int | ast_check_realtime (const char *family) |
Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists. | |
void | ast_config_destroy (struct ast_config *cfg) |
Destroys a config. | |
int | ast_config_engine_deregister (struct ast_config_engine *del) |
Deegister config engine. | |
int | ast_config_engine_register (struct ast_config_engine *new) |
Register config engine. | |
ast_category * | ast_config_get_current_category (const struct ast_config *cfg) |
ast_config * | ast_config_internal_load (const char *filename, struct ast_config *cfg, int withcomments) |
ast_config * | ast_config_load (const char *filename) |
Load a config file. | |
ast_config * | ast_config_load_with_comments (const char *filename) |
ast_config * | ast_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_variable * | ast_load_realtime (const char *family,...) |
Retrieve realtime configuration. | |
ast_config * | ast_load_realtime_multientry (const char *family,...) |
Retrieve realtime configuration. | |
AST_MUTEX_DEFINE_STATIC (config_lock) | |
int | ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...) |
Update realtime configuration. | |
void | ast_variable_append (struct ast_category *category, struct ast_variable *variable) |
ast_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. | |
int | ast_variable_delete (struct ast_category *category, char *variable, char *match) |
ast_variable * | ast_variable_new (const char *name, const char *value) |
const char * | ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable) |
Gets a variable. | |
int | ast_variable_update (struct ast_category *category, const char *variable, const char *value, const char *match, unsigned int object) |
void | ast_variables_destroy (struct ast_variable *v) |
Free variable list. | |
static struct ast_category * | category_get (const struct ast_config *config, const char *category_name, int ignored) |
static void | CB_ADD (char **comment_buffer, int *comment_buffer_size, char *str) |
static void | CB_ADD_LEN (char **comment_buffer, int *comment_buffer_size, char *str, int len) |
static void | CB_INIT (char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size) |
static void | CB_RESET (char **comment_buffer, char **lline_buffer) |
static void | clear_config_maps (void) |
static int | config_command (int fd, int argc, char **argv) |
static struct ast_config * | config_text_file_load (const char *database, const char *table, const char *filename, struct ast_config *cfg, int withcomments) |
int | config_text_file_save (const char *configfile, const struct ast_config *cfg, const char *generator) |
static struct ast_config_engine * | find_engine (const char *family, char *database, int dbsiz, char *table, int tabsiz) |
Find realtime engine for realtime family. | |
static void | inherit_category (struct ast_category *new, const struct ast_category *base) |
static void | LLB_ADD (char **lline_buffer, int *lline_buffer_size, char *str) |
static void | move_variables (struct ast_category *old, struct ast_category *new) |
static struct ast_category * | next_available_category (struct ast_category *cat) |
static int | process_text_line (struct ast_config *cfg, struct ast_category **cat, char *buf, int lineno, const char *configfile, int withcomments, char **comment_buffer, int *comment_buffer_size, char **lline_buffer, int *lline_buffer_size) |
int | read_config_maps (void) |
int | register_config_cli () |
static struct ast_variable * | variable_clone (const struct ast_variable *old) |
Variables | |
static struct ast_cli_entry | cli_config [] |
static struct ast_cli_entry | cli_show_config_mappings_deprecated |
static struct ast_config_engine * | config_engine_list |
static struct ast_config_map * | config_maps |
static char * | extconfig_conf = "extconfig.conf" |
static char | show_config_help [] |
static struct ast_config_engine | text_file_engine |
Includes the Asterisk Realtime API - ARA See doc/realtime.txt and doc/extconfig.txt
Definition in file config.c.
#define CB_INCR 250 |
#define COMMENT_META ';' |
#define COMMENT_TAG '-' |
#define MAX_INCLUDE_LEVEL 10 |
#define MAX_NESTED_COMMENTS 128 |
static struct ast_comment* ALLOC_COMMENT | ( | const char * | buffer | ) | [static] |
Definition at line 140 of file config.c.
References ast_calloc, and ast_comment::cmt.
Referenced by process_text_line().
00141 { 00142 struct ast_comment *x = ast_calloc(1,sizeof(struct ast_comment)+strlen(buffer)+1); 00143 strcpy(x->cmt, buffer); 00144 return x; 00145 }
static int append_mapping | ( | char * | name, | |
char * | driver, | |||
char * | database, | |||
char * | table | |||
) | [static] |
Definition at line 1054 of file config.c.
References ast_calloc, ast_verbose(), config_maps, map, option_verbose, and VERBOSE_PREFIX_2.
Referenced by read_config_maps().
01055 { 01056 struct ast_config_map *map; 01057 int length; 01058 01059 length = sizeof(*map); 01060 length += strlen(name) + 1; 01061 length += strlen(driver) + 1; 01062 length += strlen(database) + 1; 01063 if (table) 01064 length += strlen(table) + 1; 01065 01066 if (!(map = ast_calloc(1, length))) 01067 return -1; 01068 01069 map->name = map->stuff; 01070 strcpy(map->name, name); 01071 map->driver = map->name + strlen(map->name) + 1; 01072 strcpy(map->driver, driver); 01073 map->database = map->driver + strlen(map->driver) + 1; 01074 strcpy(map->database, database); 01075 if (table) { 01076 map->table = map->database + strlen(map->database) + 1; 01077 strcpy(map->table, table); 01078 } 01079 map->next = config_maps; 01080 01081 if (option_verbose > 1) 01082 ast_verbose(VERBOSE_PREFIX_2 "Binding %s to %s/%s/%s\n", 01083 map->name, map->driver, map->database, map->table ? map->table : map->name); 01084 01085 config_maps = map; 01086 return 0; 01087 }
void ast_category_append | ( | struct ast_config * | config, | |
struct ast_category * | category | |||
) |
Definition at line 332 of file config.c.
References config, and ast_category::include_level.
Referenced by config_mysql(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_mysql(), realtime_multi_odbc(), and realtime_multi_pgsql().
00333 { 00334 if (config->last) 00335 config->last->next = category; 00336 else 00337 config->root = category; 00338 category->include_level = config->include_level; 00339 config->last = category; 00340 config->current = category; 00341 }
char* ast_category_browse | ( | struct ast_config * | config, | |
const char * | prev | |||
) |
Goes through categories.
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. |
Definition at line 356 of file config.c.
References config, ast_category::name, ast_category::next, and next_available_category().
Referenced by action_getconfig(), aji_load_config(), authenticate(), complete_sipnotify(), do_directory(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), init_manager(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), osp_load(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_zap(), sla_load_config(), and vm_change_password().
00357 { 00358 struct ast_category *cat = NULL; 00359 00360 if (prev && config->last_browse && (config->last_browse->name == prev)) 00361 cat = config->last_browse->next; 00362 else if (!prev && config->root) 00363 cat = config->root; 00364 else if (prev) { 00365 for (cat = config->root; cat; cat = cat->next) { 00366 if (cat->name == prev) { 00367 cat = cat->next; 00368 break; 00369 } 00370 } 00371 if (!cat) { 00372 for (cat = config->root; cat; cat = cat->next) { 00373 if (!strcasecmp(cat->name, prev)) { 00374 cat = cat->next; 00375 break; 00376 } 00377 } 00378 } 00379 } 00380 00381 if (cat) 00382 cat = next_available_category(cat); 00383 00384 config->last_browse = cat; 00385 return (cat) ? cat->name : NULL; 00386 }
int ast_category_delete | ( | struct ast_config * | cfg, | |
char * | category | |||
) |
Definition at line 508 of file config.c.
References ast_variables_destroy(), free, ast_config::last, ast_category::next, and ast_config::root.
Referenced by handle_updates().
00509 { 00510 struct ast_category *prev=NULL, *cat; 00511 cat = cfg->root; 00512 while(cat) { 00513 if (cat->name == category) { 00514 ast_variables_destroy(cat->root); 00515 if (prev) { 00516 prev->next = cat->next; 00517 if (cat == cfg->last) 00518 cfg->last = prev; 00519 } else { 00520 cfg->root = cat->next; 00521 if (cat == cfg->last) 00522 cfg->last = NULL; 00523 } 00524 free(cat); 00525 return 0; 00526 } 00527 prev = cat; 00528 cat = cat->next; 00529 } 00530 00531 prev = NULL; 00532 cat = cfg->root; 00533 while(cat) { 00534 if (!strcasecmp(cat->name, category)) { 00535 ast_variables_destroy(cat->root); 00536 if (prev) { 00537 prev->next = cat->next; 00538 if (cat == cfg->last) 00539 cfg->last = prev; 00540 } else { 00541 cfg->root = cat->next; 00542 if (cat == cfg->last) 00543 cfg->last = NULL; 00544 } 00545 free(cat); 00546 return 0; 00547 } 00548 prev = cat; 00549 cat = cat->next; 00550 } 00551 return -1; 00552 }
void ast_category_destroy | ( | struct ast_category * | cat | ) |
Definition at line 343 of file config.c.
References ast_variables_destroy(), free, and ast_category::root.
Referenced by process_text_line(), and realtime_multi_odbc().
00344 { 00345 ast_variables_destroy(cat->root); 00346 free(cat); 00347 }
struct ast_variable* ast_category_detach_variables | ( | struct ast_category * | cat | ) |
Definition at line 388 of file config.c.
References ast_category::last, and ast_category::root.
Referenced by realtime_switch_common().
00389 { 00390 struct ast_variable *v; 00391 00392 v = cat->root; 00393 cat->root = NULL; 00394 cat->last = NULL; 00395 00396 return v; 00397 }
int ast_category_exist | ( | const struct ast_config * | config, | |
const char * | category_name | |||
) |
Check for category duplicates.
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. |
Definition at line 327 of file config.c.
References ast_category_get(), and config.
00328 { 00329 return !!ast_category_get(config, category_name); 00330 }
struct ast_category* ast_category_get | ( | const struct ast_config * | config, | |
const char * | category_name | |||
) |
Retrieve a category if it exists.
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. |
Definition at line 322 of file config.c.
References category_get(), and config.
Referenced by ast_category_exist(), ast_variable_browse(), handle_updates(), realtime_directory(), realtime_switch_common(), vm_change_password(), and vm_forwardoptions().
00323 { 00324 return category_get(config, category_name, 0); 00325 }
struct ast_category* ast_category_new | ( | const char * | name | ) |
Definition at line 295 of file config.c.
References ast_calloc.
Referenced by config_mysql(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_mysql(), realtime_multi_odbc(), and realtime_multi_pgsql().
00296 { 00297 struct ast_category *category; 00298 00299 if ((category = ast_calloc(1, sizeof(*category)))) 00300 ast_copy_string(category->name, name, sizeof(category->name)); 00301 return category; 00302 }
void ast_category_rename | ( | struct ast_category * | cat, | |
const char * | name | |||
) |
Definition at line 399 of file config.c.
References ast_category::name.
Referenced by handle_updates(), realtime_multi_mysql(), realtime_multi_odbc(), and realtime_multi_pgsql().
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.
family | which family/config to be checked |
Definition at line 1327 of file config.c.
References find_engine().
Referenced by _sip_show_peer(), _sip_show_peers(), and sip_show_settings().
01328 { 01329 struct ast_config_engine *eng; 01330 01331 eng = find_engine(family, NULL, 0, NULL, 0); 01332 if (eng) 01333 return 1; 01334 return 0; 01335 01336 }
void ast_config_destroy | ( | struct ast_config * | config | ) |
Destroys a config.
config | pointer to config data structure Free memory associated with a given config |
Definition at line 554 of file config.c.
References ast_variables_destroy(), free, ast_category::next, ast_config::root, and ast_category::root.
Referenced by __ast_http_load(), action_getconfig(), action_updateconfig(), adsi_load(), advanced_options(), ast_config_load(), ast_config_load_with_comments(), ast_enum_init(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_realtime_queue(), load_rpt_vars(), loadconfigurationfile(), my_load_module(), odbc_load_module(), osp_load(), parse_config(), pbx_load_users(), play_message(), privacy_exec(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_multi_mysql(), realtime_switch_common(), reload(), reload_config(), reload_followme(), rpt_master(), set_config(), setup_zap(), sla_load_config(), tds_load_module(), unload_module(), and vm_forwardoptions().
00555 { 00556 struct ast_category *cat, *catn; 00557 00558 if (!cfg) 00559 return; 00560 00561 cat = cfg->root; 00562 while(cat) { 00563 ast_variables_destroy(cat->root); 00564 catn = cat; 00565 cat = cat->next; 00566 free(catn); 00567 } 00568 free(cfg); 00569 }
int ast_config_engine_deregister | ( | struct ast_config_engine * | del | ) |
Deegister config engine.
Definition at line 1176 of file config.c.
References ast_mutex_lock(), ast_mutex_unlock(), config_engine_list, last, and ast_config_engine::next.
Referenced by unload_module().
01177 { 01178 struct ast_config_engine *ptr, *last=NULL; 01179 01180 ast_mutex_lock(&config_lock); 01181 01182 for (ptr = config_engine_list; ptr; ptr=ptr->next) { 01183 if (ptr == del) { 01184 if (last) 01185 last->next = ptr->next; 01186 else 01187 config_engine_list = ptr->next; 01188 break; 01189 } 01190 last = ptr; 01191 } 01192 01193 ast_mutex_unlock(&config_lock); 01194 01195 return 0; 01196 }
int ast_config_engine_register | ( | struct ast_config_engine * | new | ) |
Register config engine.
Definition at line 1157 of file config.c.
References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_engine_list, LOG_NOTICE, ast_config_engine::name, and ast_config_engine::next.
Referenced by load_module().
01158 { 01159 struct ast_config_engine *ptr; 01160 01161 ast_mutex_lock(&config_lock); 01162 01163 if (!config_engine_list) { 01164 config_engine_list = new; 01165 } else { 01166 for (ptr = config_engine_list; ptr->next; ptr=ptr->next); 01167 ptr->next = new; 01168 } 01169 01170 ast_mutex_unlock(&config_lock); 01171 ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name); 01172 01173 return 1; 01174 }
struct ast_category* ast_config_get_current_category | ( | const struct ast_config * | cfg | ) |
Definition at line 571 of file config.c.
References ast_config::current.
Referenced by config_odbc(), and config_text_file_load().
00572 { 00573 return cfg->current; 00574 }
struct ast_config* ast_config_internal_load | ( | const char * | filename, | |
struct ast_config * | cfg, | |||
int | withcomments | |||
) |
Definition at line 1238 of file config.c.
References ast_log(), config_engine_list, db, extconfig_conf, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, result, table, and text_file_engine.
Referenced by ast_config_load(), ast_config_load_with_comments(), config_mysql(), config_odbc(), config_pgsql(), process_text_line(), and read_config_maps().
01239 { 01240 char db[256]; 01241 char table[256]; 01242 struct ast_config_engine *loader = &text_file_engine; 01243 struct ast_config *result; 01244 01245 if (cfg->include_level == cfg->max_include_level) { 01246 ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level); 01247 return NULL; 01248 } 01249 01250 cfg->include_level++; 01251 01252 if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) { 01253 struct ast_config_engine *eng; 01254 01255 eng = find_engine(filename, db, sizeof(db), table, sizeof(table)); 01256 01257 01258 if (eng && eng->load_func) { 01259 loader = eng; 01260 } else { 01261 eng = find_engine("global", db, sizeof(db), table, sizeof(table)); 01262 if (eng && eng->load_func) 01263 loader = eng; 01264 } 01265 } 01266 01267 result = loader->load_func(db, table, filename, cfg, withcomments); 01268 01269 if (result) 01270 result->include_level--; 01271 else 01272 cfg->include_level--; 01273 01274 return result; 01275 }
struct ast_config* ast_config_load | ( | const char * | filename | ) |
Load a config file.
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. |
Definition at line 1277 of file config.c.
References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), and result.
Referenced by __ast_http_load(), __say_init(), adsi_load(), advanced_options(), aji_load_config(), ast_enum_init(), ast_readconfig(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), my_load_module(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), privacy_exec(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queues(), set_config(), setup_zap(), sla_load_config(), smdi_load(), tds_load_module(), and vm_forwardoptions().
01278 { 01279 struct ast_config *cfg; 01280 struct ast_config *result; 01281 01282 cfg = ast_config_new(); 01283 if (!cfg) 01284 return NULL; 01285 01286 result = ast_config_internal_load(filename, cfg, 0); 01287 if (!result) 01288 ast_config_destroy(cfg); 01289 01290 return result; 01291 }
struct ast_config* ast_config_load_with_comments | ( | const char * | filename | ) |
Definition at line 1293 of file config.c.
References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), and result.
Referenced by action_getconfig(), action_updateconfig(), and vm_change_password().
01294 { 01295 struct ast_config *cfg; 01296 struct ast_config *result; 01297 01298 cfg = ast_config_new(); 01299 if (!cfg) 01300 return NULL; 01301 01302 result = ast_config_internal_load(filename, cfg, 1); 01303 if (!result) 01304 ast_config_destroy(cfg); 01305 01306 return result; 01307 }
struct ast_config* ast_config_new | ( | void | ) |
Definition at line 412 of file config.c.
References ast_calloc, config, and MAX_INCLUDE_LEVEL.
Referenced by ast_config_load(), ast_config_load_with_comments(), read_config_maps(), realtime_multi_mysql(), realtime_multi_odbc(), and realtime_multi_pgsql().
00413 { 00414 struct ast_config *config; 00415 00416 if ((config = ast_calloc(1, sizeof(*config)))) 00417 config->max_include_level = MAX_INCLUDE_LEVEL; 00418 return config; 00419 }
const char* ast_config_option | ( | struct ast_config * | cfg, | |
const char * | cat, | |||
const char * | var | |||
) |
Definition at line 233 of file config.c.
References ast_variable_retrieve().
Referenced by do_directory(), load_config(), and pbx_load_users().
00234 { 00235 const char *tmp; 00236 tmp = ast_variable_retrieve(cfg, cat, var); 00237 if (!tmp) 00238 tmp = ast_variable_retrieve(cfg, "general", var); 00239 return tmp; 00240 }
void ast_config_set_current_category | ( | struct ast_config * | cfg, | |
const struct ast_category * | cat | |||
) |
Definition at line 576 of file config.c.
References ast_config::current.
00577 { 00578 /* cast below is just to silence compiler warning about dropping "const" */ 00579 cfg->current = (struct ast_category *) cat; 00580 }
struct ast_variable* ast_load_realtime | ( | const char * | family, | |
... | ||||
) |
Retrieve realtime configuration.
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 1309 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(), realtime_alias(), realtime_exec(), realtime_peer(), realtime_switch_common(), and realtime_user().
01310 { 01311 struct ast_config_engine *eng; 01312 char db[256]=""; 01313 char table[256]=""; 01314 struct ast_variable *res=NULL; 01315 va_list ap; 01316 01317 va_start(ap, family); 01318 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01319 if (eng && eng->realtime_func) 01320 res = eng->realtime_func(db, table, ap); 01321 va_end(ap); 01322 01323 return res; 01324 }
struct ast_config* ast_load_realtime_multientry | ( | const char * | family, | |
... | ||||
) |
Retrieve realtime configuration.
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 1338 of file config.c.
References db, find_engine(), ast_config_engine::realtime_multi_func, and table.
Referenced by load_realtime_queue(), realtime_directory(), and realtime_switch_common().
01339 { 01340 struct ast_config_engine *eng; 01341 char db[256]=""; 01342 char table[256]=""; 01343 struct ast_config *res=NULL; 01344 va_list ap; 01345 01346 va_start(ap, family); 01347 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01348 if (eng && eng->realtime_multi_func) 01349 res = eng->realtime_multi_func(db, table, ap); 01350 va_end(ap); 01351 01352 return res; 01353 }
AST_MUTEX_DEFINE_STATIC | ( | config_lock | ) |
int ast_update_realtime | ( | const char * | family, | |
const char * | keyfield, | |||
const char * | lookup, | |||
... | ||||
) |
Update realtime configuration.
family | which family/config to be updated | |
keyfield | which field to use as the key | |
lookup | which value to look for in the key field to match the entry. This function is used to update a parameter in realtime configuration space. |
Definition at line 1355 of file config.c.
References db, find_engine(), table, and ast_config_engine::update_func.
Referenced by change_password_realtime(), cli_realtime_update(), conf_run(), destroy_association(), function_realtime_write(), realtime_update_exec(), and realtime_update_peer().
01356 { 01357 struct ast_config_engine *eng; 01358 int res = -1; 01359 char db[256]=""; 01360 char table[256]=""; 01361 va_list ap; 01362 01363 va_start(ap, lookup); 01364 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01365 if (eng && eng->update_func) 01366 res = eng->update_func(db, table, keyfield, lookup, ap); 01367 va_end(ap); 01368 01369 return res; 01370 }
void ast_variable_append | ( | struct ast_category * | category, | |
struct ast_variable * | variable | |||
) |
Definition at line 197 of file config.c.
References ast_category::last, ast_variable::next, and ast_category::root.
Referenced by config_mysql(), config_odbc(), config_pgsql(), handle_updates(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), and vm_change_password().
00198 { 00199 if (!variable) 00200 return; 00201 if (category->last) 00202 category->last->next = variable; 00203 else 00204 category->root = variable; 00205 category->last = variable; 00206 while (category->last->next) 00207 category->last = category->last->next; 00208 }
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 221 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_retrieve(), authenticate(), collect_function_digits(), conf_exec(), database_first_connect(), do_directory(), do_say(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), misdn_cfg_init(), my_load_module(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), process_my_load_module(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queues(), set_config(), setup_zap(), sip_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().
00222 { 00223 struct ast_category *cat = NULL; 00224 00225 if (category && config->last_browse && (config->last_browse->name == category)) 00226 cat = config->last_browse; 00227 else 00228 cat = ast_category_get(config, category); 00229 00230 return (cat) ? cat->root : NULL; 00231 }
int ast_variable_delete | ( | struct ast_category * | category, | |
char * | variable, | |||
char * | match | |||
) |
Definition at line 421 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().
00422 { 00423 struct ast_variable *cur, *prev=NULL, *curn; 00424 int res = -1; 00425 cur = category->root; 00426 while (cur) { 00427 if (cur->name == variable) { 00428 if (prev) { 00429 prev->next = cur->next; 00430 if (cur == category->last) 00431 category->last = prev; 00432 } else { 00433 category->root = cur->next; 00434 if (cur == category->last) 00435 category->last = NULL; 00436 } 00437 cur->next = NULL; 00438 ast_variables_destroy(cur); 00439 return 0; 00440 } 00441 prev = cur; 00442 cur = cur->next; 00443 } 00444 00445 prev = NULL; 00446 cur = category->root; 00447 while (cur) { 00448 curn = cur->next; 00449 if (!strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match))) { 00450 if (prev) { 00451 prev->next = cur->next; 00452 if (cur == category->last) 00453 category->last = prev; 00454 } else { 00455 category->root = cur->next; 00456 if (cur == category->last) 00457 category->last = NULL; 00458 } 00459 cur->next = NULL; 00460 ast_variables_destroy(cur); 00461 res = 0; 00462 } else 00463 prev = cur; 00464 00465 cur = curn; 00466 } 00467 return res; 00468 }
struct ast_variable* ast_variable_new | ( | const char * | name, | |
const char * | value | |||
) |
Definition at line 182 of file config.c.
References ast_calloc, and ast_variable::name.
Referenced by apply_outgoing(), ast_channeltype_list(), ast_httpd_helper_thread(), ast_variable_update(), astman_get_variables(), build_peer(), build_user(), check_access(), check_user_full(), config_mysql(), config_odbc(), config_pgsql(), handle_updates(), handle_uri(), iax_parse_ies(), parkandannounce_exec(), process_text_line(), realtime_directory(), realtime_multi_mysql(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_mysql(), realtime_odbc(), realtime_pgsql(), variable_clone(), and vm_change_password().
00183 { 00184 struct ast_variable *variable; 00185 int name_len = strlen(name) + 1; 00186 00187 if ((variable = ast_calloc(1, name_len + strlen(value) + 1 + sizeof(*variable)))) { 00188 variable->name = variable->stuff; 00189 variable->value = variable->stuff + name_len; 00190 strcpy(variable->name,name); 00191 strcpy(variable->value,value); 00192 } 00193 00194 return variable; 00195 }
const char* ast_variable_retrieve | ( | const struct ast_config * | config, | |
const char * | category, | |||
const char * | variable | |||
) |
Gets a variable.
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 |
Definition at line 243 of file config.c.
References ast_variable_browse(), config, ast_variable::name, ast_variable::next, ast_category::next, ast_category::root, and ast_variable::value.
Referenced by advanced_options(), aji_load_config(), ast_config_option(), ast_rtp_reload(), ast_udptl_reload(), attempt_reconnect(), cdr_pgsql_read_config(), directory_exec(), do_directory(), do_reload(), festival_exec(), function_ilink(), function_macro(), function_remote(), get_wait_interval(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_rpt_vars(), my_load_module(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), privacy_exec(), process_my_load_module(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_queues(), retrieve_astcfgint(), rpt(), rpt_exec(), rpt_master(), rpt_tele_thread(), set_config(), setup_zap(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), vm_change_password(), and vm_forwardoptions().
00244 { 00245 struct ast_variable *v; 00246 00247 if (category) { 00248 for (v = ast_variable_browse(config, category); v; v = v->next) { 00249 if (!strcasecmp(variable, v->name)) 00250 return v->value; 00251 } 00252 } else { 00253 struct ast_category *cat; 00254 00255 for (cat = config->root; cat; cat = cat->next) 00256 for (v = cat->root; v; v = v->next) 00257 if (!strcasecmp(variable, v->name)) 00258 return v->value; 00259 } 00260 00261 return NULL; 00262 }
int ast_variable_update | ( | struct ast_category * | category, | |
const char * | variable, | |||
const char * | value, | |||
const char * | match, | |||
unsigned int | object | |||
) |
Definition at line 470 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().
00472 { 00473 struct ast_variable *cur, *prev=NULL, *newer; 00474 00475 if (!(newer = ast_variable_new(variable, value))) 00476 return -1; 00477 00478 newer->object = object; 00479 00480 for (cur = category->root; cur; prev = cur, cur = cur->next) { 00481 if (strcasecmp(cur->name, variable) || 00482 (!ast_strlen_zero(match) && strcasecmp(cur->value, match))) 00483 continue; 00484 00485 newer->next = cur->next; 00486 newer->object = cur->object || object; 00487 if (prev) 00488 prev->next = newer; 00489 else 00490 category->root = newer; 00491 if (category->last == cur) 00492 category->last = newer; 00493 00494 cur->next = NULL; 00495 ast_variables_destroy(cur); 00496 00497 return 0; 00498 } 00499 00500 if (prev) 00501 prev->next = newer; 00502 else 00503 category->root = newer; 00504 00505 return 0; 00506 }
void ast_variables_destroy | ( | struct ast_variable * | var | ) |
Free variable list.
var | the linked list of variables to free This function frees a list of variables. |
Definition at line 210 of file config.c.
References free, and ast_variable::next.
Referenced by ast_category_delete(), ast_category_destroy(), ast_config_destroy(), ast_httpd_helper_thread(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), destroy_user(), find_conf_realtime(), find_user_realtime(), handle_uri(), iax2_destroy(), load_realtime_queue(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), and socket_process().
00211 { 00212 struct ast_variable *vn; 00213 00214 while(v) { 00215 vn = v; 00216 v = v->next; 00217 free(vn); 00218 } 00219 }
static struct ast_category* category_get | ( | const struct ast_config * | config, | |
const char * | category_name, | |||
int | ignored | |||
) | [static] |
Definition at line 304 of file config.c.
References config, ast_category::ignored, ast_category::name, and ast_category::next.
Referenced by ast_category_get(), and process_text_line().
00305 { 00306 struct ast_category *cat; 00307 00308 /* try exact match first, then case-insensitive match */ 00309 for (cat = config->root; cat; cat = cat->next) { 00310 if (cat->name == category_name && (ignored || !cat->ignored)) 00311 return cat; 00312 } 00313 00314 for (cat = config->root; cat; cat = cat->next) { 00315 if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored)) 00316 return cat; 00317 } 00318 00319 return NULL; 00320 }
static void CB_ADD | ( | char ** | comment_buffer, | |
int * | comment_buffer_size, | |||
char * | str | |||
) | [static] |
Definition at line 93 of file config.c.
References ast_realloc, and CB_INCR.
Referenced by config_text_file_load().
00094 { 00095 int rem = *comment_buffer_size - strlen(*comment_buffer) - 1; 00096 int siz = strlen(str); 00097 if (rem < siz+1) { 00098 *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + siz + 1); 00099 if (!(*comment_buffer)) 00100 return; 00101 *comment_buffer_size += CB_INCR+siz+1; 00102 } 00103 strcat(*comment_buffer,str); 00104 }
static void CB_ADD_LEN | ( | char ** | comment_buffer, | |
int * | comment_buffer_size, | |||
char * | str, | |||
int | len | |||
) | [static] |
Definition at line 106 of file config.c.
References ast_realloc, and CB_INCR.
Referenced by config_text_file_load().
00107 { 00108 int cbl = strlen(*comment_buffer) + 1; 00109 int rem = *comment_buffer_size - cbl; 00110 if (rem < len+1) { 00111 *comment_buffer = ast_realloc(*comment_buffer, *comment_buffer_size + CB_INCR + len + 1); 00112 if (!(*comment_buffer)) 00113 return; 00114 *comment_buffer_size += CB_INCR+len+1; 00115 } 00116 strncat(*comment_buffer,str,len); 00117 (*comment_buffer)[cbl+len-1] = 0; 00118 }
static void CB_INIT | ( | char ** | comment_buffer, | |
int * | comment_buffer_size, | |||
char ** | lline_buffer, | |||
int * | lline_buffer_size | |||
) | [static] |
Definition at line 74 of file config.c.
References ast_malloc, and CB_INCR.
Referenced by config_text_file_load().
00075 { 00076 if (!(*comment_buffer)) { 00077 *comment_buffer = ast_malloc(CB_INCR); 00078 if (!(*comment_buffer)) 00079 return; 00080 (*comment_buffer)[0] = 0; 00081 *comment_buffer_size = CB_INCR; 00082 *lline_buffer = ast_malloc(CB_INCR); 00083 if (!(*lline_buffer)) 00084 return; 00085 (*lline_buffer)[0] = 0; 00086 *lline_buffer_size = CB_INCR; 00087 } else { 00088 (*comment_buffer)[0] = 0; 00089 (*lline_buffer)[0] = 0; 00090 } 00091 }
static void CB_RESET | ( | char ** | comment_buffer, | |
char ** | lline_buffer | |||
) | [static] |
static void clear_config_maps | ( | void | ) | [static] |
Definition at line 1039 of file config.c.
References ast_mutex_lock(), ast_mutex_unlock(), config_maps, free, map, and ast_config_map::next.
Referenced by read_config_maps().
01040 { 01041 struct ast_config_map *map; 01042 01043 ast_mutex_lock(&config_lock); 01044 01045 while (config_maps) { 01046 map = config_maps; 01047 config_maps = config_maps->next; 01048 free(map); 01049 } 01050 01051 ast_mutex_unlock(&config_lock); 01052 }
static int config_command | ( | int | fd, | |
int | argc, | |||
char ** | argv | |||
) | [static] |
Definition at line 1372 of file config.c.
References ast_cli(), ast_mutex_lock(), config_engine_list, config_maps, map, ast_config_engine::name, and ast_config_engine::next.
01373 { 01374 struct ast_config_engine *eng; 01375 struct ast_config_map *map; 01376 01377 ast_mutex_lock(&config_lock); 01378 01379 ast_cli(fd, "\n\n"); 01380 for (eng = config_engine_list; eng; eng = eng->next) { 01381 ast_cli(fd, "\nConfig Engine: %s\n", eng->name); 01382 for (map = config_maps; map; map = map->next) 01383 if (!strcasecmp(map->driver, eng->name)) { 01384 ast_cli(fd, "===> %s (db=%s, table=%s)\n", map->name, map->database, 01385 map->table ? map->table : map->name); 01386 } 01387 } 01388 ast_cli(fd,"\n\n"); 01389 01390 ast_mutex_unlock(&config_lock); 01391 01392 return 0; 01393 }
static struct ast_config* config_text_file_load | ( | const char * | database, | |
const char * | table, | |||
const char * | filename, | |||
struct ast_config * | cfg, | |||
int | withcomments | |||
) | [static] |
Definition at line 761 of file config.c.
References ast_config_AST_CONFIG_DIR, ast_config_get_current_category(), ast_log(), ast_strlen_zero(), ast_verbose(), CB_ADD(), CB_ADD_LEN(), CB_INIT(), COMMENT_META, COMMENT_TAG, f, lineno, LLB_ADD(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, option_debug, option_verbose, process_text_line(), and VERBOSE_PREFIX_2.
00762 { 00763 char fn[256]; 00764 char buf[8192]; 00765 char *new_buf, *comment_p, *process_buf; 00766 FILE *f; 00767 int lineno=0; 00768 int comment = 0, nest[MAX_NESTED_COMMENTS]; 00769 struct ast_category *cat = NULL; 00770 int count = 0; 00771 struct stat statbuf; 00772 /*! Growable string buffer */ 00773 char *comment_buffer=0; /*!< this will be a comment collector.*/ 00774 int comment_buffer_size=0; /*!< the amount of storage so far alloc'd for the comment_buffer */ 00775 00776 char *lline_buffer=0; /*!< A buffer for stuff behind the ; */ 00777 int lline_buffer_size=0; 00778 00779 00780 cat = ast_config_get_current_category(cfg); 00781 00782 if (filename[0] == '/') { 00783 ast_copy_string(fn, filename, sizeof(fn)); 00784 } else { 00785 snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, filename); 00786 } 00787 00788 if (withcomments) { 00789 CB_INIT(&comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size); 00790 if (!lline_buffer || !comment_buffer) { 00791 ast_log(LOG_ERROR, "Failed to initialize the comment buffer!\n"); 00792 return NULL; 00793 } 00794 } 00795 #ifdef AST_INCLUDE_GLOB 00796 { 00797 int glob_ret; 00798 glob_t globbuf; 00799 globbuf.gl_offs = 0; /* initialize it to silence gcc */ 00800 #ifdef SOLARIS 00801 glob_ret = glob(fn, GLOB_NOCHECK, NULL, &globbuf); 00802 #else 00803 glob_ret = glob(fn, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf); 00804 #endif 00805 if (glob_ret == GLOB_NOSPACE) 00806 ast_log(LOG_WARNING, 00807 "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn); 00808 else if (glob_ret == GLOB_ABORTED) 00809 ast_log(LOG_WARNING, 00810 "Glob Expansion of pattern '%s' failed: Read error\n", fn); 00811 else { 00812 /* loop over expanded files */ 00813 int i; 00814 for (i=0; i<globbuf.gl_pathc; i++) { 00815 ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn)); 00816 #endif 00817 do { 00818 if (stat(fn, &statbuf)) 00819 continue; 00820 00821 if (!S_ISREG(statbuf.st_mode)) { 00822 ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn); 00823 continue; 00824 } 00825 if (option_verbose > 1) { 00826 ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn); 00827 fflush(stdout); 00828 } 00829 if (!(f = fopen(fn, "r"))) { 00830 if (option_debug) 00831 ast_log(LOG_DEBUG, "No file to parse: %s\n", fn); 00832 if (option_verbose > 1) 00833 ast_verbose( "Not found (%s)\n", strerror(errno)); 00834 continue; 00835 } 00836 count++; 00837 if (option_debug) 00838 ast_log(LOG_DEBUG, "Parsing %s\n", fn); 00839 if (option_verbose > 1) 00840 ast_verbose("Found\n"); 00841 while(!feof(f)) { 00842 lineno++; 00843 if (fgets(buf, sizeof(buf), f)) { 00844 if ( withcomments ) { 00845 CB_ADD(&comment_buffer, &comment_buffer_size, lline_buffer); /* add the current lline buffer to the comment buffer */ 00846 lline_buffer[0] = 0; /* erase the lline buffer */ 00847 } 00848 00849 new_buf = buf; 00850 if (comment) 00851 process_buf = NULL; 00852 else 00853 process_buf = buf; 00854 00855 while ((comment_p = strchr(new_buf, COMMENT_META))) { 00856 if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) { 00857 /* Yuck, gotta memmove */ 00858 memmove(comment_p - 1, comment_p, strlen(comment_p) + 1); 00859 new_buf = comment_p; 00860 } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) { 00861 /* Meta-Comment start detected ";--" */ 00862 if (comment < MAX_NESTED_COMMENTS) { 00863 *comment_p = '\0'; 00864 new_buf = comment_p + 3; 00865 comment++; 00866 nest[comment-1] = lineno; 00867 } else { 00868 ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS); 00869 } 00870 } else if ((comment_p >= new_buf + 2) && 00871 (*(comment_p - 1) == COMMENT_TAG) && 00872 (*(comment_p - 2) == COMMENT_TAG)) { 00873 /* Meta-Comment end detected */ 00874 comment--; 00875 new_buf = comment_p + 1; 00876 if (!comment) { 00877 /* Back to non-comment now */ 00878 if (process_buf) { 00879 /* Actually have to move what's left over the top, then continue */ 00880 char *oldptr; 00881 oldptr = process_buf + strlen(process_buf); 00882 if ( withcomments ) { 00883 CB_ADD(&comment_buffer, &comment_buffer_size, ";"); 00884 CB_ADD_LEN(&comment_buffer, &comment_buffer_size, oldptr+1, new_buf-oldptr-1); 00885 } 00886 00887 memmove(oldptr, new_buf, strlen(new_buf) + 1); 00888 new_buf = oldptr; 00889 } else 00890 process_buf = new_buf; 00891 } 00892 } else { 00893 if (!comment) { 00894 /* If ; is found, and we are not nested in a comment, 00895 we immediately stop all comment processing */ 00896 if ( withcomments ) { 00897 LLB_ADD(&lline_buffer, &lline_buffer_size, comment_p); 00898 } 00899 *comment_p = '\0'; 00900 new_buf = comment_p; 00901 } else 00902 new_buf = comment_p + 1; 00903 } 00904 } 00905 if( withcomments && comment && !process_buf ) 00906 { 00907 CB_ADD(&comment_buffer, &comment_buffer_size, buf); /* the whole line is a comment, store it */ 00908 } 00909 00910 if (process_buf) { 00911 char *buf = ast_strip(process_buf); 00912 if (!ast_strlen_zero(buf)) { 00913 if (process_text_line(cfg, &cat, buf, lineno, fn, withcomments, &comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size)) { 00914 cfg = NULL; 00915 break; 00916 } 00917 } 00918 } 00919 } 00920 } 00921 fclose(f); 00922 } while(0); 00923 if (comment) { 00924 ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment]); 00925 } 00926 #ifdef AST_INCLUDE_GLOB 00927 if (!cfg) 00928 break; 00929 } 00930 globfree(&globbuf); 00931 } 00932 } 00933 #endif 00934 00935 if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) { 00936 free(comment_buffer); 00937 free(lline_buffer); 00938 comment_buffer = NULL; 00939 lline_buffer = NULL; 00940 comment_buffer_size = 0; 00941 lline_buffer_size = 0; 00942 } 00943 00944 if (count == 0) 00945 return NULL; 00946 00947 return cfg; 00948 }
int config_text_file_save | ( | const char * | configfile, | |
const struct ast_config * | cfg, | |||
const char * | generator | |||
) |
Definition at line 950 of file config.c.
References ast_config_AST_CONFIG_DIR, ast_log(), ast_verbose(), ast_comment::cmt, f, LOG_DEBUG, ast_category::name, ast_category::next, option_debug, option_verbose, ast_category::precomments, ast_config::root, ast_category::root, ast_category::sameline, t, var, and VERBOSE_PREFIX_2.
Referenced by action_updateconfig(), vm_change_password(), and vm_forwardoptions().
00951 { 00952 FILE *f; 00953 char fn[256]; 00954 char date[256]=""; 00955 time_t t; 00956 struct ast_variable *var; 00957 struct ast_category *cat; 00958 struct ast_comment *cmt; 00959 int blanklines = 0; 00960 00961 if (configfile[0] == '/') { 00962 ast_copy_string(fn, configfile, sizeof(fn)); 00963 } else { 00964 snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile); 00965 } 00966 time(&t); 00967 ast_copy_string(date, ctime(&t), sizeof(date)); 00968 #ifdef __CYGWIN__ 00969 if ((f = fopen(fn, "w+"))) { 00970 #else 00971 if ((f = fopen(fn, "w"))) { 00972 #endif 00973 if (option_verbose > 1) 00974 ast_verbose(VERBOSE_PREFIX_2 "Saving '%s': ", fn); 00975 fprintf(f, ";!\n"); 00976 fprintf(f, ";! Automatically generated configuration file\n"); 00977 if (strcmp(configfile, fn)) 00978 fprintf(f, ";! Filename: %s (%s)\n", configfile, fn); 00979 else 00980 fprintf(f, ";! Filename: %s\n", configfile); 00981 fprintf(f, ";! Generator: %s\n", generator); 00982 fprintf(f, ";! Creation Date: %s", date); 00983 fprintf(f, ";!\n"); 00984 cat = cfg->root; 00985 while(cat) { 00986 /* Dump section with any appropriate comment */ 00987 for (cmt = cat->precomments; cmt; cmt=cmt->next) 00988 { 00989 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 00990 fprintf(f,"%s", cmt->cmt); 00991 } 00992 if (!cat->precomments) 00993 fprintf(f,"\n"); 00994 fprintf(f, "[%s]", cat->name); 00995 for(cmt = cat->sameline; cmt; cmt=cmt->next) 00996 { 00997 fprintf(f,"%s", cmt->cmt); 00998 } 00999 if (!cat->sameline) 01000 fprintf(f,"\n"); 01001 var = cat->root; 01002 while(var) { 01003 for (cmt = var->precomments; cmt; cmt=cmt->next) 01004 { 01005 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01006 fprintf(f,"%s", cmt->cmt); 01007 } 01008 if (var->sameline) 01009 fprintf(f, "%s %s %s %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt); 01010 else 01011 fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value); 01012 if (var->blanklines) { 01013 blanklines = var->blanklines; 01014 while (blanklines--) 01015 fprintf(f, "\n"); 01016 } 01017 01018 var = var->next; 01019 } 01020 #if 0 01021 /* Put an empty line */ 01022 fprintf(f, "\n"); 01023 #endif 01024 cat = cat->next; 01025 } 01026 if ((option_verbose > 1) && !option_debug) 01027 ast_verbose("Saved\n"); 01028 } else { 01029 if (option_debug) 01030 ast_log(LOG_DEBUG, "Unable to open for writing: %s\n", fn); 01031 if (option_verbose > 1) 01032 ast_verbose(VERBOSE_PREFIX_2 "Unable to write (%s)", strerror(errno)); 01033 return -1; 01034 } 01035 fclose(f); 01036 return 0; 01037 }
static struct ast_config_engine* find_engine | ( | const char * | family, | |
char * | database, | |||
int | dbsiz, | |||
char * | table, | |||
int | tabsiz | |||
) | [static] |
Find realtime engine for realtime family.
Definition at line 1199 of file config.c.
References ast_mutex_lock(), config_maps, and map.
Referenced by ast_check_realtime(), ast_config_internal_load(), ast_load_realtime(), ast_load_realtime_multientry(), ast_speech_new(), ast_speech_register(), and ast_update_realtime().
01200 { 01201 struct ast_config_engine *eng, *ret = NULL; 01202 struct ast_config_map *map; 01203 01204 ast_mutex_lock(&config_lock); 01205 01206 for (map = config_maps; map; map = map->next) { 01207 if (!strcasecmp(family, map->name)) { 01208 if (database) 01209 ast_copy_string(database, map->database, dbsiz); 01210 if (table) 01211 ast_copy_string(table, map->table ? map->table : family, tabsiz); 01212 break; 01213 } 01214 } 01215 01216 /* Check if the required driver (engine) exist */ 01217 if (map) { 01218 for (eng = config_engine_list; !ret && eng; eng = eng->next) { 01219 if (!strcasecmp(eng->name, map->driver)) 01220 ret = eng; 01221 } 01222 } 01223 01224 ast_mutex_unlock(&config_lock); 01225 01226 /* if we found a mapping, but the engine is not available, then issue a warning */ 01227 if (map && !ret) 01228 ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver); 01229 01230 return ret; 01231 }
static void inherit_category | ( | struct ast_category * | new, | |
const struct ast_category * | base | |||
) | [static] |
Definition at line 404 of file config.c.
References ast_variable_append(), ast_category::root, var, and variable_clone().
Referenced by process_text_line().
00405 { 00406 struct ast_variable *var; 00407 00408 for (var = base->root; var; var = var->next) 00409 ast_variable_append(new, variable_clone(var)); 00410 }
static void LLB_ADD | ( | char ** | lline_buffer, | |
int * | lline_buffer_size, | |||
char * | str | |||
) | [static] |
Definition at line 120 of file config.c.
References ast_realloc, and CB_INCR.
Referenced by config_text_file_load().
00121 { 00122 int rem = *lline_buffer_size - strlen(*lline_buffer) - 1; 00123 int siz = strlen(str); 00124 if (rem < siz+1) { 00125 *lline_buffer = ast_realloc(*lline_buffer, *lline_buffer_size + CB_INCR + siz + 1); 00126 if (!(*lline_buffer)) 00127 return; 00128 *lline_buffer_size += CB_INCR + siz + 1; 00129 } 00130 strcat(*lline_buffer,str); 00131 }
static void move_variables | ( | struct ast_category * | old, | |
struct ast_category * | new | |||
) | [static] |
Definition at line 278 of file config.c.
References ast_variable_append(), ast_variable::next, ast_category::root, and var.
Referenced by process_text_line().
00279 { 00280 struct ast_variable *var = old->root; 00281 old->root = NULL; 00282 #if 1 00283 /* we can just move the entire list in a single op */ 00284 ast_variable_append(new, var); 00285 #else 00286 while (var) { 00287 struct ast_variable *next = var->next; 00288 var->next = NULL; 00289 ast_variable_append(new, var); 00290 var = next; 00291 } 00292 #endif 00293 }
static struct ast_category* next_available_category | ( | struct ast_category * | cat | ) | [static] |
Definition at line 349 of file config.c.
References ast_category::ignored, and ast_category::next.
Referenced by ast_category_browse().
static int process_text_line | ( | struct ast_config * | cfg, | |
struct ast_category ** | cat, | |||
char * | buf, | |||
int | lineno, | |||
const char * | configfile, | |||
int | withcomments, | |||
char ** | comment_buffer, | |||
int * | comment_buffer_size, | |||
char ** | lline_buffer, | |||
int * | lline_buffer_size | |||
) | [static] |
Definition at line 582 of file config.c.
References ALLOC_COMMENT(), ast_category_append(), ast_category_destroy(), ast_category_new(), ast_config_internal_load(), ast_log(), ast_opt_exec_includes, ast_safe_system(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), ast_variable::blanklines, category_get(), CB_RESET(), inherit_category(), ast_variable::lineno, LOG_WARNING, move_variables(), ast_variable::object, ast_variable::precomments, ast_category::precomments, ast_variable::sameline, ast_category::sameline, and strsep().
Referenced by config_text_file_load().
00584 { 00585 char *c; 00586 char *cur = buf; 00587 struct ast_variable *v; 00588 char cmd[512], exec_file[512]; 00589 int object, do_exec, do_include; 00590 00591 /* Actually parse the entry */ 00592 if (cur[0] == '[') { 00593 struct ast_category *newcat = NULL; 00594 char *catname; 00595 00596 /* A category header */ 00597 c = strchr(cur, ']'); 00598 if (!c) { 00599 ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile); 00600 return -1; 00601 } 00602 *c++ = '\0'; 00603 cur++; 00604 if (*c++ != '(') 00605 c = NULL; 00606 catname = cur; 00607 if (!(*cat = newcat = ast_category_new(catname))) { 00608 return -1; 00609 } 00610 /* add comments */ 00611 if (withcomments && *comment_buffer && (*comment_buffer)[0] ) { 00612 newcat->precomments = ALLOC_COMMENT(*comment_buffer); 00613 } 00614 if (withcomments && *lline_buffer && (*lline_buffer)[0] ) { 00615 newcat->sameline = ALLOC_COMMENT(*lline_buffer); 00616 } 00617 if( withcomments ) 00618 CB_RESET(comment_buffer, lline_buffer); 00619 00620 /* If there are options or categories to inherit from, process them now */ 00621 if (c) { 00622 if (!(cur = strchr(c, ')'))) { 00623 ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile); 00624 return -1; 00625 } 00626 *cur = '\0'; 00627 while ((cur = strsep(&c, ","))) { 00628 if (!strcasecmp(cur, "!")) { 00629 (*cat)->ignored = 1; 00630 } else if (!strcasecmp(cur, "+")) { 00631 *cat = category_get(cfg, catname, 1); 00632 if (!(*cat)) { 00633 if (newcat) 00634 ast_category_destroy(newcat); 00635 ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile); 00636 return -1; 00637 } 00638 if (newcat) { 00639 move_variables(newcat, *cat); 00640 ast_category_destroy(newcat); 00641 newcat = NULL; 00642 } 00643 } else { 00644 struct ast_category *base; 00645 00646 base = category_get(cfg, cur, 1); 00647 if (!base) { 00648 ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile); 00649 return -1; 00650 } 00651 inherit_category(*cat, base); 00652 } 00653 } 00654 } 00655 if (newcat) 00656 ast_category_append(cfg, *cat); 00657 } else if (cur[0] == '#') { 00658 /* A directive */ 00659 cur++; 00660 c = cur; 00661 while(*c && (*c > 32)) c++; 00662 if (*c) { 00663 *c = '\0'; 00664 /* Find real argument */ 00665 c = ast_skip_blanks(c + 1); 00666 if (!(*c)) 00667 c = NULL; 00668 } else 00669 c = NULL; 00670 do_include = !strcasecmp(cur, "include"); 00671 if(!do_include) 00672 do_exec = !strcasecmp(cur, "exec"); 00673 else 00674 do_exec = 0; 00675 if (do_exec && !ast_opt_exec_includes) { 00676 ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n"); 00677 do_exec = 0; 00678 } 00679 if (do_include || do_exec) { 00680 if (c) { 00681 /* Strip off leading and trailing "'s and <>'s */ 00682 while((*c == '<') || (*c == '>') || (*c == '\"')) c++; 00683 /* Get rid of leading mess */ 00684 cur = c; 00685 while (!ast_strlen_zero(cur)) { 00686 c = cur + strlen(cur) - 1; 00687 if ((*c == '>') || (*c == '<') || (*c == '\"')) 00688 *c = '\0'; 00689 else 00690 break; 00691 } 00692 /* #exec </path/to/executable> 00693 We create a tmp file, then we #include it, then we delete it. */ 00694 if (do_exec) { 00695 snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self()); 00696 snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file); 00697 ast_safe_system(cmd); 00698 cur = exec_file; 00699 } else 00700 exec_file[0] = '\0'; 00701 /* A #include */ 00702 do_include = ast_config_internal_load(cur, cfg, withcomments) ? 1 : 0; 00703 if(!ast_strlen_zero(exec_file)) 00704 unlink(exec_file); 00705 if(!do_include) 00706 return 0; 00707 00708 } else { 00709 ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n", 00710 do_exec ? "exec" : "include", 00711 do_exec ? "/path/to/executable" : "filename", 00712 lineno, 00713 configfile); 00714 } 00715 } 00716 else 00717 ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile); 00718 } else { 00719 /* Just a line (variable = value) */ 00720 if (!(*cat)) { 00721 ast_log(LOG_WARNING, 00722 "parse error: No category context for line %d of %s\n", lineno, configfile); 00723 return -1; 00724 } 00725 c = strchr(cur, '='); 00726 if (c) { 00727 *c = 0; 00728 c++; 00729 /* Ignore > in => */ 00730 if (*c== '>') { 00731 object = 1; 00732 c++; 00733 } else 00734 object = 0; 00735 if ((v = ast_variable_new(ast_strip(cur), ast_strip(c)))) { 00736 v->lineno = lineno; 00737 v->object = object; 00738 /* Put and reset comments */ 00739 v->blanklines = 0; 00740 ast_variable_append(*cat, v); 00741 /* add comments */ 00742 if (withcomments && *comment_buffer && (*comment_buffer)[0] ) { 00743 v->precomments = ALLOC_COMMENT(*comment_buffer); 00744 } 00745 if (withcomments && *lline_buffer && (*lline_buffer)[0] ) { 00746 v->sameline = ALLOC_COMMENT(*lline_buffer); 00747 } 00748 if( withcomments ) 00749 CB_RESET(comment_buffer, lline_buffer); 00750 00751 } else { 00752 return -1; 00753 } 00754 } else { 00755 ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile); 00756 } 00757 } 00758 return 0; 00759 }
int read_config_maps | ( | void | ) |
Definition at line 1089 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, extconfig_conf, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, strsep(), table, and ast_variable::value.
Referenced by main().
01090 { 01091 struct ast_config *config, *configtmp; 01092 struct ast_variable *v; 01093 char *driver, *table, *database, *stringp, *tmp; 01094 01095 clear_config_maps(); 01096 01097 configtmp = ast_config_new(); 01098 configtmp->max_include_level = 1; 01099 config = ast_config_internal_load(extconfig_conf, configtmp, 0); 01100 if (!config) { 01101 ast_config_destroy(configtmp); 01102 return 0; 01103 } 01104 01105 for (v = ast_variable_browse(config, "settings"); v; v = v->next) { 01106 stringp = v->value; 01107 driver = strsep(&stringp, ","); 01108 01109 if ((tmp = strchr(stringp, '\"'))) 01110 stringp = tmp; 01111 01112 /* check if the database text starts with a double quote */ 01113 if (*stringp == '"') { 01114 stringp++; 01115 database = strsep(&stringp, "\""); 01116 strsep(&stringp, ","); 01117 } else { 01118 /* apparently this text has no quotes */ 01119 database = strsep(&stringp, ","); 01120 } 01121 01122 table = strsep(&stringp, ","); 01123 01124 if (!strcmp(v->name, extconfig_conf)) { 01125 ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf); 01126 continue; 01127 } 01128 01129 if (!strcmp(v->name, "asterisk.conf")) { 01130 ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n"); 01131 continue; 01132 } 01133 01134 if (!strcmp(v->name, "logger.conf")) { 01135 ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n"); 01136 continue; 01137 } 01138 01139 if (!driver || !database) 01140 continue; 01141 if (!strcasecmp(v->name, "sipfriends")) { 01142 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"); 01143 append_mapping("sipusers", driver, database, table ? table : "sipfriends"); 01144 append_mapping("sippeers", driver, database, table ? table : "sipfriends"); 01145 } else if (!strcasecmp(v->name, "iaxfriends")) { 01146 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"); 01147 append_mapping("iaxusers", driver, database, table ? table : "iaxfriends"); 01148 append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends"); 01149 } else 01150 append_mapping(v->name, driver, database, table); 01151 } 01152 01153 ast_config_destroy(config); 01154 return 0; 01155 }
int register_config_cli | ( | void | ) |
Definition at line 1410 of file config.c.
References ast_cli_register_multiple(), and cli_config.
Referenced by main().
01411 { 01412 ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry)); 01413 return 0; 01414 }
static struct ast_variable* variable_clone | ( | const struct ast_variable * | old | ) | [static] |
Definition at line 264 of file config.c.
References ast_variable_new(), ast_variable::blanklines, ast_variable::lineno, ast_variable::name, ast_variable::object, and ast_variable::value.
Referenced by inherit_category().
00265 { 00266 struct ast_variable *new = ast_variable_new(old->name, old->value); 00267 00268 if (new) { 00269 new->lineno = old->lineno; 00270 new->object = old->object; 00271 new->blanklines = old->blanklines; 00272 /* TODO: clone comments? */ 00273 } 00274 00275 return new; 00276 }
struct ast_cli_entry cli_config[] [static] |
Initial value:
{ { { "core", "show", "config", "mappings", NULL }, config_command, "Display config mappings (file names to config engines)", show_config_help, NULL, &cli_show_config_mappings_deprecated }, }
Definition at line 1404 of file config.c.
Referenced by register_config_cli().
struct ast_cli_entry cli_show_config_mappings_deprecated [static] |
Initial value:
{ { "show", "config", "mappings", NULL }, config_command, NULL, NULL }
struct ast_config_engine* config_engine_list [static] |
Definition at line 158 of file config.c.
Referenced by ast_config_engine_deregister(), ast_config_engine_register(), ast_config_internal_load(), and config_command().
struct ast_config_map * config_maps [static] |
Referenced by append_mapping(), clear_config_maps(), config_command(), and find_engine().
char* extconfig_conf = "extconfig.conf" [static] |
Definition at line 63 of file config.c.
Referenced by ast_config_internal_load(), and read_config_maps().
char show_config_help[] [static] |
struct ast_config_engine text_file_engine [static] |
Initial value:
{ .name = "text", .load_func = config_text_file_load, }
Definition at line 1233 of file config.c.
Referenced by ast_config_internal_load().