dns_naptr.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2015, Digium, Inc.
 *
 * Joshua Colp <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief DNS NAPTR Record Support
 *
 * \author Joshua Colp <[email protected]>
 */

/*** MODULEINFO
 <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <arpa/nameser.h>
#include <netinet/in.h>
#include <resolv.h>
#include <regex.h>

#include "asterisk/dns_core.h"
#include "asterisk/dns_naptr.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dns_internal.h"
#include "asterisk/utils.h"

/*!
 * \brief Result of analyzing NAPTR flags on a record
 */
enum flags_result {
 /*! Terminal record, meaning the DDDS algorithm can be stopped */
 FLAGS_TERMINAL,
 /*! No flags provided, likely meaning another NAPTR lookup */
 FLAGS_EMPTY,
 /*! Unrecognized but valid flags. We cannot conclude what they mean */
 FLAGS_UNKNOWN,
 /*! Non-alphanumeric or invalid combination of flags */
 FLAGS_INVALID,
};

/*!
 * \brief Analyze and interpret NAPTR flags as per RFC 3404
 *
 * \note The flags string passed into this function is NOT NULL-terminated
 *
 * \param flags The flags string from a NAPTR record
 * \flags_size The size of the flags string in bytes
 * \return flag result
 */
static enum flags_result interpret_flags(const char *flags, uint8_t flags_size)
{
 int i;
 char known_flag_found = 0;

 if (flags_size == 0) {
 return FLAGS_EMPTY;
 }

 /* Take care of the most common (and easy) case, one character */
 if (flags_size == 1) {
 if (*flags == 's' || *flags == 'S' ||
 *flags == 'a' || *flags == 'A' ||
 *flags == 'u' || *flags == 'U') {
 return FLAGS_TERMINAL;
 } else if (!isalnum(*flags)) {
 return FLAGS_INVALID;
 } else {
 return FLAGS_UNKNOWN;
 }
 }

 /*
 * Multiple flags are allowed, but you cannot mix the
 * S, A, U, and P flags together.
 */
 for (i = 0; i < flags_size; ++i) {
 if (!isalnum(flags[i])) {
 return FLAGS_INVALID;
 } else if (flags[i] == 's' || flags[i] == 'S') {
 if (known_flag_found && known_flag_found != 's') {
 return FLAGS_INVALID;
 }
 known_flag_found = 's';
 } else if (flags[i] == 'u' || flags[i] == 'U') {
 if (known_flag_found && known_flag_found != 'u') {
 return FLAGS_INVALID;
 }
 known_flag_found = 'u';
 } else if (flags[i] == 'a' || flags[i] == 'A') {
 if (known_flag_found && known_flag_found != 'a') {
 return FLAGS_INVALID;
 }
 known_flag_found = 'a';
 } else if (flags[i] == 'p' || flags[i] == 'P') {
 if (known_flag_found && known_flag_found != 'p') {
 return FLAGS_INVALID;
 }
 known_flag_found = 'p';
 }
 }

 return (!known_flag_found || known_flag_found == 'p') ? FLAGS_UNKNOWN : FLAGS_TERMINAL;
}

/*!
 * \brief Analyze NAPTR services for validity as defined by RFC 3404
 *
 * \note The services string passed to this function is NOT NULL-terminated
 * \param services The services string parsed from a NAPTR record
 * \param services_size The size of the services string
 * \retval 0 Services are valid
 * \retval -1 Services are invalid
 */
static int services_invalid(const char *services, uint8_t services_size)
{
 const char *current_pos = services;
 const char *end_of_services = services + services_size;

 if (services_size == 0) {
 return 0;
 }

 /* Services are broken into sections divided by a + sign. Each section
 * must start with an alphabetic character, and then can only contain
 * alphanumeric characters. The size of any section is limited to
 * 32 characters
 */
 while (1) {
 char *plus_pos = memchr(current_pos, '+', end_of_services - current_pos);
 uint8_t current_size = plus_pos ? plus_pos - current_pos : end_of_services - current_pos;
 int i;

 if (!isalpha(current_pos[0])) {
 return -1;
 }

 if (current_size > 32) {
 return -1;
 }

 for (i = 1; i < current_size; ++i) {
 if (!isalnum(current_pos[i])) {
 return -1;
 }
 }

 if (!plus_pos) {
 break;
 }
 current_pos = plus_pos + 1;
 }

 return 0;
}

