test_dns_naptr.c File Reference

#include "asterisk.h"
#include <arpa/nameser.h>
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/dns_core.h"
#include "asterisk/dns_resolver.h"
#include "asterisk/dns_naptr.h"
#include "asterisk/dns_test.h"

Include dependency graph for test_dns_naptr.c:

Go to the source code of this file.

Data Structures
struct	naptr_record

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_TEST_DEFINE (naptr_resolve_nominal)
	AST_TEST_DEFINE (naptr_resolve_off_nominal_flags)
	AST_TEST_DEFINE (naptr_resolve_off_nominal_interactions)
	AST_TEST_DEFINE (naptr_resolve_off_nominal_length)
	AST_TEST_DEFINE (naptr_resolve_off_nominal_regexp)
	AST_TEST_DEFINE (naptr_resolve_off_nominal_services)
static int	generate_naptr_record (void *dns_record, char *buf)
	Given a NAPTR record, generate a binary form, as would appear in DNS RDATA. More...
static int	load_module (void)
static int	naptr_cancel (struct ast_dns_query *query)
	A STUB. More...
static int	naptr_resolve (struct ast_dns_query *query)
	Mock NAPTR resolution method. More...
static void *	naptr_thread (void *dns_query)
	Asynchronous NAPTR resolution thread. More...
static enum ast_test_result_state	off_nominal_test (struct ast_test *test, struct naptr_record *records, int num_records)
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 char	ans_buffer [1024]
	A buffer to place raw DNS records into. More...
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_dns_resolver	naptr_resolver
	Mock NAPTR resolver. More...
static int	num_test_records
	The number of records in the test_records array. More...
static struct naptr_record *	test_records
	A pointer to an array of records for a test. More...

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 502 of file test_dns_naptr.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 502 of file test_dns_naptr.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 502 of file test_dns_naptr.c.

AST_TEST_DEFINE() [1/6]

AST_TEST_DEFINE

(

naptr_resolve_nominal

)

Definition at line 165 of file test_dns_naptr.c.

