ForEachMacros: [ 'cds_lfs_for_each', 'cds_lfs_for_each_safe', 'cds_list_for_each_entry_safe', 'ISC_LIST_FOREACH', 'ISC_LIST_FOREACH_SAFE', 'ISC_LIST_FOREACH_REV', 'ISC_LIST_FOREACH_REV_SAFE', 'MSG_SECTION_FOREACH', 'DNS_DBITERATOR_FOREACH', 'DNS_RDATASET_FOREACH', 'DNS_RDATASETITER_FOREACH', 'CFG_LIST_FOREACH' ]
RemoveParentheses: ReturnStatement
RemoveSemicolon: true
+SpaceBeforeParens: ControlStatementsExceptControlMacros
ContinuationIndentWidth: 8
RemoveParentheses: ReturnStatement
RemoveSemicolon: true
+SpaceBeforeParens: ControlStatementsExceptControlMacros
goto checkaaaa;
}
- DNS_RDATASET_FOREACH (a) {
+ DNS_RDATASET_FOREACH(a) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(a, &rdata);
match = false;
if (!dns_rdataset_isassociated(aaaa)) {
goto checkmissing;
}
- DNS_RDATASET_FOREACH (aaaa) {
+ DNS_RDATASET_FOREACH(aaaa) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(aaaa, &rdata);
match = false;
}
match = false;
if (dns_rdataset_isassociated(rdataset)) {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
if (memcmp(ptr, rdata.data,
*obj = checknames;
return true;
}
- CFG_LIST_FOREACH (checknames, element) {
+ CFG_LIST_FOREACH(checknames, element) {
value = cfg_listelt_value(element);
type = cfg_tuple_get(value, "type");
if ((strcasecmp(cfg_obj_asstring(type), "primary") !=
(void)cfg_map_get(config, "zone", &zonelist);
}
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
tresult = configure_zone(vclass, view, zconfig, vconfig, config,
list);
views = NULL;
(void)cfg_map_get(config, "view", &views);
- CFG_LIST_FOREACH (views, element) {
+ CFG_LIST_FOREACH(views, element) {
const cfg_obj_t *classobj;
dns_rdataclass_t viewclass;
const char *vname;
isc_buffer_init(&target, t, len);
if (short_form) {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
if (rdataset->attributes.negative) {
const cfg_obj_t *key = NULL, *keylist = NULL;
isc_result_t result = ISC_R_SUCCESS;
- CFG_LIST_FOREACH (keys, elt) {
+ CFG_LIST_FOREACH(keys, elt) {
keylist = cfg_listelt_value(elt);
- CFG_LIST_FOREACH (keylist, elt2) {
+ CFG_LIST_FOREACH(keylist, elt2) {
key = cfg_listelt_value(elt2);
CHECK(key_fromconfig(key, client, toview));
}
CHECK(dns_client_setservers(client, dns_rdataclass_in, name, &servers));
cleanup:
- ISC_LIST_FOREACH (servers, s, link) {
+ ISC_LIST_FOREACH(servers, s, link) {
ISC_LIST_UNLINK(servers, s, link);
isc_mem_put(isc_g_mctx, s, sizeof(*s));
}
/* Get nameservers from resolv.conf */
nameservers = irs_resconf_getnameservers(resconf);
- ISC_LIST_FOREACH (*nameservers, sa, link) {
+ ISC_LIST_FOREACH(*nameservers, sa, link) {
/* Set destination port */
if (sa->type.sa.sa_family == AF_INET && use_ipv4) {
sa->type.sin.sin_port = htons(destport);
printf("records:\n");
}
- ISC_LIST_FOREACH (*namelist, response_name, link) {
- ISC_LIST_FOREACH (response_name->list, rdataset, link) {
+ ISC_LIST_FOREACH(*namelist, response_name, link) {
+ ISC_LIST_FOREACH(response_name->list, rdataset, link) {
printdata(rdataset, response_name);
}
}
goto cleanup;
}
- MSG_SECTION_FOREACH (response, DNS_SECTION_ANSWER, name) {
+ MSG_SECTION_FOREACH(response, DNS_SECTION_ANSWER, name) {
dns_rdatatype_t prevtype = dns_rdatatype_none;
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
dns_rdataset_t rds, sigs;
int options = 0;
UNUSED(flags);
dns_name_init(&empty_name);
- MSG_SECTION_FOREACH (msg, DNS_SECTION_ANSWER, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
- DNS_RDATASET_FOREACH (rdataset) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_ANSWER, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
static unsigned char local_ndata[] = { "\005local" };
static dns_name_t local = DNS_NAME_INITABSOLUTE(local_ndata);
- MSG_SECTION_FOREACH (msg, DNS_SECTION_QUESTION, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_QUESTION, name) {
if (dns_name_issubdomain(name, &local)) {
return true;
}
debug("get_server_list()");
isc_sockaddrlist_t *servers = irs_resconf_getnameservers(resconf);
- ISC_LIST_FOREACH (*servers, sa, link) {
+ ISC_LIST_FOREACH(*servers, sa, link) {
int pf = isc_sockaddr_pf(sa);
char tmp[ISC_NETADDR_FORMATSIZE];
isc_result_t result;
void
flush_server_list(void) {
debug("flush_server_list()");
- ISC_LIST_FOREACH (server_list, s, link) {
+ ISC_LIST_FOREACH(server_list, s, link) {
ISC_LIST_DEQUEUE(server_list, s, link);
isc_mem_free(isc_g_mctx, s);
}
void
clone_server_list(dig_serverlist_t src, dig_serverlist_t *dest) {
debug("clone_server_list()");
- ISC_LIST_FOREACH (src, srv, link) {
+ ISC_LIST_FOREACH(src, srv, link) {
dig_server_t *newsrv = make_server(srv->servername,
srv->userarg);
ISC_LINK_INIT(newsrv, link);
static void
clear_searchlist(void) {
- ISC_LIST_FOREACH (search_list, search, link) {
+ ISC_LIST_FOREACH(search_list, search, link) {
ISC_LIST_UNLINK(search_list, search, link);
isc_mem_free(isc_g_mctx, search);
}
clear_searchlist();
irs_resconf_searchlist_t *list = irs_resconf_getsearchlist(resconf);
- ISC_LIST_FOREACH (*list, entry, link) {
+ ISC_LIST_FOREACH(*list, entry, link) {
dig_searchlist_t *search = make_searchlist_entry(entry->domain);
ISC_LIST_APPEND(search_list, search, link);
}
debug("check_if_done()");
debug("list %s", ISC_LIST_EMPTY(lookup_list) ? "empty" : "full");
- ISC_LIST_FOREACH (lookup_list, lookup, link) {
+ ISC_LIST_FOREACH(lookup_list, lookup, link) {
debug("pending lookup %p", lookup);
}
check_if_queries_done(dig_lookup_t *l, dig_query_t *except_q) {
debug("check_if_queries_done(%p)", l);
- ISC_LIST_FOREACH (l->q, q, link) {
+ ISC_LIST_FOREACH(l->q, q, link) {
if (!q->started || isc_refcount_current(&q->references) > 1) {
if (!q->canceled && q != except_q) {
debug("there is a pending query %p", q);
isc_refcount_destroy(&lookup->references);
- ISC_LIST_FOREACH (lookup->my_server_list, s, link) {
+ ISC_LIST_FOREACH(lookup->my_server_list, s, link) {
debug("freeing server %p belonging to %p", s, lookup);
ISC_LIST_DEQUEUE(lookup->my_server_list, s, link);
isc_mem_free(isc_g_mctx, s);
addresses_result = ISC_R_SUCCESS;
bad_namestr[0] = '\0';
- MSG_SECTION_FOREACH (msg, section, name) {
+ MSG_SECTION_FOREACH(msg, section, name) {
if (section == DNS_SECTION_AUTHORITY) {
rdataset = NULL;
result = dns_message_findtype(name, dns_rdatatype_soa,
}
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
char namestr[DNS_NAME_FORMATSIZE];
dns_rdata_ns_t ns;
lookup->pending = false;
- ISC_LIST_FOREACH (lookup->my_server_list, serv, link) {
+ 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);
static void
_cancel_lookup(dig_lookup_t *lookup, const char *file, unsigned int line) {
debug("%s:%u:%s()", file, line, __func__);
- ISC_LIST_FOREACH (lookup->q, query, link) {
+ ISC_LIST_FOREACH(lookup->q, query, link) {
REQUIRE(DIG_VALID_QUERY(query));
ISC_LIST_DEQUEUE(lookup->q, query, link);
debug("canceling pending query %p, belonging to %p", query,
puts("; Transfer failed.");
return true;
}
- MSG_SECTION_FOREACH (msg, DNS_SECTION_ANSWER, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
- DNS_RDATASET_FOREACH (rdataset) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_ANSWER, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
}
} else {
match = true;
- MSG_SECTION_FOREACH (msg, DNS_SECTION_QUESTION, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_QUESTION, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (l->rdtype != rdataset->type ||
l->rdclass != rdataset->rdclass ||
!dns_name_equal(l->name, name))
cancel_now = true;
while (current_lookup != NULL) {
- ISC_LIST_FOREACH (current_lookup->q, q, link) {
+ ISC_LIST_FOREACH(current_lookup->q, q, link) {
debug("canceling pending query %p, belonging to %p", q,
current_lookup);
q->canceled = true;
lookup_detach(¤t_lookup);
}
}
- ISC_LIST_FOREACH (lookup_list, l, link) {
+ ISC_LIST_FOREACH(lookup_list, l, link) {
ISC_LIST_DEQUEUE(lookup_list, l, link);
lookup_detach(&l);
}
dns_name_init(&empty_name);
- MSG_SECTION_FOREACH (msg, sectionid, name) {
+ MSG_SECTION_FOREACH(msg, sectionid, name) {
isc_buffer_init(&target, tbuf, sizeof(tbuf));
first = true;
print_name = name;
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (query->lookup->rdtype == dns_rdatatype_axfr &&
!((!list_addresses &&
(list_type == dns_rdatatype_any ||
UNUSED(first); /* Shut up compiler. */
#endif /* ifdef USEINITALWS */
} else {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
struct rtype *t;
const char *rtt;
debug("printsection()");
- MSG_SECTION_FOREACH (msg, section, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
- DNS_RDATASET_FOREACH (rdataset) {
+ MSG_SECTION_FOREACH(msg, section, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
switch (rdata.type) {
}
}
- MSG_SECTION_FOREACH (msg, section, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ MSG_SECTION_FOREACH(msg, section, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (section == DNS_SECTION_QUESTION) {
dns_name_format(name, namebuf, sizeof(namebuf));
printf("\t%s, ", namebuf);
namebuf, sizeof(namebuf));
printf("class = %s\n", namebuf);
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
isc_sockaddr_t sockaddr;
isc_result_t result;
- ISC_LIST_FOREACH (server_list, srv, link) {
+ ISC_LIST_FOREACH(server_list, srv, link) {
char sockstr[ISC_SOCKADDR_FORMATSIZE];
result = get_address(srv->servername, port, &sockaddr);
tries, port, ndots);
printf(" querytype = %-8s\tclass = %s\n", deftype, defclass);
printf(" srchlist = ");
- ISC_LIST_FOREACH (search_list, listent, link) {
+ ISC_LIST_FOREACH(search_list, listent, link) {
printf("%s", listent->origin);
if (ISC_LIST_NEXT(listent, link) != NULL) {
printf("/");
dns_rdatalist_fromrdataset(rdataset, &rdlist);
- ISC_LIST_FOREACH (rdlist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
isc_mem_put(isc_g_mctx, rdata, sizeof(*rdata));
}
isc_result_t result;
unsigned char dsbuf[DNS_DS_BUFFERSIZE];
- DNS_RDATASET_FOREACH (dsset) {
+ DNS_RDATASET_FOREACH(dsset) {
dns_rdata_ds_t ds;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t newdsrdata = DNS_RDATA_INIT;
keytable = isc_mem_cget(isc_g_mctx, nkey, sizeof(keytable[0]));
ki = keytable;
- DNS_RDATASET_FOREACH (keyset) {
+ DNS_RDATASET_FOREACH(keyset) {
dns_rdata_dnskey_t dnskey;
dns_rdata_t *keyrdata = NULL;
isc_region_t r;
algo = isc_mem_cget(isc_g_mctx, nkey, sizeof(algo[0]));
- DNS_RDATASET_FOREACH (sigset) {
+ DNS_RDATASET_FOREACH(sigset) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t sig;
isc_result_t result;
bool all_ok = true;
- DNS_RDATASET_FOREACH (dsset) {
+ DNS_RDATASET_FOREACH(dsset) {
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
bool ds_ok;
dns_rdataset_t *crdset) {
isc_result_t result;
- DNS_RDATASET_FOREACH (crdset) {
+ DNS_RDATASET_FOREACH(crdset) {
dns_rdata_t crdata = DNS_RDATA_INIT;
dns_rdata_t *ds = NULL;
arrdata = isc_mem_cget(isc_g_mctx, n, sizeof(dns_rdata_t));
- DNS_RDATASET_FOREACH (dsset) {
+ DNS_RDATASET_FOREACH(dsset) {
dns_rdata_init(&arrdata[i]);
dns_rdataset_current(dsset, &arrdata[i]);
i++;
isc_result_totext(result));
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
isc_result_totext(result));
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
emit(dir, &rdata);
ctx.ttl = dns_kasp_dnskeyttl(kasp);
ctx.setttl = true;
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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. */
- ISC_LIST_FOREACH (keys_read, dk, link) {
+ ISC_LIST_FOREACH(keys_read, dk, link) {
n++;
}
keys_sorted = isc_mem_cget(isc_g_mctx, n, sizeof(dns_dnsseckey_t *));
- ISC_LIST_FOREACH (keys_read, dk, link) {
+ ISC_LIST_FOREACH(keys_read, dk, link) {
keys_sorted[i++] = dk;
}
qsort(keys_sorted, n, sizeof(dns_dnsseckey_t *), keyalgtag_cmp);
- ISC_LIST_FOREACH (keys_read, key, link) {
+ ISC_LIST_FOREACH(keys_read, key, link) {
ISC_LIST_UNLINK(keys_read, key, link);
}
/* Save sorted list in 'keys' */
static void
cleanup(dns_dnsseckeylist_t *keys, dns_kasp_t *kasp) {
- ISC_LIST_FOREACH (*keys, key, link) {
+ ISC_LIST_FOREACH(*keys, key, link) {
ISC_LIST_UNLINK(*keys, key, link);
dst_key_free(&key->key);
dns_dnsseckey_destroy(isc_g_mctx, &key);
}
dns_kasp_detach(&kasp);
- ISC_LIST_FOREACH (cleanup_list, cbuf, link) {
+ ISC_LIST_FOREACH(cleanup_list, cbuf, link) {
ISC_LIST_UNLINK(cleanup_list, cbuf, link);
isc_buffer_free(&cbuf);
}
dns_rdatalist_fromrdataset(rdataset, &rdlist);
- ISC_LIST_FOREACH (rdlist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
isc_mem_put(isc_g_mctx, rdata, sizeof(*rdata));
}
isc_buffer_init(&buf, filename, sizeof(filename) - 1);
/* Check existing keys. */
- ISC_LIST_FOREACH (*keys, 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;
- ISC_LIST_FOREACH (*keys, 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;
- ISC_LIST_FOREACH (*keys, 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;
- ISC_LIST_FOREACH (*keys, dk, link) {
+ ISC_LIST_FOREACH(*keys, dk, link) {
bool published = true;
isc_buffer_t buf;
isc_buffer_t *newbuf;
isc_buffer_clear(newbuf);
/* CDS */
- ISC_LIST_FOREACH (digests, 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 */
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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;
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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
isc_buffer_allocate(isc_g_mctx, &buffer, bufsize);
- DNS_RDATASETITER_FOREACH (iter) {
+ DNS_RDATASETITER_FOREACH(iter) {
dns_rdataset_t rds = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iter, &rds);
dst_algorithm_t algorithm = dst_algorithm_fromdata(
rrsig->algorithm, rrsig->signature, rrsig->siglen);
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
if (rrsig->keyid == dst_key_id(key->key) &&
algorithm == dst_key_alg(key->key) &&
dns_name_equal(&rrsig->signer, dst_key_name(key->key)))
}
if (!nosigs) {
- DNS_RDATASET_FOREACH (&sigset) {
+ DNS_RDATASET_FOREACH(&sigset) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dns_dnsseckey_t *key = NULL;
bool expired, refresh, future, offline;
dns_rdataset_disassociate(&sigset);
}
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
if (REVOKE(key->key) && set->type != dns_rdatatype_dnskey) {
continue;
}
{
bool have_ksk = isksk(key);
- ISC_LIST_FOREACH (keylist, curr, link) {
+ ISC_LIST_FOREACH(keylist, curr, link) {
if (dst_key_alg(key->key) !=
dst_key_alg(curr->key))
{
* - Have key ID equal to the predecessor id.
* - Have a successor that matches 'key' id.
*/
- ISC_LIST_FOREACH (keylist, curr, link) {
+ ISC_LIST_FOREACH(keylist, curr, link) {
uint32_t suc;
if (dst_key_alg(key->key) !=
check_result(result, "dns_db_newversion");
dns_diff_init(isc_g_mctx, &diff);
- DNS_RDATASET_FOREACH (&keyset) {
+ DNS_RDATASET_FOREACH(&keyset) {
dns_rdata_t key = DNS_RDATA_INIT;
dns_rdata_t ds = DNS_RDATA_INIT;
dns_rdataset_current(&keyset, &key);
rdsiter = NULL;
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
/* If this is a RRSIG set, skip it. */
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
dns_rdatatype_t t = rdataset.type;
dns_rdataset_disassociate(&rdataset);
/*%
* The node is empty of everything but NSEC / RRSIG records.
*/
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
result = dns_db_deleterdataset(gdb, node, gversion,
rdataset.type,
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0,
&rdsiter2);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
type = rdataset.type;
covers = rdataset.covers;
continue;
}
found = false;
- DNS_RDATASETITER_FOREACH (rdsiter2) {
+ DNS_RDATASETITER_FOREACH(rdsiter2) {
dns_rdatasetiter_current(rdsiter2, &rdataset);
if (rdataset.type == covers) {
found = true;
*/
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
type = rdataset.type;
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
type = rdataset.type;
*/
result = dns_db_createiterator(gdb, DNS_DB_NSEC3ONLY, &dbiter);
check_result(result, "dns_db_createiterator()");
- DNS_DBITERATOR_FOREACH (dbiter) {
+ DNS_DBITERATOR_FOREACH(dbiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
result = dns_dbiterator_current(dbiter, &node, name);
check_dns_dbiterator_current(result);
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0,
&rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
type = rdataset.type;
covers = rdataset.covers;
* Delete any NSEC3 records which are not part of the current
* NSEC3 chain.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t delrdata = DNS_RDATA_INIT;
dns_rdatatype_format(rdataset->type, typestr, sizeof(typestr));
dns_rdataset_init(&tmprdataset);
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata1 = DNS_RDATA_INIT;
unsigned int count2 = 0;
count1++;
dns_rdataset_current(rdataset, &rdata1);
dns_rdataset_clone(rdataset, &tmprdataset);
- DNS_RDATASET_FOREACH (&tmprdataset) {
+ DNS_RDATASET_FOREACH(&tmprdataset) {
dns_rdata_t rdata2 = DNS_RDATA_INIT;
dns_difftuple_t *tuple = NULL;
count2++;
result = dns_db_createiterator(gdb, 0, &dbiter);
check_result(result, "dns_db_createiterator()");
- DNS_DBITERATOR_FOREACH (dbiter) {
+ DNS_DBITERATOR_FOREACH(dbiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
result = dns_dbiterator_current(dbiter, &node, name);
check_dns_dbiterator_current(result);
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0,
&rdsiter);
check_result(result, "dns_db_allrdatasets()");
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
rrset_cleanup(name, &rdataset, &add, &del);
dns_rdataset_disassociate(&rdataset);
result = dns_db_createiterator(gdb, DNS_DB_NSEC3ONLY, &dbiter);
check_result(result, "dns_db_createiterator()");
- DNS_DBITERATOR_FOREACH (dbiter) {
+ DNS_DBITERATOR_FOREACH(dbiter) {
result = dns_dbiterator_current(dbiter, &node, name);
check_dns_dbiterator_current(result);
nsec3clean(name, node, hashalg, iterations, salt, salt_len,
}
/* Skip any duplicates */
- ISC_LIST_FOREACH (keylist, k, link) {
+ 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))
{
static void
clear_keylist(dns_dnsseckeylist_t *list) {
- ISC_LIST_FOREACH (*list, key, link) {
+ ISC_LIST_FOREACH(*list, key, link) {
ISC_LIST_UNLINK(*list, key, link);
dns_dnsseckey_destroy(isc_g_mctx, &key);
}
}
/* Suppress duplicates */
- ISC_LIST_FOREACH (*digests, d, link) {
+ ISC_LIST_FOREACH(*digests, d, link) {
if (d->digest == alg) {
return;
}
clear_keylist(&rmkeys);
clear_keylist(&matchkeys);
- ISC_LIST_FOREACH (digests, d, link) {
+ ISC_LIST_FOREACH(digests, d, link) {
ISC_LIST_UNLINK(digests, d, link);
isc_mem_put(isc_g_mctx, d, sizeof(*d));
}
result = dns_rdataset_first(&rdataset);
check_result(result, "dns_rdataset_first");
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
name = gorigin;
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
if (REVOKE(key->key)) {
continue;
}
have_non_ksk = true;
}
- ISC_LIST_FOREACH (keylist, curr, link) {
+ ISC_LIST_FOREACH(keylist, curr, link) {
if (dst_key_alg(key->key) != dst_key_alg(curr->key)) {
continue;
}
}
/* Now enumerate the key list */
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
key->index = keycount++;
}
hashlist_free(&hashlist);
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
ISC_LIST_UNLINK(keylist, key, link);
dns_dnsseckey_destroy(isc_g_mctx, &key);
}
ISC_LIST_INIT(kslist);
(void)cfg_map_get(config, "key-store", &keystores);
- CFG_LIST_FOREACH (keystores, element) {
+ CFG_LIST_FOREACH(keystores, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
result = cfg_keystore_fromconfig(kconfig, mctx, &kslist, NULL);
if (result != ISC_R_SUCCESS) {
dns_keystore_detach(&keystore);
(void)cfg_map_get(config, "dnssec-policy", &kasps);
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
dns_kasp_t *kasp = NULL;
cfg_obj_t *kconfig = cfg_listelt_value(element);
/*
* Cleanup kasp list.
*/
- ISC_LIST_FOREACH (kasplist, kasp, link) {
+ ISC_LIST_FOREACH(kasplist, kasp, link) {
ISC_LIST_UNLINK(kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
/*
* Cleanup keystore list.
*/
- ISC_LIST_FOREACH (kslist, ks, link) {
+ ISC_LIST_FOREACH(kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}
bdb = node->bdb;
mctx = bdb->common.mctx;
- ISC_LIST_FOREACH (node->lists, list, link) {
- ISC_LIST_FOREACH (list->rdata, rdata, link) {
+ ISC_LIST_FOREACH(node->lists, list, link) {
+ ISC_LIST_FOREACH(list->rdata, rdata, link) {
ISC_LIST_UNLINK(list->rdata, rdata, link);
isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));
}
isc_mem_put(mctx, list, sizeof(dns_rdatalist_t));
}
- ISC_LIST_FOREACH (node->buffers, b, link) {
+ ISC_LIST_FOREACH(node->buffers, b, link) {
ISC_LIST_UNLINK(node->buffers, b, link);
isc_buffer_free(&b);
}
return ISC_R_NOTIMPLEMENTED;
}
- ISC_LIST_FOREACH (bdbnode->lists, list, link) {
+ ISC_LIST_FOREACH(bdbnode->lists, list, link) {
if (list->type == type) {
new_rdataset(list, db, node, rdataset);
return ISC_R_SUCCESS;
*obj = checknames;
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (checknames, element) {
+ CFG_LIST_FOREACH(checknames, element) {
value = cfg_listelt_value(element);
type = cfg_tuple_get(value, "type");
named_config_listcount(const cfg_obj_t *list) {
int i = 0;
- CFG_LIST_FOREACH (list, e) {
+ CFG_LIST_FOREACH(list, e) {
i++;
}
if (result != ISC_R_SUCCESS) {
return result;
}
- CFG_LIST_FOREACH (obj, elt) {
+ CFG_LIST_FOREACH(obj, elt) {
obj = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_tuple_get(obj, "name")),
name) == 0)
static void
free_controlkeylist(controlkeylist_t *keylist, isc_mem_t *mctx) {
- ISC_LIST_FOREACH (*keylist, key, link) {
+ ISC_LIST_FOREACH(*keylist, key, link) {
ISC_LIST_UNLINK(*keylist, key, link);
free_controlkey(key, mctx);
}
}
listener->shuttingdown = true;
- ISC_LIST_FOREACH (listener->connections, conn, link) {
+ ISC_LIST_FOREACH(listener->connections, conn, link) {
conn_shutdown(conn);
}
goto cleanup;
}
- ISC_LIST_FOREACH (listener->keys, key, link) {
+ ISC_LIST_FOREACH(listener->keys, key, link) {
isccc_region_t ccregion;
isccc_ccmsg_toregion(&conn->ccmsg, &ccregion);
static void
controls_shutdown(named_controls_t *controls) {
- ISC_LIST_FOREACH (controls->listeners, listener, link) {
+ ISC_LIST_FOREACH(controls->listeners, listener, link) {
/*
* As listeners shut down, they will call their callbacks.
*/
const char *str = NULL;
const cfg_obj_t *obj = NULL;
- CFG_LIST_FOREACH (keylist, element) {
+ CFG_LIST_FOREACH(keylist, element) {
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(cfg_map_getname(obj));
if (strcasecmp(str, keyname) == 0) {
const cfg_obj_t *obj = NULL;
controlkey_t *key = NULL;
- CFG_LIST_FOREACH (keylist, element) {
+ CFG_LIST_FOREACH(keylist, element) {
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
newstr = isc_mem_strdup(mctx, str);
/*
* Find the keys corresponding to the keyids used by this listener.
*/
- ISC_LIST_FOREACH (*keyids, keyid, link) {
+ ISC_LIST_FOREACH(*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;
- ISC_LIST_FOREACH (cp->listeners, l, link) {
+ ISC_LIST_FOREACH(cp->listeners, l, link) {
if (isc_sockaddr_equal(addr, &l->address)) {
listener = l;
break;
* address-in-use error.
*/
if (controlslist != NULL) {
- CFG_LIST_FOREACH (controlslist, element) {
+ CFG_LIST_FOREACH(controlslist, element) {
const cfg_obj_t *controls = NULL;
const cfg_obj_t *inetcontrols = NULL;
const cfg_obj_t *unixcontrols = NULL;
continue;
}
- CFG_LIST_FOREACH (inetcontrols, element2) {
+ CFG_LIST_FOREACH(inetcontrols, element2) {
const cfg_obj_t *control = NULL;
const cfg_obj_t *obj = NULL;
isc_sockaddr_t addr;
}
destinations = cfg_tuple_get(ccat, "destinations");
- CFG_LIST_FOREACH (destinations, element) {
+ CFG_LIST_FOREACH(destinations, element) {
const cfg_obj_t *channel = cfg_listelt_value(element);
const char *channelname = cfg_obj_asstring(channel);
}
(void)cfg_map_get(logstmt, "channel", &channels);
- CFG_LIST_FOREACH (channels, element) {
+ CFG_LIST_FOREACH(channels, element) {
const cfg_obj_t *channel = cfg_listelt_value(element);
CHECK(channel_fromconf(channel, logconfig));
}
(void)cfg_map_get(logstmt, "category", &categories);
- CFG_LIST_FOREACH (categories, element) {
+ CFG_LIST_FOREACH(categories, element) {
const cfg_obj_t *category = cfg_listelt_value(element);
CHECK(category_fromconf(category, logconfig));
if (!default_set) {
}
name = dns_fixedname_initname(&fixed);
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
nameobj = cfg_listelt_value(element);
str = cfg_obj_asstring(nameobj);
isc_buffer_constinit(&b, str, strlen(str));
CHECK(dns_view_getsecroots(view, &secroots));
- CFG_LIST_FOREACH (keys, elt) {
+ CFG_LIST_FOREACH(keys, elt) {
keylist = cfg_listelt_value(elt);
- CFG_LIST_FOREACH (keylist, elt2) {
+ CFG_LIST_FOREACH(keylist, elt2) {
CHECK(process_key(cfg_listelt_value(elt2), secroots,
keyname, view, managed));
}
CHECK(dns_name_fromtext(name, &b, dns_rootname, 0));
algorithms = cfg_tuple_get(disabled, "algorithms");
- CFG_LIST_FOREACH (algorithms, element) {
+ CFG_LIST_FOREACH(algorithms, element) {
isc_textregion_t r;
dst_algorithm_t alg;
CHECK(dns_name_fromtext(name, &b, dns_rootname, 0));
digests = cfg_tuple_get(disabled, "digests");
- CFG_LIST_FOREACH (digests, element) {
+ CFG_LIST_FOREACH(digests, element) {
isc_textregion_t r;
dns_dsdigest_t digest;
name = dns_fixedname_initname(&fixed);
- CFG_LIST_FOREACH (disablelist, element) {
+ CFG_LIST_FOREACH(disablelist, element) {
value = cfg_listelt_value(element);
str = cfg_obj_asstring(value);
isc_buffer_constinit(&b, str, strlen(str));
static named_cache_t *
cachelist_find(named_cachelist_t *cachelist, const char *cachename,
dns_rdataclass_t rdclass) {
- ISC_LIST_FOREACH (*cachelist, nsc, link) {
+ ISC_LIST_FOREACH(*cachelist, nsc, link) {
if (nsc->rdclass == rdclass &&
strcmp(dns_cache_getname(nsc->cache), cachename) == 0)
{
}
int i = 0;
- CFG_LIST_FOREACH (zonelist, zone_element) {
+ CFG_LIST_FOREACH(zonelist, zone_element) {
INSIST(!*old_rpz_okp || old != NULL);
if (*old_rpz_okp && i < old->p.num_zones) {
old_zone = old->zones[i];
&ns_catz_zonemodmethods);
}
- CFG_LIST_FOREACH (zones, zone_element) {
+ CFG_LIST_FOREACH(zones, zone_element) {
CHECK(configure_catz_zone(view, pview, config, zone_element));
}
* Look for forward "zones" beneath this empty zone and if so
* create a custom db for the empty zone.
*/
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
const cfg_obj_t *zoptions = cfg_tuple_get(zconfig, "options");
const cfg_obj_t *toptions = NULL;
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (dlist, element) {
+ CFG_LIST_FOREACH(dlist, element) {
const char *str = NULL;
dns_dtmsgtype_t dt = 0;
/*
* Load zone configuration
*/
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
CHECK(configure_zone(config, zconfig, vconfig, view, viewlist,
kasplist, keystores, actx, false,
(void)cfg_map_get(config, "dlz", &dlzlist);
}
- CFG_LIST_FOREACH (dlzlist, element) {
+ CFG_LIST_FOREACH(dlzlist, element) {
dlz = cfg_listelt_value(element);
obj = NULL;
contact = NULL;
}
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
const cfg_obj_t *map = cfg_listelt_value(element);
dns_dns64_t *dns64 = NULL;
unsigned int dns64options = 0;
disabled = NULL;
(void)named_config_get(maps, "disable-algorithms", &disabled);
if (disabled != NULL) {
- CFG_LIST_FOREACH (disabled, element) {
+ CFG_LIST_FOREACH(disabled, element) {
CHECK(disable_algorithms(cfg_listelt_value(element),
view->resolver));
}
disabled = NULL;
(void)named_config_get(maps, "disable-ds-digests", &disabled);
if (disabled != NULL) {
- CFG_LIST_FOREACH (disabled, element) {
+ CFG_LIST_FOREACH(disabled, element) {
CHECK(disable_ds_digests(cfg_listelt_value(element),
view->resolver));
}
(void)named_config_get(cfgmaps, "server", &peers);
dns_peerlist_new(mctx, &newpeers);
- CFG_LIST_FOREACH (peers, element) {
+ CFG_LIST_FOREACH(peers, element) {
const cfg_obj_t *cpeer = cfg_listelt_value(element);
dns_peer_t *peer;
(void)named_config_get(maps, "rrset-order", &rrsetorder);
dns_order_create(mctx, &order);
- CFG_LIST_FOREACH (rrsetorder, element) {
+ CFG_LIST_FOREACH(rrsetorder, element) {
const cfg_obj_t *ent = cfg_listelt_value(element);
CHECK(configure_order(order, ent));
(void)cfg_map_get(config, "dyndb", &dyndb_list);
}
- CFG_LIST_FOREACH (dyndb_list, element) {
+ CFG_LIST_FOREACH(dyndb_list, element) {
const cfg_obj_t *dyndb = cfg_listelt_value(element);
if (dctx == NULL) {
result = dns_view_getntatable(view, &ntatable);
}
if (result == ISC_R_SUCCESS) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
dns_fixedname_t fntaname;
dns_name_t *ntaname;
}
if (zone_element_latest != NULL) {
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig =
cfg_listelt_value(element);
configure_zone_setviewcommit(result, zconfig,
addresses = cfg_tuple_get(alternates, "addresses");
}
- CFG_LIST_FOREACH (addresses, element) {
+ CFG_LIST_FOREACH(addresses, element) {
const cfg_obj_t *alternate = cfg_listelt_value(element);
isc_sockaddr_t sa;
faddresses = cfg_tuple_get(forwarders, "addresses");
}
- CFG_LIST_FOREACH (faddresses, element) {
+ CFG_LIST_FOREACH(faddresses, element) {
const cfg_obj_t *forwarder = cfg_listelt_value(element);
const char *cur_tls = NULL;
cleanup:
- ISC_LIST_FOREACH (fwdlist, fwd, link) {
+ ISC_LIST_FOREACH(fwdlist, fwd, link) {
ISC_LIST_UNLINK(fwdlist, fwd, link);
if (fwd->tlsname != NULL) {
dns_name_free(fwd->tlsname, view->mctx);
if (dns_keynode_dsset(keynode, &dsset)) {
isc_result_t result;
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
struct dotat_arg dotat_arg = { 0 };
dns_keytable_t *secroots = NULL;
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (!view->trust_anchor_telemetry || !view->enablevalidation) {
continue;
}
zonelist = NULL;
cfg_map_get(nzctx->nzf_config, "zone", &zonelist);
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
CHECK(configure_zone(config, zconfig, vconfig, view,
&named_g_server->viewlist,
result = ISC_R_SUCCESS;
cleanup:
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
configure_zone_setviewcommit(result, zconfig, view);
}
*/
keystores = NULL;
(void)cfg_map_get(config, "key-store", &keystores);
- CFG_LIST_FOREACH (keystores, element) {
+ CFG_LIST_FOREACH(keystores, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
result = cfg_keystore_fromconfig(kconfig, isc_g_mctx,
*/
kasps = NULL;
(void)cfg_map_get(named_g_defaultconfig, "dnssec-policy", &kasps);
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
dns_kasp_t *kasp = NULL;
*/
kasps = NULL;
(void)cfg_map_get(config, "dnssec-policy", &kasps);
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
dns_kasp_t *kasp = NULL;
/*
* Create the views.
*/
- CFG_LIST_FOREACH (views, element) {
+ CFG_LIST_FOREACH(views, element) {
cfg_obj_t *vconfig = cfg_listelt_value(element);
dns_view_t *view = NULL;
* views that have zones were already created at parsing
* time, but views with no zones must be created here.
*/
- CFG_LIST_FOREACH (views, element) {
+ CFG_LIST_FOREACH(views, element) {
cfg_obj_t *vconfig = cfg_listelt_value(element);
dns_view_t *view = NULL;
builtin_views = NULL;
RUNTIME_CHECK(cfg_map_get(named_g_defaultconfig, "view",
&builtin_views) == ISC_R_SUCCESS);
- CFG_LIST_FOREACH (builtin_views, element) {
+ CFG_LIST_FOREACH(builtin_views, element) {
cfg_obj_t *vconfig = cfg_listelt_value(element);
dns_view_t *view = NULL;
* Commit any dns_zone_setview() calls on all zones in the new
* view.
*/
- ISC_LIST_FOREACH (viewlist, view, link) {
+ ISC_LIST_FOREACH(viewlist, view, link) {
dns_view_setviewcommit(view);
}
viewlist = tmpviewlist;
/* Make the view list available to each of the views */
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
view->viewlist = &server->viewlist;
}
* after relinquishing privileges them.
*/
if (first_time) {
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
nzd_env_close(view);
}
}
* Reopen NZD databases.
*/
if (first_time) {
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
nzd_env_reopen(view);
}
}
&categories);
}
if (categories != NULL) {
- CFG_LIST_FOREACH (categories, element) {
+ CFG_LIST_FOREACH(categories, element) {
const cfg_obj_t *catobj;
const char *str;
unsigned int usedlength;
unsigned int expectedlength;
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
* were swapped above or not.
*/
cleanup_altsecrets:
- ISC_LIST_FOREACH (altsecrets, as, link) {
+ ISC_LIST_FOREACH(altsecrets, as, link) {
ISC_LIST_UNLINK(altsecrets, as, link);
isc_mem_put(server->sctx->mctx, as, sizeof(*as));
}
}
cleanup_cachelist:
- ISC_LIST_FOREACH (cachelist, nsc, link) {
+ ISC_LIST_FOREACH(cachelist, nsc, link) {
ISC_LIST_UNLINK(cachelist, nsc, link);
dns_cache_detach(&nsc->cache);
isc_mem_put(server->mctx, nsc, sizeof(*nsc));
ISC_LIST_APPENDLIST(viewlist, builtin_viewlist, link);
cleanup_viewlist:
- ISC_LIST_FOREACH (viewlist, view, link) {
+ ISC_LIST_FOREACH(viewlist, view, link) {
ISC_LIST_UNLINK(viewlist, view, link);
if (result == ISC_R_SUCCESS && strcmp(view->name, "_bind") != 0)
{
}
cleanup_kasplist:
- ISC_LIST_FOREACH (kasplist, kasp, link) {
+ ISC_LIST_FOREACH(kasplist, kasp, link) {
ISC_LIST_UNLINK(kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
cleanup_keystorelist:
- ISC_LIST_FOREACH (keystorelist, keystore, link) {
+ ISC_LIST_FOREACH(keystorelist, keystore, link) {
ISC_LIST_UNLINK(keystorelist, keystore, link);
dns_keystore_detach(&keystore);
}
"all zones loaded");
}
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (view->managed_keys != NULL) {
result = dns_zone_synckeyzone(
view->managed_keys);
/*
* Schedule zones to be loaded from disk.
*/
- ISC_LIST_FOREACH (server->viewlist, 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 &&
(void)named_server_saventa(server);
- ISC_LIST_FOREACH (server->kasplist, kasp, link) {
+ ISC_LIST_FOREACH(server->kasplist, kasp, link) {
ISC_LIST_UNLINK(server->kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
- ISC_LIST_FOREACH (server->keystorelist, keystore, link) {
+ ISC_LIST_FOREACH(server->keystorelist, keystore, link) {
ISC_LIST_UNLINK(server->keystorelist, keystore, link);
dns_keystore_detach(&keystore);
}
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
view_next = ISC_LIST_NEXT(view, link);
ISC_LIST_UNLINK(server->viewlist, view, link);
dns_view_flushonshutdown(view, flush);
*/
dns_dyndb_cleanup();
- ISC_LIST_FOREACH (server->cachelist, nsc, link) {
+ ISC_LIST_FOREACH(server->cachelist, nsc, link) {
ISC_LIST_UNLINK(server->cachelist, nsc, link);
dns_cache_detach(&nsc->cache);
isc_mem_put(server->mctx, nsc, sizeof(*nsc));
INSIST(message->tsigkey != NULL || message->tsig != NULL ||
message->sig0 == NULL);
- ISC_LIST_FOREACH (named_g_server->viewlist, view, link) {
+ ISC_LIST_FOREACH(named_g_server->viewlist, view, link) {
if (message->rdclass == view->rdclass ||
message->rdclass == dns_rdataclass_any)
{
return result;
}
- CFG_LIST_FOREACH (listenlist, element) {
+ CFG_LIST_FOREACH(listenlist, element) {
ns_listenelt_t *delt = NULL;
const cfg_obj_t *listener = cfg_listelt_value(element);
result = listenelt_fromconfig(listener, config, actx, mctx,
return NULL;
}
- CFG_LIST_FOREACH (maplist, elt) {
+ CFG_LIST_FOREACH(maplist, elt) {
const cfg_obj_t *map = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
0)
ISC_R_SUCCESS)
{
INSIST(tls_proto_list != NULL);
- CFG_LIST_FOREACH (tls_proto_list, proto) {
+ CFG_LIST_FOREACH(tls_proto_list, proto) {
const cfg_obj_t *tls_proto_obj =
cfg_listelt_value(proto);
const char *tls_sver =
endpoints = isc_mem_allocate(mctx, sizeof(endpoints[0]) * len);
if (http != NULL && eplist != NULL) {
- CFG_LIST_FOREACH (eplist, elt) {
+ CFG_LIST_FOREACH(eplist, elt) {
const cfg_obj_t *ep = cfg_listelt_value(elt);
const char *path = cfg_obj_asstring(ep);
endpoints[i++] = isc_mem_strdup(mctx, path);
/*
* Prevent duplicate views.
*/
- ISC_LIST_FOREACH (dctx->viewlist, vle, link) {
+ ISC_LIST_FOREACH(dctx->viewlist, vle, link) {
if (vle->view == view) {
return ISC_R_SUCCESS;
}
static void
dumpcontext_destroy(struct dumpcontext *dctx) {
- ISC_LIST_FOREACH (dctx->viewlist, vle, link) {
+ ISC_LIST_FOREACH(dctx->viewlist, vle, link) {
ISC_LIST_UNLINK(dctx->viewlist, vle, link);
- ISC_LIST_FOREACH (vle->zonelist, zle, link) {
+ ISC_LIST_FOREACH(vle->zonelist, zle, link) {
ISC_LIST_UNLINK(vle->zonelist, zle, link);
dns_zone_detach(&zle->zone);
isc_mem_put(dctx->mctx, zle, sizeof *zle);
nextview:
found = false;
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (ptr != NULL && strcmp(view->name, ptr) != 0) {
continue;
}
used = isc_buffer_usedlength(*text);
do {
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (ptr != NULL && strcmp(view->name, ptr) != 0) {
continue;
}
fprintf(fp, ";\n; Recursing Queries\n;\n");
ns_interfacemgr_dumprecursing(fp, server->interfacemgr);
- ISC_LIST_FOREACH (server->viewlist, 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,
ptr = next_token(lex, text);
isc_loopmgr_pause();
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if ((ptr != NULL && strcasecmp(ptr, view->name) != 0) ||
strcasecmp("_bind", view->name) == 0)
{
* much more lightweight because only a few (most typically just
* one) views will match.
*/
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (strcasecmp(ptr, view->name) != 0) {
continue;
}
found = true;
- ISC_LIST_FOREACH (server->cachelist, nsc, link) {
+ ISC_LIST_FOREACH(server->cachelist, nsc, link) {
if (nsc->cache == view->cache) {
nsc->needflush = true;
break;
}
/* Perform flush */
- ISC_LIST_FOREACH (server->cachelist, 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.
*/
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (!dns_view_iscacheshared(view)) {
continue;
}
- ISC_LIST_FOREACH (server->cachelist, nsc, link) {
+ ISC_LIST_FOREACH(server->cachelist, nsc, link) {
if (!nsc->needflush || nsc->cache != view->cache) {
continue;
}
}
/* Cleanup the cache list. */
- ISC_LIST_FOREACH (server->cachelist, nsc, link) {
+ ISC_LIST_FOREACH(server->cachelist, nsc, link) {
nsc->needflush = false;
}
isc_loopmgr_pause();
flushed = true;
found = false;
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (viewname != NULL && strcasecmp(viewname, view->name) != 0) {
continue;
}
if (zone == NULL) {
isc_loopmgr_pause();
tresult = ISC_R_SUCCESS;
- ISC_LIST_FOREACH (server->viewlist, 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)
if (mayberaw == NULL) {
isc_loopmgr_pause();
tresult = ISC_R_SUCCESS;
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
result = dns_view_freezezones(view, freeze);
if (result != ISC_R_SUCCESS && tresult == ISC_R_SUCCESS)
{
CHECK(add_comment(fp, view->name)); /* force a comment */
- ISC_LIST_FOREACH (*list, 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));
isc_buffer_allocate(view->mctx, &text, 256);
- CFG_LIST_FOREACH (zonelist, element) {
+ CFG_LIST_FOREACH(zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
const cfg_obj_t *zoptions;
char zname[DNS_NAME_FORMATSIZE];
}
cfg_list_t *list = UNCONST(&zl->value.list);
- ISC_LIST_FOREACH (*list, elt, link) {
+ 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);
}
cfg_map_get(config, map_key_for_list, &list);
- CFG_LIST_FOREACH (list, element) {
+ CFG_LIST_FOREACH(list, element) {
const char *vname = NULL;
obj = cfg_listelt_value(element);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&privset) {
+ DNS_RDATASET_FOREACH(&privset) {
dns_rdata_t priv = DNS_RDATA_INIT;
/*
* In theory, the output buffer could hold a full RDATA
dns_db_detach(&db);
}
- ISC_LIST_FOREACH (keys, key, link) {
+ ISC_LIST_FOREACH(keys, key, link) {
ISC_LIST_UNLINK(keys, key, link);
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
if (dump) {
size_t last = 0;
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (ntatable != NULL) {
dns_ntatable_detach(&ntatable);
}
now = isc_stdtime_now();
isc_loopmgr_pause();
- ISC_LIST_FOREACH (server->viewlist, 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) {
- ISC_LIST_FOREACH (server->viewlist, 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) {
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
isc_result_t result = dns_view_loadnta(view);
if ((result != ISC_R_SUCCESS) &&
CHECK(putstr(text, buf));
}
- DNS_RDATASET_FOREACH (kdset) {
+ DNS_RDATASET_FOREACH(kdset) {
char alg[DNS_SECALG_FORMATSIZE];
char tbuf[ISC_FORMATHTTPTIMESTAMP_SIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
viewtxt = next_token(lex, text);
}
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
if (viewtxt != NULL && (rdclass != view->rdclass ||
strcmp(view->name, viewtxt) != 0))
{
isc_loopmgr_pause();
- ISC_LIST_FOREACH (server->viewlist, 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;
/* Look for the view name. */
viewname = next_token(lex, text);
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
char tbuf[100];
unsigned int used;
uint32_t val;
json_object_object_add(bindstats, "views", viewlist);
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
json_object *za, *xa, *v = json_object_new_object();
dns_adb_t *adb = NULL;
dns_acl_t *new_acl = NULL;
isc_result_t result = ISC_R_SUCCESS;
- ISC_LIST_FOREACH (server->statschannels, l, link) {
+ ISC_LIST_FOREACH(server->statschannels, l, link) {
if (isc_sockaddr_equal(addr, &l->address)) {
listener = l;
break;
#endif /* !HAVE_JSON_C */
#endif /* EXTENDED_STATS */
- CFG_LIST_FOREACH (statschannellist, element) {
+ CFG_LIST_FOREACH(statschannellist, element) {
const cfg_obj_t *statschannel = NULL;
const cfg_obj_t *listenercfg = NULL;
continue;
}
- CFG_LIST_FOREACH (listenercfg, element2) {
+ CFG_LIST_FOREACH(listenercfg, element2) {
named_statschannel_t *listener = NULL;
const cfg_obj_t *listen_params = NULL;
const cfg_obj_t *obj = NULL;
}
}
- ISC_LIST_FOREACH (server->statschannels, listener, link) {
+ ISC_LIST_FOREACH(server->statschannels, listener, link) {
ISC_LIST_UNLINK(server->statschannels, listener, link);
shutdown_listener(listener);
}
void
named_statschannels_shutdown(named_server_t *server) {
- ISC_LIST_FOREACH (server->statschannels, listener, link) {
+ ISC_LIST_FOREACH(server->statschannels, listener, link) {
ISC_LIST_UNLINK(server->statschannels, listener, link);
shutdown_listener(listener);
}
0);
fprintf(fp, "++ Outgoing Queries ++\n");
- ISC_LIST_FOREACH (server->viewlist, 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);
- ISC_LIST_FOREACH (server->viewlist, 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");
- ISC_LIST_FOREACH (server->viewlist, 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");
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
dns_stats_t *cacherrstats;
cacherrstats = dns_db_getrrsetstats(view->cachedb);
}
fprintf(fp, "++ ADB stats ++\n");
- ISC_LIST_FOREACH (server->viewlist, view, link) {
+ ISC_LIST_FOREACH(server->viewlist, view, link) {
dns_adb_t *adb = NULL;
isc_stats_t *adbstats = NULL;
{ \
uint32_t tls_protos = 0; \
INSIST(obj != NULL); \
- CFG_LIST_FOREACH (obj, proto) { \
+ CFG_LIST_FOREACH(obj, proto) { \
const cfg_obj_t *tls_proto_obj = \
cfg_listelt_value(proto); \
const char *tls_sver = \
const char *dohid = NULL;
isc_result_t result;
- CFG_LIST_FOREACH (transportlist, element) {
+ CFG_LIST_FOREACH(transportlist, element) {
dns_name_t *dohname = NULL;
dns_transport_t *transport = NULL;
const char *tlsid = NULL;
isc_result_t result;
- CFG_LIST_FOREACH (transportlist, element) {
+ CFG_LIST_FOREACH(transportlist, element) {
dns_name_t *tlsname = NULL;
dns_transport_t *transport = NULL;
int secretalloc = 0;
isc_result_t ret;
- CFG_LIST_FOREACH (list, element) {
+ CFG_LIST_FOREACH(list, element) {
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
dns_fixedname_t fkey;
dns_ssutable_create(mctx, &table);
- CFG_LIST_FOREACH (updatepolicy, element) {
+ CFG_LIST_FOREACH(updatepolicy, element) {
const cfg_obj_t *stmt = cfg_listelt_value(element);
const cfg_obj_t *mode = cfg_tuple_get(stmt, "mode");
const cfg_obj_t *identity = cfg_tuple_get(stmt, "identity");
}
i = 0;
- CFG_LIST_FOREACH (typelist, element2) {
+ CFG_LIST_FOREACH(typelist, element2) {
const cfg_obj_t *typeobj;
const char *bracket;
isc_textregion_t r;
dns_rdata_t *rdata = NULL;
isc_result_t result = ISC_R_SUCCESS;
- CFG_LIST_FOREACH (zconfig, element) {
+ CFG_LIST_FOREACH(zconfig, element) {
const isc_sockaddr_t *sa;
isc_netaddr_t na;
const cfg_obj_t *address = cfg_listelt_value(element);
isc_region_t sregion, region;
isc_result_t result = ISC_R_SUCCESS;
- CFG_LIST_FOREACH (zconfig, element) {
+ CFG_LIST_FOREACH(zconfig, element) {
const cfg_obj_t *obj = NULL;
const char *str = NULL;
dns_fixedname_t fixed_name;
dns_db_detach(&db);
}
for (i = 0; rdatalists[i] != NULL; i++) {
- ISC_LIST_FOREACH (rdatalists[i]->rdata, rdata, link) {
+ ISC_LIST_FOREACH(rdatalists[i]->rdata, rdata, link) {
ISC_LIST_UNLINK(rdatalists[i]->rdata, rdata, link);
dns_rdata_toregion(rdata, ®ion);
isc_mem_put(mctx, rdata,
isc_netaddr_fromsockaddr(&netdst, dstaddr);
env = ns_interfacemgr_getaclenv(named_g_server->interfacemgr);
- ISC_LIST_FOREACH (named_g_server->viewlist, view, link) {
+ ISC_LIST_FOREACH(named_g_server->viewlist, view, link) {
const dns_name_t *tsig = NULL;
if (view->matchrecursiveonly) {
(void)cfg_map_get(zoptions, "template", &obj);
if (obj != NULL && templates != NULL) {
const char *tmplname = cfg_obj_asstring(obj);
- CFG_LIST_FOREACH (templates, e) {
+ CFG_LIST_FOREACH(templates, e) {
const cfg_obj_t *t = cfg_tuple_get(cfg_listelt_value(e),
"name");
if (strcasecmp(cfg_obj_asstring(t), tmplname) == 0) {
* the servers array.
*/
ns_total = 0;
- ISC_LIST_FOREACH (*nslist, sa, link) {
+ ISC_LIST_FOREACH(*nslist, sa, link) {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {
sizeof(isc_sockaddr_t));
i = 0;
- ISC_LIST_FOREACH (*nslist, sa, link) {
+ ISC_LIST_FOREACH(*nslist, sa, link) {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {
name = ISC_LIST_HEAD(secs[DNS_SECTION_ZONE]);
ISC_LIST_UNLINK(secs[DNS_SECTION_ZONE], name, link);
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
ISC_LIST_UNLINK(name->list, rdataset, link);
dns_rdataset_disassociate(rdataset);
dns_message_puttemprdataset(updatemsg, &rdataset);
goto lookforsoa;
}
- ISC_LIST_FOREACH (rcvmsg->sections[section], n, link) {
+ ISC_LIST_FOREACH(rcvmsg->sections[section], n, link) {
soaset = NULL;
result = dns_message_findtype(n, dns_rdatatype_soa, 0, &soaset);
if (result == ISC_R_SUCCESS) {
dns_message_t *message = qctx->client->message;
- MSG_SECTION_FOREACH (message, section, cur) {
+ MSG_SECTION_FOREACH(message, section, cur) {
if (name != NULL && !dns_name_equal(name, cur)) {
/*
* We only want to process 'name' and this is not it.
dns_message_t *message = qctx->client->message;
- MSG_SECTION_FOREACH (message, section, cur) {
+ MSG_SECTION_FOREACH(message, section, cur) {
if (name != NULL && !dns_name_equal(name, cur)) {
/*
* We only want to process 'name' and this is not it.
if (!key_only) {
(void)cfg_map_get(config, "server", &servers);
if (servers != NULL) {
- CFG_LIST_FOREACH (servers, elt) {
+ CFG_LIST_FOREACH(servers, elt) {
const char *name = NULL;
server = cfg_listelt_value(elt);
name = cfg_obj_asstring(
} else {
DO("get config key list", cfg_map_get(config, "key", &keys));
bool match = false;
- CFG_LIST_FOREACH (keys, elt) {
+ CFG_LIST_FOREACH(keys, elt) {
const char *name = NULL;
key = cfg_listelt_value(elt);
result = ISC_R_NOTFOUND;
}
if (result == ISC_R_SUCCESS) {
- CFG_LIST_FOREACH (addresses, element) {
+ CFG_LIST_FOREACH(addresses, element) {
isc_sockaddr_t sa;
address = cfg_listelt_value(element);
syncptrs(sample_instance_t *inst, dns_name_t *name, dns_rdataset_t *rdataset,
dns_diffop_t op) {
isc_result_t result = ISC_R_SUCCESS;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
result = syncptr(inst, name, &rdata, rdataset->ttl, op);
dns_name_init(&empty_name);
- MSG_SECTION_FOREACH (response, DNS_SECTION_ANSWER, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
- DNS_RDATASET_FOREACH (rdataset) {
+ MSG_SECTION_FOREACH(response, DNS_SECTION_ANSWER, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
result = dns_rdata_tofmttext(
isc_loopmgr_run();
- ISC_LIST_FOREACH (queries, query, link) {
+ ISC_LIST_FOREACH(queries, query, link) {
if (query->ednsopts != NULL) {
for (i = 0; i < EDNSOPTS; i++) {
if (query->ednsopts[i].value != NULL) {
REQUIRE(DNS_ACL_VALID(acl));
dns_acl_t *a = UNCONST(acl); /* for ISC_LIST_FOREACH */
- ISC_LIST_FOREACH (a->ports_and_transports, next, link) {
+ ISC_LIST_FOREACH(a->ports_and_transports, next, link) {
bool match_port = true;
bool match_transport = true;
result = ISC_R_FAILURE;
static void
dns__acl_destroy_port_transports(dns_acl_t *acl) {
- ISC_LIST_FOREACH (acl->ports_and_transports, port_proto, link) {
+ ISC_LIST_FOREACH(acl->ports_and_transports, port_proto, link) {
ISC_LIST_DEQUEUE(acl->ports_and_transports, port_proto, link);
isc_mem_put(acl->mctx, port_proto, sizeof(*port_proto));
}
/*
* Merge ports and transports
*/
- ISC_LIST_FOREACH (source->ports_and_transports, next, link) {
+ ISC_LIST_FOREACH(source->ports_and_transports, next, link) {
const bool next_positive = !next->negative;
bool add_negative;
REQUIRE(dns_rdatatype_isaddr(rdtype));
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
/* FIXME: Move to a separate function */
dns_adbnamehooklist_t *hookhead = NULL;
dns_adbentry_t *entry = NULL;
entry = get_attached_and_locked_entry(adb, now, &sockaddr);
bool found = false;
- ISC_LIST_FOREACH (*hookhead, anh, name_link) {
+ ISC_LIST_FOREACH(*hookhead, anh, name_link) {
if (anh->entry == entry) {
found = true;
}
*/
static void
clean_namehooks(dns_adb_t *adb, dns_adbnamehooklist_t *namehooks) {
- ISC_LIST_FOREACH (*namehooks, namehook, name_link) {
+ ISC_LIST_FOREACH(*namehooks, namehook, name_link) {
INSIST(DNS_ADBNAMEHOOK_VALID(namehook));
INSIST(DNS_ADBENTRY_VALID(namehook->entry));
dns_adbentry_t *entry = NULL;
if ((find->options & DNS_ADBFIND_INET) != 0) {
- ISC_LIST_FOREACH (name->v4, namehook, name_link) {
+ ISC_LIST_FOREACH(name->v4, namehook, name_link) {
dns_adbaddrinfo_t *addrinfo = NULL;
entry = namehook->entry;
}
if ((find->options & DNS_ADBFIND_INET6) != 0) {
- ISC_LIST_FOREACH (name->v6, namehook, name_link) {
+ ISC_LIST_FOREACH(name->v6, namehook, name_link) {
dns_adbaddrinfo_t *addrinfo = NULL;
entry = namehook->entry;
* we also need to decrement the reference counter in the
* associated adbentry every time we remove one from the list.
*/
- ISC_LIST_FOREACH (find->list, ai, publink) {
+ ISC_LIST_FOREACH(find->list, ai, publink) {
ISC_LIST_UNLINK(find->list, ai, publink);
free_adbaddrinfo(adb, &ai);
}
if (!ISC_LIST_EMPTY(find->list)) {
fprintf(f, "\tAddresses:\n");
}
- ISC_LIST_FOREACH (find->list, ai, publink) {
+ ISC_LIST_FOREACH(find->list, ai, publink) {
sa = &ai->sockaddr;
switch (sa->type.sa.sa_family) {
case AF_INET:
print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
dns_adbnamehooklist_t *list, bool debug,
isc_stdtime_t now) {
- ISC_LIST_FOREACH (*list, nh, name_link) {
+ ISC_LIST_FOREACH(*list, nh, name_link) {
if (debug) {
fprintf(f, ";\tHook(%s) %p\n", legend, nh);
}
static void
print_find_list(FILE *f, dns_adbname_t *name) {
- ISC_LIST_FOREACH (name->finds, find, plink) {
+ ISC_LIST_FOREACH(name->finds, find, plink) {
dumpfind(find, f);
}
}
return result;
}
- DNS_RDATASETITER_FOREACH (iter) {
+ DNS_RDATASETITER_FOREACH(iter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iter, &rdataset);
dns_ipkeylist_resize(mctx, ipkl, rcount);
- DNS_RDATASET_FOREACH (value) {
+ DNS_RDATASET_FOREACH(value) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(value, &rdata);
/*
}
dns_rdataset_init(&rdataset);
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &rdataset);
/*
* Free temporary resources
*/
if (ansname != NULL) {
- ISC_LIST_FOREACH (ansname->list, rdataset, link) {
+ ISC_LIST_FOREACH(ansname->list, rdataset, link) {
ISC_LIST_UNLINK(ansname->list, rdataset, link);
putrdataset(mctx, &rdataset);
}
} while (want_restart);
if (send_event) {
- ISC_LIST_FOREACH (rctx->namelist, n, link) {
+ ISC_LIST_FOREACH(rctx->namelist, n, link) {
ISC_LIST_UNLINK(rctx->namelist, n, link);
ISC_LIST_APPEND(rctx->rev->answerlist, n, link);
}
resarg->result = rev->result;
resarg->vresult = rev->vresult;
- ISC_LIST_FOREACH (rev->answerlist, name, link) {
+ ISC_LIST_FOREACH(rev->answerlist, name, link) {
ISC_LIST_UNLINK(rev->answerlist, name, link);
ISC_LIST_APPEND(*resarg->namelist, name, link);
}
REQUIRE(DNS_CLIENT_VALID(client));
REQUIRE(namelist != NULL);
- ISC_LIST_FOREACH (*namelist, name, link) {
+ ISC_LIST_FOREACH(*namelist, name, link) {
ISC_LIST_UNLINK(*namelist, name, link);
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
ISC_LIST_UNLINK(name->list, rdataset, link);
putrdataset(client->mctx, &rdataset);
}
static dns_dbimplementation_t *
impfind(const char *name) {
- ISC_LIST_FOREACH (implementations, imp, link) {
+ ISC_LIST_FOREACH(implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}
void
dns_diff_clear(dns_diff_t *diff) {
REQUIRE(DNS_DIFF_VALID(diff));
- ISC_LIST_FOREACH (diff->tuples, t, link) {
+ ISC_LIST_FOREACH(diff->tuples, t, link) {
ISC_LIST_UNLINK(diff->tuples, t, link);
dns_difftuple_free(&t);
}
* the one we are doing, there must be a programming
* error. We report it but try to continue anyway.
*/
- ISC_LIST_FOREACH (diff->tuples, ot, link) {
+ ISC_LIST_FOREACH(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_difftuple_t **v = NULL;
REQUIRE(DNS_DIFF_VALID(diff));
- ISC_LIST_FOREACH (diff->tuples, p, link) {
+ ISC_LIST_FOREACH(diff->tuples, p, link) {
length++;
}
if (length == 0) {
mem = isc_mem_get(diff->mctx, size);
- ISC_LIST_FOREACH (diff->tuples, t, link) {
+ ISC_LIST_FOREACH(diff->tuples, t, link) {
isc_buffer_t buf;
isc_region_t r;
/*
* If there are any active responses, shut them all down.
*/
- ISC_LIST_FOREACH (disp->active, resp, alink) {
+ ISC_LIST_FOREACH(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) {
- ISC_LIST_FOREACH (*resps, resp, rlink) {
+ ISC_LIST_FOREACH(*resps, resp, rlink) {
ISC_LIST_UNLINK(*resps, resp, rlink);
dispentry_log(resp, ISC_LOG_DEBUG(90), "read callback: %s",
* If there are pending responses, call the connect
* callbacks for all of them.
*/
- ISC_LIST_FOREACH (disp->pending, resp, plink) {
+ ISC_LIST_FOREACH(disp->pending, resp, plink) {
ISC_LIST_UNLINK(disp->pending, resp, plink);
ISC_LIST_APPEND(resps, resp, rlink);
resp->result = eresult;
disp->state = DNS_DISPATCHSTATE_NONE;
}
- ISC_LIST_FOREACH (resps, resp, rlink) {
+ ISC_LIST_FOREACH(resps, resp, rlink) {
ISC_LIST_UNLINK(resps, resp, rlink);
resp_connected(resp);
*/
static dns_dlzimplementation_t *
dlz_impfind(const char *name) {
- ISC_LIST_FOREACH (dlz_implementations, imp, link) {
+ ISC_LIST_FOREACH(dlz_implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}
/*
* Find a driver in which the zone exists and transfer is supported
*/
- ISC_LIST_FOREACH (view->dlz_searched, dlzdb, link) {
+ ISC_LIST_FOREACH(view->dlz_searched, dlzdb, link) {
REQUIRE(DNS_DLZ_VALID(dlzdb));
allowzonexfr = dlzdb->implementation->methods->allowzonexfr;
i = 0;
ok = 0;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
if (aaaaok == NULL || !aaaaok[i]) {
dns_rdataset_current(rdataset, &rdata);
dns_rdataset_clone(rdataset, &outer);
dns_rdataset_clone(rdataset, &inner);
- DNS_RDATASET_FOREACH (&outer) {
+ DNS_RDATASET_FOREACH(&outer) {
dns_rdata_t rd1 = DNS_RDATA_INIT;
dns_rdataset_current(&outer, &rd1);
oplen = 0;
/* Look for the 192.0.0.171 match. */
bool matched = false;
- DNS_RDATASET_FOREACH (&inner) {
+ DNS_RDATASET_FOREACH(&inner) {
dns_rdata_t rd2 = DNS_RDATA_INIT;
dns_rdataset_current(&inner, &rd2);
aaaalist->rdclass = dns_rdataclass_in;
aaaalist->type = dns_rdatatype_aaaa;
- DNS_RDATASET_FOREACH (a) {
+ DNS_RDATASET_FOREACH(a) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(a, &rdata);
- ISC_LIST_FOREACH (dns64s, dns64, link) {
+ ISC_LIST_FOREACH(dns64s, dns64, link) {
dns_rdata_t *dns64_rdata = NULL;
isc_region_t r;
/* No applicable dns64; free the resources */
isc_buffer_free(&buffer);
- ISC_LIST_FOREACH (aaaalist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(aaaalist->rdata, rdata, link) {
ISC_LIST_UNLINK(aaaalist->rdata, rdata, link);
dns_message_puttemprdata(message, &rdata);
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
keytag = dst_key_id(dstkey);
- DNS_RDATASET_FOREACH (sigrdataset) {
+ DNS_RDATASET_FOREACH(sigrdataset) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dns_rdataset_current(sigrdataset, &sigrdata);
result = dns_rdata_tostruct(&sigrdata, &sig, NULL);
return false;
}
- DNS_RDATASET_FOREACH (keyset) {
+ DNS_RDATASET_FOREACH(keyset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_dnskey_t key;
RETERR(findmatchingkeys(keydir, namebuf, len, mctx, now,
&list));
} else if (keystores != NULL) {
- ISC_LIST_FOREACH (*keystores, keystore, link) {
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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:
- ISC_LIST_FOREACH (list, key, link) {
+ ISC_LIST_FOREACH(list, key, link) {
ISC_LIST_UNLINK(list, key, link);
INSIST(key->key != NULL);
dst_key_free(&key->key);
dns_dnsseckey_t *key = NULL;
/* Skip duplicates */
- ISC_LIST_FOREACH (*keylist, k, link) {
+ 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) &&
dns_name_equal(dst_key_name(k->key), dst_key_name(*newkey)))
dns_rdataset_init(&sigs);
dns_rdataset_clone(rrsigs, &sigs);
- ISC_LIST_FOREACH (*keylist, key, link) {
+ ISC_LIST_FOREACH(*keylist, key, link) {
uint16_t keyid, sigid;
dst_algorithm_t keyalg, sigalg;
keyid = dst_key_id(key->key);
keyalg = dst_key_alg(key->key);
- DNS_RDATASET_FOREACH (&sigs) {
+ DNS_RDATASET_FOREACH(&sigs) {
dns_rdata_rrsig_t sig;
dns_rdata_reset(&rdata);
dst_key_alg(key), type, directory,
mctx, savekey);
} else {
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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),
dns_rdataset_init(&keys);
dns_rdataset_clone(keyset, &keys);
- DNS_RDATASET_FOREACH (&keys) {
+ DNS_RDATASET_FOREACH(&keys) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dst_algorithm_t algorithm;
dns_rdata_dnskey_t keystruct;
dns_rdataset_t trdataset = DNS_RDATASET_INIT;
dns_rdataset_clone(rdataset, &trdataset);
- DNS_RDATASET_FOREACH (&trdataset) {
+ DNS_RDATASET_FOREACH(&trdataset) {
dns_rdata_t current = DNS_RDATA_INIT;
dns_rdataset_current(&trdataset, ¤t);
cdnskeyttl = cdnskey->ttl;
}
- ISC_LIST_FOREACH (*keys, 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));
- ISC_LIST_FOREACH (*digests, 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.
*/
- ISC_LIST_FOREACH (*rmkeys, key, link) {
+ ISC_LIST_FOREACH(*rmkeys, key, link) {
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
dns_name_t *origin = dst_key_name(key->key);
* Also, if there are keys published in the zone already,
* use their TTL for all subsequent published keys.
*/
- ISC_LIST_FOREACH (*keys, 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;
- ISC_LIST_FOREACH (*newkeys, 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.
*/
- ISC_LIST_FOREACH (*newkeys, key1, link) {
+ ISC_LIST_FOREACH(*newkeys, key1, link) {
bool key_revoked = false;
char keystr1[DST_KEY_FORMATSIZE];
char keystr2[DST_KEY_FORMATSIZE];
dns_dnsseckey_t *key2 = NULL;
- ISC_LIST_FOREACH (*keys, k2, link) {
+ ISC_LIST_FOREACH(*keys, k2, link) {
int f1 = dst_key_flags(key1->key);
int f2 = dst_key_flags(k2->key);
int nr1 = f1 & ~DNS_KEYFLAG_REVOKE;
}
/* Free any leftover keys in newkeys */
- ISC_LIST_FOREACH (*newkeys, key1, link) {
+ ISC_LIST_FOREACH(*newkeys, key1, link) {
ISC_LIST_UNLINK(*newkeys, key1, link);
dns_dnsseckey_destroy(mctx, &key1);
}
result = dns_rdata_tostruct(dsrdata, &ds, NULL);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
- DNS_RDATASET_FOREACH (keyset) {
+ DNS_RDATASET_FOREACH(keyset) {
dns_rdata_t newdsrdata = DNS_RDATA_INIT;
dns_rdata_reset(keyrdata);
static dyndb_implementation_t *
impfind(const char *name) {
- ISC_LIST_FOREACH (dyndb_implementations, imp, link) {
+ ISC_LIST_FOREACH(dyndb_implementations, imp, link) {
if (strcasecmp(name, imp->name) == 0) {
return imp;
}
forwarders = new_forwarders(fwdtable->mctx, name, fwdpolicy);
- ISC_LIST_FOREACH (*fwdrs, fwd, link) {
+ ISC_LIST_FOREACH(*fwdrs, fwd, link) {
dns_forwarder_t *nfwd = isc_mem_get(fwdtable->mctx,
sizeof(*nfwd));
*nfwd = *fwd;
forwarders = new_forwarders(fwdtable->mctx, name, fwdpolicy);
- ISC_LIST_FOREACH (*addrs, sa, link) {
+ ISC_LIST_FOREACH(*addrs, sa, link) {
dns_forwarder_t *fwd = isc_mem_get(fwdtable->mctx,
sizeof(*fwd));
*fwd = (dns_forwarder_t){ .addr = *sa,
static void
destroy_forwarders(dns_forwarders_t *forwarders) {
- ISC_LIST_FOREACH (forwarders->fwdrs, fwd, link) {
+ ISC_LIST_FOREACH(forwarders->fwdrs, fwd, link) {
ISC_LIST_UNLINK(forwarders->fwdrs, fwd, link);
if (fwd->tlsname != NULL) {
dns_name_free(fwd->tlsname, forwarders->mctx);
* Pass 1: determine the buffer size needed, and
* keep track of SOA serial numbers.
*/
- ISC_LIST_FOREACH (diff->tuples, 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.
*/
- ISC_LIST_FOREACH (diff->tuples, t, link) {
+ ISC_LIST_FOREACH(diff->tuples, t, link) {
/*
* Write the RR header.
*/
goto cleanup_node;
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
dns_difftuple_create(diff->mctx, op, name, rdataset.ttl,
destroy(dns_kasp_t *kasp) {
REQUIRE(!ISC_LINK_LINKED(kasp, link));
- ISC_LIST_FOREACH (kasp->keys, key, link) {
+ ISC_LIST_FOREACH(kasp->keys, key, link) {
ISC_LIST_UNLINK(kasp->keys, key, link);
dns_kasp_key_destroy(key);
}
INSIST(ISC_LIST_EMPTY(kasp->keys));
- ISC_LIST_FOREACH (kasp->digests, digest, link) {
+ ISC_LIST_FOREACH(kasp->digests, digest, link) {
ISC_LIST_UNLINK(kasp->digests, digest, link);
isc_mem_put(kasp->mctx, digest, sizeof(*digest));
}
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (*list, kasp, link) {
+ ISC_LIST_FOREACH(*list, kasp, link) {
if (strcmp(kasp->name, name) == 0) {
dns_kasp_attach(kasp, kaspp);
return ISC_R_SUCCESS;
}
/* Suppress duplicates */
- ISC_LIST_FOREACH (kasp->digests, d, link) {
+ ISC_LIST_FOREACH(kasp->digests, d, link) {
if (d->digest == alg) {
return;
}
return true;
}
- ISC_LIST_FOREACH (*keys, 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) {
- ISC_LIST_FOREACH (*keyring, 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;
}
- ISC_LIST_FOREACH (*keyring, 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) {
- ISC_LIST_FOREACH (*keyring, 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.
*/
- ISC_LIST_FOREACH (*keyring, 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) {
- ISC_LIST_FOREACH (*keyring, 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 };
- ISC_LIST_FOREACH (*keyring, 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 };
- ISC_LIST_FOREACH (*keyring, 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. */
- ISC_LIST_FOREACH (*keyring, dkey, link) {
+ ISC_LIST_FOREACH(*keyring, dkey, link) {
char keystr[DST_KEY_FORMATSIZE];
dst_key_format(dkey->key, keystr, sizeof(keystr));
* Check if there is a key available in pool because keys
* may have been pregenerated with dnssec-keygen.
*/
- ISC_LIST_FOREACH (*keyring, candidate, link) {
+ ISC_LIST_FOREACH(*keyring, candidate, link) {
if (dns_kasp_key_match(kaspkey, candidate) &&
dst_key_is_unused(candidate->key))
{
dst_key_doublematch(dns_dnsseckey_t *key, dns_kasp_t *kasp) {
int matches = 0;
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
+ ISC_LIST_FOREACH(dns_kasp_keys(kasp), kkey, link) {
if (dns_kasp_key_match(kkey, key)) {
matches++;
}
namebuf, dns_kasp_getname(kasp));
}
- ISC_LIST_FOREACH (*keyring, 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));
}
- ISC_LIST_FOREACH (*dnskeys, 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),
}
}
- ISC_LIST_FOREACH (*dnskeys, dkey, link) {
+ ISC_LIST_FOREACH(*dnskeys, dkey, link) {
numkeys++;
}
/* Do we need to remove keys? */
- ISC_LIST_FOREACH (*keyring, dkey, link) {
+ ISC_LIST_FOREACH(*keyring, dkey, link) {
bool found_match = false;
keymgr_key_init(dkey, kasp, now, numkeys == 1);
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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. */
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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? */
- ISC_LIST_FOREACH (*keyring, 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.
*/
- ISC_LIST_FOREACH (*dnskeys, 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. */
- ISC_LIST_FOREACH (*keyring, 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));
failure:
if (result != ISC_R_SUCCESS) {
- ISC_LIST_FOREACH (newkeys, newkey, link) {
+ ISC_LIST_FOREACH(newkeys, newkey, link) {
ISC_LIST_UNLINK(newkeys, newkey, link);
INSIST(newkey->key != NULL);
dst_key_free(&newkey->key);
REQUIRE(DNS_KASP_VALID(kasp));
REQUIRE(keyring != NULL);
- ISC_LIST_FOREACH (*keyring, 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));
- ISC_LIST_FOREACH (*keyring, 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);
- ISC_LIST_FOREACH (*keyring, dkey, link) {
+ ISC_LIST_FOREACH(*keyring, dkey, link) {
if (dst_key_id(dkey->key) != id) {
continue;
}
*nexttime = 0;
/* Store key states and update hints. */
- ISC_LIST_FOREACH (*keyring, dkey, link) {
+ ISC_LIST_FOREACH(*keyring, dkey, link) {
bool modified;
bool ksk = false, zsk = false;
isc_stdtime_t active = 0, published = 0, inactive = 0,
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (*list, keystore, link) {
+ ISC_LIST_FOREACH(*list, keystore, link) {
if (strcmp(keystore->name, name) == 0) {
dns_keystore_attach(keystore, kspp);
return ISC_R_SUCCESS;
destroy_keynode(dns_keynode_t *knode) {
isc_rwlock_destroy(&knode->rwlock);
if (knode->dslist != NULL) {
- ISC_LIST_FOREACH (knode->dslist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(knode->dslist->rdata, rdata, link) {
ISC_LIST_UNLINK(knode->dslist->rdata, rdata, link);
isc_mem_put(knode->mctx, rdata->data,
DNS_DS_BUFFERSIZE);
knode->dsset.trust = dns_trust_ultimate;
}
- ISC_LIST_FOREACH (knode->dslist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(knode->dslist->rdata, rdata, link) {
if (dns_rdata_compare(rdata, dsrdata) == 0) {
exists = true;
break;
return result;
}
- ISC_LIST_FOREACH (knode->dslist->rdata, 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);
- ISC_LIST_FOREACH (knode->dslist->rdata, 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);
dns_name_format(&keynode->name, namebuf, sizeof(namebuf));
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
char algbuf[DNS_SECALG_FORMATSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
callbacks->commit(callbacks->add_private);
}
- ISC_LIST_FOREACH (current_list, this, link) {
+ ISC_LIST_FOREACH(current_list, this, link) {
ISC_LIST_UNLINK(current_list, this, link);
}
- ISC_LIST_FOREACH (glue_list, this, link) {
+ ISC_LIST_FOREACH(glue_list, this, link) {
ISC_LIST_UNLINK(glue_list, this, link);
}
if (rdatalist != NULL) {
newlist = isc_mem_cget(mctx, new_len, sizeof(newlist[0]));
ISC_LIST_INIT(save);
- ISC_LIST_FOREACH (*current, this, link) {
+ ISC_LIST_FOREACH(*current, this, link) {
ISC_LIST_UNLINK(*current, this, link);
ISC_LIST_APPEND(save, this, link);
}
- ISC_LIST_FOREACH (save, this, link) {
+ ISC_LIST_FOREACH(save, this, link) {
ISC_LIST_UNLINK(save, this, link);
INSIST(rdlcount < new_len);
newlist[rdlcount] = *this;
}
ISC_LIST_INIT(save);
- ISC_LIST_FOREACH (*glue, this, link) {
+ ISC_LIST_FOREACH(*glue, this, link) {
ISC_LIST_UNLINK(*glue, this, link);
ISC_LIST_APPEND(save, this, link);
}
- ISC_LIST_FOREACH (save, this, link) {
+ ISC_LIST_FOREACH(save, this, link) {
ISC_LIST_UNLINK(save, this, link);
INSIST(rdlcount < new_len);
newlist[rdlcount] = *this;
/*
* Copy current relinking.
*/
- ISC_LIST_FOREACH (*current, this, link) {
+ ISC_LIST_FOREACH(*current, this, link) {
ISC_LIST_INIT(save);
- ISC_LIST_FOREACH (this->rdata, rdata, link) {
+ ISC_LIST_FOREACH(this->rdata, rdata, link) {
ISC_LIST_UNLINK(this->rdata, rdata, link);
ISC_LIST_APPEND(save, rdata, link);
}
- ISC_LIST_FOREACH (save, rdata, link) {
+ ISC_LIST_FOREACH(save, rdata, link) {
ISC_LIST_UNLINK(save, rdata, link);
INSIST(rdcount < new_len);
newlist[rdcount] = *rdata;
/*
* Copy glue relinking.
*/
- ISC_LIST_FOREACH (*glue, this, link) {
+ ISC_LIST_FOREACH(*glue, this, link) {
ISC_LIST_INIT(save);
- ISC_LIST_FOREACH (this->rdata, rdata, link) {
+ ISC_LIST_FOREACH(this->rdata, rdata, link) {
ISC_LIST_UNLINK(this->rdata, rdata, link);
ISC_LIST_APPEND(save, rdata, link);
}
- ISC_LIST_FOREACH (save, rdata, link) {
+ ISC_LIST_FOREACH(save, rdata, link) {
ISC_LIST_UNLINK(save, rdata, link);
INSIST(rdcount < new_len);
newlist[rdcount] = *rdata;
error = callbacks->error;
- ISC_LIST_FOREACH (*head, this, link) {
+ ISC_LIST_FOREACH(*head, this, link) {
dns_rdataset_init(&dataset);
dns_rdatalist_tordataset(this, &dataset);
dataset.trust = dns_trust_ultimate;
/*
* Find NS rrset.
*/
- ISC_LIST_FOREACH (*head, this, link) {
+ ISC_LIST_FOREACH(*head, this, link) {
if (this->type == dns_rdatatype_ns) {
nslist = this;
break;
return false;
}
- ISC_LIST_FOREACH (nslist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(nslist->rdata, rdata, link) {
dns_name_init(&name);
dns_rdata_toregion(rdata, ®ion);
dns_name_fromregion(&name, ®ion);
do {
dns_ncache_current(rdataset, &name, &rds);
- DNS_RDATASET_FOREACH (&rds) {
+ DNS_RDATASET_FOREACH(&rds) {
if ((ctx->style.flags & DNS_STYLEFLAG_INDENT) != 0 ||
(ctx->style.flags & DNS_STYLEFLAG_YAML) != 0)
{
dns_rdataset_getownercase(rdataset, name);
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
column = 0;
/*
isc_buffer_copyregion(buffer, &r);
totallen += sizeof(dlen) + r.length;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
dns_name_t *name = dns_fixedname_initname(&fixed);
dns_name_copy(owner_name, name);
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
CHECK(writeheader(dctx));
- DNS_DBITERATOR_FOREACH (dctx->dbiter) {
+ DNS_DBITERATOR_FOREACH(dctx->dbiter) {
dns_rdatasetiter_t *rdsiter = NULL;
dns_dbnode_t *node = NULL;
static void
msgresetname(dns_message_t *msg, dns_name_t *name) {
- ISC_LIST_FOREACH (name->list, rds, link) {
+ ISC_LIST_FOREACH(name->list, rds, link) {
ISC_LIST_UNLINK(name->list, rds, link);
dns__message_putassociatedrdataset(msg, &rds);
}
msgresetnames(dns_message_t *msg, unsigned int first_section) {
/* Clean up name lists. */
for (size_t i = first_section; i < DNS_SECTION_MAX; i++) {
- ISC_LIST_FOREACH (msg->sections[i], name, link) {
+ ISC_LIST_FOREACH(msg->sections[i], name, link) {
ISC_LIST_UNLINK(msg->sections[i], name, link);
msgresetname(msg, name);
dns_message_puttempname(msg, &name);
* The memory isn't lost since these are part of message blocks we
* have allocated.
*/
- ISC_LIST_FOREACH (msg->freerdata, rdata, link) {
+ ISC_LIST_FOREACH(msg->freerdata, rdata, link) {
ISC_LIST_UNLINK(msg->freerdata, rdata, link);
}
- ISC_LIST_FOREACH (msg->freerdatalist, rdatalist, link) {
+ ISC_LIST_FOREACH(msg->freerdatalist, rdatalist, link) {
ISC_LIST_UNLINK(msg->freerdatalist, rdatalist, link);
}
static isc_result_t
findname(dns_name_t **foundname, const dns_name_t *target,
dns_namelist_t *section) {
- ISC_LIST_FOREACH_REV (*section, name, link) {
+ ISC_LIST_FOREACH_REV(*section, name, link) {
if (dns_name_equal(name, target)) {
if (foundname != NULL) {
*foundname = name;
REQUIRE(name != NULL);
REQUIRE(rdatasetp == NULL || *rdatasetp == NULL);
- ISC_LIST_FOREACH_REV (name->list, rds, link) {
+ ISC_LIST_FOREACH_REV(name->list, rds, link) {
if (rds->type == type && rds->covers == covers) {
SET_IF_NOT_NULL(rdatasetp, rds);
return ISC_R_SUCCESS;
static void
cleanup_name_hashmaps(dns_namelist_t *section) {
- ISC_LIST_FOREACH (*section, name, link) {
+ ISC_LIST_FOREACH(*section, name, link) {
if (name->hashmap != NULL) {
isc_hashmap_destroy(&name->hashmap);
}
return ISC_R_SUCCESS;
}
- ISC_LIST_FOREACH (*section, n, link) {
- ISC_LIST_FOREACH (n->list, rds, link) {
+ ISC_LIST_FOREACH(*section, n, link) {
+ ISC_LIST_FOREACH(n->list, rds, link) {
if (rds->attributes.rendered) {
continue;
}
for (size_t i = 0; i < DNS_SECTION_MAX; i++) {
msg->cursors[i] = NULL;
msg->counts[i] = 0;
- MSG_SECTION_FOREACH (msg, i, name) {
- ISC_LIST_FOREACH (name->list, rds, link) {
+ MSG_SECTION_FOREACH(msg, i, name) {
+ ISC_LIST_FOREACH(name->list, rds, link) {
rds->attributes.rendered = false;
}
}
bool has_yaml = (sflags & DNS_STYLEFLAG_YAML) != 0;
msg->indent.count += has_yaml;
- MSG_SECTION_FOREACH (msg, section, name) {
- ISC_LIST_FOREACH (name->list, rds, link) {
+ MSG_SECTION_FOREACH(msg, section, name) {
+ ISC_LIST_FOREACH(name->list, rds, link) {
if (section == DNS_SECTION_ANSWER &&
rds->type == dns_rdatatype_soa)
{
static isc_result_t
rdataset_soa_min(dns_rdataset_t *rds, dns_ttl_t *ttlp) {
/* loop over the rdatas */
- DNS_RDATASET_FOREACH (rds) {
+ DNS_RDATASET_FOREACH(rds) {
dns_name_t tmp;
isc_region_t r = { 0 };
dns_rdata_t rdata = DNS_RDATA_INIT;
return ISC_R_NOTFOUND;
}
- MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) {
- ISC_LIST_FOREACH (name->list, rds, link) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_AUTHORITY, name) {
+ ISC_LIST_FOREACH(name->list, rds, link) {
if (!rds->attributes.rendered) {
continue;
}
INSIST(count <= 65535);
isc_buffer_putuint16(buffer, (uint16_t)count);
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
trust = 0xffff;
isc_buffer_init(&buffer, data, sizeof(data));
- MSG_SECTION_FOREACH (message, DNS_SECTION_AUTHORITY, name) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, name) {
result = ISC_R_SUCCESS;
if (name->attributes.ncache) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (!rdataset->attributes.ncache) {
continue;
}
savedbuffer = *target;
count = 0;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
dns_rdataset_init(&rclone);
dns_rdataset_clone(ncacherdataset, &rclone);
- DNS_RDATASET_FOREACH (&rclone) {
+ DNS_RDATASET_FOREACH(&rclone) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rclone, &rdata);
dns_rdataset_init(&rclone);
dns_rdataset_clone(ncacherdataset, &rclone);
- DNS_RDATASET_FOREACH (&rclone) {
+ DNS_RDATASET_FOREACH(&rclone) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rclone, &rdata);
if (result != ISC_R_SUCCESS) {
return result;
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
if (!dns_rdatatype_isnsec(rdataset.type) &&
return result;
}
bool matched = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
{
bool deleted = false;
if (diff != NULL) {
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
if (tuple->rdata.type !=
dns_rdatatype_dnskey ||
tuple->op != DNS_DIFFOP_DEL)
dns_rdataset_clone(nsecset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (!dns_nsec_typepresent(&rdata, dns_rdatatype_nsec) ||
return result;
}
found = found_ns = need_rrsig = false;
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
if (!dns_rdatatype_isnsec(rdataset.type) &&
goto cleanup_node;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &nsec3, NULL));
}
dns_rdataset_clone(nsec3paramset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
static isc_result_t
find_nsec3(dns_rdata_nsec3_t *nsec3, dns_rdataset_t *rdataset,
const dns_rdata_nsec3param_t *nsec3param) {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
dns_rdata_tostruct(&rdata, nsec3, NULL);
/*
* Update each active NSEC3 chain.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
}
bool matched = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t myrdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &myrdata);
if (dns_rdata_casecompare(&myrdata, rdata) == 0) {
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t private = DNS_RDATA_INIT;
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
INSIST(rdata.length <= sizeof(buf));
/*
* Update each active NSEC3 chain.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
/*
* Update each active NSEC3 chain.
*/
- DNS_RDATASET_FOREACH (&prdataset) {
+ DNS_RDATASET_FOREACH(&prdataset) {
dns_rdata_t rdata1 = DNS_RDATA_INIT;
dns_rdata_t rdata2 = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
/*
* Update each active NSEC3 chain.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
/*
* Update each NSEC3 chain being built.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata1 = DNS_RDATA_INIT;
dns_rdata_t rdata2 = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
}
bool found = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
dns_rdata_tostruct(&rdata, &nsec3param, NULL);
}
found = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata1 = DNS_RDATA_INIT;
dns_rdata_t rdata2 = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass) {
REQUIRE(DNS_ORDER_VALID(order));
- ISC_LIST_FOREACH (order->ents, ent, link) {
+ ISC_LIST_FOREACH(order->ents, ent, link) {
if (ent->rdtype != rdtype && ent->rdtype != dns_rdatatype_any) {
continue;
}
if (isc_refcount_decrement(&order->references) == 1) {
isc_refcount_destroy(&order->references);
order->magic = 0;
- ISC_LIST_FOREACH (order->ents, ent, link) {
+ ISC_LIST_FOREACH(order->ents, ent, link) {
ISC_LIST_UNLINK(order->ents, ent, link);
isc_mem_put(order->mctx, ent, sizeof(*ent));
}
isc_refcount_destroy(&l->refs);
- ISC_LIST_FOREACH (l->elements, server, next) {
+ ISC_LIST_FOREACH(l->elements, server, next) {
ISC_LIST_UNLINK(l->elements, server, next);
dns_peer_detach(&server);
}
* More specifics to front of list.
*/
dns_peer_attach(peer, &(dns_peer_t *){ NULL });
- ISC_LIST_FOREACH (peers->elements, p, next) {
+ ISC_LIST_FOREACH(peers->elements, p, next) {
if (p->prefixlen < peer->prefixlen) {
ISC_LIST_INSERTBEFORE(peers->elements, p, peer, next);
return;
REQUIRE(retval != NULL);
REQUIRE(DNS_PEERLIST_VALID(servers));
- ISC_LIST_FOREACH (servers->elements, server, next) {
+ ISC_LIST_FOREACH(servers->elements, server, next) {
if (isc_netaddr_eqprefix(addr, &server->address,
server->prefixlen))
{
static bool
ignore(dns_rdata_t *param, dns_rdataset_t *privateset) {
- DNS_RDATASET_FOREACH (privateset) {
+ DNS_RDATASET_FOREACH(privateset) {
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
if (!dns_rdataset_isassociated(&privateset)) {
goto success;
}
- DNS_RDATASET_FOREACH (&privateset) {
+ DNS_RDATASET_FOREACH(&privateset) {
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
* If we are in the process of building a new NSEC3 chain
* then we don't need to build a NSEC chain.
*/
- DNS_RDATASET_FOREACH (&privateset) {
+ DNS_RDATASET_FOREACH(&privateset) {
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
* the changes queued complete.
*/
count = 0;
- DNS_RDATASET_FOREACH (&nsec3paramset) {
+ DNS_RDATASET_FOREACH(&nsec3paramset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
/*
signing = false;
nsec3chain = false;
- DNS_RDATASET_FOREACH (&privateset) {
+ DNS_RDATASET_FOREACH(&privateset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t private = DNS_RDATA_INIT;
dns_qp_t *qpw = &multi->writer;
- ISC_LIST_FOREACH (multi->snapshots, 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] ==
*
* The caller must be holding the database lock.
*/
- ISC_LIST_FOREACH (version->changed_list, changed, link) {
+ ISC_LIST_FOREACH(version->changed_list, changed, link) {
if (!changed->dirty) {
ISC_LIST_UNLINK(version->changed_list, changed, link);
ISC_LIST_APPEND(*cleanup_list, changed, link);
/*
* Commit/rollback re-signed headers.
*/
- ISC_LIST_FOREACH (resigned_list, resigned, link) {
+ ISC_LIST_FOREACH(resigned_list, resigned, link) {
isc_rwlock_t *nlock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
dns_slabheader_t *header = resigned->header;
return;
}
- ISC_LIST_FOREACH (cleanup_list, changed, link) {
+ ISC_LIST_FOREACH(cleanup_list, changed, link) {
isc_rwlock_t *nlock = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
rdatalist = rdataset->rdlist.list;
count = 0;
- ISC_LIST_FOREACH (rdatalist->rdata, rdata, link) {
+ ISC_LIST_FOREACH(rdatalist->rdata, rdata, link) {
count++;
}
REQUIRE(rdataset != NULL);
- ISC_LIST_FOREACH (name->list, rdset, link) {
+ ISC_LIST_FOREACH(name->list, rdset, link) {
if (rdset->rdclass != rdataset->rdclass) {
continue;
}
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (name->list, rdset, link) {
+ ISC_LIST_FOREACH(name->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == neg->type)
{
(void)dns_name_dynamic(noqname); /* Sanity Check. */
- ISC_LIST_FOREACH (noqname->list, rdset, link) {
+ ISC_LIST_FOREACH(noqname->list, rdset, link) {
if (rdset->rdclass != rdclass) {
continue;
}
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (noqname->list, rdset, link) {
+ ISC_LIST_FOREACH(noqname->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == tneg->type)
{
REQUIRE(rdataset != NULL);
- ISC_LIST_FOREACH (name->list, rdset, link) {
+ ISC_LIST_FOREACH(name->list, rdset, link) {
if (rdset->rdclass != rdataset->rdclass) {
continue;
}
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (name->list, rdset, link) {
+ ISC_LIST_FOREACH(name->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == neg->type)
{
(void)dns_name_dynamic(closest); /* Sanity Check. */
- ISC_LIST_FOREACH (closest->list, rdset, link) {
+ ISC_LIST_FOREACH(closest->list, rdset, link) {
if (rdset->rdclass != rdclass) {
continue;
}
return ISC_R_NOTFOUND;
}
- ISC_LIST_FOREACH (closest->list, rdset, link) {
+ ISC_LIST_FOREACH(closest->list, rdset, link) {
if (rdset->type == dns_rdatatype_rrsig &&
rdset->covers == tneg->type)
{
return DNS_R_TOOMANYRECORDS;
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
dns_requestmgr_t *requestmgr = arg;
isc_tid_t tid = isc_tid();
- ISC_LIST_FOREACH (requestmgr->requests[tid], request, link) {
+ ISC_LIST_FOREACH(requestmgr->requests[tid], request, link) {
req_log(ISC_LOG_DEBUG(3), "%s(%" PRItid ": request %p",
__func__, tid, request);
if (DNS_REQUEST_COMPLETE(request)) {
static void
free_search(irs_resconf_t *conf) {
- ISC_LIST_FOREACH (conf->searchlist, searchentry, link) {
+ ISC_LIST_FOREACH(conf->searchlist, searchentry, link) {
ISC_LIST_UNLINK(conf->searchlist, searchentry, link);
isc_mem_free(conf->mctx, searchentry->domain);
isc_mem_put(conf->mctx, searchentry, sizeof(*searchentry));
free_search(conf);
- ISC_LIST_FOREACH (conf->nameservers, address, link) {
+ ISC_LIST_FOREACH(conf->nameservers, address, link) {
ISC_LIST_UNLINK(conf->nameservers, address, link);
isc_mem_put(conf->mctx, address, sizeof(*address));
}
* Age RTTs of servers not tried.
*/
if (finish != NULL || age_untried) {
- ISC_LIST_FOREACH (fctx->forwaddrs, 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)) {
- ISC_LIST_FOREACH (fctx->finds, find, publink) {
- ISC_LIST_FOREACH (find->list, 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)) {
- ISC_LIST_FOREACH (fctx->altaddrs, addrinfo, publink) {
+ ISC_LIST_FOREACH(fctx->altaddrs, addrinfo, publink) {
if (UNMARKED(addrinfo)) {
dns_adb_agesrtt(fctx->adb, addrinfo, now);
}
}
- ISC_LIST_FOREACH (fctx->altfinds, find, publink) {
- ISC_LIST_FOREACH (find->list, 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);
fctx_cleanup(fetchctx_t *fctx) {
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
- ISC_LIST_FOREACH (fctx->finds, find, publink) {
+ ISC_LIST_FOREACH(fctx->finds, find, publink) {
ISC_LIST_UNLINK(fctx->finds, find, publink);
dns_adb_destroyfind(&find);
fetchctx_unref(fctx);
}
fctx->find = NULL;
- ISC_LIST_FOREACH (fctx->altfinds, find, publink) {
+ ISC_LIST_FOREACH(fctx->altfinds, find, publink) {
ISC_LIST_UNLINK(fctx->altfinds, find, publink);
dns_adb_destroyfind(&find);
fetchctx_unref(fctx);
}
fctx->altfind = NULL;
- ISC_LIST_FOREACH (fctx->forwaddrs, addr, publink) {
+ ISC_LIST_FOREACH(fctx->forwaddrs, addr, publink) {
ISC_LIST_UNLINK(fctx->forwaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
}
- ISC_LIST_FOREACH (fctx->altaddrs, addr, publink) {
+ ISC_LIST_FOREACH(fctx->altaddrs, addr, publink) {
ISC_LIST_UNLINK(fctx->altaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
}
ISC_LIST_MOVE(queries, fctx->queries);
UNLOCK(&fctx->lock);
- ISC_LIST_FOREACH (queries, query, link) {
+ ISC_LIST_FOREACH(queries, query, link) {
/*
* Note that we have to unlink the query here,
* because if it's still linked in fctx_cancelquery(),
now = isc_time_now();
fctx->duration = isc_time_microdiff(&now, &fctx->start);
- ISC_LIST_FOREACH (fctx->resps, resp, link) {
+ ISC_LIST_FOREACH(fctx->resps, resp, link) {
ISC_LIST_UNLINK(fctx->resps, resp, link);
count++;
static struct tried *
triededns(fetchctx_t *fctx, isc_sockaddr_t *address) {
- ISC_LIST_FOREACH (fctx->edns, tried, link) {
+ ISC_LIST_FOREACH(fctx->edns, tried, link) {
if (isc_sockaddr_equal(&tried->addr, address)) {
return tried;
}
static bool
bad_server(fetchctx_t *fctx, isc_sockaddr_t *address) {
- ISC_LIST_FOREACH (fctx->bad, sa, link) {
+ ISC_LIST_FOREACH(fctx->bad, sa, link) {
if (isc_sockaddr_equal(sa, address)) {
return true;
}
/*
* Mark any bad nameservers.
*/
- ISC_LIST_FOREACH (fctx->finds, curr, publink) {
- ISC_LIST_FOREACH (curr->list, 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.
*/
- ISC_LIST_FOREACH (fctx->forwaddrs, 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.
*/
- ISC_LIST_FOREACH (fctx->altfinds, curr, publink) {
- ISC_LIST_FOREACH (curr->list, 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 {
}
}
- ISC_LIST_FOREACH (fctx->altaddrs, addrinfo, publink) {
+ ISC_LIST_FOREACH(fctx->altaddrs, addrinfo, publink) {
if (bad_server(fctx, &addrinfo->sockaddr)) {
addrinfo->flags |= FCTX_ADDRINFO_MARK;
} else {
dns_adbaddrinfo_t *addrinfo, *bestaddrinfo;
/* Sort each find's addrinfo list by SRTT. */
- ISC_LIST_FOREACH (*findlist, curr, publink) {
+ ISC_LIST_FOREACH(*findlist, curr, publink) {
sort_adbfind(curr, bias);
}
*/
INSIST((find->options & DNS_ADBFIND_WANTEVENT) == 0);
if (flags != 0 || port != 0) {
- ISC_LIST_FOREACH (find->list, ai, publink) {
+ ISC_LIST_FOREACH(find->list, ai, publink) {
ai->flags |= flags;
if (port != 0) {
isc_sockaddr_setport(&ai->sockaddr,
INSIST(ISC_LIST_EMPTY(fctx->finds));
INSIST(ISC_LIST_EMPTY(fctx->altfinds));
- DNS_RDATASET_FOREACH (&fctx->nameservers) {
+ DNS_RDATASET_FOREACH(&fctx->nameservers) {
dns_rdata_t rdata = DNS_RDATA_INIT;
bool overquota = false;
unsigned int static_stub = 0;
if (need_alternate) {
int family;
family = (res->dispatches6 != NULL) ? AF_INET6 : AF_INET;
- ISC_LIST_FOREACH (res->alternates, 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,
/*
* Find the first unmarked forwarder (if any).
*/
- ISC_LIST_FOREACH (fctx->forwaddrs, ai, publink) {
+ ISC_LIST_FOREACH(fctx->forwaddrs, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
if (find != NULL) {
start = find;
do {
- ISC_LIST_FOREACH (find->list, ai, publink) {
+ ISC_LIST_FOREACH(find->list, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
if (find != NULL) {
start = find;
do {
- ISC_LIST_FOREACH (find->list, ai, publink) {
+ ISC_LIST_FOREACH(find->list, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
/*
* See if we have a better alternate server by address.
*/
- ISC_LIST_FOREACH (fctx->altaddrs, ai, publink) {
+ ISC_LIST_FOREACH(fctx->altaddrs, ai, publink) {
if (!UNMARKED(ai)) {
continue;
}
dec_stats(res, dns_resstatscounter_nfetch);
/* Free bad */
- ISC_LIST_FOREACH (fctx->bad, sa, link) {
+ ISC_LIST_FOREACH(fctx->bad, sa, link) {
ISC_LIST_UNLINK(fctx->bad, sa, link);
isc_mem_put(fctx->mctx, sa, sizeof(*sa));
}
- ISC_LIST_FOREACH (fctx->edns, tried, link) {
+ ISC_LIST_FOREACH(fctx->edns, tried, link) {
ISC_LIST_UNLINK(fctx->edns, tried, link);
isc_mem_put(fctx->mctx, tried, sizeof(*tried));
}
return false;
}
- MSG_SECTION_FOREACH (message, DNS_SECTION_AUTHORITY, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
dns_namereln_t namereln;
int order;
unsigned int labels;
FCTXTRACE("clone_results");
- ISC_LIST_FOREACH (fctx->resps, 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));
- ISC_LIST_FOREACH (fctx->validators, validator, link) {
+ ISC_LIST_FOREACH(fctx->validators, validator, link) {
dns_validator_cancel(validator);
}
}
dns_rdataset_clone(nsecset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_nsec_t nsec;
dns_rdataset_clone(nsecset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (dns_nsec_typepresent(&rdata, dns_rdatatype_soa) &&
dns_rdataset_clone(nsecset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (rdata.length > 1 && rdata.data[0] == 1 &&
/*
* Cache any SOA/NS/NSEC records that happened to be validated.
*/
- MSG_SECTION_FOREACH (message, DNS_SECTION_AUTHORITY, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
dns_rdataset_t *sigrdataset = NULL;
if ((rdataset->type != dns_rdatatype_ns &&
labels = dns_name_countlabels(name);
result = ISC_R_NOTFOUND;
- DNS_RDATASET_FOREACH (sigrdataset) {
+ DNS_RDATASET_FOREACH(sigrdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(sigrdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &rrsig, NULL);
#define NXND(x) ((x) == ISC_R_SUCCESS)
- MSG_SECTION_FOREACH (message, DNS_SECTION_AUTHORITY, nsec) {
- ISC_LIST_FOREACH (nsec->list, nrdataset, link) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, nsec) {
+ ISC_LIST_FOREACH(nsec->list, nrdataset, link) {
bool data = false, exists = false;
bool optout = false, unknown = false;
bool setclosest = false;
* Cache or validate each cacheable rdataset.
*/
bool fail = ((res->options & DNS_RESOLVER_CHECKNAMESFAIL) != 0);
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
result = check_cacheable(name, rdataset, fail);
if (result == DNS_R_CONTINUE) {
result = ISC_R_SUCCESS;
for (dns_section_t section = DNS_SECTION_ANSWER;
section <= DNS_SECTION_ADDITIONAL; section++)
{
- MSG_SECTION_FOREACH (message, section, name) {
+ MSG_SECTION_FOREACH(message, section, name) {
if (name->attributes.cache) {
result = rctx_cachename(rctx, message, name);
if (result != ISC_R_SUCCESS) {
* any domain under a trust anchor, regardless
* of whether we're actually validating.)
*/
- MSG_SECTION_FOREACH (message, DNS_SECTION_AUTHORITY, tname) {
- ISC_LIST_FOREACH (tname->list, trdataset, link) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_AUTHORITY, tname) {
+ ISC_LIST_FOREACH(tname->list, trdataset, link) {
trdataset->trust = dns_trust_pending_answer;
}
}
if (result == ISC_R_SUCCESS) {
external = name_external(name, type, fctx);
if (type == dns_rdatatype_a) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (dns_rdatatype_issig(rdataset->type)) {
rtype = rdataset->covers;
} else {
* address record. If a match is found, the address should be
* filtered, so should the entire answer.
*/
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_reset(&rdata);
dns_rdataset_current(rdataset, &rdata);
if (rdataset->type == dns_rdatatype_a) {
static void
checknamessection(dns_message_t *message, dns_section_t section) {
- MSG_SECTION_FOREACH (message, section, name) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
- DNS_RDATASET_FOREACH (rdataset) {
+ MSG_SECTION_FOREACH(message, section, name) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
if (!dns_rdata_checkowner(name, rdata.rdclass,
betterreferral(respctx_t *rctx) {
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_AUTHORITY, name) {
if (!isstrictsubdomain(name, rctx->fctx->domain)) {
continue;
}
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (rdataset->type == dns_rdatatype_ns) {
return true;
}
fetchctx_t *fctx = rctx->fctx;
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, DNS_SECTION_ANSWER, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_ANSWER, name) {
int order;
unsigned int nlabels;
dns_namereln_t namereln;
&nlabels);
switch (namereln) {
case dns_namereln_equal:
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (rdataset->type == rctx->type ||
rctx->type == dns_rdatatype_any)
{
* there are multiple ones (which there
* shouldn't be).
*/
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (rdataset->type != dns_rdatatype_dname) {
continue;
}
rctx_answer_any(respctx_t *rctx) {
fetchctx_t *fctx = rctx->fctx;
- ISC_LIST_FOREACH (rctx->aname->list, rdataset, link) {
+ ISC_LIST_FOREACH(rctx->aname->list, rdataset, link) {
if (!validinanswer(rdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
check_related, rctx,
DNS_RDATASET_MAXADDITIONAL);
- ISC_LIST_FOREACH (rctx->aname->list, sigrdataset, link) {
+ ISC_LIST_FOREACH(rctx->aname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
rctx->crdataset->attributes.chaining = true;
rctx->crdataset->trust = rctx->trust;
- ISC_LIST_FOREACH (rctx->cname->list, sigrdataset, link) {
+ ISC_LIST_FOREACH(rctx->cname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
rctx->drdataset->attributes.chaining = true;
rctx->drdataset->trust = rctx->trust;
- ISC_LIST_FOREACH (rctx->dname->list, sigrdataset, link) {
+ ISC_LIST_FOREACH(rctx->dname->list, sigrdataset, link) {
if (!validinanswer(sigrdataset, fctx)) {
rctx->result = DNS_R_FORMERR;
return ISC_R_COMPLETE;
fetchctx_t *fctx = rctx->fctx;
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_AUTHORITY, name) {
if (!name_external(name, dns_rdatatype_ns, fctx)) {
/*
* We expect to find NS or SIG NS rdatasets, and
* nothing else.
*/
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (dns_rdataset_matchestype(rdataset,
dns_rdatatype_ns))
{
section = DNS_SECTION_AUTHORITY;
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, section, name) {
+ MSG_SECTION_FOREACH(msg, section, name) {
if (!dns_name_issubdomain(name, fctx->domain)) {
continue;
}
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
dns_rdatatype_t type = rdataset->type;
if (dns_rdatatype_issig(rdataset->type)) {
type = rdataset->covers;
fetchctx_t *fctx = rctx->fctx;
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_AUTHORITY, name) {
if (!dns_name_issubdomain(name, fctx->domain)) {
/*
* Invalid name found; preserve it for logging
continue;
}
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
bool secure_domain = false;
dns_rdatatype_t type = rdataset->type;
rescan = false;
dns_message_t *msg = rctx->query->rmessage;
- MSG_SECTION_FOREACH (msg, section, name) {
+ MSG_SECTION_FOREACH(msg, section, name) {
if (!name->attributes.chase) {
continue;
}
name->attributes.chase = false;
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (CHASE(rdataset)) {
rdataset->attributes.chase = false;
(void)dns_rdataset_additionaldata(
/* Is this a duplicate? */
if (client != NULL) {
- ISC_LIST_FOREACH (fctx->resps, 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) {
- ISC_LIST_FOREACH (fctx->resps, resp, link) {
+ ISC_LIST_FOREACH(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) {
- ISC_LIST_FOREACH (fctx->resps, resp, link) {
+ ISC_LIST_FOREACH(fctx->resps, resp, link) {
RUNTIME_CHECK(resp->fetch != fetch);
}
}
fctx->state == fetchstate_active ? "active" : "done",
timebuf);
- ISC_LIST_FOREACH (fctx->resps, resp, link) {
+ ISC_LIST_FOREACH(fctx->resps, resp, link) {
resp_count++;
}
- ISC_LIST_FOREACH (fctx->queries, query, link) {
+ ISC_LIST_FOREACH(fctx->queries, query, link) {
query_count++;
}
return ISC_R_NOTFOUND;
}
- DNS_RDATASET_FOREACH (rootns) {
+ DNS_RDATASET_FOREACH(rootns) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rootns, &rdata);
result = dns_rdata_tostruct(&rdata, &ns, NULL);
static isc_result_t
check_node(dns_rdataset_t *rootns, dns_name_t *name,
dns_rdatasetiter_t *rdsiter) {
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
dns_rdatatype_t type = rdataset.type;
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- DNS_DBITERATOR_FOREACH (dbiter) {
+ DNS_DBITERATOR_FOREACH(dbiter) {
result = dns_dbiterator_current(dbiter, &node, name);
if (result != ISC_R_SUCCESS) {
goto cleanup;
static bool
inrrset(dns_rdataset_t *rrset, dns_rdata_t *rdata) {
- DNS_RDATASET_FOREACH (rrset) {
+ DNS_RDATASET_FOREACH(rrset) {
dns_rdata_t current = DNS_RDATA_INIT;
dns_rdataset_current(rrset, ¤t);
if (dns_rdata_compare(rdata, ¤t) == 0) {
if (hresult == ISC_R_SUCCESS &&
(rresult == ISC_R_SUCCESS || rresult == DNS_R_GLUE))
{
- DNS_RDATASET_FOREACH (&rootrrset) {
+ DNS_RDATASET_FOREACH(&rootrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rootrrset, &rdata);
if (!inrrset(&hintrrset, &rdata) &&
report(view, name, true, &rdata);
}
}
- DNS_RDATASET_FOREACH (&hintrrset) {
+ DNS_RDATASET_FOREACH(&hintrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&hintrrset, &rdata);
if (!inrrset(&rootrrset, &rdata) &&
if (hresult == ISC_R_NOTFOUND &&
(rresult == ISC_R_SUCCESS || rresult == DNS_R_GLUE))
{
- DNS_RDATASET_FOREACH (&rootrrset) {
+ DNS_RDATASET_FOREACH(&rootrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rootrrset, &rdata);
report(view, name, true, &rdata);
if (hresult == ISC_R_SUCCESS &&
(rresult == ISC_R_SUCCESS || rresult == DNS_R_GLUE))
{
- DNS_RDATASET_FOREACH (&rootrrset) {
+ DNS_RDATASET_FOREACH(&rootrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rootrrset, &rdata);
if (!inrrset(&hintrrset, &rdata) &&
report(view, name, true, &rdata);
}
}
- DNS_RDATASET_FOREACH (&hintrrset) {
+ DNS_RDATASET_FOREACH(&hintrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&hintrrset, &rdata);
if (!inrrset(&rootrrset, &rdata) &&
if (hresult == ISC_R_NOTFOUND &&
(rresult == ISC_R_SUCCESS || rresult == DNS_R_GLUE))
{
- DNS_RDATASET_FOREACH (&rootrrset) {
+ DNS_RDATASET_FOREACH(&rootrrset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rootrrset, &rdata);
report(view, name, true, &rdata);
/*
* Look for missing root NS names.
*/
- DNS_RDATASET_FOREACH (&rootns) {
+ DNS_RDATASET_FOREACH(&rootns) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rootns, &rdata);
result = dns_rdata_tostruct(&rdata, &ns, NULL);
/*
* Look for extra root NS names.
*/
- DNS_RDATASET_FOREACH (&hintns) {
+ DNS_RDATASET_FOREACH(&hintns) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&hintns, &rdata);
result = dns_rdata_tostruct(&rdata, &ns, NULL);
for (old_bin = &old_hash->bins[0];
old_bin < &old_hash->bins[old_hash->length]; ++old_bin)
{
- ISC_LIST_FOREACH (*old_bin, e, hlink) {
+ ISC_LIST_FOREACH(*old_bin, e, hlink) {
ISC_LINK_INIT(e, hlink);
}
}
*/
new_bin = get_bin(rrl->hash, hval);
probes = 1;
- ISC_LIST_FOREACH (*new_bin, e, hlink) {
+ ISC_LIST_FOREACH(*new_bin, e, hlink) {
if (key_cmp(&e->key, &key)) {
ref_entry(rrl, e, probes, now);
return e;
*/
if (rrl->old_hash != NULL) {
old_bin = get_bin(rrl->old_hash, hval);
- ISC_LIST_FOREACH (*old_bin, e, hlink) {
+ ISC_LIST_FOREACH(*old_bin, e, hlink) {
if (key_cmp(&e->key, &key)) {
ISC_LIST_UNLINK(*old_bin, e, hlink);
ISC_LIST_PREPEND(*new_bin, e, hlink);
* Steal the oldest entry if we cannot create more.
*/
dns_rrl_entry_t *entry = NULL;
- ISC_LIST_FOREACH_REV (rrl->lru, e, lru) {
+ ISC_LIST_FOREACH_REV(rrl->lru, e, lru) {
entry = e;
if (!ISC_LINK_LINKED(e, hlink)) {
break;
isc_mutex_destroy(&rrl->lock);
- ISC_LIST_FOREACH (rrl->blocks, b, link) {
+ ISC_LIST_FOREACH(rrl->blocks, b, link) {
ISC_LIST_UNLINK(rrl->blocks, b, link);
isc_mem_put(rrl->mctx, b,
STRUCT_FLEX_SIZE(b, entries, b->count));
REQUIRE(DNS_SKRBUNDLE_VALID(bundle));
REQUIRE(DNS_DIFF_VALID(&bundle->diff));
- ISC_LIST_FOREACH (bundle->diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(bundle->diff.tuples, tuple, link) {
dns_rdata_rrsig_t rrsig;
if (tuple->op != DNS_DIFFOP_ADDRESIGN) {
dns_skr_lookup(dns_skr_t *skr, isc_stdtime_t time, uint32_t sigval) {
REQUIRE(DNS_SKR_VALID(skr));
- ISC_LIST_FOREACH (skr->bundles, b, link) {
+ ISC_LIST_FOREACH(skr->bundles, b, link) {
dns_skrbundle_t *next = ISC_LIST_NEXT(b, link);
isc_stdtime_t expired = (next != NULL)
? next->inception
dns_skr_destroy(dns_skr_t *skr) {
REQUIRE(DNS_SKR_VALID(skr));
- ISC_LIST_FOREACH (skr->bundles, b, link) {
+ ISC_LIST_FOREACH(skr->bundles, b, link) {
ISC_LIST_UNLINK(skr->bundles, b, link);
dns_diff_clear(&b->diff);
isc_mem_put(skr->mctx, b, sizeof(*b));
REQUIRE(VALID_SSUTABLE(table));
mctx = table->mctx;
- ISC_LIST_FOREACH (table->rules, rule, link) {
+ ISC_LIST_FOREACH(table->rules, rule, link) {
if (rule->identity != NULL) {
dns_name_free(rule->identity, mctx);
isc_mem_put(mctx, rule->identity,
return false;
}
- ISC_LIST_FOREACH (table->rules, 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),
static void
free_namelist(dns_message_t *msg, dns_namelist_t *namelist) {
- ISC_LIST_FOREACH (*namelist, name, link) {
+ ISC_LIST_FOREACH(*namelist, name, link) {
ISC_LIST_UNLINK(*namelist, name, link);
- ISC_LIST_FOREACH (name->list, set, link) {
+ ISC_LIST_FOREACH(name->list, set, link) {
ISC_LIST_UNLINK(name->list, set, link);
if (dns_rdataset_isassociated(set)) {
dns_rdataset_disassociate(set);
RETERR(dns_message_reply(msg, true));
add_rdata_to_list(msg, keyname, &rdata, 0, &namelist);
- ISC_LIST_FOREACH (namelist, name, link) {
+ ISC_LIST_FOREACH(namelist, name, link) {
ISC_LIST_UNLINK(namelist, name, link);
dns_message_addname(msg, name, DNS_SECTION_ANSWER);
}
int section) {
isc_result_t result;
- MSG_SECTION_FOREACH (msg, section, cur) {
+ MSG_SECTION_FOREACH(msg, section, cur) {
dns_rdataset_t *tkeyset = NULL;
result = dns_message_findtype(cur, dns_rdatatype_tkey, 0,
&tkeyset);
foreach_node_rr_action(void *data, dns_rdataset_t *rdataset) {
isc_result_t result;
foreach_node_rr_ctx_t *ctx = data;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(rdataset, &rr.rdata);
goto cleanup_node;
}
- DNS_RDATASETITER_FOREACH (iter) {
+ DNS_RDATASETITER_FOREACH(iter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iter, &rdataset);
goto cleanup_node;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(&rdataset, &rr.rdata);
rr.ttl = rdataset.ttl;
CHECK(dns_diff_sort(list, name_order));
dns_name_t *curr_name = NULL;
- ISC_LIST_FOREACH (list->tuples, p, link) {
+ ISC_LIST_FOREACH(list->tuples, p, link) {
if (curr_name == NULL || !dns_name_equal(curr_name, &p->name)) {
curr_name = &(p->name);
} else {
}
/* Add new 'dnskeys' to 'keys' */
- ISC_LIST_FOREACH (keylist, k, link) {
+ ISC_LIST_FOREACH(keylist, k, link) {
if (count >= maxkeys) {
ISC_LIST_UNLINK(keylist, k, link);
dns_dnsseckey_destroy(mctx, &k);
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &rrsig, NULL);
goto cleanup_node;
}
- DNS_RDATASETITER_FOREACH (iter) {
+ DNS_RDATASETITER_FOREACH(iter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatatype_t type;
bool flag;
state->state = remove_orphaned;
/* Remove orphaned NSECs and RRSIG NSECs. */
- ISC_LIST_FOREACH (state->diffnames.tuples, 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.
*/
- ISC_LIST_FOREACH (state->diffnames.tuples, 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).
*/
- ISC_LIST_FOREACH (state->diffnames.tuples, 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.
*/
- ISC_LIST_FOREACH (state->affected.tuples, t, link) {
+ ISC_LIST_FOREACH(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.
*/
- ISC_LIST_FOREACH (state->affected.tuples, 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.
*/
- ISC_LIST_FOREACH (state->nsec_diff.tuples, t, link) {
+ ISC_LIST_FOREACH(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. */
- ISC_LIST_FOREACH (state->nsec_mindiff.tuples, t, link) {
+ ISC_LIST_FOREACH(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. */
- ISC_LIST_FOREACH (state->sig_diff.tuples, t, link) {
+ ISC_LIST_FOREACH(state->sig_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->sig_diff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
- ISC_LIST_FOREACH (state->nsec_mindiff.tuples, t, link) {
+ ISC_LIST_FOREACH(state->nsec_mindiff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
FALLTHROUGH;
case process_nsec3:
state->state = process_nsec3;
- ISC_LIST_FOREACH (state->affected.tuples, t, link) {
+ ISC_LIST_FOREACH(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.
*/
- ISC_LIST_FOREACH (state->nsec_diff.tuples, t, link) {
+ ISC_LIST_FOREACH(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. */
- ISC_LIST_FOREACH (state->nsec_mindiff.tuples, t, link) {
+ ISC_LIST_FOREACH(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. */
- ISC_LIST_FOREACH (state->sig_diff.tuples, t, link) {
+ ISC_LIST_FOREACH(state->sig_diff.tuples, t, link) {
ISC_LIST_UNLINK(state->sig_diff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
- ISC_LIST_FOREACH (state->nsec_mindiff.tuples, t, link) {
+ ISC_LIST_FOREACH(state->nsec_mindiff.tuples, t, link) {
ISC_LIST_UNLINK(state->nsec_mindiff.tuples, t, link);
dns_diff_appendminimal(diff, &t);
}
dns_fixedname_init(&fixed);
dns_name_downcase(name, dns_fixedname_name(&fixed));
name = dns_fixedname_name(&fixed);
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_ncache_current(rdataset, &nsec3name, &set);
if (set.type != dns_rdatatype_nsec3) {
dns_rdataset_disassociate(&set);
dns_rdataset_disassociate(&set);
continue;
}
- DNS_RDATASET_FOREACH (&set) {
+ DNS_RDATASET_FOREACH(&set) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&set, &rdata);
(void)dns_rdata_tostruct(&rdata, &nsec3, NULL);
return DNS_R_NOKEYMATCH;
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t keyrdata = DNS_RDATA_INIT;
dns_rdata_dnskey_t key;
dns_rdata_rrsig_t sig;
RUNTIME_CHECK(result == ISC_R_SUCCESS);
keytag = compute_keytag(&keyrdata);
- DNS_RDATASET_FOREACH (sigrdataset) {
+ DNS_RDATASET_FOREACH(sigrdataset) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
dst_key_t *dstkey = NULL;
dns_rdataset_clone(val->sigrdataset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
* DNS_DSDIGEST_SHA256 or DNS_DSDIGEST_SHA384 is present.
*/
val->digest_sha1 = true;
- DNS_RDATASET_FOREACH (val->dsset) {
+ DNS_RDATASET_FOREACH(val->dsset) {
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdataset_current(val->dsset, &dsrdata);
result = dns_rdata_tostruct(&dsrdata, &ds, NULL);
uint16_t key_tag = 0;
uint8_t algorithm = 0;
- DNS_RDATASET_FOREACH (dsrdataset) {
+ DNS_RDATASET_FOREACH(dsrdataset) {
isc_result_t result;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t keyrdata = DNS_RDATA_INIT;
dns_catz_zones_shutdown(view->catzs);
dns_catz_zones_detach(&view->catzs);
}
- ISC_LIST_FOREACH (view->dlz_searched, dlzdb, link) {
+ ISC_LIST_FOREACH(view->dlz_searched, dlzdb, link) {
ISC_LIST_UNLINK(view->dlz_searched, dlzdb, link);
dns_dlzdestroy(&dlzdb);
}
- ISC_LIST_FOREACH (view->dlz_unsearched, dlzdb, link) {
+ ISC_LIST_FOREACH(view->dlz_unsearched, dlzdb, link) {
ISC_LIST_UNLINK(view->dlz_unsearched, dlzdb, link);
dns_dlzdestroy(&dlzdb);
}
dns_rdataclass_t rdclass, dns_view_t **viewp) {
REQUIRE(list != NULL);
- ISC_LIST_FOREACH (*list, view, link) {
+ ISC_LIST_FOREACH(*list, view, link) {
if (strcmp(view->name, name) == 0 && view->rdclass == rdclass) {
dns_view_attach(view, viewp);
return ISC_R_SUCCESS;
REQUIRE(list != NULL);
REQUIRE(zonep != NULL && *zonep == NULL);
- ISC_LIST_FOREACH (*list, view, link) {
+ ISC_LIST_FOREACH(*list, view, link) {
dns_zt_t *zonetable = NULL;
if (!allclasses && view->rdclass != rdclass) {
continue;
goto finish;
}
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
dns_rdata_t this = DNS_RDATA_INIT;
dns_rdataset_current(&dsset, &this);
if (dns_rdata_compare(&rdata, &this) == 0) {
/* count the number of labels in the name */
namelabels = dns_name_countlabels(name);
- ISC_LIST_FOREACH (view->dlz_searched, dlzdb, link) {
+ ISC_LIST_FOREACH(view->dlz_searched, dlzdb, link) {
REQUIRE(DNS_DLZ_VALID(dlzdb));
/*
goto failure;
}
- MSG_SECTION_FOREACH (msg, DNS_SECTION_QUESTION, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_QUESTION, name) {
dns_rdataset_t *rds = NULL;
LIBDNS_XFRIN_RECV_QUESTION(xfr, xfr->info, msg);
goto failure;
}
- MSG_SECTION_FOREACH (msg, DNS_SECTION_ANSWER, name) {
+ MSG_SECTION_FOREACH(msg, DNS_SECTION_ANSWER, name) {
LIBDNS_XFRIN_RECV_ANSWER(xfr, xfr->info, msg);
- ISC_LIST_FOREACH (name->list, rds, link) {
- DNS_RDATASET_FOREACH (rds) {
+ ISC_LIST_FOREACH(name->list, rds, link) {
+ DNS_RDATASET_FOREACH(rds) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rds, &rdata);
CHECK(xfr_rr(xfr, name, rds->ttl, &rdata));
static void
clear_keylist(dns_dnsseckeylist_t *list, isc_mem_t *mctx) {
- ISC_LIST_FOREACH (*list, key, link) {
+ ISC_LIST_FOREACH(*list, key, link) {
ISC_LIST_UNLINK(*list, key, link);
dns_dnsseckey_destroy(mctx, &key);
}
INSIST(zone->prev_view == NULL);
/* Unmanaged objects */
- ISC_LIST_FOREACH (zone->setnsec3param_queue, npe, link) {
+ ISC_LIST_FOREACH(zone->setnsec3param_queue, npe, link) {
ISC_LIST_UNLINK(zone->setnsec3param_queue, npe, link);
isc_mem_put(zone->mctx, npe, sizeof(*npe));
}
- ISC_LIST_FOREACH (zone->signing, signing, link) {
+ ISC_LIST_FOREACH(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);
}
- ISC_LIST_FOREACH (zone->nsec3chain, nsec3chain, link) {
+ ISC_LIST_FOREACH(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);
}
- ISC_LIST_FOREACH (zone->includes, include, link) {
+ ISC_LIST_FOREACH(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);
}
- ISC_LIST_FOREACH (zone->newincludes, include, link) {
+ ISC_LIST_FOREACH(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);
return true;
}
- ISC_LIST_FOREACH (zone->includes, 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)
dns_dlzdb_t *dlzdb = NULL;
dns_dlzfindzone_t findzone;
- ISC_LIST_FOREACH (zone->view->dlz_unsearched, d, link) {
+ 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;
/*
* Suppress duplicates.
*/
- ISC_LIST_FOREACH (zone->newincludes, inc, link) {
+ ISC_LIST_FOREACH(zone->newincludes, inc, link) {
if (strcmp(filename, inc->name) == 0) {
return;
}
}
dns_rdataset_init(&tmprdataset);
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata1 = DNS_RDATA_INIT;
unsigned int count2 = 0;
count1++;
dns_rdataset_current(rdataset, &rdata1);
dns_rdataset_clone(rdataset, &tmprdataset);
- DNS_RDATASET_FOREACH (&tmprdataset) {
+ DNS_RDATASET_FOREACH(&tmprdataset) {
dns_rdata_t rdata2 = DNS_RDATA_INIT;
count2++;
if (count1 >= count2) {
return true;
}
- DNS_DBITERATOR_FOREACH (dbiterator) {
+ DNS_DBITERATOR_FOREACH(dbiterator) {
result = dns_dbiterator_current(dbiterator, &node, name);
if (result != ISC_R_SUCCESS) {
continue;
continue;
}
- DNS_RDATASETITER_FOREACH (rdsit) {
+ DNS_RDATASETITER_FOREACH(rdsit) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsit, &rdataset);
if (!zone_rrset_check_dup(zone, name, &rdataset)) {
return true;
}
- DNS_DBITERATOR_FOREACH (dbiterator) {
+ DNS_DBITERATOR_FOREACH(dbiterator) {
result = dns_dbiterator_current(dbiterator, &node, name);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
memset(logged_algorithm, 0, sizeof(logged_algorithm));
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_key_t key;
dns_rdataset_current(&rdataset, &rdata);
*/
dns_name_copy(name, bottom);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
memset(logged_algorithm, 0, sizeof(logged_algorithm));
memset(logged_digest_type, 0, sizeof(logged_digest_type));
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
dns_rdata_ds_t ds;
if (result != ISC_R_SUCCESS) {
goto checksrv;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (result != ISC_R_SUCCESS) {
goto checkforaaaa;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (result != ISC_R_SUCCESS) {
goto notxt;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
char algbuf[DNS_SECALG_FORMATSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dst_algorithm_t alg;
* currently being processed, interrupt its processing to avoid
* simultaneously adding and removing records for the same NSEC3 chain.
*/
- ISC_LIST_FOREACH (zone->nsec3chain, current, link) {
+ ISC_LIST_FOREACH(zone->nsec3chain, current, link) {
if ((current->db == db) &&
(current->nsec3param.hash == nsec3param->hash) &&
(current->nsec3param.iterations ==
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t private = DNS_RDATA_INIT;
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
dns_name_t *name, dns_rdataset_t *rdataset) {
isc_result_t uresult;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
uresult = update_one_rr(db, ver, diff, DNS_DIFFOP_DEL, name, 0,
}
/* Now insert all the accepted trust anchors from this keydata set. */
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
* legitimate data, in which case we will not use it, and we
* will try to refresh it.
*/
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
isc_result_t iresult;
dns_rdata_t rdata = DNS_RDATA_INIT;
static void
process_zone_setnsec3param(dns_zone_t *zone) {
- ISC_LIST_FOREACH (zone->setnsec3param_queue, npe, link) {
+ ISC_LIST_FOREACH(zone->setnsec3param_queue, npe, link) {
ISC_LIST_UNLINK(zone->setnsec3param_queue, npe, link);
zone_iattach(zone, &npe->zone);
isc_async_run(zone->loop, setnsec3param, npe);
/*
* Clear old include list.
*/
- ISC_LIST_FOREACH (zone->includes, inc, link) {
+ ISC_LIST_FOREACH(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.
*/
- ISC_LIST_FOREACH (zone->newincludes, inc, link) {
+ ISC_LIST_FOREACH(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);
}
- ISC_LIST_FOREACH (zone->newincludes, inc, link) {
+ ISC_LIST_FOREACH(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));
goto invalidate_rdataset;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
if (errors != NULL && zone->rdclass == dns_rdataclass_in &&
(zone->type == dns_zone_primary ||
zone->type == dns_zone_secondary ||
goto invalidate_rdataset;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
DST_TYPE_PUBLIC | DST_TYPE_PRIVATE | DST_TYPE_STATE,
directory, mctx, &foundkey);
} else {
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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);
}
/* Add new 'dnskeys' to 'keys'. */
- ISC_LIST_FOREACH (dnskeys, k1, link) {
+ ISC_LIST_FOREACH(dnskeys, k1, link) {
bool match = false;
- ISC_LIST_FOREACH (*keys, k2, link) {
+ ISC_LIST_FOREACH(*keys, k2, link) {
if (dst_key_compare(k1->key, k2->key)) {
match = true;
break;
if (node != NULL) {
dns_db_detachnode(&node);
}
- ISC_LIST_FOREACH (dnskeys, key, link) {
+ ISC_LIST_FOREACH(dnskeys, key, link) {
ISC_LIST_UNLINK(dnskeys, key, link);
dns_dnsseckey_destroy(dns_zone_getmctx(zone), &key);
}
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dst_algorithm_t algorithm;
INSIST(!dns_rdataset_isassociated(&rdataset));
return false;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &rrsig, NULL);
bool approved;
KASP_LOCK(kasp);
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
+ ISC_LIST_FOREACH(dns_kasp_keys(kasp), kkey, link) {
if (dns_kasp_key_algorithm(kkey) != dst_key_alg(key)) {
continue;
}
return result;
}
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iterator, &rdataset);
switch (rdataset.type) {
isc_buffer_init(&buffer, data, sizeof(data));
seen_rr = seen_soa = seen_ns = seen_nsec = seen_nsec3 = seen_ds = false;
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
dns_rdatasetiter_current(iterator, &rdataset);
if (rdataset.type == dns_rdatatype_soa) {
seen_soa = true;
}
}
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
isc_stdtime_t when;
if (dns_rdataset_isassociated(&rdataset)) {
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
unsigned char alg = dst_algorithm_tosecalg(signing->algorithm);
/*
* Delete all NSEC3PARAM records which match that in nsec3chain.
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &nsec3param, NULL));
* Restore any NSEC3PARAM records that we deleted to change the TTL.
*/
if (rdataset.ttl != ttl) {
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &nsec3param, NULL));
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t private = DNS_RDATA_INIT;
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
return result;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
return result;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
}
bool active = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &myparam, NULL));
}
seen_soa = seen_ns = seen_dname = seen_ds = seen_nsec = false;
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iterator, &rdataset);
INSIST(rdataset.type != dns_rdatatype_nsec3);
seen_soa = seen_ns = seen_dname = seen_nsec3 = seen_nsec =
seen_rr = false;
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iterator, &rdataset);
if (rdataset.type == dns_rdatatype_soa) {
isc_result_totext(result));
goto failure;
}
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iterator, &rdataset);
if (rdataset.type == dns_rdatatype_nsec) {
* Pause all iterators so that dns_db_closeversion() can succeed.
*/
LOCK_ZONE(zone);
- ISC_LIST_FOREACH (zone->nsec3chain, chain, link) {
+ ISC_LIST_FOREACH(zone->nsec3chain, chain, link) {
dns_dbiterator_pause(chain->dbiterator);
}
UNLOCK_ZONE(zone);
/*
* Everything succeeded so we can clean these up now.
*/
- ISC_LIST_FOREACH (cleanup, chain, link) {
+ ISC_LIST_FOREACH(cleanup, chain, link) {
ISC_LIST_UNLINK(cleanup, chain, link);
dns_db_detach(&chain->db);
dns_dbiterator_destroy(&chain->dbiterator);
/*
* Rollback the cleanup list.
*/
- ISC_LIST_FOREACH_REV (cleanup, chain, link) {
+ ISC_LIST_FOREACH_REV(cleanup, chain, link) {
ISC_LIST_UNLINK(cleanup, chain, link);
if (chain->done) {
dns_db_detach(&chain->db);
}
LOCK_ZONE(zone);
- ISC_LIST_FOREACH (zone->nsec3chain, chain, link) {
+ ISC_LIST_FOREACH(zone->nsec3chain, chain, link) {
dns_dbiterator_pause(chain->dbiterator);
}
UNLOCK_ZONE(zone);
}
dns_rdataset_init(&rdataset);
- DNS_RDATASETITER_FOREACH (iterator) {
+ DNS_RDATASETITER_FOREACH(iterator) {
bool has_alg = false;
dns_rdatasetiter_current(iterator, &rdataset);
if (nkeys == 0 && rdataset.type == dns_rdatatype_nsec) {
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
CHECK(update_one_rr(db, version, diff,
dns_rdataset_disassociate(&rdataset);
continue;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dst_algorithm_t sigalg;
/* Scan the tuples for an NSEC-only DNSKEY */
if (diff != NULL) {
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
if (nseconly && nsec3) {
break;
}
/*
* Pause all iterators so that dns_db_closeversion() can succeed.
*/
- ISC_LIST_FOREACH (zone->signing, s, link) {
+ ISC_LIST_FOREACH(zone->signing, s, link) {
dns_dbiterator_pause(s->dbiterator);
}
- ISC_LIST_FOREACH (cleanup, s, link) {
+ ISC_LIST_FOREACH(cleanup, s, link) {
dns_dbiterator_pause(s->dbiterator);
}
/*
* Everything succeeded so we can clean these up now.
*/
- ISC_LIST_FOREACH (cleanup, s, link) {
+ ISC_LIST_FOREACH(cleanup, s, link) {
ISC_LIST_UNLINK(cleanup, s, link);
dns_db_detach(&s->db);
dns_dbiterator_destroy(&s->dbiterator);
/*
* Pause all dbiterators.
*/
- ISC_LIST_FOREACH (zone->signing, s, link) {
+ ISC_LIST_FOREACH(zone->signing, s, link) {
dns_dbiterator_pause(s->dbiterator);
}
/*
* Rollback the cleanup list.
*/
- ISC_LIST_FOREACH (cleanup, s, link) {
+ ISC_LIST_FOREACH(cleanup, s, link) {
ISC_LIST_UNLINK(cleanup, s, link);
ISC_LIST_PREPEND(zone->signing, s, link);
dns_dbiterator_first(s->dbiterator);
return false;
}
- DNS_RDATASET_FOREACH (rdset) {
+ DNS_RDATASET_FOREACH(rdset) {
unsigned char data2[4096];
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t rdata2 = DNS_RDATA_INIT;
name = dns_fixedname_name(&kfetch->name);
- DNS_RDATASET_FOREACH (&kfetch->keydataset) {
+ DNS_RDATASET_FOREACH(&kfetch->keydataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&kfetch->keydataset, &rdata);
}
/* See if that key generated any of the signatures */
- DNS_RDATASET_FOREACH (&kfetch->dnskeysigset) {
+ DNS_RDATASET_FOREACH(&kfetch->dnskeysigset) {
dns_rdata_t sigrr = DNS_RDATA_INIT;
dns_fixedname_t fixed;
dns_fixedname_init(&fixed);
*/
dns_rdataset_init(&dsset);
if (dns_keynode_dsset(keynode, &dsset)) {
- DNS_RDATASET_FOREACH (dnskeysigs) {
+ DNS_RDATASET_FOREACH(dnskeysigs) {
isc_result_t tresult = ISC_R_NOTFOUND;
dns_rdata_t keyrdata = DNS_RDATA_INIT;
dns_rdata_t sigrr = DNS_RDATA_INIT;
dns_rdataset_current(dnskeysigs, &sigrr);
dns_rdata_tostruct(&sigrr, &sig, NULL);
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
* updated
*/
initializing = true;
- DNS_RDATASET_FOREACH (keydataset) {
+ DNS_RDATASET_FOREACH(keydataset) {
dns_keytag_t keytag;
dns_rdata_reset(&keydatarr);
* - All keys not being removed have their refresh
* timers updated
*/
- DNS_RDATASET_FOREACH (dnskeys) {
+ DNS_RDATASET_FOREACH(dnskeys) {
dns_rdata_t dnskeyrr = DNS_RDATA_INIT;
bool revoked = false;
bool newkey = false;
* Scan the stored keys looking for ones that need
* removal or refreshing
*/
- DNS_RDATASET_FOREACH (kdset) {
+ DNS_RDATASET_FOREACH(kdset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(kdset, &rdata);
result = dns_rdata_tostruct(&rdata, &kd, NULL);
REQUIRE(LOCKED_ZONE(zone));
- ISC_LIST_FOREACH (zone->notifies, notify, link) {
+ ISC_LIST_FOREACH(zone->notifies, notify, link) {
if (notify->find != NULL) {
dns_adb_cancelfind(notify->find);
}
REQUIRE(LOCKED_ZONE(zone));
- ISC_LIST_FOREACH (zone->checkds_requests, checkds, link) {
+ ISC_LIST_FOREACH(zone->checkds_requests, checkds, link) {
if (checkds->find != NULL) {
dns_adb_cancelfind(checkds->find);
}
REQUIRE(LOCKED_ZONE(zone));
- ISC_LIST_FOREACH (zone->forwards, forward, link) {
+ ISC_LIST_FOREACH(zone->forwards, forward, link) {
if (forward->request != NULL) {
dns_request_cancel(forward->request);
}
dns_zonemgr_t *zmgr = NULL;
isc_result_t result;
- ISC_LIST_FOREACH (zone->notifies, n, link) {
+ ISC_LIST_FOREACH(zone->notifies, n, link) {
if (n->request != NULL) {
continue;
}
return;
}
- ISC_LIST_FOREACH (notify->find->list, ai, publink) {
+ ISC_LIST_FOREACH(notify->find->list, ai, publink) {
dst = ai->sockaddr;
if (notify_isqueued(notify->zone, notify->flags, NULL, &dst,
NULL, NULL))
goto cleanup3;
}
- DNS_RDATASET_FOREACH (&nsrdset) {
+ DNS_RDATASET_FOREACH(&nsrdset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&nsrdset, &rdata);
/*
* Add glue rdatasets.
*/
- DNS_RDATASET_FOREACH (nsrdataset) {
+ DNS_RDATASET_FOREACH(nsrdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(nsrdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &ns, NULL);
* for each NS entry found in the answer.
*/
if (!has_glue) {
- ISC_LIST_FOREACH (ns_list, ns_name, link) {
+ ISC_LIST_FOREACH(ns_list, ns_name, link) {
/*
* Resolve NS IPv4 address/A.
*/
result = ISC_R_SUCCESS;
done:
- ISC_LIST_FOREACH (ns_list, ns_name, link) {
+ ISC_LIST_FOREACH(ns_list, ns_name, link) {
ISC_LIST_UNLINK(ns_list, ns_name, link);
dns_name_free(ns_name, cb_args->stub->mctx);
isc_mem_put(cb_args->stub->mctx, ns_name, sizeof(*ns_name));
message_count(dns_message_t *msg, dns_section_t section, dns_rdatatype_t type) {
int count = 0;
- MSG_SECTION_FOREACH (msg, section, name) {
- ISC_LIST_FOREACH_REV (name->list, curr, link) {
+ MSG_SECTION_FOREACH(msg, section, name) {
+ ISC_LIST_FOREACH_REV(name->list, curr, link) {
if (curr->type == type) {
count++;
}
return result;
}
- ISC_LIST_FOREACH (*keylist, k, link) {
+ ISC_LIST_FOREACH(*keylist, k, link) {
if (dst_key_pubcompare(k->key, dstkey, false)) {
*inuse = true;
break;
return result;
}
- ISC_LIST_FOREACH (*keylist, k, link) {
+ ISC_LIST_FOREACH(*keylist, k, link) {
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
unsigned char keybuf[DST_KEY_MAXSIZE];
return result;
}
- ISC_LIST_FOREACH (*keylist, 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];
break;
}
- ISC_LIST_FOREACH (keylist, key, link) {
+ ISC_LIST_FOREACH(keylist, key, link) {
ISC_LIST_UNLINK(keylist, key, link);
dns_dnsseckey_destroy(mctx, &key);
}
dns_db_detachnode(&node);
}
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
dns_difftuplelist_t *al = &add, *dl = &del;
/*
* is why we use an nsec3list, even though we will usually only
* have one).
*/
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t private = DNS_RDATA_INIT;
* using dns_nsec3param_fromprivate(), do the right thing based on
* CREATE and REMOVE flags
*/
- DNS_RDATASET_FOREACH (&prdataset) {
+ DNS_RDATASET_FOREACH(&prdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t private = DNS_RDATA_INIT;
*/
rdata.data[1] = 0;
- ISC_LIST_FOREACH (*nsec3list, nsec3p, link) {
+ ISC_LIST_FOREACH(*nsec3list, nsec3p, link) {
if (nsec3p->length ==
(unsigned int)rdata.length + 1 &&
memcmp(rdata.data, nsec3p->data + 1,
* and CREATE flags, and the add the record to the apex of the tree
* in db.
*/
- ISC_LIST_FOREACH (*nsec3list, nsec3p, link) {
+ ISC_LIST_FOREACH(*nsec3list, nsec3p, link) {
dns_rdata_init(&rdata);
nsec3p->data[2] = DNS_NSEC3FLAG_CREATE | DNS_NSEC3FLAG_INITIAL;
rdata.length = nsec3p->length;
goto cleanup;
}
- DNS_RDATASETITER_FOREACH (rdsit) {
+ DNS_RDATASETITER_FOREACH(rdsit) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsit, &rdataset);
if (rdataset.type == dns_rdatatype_nsec ||
goto failure;
}
- DNS_DBITERATOR_FOREACH (dbiterator) {
+ DNS_DBITERATOR_FOREACH(dbiterator) {
result = copy_non_dnssec_records(db, version, rawdb, dbiterator,
oldserialp);
if (result != ISC_R_SUCCESS) {
REQUIRE(DNS_ZONEMGR_VALID(zmgr));
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- ISC_LIST_FOREACH (zmgr->zones, zone, link) {
+ ISC_LIST_FOREACH(zmgr->zones, zone, link) {
isc_time_t now;
LOCK_ZONE(zone);
}
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
- ISC_LIST_FOREACH (zmgr->zones, 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) {
- ISC_LIST_FOREACH (zmgr->waiting_for_xfrin, zone, statelink) {
+ ISC_LIST_FOREACH(zmgr->waiting_for_xfrin, zone, statelink) {
isc_result_t result;
result = zmgr_start_xfrin_ifquota(zmgr, zone);
if (result == ISC_R_SUCCESS) {
* out to be too slow, we could hash on the primary address.
*/
nxfrsin = nxfrsperns = 0;
- ISC_LIST_FOREACH (zmgr->xfrin_in_progress, x, statelink) {
+ ISC_LIST_FOREACH(zmgr->xfrin_in_progress, x, statelink) {
isc_netaddr_t xip;
isc_sockaddr_t xaddr;
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
switch (state) {
case DNS_ZONESTATE_XFERRUNNING:
- ISC_LIST_FOREACH (zmgr->xfrin_in_progress, zone, statelink) {
+ ISC_LIST_FOREACH(zmgr->xfrin_in_progress, zone, statelink) {
count++;
}
break;
case DNS_ZONESTATE_XFERDEFERRED:
- ISC_LIST_FOREACH (zmgr->waiting_for_xfrin, zone, statelink) {
+ ISC_LIST_FOREACH(zmgr->waiting_for_xfrin, zone, statelink) {
count++;
}
break;
case DNS_ZONESTATE_XFERFIRSTREFRESH:
- ISC_LIST_FOREACH (zmgr->zones, zone, link) {
+ ISC_LIST_FOREACH(zmgr->zones, zone, link) {
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_FIRSTREFRESH)) {
count++;
}
}
break;
case DNS_ZONESTATE_SOAQUERY:
- ISC_LIST_FOREACH (zmgr->zones, zone, link) {
+ ISC_LIST_FOREACH(zmgr->zones, zone, link) {
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_REFRESH)) {
count++;
}
}
break;
case DNS_ZONESTATE_ANY:
- ISC_LIST_FOREACH (zmgr->zones, 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:
- ISC_LIST_FOREACH (zmgr->zones, zone, link) {
+ ISC_LIST_FOREACH(zmgr->zones, zone, link) {
dns_view_t *view = zone->view;
if (view != NULL && strcmp(view->name, "_bind") == 0) {
continue;
dns_db_attach(db, &signing->db);
- ISC_LIST_FOREACH (zone->signing, current, link) {
+ ISC_LIST_FOREACH(zone->signing, current, link) {
if (current->db == signing->db &&
current->algorithm == signing->algorithm &&
current->keyid == signing->keyid)
}
bool matched = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t myrdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &myrdata);
if (dns_rdata_compare(&myrdata, rdata) == 0) {
* Move non DNSKEY and not DNSSEC DNSKEY records to tuples
* and sort the remaining DNSKEY records to add and del.
*/
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(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.
*/
- ISC_LIST_FOREACH (del, deltuple, link) {
- ISC_LIST_FOREACH (add, addtuple, link) {
+ ISC_LIST_FOREACH(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.
*/
- ISC_LIST_FOREACH (tuples, tuple, link) {
+ ISC_LIST_FOREACH(tuples, tuple, link) {
dst_algorithm_t algorithm;
dns_rdata_toregion(&tuple->rdata, &r);
isc_result_t result;
bool apexsig = false;
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
if (tuple->rdata.type == rrtype &&
dns_name_equal(&tuple->name, &zone->origin))
{
return false;
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t rrsig;
/* Lookup DS RRset. */
- MSG_SECTION_FOREACH (message, DNS_SECTION_ANSWER, name) {
+ MSG_SECTION_FOREACH(message, DNS_SECTION_ANSWER, name) {
if (dns_name_compare(&zone->origin, name) != 0) {
continue;
}
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (rdataset->type != dns_rdatatype_ds) {
goto next;
}
KASP_LOCK(kasp);
LOCK_ZONE(zone);
- ISC_LIST_FOREACH (zone->checkds_ok, 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;
}
/* Find the appropriate DS record. */
- DNS_RDATASET_FOREACH (ds_rrset) {
+ DNS_RDATASET_FOREACH(ds_rrset) {
dns_rdata_ds_t ds;
dns_rdata_t dnskey = DNS_RDATA_INIT;
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_db_detach(&db);
}
- ISC_LIST_FOREACH (keys, key, link) {
+ ISC_LIST_FOREACH(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) {
- ISC_LIST_FOREACH (zone->checkds_requests, checkds, link) {
+ ISC_LIST_FOREACH(zone->checkds_requests, checkds, link) {
if (checkds->request != NULL) {
continue;
}
return;
}
- ISC_LIST_FOREACH (checkds->find->list, ai, publink) {
+ ISC_LIST_FOREACH(checkds->find->list, ai, publink) {
dst = ai->sockaddr;
if (checkds_isqueued(zone, NULL, &dst, NULL, NULL)) {
continue;
UNLOCK_ZONE(zone);
/* Look up the addresses for the found parental name servers. */
- DNS_RDATASET_FOREACH (nsrrset) {
+ DNS_RDATASET_FOREACH(nsrrset) {
dns_checkds_t *checkds = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_ns_t ns;
return;
}
- ISC_LIST_FOREACH (zone->checkds_ok, 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;
/*
* Delete everything using the existing TTL.
*/
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_difftuple_t *tuple = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
/*
* Add everything using the new TTL.
*/
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_difftuple_t *tuple = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
/*
* Make sure that the existing keys are also present in the new keylist.
*/
- ISC_LIST_FOREACH (zone->keyring, key1, link) {
+ ISC_LIST_FOREACH(zone->keyring, key1, link) {
bool found = false;
if (dst_key_is_unused(key1->key)) {
continue;
}
- ISC_LIST_FOREACH (*newkeys, key2, link) {
+ ISC_LIST_FOREACH(*newkeys, key2, link) {
if (dst_key_compare(key1->key, key2->key)) {
found = true;
break;
return;
}
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_difftuple_t *tuple = NULL;
remove_rdataset(zone, diff, cdnskeyset);
/* Add the records from the bundle. */
- ISC_LIST_FOREACH (bundle->diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(bundle->diff.tuples, tuple, link) {
switch (tuple->rdata.type) {
case dns_rdatatype_dnskey:
add_tuple(diff, tuple);
} else {
/* Check if there is a CDS DELETE record. */
if (dns_rdataset_isassociated(&cdsset)) {
- DNS_RDATASET_FOREACH (&cdsset) {
+ DNS_RDATASET_FOREACH(&cdsset) {
dns_rdata_t crdata = DNS_RDATA_INIT;
dns_rdataset_current(&cdsset, &crdata);
/*
/* Check if there is a CDNSKEY DELETE record. */
if (dns_rdataset_isassociated(&cdnskeyset)) {
- DNS_RDATASET_FOREACH (&cdnskeyset) {
+ DNS_RDATASET_FOREACH(&cdnskeyset) {
dns_rdata_t crdata = DNS_RDATA_INIT;
dns_rdataset_current(&cdnskeyset,
&crdata);
* published and is used for signing.
*/
bool allow = false;
- ISC_LIST_FOREACH (dnskeys, 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.)
*/
- ISC_LIST_FOREACH (dnskeys, key, link) {
+ ISC_LIST_FOREACH(dnskeys, key, link) {
if (!key->first_sign) {
continue;
}
zone_settimer(zone, &timenow);
/* Remove any signatures from removed keys. */
- ISC_LIST_FOREACH (rmkeys, key, link) {
+ 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) {
* "rndc sign" was called, so we now sign the zone
* with all active keys, whether they're new or not.
*/
- ISC_LIST_FOREACH (dnskeys, 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.
*/
- ISC_LIST_FOREACH (dnskeys, 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.
*/
- ISC_LIST_FOREACH (zonediff.diff->tuples, 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;
- ISC_LIST_FOREACH (dnskeys, key, link) {
+ ISC_LIST_FOREACH(dnskeys, key, link) {
then = now;
result = next_keyevent(key->key, &then);
if (result != ISC_R_SUCCESS) {
clear_keylist(&zone->keyring, zone->mctx);
}
- ISC_LIST_FOREACH (dnskeys, key, link) {
+ ISC_LIST_FOREACH(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];
bool logged_digest_type[DNS_DSDIGEST_MAX + 1] = { 0 };
bool delete = false;
memset(algorithms, notexpected, sizeof(algorithms));
- DNS_RDATASET_FOREACH (&cds) {
+ DNS_RDATASET_FOREACH(&cds) {
dns_rdata_t crdata = DNS_RDATA_INIT;
dns_rdata_cds_t structcds;
algorithms[structcds.algorithm] =
expected;
}
- DNS_RDATASET_FOREACH (&dnskey) {
+ DNS_RDATASET_FOREACH(&dnskey) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_dnskey_t structdnskey;
if (dns_rdataset_isassociated(&cdnskey)) {
bool delete = false;
memset(algorithms, notexpected, sizeof(algorithms));
- DNS_RDATASET_FOREACH (&cdnskey) {
+ DNS_RDATASET_FOREACH(&cdnskey) {
dns_rdata_t crdata = DNS_RDATA_INIT;
dns_rdata_cdnskey_t structcdnskey;
dst_algorithm_t cdnskeyalg;
if (algorithms[cdnskeyalg] == 0) {
algorithms[cdnskeyalg] = expected;
}
- DNS_RDATASET_FOREACH (&dnskey) {
+ DNS_RDATASET_FOREACH(&dnskey) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_dnskey_t structdnskey;
dst_algorithm_t dnskeyalg;
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
bool found = false;
result = dns_db_findrdataset(db, node, newver, zone->privatetype,
dns_rdatatype_none, 0, &prdataset, NULL);
if (result == ISC_R_SUCCESS) {
- DNS_RDATASET_FOREACH (&prdataset) {
+ DNS_RDATASET_FOREACH(&prdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&prdataset, &rdata);
result = dns_db_findrdataset(db, node, newver, dns_rdatatype_nsec3param,
dns_rdatatype_none, 0, &nrdataset, NULL);
if (result == ISC_R_SUCCESS) {
- DNS_RDATASET_FOREACH (&nrdataset) {
+ DNS_RDATASET_FOREACH(&nrdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&nrdataset, &rdata);
}
result = ISC_R_NOTFOUND;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
dns_rdata_tostruct(&rdata, &nsec3param, NULL);
}
array = isc_mem_allocate(zone->mctx, sizeof(char *) * zone->nincludes);
- ISC_LIST_FOREACH (zone->includes, include, link) {
+ ISC_LIST_FOREACH(zone->includes, include, link) {
INSIST(n < zone->nincludes);
array[n++] = isc_mem_strdup(zone->mctx, include->name);
}
isc_result_totext(result));
return result;
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &sigrdataset);
if (sigrdataset.type == dns_rdatatype_rrsig &&
sigrdataset.covers == rdataset->type)
/*
* Find matching NSEC3 record.
*/
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(rdataset, &rdata);
dns_rdata_tostruct(&rdata, nsec3_match, NULL);
dns_rdata_nsec3param_t nsec3param;
isc_result_t result;
- DNS_RDATASET_FOREACH (nsec3paramset) {
+ DNS_RDATASET_FOREACH(nsec3paramset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(nsec3paramset, &rdata);
goto cleanup;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &nsec3, NULL);
isc_result_t *vresult) {
isc_result_t result = ISC_R_NOMORE;
- DNS_RDATASET_FOREACH (nsec3paramset) {
+ DNS_RDATASET_FOREACH(nsec3paramset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(nsec3paramset, &rdata);
isc_result_totext(result));
return result;
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, &sigrdataset);
if (sigrdataset.type == dns_rdatatype_rrsig &&
sigrdataset.covers == rdataset->type)
goto done;
}
- DNS_RDATASET_FOREACH (&sigrdataset) {
+ DNS_RDATASET_FOREACH(&sigrdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t sig;
dst_algorithm_t algorithm;
return result;
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(rdsiter, &rdataset);
*/
dns_rdataset_init(&dsset);
if (dns_keynode_dsset(keynode, &dsset)) {
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
dns_rdata_t dsrdata = DNS_RDATA_INIT;
dns_rdata_t newdsrdata = DNS_RDATA_INIT;
unsigned char buf[DNS_DS_BUFFERSIZE];
isc_result_t result;
bool is_ksk;
- DNS_RDATASET_FOREACH (&vctx->keyset) {
+ DNS_RDATASET_FOREACH(&vctx->keyset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&vctx->keyset, &rdata);
result = dns_rdata_tostruct(&rdata, &dnskey, NULL);
count = dns_rdataset_count(&vctx->keyset);
dstkeys = isc_mem_cget(vctx->mctx, count, sizeof(*dstkeys));
- DNS_RDATASET_FOREACH (&vctx->keyset) {
+ DNS_RDATASET_FOREACH(&vctx->keyset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&vctx->keyset, &rdata);
dstkeys[nkeys] = NULL;
return result;
}
- DNS_DBITERATOR_FOREACH (dbiter) {
+ DNS_DBITERATOR_FOREACH(dbiter) {
result = dns_dbiterator_current(dbiter, &node, name);
if (result != ISC_R_SUCCESS && result != DNS_R_NEWORIGIN) {
zoneverify_log_error(vctx,
* Clear out the list of all actions we know about. Just free the
* memory.
*/
- ISC_LIST_FOREACH (httpdmgr->urls, url, link) {
+ ISC_LIST_FOREACH(httpdmgr->urls, url, link) {
isc_mem_free(httpdmgr->mctx, url->url);
ISC_LIST_UNLINK(httpdmgr->urls, url, link);
isc_mem_put(httpdmgr->mctx, url, sizeof(isc_httpdurl_t));
}
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->urls, u, link) {
+ ISC_LIST_FOREACH(mgr->urls, u, link) {
if (strncmp(path, u->url, path_len) == 0) {
url = u;
break;
LOCK(&httpdmgr->lock);
- ISC_LIST_FOREACH (httpdmgr->running, httpd, link) {
+ ISC_LIST_FOREACH(httpdmgr->running, httpd, link) {
if (httpd->handle != NULL) {
httpd_request(httpd->handle, ISC_R_SUCCESS, NULL,
httpd);
ISC_LIST_MOVE(jobs, loop->run_jobs);
- ISC_LIST_FOREACH (jobs, job, link) {
+ ISC_LIST_FOREACH(jobs, job, link) {
isc_job_cb cb = job->cb;
void *cbarg = job->cbarg;
ISC_LIST_UNLINK(jobs, job, link);
mctx = lcfg->lctx->mctx;
- ISC_LIST_FOREACH (lcfg->channels, channel, link) {
+ ISC_LIST_FOREACH(lcfg->channels, channel, link) {
if (channel->type == ISC_LOG_TOFILE) {
/*
* The filename for the channel may have ultimately
}
for (size_t i = 0; i < ARRAY_SIZE(lcfg->channellists); i++) {
- ISC_LIST_FOREACH (lcfg->channellists[i], item, link) {
+ ISC_LIST_FOREACH(lcfg->channellists[i], item, link) {
ISC_LIST_UNLINK(lcfg->channellists[i], item, link);
isc_mem_put(mctx, item, sizeof(*item));
}
category < ISC_LOGCATEGORY_MAX);
REQUIRE(module >= ISC_LOGMODULE_DEFAULT && module < ISC_LOGMODULE_MAX);
- ISC_LIST_FOREACH (lcfg->channels, c, link) {
+ 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);
- ISC_LIST_FOREACH (lcfg->channels, channel, link) {
+ ISC_LIST_FOREACH(lcfg->channels, channel, link) {
if (channel->type == ISC_LOG_TOFILE &&
(channel->flags & ISC_LOG_DEBUGONLY) != 0 &&
FILE_STREAM(channel) != NULL)
isc_logconfig_t *lcfg = rcu_dereference(isc__lctx->logconfig);
if (lcfg != NULL) {
LOCK(&isc__lctx->lock);
- ISC_LIST_FOREACH (lcfg->channels, channel, link) {
+ ISC_LIST_FOREACH(lcfg->channels, channel, link) {
if (channel->type == ISC_LOG_TOFILE &&
FILE_STREAM(channel) != NULL)
{
#endif
idx = hash % DEBUG_TABLE_COUNT;
- ISC_LIST_FOREACH (mctx->debuglist[idx], dl, link) {
+ ISC_LIST_FOREACH(mctx->debuglist[idx], dl, link) {
if (dl->ptr == ptr) {
ISC_LIST_UNLINK(mctx->debuglist[idx], dl, link);
sdallocx(dl, dl->dlsize, mctx->jemalloc_flags);
#if ISC_MEM_TRACKLINES
if (ctx->debuglist != NULL) {
for (size_t i = 0; i < DEBUG_TABLE_COUNT; i++) {
- ISC_LIST_FOREACH (ctx->debuglist[i], dl, link) {
+ ISC_LIST_FOREACH(ctx->debuglist[i], dl, link) {
if (ctx->checkfree && dl->ptr != NULL) {
print_active(ctx, stderr);
}
"allocations:\n");
found = false;
for (i = 0; i < DEBUG_TABLE_COUNT; i++) {
- ISC_LIST_FOREACH (mctx->debuglist[i], dl, link) {
+ ISC_LIST_FOREACH(mctx->debuglist[i], dl, link) {
found = true;
if (dl->ptr != NULL) {
fprintf(out,
"size", "allocated", "freecount", "freemax",
"fillcount", "gets", "L");
}
- ISC_LIST_FOREACH (ctx->pools, pool, link) {
+ ISC_LIST_FOREACH(ctx->pools, pool, link) {
fprintf(out,
"%15s %10zu %10zu %10zu %10zu %10zu %10zu %10zu %s\n",
pool->name, pool->size, (size_t)0, pool->allocated,
#if ISC_MEM_TRACKLINES
static void
print_contexts(FILE *file) {
- ISC_LIST_FOREACH (contexts, 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));
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "contexts"));
LOCK(&contextslock);
- ISC_LIST_FOREACH (contexts, ctx, link) {
+ ISC_LIST_FOREACH(contexts, ctx, link) {
xmlrc = xml_renderctx(ctx, &inuse, writer);
if (xmlrc < 0) {
UNLOCK(&contextslock);
CHECKMEM(ctxarray);
LOCK(&contextslock);
- ISC_LIST_FOREACH (contexts, ctx, link) {
+ ISC_LIST_FOREACH(contexts, ctx, link) {
result = json_renderctx(ctx, &inuse, ctxarray);
if (result != ISC_R_SUCCESS) {
UNLOCK(&contextslock);
return NULL;
}
- ISC_LIST_FOREACH (session->cstreams, cstream, link) {
+ ISC_LIST_FOREACH(session->cstreams, cstream, link) {
if (cstream->stream_id == stream_id) {
/* LRU-like behaviour */
if (ISC_LIST_HEAD(session->cstreams) != cstream) {
static void
call_pending_callbacks(isc__nm_http_pending_callbacks_t pending_callbacks,
isc_result_t result) {
- ISC_LIST_FOREACH (pending_callbacks, cbreq, link) {
+ ISC_LIST_FOREACH(pending_callbacks, cbreq, link) {
ISC_LIST_UNLINK(pending_callbacks, cbreq, link);
isc__nm_sendcb(cbreq->handle->sock, cbreq, result, true);
}
mctx = eps->mctx;
/* Delete all handlers */
- ISC_LIST_FOREACH (eps->handlers, handler, link) {
+ ISC_LIST_FOREACH(eps->handlers, handler, link) {
ISC_LIST_DEQUEUE(eps->handlers, handler, link);
isc_mem_free(mctx, handler->path);
handler->magic = 0;
return NULL;
}
- ISC_LIST_FOREACH (eps->handlers, handler, link) {
+ ISC_LIST_FOREACH(eps->handlers, handler, link) {
if (!strcmp(request_path, handler->path)) {
INSIST(VALID_HTTP_HANDLER(handler));
INSIST(handler->cb != NULL);
REQUIRE(VALID_HTTP2_SESSION(session));
REQUIRE(result != ISC_R_SUCCESS);
- ISC_LIST_FOREACH (session->cstreams, cstream, link) {
+ ISC_LIST_FOREACH(session->cstreams, cstream, link) {
/*
* read_cb could be NULL if cstream was allocated and added
* to the tracking list, but was not properly initialized due
REQUIRE(VALID_HTTP2_SESSION(session));
REQUIRE(result != ISC_R_SUCCESS);
- ISC_LIST_FOREACH (session->sstreams, h2data, link) {
+ ISC_LIST_FOREACH(session->sstreams, h2data, link) {
failed_httpstream_read_cb(h2data->psock, result, session);
}
- ISC_LIST_FOREACH (session->sstreams, h2data, link) {
+ ISC_LIST_FOREACH(session->sstreams, h2data, link) {
ISC_LIST_DEQUEUE(session->sstreams, h2data, link);
/* Cleanup socket in place */
isc__nmsocket_detach(&sock->outer);
}
- ISC_LIST_FOREACH (sock->inactive_handles, handle, inactive_link) {
+ ISC_LIST_FOREACH(sock->inactive_handles, handle, inactive_link) {
ISC_LIST_DEQUEUE(sock->inactive_handles, handle, inactive_link);
nmhandle_free(sock, handle);
}
STDERR_FILENO);
fprintf(stderr, "\n");
- ISC_LIST_FOREACH (sock->active_handles, handle, active_link) {
+ ISC_LIST_FOREACH(sock->active_handles, handle, active_link) {
static bool first = true;
if (first) {
fprintf(stderr, "Active handles:\n");
isc__nm_dump_active(isc__networker_t *worker) {
bool first = true;
- ISC_LIST_FOREACH (worker->active_sockets, sock, active_link) {
+ ISC_LIST_FOREACH(worker->active_sockets, sock, active_link) {
if (first) {
fprintf(stderr, "Outstanding sockets\n");
first = false;
unlock:
UNLOCK(&rl->lock);
- ISC_LIST_FOREACH (pending, rle, link) {
+ ISC_LIST_FOREACH(pending, rle, link) {
ISC_LIST_UNLINK(pending, rle, link);
isc_async_run(rle->loop, rle->cb, rle->arg);
}
}
UNLOCK(&rl->lock);
- ISC_LIST_FOREACH (pending, rle, link) {
+ ISC_LIST_FOREACH(pending, rle, link) {
ISC_LIST_UNLINK(pending, rle, link);
rle->canceled = true;
isc_async_run(rl->loop, rle->cb, rle->arg);
isc_refcount_destroy(&cache->references);
- ISC_LIST_FOREACH (cache->lru_entries, entry, cache_link) {
+ ISC_LIST_FOREACH(cache->lru_entries, entry, cache_link) {
client_cache_entry_delete(cache, entry);
}
if (isc_refcount_decrement(&actx->references) == 1) {
isc_refcount_destroy(&actx->references);
- ISC_LIST_FOREACH (actx->named_acl_cache, dacl, nextincache) {
+ ISC_LIST_FOREACH(actx->named_acl_cache, dacl, nextincache) {
ISC_LIST_UNLINK(actx->named_acl_cache, dacl,
nextincache);
dns_acl_detach(&dacl);
if (result != ISC_R_SUCCESS) {
return result;
}
- CFG_LIST_FOREACH (acls, elt) {
+ CFG_LIST_FOREACH(acls, elt) {
const cfg_obj_t *acl = cfg_listelt_value(elt);
const char *aclname =
cfg_obj_asstring(cfg_tuple_get(acl, "name"));
const char *aclname = cfg_obj_asstring(nameobj);
/* Look for an already-converted version. */
- ISC_LIST_FOREACH (ctx->named_acl_cache, 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,
SET_IF_NOT_NULL(has_negative, false);
- CFG_LIST_FOREACH (caml, elt) {
+ CFG_LIST_FOREACH(caml, elt) {
const cfg_obj_t *ce = cfg_listelt_value(elt);
/* might be a negated element, in which case get the value. */
}
de = dacl->elements;
- CFG_LIST_FOREACH (caml, elt) {
+ CFG_LIST_FOREACH(caml, elt) {
const cfg_obj_t *ce = cfg_listelt_value(elt);
bool neg = false;
return result;
}
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
tresult = check_orderent(cfg_listelt_value(element));
if (result == ISC_R_SUCCESS && tresult != ISC_R_SUCCESS) {
result = tresult;
}
}
obj = cfg_tuple_get(alternates, "addresses");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
value = cfg_listelt_value(element);
if (cfg_obj_issockaddr(value)) {
continue;
}
faddresses = cfg_tuple_get(forwarders, "addresses");
- CFG_LIST_FOREACH (faddresses, element) {
+ CFG_LIST_FOREACH(faddresses, element) {
const cfg_obj_t *forwarder = cfg_listelt_value(element);
const char *tls = cfg_obj_getsockaddrtls(forwarder);
if (tls != NULL) {
obj = cfg_tuple_get(disabled, "algorithms");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
isc_textregion_t r;
dst_algorithm_t alg;
obj = cfg_tuple_get(disabled, "digests");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
isc_textregion_t r;
dns_dsdigest_t digest;
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (dns64, element) {
+ CFG_LIST_FOREACH(dns64, element) {
map = cfg_listelt_value(element);
obj = cfg_map_getname(map);
return NULL;
}
- CFG_LIST_FOREACH (maplist, elt) {
+ CFG_LIST_FOREACH(maplist, elt) {
const cfg_obj_t *map = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
0)
cfg_aclconfctx_t *actx, isc_mem_t *mctx) {
isc_result_t tresult, result = ISC_R_SUCCESS;
- CFG_LIST_FOREACH (list, elt) {
+ CFG_LIST_FOREACH(list, elt) {
const cfg_obj_t *obj = cfg_listelt_value(elt);
tresult = check_listener(obj, config, actx, mctx);
if (result == ISC_R_SUCCESS) {
result = ISC_R_FAILURE;
}
} else if (cfg_obj_islist(obj)) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
isc_result_t ret;
const char *val = NULL;
cfg_obj_t *kconfig = cfg_listelt_value(element);
ISC_LIST_INIT(list);
if (cfg_obj_islist(obj)) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
isc_result_t ret;
cfg_obj_t *kconfig =
cfg_listelt_value(element);
}
}
- ISC_LIST_FOREACH (list, k, link) {
+ ISC_LIST_FOREACH(list, k, link) {
ISC_LIST_UNLINK(list, k, link);
dns_kasp_detach(&k);
}
/*
* Cleanup key-store.
*/
- ISC_LIST_FOREACH (kslist, ks, link) {
+ ISC_LIST_FOREACH(kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}
obj = NULL;
(void)cfg_map_get(options, "disable-algorithms", &obj);
if (obj != NULL) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
tresult = disabled_algorithms(obj);
if (tresult != ISC_R_SUCCESS) {
obj = NULL;
(void)cfg_map_get(options, "disable-ds-digests", &obj);
if (obj != NULL) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
tresult = disabled_ds_digests(obj);
if (tresult != ISC_R_SUCCESS) {
*/
obj = NULL;
(void)cfg_map_get(options, "disable-empty-zone", &obj);
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
str = cfg_obj_asstring(obj);
if (check_name(str) != ISC_R_SUCCESS) {
if (obj != NULL) {
unsigned char secret[32];
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
unsigned int usedlength;
obj = cfg_listelt_value(element);
if (obj != NULL) {
/* Note: SEC is defined in <sys/time.h> on some platforms. */
enum { MAS = 1, PRI = 2, SLA = 4, SCN = 8 } values = 0;
- CFG_LIST_FOREACH (obj, el) {
+ CFG_LIST_FOREACH(obj, el) {
const cfg_obj_t *tuple = cfg_listelt_value(el);
const cfg_obj_t *type = cfg_tuple_get(tuple, "type");
const char *keyword = cfg_obj_asstring(type);
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (obj, elt) {
+ CFG_LIST_FOREACH(obj, elt) {
char *tmp = NULL;
const char *name = NULL;
/* Check endpoints are valid */
tresult = cfg_map_get(http, "endpoints", &eps);
if (tresult == ISC_R_SUCCESS) {
- CFG_LIST_FOREACH (eps, elt) {
+ CFG_LIST_FOREACH(eps, elt) {
const cfg_obj_t *ep = cfg_listelt_value(elt);
const char *path = cfg_obj_asstring(ep);
if (!isc_nm_http_path_isvalid(path)) {
goto done;
}
- CFG_LIST_FOREACH (obj, elt) {
+ CFG_LIST_FOREACH(obj, elt) {
obj = cfg_listelt_value(elt);
tresult = check_httpserver(obj, symtab);
if (result == ISC_R_SUCCESS) {
tresult = cfg_map_get(tlsobj, "protocols", &tls_proto_list);
if (tresult == ISC_R_SUCCESS) {
INSIST(tls_proto_list != NULL);
- CFG_LIST_FOREACH (tls_proto_list, proto) {
+ CFG_LIST_FOREACH(tls_proto_list, proto) {
const cfg_obj_t *tls_proto_obj =
cfg_listelt_value(proto);
const char *tls_sver = cfg_obj_asstring(tls_proto_obj);
isc_symtab_create(mctx, NULL, NULL, false, &symtab);
- CFG_LIST_FOREACH (obj, elt) {
+ CFG_LIST_FOREACH(obj, elt) {
const char *name;
obj = cfg_listelt_value(elt);
name = cfg_obj_asstring(cfg_map_getname(obj));
return result;
}
- CFG_LIST_FOREACH (obj, elt) {
+ CFG_LIST_FOREACH(obj, elt) {
const char *listname = NULL;
obj = cfg_listelt_value(elt);
}
/* Now check the grant policy */
- CFG_LIST_FOREACH (policy, element) {
+ CFG_LIST_FOREACH(policy, element) {
const cfg_obj_t *stmt = cfg_listelt_value(element);
const cfg_obj_t *identity = cfg_tuple_get(stmt, "identity");
const cfg_obj_t *matchtype = cfg_tuple_get(stmt, "matchtype");
UNREACHABLE();
}
- CFG_LIST_FOREACH (typelist, element2) {
+ CFG_LIST_FOREACH(typelist, element2) {
const cfg_obj_t *typeobj;
const char *bracket;
/*
* Build the keystore list.
*/
- CFG_LIST_FOREACH (keystores, element) {
+ CFG_LIST_FOREACH(keystores, element) {
cfg_obj_t *kcfg = cfg_listelt_value(element);
(void)cfg_keystore_fromconfig(kcfg, mctx, &kslist, NULL);
}
* Look for the dnssec-policy by name, which is the dnssec-policy
* for the zone in question.
*/
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
const cfg_obj_t *kaspobj = NULL;
/* Check key-stores of keys */
dns_kasp_freeze(kasp);
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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);
}
- ISC_LIST_FOREACH (kasplist, k, link) {
+ ISC_LIST_FOREACH(kasplist, k, link) {
ISC_LIST_UNLINK(kasplist, k, link);
dns_kasp_detach(&k);
}
- ISC_LIST_FOREACH (kslist, ks, link) {
+ ISC_LIST_FOREACH(kslist, ks, link) {
ISC_LIST_UNLINK(kslist, ks, link);
dns_keystore_detach(&ks);
}
if (obj != NULL) {
tmplname = cfg_obj_asstring(obj);
- CFG_LIST_FOREACH (templates, e) {
+ CFG_LIST_FOREACH(templates, e) {
const cfg_obj_t *t = cfg_tuple_get(cfg_listelt_value(e),
"name");
if (strcasecmp(cfg_obj_asstring(t), tmplname) == 0) {
} else {
const cfg_obj_t *kasps = NULL;
(void)cfg_map_get(config, "dnssec-policy", &kasps);
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
const cfg_obj_t *kobj = cfg_tuple_get(
cfg_listelt_value(element), "name");
if (strcmp(kaspname, cfg_obj_asstring(kobj)) ==
(void)get_zoneopt(zoptions, toptions, NULL, NULL, "server-addresses",
&obj);
if (ztype == CFG_ZONE_STATICSTUB && obj != NULL) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
isc_sockaddr_t sa;
isc_netaddr_t na;
obj = cfg_listelt_value(element);
obj = NULL;
(void)get_zoneopt(zoptions, toptions, NULL, NULL, "server-names", &obj);
if (zname != NULL && ztype == CFG_ZONE_STATICSTUB && obj != NULL) {
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
const char *snamestr = NULL;
dns_fixedname_t fixed_sname;
isc_buffer_t b2;
isc_result_t tresult;
name = dns_fixedname_initname(&fname);
- CFG_LIST_FOREACH (keys, element) {
+ CFG_LIST_FOREACH(keys, element) {
const cfg_obj_t *key = cfg_listelt_value(element);
const char *keyid = cfg_obj_asstring(cfg_map_getname(key));
isc_symvalue_t symvalue;
return false;
}
- CFG_LIST_FOREACH (keylist, element) {
+ CFG_LIST_FOREACH(keylist, element) {
const cfg_obj_t *obj = cfg_listelt_value(element);
const char *str = cfg_obj_asstring(cfg_map_getname(obj));
if (!strcasecmp(str, keyname)) {
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (servers, e1) {
+ CFG_LIST_FOREACH(servers, e1) {
const cfg_obj_t *v1 = cfg_listelt_value(e1);
isc_netaddr_t n1;
unsigned int p1;
name = dns_fixedname_initname(&fixed);
- CFG_LIST_FOREACH (keylist, elt) {
+ CFG_LIST_FOREACH(keylist, elt) {
const char *initmethod;
const cfg_obj_t *init = NULL;
const cfg_obj_t *obj = cfg_listelt_value(elt);
name = dns_fixedname_initname(&fixed);
- CFG_LIST_FOREACH (keylist, elt) {
+ CFG_LIST_FOREACH(keylist, elt) {
const cfg_obj_t *obj = cfg_listelt_value(elt);
const cfg_obj_t *init = NULL;
const char *str;
name = dns_fixedname_initname(&fixed);
- CFG_LIST_FOREACH (keylist, elt) {
+ CFG_LIST_FOREACH(keylist, elt) {
const char *initmethod;
const cfg_obj_t *init = NULL;
const cfg_obj_t *obj = cfg_listelt_value(elt);
* First we record all the static keys (trust-anchors configured with
* "static-key"), and all the DS-style trust anchors.
*/
- CFG_LIST_FOREACH (global_ta, elt) {
+ CFG_LIST_FOREACH(global_ta, elt) {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
}
}
- CFG_LIST_FOREACH (view_ta, elt) {
+ CFG_LIST_FOREACH(view_ta, elt) {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist,
autovalidation);
* Next, ensure that there's no conflict between the
* static keys and the trust-anchors configured with "initial-key".
*/
- CFG_LIST_FOREACH (global_ta, elt) {
+ CFG_LIST_FOREACH(global_ta, elt) {
keylist = cfg_listelt_value(elt);
tresult = check_initializing_keys(statictab, keylist);
if (result == ISC_R_SUCCESS) {
}
}
- CFG_LIST_FOREACH (view_ta, elt) {
+ CFG_LIST_FOREACH(view_ta, elt) {
keylist = cfg_listelt_value(elt);
tresult = check_initializing_keys(statictab, keylist);
if (result == ISC_R_SUCCESS) {
name = dns_fixedname_initname(&fixed);
obj = cfg_tuple_get(rpz_obj, "zone list");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
nameobj = cfg_tuple_get(obj, "zone name");
zonename = cfg_obj_asstring(nameobj);
obj = cfg_tuple_get(rpz_obj, "zone list");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
obj = cfg_listelt_value(element);
nameobj = cfg_tuple_get(obj, "zone name");
zonename = cfg_obj_asstring(nameobj);
obj = cfg_tuple_get(catz_obj, "zone list");
- CFG_LIST_FOREACH (obj, element) {
+ CFG_LIST_FOREACH(obj, element) {
char namebuf[DNS_NAME_FORMATSIZE];
obj = cfg_listelt_value(element);
(void)cfg_map_get(config, "zone", &zones);
}
- CFG_LIST_FOREACH (zones, element) {
+ CFG_LIST_FOREACH(zones, element) {
const cfg_obj_t *zone = cfg_listelt_value(element);
tresult = isccfg_check_zoneconf(zone, voptions, config, symtab,
if (check_keys[i] != NULL) {
unsigned int taflags = 0;
- CFG_LIST_FOREACH (check_keys[i], element) {
+ CFG_LIST_FOREACH(check_keys[i], element) {
const cfg_obj_t *keylist =
cfg_listelt_value(element);
- CFG_LIST_FOREACH (keylist, element2) {
+ CFG_LIST_FOREACH(keylist, element2) {
obj = cfg_listelt_value(element2);
tresult = check_trust_anchor(obj,
&taflags);
cfg_map_get(logobj, "channel", &channels);
- CFG_LIST_FOREACH (channels, element) {
+ CFG_LIST_FOREACH(channels, element) {
channel = cfg_listelt_value(element);
channelname = cfg_obj_asstring(cfg_map_getname(channel));
fileobj = syslogobj = nullobj = stderrobj = NULL;
cfg_map_get(logobj, "category", &categories);
- CFG_LIST_FOREACH (categories, element) {
+ CFG_LIST_FOREACH(categories, element) {
category = cfg_listelt_value(element);
catname = cfg_obj_asstring(cfg_tuple_get(category, "name"));
if (isc_log_categorybyname(catname) == ISC_LOGCATEGORY_INVALID)
result = ISC_R_FAILURE;
}
channels = cfg_tuple_get(category, "destinations");
- CFG_LIST_FOREACH (channels, delement) {
+ CFG_LIST_FOREACH(channels, delement) {
channel = cfg_listelt_value(delement);
channelname = cfg_obj_asstring(channel);
tresult = isc_symtab_lookup(symtab, channelname, 1,
return ISC_R_SUCCESS;
}
- CFG_LIST_FOREACH (control_keylist, element) {
+ CFG_LIST_FOREACH(control_keylist, element) {
key = cfg_listelt_value(element);
keyval = cfg_obj_asstring(key);
* INET: Check allow clause.
* UNIX: Not supported.
*/
- CFG_LIST_FOREACH (controlslist, element) {
+ CFG_LIST_FOREACH(controlslist, element) {
controls = cfg_listelt_value(element);
unixcontrols = NULL;
inetcontrols = NULL;
(void)cfg_map_get(controls, "unix", &unixcontrols);
(void)cfg_map_get(controls, "inet", &inetcontrols);
- CFG_LIST_FOREACH (inetcontrols, element2) {
+ CFG_LIST_FOREACH(inetcontrols, element2) {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
result = tresult;
}
}
- CFG_LIST_FOREACH (unixcontrols, element2) {
+ CFG_LIST_FOREACH(unixcontrols, element2) {
control = cfg_listelt_value(element2);
path = cfg_obj_asstring(cfg_tuple_get(control, "path"));
cfg_obj_log(control, ISC_LOG_ERROR,
isc_symtab_create(mctx, NULL, NULL, true, &symtab);
- CFG_LIST_FOREACH (views, velement) {
+ CFG_LIST_FOREACH(views, velement) {
const cfg_obj_t *view = cfg_listelt_value(velement);
const cfg_obj_t *vname = cfg_tuple_get(view, "name");
const cfg_obj_t *voptions = cfg_tuple_get(view, "options");
if (acls != NULL) {
const char *aclname = NULL;
- CFG_LIST_FOREACH (acls, elt) {
+ CFG_LIST_FOREACH(acls, elt) {
const cfg_obj_t *acl = cfg_listelt_value(elt);
unsigned int line = cfg_obj_line(acl);
unsigned int i;
iter = cfg_obj_asuint32(obj);
}
dns_kasp_freeze(kasp);
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), 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);
(void)confget(maps, "cds-digest-types", &cds);
if (cds != NULL) {
- CFG_LIST_FOREACH (cds, element) {
+ CFG_LIST_FOREACH(cds, element) {
result = add_digest(kasp, cfg_listelt_value(element));
if (result != ISC_R_SUCCESS) {
goto cleanup;
char role[DST_MAX_ALGS] = { 0 };
bool warn[DST_MAX_ALGS][2] = { { false } };
- CFG_LIST_FOREACH (keys, element) {
+ CFG_LIST_FOREACH(keys, element) {
cfg_obj_t *kobj = cfg_listelt_value(element);
result = cfg_kaspkey_fromconfig(
kobj, kasp, check_algorithms, offline_ksk,
}
}
dns_kasp_freeze(kasp);
- ISC_LIST_FOREACH (dns_kasp_keys(kasp), kkey, link) {
+ ISC_LIST_FOREACH(dns_kasp_keys(kasp), kkey, link) {
uint32_t keyalg = dns_kasp_key_algorithm(kkey);
INSIST(keyalg < ARRAY_SIZE(role));
* inherit from the default policy (except for the built-in
* "insecure" policy).
*/
- ISC_LIST_FOREACH (dns_kasp_keys(default_kasp), key, link) {
+ ISC_LIST_FOREACH(dns_kasp_keys(default_kasp), key, link) {
dns_kasp_key_t *new_key = NULL;
/* Create a new key reference. */
static void
free_list(cfg_parser_t *pctx, cfg_obj_t *obj) {
- ISC_LIST_FOREACH (obj->value.list, elt, link) {
+ ISC_LIST_FOREACH(obj->value.list, elt, link) {
free_listelt(pctx, elt);
}
}
print_list(cfg_printer_t *pctx, const cfg_obj_t *obj) {
cfg_list_t *list = UNCONST(&obj->value.list);
- ISC_LIST_FOREACH (*list, 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, "; ");
list = UNCONST(&obj->value.list);
- ISC_LIST_FOREACH (*list, 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;
- ISC_LIST_FOREACH (*list, elt, link) {
+ ISC_LIST_FOREACH(*list, elt, link) {
print_symval(pctx, clause->name,
elt->obj);
}
REQUIRE(config != NULL);
REQUIRE(callback != NULL);
- CFG_LIST_FOREACH (list, element) {
+ CFG_LIST_FOREACH(list, element) {
const cfg_obj_t *plugin = cfg_listelt_value(element);
const cfg_obj_t *obj;
const char *type, *library;
return;
}
- ISC_LIST_FOREACH (client->manager->sctx->altsecrets, 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)) {
MTRACE("destroy");
LOCK(&manager->reclock);
- ISC_LIST_FOREACH (manager->recursing, client, inner.rlink) {
+ ISC_LIST_FOREACH(manager->recursing, client, inner.rlink) {
ns_query_cancel(client);
}
UNLOCK(&manager->reclock);
REQUIRE(VALID_MANAGER(manager));
LOCK(&manager->reclock);
- ISC_LIST_FOREACH (manager->recursing, client, inner.rlink) {
+ ISC_LIST_FOREACH(manager->recursing, client, inner.rlink) {
INSIST(client->inner.state == NS_CLIENTSTATE_RECURSING);
ns_client_name(client, peerbuf, sizeof(peerbuf));
ns_dbversion_t *
ns_client_findversion(ns_client_t *client, dns_db_t *db) {
- ISC_LIST_FOREACH (client->query.activeversions, dbversion, link) {
+ ISC_LIST_FOREACH(client->query.activeversions, dbversion, link) {
if (dbversion->db == db) {
return dbversion;
}
*tablep = NULL;
for (i = 0; i < NS_HOOKPOINTS_COUNT; i++) {
- ISC_LIST_FOREACH ((*table)[i], hook, link) {
+ ISC_LIST_FOREACH((*table)[i], hook, link) {
ISC_LIST_UNLINK((*table)[i], hook, link);
if (hook->mctx != NULL) {
isc_mem_putanddetach(&hook->mctx, hook,
list = *listp;
*listp = NULL;
- ISC_LIST_FOREACH (*list, plugin, link) {
+ ISC_LIST_FOREACH(*list, plugin, link) {
ISC_LIST_UNLINK(*list, plugin, link);
unload_plugin(&plugin);
}
* router advertisements?)
*/
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->interfaces, 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) {
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->interfaces, ifp, link) {
+ ISC_LIST_FOREACH(mgr->interfaces, ifp, link) {
if (isc_sockaddr_equal(&ifp->addr, addr)) {
UNLOCK(&mgr->lock);
return ifp;
ISC_LIST_INIT(interfaces);
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->interfaces, ifp, link) {
+ ISC_LIST_FOREACH(mgr->interfaces, ifp, link) {
INSIST(NS_INTERFACE_VALID(ifp));
if (ifp->generation != mgr->generation) {
ISC_LIST_UNLINK(ifp->mgr->interfaces, ifp, link);
}
UNLOCK(&mgr->lock);
- ISC_LIST_FOREACH (interfaces, ifp, link) {
+ ISC_LIST_FOREACH(interfaces, ifp, link) {
if (LISTENING(ifp)) {
log_interface_shutdown(ifp);
ns_interface_shutdown(ifp);
isc_sockaddr_fromnetaddr(addr, &interface->address, port);
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->listenon, 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));
ISC_LIST_MOVE(listenon, mgr->listenon);
UNLOCK(&mgr->lock);
- ISC_LIST_FOREACH (listenon, old, link) {
+ ISC_LIST_FOREACH(listenon, old, link) {
ISC_LIST_UNLINK(listenon, old, link);
isc_mem_put(mgr->mctx, old, sizeof(*old));
}
listenon:
ll = (family == AF_INET) ? mgr->listenon4 : mgr->listenon6;
dolistenon = true;
- ISC_LIST_FOREACH (ll->elts, le, link) {
+ ISC_LIST_FOREACH(ll->elts, le, link) {
int match;
bool addr_in_use = false;
isc_sockaddr_t listen_sockaddr;
return true;
}
LOCK(&mgr->lock);
- ISC_LIST_FOREACH (mgr->listenon, 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) {
- ISC_LIST_FOREACH (list->elts, elt, link) {
+ ISC_LIST_FOREACH(list->elts, elt, link) {
ns_listenelt_destroy(elt);
}
isc_mem_put(list->mctx, list, sizeof(*list));
query_freefreeversions(ns_client_t *client, bool everything) {
unsigned int i = 0;
- ISC_LIST_FOREACH (client->query.freeversions, dbversion, link) {
+ ISC_LIST_FOREACH(client->query.freeversions, dbversion, link) {
/*
* If we're not freeing everything, we keep the first three
* dbversions structures around.
/*
* Cleanup any active versions.
*/
- ISC_LIST_FOREACH (client->query.activeversions, dbversion, link) {
+ ISC_LIST_FOREACH(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);
- ISC_LIST_FOREACH (client->query.namebufs, dbuf, link) {
+ ISC_LIST_FOREACH(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);
return false;
}
- DNS_RDATASET_FOREACH (sigrdataset) {
+ DNS_RDATASET_FOREACH(sigrdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(sigrdataset, &rdata);
result = dns_rdata_tostruct(&rdata, &rrsig, NULL);
if (qtype == dns_rdatatype_aaaa &&
!ISC_LIST_EMPTY(client->inner.view->dns64))
{
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, *rdatasetp);
if ((*rdatasetp)->type == dns_rdatatype_a) {
found_a = true;
dns_rdataset_disassociate(*rdatasetp);
}
}
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, *rdatasetp);
if ((*rdatasetp)->type == dns_rdatatype_cname ||
(*rdatasetp)->type == qtype)
/*
* Check all of the IP addresses in the rdataset.
*/
- DNS_RDATASET_FOREACH (*ip_rdatasetp) {
+ DNS_RDATASET_FOREACH(*ip_rdatasetp) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(*ip_rdatasetp, &rdata);
switch (rdata.type) {
}
found = dns_fixedname_initname(&fixed);
dns_rdataset_init(&trdataset);
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_ncache_current(rdataset, found, &trdataset);
type = trdataset.type;
dns_rdataset_disassociate(&trdataset);
return ISC_R_NOTFOUND;
}
if (rdataset->attributes.negative) {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_ncache_current(rdataset, found, &trdataset);
type = trdataset.type;
dns_rdataset_disassociate(&trdataset);
return ISC_R_NOTFOUND;
}
if (rdataset->attributes.negative) {
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
dns_ncache_current(rdataset, found, &trdataset);
type = trdataset.type;
dns_rdataset_disassociate(&trdataset);
dns_rdataset_t nc_rdataset = DNS_RDATASET_INIT;
dns_fixedname_t fixed;
dns_name_t *n = dns_fixedname_initname(&fixed);
- DNS_RDATASET_FOREACH (qctx->rdataset) {
+ DNS_RDATASET_FOREACH(qctx->rdataset) {
dns_ncache_current(qctx->rdataset, n,
&nc_rdataset);
if (nc_rdataset.type == dns_rdatatype_soa) {
dns_rdataset_init(&dsset);
if (dns_keynode_dsset(keynode, &dsset)) {
- DNS_RDATASET_FOREACH (&dsset) {
+ DNS_RDATASET_FOREACH(&dsset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_ds_t ds;
ns_client_keepname(qctx->client, qctx->fname, qctx->dbuf);
qctx->tname = qctx->fname;
- DNS_RDATASETITER_FOREACH (rdsiter) {
+ DNS_RDATASETITER_FOREACH(rdsiter) {
dns_rdatasetiter_current(rdsiter, qctx->rdataset);
/*
myrdatalist->ttl = qctx->rdataset->ttl;
i = 0;
- DNS_RDATASET_FOREACH (qctx->rdataset) {
+ DNS_RDATASET_FOREACH(qctx->rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_t *myrdata = NULL;
isc_region_t r;
* the first name in the AUTHORITY section when wildcard processing is
* involved.
*/
- MSG_SECTION_FOREACH (client->message, DNS_SECTION_AUTHORITY, rname) {
+ MSG_SECTION_FOREACH(client->message, DNS_SECTION_AUTHORITY, rname) {
result = dns_message_findtype(rname, dns_rdatatype_ns, 0, NULL);
if (result == ISC_R_SUCCESS) {
/*
*/
static isc_result_t
checksignames(dns_name_t *signer, dns_rdataset_t *sigrdataset) {
- DNS_RDATASET_FOREACH (sigrdataset) {
+ DNS_RDATASET_FOREACH(sigrdataset) {
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdata_rrsig_t rrsig;
}
msg = qctx->client->message;
- MSG_SECTION_FOREACH (msg, section, name) {
+ MSG_SECTION_FOREACH(msg, section, name) {
if (dns_name_equal(name, qctx->client->query.qname)) {
- ISC_LIST_FOREACH (name->list, rdataset, link) {
+ ISC_LIST_FOREACH(name->list, rdataset, link) {
if (rdataset->type == qctx->qtype) {
ISC_LIST_UNLINK(msg->sections[section],
name, link);
*sctxp = NULL;
if (isc_refcount_decrement(&sctx->references) == 1) {
- ISC_LIST_FOREACH (sctx->altsecrets, altsecret, link) {
+ ISC_LIST_FOREACH(sctx->altsecrets, altsecret, link) {
ISC_LIST_UNLINK(sctx->altsecrets, altsecret, link);
isc_mem_put(sctx->mctx, altsecret, sizeof(*altsecret));
}
isc_quota_destroy(&sctx->tcpquota);
isc_quota_destroy(&sctx->xfroutquota);
- ISC_LIST_FOREACH (sctx->http_quotas, http_quota, link) {
+ ISC_LIST_FOREACH(sctx->http_quotas, http_quota, link) {
ISC_LIST_DEQUEUE(sctx->http_quotas, http_quota, link);
isc_quota_destroy(http_quota);
isc_mem_put(sctx->mctx, http_quota,
do_diff(dns_diff_t *updates, dns_db_t *db, dns_dbversion_t *ver,
dns_diff_t *diff) {
isc_result_t result;
- ISC_LIST_FOREACH (updates->tuples, t, link) {
+ ISC_LIST_FOREACH(updates->tuples, t, link) {
ISC_LIST_UNLINK(updates->tuples, t, link);
CHECK(do_one_tuple(&t, db, ver, diff));
}
foreach_node_rr_action(void *data, dns_rdataset_t *rdataset) {
isc_result_t result;
foreach_node_rr_ctx_t *ctx = data;
- DNS_RDATASET_FOREACH (rdataset) {
+ DNS_RDATASET_FOREACH(rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(rdataset, &rr.rdata);
goto cleanup_node;
}
- DNS_RDATASETITER_FOREACH (iter) {
+ DNS_RDATASETITER_FOREACH(iter) {
dns_rdataset_t rdataset = DNS_RDATASET_INIT;
dns_rdatasetiter_current(iter, &rdataset);
dns_rdataset_getownercase(&rdataset, ctx->oldname);
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
rr_t rr = { 0, DNS_RDATA_INIT };
dns_rdataset_current(&rdataset, &rr.rdata);
rr.ttl = rdataset.ttl;
dns_rdataset_init(&rdataset);
dns_rdataset_clone(rrset, &rdataset);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (rrset->type == dns_rdatatype_ptr) {
dns_diff_init(mctx, &d_rrs);
dns_diff_init(mctx, &u_rrs);
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
temp_append(&d_rrs, name, &rdata);
}
update = 0;
- MSG_SECTION_FOREACH (request, DNS_SECTION_UPDATE, name) {
+ MSG_SECTION_FOREACH(request, DNS_SECTION_UPDATE, name) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_ttl_t ttl;
dns_rdataclass_t update_class;
dns_diff_init(diff->mctx, &temp_diff);
- ISC_LIST_FOREACH (diff->tuples, 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:
- ISC_LIST_FOREACH (temp_diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(temp_diff.tuples, tuple, link) {
ISC_LIST_UNLINK(temp_diff.tuples, tuple, link);
dns_diff_appendminimal(diff, &tuple);
}
dns_rdata_init(&rdata);
options = dns_zone_getoptions(zone);
- ISC_LIST_FOREACH (diff->tuples, t, link) {
+ ISC_LIST_FOREACH(diff->tuples, t, link) {
if (t->op != DNS_DIFFOP_ADD ||
t->rdata.type != dns_rdatatype_mx)
{
}
bool matched = false;
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t myrdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &myrdata);
if (dns_rdata_casecompare(&myrdata, rdata) == 0) {
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &nsec3param, NULL));
goto failure;
}
- DNS_RDATASET_FOREACH (&rdataset) {
+ DNS_RDATASET_FOREACH(&rdataset) {
unsigned char buf[DNS_NSEC3PARAM_BUFFERSIZE];
dns_rdata_t private = DNS_RDATA_INIT;
dns_rdata_t rdata = DNS_RDATA_INIT;
/*
* Extract NSEC3PARAM tuples from list.
*/
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
if (tuple->rdata.type != dns_rdatatype_nsec3param ||
!dns_name_equal(name, &tuple->name))
{
* in managing and should not be touched so revert such changes
* taking into account any TTL change of the NSEC3PARAM RRset.
*/
- ISC_LIST_FOREACH (temp_diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(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
/*
* Extract the changes to be rolled back.
*/
- ISC_LIST_FOREACH (diff->tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff->tuples, tuple, link) {
if (tuple->rdata.type != privatetype ||
!dns_name_equal(name, &tuple->name))
{
/*
* Rollback the changes.
*/
- ISC_LIST_FOREACH (temp_diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(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,
* Check prerequisites.
*/
- MSG_SECTION_FOREACH (request, DNS_SECTION_PREREQUISITE, name) {
+ MSG_SECTION_FOREACH(request, DNS_SECTION_PREREQUISITE, name) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_ttl_t ttl;
dns_rdataclass_t update_class;
INSIST(ssutable == NULL || maxbytype != NULL);
update = 0;
- MSG_SECTION_FOREACH (request, DNS_SECTION_UPDATE, name) {
+ MSG_SECTION_FOREACH(request, DNS_SECTION_UPDATE, name) {
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_ttl_t ttl;
dns_rdataclass_t update_class;
* Check the authority section. Look for a SOA record with
* the same name and class as the question.
*/
- MSG_SECTION_FOREACH (request, DNS_SECTION_AUTHORITY, soa_name) {
+ MSG_SECTION_FOREACH(request, DNS_SECTION_AUTHORITY, soa_name) {
/*
* Ignore data whose owner name is not the zone apex.
*/
continue;
}
- ISC_LIST_FOREACH (soa_name->list, soa_rdataset, link) {
+ ISC_LIST_FOREACH(soa_name->list, soa_rdataset, link) {
/*
* Ignore non-SOA data.
*/
assert_int_equal(result, ISC_R_SUCCESS);
assert_false(ISC_LIST_EMPTY(diff.tuples));
- ISC_LIST_FOREACH (diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff.tuples, tuple, link) {
assert_int_equal(tuple->op, DNS_DIFFOP_ADD);
count++;
}
assert_int_equal(result, ISC_R_SUCCESS);
assert_false(ISC_LIST_EMPTY(diff.tuples));
- ISC_LIST_FOREACH (diff.tuples, tuple, link) {
+ ISC_LIST_FOREACH(diff.tuples, tuple, link) {
assert_int_equal(tuple->op, DNS_DIFFOP_DEL);
count++;
}
result = dns_db_createiterator(db, flags, &iter);
assert_int_equal(result, ISC_R_SUCCESS);
- DNS_DBITERATOR_FOREACH (iter) {
+ DNS_DBITERATOR_FOREACH(iter) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detachnode(&node);
count_elements(dns_diff_t *diff) {
size_t count = 0;
- ISC_LIST_FOREACH (diff->tuples, ot, link) {
+ ISC_LIST_FOREACH(diff->tuples, ot, link) {
++count;
}
}
tuples_found = 0;
- ISC_LIST_FOREACH (zone_diff.tuples, found, link) {
+ ISC_LIST_FOREACH(zone_diff.tuples, found, link) {
tuples_found++;
}
*/
expected = test->zonediff;
index = 1;
- ISC_LIST_FOREACH (zone_diff.tuples, 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);
- ISC_LIST_FOREACH (rdatalist->rdata, rd, link) {
+ ISC_LIST_FOREACH(rdatalist->rdata, rd, link) {
ISC_LIST_UNLINK(rdatalist->rdata, rdata, link);
}
isc_mem_put(isc_g_mctx, rdatalist, sizeof(*rdatalist));
sign_rrset(fp, btime, btime + LIFETIME, dnskeyset,
test_bundles[bnum].rrsig1buf,
&test_bundles[bnum].dnskey_rrsig);
- ISC_LIST_FOREACH (dnskeylist->rdata, rd, link) {
+ ISC_LIST_FOREACH(dnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(dnskeylist->rdata, rd, link);
}
isc_mem_put(isc_g_mctx, dnskeylist, sizeof(*dnskeylist));
sign_rrset(fp, btime, btime + LIFETIME, cdnskeyset,
test_bundles[bnum].rrsig2buf,
&test_bundles[bnum].cdnskey_rrsig);
- ISC_LIST_FOREACH (cdnskeylist->rdata, rd, link) {
+ ISC_LIST_FOREACH(cdnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(cdnskeylist->rdata, rd, link);
}
isc_mem_put(isc_g_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);
- ISC_LIST_FOREACH (cdslist->rdata, rd, link) {
+ ISC_LIST_FOREACH(cdslist->rdata, rd, link) {
ISC_LIST_UNLINK(cdslist->rdata, rd, link);
}
isc_mem_put(isc_g_mctx, cdslist, sizeof(*cdslist));
isc_file_remove(testskr);
/* Test bundles */
- ISC_LIST_FOREACH (skr->bundles, bundle, link) {
+ ISC_LIST_FOREACH(skr->bundles, bundle, link) {
count++;
}
assert_int_equal(count, 42);
(void)cfg_map_get(c1, "dnssec-policy", &kasps);
assert_non_null(kasps);
- CFG_LIST_FOREACH (kasps, element) {
+ CFG_LIST_FOREACH(kasps, element) {
const cfg_listelt_t *key_element;
const cfg_obj_t *lifetime = NULL;
const cfg_obj_t *keys = NULL;
qpr.base);
printf("qpmulti->reader %p whence %p\n", reader, whence);
unsigned int snapshots = 0;
- ISC_LIST_FOREACH (multi->snapshots, snap, link) {
+ ISC_LIST_FOREACH(multi->snapshots, snap, link) {
snapshots++;
}
printf("qpmulti %p snapshots %u\n", multi, snapshots);
projects / thirdparty / bind9.git / commitdiff
