dns_core.c File Reference

Core DNS Functionality. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/linkedlists.h"
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/sched.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_srv.h"
#include "asterisk/dns_tlsa.h"
#include "asterisk/dns_recurring.h"
#include "asterisk/dns_resolver.h"
#include "asterisk/dns_internal.h"
#include "asterisk/netsock2.h"
#include <netinet/in.h>
#include <arpa/nameser.h>

Include dependency graph for dns_core.c:

Go to the source code of this file.

Data Structures
struct	dns_synchronous_resolve
	Structure used for signaling back for synchronous resolution completion. More...
struct	resolvers

Typedefs
typedef struct ast_dns_record *(*	dns_alloc_fn) (struct ast_dns_query *query, const char *data, const size_t size)
typedef void(*	dns_sort_fn) (struct ast_dns_result *result)

Functions
static struct ast_dns_record *	allocate_dns_record (unsigned int rr_type, struct ast_dns_query *query, const char *data, const size_t size)
struct ast_sched_context *	ast_dns_get_sched (void)
	Retrieve the DNS scheduler context.
void *	ast_dns_query_get_data (const struct ast_dns_query *query)
	Get the user specific data of a DNS query.
const char *	ast_dns_query_get_name (const struct ast_dns_query *query)
	Get the name queried in a DNS query.
struct ast_dns_result *	ast_dns_query_get_result (const struct ast_dns_query *query)
	Get the result information for a DNS query.
int	ast_dns_query_get_rr_class (const struct ast_dns_query *query)
	Get the record resource class of a DNS query.
int	ast_dns_query_get_rr_type (const struct ast_dns_query *query)
	Get the record resource type of a DNS query.
const char *	ast_dns_record_get_data (const struct ast_dns_record *record)
	Retrieve the raw DNS record.
size_t	ast_dns_record_get_data_size (const struct ast_dns_record *record)
	Retrieve the size of the raw DNS record.
const struct ast_dns_record *	ast_dns_record_get_next (const struct ast_dns_record *record)
	Get the next DNS record.
int	ast_dns_record_get_rr_class (const struct ast_dns_record *record)
	Get the resource record class of a DNS record.
int	ast_dns_record_get_rr_type (const struct ast_dns_record *record)
	Get the resource record type of a DNS record.
int	ast_dns_record_get_ttl (const struct ast_dns_record *record)
	Get the TTL of a DNS record.
int	ast_dns_resolve (const char *name, int rr_type, int rr_class, struct ast_dns_result **result)
	Synchronously resolve a DNS query.
struct ast_dns_query_active *	ast_dns_resolve_async (const char *name, int rr_type, int rr_class, ast_dns_resolve_callback callback, void *data)
	Asynchronously resolve a DNS query.
int	ast_dns_resolve_cancel (struct ast_dns_query_active *active)
	Cancel an asynchronous DNS resolution.
int	ast_dns_resolve_ipv6_and_ipv4 (struct ast_sockaddr *address, const char *host, const char *port)
	Synchronously resolves host to an AAAA or A record.
int	ast_dns_resolver_add_record (struct ast_dns_query *query, int rr_type, int rr_class, int ttl, const char *data, const size_t size)
	Add a DNS record to the result of a DNS query.
void	ast_dns_resolver_completed (struct ast_dns_query *query)
	Mark a DNS query as having been completed.
void *	ast_dns_resolver_get_data (const struct ast_dns_query *query)
	Retrieve resolver specific data.
int	ast_dns_resolver_register (struct ast_dns_resolver *resolver)
	Register a DNS resolver.
int	ast_dns_resolver_set_data (struct ast_dns_query *query, void *data)
	Set resolver specific data on a query.
int	ast_dns_resolver_set_result (struct ast_dns_query *query, unsigned int secure, unsigned int bogus, unsigned int rcode, const char *canonical, const char *answer, size_t answer_size)
	Set result information for a DNS query.
void	ast_dns_resolver_unregister (struct ast_dns_resolver *resolver)
	Unregister a DNS resolver.
void	ast_dns_result_free (struct ast_dns_result *result)
	Free the DNS result information.
const char *	ast_dns_result_get_answer (const struct ast_dns_result *result)
	Get the raw DNS answer from a DNS result.
unsigned int	ast_dns_result_get_bogus (const struct ast_dns_result *result)
	Get whether the result is bogus or not.
const char *	ast_dns_result_get_canonical (const struct ast_dns_result *result)
	Get the canonical name of the result.
int	ast_dns_result_get_lowest_ttl (const struct ast_dns_result *result)
	Retrieve the lowest TTL from a result.
unsigned int	ast_dns_result_get_rcode (const struct ast_dns_result *result)
	Get the error rcode of a DN result.
const struct ast_dns_record *	ast_dns_result_get_records (const struct ast_dns_result *result)
	Get the first record of a DNS Result.
unsigned int	ast_dns_result_get_secure (const struct ast_dns_result *result)
	Get whether the result is secure or not.
int	dns_core_init (void)
char *	dns_find_record (const char *record, size_t record_size, const char *response, size_t response_size)
	Find the location of a DNS record within the entire DNS answer.
int	dns_parse_short (unsigned char *cur, uint16_t *val)
	Parse a 16-bit unsigned value from a DNS record.
int	dns_parse_string (char *cur, uint8_t *size, char **val)
	Parse a DNS string from a DNS record.
static void	dns_query_active_destroy (void *data)
	Destructor for an active DNS query.
struct ast_dns_query *	dns_query_alloc (const char *name, int rr_type, int rr_class, ast_dns_resolve_callback callback, void *data)
	Allocate a DNS query (but do not start resolution)
static void	dns_query_destroy (void *data)
	Destructor for a DNS query.
static void	dns_shutdown (void)
static void	dns_synchronous_resolve_callback (const struct ast_dns_query *query)
	Callback used to implement synchronous resolution.
static void	dns_synchronous_resolve_destroy (void *data)
	Destructor for synchronous resolution structure.
