upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-04-22 14:49:20 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

switch to ISC_LIST_FOREACH everywhere

Browse source 
the pattern `for (x = ISC_LIST_HEAD(...); x != NULL; ISC_LIST_NEXT(...)`
has been changed to `ISC_LIST_FOREACH` throughout BIND, except in a few
cases where the change would be excessively complex.

in most cases this was a straightforward change. in some places,
however, the list element variable was referenced after the loop
ended, and the code was refactored to avoid this necessity.

also, because `ISC_LIST_FOREACH` uses typeof(list.head) to declare
the list elements, compilation failures can occur if the list object
has a `const` qualifier.  some `const` qualifiers have been removed
from function parameters to avoid this problem, and where that was not
possible, `UNCONST` was used.
This commit is contained in:
Evan Hunt 2025-03-20 22:25:56 -07:00
parent 5cff8f9017
commit 522ca7bb54
66 changed files with 766 additions and 1786 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
bin/delv/delv.c
View file

@ -974,8 +974,7 @@ static isc_result_t
findserver(dns_client_t *client) {
isc_result_t result;
irs_resconf_t *resconf = NULL;
isc_sockaddrlist_t *nameservers;
isc_sockaddr_t *sa = NULL, *next = NULL;
isc_sockaddrlist_t *nameservers = NULL;
result = irs_resconf_load(mctx, "/etc/resolv.conf", &resconf);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
@ -986,9 +985,7 @@ findserver(dns_client_t *client) {
/* Get nameservers from resolv.conf */
nameservers = irs_resconf_getnameservers(resconf);
for (sa = ISC_LIST_HEAD(*nameservers); sa != NULL; sa = next) {
next = ISC_LIST_NEXT(sa, link);
ISC_LIST_FOREACH_SAFE (*nameservers, sa, link) {
/* Set destination port */
if (sa->type.sa.sa_family == AF_INET && use_ipv4) {
sa->type.sin.sin_port = htons(destport);
@ -1009,7 +1006,7 @@ findserver(dns_client_t *client) {
if (use_ipv4) {
struct in_addr localhost;
localhost.s_addr = htonl(INADDR_LOOPBACK);
sa = isc_mem_get(mctx, sizeof(*sa));
isc_sockaddr_t *sa = isc_mem_get(mctx, sizeof(*sa));
isc_sockaddr_fromin(sa, &localhost, destport);
ISC_LINK_INIT(sa, link);
@ -1017,7 +1014,7 @@ findserver(dns_client_t *client) {
}
if (use_ipv6) {
sa = isc_mem_get(mctx, sizeof(*sa));
isc_sockaddr_t *sa = isc_mem_get(mctx, sizeof(*sa));
isc_sockaddr_fromin6(sa, &in6addr_loopback, destport);
ISC_LINK_INIT(sa, link);
@ -1855,10 +1852,7 @@ resolve_cb(dns_client_t *client, const dns_name_t *query_name,
}
ISC_LIST_FOREACH (*namelist, response_name, link) {
for (dns_rdataset_t *rdataset =
ISC_LIST_HEAD(response_name->list);
rdataset != NULL; rdataset = ISC_LIST_NEXT(rdataset, link))
{
ISC_LIST_FOREACH (response_name->list, rdataset, link) {
printdata(rdataset, response_name);
}
}

43
bin/dig/dighost.c
View file

@ -463,19 +463,14 @@ make_server(const char *servname, const char *userarg) {
*/
static void
get_server_list(irs_resconf_t *resconf) {
isc_sockaddrlist_t *servers;
isc_sockaddr_t *sa;
dig_server_t *newsrv;
char tmp[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255") +
sizeof("%4000000000")];
debug("get_server_list()");
servers = irs_resconf_getnameservers(resconf);
for (sa = ISC_LIST_HEAD(*servers); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
isc_sockaddrlist_t *servers = irs_resconf_getnameservers(resconf);
ISC_LIST_FOREACH (*servers, sa, link) {
int pf = isc_sockaddr_pf(sa);
isc_netaddr_t na;
char tmp[ISC_NETADDR_FORMATSIZE];
isc_result_t result;
isc_netaddr_t na;
isc_buffer_t b;
if (pf == AF_INET && !have_ipv4) {
@ -497,7 +492,8 @@ get_server_list(irs_resconf_t *resconf) {
snprintf(buf, sizeof(buf), "%%%u", na.zone);
strlcat(tmp, buf, sizeof(tmp));
}
newsrv = make_server(tmp, tmp);
dig_server_t *newsrv = make_server(tmp, tmp);
ISC_LINK_INIT(newsrv, link);
ISC_LIST_APPEND(server_list, newsrv, link);
}
@ -1221,18 +1217,12 @@ clear_searchlist(void) {
static void
create_search_list(irs_resconf_t *resconf) {
irs_resconf_searchlist_t *list;
irs_resconf_search_t *entry;
dig_searchlist_t *search;
debug("create_search_list()");
clear_searchlist();
list = irs_resconf_getsearchlist(resconf);
for (entry = ISC_LIST_HEAD(*list); entry != NULL;
entry = ISC_LIST_NEXT(entry, link))
{
search = make_searchlist_entry(entry->domain);
irs_resconf_searchlist_t *list = irs_resconf_getsearchlist(resconf);
ISC_LIST_FOREACH (*list, entry, link) {
dig_searchlist_t *search = make_searchlist_entry(entry->domain);
ISC_LIST_APPEND(search_list, search, link);
}
}
@ -2168,8 +2158,6 @@ bool
setup_lookup(dig_lookup_t *lookup) {
isc_result_t result;
unsigned int len;
dig_server_t *serv;
dig_query_t *query;
isc_buffer_t b;
dns_compress_t cctx;
char store[MXNAME];
@ -2644,10 +2632,9 @@ setup_lookup(dig_lookup_t *lookup) {
lookup->pending = false;
for (serv = ISC_LIST_HEAD(lookup->my_server_list); serv != NULL;
serv = ISC_LIST_NEXT(serv, link))
{
query = new_query(lookup, serv->servername, serv->userarg);
ISC_LIST_FOREACH (lookup->my_server_list, serv, link) {
dig_query_t *query = new_query(lookup, serv->servername,
serv->userarg);
ISC_LIST_ENQUEUE(lookup->q, query, link);
}
@ -4672,7 +4659,6 @@ run_loop(void *arg) {
void
cancel_all(void) {
dig_lookup_t *l, *n;
dig_query_t *q, *nq;
debug("cancel_all()");
@ -4683,8 +4669,7 @@ cancel_all(void) {
cancel_now = true;
while (current_lookup != NULL) {
for (q = ISC_LIST_HEAD(current_lookup->q); q != NULL; q = nq) {
nq = ISC_LIST_NEXT(q, link);
ISC_LIST_FOREACH_SAFE (current_lookup->q, q, link) {
debug("canceling pending query %p, belonging to %p", q,
current_lookup);
q->canceled = true;

5
bin/dig/host.c
View file

@ -207,7 +207,6 @@ static isc_result_t
printsection(dns_message_t *msg, dns_section_t sectionid,
const char *section_name, bool headers, dig_query_t *query) {
dns_name_t *print_name;
dns_rdataset_t *rdataset;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_buffer_t target;
isc_result_t result, loopresult;
@ -228,9 +227,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
first = true;
print_name = name;
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
ISC_LIST_FOREACH (name->list, rdataset, link) {
if (query->lookup->rdtype == dns_rdatatype_axfr &&
!((!list_addresses &&
(list_type == dns_rdatatype_any ||

5
bin/dig/nslookup.c
View file

@ -448,7 +448,6 @@ static void
show_settings(bool full, bool serv_only) {
dig_server_t *srv;
isc_sockaddr_t sockaddr;
dig_searchlist_t *listent;
isc_result_t result;
srv = ISC_LIST_HEAD(server_list);
@ -479,9 +478,7 @@ show_settings(bool full, bool serv_only) {
tries, port, ndots);
printf(" querytype = %-8s\tclass = %s\n", deftype, defclass);
printf(" srchlist = ");
for (listent = ISC_LIST_HEAD(search_list); listent != NULL;
listent = ISC_LIST_NEXT(listent, link))
{
ISC_LIST_FOREACH (search_list, listent, link) {
printf("%s", listent->origin);
if (ISC_LIST_NEXT(listent, link) != NULL) {
printf("/");

7
bin/dnssec/dnssec-cds.c
View file

@ -209,8 +209,7 @@ freeset(dns_rdataset_t *rdataset) {
static void
freelist(dns_rdataset_t *rdataset) {
dns_rdatalist_t *rdlist;
dns_rdata_t *rdata;
dns_rdatalist_t *rdlist = NULL;
if (!dns_rdataset_isassociated(rdataset)) {
return;
@ -218,9 +217,7 @@ freelist(dns_rdataset_t *rdataset) {
dns_rdatalist_fromrdataset(rdataset, &rdlist);
for (rdata = ISC_LIST_HEAD(rdlist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(rdlist->rdata))
{
ISC_LIST_FOREACH_SAFE (rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
isc_mem_put(mctx, rdata, sizeof(*rdata));
}

6
bin/dnssec/dnssec-keygen.c
View file

@ -1123,7 +1123,6 @@ main(int argc, char **argv) {
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
dns_kasp_t *kasp = NULL;
dns_kasp_key_t *kaspkey = NULL;
RUNTIME_CHECK(cfg_parser_create(mctx, &parser) ==
ISC_R_SUCCESS);
@ -1151,10 +1150,7 @@ main(int argc, char **argv) {
ctx.ttl = dns_kasp_dnskeyttl(kasp);
ctx.setttl = true;
for (kaspkey = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kaspkey != NULL;
kaspkey = ISC_LIST_NEXT(kaspkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kaspkey, link) {
ctx.use_nsec3 = false;
ctx.alg = dns_kasp_key_algorithm(kaspkey);
ctx.size = dns_kasp_key_size(kaspkey);

45
bin/dnssec/dnssec-ksr.c
View file

@ -228,16 +228,12 @@ get_dnskeys(ksr_ctx_t *ksr, dns_dnsseckeylist_t *keys) {
isc_result_totext(ret));
}
/* Sort on keytag. */
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(keys_read); dk != NULL;
dk = ISC_LIST_NEXT(dk, link))
{
ISC_LIST_FOREACH (keys_read, dk, link) {
n++;
}
keys_sorted = isc_mem_cget(mctx, n, sizeof(dns_dnsseckey_t *));
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(keys_read); dk != NULL;
dk = ISC_LIST_NEXT(dk, link), i++)
{
keys_sorted[i] = dk;
ISC_LIST_FOREACH (keys_read, dk, link) {
keys_sorted[i++] = dk;
}
qsort(keys_sorted, n, sizeof(dns_dnsseckey_t *), keyalgtag_cmp);
while (!ISC_LIST_EMPTY(keys_read)) {
@ -310,8 +306,7 @@ progress(int p) {
static void
freerrset(dns_rdataset_t *rdataset) {
dns_rdatalist_t *rdlist;
dns_rdata_t *rdata;
dns_rdatalist_t *rdlist = NULL;
if (!dns_rdataset_isassociated(rdataset)) {
return;
@ -319,9 +314,7 @@ freerrset(dns_rdataset_t *rdataset) {
dns_rdatalist_fromrdataset(rdataset, &rdlist);
for (rdata = ISC_LIST_HEAD(rdlist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(rdlist->rdata))
{
ISC_LIST_FOREACH_SAFE (rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
isc_mem_put(mctx, rdata, sizeof(*rdata));
}
@ -395,9 +388,7 @@ create_key(ksr_ctx_t *ksr, dns_kasp_t *kasp, dns_kasp_key_t *kaspkey,
isc_buffer_init(&buf, filename, sizeof(filename) - 1);
/* Check existing keys. */
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(*keys); dk != NULL;
dk = ISC_LIST_NEXT(dk, link))
{
ISC_LIST_FOREACH (*keys, dk, link) {
isc_stdtime_t act = 0, inact = 0;
if (!dns_kasp_key_match(kaspkey, dk)) {
@ -578,9 +569,7 @@ print_dnskeys(dns_kasp_key_t *kaspkey, dns_ttl_t ttl, dns_dnsseckeylist_t *keys,
rdatalist->rdclass = dns_rdataclass_in;
rdatalist->type = dns_rdatatype_dnskey;
rdatalist->ttl = ttl;
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(*keys); dk != NULL;
dk = ISC_LIST_NEXT(dk, link))
{
ISC_LIST_FOREACH (*keys, dk, link) {
isc_stdtime_t pub = 0, del = 0;
(void)dst_key_gettime(dk->key, DST_TIME_PUBLISH, &pub);
@ -685,9 +674,7 @@ sign_rrset(ksr_ctx_t *ksr, isc_stdtime_t inception, isc_stdtime_t expiration,
rrsiglist->rdclass = dns_rdataclass_in;
rrsiglist->type = dns_rdatatype_rrsig;
rrsiglist->ttl = rrset->ttl;
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(*keys); dk != NULL;
dk = ISC_LIST_NEXT(dk, link))
{
ISC_LIST_FOREACH (*keys, dk, link) {
isc_buffer_t buf;
isc_buffer_t *newbuf = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
@ -771,9 +758,7 @@ get_keymaterial(ksr_ctx_t *ksr, dns_kasp_t *kasp, isc_stdtime_t inception,
cdslist->type = dns_rdatatype_cds;
cdslist->ttl = ksr->ttl;
for (dns_dnsseckey_t *dk = ISC_LIST_HEAD(*keys); dk != NULL;
dk = ISC_LIST_NEXT(dk, link))
{
ISC_LIST_FOREACH (*keys, dk, link) {
bool published = true;
isc_buffer_t buf;
isc_buffer_t *newbuf;
@ -862,9 +847,7 @@ get_keymaterial(ksr_ctx_t *ksr, dns_kasp_t *kasp, isc_stdtime_t inception,
isc_buffer_clear(newbuf);
/* CDS */
for (dns_kasp_digest_t *alg = ISC_LIST_HEAD(digests);
alg != NULL; alg = ISC_LIST_NEXT(alg, link))
{
ISC_LIST_FOREACH (digests, alg, link) {
isc_buffer_t *newbuf2 = NULL;
dns_rdata_t *rdata2 = NULL;
dns_rdata_t cds = DNS_RDATA_INIT;
@ -1069,9 +1052,7 @@ keygen(ksr_ctx_t *ksr) {
/* Set context */
setcontext(ksr, kasp);
/* Key generation */
for (dns_kasp_key_t *kk = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kk != NULL; kk = ISC_LIST_NEXT(kk, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kk, link) {
if (dns_kasp_key_ksk(kk) && !ksr->ksk) {
/* only ZSKs allowed */
continue;
@ -1138,9 +1119,7 @@ request(ksr_ctx_t *ksr) {
(int)r.length, r.base, timestr);
next = ksr->end + 1;
for (dns_kasp_key_t *kk = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kk != NULL; kk = ISC_LIST_NEXT(kk, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kk, link) {
/*
* Output the DNSKEY records for the current bundle
* that starts at 'inception. The 'next' variable is

61
bin/dnssec/dnssec-signzone.c
View file

@ -354,11 +354,7 @@ iszsk(dns_dnsseckey_t *key) {
*/
static dns_dnsseckey_t *
keythatsigned_unlocked(dns_rdata_rrsig_t *rrsig) {
dns_dnsseckey_t *key;
for (key = ISC_LIST_HEAD(keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (keylist, key, link) {
if (rrsig->keyid == dst_key_id(key->key) &&
rrsig->algorithm == dst_key_alg(key->key) &&
dns_name_equal(&rrsig->signer, dst_key_name(key->key)))
@ -485,7 +481,6 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
dns_rdataset_t sigset;
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t rrsig;
dns_dnsseckey_t *key;
isc_result_t result;
bool nosigs = false;
bool *wassignedby, *nowsignedby;
@ -536,6 +531,7 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
}
while (result == ISC_R_SUCCESS) {
dns_dnsseckey_t *key = NULL;
bool expired, refresh, future, offline;
bool keep = false, resign = false;
@ -681,9 +677,7 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
dns_rdataset_disassociate(&sigset);
}
for (key = ISC_LIST_HEAD(keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (keylist, key, link) {
if (REVOKE(key->key) && set->type != dns_rdatatype_dnskey) {
continue;
}
@ -701,13 +695,9 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
set->type == dns_rdatatype_dnskey) &&
dns_name_equal(name, gorigin))
{
bool have_ksk;
dns_dnsseckey_t *curr;
bool have_ksk = isksk(key);
have_ksk = isksk(key);
for (curr = ISC_LIST_HEAD(keylist); curr != NULL;
curr = ISC_LIST_NEXT(curr, link))
{
ISC_LIST_FOREACH (keylist, curr, link) {
if (dst_key_alg(key->key) !=
dst_key_alg(curr->key))
{
@ -732,7 +722,6 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
* key that already signs this RRset.
*/
bool have_pre_sig = false;
dns_dnsseckey_t *curr;
uint32_t pre;
isc_result_t ret = dst_key_getnum(
key->key, DST_NUM_PREDECESSOR, &pre);
@ -746,10 +735,7 @@ signset(dns_diff_t *del, dns_diff_t *add, dns_dbnode_t *node, dns_name_t *name,
* - Have key ID equal to the predecessor id.
* - Have a successor that matches 'key' id.
*/
for (curr = ISC_LIST_HEAD(keylist);
curr != NULL;
curr = ISC_LIST_NEXT(curr, link))
{
ISC_LIST_FOREACH (keylist, curr, link) {
uint32_t suc;
if (dst_key_alg(key->key) !=
@ -2695,12 +2681,11 @@ loadexplicitkeys(char *keyfiles[], int n, bool setksk) {
}
/* Skip any duplicates */
for (key = ISC_LIST_HEAD(keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
if (dst_key_id(key->key) == dst_key_id(newkey) &&
dst_key_alg(key->key) == dst_key_alg(newkey))
ISC_LIST_FOREACH (keylist, k, link) {
if (dst_key_id(k->key) == dst_key_id(newkey) &&
dst_key_alg(k->key) == dst_key_alg(newkey))
{
key = k;
break;
}
}
@ -2779,9 +2764,7 @@ add_digest(char *str, size_t dlen, dns_kasp_digestlist_t *digests,
}
/* Suppress duplicates */
for (dns_kasp_digest_t *d = ISC_LIST_HEAD(*digests); d != NULL;
d = ISC_LIST_NEXT(d, link))
{
ISC_LIST_FOREACH (*digests, d, link) {
if (d->digest == alg) {
return;
}
@ -2803,7 +2786,6 @@ build_final_keylist(void) {
char name[DNS_NAME_FORMATSIZE];
dns_rdataset_t cdsset, cdnskeyset, soaset;
dns_kasp_digestlist_t digests;
dns_kasp_digest_t *d, *d_next;
bool cdnskey = false;
ISC_LIST_INIT(rmkeys);
@ -2903,8 +2885,7 @@ findkeys:
clear_keylist(&rmkeys);
clear_keylist(&matchkeys);
for (d = ISC_LIST_HEAD(digests); d != NULL; d = d_next) {
d_next = ISC_LIST_NEXT(d, link);
ISC_LIST_FOREACH_SAFE (digests, d, link) {
ISC_LIST_UNLINK(digests, d, link);
isc_mem_put(mctx, d, sizeof(*d));
}
@ -3086,7 +3067,6 @@ writeset(const char *prefix, dns_rdatatype_t type) {
isc_buffer_t namebuf;
isc_region_t r;
isc_result_t result;
dns_dnsseckey_t *key, *curr;
unsigned char dsbuf[DNS_DS_BUFFERSIZE];
unsigned char keybuf[DST_KEY_MAXSIZE];
unsigned int filenamelen;
@ -3115,9 +3095,7 @@ writeset(const char *prefix, dns_rdatatype_t type) {
name = gorigin;
for (key = ISC_LIST_HEAD(keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (keylist, key, link) {
if (REVOKE(key->key)) {
continue;
}
@ -3128,9 +3106,8 @@ writeset(const char *prefix, dns_rdatatype_t type) {
have_ksk = false;
have_non_ksk = true;
}
for (curr = ISC_LIST_HEAD(keylist); curr != NULL;
curr = ISC_LIST_NEXT(curr, link))
{
ISC_LIST_FOREACH (keylist, curr, link) {
if (dst_key_alg(key->key) != dst_key_alg(curr->key)) {
continue;
}
@ -3364,7 +3341,6 @@ main(int argc, char *argv[]) {
char *endp;
isc_time_t timer_start, timer_finish;
isc_time_t sign_start, sign_finish;
dns_dnsseckey_t *key;
isc_result_t result, vresult;
bool free_output = false;
int tempfilelen = 0;
@ -3899,9 +3875,7 @@ main(int argc, char *argv[]) {
}
/* Now enumerate the key list */
for (key = ISC_LIST_HEAD(keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (keylist, key, link) {
key->index = keycount++;
}
@ -4087,8 +4061,7 @@ main(int argc, char *argv[]) {
hashlist_free(&hashlist);
while (!ISC_LIST_EMPTY(keylist)) {
key = ISC_LIST_HEAD(keylist);
ISC_LIST_FOREACH_SAFE (keylist, key, link) {
ISC_LIST_UNLINK(keylist, key, link);
dns_dnsseckey_destroy(mctx, &key);
}

28
bin/dnssec/dnssectool.c
View file

@ -591,12 +591,11 @@ void
kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
const char *keydir, dns_kasp_t **kaspp) {
isc_result_t result = ISC_R_NOTFOUND;
const cfg_listelt_t *element;
const cfg_listelt_t *element = NULL;
const cfg_obj_t *kasps = NULL;
dns_kasp_t *kasp = NULL, *kasp_next;
dns_kasplist_t kasplist;
const cfg_obj_t *keystores = NULL;
dns_keystore_t *ks = NULL, *ks_next;
dns_keystore_t *keystore = NULL;
dns_keystorelist_t kslist;
ISC_LIST_INIT(kasplist);
@ -607,7 +606,6 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
element = cfg_list_next(element))
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
ks = NULL;
result = cfg_keystore_fromconfig(kconfig, mctx, &kslist, NULL);
if (result != ISC_R_SUCCESS) {
fatal("failed to configure key-store '%s': %s",
@ -616,21 +614,21 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
}
}
/* Default key-directory key store. */
ks = NULL;
(void)cfg_keystore_fromconfig(NULL, mctx, &kslist, &ks);
INSIST(ks != NULL);
(void)cfg_keystore_fromconfig(NULL, mctx, &kslist, &keystore);
INSIST(keystore != NULL);
if (keydir != NULL) {
/* '-K keydir' takes priority */
dns_keystore_setdirectory(ks, keydir);
dns_keystore_setdirectory(keystore, keydir);
}
dns_keystore_detach(&ks);
dns_keystore_detach(&keystore);
(void)cfg_map_get(config, "dnssec-policy", &kasps);
for (element = cfg_list_first(kasps); element != NULL;
element = cfg_list_next(element))
{
dns_kasp_t *kasp = NULL;
cfg_obj_t *kconfig = cfg_listelt_value(element);
kasp = NULL;
if (strcmp(cfg_obj_asstring(cfg_tuple_get(kconfig, "name")),
name) != 0)
{
@ -646,16 +644,15 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
}
INSIST(kasp != NULL);
dns_kasp_freeze(kasp);
*kaspp = kasp;
break;
}
*kaspp = kasp;
/*
* Cleanup kasp list.
*/
for (kasp = ISC_LIST_HEAD(kasplist); kasp != NULL; kasp = kasp_next) {
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_FOREACH_SAFE (kasplist, kasp, link) {
ISC_LIST_UNLINK(kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
@ -663,8 +660,7 @@ kasp_from_conf(cfg_obj_t *config, isc_mem_t *mctx, const char *name,
/*
* Cleanup keystore list.
*/
for (ks = ISC_LIST_HEAD(kslist); ks != NULL; ks = ks_next) {
ks_next = ISC_LIST_NEXT(ks, link);
ISC_LIST_FOREACH_SAFE (kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}

40
bin/named/controlconf.c
View file

@ -202,22 +202,13 @@ ISC_REFCOUNT_IMPL(controlconnection, conn_free);
static void
shutdown_listener(controllistener_t *listener) {
controlconnection_t *conn = NULL;
controlconnection_t *next = NULL;
/* Don't shutdown the same listener twice */
if (listener->shuttingdown) {
return;
}
listener->shuttingdown = true;
for (conn = ISC_LIST_HEAD(listener->connections); conn != NULL;
conn = next)
{
/*
* 'conn' is likely to be freed by the conn_shutdown() call.
*/
next = ISC_LIST_NEXT(conn, link);
ISC_LIST_FOREACH_SAFE (listener->connections, conn, link) {
conn_shutdown(conn);
}
@ -433,7 +424,7 @@ control_recvmessage(isc_nmhandle_t *handle ISC_ATTR_UNUSED, isc_result_t result,
void *arg) {
controlconnection_t *conn = (controlconnection_t *)arg;
controllistener_t *listener = conn->listener;
controlkey_t *key = NULL;
bool match = false;
isccc_time_t sent;
isccc_time_t exp;
uint32_t nonce;
@ -442,9 +433,7 @@ control_recvmessage(isc_nmhandle_t *handle ISC_ATTR_UNUSED, isc_result_t result,
goto cleanup;
}
for (key = ISC_LIST_HEAD(listener->keys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (listener->keys, key, link) {
isccc_region_t ccregion;
isccc_ccmsg_toregion(&conn->ccmsg, &ccregion);
@ -457,13 +446,14 @@ control_recvmessage(isc_nmhandle_t *handle ISC_ATTR_UNUSED, isc_result_t result,
result = isccc_cc_fromwire(&ccregion, &conn->request, conn->alg,
&conn->secret);
if (result == ISC_R_SUCCESS) {
match = true;
break;
}
isc_mem_put(listener->mctx, conn->secret.rstart,
REGION_SIZE(conn->secret));
}
if (key == NULL) {
if (!match) {
result = ISCCC_R_BADAUTH;
goto cleanup;
}
@ -658,16 +648,10 @@ control_newconn(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
static void
controls_shutdown(named_controls_t *controls) {
controllistener_t *listener = NULL;
controllistener_t *next = NULL;
for (listener = ISC_LIST_HEAD(controls->listeners); listener != NULL;
listener = next)
{
ISC_LIST_FOREACH_SAFE (controls->listeners, listener, link) {
/*
* As listeners shut down, they will call their callbacks.
*/
next = ISC_LIST_NEXT(listener, link);
shutdown_listener(listener);
}
}
@ -742,7 +726,6 @@ controlkeylist_fromcfg(const cfg_obj_t *keylist, isc_mem_t *mctx,
static void
register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
controlkeylist_t *keyids, isc_mem_t *mctx, const char *socktext) {
controlkey_t *keyid = NULL, *next = NULL;
const cfg_obj_t *keydef = NULL;
char secret[1024];
isc_buffer_t b;
@ -751,9 +734,7 @@ register_keys(const cfg_obj_t *control, const cfg_obj_t *keylist,
/*
* Find the keys corresponding to the keyids used by this listener.
*/
for (keyid = ISC_LIST_HEAD(*keyids); keyid != NULL; keyid = next) {
next = ISC_LIST_NEXT(keyid, link);
ISC_LIST_FOREACH_SAFE (*keyids, keyid, link) {
result = cfgkeylist_find(keylist, keyid->keyname, &keydef);
if (result != ISC_R_SUCCESS) {
cfg_obj_log(control, ISC_LOG_WARNING,
@ -940,10 +921,9 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
controlkeylist_t keys;
isc_result_t result = ISC_R_SUCCESS;
for (listener = ISC_LIST_HEAD(cp->listeners); listener != NULL;
listener = ISC_LIST_NEXT(listener, link))
{
if (isc_sockaddr_equal(addr, &listener->address)) {
ISC_LIST_FOREACH (cp->listeners, l, link) {
if (isc_sockaddr_equal(addr, &l->address)) {
listener = l;
break;
}
}

235
bin/named/server.c
View file

@ -1738,9 +1738,7 @@ setquerystats(dns_zone_t *zone, isc_mem_t *mctx, dns_zonestat_level_t level) {
static named_cache_t *
cachelist_find(named_cachelist_t *cachelist, const char *cachename,
dns_rdataclass_t rdclass) {
for (named_cache_t *nsc = ISC_LIST_HEAD(*cachelist); nsc != NULL;
nsc = ISC_LIST_NEXT(nsc, link))
{
ISC_LIST_FOREACH (*cachelist, nsc, link) {
if (nsc->rdclass == rdclass &&
strcmp(dns_cache_getname(nsc->cache), cachename) == 0)
{
@ -7045,12 +7043,9 @@ tat_timer_tick(void *arg) {
isc_result_t result;
named_server_t *server = (named_server_t *)arg;
struct dotat_arg dotat_arg = { 0 };
dns_view_t *view = NULL;
dns_keytable_t *secroots = NULL;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (!view->trust_anchor_telemetry || !view->enablevalidation) {
continue;
}
@ -7866,15 +7861,10 @@ load_configuration(const char *filename, named_server_t *server,
const cfg_obj_t *options;
const cfg_obj_t *kasps;
const cfg_obj_t *keystores;
dns_kasp_t *kasp = NULL;
dns_kasp_t *kasp_next = NULL;
dns_kasp_t *default_kasp = NULL;
dns_kasplist_t tmpkasplist, kasplist;
dns_keystore_t *keystore = NULL;
dns_keystore_t *keystore_next = NULL;
dns_keystorelist_t tmpkeystorelist, keystorelist;
const cfg_obj_t *views = NULL;
dns_view_t *view_next = NULL;
dns_viewlist_t tmpviewlist;
dns_viewlist_t viewlist, builtin_viewlist;
in_port_t listen_port, udpport_low, udpport_high;
@ -8594,7 +8584,7 @@ load_configuration(const char *filename, named_server_t *server,
element = cfg_list_next(element))
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
keystore = NULL;
result = cfg_keystore_fromconfig(kconfig, named_g_mctx,
&keystorelist, NULL);
if (result != ISC_R_SUCCESS) {
@ -8611,8 +8601,8 @@ load_configuration(const char *filename, named_server_t *server,
element = cfg_list_next(element))
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
dns_kasp_t *kasp = NULL;
kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
named_g_mctx, &keystorelist,
&kasplist, &kasp);
@ -8641,7 +8631,8 @@ load_configuration(const char *filename, named_server_t *server,
element = cfg_list_next(element))
{
cfg_obj_t *kconfig = cfg_listelt_value(element);
kasp = NULL;
dns_kasp_t *kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
named_g_mctx, &keystorelist,
&kasplist, &kasp);
@ -8807,9 +8798,7 @@ load_configuration(const char *filename, named_server_t *server,
* Commit any dns_zone_setview() calls on all zones in the new
* view.
*/
for (dns_view_t *view = ISC_LIST_HEAD(viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (viewlist, view, link) {
dns_view_setviewcommit(view);
}
@ -8819,9 +8808,7 @@ load_configuration(const char *filename, named_server_t *server,
viewlist = tmpviewlist;
/* Make the view list available to each of the views */
for (dns_view_t *view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
view->viewlist = &server->viewlist;
}
@ -8857,9 +8844,7 @@ load_configuration(const char *filename, named_server_t *server,
* after relinquishing privileges them.
*/
if (first_time) {
for (dns_view_t *view = ISC_LIST_HEAD(server->viewlist);
view != NULL; view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
nzd_env_close(view);
}
}
@ -8890,9 +8875,7 @@ load_configuration(const char *filename, named_server_t *server,
* Reopen NZD databases.
*/
if (first_time) {
for (dns_view_t *view = ISC_LIST_HEAD(server->viewlist);
view != NULL; view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
nzd_env_reopen(view);
}
}
@ -9271,10 +9254,7 @@ cleanup_cachelist:
ISC_LIST_APPENDLIST(viewlist, builtin_viewlist, link);
cleanup_viewlist:
for (dns_view_t *view = ISC_LIST_HEAD(viewlist); view != NULL;
view = view_next)
{
view_next = ISC_LIST_NEXT(view, link);
ISC_LIST_FOREACH_SAFE (viewlist, view, link) {
ISC_LIST_UNLINK(viewlist, view, link);
if (result == ISC_R_SUCCESS && strcmp(view->name, "_bind") != 0)
{
@ -9285,17 +9265,13 @@ cleanup_viewlist:
}
cleanup_kasplist:
for (kasp = ISC_LIST_HEAD(kasplist); kasp != NULL; kasp = kasp_next) {
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_FOREACH_SAFE (kasplist, kasp, link) {
ISC_LIST_UNLINK(kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
cleanup_keystorelist:
for (keystore = ISC_LIST_HEAD(keystorelist); keystore != NULL;
keystore = keystore_next)
{
keystore_next = ISC_LIST_NEXT(keystore, link);
ISC_LIST_FOREACH_SAFE (keystorelist, keystore, link) {
ISC_LIST_UNLINK(keystorelist, keystore, link);
dns_keystore_detach(&keystore);
}
@ -9347,7 +9323,6 @@ view_loaded(void *arg) {
if (isc_refcount_decrement(&zl->refs) == 1) {
named_server_t *server = zl->server;
bool reconfig = zl->reconfig;
dns_view_t *view = NULL;
isc_refcount_destroy(&zl->refs);
isc_mem_put(server->mctx, zl, sizeof(*zl));
@ -9368,9 +9343,7 @@ view_loaded(void *arg) {
"all zones loaded");
}
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (view->managed_keys != NULL) {
result = dns_zone_synckeyzone(
view->managed_keys);
@ -9416,7 +9389,6 @@ static isc_result_t
load_zones(named_server_t *server, bool reconfig) {
isc_result_t result = ISC_R_SUCCESS;
ns_zoneload_t *zl = NULL;
dns_view_t *view = NULL;
zl = isc_mem_get(server->mctx, sizeof(*zl));
zl->server = server;
@ -9429,9 +9401,7 @@ load_zones(named_server_t *server, bool reconfig) {
/*
* Schedule zones to be loaded from disk.
*/
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (view->managed_keys != NULL) {
result = dns_zone_load(view->managed_keys, false);
if (result != ISC_R_SUCCESS &&
@ -9534,9 +9504,6 @@ named_server_flushonshutdown(named_server_t *server, bool flush) {
static void
shutdown_server(void *arg) {
named_server_t *server = (named_server_t *)arg;
dns_view_t *view = NULL, *view_next = NULL;
dns_kasp_t *kasp = NULL, *kasp_next = NULL;
dns_keystore_t *keystore = NULL, *keystore_next = NULL;
bool flush = server->flushonshutdown;
named_cache_t *nsc = NULL;
@ -9577,25 +9544,17 @@ shutdown_server(void *arg) {
(void)named_server_saventa(server);
for (kasp = ISC_LIST_HEAD(server->kasplist); kasp != NULL;
kasp = kasp_next)
{
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_FOREACH_SAFE (server->kasplist, kasp, link) {
ISC_LIST_UNLINK(server->kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
for (keystore = ISC_LIST_HEAD(server->keystorelist); keystore != NULL;
keystore = keystore_next)
{
keystore_next = ISC_LIST_NEXT(keystore, link);
ISC_LIST_FOREACH_SAFE (server->keystorelist, keystore, link) {
ISC_LIST_UNLINK(server->keystorelist, keystore, link);
dns_keystore_detach(&keystore);
}
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = view_next)
{
ISC_LIST_FOREACH_SAFE (server->viewlist, view, link) {
view_next = ISC_LIST_NEXT(view, link);
ISC_LIST_UNLINK(server->viewlist, view, link);
dns_view_flushonshutdown(view, flush);
@ -9636,8 +9595,6 @@ static isc_result_t
get_matching_view_sync(isc_netaddr_t *srcaddr, isc_netaddr_t *destaddr,
dns_message_t *message, dns_aclenv_t *env,
isc_result_t *sigresult, dns_view_t **viewp) {
dns_view_t *view;
/*
* We should not be running synchronous view matching if signature
* checking involves SIG(0). TSIG has priority of SIG(0), so if TSIG
@ -9646,9 +9603,7 @@ get_matching_view_sync(isc_netaddr_t *srcaddr, isc_netaddr_t *destaddr,
INSIST(message->tsigkey != NULL || message->tsig != NULL ||
message->sig0 == NULL);
for (view = ISC_LIST_HEAD(named_g_server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (named_g_server->viewlist, view, link) {
if (message->rdclass == view->rdclass ||
message->rdclass == dns_rdataclass_any)
{
@ -11118,21 +11073,18 @@ add_zone_tolist(dns_zone_t *zone, void *uap) {
static isc_result_t
add_view_tolist(struct dumpcontext *dctx, dns_view_t *view) {
struct viewlistentry *vle;
isc_result_t result = ISC_R_SUCCESS;
/*
* Prevent duplicate views.
*/
for (vle = ISC_LIST_HEAD(dctx->viewlist); vle != NULL;
vle = ISC_LIST_NEXT(vle, link))
{
ISC_LIST_FOREACH (dctx->viewlist, vle, link) {
if (vle->view == view) {
return ISC_R_SUCCESS;
}
}
vle = isc_mem_get(dctx->mctx, sizeof *vle);
struct viewlistentry *vle = isc_mem_get(dctx->mctx, sizeof *vle);
vle->view = NULL;
dns_view_attach(view, &vle->view);
ISC_LINK_INIT(vle, link);
@ -11332,10 +11284,9 @@ isc_result_t
named_server_dumpdb(named_server_t *server, isc_lex_t *lex,
isc_buffer_t **text) {
struct dumpcontext *dctx = NULL;
dns_view_t *view;
isc_result_t result;
char *ptr;
const char *sep;
char *ptr = NULL;
const char *sep = NULL;
bool found;
REQUIRE(text != NULL);
@ -11402,9 +11353,7 @@ named_server_dumpdb(named_server_t *server, isc_lex_t *lex,
nextview:
found = false;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (ptr != NULL && strcmp(view->name, ptr) != 0) {
continue;
}
@ -11437,11 +11386,10 @@ cleanup:
isc_result_t
named_server_dumpsecroots(named_server_t *server, isc_lex_t *lex,
isc_buffer_t **text) {
dns_view_t *view;
dns_keytable_t *secroots = NULL;
dns_ntatable_t *ntatable = NULL;
isc_result_t result;
char *ptr;
char *ptr = NULL;
FILE *fp = NULL;
isc_time_t now;
char tbuf[64];
@ -11478,9 +11426,7 @@ named_server_dumpsecroots(named_server_t *server, isc_lex_t *lex,
used = isc_buffer_usedlength(*text);
do {
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (ptr != NULL && strcmp(view->name, ptr) != 0) {
continue;
}
@ -11557,7 +11503,6 @@ cleanup:
isc_result_t
named_server_dumprecursing(named_server_t *server) {
FILE *fp = NULL;
dns_view_t *view;
isc_result_t result;
CHECKMF(isc_stdio_open(server->recfile, "w", &fp),
@ -11565,9 +11510,7 @@ named_server_dumprecursing(named_server_t *server) {
fprintf(fp, ";\n; Recursing Queries\n;\n");
ns_interfacemgr_dumprecursing(fp, server->interfacemgr);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
fprintf(fp, ";\n; Active fetch domains [view: %s]\n;\n",
view->name);
dns_resolver_dumpfetches(view->resolver, isc_statsformat_file,
@ -11628,8 +11571,7 @@ named_server_setdebuglevel(named_server_t *server, isc_lex_t *lex) {
isc_result_t
named_server_validation(named_server_t *server, isc_lex_t *lex,
isc_buffer_t **text) {
char *ptr;
dns_view_t *view;
char *ptr = NULL;
bool changed = false;
isc_result_t result;
bool enable = true, set = true, first = true;
@ -11666,9 +11608,7 @@ named_server_validation(named_server_t *server, isc_lex_t *lex,
ptr = next_token(lex, text);
isc_loopmgr_pause(named_g_loopmgr);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if ((ptr != NULL && strcasecmp(ptr, view->name) != 0) ||
strcasecmp("_bind", view->name) == 0)
{
@ -11709,12 +11649,10 @@ cleanup:
isc_result_t
named_server_flushcache(named_server_t *server, isc_lex_t *lex) {
char *ptr;
dns_view_t *view;
char *ptr = NULL;
bool flushed;
bool found;
isc_result_t result;
named_cache_t *nsc;
/* Skip the command name. */
ptr = next_token(lex, NULL);
@ -11742,31 +11680,25 @@ named_server_flushcache(named_server_t *server, isc_lex_t *lex) {
* much more lightweight because only a few (most typically just
* one) views will match.
*/
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (strcasecmp(ptr, view->name) != 0) {
continue;
}
found = true;
for (nsc = ISC_LIST_HEAD(server->cachelist);
nsc != NULL; nsc = ISC_LIST_NEXT(nsc, link))
{
ISC_LIST_FOREACH (server->cachelist, nsc, link) {
if (nsc->cache == view->cache) {
nsc->needflush = true;
break;
}
}
INSIST(nsc != NULL);
nsc->needflush = true;
}
} else {
found = true;
}
/* Perform flush */
for (nsc = ISC_LIST_HEAD(server->cachelist); nsc != NULL;
nsc = ISC_LIST_NEXT(nsc, link))
{
ISC_LIST_FOREACH (server->cachelist, nsc, link) {
if (ptr != NULL && !nsc->needflush) {
continue;
}
@ -11791,15 +11723,12 @@ named_server_flushcache(named_server_t *server, isc_lex_t *lex) {
* A worst case is that we have n views and n/2 caches, each shared by
* two views. Then this will be a O(n^2/4) operation.
*/
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (!dns_view_iscacheshared(view)) {
continue;
}
for (nsc = ISC_LIST_HEAD(server->cachelist); nsc != NULL;
nsc = ISC_LIST_NEXT(nsc, link))
{
ISC_LIST_FOREACH (server->cachelist, nsc, link) {
if (!nsc->needflush || nsc->cache != view->cache) {
continue;
}
@ -11817,9 +11746,7 @@ named_server_flushcache(named_server_t *server, isc_lex_t *lex) {
}
/* Cleanup the cache list. */
for (nsc = ISC_LIST_HEAD(server->cachelist); nsc != NULL;
nsc = ISC_LIST_NEXT(nsc, link))
{
ISC_LIST_FOREACH (server->cachelist, nsc, link) {
nsc->needflush = false;
}
@ -11855,13 +11782,12 @@ isc_result_t
named_server_flushnode(named_server_t *server, isc_lex_t *lex, bool tree) {
char *ptr, *viewname;
char target[DNS_NAME_FORMATSIZE];
dns_view_t *view;
bool flushed;
bool found;
isc_result_t result;
isc_buffer_t b;
dns_fixedname_t fixed;
dns_name_t *name;
dns_name_t *name = NULL;
/* Skip the command name. */
ptr = next_token(lex, NULL);
@ -11890,9 +11816,7 @@ named_server_flushnode(named_server_t *server, isc_lex_t *lex, bool tree) {
isc_loopmgr_pause(named_g_loopmgr);
flushed = true;
found = false;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (viewname != NULL && strcasecmp(viewname, view->name) != 0) {
continue;
}
@ -12213,7 +12137,6 @@ synczone(dns_zone_t *zone, void *uap) {
isc_result_t
named_server_sync(named_server_t *server, isc_lex_t *lex, isc_buffer_t **text) {
isc_result_t result, tresult;
dns_view_t *view = NULL;
dns_zone_t *zone = NULL;
char classstr[DNS_RDATACLASS_FORMATSIZE];
char zonename[DNS_NAME_FORMATSIZE];
@ -12242,9 +12165,7 @@ named_server_sync(named_server_t *server, isc_lex_t *lex, isc_buffer_t **text) {
if (zone == NULL) {
isc_loopmgr_pause(named_g_loopmgr);
tresult = ISC_R_SUCCESS;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
result = dns_view_apply(view, false, NULL, synczone,
&cleanup);
if (result != ISC_R_SUCCESS && tresult == ISC_R_SUCCESS)
@ -12264,7 +12185,7 @@ named_server_sync(named_server_t *server, isc_lex_t *lex, isc_buffer_t **text) {
result = synczone(zone, &cleanup);
isc_loopmgr_resume(named_g_loopmgr);
view = dns_zone_getview(zone);
dns_view_t *view = dns_zone_getview(zone);
if (strcmp(view->name, "_default") == 0 ||
strcmp(view->name, "_bind") == 0)
{
@ -12297,8 +12218,7 @@ named_server_freeze(named_server_t *server, bool freeze, isc_lex_t *lex,
dns_zonetype_t type;
char classstr[DNS_RDATACLASS_FORMATSIZE];
char zonename[DNS_NAME_FORMATSIZE];
dns_view_t *view;
const char *vname, *sep;
const char *vname = NULL, *sep = NULL;
bool frozen;
const char *msg = NULL;
@ -12311,9 +12231,7 @@ named_server_freeze(named_server_t *server, bool freeze, isc_lex_t *lex,
if (mayberaw == NULL) {
isc_loopmgr_pause(named_g_loopmgr);
tresult = ISC_R_SUCCESS;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
result = dns_view_freezezones(view, freeze);
if (result != ISC_R_SUCCESS && tresult == ISC_R_SUCCESS)
{
@ -12390,7 +12308,7 @@ named_server_freeze(named_server_t *server, bool freeze, isc_lex_t *lex,
(void)putnull(text);
}
view = dns_zone_getview(mayberaw);
dns_view_t *view = dns_zone_getview(mayberaw);
if (strcmp(view->name, "_default") == 0 ||
strcmp(view->name, "_bind") == 0)
{
@ -12505,8 +12423,6 @@ static isc_result_t
nzf_writeconf(const cfg_obj_t *config, dns_view_t *view) {
const cfg_obj_t *zl = NULL;
cfg_list_t *list;
const cfg_listelt_t *elt;
FILE *fp = NULL;
char tmp[1024];
isc_result_t result;
@ -12529,9 +12445,7 @@ nzf_writeconf(const cfg_obj_t *config, dns_view_t *view) {
CHECK(add_comment(fp, view->name)); /* force a comment */
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
elt = ISC_LIST_NEXT(elt, link))
{
ISC_LIST_FOREACH (*list, elt, link) {
const cfg_obj_t *zconfig = cfg_listelt_value(elt);
CHECK(isc_stdio_write("zone ", 5, 1, fp, NULL));
@ -13190,11 +13104,7 @@ static isc_result_t
delete_zoneconf(dns_view_t *view, cfg_parser_t *pctx, const cfg_obj_t *config,
const dns_name_t *zname, nzfwriter_t nzfwriter) {
isc_result_t result = ISC_R_NOTFOUND;
const cfg_listelt_t *elt = NULL;
const cfg_obj_t *zl = NULL;
cfg_list_t *list;
dns_fixedname_t myfixed;
dns_name_t *myname;
REQUIRE(view != NULL);
REQUIRE(pctx != NULL);
@ -13209,16 +13119,13 @@ delete_zoneconf(dns_view_t *view, cfg_parser_t *pctx, const cfg_obj_t *config,
CHECK(ISC_R_FAILURE);
}
list = UNCONST(&zl->value.list);
myname = dns_fixedname_initname(&myfixed);
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
elt = ISC_LIST_NEXT(elt, link))
{
cfg_list_t *list = UNCONST(&zl->value.list);
ISC_LIST_FOREACH (*list, elt, link) {
dns_fixedname_t myfixed;
dns_name_t *myname = dns_fixedname_initname(&myfixed);
const cfg_obj_t *zconf = cfg_listelt_value(elt);
const char *zn;
cfg_listelt_t *e;
const char *zn = NULL;
cfg_listelt_t *e = NULL;
zn = cfg_obj_asstring(cfg_tuple_get(zconf, "name"));
result = dns_name_fromstring(myname, zn, dns_rootname, 0, NULL);
@ -15114,7 +15021,6 @@ cleanup:
isc_result_t
named_server_nta(named_server_t *server, isc_lex_t *lex, bool readonly,
isc_buffer_t **text) {
dns_view_t *view;
dns_ntatable_t *ntatable = NULL;
isc_result_t result = ISC_R_SUCCESS;
char *ptr, *nametext = NULL, *viewname;
@ -15215,9 +15121,7 @@ named_server_nta(named_server_t *server, isc_lex_t *lex, bool readonly,
if (dump) {
size_t last = 0;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (ntatable != NULL) {
dns_ntatable_detach(&ntatable);
}
@ -15282,9 +15186,7 @@ named_server_nta(named_server_t *server, isc_lex_t *lex, bool readonly,
now = isc_stdtime_now();
isc_loopmgr_pause(named_g_loopmgr);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (viewname != NULL && strcmp(view->name, viewname) != 0) {
continue;
}
@ -15410,11 +15312,7 @@ cleanup:
isc_result_t
named_server_saventa(named_server_t *server) {
dns_view_t *view;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
isc_result_t result = dns_view_saventa(view);
if (result != ISC_R_SUCCESS) {
@ -15431,11 +15329,7 @@ named_server_saventa(named_server_t *server) {
isc_result_t
named_server_loadnta(named_server_t *server) {
dns_view_t *view;
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
isc_result_t result = dns_view_loadnta(view);
if ((result != ISC_R_SUCCESS) &&
@ -15679,7 +15573,6 @@ named_server_mkeys(named_server_t *server, isc_lex_t *lex,
isc_buffer_t **text) {
char *cmd, *classtxt, *viewtxt = NULL;
isc_result_t result = ISC_R_SUCCESS;
dns_view_t *view = NULL;
dns_rdataclass_t rdclass;
char msg[DNS_NAME_FORMATSIZE + 500] = "";
enum { NONE, STAT, REFRESH, SYNC, DESTROY } opt = NONE;
@ -15731,9 +15624,7 @@ named_server_mkeys(named_server_t *server, isc_lex_t *lex,
viewtxt = next_token(lex, text);
}
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (viewtxt != NULL && (rdclass != view->rdclass ||
strcmp(view->name, viewtxt) != 0))
{
@ -15950,7 +15841,6 @@ named_server_servestale(named_server_t *server, isc_lex_t *lex,
char *ptr, *classtxt, *viewtxt = NULL;
char msg[128];
dns_rdataclass_t rdclass = dns_rdataclass_in;
dns_view_t *view;
bool found = false;
dns_stale_answer_t staleanswersok = dns_stale_answer_conf;
bool wantstatus = false;
@ -16014,9 +15904,7 @@ named_server_servestale(named_server_t *server, isc_lex_t *lex,
isc_loopmgr_pause(named_g_loopmgr);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
dns_ttl_t stale_ttl = 0;
uint32_t stale_refresh = 0;
dns_db_t *db = NULL;
@ -16114,7 +16002,6 @@ isc_result_t
named_server_fetchlimit(named_server_t *server, isc_lex_t *lex,
isc_buffer_t **text) {
isc_result_t result = ISC_R_SUCCESS;
dns_view_t *view = NULL;
char *ptr = NULL, *viewname = NULL;
bool first = true;
dns_adb_t *adb = NULL;
@ -16129,9 +16016,7 @@ named_server_fetchlimit(named_server_t *server, isc_lex_t *lex,
/* Look for the view name. */
viewname = next_token(lex, text);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
char tbuf[100];
unsigned int used;
uint32_t val;

51
bin/named/statschannel.c
View file

@ -3757,15 +3757,14 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
const cfg_obj_t *listen_params, const cfg_obj_t *config,
isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
const char *socktext) {
named_statschannel_t *listener;
named_statschannel_t *listener = NULL;
const cfg_obj_t *allow = NULL;
dns_acl_t *new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
for (listener = ISC_LIST_HEAD(server->statschannels); listener != NULL;
listener = ISC_LIST_NEXT(listener, link))
{
if (isc_sockaddr_equal(addr, &listener->address)) {
ISC_LIST_FOREACH (server->statschannels, l, link) {
if (isc_sockaddr_equal(addr, &l->address)) {
listener = l;
break;
}
}
@ -3807,7 +3806,6 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
isc_result_t
named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
cfg_aclconfctx_t *aclconfctx) {
named_statschannel_t *listener, *listener_next;
named_statschannellist_t new_listeners;
const cfg_obj_t *statschannellist = NULL;
const cfg_listelt_t *element, *element2;
@ -3867,8 +3865,9 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
element2 != NULL;
element2 = cfg_list_next(element2))
{
const cfg_obj_t *listen_params;
const cfg_obj_t *obj;
named_statschannel_t *listener = NULL;
const cfg_obj_t *listen_params = NULL;
const cfg_obj_t *obj = NULL;
isc_sockaddr_t addr;
listen_params = cfg_listelt_value(element2);
@ -3932,10 +3931,7 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
}
}
for (listener = ISC_LIST_HEAD(server->statschannels); listener != NULL;
listener = listener_next)
{
listener_next = ISC_LIST_NEXT(listener, link);
ISC_LIST_FOREACH_SAFE (server->statschannels, listener, link) {
ISC_LIST_UNLINK(server->statschannels, listener, link);
shutdown_listener(listener);
}
@ -3946,9 +3942,7 @@ named_statschannels_configure(named_server_t *server, const cfg_obj_t *config,
void
named_statschannels_shutdown(named_server_t *server) {
named_statschannel_t *listener;
while ((listener = ISC_LIST_HEAD(server->statschannels)) != NULL) {
ISC_LIST_FOREACH_SAFE (server->statschannels, listener, link) {
ISC_LIST_UNLINK(server->statschannels, listener, link);
shutdown_listener(listener);
}
@ -3957,7 +3951,6 @@ named_statschannels_shutdown(named_server_t *server) {
isc_result_t
named_stats_dump(named_server_t *server, FILE *fp) {
isc_result_t result;
dns_view_t *view;
dns_zone_t *zone, *next;
stats_dumparg_t dumparg;
uint64_t nsstat_values[ns_statscounter_max];
@ -3989,9 +3982,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
0);
fprintf(fp, "++ Outgoing Queries ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
dns_stats_t *dstats = NULL;
dns_resolver_getquerystats(view->resolver, &dstats);
if (dstats == NULL) {
@ -4021,9 +4012,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
(void)dump_stats(server->resolverstats, isc_statsformat_file, fp, NULL,
resstats_desc, dns_resstatscounter_max, resstats_index,
resstat_values, 0);
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
isc_stats_t *istats = NULL;
dns_resolver_getstats(view->resolver, &istats);
if (istats == NULL) {
@ -4041,9 +4030,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
}
fprintf(fp, "++ Cache Statistics ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
if (strcmp(view->name, "_default") == 0) {
fprintf(fp, "[View: default]\n");
} else {
@ -4060,9 +4047,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
}
fprintf(fp, "++ Cache DB RRsets ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
dns_stats_t *cacherrstats;
cacherrstats = dns_db_getrrsetstats(view->cachedb);
@ -4087,9 +4072,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
}
fprintf(fp, "++ ADB stats ++\n");
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (server->viewlist, view, link) {
dns_adb_t *adb = NULL;
isc_stats_t *adbstats = NULL;
@ -4125,8 +4108,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
isc_stats_t *zonestats = dns_zone_getrequeststats(zone);
if (zonestats != NULL) {
char zonename[DNS_NAME_FORMATSIZE];
view = dns_zone_getview(zone);
dns_view_t *view = dns_zone_getview(zone);
if (view == NULL) {
continue;
}
@ -4155,8 +4137,7 @@ named_stats_dump(named_server_t *server, FILE *fp) {
isc_stats_t *gluecachestats = dns_zone_getgluecachestats(zone);
if (gluecachestats != NULL) {
char zonename[DNS_NAME_FORMATSIZE];
view = dns_zone_getview(zone);
dns_view_t *view = dns_zone_getview(zone);
if (view == NULL) {
continue;
}

10
bin/named/zoneconf.c
View file

@ -788,7 +788,6 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
const isc_sockaddr_t *dstaddr, dns_rdataclass_t rdclass,
void *arg ISC_ATTR_UNUSED) {
dns_aclenv_t *env = NULL;
dns_view_t *view = NULL;
dns_tsigkey_t *key = NULL;
isc_netaddr_t netsrc;
isc_netaddr_t netdst;
@ -807,9 +806,7 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
isc_netaddr_fromsockaddr(&netdst, dstaddr);
env = ns_interfacemgr_getaclenv(named_g_server->interfacemgr);
for (view = ISC_LIST_HEAD(named_g_server->viewlist); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (named_g_server->viewlist, view, link) {
const dns_name_t *tsig = NULL;
if (view->matchrecursiveonly) {
@ -840,10 +837,11 @@ isself(dns_view_t *myview, dns_tsigkey_t *mykey, const isc_sockaddr_t *srcaddr,
dns_acl_allowed(&netdst, tsig, view->matchdestinations,
env))
{
break;
return view == myview;
}
}
return view == myview;
return false;
}
/*%

9
bin/nsupdate/nsupdate.c
View file

@ -852,7 +852,6 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
dnsport);
}
} else {
isc_sockaddr_t *sa;
int i;
/*
@ -861,9 +860,7 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
* the servers array.
*/
ns_total = 0;
for (sa = ISC_LIST_HEAD(*nslist); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
ISC_LIST_FOREACH (*nslist, sa, link) {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {
@ -884,9 +881,7 @@ setup_system(void *arg ISC_ATTR_UNUSED) {
servers = isc_mem_cget(gmctx, ns_alloc, sizeof(isc_sockaddr_t));
i = 0;
for (sa = ISC_LIST_HEAD(*nslist); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
ISC_LIST_FOREACH (*nslist, sa, link) {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {

6
doc/dev/dev.md
View file

@ -588,6 +588,12 @@ Several macros are provided for this purpose, including `ISC_LIST_PREPEND`,
More macros are provided for iterating the list:
ISC_LIST_FOREACH (foolist, foo, link) {
/* do things */
}
... which is equivalent to:
isc_foo_t *foo;
for (foo = ISC_LIST_HEAD(foolist);
foo != NULL;

46
lib/dns/acl.c
View file

@ -226,36 +226,30 @@ dns_acl_match_port_transport(const isc_netaddr_t *reqaddr,
const dns_acl_t *acl, dns_aclenv_t *env,
int *match, const dns_aclelement_t **matchelt) {
isc_result_t result = ISC_R_SUCCESS;
dns_acl_port_transports_t *next;
REQUIRE(reqaddr != NULL);
REQUIRE(DNS_ACL_VALID(acl));
if (!ISC_LIST_EMPTY(acl->ports_and_transports)) {
dns_acl_t *a = UNCONST(acl); /* for ISC_LIST_FOREACH */
ISC_LIST_FOREACH (a->ports_and_transports, next, link) {
bool match_port = true;
bool match_transport = true;
result = ISC_R_FAILURE;
for (next = ISC_LIST_HEAD(acl->ports_and_transports);
next != NULL; next = ISC_LIST_NEXT(next, link))
{
bool match_port = true;
bool match_transport = true;
if (next->port != 0) {
/* Port is specified. */
match_port = (local_port == next->port);
}
if (next->transports != 0) {
/* Transport protocol is specified. */
match_transport =
((transport & next->transports) ==
transport &&
next->encrypted == encrypted);
}
if (next->port != 0) {
/* Port is specified. */
match_port = (local_port == next->port);
}
if (next->transports != 0) {
/* Transport protocol is specified. */
match_transport = ((transport & next->transports) ==
transport &&
next->encrypted == encrypted);
}
if (match_port && match_transport) {
result = next->negative ? ISC_R_FAILURE
: ISC_R_SUCCESS;
break;
}
if (match_port && match_transport) {
result = next->negative ? ISC_R_FAILURE : ISC_R_SUCCESS;
break;
}
}
@ -766,8 +760,6 @@ dns_acl_add_port_transports(dns_acl_t *acl, const in_port_t port,
void
dns_acl_merge_ports_transports(dns_acl_t *dest, dns_acl_t *source, bool pos) {
dns_acl_port_transports_t *next;
REQUIRE(DNS_ACL_VALID(dest));
REQUIRE(DNS_ACL_VALID(source));
@ -776,9 +768,7 @@ dns_acl_merge_ports_transports(dns_acl_t *dest, dns_acl_t *source, bool pos) {
/*
* Merge ports and transports
*/
for (next = ISC_LIST_HEAD(source->ports_and_transports); next != NULL;
next = ISC_LIST_NEXT(next, link))
{
ISC_LIST_FOREACH (source->ports_and_transports, next, link) {
const bool next_positive = !next->negative;
bool add_negative;

63
lib/dns/adb.c
View file

@ -575,7 +575,6 @@ import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
/* FIXME: Move to a separate function */
dns_adbnamehooklist_t *hookhead = NULL;
dns_adbentry_t *entry = NULL;
dns_adbnamehook_t *nh = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
isc_sockaddr_t sockaddr;
struct in_addr ina;
@ -602,16 +601,14 @@ import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
entry = get_attached_and_locked_entry(adb, now, &sockaddr);
INSIST(!ENTRY_DEAD(entry));
dns_adbnamehook_t *anh = NULL;
for (anh = ISC_LIST_HEAD(*hookhead); anh != NULL;
anh = ISC_LIST_NEXT(anh, name_link))
{
bool found = false;
ISC_LIST_FOREACH (*hookhead, anh, name_link) {
if (anh->entry == entry) {
break;
found = true;
}
}
if (anh == NULL) {
nh = new_adbnamehook(adb);
if (!found) {
dns_adbnamehook_t *nh = new_adbnamehook(adb);
dns_adbentry_attach(entry, &nh->entry);
ISC_LIST_APPEND(*hookhead, nh, name_link);
ISC_LIST_APPEND(entry->nhs, nh, entry_link);
@ -734,13 +731,8 @@ maybe_expire_namehooks(dns_adbname_t *adbname, isc_stdtime_t now) {
static void
shutdown_names(dns_adb_t *adb) {
dns_adbname_t *next = NULL;
RWLOCK(&adb->names_lock, isc_rwlocktype_write);
for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
name = next)
{
next = ISC_LIST_NEXT(name, link);
ISC_LIST_FOREACH_SAFE (adb->names_lru, name, link) {
dns_adbname_ref(name);
LOCK(&name->lock);
/*
@ -758,12 +750,8 @@ shutdown_names(dns_adb_t *adb) {
static void
shutdown_entries(dns_adb_t *adb) {
dns_adbentry_t *next = NULL;
RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
adbentry != NULL; adbentry = next)
{
next = ISC_LIST_NEXT(adbentry, link);
ISC_LIST_FOREACH_SAFE (adb->entries_lru, adbentry, link) {
expire_entry(adbentry);
}
RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
@ -1591,14 +1579,8 @@ purge_stale_names(dns_adb_t *adb, isc_stdtime_t now) {
static void
cleanup_names(dns_adb_t *adb, isc_stdtime_t now) {
dns_adbname_t *next = NULL;
RWLOCK(&adb->names_lock, isc_rwlocktype_write);
for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
adbname != NULL; adbname = next)
{
next = ISC_LIST_NEXT(adbname, link);
ISC_LIST_FOREACH_SAFE (adb->names_lru, adbname, link) {
dns_adbname_ref(adbname);
LOCK(&adbname->lock);
/*
@ -1694,14 +1676,8 @@ purge_stale_entries(dns_adb_t *adb, isc_stdtime_t now) {
static void
cleanup_entries(dns_adb_t *adb, isc_stdtime_t now) {
dns_adbentry_t *next = NULL;
RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
adbentry != NULL; adbentry = next)
{
next = ISC_LIST_NEXT(adbentry, link);
ISC_LIST_FOREACH_SAFE (adb->entries_lru, adbentry, link) {
dns_adbentry_ref(adbentry);
LOCK(&adbentry->lock);
maybe_expire_entry(adbentry, now);
@ -2302,9 +2278,7 @@ dump_adb(dns_adb_t *adb, FILE *f, bool debug, isc_stdtime_t now) {
*/
RWLOCK(&adb->names_lock, isc_rwlocktype_write);
for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
name = ISC_LIST_NEXT(name, link))
{
ISC_LIST_FOREACH (adb->names_lru, name, link) {
LOCK(&name->lock);
/*
* Dump the names
@ -2336,9 +2310,7 @@ dump_adb(dns_adb_t *adb, FILE *f, bool debug, isc_stdtime_t now) {
RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
fprintf(f, ";\n; Unassociated entries\n;\n");
for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
adbentry != NULL; adbentry = ISC_LIST_NEXT(adbentry, link))
{
ISC_LIST_FOREACH (adb->entries_lru, adbentry, link) {
LOCK(&adbentry->lock);
if (ISC_LIST_EMPTY(adbentry->nhs)) {
dump_entry(f, adb, adbentry, debug, now);
@ -2449,11 +2421,7 @@ static void
print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
dns_adbnamehooklist_t *list, bool debug,
isc_stdtime_t now) {
dns_adbnamehook_t *nh = NULL;
for (nh = ISC_LIST_HEAD(*list); nh != NULL;
nh = ISC_LIST_NEXT(nh, name_link))
{
ISC_LIST_FOREACH (*list, nh, name_link) {
if (debug) {
fprintf(f, ";\tHook(%s) %p\n", legend, nh);
}
@ -3365,8 +3333,6 @@ again:
void
dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
dns_adbname_t *next = NULL;
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(name != NULL);
@ -3375,10 +3341,7 @@ dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
}
RWLOCK(&adb->names_lock, isc_rwlocktype_write);
for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
adbname != NULL; adbname = next)
{
next = ISC_LIST_NEXT(adbname, link);
ISC_LIST_FOREACH_SAFE (adb->names_lru, adbname, link) {
dns_adbname_ref(adbname);
LOCK(&adbname->lock);
if (dns_name_issubdomain(adbname->name, name)) {

6
lib/dns/db.c
View file

@ -101,11 +101,7 @@ dns__db_shutdown(void) {
static dns_dbimplementation_t *
impfind(const char *name) {
dns_dbimplementation_t *imp;
for (imp = ISC_LIST_HEAD(implementations); imp != NULL;
imp = ISC_LIST_NEXT(imp, link))
{
ISC_LIST_FOREACH (implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}

21
lib/dns/diff.c
View file

@ -170,8 +170,6 @@ dns_diff_size(const dns_diff_t *diff) {
void
dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuplep) {
dns_difftuple_t *ot, *next_ot;
REQUIRE(DNS_DIFF_VALID(diff));
REQUIRE(DNS_DIFFTUPLE_VALID(*tuplep));
@ -187,8 +185,7 @@ dns_diff_appendminimal(dns_diff_t *diff, dns_difftuple_t **tuplep) {
* the one we are doing, there must be a programming
* error. We report it but try to continue anyway.
*/
for (ot = ISC_LIST_HEAD(diff->tuples); ot != NULL; ot = next_ot) {
next_ot = ISC_LIST_NEXT(ot, link);
ISC_LIST_FOREACH_SAFE (diff->tuples, ot, link) {
if (dns_name_caseequal(&ot->name, &(*tuplep)->name) &&
dns_rdata_compare(&ot->rdata, &(*tuplep)->rdata) == 0 &&
ot->ttl == (*tuplep)->ttl)
@ -619,13 +616,10 @@ isc_result_t
dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare) {
unsigned int length = 0;
unsigned int i;
dns_difftuple_t **v;
dns_difftuple_t *p;
dns_difftuple_t **v = NULL;
REQUIRE(DNS_DIFF_VALID(diff));
for (p = ISC_LIST_HEAD(diff->tuples); p != NULL;
p = ISC_LIST_NEXT(p, link))
{
ISC_LIST_FOREACH (diff->tuples, p, link) {
length++;
}
if (length == 0) {
@ -633,7 +627,7 @@ dns_diff_sort(dns_diff_t *diff, dns_diff_compare_func *compare) {
}
v = isc_mem_cget(diff->mctx, length, sizeof(dns_difftuple_t *));
for (i = 0; i < length; i++) {
p = ISC_LIST_HEAD(diff->tuples);
dns_difftuple_t *p = ISC_LIST_HEAD(diff->tuples);
v[i] = p;
ISC_LIST_UNLINK(diff->tuples, p, link);
}
@ -671,9 +665,8 @@ diff_tuple_tordataset(dns_difftuple_t *t, dns_rdata_t *rdata,
}
isc_result_t
dns_diff_print(const dns_diff_t *diff, FILE *file) {
dns_diff_print(dns_diff_t *diff, FILE *file) {
isc_result_t result;
dns_difftuple_t *t;
char *mem = NULL;
unsigned int size = 2048;
const char *op = NULL;
@ -682,9 +675,7 @@ dns_diff_print(const dns_diff_t *diff, FILE *file) {
mem = isc_mem_get(diff->mctx, size);
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (diff->tuples, t, link) {
isc_buffer_t buf;
isc_region_t r;

28
lib/dns/dispatch.c
View file

@ -731,13 +731,10 @@ tcp_recv_add(dns_displist_t *resps, dns_dispentry_t *resp,
static void
tcp_recv_shutdown(dns_dispatch_t *disp, dns_displist_t *resps,
isc_result_t result) {
dns_dispentry_t *resp = NULL, *next = NULL;
/*
* If there are any active responses, shut them all down.
*/
for (resp = ISC_LIST_HEAD(disp->active); resp != NULL; resp = next) {
next = ISC_LIST_NEXT(resp, alink);
ISC_LIST_FOREACH_SAFE (disp->active, resp, alink) {
tcp_recv_add(resps, resp, result);
}
disp->state = DNS_DISPATCHSTATE_CANCELED;
@ -745,10 +742,7 @@ tcp_recv_shutdown(dns_dispatch_t *disp, dns_displist_t *resps,
static void
tcp_recv_processall(dns_displist_t *resps, isc_region_t *region) {
dns_dispentry_t *resp = NULL, *next = NULL;
for (resp = ISC_LIST_HEAD(*resps); resp != NULL; resp = next) {
next = ISC_LIST_NEXT(resp, rlink);
ISC_LIST_FOREACH_SAFE (*resps, resp, rlink) {
ISC_LIST_UNLINK(*resps, resp, rlink);
dispentry_log(resp, ISC_LOG_DEBUG(90), "read callback: %s",
@ -1819,8 +1813,6 @@ resp_connected(void *arg) {
static void
tcp_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
dns_dispatch_t *disp = (dns_dispatch_t *)arg;
dns_dispentry_t *resp = NULL;
dns_dispentry_t *next = NULL;
dns_displist_t resps = ISC_LIST_INITIALIZER;
if (isc_log_wouldlog(90)) {
@ -1853,8 +1845,7 @@ tcp_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
* If there are pending responses, call the connect
* callbacks for all of them.
*/
for (resp = ISC_LIST_HEAD(disp->pending); resp != NULL; resp = next) {
next = ISC_LIST_NEXT(resp, plink);
ISC_LIST_FOREACH_SAFE (disp->pending, resp, plink) {
ISC_LIST_UNLINK(disp->pending, resp, plink);
ISC_LIST_APPEND(resps, resp, rlink);
resp->result = eresult;
@ -1872,24 +1863,23 @@ tcp_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
}
/* Take the oldest active response. */
resp = ISC_LIST_HEAD(disp->active);
if (resp == NULL) {
dns_dispentry_t *oldest = ISC_LIST_HEAD(disp->active);
if (oldest == NULL) {
/* All responses have been canceled */
disp->state = DNS_DISPATCHSTATE_CANCELED;
} else if (eresult == ISC_R_SUCCESS) {
disp->state = DNS_DISPATCHSTATE_CONNECTED;
isc_nmhandle_attach(handle, &disp->handle);
isc_nmhandle_cleartimeout(disp->handle);
if (resp->timeout != 0) {
isc_nmhandle_settimeout(disp->handle, resp->timeout);
if (oldest->timeout != 0) {
isc_nmhandle_settimeout(disp->handle, oldest->timeout);
}
tcp_startrecv(disp, resp);
tcp_startrecv(disp, oldest);
} else {
disp->state = DNS_DISPATCHSTATE_NONE;
}
for (resp = ISC_LIST_HEAD(resps); resp != NULL; resp = next) {
next = ISC_LIST_NEXT(resp, rlink);
ISC_LIST_FOREACH_SAFE (resps, resp, rlink) {
ISC_LIST_UNLINK(resps, resp, rlink);
resp_connected(resp);

11
lib/dns/dlz.c
View file

@ -97,11 +97,7 @@ dns__dlz_shutdown(void) {
*/
static dns_dlzimplementation_t *
dlz_impfind(const char *name) {
dns_dlzimplementation_t *imp;
for (imp = ISC_LIST_HEAD(dlz_implementations); imp != NULL;
imp = ISC_LIST_NEXT(imp, link))
{
ISC_LIST_FOREACH (dlz_implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}
@ -118,7 +114,6 @@ dns_dlzallowzonexfr(dns_view_t *view, const dns_name_t *name,
const isc_sockaddr_t *clientaddr, dns_db_t **dbp) {
isc_result_t result = ISC_R_NOTFOUND;
dns_dlzallowzonexfr_t allowzonexfr;
dns_dlzdb_t *dlzdb;
/*
* Performs checks to make sure data is as we expect it to be.
@ -129,9 +124,7 @@ dns_dlzallowzonexfr(dns_view_t *view, const dns_name_t *name,
/*
* Find a driver in which the zone exists and transfer is supported
*/
for (dlzdb = ISC_LIST_HEAD(view->dlz_searched); dlzdb != NULL;
dlzdb = ISC_LIST_NEXT(dlzdb, link))
{
ISC_LIST_FOREACH (view->dlz_searched, dlzdb, link) {
REQUIRE(DNS_DLZ_VALID(dlzdb));
allowzonexfr = dlzdb->implementation->methods->allowzonexfr;

8
lib/dns/dns64.c
View file

@ -496,9 +496,7 @@ dns_dns64_apply(isc_mem_t *mctx, dns_dns64list_t dns64s, unsigned int count,
for (result = dns_rdataset_first(a); result == ISC_R_SUCCESS;
result = dns_rdataset_next(a))
{
for (dns_dns64_t *dns64 = ISC_LIST_HEAD(dns64s); dns64 != NULL;
dns64 = ISC_LIST_NEXT(dns64, link))
{
ISC_LIST_FOREACH (dns64s, dns64, link) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t *dns64_rdata = NULL;
isc_region_t r;
@ -534,9 +532,7 @@ dns_dns64_apply(isc_mem_t *mctx, dns_dns64list_t dns64s, unsigned int count,
/* No applicable dns64; free the resources */
isc_buffer_free(&buffer);
for (dns_rdata_t *rdata = ISC_LIST_HEAD(aaaalist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(aaaalist->rdata))
{
ISC_LIST_FOREACH_SAFE (aaaalist->rdata, rdata, link) {
ISC_LIST_UNLINK(aaaalist->rdata, rdata, link);
dns_message_puttemprdata(message, &rdata);
}

51
lib/dns/dnssec.c
View file

@ -1353,7 +1353,6 @@ dns_dnssec_findmatchingkeys(const dns_name_t *origin, dns_kasp_t *kasp,
dns_dnsseckeylist_t *keylist) {
isc_result_t result = ISC_R_SUCCESS;
dns_dnsseckeylist_t list;
dns_dnsseckey_t *key = NULL;
char namebuf[DNS_NAME_FORMATSIZE];
isc_buffer_t b;
unsigned int len;
@ -1372,13 +1371,8 @@ dns_dnssec_findmatchingkeys(const dns_name_t *origin, dns_kasp_t *kasp,
RETERR(findmatchingkeys(keydir, namebuf, len, mctx, now,
&list));
} else if (keystores != NULL) {
for (dns_keystore_t *keystore = ISC_LIST_HEAD(*keystores);
keystore != NULL; keystore = ISC_LIST_NEXT(keystore, link))
{
for (dns_kasp_key_t *kkey =
ISC_LIST_HEAD(dns_kasp_keys(kasp));
kkey != NULL; kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (*keystores, keystore, link) {
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
if (dns_kasp_key_keystore(kkey) == keystore) {
const char *directory =
dns_keystore_directory(keystore,
@ -1400,7 +1394,7 @@ dns_dnssec_findmatchingkeys(const dns_name_t *origin, dns_kasp_t *kasp,
}
failure:
while ((key = ISC_LIST_HEAD(list)) != NULL) {
ISC_LIST_FOREACH_SAFE (list, key, link) {
ISC_LIST_UNLINK(list, key, link);
INSIST(key->key != NULL);
dst_key_free(&key->key);
@ -1478,15 +1472,12 @@ mark_active_keys(dns_dnsseckeylist_t *keylist, dns_rdataset_t *rrsigs) {
isc_result_t result = ISC_R_SUCCESS;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_t sigs;
dns_dnsseckey_t *key;
REQUIRE(rrsigs != NULL && dns_rdataset_isassociated(rrsigs));
dns_rdataset_init(&sigs);
dns_rdataset_clone(rrsigs, &sigs);
for (key = ISC_LIST_HEAD(*keylist); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (*keylist, key, link) {
uint16_t keyid, sigid;
dns_secalg_t keyalg, sigalg;
keyid = dst_key_id(key->key);
@ -1533,9 +1524,7 @@ keyfromfile(dns_kasp_t *kasp, const char *keydir, dst_key_t *key, int type,
dst_key_alg(key), type, directory,
mctx, savekey);
} else {
for (dns_kasp_key_t *kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kkey != NULL; kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
dns_keystore_t *ks = dns_kasp_key_keystore(kkey);
directory = dns_keystore_directory(ks, keydir);
result = dst_key_fromfile(dst_key_name(key),
@ -1931,7 +1920,6 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
isc_mem_t *mctx) {
unsigned char keybuf[DST_KEY_MAXSIZE];
isc_result_t result;
dns_dnsseckey_t *key;
dns_ttl_t cdsttl = ttl;
dns_ttl_t cdnskeyttl = ttl;
@ -1947,9 +1935,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
cdnskeyttl = cdnskey->ttl;
}
for (key = ISC_LIST_HEAD(*keys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (*keys, key, link) {
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
dns_name_t *origin = dst_key_name(key->key);
@ -1961,9 +1947,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(key->key, keystr, sizeof(keystr));
for (dns_kasp_digest_t *alg = ISC_LIST_HEAD(*digests);
alg != NULL; alg = ISC_LIST_NEXT(alg, link))
{
ISC_LIST_FOREACH (*digests, alg, link) {
RETERR(add_cds(key, &cdnskeyrdata,
(const char *)keystr, cds,
alg->digest, cdsttl, diff,
@ -2025,9 +2009,7 @@ dns_dnssec_syncupdate(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *rmkeys,
/*
* Unconditionally remove CDS/DNSKEY records for removed keys.
*/
for (key = ISC_LIST_HEAD(*rmkeys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (*rmkeys, key, link) {
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
dns_name_t *origin = dst_key_name(key->key);
@ -2152,7 +2134,6 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
void (*report)(const char *, ...)
ISC_FORMAT_PRINTF(1, 2)) {
isc_result_t result;
dns_dnsseckey_t *key, *key1, *key2, *next;
bool found_ttl = false;
dns_ttl_t ttl = hint_ttl;
@ -2164,9 +2145,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
* Also, if there are keys published in the zone already,
* use their TTL for all subsequent published keys.
*/
for (key = ISC_LIST_HEAD(*keys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (*keys, key, link) {
if (key->source == dns_keysource_user &&
(key->hint_publish || key->force_publish))
{
@ -2186,9 +2165,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
if (!found_ttl && !ISC_LIST_EMPTY(*newkeys)) {
dns_ttl_t shortest = 0;
for (key = ISC_LIST_HEAD(*newkeys); key != NULL;
key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (*newkeys, key, link) {
dns_ttl_t thisttl = dst_key_getttl(key->key);
if (thisttl != 0 &&
(shortest == 0 || thisttl < shortest))
@ -2206,12 +2183,11 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
* Second, scan the list of newly found keys looking for matches
* with known keys, and update accordingly.
*/
for (key1 = ISC_LIST_HEAD(*newkeys); key1 != NULL; key1 = next) {
ISC_LIST_FOREACH_SAFE (*newkeys, key1, link) {
bool key_revoked = false;
char keystr1[DST_KEY_FORMATSIZE];
char keystr2[DST_KEY_FORMATSIZE];
next = ISC_LIST_NEXT(key1, link);
dns_dnsseckey_t *key2 = NULL;
for (key2 = ISC_LIST_HEAD(*keys); key2 != NULL;
key2 = ISC_LIST_NEXT(key2, link))
@ -2366,8 +2342,7 @@ dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
}
/* Free any leftover keys in newkeys */
while (!ISC_LIST_EMPTY(*newkeys)) {
key1 = ISC_LIST_HEAD(*newkeys);
ISC_LIST_FOREACH_SAFE (*newkeys, key1, link) {
ISC_LIST_UNLINK(*newkeys, key1, link);
dns_dnsseckey_destroy(mctx, &key1);
}

6
lib/dns/dyndb.c
View file

@ -70,11 +70,7 @@ dns__dyndb_shutdown(void) {
static dyndb_implementation_t *
impfind(const char *name) {
dyndb_implementation_t *imp;
for (imp = ISC_LIST_HEAD(dyndb_implementations); imp != NULL;
imp = ISC_LIST_NEXT(imp, link))
{
ISC_LIST_FOREACH (dyndb_implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}

17
lib/dns/forward.c
View file

@ -91,17 +91,15 @@ dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_forwarderlist_t *fwdrs, dns_fwdpolicy_t fwdpolicy) {
isc_result_t result;
dns_forwarders_t *forwarders = NULL;
dns_forwarder_t *fwd = NULL, *nfwd = NULL;
dns_qp_t *qp = NULL;
REQUIRE(VALID_FWDTABLE(fwdtable));
forwarders = new_forwarders(fwdtable->mctx, name, fwdpolicy);
for (fwd = ISC_LIST_HEAD(*fwdrs); fwd != NULL;
fwd = ISC_LIST_NEXT(fwd, link))
{
nfwd = isc_mem_get(fwdtable->mctx, sizeof(*nfwd));
ISC_LIST_FOREACH (*fwdrs, fwd, link) {
dns_forwarder_t *nfwd = isc_mem_get(fwdtable->mctx,
sizeof(*nfwd));
*nfwd = *fwd;
if (fwd->tlsname != NULL) {
@ -131,18 +129,15 @@ dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
isc_sockaddrlist_t *addrs, dns_fwdpolicy_t fwdpolicy) {
isc_result_t result;
dns_forwarders_t *forwarders = NULL;
dns_forwarder_t *fwd = NULL;
isc_sockaddr_t *sa = NULL;
dns_qp_t *qp = NULL;
REQUIRE(VALID_FWDTABLE(fwdtable));
forwarders = new_forwarders(fwdtable->mctx, name, fwdpolicy);
for (sa = ISC_LIST_HEAD(*addrs); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
fwd = isc_mem_get(fwdtable->mctx, sizeof(*fwd));
ISC_LIST_FOREACH (*addrs, sa, link) {
dns_forwarder_t *fwd = isc_mem_get(fwdtable->mctx,
sizeof(*fwd));
*fwd = (dns_forwarder_t){ .addr = *sa,
.link = ISC_LINK_INITIALIZER };
ISC_LIST_APPEND(forwarders->fwdrs, fwd, link);

2
lib/dns/include/dns/diff.h
View file

@ -272,7 +272,7 @@ dns_diff_load(const dns_diff_t *diff, dns_rdatacallbacks_t *callbacks);
*/
isc_result_t
dns_diff_print(const dns_diff_t *diff, FILE *file);
dns_diff_print(dns_diff_t *diff, FILE *file);
/*%<
* Print the differences to 'file' or if 'file' is NULL via the

4
lib/dns/include/dns/rdatalist.h
View file

@ -127,7 +127,7 @@ unsigned int
dns_rdatalist_count(dns_rdataset_t *rdataset);
isc_result_t
dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name);
dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name);
isc_result_t
dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
@ -135,7 +135,7 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataset_t *negsig DNS__DB_FLARG);
isc_result_t
dns_rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name);
dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
isc_result_t
dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,

12
lib/dns/include/dns/rdataset.h
View file

@ -82,13 +82,11 @@ struct dns_rdatasetmethods {
void (*clone)(dns_rdataset_t *source,
dns_rdataset_t *target DNS__DB_FLARG);
unsigned int (*count)(dns_rdataset_t *rdataset);
isc_result_t (*addnoqname)(dns_rdataset_t *rdataset,
const dns_name_t *name);
isc_result_t (*addnoqname)(dns_rdataset_t *rdataset, dns_name_t *name);
isc_result_t (*getnoqname)(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataset_t *neg,
dns_rdataset_t *negsig DNS__DB_FLARG);
isc_result_t (*addclosest)(dns_rdataset_t *rdataset,
const dns_name_t *name);
isc_result_t (*addclosest)(dns_rdataset_t *rdataset, dns_name_t *name);
isc_result_t (*getclosest)(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataset_t *neg,
dns_rdataset_t *negsig DNS__DB_FLARG);
@ -210,8 +208,8 @@ struct dns_rdataset {
* These refer to names passed in by the caller of
* dns_rdataset_addnoqname() and _addclosest()
*/
const struct dns_name *noqname, *closest;
dns_dbnode_t *node;
struct dns_name *noqname, *closest;
dns_dbnode_t *node;
} rdlist;
};
};
@ -589,7 +587,7 @@ dns__rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
*/
isc_result_t
dns_rdataset_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name);
dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
/*%<
* Associate a closest encloset proof with this record.
* Sets #DNS_RDATASETATTR_CLOSEST if successful.

9
lib/dns/journal.c
View file

@ -1189,7 +1189,6 @@ failure:
isc_result_t
dns_journal_writediff(dns_journal_t *j, dns_diff_t *diff) {
dns_difftuple_t *t;
isc_buffer_t buffer;
void *mem = NULL;
uint64_t size = 0;
@ -1208,9 +1207,7 @@ dns_journal_writediff(dns_journal_t *j, dns_diff_t *diff) {
* Pass 1: determine the buffer size needed, and
* keep track of SOA serial numbers.
*/
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (diff->tuples, t, link) {
if (t->rdata.type == dns_rdatatype_soa) {
if (j->x.n_soa < 2) {
j->x.pos[j->x.n_soa].serial =
@ -1240,9 +1237,7 @@ dns_journal_writediff(dns_journal_t *j, dns_diff_t *diff) {
/*
* Pass 2. Write RRs to buffer.
*/
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (diff->tuples, t, link) {
/*
* Write the RR header.
*/

31
lib/dns/kasp.c
View file

@ -67,22 +67,15 @@ dns_kasp_attach(dns_kasp_t *source, dns_kasp_t **targetp) {
static void
destroy(dns_kasp_t *kasp) {
dns_kasp_key_t *key, *key_next;
dns_kasp_digest_t *digest, *digest_next;
REQUIRE(!ISC_LINK_LINKED(kasp, link));
for (key = ISC_LIST_HEAD(kasp->keys); key != NULL; key = key_next) {
key_next = ISC_LIST_NEXT(key, link);
ISC_LIST_FOREACH_SAFE (kasp->keys, key, link) {
ISC_LIST_UNLINK(kasp->keys, key, link);
dns_kasp_key_destroy(key);
}
INSIST(ISC_LIST_EMPTY(kasp->keys));
for (digest = ISC_LIST_HEAD(kasp->digests); digest != NULL;
digest = digest_next)
{
digest_next = ISC_LIST_NEXT(digest, link);
ISC_LIST_FOREACH_SAFE (kasp->digests, digest, link) {
ISC_LIST_UNLINK(kasp->digests, digest, link);
isc_mem_put(kasp->mctx, digest, sizeof(*digest));
}
@ -349,28 +342,20 @@ dns_kasp_setparentpropagationdelay(dns_kasp_t *kasp, uint32_t value) {
isc_result_t
dns_kasplist_find(dns_kasplist_t *list, const char *name, dns_kasp_t **kaspp) {
dns_kasp_t *kasp = NULL;
REQUIRE(kaspp != NULL && *kaspp == NULL);
if (list == NULL) {
return ISC_R_NOTFOUND;
}
for (kasp = ISC_LIST_HEAD(*list); kasp != NULL;
kasp = ISC_LIST_NEXT(kasp, link))
{
ISC_LIST_FOREACH (*list, kasp, link) {
if (strcmp(kasp->name, name) == 0) {
break;
dns_kasp_attach(kasp, kaspp);
return ISC_R_SUCCESS;
}
}
if (kasp == NULL) {
return ISC_R_NOTFOUND;
}
dns_kasp_attach(kasp, kaspp);
return ISC_R_SUCCESS;
return ISC_R_NOTFOUND;
}
dns_kasp_keylist_t
@ -667,9 +652,7 @@ dns_kasp_adddigest(dns_kasp_t *kasp, dns_dsdigest_t alg) {
}
/* Suppress duplicates */
for (dns_kasp_digest_t *d = ISC_LIST_HEAD(kasp->digests); d != NULL;
d = ISC_LIST_NEXT(d, link))
{
ISC_LIST_FOREACH (kasp->digests, d, link) {
if (d->digest == alg) {
return;
}

110
lib/dns/keymgr.c
View file

@ -452,9 +452,7 @@ keymgr_keyid_conflict(dst_key_t *newkey, uint16_t min, uint16_t max,
return true;
}
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keys); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keys, dkey, link) {
if (dst_key_alg(dkey->key) != alg) {
continue;
}
@ -659,9 +657,7 @@ keymgr_direct_dep(dst_key_t *d, dst_key_t *k) {
*/
static bool
keymgr_dep(dst_key_t *k, dns_dnsseckeylist_t *keyring, uint32_t *dep) {
for (dns_dnsseckey_t *d = ISC_LIST_HEAD(*keyring); d != NULL;
d = ISC_LIST_NEXT(d, link))
{
ISC_LIST_FOREACH (*keyring, d, link) {
/*
* Check if k is a direct successor of d, e.g. d depends on k.
*/
@ -736,9 +732,7 @@ keymgr_key_is_successor(dst_key_t *x, dst_key_t *z, dst_key_t *key, int type,
zst[i] = state;
}
for (dns_dnsseckey_t *y = ISC_LIST_HEAD(*keyring); y != NULL;
y = ISC_LIST_NEXT(y, link))
{
ISC_LIST_FOREACH (*keyring, y, link) {
if (dst_key_id(y->key) == dst_key_id(z)) {
continue;
}
@ -781,9 +775,7 @@ keymgr_key_exists_with_state(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
dst_key_state_t states[NUM_KEYSTATES],
dst_key_state_t states2[NUM_KEYSTATES],
bool check_successor, bool match_algorithms) {
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
if (match_algorithms &&
(dst_key_alg(dkey->key) != dst_key_alg(key->key)))
{
@ -805,9 +797,7 @@ keymgr_key_exists_with_state(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
* We have to make sure that the key we are checking, also
* has a successor relationship with another key.
*/
for (dns_dnsseckey_t *skey = ISC_LIST_HEAD(*keyring);
skey != NULL; skey = ISC_LIST_NEXT(skey, link))
{
ISC_LIST_FOREACH (*keyring, skey, link) {
if (skey == dkey) {
continue;
}
@ -839,9 +829,7 @@ keymgr_key_exists_with_state(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
static bool
keymgr_key_has_successor(dns_dnsseckey_t *predecessor,
dns_dnsseckeylist_t *keyring) {
for (dns_dnsseckey_t *successor = ISC_LIST_HEAD(*keyring);
successor != NULL; successor = ISC_LIST_NEXT(successor, link))
{
ISC_LIST_FOREACH (*keyring, successor, link) {
if (keymgr_direct_dep(predecessor->key, successor->key)) {
return true;
}
@ -869,9 +857,7 @@ keymgr_ds_hidden_or_chained(dns_dnsseckeylist_t *keyring, dns_dnsseckey_t *key,
/* successor n/a */
dst_key_state_t na[NUM_KEYSTATES] = { NA, NA, NA, NA };
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
if (match_algorithms &&
(dst_key_alg(dkey->key) != dst_key_alg(key->key)))
{
@ -938,9 +924,7 @@ keymgr_dnskey_hidden_or_chained(dns_dnsseckeylist_t *keyring,
/* successor n/a */
dst_key_state_t na[NUM_KEYSTATES] = { NA, NA, NA, NA };
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
if (match_algorithms &&
(dst_key_alg(dkey->key) != dst_key_alg(key->key)))
{
@ -1472,9 +1456,7 @@ transition:
changed = false;
/* For all keys in the zone. */
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(dkey->key, keystr, sizeof(keystr));
@ -1739,8 +1721,8 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
char keystr[DST_KEY_FORMATSIZE];
isc_stdtime_t retire = 0, active = 0, prepub = 0;
dns_dnsseckey_t *new_key = NULL;
dns_dnsseckey_t *candidate = NULL;
dst_key_t *dst_key = NULL;
bool keycreated = false;
/* Do we need to create a successor for the active key? */
if (active_key != NULL) {
@ -1838,18 +1820,17 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
* Check if there is a key available in pool because keys
* may have been pregenerated with dnssec-keygen.
*/
for (candidate = ISC_LIST_HEAD(*keyring); candidate != NULL;
candidate = ISC_LIST_NEXT(candidate, link))
{
ISC_LIST_FOREACH (*keyring, candidate, link) {
if (dns_kasp_key_match(kaspkey, candidate) &&
dst_key_is_unused(candidate->key))
{
/* Found a candidate in keyring. */
new_key = candidate;
break;
}
}
if (candidate == NULL) {
if (new_key == NULL) {
/* No key available in keyring, create a new one. */
bool csk = (dns_kasp_key_ksk(kaspkey) &&
dns_kasp_key_zsk(kaspkey));
@ -1864,8 +1845,7 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
dst_key_settime(dst_key, DST_TIME_CREATED, now);
dns_dnsseckey_create(mctx, &dst_key, &new_key);
keymgr_key_init(new_key, kasp, now, csk);
} else {
new_key = candidate;
keycreated = true;
}
dst_key_setnum(new_key->key, DST_NUM_LIFETIME, lifetime);
@ -1936,7 +1916,7 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
dns_dnssec_get_hints(new_key, now);
new_key->source = dns_keysource_repository;
INSIST(!new_key->legacy);
if (candidate == NULL) {
if (keycreated) {
ISC_LIST_APPEND(*newkeys, new_key, link);
}
@ -1945,7 +1925,7 @@ keymgr_key_rollover(dns_kasp_key_t *kaspkey, dns_dnsseckey_t *active_key,
isc_log_write(DNS_LOGCATEGORY_DNSSEC, DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO, "keymgr: DNSKEY %s (%s) %s for policy %s",
keystr, keymgr_keyrole(new_key->key),
(candidate != NULL) ? "selected" : "created",
keycreated ? "created" : "selected",
dns_kasp_getname(kasp));
return ISC_R_SUCCESS;
}
@ -2042,9 +2022,7 @@ static bool
dst_key_doublematch(dns_dnsseckey_t *key, dns_kasp_t *kasp) {
int matches = 0;
for (dns_kasp_key_t *kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kkey != NULL; kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
if (dns_kasp_key_match(kkey, key)) {
matches++;
}
@ -2063,7 +2041,6 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
dns_kasp_t *kasp, isc_stdtime_t now, isc_stdtime_t *nexttime) {
isc_result_t result = ISC_R_SUCCESS;
dns_dnsseckeylist_t newkeys;
dns_kasp_key_t *kkey;
dns_dnsseckey_t *newkey = NULL;
bool secure_to_insecure = false;
int numkeys = 0;
@ -2091,18 +2068,14 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
namebuf, dns_kasp_getname(kasp));
}
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring);
dkey != NULL; dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
dst_key_format(dkey->key, keystr, sizeof(keystr));
isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
"keymgr: keyring: %s (policy %s)", keystr,
dns_kasp_getname(kasp));
}
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*dnskeys);
dkey != NULL; dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*dnskeys, dkey, link) {
dst_key_format(dkey->key, keystr, sizeof(keystr));
isc_log_write(DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_DEBUG(1),
@ -2111,23 +2084,17 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
}
}
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*dnskeys); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*dnskeys, dkey, link) {
numkeys++;
}
/* Do we need to remove keys? */
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
bool found_match = false;
keymgr_key_init(dkey, kasp, now, (numkeys == 1));
for (kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp)); kkey != NULL;
kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
if (dns_kasp_key_match(kkey, dkey)) {
found_match = true;
break;
@ -2159,17 +2126,13 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
}
/* Create keys according to the policy, if come in short. */
for (kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp)); kkey != NULL;
kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
uint32_t lifetime = dns_kasp_key_lifetime(kkey);
dns_dnsseckey_t *active_key = NULL;
bool rollover_allowed = true;
/* Do we have keys available for this kasp key? */
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring);
dkey != NULL; dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
if (dns_kasp_key_match(kkey, dkey)) {
/* Found a match. */
dst_key_format(dkey->key, keystr,
@ -2229,10 +2192,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
* a successor key. Check if we have an appropriate
* state file.
*/
for (dns_dnsseckey_t *dnskey = ISC_LIST_HEAD(*dnskeys);
dnskey != NULL;
dnskey = ISC_LIST_NEXT(dnskey, link))
{
ISC_LIST_FOREACH (*dnskeys, dnskey, link) {
if (dns_kasp_key_match(kkey, dnskey)) {
/* Found a match. */
dst_key_format(dnskey->key, keystr,
@ -2275,9 +2235,7 @@ dns_keymgr_run(const dns_name_t *origin, dns_rdataclass_t rdclass,
keymgr_update(keyring, kasp, now, nexttime, secure_to_insecure);
/* Store key states and update hints. */
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
bool modified = dst_key_ismodified(dkey->key);
if (dst_key_getttl(dkey->key) != dns_kasp_dnskeyttl(kasp)) {
dst_key_setttl(dkey->key, dns_kasp_dnskeyttl(kasp));
@ -2340,9 +2298,7 @@ keymgr_checkds(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(keyring != NULL);
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
isc_result_t ret;
bool ksk = false;
@ -2589,9 +2545,7 @@ dns_keymgr_status(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
isc_stdtime_tostring(now, timestr, sizeof(timestr));
RETERR(isc_buffer_printf(&buf, "%s\n", timestr));
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
char algstr[DNS_NAME_FORMATSIZE];
bool ksk = false, zsk = false;
@ -2659,9 +2613,7 @@ dns_keymgr_rollover(dns_kasp_t *kasp, dns_dnsseckeylist_t *keyring,
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(keyring != NULL);
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
if (dst_key_id(dkey->key) != id) {
continue;
}
@ -2734,9 +2686,7 @@ dns_keymgr_offline(const dns_name_t *origin, dns_dnsseckeylist_t *keyring,
*nexttime = 0;
/* Store key states and update hints. */
for (dns_dnsseckey_t *dkey = ISC_LIST_HEAD(*keyring); dkey != NULL;
dkey = ISC_LIST_NEXT(dkey, link))
{
ISC_LIST_FOREACH (*keyring, dkey, link) {
bool modified;
bool ksk = false, zsk = false;
isc_stdtime_t active = 0, published = 0, inactive = 0,

16
lib/dns/keystore.c
View file

@ -255,26 +255,18 @@ dns_keystore_keygen(dns_keystore_t *keystore, const dns_name_t *origin,
isc_result_t
dns_keystorelist_find(dns_keystorelist_t *list, const char *name,
dns_keystore_t **kspp) {
dns_keystore_t *keystore = NULL;
REQUIRE(kspp != NULL && *kspp == NULL);
if (list == NULL) {
return ISC_R_NOTFOUND;
}
for (keystore = ISC_LIST_HEAD(*list); keystore != NULL;
keystore = ISC_LIST_NEXT(keystore, link))
{
ISC_LIST_FOREACH (*list, keystore, link) {
if (strcmp(keystore->name, name) == 0) {
break;
dns_keystore_attach(keystore, kspp);
return ISC_R_SUCCESS;
}
}
if (keystore == NULL) {
return ISC_R_NOTFOUND;
}
dns_keystore_attach(keystore, kspp);
return ISC_R_SUCCESS;
return ISC_R_NOTFOUND;
}

21
lib/dns/keytable.c
View file

@ -101,13 +101,9 @@ static dns_rdatasetmethods_t methods = {
static void
destroy_keynode(dns_keynode_t *knode) {
dns_rdata_t *rdata = NULL;
isc_rwlock_destroy(&knode->rwlock);
if (knode->dslist != NULL) {
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_HEAD(knode->dslist->rdata))
{
ISC_LIST_FOREACH_SAFE (knode->dslist->rdata, rdata, link) {
ISC_LIST_UNLINK(knode->dslist->rdata, rdata, link);
isc_mem_put(knode->mctx, rdata->data,
DNS_DS_BUFFERSIZE);
@ -171,7 +167,7 @@ ISC_REFCOUNT_IMPL(dns_keytable, destroy_keytable);
static void
add_ds(dns_keynode_t *knode, dns_rdata_ds_t *ds, isc_mem_t *mctx) {
isc_result_t result;
dns_rdata_t *dsrdata = NULL, *rdata = NULL;
dns_rdata_t *dsrdata = NULL;
void *data = NULL;
bool exists = false;
isc_buffer_t b;
@ -205,9 +201,7 @@ add_ds(dns_keynode_t *knode, dns_rdata_ds_t *ds, isc_mem_t *mctx) {
knode->dsset.trust = dns_trust_ultimate;
}
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
{
ISC_LIST_FOREACH (knode->dslist->rdata, rdata, link) {
if (dns_rdata_compare(rdata, dsrdata) == 0) {
exists = true;
break;
@ -229,7 +223,6 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
dns_rdata_ds_t *ds) {
isc_result_t result;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t *rdata = NULL;
dns_keynode_t *newnode = NULL;
unsigned char data[DNS_DS_BUFFERSIZE];
bool found = false;
@ -251,9 +244,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
return result;
}
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
{
ISC_LIST_FOREACH (knode->dslist->rdata, rdata, link) {
if (dns_rdata_compare(rdata, &dsrdata) == 0) {
found = true;
break;
@ -274,9 +265,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
*/
newnode = new_keynode(&knode->name, NULL, keytable, knode->managed,
knode->initial);
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
{
ISC_LIST_FOREACH (knode->dslist->rdata, rdata, link) {
if (dns_rdata_compare(rdata, &dsrdata) != 0) {
dns_rdata_ds_t ds0;
result = dns_rdata_tostruct(rdata, &ds0, NULL);

5
lib/dns/order.c
View file

@ -100,12 +100,9 @@ match(const dns_name_t *name1, const dns_name_t *name2) {
unsigned int
dns_order_find(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass) {
dns_order_ent_t *ent;
REQUIRE(DNS_ORDER_VALID(order));
for (ent = ISC_LIST_HEAD(order->ents); ent != NULL;
ent = ISC_LIST_NEXT(ent, link))
{
ISC_LIST_FOREACH (order->ents, ent, link) {
if (ent->rdtype != rdtype && ent->rdtype != dns_rdatatype_any) {
continue;
}

18
lib/dns/peer.c
View file

@ -182,26 +182,18 @@ peerlist_delete(dns_peerlist_t **list) {
void
dns_peerlist_addpeer(dns_peerlist_t *peers, dns_peer_t *peer) {
dns_peer_t *p = NULL;
dns_peer_attach(peer, &p);
/*
* More specifics to front of list.
*/
for (p = ISC_LIST_HEAD(peers->elements); p != NULL;
p = ISC_LIST_NEXT(p, next))
{
dns_peer_attach(peer, &(dns_peer_t *){ NULL });
ISC_LIST_FOREACH (peers->elements, p, next) {
if (p->prefixlen < peer->prefixlen) {
break;
ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
return;
}
}
if (p != NULL) {
ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
} else {
ISC_LIST_APPEND(peers->elements, peer, next);
}
ISC_LIST_APPEND(peers->elements, peer, next);
}
isc_result_t

4
lib/dns/qp.c
View file

@ -790,9 +790,7 @@ marksweep_chunks(dns_qpmulti_t *multi) {
dns_qp_t *qpw = &multi->writer;
for (dns_qpsnap_t *qps = ISC_LIST_HEAD(multi->snapshots); qps != NULL;
qps = ISC_LIST_NEXT(qps, link))
{
ISC_LIST_FOREACH (multi->snapshots, qps, link) {
for (dns_qpchunk_t chunk = 0; chunk < qps->chunk_max; chunk++) {
if (qps->base->ptr[chunk] != NULL) {
INSIST(qps->base->ptr[chunk] ==

18
lib/dns/qpzone.c
View file

@ -1111,8 +1111,6 @@ unlock:
static void
cleanup_nondirty(qpz_version_t *version, qpz_changedlist_t *cleanup_list) {
qpz_changed_t *changed = NULL, *next_changed = NULL;
/*
* If the changed record is dirty, then an update created multiple
* versions of a given rdataset. We keep this list until we're the
@ -1124,10 +1122,7 @@ cleanup_nondirty(qpz_version_t *version, qpz_changedlist_t *cleanup_list) {
*
* The caller must be holding the database lock.
*/
for (changed = ISC_LIST_HEAD(version->changed_list); changed != NULL;
changed = next_changed)
{
next_changed = ISC_LIST_NEXT(changed, link);
ISC_LIST_FOREACH_SAFE (version->changed_list, changed, link) {
if (!changed->dirty) {
ISC_LIST_UNLINK(version->changed_list, changed, link);
ISC_LIST_APPEND(*cleanup_list, changed, link);
@ -1322,10 +1317,8 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
qpz_version_t *least_greater = NULL;
qpznode_t *node = NULL;
bool rollback = false;
qpz_changed_t *changed = NULL, *next_changed = NULL;
qpz_changedlist_t cleanup_list;
dns_slabheaderlist_t resigned_list;
dns_slabheader_t *header = NULL;
uint32_t serial, least_serial;
REQUIRE(VALID_QPZONE(qpdb));
@ -1499,9 +1492,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
/*
* Commit/rollback re-signed headers.
*/
for (header = ISC_LIST_HEAD(resigned_list); header != NULL;
header = ISC_LIST_HEAD(resigned_list))
{
ISC_LIST_FOREACH_SAFE (resigned_list, header, link) {
isc_rwlock_t *nlock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@ -1522,13 +1513,10 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
return;
}
for (changed = ISC_LIST_HEAD(cleanup_list); changed != NULL;
changed = next_changed)
{
ISC_LIST_FOREACH_SAFE (cleanup_list, changed, link) {
isc_rwlock_t *nlock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
next_changed = ISC_LIST_NEXT(changed, link);
node = changed->node;
nlock = &qpdb->buckets[node->locknum].lock;

78
lib/dns/rdatalist.c
View file

@ -155,8 +155,7 @@ dns_rdatalist_clone(dns_rdataset_t *source,
unsigned int
dns_rdatalist_count(dns_rdataset_t *rdataset) {
dns_rdatalist_t *rdatalist;
dns_rdata_t *rdata;
dns_rdatalist_t *rdatalist = NULL;
unsigned int count;
REQUIRE(rdataset != NULL);
@ -164,9 +163,7 @@ dns_rdatalist_count(dns_rdataset_t *rdataset) {
rdatalist = rdataset->rdlist.list;
count = 0;
for (rdata = ISC_LIST_HEAD(rdatalist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
{
ISC_LIST_FOREACH (rdatalist->rdata, rdata, link) {
count++;
}
@ -174,17 +171,14 @@ dns_rdatalist_count(dns_rdataset_t *rdataset) {
}
isc_result_t
dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) {
dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
dns_rdataset_t *neg = NULL;
dns_rdataset_t *negsig = NULL;
dns_rdataset_t *rdset;
dns_ttl_t ttl;
REQUIRE(rdataset != NULL);
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
rdset = ISC_LIST_NEXT(rdset, link))
{
ISC_LIST_FOREACH (name->list, rdset, link) {
if (rdset->rdclass != rdataset->rdclass) {
continue;
}
@ -198,9 +192,7 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) {
return ISC_R_NOTFOUND;
}
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
rdset = ISC_LIST_NEXT(rdset, link))
{
ISC_LIST_FOREACH (name->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == neg->type)
{
@ -211,6 +203,7 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) {
if (negsig == NULL) {
return ISC_R_NOTFOUND;
}
/*
* Minimise ttl.
*/
@ -234,7 +227,7 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataclass_t rdclass;
dns_rdataset_t *tneg = NULL;
dns_rdataset_t *tnegsig = NULL;
const dns_name_t *noqname;
dns_name_t *noqname = NULL;
REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
@ -244,29 +237,25 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
(void)dns_name_dynamic(noqname); /* Sanity Check. */
for (rdataset = ISC_LIST_HEAD(noqname->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->rdclass != rdclass) {
ISC_LIST_FOREACH (noqname->list, rdset, link) {
if (rdset->rdclass != rdclass) {
continue;
}
if (rdataset->type == dns_rdatatype_nsec ||
rdataset->type == dns_rdatatype_nsec3)
if (rdset->type == dns_rdatatype_nsec ||
rdset->type == dns_rdatatype_nsec3)
{
tneg = rdataset;
tneg = rdset;
}
}
if (tneg == NULL) {
return ISC_R_NOTFOUND;
}
for (rdataset = ISC_LIST_HEAD(noqname->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == dns_rdatatype_rrsig &&
rdataset->covers == tneg->type)
ISC_LIST_FOREACH (noqname->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == tneg->type)
{
tnegsig = rdataset;
tnegsig = rdset;
}
}
if (tnegsig == NULL) {
@ -280,17 +269,14 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
}
isc_result_t
dns_rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
dns_rdataset_t *neg = NULL;
dns_rdataset_t *negsig = NULL;
dns_rdataset_t *rdset;
dns_ttl_t ttl;
REQUIRE(rdataset != NULL);
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
rdset = ISC_LIST_NEXT(rdset, link))
{
ISC_LIST_FOREACH (name->list, rdset, link) {
if (rdset->rdclass != rdataset->rdclass) {
continue;
}
@ -304,9 +290,7 @@ dns_rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
return ISC_R_NOTFOUND;
}
for (rdset = ISC_LIST_HEAD(name->list); rdset != NULL;
rdset = ISC_LIST_NEXT(rdset, link))
{
ISC_LIST_FOREACH (name->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == neg->type)
{
@ -340,7 +324,7 @@ dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataclass_t rdclass;
dns_rdataset_t *tneg = NULL;
dns_rdataset_t *tnegsig = NULL;
const dns_name_t *closest;
dns_name_t *closest = NULL;
REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0);
@ -350,29 +334,25 @@ dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
(void)dns_name_dynamic(closest); /* Sanity Check. */
for (rdataset = ISC_LIST_HEAD(closest->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->rdclass != rdclass) {
ISC_LIST_FOREACH (closest->list, rdset, link) {
if (rdset->rdclass != rdclass) {
continue;
}
if (rdataset->type == dns_rdatatype_nsec ||
rdataset->type == dns_rdatatype_nsec3)
if (rdset->type == dns_rdatatype_nsec ||
rdset->type == dns_rdatatype_nsec3)
{
tneg = rdataset;
tneg = rdset;
}
}
if (tneg == NULL) {
return ISC_R_NOTFOUND;
}
for (rdataset = ISC_LIST_HEAD(closest->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == dns_rdatatype_rrsig &&
rdataset->covers == tneg->type)
ISC_LIST_FOREACH (closest->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == tneg->type)
{
tnegsig = rdataset;
tnegsig = rdset;
}
}
if (tnegsig == NULL) {

2
lib/dns/rdataset.c
View file

@ -540,7 +540,7 @@ dns__rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
}
isc_result_t
dns_rdataset_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->addclosest == NULL) {

319
lib/dns/resolver.c
View file

@ -1083,8 +1083,6 @@ fctx_cancelquery(resquery_t **queryp, isc_time_t *finish, bool no_response,
bool age_untried) {
resquery_t *query = NULL;
fetchctx_t *fctx = NULL;
dns_adbfind_t *find = NULL;
dns_adbaddrinfo_t *addrinfo;
isc_stdtime_t now = isc_stdtime_now();
REQUIRE(queryp != NULL);
@ -1213,10 +1211,7 @@ fctx_cancelquery(resquery_t **queryp, isc_time_t *finish, bool no_response,
* Age RTTs of servers not tried.
*/
if (finish != NULL || age_untried) {
for (addrinfo = ISC_LIST_HEAD(fctx->forwaddrs);
addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->forwaddrs, addrinfo, publink) {
if (UNMARKED(addrinfo)) {
dns_adb_agesrtt(fctx->adb, addrinfo, now);
}
@ -1224,13 +1219,8 @@ fctx_cancelquery(resquery_t **queryp, isc_time_t *finish, bool no_response,
}
if ((finish != NULL || age_untried) && TRIEDFIND(fctx)) {
for (find = ISC_LIST_HEAD(fctx->finds); find != NULL;
find = ISC_LIST_NEXT(find, publink))
{
for (addrinfo = ISC_LIST_HEAD(find->list);
addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->finds, find, publink) {
ISC_LIST_FOREACH (find->list, addrinfo, publink) {
if (UNMARKED(addrinfo)) {
dns_adb_agesrtt(fctx->adb, addrinfo,
now);
@ -1240,20 +1230,13 @@ fctx_cancelquery(resquery_t **queryp, isc_time_t *finish, bool no_response,
}
if ((finish != NULL || age_untried) && TRIEDALT(fctx)) {
for (addrinfo = ISC_LIST_HEAD(fctx->altaddrs); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->altaddrs, addrinfo, publink) {
if (UNMARKED(addrinfo)) {
dns_adb_agesrtt(fctx->adb, addrinfo, now);
}
}
for (find = ISC_LIST_HEAD(fctx->altfinds); find != NULL;
find = ISC_LIST_NEXT(find, publink))
{
for (addrinfo = ISC_LIST_HEAD(find->list);
addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->altfinds, find, publink) {
ISC_LIST_FOREACH (find->list, addrinfo, publink) {
if (UNMARKED(addrinfo)) {
dns_adb_agesrtt(fctx->adb, addrinfo,
now);
@ -1281,42 +1264,28 @@ fctx_cancelquery(resquery_t **queryp, isc_time_t *finish, bool no_response,
static void
fctx_cleanup(fetchctx_t *fctx) {
dns_adbfind_t *find = NULL, *next_find = NULL;
dns_adbaddrinfo_t *addr = NULL, *next_addr = NULL;
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
for (find = ISC_LIST_HEAD(fctx->finds); find != NULL; find = next_find)
{
next_find = ISC_LIST_NEXT(find, publink);
ISC_LIST_FOREACH_SAFE (fctx->finds, find, publink) {
ISC_LIST_UNLINK(fctx->finds, find, publink);
dns_adb_destroyfind(&find);
fetchctx_unref(fctx);
}
fctx->find = NULL;
for (find = ISC_LIST_HEAD(fctx->altfinds); find != NULL;
find = next_find)
{
next_find = ISC_LIST_NEXT(find, publink);
ISC_LIST_FOREACH_SAFE (fctx->altfinds, find, publink) {
ISC_LIST_UNLINK(fctx->altfinds, find, publink);
dns_adb_destroyfind(&find);
fetchctx_unref(fctx);
}
fctx->altfind = NULL;
for (addr = ISC_LIST_HEAD(fctx->forwaddrs); addr != NULL;
addr = next_addr)
{
next_addr = ISC_LIST_NEXT(addr, publink);
ISC_LIST_FOREACH_SAFE (fctx->forwaddrs, addr, publink) {
ISC_LIST_UNLINK(fctx->forwaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
}
for (addr = ISC_LIST_HEAD(fctx->altaddrs); addr != NULL;
addr = next_addr)
{
next_addr = ISC_LIST_NEXT(addr, publink);
ISC_LIST_FOREACH_SAFE (fctx->altaddrs, addr, publink) {
ISC_LIST_UNLINK(fctx->altaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
}
@ -1324,7 +1293,6 @@ fctx_cleanup(fetchctx_t *fctx) {
static void
fctx_cancelqueries(fetchctx_t *fctx, bool no_response, bool age_untried) {
resquery_t *query = NULL, *next_query = NULL;
ISC_LIST(resquery_t) queries;
FCTXTRACE("cancelqueries");
@ -1339,10 +1307,7 @@ fctx_cancelqueries(fetchctx_t *fctx, bool no_response, bool age_untried) {
ISC_LIST_MOVE(queries, fctx->queries);
UNLOCK(&fctx->lock);
for (query = ISC_LIST_HEAD(queries); query != NULL; query = next_query)
{
next_query = ISC_LIST_NEXT(query, link);
ISC_LIST_FOREACH_SAFE (queries, query, link) {
/*
* Note that we have to unlink the query here,
* because if it's still linked in fctx_cancelquery(),
@ -1532,7 +1497,6 @@ spillattimer_countdown(void *arg);
static void
fctx_sendevents(fetchctx_t *fctx, isc_result_t result) {
dns_fetchresponse_t *resp = NULL, *next = NULL;
unsigned int count = 0;
bool logit = false;
isc_time_t now;
@ -1553,8 +1517,7 @@ fctx_sendevents(fetchctx_t *fctx, isc_result_t result) {
now = isc_time_now();
fctx->duration = isc_time_microdiff(&now, &fctx->start);
for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL; resp = next) {
next = ISC_LIST_NEXT(resp, link);
ISC_LIST_FOREACH_SAFE (fctx->resps, resp, link) {
ISC_LIST_UNLINK(fctx->resps, resp, link);
count++;
@ -2196,11 +2159,7 @@ cleanup_query:
static bool
bad_edns(fetchctx_t *fctx, isc_sockaddr_t *address) {
isc_sockaddr_t *sa;
for (sa = ISC_LIST_HEAD(fctx->bad_edns); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
ISC_LIST_FOREACH (fctx->bad_edns, sa, link) {
if (isc_sockaddr_equal(sa, address)) {
return true;
}
@ -2211,8 +2170,6 @@ bad_edns(fetchctx_t *fctx, isc_sockaddr_t *address) {
static void
add_bad_edns(fetchctx_t *fctx, isc_sockaddr_t *address) {
isc_sockaddr_t *sa;
#ifdef ENABLE_AFL
if (dns_fuzzing_resolver) {
return;
@ -2222,19 +2179,14 @@ add_bad_edns(fetchctx_t *fctx, isc_sockaddr_t *address) {
return;
}
sa = isc_mem_get(fctx->mctx, sizeof(*sa));
isc_sockaddr_t *sa = isc_mem_get(fctx->mctx, sizeof(*sa));
*sa = *address;
ISC_LIST_INITANDAPPEND(fctx->bad_edns, sa, link);
}
static struct tried *
triededns(fetchctx_t *fctx, isc_sockaddr_t *address) {
struct tried *tried;
for (tried = ISC_LIST_HEAD(fctx->edns); tried != NULL;
tried = ISC_LIST_NEXT(tried, link))
{
ISC_LIST_FOREACH (fctx->edns, tried, link) {
if (isc_sockaddr_equal(&tried->addr, address)) {
return tried;
}
@ -2245,16 +2197,13 @@ triededns(fetchctx_t *fctx, isc_sockaddr_t *address) {
static void
add_triededns(fetchctx_t *fctx, isc_sockaddr_t *address) {
struct tried *tried;
tried = triededns(fctx, address);
struct tried *tried = triededns(fctx, address);
if (tried != NULL) {
tried->count++;
return;
}
tried = isc_mem_get(fctx->mctx, sizeof(*tried));
tried->addr = *address;
tried->count = 1;
ISC_LIST_INITANDAPPEND(fctx->edns, tried, link);
@ -2967,11 +2916,7 @@ fctx_finddone(void *arg) {
static bool
bad_server(fetchctx_t *fctx, isc_sockaddr_t *address) {
isc_sockaddr_t *sa;
for (sa = ISC_LIST_HEAD(fctx->bad); sa != NULL;
sa = ISC_LIST_NEXT(sa, link))
{
ISC_LIST_FOREACH (fctx->bad, sa, link) {
if (isc_sockaddr_equal(sa, address)) {
return true;
}
@ -2982,8 +2927,6 @@ bad_server(fetchctx_t *fctx, isc_sockaddr_t *address) {
static bool
mark_bad(fetchctx_t *fctx) {
dns_adbfind_t *curr;
dns_adbaddrinfo_t *addrinfo;
bool all_bad = true;
#ifdef ENABLE_AFL
@ -3000,12 +2943,8 @@ mark_bad(fetchctx_t *fctx) {
/*
* Mark any bad nameservers.
*/
for (curr = ISC_LIST_HEAD(fctx->finds); curr != NULL;
curr = ISC_LIST_NEXT(curr, publink))
{
for (addrinfo = ISC_LIST_HEAD(curr->list); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->finds, curr, publink) {
ISC_LIST_FOREACH (curr->list, addrinfo, publink) {
if (bad_server(fctx, &addrinfo->sockaddr)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
} else {
@ -3017,9 +2956,7 @@ mark_bad(fetchctx_t *fctx) {
/*
* Mark any bad forwarders.
*/
for (addrinfo = ISC_LIST_HEAD(fctx->forwaddrs); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->forwaddrs, addrinfo, publink) {
if (bad_server(fctx, &addrinfo->sockaddr)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
} else {
@ -3030,12 +2967,8 @@ mark_bad(fetchctx_t *fctx) {
/*
* Mark any bad alternates.
*/
for (curr = ISC_LIST_HEAD(fctx->altfinds); curr != NULL;
curr = ISC_LIST_NEXT(curr, publink))
{
for (addrinfo = ISC_LIST_HEAD(curr->list); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->altfinds, curr, publink) {
ISC_LIST_FOREACH (curr->list, addrinfo, publink) {
if (bad_server(fctx, &addrinfo->sockaddr)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
} else {
@ -3044,9 +2977,7 @@ mark_bad(fetchctx_t *fctx) {
}
}
for (addrinfo = ISC_LIST_HEAD(fctx->altaddrs); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
ISC_LIST_FOREACH (fctx->altaddrs, addrinfo, publink) {
if (bad_server(fctx, &addrinfo->sockaddr)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
} else {
@ -3183,21 +3114,21 @@ sort_adbfind(dns_adbfind_t *find, unsigned int bias) {
*/
static void
sort_finds(dns_adbfindlist_t *findlist, unsigned int bias) {
dns_adbfind_t *best, *curr;
dns_adbfind_t *best = NULL;
dns_adbfindlist_t sorted;
dns_adbaddrinfo_t *addrinfo, *bestaddrinfo;
/* Sort each find's addrinfo list by SRTT. */
for (curr = ISC_LIST_HEAD(*findlist); curr != NULL;
curr = ISC_LIST_NEXT(curr, publink))
{
ISC_LIST_FOREACH (*findlist, curr, publink) {
sort_adbfind(curr, bias);
}
/* Lame N^2 bubble sort. */
ISC_LIST_INIT(sorted);
while (!ISC_LIST_EMPTY(*findlist)) {
dns_adbfind_t *curr = NULL;
unsigned int best_srtt;
best = ISC_LIST_HEAD(*findlist);
bestaddrinfo = ISC_LIST_HEAD(best->list);
INSIST(bestaddrinfo != NULL);
@ -3263,7 +3194,6 @@ static void
findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
unsigned int options, unsigned int flags, isc_stdtime_t now,
bool *overquota, bool *need_alternate, unsigned int *no_addresses) {
dns_adbaddrinfo_t *ai = NULL;
dns_adbfind_t *find = NULL;
dns_resolver_t *res = fctx->res;
bool unshared = ((fctx->options & DNS_FETCHOPT_UNSHARED) != 0);
@ -3338,9 +3268,7 @@ findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
*/
INSIST((find->options & DNS_ADBFIND_WANTEVENT) == 0);
if (flags != 0 || port != 0) {
for (ai = ISC_LIST_HEAD(find->list); ai != NULL;
ai = ISC_LIST_NEXT(ai, publink))
{
ISC_LIST_FOREACH (find->list, ai, publink) {
ai->flags |= flags;
if (port != 0) {
isc_sockaddr_setport(&ai->sockaddr,
@ -3677,11 +3605,8 @@ normal_nses:
*/
if (need_alternate) {
int family;
alternate_t *a;
family = (res->dispatches6 != NULL) ? AF_INET6 : AF_INET;
for (a = ISC_LIST_HEAD(res->alternates); a != NULL;
a = ISC_LIST_NEXT(a, link))
{
ISC_LIST_FOREACH (res->alternates, a, link) {
if (!a->isaddress) {
findname(fctx, &a->_u._n.name, a->_u._n.port,
stdoptions, FCTX_ADDRINFO_DUALSTACK,
@ -3843,9 +3768,8 @@ possibly_mark(fetchctx_t *fctx, dns_adbaddrinfo_t *addr) {
static dns_adbaddrinfo_t *
fctx_nextaddress(fetchctx_t *fctx) {
dns_adbfind_t *find, *start;
dns_adbaddrinfo_t *addrinfo;
dns_adbaddrinfo_t *faddrinfo;
dns_adbfind_t *find = NULL, *start = NULL;
dns_adbaddrinfo_t *addrinfo = NULL, *faddrinfo = NULL;
/*
* Return the next untried address, if any.
@ -3854,15 +3778,13 @@ fctx_nextaddress(fetchctx_t *fctx) {
/*
* Find the first unmarked forwarder (if any).
*/
for (addrinfo = ISC_LIST_HEAD(fctx->forwaddrs); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
if (!UNMARKED(addrinfo)) {
ISC_LIST_FOREACH (fctx->forwaddrs, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
possibly_mark(fctx, addrinfo);
if (UNMARKED(addrinfo)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
possibly_mark(fctx, ai);
if (UNMARKED(ai)) {
ai->flags |= FCTX_ADDRINFO_MARK;
fctx->find = NULL;
fctx->forwarding = true;
@ -3874,7 +3796,7 @@ fctx_nextaddress(fetchctx_t *fctx) {
* state.
*/
fctx->minimized = false;
return addrinfo;
return ai;
}
}
@ -3897,24 +3819,21 @@ fctx_nextaddress(fetchctx_t *fctx) {
/*
* Find the first unmarked addrinfo.
*/
addrinfo = NULL;
if (find != NULL) {
start = find;
do {
for (addrinfo = ISC_LIST_HEAD(find->list);
addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
if (!UNMARKED(addrinfo)) {
ISC_LIST_FOREACH (find->list, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
possibly_mark(fctx, addrinfo);
if (UNMARKED(addrinfo)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
possibly_mark(fctx, ai);
if (UNMARKED(ai)) {
ai->flags |= FCTX_ADDRINFO_MARK;
faddrinfo = ai;
break;
}
}
if (addrinfo != NULL) {
if (faddrinfo != NULL) {
break;
}
find = ISC_LIST_NEXT(find, publink);
@ -3925,8 +3844,8 @@ fctx_nextaddress(fetchctx_t *fctx) {
}
fctx->find = find;
if (addrinfo != NULL) {
return addrinfo;
if (faddrinfo != NULL) {
return faddrinfo;
}
/*
@ -3948,24 +3867,21 @@ fctx_nextaddress(fetchctx_t *fctx) {
/*
* Find the first unmarked addrinfo.
*/
addrinfo = NULL;
if (find != NULL) {
start = find;
do {
for (addrinfo = ISC_LIST_HEAD(find->list);
addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
if (!UNMARKED(addrinfo)) {
ISC_LIST_FOREACH (find->list, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
possibly_mark(fctx, addrinfo);
if (UNMARKED(addrinfo)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
possibly_mark(fctx, ai);
if (UNMARKED(ai)) {
ai->flags |= FCTX_ADDRINFO_MARK;
faddrinfo = ai;
break;
}
}
if (addrinfo != NULL) {
if (faddrinfo != NULL) {
break;
}
find = ISC_LIST_NEXT(find, publink);
@ -3975,26 +3891,22 @@ fctx_nextaddress(fetchctx_t *fctx) {
} while (find != start);
}
faddrinfo = addrinfo;
/*
* See if we have a better alternate server by address.
*/
for (addrinfo = ISC_LIST_HEAD(fctx->altaddrs); addrinfo != NULL;
addrinfo = ISC_LIST_NEXT(addrinfo, publink))
{
if (!UNMARKED(addrinfo)) {
ISC_LIST_FOREACH (fctx->altaddrs, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
possibly_mark(fctx, addrinfo);
if (UNMARKED(addrinfo) &&
(faddrinfo == NULL || addrinfo->srtt < faddrinfo->srtt))
possibly_mark(fctx, ai);
if (UNMARKED(ai) &&
(faddrinfo == NULL || ai->srtt < faddrinfo->srtt))
{
if (faddrinfo != NULL) {
faddrinfo->flags &= ~FCTX_ADDRINFO_MARK;
}
addrinfo->flags |= FCTX_ADDRINFO_MARK;
ai->flags |= FCTX_ADDRINFO_MARK;
addrinfo = ai;
break;
}
}
@ -4466,8 +4378,6 @@ cleanup:
static void
fctx_destroy(fetchctx_t *fctx) {
dns_resolver_t *res = NULL;
isc_sockaddr_t *sa = NULL, *next_sa = NULL;
struct tried *tried = NULL;
REQUIRE(VALID_FCTX(fctx));
REQUIRE(ISC_LIST_EMPTY(fctx->resps));
@ -4487,21 +4397,17 @@ fctx_destroy(fetchctx_t *fctx) {
dec_stats(res, dns_resstatscounter_nfetch);
/* Free bad */
for (sa = ISC_LIST_HEAD(fctx->bad); sa != NULL; sa = next_sa) {
next_sa = ISC_LIST_NEXT(sa, link);
ISC_LIST_FOREACH_SAFE (fctx->bad, sa, link) {
ISC_LIST_UNLINK(fctx->bad, sa, link);
isc_mem_put(fctx->mctx, sa, sizeof(*sa));
}
for (tried = ISC_LIST_HEAD(fctx->edns); tried != NULL;
tried = ISC_LIST_HEAD(fctx->edns))
{
ISC_LIST_FOREACH_SAFE (fctx->edns, tried, link) {
ISC_LIST_UNLINK(fctx->edns, tried, link);
isc_mem_put(fctx->mctx, tried, sizeof(*tried));
}
for (sa = ISC_LIST_HEAD(fctx->bad_edns); sa != NULL; sa = next_sa) {
next_sa = ISC_LIST_NEXT(sa, link);
ISC_LIST_FOREACH_SAFE (fctx->bad_edns, sa, link) {
ISC_LIST_UNLINK(fctx->bad_edns, sa, link);
isc_mem_put(fctx->mctx, sa, sizeof(*sa));
}
@ -5127,7 +5033,7 @@ same_question(fetchctx_t *fctx, dns_message_t *message) {
static void
clone_results(fetchctx_t *fctx) {
dns_fetchresponse_t *resp = NULL, *hresp = NULL;
dns_fetchresponse_t *hresp = NULL;
FCTXTRACE("clone_results");
@ -5139,9 +5045,7 @@ clone_results(fetchctx_t *fctx) {
fctx->cloned = true;
for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
resp = ISC_LIST_NEXT(resp, link))
{
ISC_LIST_FOREACH (fctx->resps, resp, link) {
/* This is the head resp; keep a pointer and move on */
if (hresp == NULL) {
hresp = ISC_LIST_HEAD(fctx->resps);
@ -5196,9 +5100,7 @@ maybe_cancel_validators(fetchctx_t *fctx) {
}
REQUIRE(SHUTTINGDOWN(fctx));
for (dns_validator_t *validator = ISC_LIST_HEAD(fctx->validators);
validator != NULL; validator = ISC_LIST_NEXT(validator, link))
{
ISC_LIST_FOREACH (fctx->validators, validator, link) {
dns_validator_cancel(validator);
}
}
@ -5936,27 +5838,22 @@ findnoqname(fetchctx_t *fctx, dns_message_t *message, dns_name_t *name,
}
if (noqname != NULL) {
for (sigrdataset = ISC_LIST_HEAD(noqname->list);
sigrdataset != NULL;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
if (sigrdataset->type == dns_rdatatype_rrsig &&
sigrdataset->covers == found)
ISC_LIST_FOREACH (noqname->list, sig, link) {
if (sig->type == dns_rdatatype_rrsig &&
sig->covers == found)
{
*noqnamep = noqname;
break;
}
}
if (sigrdataset != NULL) {
*noqnamep = noqname;
}
}
return result;
}
static isc_result_t
cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
dns_adbaddrinfo_t *addrinfo, isc_stdtime_t now) {
dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
dns_rdataset_t *addedrdataset = NULL;
dns_rdataset_t *ardataset = NULL, *asigrdataset = NULL;
dns_rdataset_t *valrdataset = NULL, *valsigrdataset = NULL;
@ -6043,9 +5940,9 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
* Cache or validate each cacheable rdataset.
*/
fail = ((fctx->res->options & DNS_RESOLVER_CHECKNAMESFAIL) != 0);
for (rdataset = ISC_LIST_HEAD(name->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
ISC_LIST_FOREACH (name->list, rdataset, link) {
dns_rdataset_t *sigrdataset = NULL;
if (!CACHE(rdataset)) {
continue;
}
@ -6097,13 +5994,11 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
/*
* Find the SIG for this rdataset, if we have it.
*/
for (sigrdataset = ISC_LIST_HEAD(name->list);
sigrdataset != NULL;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
if (sigrdataset->type == dns_rdatatype_rrsig &&
sigrdataset->covers == rdataset->type)
ISC_LIST_FOREACH (name->list, sig, link) {
if (sig->type == dns_rdatatype_rrsig &&
sig->covers == rdataset->type)
{
sigrdataset = sig;
break;
}
}
@ -6834,7 +6729,6 @@ check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
fetchctx_t *fctx = rctx->fctx;
isc_result_t result;
dns_name_t *name = NULL;
dns_rdataset_t *rdataset = NULL;
bool external;
dns_rdatatype_t rtype;
bool gluing;
@ -6855,10 +6749,7 @@ check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
if (result == ISC_R_SUCCESS) {
external = name_external(name, type, fctx);
if (type == dns_rdatatype_a) {
for (rdataset = ISC_LIST_HEAD(name->list);
rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
ISC_LIST_FOREACH (name->list, rdataset, link) {
if (dns_rdatatype_issig(rdataset->type)) {
rtype = rdataset->covers;
} else {
@ -6870,6 +6761,7 @@ check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
}
}
} else {
dns_rdataset_t *rdataset = NULL;
result = dns_message_findtype(name, type, 0, &rdataset);
if (result == ISC_R_SUCCESS) {
mark_related(name, rdataset, external, gluing);
@ -8655,12 +8547,9 @@ rctx_answer_scan(respctx_t *rctx) {
*/
static isc_result_t
rctx_answer_any(respctx_t *rctx) {
dns_rdataset_t *rdataset = NULL;
fetchctx_t *fctx = rctx->fctx;
for (rdataset = ISC_LIST_HEAD(rctx->aname->list); rdataset != NULL;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
ISC_LIST_FOREACH (rctx->aname->list, rdataset, link) {
if (!validinanswer(rdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
@ -8707,7 +8596,6 @@ rctx_answer_any(respctx_t *rctx) {
*/
static isc_result_t
rctx_answer_match(respctx_t *rctx) {
dns_rdataset_t *sigrdataset = NULL;
fetchctx_t *fctx = rctx->fctx;
if (!validinanswer(rctx->ardataset, fctx)) {
@ -8741,10 +8629,7 @@ rctx_answer_match(respctx_t *rctx) {
check_related, rctx,
DNS_RDATASET_MAXADDITIONAL);
for (sigrdataset = ISC_LIST_HEAD(rctx->aname->list);
sigrdataset != NULL;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
ISC_LIST_FOREACH (rctx->aname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
@ -8772,7 +8657,6 @@ rctx_answer_match(respctx_t *rctx) {
*/
static isc_result_t
rctx_answer_cname(respctx_t *rctx) {
dns_rdataset_t *sigrdataset = NULL;
fetchctx_t *fctx = rctx->fctx;
if (!validinanswer(rctx->crdataset, fctx)) {
@ -8805,10 +8689,7 @@ rctx_answer_cname(respctx_t *rctx) {
rctx->crdataset->attributes |= DNS_RDATASETATTR_CHAINING;
rctx->crdataset->trust = rctx->trust;
for (sigrdataset = ISC_LIST_HEAD(rctx->cname->list);
sigrdataset != NULL;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
ISC_LIST_FOREACH (rctx->cname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
@ -8836,7 +8717,6 @@ rctx_answer_cname(respctx_t *rctx) {
*/
static isc_result_t
rctx_answer_dname(respctx_t *rctx) {
dns_rdataset_t *sigrdataset = NULL;
fetchctx_t *fctx = rctx->fctx;
if (!validinanswer(rctx->drdataset, fctx)) {
@ -8859,10 +8739,7 @@ rctx_answer_dname(respctx_t *rctx) {
rctx->drdataset->attributes |= DNS_RDATASETATTR_CHAINING;
rctx->drdataset->trust = rctx->trust;
for (sigrdataset = ISC_LIST_HEAD(rctx->dname->list);
sigrdataset != NULL;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
ISC_LIST_FOREACH (rctx->dname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
@ -10608,10 +10485,7 @@ dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name,
/* Is this a duplicate? */
if (client != NULL) {
dns_fetchresponse_t *resp = NULL;
for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
resp = ISC_LIST_NEXT(resp, link))
{
ISC_LIST_FOREACH (fctx->resps, resp, link) {
if (resp->client != NULL && resp->id == id &&
isc_sockaddr_equal(resp->client, client))
{
@ -10696,12 +10570,7 @@ dns_resolver_cancelfetch(dns_fetch_t *fetch) {
* the callback asynchronously with a ISC_R_CANCELED result.
*/
if (fctx->state != fetchstate_done) {
dns_fetchresponse_t *next = NULL;
for (dns_fetchresponse_t *resp = ISC_LIST_HEAD(fctx->resps);
resp != NULL; resp = next)
{
next = ISC_LIST_NEXT(resp, link);
ISC_LIST_FOREACH_SAFE (fctx->resps, resp, link) {
if (resp->fetch == fetch) {
resp->result = ISC_R_CANCELED;
ISC_LIST_UNLINK(fctx->resps, resp, link);
@ -10746,11 +10615,7 @@ dns_resolver_destroyfetch(dns_fetch_t **fetchp) {
* trying to destroy the fetch.
*/
if (fctx->state != fetchstate_done) {
dns_fetchresponse_t *resp = NULL, *next = NULL;
for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
resp = next)
{
next = ISC_LIST_NEXT(resp, link);
ISC_LIST_FOREACH_SAFE (fctx->resps, resp, link) {
RUNTIME_CHECK(resp->fetch != fetch);
}
}
@ -11030,8 +10895,6 @@ dns_resolver_dumpfetches(dns_resolver_t *res, isc_statsformat_t format,
char typebuf[DNS_RDATATYPE_FORMATSIZE];
char timebuf[1024];
fetchctx_t *fctx = NULL;
dns_fetchresponse_t *resp = NULL;
resquery_t *query = NULL;
unsigned int resp_count = 0, query_count = 0;
isc_hashmap_iter_current(it, (void **)&fctx);
@ -11048,15 +10911,11 @@ dns_resolver_dumpfetches(dns_resolver_t *res, isc_statsformat_t format,
fctx->state == fetchstate_active ? "active" : "done",
timebuf);
for (resp = ISC_LIST_HEAD(fctx->resps); resp != NULL;
resp = ISC_LIST_NEXT(resp, link))
{
ISC_LIST_FOREACH (fctx->resps, resp, link) {
resp_count++;
}
for (query = ISC_LIST_HEAD(fctx->queries); query != NULL;
query = ISC_LIST_NEXT(query, link))
{
ISC_LIST_FOREACH (fctx->queries, query, link) {
query_count++;
}

4
lib/dns/rrl.c
View file

@ -263,14 +263,12 @@ static void
free_old_hash(dns_rrl_t *rrl) {
dns_rrl_hash_t *old_hash;
dns_rrl_bin_t *old_bin;
dns_rrl_entry_t *e, *e_next;
old_hash = rrl->old_hash;
for (old_bin = &old_hash->bins[0];
old_bin < &old_hash->bins[old_hash->length]; ++old_bin)
{
for (e = ISC_LIST_HEAD(*old_bin); e != NULL; e = e_next) {
e_next = ISC_LIST_NEXT(e, hlink);
ISC_LIST_FOREACH_SAFE (*old_bin, e, hlink) {
ISC_LINK_INIT(e, hlink);
}
}

29
lib/dns/skr.c
View file

@ -166,12 +166,10 @@ dns_skrbundle_getsig(dns_skrbundle_t *bundle, dst_key_t *key,
REQUIRE(DNS_SKRBUNDLE_VALID(bundle));
REQUIRE(DNS_DIFF_VALID(&bundle->diff));
dns_difftuple_t *tuple = ISC_LIST_HEAD(bundle->diff.tuples);
while (tuple != NULL) {
ISC_LIST_FOREACH_SAFE (bundle->diff.tuples, tuple, link) {
dns_rdata_rrsig_t rrsig;
if (tuple->op != DNS_DIFFOP_ADDRESIGN) {
tuple = ISC_LIST_NEXT(tuple, link);
continue;
}
INSIST(tuple->rdata.type == dns_rdatatype_rrsig);
@ -191,8 +189,6 @@ dns_skrbundle_getsig(dns_skrbundle_t *bundle, dst_key_t *key,
dns_rdata_clone(&tuple->rdata, sigrdata);
return ISC_R_SUCCESS;
}
tuple = ISC_LIST_NEXT(tuple, link);
}
return ISC_R_NOTFOUND;
@ -393,20 +389,14 @@ failure:
dns_skrbundle_t *
dns_skr_lookup(dns_skr_t *skr, isc_stdtime_t time, uint32_t sigval) {
dns_skrbundle_t *b, *next;
REQUIRE(DNS_SKR_VALID(skr));
for (b = ISC_LIST_HEAD(skr->bundles); b != NULL; b = next) {
next = ISC_LIST_NEXT(b, link);
if (next == NULL) {
isc_stdtime_t expired = b->inception + sigval;
if (b->inception <= time && time < expired) {
return b;
}
return NULL;
}
if (b->inception <= time && time < next->inception) {
ISC_LIST_FOREACH (skr->bundles, b, link) {
dns_skrbundle_t *next = ISC_LIST_NEXT(b, link);
isc_stdtime_t expired = (next != NULL)
? next->inception
: (b->inception + sigval);
if (b->inception <= time && time < expired) {
return b;
}
}
@ -437,12 +427,9 @@ dns_skr_detach(dns_skr_t **skrp) {
void
dns_skr_destroy(dns_skr_t *skr) {
dns_skrbundle_t *b, *next;
REQUIRE(DNS_SKR_VALID(skr));
for (b = ISC_LIST_HEAD(skr->bundles); b != NULL; b = next) {
next = ISC_LIST_NEXT(b, link);
ISC_LIST_FOREACH_SAFE (skr->bundles, b, link) {
ISC_LIST_UNLINK(skr->bundles, b, link);
dns_diff_clear(&b->diff);
isc_mem_put(skr->mctx, b, sizeof(*b));

5
lib/dns/ssu.c
View file

@ -332,7 +332,6 @@ dns_ssutable_checkrules(dns_ssutable_t *table, const dns_name_t *signer,
dns_name_t *stfself;
dns_name_t *tcpself;
dns_name_t *wildcard;
dns_ssurule_t *rule;
const dns_name_t *tname;
int match;
isc_result_t result;
@ -375,9 +374,7 @@ dns_ssutable_checkrules(dns_ssutable_t *table, const dns_name_t *signer,
return false;
}
for (rule = ISC_LIST_HEAD(table->rules); rule != NULL;
rule = ISC_LIST_NEXT(rule, link))
{
ISC_LIST_FOREACH (table->rules, rule, link) {
if (logit) {
isc_log_write(DNS_LOGCATEGORY_UPDATE_POLICY,
DNS_LOGMODULE_SSU, ISC_LOG_DEBUG(99),

95
lib/dns/update.c
View file

@ -1521,9 +1521,8 @@ dns_update_signaturesinc(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
dns_diff_t *diff, uint32_t sigvalidityinterval,
dns_update_state_t **statep) {
isc_result_t result = ISC_R_SUCCESS;
dns_update_state_t mystate, *state;
dns_difftuple_t *t, *next;
dns_update_state_t mystate, *state = NULL;
dns_difftuple_t *tuple = NULL;
bool flag, build_nsec;
unsigned int i;
dns_rdata_soa_t soa;
@ -1612,19 +1611,22 @@ dns_update_signaturesinc(dns_update_log_t *log, dns_zone_t *zone, dns_db_t *db,
next_state:
switch (state->state) {
case sign_updates:
t = ISC_LIST_HEAD(diff->tuples);
while (t != NULL) {
dns_name_t *name = &t->name;
tuple = ISC_LIST_HEAD(diff->tuples);
while (tuple != NULL) {
dns_name_t *name = &tuple->name;
dns_difftuple_t *next = NULL;
/*
* Now "name" is a new, unique name affected by the
* update.
*/
namelist_append_name(&state->diffnames, name);
while (t != NULL && dns_name_equal(&t->name, name)) {
while (tuple != NULL &&
dns_name_equal(&tuple->name, name))
{
dns_rdatatype_t type;
type = t->rdata.type;
type = tuple->rdata.type;
/*
* Now "name" and "type" denote a new unique
@ -1682,15 +1684,16 @@ next_state:
}
skip:
/* Skip any other updates to the same RRset. */
while (t != NULL &&
dns_name_equal(&t->name, name) &&
t->rdata.type == type)
while (tuple != NULL &&
dns_name_equal(&tuple->name, name) &&
tuple->rdata.type == type)
{
next = ISC_LIST_NEXT(t, link);
ISC_LIST_UNLINK(diff->tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t,
next = ISC_LIST_NEXT(tuple, link);
ISC_LIST_UNLINK(diff->tuples, tuple,
link);
t = next;
ISC_LIST_APPEND(state->work.tuples,
tuple, link);
tuple = next;
}
}
if (state != &mystate && sigs > maxsigs) {
@ -1706,9 +1709,7 @@ next_state:
state->state = remove_orphaned;
/* Remove orphaned NSECs and RRSIG NSECs. */
for (t = ISC_LIST_HEAD(state->diffnames.tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (state->diffnames.tuples, t, link) {
CHECK(non_nsec_rrset_exists(db, newver, &t->name,
&flag));
if (!flag) {
@ -1740,9 +1741,7 @@ next_state:
* When a name is created or deleted, its predecessor needs to
* have its NSEC updated.
*/
for (t = ISC_LIST_HEAD(state->diffnames.tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (state->diffnames.tuples, t, link) {
bool existed, exists;
dns_fixedname_t fixedname;
dns_name_t *prevname;
@ -1781,9 +1780,7 @@ next_state:
* (obscured by adding an NS or DNAME, or unobscured by
* removing one).
*/
for (t = ISC_LIST_HEAD(state->diffnames.tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (state->diffnames.tuples, t, link) {
bool ns_existed, dname_existed;
bool ns_exists, dname_exists;
@ -1835,7 +1832,7 @@ next_state:
* contents to indicate that their respective owner names
* should be part of the NSEC chain.
*/
while ((t = ISC_LIST_HEAD(state->affected.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->affected.tuples, t, link) {
bool exists;
dns_name_t *name = &t->name;
@ -1896,9 +1893,7 @@ next_state:
* Now we know which names are part of the NSEC chain.
* Make them all point at their correct targets.
*/
for (t = ISC_LIST_HEAD(state->affected.tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (state->affected.tuples, t, link) {
CHECK(rrset_exists(db, newver, &t->name,
dns_rdatatype_nsec, 0, &flag));
if (flag) {
@ -1932,7 +1927,7 @@ next_state:
* have to regenerate the RRSIG NSECs for NSECs that were
* replaced with identical ones.
*/
while ((t = ISC_LIST_HEAD(state->nsec_diff.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->nsec_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_diff.tuples, t, link);
dns_diff_appendminimal(&state->nsec_mindiff, &t);
}
@ -1944,8 +1939,7 @@ next_state:
case sign_nsec:
state->state = sign_nsec;
/* Update RRSIG NSECs. */
while ((t = ISC_LIST_HEAD(state->nsec_mindiff.tuples)) != NULL)
{
ISC_LIST_FOREACH_SAFE (state->nsec_mindiff.tuples, t, link) {
if (t->op == DNS_DIFFOP_DEL) {
CHECK(delete_if(true_p, db, newver, &t->name,
dns_rdatatype_rrsig,
@ -1975,12 +1969,11 @@ next_state:
state->state = update_nsec3;
/* Record our changes for the journal. */
while ((t = ISC_LIST_HEAD(state->sig_diff.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->sig_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->sig_diff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
while ((t = ISC_LIST_HEAD(state->nsec_mindiff.tuples)) != NULL)
{
ISC_LIST_FOREACH_SAFE (state->nsec_mindiff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
@ -2008,18 +2001,18 @@ next_state:
* (obscured by adding an NS or DNAME, or unobscured by
* removing one).
*/
t = ISC_LIST_HEAD(diff->tuples);
while (t != NULL) {
dns_name_t *name = &t->name;
tuple = ISC_LIST_HEAD(diff->tuples);
while (tuple != NULL) {
dns_name_t *name = &tuple->name;
bool ns_existed, dname_existed;
bool ns_exists, dname_exists;
bool exists, existed;
if (t->rdata.type == dns_rdatatype_nsec ||
t->rdata.type == dns_rdatatype_rrsig)
if (tuple->rdata.type == dns_rdatatype_nsec ||
tuple->rdata.type == dns_rdatatype_rrsig)
{
t = ISC_LIST_NEXT(t, link);
tuple = ISC_LIST_NEXT(tuple, link);
continue;
}
@ -2052,21 +2045,23 @@ next_state:
}
/*
* There was a delegation change. Mark all subdomains
* of t->name as potentially needing a NSEC3 update.
* of tuple->name as potentially needing a NSEC3 update.
*/
CHECK(namelist_append_subdomain(db, name,
&state->affected));
nextname:
while (t != NULL && dns_name_equal(&t->name, name)) {
t = ISC_LIST_NEXT(t, link);
while (tuple != NULL &&
dns_name_equal(&tuple->name, name))
{
tuple = ISC_LIST_NEXT(tuple, link);
}
}
FALLTHROUGH;
case process_nsec3:
state->state = process_nsec3;
while ((t = ISC_LIST_HEAD(state->affected.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->affected.tuples, t, link) {
dns_name_t *name = &t->name;
unsecure = false; /* Silence compiler warning. */
@ -2106,7 +2101,7 @@ next_state:
* have to regenerate the RRSIG NSEC3s for NSEC3s that were
* replaced with identical ones.
*/
while ((t = ISC_LIST_HEAD(state->nsec_diff.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->nsec_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_diff.tuples, t, link);
dns_diff_appendminimal(&state->nsec_mindiff, &t);
}
@ -2118,8 +2113,7 @@ next_state:
case sign_nsec3:
state->state = sign_nsec3;
/* Update RRSIG NSEC3s. */
while ((t = ISC_LIST_HEAD(state->nsec_mindiff.tuples)) != NULL)
{
ISC_LIST_FOREACH_SAFE (state->nsec_mindiff.tuples, t, link) {
if (t->op == DNS_DIFFOP_DEL) {
CHECK(delete_if(true_p, db, newver, &t->name,
dns_rdatatype_rrsig,
@ -2146,12 +2140,11 @@ next_state:
state->work.tuples, link);
/* Record our changes for the journal. */
while ((t = ISC_LIST_HEAD(state->sig_diff.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (state->sig_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->sig_diff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
while ((t = ISC_LIST_HEAD(state->nsec_mindiff.tuples)) != NULL)
{
ISC_LIST_FOREACH_SAFE (state->nsec_mindiff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}

37
lib/dns/view.c
View file

@ -165,8 +165,7 @@ dns_view_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
static void
destroy(dns_view_t *view) {
dns_dns64_t *dns64;
dns_dlzdb_t *dlzdb;
dns_dns64_t *dns64 = NULL;
REQUIRE(!ISC_LINK_LINKED(view, link));
@ -233,15 +232,11 @@ destroy(dns_view_t *view) {
dns_catz_zones_shutdown(view->catzs);
dns_catz_zones_detach(&view->catzs);
}
for (dlzdb = ISC_LIST_HEAD(view->dlz_searched); dlzdb != NULL;
dlzdb = ISC_LIST_HEAD(view->dlz_searched))
{
ISC_LIST_FOREACH_SAFE (view->dlz_searched, dlzdb, link) {
ISC_LIST_UNLINK(view->dlz_searched, dlzdb, link);
dns_dlzdestroy(&dlzdb);
}
for (dlzdb = ISC_LIST_HEAD(view->dlz_unsearched); dlzdb != NULL;
dlzdb = ISC_LIST_HEAD(view->dlz_unsearched))
{
ISC_LIST_FOREACH_SAFE (view->dlz_unsearched, dlzdb, link) {
ISC_LIST_UNLINK(view->dlz_unsearched, dlzdb, link);
dns_dlzdestroy(&dlzdb);
}
@ -1227,40 +1222,29 @@ cleanup:
isc_result_t
dns_viewlist_find(dns_viewlist_t *list, const char *name,
dns_rdataclass_t rdclass, dns_view_t **viewp) {
dns_view_t *view;
REQUIRE(list != NULL);
for (view = ISC_LIST_HEAD(*list); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (*list, view, link) {
if (strcmp(view->name, name) == 0 && view->rdclass == rdclass) {
break;
dns_view_attach(view, viewp);
return ISC_R_SUCCESS;
}
}
if (view == NULL) {
return ISC_R_NOTFOUND;
}
dns_view_attach(view, viewp);
return ISC_R_SUCCESS;
return ISC_R_NOTFOUND;
}
isc_result_t
dns_viewlist_findzone(dns_viewlist_t *list, const dns_name_t *name,
bool allclasses, dns_rdataclass_t rdclass,
dns_zone_t **zonep) {
dns_view_t *view;
isc_result_t result;
dns_zone_t *zone1 = NULL, *zone2 = NULL;
REQUIRE(list != NULL);
REQUIRE(zonep != NULL && *zonep == NULL);
for (view = ISC_LIST_HEAD(*list); view != NULL;
view = ISC_LIST_NEXT(view, link))
{
ISC_LIST_FOREACH (*list, view, link) {
dns_zt_t *zonetable = NULL;
if (!allclasses && view->rdclass != rdclass) {
continue;
@ -1883,7 +1867,6 @@ dns_view_searchdlz(dns_view_t *view, const dns_name_t *name,
unsigned int i;
isc_result_t result;
dns_dlzfindzone_t findzone;
dns_dlzdb_t *dlzdb;
dns_db_t *db, *best = NULL;
/*
@ -1899,9 +1882,7 @@ dns_view_searchdlz(dns_view_t *view, const dns_name_t *name,
/* count the number of labels in the name */
namelabels = dns_name_countlabels(name);
for (dlzdb = ISC_LIST_HEAD(view->dlz_searched); dlzdb != NULL;
dlzdb = ISC_LIST_NEXT(dlzdb, link))
{
ISC_LIST_FOREACH (view->dlz_searched, dlzdb, link) {
REQUIRE(DNS_DLZ_VALID(dlzdb));
/*

481
lib/dns/zone.c
View file

File diff suppressed because it is too large Load diff

7
lib/isc/job.c
View file

@ -64,12 +64,7 @@ isc__job_cb(uv_idle_t *handle) {
ISC_LIST_MOVE(jobs, loop->run_jobs);
isc_job_t *job, *next;
for (job = ISC_LIST_HEAD(jobs),
next = (job != NULL) ? ISC_LIST_NEXT(job, link) : NULL;
job != NULL;
job = next, next = job ? ISC_LIST_NEXT(job, link) : NULL)
{
ISC_LIST_FOREACH_SAFE (jobs, job, link) {
isc_job_cb cb = job->cb;
void *cbarg = job->cbarg;
ISC_LIST_UNLINK(jobs, job, link);

14
lib/isc/log.c
View file

@ -554,17 +554,17 @@ isc_result_t
isc_log_usechannel(isc_logconfig_t *lcfg, const char *name,
const isc_logcategory_t category,
const isc_logmodule_t module) {
isc_logchannel_t *channel = NULL;
REQUIRE(VALID_CONFIG(lcfg));
REQUIRE(name != NULL);
REQUIRE(category >= ISC_LOGCATEGORY_DEFAULT &&
category < ISC_LOGCATEGORY_MAX);
REQUIRE(module >= ISC_LOGMODULE_DEFAULT && module < ISC_LOGMODULE_MAX);
isc_logchannel_t *channel;
for (channel = ISC_LIST_HEAD(lcfg->channels); channel != NULL;
channel = ISC_LIST_NEXT(channel, link))
{
if (strcmp(name, channel->name) == 0) {
ISC_LIST_FOREACH (lcfg->channels, c, link) {
if (strcmp(name, c->name) == 0) {
channel = c;
break;
}
}
@ -711,9 +711,7 @@ isc_log_closefilelogs(void) {
isc_logconfig_t *lcfg = rcu_dereference(isc__lctx->logconfig);
if (lcfg != NULL) {
LOCK(&isc__lctx->lock);
for (isc_logchannel_t *channel = ISC_LIST_HEAD(lcfg->channels);
channel != NULL; channel = ISC_LIST_NEXT(channel, link))
{
ISC_LIST_FOREACH (lcfg->channels, channel, link) {
if (channel->type == ISC_LOG_TOFILE &&
FILE_STREAM(channel) != NULL)
{

21
lib/isc/mem.c
View file

@ -526,11 +526,8 @@ mem_destroy(isc_mem_t *ctx) {
#if ISC_MEM_TRACKLINES
if (ctx->debuglist != NULL) {
debuglink_t *dl;
for (size_t i = 0; i < DEBUG_TABLE_COUNT; i++) {
for (dl = ISC_LIST_HEAD(ctx->debuglist[i]); dl != NULL;
dl = ISC_LIST_HEAD(ctx->debuglist[i]))
{
ISC_LIST_FOREACH_SAFE (ctx->debuglist[i], dl, link) {
if (ctx->checkfree && dl->ptr != NULL) {
print_active(ctx, stderr);
}
@ -1185,11 +1182,7 @@ isc_mempool_getfillcount(isc_mempool_t *restrict mpctx) {
#if ISC_MEM_TRACKLINES
static void
print_contexts(FILE *file) {
isc_mem_t *ctx;
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
ctx = ISC_LIST_NEXT(ctx, link))
{
ISC_LIST_FOREACH (contexts, ctx, link) {
fprintf(file, "context: %p (%s): %" PRIuFAST32 " references\n",
ctx, ctx->name[0] == 0 ? "<unknown>" : ctx->name,
isc_refcount_current(&ctx->references));
@ -1301,7 +1294,6 @@ error:
int
isc_mem_renderxml(void *writer0) {
isc_mem_t *ctx;
size_t inuse = 0;
int xmlrc;
xmlTextWriterPtr writer = (xmlTextWriterPtr)writer0;
@ -1309,9 +1301,7 @@ isc_mem_renderxml(void *writer0) {
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "contexts"));
LOCK(&contextslock);
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
ctx = ISC_LIST_NEXT(ctx, link))
{
ISC_LIST_FOREACH (contexts, ctx, link) {
xmlrc = xml_renderctx(ctx, &inuse, writer);
if (xmlrc < 0) {
UNLOCK(&contextslock);
@ -1402,7 +1392,6 @@ json_renderctx(isc_mem_t *ctx, size_t *inuse, json_object *array) {
isc_result_t
isc_mem_renderjson(void *memobj0) {
isc_result_t result = ISC_R_SUCCESS;
isc_mem_t *ctx;
size_t inuse = 0;
json_object *ctxarray, *obj;
json_object *memobj = (json_object *)memobj0;
@ -1411,9 +1400,7 @@ isc_mem_renderjson(void *memobj0) {
CHECKMEM(ctxarray);
LOCK(&contextslock);
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
ctx = ISC_LIST_NEXT(ctx, link))
{
ISC_LIST_FOREACH (contexts, ctx, link) {
result = json_renderctx(ctx, &inuse, ctxarray);
if (result != ISC_R_SUCCESS) {
UNLOCK(&contextslock);

50
lib/isc/netmgr/http.c
View file

@ -294,7 +294,7 @@ server_call_cb(isc_nmsocket_t *socket, const isc_result_t result,
static isc_nm_httphandler_t *
http_endpoints_find(const char *request_path,
const isc_nm_http_endpoints_t *restrict eps);
isc_nm_http_endpoints_t *restrict eps);
static void
http_init_listener_endpoints(isc_nmsocket_t *listener,
@ -424,28 +424,27 @@ isc__nm_httpsession_handle(isc_nm_http_session_t *session) {
static http_cstream_t *
find_http_cstream(int32_t stream_id, isc_nm_http_session_t *session) {
http_cstream_t *cstream = NULL;
REQUIRE(VALID_HTTP2_SESSION(session));
if (ISC_LIST_EMPTY(session->cstreams)) {
return NULL;
}
for (cstream = ISC_LIST_HEAD(session->cstreams); cstream != NULL;
cstream = ISC_LIST_NEXT(cstream, link))
{
ISC_LIST_FOREACH (session->cstreams, cstream, link) {
if (cstream->stream_id == stream_id) {
break;
/* LRU-like behaviour */
if (ISC_LIST_HEAD(session->cstreams) != cstream) {
ISC_LIST_UNLINK(session->cstreams, cstream,
link);
ISC_LIST_PREPEND(session->cstreams, cstream,
link);
}
return cstream;
}
}
/* LRU-like behaviour */
if (cstream && ISC_LIST_HEAD(session->cstreams) != cstream) {
ISC_LIST_UNLINK(session->cstreams, cstream, link);
ISC_LIST_PREPEND(session->cstreams, cstream, link);
}
return cstream;
return NULL;
}
static isc_result_t
@ -3087,26 +3086,22 @@ isc_nm_http_endpoints_attach(isc_nm_http_endpoints_t *source,
static isc_nm_httphandler_t *
http_endpoints_find(const char *request_path,
const isc_nm_http_endpoints_t *restrict eps) {
isc_nm_httphandler_t *handler = NULL;
isc_nm_http_endpoints_t *restrict eps) {
REQUIRE(VALID_HTTP_ENDPOINTS(eps));
if (request_path == NULL || *request_path == '\0') {
return NULL;
}
for (handler = ISC_LIST_HEAD(eps->handlers); handler != NULL;
handler = ISC_LIST_NEXT(handler, link))
{
ISC_LIST_FOREACH (eps->handlers, handler, link) {
if (!strcmp(request_path, handler->path)) {
INSIST(VALID_HTTP_HANDLER(handler));
INSIST(handler->cb != NULL);
break;
return handler;
}
}
return handler;
return NULL;
}
isc_result_t
@ -3266,27 +3261,20 @@ client_call_failed_read_cb(isc_result_t result,
static void
server_call_failed_read_cb(isc_result_t result,
isc_nm_http_session_t *session) {
isc_nmsocket_h2_t *h2data = NULL; /* stream socket */
REQUIRE(VALID_HTTP2_SESSION(session));
REQUIRE(result != ISC_R_SUCCESS);
for (h2data = ISC_LIST_HEAD(session->sstreams); h2data != NULL;
h2data = ISC_LIST_NEXT(h2data, link))
{
ISC_LIST_FOREACH (session->sstreams, h2data, link) {
failed_httpstream_read_cb(h2data->psock, result, session);
}
h2data = ISC_LIST_HEAD(session->sstreams);
while (h2data != NULL) {
isc_nmsocket_h2_t *next = ISC_LIST_NEXT(h2data, link);
ISC_LIST_FOREACH_SAFE (session->sstreams, h2data, link) {
ISC_LIST_DEQUEUE(session->sstreams, h2data, link);
/* Cleanup socket in place */
h2data->psock->active = false;
h2data->psock->closed = true;
isc__nmsocket_detach(&h2data->psock);
h2data = next;
}
}

11
lib/isc/netmgr/netmgr.c
View file

@ -2944,8 +2944,6 @@ nmhandle_dump(isc_nmhandle_t *handle) {
static void
nmsocket_dump(isc_nmsocket_t *sock) {
isc_nmhandle_t *handle = NULL;
fprintf(stderr, "\n=================\n");
fprintf(stderr, "Active %s socket %p, type %s, refs %" PRIuFAST32 "\n",
sock->client ? "client" : "server", sock,
@ -2965,9 +2963,7 @@ nmsocket_dump(isc_nmsocket_t *sock) {
STDERR_FILENO);
fprintf(stderr, "\n");
for (handle = ISC_LIST_HEAD(sock->active_handles); handle != NULL;
handle = ISC_LIST_NEXT(handle, active_link))
{
ISC_LIST_FOREACH (sock->active_handles, handle, active_link) {
static bool first = true;
if (first) {
fprintf(stderr, "Active handles:\n");
@ -2981,12 +2977,9 @@ nmsocket_dump(isc_nmsocket_t *sock) {
void
isc__nm_dump_active(isc__networker_t *worker) {
isc_nmsocket_t *sock = NULL;
bool first = true;
for (sock = ISC_LIST_HEAD(worker->active_sockets); sock != NULL;
sock = ISC_LIST_NEXT(sock, active_link))
{
ISC_LIST_FOREACH (worker->active_sockets, sock, active_link) {
if (first) {
fprintf(stderr, "Outstanding sockets\n");
first = false;

21
lib/isccfg/aclconf.c
View file

@ -70,16 +70,14 @@ cfg_aclconfctx_attach(cfg_aclconfctx_t *src, cfg_aclconfctx_t **dest) {
void
cfg_aclconfctx_detach(cfg_aclconfctx_t **actxp) {
REQUIRE(actxp != NULL && *actxp != NULL);
cfg_aclconfctx_t *actx = *actxp;
*actxp = NULL;
if (isc_refcount_decrement(&actx->references) == 1) {
dns_acl_t *dacl, *next;
isc_refcount_destroy(&actx->references);
for (dacl = ISC_LIST_HEAD(actx->named_acl_cache); dacl != NULL;
dacl = next)
ISC_LIST_FOREACH_SAFE (actx->named_acl_cache, dacl, nextincache)
{
next = ISC_LIST_NEXT(dacl, nextincache);
ISC_LIST_UNLINK(actx->named_acl_cache, dacl,
nextincache);
dns_acl_detach(&dacl);
@ -122,14 +120,11 @@ convert_named_acl(const cfg_obj_t *nameobj, const cfg_obj_t *cctx,
unsigned int nest_level, dns_acl_t **target) {
isc_result_t result;
const cfg_obj_t *cacl = NULL;
dns_acl_t *dacl;
dns_acl_t loop;
dns_acl_t loop, *acl = NULL;
const char *aclname = cfg_obj_asstring(nameobj);
/* Look for an already-converted version. */
for (dacl = ISC_LIST_HEAD(ctx->named_acl_cache); dacl != NULL;
dacl = ISC_LIST_NEXT(dacl, nextincache))
{
ISC_LIST_FOREACH (ctx->named_acl_cache, dacl, nextincache) {
if (strcasecmp(aclname, dacl->name) == 0) {
if (ISC_MAGIC_VALID(dacl, LOOP_MAGIC)) {
cfg_obj_log(nameobj, ISC_LOG_ERROR,
@ -155,16 +150,16 @@ convert_named_acl(const cfg_obj_t *nameobj, const cfg_obj_t *cctx,
loop.name = UNCONST(aclname);
loop.magic = LOOP_MAGIC;
ISC_LIST_APPEND(ctx->named_acl_cache, &loop, nextincache);
result = cfg_acl_fromconfig(cacl, cctx, ctx, mctx, nest_level, &dacl);
result = cfg_acl_fromconfig(cacl, cctx, ctx, mctx, nest_level, &acl);
ISC_LIST_UNLINK(ctx->named_acl_cache, &loop, nextincache);
loop.magic = 0;
loop.name = NULL;
if (result != ISC_R_SUCCESS) {
return result;
}
dacl->name = isc_mem_strdup(dacl->mctx, aclname);
ISC_LIST_APPEND(ctx->named_acl_cache, dacl, nextincache);
dns_acl_attach(dacl, target);
acl->name = isc_mem_strdup(acl->mctx, aclname);
ISC_LIST_APPEND(ctx->named_acl_cache, acl, nextincache);
dns_acl_attach(acl, target);
return ISC_R_SUCCESS;
}

36
lib/isccfg/check.c
View file

@ -1193,7 +1193,6 @@ check_options(const cfg_obj_t *options, const cfg_obj_t *config,
isc_buffer_t b;
uint32_t lifetime = 3600;
dns_keystorelist_t kslist;
dns_keystore_t *ks = NULL, *ks_next = NULL;
const char *ccalg = "siphash24";
cfg_aclconfctx_t *actx = NULL;
static const char *sources[] = {
@ -1428,7 +1427,7 @@ check_options(const cfg_obj_t *options, const cfg_obj_t *config,
bad_kasp = true;
} else if (optlevel == optlevel_config) {
dns_kasplist_t list;
dns_kasp_t *kasp = NULL, *kasp_next = NULL;
dns_kasp_t *kasp = NULL;
ISC_LIST_INIT(list);
@ -1465,12 +1464,9 @@ check_options(const cfg_obj_t *options, const cfg_obj_t *config,
}
}
for (kasp = ISC_LIST_HEAD(list); kasp != NULL;
kasp = kasp_next)
{
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_UNLINK(list, kasp, link);
dns_kasp_detach(&kasp);
ISC_LIST_FOREACH_SAFE (list, k, link) {
ISC_LIST_UNLINK(list, k, link);
dns_kasp_detach(&k);
}
}
@ -1496,8 +1492,7 @@ check_options(const cfg_obj_t *options, const cfg_obj_t *config,
/*
* Cleanup key-store.
*/
for (ks = ISC_LIST_HEAD(kslist); ks != NULL; ks = ks_next) {
ks_next = ISC_LIST_NEXT(ks, link);
ISC_LIST_FOREACH_SAFE (kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}
@ -2888,13 +2883,10 @@ check_keydir(const cfg_obj_t *config, const cfg_obj_t *zconfig,
bool do_cleanup = false;
bool done = false;
bool keystore = false;
const cfg_obj_t *kasps = NULL;
dns_kasp_t *kasp = NULL, *kasp_next = NULL;
dns_kasp_t *kasp = NULL;
dns_kasplist_t kasplist;
const cfg_obj_t *keystores = NULL;
dns_keystore_t *ks = NULL, *ks_next = NULL;
dns_keystorelist_t kslist;
/* If no dnssec-policy or key-store, use the dir (key-directory) */
@ -2951,9 +2943,7 @@ check_keydir(const cfg_obj_t *config, const cfg_obj_t *zconfig,
/* Check key-stores of keys */
dns_kasp_freeze(kasp);
for (dns_kasp_key_t *kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp));
kkey != NULL; kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
dns_keystore_t *kks = dns_kasp_key_keystore(kkey);
dir = dns_keystore_directory(kks, keydir);
keystore = (kks != NULL && strcmp(DNS_KEYSTORE_KEYDIRECTORY,
@ -2983,15 +2973,11 @@ check:
if (kasp != NULL) {
dns_kasp_detach(&kasp);
}
for (kasp = ISC_LIST_HEAD(kasplist); kasp != NULL;
kasp = kasp_next)
{
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_UNLINK(kasplist, kasp, link);
dns_kasp_detach(&kasp);
ISC_LIST_FOREACH_SAFE (kasplist, k, link) {
ISC_LIST_UNLINK(kasplist, k, link);
dns_kasp_detach(&k);
}
for (ks = ISC_LIST_HEAD(kslist); ks != NULL; ks = ks_next) {
ks_next = ISC_LIST_NEXT(ks, link);
ISC_LIST_FOREACH_SAFE (kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}

18
lib/isccfg/kaspconf.c
View file

@ -334,7 +334,6 @@ cleanup:
static isc_result_t
cfg_nsec3param_fromconfig(const cfg_obj_t *config, dns_kasp_t *kasp) {
dns_kasp_key_t *kkey;
unsigned int min_keysize = 4096;
const cfg_obj_t *obj = NULL;
uint32_t iter = DEFAULT_NSEC3PARAM_ITER;
@ -348,9 +347,7 @@ cfg_nsec3param_fromconfig(const cfg_obj_t *config, dns_kasp_t *kasp) {
iter = cfg_obj_asuint32(obj);
}
dns_kasp_freeze(kasp);
for (kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp)); kkey != NULL;
kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
unsigned int keysize = dns_kasp_key_size(kkey);
uint32_t keyalg = dns_kasp_key_algorithm(kkey);
@ -632,7 +629,6 @@ cfg_kasp_fromconfig(const cfg_obj_t *config, dns_kasp_t *default_kasp,
if (keys != NULL) {
char role[256] = { 0 };
bool warn[256][2] = { { false } };
dns_kasp_key_t *kkey = NULL;
for (element = cfg_list_first(keys); element != NULL;
element = cfg_list_next(element))
@ -651,9 +647,7 @@ cfg_kasp_fromconfig(const cfg_obj_t *config, dns_kasp_t *default_kasp,
}
}
dns_kasp_freeze(kasp);
for (kkey = ISC_LIST_HEAD(dns_kasp_keys(kasp)); kkey != NULL;
kkey = ISC_LIST_NEXT(kkey, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
uint32_t keyalg = dns_kasp_key_algorithm(kkey);
INSIST(keyalg < ARRAY_SIZE(role));
@ -704,17 +698,15 @@ cfg_kasp_fromconfig(const cfg_obj_t *config, dns_kasp_t *default_kasp,
goto cleanup;
}
} else if (default_kasp) {
dns_kasp_key_t *key, *new_key;
/*
* If there are no specific keys configured in the policy,
* inherit from the default policy (except for the built-in
* "insecure" policy).
*/
for (key = ISC_LIST_HEAD(dns_kasp_keys(default_kasp));
key != NULL; key = ISC_LIST_NEXT(key, link))
{
ISC_LIST_FOREACH (dns_kasp_keys(default_kasp), key, link) {
dns_kasp_key_t *new_key = NULL;
/* Create a new key reference. */
new_key = NULL;
dns_kasp_key_create(kasp, &new_key);
if (dns_kasp_key_ksk(key)) {
new_key->role |= DNS_KASP_KEY_ROLE_KSK;

26
lib/isccfg/parser.c
View file

@ -1949,9 +1949,7 @@ free_listelt(cfg_parser_t *pctx, cfg_listelt_t *elt) {
static void
free_list(cfg_parser_t *pctx, cfg_obj_t *obj) {
cfg_listelt_t *elt, *next;
for (elt = ISC_LIST_HEAD(obj->value.list); elt != NULL; elt = next) {
next = ISC_LIST_NEXT(elt, link);
ISC_LIST_FOREACH_SAFE (obj->value.list, elt, link) {
free_listelt(pctx, elt);
}
}
@ -2022,12 +2020,9 @@ cleanup:
static void
print_list(cfg_printer_t *pctx, const cfg_obj_t *obj) {
const cfg_list_t *list = &obj->value.list;
const cfg_listelt_t *elt;
cfg_list_t *list = UNCONST(&obj->value.list);
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
elt = ISC_LIST_NEXT(elt, link))
{
ISC_LIST_FOREACH (*list, elt, link) {
if ((pctx->flags & CFG_PRINTER_ONELINE) != 0) {
cfg_print_obj(pctx, elt->obj);
cfg_print_cstr(pctx, "; ");
@ -2117,17 +2112,14 @@ cleanup:
void
cfg_print_spacelist(cfg_printer_t *pctx, const cfg_obj_t *obj) {
const cfg_list_t *list = NULL;
const cfg_listelt_t *elt = NULL;
cfg_list_t *list = NULL;
REQUIRE(pctx != NULL);
REQUIRE(obj != NULL);
list = &obj->value.list;
list = UNCONST(&obj->value.list);
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
elt = ISC_LIST_NEXT(elt, link))
{
ISC_LIST_FOREACH (*list, elt, link) {
cfg_print_obj(pctx, elt->obj);
if (ISC_LIST_NEXT(elt, link) != NULL) {
cfg_print_cstr(pctx, " ");
@ -2551,11 +2543,7 @@ cfg_print_mapbody(cfg_printer_t *pctx, const cfg_obj_t *obj) {
if (symobj->type == &cfg_type_implicitlist) {
/* Multivalued. */
cfg_list_t *list = &symobj->value.list;
cfg_listelt_t *elt;
for (elt = ISC_LIST_HEAD(*list);
elt != NULL;
elt = ISC_LIST_NEXT(elt, link))
{
ISC_LIST_FOREACH (*list, elt, link) {
print_symval(pctx, clause->name,
elt->obj);
}

42
lib/ns/client.c
View file

@ -1305,7 +1305,6 @@ compute_cookie(ns_client_t *client, uint32_t when, const unsigned char *secret,
static void
process_cookie(ns_client_t *client, isc_buffer_t *buf, size_t optlen) {
ns_altsecret_t *altsecret;
unsigned char dbuf[COOKIE_SIZE];
unsigned char *old;
isc_stdtime_t now;
@ -1392,9 +1391,7 @@ process_cookie(ns_client_t *client, isc_buffer_t *buf, size_t optlen) {
return;
}
for (altsecret = ISC_LIST_HEAD(client->manager->sctx->altsecrets);
altsecret != NULL; altsecret = ISC_LIST_NEXT(altsecret, link))
{
ISC_LIST_FOREACH (client->manager->sctx->altsecrets, altsecret, link) {
isc_buffer_init(&db, dbuf, sizeof(dbuf));
compute_cookie(client, when, altsecret->secret, &db);
if (isc_safe_memequal(old, dbuf, COOKIE_SIZE)) {
@ -2667,16 +2664,12 @@ ns_clientmgr_create(ns_server_t *sctx, isc_loopmgr_t *loopmgr,
void
ns_clientmgr_shutdown(ns_clientmgr_t *manager) {
ns_client_t *client;
REQUIRE(VALID_MANAGER(manager));
MTRACE("destroy");
LOCK(&manager->reclock);
for (client = ISC_LIST_HEAD(manager->recursing); client != NULL;
client = ISC_LIST_NEXT(client, rlink))
{
ISC_LIST_FOREACH (manager->recursing, client, rlink) {
ns_query_cancel(client);
}
UNLOCK(&manager->reclock);
@ -3139,28 +3132,21 @@ client_getdbversion(ns_client_t *client) {
ns_dbversion_t *
ns_client_findversion(ns_client_t *client, dns_db_t *db) {
ns_dbversion_t *dbversion;
for (dbversion = ISC_LIST_HEAD(client->query.activeversions);
dbversion != NULL; dbversion = ISC_LIST_NEXT(dbversion, link))
{
ISC_LIST_FOREACH (client->query.activeversions, dbversion, link) {
if (dbversion->db == db) {
break;
return dbversion;
}
}
if (dbversion == NULL) {
/*
* This is a new zone for this query. Add it to
* the active list.
*/
dbversion = client_getdbversion(client);
dns_db_attach(db, &dbversion->db);
dns_db_currentversion(db, &dbversion->version);
dbversion->acl_checked = false;
dbversion->queryok = false;
ISC_LIST_APPEND(client->query.activeversions, dbversion, link);
}
/*
* This is a new zone for this query. Add it to
* the active list.
*/
ns_dbversion_t *dbversion = client_getdbversion(client);
dns_db_attach(db, &dbversion->db);
dns_db_currentversion(db, &dbversion->version);
dbversion->acl_checked = false;
dbversion->queryok = false;
ISC_LIST_APPEND(client->query.activeversions, dbversion, link);
return dbversion;
}

10
lib/ns/hooks.c
View file

@ -280,7 +280,6 @@ ns_hooktable_create(isc_mem_t *mctx, ns_hooktable_t **tablep) {
void
ns_hooktable_free(isc_mem_t *mctx, void **tablep) {
ns_hooktable_t *table = NULL;
ns_hook_t *hook = NULL, *next = NULL;
int i = 0;
REQUIRE(tablep != NULL && *tablep != NULL);
@ -289,10 +288,7 @@ ns_hooktable_free(isc_mem_t *mctx, void **tablep) {
*tablep = NULL;
for (i = 0; i < NS_HOOKPOINTS_COUNT; i++) {
for (hook = ISC_LIST_HEAD((*table)[i]); hook != NULL;
hook = next)
{
next = ISC_LIST_NEXT(hook, link);
ISC_LIST_FOREACH_SAFE ((*table)[i], hook, link) {
ISC_LIST_UNLINK((*table)[i], hook, link);
if (hook->mctx != NULL) {
isc_mem_putanddetach(&hook->mctx, hook,
@ -341,15 +337,13 @@ ns_plugins_create(isc_mem_t *mctx, ns_plugins_t **listp) {
void
ns_plugins_free(isc_mem_t *mctx, void **listp) {
ns_plugins_t *list = NULL;
ns_plugin_t *plugin = NULL, *next = NULL;
REQUIRE(listp != NULL && *listp != NULL);
list = *listp;
*listp = NULL;
for (plugin = ISC_LIST_HEAD(*list); plugin != NULL; plugin = next) {
next = ISC_LIST_NEXT(plugin, link);
ISC_LIST_FOREACH_SAFE (*list, plugin, link) {
ISC_LIST_UNLINK(*list, plugin, link);
unload_plugin(&plugin);
}

40
lib/ns/interfacemgr.c
View file

@ -119,7 +119,6 @@ need_rescan(ns_interfacemgr_t *mgr, struct MSGHDR *rtm, size_t len) {
bool existed = false;
bool was_listening = false;
isc_netaddr_t addr = { 0 };
ns_interface_t *ifp = NULL;
isc_netaddr_fromin6(&addr, RTA_DATA(rth));
INSIST(isc_netaddr_getzone(&addr) == 0);
@ -133,10 +132,7 @@ need_rescan(ns_interfacemgr_t *mgr, struct MSGHDR *rtm, size_t len) {
* router advertisements?)
*/
LOCK(&mgr->lock);
for (ifp = ISC_LIST_HEAD(mgr->interfaces);
ifp != NULL;
ifp = ISC_LIST_NEXT(ifp, link))
{
ISC_LIST_FOREACH (mgr->interfaces, ifp, link) {
isc_netaddr_t tmp = { 0 };
isc_netaddr_fromsockaddr(&tmp,
&ifp->addr);
@ -792,17 +788,16 @@ interface_destroy(ns_interface_t **interfacep) {
*/
static ns_interface_t *
find_matching_interface(ns_interfacemgr_t *mgr, isc_sockaddr_t *addr) {
ns_interface_t *ifp;
LOCK(&mgr->lock);
for (ifp = ISC_LIST_HEAD(mgr->interfaces); ifp != NULL;
ifp = ISC_LIST_NEXT(ifp, link))
{
ISC_LIST_FOREACH (mgr->interfaces, ifp, link) {
if (isc_sockaddr_equal(&ifp->addr, addr)) {
break;
UNLOCK(&mgr->lock);
return ifp;
}
}
UNLOCK(&mgr->lock);
return ifp;
return NULL;
}
static void
@ -818,15 +813,13 @@ log_interface_shutdown(const ns_interface_t *ifp) {
*/
static void
purge_old_interfaces(ns_interfacemgr_t *mgr) {
ns_interface_t *ifp = NULL, *next = NULL;
ISC_LIST(ns_interface_t) interfaces;
ISC_LIST_INIT(interfaces);
LOCK(&mgr->lock);
for (ifp = ISC_LIST_HEAD(mgr->interfaces); ifp != NULL; ifp = next) {
ISC_LIST_FOREACH_SAFE (mgr->interfaces, ifp, link) {
INSIST(NS_INTERFACE_VALID(ifp));
next = ISC_LIST_NEXT(ifp, link);
if (ifp->generation != mgr->generation) {
ISC_LIST_UNLINK(ifp->mgr->interfaces, ifp, link);
ISC_LIST_APPEND(interfaces, ifp, link);
@ -834,8 +827,7 @@ purge_old_interfaces(ns_interfacemgr_t *mgr) {
}
UNLOCK(&mgr->lock);
for (ifp = ISC_LIST_HEAD(interfaces); ifp != NULL; ifp = next) {
next = ISC_LIST_NEXT(ifp, link);
ISC_LIST_FOREACH_SAFE (interfaces, ifp, link) {
if (LISTENING(ifp)) {
log_interface_shutdown(ifp);
ns_interface_shutdown(ifp);
@ -902,16 +894,12 @@ static void
setup_listenon(ns_interfacemgr_t *mgr, isc_interface_t *interface,
in_port_t port) {
isc_sockaddr_t *addr;
isc_sockaddr_t *old;
addr = isc_mem_get(mgr->mctx, sizeof(*addr));
isc_sockaddr_fromnetaddr(addr, &interface->address, port);
LOCK(&mgr->lock);
for (old = ISC_LIST_HEAD(mgr->listenon); old != NULL;
old = ISC_LIST_NEXT(old, link))
{
ISC_LIST_FOREACH (mgr->listenon, old, link) {
if (isc_sockaddr_equal(addr, old)) {
/* We found an existing address */
isc_mem_put(mgr->mctx, addr, sizeof(*addr));
@ -1081,7 +1069,6 @@ do_scan(ns_interfacemgr_t *mgr, bool verbose, bool config) {
bool scan_ipv6 = false;
isc_result_t result;
isc_netaddr_t zero_address, zero_address6;
ns_listenelt_t *le = NULL;
ns_interface_t *ifp = NULL;
bool dolistenon;
char sabuf[ISC_SOCKADDR_FORMATSIZE];
@ -1180,9 +1167,7 @@ do_scan(ns_interfacemgr_t *mgr, bool verbose, bool config) {
listenon:
ll = (family == AF_INET) ? mgr->listenon4 : mgr->listenon6;
dolistenon = true;
for (le = ISC_LIST_HEAD(ll->elts); le != NULL;
le = ISC_LIST_NEXT(le, link))
{
ISC_LIST_FOREACH (ll->elts, le, link) {
int match;
bool addr_in_use = false;
isc_sockaddr_t listen_sockaddr;
@ -1347,7 +1332,6 @@ ns_interfacemgr_dumprecursing(FILE *f, ns_interfacemgr_t *mgr) {
bool
ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr,
const isc_sockaddr_t *addr) {
isc_sockaddr_t *old;
bool result = false;
REQUIRE(NS_INTERFACEMGR_VALID(mgr));
@ -1359,9 +1343,7 @@ ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr,
return true;
}
LOCK(&mgr->lock);
for (old = ISC_LIST_HEAD(mgr->listenon); old != NULL;
old = ISC_LIST_NEXT(old, link))
{
ISC_LIST_FOREACH (mgr->listenon, old, link) {
if (isc_sockaddr_equal(old, addr)) {
result = true;
break;

4
lib/ns/listenlist.c
View file

@ -297,9 +297,7 @@ ns_listenlist_create(isc_mem_t *mctx, ns_listenlist_t **target) {
static void
destroy(ns_listenlist_t *list) {
ns_listenelt_t *elt, *next;
for (elt = ISC_LIST_HEAD(list->elts); elt != NULL; elt = next) {
next = ISC_LIST_NEXT(elt, link);
ISC_LIST_FOREACH_SAFE (list->elts, elt, link) {
ns_listenelt_destroy(elt);
}
isc_mem_put(list->mctx, list, sizeof(*list));

25
lib/ns/query.c
View file

@ -730,18 +730,14 @@ query_next(ns_client_t *client, isc_result_t result) {
static void
query_freefreeversions(ns_client_t *client, bool everything) {
ns_dbversion_t *dbversion, *dbversion_next;
unsigned int i;
unsigned int i = 0;
for (dbversion = ISC_LIST_HEAD(client->query.freeversions), i = 0;
dbversion != NULL; dbversion = dbversion_next, i++)
{
dbversion_next = ISC_LIST_NEXT(dbversion, link);
ISC_LIST_FOREACH_SAFE (client->query.freeversions, dbversion, link) {
/*
* If we're not freeing everything, we keep the first three
* dbversions structures around.
*/
if (i > 3 || everything) {
if (i++ > 3 || everything) {
ISC_LIST_UNLINK(client->query.freeversions, dbversion,
link);
isc_mem_put(client->manager->mctx, dbversion,
@ -771,9 +767,6 @@ ns_query_cancel(ns_client_t *client) {
static void
query_reset(ns_client_t *client, bool everything) {
isc_buffer_t *dbuf, *dbuf_next;
ns_dbversion_t *dbversion, *dbversion_next;
CTRACE(ISC_LOG_DEBUG(3), "query_reset");
/*%
@ -788,10 +781,7 @@ query_reset(ns_client_t *client, bool everything) {
/*
* Cleanup any active versions.
*/
for (dbversion = ISC_LIST_HEAD(client->query.activeversions);
dbversion != NULL; dbversion = dbversion_next)
{
dbversion_next = ISC_LIST_NEXT(dbversion, link);
ISC_LIST_FOREACH_SAFE (client->query.activeversions, dbversion, link) {
dns_db_closeversion(dbversion->db, &dbversion->version, false);
dns_db_detach(&dbversion->db);
ISC_LIST_INITANDAPPEND(client->query.freeversions, dbversion,
@ -834,11 +824,8 @@ query_reset(ns_client_t *client, bool everything) {
query_freefreeversions(client, everything);
for (dbuf = ISC_LIST_HEAD(client->query.namebufs); dbuf != NULL;
dbuf = dbuf_next)
{
dbuf_next = ISC_LIST_NEXT(dbuf, link);
if (dbuf_next != NULL || everything) {
ISC_LIST_FOREACH_SAFE (client->query.namebufs, dbuf, link) {
if (ISC_LIST_NEXT(dbuf, link) != NULL || everything) {
ISC_LIST_UNLINK(client->query.namebufs, dbuf, link);
isc_buffer_free(&dbuf);
}

50
lib/ns/update.c
View file

@ -2033,14 +2033,11 @@ static isc_result_t
remove_orphaned_ds(dns_db_t *db, dns_dbversion_t *newver, dns_diff_t *diff) {
isc_result_t result;
bool ns_exists;
dns_difftuple_t *tuple;
dns_diff_t temp_diff;
dns_diff_init(diff->mctx, &temp_diff);
for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL;
tuple = ISC_LIST_NEXT(tuple, link))
{
ISC_LIST_FOREACH (diff->tuples, tuple, link) {
if (!((tuple->op == DNS_DIFFOP_DEL &&
tuple->rdata.type == dns_rdatatype_ns) ||
(tuple->op == DNS_DIFFOP_ADD &&
@ -2061,9 +2058,7 @@ remove_orphaned_ds(dns_db_t *db, dns_dbversion_t *newver, dns_diff_t *diff) {
result = ISC_R_SUCCESS;
failure:
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
tuple = ISC_LIST_HEAD(temp_diff.tuples))
{
ISC_LIST_FOREACH_SAFE (temp_diff.tuples, tuple, link) {
ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
dns_diff_appendminimal(diff, &tuple);
}
@ -2080,9 +2075,8 @@ check_mx(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
char ownerbuf[DNS_NAME_FORMATSIZE];
char namebuf[DNS_NAME_FORMATSIZE];
char altbuf[DNS_NAME_FORMATSIZE];
dns_difftuple_t *t;
dns_fixedname_t fixed;
dns_name_t *foundname;
dns_name_t *foundname = NULL;
dns_rdata_mx_t mx;
dns_rdata_t rdata;
bool ok = true;
@ -2096,9 +2090,7 @@ check_mx(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
dns_rdata_init(&rdata);
options = dns_zone_getoptions(zone);
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
{
ISC_LIST_FOREACH (diff->tuples, t, link) {
if (t->op != DNS_DIFFOP_ADD ||
t->rdata.type != dns_rdatatype_mx)
{
@ -2369,7 +2361,7 @@ static isc_result_t
add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t *ver, dns_diff_t *diff) {
isc_result_t result = ISC_R_SUCCESS;
dns_difftuple_t *tuple, *newtuple = NULL, *next;
dns_difftuple_t *newtuple = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE + 1];
dns_diff_t temp_diff;
@ -2388,9 +2380,7 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
/*
* Extract NSEC3PARAM tuples from list.
*/
for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL; tuple = next) {
next = ISC_LIST_NEXT(tuple, link);
ISC_LIST_FOREACH_SAFE (diff->tuples, tuple, link) {
if (tuple->rdata.type != dns_rdatatype_nsec3param ||
!dns_name_equal(name, &tuple->name))
{
@ -2404,8 +2394,9 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
* Extract TTL changes pairs, we don't need to convert these to
* delayed changes.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
tuple = next)
for (dns_difftuple_t *tuple = ISC_LIST_HEAD(temp_diff.tuples),
*next = NULL;
tuple != NULL; tuple = next)
{
if (tuple->op == DNS_DIFFOP_ADD) {
if (!ttl_good) {
@ -2464,10 +2455,7 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
* in managing and should not be touched so revert such changes
* taking into account any TTL change of the NSEC3PARAM RRset.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
tuple = next)
{
next = ISC_LIST_NEXT(tuple, link);
ISC_LIST_FOREACH_SAFE (temp_diff.tuples, tuple, link) {
if ((tuple->rdata.data[1] & ~DNS_NSEC3FLAG_OPTOUT) != 0) {
/*
* If we haven't had any adds then the tuple->ttl must
@ -2493,8 +2481,9 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
* Convert the adds to delayed adds and the deletions into delayed
* deletions.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
tuple = next)
for (dns_difftuple_t *tuple = ISC_LIST_HEAD(temp_diff.tuples),
*next = NULL;
tuple != NULL; tuple = next)
{
/*
* If we haven't had any adds then the tuple->ttl must be the
@ -2598,8 +2587,9 @@ add_nsec3param_records(ns_client_t *client, dns_zone_t *zone, dns_db_t *db,
}
}
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
tuple = next)
for (dns_difftuple_t *tuple = ISC_LIST_HEAD(temp_diff.tuples),
*next = NULL;
tuple != NULL; tuple = next)
{
INSIST(ttl_good);
@ -2642,7 +2632,7 @@ rollback_private(dns_db_t *db, dns_rdatatype_t privatetype,
dns_dbversion_t *ver, dns_diff_t *diff) {
dns_diff_t temp_diff;
dns_diffop_t op;
dns_difftuple_t *tuple, *newtuple = NULL, *next;
dns_difftuple_t *newtuple = NULL;
dns_name_t *name = dns_db_origin(db);
isc_mem_t *mctx = diff->mctx;
isc_result_t result;
@ -2656,9 +2646,7 @@ rollback_private(dns_db_t *db, dns_rdatatype_t privatetype,
/*
* Extract the changes to be rolled back.
*/
for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL; tuple = next) {
next = ISC_LIST_NEXT(tuple, link);
ISC_LIST_FOREACH_SAFE (diff->tuples, tuple, link) {
if (tuple->rdata.type != privatetype ||
!dns_name_equal(name, &tuple->name))
{
@ -2682,7 +2670,7 @@ rollback_private(dns_db_t *db, dns_rdatatype_t privatetype,
/*
* Rollback the changes.
*/
while ((tuple = ISC_LIST_HEAD(temp_diff.tuples)) != NULL) {
ISC_LIST_FOREACH_SAFE (temp_diff.tuples, tuple, link) {
op = (tuple->op == DNS_DIFFOP_DEL) ? DNS_DIFFOP_ADD
: DNS_DIFFOP_DEL;
dns_difftuple_create(mctx, op, name, tuple->ttl, &tuple->rdata,

10
tests/dns/dbdiff_test.c
View file

@ -76,7 +76,6 @@ ISC_RUN_TEST_IMPL(diffx_same) {
/* dns_db_diffx of zone with record added */
ISC_RUN_TEST_IMPL(diffx_add) {
dns_db_t *newdb = NULL, *olddb = NULL;
dns_difftuple_t *tuple;
isc_result_t result;
dns_diff_t diff;
int count = 0;
@ -92,9 +91,7 @@ ISC_RUN_TEST_IMPL(diffx_add) {
assert_int_equal(result, ISC_R_SUCCESS);
assert_false(ISC_LIST_EMPTY(diff.tuples));
for (tuple = ISC_LIST_HEAD(diff.tuples); tuple != NULL;
tuple = ISC_LIST_NEXT(tuple, link))
{
ISC_LIST_FOREACH (diff.tuples, tuple, link) {
assert_int_equal(tuple->op, DNS_DIFFOP_ADD);
count++;
}
@ -108,7 +105,6 @@ ISC_RUN_TEST_IMPL(diffx_add) {
/* dns_db_diffx of zone with record removed */
ISC_RUN_TEST_IMPL(diffx_remove) {
dns_db_t *newdb = NULL, *olddb = NULL;
dns_difftuple_t *tuple;
isc_result_t result;
dns_diff_t diff;
int count = 0;
@ -124,9 +120,7 @@ ISC_RUN_TEST_IMPL(diffx_remove) {
assert_int_equal(result, ISC_R_SUCCESS);
assert_false(ISC_LIST_EMPTY(diff.tuples));
for (tuple = ISC_LIST_HEAD(diff.tuples); tuple != NULL;
tuple = ISC_LIST_NEXT(tuple, link))
{
ISC_LIST_FOREACH (diff.tuples, tuple, link) {
assert_int_equal(tuple->op, DNS_DIFFOP_DEL);
count++;
}

7
tests/dns/diff_test.c
View file

@ -47,13 +47,10 @@ unsigned char data_nodup[] = "\006name_1";
dns_name_t name_nodup = DNS_NAME_INITABSOLUTE(data_nodup);
static size_t
count_elements(const dns_diff_t *diff) {
dns_difftuple_t *ot = NULL;
count_elements(dns_diff_t *diff) {
size_t count = 0;
for (ot = ISC_LIST_HEAD(diff->tuples); ot != NULL;
ot = ISC_LIST_NEXT(ot, link))
{
ISC_LIST_FOREACH (diff->tuples, ot, link) {
++count;
}

11
tests/dns/sigs_test.c
View file

@ -175,8 +175,7 @@ updatesigs_test(const updatesigs_test_params_t *test, dns_zone_t *zone,
size_t tuples_expected, tuples_found, index;
dns_dbversion_t *version = NULL;
dns_diff_t raw_diff, zone_diff;
const zonediff_t *expected;
dns_difftuple_t *found;
const zonediff_t *expected = NULL;
isc_result_t result;
dns__zonediff_t zonediff = {
@ -235,9 +234,7 @@ updatesigs_test(const updatesigs_test_params_t *test, dns_zone_t *zone,
}
tuples_found = 0;
for (found = ISC_LIST_HEAD(zone_diff.tuples); found != NULL;
found = ISC_LIST_NEXT(found, link))
{
ISC_LIST_FOREACH (zone_diff.tuples, found, link) {
tuples_found++;
}
@ -248,9 +245,7 @@ updatesigs_test(const updatesigs_test_params_t *test, dns_zone_t *zone,
*/
expected = test->zonediff;
index = 1;
for (found = ISC_LIST_HEAD(zone_diff.tuples); found != NULL;
found = ISC_LIST_NEXT(found, link))
{
ISC_LIST_FOREACH (zone_diff.tuples, found, link) {
compare_tuples(expected, found, index);
expected++;
index++;

20
tests/dns/skr_test.c
View file

@ -129,9 +129,7 @@ print_rdata(FILE *fp, dns_rdata_t *rdata) {
isc_buffer_usedregion(&target, &r);
fprintf(fp, "%.*s", (int)r.length, (char *)r.base);
for (dns_rdata_t *rd = ISC_LIST_HEAD(rdatalist->rdata); rd != NULL;
rd = ISC_LIST_HEAD(rdatalist->rdata))
{
ISC_LIST_FOREACH_SAFE (rdatalist->rdata, rd, link) {
ISC_LIST_UNLINK(rdatalist->rdata, rdata, link);
}
isc_mem_put(mctx, rdatalist, sizeof(*rdatalist));
@ -241,9 +239,7 @@ create_bundle(FILE *fp, isc_stdtime_t btime, int bnum) {
sign_rrset(fp, btime, (btime + LIFETIME), dnskeyset,
test_bundles[bnum].rrsig1buf,
&test_bundles[bnum].dnskey_rrsig);
for (dns_rdata_t *rd = ISC_LIST_HEAD(dnskeylist->rdata); rd != NULL;
rd = ISC_LIST_HEAD(dnskeylist->rdata))
{
ISC_LIST_FOREACH_SAFE (dnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(dnskeylist->rdata, rd, link);
}
isc_mem_put(mctx, dnskeylist, sizeof(*dnskeylist));
@ -268,9 +264,7 @@ create_bundle(FILE *fp, isc_stdtime_t btime, int bnum) {
sign_rrset(fp, btime, (btime + LIFETIME), cdnskeyset,
test_bundles[bnum].rrsig2buf,
&test_bundles[bnum].cdnskey_rrsig);
for (dns_rdata_t *rd = ISC_LIST_HEAD(cdnskeylist->rdata); rd != NULL;
rd = ISC_LIST_HEAD(cdnskeylist->rdata))
{
ISC_LIST_FOREACH_SAFE (cdnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(cdnskeylist->rdata, rd, link);
}
isc_mem_put(mctx, cdnskeylist, sizeof(*cdnskeylist));
@ -293,9 +287,7 @@ create_bundle(FILE *fp, isc_stdtime_t btime, int bnum) {
dns_rdata_init(&test_bundles[bnum].cds_rrsig);
sign_rrset(fp, btime, (btime + LIFETIME), cdsset,
test_bundles[bnum].rrsig3buf, &test_bundles[bnum].cds_rrsig);
for (dns_rdata_t *rd = ISC_LIST_HEAD(cdslist->rdata); rd != NULL;
rd = ISC_LIST_HEAD(cdslist->rdata))
{
ISC_LIST_FOREACH_SAFE (cdslist->rdata, rd, link) {
ISC_LIST_UNLINK(cdslist->rdata, rd, link);
}
isc_mem_put(mctx, cdslist, sizeof(*cdslist));
@ -467,9 +459,7 @@ ISC_RUN_TEST_IMPL(skr_read) {
isc_file_remove(testskr);
/* Test bundles */
for (dns_skrbundle_t *bundle = ISC_LIST_HEAD(skr->bundles);
bundle != NULL; bundle = ISC_LIST_NEXT(bundle, link))
{
ISC_LIST_FOREACH (skr->bundles, bundle, link) {
count++;
}
assert_int_equal(count, 42);

5
tests/libtest/qp.c
View file

@ -167,9 +167,8 @@ qp_test_dumpmulti(dns_qpmulti_t *multi) {
qpr.base);
printf("qpmulti->reader %p whence %p\n", reader, whence);
unsigned int snapshots = 0;
for (dns_qpsnap_t *snap = ISC_LIST_HEAD(multi->snapshots); //
snap != NULL; snap = ISC_LIST_NEXT(snap, link), snapshots++)
{
ISC_LIST_FOREACH (multi->snapshots, snap, link) {
snapshots++;
}
printf("qpmulti %p snapshots %u\n", multi, snapshots);
fflush(stdout);