diff options
Diffstat (limited to 'main')
| -rw-r--r-- | main/asterisk.c | 2 | ||||
| -rw-r--r-- | main/config_options.c | 534 | ||||
| -rw-r--r-- | main/named_acl.c | 51 | ||||
| -rw-r--r-- | main/udptl.c | 37 | ||||
| -rw-r--r-- | main/xml.c | 39 | ||||
| -rw-r--r-- | main/xmldoc.c | 254 |
6 files changed, 861 insertions, 56 deletions
diff --git a/main/asterisk.c b/main/asterisk.c index 243321dda..1d5371938 100644 --- a/main/asterisk.c +++ b/main/asterisk.c @@ -4170,6 +4170,8 @@ int main(int argc, char *argv[]) ast_xmldoc_load_documentation(); #endif + aco_init(); + if (astdb_init()) { printf("%s", term_quit()); exit(1); diff --git a/main/config_options.c b/main/config_options.c index 5e76a7a7b..7a65cc555 100644 --- a/main/config_options.c +++ b/main/config_options.c @@ -31,11 +31,15 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include <regex.h> +#include "asterisk/_private.h" #include "asterisk/config.h" #include "asterisk/config_options.h" #include "asterisk/stringfields.h" #include "asterisk/acl.h" #include "asterisk/frame.h" +#include "asterisk/xmldoc.h" +#include "asterisk/cli.h" +#include "asterisk/term.h" #ifdef LOW_MEMORY #define CONFIG_OPT_BUCKETS 5 @@ -70,6 +74,26 @@ struct aco_option { intptr_t args[0]; }; +#ifdef AST_XML_DOCS +static struct ao2_container *xmldocs; +#endif /* AST_XML_DOCS */ + +/*! \brief Value of the aco_option_type enum as strings */ +static char *aco_option_type_string[] = { + "ACL", /* OPT_ACL_T, */ + "Boolean", /* OPT_BOOL_T, */ + "Boolean", /* OPT_BOOLFLAG_T, */ + "String", /* OPT_CHAR_ARRAY_T, */ + "Codec", /* OPT_CODEC_T, */ + "Custom", /* OPT_CUSTOM_T, */ + "Double", /* OPT_DOUBLE_T, */ + "Integer", /* OPT_INT_T, */ + "None", /* OPT_NOOP_T, */ + "IP Address", /* OPT_SOCKADDR_T, */ + "String", /* OPT_STRINGFIELD_T, */ + "Unsigned Integer", /* OPT_UINT_T, */ +}; + void *aco_pending_config(struct aco_info *info) { if (!(info && info->internal)) { @@ -100,6 +124,11 @@ static int codec_handler_fn(const struct aco_option *opt, struct ast_variable *v static int noop_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj); static int chararray_handler_fn(const struct aco_option *opt, struct ast_variable *var, void *obj); +#ifdef AST_XML_DOCS +static int xmldoc_update_config_type(const char *module, const char *name, const char *category, const char *matchfield, const char *matchvalue, unsigned int matches); +static int xmldoc_update_config_option(struct aco_type **types, const char *module, const char *name, const char *object_name, const char *default_value, unsigned int regex, enum aco_option_type type); +#endif + static aco_option_handler ast_config_option_default_handler(enum aco_option_type type) { switch(type) { @@ -142,7 +171,7 @@ static regex_t *build_regex(const char *text) return regex; } -static int link_option_to_types(struct aco_type **types, struct aco_option *opt) +static int link_option_to_types(struct aco_info *info, struct aco_type **types, struct aco_option *opt) { size_t idx = 0; struct aco_type *type; @@ -152,7 +181,11 @@ static int link_option_to_types(struct aco_type **types, struct aco_option *opt) ast_log(LOG_ERROR, "Attempting to register option using uninitialized type\n"); return -1; } - if (!ao2_link(type->internal->opts, opt)) { + if (!ao2_link(type->internal->opts, opt) +#ifdef AST_XML_DOCS + || xmldoc_update_config_option(types, info->module, opt->name, type->name, opt->default_val, opt->match_type == ACO_REGEX, opt->type) +#endif /* AST_XML_DOCS */ + ) { while (--idx) { ao2_unlink(types[idx]->internal->opts, opt); } @@ -181,7 +214,7 @@ int aco_option_register_deprecated(struct aco_info *info, const char *name, stru opt->deprecated = 1; opt->match_type = ACO_EXACT; - if (link_option_to_types(types, opt)) { + if (link_option_to_types(info, types, opt)) { ao2_ref(opt, -1); return -1; } @@ -189,6 +222,53 @@ int aco_option_register_deprecated(struct aco_info *info, const char *name, stru return 0; } +#ifdef AST_XML_DOCS +/*! \internal + * \brief Find a particular ast_xml_doc_item from it's parent config_info, types, and name + */ +static struct ast_xml_doc_item *find_xmldoc_option(struct ast_xml_doc_item *config_info, struct aco_type **types, const char *name) +{ + struct ast_xml_doc_item *iter = config_info; + + if (!iter) { + return NULL; + } + /* First is just the configInfo, we can skip it */ + while ((iter = iter->next)) { + size_t x; + if (strcasecmp(iter->name, name)) { + continue; + } + for (x = 0; types[x]; x++) { + /* All we care about is that at least one type has the option */ + if (!strcasecmp(types[x]->name, iter->ref)) { + return iter; + } + } + } + return NULL; +} + +/*! \internal + * \brief Find a particular ast_xml_doc_item from it's parent config_info and name + */ +static struct ast_xml_doc_item *find_xmldoc_type(struct ast_xml_doc_item *config_info, const char *name) +{ + struct ast_xml_doc_item *iter = config_info; + if (!iter) { + return NULL; + } + /* First is just the config Info, skip it */ + while ((iter = iter->next)) { + if (!strcasecmp(iter->type, "configObject") && !strcasecmp(iter->name, name)) { + break; + } + } + return iter; +} + +#endif /* AST_XML_DOCS */ + int __aco_option_register(struct aco_info *info, const char *name, enum aco_matchtype matchtype, struct aco_type **types, const char *default_val, enum aco_option_type kind, aco_option_handler handler, unsigned int flags, size_t argc, ...) { @@ -235,7 +315,7 @@ int __aco_option_register(struct aco_info *info, const char *name, enum aco_matc return -1; }; - if (link_option_to_types(types, opt)) { + if (link_option_to_types(info, types, opt)) { ao2_ref(opt, -1); return -1; } @@ -535,10 +615,10 @@ try_alias: } if (res != ACO_PROCESS_OK) { - goto end; + goto end; } - if (info->pre_apply_config && (info->pre_apply_config())) { + if (info->pre_apply_config && (info->pre_apply_config())) { res = ACO_PROCESS_ERROR; goto end; } @@ -648,18 +728,26 @@ static int internal_type_init(struct aco_type *type) int aco_info_init(struct aco_info *info) { - size_t x, y; + size_t x = 0, y = 0; + struct aco_file *file; + struct aco_type *type; if (!(info->internal = ast_calloc(1, sizeof(*info->internal)))) { return -1; } - for (x = 0; info->files[x]; x++) { - for (y = 0; info->files[x]->types[y]; y++) { - if (internal_type_init(info->files[x]->types[y])) { + while ((file = info->files[x++])) { + while ((type = file->types[y++])) { + if (internal_type_init(type)) { + goto error; + } +#ifdef AST_XML_DOCS + if (xmldoc_update_config_type(info->module, type->name, type->category, type->matchfield, type->matchvalue, type->category_match == ACO_WHITELIST)) { goto error; } +#endif /* AST_XML_DOCS */ } + y = 0; } return 0; @@ -714,6 +802,428 @@ int aco_set_defaults(struct aco_type *type, const char *category, void *obj) return 0; } +#ifdef AST_XML_DOCS + +/*! \internal + * \brief Complete the name of the module the user is looking for + */ +static char *complete_config_module(const char *word, int pos, int state) +{ + char *c = NULL; + size_t wordlen = strlen(word); + int which = 0; + struct ao2_iterator i; + struct ast_xml_doc_item *cur; + + if (pos != 3) { + return NULL; + } + + i = ao2_iterator_init(xmldocs, 0); + while ((cur = ao2_iterator_next(&i))) { + if (!strncasecmp(word, cur->name, wordlen) && ++which > state) { + c = ast_strdup(cur->name); + ao2_ref(cur, -1); + break; + } + ao2_ref(cur, -1); + } + ao2_iterator_destroy(&i); + + return c; +} + +/*! \internal + * \brief Complete the name of the configuration type the user is looking for + */ +static char *complete_config_type(const char *module, const char *word, int pos, int state) +{ + char *c = NULL; + size_t wordlen = strlen(word); + int which = 0; + RAII_VAR(struct ast_xml_doc_item *, info, NULL, ao2_cleanup); + struct ast_xml_doc_item *cur; + + if (pos != 4) { + return NULL; + } + + if (!(info = ao2_find(xmldocs, module, OBJ_KEY))) { + return NULL; + } + + cur = info; + while ((cur = cur->next)) { + if (!strcasecmp(cur->type, "configObject") && !strncasecmp(word, cur->name, wordlen) && ++which > state) { + c = ast_strdup(cur->name); + break; + } + } + return c; +} + +/*! \internal + * \brief Complete the name of the configuration option the user is looking for + */ +static char *complete_config_option(const char *module, const char *option, const char *word, int pos, int state) +{ + char *c = NULL; + size_t wordlen = strlen(word); + int which = 0; + RAII_VAR(struct ast_xml_doc_item *, info, NULL, ao2_cleanup); + struct ast_xml_doc_item *cur; + + if (pos != 5) { + return NULL; + } + + if (!(info = ao2_find(xmldocs, module, OBJ_KEY))) { + return NULL; + } + + cur = info; + while ((cur = cur->next)) { + if (!strcasecmp(cur->type, "configOption") && !strcasecmp(cur->ref, option) && !strncasecmp(word, cur->name, wordlen) && ++which > state) { + c = ast_strdup(cur->name); + break; + } + } + return c; +} + +/* Define as 0 if we want to allow configurations to be registered without + * documentation + */ +#define XMLDOC_STRICT 1 + +/*! \internal + * \brief Update the XML documentation for a config type based on its registration + */ +static int xmldoc_update_config_type(const char *module, const char *name, const char *category, const char *matchfield, const char *matchvalue, unsigned int matches) +{ + RAII_VAR(struct ast_xml_xpath_results *, results, NULL, ast_xml_xpath_results_free); + RAII_VAR(struct ast_xml_doc_item *, config_info, ao2_find(xmldocs, module, OBJ_KEY), ao2_cleanup); + struct ast_xml_doc_item *config_type; + struct ast_xml_node *type, *syntax, *matchinfo, *tmp; + + /* If we already have a syntax element, bail. This isn't an error, since we may unload a module which + * has updated the docs and then load it again. */ + if ((results = ast_xmldoc_query("//configInfo[@name='%s']/*/configObject[@name='%s']/syntax", module, name))) { + return 0; + } + + if (!(results = ast_xmldoc_query("//configInfo[@name='%s']/*/configObject[@name='%s']", module, name))) { + ast_log(LOG_WARNING, "Cannot update type '%s' in module '%s' because it has no existing documentation!\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(type = ast_xml_xpath_get_first_result(results))) { + ast_log(LOG_WARNING, "Could not retrieve documentation for type '%s' in module '%s'\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(syntax = ast_xml_new_child(type, "syntax"))) { + ast_log(LOG_WARNING, "Could not create syntax node for type '%s' in module '%s'\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(matchinfo = ast_xml_new_child(syntax, "matchInfo"))) { + ast_log(LOG_WARNING, "Could not create matchInfo node for type '%s' in module '%s'\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(tmp = ast_xml_new_child(matchinfo, "category"))) { + ast_log(LOG_WARNING, "Could not create category node for type '%s' in module '%s'\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + ast_xml_set_text(tmp, category); + ast_xml_set_attribute(tmp, "match", matches ? "true" : "false"); + + if (!ast_strlen_zero(matchfield) && !(tmp = ast_xml_new_child(matchinfo, "field"))) { + ast_log(LOG_WARNING, "Could not add %s attribute for type '%s' in module '%s'\n", matchfield, name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + ast_xml_set_attribute(tmp, "name", matchfield); + ast_xml_set_text(tmp, matchvalue); + + if (!config_info || !(config_type = find_xmldoc_type(config_info, name))) { + ast_log(LOG_WARNING, "Could not obtain XML documentation item for config type %s\n", name); + return XMLDOC_STRICT ? -1 : 0; + } + + if (ast_xmldoc_regenerate_doc_item(config_type)) { + ast_log(LOG_WARNING, "Could not update type '%s' with values from config type registration\n", name); + return XMLDOC_STRICT ? -1 : 0; + } + + return 0; +} + +/*! \internal + * \brief Update the XML documentation for a config option based on its registration + */ +static int xmldoc_update_config_option(struct aco_type **types, const char *module, const char *name, const char *object_name, const char *default_value, unsigned int regex, enum aco_option_type type) +{ + RAII_VAR(struct ast_xml_xpath_results *, results, NULL, ast_xml_xpath_results_free); + RAII_VAR(struct ast_xml_doc_item *, config_info, ao2_find(xmldocs, module, OBJ_KEY), ao2_cleanup); + struct ast_xml_doc_item * config_option; + struct ast_xml_node *option; + + ast_assert(ARRAY_LEN(aco_option_type_string) > type); + + if (!config_info || !(config_option = find_xmldoc_option(config_info, types, name))) { + ast_log(LOG_ERROR, "XML Documentation for option '%s' in modules '%s' not found!\n", name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(results = ast_xmldoc_query("//configInfo[@name='%s']/*/configObject[@name='%s']/configOption[@name='%s']", module, object_name, name))) { + ast_log(LOG_WARNING, "Could not find option '%s' with type '%s' in module '%s'\n", name, object_name, module); + return XMLDOC_STRICT ? -1 : 0; + } + + if (!(option = ast_xml_xpath_get_first_result(results))) { + ast_log(LOG_WARNING, "Could obtain results for option '%s' with type '%s' in module '%s'\n", name, object_name, module); + return XMLDOC_STRICT ? -1 : 0; + } + ast_xml_set_attribute(option, "regex", regex ? "true" : "false"); + ast_xml_set_attribute(option, "default", default_value); + ast_xml_set_attribute(option, "type", aco_option_type_string[type]); + + if (ast_xmldoc_regenerate_doc_item(config_option)) { + ast_log(LOG_WARNING, "Could not update option '%s' with values from config option registration\n", name); + return XMLDOC_STRICT ? -1 : 0; + } + + return 0; +} + +/*! \internal + * \brief Show the modules with configuration information + */ +static void cli_show_modules(struct ast_cli_args *a) +{ + struct ast_xml_doc_item *item; + struct ao2_iterator it_items; + + ast_assert(a->argc == 3); + + if (ao2_container_count(xmldocs) == 0) { + ast_cli(a->fd, "No modules found.\n"); + return; + } + + it_items = ao2_iterator_init(xmldocs, 0); + ast_cli(a->fd, "The following modules have configuration information:\n"); + while ((item = ao2_iterator_next(&it_items))) { + ast_cli(a->fd, "\t%s\n", item->name); + ao2_ref(item, -1); + } + ao2_iterator_destroy(&it_items); +} + +/*! \internal + * \brief Show the configuration types for a module + */ +static void cli_show_module_types(struct ast_cli_args *a) +{ + RAII_VAR(struct ast_xml_doc_item *, item, NULL, ao2_cleanup); + struct ast_xml_doc_item *tmp; + + ast_assert(a->argc == 4); + + if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) { + ast_cli(a->fd, "Module %s not found.\n", a->argv[3]); + return; + } + + if (ast_str_strlen(item->synopsis)) { + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(item->synopsis), 1)); + } + if (ast_str_strlen(item->description)) { + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(item->description), 1)); + } + + tmp = item; + ast_cli(a->fd, "Configuration option types for %s:\n", tmp->name); + while ((tmp = tmp->next)) { + if (!strcasecmp(tmp->type, "configObject")) { + ast_cli(a->fd, "%-25s -- %-65.65s\n", tmp->name, + ast_str_buffer(tmp->synopsis)); + } + } +} + +/*! \internal + * \brief Show the information for a configuration type + */ +static void cli_show_module_type(struct ast_cli_args *a) +{ + RAII_VAR(struct ast_xml_doc_item *, item, NULL, ao2_cleanup); + struct ast_xml_doc_item *tmp; + char option_type[64]; + int match = 0; + + ast_assert(a->argc == 5); + + if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) { + ast_cli(a->fd, "Unknown module %s\n", a->argv[3]); + return; + } + + tmp = item; + while ((tmp = tmp->next)) { + if (!strcasecmp(tmp->type, "configObject") && !strcasecmp(tmp->name, a->argv[4])) { + match = 1; + term_color(option_type, tmp->name, COLOR_MAGENTA, COLOR_BLACK, sizeof(option_type)); + ast_cli(a->fd, "%s", option_type); + if (ast_str_strlen(tmp->syntax)) { + ast_cli(a->fd, ": [%s]\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->syntax), 1)); + } else { + ast_cli(a->fd, "\n\n"); + } + if (ast_str_strlen(tmp->synopsis)) { + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->synopsis), 1)); + } + if (ast_str_strlen(tmp->description)) { + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->description), 1)); + } + } + } + + if (!match) { + ast_cli(a->fd, "Unknown configuration type %s\n", a->argv[4]); + return; + } + + /* Now iterate over the options for the type */ + tmp = item; + while ((tmp = tmp->next)) { + if (!strcasecmp(tmp->type, "configOption") && !strcasecmp(tmp->ref, a->argv[4])) { + ast_cli(a->fd, "%-25s -- %-65.65s\n", tmp->name, + ast_str_buffer(tmp->synopsis)); + } + } +} + +/*! \internal + * \brief Show detailed information for an option + */ +static void cli_show_module_options(struct ast_cli_args *a) +{ + RAII_VAR(struct ast_xml_doc_item *, item, NULL, ao2_cleanup); + struct ast_xml_doc_item *tmp; + char option_name[64]; + int match = 0; + + ast_assert(a->argc == 6); + + if (!(item = ao2_find(xmldocs, a->argv[3], OBJ_KEY))) { + ast_cli(a->fd, "Unknown module %s\n", a->argv[3]); + return; + } + tmp = item; + while ((tmp = tmp->next)) { + if (!strcasecmp(tmp->type, "configOption") && !strcasecmp(tmp->ref, a->argv[4]) && !strcasecmp(tmp->name, a->argv[5])) { + if (match) { + ast_cli(a->fd, "\n"); + } + term_color(option_name, tmp->ref, COLOR_MAGENTA, COLOR_BLACK, sizeof(option_name)); + ast_cli(a->fd, "[%s%s]\n", option_name, term_end()); + if (ast_str_strlen(tmp->syntax)) { + ast_cli(a->fd, "%s\n", ast_xmldoc_printable(ast_str_buffer(tmp->syntax), 1)); + } + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(AS_OR(tmp->synopsis, "No information available"), 1)); + if (ast_str_strlen(tmp->description)) { + ast_cli(a->fd, "%s\n\n", ast_xmldoc_printable(ast_str_buffer(tmp->description), 1)); + } + + match = 1; + } + } + + if (!match) { + ast_cli(a->fd, "No option %s found for %s:%s\n", a->argv[5], a->argv[3], a->argv[4]); + } +} + +static char *cli_show_help(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + switch (cmd) { + case CLI_INIT: + e->command = "config show help"; + e->usage = + "Usage: config show help [<module> [<type> [<option>]]]\n" + " Display detailed information about module configuration.\n" + " * If nothing is specified, the modules that have\n" + " configuration information are listed.\n" + " * If <module> is specified, the configuration types\n" + " for that module will be listed, along with brief\n" + " information about that type.\n" + " * If <module> and <type> are specified, detailed\n" + " information about the type is displayed, as well\n" + " as the available options.\n" + " * If <module>, <type>, and <option> are specified,\n" + " detailed information will be displayed about that\n" + " option.\n" + " NOTE: the help documentation is partially generated at run\n" + " time when a module is loaded. If a module is not loaded,\n" + " configuration help for that module may be incomplete.\n"; + return NULL; + case CLI_GENERATE: + switch(a->pos) { + case 3: return complete_config_module(a->word, a->pos, a->n); + case 4: return complete_config_type(a->argv[3], a->word, a->pos, a->n); + case 5: return complete_config_option(a->argv[3], a->argv[4], a->word, a->pos, a->n); + default: return NULL; + } + } + + switch (a->argc) { + case 3: + cli_show_modules(a); + break; + case 4: + cli_show_module_types(a); + break; + case 5: + cli_show_module_type(a); + break; + case 6: + cli_show_module_options(a); + break; + default: + return CLI_SHOWUSAGE; + } + + return CLI_SUCCESS; +} + +static struct ast_cli_entry cli_aco[] = { + AST_CLI_DEFINE(cli_show_help, "Show configuration help for a module"), +}; + +static void aco_deinit(void) +{ + ast_cli_unregister(cli_aco); + ao2_cleanup(xmldocs); +} +#endif /* AST_XML_DOCS */ + +int aco_init(void) +{ +#ifdef AST_XML_DOCS + ast_register_atexit(aco_deinit); + if (!(xmldocs = ast_xmldoc_build_documentation("configInfo"))) { + ast_log(LOG_ERROR, "Couldn't build config documentation\n"); + return -1; + } + ast_cli_register_multiple(cli_aco, ARRAY_LEN(cli_aco)); +#endif /* AST_XML_DOCS */ + return 0; +} + /* Default config option handlers */ /*! \brief Default option handler for signed integers @@ -730,7 +1240,7 @@ static int int_handler_fn(const struct aco_option *opt, struct ast_variable *var ast_parse_arg(var->value, flags, field, (int) opt->args[1], (int) opt->args[2]); if (res) { if (opt->flags & PARSE_RANGE_DEFAULTS) { - ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]); + ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]); res = 0; } else if (opt->flags & PARSE_DEFAULT) { ast_log(LOG_WARNING, "Failed to set %s=%s, Set to default value %d instead.\n", var->name, var->value, *field); @@ -760,7 +1270,7 @@ static int uint_handler_fn(const struct aco_option *opt, struct ast_variable *va ast_parse_arg(var->value, flags, field, (unsigned int) opt->args[1], (unsigned int) opt->args[2]); if (res) { if (opt->flags & PARSE_RANGE_DEFAULTS) { - ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]); + ast_log(LOG_WARNING, "Failed to set %s=%s. Set to %d instead due to range limit (%d, %d)\n", var->name, var->value, *field, (int) opt->args[1], (int) opt->args[2]); res = 0; } else if (opt->flags & PARSE_DEFAULT) { ast_log(LOG_WARNING, "Failed to set %s=%s, Set to default value %d instead.\n", var->name, var->value, *field); diff --git a/main/named_acl.c b/main/named_acl.c index 074f4c57f..142693194 100644 --- a/main/named_acl.c +++ b/main/named_acl.c @@ -44,11 +44,21 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #define NACL_CONFIG "acl.conf" #define ACL_FAMILY "acls" -struct named_acl_global_config { - AST_DECLARE_STRING_FIELDS( - /* Nothing here yet. */ - ); -}; +/*** DOCUMENTATION + <configInfo name="named_acl" language="en_US"> + <configFile name="named_acl.conf"> + <configObject name="named_acl"> + <synopsis>Options for configuring a named ACL</synopsis> + <configOption name="permit"> + <synopsis>An address/subnet from which to allow access</synopsis> + </configOption> + <configOption name="deny"> + <synopsis>An address/subnet from which to disallow access</synopsis> + </configOption> + </configObject> + </configFile> + </configInfo> +***/ /* * Configuration structure - holds pointers to ao2 containers used for configuration @@ -56,7 +66,6 @@ struct named_acl_global_config { * time, it's really a config options friendly wrapper for the named ACL container */ struct named_acl_config { - struct named_acl_global_config *global; struct ao2_container *named_acl_list; }; @@ -70,6 +79,7 @@ static void *named_acl_find(struct ao2_container *container, const char *cat); /* Config type for named ACL profiles (must not be named general) */ static struct aco_type named_acl_type = { .type = ACO_ITEM, /*!< named_acls are items stored in containers, not individual global objects */ + .name = "named_acl", .category_match = ACO_BLACKLIST, .category = "^general$", /*!< Match everything but "general" */ .item_alloc = named_acl_alloc, /*!< A callback to allocate a new named_acl based on category */ @@ -77,26 +87,16 @@ static struct aco_type named_acl_type = { .item_offset = offsetof(struct named_acl_config, named_acl_list), /*!< Could leave this out since 0 */ }; -/* Config type for the general part of the ACL profile (must be named general) */ -static struct aco_type global_option = { - .type = ACO_GLOBAL, - .item_offset = offsetof(struct named_acl_config, global), - .category_match = ACO_WHITELIST, - .category = "^general$", -}; - /* This array of aco_type structs is necessary to use aco_option_register */ struct aco_type *named_acl_types[] = ACO_TYPES(&named_acl_type); -struct aco_type *global_options[] = ACO_TYPES(&global_option); - struct aco_file named_acl_conf = { .filename = "acl.conf", - .types = ACO_TYPES(&named_acl_type, &global_option), + .types = ACO_TYPES(&named_acl_type), }; /* Create a config info struct that describes the config processing for named ACLs. */ -CONFIG_INFO_STANDARD(cfg_info, globals, named_acl_config_alloc, +CONFIG_INFO_CORE("named_acl", cfg_info, globals, named_acl_config_alloc, .files = ACO_FILES(&named_acl_conf), ); @@ -124,13 +124,6 @@ static void named_acl_config_destructor(void *obj) { struct named_acl_config *cfg = obj; ao2_cleanup(cfg->named_acl_list); - ao2_cleanup(cfg->global); -} - -static void named_acl_global_config_destructor(void *obj) -{ - struct named_acl_global_config *global = obj; - ast_string_field_free_memory(global); } /*! \brief allocator callback for named_acl_config. Notice it returns void * since it is used by @@ -144,14 +137,6 @@ static void *named_acl_config_alloc(void) return NULL; } - if (!(cfg->global = ao2_alloc(sizeof(*cfg->global), named_acl_global_config_destructor))) { - goto error; - } - - if (ast_string_field_init(cfg->global, 128)) { - goto error; - } - if (!(cfg->named_acl_list = ao2_container_alloc(37, named_acl_hash_fn, named_acl_cmp_fn))) { goto error; } diff --git a/main/udptl.c b/main/udptl.c index 37f04d530..8ae8334a9 100644 --- a/main/udptl.c +++ b/main/udptl.c @@ -80,6 +80,40 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include "asterisk/cli.h" #include "asterisk/unaligned.h" +/*** DOCUMENTATION + <configInfo name="udptl" language="en_US"> + <configFile name="udptl.conf"> + <configObject name="global"> + <synopsis>Global options for configuring UDPTL</synopsis> + <configOption name="udptlstart"> + <synopsis>The start of the UDPTL port range</synopsis> + </configOption> + <configOption name="udptlend"> + <synopsis>The end of the UDPTL port range</synopsis> + </configOption> + <configOption name="udptlchecksums"> + <synopsis>Whether to enable or disable UDP checksums on UDPTL traffic</synopsis> + </configOption> + <configOption name="udptlfecentries"> + <synopsis>The number of error correction entries in a UDPTL packet</synopsis> + </configOption> + <configOption name="udptlfecspan"> + <synopsis>The span over which parity is calculated for FEC in a UDPTL packet</synopsis> + </configOption> + <configOption name="use_even_ports"> + <synopsis>Whether to only use even-numbered UDPTL ports</synopsis> + </configOption> + <configOption name="t38faxudpec"> + <synopsis>Removed</synopsis> + </configOption> + <configOption name="t38faxmaxdatagram"> + <synopsis>Removed</synopsis> + </configOption> + </configObject> + </configFile> + </configInfo> +***/ + #define UDPTL_MTU 1200 #if !defined(FALSE) @@ -206,6 +240,7 @@ static int udptl_pre_apply_config(void); static struct aco_type general_option = { .type = ACO_GLOBAL, + .name = "global", .category_match = ACO_WHITELIST, .item_offset = offsetof(struct udptl_config, general), .category = "^general$", @@ -218,7 +253,7 @@ static struct aco_file udptl_conf = { .types = ACO_TYPES(&general_option), }; -CONFIG_INFO_STANDARD(cfg_info, globals, udptl_snapshot_alloc, +CONFIG_INFO_CORE("udptl", cfg_info, globals, udptl_snapshot_alloc, .files = ACO_FILES(&udptl_conf), .pre_apply_config = udptl_pre_apply_config, ); diff --git a/main/xml.c b/main/xml.c index bdf983e51..5ca4d4ff1 100644 --- a/main/xml.c +++ b/main/xml.c @@ -28,6 +28,7 @@ #include "asterisk.h" #include "asterisk/xml.h" #include "asterisk/logger.h" +#include "asterisk/utils.h" ASTERISK_FILE_VERSION(__FILE__, "$Revision$") @@ -35,6 +36,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include <libxml/parser.h> #include <libxml/tree.h> #include <libxml/xinclude.h> +#include <libxml/xpath.h> /* libxml2 ast_xml implementation. */ @@ -316,5 +318,42 @@ struct ast_xml_node *ast_xml_node_get_parent(struct ast_xml_node *node) return (struct ast_xml_node *) ((xmlNode *) node)->parent; } +struct ast_xml_node *ast_xml_xpath_get_first_result(struct ast_xml_xpath_results *results) +{ + return (struct ast_xml_node *) ((xmlXPathObjectPtr) results)->nodesetval->nodeTab[0]; +} + +void ast_xml_xpath_results_free(struct ast_xml_xpath_results *results) +{ + xmlXPathFreeObject((xmlXPathObjectPtr) results); +} + +int ast_xml_xpath_num_results(struct ast_xml_xpath_results *results) +{ + return ((xmlXPathObjectPtr) results)->nodesetval->nodeNr; +} + +struct ast_xml_xpath_results *ast_xml_query(struct ast_xml_doc *doc, const char *xpath_str) +{ + xmlXPathContextPtr context; + xmlXPathObjectPtr result; + if (!(context = xmlXPathNewContext((xmlDoc *) doc))) { + ast_log(LOG_ERROR, "Could not create XPath context!\n"); + return NULL; + } + result = xmlXPathEvalExpression((xmlChar *) xpath_str, context); + xmlXPathFreeContext(context); + if (!result) { + ast_log(LOG_WARNING, "Error for query: %s\n", xpath_str); + return NULL; + } + if (xmlXPathNodeSetIsEmpty(result->nodesetval)) { + xmlXPathFreeObject(result); + ast_debug(5, "No results for query: %s\n", xpath_str); + return NULL; + } + return (struct ast_xml_xpath_results *) result; +} + #endif /* defined(HAVE_LIBXML2) */ diff --git a/main/xmldoc.c b/main/xmldoc.c index 225ed6611..a38b59852 100644 --- a/main/xmldoc.c +++ b/main/xmldoc.c @@ -38,6 +38,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include "asterisk/term.h" #include "asterisk/astobj2.h" #include "asterisk/xmldoc.h" +#include "asterisk/cli.h" #ifdef AST_XML_DOCS @@ -979,6 +980,10 @@ static char *xmldoc_get_syntax_cmd(struct ast_xml_node *fixnode, const char *nam const char *paramtype, *attrname, *literal; int required, isenum, first = 1, isliteral; + if (!fixnode) { + return NULL; + } + syntax = ast_str_create(128); if (!syntax) { /* at least try to return something... */ @@ -1078,6 +1083,10 @@ static char *xmldoc_get_syntax_manager(struct ast_xml_node *fixnode, const char int required; char *ret; + if (!fixnode) { + return NULL; + } + syntax = ast_str_create(128); if (!syntax) { return ast_strdup(name); @@ -1118,11 +1127,76 @@ static char *xmldoc_get_syntax_manager(struct ast_xml_node *fixnode, const char return ret; } +static char *xmldoc_get_syntax_config_object(struct ast_xml_node *fixnode, const char *name) +{ + struct ast_xml_node *matchinfo, *tmp; + int match; + const char *attr_value; + const char *text; + RAII_VAR(struct ast_str *, syntax, ast_str_create(128), ast_free); + + if (!syntax || !fixnode) { + return NULL; + } + if (!(matchinfo = ast_xml_find_element(ast_xml_node_get_children(fixnode), "matchInfo", NULL, NULL))) { + return NULL; + } + if (!(tmp = ast_xml_find_element(ast_xml_node_get_children(matchinfo), "category", NULL, NULL))) { + return NULL; + } + attr_value = ast_xml_get_attribute(tmp, "match"); + if (attr_value) { + match = ast_true(attr_value); + text = ast_xml_get_text(tmp); + ast_str_set(&syntax, 0, "category %s /%s/", match ? "=~" : "!~", text); + ast_xml_free_attr(attr_value); + } + + if ((tmp = ast_xml_find_element(ast_xml_node_get_children(matchinfo), "field", NULL, NULL))) { + text = ast_xml_get_text(tmp); + attr_value = ast_xml_get_attribute(tmp, "name"); + ast_str_append(&syntax, 0, " matchfield: %s = %s", S_OR(attr_value, "Unknown"), text); + ast_xml_free_attr(attr_value); + } + return ast_strdup(ast_str_buffer(syntax)); +} + +static char *xmldoc_get_syntax_config_option(struct ast_xml_node *fixnode, const char *name) +{ + const char *type; + const char *default_value; + const char *regex; + RAII_VAR(struct ast_str *, syntax, ast_str_create(128), ast_free); + + if (!syntax || !fixnode) { + return NULL; + } + type = ast_xml_get_attribute(fixnode, "type"); + default_value = ast_xml_get_attribute(fixnode, "default"); + + regex = ast_xml_get_attribute(fixnode, "regex"); + ast_str_set(&syntax, 0, "%s = [%s] (Default: %s) (Regex: %s)\n", + name, + type, + default_value, + regex ? regex : "False"); + + ast_xml_free_attr(type); + ast_xml_free_attr(default_value); + ast_xml_free_attr(regex); + + return ast_strdup(ast_str_buffer(syntax)); +} + /*! \brief Types of syntax that we are able to generate. */ enum syntaxtype { FUNCTION_SYNTAX, MANAGER_SYNTAX, MANAGER_EVENT_SYNTAX, + CONFIG_INFO_SYNTAX, + CONFIG_FILE_SYNTAX, + CONFIG_OPTION_SYNTAX, + CONFIG_OBJECT_SYNTAX, COMMAND_SYNTAX }; @@ -1131,11 +1205,15 @@ static struct strsyntaxtype { const char *type; enum syntaxtype stxtype; } stxtype[] = { - { "function", FUNCTION_SYNTAX }, - { "application", FUNCTION_SYNTAX }, - { "manager", MANAGER_SYNTAX }, - { "managerEvent", MANAGER_EVENT_SYNTAX }, - { "agi", COMMAND_SYNTAX } + { "function", FUNCTION_SYNTAX }, + { "application", FUNCTION_SYNTAX }, + { "manager", MANAGER_SYNTAX }, + { "managerEvent", MANAGER_EVENT_SYNTAX }, + { "configInfo", CONFIG_INFO_SYNTAX }, + { "configFile", CONFIG_FILE_SYNTAX }, + { "configOption", CONFIG_OPTION_SYNTAX }, + { "configObject", CONFIG_OBJECT_SYNTAX }, + { "agi", COMMAND_SYNTAX }, }; /*! \internal @@ -1170,9 +1248,10 @@ static enum syntaxtype xmldoc_get_syntax_type(const char *type) * * \since 11 */ -static char *_ast_xmldoc_build_syntax(struct ast_xml_node *node, const char *type, const char *name) +static char *_ast_xmldoc_build_syntax(struct ast_xml_node *root_node, const char *type, const char *name) { char *syntax = NULL; + struct ast_xml_node *node = root_node; for (node = ast_xml_node_get_children(node); node; node = ast_xml_node_get_next(node)) { if (!strcasecmp(ast_xml_node_get_name(node), "syntax")) { @@ -1180,10 +1259,6 @@ static char *_ast_xmldoc_build_syntax(struct ast_xml_node *node, const char *typ } } - if (!node) { - return syntax; - } - switch (xmldoc_get_syntax_type(type)) { case FUNCTION_SYNTAX: syntax = xmldoc_get_syntax_fun(node, name, "parameter", 1, 1); @@ -1197,6 +1272,12 @@ static char *_ast_xmldoc_build_syntax(struct ast_xml_node *node, const char *typ case MANAGER_EVENT_SYNTAX: syntax = xmldoc_get_syntax_manager(node, name, "Event"); break; + case CONFIG_OPTION_SYNTAX: + syntax = xmldoc_get_syntax_config_option(root_node, name); + break; + case CONFIG_OBJECT_SYNTAX: + syntax = xmldoc_get_syntax_config_object(node, name); + break; default: syntax = xmldoc_get_syntax_fun(node, name, "parameter", 1, 1); } @@ -2198,6 +2279,7 @@ static struct ast_xml_doc_item *xmldoc_build_documentation_item(struct ast_xml_n if (!(item = ast_xml_doc_item_alloc(name, type))) { return NULL; } + item->node = node; syntax = _ast_xmldoc_build_syntax(node, type, name); seealso = _ast_xmldoc_build_seealso(node); @@ -2230,6 +2312,105 @@ static struct ast_xml_doc_item *xmldoc_build_documentation_item(struct ast_xml_n return item; } +struct ast_xml_xpath_results *__attribute__((format(printf, 1, 2))) ast_xmldoc_query(const char *fmt, ...) +{ + struct ast_xml_xpath_results *results = NULL; + struct documentation_tree *doctree; + RAII_VAR(struct ast_str *, xpath_str, ast_str_create(128), ast_free); + va_list ap; + + if (!xpath_str) { + return NULL; + } + + va_start(ap, fmt); + ast_str_set_va(&xpath_str, 0, fmt, ap); + va_end(ap); + + AST_RWLIST_RDLOCK(&xmldoc_tree); + AST_LIST_TRAVERSE(&xmldoc_tree, doctree, entry) { + if (!(results = ast_xml_query(doctree->doc, ast_str_buffer(xpath_str)))) { + continue; + } + break; + } + AST_RWLIST_UNLOCK(&xmldoc_tree); + + return results; +} + +static void build_config_docs(struct ast_xml_node *cur, struct ast_xml_doc_item **tail) +{ + struct ast_xml_node *iter; + struct ast_xml_doc_item *item; + + for (iter = ast_xml_node_get_children(cur); iter; iter = ast_xml_node_get_next(iter)) { + if (strncasecmp(ast_xml_node_get_name(iter), "config", 6)) { + continue; + } + /* Now add all of the child config-related items to the list */ + if (!(item = xmldoc_build_documentation_item(iter, ast_xml_get_attribute(iter, "name"), ast_xml_node_get_name(iter)))) { + ast_log(LOG_ERROR, "Could not build documentation for '%s:%s'\n", ast_xml_node_get_name(iter), ast_xml_get_attribute(iter, "name")); + break; + } + if (!strcasecmp(ast_xml_node_get_name(iter), "configOption")) { + ast_string_field_set(item, ref, ast_xml_get_attribute(cur, "name")); + } + (*tail)->next = item; + *tail = (*tail)->next; + build_config_docs(iter, tail); + } +} + +int ast_xmldoc_regenerate_doc_item(struct ast_xml_doc_item *item) +{ + const char *name; + char *syntax; + char *seealso; + char *arguments; + char *synopsis; + char *description; + + if (!item || !item->node) { + return -1; + } + + name = ast_xml_get_attribute(item->node, "name"); + if (!name) { + return -1; + } + + syntax = _ast_xmldoc_build_syntax(item->node, item->type, name); + seealso = _ast_xmldoc_build_seealso(item->node); + arguments = _ast_xmldoc_build_arguments(item->node); + synopsis = _ast_xmldoc_build_synopsis(item->node); + description = _ast_xmldoc_build_description(item->node); + + if (syntax) { + ast_str_set(&item->syntax, 0, "%s", syntax); + } + if (seealso) { + ast_str_set(&item->seealso, 0, "%s", seealso); + } + if (arguments) { + ast_str_set(&item->arguments, 0, "%s", arguments); + } + if (synopsis) { + ast_str_set(&item->synopsis, 0, "%s", synopsis); + } + if (description) { + ast_str_set(&item->description, 0, "%s", description); + } + + ast_free(syntax); + ast_free(seealso); + ast_free(arguments); + ast_free(synopsis); + ast_free(description); + ast_xml_free_attr(name); + return 0; +} + struct ao2_container *ast_xmldoc_build_documentation(const char *type) { struct ao2_container *docs; @@ -2282,6 +2463,19 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type) } item = root; break; + case CONFIG_INFO_SYNTAX: + { + struct ast_xml_doc_item *tail; + if (item || !ast_xml_node_get_children(node) || strcasecmp(ast_xml_node_get_name(node), "configInfo")) { + break; + } + if (!(item = xmldoc_build_documentation_item(node, ast_xml_get_attribute(node, "name"), "configInfo"))) { + break; + } + tail = item; + build_config_docs(node, &tail); + break; + } default: item = xmldoc_build_documentation_item(node, name, type); } @@ -2299,6 +2493,9 @@ struct ao2_container *ast_xmldoc_build_documentation(const char *type) return docs; } +int ast_xmldoc_regenerate_doc_item(struct ast_xml_doc_item *item); + + #if !defined(HAVE_GLOB_NOMAGIC) || !defined(HAVE_GLOB_BRACE) || defined(DEBUG_NONGNU) static int xml_pathmatch(char *xmlpattern, int xmlpattern_maxlen, glob_t *globbuf) { @@ -2342,11 +2539,47 @@ static int xml_pathmatch(char *xmlpattern, int xmlpattern_maxlen, glob_t *globbu } #endif +static char *handle_dump_docs(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct documentation_tree *doctree; + FILE *f; + + switch (cmd) { + case CLI_INIT: + e->command = "xmldoc dump"; + e->usage = + "Usage: xmldoc dump <filename>\n" + " Dump XML documentation to a file\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) { + return CLI_SHOWUSAGE; + } + if (!(f = fopen(a->argv[2], "w"))) { + ast_log(LOG_ERROR, "Could not open file '%s': %s\n", a->argv[2], strerror(errno)); + return CLI_FAILURE; + } + AST_RWLIST_RDLOCK(&xmldoc_tree); + AST_LIST_TRAVERSE(&xmldoc_tree, doctree, entry) { + ast_xml_doc_dump_file(f, doctree->doc); + } + AST_RWLIST_UNLOCK(&xmldoc_tree); + fclose(f); + return CLI_SUCCESS; +} + +static struct ast_cli_entry cli_dump_xmldocs = AST_CLI_DEFINE(handle_dump_docs, "Dump the XML docs to the specified file"); + /*! \brief Close and unload XML documentation. */ static void xmldoc_unload_documentation(void) { struct documentation_tree *doctree; + ast_cli_unregister(&cli_dump_xmldocs); + AST_RWLIST_WRLOCK(&xmldoc_tree); while ((doctree = AST_RWLIST_REMOVE_HEAD(&xmldoc_tree, entry))) { ast_free(doctree->filename); @@ -2390,6 +2623,7 @@ int ast_xmldoc_load_documentation(void) /* initialize the XML library. */ ast_xml_init(); + ast_cli_register(&cli_dump_xmldocs); /* register function to be run when asterisk finish. */ ast_register_atexit(xmldoc_unload_documentation); |