dns.c File Reference

DNS Support for Asterisk. More...

#include "asterisk.h"
#include "asterisk/network.h"
#include <arpa/nameser.h>
#include <resolv.h>
#include "asterisk/channel.h"
#include "asterisk/dns.h"
#include "asterisk/endian.h"

Include dependency graph for dns.c:

Go to the source code of this file.

Data Structures
struct	dn_answer
struct	dns_HEADER

Macros
#define	MAX_SIZE   4096
	The maximum size permitted for the answer from the DNS server. More...

Functions
struct ao2_container *	ast_dns_get_nameservers (void)
	Retrieve the configured nameservers of the system. More...
int	ast_search_dns (void *context, const char *dname, int class, int type, int(*callback)(void *context, unsigned char *answer, int len, unsigned char *fullanswer))
	Lookup record in DNS. More...
enum ast_dns_search_result	ast_search_dns_ex (void *context, const char *dname, int rr_class, int rr_type, int(*response_handler)(void *context, unsigned char *dns_response, int dns_response_len, int rcode), int(*record_handler)(void *context, unsigned char *record, int record_len, int ttl))
	Extended version of the DNS search function. More...
static int	dns_advance_field (unsigned char **dns_response, int remaining_len, int field_size)
	Advances the position of the DNS response pointer by the size of the current field. More...
static int	dns_parse_answer (void *context, int class, int type, unsigned char *answer, int len, int(*callback)(void *context, unsigned char *answer, int len, unsigned char *fullanswer))
	Parse DNS lookup result, call callback. More...
static int	dns_parse_answer_ex (void *context, int rr_class, int rr_type, unsigned char *answer, int answer_len, int(*response_handler)(void *context, unsigned char *dns_response, int dns_response_len, int rcode), int(*record_handler)(void *context, unsigned char *record, int record_len, int ttl))
	Extended version of the DNS Parsing function. More...
static int	dns_search_res (const char *dname, int rr_class, int rr_type, unsigned char *dns_response, int dns_response_len)
	Handles the DNS search if the system has RES_NINIT. More...
static int	skip_name (unsigned char *s, int len)
	Tries to find the position of the next field in the DNS response. More...

Detailed Description

DNS Support for Asterisk.

Author

Thorsten Lockert tholo.nosp@m.@tro.nosp@m.llpho.nosp@m.ne.o.nosp@m.rg

Reference

• DNR SRV records http://www.ietf.org/rfc/rfc2782.txt

Definition in file dns.c.

Macro Definition Documentation

MAX_SIZE

#define MAX_SIZE   4096

The maximum size permitted for the answer from the DNS server.

Definition at line 47 of file dns.c.

Referenced by ast_search_dns(), and ast_search_dns_ex().

Function Documentation

ast_dns_get_nameservers()

struct ao2_container* ast_dns_get_nameservers

(

void

)

Retrieve the configured nameservers of the system.

Definition at line 583 of file dns.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ast_inet_ntoa(), ast_mutex_lock, ast_mutex_unlock, ast_str_container_add(), ast_str_container_alloc_options(), NULL, and state.

Referenced by system_create_resolver_and_set_nameservers().

{
#ifdef HAVE_RES_NINIT
   struct __res_state dnsstate;
#endif
   struct __res_state *state;
   struct ao2_container *nameservers;
   int i;

   nameservers = ast_str_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, 3);
   if (!nameservers) {
      return NULL;
   }

#ifdef HAVE_RES_NINIT
   memset(&dnsstate, 0, sizeof(dnsstate));
   res_ninit(&dnsstate);
   state = &dnsstate;
#else
   ast_mutex_lock(&res_lock);
   res_init();
   state = &_res;
#endif

   for (i = 0; i < state->nscount; i++) {
      ast_str_container_add(nameservers, ast_inet_ntoa(state->nsaddr_list[i].sin_addr));
   }

#ifdef HAVE_RES_NINIT
#ifdef HAVE_RES_NDESTROY
   res_ndestroy(&dnsstate);
#else
   res_nclose(&dnsstate);
#endif
#else
#ifdef HAVE_RES_CLOSE
   res_close();
#endif
   ast_mutex_unlock(&res_lock);
#endif

   return nameservers;
}

ast_search_dns()

int ast_search_dns	(	void *	context,
		const char *	dname,
		int	class,
		int	type,
		int(*)(void *context, unsigned char *answer, int len, unsigned char *fullanswer)	callback
	)

