dns_recurring.c File Reference

DNS Recurring Query Support. More...

#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>

Include dependency graph for dns_recurring.c:

Go to the source code of this file.

Functions
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)
	Asynchronously resolve a DNS query, and continue resolving it according to the lowest TTL available. More...
int	ast_dns_resolve_recurring_cancel (struct ast_dns_query_recurring *recurring)
	Cancel an asynchronous recurring DNS resolution. More...
static void	dns_query_recurring_destroy (void *data)
	Destructor for a DNS query. More...
static void	dns_query_recurring_resolution_callback (const struct ast_dns_query *query)
	Query resolution callback. More...
static int	dns_query_recurring_scheduled_callback (const void *data)
	Scheduled recurring query callback. More...

Detailed Description

DNS Recurring Query Support.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file dns_recurring.c.

Function Documentation

ast_dns_resolve_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
	)

Asynchronously resolve a DNS query, and continue resolving it according to the lowest TTL available.

Parameters

name	The name of what to resolve
rr_type	Resource record type
rr_class	Resource record class
callback	The callback to invoke upon completion
data	User data to make available on the query

Return values

non-NULL	success - query has been sent for resolution
NULL	failure

Note

The user data passed in to this function must be ao2 allocated

This query will continue to happen according to the lowest TTL unless cancelled using ast_dns_resolve_recurring_cancel

It is NOT possible for the callback to be invoked concurrently for the query multiple times

The query will occur when the TTL expires, not before. This means that there is a period of time where the previous information can be considered stale.

If the TTL is determined to be 0 (the record specifies 0, or no records exist) this will cease doing a recurring query. It is the responsibility of the caller to resume querying at an interval they determine.

Definition at line 109 of file dns_recurring.c.

References ast_dns_query_recurring::active, ao2_alloc, ao2_bump, ao2_ref, ast_dns_get_sched(), ast_dns_resolve_async(), ast_strlen_zero, ast_dns_query_recurring::callback, dns_query_recurring_destroy(), dns_query_recurring_resolution_callback(), ast_dns_query_recurring::name, NULL, ast_dns_query_recurring::rr_class, ast_dns_query_recurring::rr_type, ast_dns_query_recurring::timer, and ast_dns_query_recurring::user_data.

Referenced by AST_TEST_DEFINE().

{
   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;
}

ast_dns_resolve_recurring_cancel()

int ast_dns_resolve_recurring_cancel

(

struct ast_dns_query_recurring *

recurring

)

Cancel an asynchronous recurring DNS resolution.

Parameters

query

The DNS query returned from ast_dns_resolve_recurring

Return values

0	success - any active query has been cancelled and the query will no longer occur
-1	failure - an active query was in progress and could not be cancelled

Note

If successfully cancelled the callback will not be invoked

This function does NOT drop your reference to the recurring query, this should be dropped using ao2_ref

Definition at line 138 of file dns_recurring.c.

References ast_dns_query_recurring::active, ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_dns_get_sched(), ast_dns_resolve_cancel(), AST_SCHED_DEL_UNREF, ast_dns_query_recurring::cancelled, NULL, and ast_dns_query_recurring::timer.

Referenced by AST_TEST_DEFINE().

{
   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;
}

dns_query_recurring_destroy()

static void dns_query_recurring_destroy ( void *  data )

static

Destructor for a DNS query.

Definition at line 43 of file dns_recurring.c.

References ao2_cleanup, dns_query_recurring_resolution_callback(), and ast_dns_query_recurring::user_data.

Referenced by ast_dns_resolve_recurring().

{
   struct ast_dns_query_recurring *recurring = data;

   ao2_cleanup(recurring->user_data);
}

dns_query_recurring_resolution_callback()

static void dns_query_recurring_resolution_callback ( const struct ast_dns_query *  query )

static

Query resolution callback.

Definition at line 71 of file dns_recurring.c.

References ast_dns_query_recurring::active, ao2_bump, ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_dns_get_sched(), ast_dns_query_get_data(), ast_dns_query_get_result(), ast_dns_result_get_lowest_ttl(), ast_sched_add(), ast_dns_query::callback, ast_dns_query_recurring::callback, ast_dns_query_recurring::cancelled, dns_query_alloc(), dns_query_recurring_scheduled_callback(), MIN, ast_dns_query::name, NULL, result, ast_dns_query::result, ast_dns_query::rr_class, ast_dns_query::rr_type, ast_dns_query_recurring::timer, and ast_dns_query_recurring::user_data.

Referenced by ast_dns_resolve_recurring(), dns_query_recurring_destroy(), and dns_query_recurring_scheduled_callback().

{
   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);
}

dns_query_recurring_scheduled_callback()

static int dns_query_recurring_scheduled_callback ( const void *  data )

static

Scheduled recurring query callback.

Definition at line 53 of file dns_recurring.c.

References ast_dns_query_recurring::active, ao2_lock, ao2_ref, ao2_unlock, ast_dns_resolve_async(), ast_dns_query_recurring::cancelled, dns_query_recurring_resolution_callback(), ast_dns_query_recurring::name, ast_dns_query_recurring::rr_class, ast_dns_query_recurring::rr_type, and ast_dns_query_recurring::timer.

Referenced by dns_query_recurring_resolution_callback().

{
   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;
}