test_dns_query_set.c File Reference

#include "asterisk.h"
#include <arpa/nameser.h>
#include <arpa/inet.h>
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/vector.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_resolver.h"
#include "asterisk/dns_query_set.h"
#include "asterisk/dns_internal.h"

Include dependency graph for test_dns_query_set.c:

Go to the source code of this file.

Data Structures
struct	query_set_data

Macros
#define	DNS_ANSWER   "Yes sirree"
#define	DNS_ANSWER_SIZE   strlen(DNS_ANSWER)

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (query_set)
	AST_TEST_DEFINE (query_set_empty)
	AST_TEST_DEFINE (query_set_nominal_cancel)
	AST_TEST_DEFINE (query_set_off_nominal_cancel)
static int	load_module (void)
static void	query_set_callback (const struct ast_dns_query_set *query_set)
	Callback which is invoked upon query set completion. More...
static int	query_set_cancel (struct ast_dns_query *query)
	Resolver's cancel() method. More...
static struct query_set_data *	query_set_data_alloc (void)
static void	query_set_data_destructor (void *obj)
static int	query_set_resolve (struct ast_dns_query *query)
	Resolver's resolve() method. More...
static enum ast_test_result_state	query_set_test (struct ast_test *test, int resolve, int cancel)
	Framework for running a query set DNS test. More...
static void *	resolution_thread (void *dns_query)
	Thread that performs asynchronous resolution. More...
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "DNS query set tests" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_dns_resolver	query_set_resolver

Macro Definition Documentation

DNS_ANSWER

#define DNS_ANSWER   "Yes sirree"

Definition at line 75 of file test_dns_query_set.c.

DNS_ANSWER_SIZE

#define DNS_ANSWER_SIZE   strlen(DNS_ANSWER)

Definition at line 76 of file test_dns_query_set.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 392 of file test_dns_query_set.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 392 of file test_dns_query_set.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 392 of file test_dns_query_set.c.

AST_TEST_DEFINE() [1/4]

AST_TEST_DEFINE

(

query_set

)

Definition at line 287 of file test_dns_query_set.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "query_set";
        info->category = "/main/dns/query_set/";
        info->summary = "Test nominal asynchronous DNS query set";
        info->description =
            "This tests nominal query set in the following ways:\n"
            "\t* Multiple queries are added to a query set\n"
            "\t* The mock resolver is configured to respond to all queries\n"
            "\t* Asynchronous resolution of the query set is started\n"
            "\t* The mock resolver responds to all queries\n"
            "\t* We ensure that the query set callback is invoked upon completion";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return query_set_test(test, 4, 0);
}

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), query_set_test(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [2/4]

AST_TEST_DEFINE

(

query_set_empty

)

Definition at line 309 of file test_dns_query_set.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "query_set_empty";
        info->category = "/main/dns/query_set/";
        info->summary = "Test nominal asynchronous empty DNS query set";
        info->description =
            "This tests nominal query set in the following ways:\n"
            "\t* No queries are added to a query set\n"
            "\t* Asynchronous resolution of the query set is started\n"
            "\t* We ensure that the query set callback is invoked upon completion";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return query_set_test(test, 0, 0);
}

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), query_set_test(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/4]

AST_TEST_DEFINE

(

query_set_nominal_cancel

)

Definition at line 329 of file test_dns_query_set.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "query_set_nominal_cancel";
        info->category = "/main/dns/query_set/";
        info->summary = "Test nominal asynchronous DNS query set cancellation";
        info->description =
            "This tests nominal query set cancellation in the following ways:\n"
            "\t* Multiple queries are added to a query set\n"
            "\t* The mock resolver is configured to NOT respond to any queries\n"
            "\t* Asynchronous resolution of the query set is started\n"
            "\t* The query set is canceled and is confirmed to return with success";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return query_set_test(test, 0, 4);
}

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), query_set_test(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/4]

AST_TEST_DEFINE

(

query_set_off_nominal_cancel

)

Definition at line 350 of file test_dns_query_set.c.