Lookup record in DNS.

Perform DNS lookup (used by DNS, enum and SRV lookups)

Note

Asterisk DNS is synchronus at this time. This means that if your DNS does not work properly, Asterisk might not start properly or a channel may lock.

Definition at line 493 of file dns.c.

References ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, dns_parse_answer(), LOG_WARNING, and MAX_SIZE.

Referenced by ast_get_enum(), ast_get_srv(), ast_get_txt(), ast_srv_lookup(), blr_ebl(), and blr_txt().

{
#ifdef HAVE_RES_NINIT
   struct __res_state dnsstate;
#endif
   unsigned char answer[MAX_SIZE];
   int res, ret = -1;

#ifdef HAVE_RES_NINIT
   memset(&dnsstate, 0, sizeof(dnsstate));
   res_ninit(&dnsstate);
   res = res_nsearch(&dnsstate, dname, class, type, answer, sizeof(answer));
#else
   ast_mutex_lock(&res_lock);
   res_init();
   res = res_search(dname, class, type, answer, sizeof(answer));
#endif
   if (res > 0) {
      if ((res = dns_parse_answer(context, class, type, answer, res, callback)) < 0) {
         ast_log(LOG_WARNING, "DNS Parse error for %s\n", dname);
         ret = -1;
      } else if (res == 0) {
         ast_debug(1, "No matches found in DNS for %s\n", dname);
         ret = 0;
      } else
         ret = 1;
   }
#ifdef HAVE_RES_NINIT
#ifdef HAVE_RES_NDESTROY
   res_ndestroy(&dnsstate);
#else
   res_nclose(&dnsstate);
#endif
#else
#ifdef HAVE_RES_CLOSE
   res_close();
#endif
   ast_mutex_unlock(&res_lock);
#endif

   return ret;
}

ast_search_dns_ex()

enum ast_dns_search_result ast_search_dns_ex	(	void *	context,
		const char *	dname,
		int	rr_class,
		int	rr_type,
		int(*)(void *context, unsigned char *dns_response, int dns_response_len, int rcode)	response_handler,
		int(*)(void *context, unsigned char *record, int record_len, int ttl)	record_handler
	)

Extended version of the DNS search function.

Performs a DNS lookup, (used by DNS, enum and SRV lookups), parses the results and notifies the observer with the response and discovered records via invoking the provided callbacks (used by ast_dns_system_resolver).

Parameters

context	Void pointer containing data to use in the handler functions.
dname	Domain name to lookup (host, SRV domain, TXT record name).
rr_class	Record Class (see "man res_search").
rr_type	Record type (see "man res_search").
response_handler	Callback function for handling the DNS response. Invoked upon completion of the DNS search.
record_handler	Callback function for handling the discovered resource records from the DNS search. Invoked n times, where n is the number of records discovered while parsing the DNS response.

Return values

AST_DNS_SEARCH_FAILURE	on search failure
AST_DNS_SEARCH_NO_RECORDS	on no records found
AST_DNS_SEARCH_SUCCESS	on success

Note

Asterisk DNS is synchronus at this time. This means that if your DNS service does not work, Asterisk may lock while waiting for a response.

Definition at line 538 of file dns.c.

References ast_assert, ast_debug, AST_DNS_SEARCH_FAILURE, AST_DNS_SEARCH_NO_RECORDS, ast_log, dns_parse_answer_ex(), dns_search_res(), LOG_WARNING, MAX_SIZE, and NULL.

Referenced by dns_system_resolver_process_query().

{
   int ret, dns_response_len;
   unsigned char dns_response[MAX_SIZE];

   /* Assert that the callbacks are not NULL */
   ast_assert(response_handler != NULL);
   ast_assert(record_handler != NULL);

   /* Try the DNS search. */
   dns_response_len = dns_search_res(dname,
                                     rr_class,
                                     rr_type,
                                     dns_response,
                                     sizeof(dns_response));

   if (dns_response_len < 0) {
      ast_debug(1, "DNS search failed for %s\n", dname);
      response_handler(context, (unsigned char *)"", 0, NXDOMAIN);
      return AST_DNS_SEARCH_FAILURE;
   }

   /* Parse records from DNS response */
   ret = dns_parse_answer_ex(context,
                             rr_class,
                             rr_type,
                             dns_response,
                             dns_response_len,
                             response_handler,
                             record_handler);

   /* Handle the return code from parsing the DNS response */
   if (ret == AST_DNS_SEARCH_FAILURE) {
      /* Parsing Error */
      ast_log(LOG_WARNING, "DNS Parse error for %s\n", dname);
   } else if (ret == AST_DNS_SEARCH_NO_RECORDS) {
      /* No results found */
      ast_debug(1, "DNS search yielded no results for %s\n", dname);
   }

   return ret;
}