static struct ast_dns_record *	generic_record_alloc (struct ast_dns_query *query, const char *data, const size_t size)
static void	sort_result (int rr_type, struct ast_dns_result *result)

Variables
static dns_alloc_fn	dns_alloc_table []
static dns_sort_fn	dns_sort_table []
struct resolvers	resolvers = AST_RWLIST_HEAD_INIT_VALUE
static struct ast_sched_context *	sched

Detailed Description

Core DNS Functionality.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file dns_core.c.

Typedef Documentation

dns_alloc_fn

typedef struct ast_dns_record *(* dns_alloc_fn) (struct ast_dns_query *query, const char *data, const size_t size)

Definition at line 503 of file dns_core.c.

dns_sort_fn

typedef void(* dns_sort_fn) (struct ast_dns_result *result)

Definition at line 586 of file dns_core.c.

Function Documentation

allocate_dns_record()

static struct ast_dns_record * allocate_dns_record ( unsigned int  rr_type, struct ast_dns_query *  query, const char *  data, const size_t  size  )

static

Definition at line 525 of file dns_core.c.

{
    dns_alloc_fn allocator = generic_record_alloc;
 
    if (rr_type < ARRAY_LEN(dns_alloc_table) && dns_alloc_table[rr_type]) {
        allocator = dns_alloc_table[rr_type];
    }
 
    return allocator(query, data, size);
}

References ARRAY_LEN, ast_dns_record::data, dns_alloc_table, generic_record_alloc(), and ast_dns_record::rr_type.

Referenced by ast_dns_resolver_add_record().

ast_dns_get_sched()

struct ast_sched_context * ast_dns_get_sched

(

void

)

Retrieve the DNS scheduler context.

Returns

scheduler context

Definition at line 52 of file dns_core.c.

{
    return sched;
}

References sched.

Referenced by ast_dns_resolve_recurring(), ast_dns_resolve_recurring_cancel(), and dns_query_recurring_resolution_callback().

ast_dns_query_get_data()

void * ast_dns_query_get_data

(

const struct ast_dns_query *

query

)

Get the user specific data of a DNS query.

Parameters

query

The DNS query

Returns

the user specific data

Note

The reference count of the data is NOT incremented on return

Definition at line 72 of file dns_core.c.

{
    return query->user_data;
}

References ast_dns_query::user_data.

Referenced by async_callback(), async_callback(), dns_query_recurring_resolution_callback(), dns_query_set_callback(), dns_synchronous_resolve_callback(), query_set_cancel(), query_set_resolve(), recurring_cancel(), recurring_resolve(), resolution_thread(), and resolution_thread().

ast_dns_query_get_name()

const char * ast_dns_query_get_name

(

const struct ast_dns_query *

query

)

Get the name queried in a DNS query.

Parameters

query

The DNS query

Returns

the name queried

Definition at line 57 of file dns_core.c.

{
    return query->name;
}

References ast_dns_query::name.

Referenced by dns_query_recurring_resolution_callback(), dns_system_resolver_process_query(), dns_system_resolver_resolve(), dns_system_resolver_set_response(), query_set_test(), unbound_resolver_callback(), and unbound_resolver_resolve().

ast_dns_query_get_result()

struct ast_dns_result * ast_dns_query_get_result

(

const struct ast_dns_query *

query

)

Get the result information for a DNS query.

Parameters

query

The DNS query

Returns

the DNS result information

Note

The result is NOT ao2 allocated

Definition at line 77 of file dns_core.c.

{
    return query->result;
}

References ast_dns_query::result.

Referenced by ast_dns_resolve_ipv6_and_ipv4(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), dns_query_recurring_resolution_callback(), dns_system_resolver_set_response(), and test_results().

ast_dns_query_get_rr_class()

int ast_dns_query_get_rr_class

(

const struct ast_dns_query *

query

)

Get the record resource class of a DNS query.

Parameters

query

The DNS query

Returns

the record resource class

Definition at line 67 of file dns_core.c.

{
    return query->rr_class;
}

References ast_dns_query::rr_class.

Referenced by dns_query_recurring_resolution_callback(), dns_system_resolver_add_record(), dns_system_resolver_process_query(), query_set_test(), and unbound_resolver_resolve().

ast_dns_query_get_rr_type()

int ast_dns_query_get_rr_type

(

const struct ast_dns_query *

query

)

Get the record resource type of a DNS query.

Parameters

query

The DNS query

Returns

the record resource type

Definition at line 62 of file dns_core.c.

{
    return query->rr_type;
}

References ast_dns_query::rr_type.

Referenced by ast_dns_resolver_completed(), dns_query_recurring_resolution_callback(), dns_system_resolver_add_record(), dns_system_resolver_process_query(), query_set_test(), and unbound_resolver_resolve().

ast_dns_record_get_data()

const char * ast_dns_record_get_data

(

const struct ast_dns_record *

record

)

Retrieve the raw DNS record.

Parameters

record

The DNS record

Returns

the raw DNS record

Definition at line 160 of file dns_core.c.

{
    return record->data_ptr;
}

References ast_dns_record::data_ptr.

Referenced by ast_dns_resolve_ipv6_and_ipv4(), ast_dns_txt_get_strings(), and test_record().

ast_dns_record_get_data_size()

size_t ast_dns_record_get_data_size

(

const struct ast_dns_record *

record

)

Retrieve the size of the raw DNS record.

Parameters

record

The DNS record

Returns

the size of the raw DNS record

Definition at line 165 of file dns_core.c.

{
    return record->data_len;
}

References ast_dns_record::data_len.

Referenced by ast_dns_resolve_ipv6_and_ipv4(), and ast_dns_txt_get_strings().

ast_dns_record_get_next()

const struct ast_dns_record * ast_dns_record_get_next

(

const struct ast_dns_record *

record

)

Get the next DNS record.

Parameters

record

The current DNS record

Returns

the next DNS record

