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. More...
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. More...
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. More...
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. More...
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. More...
static void	unbound_resolver_callback (void *data, int err, struct ub_result *ub_result)
	Callback invoked when resolution completes on a query. More...
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. More...
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. More...
static void	unbound_resolver_stop (struct unbound_resolver *resolver)
	Stop function for the unbound resolver. More...
static void *	unbound_resolver_thread (void *data)
	Resolver thread which waits and handles results. More...
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 = "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, .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. More...
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 1489 of file res_resolver_unbound.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1489 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 1489 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 1424 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 1438 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 1400 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 373 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 480 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 347 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 399 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 505 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 363 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 354 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 171 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 256 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 324 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 286 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 161 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 293 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 217 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 237 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 195 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 1409 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 = "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, .reload = reload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND - 4, }

static

Definition at line 1489 of file res_resolver_unbound.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1489 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 130 of file res_resolver_unbound.c.

Referenced by unbound_config_apply_default().

global_options

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

static

Definition at line 138 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 140 of file res_resolver_unbound.c.

Referenced by load_module().

unbound_resolver

struct ast_dns_resolver unbound_resolver

Definition at line 340 of file res_resolver_unbound.c.