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 "asterisk/dns_srv.h"
#include "asterisk/dns_naptr.h"

Include dependency graph for res_resolver_unbound.c:

Go to the source code of this file.

Data Structures
struct	async_data
	Data required for an asynchronous callback. More...
struct	async_minimal_data
	Minimal data required to signal the completion of an async resolve. More...
struct	dns_record
	A DNS record to be used during a test. More...
struct	off_nominal_async_data
	User data for off-nominal async resolution test. More...
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...

Typedefs
typedef int(*	off_nominal_resolve_fn) (struct ast_test *test, const char *domain, int rr_type, int rr_class, int expected_rcode)
typedef int(*	resolve_fn) (struct ast_test *test, const char *domain, int rr_type, int rr_class, struct dns_record *records, size_t num_records)
	Resolution function for tests. 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)
	AST_TEST_DEFINE (resolve_sync)
	AST_TEST_DEFINE (resolve_async)
	AST_TEST_DEFINE (resolve_sync_off_nominal)
	AST_TEST_DEFINE (resolve_async_off_nominal)
	AST_TEST_DEFINE (resolve_cancel_off_nominal)
	AST_TEST_DEFINE (resolve_naptr)
	AST_TEST_DEFINE (resolve_srv)
static void	async_callback (const struct ast_dns_query *query)
	Callback for asynchronous queries. More...
static struct async_data *	async_data_alloc (struct dns_record *records, size_t num_records)
static void	async_data_destructor (void *obj)
static struct async_minimal_data *	async_minimal_data_alloc (void)
static void	async_minimal_data_destructor (void *obj)
	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 void	minimal_callback (const struct ast_dns_query *query)
	Async callback for off-nominal cancellation test. More...
static int	nominal_async_run (struct ast_test *test, const char *domain, int rr_type, int rr_class, struct dns_record *records, size_t num_records)
	Pluggable function for performing an asynchronous query during a test. More...
static int	nominal_sync_run (struct ast_test *test, const char *domain, int rr_type, int rr_class, struct dns_record *records, size_t num_records)
	Pluggable function for running a synchronous query and checking its results. More...
static enum ast_test_result_state	nominal_test (struct ast_test *test, resolve_fn runner)
	Framework for running a nominal DNS test. More...
static void	off_nominal_async_callback (const struct ast_dns_query *query)
	Async callback for off-nominal async test. More...
static struct off_nominal_async_data *	off_nominal_async_data_alloc (int expected_rcode)
static void	off_nominal_async_data_destructor (void *obj)
static int	off_nominal_async_run (struct ast_test *test, const char *domain, int rr_type, int rr_class, int expected_rcode)
static int	off_nominal_sync_run (struct ast_test *test, const char *domain, int rr_type, int rr_class, int expected_rcode)
static enum ast_test_result_state	off_nominal_test (struct ast_test *test, off_nominal_resolve_fn runner)
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

Typedef Documentation

off_nominal_resolve_fn

typedef int(* off_nominal_resolve_fn) (struct ast_test *test, const char *domain, int rr_type, int rr_class, int expected_rcode)

Definition at line 876 of file res_resolver_unbound.c.

resolve_fn

typedef int(* resolve_fn) (struct ast_test *test, const char *domain, int rr_type, int rr_class, struct dns_record *records, size_t num_records)

Resolution function for tests.

Several tests will have similar setups but will want to make use of a different means of actually making queries and checking their results. This pluggable function pointer allows for similar tests to be operated in different ways.

Parameters

test	The test being run
domain	The domain to look up
rr_type	The record type to look up
rr_class	The class of record to look up
records	All records that exist for the test.
num_records	Number of records in the records array.

Return values

0	The test has passed thus far.
-1	The test has failed.

Definition at line 545 of file res_resolver_unbound.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1474 of file res_resolver_unbound.c.

__unreg_module()

static void __unreg_module ( void  )

static

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

AST_TEST_DEFINE() [1/7]

AST_TEST_DEFINE

(

resolve_sync

)

Definition at line 827 of file res_resolver_unbound.c.

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), nominal_sync_run(), nominal_test(), TEST_EXECUTE, and TEST_INIT.

{

   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_sync";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Test nominal synchronous resolution using libunbound";
      info->description = "This test performs the following:\n"
         "\t* Set two static A records and one static AAAA record on one domain\n"
         "\t* Set an A record for a second domain\n"
         "\t* Perform an A record lookup on the first domain\n"
         "\t* Ensure that both A records are returned and no AAAA record is returned\n"
         "\t* Perform an AAAA record lookup on the first domain\n"
         "\t* Ensure that the AAAA record is returned and no A record is returned\n"
         "\t* Perform an A record lookup on the second domain\n"
         "\t* Ensure that the A record from the second domain is returned";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return nominal_test(test, nominal_sync_run);
}

AST_TEST_DEFINE() [2/7]

AST_TEST_DEFINE

(

resolve_async

)

Definition at line 852 of file res_resolver_unbound.c.

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), nominal_async_run(), nominal_test(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_async";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Test nominal asynchronous resolution using libunbound";
      info->description = "This test performs the following:\n"
         "\t* Set two static A records and one static AAAA record on one domain\n"
         "\t* Set an A record for a second domain\n"
         "\t* Perform an A record lookup on the first domain\n"
         "\t* Ensure that both A records are returned and no AAAA record is returned\n"
         "\t* Perform an AAAA record lookup on the first domain\n"
         "\t* Ensure that the AAAA record is returned and no A record is returned\n"
         "\t* Perform an A record lookup on the second domain\n"
         "\t* Ensure that the A record from the second domain is returned";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return nominal_test(test, nominal_async_run);
}

