dns_recurring.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 Recurring Query Support
 *
 * \author Joshua Colp <[email protected]>
 */

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

#include "asterisk.h"

#include "asterisk/astobj2.h"
#include "asterisk/linkedlists.h"
#include "asterisk/sched.h"
#include "asterisk/strings.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_recurring.h"
#include "asterisk/dns_internal.h"

#include <arpa/nameser.h>

/*! \brief Destructor for a DNS query */
static void dns_query_recurring_destroy(void *data)
{
 struct ast_dns_query_recurring *recurring = data;

 ao2_cleanup(recurring->user_data);
}

static void dns_query_recurring_resolution_callback(const struct ast_dns_query *query);

/*! \brief Scheduled recurring query callback */
static int dns_query_recurring_scheduled_callback(const void *data)
{
 struct ast_dns_query_recurring *recurring = (struct ast_dns_query_recurring *)data;

 ao2_lock(recurring);
 recurring->timer = -1;
 if (!recurring->cancelled) {
 recurring->active = ast_dns_resolve_async(recurring->name, recurring->rr_type, recurring->rr_class, dns_query_recurring_resolution_callback,
 recurring);
 }
 ao2_unlock(recurring);

 ao2_ref(recurring, -1);

 return 0;
}

/*! \brief Query resolution callback */
static void dns_query_recurring_resolution_callback(const struct ast_dns_query *query)
{
 struct ast_dns_query_recurring *recurring = ast_dns_query_get_data(query);
 struct ast_dns_query *callback_query;

 /* Create a separate query to invoke the user specific callback on as the
 * recurring query user data may get used externally (by the unit test)
 * and thus changing it is problematic
 */
 callback_query = dns_query_alloc(query->name, query->rr_type, query->rr_class,
 recurring->callback, recurring->user_data);
 if (callback_query) {
 /* The result is immutable at this point and can be safely provided */
 callback_query->result = query->result;
 callback_query->callback(callback_query);
 callback_query->result = NULL;
 ao2_ref(callback_query, -1);
 }

 ao2_lock(recurring);
 /* So.. if something has not externally cancelled this we can reschedule based on the TTL */
 if (!recurring->cancelled) {
 const struct ast_dns_result *result = ast_dns_query_get_result(query);
 int ttl = MIN(ast_dns_result_get_lowest_ttl(result), INT_MAX / 1000);

 if (ttl) {
 recurring->timer = ast_sched_add(ast_dns_get_sched(), ttl * 1000, dns_query_recurring_scheduled_callback, ao2_bump(recurring));
 if (recurring->timer < 0) {
 /* It is impossible for this to be the last reference as the query has a reference to it */
 ao2_ref(recurring, -1);
 }
 }
 }

 ao2_replace(recurring->active, NULL);
 ao2_unlock(recurring);
}

struct ast_dns_query_recurring *ast_dns_resolve_recurring(const char *name, int rr_type, int rr_class, ast_dns_resolve_callback callback, void *data)
{
 struct ast_dns_query_recurring *recurring;

 if (ast_strlen_zero(name) || !callback || !ast_dns_get_sched()) {
 return NULL;
 }

 recurring = ao2_alloc(sizeof(*recurring) + strlen(name) + 1, dns_query_recurring_destroy);
 if (!recurring) {
 return NULL;
 }

 recurring->callback = callback;
 recurring->user_data = ao2_bump(data);
 recurring->timer = -1;
 recurring->rr_type = rr_type;
 recurring->rr_class = rr_class;
 strcpy(recurring->name, name); /* SAFE */

 recurring->active = ast_dns_resolve_async(name, rr_type, rr_class, dns_query_recurring_resolution_callback, recurring);
 if (!recurring->active) {
 ao2_ref(recurring, -1);
 return NULL;
 }

 return recurring;
}

int ast_dns_resolve_recurring_cancel(struct ast_dns_query_recurring *recurring)
{
 int res = 0;

 ao2_lock(recurring);

 recurring->cancelled = 1;
 AST_SCHED_DEL_UNREF(ast_dns_get_sched(), recurring->timer, ao2_ref(recurring, -1));

 if (recurring->active) {
 res = ast_dns_resolve_cancel(recurring->active);
 ao2_replace(recurring->active, NULL);
 }

 ao2_unlock(recurring);

 return res;
}