dns_system_resolver.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2015, Digium, Inc.
 *
 * Ashley Sanders <asanders@digium.com>
 *
 * 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 The default DNS resolver for Asterisk.
 *
 * \arg See also \ref res_resolver_unbound.c
 *
 * \author Ashley Sanders <asanders@digium.com>
 */
 
#include "asterisk.h"
 
#include "asterisk/_private.h"
#include "asterisk/astobj2.h"
#include "asterisk/dns.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_resolver.h"
#include "asterisk/linkedlists.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/utils.h"
 
/*! \brief The consideration priority for this resolver implementation. */
#define DNS_SYSTEM_RESOLVER_PRIORITY INT_MAX
 
/*! \brief Resolver return code upon success. */
#define DNS_SYSTEM_RESOLVER_SUCCESS 0
 
/*! \brief Resolver return code upon failure. */
#define DNS_SYSTEM_RESOLVER_FAILURE -1
 
 
static int dns_system_resolver_add_record(void *context, unsigned char *record, int record_len, int ttl);
static int dns_system_resolver_cancel(struct ast_dns_query *query);
static void dns_system_resolver_destroy(void);
static int dns_system_resolver_process_query(void *data);
static int dns_system_resolver_resolve(struct ast_dns_query *query);
static int dns_system_resolver_set_response(void *context, unsigned char *dns_response, int dns_response_len, int rcode);
 
 
/*! \brief The task processor to use for making DNS searches asynchronous. */
static struct ast_taskprocessor *dns_system_resolver_tp;
 
/*! \brief The base definition for the dns_system_resolver */
struct ast_dns_resolver dns_system_resolver_base = {
    .name = "system",
    .priority = DNS_SYSTEM_RESOLVER_PRIORITY,
    .resolve = dns_system_resolver_resolve,
    .cancel = dns_system_resolver_cancel,
};
 
/*!
 * \brief Callback to handle processing resource records.
 *
 * \details Adds an individual resource record discovered with ast_search_dns_ex to the
 *          ast_dns_query currently being resolved.
 *
 * \internal
 *
 * \param context     A void pointer to the ast_dns_query being processed.
 * \param record      An individual resource record discovered during the DNS search.
 * \param record_len  The length of the resource record.
 * \param ttl         The resource record's expiration time limit (time to live).
 *
 * \retval  0 on success
 * \retval -1 on failure
 */
static int dns_system_resolver_add_record(void *context, unsigned char *record, int record_len, int ttl)
{
    struct ast_dns_query *query = context;
 
    /* Add the record to the query.*/
    return ast_dns_resolver_add_record(query,
                                       ast_dns_query_get_rr_type(query),
                                       ast_dns_query_get_rr_class(query),
                                       ttl,
                                       (const char*) record,
                                       record_len);
}
 
/*!
 * \brief Cancels processing resolution for a given query.
 *
 * \note The system API calls block so there is no way to cancel them. Therefore, this function always
 * returns failure when invoked.
 *
 * \internal
 *
 * \param query  The ast_dns_query to cancel.
 *
 * \retval  0 on success
 * \retval -1 on failure
 */
static int dns_system_resolver_cancel(struct ast_dns_query *query)
{
    return DNS_SYSTEM_RESOLVER_FAILURE;
}
 
/*!
 * \brief Destructor.
 *
 * \internal
 */
static void dns_system_resolver_destroy(void)
{
    /* Unreference the task processor */
    dns_system_resolver_tp = ast_taskprocessor_unreference(dns_system_resolver_tp);
 
    /* Unregister the base resolver */
    ast_dns_resolver_unregister(&dns_system_resolver_base);
}
 
/*!
 * \brief Callback to handle processing the query from the ast_taskprocessor instance.
 *
 * \internal
 *
 * \param data  A void pointer to the ast_dns_query being processed.
 *
 * \retval -1 on search failure
 * \retval  0 on no records found
 * \retval  1 on success
 */