AST_TEST_DEFINE() [3/7]

AST_TEST_DEFINE

(

resolve_sync_off_nominal

)

Definition at line 1069 of file res_resolver_unbound.c.

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_sync_run(), off_nominal_test(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_sync_off_nominal";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Test off-nominal synchronous resolution using libunbound";
      info->description = "This test performs the following:\n"
         "\t* Attempt a lookup of a non-existent domain\n"
         "\t* Attempt a lookup of a AAAA record on a domain that contains only A records\n"
         "\t* Attempt a lookup of an A record on Chaos-net";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return off_nominal_test(test, off_nominal_sync_run);
}

AST_TEST_DEFINE() [4/7]

AST_TEST_DEFINE

(

resolve_async_off_nominal

)

Definition at line 1088 of file res_resolver_unbound.c.

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_async_run(), off_nominal_test(), TEST_EXECUTE, and TEST_INIT.

{
   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_async_off_nominal";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Test off-nominal synchronous resolution using libunbound";
      info->description = "This test performs the following:\n"
         "\t* Attempt a lookup of a non-existent domain\n"
         "\t* Attempt a lookup of a AAAA record on a domain that contains only A records\n"
         "\t* Attempt a lookup of an A record on Chaos-net";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   return off_nominal_test(test, off_nominal_async_run);
}

AST_TEST_DEFINE() [5/7]

AST_TEST_DEFINE

(

resolve_cancel_off_nominal

)

Definition at line 1154 of file res_resolver_unbound.c.

References ao2_cleanup, ast_cond_wait, ast_dns_resolve_async(), ast_dns_resolve_cancel(), ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, async_minimal_data_alloc(), sip_to_pjsip::info(), minimal_callback(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

{
   RAII_VAR(struct ast_dns_query_active *, active, NULL, ao2_cleanup);
   RAII_VAR(struct async_minimal_data *, adata, NULL, ao2_cleanup);

   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_cancel_off_nominal";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Off nominal cancellation test using libunbound";
      info->description = "This test does the following:\n"
         "\t* Perform an asynchronous query\n"
         "\t* Once the query has completed, attempt to cancel it";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   adata = async_minimal_data_alloc();
   if (!adata) {
      ast_test_status_update(test, "Failed to allocate necessary data for test\n");
      return AST_TEST_FAIL;
   }

   active = ast_dns_resolve_async("crunchy.peanut.butter", ns_t_a, ns_c_in, minimal_callback, adata);
   if (!active) {
      ast_test_status_update(test, "Failed to perform asynchronous query\n");
      return AST_TEST_FAIL;
   }

   /* Wait for async query to complete */
   ast_mutex_lock(&adata->lock);
   while (!adata->complete) {
      ast_cond_wait(&adata->cond, &adata->lock);
   }
   ast_mutex_unlock(&adata->lock);

   if (!ast_dns_resolve_cancel(active)) {
      ast_test_status_update(test, "Successfully canceled completed query\n");
      return AST_TEST_FAIL;
   }

   return AST_TEST_PASS;
}

AST_TEST_DEFINE() [6/7]

AST_TEST_DEFINE

(

resolve_naptr

)

Definition at line 1199 of file res_resolver_unbound.c.

References ao2_bump, ao2_cleanup, ao2_global_obj_ref, ARRAY_LEN, ast_dns_naptr_get_flags(), ast_dns_naptr_get_order(), ast_dns_naptr_get_preference(), ast_dns_naptr_get_regexp(), ast_dns_naptr_get_replacement(), ast_dns_naptr_get_service(), ast_dns_record_get_next(), ast_dns_resolve(), ast_dns_result_free(), ast_dns_result_get_records(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, globals, sip_to_pjsip::info(), NULL, order, RAII_VAR, result, TEST_EXECUTE, TEST_INIT, and dns_record::visited.

{
   RAII_VAR(struct unbound_resolver *, resolver, NULL, ao2_cleanup);
   RAII_VAR(struct unbound_config *, cfg, NULL, ao2_cleanup);
   RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);

   const struct ast_dns_record *record;

   static char * DOMAIN1 = "goose.feathers";
   int i;
   enum ast_test_result_state res = AST_TEST_PASS;

   struct naptr_record {
      const char *zone_entry;
      uint16_t order;
      uint16_t preference;
      const char *flags;
      const char *services;
      const char *regexp;
      const char *replacement;
      int visited;
   } records [] = {
      { "goose.feathers 12345 IN NAPTR 100 100 A SIP+D2U \"\" goose.down", 100, 100, "A", "SIP+D2U", "", "goose.down", 0},
      { "goose.feathers 12345 IN NAPTR 100 200 A SIP+D2T \"\" duck.down", 100, 200, "A", "SIP+D2T", "", "duck.down", 0},
      { "goose.feathers 12345 IN NAPTR 200 100 A SIPS+D2U \"\" pheasant.down", 200, 100, "A", "SIPS+D2U", "", "pheasant.down", 0},
      { "goose.feathers 12345 IN NAPTR 200 200 A SIPS+D2T \"\" platypus.fur", 200, 200, "A", "SIPS+D2T", "", "platypus.fur", 0},
   };

   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_naptr";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Attempt resolution of NAPTR record";
      info->description = "This test performs a NAPTR lookup and ensures that\n"
         "the returned record has the appropriate values set";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cfg = ao2_global_obj_ref(globals);
   resolver = ao2_bump(cfg->global->state->resolver);

   ub_ctx_zone_add(resolver->context, DOMAIN1, "static");

   for (i = 0; i < ARRAY_LEN(records); ++i) {
      ub_ctx_data_add(resolver->context, records[i].zone_entry);
   }

   if (ast_dns_resolve(DOMAIN1, ns_t_naptr, ns_c_in, &result)) {
      ast_test_status_update(test, "Failed to resolve domain\n");
      return AST_TEST_FAIL;
   }

   if (!result) {
      ast_test_status_update(test, "Successful resolution set a NULL result\n");
      return AST_TEST_FAIL;
   }

   record = ast_dns_result_get_records(result);
   if (!record) {
      ast_test_status_update(test, "Failed to get any DNS records from the result\n");
      return AST_TEST_FAIL;
   }

   i = 0;
   for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
      if (ast_dns_naptr_get_order(record) != records[i].order) {
         ast_test_status_update(test, "Expected order %hu, got order %hu from NAPTR record\n",
               records[i].order, ast_dns_naptr_get_order(record));
         res = AST_TEST_FAIL;
      }
      if (ast_dns_naptr_get_preference(record) != records[i].preference) {
         ast_test_status_update(test, "Expected preference %hu, got preference %hu from NAPTR record\n",
               records[i].preference, ast_dns_naptr_get_preference(record));
         res = AST_TEST_FAIL;
      }
      if (strcmp(ast_dns_naptr_get_flags(record), records[i].flags)) {
         ast_test_status_update(test, "Expected flags %s, got flags %s from NAPTR record\n",
               records[i].flags, ast_dns_naptr_get_flags(record));
         res = AST_TEST_FAIL;
      }
      if (strcmp(ast_dns_naptr_get_service(record), records[i].services)) {
         ast_test_status_update(test, "Expected services %s, got services %s from NAPTR record\n",
               records[i].services, ast_dns_naptr_get_service(record));
         res = AST_TEST_FAIL;
      }
      if (strcmp(ast_dns_naptr_get_regexp(record), records[i].regexp)) {
         ast_test_status_update(test, "Expected regexp %s, got regexp %s from NAPTR record\n",
               records[i].regexp, ast_dns_naptr_get_regexp(record));
         res = AST_TEST_FAIL;
      }
      if (strcmp(ast_dns_naptr_get_replacement(record), records[i].replacement)) {
         ast_test_status_update(test, "Expected replacement %s, got replacement %s from NAPTR record\n",
               records[i].replacement, ast_dns_naptr_get_replacement(record));
         res = AST_TEST_FAIL;
      }
      records[i].visited = 1;
      ++i;
   }

   if (i != ARRAY_LEN(records)) {
      ast_test_status_update(test, "Unexpected number of records visited\n");
      res = AST_TEST_FAIL;
   }

   for (i = 0; i < ARRAY_LEN(records); ++i) {
      if (!records[i].visited) {
         ast_test_status_update(test, "Did not visit all expected NAPTR records\n");
         res = AST_TEST_FAIL;
      }
   }

   return res;

}