Definition at line 170 of file dns_core.c.

{
    return AST_LIST_NEXT(record, list);
}

References AST_LIST_NEXT, and ast_dns_record::list.

Referenced by ast_dns_resolve_ipv6_and_ipv4(), ast_dns_result_get_lowest_ttl(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and nominal_test().

ast_dns_record_get_rr_class()

int ast_dns_record_get_rr_class

(

const struct ast_dns_record *

record

)

Get the resource record class of a DNS record.

Parameters

record

The DNS record

Returns

the resource record class

Definition at line 150 of file dns_core.c.

{
    return record->rr_class;
}

References ast_dns_record::rr_class.

Referenced by test_record().

ast_dns_record_get_rr_type()

int ast_dns_record_get_rr_type

(

const struct ast_dns_record *

record

)

Get the resource record type of a DNS record.

Parameters

record

The DNS record

Returns

the resource record type

Definition at line 145 of file dns_core.c.

{
    return record->rr_type;
}

References ast_dns_record::rr_type.

Referenced by 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_resolve_ipv6_and_ipv4(), ast_dns_srv_get_host(), ast_dns_srv_get_port(), ast_dns_srv_get_priority(), ast_dns_srv_get_weight(), ast_dns_txt_get_count(), ast_dns_txt_get_strings(), AST_TEST_DEFINE(), and test_record().

ast_dns_record_get_ttl()

int ast_dns_record_get_ttl

(

const struct ast_dns_record *

record

)

Get the TTL of a DNS record.

Parameters

record

The DNS record

Returns

the TTL

Definition at line 155 of file dns_core.c.

{
    return record->ttl;
}

References ast_dns_record::ttl.

Referenced by ast_dns_result_get_lowest_ttl(), and test_record().

ast_dns_resolve()

int ast_dns_resolve	(	const char *	name,
		int	rr_type,
		int	rr_class,
		struct ast_dns_result **	result
	)

Synchronously resolve a DNS query.

Parameters

name	The name of what to resolve
rr_type	Resource record type
rr_class	Resource record class
result	A pointer to hold the DNS result

Return values

0	success - query was completed and result is available
-1	failure

Definition at line 315 of file dns_core.c.

{
    struct dns_synchronous_resolve *synchronous;
    struct ast_dns_query_active *active;
 
    if (ast_strlen_zero(name)) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution, no name provided\n");
        return -1;
    } else if (rr_type > 65536) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution of '%s', resource record type '%d' exceeds maximum\n",
            name, rr_type);
        return -1;
    } else if (rr_type < 0) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution of '%s', invalid resource record type '%d'\n",
            name, rr_type);
        return -1;
    } else if (rr_class > 65536) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution of '%s', resource record class '%d' exceeds maximum\n",
            name, rr_class);
        return -1;
    } else if (rr_class < 0) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution of '%s', invalid resource class '%d'\n",
            name, rr_class);
        return -1;
    } else if (!result) {
        ast_log(LOG_WARNING, "Could not perform synchronous resolution of '%s', no result pointer provided for storing results\n",
            name);
        return -1;
    }
 
    synchronous = ao2_alloc_options(sizeof(*synchronous), dns_synchronous_resolve_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!synchronous) {
        return -1;
    }
 
    ast_mutex_init(&synchronous->lock);
    ast_cond_init(&synchronous->cond, NULL);
 
    active = ast_dns_resolve_async(name, rr_type, rr_class, dns_synchronous_resolve_callback, synchronous);
    if (active) {
        /* Wait for resolution to complete */
        ast_mutex_lock(&synchronous->lock);
        while (!synchronous->completed) {
            ast_cond_wait(&synchronous->cond, &synchronous->lock);
        }
        ast_mutex_unlock(&synchronous->lock);
        ao2_ref(active, -1);
    }
 
    *result = synchronous->result;
    ao2_ref(synchronous, -1);
 
    return *result ? 0 : -1;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_cond_init, ast_cond_wait, ast_dns_resolve_async(), ast_log, ast_mutex_init, ast_mutex_lock, ast_mutex_unlock, ast_strlen_zero(), dns_synchronous_resolve::completed, dns_synchronous_resolve::cond, dns_synchronous_resolve_callback(), dns_synchronous_resolve_destroy(), dns_synchronous_resolve::lock, LOG_WARNING, name, NULL, result, and dns_synchronous_resolve::result.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), invalid_record_test(), nominal_test(), and off_nominal_test().

ast_dns_resolve_async()

struct ast_dns_query_active * ast_dns_resolve_async	(	const char *	name,
		int	rr_type,
		int	rr_class,
		ast_dns_resolve_callback	callback,
		void *	data
	)

Asynchronously resolve a DNS query.

Parameters

name	The name of what to resolve
rr_type	Resource record type
rr_class	Resource record class
callback	The callback to invoke upon completion
data	User data to make available on the query

Return values

non-NULL	success - query has been sent for resolution
NULL	failure

Note

The result passed to the callback does not need to be freed

The user data MUST be an ao2 object

This function increments the reference count of the user data, it does NOT steal

The active query must be released upon completion or cancellation using ao2_ref

Definition at line 247 of file dns_core.c.

