dns_fixedname_init(&fname);
result = dns_db_find(gdb, name, gversion, dns_rdatatype_dnskey, options,
- 0, NULL, dns_fixedname_name(&fname), NULL, NULL);
+ 0, dns_fixedname_name(&fname), NULL, NULL);
switch (result) {
case ISC_R_SUCCESS:
case DNS_R_NXDOMAIN:
name = dns_fixedname_initname(&fname);
dns_rdataset_init(&soaset);
result = dns_db_find(gdb, gorigin, gversion, dns_rdatatype_soa, 0, 0,
- NULL, name, &soaset, NULL);
+ name, &soaset, NULL);
if (result != ISC_R_SUCCESS) {
fatal("failed to find an SOA at the zone apex: %s",
isc_result_totext(result));
REQUIRE(VALID_SAMPLEDB(sampledb));
- return dns__db_find(sampledb->db, name, version, type, options, now,
- nodep, foundname, methods, clientinfo, rdataset,
- sigrdataset DNS__DB_FLARG_PASS);
+ if (sampledb->db->methods->find == NULL) {
+ return ISC_R_NOTIMPLEMENTED;
+ }
+
+ return (sampledb->db->methods->find)(sampledb->db, name, version, type,
+ options, now, nodep, foundname,
+ methods, clientinfo, rdataset,
+ sigrdataset DNS__DB_FLARG_PASS);
}
static isc_result_t
result = dns_view_find(adb->view, adbname->name, rdtype, now, options,
true,
(adbname->type & DNS_ADBFIND_STARTATZONE) != 0,
- NULL, NULL, fname, &rdataset, NULL);
+ NULL, fname, &rdataset, NULL);
switch (result) {
case DNS_R_GLUE:
}
result = dns_view_find(rctx->view, name, type, 0, 0, false, false, dbp,
- NULL, foundname, rctx->rdataset, rctx->sigrdataset);
+ foundname, rctx->rdataset, rctx->sigrdataset);
return result;
}
if (node == NULL) {
INSIST(db != NULL);
- tresult = dns_db_findnode(db, fname, false, &node);
+ tresult = dns_db_findnode(db, fname, false,
+ &node);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
+ putrdataset(mctx, &rctx->rdataset);
+ if (rctx->sigrdataset != NULL) {
+ putrdataset(mctx,
+ &rctx->sigrdataset);
+ }
goto done;
}
}
isc_result_t
dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
- dns_dbnode_t **nodep, dns_name_t *foundname,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
- dns_rdataset_t *rdataset,
+ dns_name_t *foundname, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
/*
* Find the best match for 'name' and 'type' in version 'version'
REQUIRE(DNS_DB_VALID(db));
REQUIRE(type != dns_rdatatype_rrsig);
- REQUIRE(nodep == NULL || *nodep == NULL);
REQUIRE(dns_name_hasbuffer(foundname));
REQUIRE(rdataset == NULL || (DNS_RDATASET_VALID(rdataset) &&
!dns_rdataset_isassociated(rdataset)));
if (db->methods->find != NULL) {
return (db->methods->find)(db, name, version, type, options,
- now, nodep, foundname, methods,
+ now, NULL, foundname, methods,
clientinfo, rdataset,
sigrdataset DNS__DB_FLARG_PASS);
}
* implementation used.
*/
-#define dns_db_find(db, name, version, type, options, now, nodep, foundname, \
- rdataset, sigrdataset) \
- dns__db_find(db, name, version, type, options, now, nodep, foundname, \
- NULL, NULL, rdataset, sigrdataset DNS__DB_FILELINE)
-#define dns_db_findext(db, name, version, type, options, now, nodep, \
- foundname, methods, clientinfo, rdataset, sigrdataset) \
- dns__db_find(db, name, version, type, options, now, nodep, foundname, \
- methods, clientinfo, rdataset, \
+#define dns_db_find(db, name, version, type, options, now, foundname, \
+ rdataset, sigrdataset) \
+ dns__db_find(db, name, version, type, options, now, foundname, NULL, \
+ NULL, rdataset, sigrdataset DNS__DB_FILELINE)
+#define dns_db_findext(db, name, version, type, options, now, foundname, \
+ methods, clientinfo, rdataset, sigrdataset) \
+ dns__db_find(db, name, version, type, options, now, foundname, \
+ methods, clientinfo, rdataset, \
sigrdataset DNS__DB_FILELINE)
isc_result_t
dns__db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
- dns_dbnode_t **nodep, dns_name_t *foundname,
- dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
- dns_rdataset_t *rdataset,
+ dns_name_t *foundname, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG);
/*%<
* Find the best match for 'name' and 'type' in version 'version' of 'db'.
*
* \li 'type' is not SIG, or a meta-RR type other than 'ANY' (e.g. 'OPT').
*
- * \li 'nodep' is NULL, or nodep is a valid pointer and *nodep == NULL.
- *
* \li 'foundname' is a valid name with a dedicated buffer.
*
* \li 'rdataset' is NULL, or is a valid unassociated rdataset.
* Ensures,
* on a non-error completion:
*
- * \li If nodep != NULL, then it is bound to the found node.
- *
* \li If foundname != NULL, then it contains the full name of the
* found node.
*
* \li If 'version' is NULL, then the current version will be used.
*
* \li Care must be used when using this routine to build a DNS response:
- * 'node' should have been found with dns_db_find(), not
- * dns_db_findnode(). No glue checking is done. No checking for
- * pending data is done.
+ * 'node' should correspond to an owner name already found with
+ * dns_db_find(). No glue checking is done. No checking for pending
+ * data is done.
*
* \li The 'now' field is ignored if 'db' is a zone database. If 'db' is a
* cache database, an rdataset will not be found unless it expires after
isc_result_t
dns_view_find(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options, bool use_hints,
- bool use_static_stub, dns_db_t **dbp, dns_dbnode_t **nodep,
- dns_name_t *foundname, dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset);
+ bool use_static_stub, dns_db_t **dbp, dns_name_t *foundname,
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
/*%<
* Find an rdataset whose owner name is 'name', and whose type is
* 'type'.
*
*\li dbp == NULL || *dbp == NULL
*
- *\li nodep == NULL || *nodep == NULL. If nodep != NULL, dbp != NULL.
- *
*\li 'foundname' is a valid name with a dedicated buffer or NULL.
*
*\li 'rdataset' is a valid, disassociated rdataset.
*
*\li If dbp != NULL, it points to the database containing the data.
*
- *\li If nodep != NULL, it points to the database node containing the data.
- *
*\li If foundname != NULL, it contains the full name of the found data.
*
* Returns:
result = dns_db_find(db, name, ver, dns_rdatatype_any,
DNS_DBFIND_GLUEOK | DNS_DBFIND_NOWILD,
- (isc_stdtime_t)0, NULL,
- dns_fixedname_name(&foundname), NULL, NULL);
+ (isc_stdtime_t)0, dns_fixedname_name(&foundname),
+ NULL, NULL);
if (result == DNS_R_EMPTYNAME || result == ISC_R_SUCCESS ||
result == DNS_R_ZONECUT)
{
* try with an additional label prepended.
*/
result = dns_db_find(fctx->cache, &name, NULL,
- dns_rdatatype_ns, 0, 0, NULL,
- fname, &rdataset, NULL);
+ dns_rdatatype_ns, 0, 0, fname,
+ &rdataset, NULL);
dns_rdataset_cleanup(&rdataset);
switch (result) {
case ISC_R_SUCCESS:
dns_rdataset_init(&rootns);
(void)dns_db_find(db, dns_rootname, NULL, dns_rdatatype_ns, 0, now,
- NULL, name, &rootns, NULL);
+ name, &rootns, NULL);
CHECK(dns_db_createiterator(db, 0, &dbiter));
DNS_DBITERATOR_FOREACH(dbiter) {
CHECK(dns_dbiterator_current(dbiter, &node, name));
dns_fixedname_init(&fixed);
result = dns_db_find(db, name, ver, type, DNS_DBFIND_NOWILD,
- (isc_stdtime_t)0, NULL, dns_fixedname_name(&fixed),
- NULL, NULL);
+ (isc_stdtime_t)0, dns_fixedname_name(&fixed), NULL,
+ NULL);
switch (result) {
case ISC_R_SUCCESS:
*visible = true;
dns_fixedname_init(&foundname);
result = dns_db_find(db, name, ver, dns_rdatatype_any,
DNS_DBFIND_GLUEOK | DNS_DBFIND_NOWILD,
- (isc_stdtime_t)0, NULL,
- dns_fixedname_name(&foundname), NULL, NULL);
+ (isc_stdtime_t)0, dns_fixedname_name(&foundname),
+ NULL, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_EMPTYNAME) {
*flag = true;
*cut = false;
* is a DS RRset.
*/
if (dns_db_find(db, name, ver, dns_rdatatype_ds, 0,
- (isc_stdtime_t)0, NULL,
+ (isc_stdtime_t)0,
dns_fixedname_name(&foundname), NULL,
NULL) == DNS_R_NXRRSET)
{
found = dns_fixedname_initname(&ffound);
result = dns_db_find(
db, newname, ver, dns_rdatatype_soa,
- DNS_DBFIND_NOWILD, 0, NULL, found, NULL, NULL);
+ DNS_DBFIND_NOWILD, 0, found, NULL, NULL);
if (result == ISC_R_SUCCESS ||
result == DNS_R_EMPTYNAME ||
result == DNS_R_NXRRSET || result == DNS_R_CNAME ||
options = DNS_DBFIND_PENDINGOK;
foundname = dns_fixedname_initname(&fixedname);
result = dns_view_find(val->view, name, type, 0, options, false, false,
- NULL, NULL, foundname, &val->frdataset,
+ NULL, foundname, &val->frdataset,
&val->fsigrdataset);
if (result == DNS_R_NXDOMAIN) {
isc_result_t
dns_view_find(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options, bool use_hints,
- bool use_static_stub, dns_db_t **dbp, dns_dbnode_t **nodep,
- dns_name_t *foundname, dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset) {
+ bool use_static_stub, dns_db_t **dbp, dns_name_t *foundname,
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
isc_result_t result;
dns_db_t *db = NULL, *zdb = NULL;
- dns_dbnode_t *node = NULL, *znode = NULL;
bool is_cache, is_staticstub_zone;
dns_rdataset_t zrdataset, zsigrdataset;
dns_zone_t *zone = NULL;
REQUIRE(view->frozen);
REQUIRE(type != dns_rdatatype_rrsig);
REQUIRE(rdataset != NULL); /* XXXBEW - remove this */
- REQUIRE(nodep == NULL || *nodep == NULL);
/*
* Initialize.
/*
* Now look for an answer in the database.
*/
- result = dns_db_find(db, name, NULL, type, options, now, &node,
- foundname, rdataset, sigrdataset);
+ result = dns_db_find(db, name, NULL, type, options, now, foundname,
+ rdataset, sigrdataset);
if (result == DNS_R_DELEGATION || result == ISC_R_NOTFOUND) {
dns_rdataset_cleanup(rdataset);
dns_rdataset_cleanup(sigrdataset);
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
if (!is_cache) {
dns_db_detach(&db);
if (view->cachedb != NULL && !is_staticstub_zone) {
dns_db_detach(&db);
}
dns_db_attach(zdb, &db);
- dns_db_attachnode(znode, &node);
goto cleanup;
}
}
dns_rdataset_cleanup(rdataset);
dns_rdataset_cleanup(sigrdataset);
if (db != NULL) {
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
}
result = dns_db_find(view->rootdb, name, NULL, type, options,
- now, &node, foundname, rdataset,
- sigrdataset);
+ now, foundname, rdataset, sigrdataset);
if (result == ISC_R_SUCCESS || result == DNS_R_GLUE) {
/*
* Lazily rearm priming if the rootdb's
} else if (result == DNS_R_NXDOMAIN) {
result = ISC_R_NOTFOUND;
}
-
- /*
- * Cleanup if the rootdb lookup failed.
- */
- if (db == NULL && node != NULL) {
- dns_db_detachnode(&node);
- }
}
cleanup:
dns_rdataset_cleanup(&zsigrdataset);
if (zdb != NULL) {
- if (znode != NULL) {
- dns_db_detachnode(&znode);
- }
dns_db_detach(&zdb);
}
if (db != NULL) {
- if (node != NULL) {
- if (nodep != NULL) {
- *nodep = node;
- } else {
- dns_db_detachnode(&node);
- }
- }
if (dbp != NULL) {
*dbp = db;
} else {
dns_db_detach(&db);
}
- } else {
- INSIST(node == NULL);
}
if (zone != NULL) {
dns_fixedname_init(&foundname);
result = dns_view_find(view, name, type, now, options, use_hints, false,
- NULL, NULL, dns_fixedname_name(&foundname),
- rdataset, sigrdataset);
+ NULL, dns_fixedname_name(&foundname), rdataset,
+ sigrdataset);
if (result == DNS_R_NXDOMAIN) {
/*
* The rdataset and sigrdataset of the relevant NSEC record
}
result = dns_db_find(db, name, NULL, dns_rdatatype_ns, options, now,
- NULL, fname, rdataset, NULL);
+ fname, rdataset, NULL);
if (result != DNS_R_DELEGATION && result != ISC_R_SUCCESS) {
/*
* The zone exists, but there is no delegation. Here again
}
isc_result_t result = dns_db_find(view->rootdb, dns_rootname, NULL,
- dns_rdatatype_ns, 0, now, NULL, fname,
+ dns_rdatatype_ns, 0, now, fname,
rdataset, NULL);
if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(rdataset);
foundname = dns_fixedname_initname(&fixed);
- result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, NULL,
- foundname, NULL, NULL);
+ result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, foundname,
+ NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, NULL, dns_rdatatype_aaaa, 0, 0,
- NULL, foundname, NULL, NULL);
+ foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
}
foundname = dns_fixedname_initname(&fixed);
- result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, NULL,
- foundname, NULL, NULL);
+ result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, foundname,
+ NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, NULL, dns_rdatatype_aaaa, 0, 0,
- NULL, foundname, NULL, NULL);
+ foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
}
* Perform a regular lookup to catch DNAME records then look
* for glue.
*/
- result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, NULL,
- foundname, &a, NULL);
+ result = dns_db_find(db, name, NULL, dns_rdatatype_a, 0, 0, foundname,
+ &a, NULL);
switch (result) {
case ISC_R_SUCCESS:
case DNS_R_DNAME:
default:
dns_rdataset_cleanup(&a);
result = dns_db_find(db, name, NULL, dns_rdatatype_a,
- DNS_DBFIND_GLUEOK, 0, NULL, foundname, &a,
- NULL);
+ DNS_DBFIND_GLUEOK, 0, foundname, &a, NULL);
}
if (result == ISC_R_SUCCESS) {
SET_IF_NOT_NULL(has_a, true);
dns_rdataset_disassociate(&a);
if (has_aaaa != NULL && !*has_aaaa) {
result = dns_db_find(db, name, NULL, dns_rdatatype_aaaa,
- DNS_DBFIND_GLUEOK, 0, NULL,
- foundname, &aaaa, NULL);
+ DNS_DBFIND_GLUEOK, 0, foundname,
+ &aaaa, NULL);
if (result == ISC_R_SUCCESS) {
*has_aaaa = true;
}
result == DNS_R_GLUE)
{
tresult = dns_db_find(db, name, NULL, dns_rdatatype_aaaa,
- DNS_DBFIND_GLUEOK, 0, NULL, foundname,
- &aaaa, NULL);
+ DNS_DBFIND_GLUEOK, 0, foundname, &aaaa,
+ NULL);
if (tresult == ISC_R_SUCCESS) {
dns_rdataset_cleanup(&a);
SET_IF_NOT_NULL(has_aaaa, true);
}
dns_rdataset_init(&rdataset);
- result = dns_db_find(db, name, NULL, type, 0, 0, NULL, foundname,
- &rdataset, NULL);
+ result = dns_db_find(db, name, NULL, type, 0, 0, foundname, &rdataset,
+ NULL);
dns_rdataset_cleanup(&rdataset);
switch (result) {
case DNS_R_DELEGATION:
if (has_a) {
has_a = false;
result = dns_db_find(db, &zone->origin, NULL, dns_rdatatype_ns,
- 0, 0, NULL, name, &rdataset, NULL);
+ 0, 0, name, &rdataset, NULL);
if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(&rdataset);
goto cleanup;
if (has_aaaa) {
has_aaaa = false;
result = dns_db_find(db, &zone->origin, NULL, dns_rdatatype_ns,
- 0, 0, NULL, name, &rdataset, NULL);
+ 0, 0, name, &rdataset, NULL);
if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(&rdataset);
goto cleanup;
*/
dns_fixedname_init(&fname);
result = dns_db_find(db, keyname, ver, dns_rdatatype_keydata,
- DNS_DBFIND_NOWILD, 0, NULL,
- dns_fixedname_name(&fname), NULL, NULL);
+ DNS_DBFIND_NOWILD, 0, dns_fixedname_name(&fname),
+ NULL, NULL);
if (result == ISC_R_SUCCESS) {
return;
}
foundname = dns_fixedname_initname(&fixed);
- result = dns_db_find(db, name, version, dns_rdatatype_a, 0, 0, NULL,
+ result = dns_db_find(db, name, version, dns_rdatatype_a, 0, 0,
foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, name, version, dns_rdatatype_aaaa, 0,
- 0, NULL, foundname, NULL, NULL);
+ 0, foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
return true;
}
found = dns_fixedname_initname(&ffound);
result = dns_db_find(
db, name, version, dns_rdatatype_soa,
- DNS_DBFIND_NOWILD, 0, NULL, found, NULL, NULL);
+ DNS_DBFIND_NOWILD, 0, found, NULL, NULL);
if ((result == DNS_R_DELEGATION ||
result == DNS_R_DNAME) &&
!dns_name_equal(name, found))
found = dns_fixedname_initname(&ffound);
result = dns_db_find(
db, name, version, dns_rdatatype_soa,
- DNS_DBFIND_NOWILD, 0, NULL, found, NULL, NULL);
+ DNS_DBFIND_NOWILD, 0, found, NULL, NULL);
if ((result == DNS_R_DELEGATION ||
result == DNS_R_DNAME) &&
!dns_name_equal(name, found))
found = dns_fixedname_initname(&ffound);
result = dns_db_find(
db, name, version, dns_rdatatype_soa,
- DNS_DBFIND_NOWILD, 0, NULL, found, NULL, NULL);
+ DNS_DBFIND_NOWILD, 0, found, NULL, NULL);
if ((result == DNS_R_DELEGATION ||
result == DNS_R_DNAME) &&
!dns_name_equal(name, found))
* query_addwildcardproof()), then go to 15 to return NXDOMAIN to client.
*
* 11. Empty answer (query_nodata()). Add authority section records
- * (query_addsoa(), query_addwildcardproof()) and signatures if authoritative
- * (query_sign_nodata()) then go to 15 and return
+ * (query_addsoa(), query_addwildcardproof()) and signatures if
+ * authoritative (query_sign_nodata()) then go to 15 and return
* NOERROR/ANCOUNT=0 to client.
*
* 12. No such domain or empty answer returned from cache (query_ncache()).
*/
result = dns_db_findext(db, name, version, type,
client->query.dboptions, client->inner.now,
- NULL, fname, &cm, &ci, rdataset, sigrdataset);
+ fname, &cm, &ci, rdataset, sigrdataset);
if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(rdataset);
static isc_result_t
query_additionalauth(query_ctx_t *qctx, const dns_name_t *name,
dns_rdatatype_t type, dns_db_t **dbp, dns_name_t *fname,
- dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset) {
+ dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
ns_client_t *client = qctx->client;
ns_dbversion_t *dbversion = NULL;
dns_dbversion_t *version = NULL;
CTRACE(ISC_LOG_DEBUG(3), "query_additionalauth: same zone");
- result = query_additionalauthfind(db, version, name, type, client, fname,
- rdataset, sigrdataset);
+ result = query_additionalauthfind(db, version, name, type, client,
+ fname, rdataset, sigrdataset);
if (result != ISC_R_SUCCESS &&
qctx->view->minimalresponses == dns_minimal_no &&
client->query.recursionok)
CTRACE(ISC_LOG_DEBUG(3), "query_additionalauth: other zone");
- result = query_additionalauthfind(db, version, name, type, client,
- fname, rdataset, sigrdataset);
+ result = query_additionalauthfind(db, version, name, type,
+ client, fname, rdataset,
+ sigrdataset);
}
if (result != ISC_R_SUCCESS) {
result = dns_db_findext(db, name, version, type,
client->query.dboptions | DNS_DBFIND_GLUEOK |
DNS_DBFIND_ADDITIONALOK,
- client->inner.now, NULL, fname, &cm, &ci,
- rdataset, sigrdataset);
+ client->inner.now, fname, &cm, &ci, rdataset,
+ sigrdataset);
dns_cache_updatestats(qctx->view->cache, result);
if (!client->inner.wantdnssec) {
version = dbversion->version;
result = dns_db_findext(db, name, version, type,
client->query.dboptions | DNS_DBFIND_GLUEOK,
- client->inner.now, NULL, fname, &cm, &ci,
- rdataset, sigrdataset);
+ client->inner.now, fname, &cm, &ci, rdataset,
+ sigrdataset);
if (result != ISC_R_SUCCESS && result != DNS_R_ZONECUT &&
result != DNS_R_GLUE)
{
}
if (qtype == dns_rdatatype_a) {
- result = dns_db_findnodeext(db, foundname, false, &cm, &ci, &node);
- if (result != ISC_R_SUCCESS) {
- goto cleanup;
- }
+ CHECK(dns_db_findnodeext(db, foundname, false, &cm, &ci,
+ &node));
/*
* We now go looking for A and AAAA records, along with
dns_db_attach(qctx.client->inner.view->cachedb, &db);
(void)dns_db_findext(db, qctx.client->query.qname, NULL,
qctx.client->query.qtype, dboptions,
- qctx.client->inner.now, &qctx.node,
- qctx.fname, &cm, &ci, qctx.rdataset,
- qctx.sigrdataset);
- if (qctx.node != NULL) {
- dns_db_detachnode(&qctx.node);
- }
+ qctx.client->inner.now, qctx.fname, &cm,
+ &ci, qctx.rdataset, qctx.sigrdataset);
dns_db_detach(&db);
cleanup:
bool resuming) {
isc_result_t result;
dns_rpz_st_t *st = NULL;
- dns_dbnode_t *node = NULL;
dns_fixedname_t fixed;
dns_name_t *found = dns_fixedname_initname(&fixed);
dns_clientinfomethods_t cm;
dns_clientinfomethods_init(&cm, ns_client_sourceip);
dns_clientinfo_init(&ci, client, NULL);
result = dns_db_findext(*dbp, name, version, type, options,
- client->inner.now, &node, found, &cm, &ci,
- *rdatasetp, NULL);
+ client->inner.now, found, &cm, &ci, *rdatasetp,
+ NULL);
if (result == DNS_R_DELEGATION && is_zone && client->query.cacheok) {
/*
* Try the cache if we're authoritative for an
* nsip-wait-recurse or nsdname-wait-recurse are
* enabled.
*/
- rpz_clean(NULL, dbp, &node, rdatasetp);
+ rpz_clean(NULL, dbp, NULL, rdatasetp);
dns_db_attach(client->inner.view->cachedb, dbp);
result = dns_db_findext(*dbp, name, NULL, type, 0,
- client->inner.now, &node, found, &cm,
- &ci, *rdatasetp, NULL);
+ client->inner.now, found, &cm, &ci,
+ *rdatasetp, NULL);
if (result == ISC_R_NOTFOUND) {
result = DNS_R_DELEGATION;
}
} else if (result == ISC_R_NOTFOUND && !is_zone) {
result = DNS_R_DELEGATION;
}
- rpz_clean(NULL, dbp, &node, NULL);
+ rpz_clean(NULL, dbp, NULL, NULL);
if (result == DNS_R_DELEGATION) {
rpz_clean(NULL, NULL, NULL, rdatasetp);
/*
found = dns_fixedname_initname(&foundf);
result = dns_db_findext(*dbp, p_name, *versionp, dns_rdatatype_any, 0,
- client->inner.now, NULL, found, &cm, &ci,
- *rdatasetp, NULL);
+ client->inner.now, found, &cm, &ci, *rdatasetp,
+ NULL);
/*
* Choose the best rdataset if we found something.
*/
} else {
result = dns_db_findext(
*dbp, p_name, *versionp, qtype, 0,
- client->inner.now, NULL, found, &cm,
- &ci, *rdatasetp, NULL);
+ client->inner.now, found, &cm, &ci,
+ *rdatasetp, NULL);
/*
- * This fallback used to repopulate nodep via
- * dns_db_findext(). Preserve that contract so
- * rpz_save_p() can keep the node for later
- * pickup in query_checkrpz().
+ * Preserve the old contract by resolving the
+ * found owner to nodep here, so rpz_save_p()
+ * can keep the node for later pickup in
+ * query_checkrpz().
*/
if (result == ISC_R_SUCCESS ||
result == DNS_R_NXRRSET)
{
isc_result_t nresult;
- nresult = rpz_findnode(
- client, *dbp, found, rpz_type,
- &cm, &ci, nodep);
+ nresult = rpz_findnode(client, *dbp,
+ found, rpz_type,
+ &cm, &ci, nodep);
if (nresult != ISC_R_SUCCESS) {
return nresult;
}
dboptions = client->query.dboptions | DNS_DBFIND_FORCENSEC3;
result = dns_db_findext(db, dns_fixedname_name(&fixed), version,
dns_rdatatype_nsec3, dboptions,
- client->inner.now, NULL, fname, &cm, &ci,
- rdataset, sigrdataset);
+ client->inner.now, fname, &cm, &ci, rdataset,
+ sigrdataset);
if (result == DNS_R_NXDOMAIN) {
if (!dns_rdataset_isassociated(rdataset)) {
dns_name_t *foundname, dns_db_t **dbp, dns_dbversion_t **versionp,
dns_rdatatype_t qtype) {
dns_db_t *db = NULL;
- dns_dbnode_t *node = NULL;
dns_fixedname_t fixed;
dns_name_t *found = NULL;
dns_rdataset_t trdataset = DNS_RDATASET_INIT;
*/
result = dns_db_findext(db, client->query.qname, dbversion->version,
qtype, DNS_DBFIND_NOZONECUT, client->inner.now,
- &node, found, &cm, &ci, &trdataset, NULL);
+ found, &cm, &ci, &trdataset, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_NXRRSET ||
result == DNS_R_NCACHENXRRSET)
{
goto nxrrset;
} else if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(&trdataset);
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
return ISC_R_NOTFOUND;
}
nxrrset:
dns_db_detach(dbp);
dns_db_attach(db, dbp);
- dns_db_detachnode(&node);
dns_db_detach(&db);
*versionp = dbversion->version;
dns_name_t *foundname, dns_db_t **dbp, dns_dbversion_t **versionp,
dns_rdatatype_t qtype, bool *is_zonep) {
dns_db_t *db = NULL;
- dns_dbnode_t *node = NULL;
dns_fixedname_t fixed;
dns_fixedname_t fixedredirect;
dns_name_t *found = NULL, *redirectname = NULL;
* Lookup the requested data in the redirect zone.
*/
result = dns_db_findext(db, redirectname, version, qtype, 0,
- client->inner.now, &node, found, &cm, &ci,
- &trdataset, NULL);
+ client->inner.now, found, &cm, &ci, &trdataset,
+ NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_NXRRSET ||
result == DNS_R_NCACHENXRRSET)
{
* Cleanup.
*/
dns_rdataset_cleanup(&trdataset);
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
/*
return ISC_R_NOTFOUND;
} else if (result != ISC_R_SUCCESS) {
dns_rdataset_cleanup(&trdataset);
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
return ISC_R_NOTFOUND;
}
nxrrset:
dns_db_detach(dbp);
dns_db_attach(db, dbp);
- dns_db_detachnode(&node);
dns_db_detach(&db);
*is_zonep = is_zone;
*versionp = version;
unsigned int dboptions;
dns_ttl_t stale_refresh = 0;
bool dbfind_stale = false;
- bool find_node = qctx->type != dns_rdatatype_any;
bool found_via_wildcard = false;
bool stale_timeout = false;
bool answer_found = false;
foundname = dns_fixedname_initname(&qctx->foundname);
result = dns_db_findext(qctx->db, rpzqname, qctx->version, qctx->type,
- dboptions, qctx->client->inner.now,
- find_node ? &qctx->node : NULL,
- foundname, &cm, &ci, qctx->rdataset,
- qctx->sigrdataset);
+ dboptions, qctx->client->inner.now, foundname,
+ &cm, &ci, qctx->rdataset, qctx->sigrdataset);
found_via_wildcard = qctx_has_foundname(qctx) &&
foundname->attributes.wildcard;
qctx->rpz_st->q.result = result;
dns_fixedname_init(&qctx->rpz_st->q.foundname);
if (qctx_has_foundname(qctx)) {
- dns_name_copy(qctx_foundname(qctx),
- dns_fixedname_name(
- &qctx->rpz_st->q.foundname));
+ dns_name_copy(
+ qctx_foundname(qctx),
+ dns_fixedname_name(&qctx->rpz_st->q.foundname));
}
qctx->client->query.recursing = true;
return ISC_R_COMPLETE;
qctx->client->query.dns64_sigaaaa =
MOVE_OWNERSHIP(qctx->sigrdataset);
ns_client_releasename(qctx->client, &qctx->fname);
- dns_db_detachnode(&qctx->node);
+ if (qctx->node != NULL) {
+ dns_db_detachnode(&qctx->node);
+ }
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64_exclude = qctx->dns64 = true;
dns_db_attach(qctx->view->rootdb, &qctx->db);
result = dns_db_findext(
qctx->db, dns_rootname, NULL, dns_rdatatype_ns, 0,
- qctx->client->inner.now, &qctx->node, qctx->fname, &cm,
- &ci, qctx->rdataset, qctx->sigrdataset);
+ qctx->client->inner.now, qctx->fname, &cm, &ci,
+ qctx->rdataset, qctx->sigrdataset);
}
if (result != ISC_R_SUCCESS) {
/*
}
qctx->version = NULL;
- dns_db_detachnode(&qctx->node);
+ if (qctx->node != NULL) {
+ dns_db_detachnode(&qctx->node);
+ }
dns_db_detach(&qctx->db);
qctx->db = MOVE_OWNERSHIP(qctx->zdb);
qctx->node = MOVE_OWNERSHIP(qctx->znode);
*/
if (result == ISC_R_NOTFOUND) {
result = dns_db_findrdataset(
- qctx->db, node, qctx->version, dns_rdatatype_nsec,
- 0, client->inner.now, rdataset, sigrdataset);
+ qctx->db, node, qctx->version, dns_rdatatype_nsec, 0,
+ client->inner.now, rdataset, sigrdataset);
}
if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
goto addnsec3;
qctx->client->query.dns64_sigaaaa =
MOVE_OWNERSHIP(qctx->sigrdataset);
ns_client_releasename(qctx->client, &qctx->fname);
- dns_db_detachnode(&qctx->node);
+ if (qctx->node != NULL) {
+ dns_db_detachnode(&qctx->node);
+ }
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64 = true;
return query_lookup(qctx);
CCTRACE(ISC_LOG_DEBUG(3), "query_redirect");
foundname = dns_fixedname_initname(&fixed);
- result = redirect(qctx->client, qctx->fname, qctx->rdataset,
- foundname, &qctx->db, &qctx->version, qctx->type);
+ result = redirect(qctx->client, qctx->fname, qctx->rdataset, foundname,
+ &qctx->db, &qctx->version, qctx->type);
switch (result) {
case ISC_R_SUCCESS:
return query_redirect_resolved(qctx, foundname);
}
foundname = dns_fixedname_initname(&fixed);
- result = redirect2(qctx->client, qctx->fname, qctx->rdataset,
- foundname, &qctx->db, &qctx->version, qctx->type,
+ result = redirect2(qctx->client, qctx->fname, qctx->rdataset, foundname,
+ &qctx->db, &qctx->version, qctx->type,
&qctx->is_zone);
switch (result) {
case ISC_R_SUCCESS:
dns_db_t *db = NULL;
dns_clientinfo_t ci;
dns_clientinfomethods_t cm;
- dns_dbnode_t *node = NULL;
dns_fixedname_t fixed;
dns_fixedname_t fnamespace;
dns_fixedname_t fnowild;
dns_db_attach(qctx->db, &db);
CHECK(dns_db_findext(db, signer, qctx->version,
dns_rdatatype_soa, dboptions,
- qctx->client->inner.now, &node, fname, &cm,
- &ci, soardataset, sigsoardataset));
+ qctx->client->inner.now, fname, &cm, &ci,
+ soardataset, sigsoardataset));
if (soardataset->trust != dns_trust_secure ||
sigsoardataset->trust != dns_trust_secure)
dns_db_attach(qctx->db, &db);
result = dns_db_findext(db, wild, qctx->version, qctx->type,
dboptions | DNS_DBFIND_COVERINGNSEC,
- qctx->client->inner.now, &node, nowild, &cm,
- &ci, &rdataset, &sigrdataset);
+ qctx->client->inner.now, nowild, &cm, &ci,
+ &rdataset, &sigrdataset);
if (rdataset.trust != dns_trust_secure ||
sigrdataset.trust != dns_trust_secure)
goto cleanup;
}
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
-
soardataset = ns_client_newrdataset(qctx->client);
sigsoardataset = ns_client_newrdataset(qctx->client);
* Look for SOA record to construct NXDOMAIN response.
*/
CHECK(dns_db_findext(db, signer, qctx->version, dns_rdatatype_soa,
- dboptions, qctx->client->inner.now, &node, fname,
- &cm, &ci, soardataset, sigsoardataset));
+ dboptions, qctx->client->inner.now, fname, &cm,
+ &ci, soardataset, sigsoardataset));
if (soardataset->trust != dns_trust_secure ||
sigsoardataset->trust != dns_trust_secure)
ns_client_putrdataset(qctx->client, &sigsoardataset);
}
if (db != NULL) {
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
}
result = dns_db_findext(qctx->db, name, qctx->version,
dns_rdatatype_soa,
- client->query.dboptions, 0, &node,
- fname, &cm, &ci, rdataset, sigrdataset);
+ client->query.dboptions, 0, fname, &cm,
+ &ci, rdataset, sigrdataset);
}
if (result != ISC_R_SUCCESS) {
/*
} else {
CTRACE(ISC_LOG_DEBUG(3), "query_addns: calling dns_db_find");
result = dns_db_findext(qctx->db, name, NULL, dns_rdatatype_ns,
- client->query.dboptions, 0, &node,
- fname, &cm, &ci, rdataset, sigrdataset);
+ client->query.dboptions, 0, fname, &cm,
+ &ci, rdataset, sigrdataset);
CTRACE(ISC_LOG_DEBUG(3), "query_addns: dns_db_find complete");
}
if (result != ISC_R_SUCCESS) {
query_addbestns(query_ctx_t *qctx) {
ns_client_t *client = qctx->client;
dns_db_t *db = NULL, *zdb = NULL;
- dns_dbnode_t *node = NULL;
dns_name_t *fname = NULL, *zfname = NULL;
dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
dns_rdataset_t *zrdataset = NULL, *zsigrdataset = NULL;
if (is_zone) {
result = dns_db_findext(
db, client->query.qname, version, dns_rdatatype_ns,
- client->query.dboptions, client->inner.now, &node,
- fname, &cm, &ci, rdataset, sigrdataset);
+ client->query.dboptions, client->inner.now, fname, &cm,
+ &ci, rdataset, sigrdataset);
if (result != DNS_R_DELEGATION) {
goto cleanup;
}
if (client->query.cacheok) {
ns_client_keepname(client, fname, dbuf);
- dns_db_detachnode(&node);
zdb = MOVE_OWNERSHIP(db);
zfname = MOVE_OWNERSHIP(fname);
zrdataset = MOVE_OWNERSHIP(rdataset);
ns_client_putrdataset(client, &sigrdataset);
}
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
dns_db_detach(&db);
db = MOVE_OWNERSHIP(zdb);
if (fname != NULL) {
ns_client_releasename(client, &fname);
}
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
if (db != NULL) {
dns_db_detach(&db);
}
dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
dns_fixedname_t wfixed;
dns_name_t *wname;
- dns_dbnode_t *node = NULL;
unsigned int options;
unsigned int olabels, nlabels, labels;
isc_result_t result;
sigrdataset = ns_client_newrdataset(client);
result = dns_db_findext(qctx->db, name, qctx->version,
- dns_rdatatype_nsec, options, 0, &node, fname,
- &cm, &ci, rdataset, sigrdataset);
- if (node != NULL) {
- dns_db_detachnode(&node);
- }
+ dns_rdatatype_nsec, options, 0, fname, &cm, &ci,
+ rdataset, sigrdataset);
if (!dns_rdataset_isassociated(rdataset)) {
/*
}
result = dns_db_findext(qctx->db, cname, qctx->version,
dns_rdatatype_nsec, options, 0,
- NULL, fname, &cm, &ci, NULL,
- NULL);
+ fname, &cm, &ci, NULL, NULL);
if (result == DNS_R_NXDOMAIN) {
maxlabels = labels;
} else {
continue;
}
result = dns_db_find(db, &mx.mx, newver, dns_rdatatype_a, 0, 0,
- NULL, foundname, NULL, NULL);
+ foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
continue;
}
if (result == DNS_R_NXRRSET) {
result = dns_db_find(db, &mx.mx, newver,
- dns_rdatatype_aaaa, 0, 0, NULL,
+ dns_rdatatype_aaaa, 0, 0,
foundname, NULL, NULL);
if (result == ISC_R_SUCCESS) {
continue;
dns_rdataset_disassociate(&rdataset);
result = dns_db_find(db, example, NULL, dns_rdatatype_a, 0, 0,
- &node, found, &rdataset, NULL);
+ found, &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
/*
assert_int_in_range(count, 1, 21); /* loop sanity */
assert_int_equal(rdataset.attributes.stale, false);
assert_true(rdataset.ttl > 0);
- dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
usleep(100000); /* 100 ms */
result = dns_db_find(db, example, NULL, dns_rdatatype_a,
- 0, 0, &node, found, &rdataset,
- NULL);
+ 0, 0, found, &rdataset, NULL);
} while (result == ISC_R_SUCCESS);
assert_int_equal(result, ISC_R_NOTFOUND);
* Check whether we can get stale data.
*/
result = dns_db_find(db, example, NULL, dns_rdatatype_a,
- DNS_DBFIND_STALEOK, 0, &node, found,
- &rdataset, NULL);
+ DNS_DBFIND_STALEOK, 0, found, &rdataset,
+ NULL);
switch (pass) {
case 0:
assert_int_equal(result, ISC_R_NOTFOUND);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(rdataset.attributes.stale,
true);
- dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
usleep(100000); /* 100 ms */
- result = dns_db_find(
- db, example, NULL, dns_rdatatype_a,
- DNS_DBFIND_STALEOK, 0, &node, found,
- &rdataset, NULL);
+ result = dns_db_find(db, example, NULL,
+ dns_rdatatype_a,
+ DNS_DBFIND_STALEOK, 0,
+ found, &rdataset, NULL);
} while (result == ISC_R_SUCCESS);
/*
* usleep(100000) can be slightly less than 10ms so
name = dns_fixedname_name(&fname);
foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
- result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(&node);
dns_db_closeversion(db, &ver, false);
/* Open new version for writing */
name = dns_fixedname_name(&fname);
foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
- result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
+ assert_int_equal(result, ISC_R_SUCCESS);
+ result = dns_db_findnode(db, foundname, false, &node);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_newversion(db, &new);
dns_db_detachnode(&node);
/* This should fail now */
- result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
assert_int_equal(result, DNS_R_NXDOMAIN);
dns_db_closeversion(db, &new, true);
/* But this should still succeed */
- result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(&node);
/* Now we create a node with an empty parent */
result = dns_db_newversion(db, &new);
/* look up the ENT; it should be empty */
dns_test_namefromstring("ent.name.test.test.", &fname);
dns_db_detachnode(&node);
- result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
assert_int_equal(result, DNS_R_EMPTYNAME);
/* ... but then we roll it back... */
/* ... and the ENT should be NXDOMAIN now */
dns_test_namefromstring("ent.name.test.test.", &fname);
- result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, &node,
- foundname, &rdataset, NULL);
+ result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, foundname,
+ &rdataset, NULL);
assert_int_equal(result, DNS_R_NXDOMAIN);
dns_rdataset_cleanup(&rdataset);
name = dns_fixedname_initname(&fixed);
dns_rdataset_init(&rdataset);
- res = dns_db_find(db1, dns_rootname, v1, dns_rdatatype_soa, 0, 0, NULL,
- name, &rdataset, NULL);
+ res = dns_db_find(db1, dns_rootname, v1, dns_rdatatype_soa, 0, 0, name,
+ &rdataset, NULL);
/*
* Note: in the QPzone database, the root node always exists,
* even if it's empty, so we would get DNS_R_NXRRSET from this
dns_rdataset_init(&rdataset);
check_assertion((void)dns_db_find(db1, dns_rootname, v2,
- dns_rdatatype_soa, 0, 0, NULL, name,
+ dns_rdatatype_soa, 0, 0, name,
&rdataset, NULL));
}
foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, name, NULL, dns_rdatatype_hinfo,
- DNS_DBFIND_STALEOK, now, NULL, foundname,
- &rdataset, NULL);
+ DNS_DBFIND_STALEOK, now, foundname, &rdataset,
+ NULL);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(rdataset.type, dns_rdatatype_hinfo);
foundname = dns_fixedname_initname(&ffound);
dns_rdataset_init(&rdataset);
result = dns_db_find(db, name, NULL, dns_rdatatype_a,
- DNS_DBFIND_STALEOK, now, NULL, foundname,
- &rdataset, NULL);
+ DNS_DBFIND_STALEOK, now, foundname, &rdataset,
+ NULL);
assert_int_equal(result, DNS_R_CNAME);
assert_int_equal(rdataset.type, dns_rdatatype_cname);
const dns_name_t *name, unsigned char (*ips)[16],
ssize_t expected_count, uint32_t expected_ttl) {
isc_result_t result;
- dns_dbnode_t *node = NULL;
dns_rdataset_t rdataset;
bool *found_ips = NULL;
dns_fixedname_t found_fname;
dns_rdataset_init(&rdataset);
- result = dns_db_find(db, name, version, dns_rdatatype_aaaa, 0, 0, &node,
+ result = dns_db_find(db, name, version, dns_rdatatype_aaaa, 0, 0,
found_name, &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
/* Verify we found exactly the expected number of records */
assert_int_equal(found_count, expected_count);
- dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
isc_mem_cput(isc_g_mctx, found_ips, (size_t)expected_count,
sizeof(bool));
isc_result_t result;
dns_db_t *db = NULL;
dns_dbversion_t *version = NULL;
- dns_dbnode_t *node = NULL;
dns_fixedname_t fqname, fwild, ffound;
dns_name_t *qname = NULL, *wild = NULL, *found = NULL;
dns_rdataset_t rdataset;
dns_rdataset_init(&rdataset);
dns_db_currentversion(db, &version);
- result = dns_db_find(db, qname, version, dns_rdatatype_a, 0, 0, &node,
- found, &rdataset, NULL);
+ result = dns_db_find(db, qname, version, dns_rdatatype_a, 0, 0, found,
+ &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
assert_true(dns_name_equal(found, wild));
assert_true(found->attributes.wildcard);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(&node);
dns_db_closeversion(db, &version, false);
dns_db_detach(&db);
assert_null(db);
projects / thirdparty / bind9.git / commitdiff
