#include "asterisk.h"
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <sys/stat.h>
#include <glob.h>
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/lock.h"
#include "asterisk/options.h"
#include "asterisk/logger.h"
#include "asterisk/utils.h"
#include "asterisk/channel.h"
#include "asterisk/app.h"
Go to the source code of this file.
Data Structures | |
struct | ast_category |
struct | ast_category_template_instance |
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) |
ast_variable * | ast_category_root (struct ast_config *config, char *cat) |
returns the root ast_variable of a config | |
int | ast_check_realtime (const char *family) |
Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists. | |
void | ast_config_destroy (struct ast_config *cfg) |
Destroys a config. | |
int | ast_config_engine_deregister (struct ast_config_engine *del) |
Deegister config engine. | |
int | ast_config_engine_register (struct ast_config_engine *new) |
Register config engine. | |
ast_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) |
static void | ast_destroy_comments (struct ast_category *cat) |
static void | ast_destroy_template_list (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_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_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) |
ast_variable * | ast_variable_next (struct ast_config *config, char *category, struct ast_variable *prev) |
Iterates through variables. | |
const char * | ast_variable_retrieve (const struct ast_config *config, const char *category, const char *variable) |
Gets a variable. | |
int | ast_variable_update (struct ast_category *category, const char *variable, const char *value, const char *match, unsigned int object) |
void | ast_variables_destroy (struct ast_variable *v) |
Free variable list. | |
static struct ast_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 |
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 1176 of file config.c.
References ast_calloc, ast_verbose(), config_maps, map, option_verbose, and VERBOSE_PREFIX_2.
Referenced by read_config_maps().
01177 { 01178 struct ast_config_map *map; 01179 int length; 01180 01181 length = sizeof(*map); 01182 length += strlen(name) + 1; 01183 length += strlen(driver) + 1; 01184 length += strlen(database) + 1; 01185 if (table) 01186 length += strlen(table) + 1; 01187 01188 if (!(map = ast_calloc(1, length))) 01189 return -1; 01190 01191 map->name = map->stuff; 01192 strcpy(map->name, name); 01193 map->driver = map->name + strlen(map->name) + 1; 01194 strcpy(map->driver, driver); 01195 map->database = map->driver + strlen(map->driver) + 1; 01196 strcpy(map->database, database); 01197 if (table) { 01198 map->table = map->database + strlen(map->database) + 1; 01199 strcpy(map->table, table); 01200 } 01201 map->next = config_maps; 01202 01203 if (option_verbose > 1) 01204 ast_verbose(VERBOSE_PREFIX_2 "Binding %s to %s/%s/%s\n", 01205 map->name, map->driver, map->database, map->table ? map->table : map->name); 01206 01207 config_maps = map; 01208 return 0; 01209 }
void ast_category_append | ( | struct ast_config * | config, | |
struct ast_category * | category | |||
) |
Definition at line 358 of file config.c.
References config, and ast_category::include_level.
Referenced by config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_odbc(), and realtime_multi_pgsql().
00359 { 00360 if (config->last) 00361 config->last->next = category; 00362 else 00363 config->root = category; 00364 category->include_level = config->include_level; 00365 config->last = category; 00366 config->current = category; 00367 }
char* ast_category_browse | ( | struct ast_config * | config, | |
const char * | prev | |||
) |
Goes through categories.
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 417 of file config.c.
References config, ast_category::name, and next_available_category().
Referenced by action_getconfig(), aji_load_config(), authenticate(), complete_sipnotify(), do_directory(), gtalk_load_config(), iax_provision_reload(), ind_load_module(), init_manager(), load_config(), load_module(), load_moh_classes(), load_odbc_config(), loadconfigurationfile(), misdn_cfg_init(), odbc_load_module(), osp_load(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_zap(), sla_load_config(), update_realtime_members(), and vm_change_password().
00418 { 00419 struct ast_category *cat = NULL; 00420 00421 if (prev && config->last_browse && (config->last_browse->name == prev)) 00422 cat = config->last_browse->next; 00423 else if (!prev && config->root) 00424 cat = config->root; 00425 else if (prev) { 00426 for (cat = config->root; cat; cat = cat->next) { 00427 if (cat->name == prev) { 00428 cat = cat->next; 00429 break; 00430 } 00431 } 00432 if (!cat) { 00433 for (cat = config->root; cat; cat = cat->next) { 00434 if (!strcasecmp(cat->name, prev)) { 00435 cat = cat->next; 00436 break; 00437 } 00438 } 00439 } 00440 } 00441 00442 if (cat) 00443 cat = next_available_category(cat); 00444 00445 config->last_browse = cat; 00446 return (cat) ? cat->name : NULL; 00447 }
int ast_category_delete | ( | struct ast_config * | cfg, | |
char * | category | |||
) |
Definition at line 572 of file config.c.
References ast_category_destroy(), ast_config::last, and ast_config::root.
Referenced by handle_updates().
00573 { 00574 struct ast_category *prev=NULL, *cat; 00575 cat = cfg->root; 00576 while(cat) { 00577 if (cat->name == category) { 00578 if (prev) { 00579 prev->next = cat->next; 00580 if (cat == cfg->last) 00581 cfg->last = prev; 00582 } else { 00583 cfg->root = cat->next; 00584 if (cat == cfg->last) 00585 cfg->last = NULL; 00586 } 00587 ast_category_destroy(cat); 00588 return 0; 00589 } 00590 prev = cat; 00591 cat = cat->next; 00592 } 00593 00594 prev = NULL; 00595 cat = cfg->root; 00596 while(cat) { 00597 if (!strcasecmp(cat->name, category)) { 00598 if (prev) { 00599 prev->next = cat->next; 00600 if (cat == cfg->last) 00601 cfg->last = prev; 00602 } else { 00603 cfg->root = cat->next; 00604 if (cat == cfg->last) 00605 cfg->last = NULL; 00606 } 00607 ast_category_destroy(cat); 00608 return 0; 00609 } 00610 prev = cat; 00611 cat = cat->next; 00612 } 00613 return -1; 00614 }
void ast_category_destroy | ( | struct ast_category * | cat | ) |
Definition at line 394 of file config.c.
References ast_destroy_comments(), ast_destroy_template_list(), ast_variables_destroy(), and free.
Referenced by ast_category_delete(), ast_config_destroy(), process_text_line(), and realtime_multi_odbc().
00395 { 00396 ast_variables_destroy(cat->root); 00397 ast_destroy_comments(cat); 00398 ast_destroy_template_list(cat); 00399 free(cat); 00400 }
struct ast_variable* ast_category_detach_variables | ( | struct ast_category * | cat | ) |
Definition at line 449 of file config.c.
Referenced by realtime_switch_common().
00450 { 00451 struct ast_variable *v; 00452 00453 v = cat->root; 00454 cat->root = NULL; 00455 cat->last = NULL; 00456 00457 return v; 00458 }
int ast_category_exist | ( | const struct ast_config * | config, | |
const char * | category_name | |||
) |
Check for category duplicates.
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 353 of file config.c.
References ast_category_get(), and config.
00354 { 00355 return !!ast_category_get(config, category_name); 00356 }
struct ast_category* ast_category_get | ( | const struct ast_config * | config, | |
const char * | category_name | |||
) |
Retrieve a category if it exists.
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 348 of file config.c.
References category_get(), and config.
Referenced by ast_category_exist(), ast_category_root(), ast_variable_browse(), handle_updates(), realtime_directory(), realtime_switch_common(), vm_change_password(), and vm_forwardoptions().
00349 { 00350 return category_get(config, category_name, 0); 00351 }
struct ast_category* ast_category_new | ( | const char * | name | ) |
Definition at line 321 of file config.c.
References ast_calloc.
Referenced by config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_odbc(), and realtime_multi_pgsql().
00322 { 00323 struct ast_category *category; 00324 00325 if ((category = ast_calloc(1, sizeof(*category)))) 00326 ast_copy_string(category->name, name, sizeof(category->name)); 00327 return category; 00328 }
void ast_category_rename | ( | struct ast_category * | cat, | |
const char * | name | |||
) |
Definition at line 460 of file config.c.
References ast_category::name.
Referenced by handle_updates(), realtime_multi_odbc(), and realtime_multi_pgsql().
struct ast_variable* ast_category_root | ( | struct ast_config * | config, | |
char * | cat | |||
) |
returns the root ast_variable of a config
config | pointer to an ast_config data structure | |
cat | name of the category for which you want the root |
Definition at line 409 of file config.c.
References ast_category_get(), and config.
00410 { 00411 struct ast_category *category = ast_category_get(config, cat); 00412 if (category) 00413 return category->root; 00414 return NULL; 00415 }
int ast_check_realtime | ( | const char * | family | ) |
Check if realtime engine is configured for family returns 1 if family is configured in realtime and engine exists.
family | which family/config to be checked |
Definition at line 1450 of file config.c.
References find_engine().
Referenced by _sip_show_peer(), _sip_show_peers(), and sip_show_settings().
01451 { 01452 struct ast_config_engine *eng; 01453 01454 eng = find_engine(family, NULL, 0, NULL, 0); 01455 if (eng) 01456 return 1; 01457 return 0; 01458 01459 }
void ast_config_destroy | ( | struct ast_config * | config | ) |
Destroys a config.
config | pointer to config data structure Free memory associated with a given config |
Definition at line 616 of file config.c.
References ast_category_destroy(), free, and ast_config::root.
Referenced by __ast_http_load(), action_getconfig(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_config_load(), ast_config_load_with_comments(), ast_enum_init(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_realtime_queue(), load_rpt_vars(), loadconfigurationfile(), my_load_module(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_users(), play_message(), privacy_exec(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), rpt_master(), set_config(), setup_zap(), sla_load_config(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().
00617 { 00618 struct ast_category *cat, *catn; 00619 00620 if (!cfg) 00621 return; 00622 00623 cat = cfg->root; 00624 while(cat) { 00625 catn = cat; 00626 cat = cat->next; 00627 ast_category_destroy(catn); 00628 } 00629 free(cfg); 00630 }
int ast_config_engine_deregister | ( | struct ast_config_engine * | del | ) |
Deegister config engine.
Definition at line 1298 of file config.c.
References ast_mutex_lock(), ast_mutex_unlock(), config_engine_list, last, and ast_config_engine::next.
Referenced by unload_module().
01299 { 01300 struct ast_config_engine *ptr, *last=NULL; 01301 01302 ast_mutex_lock(&config_lock); 01303 01304 for (ptr = config_engine_list; ptr; ptr=ptr->next) { 01305 if (ptr == del) { 01306 if (last) 01307 last->next = ptr->next; 01308 else 01309 config_engine_list = ptr->next; 01310 break; 01311 } 01312 last = ptr; 01313 } 01314 01315 ast_mutex_unlock(&config_lock); 01316 01317 return 0; 01318 }
int ast_config_engine_register | ( | struct ast_config_engine * | new | ) |
Register config engine.
Definition at line 1279 of file config.c.
References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_engine_list, LOG_NOTICE, ast_config_engine::name, and ast_config_engine::next.
Referenced by load_module().
01280 { 01281 struct ast_config_engine *ptr; 01282 01283 ast_mutex_lock(&config_lock); 01284 01285 if (!config_engine_list) { 01286 config_engine_list = new; 01287 } else { 01288 for (ptr = config_engine_list; ptr->next; ptr=ptr->next); 01289 ptr->next = new; 01290 } 01291 01292 ast_mutex_unlock(&config_lock); 01293 ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name); 01294 01295 return 1; 01296 }
struct ast_category* ast_config_get_current_category | ( | const struct ast_config * | cfg | ) |
Definition at line 632 of file config.c.
References ast_config::current.
Referenced by config_odbc(), and config_text_file_load().
00633 { 00634 return cfg->current; 00635 }
struct ast_config* ast_config_internal_load | ( | const char * | filename, | |
struct ast_config * | cfg, | |||
int | withcomments | |||
) |
Definition at line 1360 of file config.c.
References ast_log(), config_engine_list, db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, table, and text_file_engine.
Referenced by ast_config_load(), ast_config_load_with_comments(), config_odbc(), config_pgsql(), process_text_line(), and read_config_maps().
01361 { 01362 char db[256]; 01363 char table[256]; 01364 struct ast_config_engine *loader = &text_file_engine; 01365 struct ast_config *result; 01366 01367 /* The config file itself bumps include_level by 1 */ 01368 if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) { 01369 ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level); 01370 return NULL; 01371 } 01372 01373 cfg->include_level++; 01374 01375 if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) { 01376 struct ast_config_engine *eng; 01377 01378 eng = find_engine(filename, db, sizeof(db), table, sizeof(table)); 01379 01380 01381 if (eng && eng->load_func) { 01382 loader = eng; 01383 } else { 01384 eng = find_engine("global", db, sizeof(db), table, sizeof(table)); 01385 if (eng && eng->load_func) 01386 loader = eng; 01387 } 01388 } 01389 01390 result = loader->load_func(db, table, filename, cfg, withcomments); 01391 01392 if (result) 01393 result->include_level--; 01394 else 01395 cfg->include_level--; 01396 01397 return result; 01398 }
struct ast_config* ast_config_load | ( | const char * | filename | ) |
Load a config file.
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 1400 of file config.c.
References ast_config_destroy(), ast_config_internal_load(), and ast_config_new().
Referenced by __ast_http_load(), __say_init(), adsi_load(), advanced_options(), aji_load_config(), ast_enum_init(), ast_readconfig(), ast_rtp_reload(), ast_udptl_reload(), authenticate(), conf_exec(), directory_exec(), do_reload(), festival_exec(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_provision_reload(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), my_load_module(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), privacy_exec(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queues(), rpt_master(), set_config(), setup_zap(), sla_load_config(), smdi_load(), tds_load_module(), and vm_forwardoptions().
01401 { 01402 struct ast_config *cfg; 01403 struct ast_config *result; 01404 01405 cfg = ast_config_new(); 01406 if (!cfg) 01407 return NULL; 01408 01409 result = ast_config_internal_load(filename, cfg, 0); 01410 if (!result) 01411 ast_config_destroy(cfg); 01412 01413 return result; 01414 }
struct ast_config* ast_config_load_with_comments | ( | const char * | filename | ) |
Definition at line 1416 of file config.c.
References ast_config_destroy(), ast_config_internal_load(), and ast_config_new().
Referenced by action_getconfig(), action_updateconfig(), and vm_change_password().
01417 { 01418 struct ast_config *cfg; 01419 struct ast_config *result; 01420 01421 cfg = ast_config_new(); 01422 if (!cfg) 01423 return NULL; 01424 01425 result = ast_config_internal_load(filename, cfg, 1); 01426 if (!result) 01427 ast_config_destroy(cfg); 01428 01429 return result; 01430 }
struct ast_config* ast_config_new | ( | void | ) |
Definition at line 476 of file config.c.
References ast_calloc, config, and MAX_INCLUDE_LEVEL.
Referenced by ast_config_load(), ast_config_load_with_comments(), read_config_maps(), realtime_multi_odbc(), and realtime_multi_pgsql().
00477 { 00478 struct ast_config *config; 00479 00480 if ((config = ast_calloc(1, sizeof(*config)))) 00481 config->max_include_level = MAX_INCLUDE_LEVEL; 00482 return config; 00483 }
const char* ast_config_option | ( | struct ast_config * | cfg, | |
const char * | cat, | |||
const char * | var | |||
) |
Definition at line 240 of file config.c.
References ast_variable_retrieve().
Referenced by do_directory(), load_config(), and pbx_load_users().
00241 { 00242 const char *tmp; 00243 tmp = ast_variable_retrieve(cfg, cat, var); 00244 if (!tmp) 00245 tmp = ast_variable_retrieve(cfg, "general", var); 00246 return tmp; 00247 }
void ast_config_set_current_category | ( | struct ast_config * | cfg, | |
const struct ast_category * | cat | |||
) |
Definition at line 637 of file config.c.
References ast_config::current.
00638 { 00639 /* cast below is just to silence compiler warning about dropping "const" */ 00640 cfg->current = (struct ast_category *) cat; 00641 }
static void ast_destroy_comments | ( | struct ast_category * | cat | ) | [static] |
Definition at line 369 of file config.c.
References free, and ast_comment::next.
Referenced by ast_category_destroy().
00370 { 00371 struct ast_comment *n, *p; 00372 for (p=cat->precomments; p; p=n) { 00373 n = p->next; 00374 free(p); 00375 } 00376 for (p=cat->sameline; p; p=n) { 00377 n = p->next; 00378 free(p); 00379 } 00380 cat->precomments = NULL; 00381 cat->sameline = NULL; 00382 }
static void ast_destroy_template_list | ( | struct ast_category * | cat | ) | [static] |
Definition at line 384 of file config.c.
References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, and free.
Referenced by ast_category_destroy().
00385 { 00386 struct ast_category_template_instance *x; 00387 AST_LIST_TRAVERSE_SAFE_BEGIN(&cat->template_instances, x, next) { 00388 AST_LIST_REMOVE_CURRENT(&cat->template_instances, next); 00389 free(x); 00390 } 00391 AST_LIST_TRAVERSE_SAFE_END; 00392 }
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 1432 of file config.c.
References db, find_engine(), ast_config_engine::realtime_func, and table.
Referenced by cli_realtime_load(), find_conf_realtime(), find_user_realtime(), function_realtime_read(), load_realtime_queue(), queue_function_queuewaitingcount(), realtime_alias(), realtime_exec(), realtime_peer(), realtime_switch_common(), realtime_user(), and update_realtime_member_field().
01433 { 01434 struct ast_config_engine *eng; 01435 char db[256]=""; 01436 char table[256]=""; 01437 struct ast_variable *res=NULL; 01438 va_list ap; 01439 01440 va_start(ap, family); 01441 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01442 if (eng && eng->realtime_func) 01443 res = eng->realtime_func(db, table, ap); 01444 va_end(ap); 01445 01446 return res; 01447 }
struct ast_config* ast_load_realtime_multientry | ( | const char * | family, | |
... | ||||
) |
Retrieve realtime configuration.
family | which family/config to lookup This will use builtin configuration backends to look up a particular entity in realtime and return a variable list of its parameters. Unlike the ast_load_realtime, this function can return more than one entry and is thus stored inside a taditional ast_config structure rather than just returning a linked list of variables. |
Definition at line 1467 of file config.c.
References db, find_engine(), ast_config_engine::realtime_multi_func, and table.
Referenced by load_realtime_queue(), realtime_directory(), realtime_switch_common(), and update_realtime_members().
01468 { 01469 struct ast_config_engine *eng; 01470 char db[256]=""; 01471 char table[256]=""; 01472 struct ast_config *res=NULL; 01473 va_list ap; 01474 01475 va_start(ap, family); 01476 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01477 if (eng && eng->realtime_multi_func) 01478 res = eng->realtime_multi_func(db, table, ap); 01479 va_end(ap); 01480 01481 return res; 01482 }
AST_MUTEX_DEFINE_STATIC | ( | config_lock | ) |
int ast_realtime_enabled | ( | void | ) |
Check if realtime engine is enabled returns 1 if realtime is enabled.
Definition at line 1462 of file config.c.
References config_maps.
Referenced by action_coresettings(), and handle_show_settings().
01463 { 01464 return config_maps ? 1 : 0; 01465 }
int ast_update_realtime | ( | const char * | family, | |
const char * | keyfield, | |||
const char * | lookup, | |||
... | ||||
) |
Update realtime configuration.
family | which family/config to be updated | |
keyfield | which field to use as the key | |
lookup | which value to look for in the key field to match the entry. This function is used to update a parameter in realtime configuration space. |
Definition at line 1484 of file config.c.
References db, find_engine(), table, and ast_config_engine::update_func.
Referenced by change_password_realtime(), cli_realtime_update(), conf_run(), destroy_association(), function_realtime_write(), realtime_update_exec(), realtime_update_peer(), and update_realtime_member_field().
01485 { 01486 struct ast_config_engine *eng; 01487 int res = -1; 01488 char db[256]=""; 01489 char table[256]=""; 01490 va_list ap; 01491 01492 va_start(ap, lookup); 01493 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 01494 if (eng && eng->update_func) 01495 res = eng->update_func(db, table, keyfield, lookup, ap); 01496 va_end(ap); 01497 01498 return res; 01499 }
void ast_variable_append | ( | struct ast_category * | category, | |
struct ast_variable * | variable | |||
) |
Definition at line 204 of file config.c.
Referenced by config_odbc(), config_pgsql(), handle_updates(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_odbc(), realtime_multi_pgsql(), and vm_change_password().
00205 { 00206 if (!variable) 00207 return; 00208 if (category->last) 00209 category->last->next = variable; 00210 else 00211 category->root = variable; 00212 category->last = variable; 00213 while (category->last->next) 00214 category->last = category->last->next; 00215 }
struct ast_variable* ast_variable_browse | ( | const struct ast_config * | config, | |
const char * | category | |||
) |
Goes through variables Somewhat similar in intent as the ast_category_browse. List variables of config file category.
Returns ast_variable list on success, or NULL on failure
Definition at line 228 of file config.c.
References ast_category_get(), and config.
Referenced by __ast_http_load(), action_getconfig(), adsi_load(), aji_load_config(), ast_enum_init(), ast_readconfig(), ast_variable_next(), ast_variable_retrieve(), authenticate(), check_tx_freq(), collect_function_digits(), conf_exec(), do_directory(), do_say(), do_scheduler(), find_conf(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_logger_chain(), init_manager(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), loadconfigurationfile(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), pbx_load_config(), process_my_load_module(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queues(), set_config(), setup_zap(), sip_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().
00229 { 00230 struct ast_category *cat = NULL; 00231 00232 if (category && config->last_browse && (config->last_browse->name == category)) 00233 cat = config->last_browse; 00234 else 00235 cat = ast_category_get(config, category); 00236 00237 return (cat) ? cat->root : NULL; 00238 }
int ast_variable_delete | ( | struct ast_category * | category, | |
char * | variable, | |||
char * | match | |||
) |
Definition at line 485 of file config.c.
References ast_strlen_zero(), ast_variables_destroy(), ast_variable::name, ast_variable::next, and ast_variable::value.
Referenced by handle_updates().
00486 { 00487 struct ast_variable *cur, *prev=NULL, *curn; 00488 int res = -1; 00489 cur = category->root; 00490 while (cur) { 00491 if (cur->name == variable) { 00492 if (prev) { 00493 prev->next = cur->next; 00494 if (cur == category->last) 00495 category->last = prev; 00496 } else { 00497 category->root = cur->next; 00498 if (cur == category->last) 00499 category->last = NULL; 00500 } 00501 cur->next = NULL; 00502 ast_variables_destroy(cur); 00503 return 0; 00504 } 00505 prev = cur; 00506 cur = cur->next; 00507 } 00508 00509 prev = NULL; 00510 cur = category->root; 00511 while (cur) { 00512 curn = cur->next; 00513 if (!strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match))) { 00514 if (prev) { 00515 prev->next = cur->next; 00516 if (cur == category->last) 00517 category->last = prev; 00518 } else { 00519 category->root = cur->next; 00520 if (cur == category->last) 00521 category->last = NULL; 00522 } 00523 cur->next = NULL; 00524 ast_variables_destroy(cur); 00525 res = 0; 00526 } else 00527 prev = cur; 00528 00529 cur = curn; 00530 } 00531 return res; 00532 }
struct ast_variable* ast_variable_new | ( | const char * | name, | |
const char * | value | |||
) |
Definition at line 189 of file config.c.
References ast_calloc, and ast_variable::name.
Referenced by apply_outgoing(), ast_channeltype_list(), ast_variable_update(), astman_get_variables(), build_peer(), build_user(), check_access(), check_user_full(), config_odbc(), config_pgsql(), handle_updates(), handle_uri(), parkandannounce_exec(), parse_cookies(), process_text_line(), realtime_directory(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_odbc(), realtime_pgsql(), variable_clone(), and vm_change_password().
00190 { 00191 struct ast_variable *variable; 00192 int name_len = strlen(name) + 1; 00193 00194 if ((variable = ast_calloc(1, name_len + strlen(value) + 1 + sizeof(*variable)))) { 00195 variable->name = variable->stuff; 00196 variable->value = variable->stuff + name_len; 00197 strcpy(variable->name,name); 00198 strcpy(variable->value,value); 00199 } 00200 00201 return variable; 00202 }
struct ast_variable* ast_variable_next | ( | struct ast_config * | config, | |
char * | category, | |||
struct ast_variable * | prev | |||
) |
Iterates through variables.
Somewhat similar in intent as the ast_category_browse. The prev variable MUST be an actual pointer to an actual variable (such as one obtained by using ast_variable_browse() or ast_variable_next() itself). List variables of config file Returns next variable on the list, or NULL on failure
Definition at line 250 of file config.c.
References ast_variable_browse(), and config.
00251 { 00252 struct ast_variable *v = NULL; 00253 v = ast_variable_browse(config, category); 00254 if(v) { 00255 if(prev) { 00256 while (v) { 00257 if (v == prev) 00258 return v->next; 00259 v=v->next; 00260 } 00261 } else { 00262 return v; 00263 } 00264 } 00265 return NULL; 00266 }
const char* ast_variable_retrieve | ( | const struct ast_config * | config, | |
const char * | category, | |||
const char * | variable | |||
) |
Gets a variable.
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 269 of file config.c.
References ast_variable_browse(), config, ast_variable::name, ast_variable::next, and ast_variable::value.
Referenced by advanced_options(), aji_load_config(), ast_config_option(), ast_rtp_reload(), ast_udptl_reload(), directory_exec(), do_directory(), do_reload(), do_scheduler(), festival_exec(), function_macro(), get_wait_interval(), gtalk_load_config(), handle_save_dialplan(), iax_template_parse(), ind_load_module(), init_acf_query(), init_logger_chain(), init_manager(), load_config(), load_config_meetme(), load_module(), load_modules(), load_rpt_vars(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), privacy_exec(), process_my_load_module(), read_agent_config(), realtime_directory(), reload_config(), reload_followme(), reload_queues(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), set_config(), setup_zap(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), update_realtime_members(), vm_change_password(), and vm_forwardoptions().
00270 { 00271 struct ast_variable *v; 00272 00273 if (category) { 00274 for (v = ast_variable_browse(config, category); v; v = v->next) { 00275 if (!strcasecmp(variable, v->name)) 00276 return v->value; 00277 } 00278 } else { 00279 struct ast_category *cat; 00280 00281 for (cat = config->root; cat; cat = cat->next) 00282 for (v = cat->root; v; v = v->next) 00283 if (!strcasecmp(variable, v->name)) 00284 return v->value; 00285 } 00286 00287 return NULL; 00288 }
int ast_variable_update | ( | struct ast_category * | category, | |
const char * | variable, | |||
const char * | value, | |||
const char * | match, | |||
unsigned int | object | |||
) |
Definition at line 534 of file config.c.
References ast_strlen_zero(), ast_variable_new(), ast_variables_destroy(), ast_variable::name, ast_variable::next, ast_variable::object, and ast_variable::value.
Referenced by handle_updates(), vm_change_password(), and vm_forwardoptions().
00536 { 00537 struct ast_variable *cur, *prev=NULL, *newer; 00538 00539 if (!(newer = ast_variable_new(variable, value))) 00540 return -1; 00541 00542 newer->object = object; 00543 00544 for (cur = category->root; cur; prev = cur, cur = cur->next) { 00545 if (strcasecmp(cur->name, variable) || 00546 (!ast_strlen_zero(match) && strcasecmp(cur->value, match))) 00547 continue; 00548 00549 newer->next = cur->next; 00550 newer->object = cur->object || object; 00551 if (prev) 00552 prev->next = newer; 00553 else 00554 category->root = newer; 00555 if (category->last == cur) 00556 category->last = newer; 00557 00558 cur->next = NULL; 00559 ast_variables_destroy(cur); 00560 00561 return 0; 00562 } 00563 00564 if (prev) 00565 prev->next = newer; 00566 else 00567 category->root = newer; 00568 00569 return 0; 00570 }
void ast_variables_destroy | ( | struct ast_variable * | var | ) |
Free variable list.
var | the linked list of variables to free This function frees a list of variables. |
Definition at line 217 of file config.c.
References free, and ast_variable::next.
Referenced by ast_category_destroy(), ast_httpd_helper_thread(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_variable_delete(), ast_variable_update(), build_peer(), build_user(), find_conf_realtime(), find_user_realtime(), handle_uri(), load_realtime_queue(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), sip_alloc(), sip_destroy_peer(), sip_destroy_user(), and user_destructor().
00218 { 00219 struct ast_variable *vn; 00220 00221 while(v) { 00222 vn = v; 00223 v = v->next; 00224 free(vn); 00225 } 00226 }
static struct ast_category* category_get | ( | const struct ast_config * | config, | |
const char * | category_name, | |||
int | ignored | |||
) | [static] |
Definition at line 330 of file config.c.
References config, ast_category::ignored, and ast_category::name.
Referenced by ast_category_get(), and process_text_line().
00331 { 00332 struct ast_category *cat; 00333 00334 /* try exact match first, then case-insensitive match */ 00335 for (cat = config->root; cat; cat = cat->next) { 00336 if (cat->name == category_name && (ignored || !cat->ignored)) 00337 return cat; 00338 } 00339 00340 for (cat = config->root; cat; cat = cat->next) { 00341 if (!strcasecmp(cat->name, category_name) && (ignored || !cat->ignored)) 00342 return cat; 00343 } 00344 00345 return NULL; 00346 }
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 1161 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().
01162 { 01163 struct ast_config_map *map; 01164 01165 ast_mutex_lock(&config_lock); 01166 01167 while (config_maps) { 01168 map = config_maps; 01169 config_maps = config_maps->next; 01170 free(map); 01171 } 01172 01173 ast_mutex_unlock(&config_lock); 01174 }
static int config_command | ( | int | fd, | |
int | argc, | |||
char ** | argv | |||
) | [static] |
Definition at line 1501 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.
01502 { 01503 struct ast_config_engine *eng; 01504 struct ast_config_map *map; 01505 01506 ast_mutex_lock(&config_lock); 01507 01508 ast_cli(fd, "\n\n"); 01509 for (eng = config_engine_list; eng; eng = eng->next) { 01510 ast_cli(fd, "\nConfig Engine: %s\n", eng->name); 01511 for (map = config_maps; map; map = map->next) 01512 if (!strcasecmp(map->driver, eng->name)) { 01513 ast_cli(fd, "===> %s (db=%s, table=%s)\n", map->name, map->database, 01514 map->table ? map->table : map->name); 01515 } 01516 } 01517 ast_cli(fd,"\n\n"); 01518 01519 ast_mutex_unlock(&config_lock); 01520 01521 return 0; 01522 }
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 831 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, errno, f, lineno, LLB_ADD(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, MAX_NESTED_COMMENTS, option_debug, option_verbose, process_text_line(), and VERBOSE_PREFIX_2.
00832 { 00833 char fn[256]; 00834 #if defined(LOW_MEMORY) 00835 char buf[512]; 00836 #else 00837 char buf[8192]; 00838 #endif 00839 char *new_buf, *comment_p, *process_buf; 00840 FILE *f; 00841 int lineno=0; 00842 int comment = 0, nest[MAX_NESTED_COMMENTS]; 00843 struct ast_category *cat = NULL; 00844 int count = 0; 00845 struct stat statbuf; 00846 /*! Growable string buffer */ 00847 char *comment_buffer=0; /*!< this will be a comment collector.*/ 00848 int comment_buffer_size=0; /*!< the amount of storage so far alloc'd for the comment_buffer */ 00849 00850 char *lline_buffer=0; /*!< A buffer for stuff behind the ; */ 00851 int lline_buffer_size=0; 00852 00853 00854 cat = ast_config_get_current_category(cfg); 00855 00856 if (filename[0] == '/') { 00857 ast_copy_string(fn, filename, sizeof(fn)); 00858 } else { 00859 snprintf(fn, sizeof(fn), "%s/%s", (char *)ast_config_AST_CONFIG_DIR, filename); 00860 } 00861 00862 if (withcomments) { 00863 CB_INIT(&comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size); 00864 if (!lline_buffer || !comment_buffer) { 00865 ast_log(LOG_ERROR, "Failed to initialize the comment buffer!\n"); 00866 return NULL; 00867 } 00868 } 00869 #ifdef AST_INCLUDE_GLOB 00870 { 00871 int glob_ret; 00872 glob_t globbuf; 00873 globbuf.gl_offs = 0; /* initialize it to silence gcc */ 00874 #ifdef SOLARIS 00875 glob_ret = glob(fn, GLOB_NOCHECK, NULL, &globbuf); 00876 #else 00877 glob_ret = glob(fn, GLOB_NOMAGIC|GLOB_BRACE, NULL, &globbuf); 00878 #endif 00879 if (glob_ret == GLOB_NOSPACE) 00880 ast_log(LOG_WARNING, 00881 "Glob Expansion of pattern '%s' failed: Not enough memory\n", fn); 00882 else if (glob_ret == GLOB_ABORTED) 00883 ast_log(LOG_WARNING, 00884 "Glob Expansion of pattern '%s' failed: Read error\n", fn); 00885 else { 00886 /* loop over expanded files */ 00887 int i; 00888 for (i=0; i<globbuf.gl_pathc; i++) { 00889 ast_copy_string(fn, globbuf.gl_pathv[i], sizeof(fn)); 00890 #endif 00891 do { 00892 if (stat(fn, &statbuf)) 00893 continue; 00894 00895 if (!S_ISREG(statbuf.st_mode)) { 00896 ast_log(LOG_WARNING, "'%s' is not a regular file, ignoring\n", fn); 00897 continue; 00898 } 00899 if (option_verbose > 1) { 00900 ast_verbose(VERBOSE_PREFIX_2 "Parsing '%s': ", fn); 00901 fflush(stdout); 00902 } 00903 if (!(f = fopen(fn, "r"))) { 00904 if (option_debug) 00905 ast_log(LOG_DEBUG, "No file to parse: %s\n", fn); 00906 if (option_verbose > 1) 00907 ast_verbose( "Not found (%s)\n", strerror(errno)); 00908 continue; 00909 } 00910 count++; 00911 if (option_debug) 00912 ast_log(LOG_DEBUG, "Parsing %s\n", fn); 00913 if (option_verbose > 1) 00914 ast_verbose("Found\n"); 00915 while(!feof(f)) { 00916 lineno++; 00917 if (fgets(buf, sizeof(buf), f)) { 00918 if ( withcomments ) { 00919 CB_ADD(&comment_buffer, &comment_buffer_size, lline_buffer); /* add the current lline buffer to the comment buffer */ 00920 lline_buffer[0] = 0; /* erase the lline buffer */ 00921 } 00922 00923 new_buf = buf; 00924 if (comment) 00925 process_buf = NULL; 00926 else 00927 process_buf = buf; 00928 00929 while ((comment_p = strchr(new_buf, COMMENT_META))) { 00930 if ((comment_p > new_buf) && (*(comment_p-1) == '\\')) { 00931 /* Escaped semicolons aren't comments. */ 00932 new_buf = comment_p + 1; 00933 } else if(comment_p[1] == COMMENT_TAG && comment_p[2] == COMMENT_TAG && (comment_p[3] != '-')) { 00934 /* Meta-Comment start detected ";--" */ 00935 if (comment < MAX_NESTED_COMMENTS) { 00936 *comment_p = '\0'; 00937 new_buf = comment_p + 3; 00938 comment++; 00939 nest[comment-1] = lineno; 00940 } else { 00941 ast_log(LOG_ERROR, "Maximum nest limit of %d reached.\n", MAX_NESTED_COMMENTS); 00942 } 00943 } else if ((comment_p >= new_buf + 2) && 00944 (*(comment_p - 1) == COMMENT_TAG) && 00945 (*(comment_p - 2) == COMMENT_TAG)) { 00946 /* Meta-Comment end detected */ 00947 comment--; 00948 new_buf = comment_p + 1; 00949 if (!comment) { 00950 /* Back to non-comment now */ 00951 if (process_buf) { 00952 /* Actually have to move what's left over the top, then continue */ 00953 char *oldptr; 00954 oldptr = process_buf + strlen(process_buf); 00955 if ( withcomments ) { 00956 CB_ADD(&comment_buffer, &comment_buffer_size, ";"); 00957 CB_ADD_LEN(&comment_buffer, &comment_buffer_size, oldptr+1, new_buf-oldptr-1); 00958 } 00959 00960 memmove(oldptr, new_buf, strlen(new_buf) + 1); 00961 new_buf = oldptr; 00962 } else 00963 process_buf = new_buf; 00964 } 00965 } else { 00966 if (!comment) { 00967 /* If ; is found, and we are not nested in a comment, 00968 we immediately stop all comment processing */ 00969 if ( withcomments ) { 00970 LLB_ADD(&lline_buffer, &lline_buffer_size, comment_p); 00971 } 00972 *comment_p = '\0'; 00973 new_buf = comment_p; 00974 } else 00975 new_buf = comment_p + 1; 00976 } 00977 } 00978 if( withcomments && comment && !process_buf ) 00979 { 00980 CB_ADD(&comment_buffer, &comment_buffer_size, buf); /* the whole line is a comment, store it */ 00981 } 00982 00983 if (process_buf) { 00984 char *buf = ast_strip(process_buf); 00985 if (!ast_strlen_zero(buf)) { 00986 if (process_text_line(cfg, &cat, buf, lineno, fn, withcomments, &comment_buffer, &comment_buffer_size, &lline_buffer, &lline_buffer_size)) { 00987 cfg = NULL; 00988 break; 00989 } 00990 } 00991 } 00992 } 00993 } 00994 fclose(f); 00995 } while(0); 00996 if (comment) { 00997 ast_log(LOG_WARNING,"Unterminated comment detected beginning on line %d\n", nest[comment - 1]); 00998 } 00999 #ifdef AST_INCLUDE_GLOB 01000 if (!cfg) 01001 break; 01002 } 01003 globfree(&globbuf); 01004 } 01005 } 01006 #endif 01007 01008 if (cfg && cfg->include_level == 1 && withcomments && comment_buffer) { 01009 free(comment_buffer); 01010 free(lline_buffer); 01011 comment_buffer = NULL; 01012 lline_buffer = NULL; 01013 comment_buffer_size = 0; 01014 lline_buffer_size = 0; 01015 } 01016 01017 if (count == 0) 01018 return NULL; 01019 01020 return cfg; 01021 }
int config_text_file_save | ( | const char * | configfile, | |
const struct ast_config * | cfg, | |||
const char * | generator | |||
) |
Definition at line 1023 of file config.c.
References ast_config_AST_CONFIG_DIR, AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_log(), ast_verbose(), ast_comment::cmt, errno, f, ast_category::ignored, ast_category_template_instance::inst, LOG_DEBUG, ast_category::name, ast_category_template_instance::name, ast_variable::name, ast_comment::next, ast_variable::next, option_debug, option_verbose, ast_config::root, t, ast_variable::value, var, and VERBOSE_PREFIX_2.
Referenced by action_updateconfig(), vm_change_password(), and vm_forwardoptions().
01024 { 01025 FILE *f = NULL; 01026 int fd = -1; 01027 char fn[256], fntmp[256]; 01028 char date[256]=""; 01029 time_t t; 01030 struct ast_variable *var; 01031 struct ast_category *cat; 01032 struct ast_comment *cmt; 01033 struct stat s; 01034 int blanklines = 0; 01035 01036 if (configfile[0] == '/') { 01037 snprintf(fntmp, sizeof(fntmp), "%s.XXXXXX", configfile); 01038 ast_copy_string(fn, configfile, sizeof(fn)); 01039 } else { 01040 snprintf(fntmp, sizeof(fntmp), "%s/%s.XXXXXX", ast_config_AST_CONFIG_DIR, configfile); 01041 snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_CONFIG_DIR, configfile); 01042 } 01043 time(&t); 01044 ast_copy_string(date, ctime(&t), sizeof(date)); 01045 if ((fd = mkstemp(fntmp)) > 0 && (f = fdopen(fd, "w")) != NULL) { 01046 if (option_verbose > 1) 01047 ast_verbose(VERBOSE_PREFIX_2 "Saving '%s': ", fn); 01048 fprintf(f, ";!\n"); 01049 fprintf(f, ";! Automatically generated configuration file\n"); 01050 if (strcmp(configfile, fn)) 01051 fprintf(f, ";! Filename: %s (%s)\n", configfile, fn); 01052 else 01053 fprintf(f, ";! Filename: %s\n", configfile); 01054 fprintf(f, ";! Generator: %s\n", generator); 01055 fprintf(f, ";! Creation Date: %s", date); 01056 fprintf(f, ";!\n"); 01057 cat = cfg->root; 01058 while(cat) { 01059 /* Dump section with any appropriate comment */ 01060 for (cmt = cat->precomments; cmt; cmt=cmt->next) 01061 { 01062 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01063 fprintf(f,"%s", cmt->cmt); 01064 } 01065 if (!cat->precomments) 01066 fprintf(f,"\n"); 01067 fprintf(f, "[%s]", cat->name); 01068 if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) { 01069 fprintf(f, "("); 01070 if (cat->ignored) { 01071 fprintf(f, "!"); 01072 } 01073 if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) { 01074 fprintf(f, ","); 01075 } 01076 if (!AST_LIST_EMPTY(&cat->template_instances)) { 01077 struct ast_category_template_instance *x; 01078 AST_LIST_TRAVERSE(&cat->template_instances, x, next) { 01079 fprintf(f,"%s",x->name); 01080 if (x != AST_LIST_LAST(&cat->template_instances)) 01081 fprintf(f,","); 01082 } 01083 } 01084 fprintf(f, ")"); 01085 } 01086 for(cmt = cat->sameline; cmt; cmt=cmt->next) 01087 { 01088 fprintf(f,"%s", cmt->cmt); 01089 } 01090 if (!cat->sameline) 01091 fprintf(f,"\n"); 01092 var = cat->root; 01093 while(var) { 01094 struct ast_category_template_instance *x; 01095 struct ast_variable *v2; 01096 int found = 0; 01097 AST_LIST_TRAVERSE(&cat->template_instances, x, next) { 01098 01099 for (v2 = x->inst->root; v2; v2 = v2->next) { 01100 if (!strcasecmp(var->name, v2->name)) 01101 break; 01102 } 01103 if (v2 && v2->value && !strcmp(v2->value, var->value)) { 01104 found = 1; 01105 break; 01106 } 01107 } 01108 if (found) { 01109 var = var->next; 01110 continue; 01111 } 01112 for (cmt = var->precomments; cmt; cmt=cmt->next) 01113 { 01114 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01115 fprintf(f,"%s", cmt->cmt); 01116 } 01117 if (var->sameline) 01118 fprintf(f, "%s %s %s %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt); 01119 else 01120 fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value); 01121 if (var->blanklines) { 01122 blanklines = var->blanklines; 01123 while (blanklines--) 01124 fprintf(f, "\n"); 01125 } 01126 01127 var = var->next; 01128 } 01129 #if 0 01130 /* Put an empty line */ 01131 fprintf(f, "\n"); 01132 #endif 01133 cat = cat->next; 01134 } 01135 if ((option_verbose > 1) && !option_debug) 01136 ast_verbose("Saved\n"); 01137 } else { 01138 if (option_debug) 01139 ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno)); 01140 if (option_verbose > 1) 01141 ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno)); 01142 if (fd > -1) 01143 close(fd); 01144 return -1; 01145 } 01146 stat(fn, &s); 01147 fchmod(fd, s.st_mode); 01148 fclose(f); 01149 if (unlink(fn) || link(fntmp, fn)) { 01150 if (option_debug) 01151 ast_log(LOG_DEBUG, "Unable to open for writing: %s (%s)\n", fn, strerror(errno)); 01152 if (option_verbose > 1) 01153 ast_verbose(VERBOSE_PREFIX_2 "Unable to write %s (%s)", fn, strerror(errno)); 01154 unlink(fntmp); 01155 return -1; 01156 } 01157 unlink(fntmp); 01158 return 0; 01159 }
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 1321 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().
01322 { 01323 struct ast_config_engine *eng, *ret = NULL; 01324 struct ast_config_map *map; 01325 01326 ast_mutex_lock(&config_lock); 01327 01328 for (map = config_maps; map; map = map->next) { 01329 if (!strcasecmp(family, map->name)) { 01330 if (database) 01331 ast_copy_string(database, map->database, dbsiz); 01332 if (table) 01333 ast_copy_string(table, map->table ? map->table : family, tabsiz); 01334 break; 01335 } 01336 } 01337 01338 /* Check if the required driver (engine) exist */ 01339 if (map) { 01340 for (eng = config_engine_list; !ret && eng; eng = eng->next) { 01341 if (!strcasecmp(eng->name, map->driver)) 01342 ret = eng; 01343 } 01344 } 01345 01346 ast_mutex_unlock(&config_lock); 01347 01348 /* if we found a mapping, but the engine is not available, then issue a warning */ 01349 if (map && !ret) 01350 ast_log(LOG_WARNING, "Realtime mapping for '%s' found to engine '%s', but the engine is not available\n", map->name, map->driver); 01351 01352 return ret; 01353 }
static void inherit_category | ( | struct ast_category * | new, | |
const struct ast_category * | base | |||
) | [static] |
Definition at line 465 of file config.c.
References ast_calloc, AST_LIST_INSERT_TAIL, ast_variable_append(), ast_category_template_instance::inst, ast_category::name, ast_category_template_instance::name, var, and variable_clone().
Referenced by process_text_line().
00466 { 00467 struct ast_variable *var; 00468 struct ast_category_template_instance *x = ast_calloc(1,sizeof(struct ast_category_template_instance)); 00469 strcpy(x->name, base->name); 00470 x->inst = base; 00471 AST_LIST_INSERT_TAIL(&new->template_instances, x, next); 00472 for (var = base->root; var; var = var->next) 00473 ast_variable_append(new, variable_clone(var)); 00474 }
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 304 of file config.c.
References ast_variable_append(), ast_variable::next, and var.
Referenced by process_text_line().
00305 { 00306 struct ast_variable *var = old->root; 00307 old->root = NULL; 00308 #if 1 00309 /* we can just move the entire list in a single op */ 00310 ast_variable_append(new, var); 00311 #else 00312 while (var) { 00313 struct ast_variable *next = var->next; 00314 var->next = NULL; 00315 ast_variable_append(new, var); 00316 var = next; 00317 } 00318 #endif 00319 }
static struct ast_category* next_available_category | ( | struct ast_category * | cat | ) | [static] |
Definition at line 402 of file config.c.
References ast_category::ignored.
Referenced by ast_category_browse().
00403 { 00404 for (; cat && cat->ignored; cat = cat->next); 00405 00406 return cat; 00407 }
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 643 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_ERROR, LOG_WARNING, move_variables(), ast_variable::object, ast_variable::precomments, ast_variable::sameline, and strsep().
Referenced by config_text_file_load().
00645 { 00646 char *c; 00647 char *cur = buf; 00648 struct ast_variable *v; 00649 char cmd[512], exec_file[512]; 00650 int object, do_exec, do_include; 00651 00652 /* Actually parse the entry */ 00653 if (cur[0] == '[') { 00654 struct ast_category *newcat = NULL; 00655 char *catname; 00656 00657 /* A category header */ 00658 c = strchr(cur, ']'); 00659 if (!c) { 00660 ast_log(LOG_WARNING, "parse error: no closing ']', line %d of %s\n", lineno, configfile); 00661 return -1; 00662 } 00663 *c++ = '\0'; 00664 cur++; 00665 if (*c++ != '(') 00666 c = NULL; 00667 catname = cur; 00668 if (!(*cat = newcat = ast_category_new(catname))) { 00669 return -1; 00670 } 00671 /* add comments */ 00672 if (withcomments && *comment_buffer && (*comment_buffer)[0] ) { 00673 newcat->precomments = ALLOC_COMMENT(*comment_buffer); 00674 } 00675 if (withcomments && *lline_buffer && (*lline_buffer)[0] ) { 00676 newcat->sameline = ALLOC_COMMENT(*lline_buffer); 00677 } 00678 if( withcomments ) 00679 CB_RESET(comment_buffer, lline_buffer); 00680 00681 /* If there are options or categories to inherit from, process them now */ 00682 if (c) { 00683 if (!(cur = strchr(c, ')'))) { 00684 ast_log(LOG_WARNING, "parse error: no closing ')', line %d of %s\n", lineno, configfile); 00685 return -1; 00686 } 00687 *cur = '\0'; 00688 while ((cur = strsep(&c, ","))) { 00689 if (!strcasecmp(cur, "!")) { 00690 (*cat)->ignored = 1; 00691 } else if (!strcasecmp(cur, "+")) { 00692 *cat = category_get(cfg, catname, 1); 00693 if (!(*cat)) { 00694 if (newcat) 00695 ast_category_destroy(newcat); 00696 ast_log(LOG_WARNING, "Category addition requested, but category '%s' does not exist, line %d of %s\n", catname, lineno, configfile); 00697 return -1; 00698 } 00699 if (newcat) { 00700 move_variables(newcat, *cat); 00701 ast_category_destroy(newcat); 00702 newcat = NULL; 00703 } 00704 } else { 00705 struct ast_category *base; 00706 00707 base = category_get(cfg, cur, 1); 00708 if (!base) { 00709 ast_log(LOG_WARNING, "Inheritance requested, but category '%s' does not exist, line %d of %s\n", cur, lineno, configfile); 00710 return -1; 00711 } 00712 inherit_category(*cat, base); 00713 } 00714 } 00715 } 00716 if (newcat) 00717 ast_category_append(cfg, *cat); 00718 } else if (cur[0] == '#') { 00719 /* A directive */ 00720 cur++; 00721 c = cur; 00722 while(*c && (*c > 32)) c++; 00723 if (*c) { 00724 *c = '\0'; 00725 /* Find real argument */ 00726 c = ast_skip_blanks(c + 1); 00727 if (!(*c)) 00728 c = NULL; 00729 } else 00730 c = NULL; 00731 do_include = !strcasecmp(cur, "include"); 00732 if(!do_include) 00733 do_exec = !strcasecmp(cur, "exec"); 00734 else 00735 do_exec = 0; 00736 if (do_exec && !ast_opt_exec_includes) { 00737 ast_log(LOG_WARNING, "Cannot perform #exec unless execincludes option is enabled in asterisk.conf (options section)!\n"); 00738 do_exec = 0; 00739 } 00740 if (do_include || do_exec) { 00741 if (c) { 00742 /* Strip off leading and trailing "'s and <>'s */ 00743 while((*c == '<') || (*c == '>') || (*c == '\"')) c++; 00744 /* Get rid of leading mess */ 00745 cur = c; 00746 while (!ast_strlen_zero(cur)) { 00747 c = cur + strlen(cur) - 1; 00748 if ((*c == '>') || (*c == '<') || (*c == '\"')) 00749 *c = '\0'; 00750 else 00751 break; 00752 } 00753 /* #exec </path/to/executable> 00754 We create a tmp file, then we #include it, then we delete it. */ 00755 if (do_exec) { 00756 snprintf(exec_file, sizeof(exec_file), "/var/tmp/exec.%d.%ld", (int)time(NULL), (long)pthread_self()); 00757 snprintf(cmd, sizeof(cmd), "%s > %s 2>&1", cur, exec_file); 00758 ast_safe_system(cmd); 00759 cur = exec_file; 00760 } else 00761 exec_file[0] = '\0'; 00762 /* A #include */ 00763 do_include = ast_config_internal_load(cur, cfg, withcomments) ? 1 : 0; 00764 if(!ast_strlen_zero(exec_file)) 00765 unlink(exec_file); 00766 if (!do_include) { 00767 ast_log(LOG_ERROR, "*********************************************************\n"); 00768 ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n"); 00769 ast_log(LOG_ERROR, "Future versions of Asterisk will treat a #include of a " 00770 "file that does not exist as an error, and will fail to " 00771 "load that configuration file. Please ensure that the " 00772 "file '%s' exists, even if it is empty.\n", cur); 00773 ast_log(LOG_ERROR, "*********** YOU SHOULD REALLY READ THIS ERROR ***********\n"); 00774 ast_log(LOG_ERROR, "*********************************************************\n"); 00775 return 0; 00776 } 00777 00778 } else { 00779 ast_log(LOG_WARNING, "Directive '#%s' needs an argument (%s) at line %d of %s\n", 00780 do_exec ? "exec" : "include", 00781 do_exec ? "/path/to/executable" : "filename", 00782 lineno, 00783 configfile); 00784 } 00785 } 00786 else 00787 ast_log(LOG_WARNING, "Unknown directive '%s' at line %d of %s\n", cur, lineno, configfile); 00788 } else { 00789 /* Just a line (variable = value) */ 00790 if (!(*cat)) { 00791 ast_log(LOG_WARNING, 00792 "parse error: No category context for line %d of %s\n", lineno, configfile); 00793 return -1; 00794 } 00795 c = strchr(cur, '='); 00796 if (c) { 00797 *c = 0; 00798 c++; 00799 /* Ignore > in => */ 00800 if (*c== '>') { 00801 object = 1; 00802 c++; 00803 } else 00804 object = 0; 00805 if ((v = ast_variable_new(ast_strip(cur), ast_strip(c)))) { 00806 v->lineno = lineno; 00807 v->object = object; 00808 /* Put and reset comments */ 00809 v->blanklines = 0; 00810 ast_variable_append(*cat, v); 00811 /* add comments */ 00812 if (withcomments && *comment_buffer && (*comment_buffer)[0] ) { 00813 v->precomments = ALLOC_COMMENT(*comment_buffer); 00814 } 00815 if (withcomments && *lline_buffer && (*lline_buffer)[0] ) { 00816 v->sameline = ALLOC_COMMENT(*lline_buffer); 00817 } 00818 if( withcomments ) 00819 CB_RESET(comment_buffer, lline_buffer); 00820 00821 } else { 00822 return -1; 00823 } 00824 } else { 00825 ast_log(LOG_WARNING, "No '=' (equal sign) in line %d of %s\n", lineno, configfile); 00826 } 00827 } 00828 return 0; 00829 }
int read_config_maps | ( | void | ) |
Definition at line 1211 of file config.c.
References append_mapping(), ast_config_destroy(), ast_config_internal_load(), ast_config_new(), ast_log(), ast_variable_browse(), clear_config_maps(), config, LOG_WARNING, ast_config::max_include_level, ast_variable::name, ast_variable::next, strsep(), table, and ast_variable::value.
Referenced by main().
01212 { 01213 struct ast_config *config, *configtmp; 01214 struct ast_variable *v; 01215 char *driver, *table, *database, *stringp, *tmp; 01216 01217 clear_config_maps(); 01218 01219 configtmp = ast_config_new(); 01220 configtmp->max_include_level = 1; 01221 config = ast_config_internal_load(extconfig_conf, configtmp, 0); 01222 if (!config) { 01223 ast_config_destroy(configtmp); 01224 return 0; 01225 } 01226 01227 for (v = ast_variable_browse(config, "settings"); v; v = v->next) { 01228 stringp = v->value; 01229 driver = strsep(&stringp, ","); 01230 01231 if ((tmp = strchr(stringp, '\"'))) 01232 stringp = tmp; 01233 01234 /* check if the database text starts with a double quote */ 01235 if (*stringp == '"') { 01236 stringp++; 01237 database = strsep(&stringp, "\""); 01238 strsep(&stringp, ","); 01239 } else { 01240 /* apparently this text has no quotes */ 01241 database = strsep(&stringp, ","); 01242 } 01243 01244 table = strsep(&stringp, ","); 01245 01246 if (!strcmp(v->name, extconfig_conf)) { 01247 ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf); 01248 continue; 01249 } 01250 01251 if (!strcmp(v->name, "asterisk.conf")) { 01252 ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n"); 01253 continue; 01254 } 01255 01256 if (!strcmp(v->name, "logger.conf")) { 01257 ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n"); 01258 continue; 01259 } 01260 01261 if (!driver || !database) 01262 continue; 01263 if (!strcasecmp(v->name, "sipfriends")) { 01264 ast_log(LOG_WARNING, "The 'sipfriends' table is obsolete, update your config to use sipusers and sippeers, though they can point to the same table.\n"); 01265 append_mapping("sipusers", driver, database, table ? table : "sipfriends"); 01266 append_mapping("sippeers", driver, database, table ? table : "sipfriends"); 01267 } else if (!strcasecmp(v->name, "iaxfriends")) { 01268 ast_log(LOG_WARNING, "The 'iaxfriends' table is obsolete, update your config to use iaxusers and iaxpeers, though they can point to the same table.\n"); 01269 append_mapping("iaxusers", driver, database, table ? table : "iaxfriends"); 01270 append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends"); 01271 } else 01272 append_mapping(v->name, driver, database, table); 01273 } 01274 01275 ast_config_destroy(config); 01276 return 0; 01277 }
int register_config_cli | ( | void | ) |
Definition at line 1539 of file config.c.
References ast_cli_register_multiple(), and cli_config.
Referenced by main().
01540 { 01541 ast_cli_register_multiple(cli_config, sizeof(cli_config) / sizeof(struct ast_cli_entry)); 01542 return 0; 01543 }
static struct ast_variable* variable_clone | ( | const struct ast_variable * | old | ) | [static] |
Definition at line 290 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().
00291 { 00292 struct ast_variable *new = ast_variable_new(old->name, old->value); 00293 00294 if (new) { 00295 new->lineno = old->lineno; 00296 new->object = old->object; 00297 new->blanklines = old->blanklines; 00298 /* TODO: clone comments? */ 00299 } 00300 00301 return new; 00302 }
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 1533 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(), ast_realtime_enabled(), clear_config_maps(), config_command(), and find_engine().
char* extconfig_conf = "extconfig.conf" [static] |
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 1355 of file config.c.
Referenced by ast_config_internal_load().