{
    struct ast_dns_query_active *active;
 
    active = ao2_alloc_options(sizeof(*active), dns_query_active_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!active) {
        return NULL;
    }
 
    active->query = dns_query_alloc(name, rr_type, rr_class, callback, data);
    if (!active->query) {
        ao2_ref(active, -1);
        return NULL;
    }
    ast_debug(2, "Calling %s resolver for name: %s class: %d type: %d", active->query->resolver->name,
        name, rr_class, rr_type);
    if (active->query->resolver->resolve(active->query)) {
        ast_log(LOG_ERROR, "Resolver '%s' returned an error when resolving '%s' of class '%d' and type '%d'\n",
            active->query->resolver->name, name, rr_class, rr_type);
        ao2_ref(active, -1);
        return NULL;
    }
 
    return active;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_debug, ast_log, callback(), dns_query_active_destroy(), dns_query_alloc(), LOG_ERROR, name, ast_dns_resolver::name, NULL, ast_dns_query_active::query, ast_dns_resolver::resolve, and ast_dns_query::resolver.

Referenced by ast_dns_resolve(), ast_dns_resolve_recurring(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and dns_query_recurring_scheduled_callback().

ast_dns_resolve_cancel()

int ast_dns_resolve_cancel

(

struct ast_dns_query_active *

active

)

Cancel an asynchronous DNS resolution.

Parameters

active

The active DNS query returned from ast_dns_resolve_async

Return values

0	success
-1	failure

Note

If successfully cancelled the callback will not be invoked

Definition at line 273 of file dns_core.c.

{
    return active->query->resolver->cancel(active->query);
}

References ast_dns_resolver::cancel, ast_dns_query_active::query, and ast_dns_query::resolver.

Referenced by ast_dns_resolve_recurring_cancel(), and AST_TEST_DEFINE().

ast_dns_resolve_ipv6_and_ipv4()

int ast_dns_resolve_ipv6_and_ipv4	(	struct ast_sockaddr *	address,
		const char *	host,
		const char *	port
	)

Synchronously resolves host to an AAAA or A record.

Since

16.6.0

Parameters

address	A pointer to an ast_sockaddr structure to receive the IPv6 or IPv4 address
host	The hostname to resolve
port	(optional) A port to parse into the final ast_sockaddr structure

Return values

0	success - query was completed and result is available
-1	failure

Note

This function makes parallel queries for both AAAA and A records for the host. The first returned AAAA record (if any) is used and if not found, the first A record is used.

Warning

This function is synchronous and will block until records are returned or an error occurs.

Definition at line 370 of file dns_core.c.

{
    RAII_VAR(struct ast_dns_query_set *, queries, ast_dns_query_set_create(), ao2_cleanup);
    int i;
    int rc;
 
    if (!queries) {
        ast_log(LOG_ERROR, "Couldn't allocate DNS query structure\n");
        return -1;
    }
    rc = ast_dns_query_set_add(queries, host, ns_t_aaaa, ns_c_in);
    if (rc != 0) {
        ast_log(LOG_ERROR, "Couldn't add 'AAAA' DNS query for '%s'\n", host);
        return -1;
    }
    rc = ast_dns_query_set_add(queries, host, ns_t_a, ns_c_in);
    if (rc != 0) {
        ast_log(LOG_ERROR, "Couldn't add 'A' DNS query for '%s'\n", host);
        return -1;
    }
    rc = ast_query_set_resolve(queries);
    if (rc != 0) {
        ast_log(LOG_ERROR, "Query set resolve failure for '%s'\n", host);
        return -1;
    }
    for (i = 0; i < ast_dns_query_set_num_queries(queries); ++i) {
        struct ast_dns_query *query = ast_dns_query_set_get(queries, i);
        struct ast_dns_result *result = ast_dns_query_get_result(query);
        const struct ast_dns_record *record;
        in_port_t in_port = 0;
 
        if (!ast_strlen_zero(port)) {
            in_port = htons(atoi(port));
        }
 
        for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
            size_t data_size = ast_dns_record_get_data_size(record);
            const unsigned char *data = (unsigned char *)ast_dns_record_get_data(record);
            int rr_type = ast_dns_record_get_rr_type(record);
 
            if (rr_type == ns_t_aaaa && data_size == 16) {
                struct sockaddr_in6 sin6 = { 0, };
 
                sin6.sin6_port = in_port;
                memcpy(&sin6.sin6_addr, data, data_size);
                sin6.sin6_family = AF_INET6;
                memcpy(&address->ss, &sin6, sizeof(sin6));
                address->len = sizeof(sin6);
 
                return 0;
            } else if (rr_type == ns_t_a && data_size == 4) {
                struct sockaddr_in sin4 = { 0, };
 
                sin4.sin_port = in_port;
                memcpy(&sin4.sin_addr, data, data_size);
                sin4.sin_family = AF_INET;
                memcpy(&address->ss, &sin4, sizeof(sin4));
                address->len = sizeof(sin4);
 
                return 0;
            } else {
                ast_debug(3, "Unrecognized rr_type '%u' or data_size '%zu' from DNS query for host '%s'\n",
                    rr_type, data_size, host);
                continue;
            }
        }
    }
 
    return -1;
}

References ao2_cleanup, ast_debug, ast_dns_query_get_result(), ast_dns_query_set_add(), ast_dns_query_set_create(), ast_dns_query_set_get(), ast_dns_query_set_num_queries(), ast_dns_record_get_data(), ast_dns_record_get_data_size(), ast_dns_record_get_next(), ast_dns_record_get_rr_type(), ast_dns_result_get_records(), ast_log, ast_query_set_resolve(), ast_strlen_zero(), ast_dns_record::data, LOG_ERROR, RAII_VAR, result, and ast_dns_record::rr_type.

Referenced by unicast_rtp_request().

ast_dns_resolver_add_record()

int ast_dns_resolver_add_record	(	struct ast_dns_query *	query,
		int	rr_type,
		int	rr_class,
		int	ttl,
		const char *	data,
		const size_t	size
	)

Add a DNS record to the result of a DNS query.

Parameters

query	The DNS query
rr_type	Resource record type
rr_class	Resource record class
ttl	TTL of the record
data	The raw DNS record
size	The size of the raw DNS record

Return values

0	success
-1	failure

Definition at line 536 of file dns_core.c.

{
    struct ast_dns_record *record;
 
    if (rr_type < 0) {
        ast_debug(2, "Query '%p': Could not add record, invalid resource record type '%d'\n",
            query, rr_type);
        return -1;
    } else if (rr_type > 65536) {
        ast_debug(2, "Query '%p': Could not add record, resource record type '%d' exceeds maximum\n",
            query, rr_type);
        return -1;
    } else if (rr_class < 0) {
        ast_debug(2, "Query '%p': Could not add record, invalid resource record class '%d'\n",
            query, rr_class);
        return -1;
    } else if (rr_class > 65536) {
        ast_debug(2, "Query '%p': Could not add record, resource record class '%d' exceeds maximum\n",
            query, rr_class);
        return -1;
    } else if (ttl < 0) {
        ast_debug(2, "Query '%p': Could not add record, invalid TTL '%d'\n",
            query, ttl);
        return -1;
    } else if (!data || !size) {
        ast_debug(2, "Query '%p': Could not add record, no data specified\n",
            query);
        return -1;
    } else if (!query->result) {
        ast_debug(2, "Query '%p': No result was set on the query, thus records can not be added\n",
            query);
        return -1;
    }
 
    record = allocate_dns_record(rr_type, query, data, size);
    if (!record) {
        return -1;
    }
 
    record->rr_type = rr_type;
    record->rr_class = rr_class;
    record->ttl = ttl;
    record->data_len = size;
    memcpy(record->data_ptr, data, size);
 
    AST_LIST_INSERT_TAIL(&query->result->records, record, list);
 
    return 0;
}

References allocate_dns_record(), ast_debug, AST_LIST_INSERT_TAIL, ast_dns_record::data, ast_dns_record::data_len, ast_dns_record::data_ptr, ast_dns_record::list, ast_dns_result::records, ast_dns_query::result, ast_dns_record::rr_class, ast_dns_record::rr_type, and ast_dns_record::ttl.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), dns_system_resolver_add_record(), naptr_thread(), resolution_thread(), resolution_thread(), srv_thread(), and unbound_resolver_callback().