AST_TEST_DEFINE() [7/7]

AST_TEST_DEFINE

(

resolve_srv

)

Definition at line 1316 of file res_resolver_unbound.c.

References ao2_bump, ao2_cleanup, ao2_global_obj_ref, ast_dns_resolve(), ast_dns_result_free(), ast_dns_result_get_records(), ast_dns_srv_get_host(), ast_dns_srv_get_port(), ast_dns_srv_get_priority(), ast_dns_srv_get_weight(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, cleanup(), globals, sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_EXECUTE, and TEST_INIT.

{
   RAII_VAR(struct unbound_resolver *, resolver, NULL, ao2_cleanup);
   RAII_VAR(struct unbound_config *, cfg, NULL, ao2_cleanup);
   RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
   const struct ast_dns_record *record;
   static const char *DOMAIN1 = "taco.bananas";
   static const char *DOMAIN1_SRV = "taco.bananas 12345 IN SRV 10 20 5060 sip.taco.bananas";
   enum ast_test_result_state res = AST_TEST_PASS;

   switch (cmd) {
   case TEST_INIT:
      info->name = "resolve_srv";
      info->category = "/res/res_resolver_unbound/";
      info->summary = "Test synchronous SRV resolution using libunbound";
      info->description = "This test performs the following:\n"
         "\t* Set one SRV record on one domain\n"
         "\t* Perform an SRV lookup on the domain\n"
         "\t* Ensure that the SRV record returned matches the expected value";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   cfg = ao2_global_obj_ref(globals);
   resolver = ao2_bump(cfg->global->state->resolver);

   ub_ctx_zone_add(resolver->context, DOMAIN1, "static");
   ub_ctx_data_add(resolver->context, DOMAIN1_SRV);

   if (ast_dns_resolve(DOMAIN1, ns_t_srv, ns_c_in, &result)) {
      ast_test_status_update(test, "Failed to synchronously resolve SRV for domain '%s'\n", DOMAIN1);
      res = AST_TEST_FAIL;
      goto cleanup;
   }

   record = ast_dns_result_get_records(result);
   if (ast_dns_srv_get_priority(record) != 10) {
      ast_test_status_update(test, "SRV Record returned priority '%d' when we expected 10\n", ast_dns_srv_get_priority(record));
      res = AST_TEST_FAIL;
      goto cleanup;
   }

   if (ast_dns_srv_get_weight(record) != 20) {
      ast_test_status_update(test, "SRV Record returned weight '%d' when we expected 20\n", ast_dns_srv_get_weight(record));
      res = AST_TEST_FAIL;
      goto cleanup;
   }

   if (ast_dns_srv_get_port(record) != 5060) {
      ast_test_status_update(test, "SRV Record returned port '%d' when we expected 5060\n", ast_dns_srv_get_port(record));
      res = AST_TEST_FAIL;
      goto cleanup;
   }

   if (strcmp(ast_dns_srv_get_host(record), "sip.taco.bananas")) {
      ast_test_status_update(test, "SRV Record returned host '%s' when we expected sip.taco.bananas\n", ast_dns_srv_get_host(record));
      res = AST_TEST_FAIL;
      goto cleanup;
   }

cleanup:
   ub_ctx_data_remove(resolver->context, DOMAIN1_SRV);
   ub_ctx_zone_remove(resolver->context, DOMAIN1);

   return res;
}

async_callback()

static void async_callback ( const struct ast_dns_query *  query )

static

Callback for asynchronous queries.

This query will check that the records in the DNS result match records that the test has created. The success or failure of the query is indicated through the async_data failed field.

Parameters

query

The DNS query that has been resolved

Definition at line 649 of file res_resolver_unbound.c.

References ast_cond_signal, ast_dns_query_get_data(), ast_dns_query_get_result(), ast_dns_record_get_data(), ast_dns_record_get_next(), ast_dns_record_get_rr_class(), ast_dns_record_get_rr_type(), ast_dns_record_get_ttl(), ast_dns_result_get_records(), ast_mutex_lock, ast_mutex_unlock, dns_record::buf, dns_record::bufsize, async_data::complete, async_data::cond, end, async_data::failed, async_data::lock, match(), async_data::num_records, async_data::records, result, dns_record::rr_class, dns_record::rr_type, dns_record::ttl, and dns_record::visited.

Referenced by nominal_async_run().

{
   struct async_data *adata = ast_dns_query_get_data(query);
   struct ast_dns_result *result = ast_dns_query_get_result(query);
   const struct ast_dns_record *record;
   int i;

   if (!result) {
      adata->failed = -1;
      goto end;
   }

   for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
      int match = 0;

      /* Let's make sure this matches one of our known records */
      for (i = 0; i < adata->num_records; ++i) {
         if (ast_dns_record_get_rr_type(record) == adata->records[i].rr_type &&
               ast_dns_record_get_rr_class(record) == adata->records[i].rr_class &&
               ast_dns_record_get_ttl(record) == adata->records[i].ttl &&
               !memcmp(ast_dns_record_get_data(record), adata->records[i].buf, adata->records[i].bufsize)) {
            match = 1;
            adata->records[i].visited = 1;
            break;
         }
      }

      if (!match) {
         adata->failed = -1;
         goto end;
      }
   }

end:
   ast_mutex_lock(&adata->lock);
   adata->complete = 1;
   ast_cond_signal(&adata->cond);
   ast_mutex_unlock(&adata->lock);
}

async_data_alloc()

static struct async_data* async_data_alloc ( struct dns_record *  records, size_t  num_records  )

static

Definition at line 623 of file res_resolver_unbound.c.

References ao2_alloc, ast_cond_init, ast_mutex_init, async_data_destructor(), async_data::cond, async_data::lock, NULL, async_data::num_records, records, and async_data::records.

Referenced by nominal_async_run().

{
   struct async_data *adata;

   adata = ao2_alloc(sizeof(*adata), async_data_destructor);
   if (!adata) {
      return NULL;
   }

   ast_mutex_init(&adata->lock);
   ast_cond_init(&adata->cond, NULL);
   adata->records = records;
   adata->num_records = num_records;

   return adata;
}

async_data_destructor()

static void async_data_destructor ( void *  obj )

static

Definition at line 615 of file res_resolver_unbound.c.

References ast_cond_destroy, ast_mutex_destroy, async_data::cond, and async_data::lock.

Referenced by async_data_alloc().

{
   struct async_data *adata = obj;

   ast_mutex_destroy(&adata->lock);
   ast_cond_destroy(&adata->cond);
}

async_minimal_data_alloc()

static struct async_minimal_data* async_minimal_data_alloc ( void  )

static

Definition at line 1124 of file res_resolver_unbound.c.

References ao2_alloc, ast_cond_init, ast_mutex_init, async_minimal_data_destructor(), async_minimal_data::cond, async_minimal_data::lock, and NULL.

Referenced by AST_TEST_DEFINE().

{
   struct async_minimal_data *adata;

   adata = ao2_alloc(sizeof(*adata), async_minimal_data_destructor);
   if (!adata) {
      return NULL;
   }

   ast_mutex_init(&adata->lock);
   ast_cond_init(&adata->cond, NULL);

   return adata;
}

async_minimal_data_destructor()

static void async_minimal_data_destructor ( void *  obj )

static

Definition at line 1116 of file res_resolver_unbound.c.

References ast_cond_destroy, ast_mutex_destroy, async_minimal_data::cond, and async_minimal_data::lock.

Referenced by async_minimal_data_alloc().

{
   struct async_minimal_data *adata = obj;

   ast_mutex_destroy(&adata->lock);
   ast_cond_destroy(&adata->cond);
}

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 1409 of file res_resolver_unbound.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ast_str_container_add(), ast_str_container_alloc_options(), global, unbound_global_config::nameservers, and ast_variable::value.

Referenced by load_module().

{
   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);
}

