res_sorcery_config.c File Reference

Sorcery Configuration File Object Wizard. More...

#include "asterisk.h"
#include <regex.h>
#include "asterisk/module.h"
#include "asterisk/sorcery.h"
#include "asterisk/astobj2.h"
#include "asterisk/config.h"
#include "asterisk/uuid.h"
#include "asterisk/hashtab.h"

Include dependency graph for res_sorcery_config.c:

Go to the source code of this file.

Data Structures
struct	sorcery_config
	Structure for storing configuration file sourced objects. More...
struct	sorcery_config_fields_cmp_params
	Structure used for fields comparison. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static void	sorcery_config_close (void *data)
static void	sorcery_config_destructor (void *obj)
	Destructor function for sorcery config.
static int	sorcery_config_fields_cmp (void *obj, void *arg, int flags)
static void	sorcery_config_internal_load (void *data, const struct ast_sorcery *sorcery, const char *type, unsigned int reload)
static void	sorcery_config_load (void *data, const struct ast_sorcery *sorcery, const char *type)
static void *	sorcery_config_open (const char *data)
static void	sorcery_config_reload (void *data, const struct ast_sorcery *sorcery, const char *type)
static void *	sorcery_config_retrieve_fields (const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
static void *	sorcery_config_retrieve_id (const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
static void	sorcery_config_retrieve_multiple (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
static void	sorcery_config_retrieve_prefix (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *prefix, const size_t prefix_len)
static void	sorcery_config_retrieve_regex (const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
static int	sorcery_is_configuration_met (const struct ast_sorcery *sorcery, const char *type, struct ast_category *category, struct sorcery_config *config)
	Internal function which determines if criteria has been met for considering an object set applicable.
static int	sorcery_is_criteria_met (struct ast_category *category, struct sorcery_config *config)
	Internal function which determines if a category matches based on criteria.
static int	sorcery_is_explicit_name_met (const struct ast_sorcery *sorcery, const char *type, struct ast_category *category, struct sorcery_config *config)
	Internal function which determines if a category matches based on explicit name.
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Configuration File Object Wizard" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_sorcery_wizard	config_object_wizard

Detailed Description

Sorcery Configuration File Object Wizard.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file res_sorcery_config.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 567 of file res_sorcery_config.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 567 of file res_sorcery_config.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 567 of file res_sorcery_config.c.

load_module()

static int load_module ( void  )

static

Definition at line 547 of file res_sorcery_config.c.

{
    if (ast_sorcery_wizard_register(&config_object_wizard)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_sorcery_wizard_register, and config_object_wizard.

sorcery_config_close()

static void sorcery_config_close ( void *  data )

static

Definition at line 540 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
 
    ao2_ref(config, -1);
}

References ao2_ref, and config.

sorcery_config_destructor()

static void sorcery_config_destructor ( void *  obj )

static

Destructor function for sorcery config.

Definition at line 122 of file res_sorcery_config.c.

{
    struct sorcery_config *config = obj;
 
    ao2_global_obj_release(config->objects);
    ast_rwlock_destroy(&config->objects.lock);
    ast_variables_destroy(config->criteria);
    ast_free(config->explicit_name);
}

References ao2_global_obj_release, ast_free, ast_rwlock_destroy, ast_variables_destroy(), and config.

Referenced by sorcery_config_open().

sorcery_config_fields_cmp()

static int sorcery_config_fields_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 132 of file res_sorcery_config.c.

{
    const struct sorcery_config_fields_cmp_params *params = arg;
    RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
 
    if (params->regex) {
        /* If a regular expression has been provided see if it matches, otherwise move on */
        if (!regexec(params->regex, ast_sorcery_object_get_id(obj), 0, NULL, 0)) {
            ao2_link(params->container, obj);
        }
        return 0;
    } else if (params->prefix) {
        if (!strncmp(params->prefix, ast_sorcery_object_get_id(obj), params->prefix_len)) {
            ao2_link(params->container, obj);
        }
        return 0;
    } else if (params->fields &&
        (!(objset = ast_sorcery_objectset_create(params->sorcery, obj)) ||
         (!ast_variable_lists_match(objset, params->fields, 0)))) {
        /* If we can't turn the object into an object set OR if differences exist between the fields
         * passed in and what are present on the object they are not a match.
         */
        return 0;
    }
 
    /* We want this object */
    if (params->container) {
        /*
         * We are putting the found objects into the given container instead
         * of the normal container traversal return mechanism.
         */
        ao2_link(params->container, obj);
        return 0;
    } else {
        return CMP_MATCH;
    }
}

References ao2_link, ast_sorcery_object_get_id(), ast_sorcery_objectset_create, ast_variable_lists_match(), ast_variables_destroy(), CMP_MATCH, sorcery_config_fields_cmp_params::container, sorcery_config_fields_cmp_params::fields, NULL, sorcery_config_fields_cmp_params::prefix, sorcery_config_fields_cmp_params::prefix_len, RAII_VAR, sorcery_config_fields_cmp_params::regex, and sorcery_config_fields_cmp_params::sorcery.

Referenced by sorcery_config_retrieve_fields(), sorcery_config_retrieve_multiple(), sorcery_config_retrieve_prefix(), and sorcery_config_retrieve_regex().

sorcery_config_internal_load()

static void sorcery_config_internal_load ( void *  data, const struct ast_sorcery *  sorcery, const char *  type, unsigned int  reload  )

static

Definition at line 316 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    struct ast_flags flags = { reload && !config->configuration_invalid && !config->has_dynamic_contents ? CONFIG_FLAG_FILEUNCHANGED : 0 };
    struct ast_config *cfg = ast_config_load2(config->filename, config->uuid, flags);
    struct ast_category *category = NULL;
    RAII_VAR(struct ao2_container *, objects, NULL, ao2_cleanup);
    const char *id = NULL;
    unsigned int buckets = 0;
    unsigned int has_dynamic_contents = 0;
 
    if (!cfg) {
        ast_log(LOG_ERROR, "Unable to load config file '%s'\n", config->filename);
        return;
    } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
        ast_debug(1, "Config file '%s' was unchanged\n", config->filename);
        return;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Contents of config file '%s' are invalid and cannot be parsed\n", config->filename);
        return;
    }
 
    /* When parsing the configuration assume it is valid until proven otherwise */
    config->configuration_invalid = 0;
 
    if (!config->buckets) {
        while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
 
            /* If given configuration has not been met skip the category, it is not applicable */
            if (!sorcery_is_configuration_met(sorcery, type, category, config)) {
                continue;
            }
 
            buckets++;
        }
 
        /* Determine the optimal number of buckets */
        while (buckets && !ast_is_prime(buckets)) {
            /* This purposely goes backwards to ensure that the container doesn't have a ton of
             * empty buckets for objects that will never get added.
             */
            buckets--;
        }
 
        if (!buckets) {
            buckets = 1;
        }
    } else {
        buckets = config->buckets;
    }
 
    /* For single object configurations there can only ever be one bucket, if there's more than the single
     * object requirement has been violated.
     */
    if (config->single_object && buckets > 1) {
        ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains more than one object of type '%s'\n",
            config->filename, type);
        ast_config_destroy(cfg);
        config->configuration_invalid = 1;
        return;
    }
 
    ast_debug(2, "Using bucket size of '%d' for objects of type '%s' from '%s'\n",
        buckets, type, config->filename);
 
    objects = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, buckets,
        ast_sorcery_object_id_hash, NULL, ast_sorcery_object_id_compare);
    if (!objects) {
        ast_log(LOG_ERROR, "Could not create bucket for new objects from '%s', keeping existing objects\n",
            config->filename);
        ast_config_destroy(cfg);
        config->configuration_invalid = 1; /* Not strictly invalid but we want to try next time */
        return;
    }
 
    while ((category = ast_category_browse_filtered(cfg, NULL, category, NULL))) {
        RAII_VAR(void *, obj, NULL, ao2_cleanup);
        id = ast_category_get_name(category);
 
        /* If given configuration has not been met skip the category, it is not applicable */
        if (!sorcery_is_configuration_met(sorcery, type, category, config)) {
            continue;
        }
 
        /*  Confirm an object with this id does not already exist in the bucket.
         *  If it exists, however, the configuration is invalid so stop
         *  processing and destroy it. */
        obj = ao2_find(objects, id, OBJ_SEARCH_KEY);
        if (obj) {
            ast_log(LOG_ERROR, "Config file '%s' could not be loaded; configuration contains a duplicate object: '%s' of type '%s'\n",
                config->filename, id, type);
            ast_config_destroy(cfg);
            config->configuration_invalid = 1;
            return;
        }
 
        if (!(obj = ast_sorcery_alloc(sorcery, type, id)) ||
            ast_sorcery_objectset_apply(sorcery, obj, ast_category_first(category))) {
 
            if (config->file_integrity) {
                ast_log(LOG_ERROR, "Config file '%s' could not be loaded due to error with object '%s' of type '%s'\n",
                    config->filename, id, type);
                ast_config_destroy(cfg);
                config->configuration_invalid = 1;
                return;
            } else {
                ast_log(LOG_ERROR, "Could not create an object of type '%s' with id '%s' from configuration file '%s'\n",
                    type, id, config->filename);
                config->configuration_invalid = 1;
            }
 
            ao2_cleanup(obj);
 
            /* To ensure we don't lose the object that already exists we retrieve it from the old objects container and add it to the new one */
            if (!(obj = sorcery_config_retrieve_id(sorcery, data, type, id))) {
                continue;
            }
 
            ast_log(LOG_NOTICE, "Retaining existing configuration for object of type '%s' with id '%s'\n", type, id);
        }
 
        /* We store the dynamic contents state until the end in case this reload or load
         * gets rolled back.
         */
        has_dynamic_contents |= ast_sorcery_object_has_dynamic_contents(obj);
 
        ao2_link(objects, obj);
    }
 
    config->has_dynamic_contents = has_dynamic_contents;
    ao2_global_obj_replace_unref(config->objects, objects);
    ast_config_destroy(cfg);
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_container_alloc_hash, ao2_find, ao2_global_obj_replace_unref, ao2_link, ast_category_browse_filtered(), ast_category_first(), ast_category_get_name(), ast_config_destroy(), ast_config_load2(), ast_debug, ast_is_prime(), ast_log, ast_sorcery_alloc(), ast_sorcery_object_has_dynamic_contents(), ast_sorcery_object_id_compare(), ast_sorcery_object_id_hash(), ast_sorcery_objectset_apply(), config, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEUNCHANGED, ast_flags::flags, LOG_ERROR, LOG_NOTICE, NULL, OBJ_SEARCH_KEY, RAII_VAR, reload(), sorcery, sorcery_config_retrieve_id(), sorcery_is_configuration_met(), and type.

Referenced by sorcery_config_load(), and sorcery_config_reload().

sorcery_config_load()

static void sorcery_config_load ( void *  data, const struct ast_sorcery *  sorcery, const char *  type  )

static

Definition at line 450 of file res_sorcery_config.c.

{
    sorcery_config_internal_load(data, sorcery, type, 0);
}

References sorcery, sorcery_config_internal_load(), and type.

sorcery_config_open()

static void * sorcery_config_open ( const char *  data )

static

Definition at line 460 of file res_sorcery_config.c.

{
    char *tmp;
    char *filename;
    char *option;
    struct sorcery_config *config;
 
    if (ast_strlen_zero(data)) {
        return NULL;
    }
 
    tmp = ast_strdupa(data);
    filename = strsep(&tmp, ",");
 
    if (ast_strlen_zero(filename) || !(config = ao2_alloc_options(sizeof(*config) + strlen(filename) + 1, sorcery_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK))) {
        return NULL;
    }
 
    ast_uuid_generate_str(config->uuid, sizeof(config->uuid));
 
    ast_rwlock_init(&config->objects.lock);
    strcpy(config->filename, filename);
 
    while ((option = strsep(&tmp, ","))) {
        char *name = strsep(&option, "="), *value = option;
 
        if (!strcasecmp(name, "buckets")) {
            if (sscanf(value, "%30u", &config->buckets) != 1) {
                ast_log(LOG_ERROR, "Unsupported bucket size of '%s' used for configuration file '%s', defaulting to automatic determination\n",
                    value, filename);
            }
        } else if (!strcasecmp(name, "integrity")) {
            if (!strcasecmp(value, "file")) {
                config->file_integrity = 1;
            } else if (!strcasecmp(value, "object")) {
                config->file_integrity = 0;
            } else {
                ast_log(LOG_ERROR, "Unsupported integrity value of '%s' used for configuration file '%s', defaulting to 'object'\n",
                    value, filename);
            }
        } else if (!strcasecmp(name, "criteria")) {
            char *field = strsep(&value, "=");
            struct ast_variable *criteria = ast_variable_new(field, value, "");
 
            if (criteria) {
                criteria->next = config->criteria;
                config->criteria = criteria;
            } else {
                /* This is fatal since not following criteria would potentially yield invalid objects */
                ast_log(LOG_ERROR, "Could not create criteria entry of field '%s' with value '%s' for configuration file '%s'\n",
                    field, value, filename);
                ao2_ref(config, -1);
                return NULL;
            }
        } else if (!strcasecmp(name, "explicit_name")) {
            ast_free(config->explicit_name);
            config->explicit_name = ast_strdup(value);
            if (ast_strlen_zero(config->explicit_name)) {
                /* This is fatal since it could stop a configuration section from getting applied */
                ast_log(LOG_ERROR, "Could not create explicit name entry of '%s' for configuration file '%s'\n",
                    value, filename);
                ao2_ref(config, -1);
                return NULL;
            }
        } else if (!strcasecmp(name, "single_object")) {
            if (ast_strlen_zero(value)) {
                ast_log(LOG_ERROR, "Could not set single object value for configuration file '%s' as the value is empty\n",
                    filename);
                ao2_ref(config, -1);
                return NULL;
            }
            config->single_object = ast_true(value);
        } else {
            ast_log(LOG_ERROR, "Unsupported option '%s' used for configuration file '%s'\n", name, filename);
        }
    }
 
    return config;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_free, ast_log, ast_rwlock_init, ast_strdup, ast_strdupa, ast_strlen_zero(), ast_true(), ast_uuid_generate_str(), ast_variable_new, config, sorcery_config::filename, LOG_ERROR, name, ast_variable::next, NULL, sorcery_config_destructor(), strsep(), and value.

sorcery_config_reload()

static void sorcery_config_reload ( void *  data, const struct ast_sorcery *  sorcery, const char *  type  )

static

Definition at line 455 of file res_sorcery_config.c.

{
    sorcery_config_internal_load(data, sorcery, type, 1);
}

References sorcery, sorcery_config_internal_load(), and type.

sorcery_config_retrieve_fields()

static void * sorcery_config_retrieve_fields ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const struct ast_variable *  fields  )

static

Definition at line 170 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
    struct sorcery_config_fields_cmp_params params = {
        .sorcery = sorcery,
        .fields = fields,
        .container = NULL,
    };
 
    /* If no fields are present return nothing, we require *something*, same goes if no objects exist yet */
    if (!objects || !fields) {
        return NULL;
    }
 
    return ao2_callback(objects, 0, sorcery_config_fields_cmp, &params);
}

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, config, sorcery_config_fields_cmp_params::fields, NULL, sorcery_config::objects, RAII_VAR, sorcery, sorcery_config_fields_cmp_params::sorcery, and sorcery_config_fields_cmp().