{
    RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
    const struct ast_dns_record *record;
    struct naptr_record records[] = {
        /* Incredibly plain record */
        { 200, 100, {1, "A"}, {4, "BLAH"}, {0, ""}, "goose.down" },
        /* Records with valid but unusual flags */
        { 300,   8, {0, ""}, {4, "BLAH"}, {0, ""}, "goose.down" },
        { 300,   6, {1, "3"}, {4, "BLAH"}, {0, ""}, "goose.down" },
        { 100,   2, {2, "32"}, {4, "BLAH"}, {0, ""}, "goose.down" },
        { 400, 100, {3, "A32"}, {4, "BLAH"}, {0, ""}, "goose.down" },
        /* Records with valid but unusual services */
        { 100, 700, {0, ""}, {0, ""}, {0, ""}, "goose.down" },
        { 500, 102, {1, "A"}, {42, "A+B12+C+D+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"}, {0, ""}, "goose.down" },
        { 500, 100, {1, "A"}, {14, "A+B12+C+D+EEEE"}, {0, ""}, "goose.down" },
        /* Records with valid regexes (regexes are always unusual) */
        { 500, 101, {1, "A"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, "" },
        { 500,  99, {1, "A"}, {4, "BLAH"}, {15, "0.*0horse.mane0"}, "" },
        {  10, 100, {1, "A"}, {4, "BLAH"}, {11, "!.*!\\!\\!\\!!"}, "" },
        { 700, 999, {1, "A"}, {4, "BLAH"}, {30, "!(.)(.)(.)(.)!\\1.m.\\2.n\\3.o\\4!"}, "" },
    };
 
    int naptr_record_order[] = { 10, 3, 5, 0, 2, 1, 4, 9, 7, 8, 6, 11};
    enum ast_test_result_state res = AST_TEST_PASS;
    int i;
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve";
        info->category = "/main/dns/naptr/";
        info->summary = "Test nominal resolution of NAPTR records";
        info->description = "This test defines four valid NAPTR records and\n"
            "performs a resolution of the domain to which they belong. The test\n"
            "ensures that all fields of the NAPTR records are parsed correctly\n"
            "and that the records are returned in sorted order";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    test_records = records;
    num_test_records = ARRAY_LEN(records);
    memset(ans_buffer, 0, sizeof(ans_buffer));
 
    ast_dns_resolver_register(&naptr_resolver);
 
    if (ast_dns_resolve("goose.feathers", T_NAPTR, C_IN, &result)) {
        ast_test_status_update(test, "DNS resolution failed\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!result) {
        ast_test_status_update(test, "DNS resolution returned no result\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    i = 0;
    for (record = ast_dns_result_get_records(result); record; record = ast_dns_record_get_next(record)) {
        if (ast_dns_naptr_get_order(record) != records[naptr_record_order[i]].order) {
            ast_test_status_update(test, "Expected order %hu, got order %hu from NAPTR record\n",
                    records[naptr_record_order[i]].order, ast_dns_naptr_get_order(record));
            res = AST_TEST_FAIL;
        }
        if (ast_dns_naptr_get_preference(record) != records[naptr_record_order[i]].preference) {
            ast_test_status_update(test, "Expected preference %hu, got preference %hu from NAPTR record\n",
                    records[naptr_record_order[i]].preference, ast_dns_naptr_get_preference(record));
            res = AST_TEST_FAIL;
        }
        if (strcmp(ast_dns_naptr_get_flags(record), records[naptr_record_order[i]].flags.val)) {
            ast_test_status_update(test, "Expected flags %s, got flags %s from NAPTR record\n",
                    records[naptr_record_order[i]].flags.val, ast_dns_naptr_get_flags(record));
            res = AST_TEST_FAIL;
        }
        if (strcmp(ast_dns_naptr_get_service(record), records[naptr_record_order[i]].services.val)) {
            ast_test_status_update(test, "Expected services %s, got services %s from NAPTR record\n",
                    records[naptr_record_order[i]].services.val, ast_dns_naptr_get_service(record));
            res = AST_TEST_FAIL;
        }
        if (strcmp(ast_dns_naptr_get_regexp(record), records[naptr_record_order[i]].regexp.val)) {
            ast_test_status_update(test, "Expected regexp %s, got regexp %s from NAPTR record\n",
                    records[naptr_record_order[i]].regexp.val, ast_dns_naptr_get_regexp(record));
            res = AST_TEST_FAIL;
        }
        if (strcmp(ast_dns_naptr_get_replacement(record), records[naptr_record_order[i]].replacement)) {
            ast_test_status_update(test, "Expected replacement %s, got replacement %s from NAPTR record\n",
                    records[naptr_record_order[i]].replacement, ast_dns_naptr_get_replacement(record));
            res = AST_TEST_FAIL;
        }
        ++i;
    }
 
    if (i != ARRAY_LEN(records)) {
        ast_test_status_update(test, "Unexpected number of records returned in NAPTR lookup\n");
        res = AST_TEST_FAIL;
    }
 
cleanup:
 
    ast_dns_resolver_unregister(&naptr_resolver);
 
    test_records = NULL;
    num_test_records = 0;
    memset(ans_buffer, 0, sizeof(ans_buffer));
 
    return res;
}

References ans_buffer, ARRAY_LEN, ast_dns_naptr_get_flags(), ast_dns_naptr_get_order(), ast_dns_naptr_get_preference(), ast_dns_naptr_get_regexp(), ast_dns_naptr_get_replacement(), ast_dns_naptr_get_service(), ast_dns_record_get_next(), 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, cleanup(), naptr_record::flags, sip_to_pjsip::info(), naptr_resolver, NULL, num_test_records, order, naptr_record::preference, RAII_VAR, records, naptr_record::regexp, naptr_record::replacement, result, naptr_record::services, TEST_EXECUTE, TEST_INIT, test_records, and ast_dns_test_string::val.

AST_TEST_DEFINE() [2/6]

AST_TEST_DEFINE

(

naptr_resolve_off_nominal_flags

)

Definition at line 346 of file test_dns_naptr.c.

{
    struct naptr_record records[] = {
        /* Non-alphanumeric flag */
        { 100, 100, {1, "!"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        /* Mix of valid and non-alphanumeric */
        { 100, 100, {2, "A!"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "!A"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        /* Invalid combinations of flags */
        { 100, 100, {2, "sa"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "su"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "sp"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "as"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "au"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "ap"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "ua"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "us"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "up"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "pa"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "ps"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {2, "pu"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, ""},
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve_off_nominal_flags";
        info->category = "/main/dns/naptr/";
        info->summary = "Ensure that NAPTR records with invalid flags are not presented in results";
        info->description = "This test defines a set of records where the flags provided are\n"
            "invalid in some way. This may be due to providing non-alphanumeric characters or\n"
            "by providing clashing flags. The result should be that none of the defined records\n"
            "are returned by the resolver";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return off_nominal_test(test, records, ARRAY_LEN(records));
}

References ARRAY_LEN, AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_test(), records, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [3/6]

AST_TEST_DEFINE

(

naptr_resolve_off_nominal_interactions

)

Definition at line 452 of file test_dns_naptr.c.

{
    struct naptr_record records[] = {
        /* Both regexp and replacement are specified */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {15, "!.*!horse.mane!"}, "goose.down"},
        /* XXX RFC 2915 says that a service MUST be present if terminal flags are
         * specified. However, RFCs 3401-3404 do not specify this behavior, so
         * I am not putting in a test for it
         */
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve_off_nominal_interactions";
        info->category = "/main/dns/naptr/";
        info->summary = "Ensure that NAPTR records with invalid interactions are not presented in results";
        info->description = "This test defines a set of records where all parts are individually valid,\n"
            "but when combined do not make sense and are thus invalid.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return off_nominal_test(test, records, ARRAY_LEN(records));
}

References ARRAY_LEN, AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_test(), records, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [4/6]

AST_TEST_DEFINE

(

naptr_resolve_off_nominal_length

)

Definition at line 316 of file test_dns_naptr.c.

{
    struct naptr_record records[] = {
        { 100, 100, {255, "A"}, {4, "BLAH"},   {15, "!.*!horse.mane!"}, "" },
        { 100, 100, {0, "A"},   {4, "BLAH"},   {15, "!.*!horse.mane!"}, "" },
        { 100, 100, {1, "A"},   {255, "BLAH"}, {15, "!.*!horse.mane!"}, "" },
        { 100, 100, {1, "A"},   {2, "BLAH"},   {15, "!.*!horse.mane!"}, "" },
        { 100, 100, {1, "A"},   {4, "BLAH"},   {255, "!.*!horse.mane!"}, "" },
        { 100, 100, {1, "A"},   {4, "BLAH"},   {3, "!.*!horse.mane!"}, "" },
        { 100, 100, {255, "A"}, {255, "BLAH"}, {255, "!.*!horse.mane!"}, "" },
        { 100, 100, {0, "A"},   {2, "BLAH"},   {3, "!.*!horse.mane!"}, "" },
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve_off_nominal_length";
        info->category = "/main/dns/naptr/";
        info->summary = "Test resolution of NAPTR records with off-nominal lengths";
        info->description = "This test defines a set of records where the strings provided\n"
            "within the record are valid, but the lengths of the strings in the record are\n"
            "invalid, either too large or too small. The goal of this test is to ensure that\n"
            "these invalid lengths result in resolution failures";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return off_nominal_test(test, records, ARRAY_LEN(records));
}

References ARRAY_LEN, AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_test(), records, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [5/6]

AST_TEST_DEFINE

(

naptr_resolve_off_nominal_regexp

)

Definition at line 417 of file test_dns_naptr.c.

{
    struct naptr_record records[] = {
        /* Invalid delim-char */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {15, "1.*1horse.mane1"}, ""},
        /* Not enough delim-chars */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {14, "!.*!horse.mane"}, ""},
        /* Not enough delim-chars, part 2 */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {16, "!.*!horse.mane\\!"}, ""},
        /* Too many delim-chars */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {15, "!.*!horse!mane!"}, ""},
        /* Invalid regex flag */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {16, "!.*!horse.mane!o"}, ""},
        /* Invalid backreference */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {13, "!.*!horse.\\0!"}, ""},
        /* Invalid regex */
        { 100, 100, {1, "A"}, {4, "BLAH"}, {16, "!(.*!horse.mane!"}, ""},
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve_off_nominal_regexp";
        info->category = "/main/dns/naptr/";
        info->summary = "Ensure that NAPTR records with invalid regexps are not presented in results";
        info->description = "This test defines a set of records where the regexps provided are\n"
            "invalid in some way. The test ensures that none of the invalid records are returned\n"
            "when performing a NAPTR lookup";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return off_nominal_test(test, records, ARRAY_LEN(records));
}

References ARRAY_LEN, AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_test(), records, TEST_EXECUTE, and TEST_INIT.

AST_TEST_DEFINE() [6/6]

AST_TEST_DEFINE

(

naptr_resolve_off_nominal_services

)

Definition at line 386 of file test_dns_naptr.c.

{
    struct naptr_record records[] = {
        { 100, 100, {1, "A"}, {5, "BLAH!"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {5, "BL!AH"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {8, "1SIP+D2U"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {8, "SIP+1D2U"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {4, "+D2U"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {4, "SIP+"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {8, "SIP++D2U"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {37, "SIPSIPSIPSIPSIPSIPSIPSIPSIPSIPSIP+D2U"}, {15, "!.*!horse.mane!"}, ""},
        { 100, 100, {1, "A"}, {37, "SIP+D2UD2UD2UD2UD2UD2UD2UD2UD2UD2UD2U"}, {15, "!.*!horse.mane!"}, ""},
    };
 
    switch (cmd) {
    case TEST_INIT:
        info->name = "naptr_resolve_off_nominal_services";
        info->category = "/main/dns/naptr/";
        info->summary = "Ensure that NAPTR records with invalid services are not presented in results";
        info->description = "This test defines a set of records where the services provided are\n"
            "invalid in some way. This may be due to providing non-alphanumeric characters, providing\n"
            "protocols or resolution services that start with a non-alphabetic character, or\n"
            "providing fields that are too long.";
        return AST_TEST_NOT_RUN;
    case TEST_EXECUTE:
        break;
    }
 
    return off_nominal_test(test, records, ARRAY_LEN(records));
}

References ARRAY_LEN, AST_TEST_NOT_RUN, sip_to_pjsip::info(), off_nominal_test(), records, TEST_EXECUTE, and TEST_INIT.

generate_naptr_record()

static int generate_naptr_record ( void *  dns_record, char *  buf  )

static

Given a NAPTR record, generate a binary form, as would appear in DNS RDATA.

This is part of a DNS answer, specific to NAPTR. It consists of all parts of the NAPTR record, encoded as it should be in a DNS record.

There is no buffer size passed to this function since we provide the data ourselves and have sized the buffer to be way larger than necessary for the tests.

Parameters

dns_record	The NAPTR record to encode
buf	The buffer to write the record into

Returns

The number of bytes written to the buffer

Definition at line 58 of file test_dns_naptr.c.

{
    struct naptr_record *record = dns_record;
    uint16_t net_order = htons(record->order);
    uint16_t net_preference = htons(record->preference);
    char *ptr = buf;
 
    memcpy(ptr, &net_order, sizeof(net_order));
    ptr += sizeof(net_order);
 
    memcpy(ptr, &net_preference, sizeof(net_preference));
    ptr += sizeof(net_preference);
 
    ptr += ast_dns_test_write_string(&record->flags, ptr);
    ptr += ast_dns_test_write_string(&record->services, ptr);
    ptr += ast_dns_test_write_string(&record->regexp, ptr);
    ptr += ast_dns_test_write_domain(record->replacement, ptr);
 
    return ptr - buf;
}

References ast_dns_test_write_domain(), ast_dns_test_write_string(), buf, naptr_record::flags, naptr_record::order, naptr_record::preference, naptr_record::regexp, naptr_record::replacement, and naptr_record::services.

Referenced by naptr_thread().

load_module()

static int load_module ( void  )

static

Definition at line 490 of file test_dns_naptr.c.

{
    AST_TEST_REGISTER(naptr_resolve_nominal);
    AST_TEST_REGISTER(naptr_resolve_off_nominal_length);
    AST_TEST_REGISTER(naptr_resolve_off_nominal_flags);
    AST_TEST_REGISTER(naptr_resolve_off_nominal_services);
    AST_TEST_REGISTER(naptr_resolve_off_nominal_regexp);
    AST_TEST_REGISTER(naptr_resolve_off_nominal_interactions);
 
    return AST_MODULE_LOAD_SUCCESS;
}

References AST_MODULE_LOAD_SUCCESS, and AST_TEST_REGISTER.

naptr_cancel()

static int naptr_cancel ( struct ast_dns_query *  query )

static

A STUB.

Definition at line 150 of file test_dns_naptr.c.

{
    return 0;
}

naptr_resolve()

static int naptr_resolve ( struct ast_dns_query *  query )

static

Mock NAPTR resolution method.

This spawns a thread to handle generation of the necessary NAPTR records

Definition at line 140 of file test_dns_naptr.c.

{
    pthread_t thread;
 
    return ast_pthread_create_detached(&thread, NULL, naptr_thread, ao2_bump(query));
}

References ao2_bump, ast_pthread_create_detached, naptr_thread(), NULL, and thread.

naptr_thread()

static void * naptr_thread ( void *  dns_query )

static

Asynchronous NAPTR resolution thread.

This builds an appropriate DNS response based on the NAPTR records for a given test. Once the records have been created, the records are added to the DNS result

Definition at line 110 of file test_dns_naptr.c.

{
    struct ast_dns_query *query = dns_query;
    int i;
    int ans_size;
 
    ans_size = ast_dns_test_generate_result(query, test_records, num_test_records,
            sizeof(struct naptr_record), generate_naptr_record, ans_buffer);
 
    ast_dns_resolver_set_result(query, 0, 0, NOERROR, "goose.feathers", ans_buffer, ans_size);
 
    for (i = 0; i < num_test_records; ++i) {
        char record[128];
        int naptr_size;
 
        naptr_size = generate_naptr_record(&test_records[i], record);
        ast_dns_resolver_add_record(query, T_NAPTR, C_IN, 12345, record, naptr_size);
    }
 
    ast_dns_resolver_completed(query);
 
    ao2_ref(query, -1);
    return NULL;
}

References ans_buffer, ao2_ref, ast_dns_resolver_add_record(), ast_dns_resolver_completed(), ast_dns_resolver_set_result(), ast_dns_test_generate_result(), generate_naptr_record(), NULL, num_test_records, and test_records.

Referenced by naptr_resolve().

off_nominal_test()

static enum ast_test_result_state off_nominal_test ( struct ast_test *  test, struct naptr_record *  records, int  num_records  )

static

Definition at line 275 of file test_dns_naptr.c.

{
    RAII_VAR(struct ast_dns_result *, result, NULL, ast_dns_result_free);
    enum ast_test_result_state res = AST_TEST_PASS;
    const struct ast_dns_record *record;
 
    test_records = records;
    num_test_records = num_records;
    memset(ans_buffer, 0, sizeof(ans_buffer));
 
    ast_dns_resolver_register(&naptr_resolver);
 
    if (ast_dns_resolve("goose.feathers", T_NAPTR, C_IN, &result)) {
        ast_test_status_update(test, "Failed to perform DNS resolution, despite using valid inputs\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    if (!result) {
        ast_test_status_update(test, "Synchronous DNS resolution failed to set a result\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
    record = ast_dns_result_get_records(result);
    if (record) {
        ast_test_status_update(test, "DNS resolution returned records when it was not expected to\n");
        res = AST_TEST_FAIL;
        goto cleanup;
    }
 
cleanup:
    ast_dns_resolver_unregister(&naptr_resolver);
 
    test_records = NULL;
    num_test_records = 0;
    memset(ans_buffer, 0, sizeof(ans_buffer));
 
    return res;
}

References ans_buffer, 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_PASS, ast_test_status_update, cleanup(), naptr_resolver, NULL, num_test_records, RAII_VAR, records, result, and test_records.

Referenced by AST_TEST_DEFINE().

unload_module()

static int unload_module ( void  )

static

Definition at line 478 of file test_dns_naptr.c.

{
    AST_TEST_UNREGISTER(naptr_resolve_nominal);
    AST_TEST_UNREGISTER(naptr_resolve_off_nominal_length);
    AST_TEST_UNREGISTER(naptr_resolve_off_nominal_flags);
    AST_TEST_UNREGISTER(naptr_resolve_off_nominal_services);
    AST_TEST_UNREGISTER(naptr_resolve_off_nominal_regexp);
    AST_TEST_UNREGISTER(naptr_resolve_off_nominal_interactions);
 
    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 502 of file test_dns_naptr.c.

ans_buffer

char ans_buffer[1024]

static

A buffer to place raw DNS records into.

This buffer is way larger than any DNS records we actually wish to create during any of the tests, but that's fine.

Definition at line 101 of file test_dns_naptr.c.

Referenced by AST_TEST_DEFINE(), naptr_thread(), and off_nominal_test().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 502 of file test_dns_naptr.c.

naptr_resolver

struct ast_dns_resolver naptr_resolver

static

Mock NAPTR resolver.

Definition at line 158 of file test_dns_naptr.c.

Referenced by AST_TEST_DEFINE(), and off_nominal_test().

num_test_records

int num_test_records

static

The number of records in the test_records array.

Each test must set this to the appropriate value at the beginning of the test and must set this back to zero at the end of the test.

Definition at line 94 of file test_dns_naptr.c.

Referenced by AST_TEST_DEFINE(), naptr_thread(), and off_nominal_test().

test_records

struct naptr_record* test_records

static

A pointer to an array of records for a test.

Each test is expected to set this pointer to its local array of records and then re-set tis pointer to NULL at the end of the test

Definition at line 86 of file test_dns_naptr.c.

Referenced by AST_TEST_DEFINE(), naptr_thread(), and off_nominal_test().