ast_dns_resolver_completed()

void ast_dns_resolver_completed

(

struct ast_dns_query *

query

)

Mark a DNS query as having been completed.

Parameters

query

The DNS query

Definition at line 600 of file dns_core.c.

{
    if (query->result) {
        sort_result(ast_dns_query_get_rr_type(query), query->result);
    }
 
    query->callback(query);
}

References ast_dns_query_get_rr_type(), ast_dns_query::callback, ast_dns_query::result, and sort_result().

Referenced by dns_system_resolver_process_query(), naptr_thread(), resolution_thread(), resolution_thread(), resolution_thread(), srv_thread(), and unbound_resolver_callback().

ast_dns_resolver_get_data()

void * ast_dns_resolver_get_data

(

const struct ast_dns_query *

query

)

Retrieve resolver specific data.

Parameters

query

The DNS query

Returns

the resolver specific data

Note

The reference count of the resolver data is NOT incremented on return

Definition at line 452 of file dns_core.c.

{
    return query->resolver_data;
}

References ast_dns_query::resolver_data.

Referenced by AST_TEST_DEFINE(), and unbound_resolver_cancel().

ast_dns_resolver_register()

int ast_dns_resolver_register

(

struct ast_dns_resolver *

resolver

)

Register a DNS resolver.

Parameters

resolver

A DNS resolver implementation

Return values

0	success
-1	failure

Definition at line 633 of file dns_core.c.

{
    struct ast_dns_resolver *iter;
    int inserted = 0;
 
    if (!resolver) {
        return -1;
    } else if (ast_strlen_zero(resolver->name)) {
        ast_log(LOG_ERROR, "Registration of DNS resolver failed as it does not have a name\n");
        return -1;
    } else if (!resolver->resolve) {
        ast_log(LOG_ERROR, "DNS resolver '%s' does not implement the resolve callback which is required\n",
            resolver->name);
        return -1;
    } else if (!resolver->cancel) {
        ast_log(LOG_ERROR, "DNS resolver '%s' does not implement the cancel callback which is required\n",
            resolver->name);
        return -1;
    }
 
    AST_RWLIST_WRLOCK(&resolvers);
 
    AST_LIST_TRAVERSE(&resolvers, iter, next) {
        if (!strcmp(iter->name, resolver->name)) {
            ast_log(LOG_ERROR, "A DNS resolver with the name '%s' is already registered\n", resolver->name);
            AST_RWLIST_UNLOCK(&resolvers);
            return -1;
        }
    }
 
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&resolvers, iter, next) {
        if (iter->priority > resolver->priority) {
            AST_RWLIST_INSERT_BEFORE_CURRENT(resolver, next);
            inserted = 1;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    if (!inserted) {
        AST_RWLIST_INSERT_TAIL(&resolvers, resolver, next);
    }
 
    AST_RWLIST_UNLOCK(&resolvers);
 
    ast_verb(5, "Registered DNS resolver '%s' with priority '%d'\n", resolver->name, resolver->priority);
 
    return 0;
}

References AST_LIST_TRAVERSE, ast_log, AST_RWLIST_INSERT_BEFORE_CURRENT, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), ast_verb, ast_dns_resolver::cancel, LOG_ERROR, ast_dns_resolver::name, ast_dns_resolver::priority, and ast_dns_resolver::resolve.

Referenced by ast_dns_system_resolver_init(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), invalid_record_test(), load_module(), nominal_test(), off_nominal_test(), and query_set_test().

ast_dns_resolver_set_data()

int ast_dns_resolver_set_data	(	struct ast_dns_query *	query,
		void *	data
	)

Set resolver specific data on a query.

Parameters

query	The DNS query
data	The resolver specific data

Note

The resolver data MUST be an ao2 object

This function increments the reference count of the resolver data, it does NOT steal

Once resolver specific data has been set it can not be changed

Return values

0	success
-1	failure, resolver data is already set

Definition at line 441 of file dns_core.c.

{
    if (query->resolver_data) {
        return -1;
    }
 
    query->resolver_data = ao2_bump(data);
 
    return 0;
}

References ao2_bump, and ast_dns_query::resolver_data.

Referenced by AST_TEST_DEFINE(), and unbound_resolver_resolve().

ast_dns_resolver_set_result()

