#include "asterisk/utils.h"
#include "asterisk/inline_api.h"

Go to the source code of this file.
Data Structures | |
| struct | ast_config_engine |
| Configuration engine structure, used to define realtime drivers. More... | |
| struct | ast_variable |
| Structure for variables, used for configurations and for channel variables. More... | |
Defines | |
| #define | ast_config_load(filename, flags) ast_config_load2(filename, AST_MODULE, flags) |
| #define | CONFIG_STATUS_FILEINVALID (void *)-2 |
| #define | CONFIG_STATUS_FILEMISSING (void *)0 |
| #define | CONFIG_STATUS_FILEUNCHANGED (void *)-1 |
| #define | CV_BOOL(__x, __dst) CV_F(__x, (__dst) = ast_true(__val) ) |
| helper macros to assign the value to a BOOL, UINT, static string and dynamic string | |
| #define | CV_DSTR(__x, __dst) CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val)) |
| #define | CV_END } while (0) |
| close a variable parsing block | |
| #define | CV_F(__pattern, __body) if (!strcasecmp((__var), __pattern)) { __body; break; } |
| call a generic function if the name matches. | |
| #define | CV_START(__in_var, __in_val) |
| the macro to open a block for variable parsing | |
| #define | CV_STR(__x, __dst) CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst))) |
| #define | CV_STRFIELD(__x, __obj, __field) CV_F(__x, ast_string_field_set(__obj, __field, __val)) |
| #define | CV_UINT(__x, __dst) CV_F(__x, (__dst) = strtoul(__val, NULL, 0) ) |
Typedefs | |
| typedef struct ast_config * | config_load_func (const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked) |
| typedef int | realtime_destroy (const char *database, const char *table, const char *keyfield, const char *entity, va_list ap) |
| typedef struct ast_config * | realtime_multi_get (const char *database, const char *table, va_list ap) |
| typedef int | realtime_require (const char *database, const char *table, va_list ap) |
| Function pointer called to ensure database schema is properly configured for realtime use. | |
| typedef int | realtime_store (const char *database, const char *table, va_list ap) |
| typedef int | realtime_unload (const char *database, const char *table) |
| Function pointer called to clear the database cache and free resources used for such. | |
| typedef int | realtime_update (const char *database, const char *table, const char *keyfield, const char *entity, va_list ap) |
| typedef int | realtime_update2 (const char *database, const char *table, va_list ap) |
| typedef struct ast_variable * | realtime_var_get (const char *database, const char *table, va_list ap) |
Enumerations | |
| enum | { CONFIG_FLAG_WITHCOMMENTS = (1 << 0), CONFIG_FLAG_FILEUNCHANGED = (1 << 1), CONFIG_FLAG_NOCACHE = (1 << 2) } |
| enum | ast_parse_flags { PARSE_TYPE = 0x000f, PARSE_INT32 = 0x0001, PARSE_UINT32 = 0x0002, PARSE_DOUBLE = 0x0003, PARSE_INADDR = 0x000f, PARSE_DEFAULT = 0x0010, PARSE_IN_RANGE = 0x0020, PARSE_OUT_RANGE = 0x0040, PARSE_PORT_MASK = 0x0300, PARSE_PORT_IGNORE = 0x0100, PARSE_PORT_REQUIRE = 0x0200, PARSE_PORT_FORBID = 0x0300 } |
| Support code to parse config file arguments. More... | |
| enum | require_type { RQ_INTEGER1, RQ_UINTEGER1, RQ_INTEGER2, RQ_UINTEGER2, RQ_INTEGER3, RQ_UINTEGER3, RQ_INTEGER4, RQ_UINTEGER4, RQ_INTEGER8, RQ_UINTEGER8, RQ_CHAR, RQ_FLOAT, RQ_DATE, RQ_DATETIME } |
| Types used in ast_realtime_require_field. More... | |
Functions | |
| void | ast_category_append (struct ast_config *config, struct ast_category *cat) |
| char * | ast_category_browse (struct ast_config *config, const char *prev) |
| Goes through categories. | |
| int | ast_category_delete (struct ast_config *cfg, const char *category) |
| void | ast_category_destroy (struct ast_category *cat) |
| struct ast_variable * | ast_category_detach_variables (struct ast_category *cat) |
| int | ast_category_empty (struct ast_config *cfg, const char *category) |
| Removes and destroys all variables within a category. | |
| int | ast_category_exist (const struct ast_config *config, const char *category_name) |
| Check for category duplicates. | |
| struct ast_variable * | ast_category_first (struct ast_category *cat) |
| given a pointer to a category, return the root variable. This is equivalent to ast_variable_browse(), but more efficient if we already have the struct ast_category * (e.g. from ast_category_get()) | |
| struct ast_category * | ast_category_get (const struct ast_config *config, const char *category_name) |
| Retrieve a category if it exists. | |
| void | ast_category_insert (struct ast_config *config, struct ast_category *cat, const char *match) |
| Inserts new category. | |
| struct ast_category * | ast_category_new (const char *name, const char *in_file, int lineno) |
| Create a category structure. | |
| void | ast_category_rename (struct ast_category *cat, const char *name) |
| struct 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. | |
| void | ast_config_destroy (struct ast_config *config) |
| Destroys a config. | |
| int | ast_config_engine_deregister (struct ast_config_engine *del) |
| Deregister config engine. | |
| int | ast_config_engine_register (struct ast_config_engine *newconfig) |
| Register config engine. | |
| struct ast_category * | ast_config_get_current_category (const struct ast_config *cfg) |
| Retrieve the current category name being built. API for backend configuration engines while building a configuration set. | |
| struct ast_config * | ast_config_internal_load (const char *configfile, struct ast_config *cfg, struct ast_flags flags, const char *suggested_incl_file, const char *who_asked) |
| struct ast_config * | ast_config_load2 (const char *filename, const char *who_asked, struct ast_flags flags) |
| Load a config file. | |
| struct ast_config * | ast_config_new (void) |
| Create a new base configuration structure. | |
| const char * | ast_config_option (struct ast_config *cfg, const char *cat, const char *var) |
Retrieve a configuration variable within the configuration set. Retrieves the named variable var within category cat of configuration set cfg. If not found, attempts to retrieve the named variable var from within category general. | |
| void | ast_config_set_current_category (struct ast_config *cfg, const struct ast_category *cat) |
| Set the category within the configuration as being current. API for backend configuration engines while building a configuration set. | |
| int | ast_config_text_file_save (const char *filename, const struct ast_config *cfg, const char *generator) |
| int | ast_destroy_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel |
| Destroy realtime configuration. | |
| struct ast_config_include * | ast_include_find (struct ast_config *conf, const char *included_file) |
| struct ast_config_include * | ast_include_new (struct ast_config *conf, const char *from_file, const char *included_file, int is_exec, const char *exec_file, int from_lineno, char *real_included_file_name, int real_included_file_name_size) |
| void | ast_include_rename (struct ast_config *conf, const char *from_file, const char *to_file) |
| struct ast_variable * | ast_load_realtime (const char *family,...) attribute_sentinel |
| Retrieve realtime configuration. | |
| struct ast_variable * | ast_load_realtime_all (const char *family,...) attribute_sentinel |
| struct ast_config * | ast_load_realtime_multientry (const char *family,...) attribute_sentinel |
| Retrieve realtime configuration. | |
| int | ast_parse_arg (const char *arg, enum ast_parse_flags flags, void *result,...) |
| The argument parsing routine. | |
| int | ast_realtime_enabled (void) |
| Check if there's any realtime engines loaded. | |
| int | ast_realtime_require_field (const char *family,...) attribute_sentinel |
| Inform realtime what fields that may be stored. | |
| int | ast_rq_is_int (require_type type) |
| Check if require type is an integer type. | |
| int | ast_store_realtime (const char *family,...) attribute_sentinel |
| Create realtime configuration. | |
| int | ast_unload_realtime (const char *family) |
| Release any resources cached for a realtime family. | |
| int | ast_update2_realtime (const char *family,...) attribute_sentinel |
| Update realtime configuration. | |
| int | ast_update_realtime (const char *family, const char *keyfield, const char *lookup,...) attribute_sentinel |
| Update realtime configuration. | |
| void | ast_variable_append (struct ast_category *category, struct ast_variable *variable) |
| 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. | |
| int | ast_variable_delete (struct ast_category *category, const char *variable, const char *match, const char *line) |
| void | ast_variable_insert (struct ast_category *category, struct ast_variable *variable, const char *line) |
| struct ast_variable * | ast_variable_new (const char *name, const char *value, const char *filename) |
| 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) |
| Update variable value within a config. | |
| void | ast_variables_destroy (struct ast_variable *var) |
| Free variable list. | |
| int | config_text_file_save (const char *filename, const struct ast_config *cfg, const char *generator) |
| int | read_config_maps (void) |
| Exposed re-initialization method for core process This method is intended for use only with the core re-initialization and is not designed to be called from any user applications. | |
| int | register_config_cli (void) |
| Exposed initialization method for core process This method is intended for use only with the core initialization and is not designed to be called from any user applications. | |
Definition in file config.h.
| #define ast_config_load | ( | filename, | |||
| flags | ) | ast_config_load2(filename, AST_MODULE, flags) |
Definition at line 139 of file config.h.
Referenced by adsi_load(), advanced_options(), aji_load_config(), conf_exec(), config_function_read(), config_load(), config_module(), directory_exec(), festival_exec(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), jingle_load_config(), load_config(), load_config_meetme(), load_module(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), read_agent_config(), read_password_from_file(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), vm_change_password(), and vm_forwardoptions().
| #define CONFIG_STATUS_FILEINVALID (void *)-2 |
Definition at line 50 of file config.h.
Referenced by __ast_http_load(), __ast_http_post_load(), __ast_udptl_reload(), __init_manager(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_config_internal_load(), ast_config_load2(), ast_readconfig(), conf_exec(), config_function_read(), config_load(), config_module(), config_text_file_load(), directory_exec(), do_reload(), festival_exec(), find_conf(), gtalk_load_config(), iax_provision_reload(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_indications(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), play_message(), private_enum_init(), read_agent_config(), realtime_directory(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), rtp_reload(), run_startup_commands(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), vm_change_password(), and vm_forwardoptions().
| #define CONFIG_STATUS_FILEMISSING (void *)0 |
Definition at line 48 of file config.h.
Referenced by __ast_http_load(), __ast_http_post_load(), __ast_udptl_reload(), _dsp_init(), action_getconfig(), adsi_load(), aji_load_config(), ast_readconfig(), do_reload(), load_config(), load_indications(), load_modules(), load_moh_classes(), load_odbc_config(), parse_config(), private_enum_init(), rtp_reload(), and run_startup_commands().
| #define CONFIG_STATUS_FILEUNCHANGED (void *)-1 |
Definition at line 49 of file config.h.
Referenced by __ast_http_load(), __ast_http_post_load(), __ast_udptl_reload(), __init_manager(), _dsp_init(), adsi_load(), aji_load_config(), ast_cli_perms_init(), ast_config_internal_load(), ast_config_load2(), ast_readconfig(), config_function_read(), config_module(), config_text_file_load(), do_reload(), iax_provision_reload(), load_config(), load_indications(), load_moh_classes(), misdn_cfg_init(), odbc_load_module(), osp_load(), parse_config(), private_enum_init(), read_agent_config(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rtp_reload(), run_startup_commands(), set_config(), setup_dahdi(), sla_load_config(), smdi_load(), and tds_load_module().
| #define CV_BOOL | ( | __x, | |||
| __dst | ) | CV_F(__x, (__dst) = ast_true(__val) ) |
helper macros to assign the value to a BOOL, UINT, static string and dynamic string
Definition at line 581 of file config.h.
Referenced by store_config_core().
| #define CV_DSTR | ( | __x, | |||
| __dst | ) | CV_F(__x, if (__dst) ast_free(__dst); __dst = ast_strdup(__val)) |
| #define CV_END } while (0) |
close a variable parsing block
Definition at line 573 of file config.h.
Referenced by store_config_core(), and store_config_tone_zone().
| #define CV_F | ( | __pattern, | |||
| __body | ) | if (!strcasecmp((__var), __pattern)) { __body; break; } |
call a generic function if the name matches.
Definition at line 576 of file config.h.
Referenced by store_config_core(), and store_config_tone_zone().
| #define CV_START | ( | __in_var, | |||
| __in_val | ) |
Value:
do { \ const char *__var = __in_var; \ const char *__val = __in_val;
Definition at line 567 of file config.h.
Referenced by store_config_core(), and store_config_tone_zone().
| #define CV_STR | ( | __x, | |||
| __dst | ) | CV_F(__x, ast_copy_string(__dst, __val, sizeof(__dst))) |
Definition at line 583 of file config.h.
Referenced by store_config_core(), and store_config_tone_zone().
| #define CV_STRFIELD | ( | __x, | |||
| __obj, | |||||
| __field | ) | CV_F(__x, ast_string_field_set(__obj, __field, __val)) |
| #define CV_UINT | ( | __x, | |||
| __dst | ) | CV_F(__x, (__dst) = strtoul(__val, NULL, 0) ) |
| typedef struct ast_config* config_load_func(const char *database, const char *table, const char *configfile, struct ast_config *config, struct ast_flags flags, const char *suggested_include_file, const char *who_asked) |
| typedef int realtime_destroy(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap) |
| typedef struct ast_config* realtime_multi_get(const char *database, const char *table, va_list ap) |
| typedef int realtime_require(const char *database, const char *table, va_list ap) |
| typedef int realtime_store(const char *database, const char *table, va_list ap) |
| typedef int realtime_unload(const char *database, const char *table) |
| typedef int realtime_update(const char *database, const char *table, const char *keyfield, const char *entity, va_list ap) |
| typedef int realtime_update2(const char *database, const char *table, va_list ap) |
| typedef struct ast_variable* realtime_var_get(const char *database, const char *table, va_list ap) |
| anonymous enum |
Options for ast_config_load()
Definition at line 39 of file config.h.
00039 { 00040 /*! Load the configuration, including comments */ 00041 CONFIG_FLAG_WITHCOMMENTS = (1 << 0), 00042 /*! On a reload, give us a -1 if the file hasn't changed. */ 00043 CONFIG_FLAG_FILEUNCHANGED = (1 << 1), 00044 /*! Don't attempt to cache mtime on this config file. */ 00045 CONFIG_FLAG_NOCACHE = (1 << 2), 00046 };
| enum ast_parse_flags |
Support code to parse config file arguments.
The function ast_parse_arg() provides a generic interface to parse strings (e.g. numbers, network addresses and so on) in a flexible way, e.g. by doing proper error and bound checks, provide default values, and so on. The function (described later) takes a string as an argument, a set of flags to specify the result format and checks to perform, a pointer to the result, and optionally some additional arguments. It returns 0 on success, != 0 otherwise.
| PARSE_TYPE | |
| PARSE_INT32 | |
| PARSE_UINT32 | |
| PARSE_DOUBLE | |
| PARSE_INADDR | |
| PARSE_DEFAULT | |
| PARSE_IN_RANGE | |
| PARSE_OUT_RANGE | |
| PARSE_PORT_MASK | |
| PARSE_PORT_IGNORE | |
| PARSE_PORT_REQUIRE | |
| PARSE_PORT_FORBID |
Definition at line 472 of file config.h.
00472 { 00473 /* low 4 bits of flags are used for the operand type */ 00474 PARSE_TYPE = 0x000f, 00475 /* numeric types, with optional default value and bound checks. 00476 * Additional arguments are passed by value. 00477 */ 00478 PARSE_INT32 = 0x0001, 00479 PARSE_UINT32 = 0x0002, 00480 PARSE_DOUBLE = 0x0003, 00481 #if 0 /* not supported yet */ 00482 PARSE_INT16 = 0x0004, 00483 PARSE_UINT16 = 0x0005, 00484 #endif 00485 /* Returns a struct sockaddr_in, with optional default value 00486 * (passed by reference) and port handling (accept, ignore, 00487 * require, forbid). The format is 'host.name[:port]' 00488 */ 00489 PARSE_INADDR = 0x000f, 00490 00491 /* Other data types can be added as needed */ 00492 00493 /* If PARSE_DEFAULT is set, next argument is a default value 00494 * which is returned in case of error. The argument is passed 00495 * by value in case of numeric types, by reference in other cases. 00496 */ 00497 PARSE_DEFAULT = 0x0010, /* assign default on error */ 00498 00499 /* Request a range check, applicable to numbers. Two additional 00500 * arguments are passed by value, specifying the low-high end of 00501 * the range (inclusive). An error is returned if the value 00502 * is outside or inside the range, respectively. 00503 */ 00504 PARSE_IN_RANGE = 0x0020, /* accept values inside a range */ 00505 PARSE_OUT_RANGE = 0x0040, /* accept values outside a range */ 00506 00507 /* Port handling, for sockaddr_in. accept/ignore/require/forbid 00508 * port number after the hostname or address. 00509 */ 00510 PARSE_PORT_MASK = 0x0300, /* 0x000: accept port if present */ 00511 PARSE_PORT_IGNORE = 0x0100, /* 0x100: ignore port if present */ 00512 PARSE_PORT_REQUIRE = 0x0200, /* 0x200: require port number */ 00513 PARSE_PORT_FORBID = 0x0300, /* 0x100: forbid port number */ 00514 };
| enum require_type |
Types used in ast_realtime_require_field.
| RQ_INTEGER1 | |
| RQ_UINTEGER1 | |
| RQ_INTEGER2 | |
| RQ_UINTEGER2 | |
| RQ_INTEGER3 | |
| RQ_UINTEGER3 | |
| RQ_INTEGER4 | |
| RQ_UINTEGER4 | |
| RQ_INTEGER8 | |
| RQ_UINTEGER8 | |
| RQ_CHAR | |
| RQ_FLOAT | |
| RQ_DATE | |
| RQ_DATETIME |
Definition at line 55 of file config.h.
00055 { 00056 RQ_INTEGER1, 00057 RQ_UINTEGER1, 00058 RQ_INTEGER2, 00059 RQ_UINTEGER2, 00060 RQ_INTEGER3, 00061 RQ_UINTEGER3, 00062 RQ_INTEGER4, 00063 RQ_UINTEGER4, 00064 RQ_INTEGER8, 00065 RQ_UINTEGER8, 00066 RQ_CHAR, 00067 RQ_FLOAT, 00068 RQ_DATE, 00069 RQ_DATETIME, 00070 } require_type;
| void ast_category_append | ( | struct ast_config * | config, | |
| struct ast_category * | cat | |||
| ) |
Definition at line 507 of file config.c.
References ast_config::current, ast_config::include_level, ast_category::include_level, ast_config::last, ast_category::next, and ast_config::root.
Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_odbc(), realtime_multi_pgsql(), and write_password_to_file().
00508 { 00509 if (config->last) 00510 config->last->next = category; 00511 else 00512 config->root = category; 00513 category->include_level = config->include_level; 00514 config->last = category; 00515 config->current = category; 00516 }
| 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 function is kind of non-intuitive in it's use. To begin, one passes NULL as the second argument. 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. |
| a | category on success | |
| NULL | on failure/no-more-categories |
Definition at line 617 of file config.c.
References ast_config::last_browse, ast_category::name, ast_category::next, next_available_category(), and ast_config::root.
Referenced by __init_manager(), __queues_show(), action_getconfig(), action_getconfigjson(), action_listcategories(), aji_load_config(), ast_cli_perms_init(), complete_sipnotify(), config_load(), find_queue_by_name_rt(), find_realtime(), get_insecure_variable_from_config(), gtalk_load_config(), iax_provision_reload(), jingle_load_config(), load_config(), load_indications(), load_module(), load_moh_classes(), load_odbc_config(), load_tech_calendars(), misdn_cfg_init(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), read_agent_config(), realtime_directory(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), search_directory(), search_directory_sub(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), update_realtime_members(), and vm_change_password().
00618 { 00619 struct ast_category *cat = NULL; 00620 00621 if (prev && config->last_browse && (config->last_browse->name == prev)) 00622 cat = config->last_browse->next; 00623 else if (!prev && config->root) 00624 cat = config->root; 00625 else if (prev) { 00626 for (cat = config->root; cat; cat = cat->next) { 00627 if (cat->name == prev) { 00628 cat = cat->next; 00629 break; 00630 } 00631 } 00632 if (!cat) { 00633 for (cat = config->root; cat; cat = cat->next) { 00634 if (!strcasecmp(cat->name, prev)) { 00635 cat = cat->next; 00636 break; 00637 } 00638 } 00639 } 00640 } 00641 00642 if (cat) 00643 cat = next_available_category(cat); 00644 00645 config->last_browse = cat; 00646 return (cat) ? cat->name : NULL; 00647 }
| int ast_category_delete | ( | struct ast_config * | cfg, | |
| const char * | category | |||
| ) |
Definition at line 778 of file config.c.
References ast_category_destroy(), ast_config::last, ast_category::next, and ast_config::root.
Referenced by handle_updates().
00779 { 00780 struct ast_category *prev=NULL, *cat; 00781 00782 cat = cfg->root; 00783 while (cat) { 00784 if (cat->name == category) { 00785 if (prev) { 00786 prev->next = cat->next; 00787 if (cat == cfg->last) 00788 cfg->last = prev; 00789 } else { 00790 cfg->root = cat->next; 00791 if (cat == cfg->last) 00792 cfg->last = NULL; 00793 } 00794 ast_category_destroy(cat); 00795 return 0; 00796 } 00797 prev = cat; 00798 cat = cat->next; 00799 } 00800 00801 prev = NULL; 00802 cat = cfg->root; 00803 while (cat) { 00804 if (!strcasecmp(cat->name, category)) { 00805 if (prev) { 00806 prev->next = cat->next; 00807 if (cat == cfg->last) 00808 cfg->last = prev; 00809 } else { 00810 cfg->root = cat->next; 00811 if (cat == cfg->last) 00812 cfg->last = NULL; 00813 } 00814 ast_category_destroy(cat); 00815 return 0; 00816 } 00817 prev = cat; 00818 cat = cat->next; 00819 } 00820 return -1; 00821 }
| void ast_category_destroy | ( | struct ast_category * | cat | ) |
Definition at line 567 of file config.c.
References ast_destroy_comments(), ast_destroy_template_list(), ast_free, ast_variables_destroy(), ast_category::file, free, and ast_category::root.
Referenced by add_cfg_entry(), ast_category_delete(), ast_config_destroy(), process_text_line(), and realtime_multi_odbc().
00568 { 00569 ast_variables_destroy(cat->root); 00570 if (cat->file) { 00571 free(cat->file); 00572 cat->file = 0; 00573 } 00574 ast_destroy_comments(cat); 00575 ast_destroy_template_list(cat); 00576 ast_free(cat); 00577 }
| struct ast_variable* ast_category_detach_variables | ( | struct ast_category * | cat | ) | [read] |
Definition at line 649 of file config.c.
References ast_category::last, and ast_category::root.
Referenced by realtime_switch_common().
00650 { 00651 struct ast_variable *v; 00652 00653 v = cat->root; 00654 cat->root = NULL; 00655 cat->last = NULL; 00656 00657 return v; 00658 }
| int ast_category_empty | ( | struct ast_config * | cfg, | |
| const char * | category | |||
| ) |
Removes and destroys all variables within a category.
| 0 | if the category was found and emptied | |
| -1 | if the category was not found |
Definition at line 823 of file config.c.
References ast_variables_destroy(), ast_category::last, ast_category::name, ast_category::next, ast_category::root, and ast_config::root.
Referenced by handle_updates().
00824 { 00825 struct ast_category *cat; 00826 00827 for (cat = cfg->root; cat; cat = cat->next) { 00828 if (!strcasecmp(cat->name, category)) 00829 continue; 00830 ast_variables_destroy(cat->root); 00831 cat->root = NULL; 00832 cat->last = NULL; 00833 return 0; 00834 } 00835 00836 return -1; 00837 }
| 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 502 of file config.c.
References ast_category_get().
00503 { 00504 return !!ast_category_get(config, category_name); 00505 }
| struct ast_variable* ast_category_first | ( | struct ast_category * | cat | ) | [read] |
given a pointer to a category, return the root variable. This is equivalent to ast_variable_browse(), but more efficient if we already have the struct ast_category * (e.g. from ast_category_get())
return the first var of a category
Definition at line 603 of file config.c.
References ast_category::root.
Referenced by process_text_line().
00604 { 00605 return (cat) ? cat->root : NULL; 00606 }
| struct ast_category* ast_category_get | ( | const struct ast_config * | config, | |
| const char * | category_name | |||
| ) | [read] |
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. |
| pointer | to category if found | |
| NULL | if not. |
Definition at line 497 of file config.c.
References category_get().
Referenced by ast_category_exist(), ast_category_root(), ast_variable_browse(), handle_updates(), realtime_directory(), realtime_switch_common(), vm_change_password(), and vm_forwardoptions().
00498 { 00499 return category_get(config, category_name, 0); 00500 }
| void ast_category_insert | ( | struct ast_config * | config, | |
| struct ast_category * | cat, | |||
| const char * | match | |||
| ) |
Inserts new category.
| config | which config to use | |
| cat | newly created category to insert | |
| match | which category to insert above This function is used to insert a new category above another category matching the match parameter. |
Definition at line 518 of file config.c.
References ast_category::name, ast_category::next, and ast_config::root.
Referenced by handle_updates().
00519 { 00520 struct ast_category *cur_category; 00521 00522 if (!cat || !match) 00523 return; 00524 if (!strcasecmp(config->root->name, match)) { 00525 cat->next = config->root; 00526 config->root = cat; 00527 return; 00528 } 00529 for (cur_category = config->root; cur_category; cur_category = cur_category->next) { 00530 if (!strcasecmp(cur_category->next->name, match)) { 00531 cat->next = cur_category->next; 00532 cur_category->next = cat; 00533 break; 00534 } 00535 } 00536 }
| struct ast_category* ast_category_new | ( | const char * | name, | |
| const char * | in_file, | |||
| int | lineno | |||
| ) | [read] |
Create a category structure.
Definition at line 468 of file config.c.
References ast_calloc, ast_copy_string(), ast_category::file, ast_category::lineno, ast_category::name, and strdup.
Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_odbc(), realtime_multi_pgsql(), and write_password_to_file().
00469 { 00470 struct ast_category *category; 00471 00472 if ((category = ast_calloc(1, sizeof(*category)))) 00473 ast_copy_string(category->name, name, sizeof(category->name)); 00474 category->file = strdup(in_file); 00475 category->lineno = lineno; /* if you don't know the lineno, set it to 999999 or something real big */ 00476 return category; 00477 }
| void ast_category_rename | ( | struct ast_category * | cat, | |
| const char * | name | |||
| ) |
Definition at line 660 of file config.c.
References ast_copy_string(), and ast_category::name.
Referenced by handle_updates(), realtime_multi_curl(), realtime_multi_odbc(), and realtime_multi_pgsql().
00661 { 00662 ast_copy_string(cat->name, name, sizeof(cat->name)); 00663 }
| struct ast_variable* ast_category_root | ( | struct ast_config * | config, | |
| char * | cat | |||
| ) | [read] |
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 608 of file config.c.
References ast_category_get(), and ast_category::root.
Referenced by get_insecure_variable_from_config().
00609 { 00610 struct ast_category *category = ast_category_get(config, cat); 00611 00612 if (category) 00613 return category->root; 00614 return NULL; 00615 }
| int ast_check_realtime | ( | const char * | family | ) |
Check if realtime engine is configured for family.
| family | which family/config to be checked |
Definition at line 2166 of file config.c.
References ast_realtime_enabled(), and find_engine().
Referenced by __queues_show(), _sip_show_peer(), _sip_show_peers(), ast_queue_log(), close_mailbox(), copy_plain_file(), destroy_association(), handle_response_peerpoke(), handle_voicemail_show_users(), leave_voicemail(), load_module(), local_ast_moh_start(), realtime_peer(), realtime_update_peer(), rename_file(), sip_poke_noanswer(), sip_show_settings(), and vm_delete().
02167 { 02168 struct ast_config_engine *eng; 02169 if (!ast_realtime_enabled()) { 02170 return 0; /* There are no engines at all so fail early */ 02171 } 02172 02173 eng = find_engine(family, NULL, 0, NULL, 0); 02174 if (eng) 02175 return 1; 02176 return 0; 02177 }
| 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 839 of file config.c.
References ast_category_destroy(), ast_free, ast_includes_destroy(), ast_config::includes, ast_category::next, and ast_config::root.
Referenced by __ast_http_load(), __ast_http_post_load(), __ast_udptl_reload(), __init_manager(), __queues_show(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), adsi_load(), advanced_options(), aji_load_config(), ast_cli_perms_init(), ast_config_load2(), ast_readconfig(), conf_exec(), config_function_read(), config_load(), config_module(), directory_exec(), do_reload(), festival_exec(), find_conf(), find_realtime(), handle_cli_dialplan_save(), iax_provision_reload(), init_logger_chain(), load_config(), load_config_meetme(), load_indications(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_realtime_queue(), load_rpt_vars(), make_email_file(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), private_enum_init(), read_agent_config(), read_config_maps(), realtime_directory(), realtime_multi_handler(), realtime_peer(), realtime_switch_common(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_queues(), rpt_master(), rtp_reload(), run_startup_commands(), set_config(), setup_dahdi(), show_users_realtime(), sla_load_config(), smdi_load(), store_config(), tds_load_module(), unload_module(), update_realtime_members(), and vm_forwardoptions().
00840 { 00841 struct ast_category *cat, *catn; 00842 00843 if (!cfg) 00844 return; 00845 00846 ast_includes_destroy(cfg->includes); 00847 00848 cat = cfg->root; 00849 while (cat) { 00850 catn = cat; 00851 cat = cat->next; 00852 ast_category_destroy(catn); 00853 } 00854 ast_free(cfg); 00855 }
| int ast_config_engine_deregister | ( | struct ast_config_engine * | del | ) |
Deregister config engine.
| 0 | Always |
Definition at line 1992 of file config.c.
References ast_mutex_lock(), ast_mutex_unlock(), config_lock, last, and ast_config_engine::next.
Referenced by unload_module().
01993 { 01994 struct ast_config_engine *ptr, *last=NULL; 01995 01996 ast_mutex_lock(&config_lock); 01997 01998 for (ptr = config_engine_list; ptr; ptr=ptr->next) { 01999 if (ptr == del) { 02000 if (last) 02001 last->next = ptr->next; 02002 else 02003 config_engine_list = ptr->next; 02004 break; 02005 } 02006 last = ptr; 02007 } 02008 02009 ast_mutex_unlock(&config_lock); 02010 02011 return 0; 02012 }
| int ast_config_engine_register | ( | struct ast_config_engine * | newconfig | ) |
Register config engine.
| 1 | Always |
Definition at line 1973 of file config.c.
References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), config_lock, LOG_NOTICE, and ast_config_engine::next.
Referenced by load_module().
01974 { 01975 struct ast_config_engine *ptr; 01976 01977 ast_mutex_lock(&config_lock); 01978 01979 if (!config_engine_list) { 01980 config_engine_list = new; 01981 } else { 01982 for (ptr = config_engine_list; ptr->next; ptr=ptr->next); 01983 ptr->next = new; 01984 } 01985 01986 ast_mutex_unlock(&config_lock); 01987 ast_log(LOG_NOTICE,"Registered Config Engine %s\n", new->name); 01988 01989 return 1; 01990 }
| struct ast_category* ast_config_get_current_category | ( | const struct ast_config * | cfg | ) | [read] |
Retrieve the current category name being built. API for backend configuration engines while building a configuration set.
Definition at line 857 of file config.c.
References ast_config::current.
Referenced by config_curl(), config_odbc(), and config_text_file_load().
00858 { 00859 return cfg->current; 00860 }
| struct ast_config* ast_config_internal_load | ( | const char * | configfile, | |
| struct ast_config * | cfg, | |||
| struct ast_flags | flags, | |||
| const char * | suggested_incl_file, | |||
| const char * | who_asked | |||
| ) | [read] |
Definition at line 2054 of file config.c.
References ast_log(), CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, db, find_engine(), ast_config::include_level, ast_config_engine::load_func, LOG_WARNING, ast_config::max_include_level, and table.
Referenced by add_cfg_entry(), ast_config_load2(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), process_text_line(), and read_config_maps().
02055 { 02056 char db[256]; 02057 char table[256]; 02058 struct ast_config_engine *loader = &text_file_engine; 02059 struct ast_config *result; 02060 02061 /* The config file itself bumps include_level by 1 */ 02062 if (cfg->max_include_level > 0 && cfg->include_level == cfg->max_include_level + 1) { 02063 ast_log(LOG_WARNING, "Maximum Include level (%d) exceeded\n", cfg->max_include_level); 02064 return NULL; 02065 } 02066 02067 cfg->include_level++; 02068 02069 if (strcmp(filename, extconfig_conf) && strcmp(filename, "asterisk.conf") && config_engine_list) { 02070 struct ast_config_engine *eng; 02071 02072 eng = find_engine(filename, db, sizeof(db), table, sizeof(table)); 02073 02074 02075 if (eng && eng->load_func) { 02076 loader = eng; 02077 } else { 02078 eng = find_engine("global", db, sizeof(db), table, sizeof(table)); 02079 if (eng && eng->load_func) 02080 loader = eng; 02081 } 02082 } 02083 02084 result = loader->load_func(db, table, filename, cfg, flags, suggested_include_file, who_asked); 02085 02086 if (result && result != CONFIG_STATUS_FILEINVALID && result != CONFIG_STATUS_FILEUNCHANGED) 02087 result->include_level--; 02088 else if (result != CONFIG_STATUS_FILEINVALID) 02089 cfg->include_level--; 02090 02091 return result; 02092 }
| struct ast_config* ast_config_load2 | ( | const char * | filename, | |
| const char * | who_asked, | |||
| struct ast_flags | flags | |||
| ) | [read] |
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. | |
| who_asked | The module which is making this request. | |
| flags | Optional flags: CONFIG_FLAG_WITHCOMMENTS - load the file with comments intact; CONFIG_FLAG_FILEUNCHANGED - check the file mtime and return CONFIG_STATUS_FILEUNCHANGED if the mtime is the same; or CONFIG_FLAG_NOCACHE - don't cache file mtime (main purpose of this option is to save memory on temporary files). |
| NULL | on error |
Definition at line 2094 of file config.c.
References ast_config_destroy(), ast_config_internal_load(), ast_config_new(), CONFIG_STATUS_FILEINVALID, and CONFIG_STATUS_FILEUNCHANGED.
Referenced by __ast_http_load(), __ast_http_post_load(), __ast_udptl_reload(), __init_manager(), _dsp_init(), action_getconfig(), action_getconfigjson(), action_listcategories(), action_updateconfig(), ast_cli_perms_init(), ast_readconfig(), do_reload(), iax_provision_reload(), init_logger_chain(), load_config(), load_indications(), load_modules(), misdn_cfg_init(), private_enum_init(), rtp_reload(), and run_startup_commands().
02095 { 02096 struct ast_config *cfg; 02097 struct ast_config *result; 02098 02099 cfg = ast_config_new(); 02100 if (!cfg) 02101 return NULL; 02102 02103 result = ast_config_internal_load(filename, cfg, flags, "", who_asked); 02104 if (!result || result == CONFIG_STATUS_FILEUNCHANGED || result == CONFIG_STATUS_FILEINVALID) 02105 ast_config_destroy(cfg); 02106 02107 return result; 02108 }
| struct ast_config* ast_config_new | ( | void | ) | [read] |
Create a new base configuration structure.
Definition at line 677 of file config.c.
References ast_calloc, config, MAX_INCLUDE_LEVEL, and ast_config::max_include_level.
Referenced by ast_config_load2(), read_config_maps(), realtime_multi_curl(), realtime_multi_handler(), realtime_multi_ldap(), realtime_multi_odbc(), realtime_multi_pgsql(), and write_password_to_file().
00678 { 00679 struct ast_config *config; 00680 00681 if ((config = ast_calloc(1, sizeof(*config)))) 00682 config->max_include_level = MAX_INCLUDE_LEVEL; 00683 return config; 00684 }
| const char* ast_config_option | ( | struct ast_config * | cfg, | |
| const char * | cat, | |||
| const char * | var | |||
| ) |
Retrieve a configuration variable within the configuration set. Retrieves the named variable var within category cat of configuration set cfg. If not found, attempts to retrieve the named variable var from within category general.
var, or NULL if not found. Definition at line 409 of file config.c.
References ast_variable_retrieve().
Referenced by load_config(), pbx_load_users(), and search_directory_sub().
00410 { 00411 const char *tmp; 00412 tmp = ast_variable_retrieve(cfg, cat, var); 00413 if (!tmp) { 00414 tmp = ast_variable_retrieve(cfg, "general", var); 00415 } 00416 return tmp; 00417 }
| void ast_config_set_current_category | ( | struct ast_config * | cfg, | |
| const struct ast_category * | cat | |||
| ) |
Set the category within the configuration as being current. API for backend configuration engines while building a configuration set.
Definition at line 862 of file config.c.
References ast_config::current.
00863 { 00864 /* cast below is just to silence compiler warning about dropping "const" */ 00865 cfg->current = (struct ast_category *) cat; 00866 }
| int ast_config_text_file_save | ( | const char * | filename, | |
| const struct ast_config * | cfg, | |||
| const char * | generator | |||
| ) |
Definition at line 1614 of file config.c.
References ao2_container_alloc, ao2_ref, ast_debug, AST_LIST_EMPTY, AST_LIST_LAST, AST_LIST_TRAVERSE, ast_verb, ast_variable::blanklines, ast_comment::cmt, errno, ast_config_include::exec, ast_config_include::exec_file, f, ast_variable::file, ast_category::file, gen_header(), hash_string(), hashtab_compare_strings(), ast_category::ignored, ast_config_include::include_location_file, ast_config_include::include_location_lineno, ast_config_include::included_file, ast_config::includes, insert_leading_blank_lines(), ast_category_template_instance::inst, ast_variable::lineno, ast_category::lineno, ast_variable::name, ast_category_template_instance::name, ast_category::name, ast_category::next, ast_variable::next, ast_comment::next, ast_config_include::next, ast_variable::object, option_debug, ast_config_include::output, ast_variable::precomments, ast_category::precomments, ast_category::root, ast_config::root, ast_variable::sameline, ast_category::sameline, set_fn(), ast_category::template_instances, ast_variable::trailing, ast_category::trailing, ast_variable::value, and var.
Referenced by action_updateconfig(), config_text_file_save(), vm_change_password(), vm_forwardoptions(), and write_password_to_file().
01615 { 01616 FILE *f; 01617 char fn[256]; 01618 struct ast_variable *var; 01619 struct ast_category *cat; 01620 struct ast_comment *cmt; 01621 struct ast_config_include *incl; 01622 int blanklines = 0; 01623 struct ao2_container *fileset = ao2_container_alloc(180000, hash_string, hashtab_compare_strings); 01624 struct inclfile *fi = 0; 01625 01626 /* reset all the output flags, in case this isn't our first time saving this data */ 01627 01628 for (incl=cfg->includes; incl; incl = incl->next) 01629 incl->output = 0; 01630 01631 /* go thru all the inclusions and make sure all the files involved (configfile plus all its inclusions) 01632 are all truncated to zero bytes and have that nice header*/ 01633 01634 for (incl=cfg->includes; incl; incl = incl->next) 01635 { 01636 if (!incl->exec) { /* leave the execs alone -- we'll write out the #exec directives, but won't zero out the include files or exec files*/ 01637 FILE *f1; 01638 01639 set_fn(fn, sizeof(fn), incl->included_file, configfile, fileset, &fi); /* normally, fn is just set to incl->included_file, prepended with config dir if relative */ 01640 f1 = fopen(fn,"w"); 01641 if (f1) { 01642 gen_header(f1, configfile, fn, generator); 01643 fclose(f1); /* this should zero out the file */ 01644 } else { 01645 ast_debug(1, "Unable to open for writing: %s\n", fn); 01646 ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno)); 01647 } 01648 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01649 fi = 0; 01650 } 01651 } 01652 01653 set_fn(fn, sizeof(fn), 0, configfile, fileset, &fi); /* just set fn to absolute ver of configfile */ 01654 #ifdef __CYGWIN__ 01655 if ((f = fopen(fn, "w+"))) { 01656 #else 01657 if ((f = fopen(fn, "w"))) { 01658 #endif 01659 ast_verb(2, "Saving '%s': ", fn); 01660 gen_header(f, configfile, fn, generator); 01661 cat = cfg->root; 01662 fclose(f); 01663 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01664 01665 /* from here out, we open each involved file and concat the stuff we need to add to the end and immediately close... */ 01666 /* since each var, cat, and associated comments can come from any file, we have to be 01667 mobile, and open each file, print, and close it on an entry-by-entry basis */ 01668 01669 while (cat) { 01670 set_fn(fn, sizeof(fn), cat->file, configfile, fileset, &fi); 01671 f = fopen(fn, "a"); 01672 if (!f) 01673 { 01674 ast_debug(1, "Unable to open for writing: %s\n", fn); 01675 ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno)); 01676 ao2_ref(fileset, -1); 01677 return -1; 01678 } 01679 01680 /* dump any includes that happen before this category header */ 01681 for (incl=cfg->includes; incl; incl = incl->next) { 01682 if (strcmp(incl->include_location_file, cat->file) == 0){ 01683 if (cat->lineno > incl->include_location_lineno && !incl->output) { 01684 if (incl->exec) 01685 fprintf(f,"#exec \"%s\"\n", incl->exec_file); 01686 else 01687 fprintf(f,"#include \"%s\"\n", incl->included_file); 01688 incl->output = 1; 01689 } 01690 } 01691 } 01692 01693 insert_leading_blank_lines(f, fi, cat->precomments, cat->lineno); 01694 /* Dump section with any appropriate comment */ 01695 for (cmt = cat->precomments; cmt; cmt=cmt->next) { 01696 char *cmtp = cmt->cmt; 01697 while (*cmtp == ';' && *(cmtp+1) == '!') { 01698 char *cmtp2 = strchr(cmtp+1, '\n'); 01699 if (cmtp2) 01700 cmtp = cmtp2+1; 01701 else cmtp = 0; 01702 } 01703 if (cmtp) 01704 fprintf(f,"%s", cmtp); 01705 } 01706 fprintf(f, "[%s]", cat->name); 01707 if (cat->ignored || !AST_LIST_EMPTY(&cat->template_instances)) { 01708 fprintf(f, "("); 01709 if (cat->ignored) { 01710 fprintf(f, "!"); 01711 } 01712 if (cat->ignored && !AST_LIST_EMPTY(&cat->template_instances)) { 01713 fprintf(f, ","); 01714 } 01715 if (!AST_LIST_EMPTY(&cat->template_instances)) { 01716 struct ast_category_template_instance *x; 01717 AST_LIST_TRAVERSE(&cat->template_instances, x, next) { 01718 fprintf(f,"%s",x->name); 01719 if (x != AST_LIST_LAST(&cat->template_instances)) 01720 fprintf(f,","); 01721 } 01722 } 01723 fprintf(f, ")"); 01724 } 01725 for(cmt = cat->sameline; cmt; cmt=cmt->next) 01726 { 01727 fprintf(f,"%s", cmt->cmt); 01728 } 01729 if (!cat->sameline) 01730 fprintf(f,"\n"); 01731 for (cmt = cat->trailing; cmt; cmt=cmt->next) { 01732 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01733 fprintf(f,"%s", cmt->cmt); 01734 } 01735 fclose(f); 01736 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01737 fi = 0; 01738 01739 var = cat->root; 01740 while (var) { 01741 struct ast_category_template_instance *x; 01742 int found = 0; 01743 AST_LIST_TRAVERSE(&cat->template_instances, x, next) { 01744 struct ast_variable *v; 01745 for (v = x->inst->root; v; v = v->next) { 01746 if (!strcasecmp(var->name, v->name) && !strcmp(var->value, v->value)) { 01747 found = 1; 01748 break; 01749 } 01750 } 01751 if (found) 01752 break; 01753 } 01754 if (found) { 01755 var = var->next; 01756 continue; 01757 } 01758 set_fn(fn, sizeof(fn), var->file, configfile, fileset, &fi); 01759 f = fopen(fn, "a"); 01760 if (!f) 01761 { 01762 ast_debug(1, "Unable to open for writing: %s\n", fn); 01763 ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno)); 01764 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01765 fi = 0; 01766 ao2_ref(fileset, -1); 01767 return -1; 01768 } 01769 01770 /* dump any includes that happen before this category header */ 01771 for (incl=cfg->includes; incl; incl = incl->next) { 01772 if (strcmp(incl->include_location_file, var->file) == 0){ 01773 if (var->lineno > incl->include_location_lineno && !incl->output) { 01774 if (incl->exec) 01775 fprintf(f,"#exec \"%s\"\n", incl->exec_file); 01776 else 01777 fprintf(f,"#include \"%s\"\n", incl->included_file); 01778 incl->output = 1; 01779 } 01780 } 01781 } 01782 01783 insert_leading_blank_lines(f, fi, var->precomments, var->lineno); 01784 for (cmt = var->precomments; cmt; cmt=cmt->next) { 01785 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01786 fprintf(f,"%s", cmt->cmt); 01787 } 01788 if (var->sameline) 01789 fprintf(f, "%s %s %s %s", var->name, (var->object ? "=>" : "="), var->value, var->sameline->cmt); 01790 else 01791 fprintf(f, "%s %s %s\n", var->name, (var->object ? "=>" : "="), var->value); 01792 for (cmt = var->trailing; cmt; cmt=cmt->next) { 01793 if (cmt->cmt[0] != ';' || cmt->cmt[1] != '!') 01794 fprintf(f,"%s", cmt->cmt); 01795 } 01796 if (var->blanklines) { 01797 blanklines = var->blanklines; 01798 while (blanklines--) 01799 fprintf(f, "\n"); 01800 } 01801 01802 fclose(f); 01803 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01804 fi = 0; 01805 01806 var = var->next; 01807 } 01808 cat = cat->next; 01809 } 01810 if (!option_debug) 01811 ast_verb(2, "Saved\n"); 01812 } else { 01813 ast_debug(1, "Unable to open for writing: %s\n", fn); 01814 ast_verb(2, "Unable to write (%s)", strerror(errno)); 01815 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01816 ao2_ref(fileset, -1); 01817 return -1; 01818 } 01819 01820 /* Now, for files with trailing #include/#exec statements, 01821 we have to make sure every entry is output */ 01822 01823 for (incl=cfg->includes; incl; incl = incl->next) { 01824 if (!incl->output) { 01825 /* open the respective file */ 01826 set_fn(fn, sizeof(fn), incl->include_location_file, configfile, fileset, &fi); 01827 f = fopen(fn, "a"); 01828 if (!f) 01829 { 01830 ast_debug(1, "Unable to open for writing: %s\n", fn); 01831 ast_verb(2, "Unable to write %s (%s)", fn, strerror(errno)); 01832 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01833 fi = 0; 01834 ao2_ref(fileset, -1); 01835 return -1; 01836 } 01837 01838 /* output the respective include */ 01839 if (incl->exec) 01840 fprintf(f,"#exec \"%s\"\n", incl->exec_file); 01841 else 01842 fprintf(f,"#include \"%s\"\n", incl->included_file); 01843 fclose(f); 01844 incl->output = 1; 01845 ao2_ref(fi,-1); /* we are giving up this reference to the object ptd to by fi */ 01846 fi = 0; 01847 } 01848 } 01849 ao2_ref(fileset, -1); /* this should destroy the hash container */ 01850 01851 return 0; 01852 }
| int ast_destroy_realtime | ( | const char * | family, | |
| const char * | keyfield, | |||
| const char * | lookup, | |||
| ... | ||||
| ) |
Destroy realtime configuration.
| family | which family/config to be destroyed | |
| 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 destroy an entry in realtime configuration space. Additional params are used as keys. |
Definition at line 2285 of file config.c.
References db, ast_config_engine::destroy_func, find_engine(), and table.
Referenced by cli_realtime_destroy(), function_realtime_readdestroy(), leave_voicemail(), and vm_delete().
02286 { 02287 struct ast_config_engine *eng; 02288 int res = -1; 02289 char db[256]; 02290 char table[256]; 02291 va_list ap; 02292 02293 va_start(ap, lookup); 02294 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02295 if (eng && eng->destroy_func) 02296 res = eng->destroy_func(db, table, keyfield, lookup, ap); 02297 va_end(ap); 02298 02299 return res; 02300 }
| struct ast_config_include* ast_include_find | ( | struct ast_config * | conf, | |
| const char * | included_file | |||
| ) | [read] |
Definition at line 337 of file config.c.
References ast_config_include::included_file, ast_config::includes, and ast_config_include::next.
Referenced by ast_include_new().
00338 { 00339 struct ast_config_include *x; 00340 for (x=conf->includes;x;x=x->next) { 00341 if (strcmp(x->included_file,included_file) == 0) 00342 return x; 00343 } 00344 return 0; 00345 }
| struct ast_config_include* ast_include_new | ( | struct ast_config * | conf, | |
| const char * | from_file, | |||
| const char * | included_file, | |||
| int | is_exec, | |||
| const char * | exec_file, | |||
| int | from_lineno, | |||
| char * | real_included_file_name, | |||
| int | real_included_file_name_size | |||
| ) | [read] |
Definition at line 246 of file config.c.
References ast_calloc, ast_include_find(), ast_log(), ast_strdup, ast_strlen_zero(), ast_config::includes, and LOG_WARNING.
Referenced by process_text_line().
00247 { 00248 /* a file should be included ONCE. Otherwise, if one of the instances is changed, 00249 * then all be changed. -- how do we know to include it? -- Handling modified 00250 * instances is possible, I'd have 00251 * to create a new master for each instance. */ 00252 struct ast_config_include *inc; 00253 struct stat statbuf; 00254 00255 inc = ast_include_find(conf, included_file); 00256 if (inc) { 00257 do { 00258 inc->inclusion_count++; 00259 snprintf(real_included_file_name, real_included_file_name_size, "%s~~%d", included_file, inc->inclusion_count); 00260 } while (stat(real_included_file_name, &statbuf) == 0); 00261 ast_log(LOG_WARNING,"'%s', line %d: Same File included more than once! This data will be saved in %s if saved back to disk.\n", from_file, from_lineno, real_included_file_name); 00262 } else 00263 *real_included_file_name = 0; 00264 00265 inc = ast_calloc(1,sizeof(struct ast_config_include)); 00266 inc->include_location_file = ast_strdup(from_file); 00267 inc->include_location_lineno = from_lineno; 00268 if (!ast_strlen_zero(real_included_file_name)) 00269 inc->included_file = ast_strdup(real_included_file_name); 00270 else 00271 inc->included_file = ast_strdup(included_file); 00272 00273 inc->exec = is_exec; 00274 if (is_exec) 00275 inc->exec_file = ast_strdup(exec_file); 00276 00277 /* attach this new struct to the conf struct */ 00278 inc->next = conf->includes; 00279 conf->includes = inc; 00280 00281 return inc; 00282 }
| void ast_include_rename | ( | struct ast_config * | conf, | |
| const char * | from_file, | |||
| const char * | to_file | |||
| ) |
Definition at line 284 of file config.c.
References ast_variable::file, ast_category::file, free, ast_config_include::include_location_file, ast_config::includes, ast_variable::next, ast_category::next, ast_config_include::next, ast_category::root, ast_config::root, and strdup.
Referenced by action_updateconfig().
00285 { 00286 struct ast_config_include *incl; 00287 struct ast_category *cat; 00288 struct ast_variable *v; 00289 00290 int from_len = strlen(from_file); 00291 int to_len = strlen(to_file); 00292 00293 if (strcmp(from_file, to_file) == 0) /* no use wasting time if the name is the same */ 00294 return; 00295 00296 /* the manager code allows you to read in one config file, then 00297 * write it back out under a different name. But, the new arrangement 00298 * ties output lines to the file name. So, before you try to write 00299 * the config file to disk, better riffle thru the data and make sure 00300 * the file names are changed. 00301 */ 00302 /* file names are on categories, includes (of course), and on variables. So, 00303 * traverse all this and swap names */ 00304 00305 for (incl = conf->includes; incl; incl=incl->next) { 00306 if (strcmp(incl->include_location_file,from_file) == 0) { 00307 if (from_len >= to_len) 00308 strcpy(incl->include_location_file, to_file); 00309 else { 00310 free(incl->include_location_file); 00311 incl->include_location_file = strdup(to_file); 00312 } 00313 } 00314 } 00315 for (cat = conf->root; cat; cat = cat->next) { 00316 if (strcmp(cat->file,from_file) == 0) { 00317 if (from_len >= to_len) 00318 strcpy(cat->file, to_file); 00319 else { 00320 free(cat->file); 00321 cat->file = strdup(to_file); 00322 } 00323 } 00324 for (v = cat->root; v; v = v->next) { 00325 if (strcmp(v->file,from_file) == 0) { 00326 if (from_len >= to_len) 00327 strcpy(v->file, to_file); 00328 else { 00329 free(v->file); 00330 v->file = strdup(to_file); 00331 } 00332 } 00333 } 00334 } 00335 }
| struct ast_variable* ast_load_realtime | ( | const char * | family, | |
| ... | ||||
| ) | [read] |
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. |
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.
Definition at line 2136 of file config.c.
References ast_free, ast_load_realtime_helper(), ast_strlen_zero(), ast_variable::next, and ast_variable::value.
Referenced by conf_run(), copy_plain_file(), find_conf_realtime(), find_realtime(), find_user_realtime(), leave_queue(), load_realtime_queue(), local_ast_moh_start(), queue_function_queuewaitingcount(), realtime_alias(), realtime_peer(), realtime_switch_common(), realtime_user(), and rt_extend_conf().
02137 { 02138 struct ast_variable *res, *cur, *prev = NULL, *freeme = NULL; 02139 va_list ap; 02140 02141 va_start(ap, family); 02142 res = ast_load_realtime_helper(family, ap); 02143 va_end(ap); 02144 02145 /* Eliminate blank entries */ 02146 for (cur = res; cur; cur = cur->next) { 02147 if (freeme) { 02148 ast_free(freeme); 02149 freeme = NULL; 02150 } 02151 02152 if (ast_strlen_zero(cur->value)) { 02153 if (prev) 02154 prev->next = cur->next; 02155 else 02156 res = cur->next; 02157 freeme = cur; 02158 } else { 02159 prev = cur; 02160 } 02161 } 02162 return res; 02163 }
| struct ast_variable* ast_load_realtime_all | ( | const char * | family, | |
| ... | ||||
| ) | [read] |
Definition at line 2124 of file config.c.
References ast_load_realtime_helper().
Referenced by cli_realtime_load(), function_realtime_read(), function_realtime_readdestroy(), and realtimefield_read().
02125 { 02126 struct ast_variable *res; 02127 va_list ap; 02128 02129 va_start(ap, family); 02130 res = ast_load_realtime_helper(family, ap); 02131 va_end(ap); 02132 02133 return res; 02134 }
| struct ast_config* ast_load_realtime_multientry | ( | const char * | family, | |
| ... | ||||
| ) | [read] |
Retrieve realtime configuration.
| family | which family/config to lookup |
Note that you should use the constant SENTINEL to terminate arguments, in order to preserve cross-platform compatibility.
Definition at line 2217 of file config.c.
References db, find_engine(), ast_config_engine::realtime_multi_func, and table.
Referenced by __queues_show(), find_realtime(), load_realtime_queue(), realtime_directory(), realtime_peer(), realtime_switch_common(), show_users_realtime(), and update_realtime_members().
02218 { 02219 struct ast_config_engine *eng; 02220 char db[256]; 02221 char table[256]; 02222 struct ast_config *res = NULL; 02223 va_list ap; 02224 02225 va_start(ap, family); 02226 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02227 if (eng && eng->realtime_multi_func) 02228 res = eng->realtime_multi_func(db, table, ap); 02229 va_end(ap); 02230 02231 return res; 02232 }
| int ast_parse_arg | ( | const char * | arg, | |
| enum ast_parse_flags | flags, | |||
| void * | p_result, | |||
| ... | ||||
| ) |
The argument parsing routine.
| arg | the string to parse. It is not modified. | |
| flags | combination of ast_parse_flags to specify the return type and additional checks. | |
| result | pointer to the result. NULL is valid here, and can be used to perform only the validity checks. | |
| ... | extra arguments are required according to flags. |
| 0 | in case of success, != 0 otherwise. | |
| result | returns the parsed value in case of success, the default value in case of error, or it is left unchanged in case of error and no default specified. Note that in certain cases (e.g. sockaddr_in, with multi-field return values) some of the fields in result may be changed even if an error occurs. |
Definition at line 2305 of file config.c.
References ast_debug, ast_gethostbyname(), ast_inet_ntoa(), ast_strdupa, buf, hp, PARSE_DEFAULT, PARSE_DOUBLE, PARSE_IN_RANGE, PARSE_INADDR, PARSE_INT32, PARSE_OUT_RANGE, PARSE_PORT_FORBID, PARSE_PORT_IGNORE, PARSE_PORT_MASK, PARSE_PORT_REQUIRE, PARSE_TYPE, PARSE_UINT32, and strsep().
Referenced by ast_sip_ouraddrfor(), ast_tls_read_conf(), check_via_response(), multicast_rtp_request(), and reload_config().
02307 { 02308 va_list ap; 02309 int error = 0; 02310 02311 va_start(ap, p_result); 02312 switch (flags & PARSE_TYPE) { 02313 case PARSE_INT32: 02314 { 02315 int32_t *result = p_result; 02316 int32_t x, def = result ? *result : 0, 02317 high = (int32_t)0x7fffffff, 02318 low = (int32_t)0x80000000; 02319 /* optional argument: first default value, then range */ 02320 if (flags & PARSE_DEFAULT) 02321 def = va_arg(ap, int32_t); 02322 if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) { 02323 /* range requested, update bounds */ 02324 low = va_arg(ap, int32_t); 02325 high = va_arg(ap, int32_t); 02326 } 02327 x = strtol(arg, NULL, 0); 02328 error = (x < low) || (x > high); 02329 if (flags & PARSE_OUT_RANGE) 02330 error = !error; 02331 if (result) 02332 *result = error ? def : x; 02333 ast_debug(3, 02334 "extract int from [%s] in [%d, %d] gives [%d](%d)\n", 02335 arg, low, high, 02336 result ? *result : x, error); 02337 break; 02338 } 02339 02340 case PARSE_UINT32: 02341 { 02342 uint32_t *result = p_result; 02343 uint32_t x, def = result ? *result : 0, 02344 low = 0, high = (uint32_t)~0; 02345 /* optional argument: first default value, then range */ 02346 if (flags & PARSE_DEFAULT) 02347 def = va_arg(ap, uint32_t); 02348 if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) { 02349 /* range requested, update bounds */ 02350 low = va_arg(ap, uint32_t); 02351 high = va_arg(ap, uint32_t); 02352 } 02353 x = strtoul(arg, NULL, 0); 02354 error = (x < low) || (x > high); 02355 if (flags & PARSE_OUT_RANGE) 02356 error = !error; 02357 if (result) 02358 *result = error ? def : x; 02359 ast_debug(3, 02360 "extract uint from [%s] in [%u, %u] gives [%u](%d)\n", 02361 arg, low, high, 02362 result ? *result : x, error); 02363 break; 02364 } 02365 02366 case PARSE_DOUBLE: 02367 { 02368 double *result = p_result; 02369 double x, def = result ? *result : 0, 02370 low = -HUGE_VAL, high = HUGE_VAL; 02371 02372 /* optional argument: first default value, then range */ 02373 if (flags & PARSE_DEFAULT) 02374 def = va_arg(ap, double); 02375 if (flags & (PARSE_IN_RANGE|PARSE_OUT_RANGE)) { 02376 /* range requested, update bounds */ 02377 low = va_arg(ap, double); 02378 high = va_arg(ap, double); 02379 } 02380 x = strtod(arg, NULL); 02381 error = (x < low) || (x > high); 02382 if (flags & PARSE_OUT_RANGE) 02383 error = !error; 02384 if (result) 02385 *result = error ? def : x; 02386 ast_debug(3, 02387 "extract double from [%s] in [%f, %f] gives [%f](%d)\n", 02388 arg, low, high, 02389 result ? *result : x, error); 02390 break; 02391 } 02392 case PARSE_INADDR: 02393 { 02394 char *port, *buf; 02395 struct sockaddr_in _sa_buf; /* buffer for the result */ 02396 struct sockaddr_in *sa = p_result ? 02397 (struct sockaddr_in *)p_result : &_sa_buf; 02398 /* default is either the supplied value or the result itself */ 02399 struct sockaddr_in *def = (flags & PARSE_DEFAULT) ? 02400 va_arg(ap, struct sockaddr_in *) : sa; 02401 struct hostent *hp; 02402 struct ast_hostent ahp; 02403 02404 memset(&_sa_buf, '\0', sizeof(_sa_buf)); /* clear buffer */ 02405 /* duplicate the string to strip away the :port */ 02406 port = ast_strdupa(arg); 02407 buf = strsep(&port, ":"); 02408 sa->sin_family = AF_INET; /* assign family */ 02409 /* 02410 * honor the ports flag setting, assign default value 02411 * in case of errors or field unset. 02412 */ 02413 flags &= PARSE_PORT_MASK; /* the only flags left to process */ 02414 if (port) { 02415 if (flags == PARSE_PORT_FORBID) { 02416 error = 1; /* port was forbidden */ 02417 sa->sin_port = def->sin_port; 02418 } else if (flags == PARSE_PORT_IGNORE) 02419 sa->sin_port = def->sin_port; 02420 else /* accept or require */ 02421 sa->sin_port = htons(strtol(port, NULL, 0)); 02422 } else { 02423 sa->sin_port = def->sin_port; 02424 if (flags == PARSE_PORT_REQUIRE) 02425 error = 1; 02426 } 02427 /* Now deal with host part, even if we have errors before. */ 02428 hp = ast_gethostbyname(buf, &ahp); 02429 if (hp) /* resolved successfully */ 02430 memcpy(&sa->sin_addr, hp->h_addr, sizeof(sa->sin_addr)); 02431 else { 02432 error = 1; 02433 sa->sin_addr = def->sin_addr; 02434 } 02435 ast_debug(3, 02436 "extract inaddr from [%s] gives [%s:%d](%d)\n", 02437 arg, ast_inet_ntoa(sa->sin_addr), 02438 ntohs(sa->sin_port), error); 02439 break; 02440 } 02441 } 02442 va_end(ap); 02443 return error; 02444 }
| int ast_realtime_enabled | ( | void | ) |
Check if there's any realtime engines loaded.
Definition at line 2180 of file config.c.
References config_maps.
Referenced by action_coresettings(), ast_check_realtime(), and handle_show_settings().
02181 { 02182 return config_maps ? 1 : 0; 02183 }
| int ast_realtime_require_field | ( | const char * | family, | |
| ... | ||||
| ) |
Inform realtime what fields that may be stored.
| family | which family/config is referenced This will inform builtin configuration backends that particular fields may be updated during the use of that configuration section. This is mainly to be used during startup routines, to ensure that various fields exist in the backend. The backends may take various actions, such as creating new fields in the data store or warning the administrator that new fields may need to be created, in order to ensure proper function. |
A family should always specify its fields to the minimum necessary requirements to fulfill all possible values (within reason; for example, a timeout value may reasonably be specified as an INTEGER2, with size 5. Even though values above 32767 seconds are possible, they are unlikely to be useful, and we should not complain about that size).
| 0 | Required fields met specified standards | |
| -1 | One or more fields was missing or insufficient |
Definition at line 2185 of file config.c.
References db, find_engine(), ast_config_engine::require_func, and table.
Referenced by change_password_realtime(), conf_run(), and load_module().
02186 { 02187 struct ast_config_engine *eng; 02188 char db[256]; 02189 char table[256]; 02190 va_list ap; 02191 int res = -1; 02192 02193 va_start(ap, family); 02194 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02195 if (eng && eng->require_func) { 02196 res = eng->require_func(db, table, ap); 02197 } 02198 va_end(ap); 02199 02200 return res; 02201 }
| int ast_rq_is_int | ( | require_type | type | ) | [inline] |
Check if require type is an integer type.
Definition at line 607 of file config.h.
Referenced by realtime_require_handler(), require_odbc(), and require_pgsql().
| int ast_store_realtime | ( | const char * | family, | |
| ... | ||||
| ) |
Create realtime configuration.
| family | which family/config to be created This function is used to create a parameter in realtime configuration space. |
Definition at line 2268 of file config.c.
References db, find_engine(), ast_config_engine::store_func, and table.
Referenced by ast_queue_log(), cli_realtime_store(), copy_plain_file(), function_realtime_store(), and leave_voicemail().
02269 { 02270 struct ast_config_engine *eng; 02271 int res = -1; 02272 char db[256]; 02273 char table[256]; 02274 va_list ap; 02275 02276 va_start(ap, family); 02277 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02278 if (eng && eng->store_func) 02279 res = eng->store_func(db, table, ap); 02280 va_end(ap); 02281 02282 return res; 02283 }
| int ast_unload_realtime | ( | const char * | family | ) |
Release any resources cached for a realtime family.
| family | which family/config to destroy Various backends may cache attributes about a realtime data storage facility; on reload, a front end resource may request to purge that cache. |
| 0 | If any cache was purged | |
| -1 | If no cache was found |
Definition at line 2203 of file config.c.
References db, find_engine(), table, and ast_config_engine::unload_func.
Referenced by __unload_module(), load_config(), reload(), reload_config(), and unload_module().
02204 { 02205 struct ast_config_engine *eng; 02206 char db[256]; 02207 char table[256]; 02208 int res = -1; 02209 02210 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02211 if (eng && eng->unload_func) { 02212 res = eng->unload_func(db, table); 02213 } 02214 return res; 02215 }
| int ast_update2_realtime | ( | const char * | family, | |
| ... | ||||
| ) |
Update realtime configuration.
| family | which family/config to be updated This function is used to update a parameter in realtime configuration space. It includes the ability to lookup a row based upon multiple key criteria. As a result, this function includes two sentinel values, one to terminate lookup values and the other to terminate the listing of fields to update. |
Definition at line 2251 of file config.c.
References db, find_engine(), table, and ast_config_engine::update2_func.
Referenced by change_password_realtime(), and cli_realtime_update2().
02252 { 02253 struct ast_config_engine *eng; 02254 int res = -1; 02255 char db[256]; 02256 char table[256]; 02257 va_list ap; 02258 02259 va_start(ap, family); 02260 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02261 if (eng && eng->update2_func) 02262 res = eng->update2_func(db, table, ap); 02263 va_end(ap); 02264 02265 return res; 02266 }
| 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 2234 of file config.c.
References db, find_engine(), table, and ast_config_engine::update_func.
Referenced by cli_realtime_update(), conf_run(), destroy_association(), function_realtime_write(), handle_response_peerpoke(), leave_voicemail(), realtime_update_peer(), rename_file(), rt_extend_conf(), sip_poke_noanswer(), and update_realtime_member_field().
02235 { 02236 struct ast_config_engine *eng; 02237 int res = -1; 02238 char db[256]; 02239 char table[256]; 02240 va_list ap; 02241 02242 va_start(ap, lookup); 02243 eng = find_engine(family, db, sizeof(db), table, sizeof(table)); 02244 if (eng && eng->update_func) 02245 res = eng->update_func(db, table, keyfield, lookup, ap); 02246 va_end(ap); 02247 02248 return res; 02249 }
| void ast_variable_append | ( | struct ast_category * | category, | |
| struct ast_variable * | variable | |||
| ) |
Definition at line 348 of file config.c.
References ast_category::last, ast_variable::next, and ast_category::root.
Referenced by add_cfg_entry(), add_rt_multi_cfg_entry(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), handle_updates(), inherit_category(), move_variables(), process_text_line(), realtime_directory(), realtime_multi_curl(), realtime_multi_ldap(), realtime_multi_odbc(), realtime_multi_pgsql(), vm_change_password(), and write_password_to_file().
00349 { 00350 if (!variable) 00351 return; 00352 if (category->last) 00353 category->last->next = variable; 00354 else 00355 category->root = variable; 00356 category->last = variable; 00357 while (category->last->next) 00358 category->last = category->last->next; 00359 }
| struct ast_variable* ast_variable_browse | ( | const struct ast_config * | config, | |
| const char * | category | |||
| ) | [read] |
Goes through variables Somewhat similar in intent as the ast_category_browse. List variables of config file category.
| ast_variable | list on success | |
| NULL | on failure |
Definition at line 396 of file config.c.
References ast_category_get(), ast_config::last_browse, ast_category::name, and ast_category::root.
Referenced by __ast_http_load(), __ast_http_post_load(), __init_manager(), action_getconfig(), action_getconfigjson(), adsi_load(), aji_load_config(), ast_cli_perms_init(), ast_readconfig(), ast_variable_retrieve(), build_calendar(), build_device(), build_event_channel(), caldav_load_calendar(), check_tx_freq(), collect_function_digits(), conf_exec(), config_load(), config_module(), do_say(), do_scheduler(), exchangecal_load_calendar(), find_conf(), gtalk_load_config(), handle_cli_dialplan_save(), iax_template_parse(), ical_load_calendar(), init_logger_chain(), jingle_load_config(), load_config(), load_module(), load_modules(), load_moh_classes(), load_odbc_config(), load_rpt_vars(), misdn_cfg_init(), node_lookup(), odbc_load_module(), osp_create_provider(), parse_config(), parse_tone_zone(), pbx_load_config(), read_agent_config(), read_config_maps(), reload(), reload_config(), reload_followme(), reload_queue_rules(), reload_single_queue(), run_startup_commands(), search_directory_sub(), set_config(), setup_dahdi(), show_users_realtime(), sip_cli_notify(), sla_build_station(), sla_build_trunk(), smdi_load(), store_config(), and tds_load_module().
00397 { 00398 struct ast_category *cat = NULL; 00399 00400 if (category && config->last_browse && (config->last_browse->name == category)) { 00401 cat = config->last_browse; 00402 } else { 00403 cat = ast_category_get(config, category); 00404 } 00405 00406 return (cat) ? cat->root : NULL; 00407 }
| int ast_variable_delete | ( | struct ast_category * | category, | |
| const char * | variable, | |||
| const char * | match, | |||
| const char * | line | |||
| ) |
Definition at line 686 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().
00687 { 00688 struct ast_variable *cur, *prev=NULL, *curn; 00689 int res = -1; 00690 int lineno = 0; 00691 00692 cur = category->root; 00693 while (cur) { 00694 if (cur->name == variable) { 00695 if (prev) { 00696 prev->next = cur->next; 00697 if (cur == category->last) 00698 category->last = prev; 00699 } else { 00700 category->root = cur->next; 00701 if (cur == category->last) 00702 category->last = NULL; 00703 } 00704 cur->next = NULL; 00705 ast_variables_destroy(cur); 00706 return 0; 00707 } 00708 prev = cur; 00709 cur = cur->next; 00710 } 00711 00712 prev = NULL; 00713 cur = category->root; 00714 while (cur) { 00715 curn = cur->next; 00716 if ((!ast_strlen_zero(line) && lineno == atoi(line)) || (ast_strlen_zero(line) && !strcasecmp(cur->name, variable) && (ast_strlen_zero(match) || !strcasecmp(cur->value, match)))) { 00717 if (prev) { 00718 prev->next = cur->next; 00719 if (cur == category->last) 00720 category->last = prev; 00721 } else { 00722 category->root = cur->next; 00723 if (cur == category->last) 00724 category->last = NULL; 00725 } 00726 cur->next = NULL; 00727 ast_variables_destroy(cur); 00728 res = 0; 00729 } else 00730 prev = cur; 00731 00732 cur = curn; 00733 lineno++; 00734 } 00735 return res; 00736 }
| void ast_variable_insert | ( | struct ast_category * | category, | |
| struct ast_variable * | variable, | |||
| const char * | line | |||
| ) |
Definition at line 361 of file config.c.
References ast_variable::next, and ast_category::root.
Referenced by handle_updates().
00362 { 00363 struct ast_variable *cur = category->root; 00364 int lineno; 00365 int insertline; 00366 00367 if (!variable || sscanf(line, "%30d", &insertline) != 1) { 00368 return; 00369 } 00370 if (!insertline) { 00371 variable->next = category->root; 00372 category->root = variable; 00373 } else { 00374 for (lineno = 1; lineno < insertline; lineno++) { 00375 cur = cur->next; 00376 if (!cur->next) { 00377 break; 00378 } 00379 } 00380 variable->next = cur->next; 00381 cur->next = variable; 00382 } 00383 }
| struct ast_variable* ast_variable_new | ( | const char * | name, | |
| const char * | value, | |||
| const char * | filename | |||
| ) | [read] |
Definition at line 223 of file config.c.
References __ast_calloc(), ast_calloc, ast_variable::file, ast_variable::name, ast_variable::stuff, and ast_variable::value.
Referenced by add_cfg_entry(), add_rt_cfg_entry(), add_rt_multi_cfg_entry(), add_var(), apply_outgoing(), ast_channeltype_list(), ast_http_get_post_vars(), ast_variable_update(), astman_get_variables(), build_user(), check_access(), config_curl(), config_ldap(), config_odbc(), config_pgsql(), copy_vars(), create_vmaccount(), handle_updates(), handle_uri(), httpd_helper_thread(), iax_parse_ies(), ldap_table_config_add_attribute(), manager_sipnotify(), mkintf(), parkandannounce_exec(), parse_cookies(), process_dahdi(), process_text_line(), realtime_curl(), realtime_directory(), realtime_ldap_entry_to_var(), realtime_ldap_result_to_vars(), realtime_multi_curl(), realtime_multi_odbc(), realtime_multi_pgsql(), realtime_odbc(), realtime_pgsql(), sip_cli_notify(), variable_clone(), vm_change_password(), and write_password_to_file().
00225 { 00226 struct ast_variable *variable; 00227 int name_len = strlen(name) + 1; 00228 int val_len = strlen(value) + 1; 00229 int fn_len = strlen(filename) + 1; 00230 00231 #ifdef MALLOC_DEBUG 00232 if ((variable = __ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable), file, lineno, func))) { 00233 #else 00234 if ((variable = ast_calloc(1, name_len + val_len + fn_len + sizeof(*variable)))) { 00235 #endif 00236 char *dst = variable->stuff; /* writable space starts here */ 00237 variable->name = strcpy(dst, name); 00238 dst += name_len; 00239 variable->value = strcpy(dst, value); 00240 dst += val_len; 00241 variable->file = strcpy(dst, filename); 00242 } 00243 return variable; 00244 }
| 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 |
| The | variable value on success | |
| NULL | if unable to find it. |
Definition at line 420 of file config.c.
References ast_variable_browse(), ast_variable::name, ast_category::next, ast_variable::next, ast_category::root, ast_config::root, and ast_variable::value.
Referenced by __ast_udptl_reload(), __init_manager(), _dsp_init(), advanced_options(), aji_load_config(), ast_config_option(), build_extension(), config_function_read(), config_module(), directory_exec(), do_reload(), do_scheduler(), festival_exec(), find_queue_by_name_rt(), find_realtime(), function_macro(), get_insecure_variable_from_config(), get_wait_interval(), gtalk_load_config(), iax_template_parse(), init_acf_query(), init_logger_chain(), jingle_load_config(), load_config(), load_config_meetme(), load_indications(), load_module(), load_modules(), load_rpt_vars(), load_tech_calendars(), make_email_file(), node_lookup(), odbc_load_module(), osp_load(), parse_config(), pbx_load_config(), pbx_load_users(), play_message(), prep_email_sub_vars(), private_enum_init(), queue_set_global_params(), read_agent_config(), read_password_from_file(), realtime_directory(), reload_config(), reload_followme(), reload_single_queue(), retreive_memory(), retrieve_astcfgint(), rpt(), rpt_master(), rpt_tele_thread(), rpt_telemetry(), rtp_reload(), saynode(), search_directory(), search_directory_sub(), set_config(), setup_dahdi(), sla_build_station(), sla_build_trunk(), sla_load_config(), tds_load_module(), telem_lookup(), update_realtime_members(), vm_change_password(), and vm_forwardoptions().
00421 { 00422 struct ast_variable *v; 00423 00424 if (category) { 00425 for (v = ast_variable_browse(config, category); v; v = v->next) { 00426 if (!strcasecmp(variable, v->name)) { 00427 return v->value; 00428 } 00429 } 00430 } else { 00431 struct ast_category *cat; 00432 00433 for (cat = config->root; cat; cat = cat->next) { 00434 for (v = cat->root; v; v = v->next) { 00435 if (!strcasecmp(variable, v->name)) { 00436 return v->value; 00437 } 00438 } 00439 } 00440 } 00441 00442 return NULL; 00443 }
| int ast_variable_update | ( | struct ast_category * | category, | |
| const char * | variable, | |||
| const char * | value, | |||
| const char * | match, | |||
| unsigned int | object | |||
| ) |
Update variable value within a config.
| category | Category element within the config | |
| variable | Name of the variable to change | |
| value | New value of the variable | |
| match | If set, previous value of the variable (if NULL or zero-length, no matching will be done) | |
| object | Boolean of whether to make the new variable an object |
Definition at line 738 of file config.c.
References ast_strlen_zero(), ast_variable_new(), ast_variables_destroy(), ast_variable::blanklines, ast_variable::file, ast_category::last, ast_variable::lineno, ast_variable::name, ast_variable::next, ast_variable::object, ast_variable::precomments, ast_category::root, ast_variable::sameline, ast_variable::trailing, and ast_variable::value.
Referenced by handle_updates(), process_text_line(), vm_change_password(), and vm_forwardoptions().
00740 { 00741 struct ast_variable *cur, *prev=NULL, *newer=NULL; 00742 00743 for (cur = category->root; cur; prev = cur, cur = cur->next) { 00744 if (strcasecmp(cur->name, variable) || 00745 (!ast_strlen_zero(match) && strcasecmp(cur->value, match))) 00746 continue; 00747 00748 if (!(newer = ast_variable_new(variable, value, cur->file))) 00749 return -1; 00750 00751 newer->next = cur->next; 00752 newer->object = cur->object || object; 00753 00754 /* Preserve everything */ 00755 newer->lineno = cur->lineno; 00756 newer->blanklines = cur->blanklines; 00757 newer->precomments = cur->precomments; cur->precomments = NULL; 00758 newer->sameline = cur->sameline; cur->sameline = NULL; 00759 newer->trailing = cur->trailing; cur->trailing = NULL; 00760 00761 if (prev) 00762 prev->next = newer; 00763 else 00764 category->root = newer; 00765 if (category->last == cur) 00766 category->last = newer; 00767 00768 cur->next = NULL; 00769 ast_variables_destroy(cur); 00770 00771 return 0; 00772 } 00773 00774 /* Could not find variable to update */ 00775 return -1; 00776 }
| 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 385 of file config.c.
References ast_free, and ast_variable::next.
Referenced by __sip_destroy(), ast_category_destroy(), ast_category_empty(), ast_http_get_cookies(), ast_http_manid_from_vars(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), ast_var_channel_types(), ast_var_channel_types_table(), ast_variable_delete(), ast_variable_update(), auth_http_callback(), build_gateway(), build_peer(), build_user(), cli_realtime_load(), conf_run(), copy_plain_file(), destroy_dahdi_pvt(), destroy_endpoint(), find_conf_realtime(), find_realtime(), find_user_realtime(), free_outgoing(), free_user(), function_realtime_read(), function_realtime_readdestroy(), generic_http_callback(), handle_uri(), http_post_callback(), httpd_helper_thread(), httpstatus_callback(), ldap_loadentry(), leave_queue(), load_realtime_queue(), local_ast_moh_start(), manager_sipnotify(), pvt_destructor(), queue_function_queuewaitingcount(), realtime_alias(), realtime_canmatch(), realtime_exec(), realtime_exists(), realtime_handler(), realtime_ldap_base_ap(), realtime_matchmore(), realtime_odbc(), realtime_peer(), realtime_user(), realtimefield_read(), rt_extend_conf(), sip_destroy_peer(), socket_process(), table_configs_free(), and user_destructor().
00386 { 00387 struct ast_variable *vn; 00388 00389 while (v) { 00390 vn = v; 00391 v = v->next; 00392 ast_free(vn); 00393 } 00394 }
| int config_text_file_save | ( | const char * | filename, | |
| const struct ast_config * | cfg, | |||
| const char * | generator | |||
| ) |
Definition at line 1609 of file config.c.
References ast_config_text_file_save().
01610 { 01611 return ast_config_text_file_save(configfile, cfg, generator); 01612 }
| int read_config_maps | ( | void | ) |
Exposed re-initialization method for core process This method is intended for use only with the core re-initialization and is not designed to be called from any user applications.
Definition at line 1902 of file config.c.
References append_mapping(), ast_config_destroy(), ast_config_internal_load(), ast_config_new(), ast_copy_string(), ast_log(), ast_variable_browse(), buf, 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().
01903 { 01904 struct ast_config *config, *configtmp; 01905 struct ast_variable *v; 01906 char *driver, *table, *database, *stringp, *tmp; 01907 struct ast_flags flags = { 0 }; 01908 01909 clear_config_maps(); 01910 01911 configtmp = ast_config_new(); 01912 configtmp->max_include_level = 1; 01913 config = ast_config_internal_load(extconfig_conf, configtmp, flags, "", "extconfig"); 01914 if (!config) { 01915 ast_config_destroy(configtmp); 01916 return 0; 01917 } 01918 01919 for (v = ast_variable_browse(config, "settings"); v; v = v->next) { 01920 char buf[512]; 01921 ast_copy_string(buf, v->value, sizeof(buf)); 01922 stringp = buf; 01923 driver = strsep(&stringp, ","); 01924 01925 if ((tmp = strchr(stringp, '\"'))) 01926 stringp = tmp; 01927 01928 /* check if the database text starts with a double quote */ 01929 if (*stringp == '"') { 01930 stringp++; 01931 database = strsep(&stringp, "\""); 01932 strsep(&stringp, ","); 01933 } else { 01934 /* apparently this text has no quotes */ 01935 database = strsep(&stringp, ","); 01936 } 01937 01938 table = strsep(&stringp, ","); 01939 01940 if (!strcmp(v->name, extconfig_conf)) { 01941 ast_log(LOG_WARNING, "Cannot bind '%s'!\n", extconfig_conf); 01942 continue; 01943 } 01944 01945 if (!strcmp(v->name, "asterisk.conf")) { 01946 ast_log(LOG_WARNING, "Cannot bind 'asterisk.conf'!\n"); 01947 continue; 01948 } 01949 01950 if (!strcmp(v->name, "logger.conf")) { 01951 ast_log(LOG_WARNING, "Cannot bind 'logger.conf'!\n"); 01952 continue; 01953 } 01954 01955 if (!driver || !database) 01956 continue; 01957 if (!strcasecmp(v->name, "sipfriends")) { 01958 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"); 01959 append_mapping("sipusers", driver, database, table ? table : "sipfriends"); 01960 append_mapping("sippeers", driver, database, table ? table : "sipfriends"); 01961 } else if (!strcasecmp(v->name, "iaxfriends")) { 01962 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"); 01963 append_mapping("iaxusers", driver, database, table ? table : "iaxfriends"); 01964 append_mapping("iaxpeers", driver, database, table ? table : "iaxfriends"); 01965 } else 01966 append_mapping(v->name, driver, database, table); 01967 } 01968 01969 ast_config_destroy(config); 01970 return 0; 01971 }
| int register_config_cli | ( | void | ) |
Exposed initialization method for core process This method is intended for use only with the core initialization and is not designed to be called from any user applications.
Definition at line 2577 of file config.c.
References ARRAY_LEN, and ast_cli_register_multiple().
Referenced by main().
02578 { 02579 ast_cli_register_multiple(cli_config, ARRAY_LEN(cli_config)); 02580 return 0; 02581 }
1.5.6