res_resolver_unbound.c File Reference

#include "asterisk.h"
#include <signal.h>
#include <unbound.h>
#include <arpa/nameser.h>
#include "asterisk/module.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_resolver.h"
#include "asterisk/config.h"
#include "asterisk/config_options.h"
#include "asterisk/test.h"

Include dependency graph for res_resolver_unbound.c:

Go to the source code of this file.

Data Structures
struct	unbound_config
	A container for config related information. More...
struct	unbound_config_state
	Unbound configuration state information. More...
struct	unbound_global_config
	A structure to hold global configuration-related options. More...
struct	unbound_resolver
	Structure for an unbound resolver. More...
struct	unbound_resolver_data
	Structure for query resolver data. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static	AO2_GLOBAL_OBJ_STATIC (globals)
	A global object container that will contain the global_config that gets swapped out on reloads.
struct ast_module *	AST_MODULE_SELF_SYM (void)
	CONFIG_INFO_STANDARD (cfg_info, globals, unbound_config_alloc,.files=ACO_FILES(&resolver_unbound_conf),.pre_apply_config=unbound_config_preapply_callback,)
	Register information about the configs being processed by this module.
static int	custom_nameserver_handler (const struct aco_option *opt, struct ast_variable *var, void *obj)
static int	load_module (void)
static int	reload_module (void)
static void *	unbound_config_alloc (void)
	Allocate a unbound_config to hold a snapshot of the complete results of parsing a config.
static int	unbound_config_apply_default (void)
static void	unbound_config_destructor (void *obj)
static int	unbound_config_preapply (struct unbound_config *cfg)
static int	unbound_config_preapply_callback (void)
	Finish initializing new configuration.
static void	unbound_config_state_destructor (void *obj)
static void	unbound_global_config_destructor (void *obj)
static struct unbound_resolver *	unbound_resolver_alloc (void)
	Allocator for unbound resolver.
static void	unbound_resolver_callback (void *data, int err, struct ub_result *ub_result)
	Callback invoked when resolution completes on a query.
static int	unbound_resolver_cancel (struct ast_dns_query *query)
static void	unbound_resolver_data_dtor (void *vdoomed)
static void	unbound_resolver_destroy (void *obj)
	Destructor for unbound resolver.
static int	unbound_resolver_resolve (struct ast_dns_query *query)
static int	unbound_resolver_start (struct unbound_resolver *resolver)
	Start function for the unbound resolver.
static void	unbound_resolver_stop (struct unbound_resolver *resolver)
	Stop function for the unbound resolver.
static void *	unbound_resolver_thread (void *data)
	Resolver thread which waits and handles results.
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Unbound DNS Resolver Support" , .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_CHANNEL_DEPEND - 4, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct aco_type	global_option
	An aco_type structure to link the "general" category to the unbound_global_config type.
static struct aco_type *	global_options [] = ACO_TYPES(&global_option)
static struct aco_file	resolver_unbound_conf
struct ast_dns_resolver	unbound_resolver

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1507 of file res_resolver_unbound.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1507 of file res_resolver_unbound.c.

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( globals  )

static

A global object container that will contain the global_config that gets swapped out on reloads.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1507 of file res_resolver_unbound.c.

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		globals	,
		unbound_config_alloc	,
		.	files = ACO_FILES(&resolver_unbound_conf),
		.	pre_apply_config = unbound_config_preapply_callback
	)

Register information about the configs being processed by this module.

custom_nameserver_handler()

static int custom_nameserver_handler ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Definition at line 1442 of file res_resolver_unbound.c.

{
    struct unbound_global_config *global = obj;
 
    if (!global->nameservers) {
        global->nameservers = ast_str_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 1);
        if (!global->nameservers) {
            return -1;
        }
    }
 
    return ast_str_container_add(global->nameservers, var->value);
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ast_str_container_add(), ast_str_container_alloc_options(), global, and var.

Referenced by load_module().

load_module()

static int load_module ( void  )

static

Definition at line 1456 of file res_resolver_unbound.c.

