test_dns.c File Reference

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

Include dependency graph for test_dns.c:

Go to the source code of this file.

Data Structures
struct	async_resolution_data
	Data used by async result callback. More...
struct	resolver_data
	File-scoped data used during resolver tests. More...

Macros
#define	DNS_ANSWER   "Grumble Grumble"
#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 (resolver_add_record)
	AST_TEST_DEFINE (resolver_add_record_off_nominal)
	AST_TEST_DEFINE (resolver_data)
	AST_TEST_DEFINE (resolver_register_off_nominal)
	AST_TEST_DEFINE (resolver_register_unregister)
	AST_TEST_DEFINE (resolver_resolve_async)
	AST_TEST_DEFINE (resolver_resolve_async_cancel)
	AST_TEST_DEFINE (resolver_resolve_async_off_nominal)
	AST_TEST_DEFINE (resolver_resolve_sync)
	AST_TEST_DEFINE (resolver_resolve_sync_off_nominal)
	AST_TEST_DEFINE (resolver_set_result)
	AST_TEST_DEFINE (resolver_set_result_off_nominal)
	AST_TEST_DEFINE (resolver_unregister_off_nominal)
static void	async_callback (const struct ast_dns_query *query)
	Async DNS callback. More...
static struct async_resolution_data *	async_data_alloc (void)
	Allocation/initialization for async_resolution_data. More...
static void	async_data_destructor (void *obj)
	Destructor for async_resolution_data. More...
static int	fail_resolve (struct ast_dns_query *query)
	A resolve() method that simply fails. More...
static int	load_module (void)
static void *	resolution_thread (void *dns_query)
	Thread spawned by the mock resolver. More...
static void	resolver_data_cleanup (void)
	Cleanup global mock resolver data. More...
static void	resolver_data_init (void)
	Initialize global mock resolver data. More...
static void	stub_callback (const struct ast_dns_query *query)
static int	stub_cancel (struct ast_dns_query *query)
static int	stub_resolve (struct ast_dns_query *query)
static int	test_cancel (struct ast_dns_query *query)
	Mock resolver's cancel method. More...
static int	test_record (struct ast_test *test, const struct ast_dns_record *record, int rr_type, int rr_class, int ttl, const char *data, const size_t size)
static int	test_resolve (struct ast_dns_query *query)
	Mock resolver's resolve method. More...
static int	test_results (struct ast_test *test, const struct ast_dns_query *query, unsigned int expected_secure, unsigned int expected_bogus, unsigned int expected_rcode, const char *expected_canonical, const char *expected_answer, size_t answer_size)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "DNS API 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	test_resolver
	The mock resolver. More...
static struct resolver_data	test_resolver_data

Macro Definition Documentation

DNS_ANSWER

#define DNS_ANSWER   "Grumble Grumble"

Definition at line 294 of file test_dns.c.

DNS_ANSWER_SIZE

#define DNS_ANSWER_SIZE   strlen(DNS_ANSWER)

Definition at line 295 of file test_dns.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1337 of file test_dns.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1337 of file test_dns.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1337 of file test_dns.c.

AST_TEST_DEFINE() [1/13]

AST_TEST_DEFINE

(

resolver_add_record

)

Definition at line 421 of file test_dns.c.