load_module()

static int load_module ( void  )

static

Definition at line 1423 of file res_resolver_unbound.c.

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_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DEPEND, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_module_shutdown_ref, AST_MODULE_SUPPORT_CORE, AST_TEST_REGISTER, ASTERISK_GPL_KEY, custom_nameserver_handler(), debug, aco_file::filename, FLDSET, OPT_STRINGFIELD_T, OPT_UINT_T, reload(), reload_module(), ast_module_info::self, STRFLDSET, unbound_config_apply_default(), and unload_module().

{
   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;
}

minimal_callback()

static void minimal_callback ( const struct ast_dns_query *  query )

static

Async callback for off-nominal cancellation test.

This simply signals the testing thread that the query completed

Definition at line 1144 of file res_resolver_unbound.c.

References ast_cond_signal, ast_dns_query_get_data(), ast_mutex_lock, ast_mutex_unlock, async_minimal_data::complete, async_minimal_data::cond, and async_minimal_data::lock.

Referenced by AST_TEST_DEFINE().

{
   struct async_minimal_data *adata = ast_dns_query_get_data(query);

   ast_mutex_lock(&adata->lock);
   adata->complete = 1;
   ast_cond_signal(&adata->cond);
   ast_mutex_unlock(&adata->lock);
}

nominal_async_run()