/*!
 * \brief Determine if flags in the regexp are invalid
 *
 * A NAPTR regexp is structured like so
 * /pattern/repl/FLAGS
 *
 * This ensures that the flags on the regexp are valid. Regexp
 * flags can either be zero or one character long. If the flags
 * are one character long, that character must be "i" to indicate
 * the regex evaluation is case-insensitive.
 *
 * \note The flags string passed to this function is not NULL-terminated
 * \param flags The regexp flags from the NAPTR record
 * \param end A pointer to the end of the flags string
 * \retval 0 Flags are valid
 * \retval -1 Flags are invalid
 */
static int regexp_flags_invalid(const char *flags, const char *end)
{
 if (flags >= end) {
 return 0;
 }

 if (end - flags > 1) {
 return -1;
 }

 if (*flags != 'i') {
 return -1;
 }

 return 0;
}

/*!
 * \brief Determine if the replacement in the regexp is invalid
 *
 * A NAPTR regexp is structured like so
 * /pattern/REPL/flags
 *
 * This ensures that the replacement on the regexp is valid. The regexp
 * replacement is free to use any character it wants, plus backreferences
 * and an escaped regexp delimiter.
 *
 * This function does not attempt to ensure that the backreferences refer
 * to valid portions of the regexp's regex pattern.
 *
 * \note The repl string passed to this function is NOT NULL-terminated
 *
 * \param repl The regexp replacement string
 * \param end Pointer to the end of the replacement string
 * \param delim The delimiter character for the regexp
 *
 * \retval 0 Replacement is valid
 * \retval -1 Replacement is invalid
 */
static int regexp_repl_invalid(const char *repl, const char *end, char delim)
{
 const char *ptr = repl;

 if (repl == end) {
 /* Kind of weird, but this is fine */
 return 0;
 }

 while (1) {
 char *backslash_pos = memchr(ptr, '\\', end - ptr);
 if (!backslash_pos) {
 break;
 }

 ast_assert(backslash_pos < end - 1);

 /* XXX RFC 3402 is unclear about whether other backslash-escaped characters
 * (such as a backslash-escaped backslash) are legal
 */
 if (!strchr("12345689", backslash_pos[1]) && backslash_pos[1] != delim) {
 return -1;
 }

 ptr = backslash_pos + 1;
 }

 return 0;
}

/*!
 * \brief Determine if the pattern in a regexp is invalid
 *
 * A NAPTR regexp is structured like so
 * /PATTERN/repl/flags
 *
 * This ensures that the pattern on the regexp is valid. The pattern is
 * passed to a regex compiler to determine its validity.
 *
 * \note The pattern string passed to this function is NOT NULL-terminated
 *
 * \param pattern The pattern from the NAPTR record
 * \param end A pointer to the end of the pattern
 *
 * \retval 0 Pattern is valid
 * \retval non-zero Pattern is invalid
 */
static int regexp_pattern_invalid(const char *pattern, const char *end)
{
 int pattern_size = end - pattern;
 char pattern_str[pattern_size + 1];
 regex_t reg;
 int res;

 /* regcomp requires a NULL-terminated string */
 memcpy(pattern_str, pattern, pattern_size);
 pattern_str[pattern_size] = '\0';

 res = regcomp(&reg, pattern_str, REG_EXTENDED);

 regfree(&reg);

 return res;
}

/*!
 * \brief Determine if the regexp in a NAPTR record is invalid
 *
 * The goal of this function is to divide the regexp into its
 * constituent parts and then let validation subroutines determine
 * if each part is valid. If all parts are valid, then the entire
 * regexp is valid.
 *
 * \note The regexp string passed to this function is NOT NULL-terminated
 *
 * \param regexp The regexp from the NAPTR record
 * \param regexp_size The size of the regexp string
 *
 * \retval 0 regexp is valid
 * \retval non-zero regexp is invalid
 */