{
    RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
    struct ast_dns_query some_query;
    const struct ast_dns_record *record;
 
    static const char *V4 = "127.0.0.1";
    static const size_t V4_BUFSIZE = sizeof(struct in_addr);
    char v4_buf[V4_BUFSIZE];
 
    static const char *V6 = "::1";
    static const size_t V6_BUFSIZE = sizeof(struct in6_addr);
    char v6_buf[V6_BUFSIZE];
 
    struct dns_record_details {
        int type;
        int class;
        int ttl;
        const char *data;
        const size_t size;
        int visited;
    } records[] = {
        { T_A, C_IN, 12345, v4_buf, V4_BUFSIZE, 0, },
        { T_AAAA, C_IN, 12345, v6_buf, V6_BUFSIZE, 0, },
    };
 
    int num_records_visited = 0;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_add_record";
        info->category = "/main/dns/";
        info->summary = "Test adding DNS records to a query";
        info->description =
            "This test performs the following:\n"
            "\t* Ensure a nominal A record can be added to a query result\n"
            "\t* Ensures that the record can be retrieved\n"
            "\t* Ensure that a second record can be added to the query result\n"
            "\t* Ensures that both records can be retrieved";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    memset(&some_query, 0, sizeof(some_query));
 
    if (ast_dns_resolver_set_result(&some_query, 0, 0, NOERROR, "asterisk.org",
                DNS_ANSWER, DNS_ANSWER_SIZE)) {
        ast_test_status_update(test, "Unable to set result for DNS query\n");
        return AST_TEST_FAIL;
    }
 
    result = ast_dns_query_get_result(&some_query);
    if (!result) {
        ast_test_status_update(test, "Unable to retrieve result from query\n");
        return AST_TEST_FAIL;
    }
 
    inet_pton(AF_INET, V4, v4_buf);
 
    /* Nominal Record */
    if (ast_dns_resolver_add_record(&some_query, records[0].type, records[0].class,
                records[0].ttl, records[0].data, records[0].size)) {
        ast_test_status_update(test, "Unable to add nominal record to query result\n");
        return AST_TEST_FAIL;
    }
 
    /* I should only be able to retrieve one record */
    record = ast_dns_result_get_records(result);
    if (!record) {
        ast_test_status_update(test, "Unable to retrieve record from result\n");
        return AST_TEST_FAIL;
    }
 
    if (test_record(test, record, records[0].type, records[0].class, records[0].ttl,
                records[0].data, records[0].size)) {
        return AST_TEST_FAIL;
    }
 
    if (ast_dns_record_get_next(record)) {
        ast_test_status_update(test, "Multiple records returned when only one was expected\n");
        return AST_TEST_FAIL;
    }
 
    inet_pton(AF_INET6, V6, v6_buf);
 
    if (ast_dns_resolver_add_record(&some_query, records[1].type, records[1].class,
                records[1].ttl, records[1].data, records[1].size)) {
        ast_test_status_update(test, "Unable to add second record to query result\n");
        return AST_TEST_FAIL;
    }
 
    for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
        int res;
 
        /* The order of returned records is not specified by the API. We use the record type
         * as the discriminator to determine which record data to expect.
         */
        if (ast_dns_record_get_rr_type(record) == records[0].type) {
            res = test_record(test, record, records[0].type, records[0].class, records[0].ttl, records[0].data, records[0].size);
            records[0].visited = 1;
        } else if (ast_dns_record_get_rr_type(record) == records[1].type) {
            res = test_record(test, record, records[1].type, records[1].class, records[1].ttl, records[1].data, records[1].size);
            records[1].visited = 1;
        } else {
            ast_test_status_update(test, "Unknown record type found in DNS results\n");
            return AST_TEST_FAIL;
        }
 
        if (res) {
            return AST_TEST_FAIL;
        }
 
        ++num_records_visited;
    }
 
    if (!records[0].visited || !records[1].visited) {
        ast_test_status_update(test, "Did not visit all added DNS records\n");
        return AST_TEST_FAIL;
    }
 
    if (num_records_visited != ARRAY_LEN(records)) {
        ast_test_status_update(test, "Did not visit the expected number of DNS records\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ARRAY_LEN, ast_dns_query_get_result(), ast_dns_record_get_next(), ast_dns_record_get_rr_type(), ast_dns_resolver_add_record(), ast_dns_resolver_set_result(), ast_dns_result_free(), ast_dns_result_get_records(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, DNS_ANSWER, DNS_ANSWER_SIZE, sip_to_pjsip::info(), NULL, RAII_VAR, records, result, TEST_EXECUTE, TEST_INIT, test_record(), and type.

AST_TEST_DEFINE() [2/13]

AST_TEST_DEFINE

(

resolver_add_record_off_nominal

)

Definition at line 550 of file test_dns.c.

{
    RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
    struct ast_dns_query some_query;
    static const char *V4 = "127.0.0.1";
    static const size_t V4_BUFSIZE = sizeof(struct in_addr);
    char v4_buf[V4_BUFSIZE];
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_add_record_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test adding off-nominal DNS records to a query";
        info->description =
            "This test performs the following:\n"
            "\t* Ensure a nominal A record cannot be added if no result has been set.\n"
            "\t* Ensure that an A record with invalid RR types cannot be added to a query\n"
            "\t* Ensure that an A record with invalid RR classes cannot be added to a query\n"
            "\t* Ensure that an A record with invalid TTL cannot be added to a query\n"
            "\t* Ensure that an A record with NULL data cannot be added to a query\n"
            "\t* Ensure that an A record with invalid length cannot be added to a query";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    memset(&some_query, 0, sizeof(some_query));
 
    inet_ntop(AF_INET, V4, v4_buf, V4_BUFSIZE);
 
    /* Add record before setting result */
    if (!ast_dns_resolver_add_record(&some_query, T_A, C_IN, 12345, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record to query before setting a result\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_dns_resolver_set_result(&some_query, 0, 0, NOERROR, "asterisk.org",
                DNS_ANSWER, DNS_ANSWER_SIZE)) {
        ast_test_status_update(test, "Unable to set result for DNS query\n");
        return AST_TEST_FAIL;
    }
 
    /* We get the result so it will be cleaned up when the function exits */
    result = ast_dns_query_get_result(&some_query);
 
    /* Invalid RR types */
    if (!ast_dns_resolver_add_record(&some_query, -1, C_IN, 12345, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record with negative RR type\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_add_record(&some_query, 65536 + 1, C_IN, 12345, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record with too large RR type\n");
        return AST_TEST_FAIL;
    }
 
    /* Invalid RR classes */
    if (!ast_dns_resolver_add_record(&some_query, T_A, -1, 12345, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record with negative RR class\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_add_record(&some_query, T_A, 65536 + 1, 12345, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record with too large RR class\n");
        return AST_TEST_FAIL;
    }
 
    /* Invalid TTL */
    if (!ast_dns_resolver_add_record(&some_query, T_A, C_IN, -1, v4_buf, V4_BUFSIZE)) {
        ast_test_status_update(test, "Successfully added DNS record with negative TTL\n");
        return AST_TEST_FAIL;
    }
 
    /* No data */
    if (!ast_dns_resolver_add_record(&some_query, T_A, C_IN, 12345, NULL, 0)) {
        ast_test_status_update(test, "Successfully added a DNS record with no data\n");
        return AST_TEST_FAIL;
    }
 
    /* Lie about the length */
    if (!ast_dns_resolver_add_record(&some_query, T_A, C_IN, 12345, v4_buf, 0)) {
        ast_test_status_update(test, "Successfully added a DNS record with length zero\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_dns_query_get_result(), ast_dns_resolver_add_record(), ast_dns_resolver_set_result(), ast_dns_result_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, DNS_ANSWER, DNS_ANSWER_SIZE, sip_to_pjsip::info(), NULL, RAII_VAR, result, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/13]

AST_TEST_DEFINE

(

resolver_data

)

Definition at line 189 of file test_dns.c.

{
    struct ast_dns_query some_query;
 
    struct digits {
        int fingers;
        int toes;
    };
 
    RAII_VAR(struct digits *, average, NULL, ao2_cleanup);
    RAII_VAR(struct digits *, polydactyl, NULL, ao2_cleanup);
 
    struct digits *data_ptr;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_data";
        info->category = "/main/dns/";
        info->summary = "Test getting and setting data on a DNS resolver";
        info->description = "This test does the following:\n"
            "\t* Ensure that requesting resolver data results in a NULL return if no data has been set.\n"
            "\t* Ensure that setting resolver data does not result in an error.\n"
            "\t* Ensure that retrieving the set resolver data returns the data we expect\n"
            "\t* Ensure that setting new resolver data on the query does not result in an error\n"
            "\t* Ensure that retrieving the resolver data returns the new data that we set";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    memset(&some_query, 0, sizeof(some_query));
 
    average = ao2_alloc(sizeof(*average), NULL);
    polydactyl = ao2_alloc(sizeof(*average), NULL);
 
    if (!average || !polydactyl) {
        ast_test_status_update(test, "Allocation failure during unit test\n");
        return AST_TEST_FAIL;
    }
 
    /* Ensure that NULL is retrieved if we haven't set anything on the query */
    data_ptr = ast_dns_resolver_get_data(&some_query);
    if (data_ptr) {
        ast_test_status_update(test, "Retrieved non-NULL resolver data from query unexpectedly\n");
        return AST_TEST_FAIL;
    }
 
    if (ast_dns_resolver_set_data(&some_query, average)) {
        ast_test_status_update(test, "Failed to set resolver data on query\n");
        return AST_TEST_FAIL;
    }
 
    /* Go ahead now and remove the query's reference to the resolver data to prevent memory leaks */
    ao2_ref(average, -1);
 
    /* Ensure that data can be set and retrieved */
    data_ptr = ast_dns_resolver_get_data(&some_query);
    if (!data_ptr) {
        ast_test_status_update(test, "Unable to retrieve resolver data from DNS query\n");
        return AST_TEST_FAIL;
    }
 
    if (data_ptr != average) {
        ast_test_status_update(test, "Unexpected resolver data retrieved from DNS query\n");
        return AST_TEST_FAIL;
    }
 
    /* Ensure that attempting to set new resolver data on the query fails */
    if (!ast_dns_resolver_set_data(&some_query, polydactyl)) {
        ast_test_status_update(test, "Successfully overwrote resolver data on a query. We shouldn't be able to do that\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_dns_resolver_get_data(), ast_dns_resolver_set_data(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), NULL, RAII_VAR, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/13]

AST_TEST_DEFINE

(

resolver_register_off_nominal

)

Definition at line 81 of file test_dns.c.

{
    struct ast_dns_resolver valid = {
        .name = "valid",
        .resolve = stub_resolve,
        .cancel = stub_cancel,
    };
 
    struct ast_dns_resolver incomplete1 = {
        .name = NULL,
        .resolve = stub_resolve,
        .cancel = stub_cancel,
    };
 
    struct ast_dns_resolver incomplete2 = {
        .name = "incomplete2",
        .resolve = NULL,
        .cancel = stub_cancel,
    };
 
    struct ast_dns_resolver incomplete3 = {
        .name = "incomplete3",
        .resolve = stub_resolve,
        .cancel = NULL,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_register_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test off-nominal resolver registration";
        info->description =
            "Test off-nominal resolver registration:\n"
            "\t* Register a duplicate resolver\n"
            "\t* Register a resolver without a name\n"
            "\t* Register a resolver without a resolve() method\n"
            "\t* Register a resolver without a cancel() method";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&valid)) {
        ast_test_status_update(test, "Failed to register valid resolver\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_register(&valid)) {
        ast_test_status_update(test, "Successfully registered the same resolver multiple times\n");
        return AST_TEST_FAIL;
    }
 
    ast_dns_resolver_unregister(&valid);
 
    if (!ast_dns_resolver_register(NULL)) {
        ast_test_status_update(test, "Successfully registered a NULL resolver\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_register(&incomplete1)) {
        ast_test_status_update(test, "Successfully registered a DNS resolver with no name\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_register(&incomplete2)) {
        ast_test_status_update(test, "Successfully registered a DNS resolver with no resolve() method\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_register(&incomplete3)) {
        ast_test_status_update(test, "Successfully registered a DNS resolver with no cancel() method\n");
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_dns_resolver_register(), ast_dns_resolver_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), ast_dns_resolver::name, NULL, stub_cancel(), stub_resolve(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [5/13]

AST_TEST_DEFINE

(

resolver_register_unregister

)

Definition at line 47 of file test_dns.c.

{
    struct ast_dns_resolver cool_guy_resolver = {
        .name = "A snake that swallowed a deer",
        .priority = 19890504,
        .resolve = stub_resolve,
        .cancel = stub_cancel,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_register_unregister";
        info->category = "/main/dns/";
        info->summary = "Test nominal resolver registration and unregistration";
        info->description =
            "The test performs the following steps:\n"
            "\t* Register a valid resolver.\n"
            "\t* Unregister the resolver.\n"
            "If either step fails, the test fails";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&cool_guy_resolver)) {
        ast_test_status_update(test, "Unable to register a perfectly good resolver\n");
        return AST_TEST_FAIL;
    }
 
    ast_dns_resolver_unregister(&cool_guy_resolver);
 
    return AST_TEST_PASS;
}

References ast_dns_resolver_register(), ast_dns_resolver_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, sip_to_pjsip::info(), ast_dns_resolver::name, stub_cancel(), stub_resolve(), TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/13]

AST_TEST_DEFINE

(

resolver_resolve_async

)

Definition at line 1018 of file test_dns.c.

{
    RAII_VAR(struct async_resolution_data *, async_data, NULL, ao2_cleanup);
    RAII_VAR(struct ast_dns_query_active *, active, NULL, ao2_cleanup);
    struct ast_dns_result *result;
    enum ast_test_result_state res = AST_TEST_PASS;
    struct timespec timeout;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_resolve_async";
        info->category = "/main/dns/";
        info->summary = "Test a nominal asynchronous DNS resolution";
        info->description =
            "This test performs an asynchronous DNS resolution of a domain. The goal of this\n"
            "test is not to check the records for accuracy. Rather, the goal is to ensure that\n"
            "the resolver is called into as expected, that we regain control before the query\n"
            "is completed, and to ensure that nothing tried to cancel the resolution.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&test_resolver)) {
        ast_test_status_update(test, "Unable to register test resolver\n");
        return AST_TEST_FAIL;
    }
 
    resolver_data_init();
 
    async_data = async_data_alloc();
    if (!async_data) {
        ast_test_status_update(test, "Failed to allocate asynchronous data\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    active = ast_dns_resolve_async("asterisk.org", T_A, C_IN, async_callback, async_data);
    if (!active) {
        ast_test_status_update(test, "Asynchronous resolution of address failed\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!test_resolver_data.resolve_called) {
        ast_test_status_update(test, "DNS resolution did not call resolver's resolve() method\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (test_resolver_data.canceled) {
        ast_test_status_update(test, "Resolver's cancel() method called for no reason\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    timeout = ast_tsnow();
    timeout.tv_sec += 10;
    ast_mutex_lock(&async_data->lock);
    while (!async_data->complete) {
        if (ast_cond_timedwait(&async_data->cond, &async_data->lock, &timeout) == ETIMEDOUT) {
            break;
        }
    }
    ast_mutex_unlock(&async_data->lock);
 
    if (!async_data->complete) {
        ast_test_status_update(test, "Asynchronous resolution timed out\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!test_resolver_data.resolution_complete) {
        ast_test_status_update(test, "Asynchronous resolution completed early?\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    result = ast_dns_query_get_result(active->query);
    if (!result) {
        ast_test_status_update(test, "Asynchronous resolution yielded no result\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!ast_dns_result_get_records(result)) {
        ast_test_status_update(test, "Asynchronous result had no records\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
cleanup:
    ast_dns_resolver_unregister(&test_resolver);
    resolver_data_cleanup();
    return res;
}

References ao2_cleanup, ast_cond_timedwait, ast_dns_query_get_result(), ast_dns_resolve_async(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), ast_dns_result_get_records(), ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tsnow(), async_callback(), async_data_alloc(), resolver_data::canceled, cleanup(), sip_to_pjsip::info(), NULL, RAII_VAR, resolver_data::resolution_complete, resolver_data::resolve_called, resolver_data_cleanup(), resolver_data_init(), result, TEST_EXECUTE, TEST_INIT, test_resolver, and test_resolver_data.

AST_TEST_DEFINE() [7/13]

AST_TEST_DEFINE

(

resolver_resolve_async_cancel

)

Definition at line 1200 of file test_dns.c.

{
    RAII_VAR(struct async_resolution_data *, async_data, NULL, ao2_cleanup);
    RAII_VAR(struct ast_dns_query_active *, active, NULL, ao2_cleanup);
    struct ast_dns_result *result;
    enum ast_test_result_state res = AST_TEST_PASS;
    struct timespec timeout;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_resolve_async_cancel";
        info->category = "/main/dns/";
        info->summary = "Test canceling an asynchronous DNS resolution";
        info->description =
            "This test performs an asynchronous DNS resolution of a domain and then cancels\n"
            "the resolution. The goal of this test is to ensure that the cancel() callback of\n"
            "the resolver is called and that it properly interrupts the resolution such that no\n"
            "records are returned.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&test_resolver)) {
        ast_test_status_update(test, "Unable to register test resolver\n");
        return AST_TEST_FAIL;
    }
 
    resolver_data_init();
 
    async_data = async_data_alloc();
    if (!async_data) {
        ast_test_status_update(test, "Failed to allocate asynchronous data\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    active = ast_dns_resolve_async("asterisk.org", T_A, C_IN, async_callback, async_data);
    if (!active) {
        ast_test_status_update(test, "Asynchronous resolution of address failed\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!test_resolver_data.resolve_called) {
        ast_test_status_update(test, "DNS resolution did not call resolver's resolve() method\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (test_resolver_data.canceled) {
        ast_test_status_update(test, "Resolver's cancel() method called for no reason\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    ast_dns_resolve_cancel(active);
 
    if (!test_resolver_data.canceled) {
        ast_test_status_update(test, "Resolver's cancel() method was not called\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    timeout = ast_tsnow();
    timeout.tv_sec += 10;
    ast_mutex_lock(&async_data->lock);
    while (!async_data->complete) {
        if (ast_cond_timedwait(&async_data->cond, &async_data->lock, &timeout) == ETIMEDOUT) {
            break;
        }
    }
    ast_mutex_unlock(&async_data->lock);
 
    if (!async_data->complete) {
        ast_test_status_update(test, "Asynchronous resolution timed out\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (test_resolver_data.resolution_complete) {
        ast_test_status_update(test, "Resolution completed without cancelation\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    result = ast_dns_query_get_result(active->query);
    if (result) {
        ast_test_status_update(test, "Canceled resolution had a result\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
cleanup:
    ast_dns_resolver_unregister(&test_resolver);
    resolver_data_cleanup();
    return res;
}

References ao2_cleanup, ast_cond_timedwait, ast_dns_query_get_result(), ast_dns_resolve_async(), ast_dns_resolve_cancel(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), ast_mutex_lock, ast_mutex_unlock, AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, ast_tsnow(), async_callback(), async_data_alloc(), resolver_data::canceled, cleanup(), sip_to_pjsip::info(), NULL, RAII_VAR, resolver_data::resolution_complete, resolver_data::resolve_called, resolver_data_cleanup(), resolver_data_init(), result, TEST_EXECUTE, TEST_INIT, test_resolver, and test_resolver_data.

AST_TEST_DEFINE() [8/13]

AST_TEST_DEFINE

(

resolver_resolve_async_off_nominal

)

Definition at line 1121 of file test_dns.c.

{
    struct ast_dns_resolver terrible_resolver = {
        .name = "Ed Wood's Filmography",
        .priority = 0,
        .resolve = fail_resolve,
        .cancel = stub_cancel,
    };
 
    struct dns_resolve_data {
        const char *name;
        int rr_type;
        int rr_class;
        ast_dns_resolve_callback callback;
    } resolves [] = {
        { NULL,           T_A,       C_IN,      stub_callback },
        { "asterisk.org", -1,        C_IN,      stub_callback },
        { "asterisk.org", 65536 + 1, C_IN,      stub_callback },
        { "asterisk.org", T_A,       -1,        stub_callback },
        { "asterisk.org", T_A,       65536 + 1, stub_callback },
        { "asterisk.org", T_A,       C_IN,      NULL },
    };
 
    struct ast_dns_query_active *active;
    enum ast_test_result_state res = AST_TEST_PASS;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_resolve_async_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test off-nominal asynchronous DNS resolution";
        info->description =
            "This test performs several off-nominal asynchronous DNS resolutions:\n"
            "\t* Attempt resolution with NULL name\n"
            "\t* Attempt resolution with invalid RR type\n"
            "\t* Attempt resolution with invalid RR class\n"
            "\t* Attempt resolution with NULL callback pointer\n"
            "\t* Attempt resolution with resolver that returns an error";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&test_resolver)) {
        ast_test_status_update(test, "Failed to register test resolver\n");
        return AST_TEST_FAIL;
    }
 
    for (i = 0; i < ARRAY_LEN(resolves); ++i) {
        active = ast_dns_resolve_async(resolves[i].name, resolves[i].rr_type, resolves[i].rr_class,
                resolves[i].callback, NULL);
        if (active) {
            ast_test_status_update(test, "Successfully performed asynchronous resolution with invalid data\n");
            ao2_ref(active, -1);
            res = AST_TEST_FAIL;
        }
    }
 
    ast_dns_resolver_unregister(&test_resolver);
 
    if (ast_dns_resolver_register(&terrible_resolver)) {
        ast_test_status_update(test, "Failed to register the DNS resolver\n");
        return AST_TEST_FAIL;
    }
 
    active = ast_dns_resolve_async("asterisk.org", T_A, C_IN, stub_callback, NULL);
 
    ast_dns_resolver_unregister(&terrible_resolver);
 
    if (active) {
        ast_test_status_update(test, "Successfully performed asynchronous resolution with invalid data\n");
        ao2_ref(active, -1);
        return AST_TEST_FAIL;
    }
 
    return res;
}

References ao2_ref, ARRAY_LEN, ast_dns_resolve_async(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, fail_resolve(), sip_to_pjsip::info(), name, ast_dns_resolver::name, NULL, stub_callback(), stub_cancel(), TEST_EXECUTE, TEST_INIT, and test_resolver.

AST_TEST_DEFINE() [9/13]

AST_TEST_DEFINE

(

resolver_resolve_sync

)

Definition at line 781 of file test_dns.c.

{
    RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_resolve_sync";
        info->category = "/main/dns/";
        info->summary = "Test a nominal synchronous DNS resolution";
        info->description =
            "This test performs a synchronous DNS resolution of a domain. The goal of this\n"
            "test is not to check the records for accuracy. Rather, the goal is to ensure that\n"
            "the resolver is called into as expected, that the query completes entirely before\n"
            "returning from the synchronous resolution, that nothing tried to cancel the resolution\n,"
            "and that some records were returned.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&test_resolver)) {
        ast_test_status_update(test, "Unable to register test resolver\n");
        return AST_TEST_FAIL;
    }
 
    resolver_data_init();
 
    if (ast_dns_resolve("asterisk.org", T_A, C_IN, &result)) {
        ast_test_status_update(test, "Resolution of address failed\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!result) {
        ast_test_status_update(test, "DNS resolution returned a NULL result\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!test_resolver_data.resolve_called) {
        ast_test_status_update(test, "DNS resolution did not call resolver's resolve() method\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (test_resolver_data.canceled) {
        ast_test_status_update(test, "Resolver's cancel() method called for no reason\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!test_resolver_data.resolution_complete) {
        ast_test_status_update(test, "Synchronous resolution completed early?\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!ast_dns_result_get_records(result)) {
        ast_test_status_update(test, "Synchronous resolution yielded no records.\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
cleanup:
    ast_dns_resolver_unregister(&test_resolver);
    resolver_data_cleanup();
    return res;
}

References ast_dns_resolve(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), ast_dns_result_free(), ast_dns_result_get_records(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, resolver_data::canceled, cleanup(), sip_to_pjsip::info(), NULL, RAII_VAR, resolver_data::resolution_complete, resolver_data::resolve_called, resolver_data_cleanup(), resolver_data_init(), result, TEST_EXECUTE, TEST_INIT, test_resolver, and test_resolver_data.

AST_TEST_DEFINE() [10/13]

AST_TEST_DEFINE

(

resolver_resolve_sync_off_nominal

)

Definition at line 862 of file test_dns.c.

{
    struct ast_dns_resolver terrible_resolver = {
        .name = "Uwe Boll's Filmography",
        .priority = 0,
        .resolve = fail_resolve,
        .cancel = stub_cancel,
    };
 
    struct ast_dns_result *result = NULL;
 
    struct dns_resolve_data {
        const char *name;
        int rr_type;
        int rr_class;
        struct ast_dns_result **result;
    } resolves [] = {
        { NULL,           T_A,       C_IN,      &result },
        { "asterisk.org", -1,        C_IN,      &result },
        { "asterisk.org", 65536 + 1, C_IN,      &result },
        { "asterisk.org", T_A,       -1,        &result },
        { "asterisk.org", T_A,       65536 + 1, &result },
        { "asterisk.org", T_A,       C_IN,      NULL },
    };
 
    int i;
 
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_resolve_sync_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test off-nominal synchronous DNS resolution";
        info->description =
            "This test performs several off-nominal synchronous DNS resolutions:\n"
            "\t* Attempt resolution with NULL name\n"
            "\t* Attempt resolution with invalid RR type\n"
            "\t* Attempt resolution with invalid RR class\n"
            "\t* Attempt resolution with NULL result pointer\n"
            "\t* Attempt resolution with resolver that returns an error";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    if (ast_dns_resolver_register(&test_resolver)) {
        ast_test_status_update(test, "Failed to register test resolver\n");
        return AST_TEST_FAIL;
    }
 
    for (i = 0; i < ARRAY_LEN(resolves); ++i) {
        if (!ast_dns_resolve(resolves[i].name, resolves[i].rr_type, resolves[i].rr_class, resolves[i].result)) {
            ast_test_status_update(test, "Successfully resolved DNS query with invalid parameters\n");
            res = AST_TEST_FAIL;
        } else if (result) {
            ast_test_status_update(test, "Failed resolution set a non-NULL result\n");
            ast_dns_result_free(result);
            res = AST_TEST_FAIL;
        }
    }
 
    ast_dns_resolver_unregister(&test_resolver);
 
    /* As a final test, try a legitimate query with a bad resolver */
    if (ast_dns_resolver_register(&terrible_resolver)) {
        ast_test_status_update(test, "Failed to register the terrible resolver\n");
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolve("asterisk.org", T_A, C_IN, &result)) {
        ast_test_status_update(test, "DNS resolution succeeded when we expected it not to\n");
        ast_dns_resolver_unregister(&terrible_resolver);
        return AST_TEST_FAIL;
    }
 
    ast_dns_resolver_unregister(&terrible_resolver);
 
    if (result) {
        ast_test_status_update(test, "Failed DNS resolution set the result to something non-NULL\n");
        ast_dns_result_free(result);
        return AST_TEST_FAIL;
    }
 
    return res;
}

References ARRAY_LEN, ast_dns_resolve(), ast_dns_resolver_register(), ast_dns_resolver_unregister(), ast_dns_result_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, fail_resolve(), sip_to_pjsip::info(), name, ast_dns_resolver::name, NULL, result, stub_cancel(), TEST_EXECUTE, TEST_INIT, and test_resolver.

AST_TEST_DEFINE() [11/13]

AST_TEST_DEFINE

(

resolver_set_result

)

Definition at line 297 of file test_dns.c.

{
    struct ast_dns_query some_query;
    struct ast_dns_result *result;
 
    struct dns_result {
        unsigned int secure;
        unsigned int bogus;
        unsigned int rcode;
    } results[] = {
        { 0, 0, NOERROR, },
        { 0, 1, NOERROR, },
        { 1, 0, NOERROR, },
        { 0, 0, NXDOMAIN, },
    };
    int i;
    enum ast_test_result_state res = AST_TEST_PASS;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_set_result";
        info->category = "/main/dns/";
        info->summary = "Test setting and getting results on DNS queries";
        info->description =
            "This test performs the following:\n"
            "\t* Sets a result that is not secure, bogus, and has rcode 0\n"
            "\t* Sets a result that is not secure, has rcode 0, but is secure\n"
            "\t* Sets a result that is not bogus, has rcode 0, but is secure\n"
            "\t* Sets a result that is not secure or bogus, but has rcode NXDOMAIN\n"
            "After each result is set, we ensure that parameters retrieved from\n"
            "the result have the expected values.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    memset(&some_query, 0, sizeof(some_query));
 
    for (i = 0; i < ARRAY_LEN(results); ++i) {
        if (ast_dns_resolver_set_result(&some_query, results[i].secure, results[i].bogus,
                results[i].rcode, "asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE)) {
            ast_test_status_update(test, "Unable to add DNS result to query\n");
            res = AST_TEST_FAIL;
        }
 
        if (test_results(test, &some_query, results[i].secure, results[i].bogus,
                results[i].rcode, "asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE)) {
            res = AST_TEST_FAIL;
        }
    }
 
    /* The final result we set needs to be freed */
    result = ast_dns_query_get_result(&some_query);
    ast_dns_result_free(result);
 
    return res;
}

References ARRAY_LEN, ast_dns_query_get_result(), ast_dns_resolver_set_result(), ast_dns_result_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, DNS_ANSWER, DNS_ANSWER_SIZE, sip_to_pjsip::info(), result, TEST_EXECUTE, TEST_INIT, and test_results().

AST_TEST_DEFINE() [12/13]

AST_TEST_DEFINE

(

resolver_set_result_off_nominal

)

Definition at line 355 of file test_dns.c.

{
    struct ast_dns_query some_query;
    struct ast_dns_result *result;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_set_result_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test setting off-nominal DNS results";
        info->description =
            "This test performs the following:\n"
            "\t* Attempt to add a DNS result that is both bogus and secure\n"
            "\t* Attempt to add a DNS result that has no canonical name";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    memset(&some_query, 0, sizeof(some_query));
 
    if (!ast_dns_resolver_set_result(&some_query, 1, 1, NOERROR, "asterisk.org",
                DNS_ANSWER, DNS_ANSWER_SIZE)) {
        ast_test_status_update(test, "Successfully added a result that was both secure and bogus\n");
        result = ast_dns_query_get_result(&some_query);
        ast_dns_result_free(result);
        return AST_TEST_FAIL;
    }
 
    if (!ast_dns_resolver_set_result(&some_query, 0, 0, NOERROR, NULL,
                DNS_ANSWER, DNS_ANSWER_SIZE)) {
        ast_test_status_update(test, "Successfully added result with no canonical name\n");
        result = ast_dns_query_get_result(&some_query);
        ast_dns_result_free(result);
        return AST_TEST_FAIL;
    }
 
    return AST_TEST_PASS;
}

References ast_dns_query_get_result(), ast_dns_resolver_set_result(), ast_dns_result_free(), AST_TEST_FAIL, AST_TEST_NOT_RUN, AST_TEST_PASS, ast_test_status_update, DNS_ANSWER, DNS_ANSWER_SIZE, sip_to_pjsip::info(), NULL, result, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [13/13]

AST_TEST_DEFINE

(

resolver_unregister_off_nominal

)

Definition at line 158 of file test_dns.c.

{
    struct ast_dns_resolver non_existent = {
        .name = "I do not exist",
        .priority = 20141004,
        .resolve = stub_resolve,
        .cancel = stub_cancel,
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "resolver_unregister_off_nominal";
        info->category = "/main/dns/";
        info->summary = "Test off-nominal DNS resolver unregister";
        info->description =
            "The test attempts the following:\n"
            "\t* Unregister a resolver that is not registered.\n"
            "\t* Unregister a NULL pointer.\n"
            "Because unregistering a resolver does not return an indicator of success, the best\n"
            "this test can do is verify that nothing blows up when this is attempted.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    ast_dns_resolver_unregister(&non_existent);
    ast_dns_resolver_unregister(NULL);
 
    return AST_TEST_PASS;
}

References ast_dns_resolver_unregister(), AST_TEST_NOT_RUN, AST_TEST_PASS, sip_to_pjsip::info(), ast_dns_resolver::name, NULL, stub_cancel(), stub_resolve(), TEST_EXECUTE, and TEST_INIT.

async_callback()

static void async_callback ( const struct ast_dns_query *  query )

static

Async DNS callback.

This is called when an async query completes, either because it resolved or because it was canceled. In our case, this callback is used to signal to the test that it can continue

Parameters

query

The DNS query that has completed

Definition at line 1008 of file test_dns.c.

{
    struct async_resolution_data *async_data = ast_dns_query_get_data(query);
 
    ast_mutex_lock(&async_data->lock);
    async_data->complete = 1;
    ast_cond_signal(&async_data->cond);
    ast_mutex_unlock(&async_data->lock);
}

References ast_cond_signal, ast_dns_query_get_data(), ast_mutex_lock, ast_mutex_unlock, async_resolution_data::complete, async_resolution_data::cond, and async_resolution_data::lock.

Referenced by AST_TEST_DEFINE().

async_data_alloc()

static struct async_resolution_data * async_data_alloc ( void  )

static

Allocation/initialization for async_resolution_data.

The DNS core mandates that a query's user data has to be ao2 allocated, so this is a helper method for doing that.

Return values

NULL	Failed allocation
non-NULL	Newly allocated async_resolution_data

Definition at line 983 of file test_dns.c.

{
    struct async_resolution_data *async_data;
 
    async_data = ao2_alloc(sizeof(*async_data), async_data_destructor);
    if (!async_data) {
        return NULL;
    }
 
    async_data->complete = 0;
    ast_mutex_init(&async_data->lock);
    ast_cond_init(&async_data->cond, NULL);
 
    return async_data;
}

References ao2_alloc, ast_cond_init, ast_mutex_init, async_data_destructor(), async_resolution_data::complete, async_resolution_data::cond, async_resolution_data::lock, and NULL.

Referenced by AST_TEST_DEFINE().

async_data_destructor()

static void async_data_destructor ( void *  obj )

static

Destructor for async_resolution_data.

Definition at line 966 of file test_dns.c.

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

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

Referenced by async_data_alloc().

fail_resolve()

static int fail_resolve ( struct ast_dns_query *  query )

static

A resolve() method that simply fails.

Parameters

query

The DNS query to resolve. This is ignored.

Returns

-1

Definition at line 857 of file test_dns.c.

{
    return -1;
}

Referenced by AST_TEST_DEFINE().

load_module()

static int load_module ( void  )

static

Definition at line 1318 of file test_dns.c.

{
    AST_TEST_REGISTER(resolver_register_unregister);
    AST_TEST_REGISTER(resolver_register_off_nominal);
    AST_TEST_REGISTER(resolver_unregister_off_nominal);
    AST_TEST_REGISTER(resolver_data);
    AST_TEST_REGISTER(resolver_set_result);
    AST_TEST_REGISTER(resolver_set_result_off_nominal);
    AST_TEST_REGISTER(resolver_add_record);
    AST_TEST_REGISTER(resolver_add_record_off_nominal);
    AST_TEST_REGISTER(resolver_resolve_sync);
    AST_TEST_REGISTER(resolver_resolve_sync_off_nominal);
    AST_TEST_REGISTER(resolver_resolve_async);
    AST_TEST_REGISTER(resolver_resolve_async_off_nominal);
    AST_TEST_REGISTER(resolver_resolve_async_cancel);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

resolution_thread()

static void * resolution_thread ( void *  dns_query )

static

Thread spawned by the mock resolver.

All DNS resolvers are required to be asynchronous. The mock resolver spawns this thread for every DNS query that is executed.

This thread waits for 5 seconds and then returns the same A record every time. The 5 second wait is to allow for the query to be canceled if desired

Parameters

dns_query

The ast_dns_query that is being resolved

Returns

NULL

Definition at line 670 of file test_dns.c.

{
    struct ast_dns_query *query = dns_query;
    struct timespec timeout;
 
    static const char *V4 = "127.0.0.1";
    static const size_t V4_BUFSIZE = sizeof(struct in_addr);
    char v4_buf[V4_BUFSIZE];
 
    timeout = ast_tsnow();
    timeout.tv_sec += 5;
 
    ast_mutex_lock(&test_resolver_data.lock);
    while (!test_resolver_data.canceled) {
        if (ast_cond_timedwait(&test_resolver_data.cancel_cond, &test_resolver_data.lock, &timeout) == ETIMEDOUT) {
            break;
        }
    }
    ast_mutex_unlock(&test_resolver_data.lock);
 
    if (test_resolver_data.canceled) {
        ast_dns_resolver_completed(query);
        ao2_ref(query, -1);
        return NULL;
    }
 
    ast_dns_resolver_set_result(query, 0, 0, NOERROR, "asterisk.org", DNS_ANSWER, DNS_ANSWER_SIZE);
 
    inet_pton(AF_INET, V4, v4_buf);
    ast_dns_resolver_add_record(query, T_A, C_IN, 12345, v4_buf, V4_BUFSIZE);
 
    test_resolver_data.resolution_complete = 1;
    ast_dns_resolver_completed(query);
 
    ao2_ref(query, -1);
    return NULL;
}

References ao2_ref, ast_cond_timedwait, ast_dns_resolver_add_record(), ast_dns_resolver_completed(), ast_dns_resolver_set_result(), ast_mutex_lock, ast_mutex_unlock, ast_tsnow(), resolver_data::cancel_cond, resolver_data::canceled, DNS_ANSWER, DNS_ANSWER_SIZE, resolver_data::lock, NULL, resolver_data::resolution_complete, and test_resolver_data.

Referenced by test_resolve().

resolver_data_cleanup()

static void resolver_data_cleanup ( void  )

static

Cleanup global mock resolver data.

This must be called at the end of tests that use the mock resolver

Definition at line 761 of file test_dns.c.

{
    ast_mutex_destroy(&test_resolver_data.lock);
    ast_cond_destroy(&test_resolver_data.cancel_cond);
}

References ast_cond_destroy, ast_mutex_destroy, resolver_data::cancel_cond, resolver_data::lock, and test_resolver_data.

Referenced by AST_TEST_DEFINE().

resolver_data_init()

static void resolver_data_init ( void  )

static

Initialize global mock resolver data.

This must be called at the beginning of tests that use the mock resolver

Definition at line 746 of file test_dns.c.

{
    test_resolver_data.resolve_called = 0;
    test_resolver_data.canceled = 0;
    test_resolver_data.resolution_complete = 0;
 
    ast_mutex_init(&test_resolver_data.lock);
    ast_cond_init(&test_resolver_data.cancel_cond, NULL);
}

References ast_cond_init, ast_mutex_init, resolver_data::cancel_cond, resolver_data::canceled, resolver_data::lock, NULL, resolver_data::resolution_complete, resolver_data::resolve_called, and test_resolver_data.

Referenced by AST_TEST_DEFINE().

stub_callback()

static void stub_callback ( const struct ast_dns_query *  query )

static

Stub async resolution callback

Definition at line 1116 of file test_dns.c.

{
    return;
}

Referenced by AST_TEST_DEFINE().

stub_cancel()

static int stub_cancel ( struct ast_dns_query *  query )

static

Definition at line 42 of file test_dns.c.

{
    return 0;
}

Referenced by AST_TEST_DEFINE().

stub_resolve()

static int stub_resolve ( struct ast_dns_query *  query )

static

Definition at line 36 of file test_dns.c.

{
    return 0;
}

Referenced by AST_TEST_DEFINE().

test_cancel()

static int test_cancel ( struct ast_dns_query *  query )

static

Mock resolver's cancel method.

This signals the resolution thread not to return any DNS results.

Parameters

query

DNS query to cancel

Returns

0

Definition at line 731 of file test_dns.c.

{
    ast_mutex_lock(&test_resolver_data.lock);
    test_resolver_data.canceled = 1;
    ast_cond_signal(&test_resolver_data.cancel_cond);
    ast_mutex_unlock(&test_resolver_data.lock);
 
    return 0;
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, resolver_data::cancel_cond, resolver_data::canceled, resolver_data::lock, and test_resolver_data.

test_record()

static int test_record ( struct ast_test *  test, const struct ast_dns_record *  record, int  rr_type, int  rr_class, int  ttl, const char *  data, const size_t  size  )

static

Definition at line 395 of file test_dns.c.

{
    if (ast_dns_record_get_rr_type(record) != rr_type) {
        ast_test_status_update(test, "Unexpected rr_type from DNS record\n");
        return -1;
    }
 
    if (ast_dns_record_get_rr_class(record) != rr_class) {
        ast_test_status_update(test, "Unexpected rr_class from DNS record\n");
        return -1;
    }
 
    if (ast_dns_record_get_ttl(record) != ttl) {
        ast_test_status_update(test, "Unexpected ttl from DNS record\n");
        return -1;
    }
 
    if (memcmp(ast_dns_record_get_data(record), data, size)) {
        ast_test_status_update(test, "Unexpected data in DNS record\n");
        return -1;
    }
 
    return 0;
}

References ast_dns_record_get_data(), ast_dns_record_get_rr_class(), ast_dns_record_get_rr_type(), ast_dns_record_get_ttl(), and ast_test_status_update.

Referenced by AST_TEST_DEFINE().

test_resolve()

static int test_resolve ( struct ast_dns_query *  query )

static

Mock resolver's resolve method.

Parameters

query

The query to resolve

Return values

0	Successfully spawned resolution thread
non-zero	Failed to spawn the resolution thread

Definition at line 715 of file test_dns.c.

{
    pthread_t resolver_thread;
 
    test_resolver_data.resolve_called = 1;
    return ast_pthread_create_detached(&resolver_thread, NULL, resolution_thread, ao2_bump(query));
}

References ao2_bump, ast_pthread_create_detached, NULL, resolution_thread(), resolver_data::resolve_called, and test_resolver_data.

test_results()

static int test_results ( struct ast_test *  test, const struct ast_dns_query *  query, unsigned int  expected_secure, unsigned int  expected_bogus, unsigned int  expected_rcode, const char *  expected_canonical, const char *  expected_answer, size_t  answer_size  )

static

Definition at line 265 of file test_dns.c.

{
    struct ast_dns_result *result;
 
    result = ast_dns_query_get_result(query);
    if (!result) {
        ast_test_status_update(test, "Unable to retrieve result from query\n");
        return -1;
    }
 
    if (ast_dns_result_get_secure(result) != expected_secure ||
            ast_dns_result_get_bogus(result) != expected_bogus ||
            ast_dns_result_get_rcode(result) != expected_rcode ||
            strcmp(ast_dns_result_get_canonical(result), expected_canonical) ||
            memcmp(ast_dns_result_get_answer(result), expected_answer, answer_size)) {
        ast_test_status_update(test, "Unexpected values in result from query\n");
        return -1;
    }
 
    return 0;
}

References ast_dns_result::answer_size, ast_dns_query_get_result(), ast_dns_result_get_answer(), ast_dns_result_get_bogus(), ast_dns_result_get_canonical(), ast_dns_result_get_rcode(), ast_dns_result_get_secure(), ast_test_status_update, and result.

Referenced by AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 1299 of file test_dns.c.

{
    AST_TEST_UNREGISTER(resolver_register_unregister);
    AST_TEST_UNREGISTER(resolver_register_off_nominal);
    AST_TEST_UNREGISTER(resolver_unregister_off_nominal);
    AST_TEST_UNREGISTER(resolver_data);
    AST_TEST_UNREGISTER(resolver_set_result);
    AST_TEST_UNREGISTER(resolver_set_result_off_nominal);
    AST_TEST_UNREGISTER(resolver_add_record);
    AST_TEST_UNREGISTER(resolver_add_record_off_nominal);
    AST_TEST_UNREGISTER(resolver_resolve_sync);
    AST_TEST_UNREGISTER(resolver_resolve_sync_off_nominal);
    AST_TEST_UNREGISTER(resolver_resolve_async);
    AST_TEST_UNREGISTER(resolver_resolve_async_off_nominal);
    AST_TEST_UNREGISTER(resolver_resolve_async_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 API 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 1337 of file test_dns.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1337 of file test_dns.c.

test_resolver

struct ast_dns_resolver test_resolver

static

The mock resolver.

The mock resolver does not care about the DNS query that is actually being made on it. It simply regurgitates the same DNS record no matter what.

Definition at line 774 of file test_dns.c.

Referenced by AST_TEST_DEFINE().

test_resolver_data

struct resolver_data test_resolver_data

static

Referenced by AST_TEST_DEFINE(), resolution_thread(), resolver_data_cleanup(), resolver_data_init(), test_cancel(), and test_resolve().