dns_internal.h File Reference

Internal DNS structure definitions. More...

#include "asterisk/linkedlists.h"
#include "asterisk/vector.h"
#include "asterisk/dns_query_set.h"

Include dependency graph for dns_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_dns_naptr_record
	A NAPTR record. More...
struct	ast_dns_query
	A DNS query. More...
struct	ast_dns_query_active
	An active DNS query. More...
struct	ast_dns_query_recurring
	A recurring DNS query. More...
struct	ast_dns_query_set
	A set of DNS queries. More...
struct	ast_dns_record
	For AST_LIST. More...
struct	ast_dns_result
	The result of a DNS query. More...
struct	ast_dns_srv_record
	An SRV record. More...
struct	ast_dns_txt_record
	A TXT record. More...
struct	dns_query_set_query
	A DNS query set query, which includes its state. More...
struct	ast_dns_result::dns_records
	Records returned. More...

Functions
struct ast_sched_context *	ast_dns_get_sched (void)
	Retrieve the DNS scheduler context. More...
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. More...
struct ast_dns_record *	dns_naptr_alloc (struct ast_dns_query *query, const char *data, const size_t size)
	Allocate and parse a DNS NAPTR record. More...
void	dns_naptr_sort (struct ast_dns_result *result)
	Sort the NAPTR records on a result. More...
int	dns_parse_short (unsigned char *cur, uint16_t *val)
	Parse a 16-bit unsigned value from a DNS record. More...
int	dns_parse_string (char *cur, uint8_t *size, char **val)
	Parse a DNS string from a DNS record. More...
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) More...
struct ast_dns_record *	dns_srv_alloc (struct ast_dns_query *query, const char *data, const size_t size)
	Allocate and parse a DNS SRV record. More...
void	dns_srv_sort (struct ast_dns_result *result)
	Sort the SRV records on a result. More...
struct ast_dns_record *	dns_txt_alloc (struct ast_dns_query *query, const char *data, const size_t size)
	Allocate and parse a DNS TXT record. More...

Detailed Description

Internal DNS structure definitions.

Author

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

Definition in file dns_internal.h.

Function Documentation

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

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 701 of file dns_core.c.