int ast_dns_resolver_set_result	(	struct ast_dns_query *	query,
		unsigned int	secure,
		unsigned int	bogus,
		unsigned int	rcode,
		const char *	canonical,
		const char *	answer,
		size_t	answer_size
	)

Set result information for a DNS query.

Parameters

query	The DNS query
secure	Whether the result is secured or not
bogus	Whether the result is bogus or not
rcode	Optional response code
canonical	The canonical name
answer	The raw DNS answer
answer_size	The size of the raw DNS answer

Zero-sized and NULL answers are permitted by this function. This may be necessary if the query fails at an early stage and no actual DNS response has been received from a DNS server.

Return values

0	success
-1	failure

Definition at line 457 of file dns_core.c.

{
    char *buf_ptr;
 
    if (secure && bogus) {
        ast_debug(2, "Query '%p': Could not set result information, it can not be both secure and bogus\n",
            query);
        return -1;
    }
 
    if (ast_strlen_zero(canonical)) {
        ast_debug(2, "Query '%p': Could not set result information since no canonical name was provided\n",
            query);
        return -1;
    }
 
    if (!answer) {
        answer = "";
        answer_size = 0;
        ast_debug(2, "Query '%p': Assuming zero-sized answer on NULL input\n", query);
    }
 
    ast_dns_result_free(query->result);
 
    query->result = ast_calloc(1, sizeof(*query->result) + strlen(canonical) + 1 + answer_size);
    if (!query->result) {
        return -1;
    }
 
    query->result->secure = secure;
    query->result->bogus = bogus;
    query->result->rcode = rcode;
 
    buf_ptr = query->result->buf;
    strcpy(buf_ptr, canonical); /* SAFE */
    query->result->canonical = buf_ptr;
 
    buf_ptr += strlen(canonical) + 1;
    memcpy(buf_ptr, answer, answer_size); /* SAFE */
    query->result->answer = buf_ptr;
    query->result->answer_size = answer_size;
 
    return 0;
}

References answer(), ast_dns_result::answer, ast_dns_result::answer_size, ast_calloc, ast_debug, ast_dns_result_free(), ast_strlen_zero(), ast_dns_result::bogus, ast_dns_result::buf, ast_dns_result::canonical, ast_dns_result::rcode, ast_dns_query::result, and ast_dns_result::secure.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), dns_system_resolver_set_response(), naptr_thread(), resolution_thread(), resolution_thread(), resolution_thread(), srv_thread(), and unbound_resolver_callback().

ast_dns_resolver_unregister()

void ast_dns_resolver_unregister

(

struct ast_dns_resolver *

resolver

)

Unregister a DNS resolver.

Parameters

resolver

A DNS resolver implementation

Definition at line 683 of file dns_core.c.

{
    struct ast_dns_resolver *iter;
 
    if (!resolver) {
        return;
    }
 
    AST_RWLIST_WRLOCK(&resolvers);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&resolvers, iter, next) {
        if (resolver == iter) {
            AST_RWLIST_REMOVE_CURRENT(next);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&resolvers);
 
    ast_verb(5, "Unregistered DNS resolver '%s'\n", resolver->name);
}

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, and ast_dns_resolver::name.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), dns_system_resolver_destroy(), invalid_record_test(), nominal_test(), off_nominal_test(), and query_set_test().

ast_dns_result_free()

void ast_dns_result_free

(

struct ast_dns_result *

result

)

Free the DNS result information.

Parameters

result

The DNS result

Definition at line 130 of file dns_core.c.

{
    struct ast_dns_record *record;
 
    if (!result) {
        return;
    }
 
    while ((record = AST_LIST_REMOVE_HEAD(&result->records, list))) {
        ast_free(record);
    }
 
    ast_free(result);
}

References ast_free, AST_LIST_REMOVE_HEAD, ast_dns_record::list, and result.

Referenced by ast_dns_resolver_set_result(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), dns_query_destroy(), invalid_record_test(), nominal_test(), and off_nominal_test().

ast_dns_result_get_answer()

const char * ast_dns_result_get_answer

(

const struct ast_dns_result *

result

)

Get the raw DNS answer from a DNS result.

Parameters

result

The DNS result

Returns

The DNS result

Definition at line 107 of file dns_core.c.

{
    return result->answer;
}

References result.

Referenced by test_results().

ast_dns_result_get_bogus()

unsigned int ast_dns_result_get_bogus

(

const struct ast_dns_result *

result

)

Get whether the result is bogus or not.

Parameters

result

The DNS result

Returns

whether the result is bogus or not

Definition at line 87 of file dns_core.c.

{
    return result->bogus;
}

References result.

Referenced by test_results().

ast_dns_result_get_canonical()

const char * ast_dns_result_get_canonical

(

const struct ast_dns_result *

result

)

Get the canonical name of the result.

Parameters

result

The DNS result

Returns

the canonical name

Definition at line 97 of file dns_core.c.

{
    return result->canonical;
}

References result.

Referenced by test_results().

ast_dns_result_get_lowest_ttl()

int ast_dns_result_get_lowest_ttl

(

const struct ast_dns_result *

result

)

Retrieve the lowest TTL from a result.

Parameters

result

The DNS result

Returns

the lowest TTL

Note

If no records exist this function will return a TTL of 0

Definition at line 112 of file dns_core.c.

{
    int ttl = 0;
    const struct ast_dns_record *record;
 
    if (ast_dns_result_get_rcode(result) == NXDOMAIN) {
        return 0;
    }
 
    for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
        if (!ttl || (ast_dns_record_get_ttl(record) && (ast_dns_record_get_ttl(record) < ttl))) {
            ttl = ast_dns_record_get_ttl(record);
        }
    }
 
    return ttl;
}

References ast_dns_record_get_next(), ast_dns_record_get_ttl(), ast_dns_result_get_rcode(), ast_dns_result_get_records(), result, and ast_dns_record::ttl.

Referenced by dns_query_recurring_resolution_callback().