{
    struct ast_config *cfg;
    struct ast_flags cfg_flags = { 0, };
 
    if (aco_info_init(&cfg_info)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    aco_option_register(&cfg_info, "hosts", ACO_EXACT, global_options, "system", OPT_STRINGFIELD_T, 0, STRFLDSET(struct unbound_global_config, hosts));
    aco_option_register(&cfg_info, "resolv", ACO_EXACT, global_options, "system", OPT_STRINGFIELD_T, 0, STRFLDSET(struct unbound_global_config, resolv));
    aco_option_register_custom(&cfg_info, "nameserver", ACO_EXACT, global_options, "", custom_nameserver_handler, 0);
    aco_option_register(&cfg_info, "debug", ACO_EXACT, global_options, "0", OPT_UINT_T, 0, FLDSET(struct unbound_global_config, debug));
    aco_option_register(&cfg_info, "ta_file", ACO_EXACT, global_options, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct unbound_global_config, ta_file));
 
    /* This purposely checks for a configuration file so we don't output an error message in ACO if one is not present */
    cfg = ast_config_load(resolver_unbound_conf.filename, cfg_flags);
    if (!cfg) {
        if (unbound_config_apply_default()) {
            unload_module();
            return AST_MODULE_LOAD_DECLINE;
        }
    } else {
        ast_config_destroy(cfg);
        if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
            unload_module();
            return AST_MODULE_LOAD_DECLINE;
        }
    }
 
    ast_dns_resolver_register(&unbound_resolver);
 
    ast_module_shutdown_ref(ast_module_info->self);
 
    AST_TEST_REGISTER(resolve_sync);
    AST_TEST_REGISTER(resolve_async);
    AST_TEST_REGISTER(resolve_sync_off_nominal);
    AST_TEST_REGISTER(resolve_async_off_nominal);
    AST_TEST_REGISTER(resolve_cancel_off_nominal);
    AST_TEST_REGISTER(resolve_naptr);
    AST_TEST_REGISTER(resolve_srv);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References ACO_EXACT, aco_info_init(), aco_option_register, aco_option_register_custom, aco_process_config(), ACO_PROCESS_ERROR, ast_config_destroy(), ast_config_load, ast_dns_resolver_register(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_module_shutdown_ref, AST_TEST_REGISTER, custom_nameserver_handler(), debug, aco_file::filename, FLDSET, global_options, OPT_STRINGFIELD_T, OPT_UINT_T, resolver_unbound_conf, ast_module_info::self, STRFLDSET, unbound_config_apply_default(), and unload_module().

reload_module()

static int reload_module ( void  )

static

Definition at line 1418 of file res_resolver_unbound.c.

{
    if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
        return AST_MODULE_RELOAD_ERROR;
    }
 
    return 0;
}

References aco_process_config(), ACO_PROCESS_ERROR, and AST_MODULE_RELOAD_ERROR.

unbound_config_alloc()

static void * unbound_config_alloc ( void  )

static

Allocate a unbound_config to hold a snapshot of the complete results of parsing a config.

Definition at line 391 of file res_resolver_unbound.c.