static int nominal_async_run ( struct ast_test *  test, const char *  domain, int  rr_type, int  rr_class, struct dns_record *  records, size_t  num_records  )

static

Pluggable function for performing an asynchronous query during a test.

Unlike the synchronous version, this does not check the records, instead leaving that to be done in the asynchronous callback.

Definition at line 695 of file res_resolver_unbound.c.

References ao2_cleanup, ast_cond_wait, ast_dns_resolve_async(), ast_mutex_lock, ast_mutex_unlock, ast_test_status_update, async_callback(), async_data_alloc(), NULL, RAII_VAR, and dns_record::visited.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct ast_dns_query_active *, active, NULL, ao2_cleanup);
   RAII_VAR(struct async_data *, adata, NULL, ao2_cleanup);
   int i;

   adata = async_data_alloc(records, num_records);
   if (!adata) {
      ast_test_status_update(test, "Unable to allocate data for async query\n");
      return -1;
   }

   /* Start by making sure no records have been visited */
   for (i = 0; i < num_records; ++i) {
      records[i].visited = 0;
   }

   ast_test_status_update(test, "Performing DNS query '%s', type %d\n", domain, rr_type);

   active = ast_dns_resolve_async(domain, rr_type, rr_class, async_callback, adata);
   if (!active) {
      ast_test_status_update(test, "Failed to perform asynchronous resolution of domain %s\n", domain);
      return -1;
   }

   ast_mutex_lock(&adata->lock);
   while (!adata->complete) {
      ast_cond_wait(&adata->cond, &adata->lock);
   }
   ast_mutex_unlock(&adata->lock);

   if (adata->failed) {
      ast_test_status_update(test, "Unknown DNS record returned from domain %s\n", domain);
   }
   return adata->failed;
}

nominal_sync_run()

static int nominal_sync_run ( struct ast_test *  test, const char *  domain, int  rr_type, int  rr_class, struct dns_record *  records, size_t  num_records  )

static

Pluggable function for running a synchronous query and checking its results.

Definition at line 551 of file res_resolver_unbound.c.

References ast_dns_record_get_data(), ast_dns_record_get_next(), ast_dns_record_get_rr_class(), ast_dns_record_get_rr_type(), ast_dns_record_get_ttl(), ast_dns_resolve(), ast_dns_result_free(), ast_dns_result_get_records(), ast_test_status_update, buf, match(), NULL, RAII_VAR, result, dns_record::rr_class, dns_record::rr_type, dns_record::ttl, and dns_record::visited.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
   const struct ast_dns_record *record;
   int i;

   /* Start by making sure no records have been visited */
   for (i = 0; i < num_records; ++i) {
      records[i].visited = 0;
   }

   ast_test_status_update(test, "Performing DNS query '%s', type %d\n", domain, rr_type);

   if (ast_dns_resolve(domain, rr_type, rr_class, &result)) {
      ast_test_status_update(test, "Failed to perform synchronous resolution of domain %s\n", domain);
      return -1;
   }

   if (!result) {
      ast_test_status_update(test, "Successful synchronous resolution of domain %s gave NULL result\n", domain);
      return -1;
   }

   for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
      int match = 0;

      /* Let's make sure this matches one of our known records */
      for (i = 0; i < num_records; ++i) {
         if (ast_dns_record_get_rr_type(record) == records[i].rr_type &&
               ast_dns_record_get_rr_class(record) == records[i].rr_class &&
               ast_dns_record_get_ttl(record) == records[i].ttl &&
               !memcmp(ast_dns_record_get_data(record), records[i].buf, records[i].bufsize)) {
            match = 1;
            records[i].visited = 1;
            break;
         }
      }

      if (!match) {
         ast_test_status_update(test, "Unknown DNS record returned from domain %s\n", domain);
         return -1;
      }
   }

   return 0;
}