ast_dns_result_get_rcode()

unsigned int ast_dns_result_get_rcode

(

const struct ast_dns_result *

result

)

Get the error rcode of a DN result.

Parameters

result

The DNS result

Returns

the DNS rcode

Definition at line 92 of file dns_core.c.

{
    return result->rcode;
}

References result.

Referenced by ast_dns_result_get_lowest_ttl(), and test_results().

ast_dns_result_get_records()

const struct ast_dns_record * ast_dns_result_get_records

(

const struct ast_dns_result *

result

)

Get the first record of a DNS Result.

Parameters

result

The DNS result

Returns

first DNS record

Definition at line 102 of file dns_core.c.

{
    return AST_LIST_FIRST(&result->records);
}

References AST_LIST_FIRST, and result.

Referenced by ast_dns_resolve_ipv6_and_ipv4(), ast_dns_result_get_lowest_ttl(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), invalid_record_test(), nominal_test(), and off_nominal_test().

ast_dns_result_get_secure()

unsigned int ast_dns_result_get_secure

(

const struct ast_dns_result *

result

)

Get whether the result is secure or not.

Parameters

result

The DNS result

Returns

whether the result is secure or not

Definition at line 82 of file dns_core.c.

{
    return result->secure;
}

References result, and ast_dns_result::secure.

Referenced by test_results().

dns_core_init()

int dns_core_init

(

void

)

Provided by dns_core.c

Definition at line 617 of file dns_core.c.

{
    sched = ast_sched_context_create();
    if (!sched) {
        return -1;
    }
 
    if (ast_sched_start_thread(sched)) {
        return -1;
    }
 
    ast_register_cleanup(dns_shutdown);
 
    return 0;
}

References ast_register_cleanup(), ast_sched_context_create(), ast_sched_start_thread(), and dns_shutdown().

Referenced by asterisk_daemon().

dns_find_record()

char * dns_find_record	(	const char *	record,
		size_t	record_size,
		const char *	response,
		size_t	response_size
	)

Find the location of a DNS record within the entire DNS answer.

The DNS record that has been returned by the resolver may be a copy of the record that was found in the complete DNS response. If so, then some DNS record types (specifically those that parse domains) will need to locate the DNS record within the complete DNS response. This is so that if the domain contains pointers to other sections of the DNS response, then the referenced domains may be located.

Parameters

record	The DNS record returned by a resolver implementation
record_size	The size of the DNS record in bytes
response	The complete DNS answer
response_size	The size of the complete DNS response

Definition at line 704 of file dns_core.c.

{
    size_t remaining_size = response_size;
    const char *search_base = response;
    char *record_offset;
 
    while (1) {
        record_offset = memchr((void *)search_base, record[0], remaining_size);
 
        ast_assert(record_offset != NULL);
        ast_assert(search_base + remaining_size - record_offset >= record_size);
 
        if (!memcmp(record_offset, record, record_size)) {
            return record_offset;
        }
 
        remaining_size -= record_offset - search_base;
        search_base = record_offset + 1;
    }
}

References ast_assert, and NULL.

Referenced by dns_naptr_alloc(), and dns_srv_alloc().

dns_parse_short()

int dns_parse_short	(	unsigned char *	cur,
		uint16_t *	val
	)

Parse a 16-bit unsigned value from a DNS record.

Parameters

	cur	Pointer to the location of the 16-bit value in the DNS record
[out]	val	The parsed 16-bit unsigned integer

Returns

The number of bytes consumed while parsing

Definition at line 725 of file dns_core.c.

{
    /* This assignment takes a big-endian 16-bit value and stores it in the
     * machine's native byte order. Using this method allows us to avoid potential
     * alignment issues in case the order is not on a short-addressable boundary.
     * See http://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html for
     * more information
     */
    *val = (cur[1] << 0) | (cur[0] << 8);
    return sizeof(*val);
}

Referenced by dns_naptr_alloc(), and dns_srv_alloc().

dns_parse_string()

int dns_parse_string	(	char *	cur,
		uint8_t *	size,
		char **	val
	)

Parse a DNS string from a DNS record.

A DNS string consists of an 8-bit size, followed by the string value (not NULL-terminated).

Parameters

	cur	Pointer to the location of the DNS string
[out]	size	The parsed size of the DNS string
[out]	val	The contained string (not NULL-terminated)

Returns

The number of bytes consumed while parsing

Definition at line 737 of file dns_core.c.

{
    *size = *cur++;
    *val = cur;
    return *size + 1;
}

Referenced by dns_naptr_alloc().

dns_query_active_destroy()

static void dns_query_active_destroy ( void *  data )

static

Destructor for an active DNS query.

Definition at line 176 of file dns_core.c.

{
    struct ast_dns_query_active *active = data;
 
    ao2_cleanup(active->query);
}

References ao2_cleanup, and ast_dns_query_active::query.

Referenced by ast_dns_resolve_async().

dns_query_alloc()

struct ast_dns_query * dns_query_alloc	(	const char *	name,
		int	rr_type,
		int	rr_class,
		ast_dns_resolve_callback	callback,
		void *	data
	)

Allocate a DNS query (but do not start resolution)

Parameters

name	The name of what to resolve
rr_type	Resource record type
rr_class	Resource record class
callback	The callback to invoke upon completion
data	User data to make available on the query

Return values

non-NULL	success
NULL	failure

Note

The result passed to the callback does not need to be freed

The user data MUST be an ao2 object

This function increments the reference count of the user data, it does NOT steal

The query must be released upon completion or cancellation using ao2_ref

Definition at line 193 of file dns_core.c.