{
    switch (cmd) {
    case TEST_INIT:
        info->name = "query_set_off_nominal_cancel";
        info->category = "/main/dns/query_set/";
        info->summary = "Test off-nominal asynchronous DNS query set cancellation";
        info->description =
            "This tests nominal query set cancellation in the following ways:\n"
            "\t* Multiple queries are added to a query set\n"
            "\t* The mock resolver is configured to respond to half the queries\n"
            "\t* Asynchronous resolution of the query set is started\n"
            "\t* The query set is canceled and is confirmed to return failure\n"
            "\t* The query set callback is confirmed to run, since it could not be fully canceled";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return query_set_test(test, 2, 2);
}

References AST_TEST_NOT_RUN, sip_to_pjsip::info(), query_set_test(), TEST_EXECUTE, and TEST_INIT.

load_module()

static int load_module ( void  )

static

Definition at line 382 of file test_dns_query_set.c.

{
    AST_TEST_REGISTER(query_set);
    AST_TEST_REGISTER(query_set_empty);
    AST_TEST_REGISTER(query_set_nominal_cancel);
    AST_TEST_REGISTER(query_set_off_nominal_cancel);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

query_set_callback()

static void query_set_callback ( const struct ast_dns_query_set *  query_set )

static

Callback which is invoked upon query set completion.

Parameters

query_set

The query set

Definition at line 161 of file test_dns_query_set.c.

{
    struct query_set_data *qsdata = ast_dns_query_set_get_data(query_set);
 
    ast_mutex_lock(&qsdata->lock);
    qsdata->query_set_complete = 1;
    ast_cond_signal(&qsdata->cond);
    ast_mutex_unlock(&qsdata->lock);
}

References ast_cond_signal, ast_dns_query_set_get_data(), ast_mutex_lock, ast_mutex_unlock, query_set_data::cond, query_set_data::lock, and query_set_data::query_set_complete.

Referenced by query_set_test().

query_set_cancel()

static int query_set_cancel ( struct ast_dns_query *  query )

static

Resolver's cancel() method.

Parameters

query

The query to cancel

Returns

0

Definition at line 131 of file test_dns_query_set.c.

{
    struct ast_dns_query_set *query_set = ast_dns_query_get_data(query);
    struct query_set_data *qsdata;
    int res = -1;
 
    if (!query_set) {
        return -1;
    }
    qsdata = query_set->user_data;
 
    if (qsdata->cancel++ < qsdata->cancel_allowed) {
        res = 0;
    }
 
    return res;
}

References ast_dns_query_get_data(), query_set_data::cancel, query_set_data::cancel_allowed, and ast_dns_query_set::user_data.

query_set_data_alloc()

static struct query_set_data * query_set_data_alloc ( void  )

static

Definition at line 60 of file test_dns_query_set.c.

{
    struct query_set_data *qsdata;
 
    qsdata = ao2_alloc(sizeof(*qsdata), query_set_data_destructor);
    if (!qsdata) {
        return NULL;
    }
 
    ast_mutex_init(&qsdata->lock);
    ast_cond_init(&qsdata->cond, NULL);
 
    return qsdata;
}

References ao2_alloc, ast_cond_init, ast_mutex_init, query_set_data::cond, query_set_data::lock, NULL, and query_set_data_destructor().

Referenced by query_set_test().

query_set_data_destructor()

static void query_set_data_destructor ( void *  obj )

static

Definition at line 52 of file test_dns_query_set.c.

{
    struct query_set_data *qsdata = obj;
 
    ast_mutex_destroy(&qsdata->lock);
    ast_cond_destroy(&qsdata->cond);
}

References ast_cond_destroy, ast_mutex_destroy, query_set_data::cond, and query_set_data::lock.

Referenced by query_set_data_alloc().

query_set_resolve()

static int query_set_resolve ( struct ast_dns_query *  query )

static

Resolver's resolve() method.

Parameters

query

The query that is to be resolved

Return values

0	Successfully created thread to perform the resolution
non-zero	Failed to create resolution thread

Definition at line 111 of file test_dns_query_set.c.

{
    struct ast_dns_query_set *query_set = ast_dns_query_get_data(query);
    struct query_set_data *qsdata = query_set->user_data;
    pthread_t resolver_thread;
 
    /* Only the queries which will not be canceled actually start a thread */
    if (qsdata->resolves++ < qsdata->cancel_allowed) {
        return 0;
    }
 
    return ast_pthread_create_detached(&resolver_thread, NULL, resolution_thread, ao2_bump(query));
}

References ao2_bump, ast_dns_query_get_data(), ast_pthread_create_detached, query_set_data::cancel_allowed, NULL, resolution_thread(), query_set_data::resolves, and ast_dns_query_set::user_data.

query_set_test()

static enum ast_test_result_state query_set_test ( struct ast_test *  test, int  resolve, int  cancel  )

static

Framework for running a query set DNS test.

This function serves as a common way of testing various numbers of queries in a query set and optional canceling of them.

Parameters

test	The test being run
resolve	The number of queries that should be allowed to complete resolution
cancel	The number of queries that should be allowed to be canceled

Definition at line 181 of file test_dns_query_set.c.

{
    int total = resolve + cancel;
    RAII_VAR(struct ast_dns_query_set *, query_set, NULL, ao2_cleanup);
    RAII_VAR(struct query_set_data *, qsdata, NULL, ao2_cleanup);
    enum ast_test_result_state res = AST_TEST_PASS;
    int idx;
    struct timespec timeout;
 
    if (ast_dns_resolver_register(&query_set_resolver)) {
        ast_test_status_update(test, "Failed to register query set DNS resolver\n");
        return AST_TEST_FAIL;
    }
 
    qsdata = query_set_data_alloc();
    if (!qsdata) {
        ast_test_status_update(test, "Failed to allocate data necessary for query set test\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    query_set = ast_dns_query_set_create();
    if (!query_set) {
        ast_test_status_update(test, "Failed to create DNS query set\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    qsdata->resolves_allowed = resolve;
    qsdata->cancel_allowed = cancel;
 
    for (idx = 0; idx < total; ++idx) {
        if (ast_dns_query_set_add(query_set, "asterisk.org", T_A, C_IN)) {
            ast_test_status_update(test, "Failed to add query to DNS query set\n");
            res = AST_TEST_FAIL;
            goto cleanup;
        }
    }
 
    if (ast_dns_query_set_num_queries(query_set) != total) {
        ast_test_status_update(test, "DNS query set does not contain the correct number of queries\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    ast_dns_query_set_resolve_async(query_set, query_set_callback, qsdata);
 
    if (cancel && (cancel == total)) {
        if (ast_dns_query_set_resolve_cancel(query_set)) {
            ast_test_status_update(test, "Failed to cancel DNS query set when it should be cancellable\n");
            res = AST_TEST_FAIL;
        }
 
        if (qsdata->query_set_complete) {
            ast_test_status_update(test, "Query set callback was invoked despite all queries being cancelled\n");
            res = AST_TEST_FAIL;
        }
 
        goto cleanup;
    } else if (cancel) {
        if (!ast_dns_query_set_resolve_cancel(query_set)) {
            ast_test_status_update(test, "Successfully cancelled DNS query set when it should not be possible\n");
            res = AST_TEST_FAIL;
            goto cleanup;
        }
    }
 
    timeout = ast_tsnow();
    timeout.tv_sec += 10;
 
    ast_mutex_lock(&qsdata->lock);
    while (!qsdata->query_set_complete) {
        if (ast_cond_timedwait(&qsdata->cond, &qsdata->lock, &timeout) == ETIMEDOUT) {
            break;
        }
    }
    ast_mutex_unlock(&qsdata->lock);
 
    if (!qsdata->query_set_complete) {
        ast_test_status_update(test, "Query set did not complete when it should have\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    for (idx = 0; idx < ast_dns_query_set_num_queries(query_set); ++idx) {
        const struct ast_dns_query *query = ast_dns_query_set_get(query_set, idx);
 
        if (strcmp(ast_dns_query_get_name(query), "asterisk.org")) {
            ast_test_status_update(test, "Query did not have expected name\n");
            res = AST_TEST_FAIL;
        }
        if (ast_dns_query_get_rr_type(query) != T_A) {
            ast_test_status_update(test, "Query did not have expected type\n");
            res = AST_TEST_FAIL;
        }
        if (ast_dns_query_get_rr_class(query) != C_IN) {
            ast_test_status_update(test, "Query did not have expected class\n");
            res = AST_TEST_FAIL;
        }
    }
 
cleanup:
    ast_dns_resolver_unregister(&query_set_resolver);
    return res;
}

References ao2_cleanup, ast_cond_timedwait, ast_dns_query_get_name(), ast_dns_query_get_rr_class(), ast_dns_query_get_rr_type(), ast_dns_query_set_add(), ast_dns_query_set_create(), ast_dns_query_set_get(), ast_dns_query_set_num_queries(), ast_dns_query_set_resolve_async(), ast_dns_query_set_resolve_cancel(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, AST_TEST_PASS, ast_test_status_update, ast_tsnow(), query_set_data::cancel, cleanup(), NULL, query_set_callback(), query_set_data_alloc(), query_set_resolver, RAII_VAR, and total.

Referenced by AST_TEST_DEFINE().

resolution_thread()

static void * resolution_thread ( void *  dns_query )

static

Thread that performs asynchronous resolution.

This thread uses the query's user data to determine how to perform the resolution. If the allowed number of resolutions has not been reached then this will succeed, otherwise the query is expected to have been canceled.

Parameters

dns_query

The ast_dns_query that is being performed

Returns

NULL

Definition at line 89 of file test_dns_query_set.c.

{
    struct ast_dns_query *query = dns_query;
    struct ast_dns_query_set *query_set = ast_dns_query_get_data(query);
    struct query_set_data *qsdata = query_set->user_data;
 
    ast_assert(qsdata != NULL);
 
    ast_dns_resolver_set_result(query, 0, 0, NOERROR, "asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE);
    ast_dns_resolver_completed(query);
 
    ao2_ref(query, -1);
    return NULL;
}

References ao2_ref, ast_assert, ast_dns_query_get_data(), ast_dns_resolver_completed(), ast_dns_resolver_set_result(), DNS_ANSWER, DNS_ANSWER_SIZE, NULL, and ast_dns_query_set::user_data.

Referenced by query_set_resolve().

unload_module()

static int unload_module ( void  )

static

Definition at line 372 of file test_dns_query_set.c.

{
    AST_TEST_UNREGISTER(query_set);
    AST_TEST_UNREGISTER(query_set_empty);
    AST_TEST_UNREGISTER(query_set_nominal_cancel);
    AST_TEST_UNREGISTER(query_set_off_nominal_cancel);
 
    return 0;
}

References AST_TEST_UNREGISTER.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "DNS query set tests" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 392 of file test_dns_query_set.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 392 of file test_dns_query_set.c.

query_set_resolver

struct ast_dns_resolver query_set_resolver

static

Definition at line 149 of file test_dns_query_set.c.

Referenced by query_set_test().