dns_advance_field()

static int dns_advance_field ( unsigned char **  dns_response, int  remaining_len, int  field_size  )

static

Advances the position of the DNS response pointer by the size of the current field.

Definition at line 223 of file dns.c.

References AST_DNS_SEARCH_FAILURE, ast_mutex_lock, ast_mutex_unlock, dns_search_res(), and NULL.

Referenced by dns_parse_answer_ex().

{
   if (dns_response == NULL || field_size < 0 || remaining_len < field_size) {
      return AST_DNS_SEARCH_FAILURE;
   }

   *dns_response += field_size;
   remaining_len -= field_size;

   return remaining_len;
}

dns_parse_answer()

static int dns_parse_answer ( void *  context, int  class, int  type, unsigned char *  answer, int  len, int(*)(void *context, unsigned char *answer, int len, unsigned char *fullanswer)  callback  )

static

Parse DNS lookup result, call callback.

Definition at line 330 of file dns.c.

References dns_HEADER::ancount, answer(), ast_log, dn_answer::class, LOG_WARNING, dns_HEADER::qdcount, dn_answer::rtype, dn_answer::size, and skip_name().

Referenced by ast_search_dns().

{
   unsigned char *fullanswer = answer;
   struct dn_answer *ans;
   dns_HEADER *h;
   int ret = 0;
   int res;
   int x;

   h = (dns_HEADER *)answer;
   answer += sizeof(dns_HEADER);
   len -= sizeof(dns_HEADER);

   for (x = 0; x < ntohs(h->qdcount); x++) {
      if ((res = skip_name(answer, len)) < 0) {
         ast_log(LOG_WARNING, "Couldn't skip over name\n");
         return -1;
      }
      answer += res + 4;   /* Skip name and QCODE / QCLASS */
      len -= res + 4;
      if (len < 0) {
         ast_log(LOG_WARNING, "Strange query size\n");
         return -1;
      }
   }

   for (x = 0; x < ntohs(h->ancount); x++) {
      if ((res = skip_name(answer, len)) < 0) {
         ast_log(LOG_WARNING, "Failed skipping name\n");
         return -1;
      }
      answer += res;
      len -= res;
      ans = (struct dn_answer *)answer;
      answer += sizeof(struct dn_answer);
      len -= sizeof(struct dn_answer);
      if (len < 0) {
         ast_log(LOG_WARNING, "Length of DNS answer exceeds frame\n");
         return -1;
      }

      if (ntohs(ans->class) == class && ntohs(ans->rtype) == type) {
         if (callback) {
            if ((res = callback(context, answer, ntohs(ans->size), fullanswer)) < 0) {
               ast_log(LOG_WARNING, "Failed to parse result\n");
               return -1;
            }
            ret = 1;
         }
      }
      answer += ntohs(ans->size);
      len -= ntohs(ans->size);
   }
   return ret;
}

dns_parse_answer_ex()

static int dns_parse_answer_ex ( void *  context, int  rr_class, int  rr_type, unsigned char *  answer, int  answer_len, int(*)(void *context, unsigned char *dns_response, int dns_response_len, int rcode)  response_handler, int(*)(void *context, unsigned char *record, int record_len, int ttl)  record_handler  )

static

Extended version of the DNS Parsing function.

Parses the DNS lookup result and notifies the observer of each discovered resource record with the provided callback.

Definition at line 409 of file dns.c.

References dns_HEADER::ancount, answer(), AST_DNS_SEARCH_FAILURE, AST_DNS_SEARCH_NO_RECORDS, AST_DNS_SEARCH_SUCCESS, ast_log, dn_answer::class, dns_advance_field(), LOG_WARNING, dns_HEADER::qdcount, dn_answer::rtype, dn_answer::size, skip_name(), and dn_answer::ttl.

Referenced by ast_search_dns_ex().

