mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 10:10:06 +00:00
Code Issues Releases Wiki Activity
bind/tests/dns/dbiterator_test.c
Alessio Podda ae6a34cbda Decouple database and node lifetimes by adding node-specific vtables 
All databases in the codebase follow the same structure: a database is
an associative container from DNS names to nodes, and each node is an
associative container from RR types to RR data.

Each database implementation (qpzone, qpcache, sdlz, builtin, dyndb) has
its own corresponding node type (qpznode, qpcnode, etc). However, some
code needs to work with nodes generically regardless of their specific
type - for example, to acquire locks, manage references, or
register/unregister slabs from the heap.

Currently, these generic node operations are implemented as methods in
the database vtable, which creates problematic coupling between database
and node lifetimes. If a node outlives its parent database, the node
destructor will destroy all RR data, and each RR data destructor will
try to unregister from heaps by calling a virtual function from the
database vtable. Since the database was already freed, this causes a
crash.

This commit breaks the coupling by standardizing the layout of all
database nodes, adding a dedicated vtable for node operations, and
moving node-specific methods from the database vtable to the node
vtable.
2025-08-07 11:39:38 -07:00

383 lines
9.4 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 <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/lib.h>
#include <isc/util.h>
#include <dns/db.h>
#include <dns/dbiterator.h>
#include <dns/lib.h>
#include <dns/name.h>
#include <tests/dns.h>
#define BUFLEN 255
#define BIGBUFLEN (64 * 1024)
#define TEST_ORIGIN "test"
static isc_result_t
make_name(const char *src, dns_name_t *name) {
isc_buffer_t b;
isc_buffer_constinit(&b, src, strlen(src));
isc_buffer_add(&b, strlen(src));
return dns_name_fromtext(name, &b, dns_rootname, 0);
}
/* create: make sure we can create a dbiterator */
static void
test_create(const char *filename) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(create) {
UNUSED(state);
test_create(TESTS_DIR "/testdata/dbiterator/zone1.data");
}
ISC_RUN_TEST_IMPL(create_nsec3) {
UNUSED(state);
test_create(TESTS_DIR "/testdata/dbiterator/zone2.data");
}
/* walk: walk a database */
static void
test_walk(const char *filename, int flags, int nodes) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
dns_dbnode_t *node = NULL;
dns_name_t *name;
dns_fixedname_t f;
int i = 0;
name = dns_fixedname_initname(&f);
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, flags, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
DNS_DBITERATOR_FOREACH (iter) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detachnode(&node);
i++;
}
assert_int_equal(i, nodes);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(walk) {
UNUSED(state);
test_walk(TESTS_DIR "/testdata/dbiterator/zone1.data", 0, 12);
test_walk(TESTS_DIR "/testdata/dbiterator/zone1.data", DNS_DB_NONSEC3,
12);
test_walk(TESTS_DIR "/testdata/dbiterator/zone1.data", DNS_DB_NSEC3ONLY,
0);
}
ISC_RUN_TEST_IMPL(walk_nsec3) {
UNUSED(state);
test_walk(TESTS_DIR "/testdata/dbiterator/zone2.data", 0, 32);
test_walk(TESTS_DIR "/testdata/dbiterator/zone2.data", DNS_DB_NONSEC3,
12);
test_walk(TESTS_DIR "/testdata/dbiterator/zone2.data", DNS_DB_NSEC3ONLY,
20);
}
/* reverse: walk database backwards */
static void
test_reverse(const char *filename, int flags, int nodes) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
dns_dbnode_t *node = NULL;
dns_name_t *name;
dns_fixedname_t f;
int i = 0;
name = dns_fixedname_initname(&f);
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, flags, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
for (result = dns_dbiterator_last(iter); result == ISC_R_SUCCESS;
result = dns_dbiterator_prev(iter))
{
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detachnode(&node);
i++;
}
assert_int_equal(i, nodes);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(reverse) {
UNUSED(state);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone1.data", 0, 12);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone1.data",
DNS_DB_NONSEC3, 12);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone1.data",
DNS_DB_NSEC3ONLY, 0);
}
ISC_RUN_TEST_IMPL(reverse_nsec3) {
UNUSED(state);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone2.data", 0, 32);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone2.data",
DNS_DB_NONSEC3, 12);
test_reverse(TESTS_DIR "/testdata/dbiterator/zone2.data",
DNS_DB_NSEC3ONLY, 20);
}
/* seek: walk database starting at a particular node */
static void
test_seek_node(const char *filename, int flags, int nodes) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
dns_dbnode_t *node = NULL;
dns_name_t *name, *seekname;
dns_fixedname_t f1, f2;
int i = 0;
name = dns_fixedname_initname(&f1);
seekname = dns_fixedname_initname(&f2);
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, flags, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_name("c." TEST_ORIGIN, seekname);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dbiterator_seek(iter, seekname);
if (flags == DNS_DB_NSEC3ONLY) {
/* "c" isn't in the NSEC3 tree but the origin node is */
assert_int_equal(result, DNS_R_PARTIALMATCH);
} else {
assert_int_equal(result, ISC_R_SUCCESS);
}
while (result == ISC_R_SUCCESS) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detachnode(&node);
result = dns_dbiterator_next(iter);
i++;
}
assert_int_equal(i, nodes);
/* now reset the iterator and walk backwards */
i = 0;
result = dns_dbiterator_seek(iter, seekname);
if (flags == DNS_DB_NSEC3ONLY) {
/* "c" isn't in the NSEC3 tree but the origin node is */
assert_int_equal(result, DNS_R_PARTIALMATCH);
nodes = 0;
} else {
assert_int_equal(result, ISC_R_SUCCESS);
nodes = 4;
}
while (result == ISC_R_SUCCESS) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detachnode(&node);
result = dns_dbiterator_prev(iter);
i++;
}
assert_int_equal(i, nodes);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(seek_node) {
UNUSED(state);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone1.data", 0, 9);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone1.data",
DNS_DB_NONSEC3, 9);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone1.data",
DNS_DB_NSEC3ONLY, 0);
}
ISC_RUN_TEST_IMPL(seek_node_nsec3) {
UNUSED(state);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone2.data", 0, 29);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone2.data",
DNS_DB_NONSEC3, 9);
test_seek_node(TESTS_DIR "/testdata/dbiterator/zone2.data",
DNS_DB_NSEC3ONLY, 0);
}
/*
* seek_emty: walk database starting at an empty nonterminal node
* (should fail)
*/
static void
test_seek_empty(const char *filename) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
dns_name_t *seekname;
dns_fixedname_t f1;
seekname = dns_fixedname_initname(&f1);
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_name("d." TEST_ORIGIN, seekname);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dbiterator_seek(iter, seekname);
assert_int_equal(result, DNS_R_PARTIALMATCH);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(seek_empty) {
UNUSED(state);
test_seek_empty(TESTS_DIR "/testdata/dbiterator/zone1.data");
}
ISC_RUN_TEST_IMPL(seek_empty_nsec3) {
UNUSED(state);
test_seek_empty(TESTS_DIR "/testdata/dbiterator/zone2.data");
}
/*
* seek_nx: walk database starting at a nonexistent node
*/
static void
test_seek_nx(const char *filename) {
isc_result_t result;
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
dns_name_t *seekname;
dns_fixedname_t f1;
seekname = dns_fixedname_initname(&f1);
result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_name("nonexistent." TEST_ORIGIN, seekname);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dbiterator_seek(iter, seekname);
assert_int_equal(result, DNS_R_PARTIALMATCH);
result = make_name("nonexistent.", seekname);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dbiterator_seek(iter, seekname);
assert_int_equal(result, ISC_R_NOTFOUND);
dns_dbiterator_destroy(&iter);
dns_db_detach(&db);
}
ISC_RUN_TEST_IMPL(seek_nx) {
UNUSED(state);
test_seek_nx(TESTS_DIR "/testdata/dbiterator/zone1.data");
}
ISC_RUN_TEST_IMPL(seek_nx_nsec3) {
UNUSED(state);
test_seek_nx(TESTS_DIR "/testdata/dbiterator/zone2.data");
}
/*
* XXX:
* dns_dbiterator API calls that are not yet part of this unit test:
*
* dns_dbiterator_pause
* dns_dbiterator_origin
* dns_dbiterator_setcleanmode
*/
ISC_TEST_LIST_START
ISC_TEST_ENTRY(create)
ISC_TEST_ENTRY(create_nsec3)
ISC_TEST_ENTRY(walk)
ISC_TEST_ENTRY(walk_nsec3)
ISC_TEST_ENTRY(reverse)
ISC_TEST_ENTRY(reverse_nsec3)
ISC_TEST_ENTRY(seek_node)
ISC_TEST_ENTRY(seek_node_nsec3)
ISC_TEST_ENTRY(seek_empty)
ISC_TEST_ENTRY(seek_empty_nsec3)
ISC_TEST_ENTRY(seek_nx)
ISC_TEST_ENTRY(seek_nx_nsec3)
ISC_TEST_LIST_END
ISC_TEST_MAIN
Reference in New Issue View Git Blame Copy Permalink