sorcery_config_retrieve_id()

static void * sorcery_config_retrieve_id ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, const char *  id  )

static

Definition at line 188 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    RAII_VAR(struct ao2_container *, objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
 
    return objects ? ao2_find(objects, id, OBJ_SEARCH_KEY) : NULL;
}

References ao2_cleanup, ao2_find, ao2_global_obj_ref, config, NULL, OBJ_SEARCH_KEY, sorcery_config::objects, and RAII_VAR.

Referenced by sorcery_config_internal_load().

sorcery_config_retrieve_multiple()

static void sorcery_config_retrieve_multiple ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const struct ast_variable *  fields  )

static

Definition at line 196 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
    struct sorcery_config_fields_cmp_params params = {
        .sorcery = sorcery,
        .fields = fields,
        .container = objects,
    };
 
    if (!config_objects) {
        return;
    }
 
    ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
}

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, config, sorcery_config_fields_cmp_params::fields, OBJ_MULTIPLE, OBJ_NODATA, RAII_VAR, sorcery, sorcery_config_fields_cmp_params::sorcery, and sorcery_config_fields_cmp().

sorcery_config_retrieve_prefix()

static void sorcery_config_retrieve_prefix ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const char *  prefix, const size_t  prefix_len  )

static

Definition at line 236 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
    struct sorcery_config_fields_cmp_params params = {
        .sorcery = sorcery,
        .container = objects,
        .prefix = prefix,
        .prefix_len = prefix_len,
    };
 
    if (!config_objects) {
        return;
    }
 
    ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
}

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, config, OBJ_MULTIPLE, OBJ_NODATA, prefix, sorcery_config_fields_cmp_params::prefix_len, RAII_VAR, sorcery, sorcery_config_fields_cmp_params::sorcery, and sorcery_config_fields_cmp().