static int regexp_invalid(const char *regexp, uint8_t regexp_size)
{
 char delim;
 const char *delim2_pos;
 const char *delim3_pos;
 const char *ptr = regexp;
 const char *end_of_regexp = regexp + regexp_size;
 const char *regex_pos;
 const char *repl_pos;
 const char *flags_pos;

 if (regexp_size == 0) {
 return 0;
 }

 /* The delimiter will be a ! or / in most cases, but the rules allow
 * for the delimiter to be nearly any character. It cannot be 'i' because
 * the delimiter cannot be the same as regexp flags. The delimiter cannot
 * be 1-9 because the delimiter cannot be a backreference number. RFC
 * 2915 specified that backslash was also not allowed as a delimiter, but
 * RFC 3402 does not say this. We've gone ahead and made the character
 * illegal for our purposes.
 */
 delim = *ptr;
 if (strchr("123456789\\i", delim)) {
 return -1;
 }
 ++ptr;
 regex_pos = ptr;

 /* Find the other two delimiters. If the delim is escaped with a backslash, it doesn't count */
 while (1) {
 delim2_pos = memchr(ptr, delim, end_of_regexp - ptr);
 if (!delim2_pos) {
 return -1;
 }
 ptr = delim2_pos + 1;
 if (delim2_pos[-1] != '\\') {
 break;
 }
 }

 if (ptr >= end_of_regexp) {
 return -1;
 }

 repl_pos = ptr;

 while (1) {
 delim3_pos = memchr(ptr, delim, end_of_regexp - ptr);
 if (!delim3_pos) {
 return -1;
 }
 ptr = delim3_pos + 1;
 if (delim3_pos[-1] != '\\') {
 break;
 }
 }
 flags_pos = ptr;

 if (regexp_flags_invalid(flags_pos, end_of_regexp) ||
 regexp_repl_invalid(repl_pos, delim3_pos, delim) ||
 regexp_pattern_invalid(regex_pos, delim2_pos)) {
 return -1;
 }

 return 0;
}

#define PAST_END_OF_RECORD ptr >= end_of_record

struct ast_dns_record *dns_naptr_alloc(struct ast_dns_query *query, const char *data, const size_t size)
{
 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;
}


static int compare_order(const void *record1, const void *record2)
{
 const struct ast_dns_naptr_record **left = (const struct ast_dns_naptr_record **)record1;
 const struct ast_dns_naptr_record **right = (const struct ast_dns_naptr_record **)record2;

 if ((*left)->order < (*right)->order) {
 return -1;
 } else if ((*left)->order > (*right)->order) {
 return 1;
 } else {
 return 0;
 }
}

static int compare_preference(const void *record1, const void *record2)
{
 const struct ast_dns_naptr_record **left = (const struct ast_dns_naptr_record **)record1;
 const struct ast_dns_naptr_record **right = (const struct ast_dns_naptr_record **)record2;

 if ((*left)->preference < (*right)->preference) {
 return -1;
 } else if ((*left)->preference > (*right)->preference) {
 return 1;
 } else {
 return 0;
 }
}

void dns_naptr_sort(struct ast_dns_result *result)
{
 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);
 }
}

const char *ast_dns_naptr_get_flags(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->flags;
}

const char *ast_dns_naptr_get_service(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->service;
}

const char *ast_dns_naptr_get_regexp(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->regexp;
}

const char *ast_dns_naptr_get_replacement(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->replacement;
}

unsigned short ast_dns_naptr_get_order(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->order;
}

unsigned short ast_dns_naptr_get_preference(const struct ast_dns_record *record)
{
 struct ast_dns_naptr_record *naptr = (struct ast_dns_naptr_record *) record;

 ast_assert(ast_dns_record_get_rr_type(record) == T_NAPTR);
 return naptr->preference;
}