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. More...
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. More...
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. More...
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. More...
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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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(), tmp(), 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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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.

Referenced by load_module(), and unload_module().