sorcery_config_retrieve_regex()

static void sorcery_config_retrieve_regex ( const struct ast_sorcery *  sorcery, void *  data, const char *  type, struct ao2_container *  objects, const char *  regex  )

static

Definition at line 213 of file res_sorcery_config.c.

{
    struct sorcery_config *config = data;
    RAII_VAR(struct ao2_container *, config_objects, ao2_global_obj_ref(config->objects), ao2_cleanup);
    regex_t expression;
    struct sorcery_config_fields_cmp_params params = {
        .sorcery = sorcery,
        .container = objects,
        .regex = &expression,
    };
 
    if (ast_strlen_zero(regex)) {
        regex = ".";
    }
 
    if (!config_objects || regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
        return;
    }
 
    ao2_callback(config_objects, OBJ_NODATA | OBJ_MULTIPLE, sorcery_config_fields_cmp, &params);
    regfree(&expression);
}

References ao2_callback, ao2_cleanup, ao2_global_obj_ref, ast_strlen_zero(), config, OBJ_MULTIPLE, OBJ_NODATA, RAII_VAR, regex(), sorcery, sorcery_config_fields_cmp_params::sorcery, and sorcery_config_fields_cmp().

sorcery_is_configuration_met()

static int sorcery_is_configuration_met ( const struct ast_sorcery *  sorcery, const char *  type, struct ast_category *  category, struct sorcery_config *  config  )

