named_acl.c File Reference

Named Access Control Lists. More...

#include "asterisk.h"
#include "asterisk/config.h"
#include "asterisk/config_options.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/acl.h"
#include "asterisk/astobj2.h"
#include "asterisk/paths.h"
#include "asterisk/stasis.h"
#include "asterisk/json.h"
#include "asterisk/security_events.h"

Include dependency graph for named_acl.c:

Go to the source code of this file.

Data Structures
struct	named_acl
struct	named_acl_config

Macros
#define	ACL_FAMILY   "acls"
#define	AST_MODULE   "acl"
#define	NACL_CONFIG   "acl.conf"

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	acl_order_comparator (struct ast_category *p, struct ast_category *q)
static	AO2_GLOBAL_OBJ_STATIC (globals)
struct ast_module *	AST_MODULE_SELF_SYM (void)
struct ast_ha *	ast_named_acl_find (const char *name, int *is_realtime, int *is_undefined)
	Retrieve a named ACL.
static void	cli_display_named_acl (int fd, const char *name)
static void	cli_display_named_acl_list (int fd)
	CONFIG_INFO_CORE ("named_acl", cfg_info, globals, named_acl_config_alloc,.files=ACO_FILES(&named_acl_conf),)
static void	destroy_named_acl (void *obj)
	Destroy a named ACL object.
static char *	handle_show_named_acl_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	ACL command show <name>
static int	load_module (void)
static void *	named_acl_alloc (const char *cat)
	Create a named ACL structure.
static void *	named_acl_config_alloc (void)
	allocator callback for named_acl_config. Notice it returns void * since it is used by the backend config code
static void	named_acl_config_destructor (void *obj)
	destructor for named_acl_config
static void *	named_acl_find (struct ao2_container *container, const char *cat)
	Find a named ACL in a container by its name.
static struct named_acl *	named_acl_find_realtime (const char *name)
static int	publish_acl_change (const char *name)
static int	reload_module (void)
	STASIS_MESSAGE_TYPE_DEFN (ast_named_acl_change_type)
	Message type for named ACL changes.
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 = "Named ACL system" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_named_acl []
struct aco_file	named_acl_conf
static struct aco_type	named_acl_type
struct aco_type *	named_acl_types [] = ACO_TYPES(&named_acl_type)

Detailed Description

Named Access Control Lists.

Author

Jonathan Rose jrose.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Note

Based on a feature proposed by Olle E. Johansson oej@e.nosp@m.dvin.nosp@m.a.net

Definition in file named_acl.c.

Macro Definition Documentation

ACL_FAMILY

#define ACL_FAMILY   "acls"

Definition at line 50 of file named_acl.c.

AST_MODULE

#define AST_MODULE   "acl"

Definition at line 33 of file named_acl.c.

NACL_CONFIG

#define NACL_CONFIG   "acl.conf"

Definition at line 49 of file named_acl.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 599 of file named_acl.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 599 of file named_acl.c.

acl_order_comparator()

static int acl_order_comparator ( struct ast_category *  p, struct ast_category *  q  )

static

Definition at line 210 of file named_acl.c.

{
    int p_value = 0, q_value = 0;
    struct ast_variable *p_var = ast_category_first(p);
    struct ast_variable *q_var = ast_category_first(q);
 
    while (p_var) {
        if (!strcasecmp(p_var->name, "rule_order")) {
            p_value = atoi(p_var->value);
            break;
        }
        p_var = p_var->next;
    }
 
    while (q_var) {
        if (!strcasecmp(q_var->name, "rule_order")) {
            q_value = atoi(q_var->value);
            break;
        }
        q_var = q_var->next;
    }
 
    if (p_value < q_value) {
        return -1;
    } else if (q_value < p_value) {
        return 1;
    }
 
    return 0;
}

References ast_category_first(), ast_variable::name, ast_variable::next, and ast_variable::value.

Referenced by named_acl_find_realtime().

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( globals  )

static

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 599 of file named_acl.c.

ast_named_acl_find()

struct ast_ha * ast_named_acl_find	(	const char *	name,
		int *	is_realtime,
		int *	is_undefined
	)

Retrieve a named ACL.

This function attempts to find a named ACL. If found, a copy of the requested ACL will be made which must be freed by the caller.

Parameters

	name	Name of the ACL sought
[out]	is_realtime	will be true if the ACL being returned is from realtime
[out]	is_undefined	will be true if no ACL profile can be found for the requested name

Returns

A copy of the named ACL as an ast_ha

Return values

NULL	if no ACL could be found.

Definition at line 302 of file named_acl.c.

