dns_test.c File Reference

#include "asterisk.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_test.h"
#include "asterisk/utils.h"

Include dependency graph for dns_test.c:

Go to the source code of this file.

Functions
int	ast_dns_test_generate_result (struct ast_dns_query *query, void *records, size_t num_records, size_t record_size, record_fn generate, char *buffer)
	Generate a full DNS response for the given DNS records. More...
int	ast_dns_test_write_domain (const char *string, char *buf)
	Write a DNS domain to a buffer. More...
int	ast_dns_test_write_string (const struct ast_dns_test_string *string, char *buf)
	Write a DNS string to a buffer. More...
static int	generate_dns_answer (int ttl, char *buf)
	Generate a DNS answer and write it to a buffer. More...
static int	generate_dns_header (unsigned short num_records, char *buf)
	Generate a DNS header and write it to a buffer. More...
static int	generate_dns_question (char *buf)
	Generate a DNS question and write it to a buffer. More...

Variables
const char	DNS_HEADER []
const char	DNS_QUESTION []
const char	NAPTR_ANSWER []

Function Documentation

ast_dns_test_generate_result()

int ast_dns_test_generate_result	(	struct ast_dns_query *	query,
		void *	records,
		size_t	num_records,
		size_t	record_size,
		record_fn	generate,
		char *	buffer
	)

Generate a full DNS response for the given DNS records.

This function takes care of generating the DNS header, question, and answer sections of a DNS response. In order to place test-specific record data into the DNS answers, a callback is provided as a parameter to this function so that the necessary records can be encoded properly by the tests.

There is no buffer size passed to this function. Tests are expected to use a buffer that is sufficiently large for their tests.

Parameters

query	The DNS query that is being processed
records	An array of test-specific representations of DNS records
num_records	The number of elements in the records array
record_size	The size of each element in the records array
generate	The test-specific encoder for DNS records
buffer	The buffer into which to write the DNS response

Definition at line 222 of file dns_test.c.

References ast_dns_test_write_domain(), ast_dns_test_write_string(), buf, generate_dns_answer(), generate_dns_header(), generate_dns_question(), and records.

Referenced by naptr_thread(), and srv_thread().

{
   char *ptr = buffer;
   char *record_iter;

   ptr += generate_dns_header(num_records, ptr);
   ptr += generate_dns_question(ptr);

   for (record_iter = records; record_iter < (char *) records + num_records * record_size; record_iter += record_size) {
      unsigned short rdlength;
      unsigned short net_rdlength;

      /* XXX Do we even want to override TTL? */
      ptr += generate_dns_answer(0, ptr);
      rdlength = generate(record_iter, ptr + 2);
      net_rdlength = htons(rdlength);
      memcpy(ptr, &net_rdlength, 2);
      ptr += 2;
      ptr += rdlength;
   }

   return ptr - buffer;
}

ast_dns_test_write_domain()

int ast_dns_test_write_domain	(	const char *	string,
		char *	buf
	)

Write a DNS domain to a buffer.

A DNS domain consists of a series of labels separated by dots. Each of these labels gets written as a DNS string. A DNS domain ends with a NULL label, which is essentially a zero-length DNS string.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

string	The DNS domain to write
buf	The buffer to write the domain into

Returns

The number of bytes written to the buffer

Definition at line 196 of file dns_test.c.

References ast_dns_test_write_string(), ast_strdupa, ast_strlen_zero, buf, copy(), ast_dns_test_string::len, strsep(), and ast_dns_test_string::val.

Referenced by ast_dns_test_generate_result(), generate_naptr_record(), and generate_srv_record().

{
   char *copy = ast_strdupa(string);
   char *part;
   char *ptr = buf;
   static const struct ast_dns_test_string null_label = {
      .len = 0,
      .val = "",
   };

   while (1) {
      struct ast_dns_test_string dns_str;
      part = strsep(&copy, ".");
      if (ast_strlen_zero(part)) {
         break;
      }
      dns_str.len = strlen(part);
      dns_str.val = part;

      ptr += ast_dns_test_write_string(&dns_str, ptr);
   }
   ptr += ast_dns_test_write_string(&null_label, ptr);

   return ptr - buf;
}