nominal_test()

static enum ast_test_result_state nominal_test ( struct ast_test *  test, resolve_fn  runner  )

static

Framework for running a nominal DNS test.

Synchronous and asynchronous tests mostly have the same setup, so this function serves as a common way to set up both types of tests by accepting a pluggable function to determine which type of lookup is used

Parameters

test	The test being run
runner	The method for resolving queries on this test

Definition at line 743 of file res_resolver_unbound.c.

References ao2_bump, ao2_cleanup, ao2_global_obj_ref, ARRAY_LEN, dns_record::as_string, AST_TEST_FAIL, AST_TEST_PASS, ast_test_status_update, cleanup(), globals, NULL, and RAII_VAR.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct unbound_resolver *, resolver, NULL, ao2_cleanup);
   RAII_VAR(struct unbound_config *, cfg, NULL, ao2_cleanup);

   static const size_t V4_SIZE = sizeof(struct in_addr);
   static const size_t V6_SIZE = sizeof(struct in6_addr);

   static const char *DOMAIN1 = "goose.feathers";
   static const char *DOMAIN2 = "duck.feathers";

   static const char *ADDR1 = "127.0.0.2";
   static const char *ADDR2 = "127.0.0.3";
   static const char *ADDR3 = "::1";
   static const char *ADDR4 = "127.0.0.4";

   char addr1_buf[V4_SIZE];
   char addr2_buf[V4_SIZE];
   char addr3_buf[V6_SIZE];
   char addr4_buf[V4_SIZE];

   struct dns_record records [] = {
      { "goose.feathers 12345 IN A 127.0.0.2", DOMAIN1, ns_t_a,    ns_c_in, 12345, addr1_buf, V4_SIZE, 0 },
      { "goose.feathers 12345 IN A 127.0.0.3", DOMAIN1, ns_t_a,    ns_c_in, 12345, addr2_buf, V4_SIZE, 0 },
      { "goose.feathers 12345 IN AAAA ::1",    DOMAIN1, ns_t_aaaa, ns_c_in, 12345, addr3_buf, V6_SIZE, 0 },
      { "duck.feathers 12345 IN A 127.0.0.4",  DOMAIN2, ns_t_a,    ns_c_in, 12345, addr4_buf, V4_SIZE, 0 },
   };

   struct {
      const char *domain;
      int rr_type;
      int rr_class;
      int visited[ARRAY_LEN(records)];
   } runs [] = {
      { DOMAIN1, ns_t_a,    ns_c_in, { 1, 1, 0, 0 } },
      { DOMAIN1, ns_t_aaaa, ns_c_in, { 0, 0, 1, 0 } },
      { DOMAIN2, ns_t_a,    ns_c_in, { 0, 0, 0, 1 } },
   };

   int i;
   enum ast_test_result_state res = AST_TEST_PASS;

   inet_pton(AF_INET,  ADDR1, addr1_buf);
   inet_pton(AF_INET,  ADDR2, addr2_buf);
   inet_pton(AF_INET6,  ADDR3, addr3_buf);
   inet_pton(AF_INET, ADDR4, addr4_buf);

   cfg = ao2_global_obj_ref(globals);
   resolver = ao2_bump(cfg->global->state->resolver);

   ub_ctx_zone_add(resolver->context, DOMAIN1, "static");
   ub_ctx_zone_add(resolver->context, DOMAIN2, "static");

   for (i = 0; i < ARRAY_LEN(records); ++i) {
      ub_ctx_data_add(resolver->context, records[i].as_string);
   }

   for (i = 0; i < ARRAY_LEN(runs); ++i) {
      int j;

      if (runner(test, runs[i].domain, runs[i].rr_type, runs[i].rr_class, records, ARRAY_LEN(records))) {
         res = AST_TEST_FAIL;
         goto cleanup;
      }

      for (j = 0; j < ARRAY_LEN(records); ++j) {
         if (records[j].visited != runs[i].visited[j]) {
            ast_test_status_update(test, "DNS results match unexpected records\n");
            res = AST_TEST_FAIL;
            goto cleanup;
         }
      }
   }

cleanup:
   for (i = 0; i < ARRAY_LEN(records); ++i) {
      ub_ctx_data_remove(resolver->context, records[i].as_string);
   }
   ub_ctx_zone_remove(resolver->context, DOMAIN1);
   ub_ctx_zone_remove(resolver->context, DOMAIN2);

   return res;
}

off_nominal_async_callback()

static void off_nominal_async_callback ( const struct ast_dns_query *  query )

static

Async callback for off-nominal async test.

This test ensures that there is a result present on the query, then it checks that the rcode on the result is the expected value and that there are no records on the result.

Once completed, the testing thread is signaled that the async query has completed.

Definition at line 958 of file res_resolver_unbound.c.

References ast_cond_signal, ast_dns_query_get_data(), ast_dns_query_get_result(), ast_dns_result_get_rcode(), ast_dns_result_get_records(), ast_mutex_lock, ast_mutex_unlock, off_nominal_async_data::complete, off_nominal_async_data::cond, end, off_nominal_async_data::expected_rcode, off_nominal_async_data::failed, off_nominal_async_data::lock, and result.

Referenced by off_nominal_async_run().

