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) {
/* 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);
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);
}
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);
}
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);
}
}
*/
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) {
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);
}
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);
}
}
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];
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);
}
void
cancel_all(void) {
dig_lookup_t *l, *n;
- dig_query_t *q, *nq;
debug("cancel_all()");
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;
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;
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 ||
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);
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("/");
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;
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));
}
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);
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);
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)) {
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;
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));
}
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)) {
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);
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;
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;
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;
/* 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;
(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
*/
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)))
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;
}
while (result == ISC_R_SUCCESS) {
+ dns_dnsseckey_t *key = NULL;
bool expired, refresh, future, offline;
bool keep = false, resign = false;
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;
}
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))
{
* 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);
* - 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) !=
}
/* 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;
}
}
}
/* 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;
}
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);
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));
}
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;
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;
}
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;
}
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;
}
/* 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++;
}
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);
}
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);
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",
}
}
/* 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)
{
}
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);
}
/*
* 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);
}
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);
}
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;
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);
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;
}
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);
}
}
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;
/*
* 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,
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;
}
}
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)
{
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;
}
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;
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) {
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);
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);
* 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);
}
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;
}
* 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);
}
}
* 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);
}
}
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)
{
}
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);
}
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));
"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);
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;
/*
* 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 &&
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;
(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);
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
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)
{
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);
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);
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;
}
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];
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;
}
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),
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,
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;
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)
{
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);
* 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;
}
* 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;
}
}
/* 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;
}
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);
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;
}
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];
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)
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)
{
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;
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)
{
(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)
{
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;
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));
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);
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);
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;
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);
}
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;
}
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) {
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) &&
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;
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))
{
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;
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;
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;
/* 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;
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;
}
}
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;
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);
}
}
- 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);
}
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);
}
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];
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) {
(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) {
}
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 {
}
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);
}
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;
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;
}
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;
}
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;
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) {
dns_acl_allowed(&netdst, tsig, view->matchdestinations,
env))
{
- break;
+ return view == myview;
}
}
- return view == myview;
+
+ return false;
}
/*%
dnsport);
}
} else {
- isc_sockaddr_t *sa;
int i;
/*
* 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) {
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) {
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;
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;
}
}
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));
/*
* 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;
/* 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;
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);
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);
/*
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);
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);
/*
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);
*/
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
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);
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);
}
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);
}
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)) {
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;
}
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));
* 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)
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) {
}
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);
}
}
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;
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;
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;
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",
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)) {
* 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;
}
/* 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);
*/
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;
}
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.
/*
* 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;
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;
/* 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);
}
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;
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,
}
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);
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);
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),
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;
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);
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,
/*
* 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);
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;
* 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))
{
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))
* 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))
}
/* 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);
}
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;
}
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) {
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);
*/
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
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,
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,
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);
* 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;
};
};
*/
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.
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;
* 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 =
/*
* 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.
*/
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));
}
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
}
/* 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;
}
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;
}
*/
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.
*/
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;
}
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)))
{
* 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;
}
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;
}
/* 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)))
{
/* 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)))
{
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));
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) {
* 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));
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);
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);
}
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;
}
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++;
}
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;
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),
}
}
- 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;
}
/* 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,
* 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,
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));
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;
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;
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;
}
*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,
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;
}
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);
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;
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;
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;
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;
*/
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);
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;
}
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
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] ==
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
*
* 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);
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));
/*
* 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;
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;
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);
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++;
}
}
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;
}
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)
{
if (negsig == NULL) {
return ISC_R_NOTFOUND;
}
+
/*
* Minimise ttl.
*/
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);
(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) {
}
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;
}
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)
{
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);
(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) {
}
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) {
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);
* 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);
}
}
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);
}
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);
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);
}
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");
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(),
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;
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++;
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;
}
static void
add_bad_edns(fetchctx_t *fctx, isc_sockaddr_t *address) {
- isc_sockaddr_t *sa;
-
#ifdef ENABLE_AFL
if (dns_fuzzing_resolver) {
return;
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;
}
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);
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;
}
static bool
mark_bad(fetchctx_t *fctx) {
- dns_adbfind_t *curr;
- dns_adbaddrinfo_t *addrinfo;
bool all_bad = true;
#ifdef ENABLE_AFL
/*
* 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 {
/*
* 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 {
/*
* 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 {
}
}
- 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 {
*/
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);
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);
*/
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,
*/
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,
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.
/*
* 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;
* state.
*/
fctx->minimized = false;
- return addrinfo;
+ return ai;
}
}
/*
* 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);
}
fctx->find = find;
- if (addrinfo != NULL) {
- return addrinfo;
+ if (faddrinfo != NULL) {
+ return faddrinfo;
}
/*
/*
* 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);
} 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;
}
}
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));
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));
}
static void
clone_results(fetchctx_t *fctx) {
- dns_fetchresponse_t *resp = NULL, *hresp = NULL;
+ dns_fetchresponse_t *hresp = NULL;
FCTXTRACE("clone_results");
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);
}
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);
}
}
}
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;
* 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;
}
/*
* 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;
}
}
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;
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 {
}
}
} 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);
*/
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;
*/
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)) {
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;
*/
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)) {
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;
*/
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)) {
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;
/* 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))
{
* 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);
* 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);
}
}
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);
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++;
}
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);
}
}
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);
dns_rdata_clone(&tuple->rdata, sigrdata);
return ISC_R_SUCCESS;
}
-
- tuple = ISC_LIST_NEXT(tuple, link);
}
return ISC_R_NOTFOUND;
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;
}
}
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));
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;
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),
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;
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
}
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) {
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) {
* 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;
* (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;
* 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;
* 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) {
* 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);
}
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,
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);
}
* (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;
}
}
/*
* 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. */
* 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);
}
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,
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);
}
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));
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);
}
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;
unsigned int i;
isc_result_t result;
dns_dlzfindzone_t findzone;
- dns_dlzdb_t *dlzdb;
dns_db_t *db, *best = NULL;
/*
/* 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));
/*
*/
static void
zone_free(dns_zone_t *zone) {
- dns_signing_t *signing = NULL;
- dns_nsec3chain_t *nsec3chain = NULL;
- dns_include_t *include = NULL;
-
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(!LOCKED_ZONE(zone));
REQUIRE(zone->timer == NULL);
INSIST(zone->prev_view == NULL);
/* Unmanaged objects */
- for (struct np3 *npe = ISC_LIST_HEAD(zone->setnsec3param_queue);
- npe != NULL; npe = ISC_LIST_HEAD(zone->setnsec3param_queue))
- {
+ ISC_LIST_FOREACH_SAFE (zone->setnsec3param_queue, npe, link) {
ISC_LIST_UNLINK(zone->setnsec3param_queue, npe, link);
isc_mem_put(zone->mctx, npe, sizeof(*npe));
}
- for (signing = ISC_LIST_HEAD(zone->signing); signing != NULL;
- signing = ISC_LIST_HEAD(zone->signing))
- {
+ ISC_LIST_FOREACH_SAFE (zone->signing, signing, link) {
ISC_LIST_UNLINK(zone->signing, signing, link);
dns_db_detach(&signing->db);
dns_dbiterator_destroy(&signing->dbiterator);
isc_mem_put(zone->mctx, signing, sizeof *signing);
}
- for (nsec3chain = ISC_LIST_HEAD(zone->nsec3chain); nsec3chain != NULL;
- nsec3chain = ISC_LIST_HEAD(zone->nsec3chain))
- {
+
+ ISC_LIST_FOREACH_SAFE (zone->nsec3chain, nsec3chain, link) {
ISC_LIST_UNLINK(zone->nsec3chain, nsec3chain, link);
dns_db_detach(&nsec3chain->db);
dns_dbiterator_destroy(&nsec3chain->dbiterator);
isc_mem_put(zone->mctx, nsec3chain, sizeof *nsec3chain);
}
- for (include = ISC_LIST_HEAD(zone->includes); include != NULL;
- include = ISC_LIST_HEAD(zone->includes))
- {
+
+ ISC_LIST_FOREACH_SAFE (zone->includes, include, link) {
ISC_LIST_UNLINK(zone->includes, include, link);
isc_mem_free(zone->mctx, include->name);
isc_mem_put(zone->mctx, include, sizeof *include);
}
- for (include = ISC_LIST_HEAD(zone->newincludes); include != NULL;
- include = ISC_LIST_HEAD(zone->newincludes))
- {
+
+ ISC_LIST_FOREACH_SAFE (zone->newincludes, include, link) {
ISC_LIST_UNLINK(zone->newincludes, include, link);
isc_mem_free(zone->mctx, include->name);
isc_mem_put(zone->mctx, include, sizeof *include);
}
+
if (zone->masterfile != NULL) {
isc_mem_free(zone->mctx, zone->masterfile);
}
zone_touched(dns_zone_t *zone) {
isc_result_t result;
isc_time_t modtime;
- dns_include_t *include;
REQUIRE(DNS_ZONE_VALID(zone));
return true;
}
- for (include = ISC_LIST_HEAD(zone->includes); include != NULL;
- include = ISC_LIST_NEXT(include, link))
- {
+ ISC_LIST_FOREACH (zone->includes, include, link) {
result = isc_file_getmodtime(include->name, &modtime);
if (result != ISC_R_SUCCESS ||
isc_time_compare(&modtime, &include->filetime) > 0)
* but we need to associate the database with the zone object.
*/
if (strcmp(zone->db_argv[0], "dlz") == 0) {
- dns_dlzdb_t *dlzdb;
+ dns_dlzdb_t *dlzdb = NULL;
dns_dlzfindzone_t findzone;
- for (dlzdb = ISC_LIST_HEAD(zone->view->dlz_unsearched);
- dlzdb != NULL; dlzdb = ISC_LIST_NEXT(dlzdb, link))
- {
- INSIST(DNS_DLZ_VALID(dlzdb));
- if (strcmp(zone->db_argv[1], dlzdb->dlzname) == 0) {
+ ISC_LIST_FOREACH (zone->view->dlz_unsearched, d, link) {
+ INSIST(DNS_DLZ_VALID(d));
+ if (strcmp(zone->db_argv[1], d->dlzname) == 0) {
+ dlzdb = d;
break;
}
}
zone_registerinclude(const char *filename, void *arg) {
isc_result_t result;
dns_zone_t *zone = (dns_zone_t *)arg;
- dns_include_t *inc = NULL;
REQUIRE(DNS_ZONE_VALID(zone));
/*
* Suppress duplicates.
*/
- for (inc = ISC_LIST_HEAD(zone->newincludes); inc != NULL;
- inc = ISC_LIST_NEXT(inc, link))
- {
+ ISC_LIST_FOREACH (zone->newincludes, inc, link) {
if (strcmp(filename, inc->name) == 0) {
return;
}
}
- inc = isc_mem_get(zone->mctx, sizeof(dns_include_t));
+ dns_include_t *inc = isc_mem_get(zone->mctx, sizeof(dns_include_t));
inc->name = isc_mem_strdup(zone->mctx, filename);
ISC_LINK_INIT(inc, link);
*/
static isc_result_t
zone_addnsec3chain(dns_zone_t *zone, dns_rdata_nsec3param_t *nsec3param) {
- dns_nsec3chain_t *nsec3chain, *current;
+ dns_nsec3chain_t *nsec3chain;
dns_dbversion_t *version = NULL;
bool nseconly = false, nsec3ok = false;
isc_result_t result;
* currently being processed, interrupt its processing to avoid
* simultaneously adding and removing records for the same NSEC3 chain.
*/
- for (current = ISC_LIST_HEAD(zone->nsec3chain); current != NULL;
- current = ISC_LIST_NEXT(current, link))
- {
+ ISC_LIST_FOREACH (zone->nsec3chain, current, link) {
if ((current->db == db) &&
(current->nsec3param.hash == nsec3param->hash) &&
(current->nsec3param.iterations ==
bool hasinclude = DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HASINCLUDE);
bool noprimary = false;
bool had_db = false;
- dns_include_t *inc;
bool is_dynamic = false;
INSIST(LOCKED_ZONE(zone));
/*
* Clear old include list.
*/
- for (inc = ISC_LIST_HEAD(zone->includes); inc != NULL;
- inc = ISC_LIST_HEAD(zone->includes))
- {
+ ISC_LIST_FOREACH_SAFE (zone->includes, inc, link) {
ISC_LIST_UNLINK(zone->includes, inc, link);
isc_mem_free(zone->mctx, inc->name);
isc_mem_put(zone->mctx, inc, sizeof(*inc));
/*
* Transfer new include list.
*/
- for (inc = ISC_LIST_HEAD(zone->newincludes); inc != NULL;
- inc = ISC_LIST_HEAD(zone->newincludes))
- {
+ ISC_LIST_FOREACH_SAFE (zone->newincludes, inc, link) {
ISC_LIST_UNLINK(zone->newincludes, inc, link);
ISC_LIST_APPEND(zone->includes, inc, link);
zone->nincludes++;
dns_zone_catz_disable_db(zone, db);
}
- for (inc = ISC_LIST_HEAD(zone->newincludes); inc != NULL;
- inc = ISC_LIST_HEAD(zone->newincludes))
- {
+ ISC_LIST_FOREACH_SAFE (zone->newincludes, inc, link) {
ISC_LIST_UNLINK(zone->newincludes, inc, link);
isc_mem_free(zone->mctx, inc->name);
isc_mem_put(zone->mctx, inc, sizeof(*inc));
(DST_TYPE_PUBLIC | DST_TYPE_PRIVATE | DST_TYPE_STATE),
directory, mctx, &foundkey);
} 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,
zone->keydirectory);
isc_result_t result;
const char *dir = dns_zone_getkeydirectory(zone);
dns_dbnode_t *node = NULL;
- dns_dnsseckey_t *key, *key_next;
dns_dnsseckeylist_t dnskeys;
dns_name_t *origin = dns_zone_getorigin(zone);
dns_kasp_t *kasp = zone->kasp;
}
/* Add new 'dnskeys' to 'keys'. */
- for (dns_dnsseckey_t *k1 = ISC_LIST_HEAD(dnskeys); k1 != NULL;
- k1 = key_next)
- {
- dns_dnsseckey_t *k2 = NULL;
- key_next = ISC_LIST_NEXT(k1, link);
+ ISC_LIST_FOREACH_SAFE (dnskeys, k1, link) {
+ bool match = false;
- for (k2 = ISC_LIST_HEAD(*keys); k2 != NULL;
- k2 = ISC_LIST_NEXT(k2, link))
- {
+ ISC_LIST_FOREACH (*keys, k2, link) {
if (dst_key_compare(k1->key, k2->key)) {
+ match = true;
break;
}
}
+
/* No match found, add the new key. */
- if (k2 == NULL) {
+ if (!match) {
ISC_LIST_UNLINK(dnskeys, k1, link);
ISC_LIST_APPEND(*keys, k1, link);
}
dns_db_detachnode(db, &node);
}
while (!ISC_LIST_EMPTY(dnskeys)) {
- key = ISC_LIST_HEAD(dnskeys);
+ dns_dnsseckey_t *key = ISC_LIST_HEAD(dnskeys);
ISC_LIST_UNLINK(dnskeys, key, link);
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
}
if (zone->kasp != NULL) {
- dns_kasp_key_t *kkey;
int zsk_count = 0;
bool approved;
KASP_LOCK(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) {
if (dns_kasp_key_algorithm(kkey) != dst_key_alg(key)) {
continue;
}
dns__zonediff_t zonediff;
dns_fixedname_t fixed;
dns_fixedname_t nextfixed;
- dns_name_t *name, *nextname;
+ dns_name_t *name = NULL, *nextname = NULL;
dns_rdataset_t rdataset;
- dns_nsec3chain_t *nsec3chain = NULL, *nextnsec3chain;
+ dns_nsec3chain_t *nsec3chain = NULL;
dns_nsec3chainlist_t cleanup;
dst_key_t *zone_keys[DNS_MAXZONEKEYS];
int32_t signatures;
dns_dbiterator_pause(nsec3chain->dbiterator);
LOCK_ZONE(zone);
- nextnsec3chain = ISC_LIST_NEXT(nsec3chain, link);
+ dns_nsec3chain_t *nextnsec3chain = ISC_LIST_NEXT(nsec3chain,
+ link);
ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
if (nsec3chain->done || nsec3chain->db != zone->db) {
dns_dbiterator_pause(nsec3chain->dbiterator);
LOCK_ZONE(zone);
- nextnsec3chain = ISC_LIST_NEXT(nsec3chain, link);
+ dns_nsec3chain_t *nextnsec3chain = ISC_LIST_NEXT(nsec3chain,
+ link);
UNLOCK_ZONE(zone);
if (nsec3chain->db != db) {
* Pause all iterators so that dns_db_closeversion() can succeed.
*/
LOCK_ZONE(zone);
- for (nsec3chain = ISC_LIST_HEAD(zone->nsec3chain); nsec3chain != NULL;
- nsec3chain = ISC_LIST_NEXT(nsec3chain, link))
- {
- dns_dbiterator_pause(nsec3chain->dbiterator);
+ ISC_LIST_FOREACH (zone->nsec3chain, chain, link) {
+ dns_dbiterator_pause(chain->dbiterator);
}
UNLOCK_ZONE(zone);
/*
* Everything succeeded so we can clean these up now.
*/
- nsec3chain = ISC_LIST_HEAD(cleanup);
- while (nsec3chain != NULL) {
- ISC_LIST_UNLINK(cleanup, nsec3chain, link);
- dns_db_detach(&nsec3chain->db);
- dns_dbiterator_destroy(&nsec3chain->dbiterator);
- isc_mem_put(zone->mctx, nsec3chain, sizeof *nsec3chain);
- nsec3chain = ISC_LIST_HEAD(cleanup);
+ ISC_LIST_FOREACH_SAFE (cleanup, chain, link) {
+ ISC_LIST_UNLINK(cleanup, chain, link);
+ dns_db_detach(&chain->db);
+ dns_dbiterator_destroy(&chain->dbiterator);
+ isc_mem_put(zone->mctx, chain, sizeof *chain);
}
LOCK_ZONE(zone);
/*
* Rollback the cleanup list.
*/
- nsec3chain = ISC_LIST_TAIL(cleanup);
- while (nsec3chain != NULL) {
- ISC_LIST_UNLINK(cleanup, nsec3chain, link);
- if (nsec3chain->done) {
- dns_db_detach(&nsec3chain->db);
- dns_dbiterator_destroy(&nsec3chain->dbiterator);
- isc_mem_put(zone->mctx, nsec3chain, sizeof *nsec3chain);
+ ISC_LIST_FOREACH_REV_SAFE (cleanup, chain, link) {
+ ISC_LIST_UNLINK(cleanup, chain, link);
+ if (chain->done) {
+ dns_db_detach(&chain->db);
+ dns_dbiterator_destroy(&chain->dbiterator);
+ isc_mem_put(zone->mctx, chain, sizeof *chain);
} else {
LOCK_ZONE(zone);
- ISC_LIST_PREPEND(zone->nsec3chain, nsec3chain, link);
+ ISC_LIST_PREPEND(zone->nsec3chain, chain, link);
UNLOCK_ZONE(zone);
- result = dns_dbiterator_first(nsec3chain->dbiterator);
+ result = dns_dbiterator_first(chain->dbiterator);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- dns_dbiterator_pause(nsec3chain->dbiterator);
- nsec3chain->delete_nsec = nsec3chain->save_delete_nsec;
+ dns_dbiterator_pause(chain->dbiterator);
+ chain->delete_nsec = chain->save_delete_nsec;
}
- nsec3chain = ISC_LIST_TAIL(cleanup);
}
LOCK_ZONE(zone);
- for (nsec3chain = ISC_LIST_HEAD(zone->nsec3chain); nsec3chain != NULL;
- nsec3chain = ISC_LIST_NEXT(nsec3chain, link))
- {
- dns_dbiterator_pause(nsec3chain->dbiterator);
+ ISC_LIST_FOREACH (zone->nsec3chain, chain, link) {
+ dns_dbiterator_pause(chain->dbiterator);
}
UNLOCK_ZONE(zone);
dst_key_t **keys, unsigned int numkeys) {
uint8_t alg;
dns_rdatatype_t privatetype;
- ;
bool nseconly = false, nsec3 = false;
isc_result_t result;
/* Scan the tuples for an NSEC-only DNSKEY */
if (diff != NULL) {
- for (dns_difftuple_t *tuple = ISC_LIST_HEAD(diff->tuples);
- tuple != NULL; tuple = ISC_LIST_NEXT(tuple, link))
- {
+ ISC_LIST_FOREACH (diff->tuples, tuple, link) {
if (nseconly && nsec3) {
break;
}
dns__zonediff_t zonediff;
dns_fixedname_t fixed;
dns_fixedname_t nextfixed;
- dns_kasp_t *kasp;
- dns_name_t *name, *nextname;
+ dns_kasp_t *kasp = NULL;
+ dns_name_t *name = NULL, *nextname = NULL;
dns_rdataset_t rdataset;
- dns_signing_t *signing, *nextsigning;
+ dns_signing_t *signing = NULL;
dns_signinglist_t cleanup;
dst_key_t *zone_keys[DNS_MAXZONEKEYS];
int32_t signatures;
}
while (signing != NULL && nodes-- > 0 && signatures > 0) {
+ dns_signing_t *nextsigning = ISC_LIST_NEXT(signing, link);
bool has_alg = false;
dns_dbiterator_pause(signing->dbiterator);
- nextsigning = ISC_LIST_NEXT(signing, link);
ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
if (signing->done || signing->db != zone->db) {
/*
* Pause all iterators so that dns_db_closeversion() can succeed.
*/
- for (signing = ISC_LIST_HEAD(zone->signing); signing != NULL;
- signing = ISC_LIST_NEXT(signing, link))
- {
- dns_dbiterator_pause(signing->dbiterator);
+ ISC_LIST_FOREACH (zone->signing, s, link) {
+ dns_dbiterator_pause(s->dbiterator);
}
- for (signing = ISC_LIST_HEAD(cleanup); signing != NULL;
- signing = ISC_LIST_NEXT(signing, link))
- {
- dns_dbiterator_pause(signing->dbiterator);
+ ISC_LIST_FOREACH (cleanup, s, link) {
+ dns_dbiterator_pause(s->dbiterator);
}
/*
/*
* Everything succeeded so we can clean these up now.
*/
- signing = ISC_LIST_HEAD(cleanup);
- while (signing != NULL) {
- ISC_LIST_UNLINK(cleanup, signing, link);
- dns_db_detach(&signing->db);
- dns_dbiterator_destroy(&signing->dbiterator);
- isc_mem_put(zone->mctx, signing, sizeof *signing);
- signing = ISC_LIST_HEAD(cleanup);
+ ISC_LIST_FOREACH_SAFE (cleanup, s, link) {
+ ISC_LIST_UNLINK(cleanup, s, link);
+ dns_db_detach(&s->db);
+ dns_dbiterator_destroy(&s->dbiterator);
+ isc_mem_put(zone->mctx, s, sizeof *s);
}
LOCK_ZONE(zone);
/*
* Pause all dbiterators.
*/
- for (signing = ISC_LIST_HEAD(zone->signing); signing != NULL;
- signing = ISC_LIST_NEXT(signing, link))
- {
- dns_dbiterator_pause(signing->dbiterator);
+ ISC_LIST_FOREACH (zone->signing, s, link) {
+ dns_dbiterator_pause(s->dbiterator);
}
/*
* Rollback the cleanup list.
*/
- signing = ISC_LIST_HEAD(cleanup);
- while (signing != NULL) {
- ISC_LIST_UNLINK(cleanup, signing, link);
- ISC_LIST_PREPEND(zone->signing, signing, link);
- dns_dbiterator_first(signing->dbiterator);
- dns_dbiterator_pause(signing->dbiterator);
- signing = ISC_LIST_HEAD(cleanup);
+ ISC_LIST_FOREACH (cleanup, s, link) {
+ ISC_LIST_UNLINK(cleanup, s, link);
+ ISC_LIST_PREPEND(zone->signing, s, link);
+ dns_dbiterator_first(s->dbiterator);
+ dns_dbiterator_pause(s->dbiterator);
}
dns_diff_clear(&_sig_diff);
static void
notify_cancel(dns_zone_t *zone) {
- dns_notify_t *notify;
-
/*
* 'zone' locked by caller.
*/
REQUIRE(LOCKED_ZONE(zone));
- for (notify = ISC_LIST_HEAD(zone->notifies); notify != NULL;
- notify = ISC_LIST_NEXT(notify, link))
- {
+ ISC_LIST_FOREACH (zone->notifies, notify, link) {
if (notify->find != NULL) {
dns_adb_cancelfind(notify->find);
}
static void
checkds_cancel(dns_zone_t *zone) {
- dns_checkds_t *checkds;
-
/*
* 'zone' locked by caller.
*/
REQUIRE(LOCKED_ZONE(zone));
- for (checkds = ISC_LIST_HEAD(zone->checkds_requests); checkds != NULL;
- checkds = ISC_LIST_NEXT(checkds, link))
- {
+ ISC_LIST_FOREACH (zone->checkds_requests, checkds, link) {
if (checkds->find != NULL) {
dns_adb_cancelfind(checkds->find);
}
static void
forward_cancel(dns_zone_t *zone) {
- dns_forward_t *forward;
-
/*
* 'zone' locked by caller.
*/
REQUIRE(LOCKED_ZONE(zone));
- for (forward = ISC_LIST_HEAD(zone->forwards); forward != NULL;
- forward = ISC_LIST_NEXT(forward, link))
- {
+ ISC_LIST_FOREACH (zone->forwards, forward, link) {
if (forward->request != NULL) {
dns_request_cancel(forward->request);
}
notify_isqueued(dns_zone_t *zone, unsigned int flags, dns_name_t *name,
isc_sockaddr_t *addr, dns_tsigkey_t *key,
dns_transport_t *transport) {
- dns_notify_t *notify;
- dns_zonemgr_t *zmgr;
+ dns_notify_t *notify = NULL;
+ dns_zonemgr_t *zmgr = NULL;
isc_result_t result;
- for (notify = ISC_LIST_HEAD(zone->notifies); notify != NULL;
- notify = ISC_LIST_NEXT(notify, link))
- {
- if (notify->request != NULL) {
+ ISC_LIST_FOREACH (zone->notifies, n, link) {
+ if (n->request != NULL) {
continue;
}
- if (name != NULL && dns_name_dynamic(¬ify->ns) &&
- dns_name_equal(name, ¬ify->ns))
- {
- goto requeue;
- }
- if (addr != NULL && isc_sockaddr_equal(addr, ¬ify->dst) &&
- notify->key == key && notify->transport == transport)
+ if ((name != NULL && dns_name_dynamic(&n->ns) &&
+ dns_name_equal(name, &n->ns)) ||
+ (addr != NULL && isc_sockaddr_equal(addr, &n->dst) &&
+ n->key == key && n->transport == transport))
{
+ notify = n;
goto requeue;
}
}
static void
notify_send(dns_notify_t *notify) {
- dns_adbaddrinfo_t *ai;
isc_sockaddr_t dst;
isc_result_t result;
dns_notify_t *newnotify = NULL;
return;
}
- for (ai = ISC_LIST_HEAD(notify->find->list); ai != NULL;
- ai = ISC_LIST_NEXT(ai, publink))
- {
+ ISC_LIST_FOREACH (notify->find->list, ai, publink) {
dst = ai->sockaddr;
if (notify_isqueued(notify->zone, notify->flags, NULL, &dst,
NULL, NULL))
return result;
}
- for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
- k = ISC_LIST_NEXT(k, link))
- {
+ ISC_LIST_FOREACH (*keylist, k, link) {
if (dst_key_pubcompare(k->key, dstkey, false)) {
*inuse = true;
break;
return result;
}
- for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
- k = ISC_LIST_NEXT(k, link))
- {
+ ISC_LIST_FOREACH (*keylist, k, link) {
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
unsigned char keybuf[DST_KEY_MAXSIZE];
return result;
}
- for (dns_dnsseckey_t *k = ISC_LIST_HEAD(*keylist); k != NULL;
- k = ISC_LIST_NEXT(k, link))
- {
+ ISC_LIST_FOREACH (*keylist, k, link) {
dns_rdata_t dnskey = DNS_RDATA_INIT;
dns_rdata_t cdsrdata = DNS_RDATA_INIT;
unsigned char keybuf[DST_KEY_MAXSIZE];
isc_result_t result;
dns_db_t *rawdb = NULL;
dns_dbversion_t *rawver = NULL;
- dns_difftuple_t *tuple = NULL, *next;
dns_difftuple_t *oldtuple = NULL, *newtuple = NULL;
dns_rdata_soa_t oldsoa, newsoa;
dns_difftuplelist_t add = ISC_LIST_INITIALIZER;
dns_db_detachnode(secdb, &node);
}
- for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL; tuple = next) {
+ ISC_LIST_FOREACH_SAFE (diff->tuples, tuple, link) {
dns_difftuplelist_t *al = &add, *dl = &del;
- next = ISC_LIST_NEXT(tuple, link);
-
/*
* Skip DNSSEC records that BIND maintains with inline-signing.
*/
dns_rdataset_t rdataset, prdataset;
dns_dbversion_t *version = NULL;
nsec3param_t *nsec3param = NULL;
- nsec3param_t *nsec3p = NULL;
- nsec3param_t *next;
dns_db_t *db = NULL;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
*/
rdata.data[1] = 0;
- for (nsec3p = ISC_LIST_HEAD(*nsec3list); nsec3p != NULL;
- nsec3p = next)
- {
- next = ISC_LIST_NEXT(nsec3p, link);
-
+ ISC_LIST_FOREACH_SAFE (*nsec3list, nsec3p, link) {
if (nsec3p->length ==
(unsigned int)rdata.length + 1 &&
memcmp(rdata.data, nsec3p->data + 1,
isc_result_t result = ISC_R_SUCCESS;
dns_diff_t diff;
dns_rdata_t rdata;
- nsec3param_t *nsec3p = NULL;
- nsec3param_t *next;
REQUIRE(DNS_ZONE_VALID(zone));
REQUIRE(!ISC_LIST_EMPTY(*nsec3list));
* and CREATE flags, and the add the record to the apex of the tree
* in db.
*/
- for (nsec3p = ISC_LIST_HEAD(*nsec3list); nsec3p != NULL; nsec3p = next)
- {
- next = ISC_LIST_NEXT(nsec3p, link);
+ ISC_LIST_FOREACH_SAFE (*nsec3list, nsec3p, link) {
dns_rdata_init(&rdata);
nsec3p->data[2] = DNS_NSEC3FLAG_CREATE | DNS_NSEC3FLAG_INITIAL;
rdata.length = nsec3p->length;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- for (dns_zone_t *zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
isc_time_t now;
LOCK_ZONE(zone);
void
dns_zonemgr_shutdown(dns_zonemgr_t *zmgr) {
- dns_zone_t *zone;
-
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
isc_ratelimiter_shutdown(zmgr->checkdsrl);
}
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
LOCK_ZONE(zone);
forward_cancel(zone);
UNLOCK_ZONE(zone);
*/
static void
zmgr_resume_xfrs(dns_zonemgr_t *zmgr, bool multi) {
- dns_zone_t *zone;
- dns_zone_t *next;
-
- for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin); zone != NULL;
- zone = next)
- {
+ ISC_LIST_FOREACH_SAFE (zmgr->waiting_for_xfrin, zone, statelink) {
isc_result_t result;
- next = ISC_LIST_NEXT(zone, statelink);
result = zmgr_start_xfrin_ifquota(zmgr, zone);
if (result == ISC_R_SUCCESS) {
if (multi) {
isc_netaddr_t primaryip;
isc_sockaddr_t curraddr;
uint32_t nxfrsin, nxfrsperns;
- dns_zone_t *x = NULL;
uint32_t maxtransfersin, maxtransfersperns;
/*
* out to be too slow, we could hash on the primary address.
*/
nxfrsin = nxfrsperns = 0;
- for (x = ISC_LIST_HEAD(zmgr->xfrin_in_progress); x != NULL;
- x = ISC_LIST_NEXT(x, statelink))
- {
+ ISC_LIST_FOREACH (zmgr->xfrin_in_progress, x, statelink) {
isc_netaddr_t xip;
isc_sockaddr_t xaddr;
unsigned int
dns_zonemgr_getcount(dns_zonemgr_t *zmgr, dns_zonestate_t state) {
- dns_zone_t *zone;
unsigned int count = 0;
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
switch (state) {
case DNS_ZONESTATE_XFERRUNNING:
- for (zone = ISC_LIST_HEAD(zmgr->xfrin_in_progress);
- zone != NULL; zone = ISC_LIST_NEXT(zone, statelink))
- {
+ ISC_LIST_FOREACH (zmgr->xfrin_in_progress, zone, statelink) {
count++;
}
break;
case DNS_ZONESTATE_XFERDEFERRED:
- for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin);
- zone != NULL; zone = ISC_LIST_NEXT(zone, statelink))
- {
+ ISC_LIST_FOREACH (zmgr->waiting_for_xfrin, zone, statelink) {
count++;
}
break;
case DNS_ZONESTATE_XFERFIRSTREFRESH:
- for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FIRSTREFRESH)) {
count++;
}
}
break;
case DNS_ZONESTATE_SOAQUERY:
- for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH)) {
count++;
}
}
break;
case DNS_ZONESTATE_ANY:
- for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
dns_view_t *view = zone->view;
if (view != NULL && strcmp(view->name, "_bind") == 0) {
continue;
}
break;
case DNS_ZONESTATE_AUTOMATIC:
- for (zone = ISC_LIST_HEAD(zmgr->zones); zone != NULL;
- zone = ISC_LIST_NEXT(zone, link))
- {
+ ISC_LIST_FOREACH (zmgr->zones, zone, link) {
dns_view_t *view = zone->view;
if (view != NULL && strcmp(view->name, "_bind") == 0) {
continue;
static isc_result_t
zone_signwithkey(dns_zone_t *zone, dns_secalg_t algorithm, uint16_t keyid,
bool deleteit) {
- dns_signing_t *signing;
- dns_signing_t *current;
+ dns_signing_t *signing = NULL;
isc_result_t result = ISC_R_SUCCESS;
isc_time_t now;
dns_db_t *db = NULL;
dns_db_attach(db, &signing->db);
- for (current = ISC_LIST_HEAD(zone->signing); current != NULL;
- current = ISC_LIST_NEXT(current, link))
- {
+ ISC_LIST_FOREACH (zone->signing, current, link) {
if (current->db == signing->db &&
current->algorithm == signing->algorithm &&
current->keyid == signing->keyid)
static isc_result_t
add_signing_records(dns_db_t *db, dns_rdatatype_t privatetype,
dns_dbversion_t *ver, dns_diff_t *diff, bool sign_all) {
- dns_difftuple_t *tuple = NULL, *newtuple = NULL, *next = NULL;
- dns_difftuple_t *addtuple = NULL, *deltuple = NULL;
+ dns_difftuple_t *newtuple = NULL;
dns_rdata_dnskey_t dnskey;
dns_rdata_t rdata = DNS_RDATA_INIT;
bool flag;
* Move non DNSKEY and not DNSSEC DNSKEY records to tuples
* and sort the remaining DNSKEY records to add and del.
*/
- for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL;
- tuple = ISC_LIST_HEAD(diff->tuples))
- {
+ ISC_LIST_FOREACH_SAFE (diff->tuples, tuple, link) {
if (tuple->rdata.type != dns_rdatatype_dnskey) {
ISC_LIST_UNLINK(diff->tuples, tuple, link);
ISC_LIST_APPEND(tuples, tuple, link);
/*
* Filter out DNSKEY TTL changes and put them back onto diff->tuples.
*/
- for (deltuple = ISC_LIST_HEAD(del); deltuple != NULL; deltuple = next) {
- next = ISC_LIST_NEXT(deltuple, link);
- for (addtuple = ISC_LIST_HEAD(add); addtuple != NULL;
- addtuple = ISC_LIST_NEXT(addtuple, link))
- {
+ ISC_LIST_FOREACH_SAFE (del, deltuple, link) {
+ ISC_LIST_FOREACH (add, addtuple, link) {
int n = dns_rdata_compare(&deltuple->rdata,
&addtuple->rdata);
if (n == 0) {
* Add private records for keys that have been removed
* or added.
*/
- for (tuple = ISC_LIST_HEAD(tuples); tuple != NULL;
- tuple = ISC_LIST_NEXT(tuple, link))
- {
+ ISC_LIST_FOREACH (tuples, tuple, link) {
dns_rdata_toregion(&tuple->rdata, &r);
keyid = dst_region_computeid(&r);
dns__zonediff_t *zonediff, dst_key_t **keys,
unsigned int nkeys, isc_stdtime_t inception,
isc_stdtime_t keyexpire) {
- dns_difftuple_t *tuple;
isc_result_t result;
+ bool apexsig = false;
- for (tuple = ISC_LIST_HEAD(diff->tuples); tuple != NULL;
- tuple = ISC_LIST_NEXT(tuple, link))
- {
+ ISC_LIST_FOREACH (diff->tuples, tuple, link) {
if (tuple->rdata.type == rrtype &&
dns_name_equal(&tuple->name, &zone->origin))
{
+ apexsig = true;
break;
}
}
- if (tuple == NULL) {
+ if (!apexsig) {
result = del_sigs(zone, db, ver, &zone->origin, rrtype,
zonediff, keys, nkeys, now, false);
if (result != ISC_R_SUCCESS) {
dns_zone_t *zone = NULL;
dns_db_t *db = NULL;
dns_dbversion_t *version = NULL;
- dns_dnsseckey_t *key = NULL;
dns_dnsseckeylist_t keys;
dns_kasp_t *kasp = NULL;
dns_message_t *message = NULL;
KASP_LOCK(kasp);
LOCK_ZONE(zone);
- for (key = ISC_LIST_HEAD(zone->checkds_ok); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (zone->checkds_ok, key, link) {
bool alldone = false, found = false;
bool checkdspub = false, checkdsdel = false, ksk = false;
dst_key_state_t ds_state = DST_KEY_STATE_NA;
dns_db_detach(&db);
}
- while (!ISC_LIST_EMPTY(keys)) {
- key = ISC_LIST_HEAD(keys);
+ ISC_LIST_FOREACH_SAFE (keys, key, link) {
ISC_LIST_UNLINK(keys, key, link);
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
static bool
checkds_isqueued(dns_zone_t *zone, dns_name_t *name, isc_sockaddr_t *addr,
dns_tsigkey_t *key, dns_transport_t *transport) {
- dns_checkds_t *checkds;
-
- for (checkds = ISC_LIST_HEAD(zone->checkds_requests); checkds != NULL;
- checkds = ISC_LIST_NEXT(checkds, link))
- {
+ ISC_LIST_FOREACH (zone->checkds_requests, checkds, link) {
if (checkds->request != NULL) {
continue;
}
static void
checkds_send_tons(dns_checkds_t *checkds) {
- dns_adbaddrinfo_t *ai;
isc_sockaddr_t dst;
isc_result_t result;
dns_checkds_t *newcheckds = NULL;
return;
}
- for (ai = ISC_LIST_HEAD(checkds->find->list); ai != NULL;
- ai = ISC_LIST_NEXT(ai, publink))
- {
+ ISC_LIST_FOREACH (checkds->find->list, ai, publink) {
dst = ai->sockaddr;
if (checkds_isqueued(zone, NULL, &dst, NULL, NULL)) {
continue;
return;
}
- for (dns_dnsseckey_t *key = ISC_LIST_HEAD(zone->checkds_ok);
- key != NULL; key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (zone->checkds_ok, key, link) {
dst_key_state_t ds_state = DST_KEY_STATE_NA;
bool ksk = false;
isc_stdtime_t published = 0, withdrawn = 0;
static isc_result_t
zone_verifykeys(dns_zone_t *zone, dns_dnsseckeylist_t *newkeys) {
- dns_dnsseckey_t *key1, *key2, *next;
-
/*
* Make sure that the existing keys are also present in the new keylist.
*/
- for (key1 = ISC_LIST_HEAD(zone->keyring); key1 != NULL; key1 = next) {
+ ISC_LIST_FOREACH_SAFE (zone->keyring, key1, link) {
bool found = false;
- next = ISC_LIST_NEXT(key1, link);
if (dst_key_is_unused(key1->key)) {
continue;
continue;
}
- for (key2 = ISC_LIST_HEAD(*newkeys); key2 != NULL;
- key2 = ISC_LIST_NEXT(key2, link))
- {
+ ISC_LIST_FOREACH (*newkeys, key2, link) {
if (dst_key_compare(key1->key, key2->key)) {
found = true;
break;
dns_dbversion_t *ver = NULL;
dns_rdataset_t cdsset, soaset, soasigs, keyset, keysigs, cdnskeyset;
dns_dnsseckeylist_t dnskeys, keys, rmkeys;
- dns_dnsseckey_t *key = NULL;
dns_diff_t diff, _sig_diff;
dns_kasp_t *kasp;
dns_skrbundle_t *bundle = NULL;
* published and is used for signing.
*/
bool allow = false;
- for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (dnskeys, key, link) {
dst_key_t *dstk = key->key;
if (dst_key_is_published(dstk, now, &when) &&
* key, but it's for an already-existing algorithm, then
* the zone signing can be handled incrementally.)
*/
- for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (dnskeys, key, link) {
if (!key->first_sign) {
continue;
}
LOCK_ZONE(zone);
if (commit) {
- dns_difftuple_t *tuple;
dns_stats_t *dnssecsignstats =
dns_zone_getdnssecsignstats(zone);
zone_settimer(zone, &timenow);
/* Remove any signatures from removed keys. */
- if (!ISC_LIST_EMPTY(rmkeys)) {
- for (key = ISC_LIST_HEAD(rmkeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
- result = zone_signwithkey(
- zone, dst_key_alg(key->key),
- dst_key_id(key->key), true);
- if (result != ISC_R_SUCCESS) {
- dnssec_log(zone, ISC_LOG_ERROR,
- "zone_signwithkey failed: "
- "%s",
- isc_result_totext(result));
- }
+ ISC_LIST_FOREACH (rmkeys, key, link) {
+ result = zone_signwithkey(zone, dst_key_alg(key->key),
+ dst_key_id(key->key), true);
+ if (result != ISC_R_SUCCESS) {
+ dnssec_log(zone, ISC_LOG_ERROR,
+ "zone_signwithkey failed: "
+ "%s",
+ isc_result_totext(result));
+ }
- /* Clear DNSSEC sign statistics. */
- if (dnssecsignstats != NULL) {
- dns_dnssecsignstats_clear(
- dnssecsignstats,
- dst_key_id(key->key),
- dst_key_alg(key->key));
- /*
- * Also clear the dnssec-sign
- * statistics of the revoked key id.
- */
- dns_dnssecsignstats_clear(
- dnssecsignstats,
- dst_key_rid(key->key),
- dst_key_alg(key->key));
- }
+ /* Clear DNSSEC sign statistics. */
+ if (dnssecsignstats != NULL) {
+ dns_dnssecsignstats_clear(
+ dnssecsignstats, dst_key_id(key->key),
+ dst_key_alg(key->key));
+ /*
+ * Also clear the dnssec-sign
+ * statistics of the revoked key id.
+ */
+ dns_dnssecsignstats_clear(
+ dnssecsignstats, dst_key_rid(key->key),
+ dst_key_alg(key->key));
}
}
* "rndc sign" was called, so we now sign the zone
* with all active keys, whether they're new or not.
*/
- for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (dnskeys, key, link) {
if (!key->force_sign && !key->hint_sign) {
continue;
}
* the full zone, but only with newly active
* keys.
*/
- for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (dnskeys, key, link) {
if (!key->first_sign) {
continue;
}
* Cause the zone to add/delete NSEC3 chains for the
* deferred NSEC3PARAM changes.
*/
- for (tuple = ISC_LIST_HEAD(zonediff.diff->tuples);
- tuple != NULL; tuple = ISC_LIST_NEXT(tuple, link))
- {
+ ISC_LIST_FOREACH (zonediff.diff->tuples, tuple, link) {
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_nsec3param_t nsec3param;
&timethen);
zone->refreshkeytime = timethen;
- for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link))
- {
+ ISC_LIST_FOREACH (dnskeys, key, link) {
then = now;
result = next_keyevent(key->key, &then);
if (result != ISC_R_SUCCESS) {
if (!ISC_LIST_EMPTY(zone->keyring)) {
clear_keylist(&zone->keyring, zone->mctx);
}
- while ((key = ISC_LIST_HEAD(dnskeys)) != NULL) {
+
+ ISC_LIST_FOREACH_SAFE (dnskeys, key, link) {
if (isc_log_wouldlog(ISC_LOG_DEBUG(3))) {
/* This debug log is used in the kasp system test */
char algbuf[DNS_SECALG_FORMATSIZE];
unsigned int
dns_zone_getincludes(dns_zone_t *zone, char ***includesp) {
- dns_include_t *include;
char **array = NULL;
unsigned int n = 0;
}
array = isc_mem_allocate(zone->mctx, sizeof(char *) * zone->nincludes);
- for (include = ISC_LIST_HEAD(zone->includes); include != NULL;
- include = ISC_LIST_NEXT(include, link))
- {
+ ISC_LIST_FOREACH (zone->includes, include, link) {
INSIST(n < zone->nincludes);
array[n++] = isc_mem_strdup(zone->mctx, include->name);
}
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);
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;
}
}
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)
{
#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);
}
#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));
int
isc_mem_renderxml(void *writer0) {
- isc_mem_t *ctx;
size_t inuse = 0;
int xmlrc;
xmlTextWriterPtr writer = (xmlTextWriterPtr)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);
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;
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);
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,
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);
+ }
- /* 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 cstream;
+ return NULL;
}
static isc_result_t
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
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;
}
}
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,
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");
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;
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);
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,
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;
}
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[] = {
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);
}
}
- 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);
}
}
/*
* 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);
}
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) */
/* 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,
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);
}
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;
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);
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))
}
}
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));
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;
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);
}
}
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, "; ");
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, " ");
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);
}
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;
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)) {
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);
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;
}
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);
*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,
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);
}
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);
* 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);
*/
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
*/
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);
}
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);
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));
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];
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;
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));
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;
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));
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,
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");
/*%
/*
* 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,
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);
}
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 &&
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);
}
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;
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)
{
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;
/*
* 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))
{
* 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) {
* 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
* 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
}
}
- 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);
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;
/*
* 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))
{
/*
* 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,
/* 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;
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++;
}
/* 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;
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++;
}
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;
}
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 = {
}
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++;
}
*/
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++;
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));
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));
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));
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));
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);
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);
projects / thirdparty / bind9.git / commitdiff