{
    struct ast_dns_query *query;
 
    if (ast_strlen_zero(name)) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution, no name provided\n");
        return NULL;
    } else if (rr_type > 65536) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution of '%s', resource record type '%d' exceeds maximum\n",
            name, rr_type);
        return NULL;
    } else if (rr_type < 0) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution of '%s', invalid resource record type '%d'\n",
            name, rr_type);
        return NULL;
    } else if (rr_class > 65536) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution of '%s', resource record class '%d' exceeds maximum\n",
            name, rr_class);
        return NULL;
    } else if (rr_class < 0) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution of '%s', invalid resource class '%d'\n",
            name, rr_class);
        return NULL;
    } else if (!callback) {
        ast_log(LOG_WARNING, "Could not perform asynchronous resolution of '%s', no callback provided\n",
            name);
        return NULL;
    }
 
    query = ao2_alloc_options(sizeof(*query) + strlen(name) + 1, dns_query_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!query) {
        return NULL;
    }
 
    query->callback = callback;
    query->user_data = ao2_bump(data);
    query->rr_type = rr_type;
    query->rr_class = rr_class;
    strcpy(query->name, name); /* SAFE */
 
    AST_RWLIST_RDLOCK(&resolvers);
    query->resolver = AST_RWLIST_FIRST(&resolvers);
    AST_RWLIST_UNLOCK(&resolvers);
 
    if (!query->resolver) {
        ast_log(LOG_ERROR, "Attempted to do a DNS query for '%s' of class '%d' and type '%d' but no resolver is available\n",
            name, rr_class, rr_type);
        ao2_ref(query, -1);
        return NULL;
    }
 
    return query;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, ast_log, AST_RWLIST_FIRST, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_dns_query::callback, callback(), dns_query_destroy(), LOG_ERROR, LOG_WARNING, ast_dns_query::name, name, NULL, ast_dns_query::resolver, ast_dns_query::rr_class, ast_dns_query::rr_type, and ast_dns_query::user_data.

Referenced by ast_dns_query_set_add(), ast_dns_resolve_async(), and dns_query_recurring_resolution_callback().

dns_query_destroy()

static void dns_query_destroy ( void *  data )

static

Destructor for a DNS query.

Definition at line 184 of file dns_core.c.

{
    struct ast_dns_query *query = data;
 
    ao2_cleanup(query->user_data);
    ao2_cleanup(query->resolver_data);
    ast_dns_result_free(query->result);
}

References ao2_cleanup, ast_dns_result_free(), ast_dns_query::resolver_data, ast_dns_query::result, and ast_dns_query::user_data.

Referenced by dns_query_alloc().

dns_shutdown()

static void dns_shutdown ( void  )

static

Definition at line 609 of file dns_core.c.

{
    if (sched) {
        ast_sched_context_destroy(sched);
        sched = NULL;
    }
}

References ast_sched_context_destroy(), and NULL.

Referenced by dns_core_init().

dns_synchronous_resolve_callback()

static void dns_synchronous_resolve_callback ( const struct ast_dns_query *  query )

static

Callback used to implement synchronous resolution.

Definition at line 302 of file dns_core.c.

{
    struct dns_synchronous_resolve *synchronous = ast_dns_query_get_data(query);
 
    synchronous->result = query->result;
    ((struct ast_dns_query *)query)->result = NULL;
 
    ast_mutex_lock(&synchronous->lock);
    synchronous->completed = 1;
    ast_cond_signal(&synchronous->cond);
    ast_mutex_unlock(&synchronous->lock);
}

References ast_cond_signal, ast_dns_query_get_data(), ast_mutex_lock, ast_mutex_unlock, dns_synchronous_resolve::completed, dns_synchronous_resolve::cond, dns_synchronous_resolve::lock, NULL, ast_dns_query::result, and dns_synchronous_resolve::result.

Referenced by ast_dns_resolve().

dns_synchronous_resolve_destroy()

static void dns_synchronous_resolve_destroy ( void *  data )

static

Destructor for synchronous resolution structure.

Definition at line 291 of file dns_core.c.

{
    struct dns_synchronous_resolve *synchronous = data;
 
    ast_mutex_destroy(&synchronous->lock);
    ast_cond_destroy(&synchronous->cond);
 
    /* This purposely does not unref result as it has been passed to the caller */
}

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

Referenced by ast_dns_resolve().

generic_record_alloc()

static struct ast_dns_record * generic_record_alloc ( struct ast_dns_query *  query, const char *  data, const size_t  size  )

static

Definition at line 503 of file dns_core.c.

{
    struct ast_dns_record *record;
 
    record = ast_calloc(1, sizeof(*record) + size);
    if (!record) {
        return NULL;
    }
 
    record->data_ptr = record->data;
 
    return record;
}

Referenced by allocate_dns_record().

sort_result()

static void sort_result ( int  rr_type, struct ast_dns_result *  result  )

static

Definition at line 593 of file dns_core.c.

{
    if (dns_sort_table[rr_type]) {
        dns_sort_table[rr_type](result);
    }
}

References dns_sort_table, and result.

Referenced by ast_dns_resolver_completed().

Variable Documentation

dns_alloc_table

dns_alloc_fn dns_alloc_table[]

static

Initial value:

= {
    [T_TXT]   = dns_txt_alloc,
    [T_NAPTR] = dns_naptr_alloc,
    [T_SRV]   = dns_srv_alloc,
}

Definition at line 519 of file dns_core.c.

                                         {
    [T_TXT]   = dns_txt_alloc,
    [T_NAPTR] = dns_naptr_alloc,
    [T_SRV]   = dns_srv_alloc,
};

Referenced by allocate_dns_record().

dns_sort_table

dns_sort_fn dns_sort_table[]

static

Initial value:

= {
    [T_NAPTR] = dns_naptr_sort,
    [T_SRV] = dns_srv_sort,
}

Definition at line 588 of file dns_core.c.

                                       {
    [T_NAPTR] = dns_naptr_sort,
    [T_SRV] = dns_srv_sort,
};

Referenced by sort_result().

resolvers

struct resolvers resolvers = AST_RWLIST_HEAD_INIT_VALUE

sched

struct ast_sched_context* sched

static

Definition at line 50 of file dns_core.c.

Referenced by ast_dns_get_sched().