{
   struct off_nominal_async_data *adata = ast_dns_query_get_data(query);
   struct ast_dns_result *result = ast_dns_query_get_result(query);

   if (!result) {
      adata->failed = -1;
      goto end;
   }

   if (ast_dns_result_get_rcode(result) != adata->expected_rcode) {
      adata->failed = -1;
   }

   if (ast_dns_result_get_records(result)) {
      adata->failed = -1;
   }

end:
   ast_mutex_lock(&adata->lock);
   adata->complete = 1;
   ast_cond_signal(&adata->cond);
   ast_mutex_unlock(&adata->lock);
}

off_nominal_async_data_alloc()

static struct off_nominal_async_data* off_nominal_async_data_alloc ( int  expected_rcode )

static

Definition at line 931 of file res_resolver_unbound.c.

References ao2_alloc, ast_cond_init, ast_mutex_init, off_nominal_async_data::cond, off_nominal_async_data::expected_rcode, off_nominal_async_data::lock, NULL, and off_nominal_async_data_destructor().

Referenced by off_nominal_async_run().

{
   struct off_nominal_async_data *adata;

   adata = ao2_alloc(sizeof(*adata), off_nominal_async_data_destructor);
   if (!adata) {
      return NULL;
   }

   ast_mutex_init(&adata->lock);
   ast_cond_init(&adata->cond, NULL);

   adata->expected_rcode = expected_rcode;

   return adata;
}

off_nominal_async_data_destructor()

static void off_nominal_async_data_destructor ( void *  obj )

static

Definition at line 923 of file res_resolver_unbound.c.

References ast_cond_destroy, ast_mutex_destroy, off_nominal_async_data::cond, and off_nominal_async_data::lock.

Referenced by off_nominal_async_data_alloc().

{
   struct off_nominal_async_data *adata = obj;

   ast_mutex_destroy(&adata->lock);
   ast_cond_destroy(&adata->cond);
}

off_nominal_async_run()

static int off_nominal_async_run ( struct ast_test *  test, const char *  domain, int  rr_type, int  rr_class, int  expected_rcode  )

static

Definition at line 983 of file res_resolver_unbound.c.

References ao2_cleanup, ast_cond_wait, ast_dns_resolve_async(), ast_mutex_lock, ast_mutex_unlock, ast_test_status_update, NULL, off_nominal_async_callback(), off_nominal_async_data_alloc(), and RAII_VAR.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct ast_dns_query_active *, active, NULL, ao2_cleanup);
   RAII_VAR(struct off_nominal_async_data *, adata, NULL, ao2_cleanup);

   adata = off_nominal_async_data_alloc(expected_rcode);
   if (!adata) {
      ast_test_status_update(test, "Unable to allocate data for async query\n");
      return -1;
   }

   ast_test_status_update(test, "Performing DNS query '%s', type %d\n", domain, rr_type);

   active = ast_dns_resolve_async(domain, rr_type, rr_class, off_nominal_async_callback, adata);
   if (!active) {
      ast_test_status_update(test, "Failed to perform asynchronous resolution of domain %s\n", domain);
      return -1;
   }

   ast_mutex_lock(&adata->lock);
   while (!adata->complete) {
      ast_cond_wait(&adata->cond, &adata->lock);
   }
   ast_mutex_unlock(&adata->lock);

   if (adata->failed) {
      ast_test_status_update(test, "Asynchronous resolution failure %s\n", domain);
   }
   return adata->failed;
}

off_nominal_sync_run()

static int off_nominal_sync_run ( struct ast_test *  test, const char *  domain, int  rr_type, int  rr_class, int  expected_rcode  )

static

Definition at line 879 of file res_resolver_unbound.c.

References ast_dns_resolve(), ast_dns_result_free(), ast_dns_result_get_rcode(), ast_dns_result_get_records(), ast_test_status_update, and result.

Referenced by AST_TEST_DEFINE().

{
   struct ast_dns_result *result;
   int res = 0;

   if (ast_dns_resolve(domain, rr_type, rr_class, &result)) {
      ast_test_status_update(test, "Failed to perform resolution :(\n");
      return -1;
   }

   if (!result) {
      ast_test_status_update(test, "Resolution returned no result\n");
      return -1;
   }

   if (ast_dns_result_get_rcode(result) != expected_rcode) {
      ast_test_status_update(test, "Unexpected rcode from DNS resolution\n");
      res = -1;
   }

   if (ast_dns_result_get_records(result)) {
      ast_test_status_update(test, "DNS resolution returned records unexpectedly\n");
      res = -1;
   }

   ast_dns_result_free(result);
   return res;
}

off_nominal_test()

static enum ast_test_result_state off_nominal_test ( struct ast_test *  test, off_nominal_resolve_fn  runner  )

static

Definition at line 1015 of file res_resolver_unbound.c.

References ao2_bump, ao2_cleanup, ao2_global_obj_ref, ARRAY_LEN, dns_record::as_string, AST_TEST_FAIL, AST_TEST_PASS, globals, NULL, and RAII_VAR.

Referenced by AST_TEST_DEFINE().