{
    size_t remaining_size = response_size;
    const char *search_base = response;
    char *record_offset;
 
    while (1) {
        record_offset = memchr(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_naptr_alloc()

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

Allocate and parse a DNS NAPTR record.

Parameters

query	The DNS query
data	This specific NAPTR record
size	The size of the NAPTR record

Return values

non-NULL	success
NULL	failure

Definition at line 380 of file dns_naptr.c.

{
    struct ast_dns_naptr_record *naptr;
    char *ptr = NULL;
    uint16_t order;
    uint16_t preference;
    uint8_t flags_size;
    char *flags;
    uint8_t services_size;
    char *services;
    uint8_t regexp_size;
    char *regexp;
    char replacement[256] = "";
    int replacement_size;
    const char *end_of_record;
    enum flags_result flags_res;
    size_t naptr_len;
 
    ptr = dns_find_record(data, size, query->result->answer, query->result->answer_size);
    ast_assert(ptr != NULL);
 
    end_of_record = ptr + size;
 
    /* ORDER */
    /* 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
     */
    ptr += dns_parse_short((unsigned char *) ptr, &order);
    if (PAST_END_OF_RECORD) {
        return NULL;
    }
 
    /* PREFERENCE */
    ptr += dns_parse_short((unsigned char *) ptr, &preference);
    if (PAST_END_OF_RECORD) {
        return NULL;
    }
 
    /* FLAGS */
    ptr += dns_parse_string(ptr, &flags_size, &flags);
    if (PAST_END_OF_RECORD) {
        return NULL;
    }
 
    /* SERVICES */
    ptr += dns_parse_string(ptr, &services_size, &services);
    if (PAST_END_OF_RECORD) {
        return NULL;
    }
 
    /* REGEXP */
    ptr += dns_parse_string(ptr, &regexp_size, &regexp);
    if (PAST_END_OF_RECORD) {
        return NULL;
    }
 
    /*
     * The return value from dn_expand represents the size of the replacement
     * in the buffer which MAY be compressed.  Since the expanded replacement
     * is NULL terminated, you can use strlen() to get the expanded size.
     */
    replacement_size = dn_expand((unsigned char *)query->result->answer,
        (unsigned char *) end_of_record, (unsigned char *) ptr,
        replacement, sizeof(replacement) - 1);
    if (replacement_size < 0) {
        ast_log(LOG_ERROR, "Failed to expand domain name: %s\n", strerror(errno));
        return NULL;
    }
 
    ptr += replacement_size;
 
    if (ptr != end_of_record) {
        ast_log(LOG_ERROR, "NAPTR record gave undersized string indications.\n");
        return NULL;
    }
 
    /* We've validated the size of the NAPTR record. Now we can validate
     * the individual parts
     */
    flags_res = interpret_flags(flags, flags_size);
    if (flags_res == FLAGS_INVALID) {
        ast_log(LOG_ERROR, "NAPTR Record contained invalid flags %.*s\n", flags_size, flags);
        return NULL;
    }
 
    if (services_invalid(services, services_size)) {
        ast_log(LOG_ERROR, "NAPTR record contained invalid services %.*s\n", services_size, services);
        return NULL;
    }
 
    if (regexp_invalid(regexp, regexp_size)) {
        ast_log(LOG_ERROR, "NAPTR record contained invalid regexp %.*s\n", regexp_size, regexp);
        return NULL;
    }
 
    /* replacement_size takes into account the NULL label, so a NAPTR record with no replacement
     * will have a replacement_size of 1.
     */
    if (regexp_size && replacement_size > 1) {
        ast_log(LOG_ERROR, "NAPTR record contained both a regexp and replacement\n");
        return NULL;
    }
 
    naptr_len = sizeof(*naptr) + size + flags_size + 1 + services_size + 1
        + regexp_size + 1 + strlen(replacement) + 1;
    naptr = ast_calloc(1, naptr_len);
    if (!naptr) {
        return NULL;
    }
 
    naptr->order = order;
    naptr->preference = preference;
 
    ptr = naptr->data;
    ptr += size;
 
    strncpy(ptr, flags, flags_size);
    ptr[flags_size] = '\0';
    naptr->flags = ptr;
    ptr += flags_size + 1;
 
    strncpy(ptr, services, services_size);
    ptr[services_size] = '\0';
    naptr->service = ptr;
    ptr += services_size + 1;
 
    strncpy(ptr, regexp, regexp_size);
    ptr[regexp_size] = '\0';
    naptr->regexp = ptr;
    ptr += regexp_size + 1;
 
    strcpy(ptr, replacement);
    naptr->replacement = ptr;
 
    naptr->generic.data_ptr = naptr->data;
 
    return (struct ast_dns_record *)naptr;
}

References ast_dns_result::answer, ast_dns_result::answer_size, ast_assert, ast_calloc, ast_log, ast_dns_naptr_record::data, dns_find_record(), dns_parse_short(), dns_parse_string(), errno, ast_dns_naptr_record::flags, FLAGS_INVALID, interpret_flags(), LOG_ERROR, NULL, order, naptr::order, PAST_END_OF_RECORD, ast_dns_naptr_record::preference, ast_dns_naptr_record::regexp, regexp_invalid(), ast_dns_naptr_record::replacement, ast_dns_query::result, and services_invalid().

dns_naptr_sort()

void dns_naptr_sort

(

struct ast_dns_result *

result

)

Sort the NAPTR records on a result.

Parameters

result

The DNS result

Definition at line 551 of file dns_naptr.c.

{
    struct ast_dns_record *current;
    size_t num_records = 0;
    struct ast_dns_naptr_record **records;
    int i = 0;
    int j = 0;
    int cur_order;
 
    /* Determine the number of records */
    AST_LIST_TRAVERSE(&result->records, current, list) {
        ++num_records;
    }
 
    /* No point in continuing if there are no records */
    if (num_records == 0) {
        return;
    }
 
    /* Allocate an array with that number of records */
    records = ast_alloca(num_records * sizeof(*records));
 
    /* Move records from the list to the array */
    AST_LIST_TRAVERSE_SAFE_BEGIN(&result->records, current, list) {
        records[i++] = (struct ast_dns_naptr_record *) current;
        AST_LIST_REMOVE_CURRENT(list);
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    /* Sort the array by order */
    qsort(records, num_records, sizeof(*records), compare_order);
 
    /* Sort subarrays by preference */
    for (i = 0; i < num_records; i = j) {
        cur_order = records[i]->order;
        for (j = i + 1; j < num_records; ++j) {
            if (records[j]->order != cur_order) {
                break;
            }
        }
        qsort(&records[i], j - i, sizeof(*records), compare_preference);
    }
 
    /* Place sorted records back into the original list */
    for (i = 0; i < num_records; ++i) {
        AST_LIST_INSERT_TAIL(&result->records, (struct ast_dns_record *)(records[i]), list);
    }
}

References ast_alloca, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, compare_order(), compare_preference(), current, order, records, and result.

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 722 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 734 of file dns_core.c.

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

Referenced by dns_naptr_alloc().

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, 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_srv_alloc()

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

Allocate and parse a DNS SRV record.

Parameters

query	The DNS query
data	This specific SRV record
size	The size of the SRV record

Return values

non-NULL	success
NULL	failure

Definition at line 42 of file dns_srv.c.

{
    uint16_t priority;
    uint16_t weight;
    uint16_t port;
    const char *ptr;
    const char *end_of_record;
    struct ast_dns_srv_record *srv;
    int host_size;
    char host[NI_MAXHOST] = "";
    size_t host_len;
 
    ptr = dns_find_record(data, size, query->result->answer, query->result->answer_size);
    ast_assert(ptr != NULL);
 
    end_of_record = ptr + size;
 
    /* PRIORITY */
    ptr += dns_parse_short((unsigned char *) ptr, &priority);
    if (ptr >= end_of_record) {
        return NULL;
    }
 
    /* WEIGHT */
    ptr += dns_parse_short((unsigned char *) ptr, &weight);
    if (ptr >= end_of_record) {
        return NULL;
    }
 
    /* PORT */
    ptr += dns_parse_short((unsigned char *) ptr, &port);
    if (ptr >= end_of_record) {
        return NULL;
    }
 
    /*
     * The return value from dn_expand represents the size of the replacement
     * in the buffer which MAY be compressed.  Since the expanded replacement
     * is NULL terminated, you can use strlen() to get the expanded size.
     */
    host_size = dn_expand((unsigned char *)query->result->answer,
        (unsigned char *) end_of_record, (unsigned char *) ptr, host, sizeof(host) - 1);
    if (host_size < 0) {
        ast_log(LOG_ERROR, "Failed to expand domain name: %s\n", strerror(errno));
        return NULL;
    }
 
    if (!strcmp(host, ".")) {
        return NULL;
    }
 
    host_len = strlen(host) + 1;
    srv = ast_calloc(1, sizeof(*srv) + size + host_len);
    if (!srv) {
        return NULL;
    }
 
    srv->priority = priority;
    srv->weight = weight;
    srv->port = port;
 
    srv->host = srv->data + size;
    ast_copy_string((char *)srv->host, host, host_len); /* SAFE */
    srv->generic.data_ptr = srv->data;
 
    return (struct ast_dns_record *)srv;
}

References ast_dns_result::answer, ast_dns_result::answer_size, ast_assert, ast_calloc, ast_copy_string(), ast_log, ast_dns_srv_record::data, ast_dns_record::data_ptr, dns_find_record(), dns_parse_short(), errno, ast_dns_srv_record::generic, ast_dns_srv_record::host, LOG_ERROR, NULL, ast_dns_srv_record::port, priority, ast_dns_srv_record::priority, ast_dns_query::result, weight, and ast_dns_srv_record::weight.

dns_srv_sort()

void dns_srv_sort

(

struct ast_dns_result *

result

)

Sort the SRV records on a result.

Parameters

result

The DNS result

Definition at line 113 of file dns_srv.c.

{
    struct ast_dns_record *current;
    struct dns_records newlist = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
 
    while (AST_LIST_FIRST(&result->records)) {
        unsigned short cur_priority = ((struct ast_dns_srv_record *)(AST_LIST_FIRST(&result->records)))->priority;
        struct dns_records temp_list = AST_LIST_HEAD_NOLOCK_INIT_VALUE;
 
        /* Find the lowest current priority to work on, but if the priority is already zero there is no lower priority */
        if (cur_priority) {
            AST_LIST_TRAVERSE(&result->records, current, list) {
                if (((struct ast_dns_srv_record *)current)->priority < cur_priority) {
                    cur_priority = ((struct ast_dns_srv_record *)current)->priority;
                }
            }
        }
 
        /* Find all records which match this priority */
        AST_LIST_TRAVERSE_SAFE_BEGIN(&result->records, current, list) {
            if (((struct ast_dns_srv_record *)current)->priority != cur_priority) {
                continue;
            }
 
            AST_LIST_REMOVE_CURRENT(list);
 
            /* Records with a weight of zero must always be at the head */
            if (((struct ast_dns_srv_record *)current)->weight == 0) {
                AST_LIST_INSERT_HEAD(&temp_list, current, list);
            } else {
                AST_LIST_INSERT_TAIL(&temp_list, current, list);
            }
        }
        AST_LIST_TRAVERSE_SAFE_END;
 
        /* Apply weighting - as each record is passed the sum of all previous weights (plus its own) is stored away, and then a random weight
         * is calculated. The first record with a weight sum greater than the random weight is put in the new list and the whole thing starts
         * once again.
         */
        while (AST_LIST_FIRST(&temp_list)) {
            unsigned int weight_sum = 0;
            unsigned int random_weight;
 
            AST_LIST_TRAVERSE(&temp_list, current, list) {
                ((struct ast_dns_srv_record *)current)->weight_sum = weight_sum += ((struct ast_dns_srv_record *)current)->weight;
            }
 
            /* if all the remaining entries have weight == 0,
               then just append them to the result list and quit */
            if (weight_sum == 0) {
                AST_LIST_APPEND_LIST(&newlist, &temp_list, list);
                break;
            }
 
            random_weight = 1 + (unsigned int) ((float) weight_sum * (ast_random() / ((float) RAND_MAX + 1.0)));
 
            AST_LIST_TRAVERSE_SAFE_BEGIN(&temp_list, current, list) {
                if (((struct ast_dns_srv_record *)current)->weight_sum < random_weight) {
                    continue;
                }
 
                AST_LIST_MOVE_CURRENT(&newlist, list);
                break;
            }
            AST_LIST_TRAVERSE_SAFE_END;
        }
 
    }
 
    /* now that the new list has been ordered,
       put it in place */
 
    AST_LIST_APPEND_LIST(&result->records, &newlist, list);
}

References AST_LIST_APPEND_LIST, AST_LIST_FIRST, AST_LIST_HEAD_NOLOCK_INIT_VALUE, AST_LIST_INSERT_HEAD, AST_LIST_INSERT_TAIL, AST_LIST_MOVE_CURRENT, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_random(), current, priority, result, weight, and ast_dns_srv_record::weight_sum.

dns_txt_alloc()

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

Allocate and parse a DNS TXT record.

Since

16.10.0, 17.4.0

Parameters

query	The DNS query
data	This specific TXT record
size	The size of the TXT record

Return values

non-NULL	success
NULL	failure

Definition at line 38 of file dns_txt.c.

{
    struct ast_dns_txt_record *txt;
    const char *end_of_record = data + size;
    size_t count = 0;
 
    /* Because we can't allocate additional memory, the best we can do here is just
     * validate that this conforms to a TXT record. */
    while (data < end_of_record) {
        uint8_t byte_count = (uint8_t) *data;
        count++;
        data += byte_count + 1;
    }
 
    if (data != end_of_record) {
        /* This is not a valid TXT record, so we can bail out */
        return NULL;
    }
 
    txt = ast_calloc(1, sizeof(*txt) + size);
    if (!txt) {
        return NULL;
    }
 
    txt->count = count;
    txt->generic.data_ptr = txt->data;
 
    return (struct ast_dns_record *) txt;
}

References ast_calloc, ast_dns_txt_record::count, ast_dns_txt_record::data, ast_dns_record::data_ptr, ast_dns_txt_record::generic, and NULL.