static

Internal function which determines if criteria has been met for considering an object set applicable.

Definition at line 300 of file res_sorcery_config.c.

{
    if (!config->criteria && ast_strlen_zero(config->explicit_name)) {
        /* Nothing is configured to allow specific matching, so accept it! */
        return 1;
    } else if (sorcery_is_explicit_name_met(sorcery, type, category, config)) {
        return 1;
    } else if (sorcery_is_criteria_met(category, config)) {
        return 1;
    } else {
        /* Nothing explicitly matched so reject */
        return 0;
    }
}

References ast_strlen_zero(), config, sorcery, sorcery_is_criteria_met(), sorcery_is_explicit_name_met(), and type.

Referenced by sorcery_config_internal_load().

sorcery_is_criteria_met()

static int sorcery_is_criteria_met ( struct ast_category *  category, struct sorcery_config *  config  )

static

Internal function which determines if a category matches based on criteria.

Definition at line 288 of file res_sorcery_config.c.

{
    RAII_VAR(struct ast_variable *, diff, NULL, ast_variables_destroy);
 
    if (!config->criteria) {
        return 0;
    }
 
    return (!ast_sorcery_changeset_create(ast_category_first(category), config->criteria, &diff) && !diff) ? 1 : 0;
}

References ast_category_first(), ast_sorcery_changeset_create(), ast_variables_destroy(), config, NULL, and RAII_VAR.