{
   unsigned char *dns_response = answer;
   dns_HEADER *dns_header = (dns_HEADER *)answer;

   struct dn_answer *ans;
   int res, x, pos, dns_response_len, ret;

   dns_response_len = answer_len;
   ret = AST_DNS_SEARCH_NO_RECORDS;

   /* Invoke the response_handler callback to notify the observer of the raw DNS response */
   response_handler(context, dns_response, dns_response_len, ntohs(dns_header->rcode));

   /* Verify there is something to parse */
   if (answer_len == 0) {
      return ret;
   }

   /* Try advancing the cursor for the dns header */
   if ((pos = dns_advance_field(&answer, answer_len, sizeof(dns_HEADER))) < 0) {
      ast_log(LOG_WARNING, "Length of DNS answer exceeds available search frames\n");
      return AST_DNS_SEARCH_FAILURE;
   }

   /* Skip domain name and QCODE / QCLASS */
   for (x = 0; x < ntohs(dns_header->qdcount); x++) {
      if ((res = skip_name(answer, pos)) < 0) {
         ast_log(LOG_WARNING, "Failed skipping name\n");
         return AST_DNS_SEARCH_FAILURE;
      }

      /* Try advancing the cursor for the name and QCODE / QCLASS fields */
      if ((pos = dns_advance_field(&answer, pos, res + 4)) < 0) {
         return AST_DNS_SEARCH_FAILURE;
      }
   }

   /* Extract the individual records */
   for (x = 0; x < ntohs(dns_header->ancount); x++) {
      if ((res = skip_name(answer, pos)) < 0) {
         ast_log(LOG_WARNING, "Failed skipping name\n");
         return AST_DNS_SEARCH_FAILURE;
      }

      /* Try advancing the cursor to the current record */
      if ((pos = dns_advance_field(&answer, pos, res)) < 0) {
         ast_log(LOG_WARNING, "Length of DNS answer exceeds available search frames\n");
         return AST_DNS_SEARCH_FAILURE;
      }

      /* Cast the current value for the answer pointer as a dn_answer struct */
      ans = (struct dn_answer *) answer;

      /* Try advancing the cursor to the end of the current record  */
      if ((pos = dns_advance_field(&answer, pos, sizeof(struct dn_answer)))  < 0) {
         ast_log(LOG_WARNING, "Length of DNS answer exceeds available search frames\n");
         return AST_DNS_SEARCH_FAILURE;
      }

      /* Skip over the records that do not have the same resource record class and type we care about */
      if (ntohs(ans->class) == rr_class && ntohs(ans->rtype) == rr_type) {
         /* Invoke the record handler callback to deliver the discovered record */
         record_handler(context, answer, ntohs(ans->size), ntohl(ans->ttl));
         /*At least one record was found */
         ret = AST_DNS_SEARCH_SUCCESS;
      }

      /* Try and update the field to the next record, but ignore any errors that come
       * back because this may be the end of the line. */
      pos = dns_advance_field(&answer, pos, ntohs(ans->size));
   }

   return ret;
}

dns_search_res()

static int dns_search_res ( const char *  dname, int  rr_class, int  rr_type, unsigned char *  dns_response, int  dns_response_len  )

static

Handles the DNS search if the system has RES_NINIT.

Definition at line 287 of file dns.c.

References AST_DNS_SEARCH_FAILURE.

Referenced by ast_search_dns_ex(), and dns_advance_field().

{

   int ret = AST_DNS_SEARCH_FAILURE;
   struct __res_state dns_state;

   memset(&dns_state, 0, sizeof(dns_state));
   res_ninit(&dns_state);
   ret = res_nsearch(&dns_state,
                     dname,
                     rr_class,
                     rr_type,
                     dns_response,
                     dns_response_len);

#ifdef HAVE_RES_NDESTROY
   res_ndestroy(&dns_state);
#else
   res_nclose(&dns_state);
#endif

   return ret;
}

skip_name()

static int skip_name ( unsigned char *  s, int  len  )

static

Tries to find the position of the next field in the DNS response.

Definition at line 179 of file dns.c.

References AST_DNS_SEARCH_FAILURE.

Referenced by dns_parse_answer(), and dns_parse_answer_ex().

{
   int x = 0;

   while (x < len) {
      if (*s == '\0') {
         s++;
         x++;
         break;
      }

      if ((*s & 0xc0) == 0xc0) {
         s += 2;
         x += 2;
         break;
      }

      x += *s + 1;
      s += *s + 1;
   }

   /* If we are out of room to search, return failure. */
   if (x >= len) {
      return AST_DNS_SEARCH_FAILURE;
   }

   /* Return the value for the current position in the DNS response. This is the start
   position of the next field. */
   return x;
}