{
    struct unbound_config *cfg;
 
    cfg = ao2_alloc_options(sizeof(*cfg), unbound_config_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cfg) {
        return NULL;
    }
 
    /* Allocate/initialize memory */
    cfg->global = ao2_alloc_options(sizeof(*cfg->global), unbound_global_config_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cfg->global) {
        goto error;
    }
 
    if (ast_string_field_init(cfg->global, 128)) {
        goto error;
    }
 
    return cfg;
error:
    ao2_ref(cfg, -1);
    return NULL;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_string_field_init, error(), unbound_config::global, NULL, unbound_config_destructor(), and unbound_global_config_destructor().

Referenced by unbound_config_apply_default().

unbound_config_apply_default()

static int unbound_config_apply_default ( void  )

static

Definition at line 498 of file res_resolver_unbound.c.

{
    struct unbound_config *cfg;
 
    cfg = unbound_config_alloc();
    if (!cfg) {
        ast_log(LOG_ERROR, "Could not create default configuration for unbound resolver\n");
        return -1;
    }
 
    aco_set_defaults(&global_option, "general", cfg->global);
 
    if (unbound_config_preapply(cfg)) {
        ao2_ref(cfg, -1);
        return -1;
    }
 
    ast_verb(1, "Starting unbound resolver using default configuration\n");
 
    ao2_global_obj_replace_unref(globals, cfg);
    ao2_ref(cfg, -1);
 
    return 0;
}

References aco_set_defaults(), ao2_global_obj_replace_unref, ao2_ref, ast_log, ast_verb, unbound_config::global, global_option, globals, LOG_ERROR, unbound_config_alloc(), and unbound_config_preapply().

Referenced by load_module().

unbound_config_destructor()

static void unbound_config_destructor ( void *  obj )

static

Definition at line 365 of file res_resolver_unbound.c.

{
    struct unbound_config *cfg = obj;
 
    ao2_cleanup(cfg->global);
}

References ao2_cleanup, and unbound_config::global.

Referenced by unbound_config_alloc().

unbound_config_preapply()

static int unbound_config_preapply ( struct unbound_config *  cfg )

static

Definition at line 417 of file res_resolver_unbound.c.

{
    int res = 0;
 
    cfg->global->state = ao2_alloc_options(sizeof(*cfg->global->state), unbound_config_state_destructor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!cfg->global->state) {
        ast_log(LOG_ERROR, "Could not allocate unbound resolver state structure\n");
        return -1;
    }
 
    cfg->global->state->resolver = unbound_resolver_alloc();
    if (!cfg->global->state->resolver) {
        ast_log(LOG_ERROR, "Could not create an unbound resolver\n");
        return -1;
    }
 
    ub_ctx_debuglevel(cfg->global->state->resolver->context, cfg->global->debug);
 
    if (!strcmp(cfg->global->hosts, "system")) {
        res = ub_ctx_hosts(cfg->global->state->resolver->context, NULL);
    } else if (!ast_strlen_zero(cfg->global->hosts)) {
        res = ub_ctx_hosts(cfg->global->state->resolver->context, cfg->global->hosts);
    }
 
    if (res) {
        ast_log(LOG_ERROR, "Failed to set hosts file to '%s' in unbound resolver: %s\n",
            cfg->global->hosts, ub_strerror(res));
        return -1;
    }
 
    if (cfg->global->nameservers) {
        struct ao2_iterator it_nameservers;
        char *nameserver;
 
        it_nameservers = ao2_iterator_init(cfg->global->nameservers, 0);
        while (!res && (nameserver = ao2_iterator_next(&it_nameservers))) {
            res = ub_ctx_set_fwd(cfg->global->state->resolver->context, nameserver);
 
            if (res) {
                ast_log(LOG_ERROR, "Failed to add nameserver '%s' to unbound resolver: %s\n",
                    nameserver, ub_strerror(res));
            }
            ao2_ref(nameserver, -1);
        }
        ao2_iterator_destroy(&it_nameservers);
        if (res) {
            return -1;
        }
    }
 
    if (!strcmp(cfg->global->resolv, "system")) {
        res = ub_ctx_resolvconf(cfg->global->state->resolver->context, NULL);
    } else if (!ast_strlen_zero(cfg->global->resolv)) {
        res = ub_ctx_resolvconf(cfg->global->state->resolver->context, cfg->global->resolv);
    }
 
    if (res) {
        ast_log(LOG_ERROR, "Failed to set resolv.conf file to '%s' in unbound resolver: %s\n",
            cfg->global->resolv, ub_strerror(res));
        return -1;
    }
 
    if (!ast_strlen_zero(cfg->global->ta_file)) {
        res = ub_ctx_add_ta_file(cfg->global->state->resolver->context, cfg->global->ta_file);
 
        if (res) {
            ast_log(LOG_ERROR, "Failed to set trusted anchor file to '%s' in unbound resolver: %s\n",
                cfg->global->ta_file, ub_strerror(res));
            return -1;
        }
    }
 
    if (unbound_resolver_start(cfg->global->state->resolver)) {
        ast_log(LOG_ERROR, "Could not start unbound resolver thread\n");
        return -1;
    }
 
    return 0;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, ast_strlen_zero(), unbound_resolver::context, unbound_global_config::debug, unbound_config::global, unbound_global_config::hosts, LOG_ERROR, unbound_global_config::nameservers, NULL, unbound_global_config::resolv, unbound_config_state::resolver, unbound_global_config::state, unbound_global_config::ta_file, unbound_config_state_destructor(), unbound_resolver_alloc(), and unbound_resolver_start().

Referenced by unbound_config_apply_default(), and unbound_config_preapply_callback().

unbound_config_preapply_callback()

static int unbound_config_preapply_callback ( void  )

static

Finish initializing new configuration.

Definition at line 523 of file res_resolver_unbound.c.

{
    return unbound_config_preapply(aco_pending_config(&cfg_info));
}

References aco_pending_config(), and unbound_config_preapply().

unbound_config_state_destructor()

static void unbound_config_state_destructor ( void *  obj )

static

Definition at line 381 of file res_resolver_unbound.c.

{
    struct unbound_config_state *state = obj;
 
    if (state->resolver) {
        unbound_resolver_stop(state->resolver);
        ao2_ref(state->resolver, -1);
    }
}

References ao2_ref, and unbound_resolver_stop().

Referenced by unbound_config_preapply().

unbound_global_config_destructor()

static void unbound_global_config_destructor ( void *  obj )

static

Definition at line 372 of file res_resolver_unbound.c.

{
    struct unbound_global_config *global = obj;
 
    ast_string_field_free_memory(global);
    ao2_cleanup(global->nameservers);
    ao2_cleanup(global->state);
}

References ao2_cleanup, ast_string_field_free_memory, and global.

Referenced by unbound_config_alloc().

unbound_resolver_alloc()

static struct unbound_resolver * unbound_resolver_alloc ( void  )

static

Allocator for unbound resolver.

Definition at line 189 of file res_resolver_unbound.c.

{
    struct unbound_resolver *resolver;
 
    resolver = ao2_alloc_options(sizeof(*resolver), unbound_resolver_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!resolver) {
        return NULL;
    }
 
    resolver->thread = AST_PTHREADT_NULL;
 
    resolver->context = ub_ctx_create();
    if (!resolver->context) {
        ao2_ref(resolver, -1);
        return NULL;
    }
 
    /* Each async result should be invoked in a separate thread so others are not blocked */
    ub_ctx_async(resolver->context, 1);
 
    return resolver;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, AST_PTHREADT_NULL, unbound_resolver::context, NULL, unbound_resolver::thread, and unbound_resolver_destroy().

Referenced by unbound_config_preapply().

unbound_resolver_callback()

static void unbound_resolver_callback ( void *  data, int  err, struct ub_result *  ub_result  )

static

Callback invoked when resolution completes on a query.

Definition at line 274 of file res_resolver_unbound.c.

{
    struct ast_dns_query *query = data;
 
    if (!ub_result) {
        ast_debug(3, "Badly formatted DNS query '%s'\n", ast_dns_query_get_name(query));
        ast_dns_resolver_set_result(query, 0, 0, ns_r_formerr, ast_dns_query_get_name(query), "", 0);
        ast_dns_resolver_completed(query);
        ao2_ref(query, -1);
        return;
    }
 
    if (!ast_dns_resolver_set_result(query, ub_result->secure, ub_result->bogus, ub_result->rcode,
        S_OR(ub_result->canonname, ast_dns_query_get_name(query)), ub_result->answer_packet, ub_result->answer_len)) {
        int i;
        char *result_data;
 
        for (i = 0; (result_data = ub_result->data[i]); i++) {
            if (ast_dns_resolver_add_record(query, ub_result->qtype, ub_result->qclass, ub_result->ttl,
                result_data, ub_result->len[i])) {
                break;
            }
        }
    }
 
    ast_dns_resolver_completed(query);
    ao2_ref(query, -1);
    ub_resolve_free(ub_result);
}

References ao2_ref, ast_debug, ast_dns_query_get_name(), ast_dns_resolver_add_record(), ast_dns_resolver_completed(), ast_dns_resolver_set_result(), and S_OR.

Referenced by unbound_resolver_resolve().

unbound_resolver_cancel()

static int unbound_resolver_cancel ( struct ast_dns_query *  query )

static

Definition at line 342 of file res_resolver_unbound.c.

{
    struct unbound_resolver_data *data = ast_dns_resolver_get_data(query);
    int res;
 
    res = ub_cancel(data->resolver->context, data->id);
    if (!res) {
        /* When this query was started we bumped the ref, now that it has been cancelled we have ownership and
         * need to drop it
         */
        ao2_ref(query, -1);
    }
 
    return res;
}

References ao2_ref, ast_dns_resolver_get_data(), unbound_resolver::context, unbound_resolver_data::id, and unbound_resolver_data::resolver.

unbound_resolver_data_dtor()

static void unbound_resolver_data_dtor ( void *  vdoomed )

static

Definition at line 304 of file res_resolver_unbound.c.

{
    struct unbound_resolver_data *doomed = vdoomed;
 
    ao2_cleanup(doomed->resolver);
}

References ao2_cleanup, and unbound_resolver_data::resolver.

Referenced by unbound_resolver_resolve().

unbound_resolver_destroy()

static void unbound_resolver_destroy ( void *  obj )

static

Destructor for unbound resolver.

Definition at line 179 of file res_resolver_unbound.c.

{
    struct unbound_resolver *resolver = obj;
 
    if (resolver->context) {
        ub_ctx_delete(resolver->context);
    }
}

References unbound_resolver::context.

Referenced by unbound_resolver_alloc().

unbound_resolver_resolve()

static int unbound_resolver_resolve ( struct ast_dns_query *  query )

static

Definition at line 311 of file res_resolver_unbound.c.

{
    struct unbound_config *cfg = ao2_global_obj_ref(globals);
    struct unbound_resolver_data *data;
    int res;
 
    data = ao2_alloc_options(sizeof(*data), unbound_resolver_data_dtor,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!data) {
        ast_log(LOG_ERROR, "Failed to allocate resolver data for resolution of '%s'\n",
            ast_dns_query_get_name(query));
        return -1;
    }
    data->resolver = ao2_bump(cfg->global->state->resolver);
    ast_dns_resolver_set_data(query, data);
 
    res = ub_resolve_async(data->resolver->context, ast_dns_query_get_name(query),
        ast_dns_query_get_rr_type(query), ast_dns_query_get_rr_class(query),
        ao2_bump(query), unbound_resolver_callback, &data->id);
 
    if (res) {
        ast_log(LOG_ERROR, "Failed to perform async DNS resolution of '%s'\n",
            ast_dns_query_get_name(query));
        ao2_ref(query, -1);
    }
 
    ao2_ref(data, -1);
    ao2_ref(cfg, -1);
    return res;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_global_obj_ref, ao2_ref, ast_dns_query_get_name(), ast_dns_query_get_rr_class(), ast_dns_query_get_rr_type(), ast_dns_resolver_set_data(), ast_log, unbound_resolver::context, unbound_config::global, globals, unbound_resolver_data::id, LOG_ERROR, unbound_resolver_data::resolver, unbound_config_state::resolver, unbound_global_config::state, unbound_resolver_callback(), and unbound_resolver_data_dtor().

unbound_resolver_start()

static int unbound_resolver_start ( struct unbound_resolver *  resolver )

static

Start function for the unbound resolver.

Definition at line 235 of file res_resolver_unbound.c.

{
    int res;
 
    if (resolver->thread != AST_PTHREADT_NULL) {
        return 0;
    }
 
    ast_debug(1, "Starting thread for unbound resolver\n");
 
    res = ast_pthread_create(&resolver->thread, NULL, unbound_resolver_thread, ao2_bump(resolver));
    if (res) {
        ast_debug(1, "Could not start thread for unbound resolver\n");
        ao2_ref(resolver, -1);
    }
 
    return res;
}

References ao2_bump, ao2_ref, ast_debug, ast_pthread_create, AST_PTHREADT_NULL, NULL, unbound_resolver::thread, and unbound_resolver_thread().

Referenced by unbound_config_preapply().

unbound_resolver_stop()

static void unbound_resolver_stop ( struct unbound_resolver *  resolver )

static

Stop function for the unbound resolver.

Definition at line 255 of file res_resolver_unbound.c.

{
    pthread_t thread;
 
    if (resolver->thread == AST_PTHREADT_NULL) {
        return;
    }
 
    ast_debug(1, "Stopping processing thread for unbound resolver\n");
 
    thread = resolver->thread;
    resolver->thread = AST_PTHREADT_STOP;
    pthread_kill(thread, SIGURG);
    pthread_join(thread, NULL);
 
    ast_debug(1, "Stopped processing thread for unbound resolver\n");
}

References ast_debug, AST_PTHREADT_NULL, AST_PTHREADT_STOP, NULL, thread, and unbound_resolver::thread.

Referenced by unbound_config_state_destructor().

unbound_resolver_thread()

static void * unbound_resolver_thread ( void *  data )

static

Resolver thread which waits and handles results.

Definition at line 213 of file res_resolver_unbound.c.

{
    struct unbound_resolver *resolver = data;
 
    ast_debug(1, "Starting processing for unbound resolver\n");
 
    while (resolver->thread != AST_PTHREADT_STOP) {
        /* Wait for any results to come in */
        ast_wait_for_input(ub_fd(resolver->context), -1);
 
        /* Finally process any results */
        ub_process(resolver->context);
    }
 
    ast_debug(1, "Terminating processing for unbound resolver\n");
 
    ao2_ref(resolver, -1);
 
    return NULL;
}

References ao2_ref, ast_debug, AST_PTHREADT_STOP, ast_wait_for_input(), unbound_resolver::context, NULL, and unbound_resolver::thread.

Referenced by unbound_resolver_start().

unload_module()

static int unload_module ( void  )

static

Definition at line 1427 of file res_resolver_unbound.c.

{
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(globals);
 
    AST_TEST_UNREGISTER(resolve_sync);
    AST_TEST_UNREGISTER(resolve_async);
    AST_TEST_UNREGISTER(resolve_sync_off_nominal);
    AST_TEST_UNREGISTER(resolve_sync_off_nominal);
    AST_TEST_UNREGISTER(resolve_cancel_off_nominal);
    AST_TEST_UNREGISTER(resolve_naptr);
    AST_TEST_UNREGISTER(resolve_srv);
    return 0;
}

References aco_info_destroy(), ao2_global_obj_release, AST_TEST_UNREGISTER, and globals.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Unbound DNS Resolver Support" , .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_CHANNEL_DEPEND - 4, }

static

Definition at line 1507 of file res_resolver_unbound.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1507 of file res_resolver_unbound.c.

global_option

struct aco_type global_option

static

An aco_type structure to link the "general" category to the unbound_global_config type.

Definition at line 148 of file res_resolver_unbound.c.

                                       {
    .type = ACO_GLOBAL,
    .name = "general",
    .item_offset = offsetof(struct unbound_config, global),
    .category_match = ACO_WHITELIST_EXACT,
    .category = "general",
};

Referenced by unbound_config_apply_default().

global_options

struct aco_type* global_options[] = ACO_TYPES(&global_option)

static

Definition at line 156 of file res_resolver_unbound.c.

Referenced by load_module().

resolver_unbound_conf

struct aco_file resolver_unbound_conf

static

Initial value:

= {
    .filename = "resolver_unbound.conf",
    .types = ACO_TYPES(&global_option),
}

Definition at line 158 of file res_resolver_unbound.c.

                                               {
    .filename = "resolver_unbound.conf",
    .types = ACO_TYPES(&global_option),
};

Referenced by load_module().

unbound_resolver

struct ast_dns_resolver unbound_resolver

Definition at line 358 of file res_resolver_unbound.c.

                                           {
    .name = "unbound",
    .priority = 100,
    .resolve = unbound_resolver_resolve,
    .cancel = unbound_resolver_cancel,
};