{
    struct ast_ha *ha = NULL;
 
    RAII_VAR(struct named_acl_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
    RAII_VAR(struct named_acl *, named_acl, NULL, ao2_cleanup);
 
    if (is_realtime) {
        *is_realtime = 0;
    }
 
    if (is_undefined) {
        *is_undefined = 0;
    }
 
    /* If the config or its named_acl_list hasn't been initialized, abort immediately. */
    if ((!cfg) || (!(cfg->named_acl_list))) {
        ast_log(LOG_ERROR, "Attempted to find named ACL '%s', but the ACL configuration isn't available.\n", name);
        return NULL;
    }
 
    named_acl = named_acl_find(cfg->named_acl_list, name);
 
    /* If a named ACL couldn't be retrieved locally, we need to try realtime storage. */
    if (!named_acl) {
        RAII_VAR(struct named_acl *, realtime_acl, NULL, ao2_cleanup);
 
        /* Attempt to create from realtime */
        if ((realtime_acl = named_acl_find_realtime(name))) {
            if (is_realtime) {
                *is_realtime = 1;
            }
            ha = ast_duplicate_ha_list(realtime_acl->ha);
            return ha;
        }
 
        /* Couldn't create from realtime. Raise relevant flags and print relevant warnings. */
        if (ast_realtime_is_mapping_defined(ACL_FAMILY) && !ast_check_realtime(ACL_FAMILY)) {
            ast_log(LOG_WARNING, "ACL '%s' does not exist. The ACL will be marked as undefined and will automatically fail if applied.\n"
                "This ACL may exist in the configured realtime backend, but that backend hasn't been registered yet. "
                "Fix this establishing preload for the backend in 'modules.conf'.\n", name);
        } else {
            ast_log(LOG_WARNING, "ACL '%s' does not exist. The ACL will be marked as undefined and will automatically fail if applied.\n", name);
        }
 
        if (is_undefined) {
            *is_undefined = 1;
        }
 
        return NULL;
    }
 
    ha = ast_duplicate_ha_list(named_acl->ha);
 
    if (!ha) {
        ast_log(LOG_NOTICE, "ACL '%s' contains no rules. It is valid, but it will accept addresses unconditionally.\n", name);
    }
 
    return ha;
}

References ACL_FAMILY, ao2_cleanup, ao2_global_obj_ref, ast_check_realtime(), ast_duplicate_ha_list(), ast_log, ast_realtime_is_mapping_defined(), globals, named_acl::ha, LOG_ERROR, LOG_NOTICE, LOG_WARNING, name, named_acl_find(), named_acl_find_realtime(), NULL, and RAII_VAR.

Referenced by ast_append_acl().

cli_display_named_acl()

static void cli_display_named_acl ( int  fd, const char *  name  )

static

Definition at line 421 of file named_acl.c.

{
    int is_realtime = 0;
 
    RAII_VAR(struct named_acl_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
    RAII_VAR(struct named_acl *, named_acl, NULL, ao2_cleanup);
 
    /* If the configuration or the configuration's named_acl_list is unavailable, abort. */
    if ((!cfg) || (!cfg->named_acl_list)) {
        ast_log(LOG_ERROR, "Attempted to show named ACL '%s', but the acl configuration isn't available.\n", name);
        return;
    }
 
    named_acl = named_acl_find(cfg->named_acl_list, name);
 
    /* If the named_acl couldn't be found with the search, also abort. */
    if (!named_acl) {
        if (!(named_acl = named_acl_find_realtime(name))) {
            ast_cli(fd, "\nCould not find ACL named '%s'\n", name);
            return;
        }
 
        is_realtime = 1;
    }
 
    ast_cli(fd, "\nACL: %s%s\n---------------------------------------------\n", name, is_realtime ? " (realtime)" : "");
    ast_ha_output(fd, named_acl->ha, NULL);
}

References ao2_cleanup, ao2_global_obj_ref, ast_cli(), ast_ha_output(), ast_log, globals, named_acl::ha, LOG_ERROR, name, named_acl_find(), named_acl_find_realtime(), NULL, and RAII_VAR.

Referenced by handle_show_named_acl_cmd().

cli_display_named_acl_list()

static void cli_display_named_acl_list ( int  fd )

static

Definition at line 456 of file named_acl.c.

{
    struct ao2_iterator i;
    void *o;
    RAII_VAR(struct named_acl_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
 
    ast_cli(fd, "\nacl\n---\n");
 
    if (!cfg || !cfg->named_acl_list) {
        ast_cli(fd, "ACL configuration isn't available.\n");
        return;
    }
    i = ao2_iterator_init(cfg->named_acl_list, 0);
 
    while ((o = ao2_iterator_next(&i))) {
        struct named_acl *named_acl = o;
        ast_cli(fd, "%s\n", named_acl->name);
        ao2_ref(o, -1);
    }
 
    ao2_iterator_destroy(&i);
}

References ao2_cleanup, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli(), globals, named_acl::name, and RAII_VAR.

Referenced by handle_show_named_acl_cmd().

CONFIG_INFO_CORE()

CONFIG_INFO_CORE	(	"named_acl"	,
		cfg_info	,
		globals	,
		named_acl_config_alloc	,
		.	files = ACO_FILES(&named_acl_conf)
	)

destroy_named_acl()

static void destroy_named_acl ( void *  obj )

static

Destroy a named ACL object.

Definition at line 157 of file named_acl.c.

{
    struct named_acl *named_acl = obj;
    ast_free_ha(named_acl->ha);
}

References ast_free_ha(), and named_acl::ha.

Referenced by named_acl_alloc().

handle_show_named_acl_cmd()

static char * handle_show_named_acl_cmd ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

ACL command show <name>

Definition at line 480 of file named_acl.c.

{
    struct named_acl_config *cfg;
    int length;
    struct ao2_iterator i;
    struct named_acl *named_acl;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "acl show";
        e->usage =
            "Usage: acl show [name]\n"
            "   Shows a list of named ACLs or lists all entries in a given named ACL.\n";
        return NULL;
    case CLI_GENERATE:
        if (a->pos != 2) {
            return NULL;
        }
 
        cfg = ao2_global_obj_ref(globals);
        if (!cfg) {
            return NULL;
        }
        length = strlen(a->word);
        i = ao2_iterator_init(cfg->named_acl_list, 0);
        while ((named_acl = ao2_iterator_next(&i))) {
            if (!strncasecmp(a->word, named_acl->name, length)) {
                if (ast_cli_completion_add(ast_strdup(named_acl->name))) {
                    ao2_ref(named_acl, -1);
                    break;
                }
            }
            ao2_ref(named_acl, -1);
        }
        ao2_iterator_destroy(&i);
        ao2_ref(cfg, -1);
 
        return NULL;
    }
 
    if (a->argc == 2) {
        cli_display_named_acl_list(a->fd);
        return CLI_SUCCESS;
    }
 
    if (a->argc == 3) {
        cli_display_named_acl(a->fd, a->argv[2]);
        return CLI_SUCCESS;
    }
 
 
    return CLI_SHOWUSAGE;
}

References a, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_completion_add(), ast_strdup, cli_display_named_acl(), cli_display_named_acl_list(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, globals, named_acl::name, named_acl_config::named_acl_list, NULL, and ast_cli_entry::usage.

load_module()

static int load_module ( void  )

static

Definition at line 573 of file named_acl.c.

{
    if (aco_info_init(&cfg_info)) {
        return AST_MODULE_LOAD_FAILURE;
    }
 
    STASIS_MESSAGE_TYPE_INIT(ast_named_acl_change_type);
 
    /* Register the per level options. */
    aco_option_register(&cfg_info, "permit", ACO_EXACT, named_acl_types, NULL, OPT_ACL_T, 1, FLDSET(struct named_acl, ha));
    aco_option_register(&cfg_info, "deny", ACO_EXACT, named_acl_types, NULL, OPT_ACL_T, 0, FLDSET(struct named_acl, ha));
 
    aco_process_config(&cfg_info, 0);
 
    ast_cli_register_multiple(cli_named_acl, ARRAY_LEN(cli_named_acl));
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ACO_EXACT, aco_info_init(), aco_option_register, aco_process_config(), ARRAY_LEN, ast_cli_register_multiple, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, ast_named_acl_change_type(), cli_named_acl, FLDSET, named_acl_types, NULL, OPT_ACL_T, and STASIS_MESSAGE_TYPE_INIT.

named_acl_alloc()

static void * named_acl_alloc ( const char *  cat )

static

Create a named ACL structure.

Parameters

cat	name given to the ACL

Return values

NULL	failure
non-NULL	successfully allocated named ACL

Definition at line 170 of file named_acl.c.

{
    struct named_acl *named_acl;
 
    named_acl = ao2_alloc(sizeof(*named_acl), destroy_named_acl);
    if (!named_acl) {
        return NULL;
    }
 
    ast_copy_string(named_acl->name, cat, sizeof(named_acl->name));
 
    return named_acl;
}

References ao2_alloc, ast_copy_string(), destroy_named_acl(), named_acl::name, and NULL.

Referenced by named_acl_find_realtime().

named_acl_config_alloc()

static void * named_acl_config_alloc ( void  )

static

allocator callback for named_acl_config. Notice it returns void * since it is used by the backend config code

Note

These functions are used for placing/retrieving named ACLs in their ao2_container.

Definition at line 135 of file named_acl.c.

{
    struct named_acl_config *cfg;
 
    if (!(cfg = ao2_alloc(sizeof(*cfg), named_acl_config_destructor))) {
        return NULL;
    }
 
    cfg->named_acl_list = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
        named_acl_hash_fn, NULL, named_acl_cmp_fn);
    if (!cfg->named_acl_list) {
        goto error;
    }
 
    return cfg;
 
error:
    ao2_ref(cfg, -1);
    return NULL;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_ref, error(), named_acl_config_destructor(), named_acl_config::named_acl_list, and NULL.

named_acl_config_destructor()

static void named_acl_config_destructor ( void *  obj )

static

destructor for named_acl_config

Definition at line 126 of file named_acl.c.

{
    struct named_acl_config *cfg = obj;
    ao2_cleanup(cfg->named_acl_list);
}

References ao2_cleanup, and named_acl_config::named_acl_list.

Referenced by named_acl_config_alloc().

named_acl_find()

static void * named_acl_find ( struct ao2_container *  container, const char *  cat  )

static

Find a named ACL in a container by its name.

Parameters

container	ao2container holding the named ACLs
cat	name of the ACL wanted to be found

Return values

pointer

to the named ACL if available. Null if not found.

Definition at line 191 of file named_acl.c.

{
    struct named_acl tmp;
    ast_copy_string(tmp.name, cat, sizeof(tmp.name));
    return ao2_find(container, &tmp, OBJ_POINTER);
}

References ao2_find, ast_copy_string(), container, named_acl::name, and OBJ_POINTER.

Referenced by ast_named_acl_find(), and cli_display_named_acl().

named_acl_find_realtime()

static struct named_acl * named_acl_find_realtime ( const char *  name )

static

Definition at line 249 of file named_acl.c.

{
    struct ast_config *cfg;
    char *item = NULL;
    const char *systemname = NULL;
    struct ast_ha *built_ha = NULL;
    struct named_acl *acl;
 
    /* If we have a systemname set in the global options, we only want to retrieve entries with a matching systemname field. */
    systemname = ast_config_AST_SYSTEM_NAME;
 
    if (ast_strlen_zero(systemname)) {
        cfg = ast_load_realtime_multientry(ACL_FAMILY, "name", name, SENTINEL);
    } else {
        cfg = ast_load_realtime_multientry(ACL_FAMILY, "name", name, "systemname", systemname, SENTINEL);
    }
 
    if (!cfg) {
        return NULL;
    }
 
    /* At this point, the configuration must be sorted by the order field. */
    ast_config_sort_categories(cfg, 0, acl_order_comparator);
 
    while ((item = ast_category_browse(cfg, item))) {
        int append_ha_error = 0;
        const char *order = ast_variable_retrieve(cfg, item, "rule_order");
        const char *sense = ast_variable_retrieve(cfg, item, "sense");
        const char *rule = ast_variable_retrieve(cfg, item, "rule");
 
        built_ha = ast_append_ha(sense, rule, built_ha, &append_ha_error);
        if (append_ha_error) {
            /* We need to completely reject an ACL that contains any bad rules. */
            ast_log(LOG_ERROR, "Rejecting realtime ACL due to bad ACL definition '%s': %s - %s - %s\n", name, order, sense, rule);
            ast_free_ha(built_ha);
            return NULL;
        }
    }
 
    ast_config_destroy(cfg);
 
    acl = named_acl_alloc(name);
    if (!acl) {
        ast_log(LOG_ERROR, "allocation error\n");
        ast_free_ha(built_ha);
        return NULL;
    }
 
    acl->ha = built_ha;
 
    return acl;
}

References ACL_FAMILY, acl_order_comparator(), ast_append_ha(), ast_category_browse(), ast_config_AST_SYSTEM_NAME, ast_config_destroy(), ast_config_sort_categories(), ast_free_ha(), ast_load_realtime_multientry(), ast_log, ast_strlen_zero(), ast_variable_retrieve(), item, LOG_ERROR, name, named_acl_alloc(), NULL, order, and SENTINEL.

Referenced by ast_named_acl_find(), and cli_display_named_acl().

publish_acl_change()

static int publish_acl_change ( const char *  name )

static

Definition at line 380 of file named_acl.c.

{
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
    RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
    RAII_VAR(struct ast_json *, json_object, ast_json_object_create(), ast_json_unref);
 
    if (!json_object || !ast_named_acl_change_type()) {
        goto publish_failure;
    }
 
    if (ast_json_object_set(json_object, "name", ast_json_string_create(name))) {
        goto publish_failure;
    }
 
    if (!(json_payload = ast_json_payload_create(json_object))) {
        goto publish_failure;
    }
 
    msg = stasis_message_create(ast_named_acl_change_type(), json_payload);
 
    if (!msg) {
        goto publish_failure;
    }
 
    stasis_publish(ast_security_topic(), msg);
 
    return 0;
 
publish_failure:
    ast_log(LOG_ERROR, "Failed to issue ACL change message for %s.\n",
        ast_strlen_zero(name) ? "all named ACLs" : name);
    return -1;
}

References ao2_cleanup, ast_json_object_create(), ast_json_object_set(), ast_json_payload_create(), ast_json_string_create(), ast_json_unref(), ast_log, ast_named_acl_change_type(), ast_security_topic(), ast_strlen_zero(), LOG_ERROR, name, NULL, RAII_VAR, stasis_message_create(), and stasis_publish().

Referenced by reload_module().

reload_module()

static int reload_module ( void  )

static

Definition at line 538 of file named_acl.c.

{
    enum aco_process_status status;
 
    status = aco_process_config(&cfg_info, 1);
 
    if (status == ACO_PROCESS_ERROR) {
        ast_log(LOG_WARNING, "Could not reload ACL config\n");
        return 0;
    }
 
    if (status == ACO_PROCESS_UNCHANGED) {
        /* We don't actually log anything if the config was unchanged,
         * but we don't need to send a config change event either.
         */
        return 0;
    }
 
    /* We need to push an ACL change event with no ACL name so that all subscribers update with all ACLs */
    publish_acl_change("");
 
    return 0;
}

References aco_process_config(), ACO_PROCESS_ERROR, ACO_PROCESS_UNCHANGED, ast_log, LOG_WARNING, publish_acl_change(), and status.

STASIS_MESSAGE_TYPE_DEFN()

STASIS_MESSAGE_TYPE_DEFN

(

ast_named_acl_change_type

)

Message type for named ACL changes.

unload_module()

static int unload_module ( void  )

static

Definition at line 562 of file named_acl.c.

{
    ast_cli_unregister_multiple(cli_named_acl, ARRAY_LEN(cli_named_acl));
 
    STASIS_MESSAGE_TYPE_CLEANUP(ast_named_acl_change_type);
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(globals);
 
    return 0;
}

References aco_info_destroy(), ao2_global_obj_release, ARRAY_LEN, ast_cli_unregister_multiple(), ast_named_acl_change_type(), cli_named_acl, globals, and STASIS_MESSAGE_TYPE_CLEANUP.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Named ACL system" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }

static

Definition at line 599 of file named_acl.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 599 of file named_acl.c.

cli_named_acl

struct ast_cli_entry cli_named_acl[]

static

Initial value:

= {
    { .handler =  handle_show_named_acl_cmd , .summary =  "Show a named ACL or list all named ACLs" ,},
}

Definition at line 534 of file named_acl.c.

                                              {
    AST_CLI_DEFINE(handle_show_named_acl_cmd, "Show a named ACL or list all named ACLs"),
};

Referenced by load_module(), and unload_module().

named_acl_conf

struct aco_file named_acl_conf

Initial value:

= {
    .filename = "acl.conf",
    .types = ACO_TYPES(&named_acl_type),
}

Definition at line 107 of file named_acl.c.

                                 {
    .filename = "acl.conf",
    .types = ACO_TYPES(&named_acl_type),
};

named_acl_type

struct aco_type named_acl_type

static

Definition at line 94 of file named_acl.c.

                                        {
    .type = ACO_ITEM,                  /*!< named_acls are items stored in containers, not individual global objects */
    .name = "named_acl",
    .category_match = ACO_BLACKLIST_EXACT,
    .category = "general",           /*!< Match everything but "general" */
    .item_alloc = named_acl_alloc,     /*!< A callback to allocate a new named_acl based on category */
    .item_find = named_acl_find,       /*!< A callback to find a named_acl in some container of named_acls */
    .item_offset = offsetof(struct named_acl_config, named_acl_list), /*!< Could leave this out since 0 */
};

named_acl_types

struct aco_type* named_acl_types[] = ACO_TYPES(&named_acl_type)

Definition at line 105 of file named_acl.c.

Referenced by load_module().