{
   RAII_VAR(struct unbound_resolver *, resolver, NULL, ao2_cleanup);
   RAII_VAR(struct unbound_config *, cfg, NULL, ao2_cleanup);

   static const size_t V4_SIZE = sizeof(struct in_addr);

   static const char *DOMAIN1 = "goose.feathers";
   static const char *DOMAIN2 = "duck.feathers";

   static const char *ADDR1 = "127.0.0.2";

   char addr1_buf[V4_SIZE];

   struct dns_record records [] = {
      { "goose.feathers 12345 IN A 127.0.0.2", DOMAIN1, ns_t_a, ns_c_in, 12345, addr1_buf, V4_SIZE, 0, },
   };

   int i;
   enum ast_test_result_state res = AST_TEST_PASS;

   struct {
      const char *domain;
      int rr_type;
      int rr_class;
      int rcode;
   } runs [] = {
      { DOMAIN2, ns_t_a,    ns_c_in, ns_r_nxdomain },
      { DOMAIN1, ns_t_aaaa, ns_c_in, ns_r_noerror },
      { DOMAIN1, ns_t_a,    ns_c_chaos, ns_r_refused },
   };

   inet_pton(AF_INET,  ADDR1, addr1_buf);

   cfg = ao2_global_obj_ref(globals);
   resolver = ao2_bump(cfg->global->state->resolver);

   ub_ctx_zone_add(resolver->context, DOMAIN1, "static");
   ub_ctx_zone_add(resolver->context, DOMAIN2, "static");

   for (i = 0; i < ARRAY_LEN(records); ++i) {
      ub_ctx_data_add(resolver->context, records[i].as_string);
   }

   for (i = 0; i < ARRAY_LEN(runs); ++i) {
      if (runner(test, runs[i].domain, runs[i].rr_type, runs[i].rr_class, runs[i].rcode)) {
         res = AST_TEST_FAIL;
      }
   }

   return res;
}

reload_module()

static int reload_module ( void  )

static

Definition at line 1385 of file res_resolver_unbound.c.

References aco_process_config(), ACO_PROCESS_ERROR, and AST_MODULE_RELOAD_ERROR.

Referenced by load_module().

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

   return 0;
}

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 365 of file res_resolver_unbound.c.

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().

{
   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;
}

unbound_config_apply_default()

static int unbound_config_apply_default ( void  )

static

Definition at line 472 of file res_resolver_unbound.c.

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

Referenced by load_module().

{
   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;
}

unbound_config_destructor()

static void unbound_config_destructor ( void *  obj )

static

Definition at line 339 of file res_resolver_unbound.c.

References ao2_cleanup, and unbound_config::global.

Referenced by unbound_config_alloc().

{
   struct unbound_config *cfg = obj;

   ao2_cleanup(cfg->global);
}

unbound_config_preapply()

static int unbound_config_preapply ( struct unbound_config *  cfg )

static

Definition at line 391 of file res_resolver_unbound.c.

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().

{
   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;
}

unbound_config_preapply_callback()

static int unbound_config_preapply_callback ( void  )

static

Finish initializing new configuration.

Definition at line 497 of file res_resolver_unbound.c.

References aco_pending_config(), and unbound_config_preapply().

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

unbound_config_state_destructor()

static void unbound_config_state_destructor ( void *  obj )

static

Definition at line 355 of file res_resolver_unbound.c.

References ao2_ref, unbound_config_state::resolver, and unbound_resolver_stop().

Referenced by unbound_config_preapply().

{
   struct unbound_config_state *state = obj;

   if (state->resolver) {
      unbound_resolver_stop(state->resolver);
      ao2_ref(state->resolver, -1);
   }
}

unbound_global_config_destructor()

static void unbound_global_config_destructor ( void *  obj )

static

Definition at line 346 of file res_resolver_unbound.c.

References ao2_cleanup, ast_string_field_free_memory, global, unbound_global_config::nameservers, and unbound_global_config::state.

Referenced by unbound_config_alloc().

{
   struct unbound_global_config *global = obj;

   ast_string_field_free_memory(global);
   ao2_cleanup(global->nameservers);
   ao2_cleanup(global->state);
}

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.

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().

{
   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;
}

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.

References ao2_ref, 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().

{
   struct ast_dns_query *query = data;

   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);
}

unbound_resolver_cancel()

static int unbound_resolver_cancel ( struct ast_dns_query *  query )

static

Definition at line 316 of file res_resolver_unbound.c.

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

{
   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;
}

unbound_resolver_data_dtor()

static void unbound_resolver_data_dtor ( void *  vdoomed )

static

Definition at line 278 of file res_resolver_unbound.c.

References ao2_cleanup, and unbound_resolver_data::resolver.

Referenced by unbound_resolver_resolve().

{
   struct unbound_resolver_data *doomed = vdoomed;

   ao2_cleanup(doomed->resolver);
}

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.

References unbound_resolver::context.

Referenced by unbound_resolver_alloc().

{
   struct unbound_resolver *resolver = obj;

   if (resolver->context) {
      ub_ctx_delete(resolver->context);
   }
}

unbound_resolver_resolve()

static int unbound_resolver_resolve ( struct ast_dns_query *  query )

static

Definition at line 285 of file res_resolver_unbound.c.

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().

{
   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;
}

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.

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().

{
   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;
}

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.

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

Referenced by unbound_config_state_destructor().

{
   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");
}

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.

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().

{
   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;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 1394 of file res_resolver_unbound.c.

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

Referenced by load_module().

{
   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;
}

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 1474 of file res_resolver_unbound.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1474 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.

global_options

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

static

Definition at line 138 of file res_resolver_unbound.c.

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.

unbound_resolver

struct ast_dns_resolver unbound_resolver

Definition at line 332 of file res_resolver_unbound.c.