Referenced by sorcery_is_configuration_met().

sorcery_is_explicit_name_met()

static int sorcery_is_explicit_name_met ( const struct ast_sorcery *  sorcery, const char *  type, struct ast_category *  category, struct sorcery_config *  config  )

static

Internal function which determines if a category matches based on explicit name.

Definition at line 255 of file res_sorcery_config.c.

{
    struct ast_sorcery_object_type *object_type;
    struct ast_variable *field;
    int met = 1;
 
    if (ast_strlen_zero(config->explicit_name) || strcmp(ast_category_get_name(category), config->explicit_name)) {
        return 0;
    }
 
    object_type = ast_sorcery_get_object_type(sorcery, type);
    if (!object_type) {
        return 0;
    }
 
    /* We iterate the configured fields to see if we don't know any, if we don't then
     * this is likely not for the given type and we skip it. If it actually is then criteria
     * may pick it up in which case it would just get rejected as an invalid configuration later.
     */
    for (field = ast_category_first(category); field; field = field->next) {
        if (!ast_sorcery_is_object_field_registered(object_type, field->name)) {
            met = 0;
            break;
        }
    }
 
    ao2_ref(object_type, -1);
 
    return met;
}

References ao2_ref, ast_category_first(), ast_category_get_name(), ast_sorcery_get_object_type(), ast_sorcery_is_object_field_registered(), ast_strlen_zero(), config, ast_variable::name, ast_variable::next, sorcery, and type.

Referenced by sorcery_is_configuration_met().

unload_module()

static int unload_module ( void  )

static

Definition at line 556 of file res_sorcery_config.c.

{
    ast_sorcery_wizard_unregister(&config_object_wizard);
    return 0;
}

References ast_sorcery_wizard_unregister(), and config_object_wizard.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Sorcery Configuration File Object Wizard" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_REALTIME_DRIVER, }

static

Definition at line 567 of file res_sorcery_config.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 567 of file res_sorcery_config.c.

config_object_wizard

struct ast_sorcery_wizard config_object_wizard

static

Definition at line 107 of file res_sorcery_config.c.

                                                        {
    .name = "config",
    .open = sorcery_config_open,
    .load = sorcery_config_load,
    .reload = sorcery_config_reload,
    .force_reload = sorcery_config_load,
    .retrieve_id = sorcery_config_retrieve_id,
    .retrieve_fields = sorcery_config_retrieve_fields,
    .retrieve_multiple = sorcery_config_retrieve_multiple,
    .retrieve_regex = sorcery_config_retrieve_regex,
    .retrieve_prefix = sorcery_config_retrieve_prefix,
    .close = sorcery_config_close,
};

Referenced by load_module(), and unload_module().