ComputerSurge/bind9
3
0
Fork 0
Code Pull Requests 1 Activity
Files
7860b6519dcb862629ba37305cc55f12b7974ce0
bind9/tests/dns/badcache_test.c
Ondřej Surý 7860b6519d Allow TTL skew in the badcache print unit test 
If the machine running the job is extra loaded (or extra slow), the
print test in the badcache unit test would fail because the TTL would be
59 (possibly even lower) and the test expects the badcache.out to only
have TTL 60.  Refactor the test to check for the expected strings and
check whether the TTL is in the expected range.
2024-08-20 15:55:35 +02:00

359 lines
11 KiB
C
Raw Blame History

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <inttypes.h>
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/buffer.h>
#include <isc/commandline.h>
#include <isc/md.h>
#include <isc/mem.h>
#include <isc/os.h>
#include <isc/thread.h>
#include <isc/urcu.h>
#include <isc/util.h>
#include <isc/uv.h>
#include <dns/badcache.h>
#include <dns/compress.h>
#include <dns/fixedname.h>
#include <dns/name.h>
#include <dns/rdatatype.h>
#include <tests/dns.h>
#define BADCACHE_TEST_FLAG 1 << 3
ISC_LOOP_TEST_IMPL(basic) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
flags = 0;
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
flags = 0;
result = dns_badcache_find(bc, name, dns_rdatatype_a, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_int_equal(flags, 0);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(expire) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
dns_badcache_add(bc, name, dns_rdatatype_a, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now + 61);
assert_int_equal(result, ISC_R_NOTFOUND);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
result = dns_badcache_find(bc, name, dns_rdatatype_a, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_badcache_add(bc, name, dns_rdatatype_a, true, flags, now + 120);
result = dns_badcache_find(bc, name, dns_rdatatype_a, &flags, now + 61);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(print) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_stdtime_t expire = now + 60;
uint32_t flags = BADCACHE_TEST_FLAG;
FILE *file = NULL;
char buf[4096];
size_t len;
char *pos;
char *endptr;
const char *part1 = ";\n; badcache\n;\n; example.com/A [ttl ";
const char *part2 = "]\n; example.com/AAAA [ttl ";
const char *part3 = "]\n";
long ttl;
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_a, false, flags, expire);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, expire);
file = fopen("./badcache.out", "w");
dns_badcache_print(bc, "badcache", file);
fclose(file);
file = fopen("./badcache.out", "r");
len = fread(buf, sizeof(buf[0]), ARRAY_SIZE(buf), file);
assert_int_equal(len, 68);
fclose(file);
pos = buf;
assert_memory_equal(pos, part1, strlen(part1));
pos += strlen(part1);
ttl = strtol(pos, &endptr, 0);
assert_ptr_not_equal(pos, endptr);
assert_true(ttl >= 0 && ttl <= 60);
pos = endptr;
assert_memory_equal(pos, part2, strlen(part2));
pos += strlen(part2);
ttl = strtol(pos, &endptr, 0);
assert_ptr_not_equal(pos, endptr);
assert_true(ttl >= 0 && ttl <= 60);
pos = endptr;
assert_memory_equal(pos, part3, strlen(part3));
pos += strlen(part3);
assert_int_equal(pos - buf, len);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(flush) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
bc = dns_badcache_new(mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_badcache_flush(bc);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(flushname) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
dns_badcache_flushname(bc, name);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
result = dns_badcache_find(bc, name, dns_rdatatype_a, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(flushtree) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
dns_badcache_flushtree(bc, name);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(flags, BADCACHE_TEST_FLAG);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_LOOP_TEST_IMPL(purge) {
dns_badcache_t *bc = NULL;
dns_fixedname_t fname = { 0 };
dns_name_t *name = dns_fixedname_initname(&fname);
isc_stdtime_t now = isc_stdtime_now();
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
bc = dns_badcache_new(mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now - 60);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now - 60);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, false, flags, now);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now - 60);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now + 30);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "sub.sub.example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now + 30);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "sub.example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now + 30);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags,
now + 30);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_badcache_destroy(&bc);
isc_loopmgr_shutdown(loopmgr);
}
ISC_TEST_LIST_START
ISC_TEST_ENTRY_CUSTOM(basic, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(expire, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(print, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(flush, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(flushname, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(flushtree, setup_managers, teardown_managers)
ISC_TEST_ENTRY_CUSTOM(purge, setup_managers, teardown_managers)
ISC_TEST_LIST_END
ISC_TEST_MAIN
View Git Blame Copy Permalink