static int dns_system_resolver_process_query(void *data)
{
    struct ast_dns_query *query = data;
 
    /* Perform the DNS search */
    enum ast_dns_search_result res = ast_search_dns_ex(query,
                                                       ast_dns_query_get_name(query),
                                                       ast_dns_query_get_rr_class(query),
                                                       ast_dns_query_get_rr_type(query),
                                                       dns_system_resolver_set_response,
                                                       dns_system_resolver_add_record);
 
    /* Handle the possible return values from the DNS search */
    if (res == AST_DNS_SEARCH_FAILURE) {
        ast_debug(1, "DNS search failed for query: '%s'\n",
                ast_dns_query_get_name(query));
    } else if (res == AST_DNS_SEARCH_NO_RECORDS) {
        ast_debug(1, "DNS search failed to yield any results for query: '%s'\n",
                ast_dns_query_get_name(query));
    }
 
    /* Mark the query as complete */
    ast_dns_resolver_completed(query);
 
    /* Reduce the reference count on the query object */
    ao2_ref(query, -1);
 
    return res;
}
 
/*!
 * \brief Resolves a DNS query.
 *
 * \internal
 *
 * \param query  The ast_dns_query to resolve.
 *
 * \retval  0 on successful load of query handler to the ast_taskprocessor instance
 * \retval -1 on failure to load the query handler to the ast_taskprocessor instance
 */
static int dns_system_resolver_resolve(struct ast_dns_query *query)
{
    /* Add query processing handler to the task processor */
    int res = ast_taskprocessor_push(dns_system_resolver_tp,
                                     dns_system_resolver_process_query,
                                     ao2_bump(query));
 
    /* The query processing handler was not added to the task processor */
    if (res < 0) {
        ast_log(LOG_ERROR, "Failed to perform async DNS resolution of '%s'\n",
                ast_dns_query_get_name(query));
        ao2_ref(query, -1);
    }
 
    /* Return the result of adding the query processing handler to the task processor */
    return res;
}
 
/*!
 * \brief Callback to handle initializing the results field.
 *
 * \internal
 *
 * \param context A void pointer to the ast_dns_query being processed.
 * \param dns_response The full DNS response.
 * \param dns_response_len The length of the full DNS response.
 * \param rcode The DNS response code.
 *
 * \retval  0 on success
 * \retval -1 on failure
 */
static int dns_system_resolver_set_response(void *context, unsigned char *dns_response, int dns_response_len, int rcode)
{
    struct ast_dns_query *query = context;
    int res;
 
    /* Instantiate the query's result field (if necessary). */
    if (!ast_dns_query_get_result(query)) {
        res = ast_dns_resolver_set_result(query,
                                          0,
                                          0,
                                          rcode,
                                          ast_dns_query_get_name(query),
                                          (const char*) dns_response,
                                          dns_response_len);
 
        if (res) {
            /* There was a problem instantiating the results field. */
            ast_log(LOG_ERROR, "Could not instantiate the results field for query: '%s'\n",
                    ast_dns_query_get_name(query));
        }
    } else {
        res = DNS_SYSTEM_RESOLVER_SUCCESS;
    }
 
    return res;
}
 
/*!
 * \brief Initializes the resolver.
 *
 * \retval  0 on success
 * \retval -1 on failure
 */
int ast_dns_system_resolver_init(void)
{
    /* Register the base resolver */
    int res = ast_dns_resolver_register(&dns_system_resolver_base);
 
    if (res) {
        return DNS_SYSTEM_RESOLVER_FAILURE;
    }
 
    /* Instantiate the task processor */
    dns_system_resolver_tp = ast_taskprocessor_get("dns_system_resolver_tp",
                                                    TPS_REF_DEFAULT);
 
    /* Return error if the task processor failed to instantiate */
    if (!dns_system_resolver_tp) {
        return DNS_SYSTEM_RESOLVER_FAILURE;
    }
 
    /* Register the cleanup function */
    ast_register_cleanup(dns_system_resolver_destroy);
 
    return DNS_SYSTEM_RESOLVER_SUCCESS;
}