ast_dns_test_write_string()

int ast_dns_test_write_string	(	const struct ast_dns_test_string *	string,
		char *	buf
	)

Write a DNS string to a buffer.

This writes the DNS string to the buffer and returns the total number of bytes written to the buffer.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

string	The string to write
buf	The buffer to write the string into

Returns

The number of bytes written to the buffer

Definition at line 162 of file dns_test.c.

References len(), and ast_dns_test_string::val.

Referenced by ast_dns_test_generate_result(), ast_dns_test_write_domain(), and generate_naptr_record().

{
   uint8_t len = string->len;
   size_t actual_len = strlen(string->val);
   buf[0] = len;
   /*
    * We use the actual length of the string instead of
    * the stated value since sometimes we're going to lie about
    * the length of the string
    */
   if (actual_len) {
      memcpy(&buf[1], string->val, strlen(string->val));
   }

   return actual_len + 1;
}

generate_dns_answer()

static int generate_dns_answer ( int  ttl, char *  buf  )

static

Generate a DNS answer and write it to a buffer.

The DNS answer is the third (and in our case final) part of a DNS response. The DNS answer generated here is only partial. The record-specific data is generated by a separate function. DNS answers in our tests may have variable TTLs, but the rest is hard-coded.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

buf	The buffer to write the answer into

Return values

The	number of bytes written to the buffer

Definition at line 135 of file dns_test.c.

References ARRAY_LEN, and NAPTR_ANSWER.

Referenced by ast_dns_test_generate_result().

{
   int net_ttl = htonl(ttl);

   memcpy(buf, NAPTR_ANSWER, ARRAY_LEN(NAPTR_ANSWER));
   /* Overwrite TTL if one is provided */
   if (ttl) {
      memcpy(&buf[6], &net_ttl, sizeof(int));
   }

   return ARRAY_LEN(NAPTR_ANSWER);
}

generate_dns_header()

static int generate_dns_header ( unsigned short  num_records, char *  buf  )

static

Generate a DNS header and write it to a buffer.

The DNS header is the first part of a DNS request or response. In our case, the only part of the header that a test can affect is the number of answers. The rest of the DNS header is based on hard-coded values.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

num_records	The number of DNS records in this DNS response
buf	The buffer to write the header into

Return values

The	number of bytes written to the buffer

Definition at line 64 of file dns_test.c.

References ARRAY_LEN, and DNS_HEADER.

Referenced by ast_dns_test_generate_result().

{
   unsigned short net_num_records = htons(num_records);

   memcpy(buf, DNS_HEADER, ARRAY_LEN(DNS_HEADER));
   /* Overwrite the ANCOUNT with the actual number of answers */
   memcpy(&buf[6], &net_num_records, sizeof(num_records));

   return ARRAY_LEN(DNS_HEADER);
}

generate_dns_question()

static int generate_dns_question ( char *  buf )

static

Generate a DNS question and write it to a buffer.

The DNS question is the second part of a DNS request or response. All DNS questions in this file are for the same domain and thus the DNS question is a hard-coded value.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

buf	The buffer to write the question into

Return values

The	number of bytes written to the buffer

Definition at line 102 of file dns_test.c.

References ARRAY_LEN, and DNS_QUESTION.

Referenced by ast_dns_test_generate_result().

{
   memcpy(buf, DNS_QUESTION, ARRAY_LEN(DNS_QUESTION));
   return ARRAY_LEN(DNS_QUESTION);
}

Variable Documentation

DNS_HEADER

const char DNS_HEADER[]

Definition at line 32 of file dns_test.c.

Referenced by generate_dns_header().

DNS_QUESTION

const char DNS_QUESTION[]

Definition at line 75 of file dns_test.c.

Referenced by generate_dns_question().

NAPTR_ANSWER

const char NAPTR_ANSWER[]

Definition at line 108 of file dns_test.c.

Referenced by generate_dns_answer().