*/
cur = ai;
while (cur != NULL && cur->ai_canonname == NULL &&
- cur->ai_next != NULL) {
+ cur->ai_next != NULL)
+ {
cur = cur->ai_next;
}
if (cur != NULL && cur->ai_canonname != NULL &&
*/
cur = ai;
while (cur != NULL && cur->ai_canonname == NULL &&
- cur->ai_next != NULL) {
+ cur->ai_next != NULL)
+ {
cur = cur->ai_next;
}
if (cur != NULL && cur->ai_canonname != NULL &&
*/
cur = ai;
while (cur != NULL && cur->ai_canonname == NULL &&
- cur->ai_next != NULL) {
+ cur->ai_next != NULL)
+ {
cur = cur->ai_next;
}
if (cur != NULL && cur->ai_canonname != NULL &&
outputformat = dns_masterformat_raw;
rawversion = strtol(outputformatstr + 4, &end, 10);
if (end == outputformatstr + 4 || *end != '\0' ||
- rawversion > 1U) {
+ rawversion > 1U)
+ {
fprintf(stderr, "unknown raw format version\n");
exit(1);
}
}
if (argc - isc_commandline_index < 1 ||
- argc - isc_commandline_index > 2) {
+ argc - isc_commandline_index > 2)
+ {
usage();
}
isc_commandline_errprint = false;
while ((ch = isc_commandline_parse(argc, argv, "a:hk:Mmr:qs:y:z:")) !=
- -1) {
+ -1)
+ {
switch (ch) {
case 'a':
algname = isc_commandline_argument;
result = dns_rdataset_next(rdataset))
{
if ((rdataset->attributes &
- DNS_RDATASETATTR_NEGATIVE) != 0) {
+ DNS_RDATASETATTR_NEGATIVE) != 0)
+ {
continue;
}
} else {
dns_indent_t indent = { " ", 2 };
if (!yaml && (rdataset->attributes &
- DNS_RDATASETATTR_NEGATIVE) != 0) {
+ DNS_RDATASETATTR_NEGATIVE) != 0)
+ {
isc_buffer_putstr(&target, "; ");
}
result = dns_master_rdatasettotext(
keylist = cfg_listelt_value(elt);
for (elt2 = cfg_list_first(keylist); elt2 != NULL;
- elt2 = cfg_list_next(elt2)) {
+ elt2 = cfg_list_next(elt2))
+ {
key = cfg_listelt_value(elt2);
CHECK(key_fromconfig(key, client));
}
result = ISC_R_SUCCESS;
for (cur = res; cur != NULL; cur = cur->ai_next) {
if (cur->ai_family != AF_INET &&
- cur->ai_family != AF_INET6) {
+ cur->ai_family != AF_INET6)
+ {
continue;
}
sa = isc_mem_get(mctx, sizeof(*sa));
warn("extra query type");
}
if (rdtype == dns_rdatatype_ixfr ||
- rdtype == dns_rdatatype_axfr) {
+ rdtype == dns_rdatatype_axfr)
+ {
fatal("Transfer not supported");
}
qtype = rdtype;
/* Look for dash value option. */
if (strpbrk(option, dash_opts) != &option[0] ||
- strlen(option) > 1U) {
+ strlen(option) > 1U)
+ {
/* Error or value in option. */
continue;
}
} else if (argv[0][0] == '-') {
if (argc <= 1) {
if (dash_option(&argv[0][1], NULL,
- &open_type_class)) {
+ &open_type_class))
+ {
argc--;
argv++;
}
} else {
if (dash_option(&argv[0][1], argv[1],
- &open_type_class)) {
+ &open_type_class))
+ {
argc--;
argv++;
}
warn("extra query type");
}
if (rdtype == dns_rdatatype_ixfr ||
- rdtype == dns_rdatatype_axfr) {
+ rdtype == dns_rdatatype_axfr)
+ {
fatal("Transfer not supported");
}
qtype = rdtype;
flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;
}
if (query->lookup->onesoa &&
- query->lookup->rdtype == dns_rdatatype_axfr) {
+ query->lookup->rdtype == dns_rdatatype_axfr)
+ {
flags |= (query->msg_count == 0) ? DNS_MESSAGETEXTFLAG_ONESOA
: DNS_MESSAGETEXTFLAG_OMITSOA;
}
}
for (num = 0;
num < sizeof(opcodetext) / sizeof(opcodetext[0]);
- num++) {
+ num++)
+ {
if (strcasecmp(opcodetext[num], value) == 0) {
break;
}
switch (cmd[2]) {
case 's':
if (!plus_tls_options(cmd, value, state,
- lookup)) {
+ lookup))
+ {
goto invalid_option;
}
break;
result = dns_rdatatype_fromtext(
&rdtype, (isc_textregion_t *)&tr);
if (result == ISC_R_SUCCESS &&
- rdtype == dns_rdatatype_ixfr) {
+ rdtype == dns_rdatatype_ixfr)
+ {
result = DNS_R_UNKNOWN;
}
}
}
*need_clone = true;
if (get_reverse(textname, sizeof(textname), value, false) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
strlcpy((*lookup)->textname, textname,
sizeof((*lookup)->textname));
debug("looking up %s", (*lookup)->textname);
}
if (batchfp != NULL) {
while (fgets(batchline, sizeof(batchline), batchfp) !=
- 0) {
+ 0)
+ {
debug("config line %s", batchline);
bargc = split_batchline(batchline, bargv, 62,
".digrc argv");
&rdtype,
(isc_textregion_t *)&tr);
if (result == ISC_R_SUCCESS &&
- rdtype == dns_rdatatype_ixfr) {
+ rdtype == dns_rdatatype_ixfr)
+ {
fprintf(stderr, ";; Warning, "
"ixfr requires "
"a "
lookup->rdtype = rdtype;
lookup->rdtypeset = true;
if (rdtype ==
- dns_rdatatype_axfr) {
+ dns_rdatatype_axfr)
+ {
lookup->section_question =
plusquest;
lookup->comments =
}
if (rdtype ==
dns_rdatatype_any &&
- !lookup->tcp_mode_set) {
+ !lookup->tcp_mode_set)
+ {
lookup->tcp_mode = true;
}
lookup->ixfr_serial = false;
debug("get_server_list()");
servers = irs_resconf_getnameservers(resconf);
for (sa = ISC_LIST_HEAD(*servers); sa != NULL;
- sa = ISC_LIST_NEXT(sa, link)) {
+ sa = ISC_LIST_NEXT(sa, link))
+ {
int pf = isc_sockaddr_pf(sa);
isc_netaddr_t na;
isc_result_t result;
dns_rdata_ns_t ns;
if (query->lookup->trace_root &&
- query->lookup->nsfound >= MXSERV) {
+ query->lookup->nsfound >= MXSERV)
+ {
break;
}
cancel_lookup(query->lookup);
lookup->doing_xfr = false;
if (!lookup->trace_root &&
- section == DNS_SECTION_ANSWER) {
+ section == DNS_SECTION_ANSWER)
+ {
lookup->trace = false;
} else {
lookup->trace = query->lookup->trace;
query->lookup);
query->canceled = true;
if (query->readhandle != NULL &&
- !isc_nm_is_http_handle(query->readhandle)) {
+ !isc_nm_is_http_handle(query->readhandle))
+ {
isc_nm_cancelread(query->readhandle);
}
query_detach(&query);
}
if (query->lookup->tls_key_file_set &&
- query->lookup->tls_cert_file_set) {
+ query->lookup->tls_cert_file_set)
+ {
result = isc_tlsctx_load_certificate(
ctx, query->lookup->tls_key_file,
query->lookup->tls_cert_file);
if (tls_mode) {
port = 853;
} else if (query->lookup->https_mode &&
- !query->lookup->http_plain) {
+ !query->lookup->http_plain)
+ {
port = 443;
} else if (query->lookup->https_mode) {
port = 80;
* it's an SOA
*/
if ((!query->first_soa_rcvd) &&
- (rdata.type != dns_rdatatype_soa)) {
+ (rdata.type != dns_rdatatype_soa))
+ {
puts("; Transfer failed. "
"Didn't start with SOA answer.");
return (true);
}
if ((!query->second_rr_rcvd) &&
- (rdata.type != dns_rdatatype_soa)) {
+ (rdata.type != dns_rdatatype_soa))
+ {
query->second_rr_rcvd = true;
query->second_rr_serial = 0;
debug("got the second rr as nonsoa");
}
if ((msg->flags & DNS_MESSAGEFLAG_TC) != 0 && !l->ignore &&
- !l->tcp_mode) {
+ !l->tcp_mode)
+ {
if (l->cookie == NULL && l->sendcookie && msg->opt != NULL) {
process_opt(l, msg);
}
if (!l->doing_xfr || l->xfr_q == query) {
if (msg->rcode == dns_rcode_nxdomain &&
- (l->origin != NULL || l->need_search)) {
+ (l->origin != NULL || l->need_search))
+ {
if (!next_origin(l) || showsearch) {
dighost_printmessage(query, &b, msg, true);
dighost_received(isc_buffer_usedlength(&b),
current_lookup);
q->canceled = true;
if (q->readhandle != NULL &&
- !isc_nm_is_http_handle(q->readhandle)) {
+ !isc_nm_is_http_handle(q->readhandle))
+ {
isc_nm_cancelread(q->readhandle);
}
query_detach(&q);
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_AUTHORITY]) &&
- !short_form) {
+ !short_form)
+ {
printf("\n");
result = printsection(msg, DNS_SECTION_AUTHORITY, "AUTHORITY",
true, query);
}
}
if (!ISC_LIST_EMPTY(msg->sections[DNS_SECTION_ADDITIONAL]) &&
- !short_form) {
+ !short_form)
+ {
printf("\n");
result = printsection(msg, DNS_SECTION_ADDITIONAL, "ADDITIONAL",
true, query);
{
isc_mem_debugging |= ISC_MEM_DEBUGTRACE;
} else if (strcasecmp("record",
- isc_commandline_argument) == 0) {
+ isc_commandline_argument) == 0)
+ {
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
} else if (strcasecmp("usage",
- isc_commandline_argument) == 0) {
+ isc_commandline_argument) == 0)
+ {
isc_mem_debugging |= ISC_MEM_DEBUGUSAGE;
}
break;
break;
case 't':
if (strncasecmp(isc_commandline_argument, "ixfr=", 5) ==
- 0) {
+ 0)
+ {
rdtype = dns_rdatatype_ixfr;
/* XXXMPA add error checking */
serial = strtoul(isc_commandline_argument + 5,
isc_commandline_argument);
}
if (!lookup->rdtypeset ||
- lookup->rdtype != dns_rdatatype_axfr) {
+ lookup->rdtype != dns_rdatatype_axfr)
+ {
lookup->rdtype = rdtype;
}
lookup->rdtypeset = true;
FALLTHROUGH;
case 'a':
if (!lookup->rdtypeset ||
- lookup->rdtype != dns_rdatatype_axfr) {
+ lookup->rdtype != dns_rdatatype_axfr)
+ {
lookup->rdtype = dns_rdatatype_any;
}
list_type = dns_rdatatype_any;
NULL);
if (result != ISC_R_SUCCESS &&
- result != DNS_R_FROMWILDCARD) {
+ result != DNS_R_FROMWILDCARD)
+ {
vbprintf(1,
"skip RRSIG by key %d:"
" verification failed: %s\n",
* optional, so that it works just like sed(1).
*/
if (isc_commandline_argument ==
- argv[isc_commandline_index - 1]) {
+ argv[isc_commandline_index - 1])
+ {
isc_commandline_index--;
inplace = "";
} else {
fatal("missing RRSIG CDNSKEY records for %s", namestr);
}
if (dns_rdataset_isassociated(&cds_set) &&
- !dns_rdataset_isassociated(&cds_sig)) {
+ !dns_rdataset_isassociated(&cds_sig))
+ {
fatal("missing RRSIG CDS records for %s", namestr);
}
if (dns_rdataset_isassociated(&cdnskey_set)) {
vbprintf(1, "verify CDNSKEY signature(s)\n");
if (!signed_loose(matching_sigs(old_key_tbl, &cdnskey_set,
- &cdnskey_sig))) {
+ &cdnskey_sig)))
+ {
fatal("could not validate child CDNSKEY RRset for %s",
namestr);
}
if (dns_rdataset_isassociated(&cds_set)) {
vbprintf(1, "verify CDS signature(s)\n");
if (!signed_loose(
- matching_sigs(old_key_tbl, &cds_set, &cds_sig))) {
+ matching_sigs(old_key_tbl, &cds_set, &cds_sig)))
+ {
fatal("could not validate child CDS RRset for %s",
namestr);
}
flags |= DNS_KEYOWNER_ZONE;
} else if ((options & DST_TYPE_KEY) != 0) { /* KEY */
if (strcasecmp(nametype, "host") == 0 ||
- strcasecmp(nametype, "entity") == 0) {
+ strcasecmp(nametype, "entity") == 0)
+ {
flags |= DNS_KEYOWNER_ENTITY;
} else if (strcasecmp(nametype, "user") == 0) {
flags |= DNS_KEYOWNER_USER;
if (protocol == -1) {
protocol = DNS_KEYPROTO_DNSSEC;
} else if ((options & DST_TYPE_KEY) == 0 &&
- protocol != DNS_KEYPROTO_DNSSEC) {
+ protocol != DNS_KEYPROTO_DNSSEC)
+ {
fatal("invalid DNSKEY protocol: %d", protocol);
}
cfg_obj_t *kconfig = cfg_listelt_value(element);
kasp = NULL;
if (strcmp(cfg_obj_asstring(cfg_tuple_get(kconfig, "name")),
- name) != 0) {
+ name) != 0)
+ {
continue;
}
if (!ctx->oldstyle && ctx->prepub > 0) {
if (ctx->setpub && ctx->setact &&
- (ctx->activate - ctx->prepub) < ctx->publish) {
+ (ctx->activate - ctx->prepub) < ctx->publish)
+ {
fatal("Activation and publication dates "
"are closer together than the\n\t"
"prepublication interval.");
if (ctx->setdel) {
if (ctx->setinact &&
- ctx->deltime < ctx->inactive) {
+ ctx->deltime < ctx->inactive)
+ {
fprintf(stderr,
"%s: warning: Key is "
"scheduled to be deleted "
ctx.protocol = strtol(isc_commandline_argument, &endp,
10);
if (*endp != '\0' || ctx.protocol < 0 ||
- ctx.protocol > 255) {
+ ctx.protocol > 255)
+ {
fatal("-p must be followed by a number "
"[0..255]");
}
ctx.signatory = strtol(isc_commandline_argument, &endp,
10);
if (*endp != '\0' || ctx.signatory < 0 ||
- ctx.signatory > 15) {
+ ctx.signatory > 15)
+ {
fatal("-s must be followed by a number "
"[0..15]");
}
}
if (argc < isc_commandline_index + 1 ||
- argv[isc_commandline_index] == NULL) {
+ argv[isc_commandline_index] == NULL)
+ {
fatal("The key file name was not specified");
}
if (argc > isc_commandline_index + 1) {
}
if (argc < isc_commandline_index + 1 ||
- argv[isc_commandline_index] == NULL) {
+ argv[isc_commandline_index] == NULL)
+ {
fatal("The key file name was not specified");
}
if (argc > isc_commandline_index + 1) {
}
if ((setgoal || setds || setdnskey || setkrrsig || setzrrsig) &&
- !write_state) {
+ !write_state)
+ {
fatal("Options -g, -d, -k, -r and -z require -s to be set");
}
dns_dnsseckey_t *key;
for (key = ISC_LIST_HEAD(keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (rrsig->keyid == dst_key_id(key->key) &&
rrsig->algorithm == dst_key_alg(key->key) &&
dns_name_equal(&rrsig->signer, dst_key_name(key->key)))
"invalid validity period\n",
sigstr);
} else if (key == NULL && !future &&
- expecttofindkey(&rrsig.signer)) {
+ expecttofindkey(&rrsig.signer))
+ {
/* rrsig is dropped and not replaced */
vbprintf(2,
"\trrsig by %s dropped - "
vbprintf(2, "\trrsig by %s %s - dnskey not found\n",
keep ? "retained" : "dropped", sigstr);
} else if (!dns_dnssec_keyactive(key->key, now) &&
- remove_inactkeysigs) {
+ remove_inactkeysigs)
+ {
keep = false;
vbprintf(2, "\trrsig by %s dropped - key inactive\n",
sigstr);
}
for (key = ISC_LIST_HEAD(keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (nowsignedby[key->index]) {
continue;
}
curr = ISC_LIST_NEXT(curr, link))
{
if (dst_key_alg(key->key) !=
- dst_key_alg(curr->key)) {
+ dst_key_alg(curr->key))
+ {
continue;
}
if (REVOKE(curr->key)) {
}
}
if (isksk(key) || !have_ksk ||
- (iszsk(key) && !keyset_kskonly)) {
+ (iszsk(key) && !keyset_kskonly))
+ {
signwithkey(name, set, key->key, ttl, add,
"signing with dnskey");
}
DST_NUM_SUCCESSOR,
&suc);
if (ret != ISC_R_SUCCESS ||
- dst_key_id(key->key) != suc) {
+ dst_key_id(key->key) != suc)
+ {
continue;
}
*/
if (isdelegation) {
if (rdataset.type != nsec_datatype &&
- rdataset.type != dns_rdatatype_ds) {
+ rdataset.type != dns_rdatatype_ds)
+ {
goto skip;
}
} else if (rdataset.type == dns_rdatatype_ds) {
check_result(result, "dns_db_deleterdataset("
"rrsig)");
} else if (result != ISC_R_NOMORE &&
- result != ISC_R_SUCCESS) {
+ result != ISC_R_SUCCESS)
+ {
fatal("rdataset iteration failed: %s",
isc_result_totext(result));
}
old_serial = dns_soa_getserial(&rdata);
if (method == dns_updatemethod_date ||
- method == dns_updatemethod_unixtime) {
+ method == dns_updatemethod_unixtime)
+ {
new_serial = dns_update_soaserial(old_serial, method, &used);
} else if (serial != 0 || method == dns_updatemethod_none) {
/* Set SOA serial to the value provided. */
!dns_name_issubdomain(name, zonecut)))
{
if (is_delegation(gdb, gversion, gorigin, name,
- node, NULL)) {
+ node, NULL))
+ {
zonecut = savezonecut(&fzonecut, name);
if (!OPTOUT(nsec3flags) ||
- secure(name, node)) {
+ secure(name, node))
+ {
found = true;
}
} else if (has_dname(gdb, gversion, node)) {
dns_rdataset_disassociate(&rdataset);
if (type == which || covers == which) {
if (which == dns_rdatatype_nsec && checknsec &&
- !update_chain) {
+ !update_chain)
+ {
fatal("Zone contains NSEC records. Use -u "
"to update to NSEC3.");
}
if (which == dns_rdatatype_nsec3param && checknsec &&
- !update_chain) {
+ !update_chain)
+ {
fatal("Zone contains NSEC3 chains. Use -u "
"to update to NSEC.");
}
count2++;
dns_rdataset_current(&tmprdataset, &rdata2);
if (count1 < count2 &&
- dns_rdata_casecompare(&rdata1, &rdata2) == 0) {
+ dns_rdata_casecompare(&rdata1, &rdata2) == 0)
+ {
vbprintf(2, "removing duplicate at %s/%s\n",
namestr, typestr);
result = dns_difftuple_create(
continue;
}
if (is_delegation(gdb, gversion, gorigin, nextname,
- nextnode, &nsttl)) {
+ nextnode, &nsttl))
+ {
zonecut = savezonecut(&fzonecut, nextname);
remove_sigs(nextnode, true, 0);
if (generateds) {
add_ds(nextname, nextnode, nsttl);
}
if (OPTOUT(nsec3flags) &&
- !secure(nextname, nextnode)) {
+ !secure(nextname, nextnode))
+ {
dns_db_detachnode(gdb, &nextnode);
result = dns_dbiterator_next(dbiter);
continue;
continue;
}
if (is_delegation(gdb, gversion, gorigin, nextname,
- nextnode, NULL)) {
+ nextnode, NULL))
+ {
zonecut = savezonecut(&fzonecut, nextname);
if (OPTOUT(nsec3flags) &&
- !secure(nextname, nextnode)) {
+ !secure(nextname, nextnode))
+ {
dns_db_detachnode(gdb, &nextnode);
result = dns_dbiterator_next(dbiter);
continue;
/* Skip any duplicates */
for (key = ISC_LIST_HEAD(keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (dst_key_id(key->key) == dst_key_id(newkey) &&
dst_key_alg(key->key) == dst_key_alg(newkey))
{
name = gorigin;
for (key = ISC_LIST_HEAD(keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (REVOKE(key->key)) {
continue;
}
outputformat = dns_masterformat_raw;
rawversion = strtol(outputformatstr + 4, &end, 10);
if (end == outputformatstr + 4 || *end != '\0' ||
- rawversion > 1U) {
+ rawversion > 1U)
+ {
fprintf(stderr, "unknown raw format version\n");
exit(1);
}
/* Now enumerate the key list */
for (key = ISC_LIST_HEAD(keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
key->index = keycount++;
}
*/
n = strspn(str, "0123456789");
if ((n == 8u || n == 14u) &&
- (str[n] == '\0' || str[n] == '-' || str[n] == '+')) {
+ (str[n] == '\0' || str[n] == '-' || str[n] == '+'))
+ {
char timestr[15];
strlcpy(timestr, str, sizeof(timestr));
base = val;
str += n;
} else if (n == 10u &&
- (str[n] == '\0' || str[n] == '-' || str[n] == '+')) {
+ (str[n] == '\0' || str[n] == '-' || str[n] == '+'))
+ {
base = strtoll(str, &endp, 0);
str += 10;
} else if (strncmp(str, "now", 3) == 0) {
* Reverse of 192.0.0.170 or 192.0.0.171 maps to ipv4only.arpa.
*/
if ((v[0] == 170 || v[0] == 171) && v[1] == 0 && v[2] == 0 &&
- v[3] == 192) {
+ v[3] == 192)
+ {
return (dns_sdb_putrdata(lookup, dns_rdatatype_ptr, 3600,
ipv4only, sizeof(ipv4only)));
}
for (i = 0; maps[i] != NULL; i++) {
checknames = NULL;
if (cfg_map_get(maps[i], "check-names", &checknames) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
/*
* Zone map entry is not a list.
*/
for (size_t j = 0; names[j] != NULL; j++) {
if (strcasecmp(cfg_obj_asstring(type),
- names[j]) == 0) {
+ names[j]) == 0)
+ {
*obj = cfg_tuple_get(value,
"mode");
return (ISC_R_SUCCESS);
if (strcasecmp(str, "primary") == 0 || strcasecmp(str, "master") == 0) {
ztype = dns_zone_primary;
} else if (strcasecmp(str, "secondary") == 0 ||
- strcasecmp(str, "slave") == 0) {
+ strcasecmp(str, "slave") == 0)
+ {
ztype = dns_zone_secondary;
} else if (strcasecmp(str, "mirror") == 0) {
ztype = dns_zone_mirror;
while (elt != NULL) {
obj = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_tuple_get(obj, "name")),
- name) == 0) {
+ name) == 0)
+ {
*ret = obj;
return (ISC_R_SUCCESS);
}
if (isccc_cc_lookupuint32(conn->ctrl, "_tim", &sent) == ISC_R_SUCCESS) {
if ((sent + CLOCKSKEW) < conn->now ||
- (sent - CLOCKSKEW) > conn->now) {
+ (sent - CLOCKSKEW) > conn->now)
+ {
log_invalid(&conn->ccmsg, ISCCC_R_CLOCKSKEW);
goto cleanup;
}
control_keylist = cfg_tuple_get(control, "keys");
if (!cfg_obj_isvoid(control_keylist) &&
- cfg_list_first(control_keylist) != NULL) {
+ cfg_list_first(control_keylist) != NULL)
+ {
result = cfg_map_get(config, "key", &global_keylist);
if (result == ISC_R_SUCCESS) {
isc_result_t result;
if (sslkeylogfile_path == NULL ||
- strcmp(sslkeylogfile_path, "config") == 0) {
+ strcmp(sslkeylogfile_path, "config") == 0)
+ {
return;
}
arglen = (int)(end - arg);
for (def = defs; def->name != NULL; def++) {
if (arglen == (int)strlen(def->name) &&
- memcmp(arg, def->name, arglen) == 0) {
+ memcmp(arg, def->name, arglen) == 0)
+ {
if (def->value == 0) {
clear = true;
}
list_hmac_algorithms(isc_buffer_t *b) {
isc_buffer_t sb = *b;
for (dst_algorithm_t i = DST_ALG_HMAC_FIRST; i <= DST_ALG_HMAC_LAST;
- i++) {
+ i++)
+ {
if (dst_algorithm_supported(i)) {
isc_buffer_putstr(b, " ");
isc_buffer_putstr(b, dst_hmac_algorithm_totext(i));
}
}
for (unsigned char *s = isc_buffer_used(&sb); s != isc_buffer_used(b);
- s++) {
+ s++)
+ {
*s = toupper(*s);
}
}
* warning, but do not prevent further keys from being processed.
*/
if (!dns_resolver_algorithm_supported(view->resolver, keyname,
- ds.algorithm)) {
+ ds.algorithm))
+ {
cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
"ignoring %s for '%s': algorithm is disabled",
initializing ? "initial-key" : "static-key",
keylist = cfg_listelt_value(elt);
for (elt2 = cfg_list_first(keylist); elt2 != NULL;
- elt2 = cfg_list_next(elt2)) {
+ elt2 = cfg_list_next(elt2))
+ {
CHECK(process_key(cfg_listelt_value(elt2), secroots,
keyname, view, managed));
}
/* We don't need trust anchors for the _bind view */
if (strcmp(view->name, "_bind") == 0 &&
- view->rdclass == dns_rdataclass_chaos) {
+ view->rdclass == dns_rdataclass_chaos)
+ {
return (ISC_R_SUCCESS);
}
if (cfg_obj_isvoid(*sub_obj)) {
*sub_obj = NULL;
if (maps != NULL &&
- ISC_R_SUCCESS != named_config_get(maps, name, sub_obj)) {
+ ISC_R_SUCCESS != named_config_get(maps, name, sub_obj))
+ {
*sub_obj = NULL;
}
}
* statement in the view and the general options.
*/
if (conf_dnsrps_get(&obj, maps, rpz_obj, "dnsrps-options", &ctx) &&
- obj != NULL) {
+ obj != NULL)
+ {
conf_dnsrps_sadd(&ctx, " %s\n", cfg_obj_asstring(obj));
}
obj = cfg_tuple_get(rpz_obj, "recursive-only");
if (cfg_obj_isvoid(obj) ? recursive_only_default
- : cfg_obj_asboolean(obj)) {
+ : cfg_obj_asboolean(obj))
+ {
view->rpzs->p.no_rd_ok &= ~DNS_RPZ_ZBIT(zone->num);
} else {
view->rpzs->p.no_rd_ok |= DNS_RPZ_ZBIT(zone->num);
}
if (!view->rpzs->p.dnsrps_enabled) {
for (rpz_num = 0; rpz_num < view->rpzs->p.num_zones - 1;
- ++rpz_num) {
+ ++rpz_num)
+ {
if (dns_name_equal(&view->rpzs->zones[rpz_num]->origin,
- &zone->origin)) {
+ &zone->origin))
+ {
cfg_obj_log(rpz_obj, named_g_lctx,
DNS_RPZ_ERROR_LEVEL,
"duplicate '%s'", str);
*/
if (*old_rpz_okp) {
if (old != NULL &&
- memcmp(&old->p, &zones->p, sizeof(zones->p)) != 0) {
+ memcmp(&old->p, &zones->p, sizeof(zones->p)) != 0)
+ {
*old_rpz_okp = false;
} else if ((old == NULL || old->rps_cstr == NULL) !=
- (zones->rps_cstr == NULL)) {
+ (zones->rps_cstr == NULL))
+ {
*old_rpz_okp = false;
} else if (old != NULL && zones->rps_cstr != NULL &&
strcmp(old->rps_cstr, zones->rps_cstr) != 0)
result = dns_fwdtable_find(ev->view->fwdtable, name, NULL,
&dnsforwarders);
if (result == ISC_R_SUCCESS &&
- dnsforwarders->fwdpolicy == dns_fwdpolicy_only) {
+ dnsforwarders->fwdpolicy == dns_fwdpolicy_only)
+ {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: catz_addmodzone_taskaction: "
}
goto cleanup;
} else if (result != ISC_R_NOTFOUND &&
- result != DNS_R_PARTIALMATCH) {
+ result != DNS_R_PARTIALMATCH)
+ {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
"catz: error \"%s\" while trying to "
obj = NULL;
(void)cfg_map_get(zoptions, "type", &obj);
if (obj != NULL &&
- strcasecmp(cfg_obj_asstring(obj), "forward") == 0) {
+ strcasecmp(cfg_obj_asstring(obj), "forward") == 0)
+ {
obj = NULL;
(void)cfg_map_get(zoptions, "forward", &obj);
if (obj == NULL) {
}
if (pzone != NULL &&
- dns_zone_gettype(pzone) != dns_zone_primary) {
+ dns_zone_gettype(pzone) != dns_zone_primary)
+ {
pzone = NULL;
}
if (pzone != NULL && dns_zone_getfile(pzone) != NULL) {
}
if (pview != NULL) {
if (!cache_reusable(pview, view,
- zero_no_soattl)) {
+ zero_no_soattl))
+ {
isc_log_write(named_g_lctx,
NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER,
max_adb_size = 1; /* Force minimum. */
}
if (view != nsc->primaryview &&
- max_adb_size > MAX_ADB_SIZE_FOR_CACHESHARE) {
+ max_adb_size > MAX_ADB_SIZE_FOR_CACHESHARE)
+ {
max_adb_size = MAX_ADB_SIZE_FOR_CACHESHARE;
if (!nsc->adbsizeadjusted) {
dns_adb_setadbsize(nsc->primaryview->adb,
NULL, actx, named_g_mctx, &view->cacheonacl));
if (strcmp(view->name, "_bind") != 0 &&
- view->rdclass != dns_rdataclass_chaos) {
+ view->rdclass != dns_rdataclass_chaos)
+ {
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL,
"allow-recursion", NULL, actx,
(void)named_config_get(maps, "empty-zones-enable", &obj);
(void)named_config_get(maps, "disable-empty-zone", &disablelist);
if (obj == NULL && disablelist == NULL &&
- view->rdclass == dns_rdataclass_in) {
+ view->rdclass == dns_rdataclass_in)
+ {
empty_zones_enable = view->recursion;
} else if (view->rdclass == dns_rdataclass_in) {
if (obj != NULL) {
*/
CHECK(dns_name_fromstring(name, empty, 0, NULL));
if (disablelist != NULL &&
- on_disable_list(disablelist, name)) {
+ on_disable_list(disablelist, name))
+ {
continue;
}
name = dns_fixedname_initname(&fixed);
for (ipv4only_zone = 0; ipv4only_zone < ARRAY_SIZE(zones);
- ipv4only_zone++) {
+ ipv4only_zone++)
+ {
dns_forwarders_t *dnsforwarders = NULL;
CHECK(dns_name_fromstring(
}
if (view->catzs != NULL &&
- dns_catz_get_zone(view->catzs, origin) != NULL) {
+ dns_catz_get_zone(view->catzs, origin) != NULL)
+ {
zone_is_catz = true;
}
isc_nm_setloadbalancesockets(named_g_netmgr,
cfg_obj_asboolean(obj));
} else if (loadbalancesockets !=
- isc_nm_getloadbalancesockets(named_g_netmgr)) {
+ isc_nm_getloadbalancesockets(named_g_netmgr))
+ {
cfg_obj_log(obj, named_g_lctx, ISC_LOG_WARNING,
"changing reuseport value requires server restart");
}
sizeof(server->sctx->secret));
result = isc_hex_decodestring(str, &b);
if (result != ISC_R_SUCCESS &&
- result != ISC_R_NOSPACE) {
+ result != ISC_R_NOSPACE)
+ {
goto cleanup_altsecrets;
}
first = false;
sizeof(altsecret->secret));
result = isc_hex_decodestring(str, &b);
if (result != ISC_R_SUCCESS &&
- result != ISC_R_NOSPACE) {
+ result != ISC_R_NOSPACE)
+ {
isc_mem_put(server->sctx->mctx,
altsecret,
sizeof(*altsecret));
cleanup_viewlist:
for (dns_view_t *view = ISC_LIST_HEAD(viewlist); view != NULL;
- view = view_next) {
+ view = view_next)
+ {
view_next = ISC_LIST_NEXT(view, link);
ISC_LIST_UNLINK(viewlist, view, link);
if (result == ISC_R_SUCCESS && strcmp(view->name, "_bind") != 0)
(void)named_server_saventa(server);
for (kasp = ISC_LIST_HEAD(server->kasplist); kasp != NULL;
- kasp = kasp_next) {
+ kasp = kasp_next)
+ {
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_UNLINK(server->kasplist, kasp, link);
dns_kasp_detach(&kasp);
}
for (view = ISC_LIST_HEAD(server->viewlist); view != NULL;
- view = view_next) {
+ view = view_next)
+ {
view_next = ISC_LIST_NEXT(view, link);
ISC_LIST_UNLINK(server->viewlist, view, link);
dns_view_flushonshutdown(view, flush);
view = ISC_LIST_NEXT(view, link))
{
if (message->rdclass == view->rdclass ||
- message->rdclass == dns_rdataclass_any) {
+ message->rdclass == dns_rdataclass_any)
+ {
const dns_name_t *tsig = NULL;
*sigresult = dns_message_rechecksig(message, view);
}
if (token.type == isc_tokentype_string ||
- token.type == isc_tokentype_qstring) {
+ token.type == isc_tokentype_qstring)
+ {
return (token.value.as_textregion.base);
}
}
for (elt = cfg_list_first(maplist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *map = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
- 0) {
+ 0)
+ {
return (map);
}
}
cert = cfg_obj_asstring(certobj);
if (cfg_map_get(tlsmap, "ca-file", &ca_obj) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
ca_file = cfg_obj_asstring(ca_obj);
}
if (cfg_map_get(tlsmap, "protocols", &tls_proto_list) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
const cfg_listelt_t *proto = NULL;
INSIST(tls_proto_list != NULL);
for (proto = cfg_list_first(tls_proto_list);
}
if (cfg_map_get(tlsmap, "dhparam-file", &dhparam_obj) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
dhparam_file = cfg_obj_asstring(dhparam_obj);
}
if (cfg_map_get(tlsmap, "ciphers", &ciphers_obj) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
ciphers = cfg_obj_asstring(ciphers_obj);
}
}
if (cfg_map_get(http, "listener-clients", &cfg_max_clients) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
INSIST(cfg_max_clients != NULL);
max_clients = cfg_obj_asuint32(cfg_max_clients);
}
if (http != NULL && eplist != NULL) {
for (elt = cfg_list_first(eplist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *ep = cfg_listelt_value(elt);
const char *path = cfg_obj_asstring(ep);
endpoints[i++] = isc_mem_strdup(mctx, path);
arg = next_token(lex, text);
if (arg != NULL &&
- (strcmp(arg, "-clean") == 0 || strcmp(arg, "-clear") == 0)) {
+ (strcmp(arg, "-clean") == 0 || strcmp(arg, "-clear") == 0))
+ {
cleanup = true;
arg = next_token(lex, text);
}
view = dns_zone_getview(zone);
if (strcmp(view->name, "_default") == 0 ||
- strcmp(view->name, "_bind") == 0) {
+ strcmp(view->name, "_bind") == 0)
+ {
vname = "";
sep = "";
} else {
view = dns_zone_getview(mayberaw);
if (strcmp(view->name, "_default") == 0 ||
- strcmp(view->name, "_bind") == 0) {
+ strcmp(view->name, "_bind") == 0)
+ {
vname = "";
sep = "";
} else {
CHECK(add_comment(fp, view->name)); /* force a comment */
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
- elt = ISC_LIST_NEXT(elt, link)) {
+ elt = ISC_LIST_NEXT(elt, link))
+ {
const cfg_obj_t *zconfig = cfg_listelt_value(elt);
CHECK(isc_stdio_write("zone ", 5, 1, fp, NULL));
myname = dns_fixedname_initname(&myfixed);
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
- elt = ISC_LIST_NEXT(elt, link)) {
+ elt = ISC_LIST_NEXT(elt, link))
+ {
const cfg_obj_t *zconf = cfg_listelt_value(elt);
const char *zn;
cfg_listelt_t *e;
if (name1 != NULL) {
result = dns_name_fromstring(name2, vname, 0, NULL);
if (result == ISC_R_SUCCESS &&
- dns_name_equal(name1, name2)) {
+ dns_name_equal(name1, name2))
+ {
const cfg_obj_t *zoptions;
const cfg_obj_t *typeobj = NULL;
zoptions = cfg_tuple_get(obj, "options");
if (strcasecmp(ptr, "-list") == 0) {
list = true;
} else if ((strcasecmp(ptr, "-clear") == 0) ||
- (strcasecmp(ptr, "-clean") == 0)) {
+ (strcasecmp(ptr, "-clean") == 0))
+ {
clear = true;
ptr = next_token(lex, text);
if (ptr == NULL) {
}
if (hash > 0xffU || flags > 0xffU ||
- iter > dns_nsec3_maxiterations()) {
+ iter > dns_nsec3_maxiterations())
+ {
return (ISC_R_RANGE);
}
/* Key refresh time */
if (zonetype == dns_zone_primary ||
- (zonetype == dns_zone_secondary && hasraw)) {
+ (zonetype == dns_zone_secondary && hasraw))
+ {
dns_zone_getrefreshkeytime(zone, &refreshkeytime);
isc_time_formathttptimestamp(&refreshkeytime, kbuf,
sizeof(kbuf));
#endif /* ifdef HAVE_JSON_C */
if ((DNS_RDATASTATSTYPE_ATTR(type) &
- DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) == 0) {
+ DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) == 0)
+ {
dns_rdatatype_format(DNS_RDATASTATSTYPE_BASE(type), typebuf,
sizeof(typebuf));
typestr = typebuf;
#endif /* ifdef HAVE_JSON_C */
if ((DNS_RDATASTATSTYPE_ATTR(type) &
- DNS_RDATASTATSTYPE_ATTR_NXDOMAIN) != 0) {
+ DNS_RDATASTATSTYPE_ATTR_NXDOMAIN) != 0)
+ {
typestr = "NXDOMAIN";
} else if ((DNS_RDATASTATSTYPE_ATTR(type) &
DNS_RDATASTATSTYPE_ATTR_OTHERTYPE) != 0)
view = ISC_LIST_HEAD(server->viewlist);
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "views"));
while (view != NULL &&
- ((flags & (STATS_XML_SERVER | STATS_XML_ZONES)) != 0)) {
+ ((flags & (STATS_XML_SERVER | STATS_XML_ZONES)) != 0))
+ {
isc_stats_t *istats = NULL;
dns_stats_t *dstats = NULL;
}
if (json_object_get_object(refresh_counters)->count !=
- 0) {
+ 0)
+ {
json_object_object_add(zoneobj,
"dnssec-refresh",
refresh_counters);
const cfg_listelt_t *proto = NULL; \
INSIST(obj != NULL); \
for (proto = cfg_list_first(obj); proto != 0; \
- proto = cfg_list_next(proto)) { \
+ proto = cfg_list_next(proto)) \
+ { \
const cfg_obj_t *tls_proto_obj = \
cfg_listelt_value(proto); \
const char *tls_sver = \
*/
algstr = cfg_obj_asstring(algobj);
if (named_config_getkeyalgorithm(algstr, &alg, &bits) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
cfg_obj_log(algobj, named_g_lctx, ISC_LOG_ERROR,
"key '%s': has a "
"unsupported algorithm '%s'",
str = cfg_obj_asstring(matchtype);
CHECK(dns_ssu_mtypefromstring(str, &mtype));
if (mtype == dns_ssumatchtype_subdomain &&
- strcasecmp(str, "zonesub") == 0) {
+ strcasecmp(str, "zonesub") == 0)
+ {
usezone = true;
}
r.length = bracket - str;
max = strtoul(bracket + 1, &end, 10);
if (max > 0xffff || end[0] != /*(*/ ')' ||
- end[1] != 0) {
+ end[1] != 0)
+ {
cfg_obj_log(identity, named_g_lctx,
ISC_LOG_ERROR,
"'%s' is not a valid count",
* there's nothing to do anymore.
*/
if (ISC_LIST_EMPTY(rdatalist_a->rdata) &&
- ISC_LIST_EMPTY(rdatalist_aaaa->rdata)) {
+ ISC_LIST_EMPTY(rdatalist_aaaa->rdata))
+ {
return (ISC_R_SUCCESS);
}
* will be needing a master file.
*/
if (ztype == dns_zone_primary && cpval == default_dbtype &&
- filename == NULL) {
+ filename == NULL)
+ {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
"zone '%s': 'file' not specified", zname);
*/
ns_total = 0;
for (sa = ISC_LIST_HEAD(*nslist); sa != NULL;
- sa = ISC_LIST_NEXT(sa, link)) {
+ sa = ISC_LIST_NEXT(sa, link))
+ {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {
i = 0;
for (sa = ISC_LIST_HEAD(*nslist); sa != NULL;
- sa = ISC_LIST_NEXT(sa, link)) {
+ sa = ISC_LIST_NEXT(sa, link))
+ {
switch (sa->type.sa.sa_family) {
case AF_INET:
if (have_ipv4) {
if (use_tls) {
if ((tls_client_key_file == NULL) !=
- (tls_client_cert_file == NULL)) {
+ (tls_client_cert_file == NULL))
+ {
fprintf(stderr,
"%s: cannot specify the -K option without"
"the -E option, and vice versa.\n",
dns_name_t *bad;
if (!dns_rdata_checkowner(name, rdata->rdclass, rdata->type,
- true)) {
+ true))
+ {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(name, namebuf, sizeof(namebuf));
return (evaluate_realm(cmdline));
}
if (strcasecmp(word, "check-names") == 0 ||
- strcasecmp(word, "checknames") == 0) {
+ strcasecmp(word, "checknames") == 0)
+ {
return (evaluate_checknames(cmdline));
}
if (strcasecmp(word, "check-svcb") == 0 ||
- strcasecmp(word, "checksvcb") == 0) {
+ strcasecmp(word, "checksvcb") == 0)
+ {
return (evaluate_checksvcb(cmdline));
}
if (strcasecmp(word, "gsstsig") == 0) {
}
if (rcvmsg->rcode != dns_rcode_noerror &&
- rcvmsg->rcode != dns_rcode_nxdomain) {
+ rcvmsg->rcode != dns_rcode_nxdomain)
+ {
fatal("response to SOA query was unsuccessful");
}
}
if (rcvmsg->rcode != dns_rcode_noerror &&
- rcvmsg->rcode != dns_rcode_nxdomain) {
+ rcvmsg->rcode != dns_rcode_nxdomain)
+ {
fatal("response to GSS-TSIG query was unsuccessful");
}
}
if (section == DNS_SECTION_ANSWER ||
- section == DNS_SECTION_AUTHORITY) {
+ section == DNS_SECTION_AUTHORITY)
+ {
message->flags &= ~DNS_MESSAGEFLAG_AD;
}
}
result = ns_client_checkaclsilent(qctx->client, NULL,
inst->a_acl, true);
if (result == ISC_R_SUCCESS && inst->v4_a != NONE &&
- is_v4_client(qctx->client)) {
+ is_v4_client(qctx->client))
+ {
client_state->mode = inst->v4_a;
} else if (result == ISC_R_SUCCESS && inst->v6_a != NONE &&
is_v6_client(qctx->client))
}
if (section == DNS_SECTION_ANSWER ||
- section == DNS_SECTION_AUTHORITY) {
+ section == DNS_SECTION_AUTHORITY)
+ {
message->flags &= ~DNS_MESSAGEFLAG_AD;
}
}
(void)cfg_map_get(config, "server", &servers);
if (servers != NULL) {
for (elt = cfg_list_first(servers); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(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));
for (elt = cfg_list_first(keys); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const char *name = NULL;
key = cfg_listelt_value(elt);
break;
case 'b':
if (inet_pton(AF_INET, isc_commandline_argument, &in) ==
- 1) {
+ 1)
+ {
isc_sockaddr_fromin(&local4, &in, 0);
local4set = true;
} else if (inet_pton(AF_INET6, isc_commandline_argument,
- &in6) == 1) {
+ &in6) == 1)
+ {
isc_sockaddr_fromin6(&local6, &in6, 0);
local6set = true;
}
}
if (strcmp(name, "too-long") == 0 ||
- strcmp(zone, "bigcname.domain") == 0) {
+ strcmp(zone, "bigcname.domain") == 0)
+ {
for (i = 0; i < 511; i++) {
buf[i] = 'x';
}
}
if (strcmp(name, "long.name.is.not.there") == 0 &&
- strcmp(zone, ".") == 0) {
+ strcmp(zone, ".") == 0)
+ {
result = state->putrr(lookup, "A", 0, "100.100.100.3");
found = true;
if (result != ISC_R_SUCCESS) {
CHECK(dns_db_addrdataset(sampledb->rbtdb, node, version, now, rdataset,
options, addedrdataset));
if (rdataset->type == dns_rdatatype_a ||
- rdataset->type == dns_rdatatype_aaaa) {
+ rdataset->type == dns_rdatatype_aaaa)
+ {
CHECK(sample_name_fromnode(node, dns_fixedname_name(&name)));
CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
rdataset, DNS_DIFFOP_ADD));
}
if (rdataset->type == dns_rdatatype_a ||
- rdataset->type == dns_rdatatype_aaaa) {
+ rdataset->type == dns_rdatatype_aaaa)
+ {
CHECK(sample_name_fromnode(node, dns_fixedname_name(&name)));
CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
rdataset, DNS_DIFFOP_DEL));
rsp = NULL;
if (!librpz->rsp_create(&emsg, &rsp, NULL, client, true,
false) ||
- rsp == NULL) {
+ rsp == NULL)
+ {
fprintf(stderr, "## %s\n", emsg.c);
librpz->client_detach(&client);
return (1);
break;
}
if (*rp != ' ' && *rp != '\t' && *rp != '\r' &&
- *rp != '\n') {
+ *rp != '\n')
+ {
*wp++ = *rp;
len++;
}
dns_rdataset_next(rdataset);
dns_rdata_reset(&rdata);
if (strlen("\n") >=
- isc_buffer_availablelength(buf)) {
+ isc_buffer_availablelength(buf))
+ {
goto buftoosmall;
}
isc_buffer_putstr(buf, "\n");
}
/* Look for dash value option. */
if (strpbrk(option, dash_opts) != &option[0] ||
- strlen(option) > 1U) {
+ strlen(option) > 1U)
+ {
/* Error or value in option. */
continue;
}
if (rc <= 1) {
if (dash_option(&rv[0][1], NULL, query, global,
- &setname)) {
+ &setname))
+ {
rc--;
rv++;
}
} else {
if (dash_option(&rv[0][1], rv[1], query, global,
- &setname)) {
+ &setname))
+ {
rc--;
rv++;
}
/* split string into dns data parts. */
if (bdbhpt_parse_data(db->log, tmp, &pd) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
goto allnodes_cleanup;
}
result = db->putnamedrr(allnodes, pd.host, pd.type,
flags = DB_SET;
while ((bdbhptres = data_cursor->c_get(data_cursor, &key, &data,
- flags)) == 0) {
+ flags)) == 0)
+ {
flags = DB_NEXT_DUP;
tmp = realloc(tmp, data.size + 1);
if (tmp == NULL) {
break;
}
if (strlen((char *)&tmpPtr[i + 1]) <=
- (unsigned int)cd->splitcnt) {
+ (unsigned int)cd->splitcnt)
+ {
break;
}
i += cd->splitcnt;
*/
while ((tmpPtr = strrchr(
tmpString,
- cd->pathsep)) != NULL) {
+ cd->pathsep)) != NULL)
+ {
if ((strlen(host) +
strlen(tmpPtr + 1) + 2) >
- DIR_NAMEMAX) {
+ DIR_NAMEMAX)
+ {
continue;
}
strcat(host, tmpPtr + 1);
tmpPtr[0] = '\0';
}
if ((strlen(host) + strlen(tmpString) +
- 1) <= DIR_NAMEMAX) {
+ 1) <= DIR_NAMEMAX)
+ {
strcat(host, tmpString);
}
}
*/
while (dir_read(dir) == ISC_R_SUCCESS) {
if (strncasecmp(".host", dir->entry.name, 5) ==
- 0) {
+ 0)
+ {
/*
* handle filesystem's special
* wildcard "-"
*/
if (strcmp((char *)&dir->entry.name[6],
- "-") == 0) {
+ "-") == 0)
+ {
strcpy(host, "*");
} else {
strncpy(host,
while (r++ < rrcount) {
record_ref = POPs;
if ((!SvROK(record_ref)) ||
- (SvTYPE(SvRV(record_ref)) != SVt_PVAV)) {
+ (SvTYPE(SvRV(record_ref)) != SVt_PVAV))
+ {
cd->log(ISC_LOG_ERROR,
"DLZ Perl: allnodes for zone %s "
"returned an invalid value "
rr_data = av_fetch((AV *)record_ref, 3, 0);
if (rr_name == NULL || rr_type == NULL || rr_ttl == NULL ||
- rr_data == NULL) {
+ rr_data == NULL)
+ {
cd->log(ISC_LOG_ERROR,
"DLZ Perl: allnodes for zone %s "
"returned an array that was missing data",
while (r++ < rrcount) {
record_ref = POPs;
if ((!SvROK(record_ref)) ||
- (SvTYPE(SvRV(record_ref)) != SVt_PVAV)) {
+ (SvTYPE(SvRV(record_ref)) != SVt_PVAV))
+ {
cd->log(ISC_LOG_ERROR, "DLZ Perl: lookup returned an "
"invalid value (expected array "
"of arrayrefs)!");
if (strcmp(cd->record, nrec->name) == 0) {
/* We handle authority data in dlz_authority() */
if (strcmp(nrec->type, "SOA") == 0 ||
- strcmp(nrec->type, "NS") == 0) {
+ strcmp(nrec->type, "NS") == 0)
+ {
nrec = next;
continue;
}
/* General case, use recursion. */
while ((test = *string) != EOS) {
if (!fnmatch(pattern, string,
- flags & ~FNM_PERIOD)) {
+ flags & ~FNM_PERIOD))
+ {
return (0);
}
if (test == '/' && flags & FNM_PATHNAME) {
}
if (*pattern == '-' && (c2 = *(pattern + 1)) != EOS &&
- c2 != ']') {
+ c2 != ']')
+ {
pattern += 2;
if (c2 == '\\' && !(flags & FNM_NOESCAPE)) {
c2 = *pattern++;
usage();
}
if (strcmp(argv[1], "master") == 0 ||
- strcmp(argv[1], "primary") == 0) {
+ strcmp(argv[1], "primary") == 0)
+ {
zonetype = CFG_ZONE_PRIMARY;
} else if (strcmp(argv[1], "slave") == 0 ||
- strcmp(argv[1], "secondary") == 0) {
+ strcmp(argv[1], "secondary") == 0)
+ {
zonetype = CFG_ZONE_SECONDARY;
} else if (strcmp(argv[1], "mirror") == 0) {
zonetype = CFG_ZONE_MIRROR;
obj = cfg_tuple_get(ent, "order");
if (!cfg_obj_isstring(obj) ||
- strcasecmp("order", cfg_obj_asstring(obj)) != 0) {
+ strcasecmp("order", cfg_obj_asstring(obj)) != 0)
+ {
cfg_obj_log(ent, logctx, ISC_LOG_ERROR,
"rrset-order: keyword 'order' missing");
if (result == ISC_R_SUCCESS) {
}
if (strcasecmp(aclname, "allow-transfer") == 0 &&
- cfg_obj_istuple(aclobj)) {
+ cfg_obj_istuple(aclobj))
+ {
const cfg_obj_t *obj_port = cfg_tuple_get(
cfg_tuple_get(aclobj, "port-transport"), "port");
const cfg_obj_t *obj_proto = cfg_tuple_get(
cfg_tuple_get(aclobj, "port-transport"), "transport");
if (cfg_obj_isuint32(obj_port) &&
- cfg_obj_asuint32(obj_port) >= UINT16_MAX) {
+ cfg_obj_asuint32(obj_port) >= UINT16_MAX)
+ {
cfg_obj_log(obj_port, logctx, ISC_LOG_ERROR,
"port value '%u' is out of range",
}
for (elt = cfg_list_first(maplist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *map = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(map)), name) ==
- 0) {
+ 0)
+ {
return (map);
}
}
portobj = cfg_tuple_get(ltup, "port");
if (cfg_obj_isuint32(portobj) &&
- cfg_obj_asuint32(portobj) >= UINT16_MAX) {
+ cfg_obj_asuint32(portobj) >= UINT16_MAX)
+ {
cfg_obj_log(portobj, logctx, ISC_LOG_ERROR,
"port value '%u' is out of range",
}
for (kasp = ISC_LIST_HEAD(list); kasp != NULL;
- kasp = kasp_next) {
+ kasp = kasp_next)
+ {
kasp_next = ISC_LIST_NEXT(kasp, link);
ISC_LIST_UNLINK(list, kasp, link);
dns_kasp_detach(&kasp);
tresult = mustbesecure(obj, symtab, logctx,
mctx);
if (result == ISC_R_SUCCESS &&
- tresult != ISC_R_SUCCESS) {
+ tresult != ISC_R_SUCCESS)
+ {
result = tresult;
}
}
usedlength = isc_buffer_usedlength(&b);
if (strcasecmp(ccalg, "aes") == 0 &&
- usedlength != ISC_AES128_KEYLENGTH) {
+ usedlength != ISC_AES128_KEYLENGTH)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"AES cookie-secret must be 128 "
"bits");
value = cfg_obj_asuint32(obj);
}
if (value < fstrm[i].min ||
- (fstrm[i].max != 0U && value > fstrm[i].max)) {
+ (fstrm[i].max != 0U && value > fstrm[i].max))
+ {
if (fstrm[i].max != 0U) {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"%s '%u' out of range (%u..%u)",
obj2 = cfg_tuple_get(obj, "size");
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
- dmode == dns_dtmode_unix) {
+ dmode == dns_dtmode_unix)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnstap-output size "
"cannot be set with mode unix");
obj2 = cfg_tuple_get(obj, "versions");
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
- dmode == dns_dtmode_unix) {
+ dmode == dns_dtmode_unix)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnstap-output versions "
"cannot be set with mode unix");
obj2 = cfg_tuple_get(obj, "suffix");
if (obj2 != NULL && !cfg_obj_isvoid(obj2) &&
- dmode == dns_dtmode_unix) {
+ dmode == dns_dtmode_unix)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnstap-output suffix "
"cannot be set with mode unix");
tresult = cfg_map_get(http, "endpoints", &eps);
if (tresult == ISC_R_SUCCESS) {
for (elt = cfg_list_first(eps); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *ep = cfg_listelt_value(elt);
const char *path = cfg_obj_asstring(ep);
if (!isc_nm_http_path_isvalid(path)) {
/* Check for "update-policy local;" */
if (cfg_obj_isstring(policy) &&
- strcmp("local", cfg_obj_asstring(policy)) == 0) {
+ strcmp("local", cfg_obj_asstring(policy)) == 0)
+ {
return (ISC_R_SUCCESS);
}
* There is no name field for subzone and dname is void
*/
if (mtype == dns_ssumatchtype_subdomain &&
- cfg_obj_isvoid(dname)) {
+ cfg_obj_isvoid(dname))
+ {
str = "."; /* Use "." as a replacement. */
} else {
str = cfg_obj_asstring(dname);
case dns_ssumatchtype_tcpself:
case dns_ssumatchtype_6to4self:
if (tresult == ISC_R_SUCCESS &&
- !dns_name_equal(dns_rootname, name)) {
+ !dns_name_equal(dns_rootname, name))
+ {
cfg_obj_log(identity, logctx, ISC_LOG_ERROR,
"name field not set to "
"placeholder value '.'");
r.length = bracket - r.base;
max = strtoul(bracket + 1, &end, 10);
if (max > 0xffff || end[0] != /*(*/ ')' ||
- end[1] != 0) {
+ end[1] != 0)
+ {
cfg_obj_log(typeobj, logctx,
ISC_LOG_ERROR,
"'%s' is not a valid count",
typestr = cfg_obj_asstring(obj);
if (strcasecmp(typestr, "master") == 0 ||
- strcasecmp(typestr, "primary") == 0) {
+ strcasecmp(typestr, "primary") == 0)
+ {
ztype = CFG_ZONE_PRIMARY;
} else if (strcasecmp(typestr, "slave") == 0 ||
strcasecmp(typestr, "secondary") == 0)
isc_mem_free(mctx, tmp);
}
if (result == ISC_R_SUCCESS &&
- tresult != ISC_R_SUCCESS) {
+ tresult != ISC_R_SUCCESS)
+ {
result = tresult;
}
}
const cfg_obj_t *kobj = cfg_tuple_get(
cfg_listelt_value(element), "name");
if (strcmp(kaspname, cfg_obj_asstring(kobj)) ==
- 0) {
+ 0)
+ {
has_dnssecpolicy = true;
}
}
obj = NULL;
res1 = cfg_map_get(zoptions, "dnssec-dnskey-kskonly", &obj);
if (res1 == ISC_R_SUCCESS && ztype == CFG_ZONE_SECONDARY &&
- !signing) {
+ !signing)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnssec-dnskey-kskonly: requires "
"inline-signing when used in secondary "
obj = NULL;
res1 = cfg_map_get(zoptions, "dnssec-loadkeys-interval", &obj);
if (res1 == ISC_R_SUCCESS && ztype == CFG_ZONE_SECONDARY &&
- !signing) {
+ !signing)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"dnssec-loadkeys-interval: requires "
"inline-signing when used in secondary "
obj = NULL;
res1 = cfg_map_get(zoptions, "update-check-ksk", &obj);
if (res1 == ISC_R_SUCCESS && ztype == CFG_ZONE_SECONDARY &&
- !signing) {
+ !signing)
+ {
cfg_obj_log(obj, logctx, ISC_LOG_ERROR,
"update-check-ksk: requires "
"inline-signing when used in secondary "
if (obj != NULL && cfg_obj_isstring(obj)) {
const char *str = cfg_obj_asstring(obj);
for (i = 0; i < sizeof(dialups) / sizeof(dialups[0]);
- i++) {
+ i++)
+ {
if (strcasecmp(dialups[i].name, str) != 0) {
continue;
}
cfg_map_get(goptions, "forward", &obj);
}
if (obj == NULL ||
- strcasecmp(cfg_obj_asstring(obj), "first") == 0) {
+ strcasecmp(cfg_obj_asstring(obj), "first") == 0)
+ {
cfg_obj_log(zconfig, logctx, ISC_LOG_WARNING,
"inherited 'forward first;' for "
"%s zone '%s' - did you want "
result = isc_parse_uint16(&digestbits, algorithm + len + 1, 10);
if (result == ISC_R_SUCCESS || result == ISC_R_RANGE) {
if (result == ISC_R_RANGE ||
- digestbits > algorithms[i].size) {
+ digestbits > algorithms[i].size)
+ {
cfg_obj_log(algobj, logctx, ISC_LOG_ERROR,
"key '%s' digest-bits too large "
"[%u..%u]",
* Recommended minima for hmac algorithms.
*/
if ((digestbits < (algorithms[i].size / 2U) ||
- (digestbits < 80U))) {
+ (digestbits < 80U)))
+ {
cfg_obj_log(algobj, logctx, ISC_LOG_WARNING,
"key '%s' digest-bits too small "
"[<%u]",
}
if (result == ISC_R_SUCCESS &&
- dns_name_equal(keyname, dns_rootname)) {
+ dns_name_equal(keyname, dns_rootname))
+ {
/*
* Flag any use of a root key, regardless of content.
*/
result = ISC_R_FAILURE;
}
if (result == ISC_R_SUCCESS &&
- dns_name_equal(keyname, dns_rootname)) {
+ dns_name_equal(keyname, dns_rootname))
+ {
/*
* Flag any use of a root key, regardless of content.
*/
name = dns_fixedname_initname(&fixed);
for (elt = cfg_list_first(keylist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const char *initmethod;
const cfg_obj_t *init = NULL;
const cfg_obj_t *obj = cfg_listelt_value(elt);
name = dns_fixedname_initname(&fixed);
for (elt = cfg_list_first(keylist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *obj = cfg_listelt_value(elt);
const cfg_obj_t *init = NULL;
const char *str;
name = dns_fixedname_initname(&fixed);
for (elt = cfg_list_first(keylist); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const char *initmethod;
const cfg_obj_t *init = NULL;
const cfg_obj_t *obj = cfg_listelt_value(elt);
* and all the DS-style trust anchors.
*/
for (elt = cfg_list_first(global_ta); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist, logctx,
autovalidation);
}
for (elt = cfg_list_first(view_ta); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist, logctx,
autovalidation);
}
for (elt = cfg_list_first(global_tkeys); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist, logctx,
autovalidation);
}
for (elt = cfg_list_first(view_tkeys); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = record_static_keys(statictab, mctx, keylist, logctx,
autovalidation);
* static keys and the trust-anchors configured with "initial-key".
*/
for (elt = cfg_list_first(global_ta); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = check_initializing_keys(statictab, keylist, logctx);
if (result == ISC_R_SUCCESS) {
}
for (elt = cfg_list_first(view_ta); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
keylist = cfg_listelt_value(elt);
tresult = check_initializing_keys(statictab, keylist, logctx);
if (result == ISC_R_SUCCESS) {
if (primariesobj != NULL && cfg_obj_istuple(primariesobj)) {
primariesobj = cfg_tuple_get(obj, "default-masters");
if (primariesobj != NULL &&
- cfg_obj_istuple(primariesobj)) {
+ cfg_obj_istuple(primariesobj))
+ {
cfg_obj_log(nameobj, logctx, ISC_LOG_ERROR,
"catalog zone '%s'%s%s: "
"'default-primaries' and "
result = ISC_R_FAILURE;
}
if (voptions != NULL &&
- check_nonzero(voptions, logctx) != ISC_R_SUCCESS) {
+ check_nonzero(voptions, logctx) != ISC_R_SUCCESS)
+ {
result = ISC_R_FAILURE;
}
* Global servers can refer to keys in views.
*/
if (check_servers(config, voptions, symtab, mctx, logctx) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
result = ISC_R_FAILURE;
}
}
if ((flags & ROOT_KSK_2010) != 0 &&
- (flags & ROOT_KSK_2017) == 0) {
+ (flags & ROOT_KSK_2017) == 0)
+ {
cfg_obj_log(check_keys[i], logctx,
ISC_LOG_WARNING,
"initial-key entry for the root "
}
if (bind9_check_parentalagentlists(config, logctx, mctx) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
result = ISC_R_FAILURE;
}
const char *aclname;
for (elt = cfg_list_first(acls); elt != NULL;
- elt = cfg_list_next(elt)) {
+ elt = cfg_list_next(elt))
+ {
const cfg_obj_t *acl = cfg_listelt_value(elt);
unsigned int line = cfg_obj_line(acl);
unsigned int i;
aclname = cfg_obj_asstring(cfg_tuple_get(acl, "name"));
for (i = 0; i < sizeof(builtin) / sizeof(builtin[0]);
- i++) {
+ i++)
+ {
if (strcasecmp(aclname, builtin[i]) == 0) {
{
cfg_obj_log(acl, logctx,
}
for (elt2 = cfg_list_next(elt); elt2 != NULL;
- elt2 = cfg_list_next(elt2)) {
+ elt2 = cfg_list_next(elt2))
+ {
const cfg_obj_t *acl2 = cfg_listelt_value(elt2);
const char *name;
name = cfg_obj_asstring(
return (ISC_R_FAILURE);
}
for (tmpai = ai, i = 0; tmpai != NULL && i < addrsize;
- tmpai = tmpai->ai_next) {
+ tmpai = tmpai->ai_next)
+ {
if (tmpai->ai_family != AF_INET && tmpai->ai_family != AF_INET6)
{
continue;
*/
next_entry = ISC_LIST_NEXT(entry, plink);
if (isc_refcount_current(&entry->references) == 1 &&
- entry->expires == 0) {
+ entry->expires == 0)
+ {
unlink_entry(entry);
}
entry_detach(&entry);
/* Search the list, while cleaning up expired entries. */
for (entry = ISC_LIST_HEAD(ebucket->entries); entry != NULL;
- entry = entry_next) {
+ entry = entry_next)
+ {
entry_next = ISC_LIST_NEXT(entry, plink);
/* Address entries expire after 30 minutes. */
}
if (!FIND_RETURNLAME(find) &&
- entry_is_lame(adb, entry, qname, qtype, now)) {
+ entry_is_lame(adb, entry, qname, qtype, now))
+ {
find->options |= DNS_ADBFIND_LAMEPRUNED;
goto nextv4;
}
}
if (!FIND_RETURNLAME(find) &&
- entry_is_lame(adb, entry, qname, qtype, now)) {
+ entry_is_lame(adb, entry, qname, qtype, now))
+ {
find->options |= DNS_ADBFIND_LAMEPRUNED;
goto nextv6;
}
void
dns_adb_shutdown(dns_adb_t *adb) {
if (!atomic_compare_exchange_strong(&adb->exiting, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
dns_adbnamehook_t *nh = NULL;
for (nh = ISC_LIST_HEAD(*list); nh != NULL;
- nh = ISC_LIST_NEXT(nh, plink)) {
+ nh = ISC_LIST_NEXT(nh, plink))
+ {
if (debug) {
fprintf(f, ";\tHook(%s) %p\n", legend, nh);
}
fetch = name->fetch_a;
name->fetch_a = NULL;
} else if (NAME_FETCH_AAAA(name) &&
- (name->fetch_aaaa->fetch == dev->fetch)) {
+ (name->fetch_aaaa->fetch == dev->fetch))
+ {
address_type = DNS_ADBFIND_INET6;
fetch = name->fetch_aaaa;
name->fetch_aaaa = NULL;
LOCK(&ebucket->lock);
li = ISC_LIST_HEAD(addr->entry->lameinfo);
while (li != NULL &&
- (li->qtype != qtype || !dns_name_equal(qname, &li->qname))) {
+ (li->qtype != qtype || !dns_name_equal(qname, &li->qname)))
+ {
li = ISC_LIST_NEXT(li, plink);
}
if (li != NULL) {
while (adbname != NULL) {
nextname = ISC_LIST_NEXT(adbname, plink);
if (!NAME_DEAD(adbname) &&
- dns_name_issubdomain(&adbname->name, name)) {
+ dns_name_issubdomain(&adbname->name, name))
+ {
expire_name(&adbname, DNS_EVENT_ADBCANCELED);
}
adbname = nextname;
count = atomic_fetch_add_relaxed(&bc->count, 1);
if ((count > bc->size * 8) ||
- (count < bc->size * 2 && bc->size > bc->minsize)) {
+ (count < bc->size * 2 && bc->size > bc->minsize))
+ {
resize = true;
}
} else {
for (size_t i = 0; i < eb->opts.masters.count; i++) {
if ((ea->opts.masters.keys[i] == NULL) !=
- (eb->opts.masters.keys[i] == NULL)) {
+ (eb->opts.masters.keys[i] == NULL))
+ {
return (false);
}
if (ea->opts.masters.keys[i] == NULL) {
continue;
}
if (!dns_name_equal(ea->opts.masters.keys[i],
- eb->opts.masters.keys[i])) {
+ eb->opts.masters.keys[i]))
+ {
return (false);
}
}
for (size_t i = 0; i < eb->opts.masters.count; i++) {
if ((ea->opts.masters.tlss[i] == NULL) !=
- (eb->opts.masters.tlss[i] == NULL)) {
+ (eb->opts.masters.tlss[i] == NULL))
+ {
return (false);
}
if (ea->opts.masters.tlss[i] == NULL) {
continue;
}
if (!dns_name_equal(ea->opts.masters.tlss[i],
- eb->opts.masters.tlss[i])) {
+ eb->opts.masters.tlss[i]))
+ {
return (false);
}
}
/* Repeat the above checks with allow_transfer */
if ((ea->opts.allow_transfer == NULL) !=
- (eb->opts.allow_transfer == NULL)) {
+ (eb->opts.allow_transfer == NULL))
+ {
return (false);
}
}
}
if (zt_find_result == ISC_R_SUCCESS ||
- zt_find_result == DNS_R_PARTIALMATCH) {
+ zt_find_result == DNS_R_PARTIALMATCH)
+ {
dns_zone_detach(&zone);
}
(void **)&oentry);
if (result != ISC_R_SUCCESS) {
if (zt_find_result == ISC_R_SUCCESS &&
- parentcatz == target) {
+ parentcatz == target)
+ {
/*
* This means that the zone's unique label
* has been changed, in that case we must
isc_result_t result;
isc_ht_iter_create(catzs->zones, &iter);
for (result = isc_ht_iter_first(iter);
- result == ISC_R_SUCCESS;) {
+ result == ISC_R_SUCCESS;)
+ {
dns_catz_zone_t *zone = NULL;
isc_ht_iter_current(iter, (void **)&zone);
result = isc_ht_iter_delcurrent_next(iter);
size_t len = strlen(opt);
if (option->length - 1 == len &&
- memcmp(opt, option->base + 1, len) == 0) {
+ memcmp(opt, option->base + 1, len) == 0)
+ {
return (true);
} else {
return (false);
} else if (catz_opt_cmp(option, "zones")) {
return (CATZ_OPT_ZONES);
} else if (catz_opt_cmp(option, "masters") ||
- catz_opt_cmp(option, "primaries")) {
+ catz_opt_cmp(option, "primaries"))
+ {
return (CATZ_OPT_PRIMARIES);
} else if (catz_opt_cmp(option, "allow-query")) {
return (CATZ_OPT_ALLOW_QUERY);
*/
for (i = 0; i < ipkl->count; i++) {
if (ipkl->labels[i] != NULL &&
- !dns_name_compare(name, ipkl->labels[i])) {
+ !dns_name_compare(name, ipkl->labels[i]))
+ {
break;
}
}
tresult = dns_rdatasetiter_next(rdsiter);
if (tresult == ISC_R_SUCCESS &&
- rctx->rdataset == NULL) {
+ rctx->rdataset == NULL)
+ {
tresult = getrdataset(mctx,
&rctx->rdataset);
if (tresult != ISC_R_SUCCESS) {
dns_rdataset_t *rdataset;
while ((rdataset = ISC_LIST_HEAD(ansname->list)) !=
- NULL) {
+ NULL)
+ {
ISC_LIST_UNLINK(ansname->list, rdataset, link);
putrdataset(mctx, &rdataset);
}
* of the name and accumulating the hash in the same manner
*/
while (insert_label(cctx, buffer, name, label, hash, probe) &&
- label-- > 0) {
+ label-- > 0)
+ {
unsigned int prefix_len = name->offsets[label];
uint8_t *suffix_ptr = name->ndata + prefix_len;
hash = hash_label(hash, suffix_ptr, sensitive);
unsigned int prev = slot;
unsigned int next = slot_index(cctx, prev, 1);
while (cctx->set[next].coff != 0 &&
- probe_distance(cctx, next) != 0) {
+ probe_distance(cctx, next) != 0)
+ {
cctx->set[prev] = cctx->set[next];
prev = next;
next = slot_index(cctx, prev, 1);
listener = ISC_LIST_NEXT(listener, link))
{
if ((listener->onupdate == fn) &&
- (listener->onupdate_arg == fn_arg)) {
+ (listener->onupdate_arg == fn_arg))
+ {
ISC_LIST_UNLINK(db->update_listeners, listener, link);
isc_mem_put(db->mctx, listener,
sizeof(dns_dbonupdatelistener_t));
node = NULL;
if (type != dns_rdatatype_nsec3 &&
- covers != dns_rdatatype_nsec3) {
+ covers != dns_rdatatype_nsec3)
+ {
CHECK(dns_db_findnode(db, name, true, &node));
} else {
CHECK(dns_db_findnsec3node(db, name, true,
resign);
}
if (op == DNS_DIFFOP_ADD ||
- op == DNS_DIFFOP_ADDRESIGN) {
+ op == DNS_DIFFOP_ADDRESIGN)
+ {
setownercase(&ardataset, name);
}
if (op == DNS_DIFFOP_DEL ||
- op == DNS_DIFFOP_DELRESIGN) {
+ op == DNS_DIFFOP_DELRESIGN)
+ {
getownercase(&ardataset, name);
}
} else if (result == DNS_R_UNCHANGED) {
namebuf, classbuf);
}
if (op == DNS_DIFFOP_ADD ||
- op == DNS_DIFFOP_ADDRESIGN) {
+ op == DNS_DIFFOP_ADDRESIGN)
+ {
setownercase(&ardataset, name);
}
if (op == DNS_DIFFOP_DEL ||
- op == DNS_DIFFOP_DELRESIGN) {
+ op == DNS_DIFFOP_DELRESIGN)
+ {
getownercase(&ardataset, name);
}
} else if (result == DNS_R_NXRRSET) {
* OK.
*/
if (op == DNS_DIFFOP_DEL ||
- op == DNS_DIFFOP_DELRESIGN) {
+ op == DNS_DIFFOP_DELRESIGN)
+ {
getownercase(&ardataset, name);
}
if (dns_rdataset_isassociated(&ardataset)) {
"dns_diff_load: "
"update with no effect");
} else if (result == ISC_R_SUCCESS ||
- result == DNS_R_NXRRSET) {
+ result == DNS_R_NXRRSET)
+ {
/*
* OK.
*/
REQUIRE(DNS_DIFF_VALID(diff));
for (p = ISC_LIST_HEAD(diff->tuples); p != NULL;
- p = ISC_LIST_NEXT(p, link)) {
+ p = ISC_LIST_NEXT(p, link))
+ {
length++;
}
if (length == 0) {
mem = isc_mem_get(diff->mctx, size);
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
- t = ISC_LIST_NEXT(t, link)) {
+ t = ISC_LIST_NEXT(t, link))
+ {
isc_buffer_t buf;
isc_region_t r;
while (res != NULL) {
if (res->id == id && isc_sockaddr_equal(dest, &res->peer) &&
- res->port == port) {
+ res->port == port)
+ {
return (res);
}
res = ISC_LIST_NEXT(res, link);
isc_sockaddr_eqaddr(localaddr, &sockname)))
{
if (atomic_load(&disp->tcpstate) ==
- DNS_DISPATCHSTATE_CONNECTED) {
+ DNS_DISPATCHSTATE_CONNECTED)
+ {
/* We found connected dispatch */
disp_connected = disp;
UNLOCK(&disp->lock);
case isc_socktype_tcp:
if (atomic_compare_exchange_strong(&disp->tcpreading,
- &(bool){ false }, true)) {
+ &(bool){ false }, true))
+ {
dns_dispatch_attach(disp, &(dns_dispatch_t *){ NULL });
if (timeout > 0) {
isc_nmhandle_settimeout(disp->handle, timeout);
librpz_emsg_t emsg;
if (!librpz->rsp_soa(&emsg, &ttl, NULL, NULL, &rpsdb->result,
- rpsdb->rsp)) {
+ rpsdb->rsp))
+ {
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
return (DNS_R_SERVFAIL);
}
}
RD_NEXT_RR(rdataset) = LIBRPZ_IDX_NULL;
if (!librpz->rsp_soa(&emsg, NULL, &rr, NULL, &rpsdb->result,
- rpsdb->rsp)) {
+ rpsdb->rsp))
+ {
librpz->log(LIBRPZ_LOG_ERROR, NULL, "%s", emsg.c);
return (DNS_R_SERVFAIL);
}
dst_key_setttl(pubkey, rdataset.ttl);
if (!is_zone_key(pubkey) ||
- (dst_key_flags(pubkey) & DNS_KEYTYPE_NOAUTH) != 0) {
+ (dst_key_flags(pubkey) & DNS_KEYTYPE_NOAUTH) != 0)
+ {
goto next;
}
/* Corrupted .key file? */
directory, mctx, &keys[count]);
if (result == ISC_R_SUCCESS &&
dst_key_pubcompare(pubkey, keys[count],
- false)) {
+ false))
+ {
dst_key_setflags(keys[count], flags);
}
dst_key_setflags(pubkey, flags);
* Did we correctly terminate?
*/
if (i != len + 1 + 1 + 3 || i >= dir.entry.length ||
- dir.entry.name[i] != '+') {
+ dir.entry.name[i] != '+')
+ {
continue;
}
/* Skip duplicates */
for (key = ISC_LIST_HEAD(*keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (dst_key_id(key->key) == dst_key_id(*newkey) &&
dst_key_alg(key->key) == dst_key_alg(*newkey) &&
dns_name_equal(dst_key_name(key->key),
dns_rdataset_init(&sigs);
dns_rdataset_clone(rrsigs, &sigs);
for (key = ISC_LIST_HEAD(*keylist); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
uint16_t keyid, sigid;
dns_secalg_t keyalg, sigalg;
keyid = dst_key_id(key->key);
dst_key_setttl(dnskey, keys.ttl);
if (!is_zone_key(dnskey) ||
- (dst_key_flags(dnskey) & DNS_KEYTYPE_NOAUTH) != 0) {
+ (dst_key_flags(dnskey) & DNS_KEYTYPE_NOAUTH) != 0)
+ {
goto skip;
}
dns_dnsseckey_t *key;
for (key = ISC_LIST_HEAD(*keys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
dns_rdata_t cds_sha1 = DNS_RDATA_INIT;
dns_rdata_t cds_sha256 = DNS_RDATA_INIT;
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
dst_key_format(key->key, keystr, sizeof(keystr));
if (!dns_rdataset_isassociated(cdnskey) ||
- !exists(cdnskey, &cdnskeyrdata)) {
+ !exists(cdnskey, &cdnskeyrdata))
+ {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC,
ISC_LOG_INFO,
}
/* Only publish SHA-256 (SHA-1 is deprecated) */
if (!dns_rdataset_isassociated(cds) ||
- !exists(cds, &cds_sha256)) {
+ !exists(cds, &cds_sha256))
+ {
isc_log_write(
dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
}
if (!dns_rdataset_isassociated(cds) &&
- !dns_rdataset_isassociated(cdnskey)) {
+ !dns_rdataset_isassociated(cdnskey))
+ {
return (ISC_R_SUCCESS);
}
* Unconditionally remove CDS/DNSKEY records for removed keys.
*/
for (key = ISC_LIST_HEAD(*rmkeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
dns_rdata_t cds_sha1 = DNS_RDATA_INIT;
dns_rdata_t cds_sha256 = DNS_RDATA_INIT;
dns_rdata_t cdnskeyrdata = DNS_RDATA_INIT;
if (expect_cds_delete) {
if (!dns_rdataset_isassociated(cds) ||
- !exists(cds, &cds_delete)) {
+ !exists(cds, &cds_delete))
+ {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDS (DELETE) for zone %s is now "
if (expect_cdnskey_delete) {
if (!dns_rdataset_isassociated(cdnskey) ||
- !exists(cdnskey, &cdnskey_delete)) {
+ !exists(cdnskey, &cdnskey_delete))
+ {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY (DELETE) for zone %s is now "
}
} else {
if (dns_rdataset_isassociated(cdnskey) &&
- exists(cdnskey, &cdnskey_delete)) {
+ exists(cdnskey, &cdnskey_delete))
+ {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
"CDNSKEY (DELETE) for zone %s is now "
* use their TTL for all subsequent published keys.
*/
for (key = ISC_LIST_HEAD(*keys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (key->source == dns_keysource_user &&
(key->hint_publish || key->force_publish))
{
dns_ttl_t shortest = 0;
for (key = ISC_LIST_HEAD(*newkeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
dns_ttl_t thisttl = dst_key_getttl(key->key);
if (thisttl != 0 &&
- (shortest == 0 || thisttl < shortest)) {
+ (shortest == 0 || thisttl < shortest))
+ {
shortest = thisttl;
}
}
continue;
} else {
if (!key2->is_active &&
- (key1->hint_sign || key1->force_sign)) {
+ (key1->hint_sign || key1->force_sign))
+ {
key2->first_sign = true;
isc_log_write(
dns_lctx, DNS_LOGCATEGORY_DNSSEC,
key1->ksk ? (key1->zsk ? "CSK" : "KSK")
: "ZSK");
} else if (key2->is_active && !key1->hint_sign &&
- !key1->force_sign) {
+ !key1->force_sign)
+ {
isc_log_write(
dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
return (false);
}
if (key1->key_id != key2->key_rid &&
- key1->key_rid != key2->key_id) {
+ key1->key_rid != key2->key_id)
+ {
return (false);
}
}
}
isc_buffer_putstr(out, directory);
if (strlen(directory) > 0U &&
- directory[strlen(directory) - 1] != '/') {
+ directory[strlen(directory) - 1] != '/')
+ {
isc_buffer_putstr(out, "/");
}
}
for (i = 0; map[i].tag != NULL; i++) {
if (strcasecmp(s, map[i].tag) == 0 &&
- (TAG_ALG(map[i].value) == alg)) {
+ (TAG_ALG(map[i].value) == alg))
+ {
return (map[i].value);
}
}
REQUIRE(ecs1 != NULL && ecs2 != NULL);
if (ecs1->source != ecs2->source ||
- ecs1->addr.family != ecs2->addr.family) {
+ ecs1->addr.family != ecs2->addr.family)
+ {
return (false);
}
ISC_LIST_INIT(forwarders->fwdrs);
for (fwd = ISC_LIST_HEAD(*fwdrs); fwd != NULL;
- fwd = ISC_LIST_NEXT(fwd, link)) {
+ fwd = ISC_LIST_NEXT(fwd, link))
+ {
nfwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
*nfwd = *fwd;
ISC_LINK_INIT(nfwd, link);
ISC_LIST_INIT(forwarders->fwdrs);
for (sa = ISC_LIST_HEAD(*addrs); sa != NULL;
- sa = ISC_LIST_NEXT(sa, link)) {
+ sa = ISC_LIST_NEXT(sa, link))
+ {
fwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
fwd->addr = *sa;
fwd->dscp = -1;
struct cc *next;
uint16_t rdclass;
char classbuf[TYPECLASSBUF];
-} * classes;
+} *classes;
static struct tt {
struct tt *next;
char classbuf[TYPECLASSBUF];
char typebuf[TYPECLASSBUF];
char dirbuf[PATH_MAX - 30];
-} * types;
+} *types;
static struct ttnam {
char typebuf[TYPECLASSBUF];
/* Hash the key if the key is longer then chosen MD block size */
if (r.length > (unsigned int)isc_md_type_get_block_size(type)) {
if (isc_md(type, r.base, r.length, hkey->key, &keylen) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
isc_mem_put(key->mctx, hkey, sizeof(dst_hmac_key_t));
return (DST_R_OPENSSLFAILURE);
}
* transaction headers in a version 1 journal.
*/
if ((xhdr->serial0 != serial ||
- isc_serial_le(xhdr->serial1, xhdr->serial0))) {
+ isc_serial_le(xhdr->serial1, xhdr->serial0)))
+ {
if (j->xhdr_version == XHDR_VERSION1 && xhdr->serial1 == serial)
{
isc_log_write(
CHECK(journal_read_xhdr(j, xhdr));
j->recovered = true;
} else if (j->xhdr_version == XHDR_VERSION2 &&
- xhdr->count == serial) {
+ xhdr->count == serial)
+ {
isc_log_write(
JOURNAL_COMMON_LOGARGS, ISC_LOG_DEBUG(3),
"%s: XHDR_VERSION2 -> XHDR_VERSION1 at %u",
* Check serial number consistency.
*/
if (xhdr.serial0 != pos->serial ||
- isc_serial_le(xhdr.serial1, xhdr.serial0)) {
+ isc_serial_le(xhdr.serial1, xhdr.serial0))
+ {
isc_log_write(JOURNAL_COMMON_LOGARGS, ISC_LOG_ERROR,
"%s: journal file corrupt: "
"expected serial %u, got %u",
* keep track of SOA serial numbers.
*/
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
- t = ISC_LIST_NEXT(t, link)) {
+ t = ISC_LIST_NEXT(t, link))
+ {
if (t->rdata.type == dns_rdatatype_soa) {
if (j->x.n_soa < 2) {
j->x.pos[j->x.n_soa].serial =
* Pass 2. Write RRs to buffer.
*/
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
- t = ISC_LIST_NEXT(t, link)) {
+ t = ISC_LIST_NEXT(t, link))
+ {
/*
* Write the RR header.
*/
*/
if (!JOURNAL_EMPTY(&j->header)) {
while (!DNS_SERIAL_GT(j->x.pos[1].serial,
- j->header.begin.serial)) {
+ j->header.begin.serial))
+ {
CHECK(journal_next(j, &j->header.begin));
}
index_invalidate(j, j->x.pos[1].serial);
* Check that xhdr is consistent.
*/
if (xhdr.serial0 != pos.serial ||
- isc_serial_le(xhdr.serial1, xhdr.serial0)) {
+ isc_serial_le(xhdr.serial1, xhdr.serial0))
+ {
CHECK(ISC_R_UNEXPECTED);
}
* xhdr format may be wrong.
*/
if (rewrite && (result != ISC_R_SUCCESS ||
- !check_delta(buf, size))) {
+ !check_delta(buf, size)))
+ {
if (j1->xhdr_version == XHDR_VERSION2) {
/* XHDR_VERSION2 -> XHDR_VERSION1 */
j1->xhdr_version = XHDR_VERSION1;
* Check that xhdr is consistent.
*/
if (xhdr.serial0 != serial ||
- isc_serial_le(xhdr.serial1, xhdr.serial0)) {
+ isc_serial_le(xhdr.serial1, xhdr.serial0))
+ {
CHECK(ISC_R_UNEXPECTED);
}
if (errno == EEXIST && !is_backup) {
result = isc_file_remove(backup);
if (result != ISC_R_SUCCESS &&
- result != ISC_R_FILENOTFOUND) {
+ result != ISC_R_FILENOTFOUND)
+ {
goto failure;
}
if (rename(filename, backup) == -1) {
return (false);
}
if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
- key->key_proto != DNS_KEYPROTO_ANY) {
+ key->key_proto != DNS_KEYPROTO_ANY)
+ {
return (false);
}
return (true);
return (false);
}
if (key->key_proto != DNS_KEYPROTO_DNSSEC &&
- key->key_proto != DNS_KEYPROTO_ANY) {
+ key->key_proto != DNS_KEYPROTO_ANY)
+ {
return (false);
}
return (true);
ret = dst_key_getbool(key->key, DST_BOOL_KSK, &ksk);
if (ret == ISC_R_SUCCESS && ksk) {
if (dst_key_getstate(key->key, DST_KEY_KRRSIG, &s) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
dst_key_setstate(key->key, DST_KEY_KRRSIG, OMNIPRESENT);
dst_key_settime(key->key, DST_TIME_KRRSIG, now);
}
ret = dst_key_getbool(key->key, DST_BOOL_ZSK, &zsk);
if (ret == ISC_R_SUCCESS && zsk) {
if (dst_key_getstate(key->key, DST_KEY_ZRRSIG, &s) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
dst_key_setstate(key->key, DST_KEY_ZRRSIG, OMNIPRESENT);
dst_key_settime(key->key, DST_TIME_ZRRSIG, now);
}
continue;
}
if (next_state != NA && i == type &&
- dst_key_id(key) == dst_key_id(subject)) {
+ dst_key_id(key) == dst_key_id(subject))
+ {
/* Check next state rather than current state. */
state = next_state;
} else if (dst_key_getstate(key, i, &state) != ISC_R_SUCCESS) {
dkey = ISC_LIST_NEXT(dkey, link))
{
if (match_algorithms &&
- (dst_key_alg(dkey->key) != dst_key_alg(key->key))) {
+ (dst_key_alg(dkey->key) != dst_key_alg(key->key)))
+ {
continue;
}
if (!keymgr_key_match_state(dkey->key, key->key, type,
- next_state, states)) {
+ next_state, states))
+ {
continue;
}
}
if (!keymgr_key_match_state(skey->key, key->key, type,
- next_state, states2)) {
+ next_state, states2))
+ {
continue;
}
dkey = ISC_LIST_NEXT(dkey, link))
{
if (match_algorithms &&
- (dst_key_alg(dkey->key) != dst_key_alg(key->key))) {
+ (dst_key_alg(dkey->key) != dst_key_alg(key->key)))
+ {
continue;
}
if (keymgr_key_match_state(dkey->key, key->key, type,
- next_state, ds_hidden)) {
+ next_state, ds_hidden))
+ {
/* This key has its DS hidden. */
continue;
}
dkey = ISC_LIST_NEXT(dkey, link))
{
if (match_algorithms &&
- (dst_key_alg(dkey->key) != dst_key_alg(key->key))) {
+ (dst_key_alg(dkey->key) != dst_key_alg(key->key)))
+ {
continue;
}
/* Is the transition allowed according to policy? */
if (!keymgr_policy_approval(keyring, dkey, i,
- next_state)) {
+ next_state))
+ {
/* No, please respect rollover methods. */
isc_log_write(
dns_lctx, DNS_LOGCATEGORY_DNSSEC,
/* Set goal if not already set. */
if (dst_key_getstate(key->key, DST_KEY_GOAL, &goal_state) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
dst_key_setstate(key->key, DST_KEY_GOAL, goal_state);
}
/* Check purge-keys interval. */
if (keymgr_key_may_be_purged(dkey->key,
- dns_kasp_purgekeys(kasp), now)) {
+ dns_kasp_purgekeys(kasp), now))
+ {
dst_key_format(dkey->key, keystr, sizeof(keystr));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_DNSSEC, ISC_LOG_INFO,
/* Initialize lifetime if not set. */
uint32_t l;
if (dst_key_getnum(dkey->key, DST_NUM_LIFETIME,
- &l) != ISC_R_SUCCESS) {
+ &l) != ISC_R_SUCCESS)
+ {
dst_key_setnum(dkey->key,
DST_NUM_LIFETIME,
lifetime);
* or desires to be active.
*/
if (dst_key_goal(dkey->key) == OMNIPRESENT ||
- dst_key_is_active(dkey->key, now)) {
+ dst_key_is_active(dkey->key, now))
+ {
active_key = dkey;
}
}
dnskey = ISC_LIST_NEXT(dnskey, link))
{
if (keymgr_dnsseckey_kaspkey_match(dnskey,
- kkey)) {
+ kkey))
+ {
/* Found a match. */
dst_key_format(dnskey->key, keystr,
sizeof(keystr));
}
if (eol != true) {
if (token->type == isc_tokentype_eol ||
- token->type == isc_tokentype_eof) {
+ token->type == isc_tokentype_eof)
+ {
{
unsigned long int line;
const char *what;
}
if (dns_master_isprimary(lctx) &&
- !dns_name_issubdomain(owner, lctx->top)) {
+ !dns_name_issubdomain(owner, lctx->top))
+ {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(owner, namebuf, sizeof(namebuf));
/*
EXPECTEOL;
continue;
} else if (strcasecmp(DNS_AS_STR(token), "$INCLUDE") ==
- 0) {
+ 0)
+ {
COMMITALL;
if ((lctx->options & DNS_MASTER_NOINCLUDE) != 0)
{
GETTOKEN(lctx->lex, 0, &token, true);
if (token.type == isc_tokentype_eol ||
- token.type == isc_tokentype_eof) {
+ token.type == isc_tokentype_eof)
+ {
if (token.type == isc_tokentype_eof) {
WARNUNEXPECTEDEOF(lctx->lex);
}
EXPECTEOL;
continue;
} else if (strcasecmp(DNS_AS_STR(token), "$GENERATE") ==
- 0) {
+ 0)
+ {
/*
* Lazy cleanup.
*/
/* TTL? */
if (dns_ttl_fromtext(&token.value.as_textregion,
&lctx->ttl) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
limit_ttl(callbacks, source, line,
&lctx->ttl);
lctx->ttl_known = true;
false);
rhs = isc_mem_strdup(mctx, DNS_AS_STR(token));
if (!lctx->ttl_known &&
- !lctx->default_ttl_known) {
+ !lctx->default_ttl_known)
+ {
(*callbacks->error)(callbacks,
"%s: %s:%lu: no "
"TTL specified",
goto insist_and_cleanup;
}
} else if (!explicit_ttl &&
- lctx->default_ttl_known) {
+ lctx->default_ttl_known)
+ {
lctx->ttl = lctx->default_ttl;
}
/*
* state. Linked lists are undone by commit().
*/
if (ictx->glue != NULL &&
- !dns_name_caseequal(ictx->glue, new_name)) {
+ !dns_name_caseequal(ictx->glue, new_name))
+ {
result = commit(callbacks, lctx, &glue_list,
ictx->glue, source,
ictx->glue_line);
!dns_name_caseequal(ictx->current, new_name)))
{
if (current_has_delegation &&
- is_glue(¤t_list, new_name)) {
+ is_glue(¤t_list, new_name))
+ {
rdcount_save = rdcount;
rdlcount_save = rdlcount;
target_save = target;
* Check for internal wildcards.
*/
if ((lctx->options &
- DNS_MASTER_CHECKWILDCARD) != 0) {
+ DNS_MASTER_CHECKWILDCARD) != 0)
+ {
check_wildcard(ictx, source, line,
callbacks);
}
}
if (dns_master_isprimary(lctx) &&
- !dns_name_issubdomain(new_name, lctx->top)) {
+ !dns_name_issubdomain(new_name, lctx->top))
+ {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(new_name, namebuf,
sizeof(namebuf));
result = DNS_R_BADOWNERNAME;
desc = isc_result_totext(result);
if (CHECKNAMESFAIL(lctx->options) ||
- type == dns_rdatatype_nsec3) {
+ type == dns_rdatatype_nsec3)
+ {
(*callbacks->error)(
callbacks, "%s:%lu: %s: %s",
source, line, namebuf, desc);
}
if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 &&
- lctx->ttl > lctx->maxttl) {
+ lctx->ttl > lctx->maxttl)
+ {
(callbacks->error)(callbacks,
"dns_master_load: %s:%lu: "
"TTL %d exceeds configured "
}
if ((lctx->options & DNS_MASTER_CHECKTTL) != 0 &&
- rdatalist.ttl > lctx->maxttl) {
+ rdatalist.ttl > lctx->maxttl)
+ {
(callbacks->error)(callbacks,
"dns_master_load: "
"TTL %d exceeds configured "
dns_rdata_init(&rdata[i]);
if (sequential_read &&
- isc_buffer_availablelength(&target) < MINTSIZ) {
+ isc_buffer_availablelength(&target) < MINTSIZ)
+ {
unsigned int j;
INSIST(i > 0); /* detect an infinite loop */
INDENT_TO(class_column);
class_start = target->used;
if ((ctx->style.flags & DNS_STYLEFLAG_UNKNOWNFORMAT) !=
- 0) {
+ 0)
+ {
result = dns_rdataclass_tounknowntext(
rdataset->rdclass, target);
} else {
#define KEYDATA "KEYDATA"
if ((ctx->style.flags & DNS_STYLEFLAG_KEYDATA) != 0) {
if (isc_buffer_availablelength(target) <
- (sizeof(KEYDATA) - 1)) {
+ (sizeof(KEYDATA) - 1))
+ {
return (ISC_R_NOSPACE);
}
isc_buffer_putstr(target, KEYDATA);
FALLTHROUGH;
default:
if ((ctx->style.flags & DNS_STYLEFLAG_UNKNOWNFORMAT) !=
- 0) {
+ 0)
+ {
result = dns_rdatatype_tounknowntext(type,
target);
} else {
if ((ctx->style.flags & DNS_STYLEFLAG_TTL) != 0) {
if (!ctx->current_ttl_valid ||
- ctx->current_ttl != rdataset->ttl) {
+ ctx->current_ttl != rdataset->ttl)
+ {
if ((ctx->style.flags & DNS_STYLEFLAG_COMMENT) != 0) {
isc_buffer_clear(buffer);
result = dns_ttl_totext(rdataset->ttl, true,
dns_rdataset_t *rds = sorted[i];
if (ANCIENT(rds) &&
- (ctx->style.flags & DNS_STYLEFLAG_EXPIRED) == 0) {
+ (ctx->style.flags & DNS_STYLEFLAG_EXPIRED) == 0)
+ {
/* Omit expired entries */
dns_rdataset_disassociate(rds);
continue;
* continue?).
*/
if (isc_buffer_availablelength(buffer) <
- sizeof(dlen) + r.length) {
+ sizeof(dlen) + r.length)
+ {
int newlength;
void *newmem;
result = dns_dbiterator_origin(dctx->dbiter, origin);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if ((dctx->tctx.style.flags & DNS_STYLEFLAG_REL_DATA) !=
- 0) {
+ 0)
+ {
dctx->tctx.origin = origin;
}
dctx->tctx.neworigin = origin;
curr = ISC_LIST_PREV(curr, link))
{
if (curr->rdclass == rdclass && curr->type == type &&
- curr->covers == covers) {
+ curr->covers == covers)
+ {
if (rdataset != NULL) {
*rdataset = curr;
}
tkeysection = DNS_SECTION_ANSWER;
}
if (sectionid != tkeysection &&
- sectionid != DNS_SECTION_ANSWER) {
+ sectionid != DNS_SECTION_ANSWER)
+ {
DO_ERROR(DNS_R_FORMERR);
}
}
goto cleanup;
}
if (msg->opcode == dns_opcode_update &&
- update(sectionid, rdclass)) {
+ update(sectionid, rdclass))
+ {
if (rdatalen != 0) {
result = DNS_R_FORMERR;
goto cleanup;
DO_ERROR(DNS_R_FORMERR);
}
} else if (rdtype == dns_rdatatype_sig /* SIG(0) */ &&
- rdata->flags == 0) {
+ rdata->flags == 0)
+ {
covers = dns_rdata_covers(rdata);
if (covers == 0) {
if (sectionid != DNS_SECTION_ADDITIONAL ||
}
} else {
if (msg->rdclass != dns_rdataclass_any &&
- msg->rdclass != rdclass) {
+ msg->rdclass != rdclass)
+ {
DO_ERROR(DNS_R_FORMERR);
}
}
* to the end of the message.
*/
if (preserve_order || msg->opcode == dns_opcode_update ||
- skip_name_search) {
+ skip_name_search)
+ {
if (!isedns && !istsig && !issigzero) {
ISC_LIST_APPEND(*section, name, link);
free_name = false;
* Skip this stage if in update mode or this is a meta-type.
*/
if (preserve_order || msg->opcode == dns_opcode_update ||
- skip_type_search) {
+ skip_type_search)
+ {
result = ISC_R_NOTFOUND;
} else {
/*
next_rdataset = ISC_LIST_NEXT(rdataset, link);
if ((rdataset->attributes &
- DNS_RDATASETATTR_RENDERED) != 0) {
+ DNS_RDATASETATTR_RENDERED) != 0)
+ {
goto next;
}
/* Check PAD */
if ((cp[-4] != 0) || (cp[-3] != DNS_OPT_PAD) || (cp[-2] != 0) ||
- (cp[-1] != 0)) {
+ (cp[-1] != 0))
+ {
return (ISC_R_UNEXPECTED);
}
{
result = ISC_R_SUCCESS;
} else if ((!msg->verified_sig) ||
- (msg->tsigstatus != dns_rcode_noerror)) {
+ (msg->tsigstatus != dns_rcode_noerror))
+ {
result = DNS_R_TSIGVERIFYFAILURE;
} else {
INSIST(tsig.error != dns_rcode_noerror);
result = dns_rdataset_first(&keyset);
INSIST(result == ISC_R_SUCCESS);
for (; result == ISC_R_SUCCESS;
- result = dns_rdataset_next(&keyset)) {
+ result = dns_rdataset_next(&keyset))
+ {
dst_key_t *key = NULL;
dns_rdata_reset(&rdata);
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (section == DNS_SECTION_ANSWER &&
- rdataset->type == dns_rdatatype_soa) {
+ rdataset->type == dns_rdatatype_soa)
+ {
if ((flags & DNS_MESSAGETEXTFLAG_OMITSOA) != 0)
{
continue;
}
if (seensoa &&
- (flags & DNS_MESSAGETEXTFLAG_ONESOA) != 0) {
+ (flags & DNS_MESSAGETEXTFLAG_ONESOA) != 0)
+ {
continue;
}
seensoa = true;
}
for (i = 0; i < optlen; i++) {
if (isprint(optdata[i]) ||
- (utf8ok && optdata[i] > 127)) {
+ (utf8ok && optdata[i] > 127))
+ {
isc_buffer_putmem(
target, &optdata[i], 1);
} else {
}
for (i = 0; i < optlen; i++) {
if (isprint(optdata[i]) ||
- (utf8ok && optdata[i] > 127)) {
+ (utf8ok && optdata[i] > 127))
+ {
isc_buffer_putmem(
target, &optdata[i], 1);
} else {
for (i = 0; i < count; i++) {
if (ednsopts[i].code == DNS_OPT_PAD &&
- ednsopts[i].length == 0U && !seenpad) {
+ ednsopts[i].length == 0U && !seenpad)
+ {
seenpad = true;
continue;
}
isc_result_t tresult;
if ((rdataset->attributes &
- DNS_RDATASETATTR_RENDERED) == 0) {
+ DNS_RDATASETATTR_RENDERED) == 0)
+ {
continue;
}
namereln = dns_name_fullcompare(name1, name2, &order, &nlabels);
if (namereln == dns_namereln_subdomain ||
- namereln == dns_namereln_equal) {
+ namereln == dns_namereln_equal)
+ {
return (true);
}
case 0x40: /* '@' */
case 0x24: /* '$' */
if ((options & DNS_NAME_MASTERFILE) ==
- 0) {
+ 0)
+ {
goto no_escape;
}
FALLTHROUGH;
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if ((rdataset->attributes &
- DNS_RDATASETATTR_NCACHE) == 0) {
+ DNS_RDATASETATTR_NCACHE) == 0)
+ {
continue;
}
type = rdataset->type;
isc_region_consume(&remaining, 2);
if (type != dns_rdatatype_rrsig ||
- !dns_name_equal(&tname, name)) {
+ !dns_name_equal(&tname, name))
+ {
result = dns_rdataset_next(&rclone);
dns_rdata_reset(&rdata);
continue;
{
for (i = 0; i <= max_type; i++) {
if (dns_nsec_isset(bm, i) &&
- !dns_rdatatype_iszonecutauth((dns_rdatatype_t)i)) {
+ !dns_rdatatype_iszonecutauth((dns_rdatatype_t)i))
+ {
dns_nsec_setbit(bm, i, 0);
}
}
{
if (tuple->rdata.type !=
dns_rdatatype_dnskey ||
- tuple->op != DNS_DIFFOP_DEL) {
+ tuple->op != DNS_DIFFOP_DEL)
+ {
continue;
}
* a NS record but do have other data.
*/
if (rdataset.type == dns_rdatatype_soa ||
- rdataset.type == dns_rdatatype_ds) {
+ rdataset.type == dns_rdatatype_ds)
+ {
need_rrsig = true;
} else if (rdataset.type == dns_rdatatype_ns) {
found_ns = true;
{
for (i = 0; i <= max_type; i++) {
if (dns_nsec_isset(bm, i) &&
- !dns_rdatatype_iszonecutauth((dns_rdatatype_t)i)) {
+ !dns_rdatatype_iszonecutauth((dns_rdatatype_t)i))
+ {
dns_nsec_setbit(bm, i, 0);
}
}
dns_rdata_t tmprdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &tmprdata);
if (!dns_nsec3param_fromprivate(&tmprdata, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
} else {
dns_rdataset_current(&prdataset, &rdata1);
if (!dns_nsec3param_fromprivate(&rdata1, &rdata2, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
CHECK(dns_rdata_tostruct(&rdata2, &nsec3param, NULL));
dns_rdataset_current(&rdataset, &rdata1);
if (!dns_nsec3param_fromprivate(&rdata1, &rdata2, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
CHECK(dns_rdata_tostruct(&rdata2, &nsec3param, NULL));
dns_rdataset_current(&rdataset, &rdata1);
if (!dns_nsec3param_fromprivate(&rdata1, &rdata2, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
result = dns_rdata_tostruct(&rdata2, &nsec3param, NULL);
* Is this zone the same or deeper than the current zone?
*/
if (dns_name_countlabels(zonename) == 0 ||
- dns_name_issubdomain(zone, zonename)) {
+ dns_name_issubdomain(zone, zonename))
+ {
dns_name_copy(zone, zonename);
}
default:
#if defined(ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED)
if (lib == ERR_R_ECDSA_LIB &&
- reason == ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED) {
+ reason == ECDSA_R_RANDOM_NUMBER_GENERATION_FAILED)
+ {
result = ISC_R_NOENTROPY;
break;
}
if (priv_key1 != NULL || priv_key2 != NULL) {
if (priv_key1 == NULL || priv_key2 == NULL ||
- BN_cmp(priv_key1, priv_key2) != 0) {
+ BN_cmp(priv_key1, priv_key2) != 0)
+ {
DST_RET(false);
}
}
* static parameters which we can use.
*/
if (key->key_size == 768 || key->key_size == 1024 ||
- key->key_size == 1536) {
+ key->key_size == 1536)
+ {
if (key->key_size == 768) {
p = BN_dup(bn768);
} else if (key->key_size == 1024) {
}
if (!DH_generate_parameters_ex(dh, key->key_size, generator,
- cb)) {
+ cb))
+ {
DST_RET(dst__openssl_toresult2("DH_generate_parameters_"
"ex",
DST_R_OPENSSLFAILURE));
}
#else
if (OSSL_PARAM_BLD_push_int(bld, OSSL_PKEY_PARAM_DH_GENERATOR,
- generator) != 1) {
+ generator) != 1)
+ {
DST_RET(dst__openssl_toresult2("OSSL_PARAM_BLD_push_"
"int",
DST_R_OPENSSLFAILURE));
DST_R_OPENSSLFAILURE));
}
if (EVP_PKEY_paramgen(param_ctx, ¶m_pkey) != 1 ||
- param_pkey == NULL) {
+ param_pkey == NULL)
+ {
DST_RET(dst__openssl_toresult2("EVP_PKEY_paramgen",
DST_R_OPENSSLFAILURE));
}
if (dctx->use == DO_SIGN) {
if (EVP_DigestSignUpdate(evp_md_ctx, data->base,
- data->length) != 1) {
+ data->length) != 1)
+ {
DST_RET(dst__openssl_toresult3(dctx->category,
"EVP_DigestSignUpdate",
ISC_R_FAILURE));
}
} else {
if (EVP_DigestVerifyUpdate(evp_md_ctx, data->base,
- data->length) != 1) {
+ data->length) != 1)
+ {
DST_RET(dst__openssl_toresult3(dctx->category,
"EVP_DigestVerifyUpdate",
ISC_R_FAILURE));
memmove(buf + 1, r.base, len);
cp = buf;
if (o2i_ECPublicKey(&eckey, (const unsigned char **)&cp,
- (long)len + 1) == NULL) {
+ (long)len + 1) == NULL)
+ {
DST_RET(dst__openssl_toresult(DST_R_INVALIDPUBLICKEY));
}
if (EC_KEY_check_key(eckey) != 1) {
DST_RET(ISC_R_FAILURE);
}
if (OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_PRIV_KEY,
- priv) != 1) {
+ priv) != 1)
+ {
DST_RET(ISC_R_FAILURE);
}
if (OSSL_PARAM_BLD_push_octet_string(bld,
dctx->category, "EVP_DigestSignInit", ISC_R_FAILURE));
}
if (EVP_DigestSign(ctx, sigreg.base, &siglen, tbsreg.base,
- tbsreg.length) != 1) {
+ tbsreg.length) != 1)
+ {
DST_RET(dst__openssl_toresult3(dctx->category, "EVP_DigestSign",
DST_R_SIGNFAILURE));
}
}
buf = isc_mem_get(key->mctx, len);
if (EVP_PKEY_get_raw_private_key(key->keydata.pkey, buf,
- &len) != 1) {
+ &len) != 1)
+ {
DST_RET(dst__openssl_toresult(ISC_R_FAILURE));
}
priv.elements[i].tag = TAG_EDDSA_PRIVATEKEY;
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
if (BN_cmp(d1, d2) != 0 || BN_cmp(p1, p2) != 0 ||
- BN_cmp(q1, q2) != 0) {
+ BN_cmp(q1, q2) != 0)
+ {
DST_RET(false);
}
}
}
if (n != NULL &&
- OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n) != 1) {
+ OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_N, n) != 1)
+ {
DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE));
}
if (e != NULL &&
- OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e) != 1) {
+ OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_E, e) != 1)
+ {
DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE));
}
if (d != NULL &&
- OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d) != 1) {
+ OSSL_PARAM_BLD_push_BN(bld, OSSL_PKEY_PARAM_RSA_D, d) != 1)
+ {
DST_RET(dst__openssl_toresult(DST_R_OPENSSLFAILURE));
}
if (p != NULL &&
}
if (rsa_check(pkey, pub != NULL ? pub->keydata.pkey : NULL) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
DST_RET(dst__openssl_toresult(DST_R_INVALIDPRIVATEKEY));
}
#endif /* OPENSSL_VERSION_NUMBER < 0x30000000L || OPENSSL_API_LEVEL < 30000 */
continue;
}
if (ent->rdclass != rdclass &&
- ent->rdclass != dns_rdataclass_any) {
+ ent->rdclass != dns_rdataclass_any)
+ {
continue;
}
if (match(name, dns_fixedname_name(&ent->name))) {
* More specifics to front of list.
*/
for (p = ISC_LIST_HEAD(peers->elements); p != NULL;
- p = ISC_LIST_NEXT(p, next)) {
+ p = ISC_LIST_NEXT(p, next))
+ {
if (p->prefixlen < peer->prefixlen) {
break;
}
server = ISC_LIST_HEAD(servers->elements);
while (server != NULL) {
if (isc_netaddr_eqprefix(addr, &server->address,
- server->prefixlen)) {
+ server->prefixlen))
+ {
break;
}
dns_rdataset_current(privateset, &private);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
/*
dns_rdataset_current(&privateset, &private);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
if (REMOVE(rdata.data[1])) {
dns_rdataset_current(&privateset, &private);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
if (CREATE(rdata.data[1])) {
dns_rdataset_current(&privateset, &private);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
/*
* Look for record that says we are signing the
* zone with a key.
isc_buffer_t b;
if (!dns_nsec3param_fromprivate(private, &rdata, nsec3buf,
- sizeof(nsec3buf))) {
+ sizeof(nsec3buf)))
+ {
CHECK(ISC_R_FAILURE);
}
hash_node(rbt, new_current, new_name);
if (common_labels ==
- dns_name_countlabels(add_name)) {
+ dns_name_countlabels(add_name))
+ {
/*
* The name has been added by pushing
* the not-in-common parts down to
* there is data associated with a node.
*/
if (result == ISC_R_SUCCESS ||
- (result == ISC_R_EXISTS && node->data == NULL)) {
+ (result == ISC_R_EXISTS && node->data == NULL))
+ {
node->data = data;
result = ISC_R_SUCCESS;
}
result2 = dns_rbtnodechain_prev(
chain, NULL, NULL);
if (result2 == ISC_R_SUCCESS ||
- result2 == DNS_R_NEWORIGIN) {
+ result2 == DNS_R_NEWORIGIN)
+ {
/* Nothing. */
} else if (result2 == ISC_R_NOMORE) {
/*
uint32_t newbits = rehash_bits(rbt, newcount);
if (rbt->hashbits[rbt->hindex] < newbits &&
- newbits <= ISC_HASH_MAX_BITS) {
+ newbits <= ISC_HASH_MAX_BITS)
+ {
hashtable_rehash(rbt, newbits);
}
}
INSIST(sibling != NULL);
if (IS_BLACK(sibling->left) &&
- IS_BLACK(sibling->right)) {
+ IS_BLACK(sibling->right))
+ {
sibling->color = RED;
child = parent;
} else {
INSIST(sibling != NULL);
if (IS_BLACK(sibling->left) &&
- IS_BLACK(sibling->right)) {
+ IS_BLACK(sibling->right))
+ {
sibling->color = RED;
child = parent;
} else {
* a subtree root and must have the flag set.
*/
if (((!node->parent) || (node->parent->down == node)) &&
- (!node->is_root)) {
+ (!node->is_root))
+ {
return (false);
}
* the origin for the second level tree.
*/
if (origin != NULL &&
- (chain->level_count > 0 || predecessor->offsetlen > 1)) {
+ (chain->level_count > 0 || predecessor->offsetlen > 1))
+ {
new_origin = true;
}
}
make_dirty = true;
}
for (dcurrent = header->down; dcurrent != NULL;
- dcurrent = dcurrent->down) {
+ dcurrent = dcurrent->down)
+ {
if (dcurrent->serial == serial) {
RDATASET_ATTR_SET(dcurrent,
RDATASET_ATTR_IGNORE);
*/
dparent = current;
for (dcurrent = current->down; dcurrent != NULL;
- dcurrent = down_next) {
+ dcurrent = down_next)
+ {
down_next = dcurrent->down;
INSIST(dcurrent->serial <= dparent->serial);
if (dcurrent->serial == dparent->serial ||
- IGNORE(dcurrent)) {
+ IGNORE(dcurrent))
+ {
if (down_next != NULL) {
down_next->next = dparent;
}
*/
dparent = current;
for (dcurrent = current->down; dcurrent != NULL;
- dcurrent = down_next) {
+ dcurrent = down_next)
+ {
down_next = dcurrent->down;
if (dcurrent->serial < least_serial) {
break;
* and we have to do it now.
*/
if (isc_refcount_current(&node->references) != 0 ||
- node->data != NULL) {
+ node->data != NULL)
+ {
node = ISC_LIST_HEAD(rbtdb->deadnodes[bucketnum]);
count--;
continue;
/* Upgrade the lock? */
if (*nlocktypep == isc_rwlocktype_read) {
if (NODE_TRYUPGRADE(&nodelock->lock, nlocktypep) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
NODE_UNLOCK(&nodelock->lock, nlocktypep);
NODE_WRLOCK(&nodelock->lock, nlocktypep);
}
header_next = header->next;
do {
if (header->serial <= version->serial &&
- !IGNORE(header)) {
+ !IGNORE(header))
+ {
if (NONEXISTENT(header)) {
header = NULL;
}
} while (header != NULL);
if (header != NULL &&
- (header->type == dns_rdatatype_nsec3param)) {
+ (header->type == dns_rdatatype_nsec3param))
+ {
/*
* Find A NSEC3PARAM with a supported algorithm.
*/
* Commit/rollback re-signed headers.
*/
for (header = HEAD(resigned_list); header != NULL;
- header = HEAD(resigned_list)) {
+ header = HEAD(resigned_list))
+ {
nodelock_t *lock;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
}
for (changed = HEAD(cleanup_list); changed != NULL;
- changed = next_changed) {
+ changed = next_changed)
+ {
nodelock_t *lock;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
* Try to upgrade the lock and if that fails unlock then relock.
*/
if (TREE_TRYUPGRADE(&rbtdb->tree_lock, &tlocktype) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
}
{
do {
if (header->serial <= search->serial &&
- !IGNORE(header)) {
+ !IGNORE(header))
+ {
/*
* Is this a "this rdataset doesn't
* exist" record?
if (header->type == dns_rdatatype_dname) {
dname_header = header;
} else if (header->type ==
- RBTDB_RDATATYPE_SIGDNAME) {
+ RBTDB_RDATATYPE_SIGDNAME)
+ {
sigdname_header = header;
} else if (node != onode ||
- IS_STUB(search->rbtdb)) {
+ IS_STUB(search->rbtdb))
+ {
/*
* We've found an NS rdataset that
* isn't at the origin node. We check
* Did we find anything?
*/
if (!IS_CACHE(search->rbtdb) && !IS_STUB(search->rbtdb) &&
- ns_header != NULL) {
+ ns_header != NULL)
+ {
/*
* Note that NS has precedence over DNAME if both exist
* in a zone. Otherwise DNAME take precedence over NS.
for (header = node->data; header != NULL; header = header->next)
{
if (header->serial <= search->serial &&
- !IGNORE(header) && EXISTS(header)) {
+ !IGNORE(header) && EXISTS(header))
+ {
break;
}
}
for (header = node->data; header != NULL; header = header->next)
{
if (header->serial <= search->serial &&
- !IGNORE(header) && EXISTS(header)) {
+ !IGNORE(header) && EXISTS(header))
+ {
break;
}
}
for (header = node->data; header != NULL; header = header->next)
{
if (header->serial <= search->serial &&
- !IGNORE(header) && EXISTS(header)) {
+ !IGNORE(header) && EXISTS(header))
+ {
break;
}
}
lock = &rbtdb->node_locks[wnode->locknum].lock;
NODE_RDLOCK(lock, &nlocktype);
for (header = wnode->data; header != NULL;
- header = header->next) {
+ header = header->next)
+ {
if (header->serial <= search->serial &&
!IGNORE(header) && EXISTS(header) &&
!ANCIENT(header))
}
NODE_UNLOCK(lock, &nlocktype);
if (header != NULL ||
- activeempty(search, &wchain, wname)) {
+ activeempty(search, &wchain, wname))
+ {
if (activeemptynode(search, qname,
- wname)) {
+ wname))
+ {
return (ISC_R_NOTFOUND);
}
/*
break;
}
} else if (result != ISC_R_NOTFOUND &&
- result != DNS_R_PARTIALMATCH) {
+ result != DNS_R_PARTIALMATCH)
+ {
/*
* An error has occurred. Bail out.
*/
result = ISC_R_SUCCESS;
}
} else if (result == ISC_R_NOTFOUND ||
- result == DNS_R_PARTIALMATCH) {
+ result == DNS_R_PARTIALMATCH)
+ {
result = dns_rbtnodechain_current(
nsecchain, name, origin, NULL);
if (result == ISC_R_NOTFOUND) {
*/
do {
if (header->serial <= search->serial &&
- !IGNORE(header)) {
+ !IGNORE(header))
+ {
/*
* Is this a "this rdataset doesn't
* exist" record?
type, search, name, origin, &prevnode,
NULL, NULL);
} else if (found != NULL &&
- (foundsig != NULL || !need_sig)) {
+ (foundsig != NULL || !need_sig))
+ {
/*
* We've found the right NSEC/NSEC3 record.
*
* we are using behave as if it isn't here.
*/
if (header->type == dns_rdatatype_nsec3 &&
- !matchparams(header, &search)) {
+ !matchparams(header, &search))
+ {
NODE_UNLOCK(lock, &nlocktype);
goto partial_match;
}
*/
found = header;
if (header->type == dns_rdatatype_cname &&
- cname_ok) {
+ cname_ok)
+ {
/*
* We may be finding a CNAME instead
* of the desired type.
break;
}
} else if (header->type == dns_rdatatype_nsec &&
- !search.rbtversion->havensec3) {
+ !search.rbtversion->havensec3)
+ {
/*
* Remember a NSEC rdataset even if we're
* not specifically looking for it, because
*/
nsecsig = header;
} else if (cname_ok &&
- header->type == RBTDB_RDATATYPE_SIGCNAME) {
+ header->type == RBTDB_RDATATYPE_SIGCNAME)
+ {
/*
* If we get a CNAME match, we'll also need
* its signature.
goto tree_exit;
}
if ((search.options & DNS_DBFIND_FORCENSEC) != 0 &&
- nsecheader == NULL) {
+ nsecheader == NULL)
+ {
/*
* There's no NSEC record, and we were told
* to find one.
RDATASET_ATTR_CLR(header, RDATASET_ATTR_STALE_WINDOW);
if (!ZEROTTL(header) && KEEPSTALE(search->rbtdb) &&
- stale > search->now) {
+ stale > search->now)
+ {
mark_header_stale(search->rbtdb, header);
*header_prev = header;
/*
RDATASET_ATTR_STALE_WINDOW);
return (false);
} else if ((search->options &
- DNS_DBFIND_STALETIMEOUT) != 0) {
+ DNS_DBFIND_STALETIMEOUT) != 0)
+ {
/*
* We want stale RRset due to timeout, so we
* don't skip it.
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
if (check_stale_header(node, header, &nlocktype, lock, search,
- &header_prev)) {
+ &header_prev))
+ {
/* Do nothing. */
} else if (header->type == dns_rdatatype_dname &&
EXISTS(header) && !ANCIENT(header))
{
header_next = header->next;
if (check_stale_header(node, header, &nlocktype, lock,
- search, &header_prev)) {
+ search, &header_prev))
+ {
/* Do nothing. */
} else if (EXISTS(header) && !ANCIENT(header)) {
/*
break;
}
} else if (header->type ==
- RBTDB_RDATATYPE_SIGNS) {
+ RBTDB_RDATATYPE_SIGNS)
+ {
foundsig = header;
if (found != NULL) {
break;
{
if (nlocktype != isc_rwlocktype_write) {
if (NODE_TRYUPGRADE(lock, &nlocktype) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
NODE_UNLOCK(lock, &nlocktype);
NODE_WRLOCK(lock, &nlocktype);
}
search->now);
}
if (foundsig != NULL &&
- need_headerupdate(foundsig, search->now)) {
+ need_headerupdate(foundsig, search->now))
+ {
update_header(search->rbtdb, foundsig,
search->now);
}
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
if (check_stale_header(node, header, &nlocktype, lock, search,
- &header_prev)) {
+ &header_prev))
+ {
continue;
}
if (NONEXISTENT(header) ||
- RBTDB_RDATATYPE_BASE(header->type) == 0) {
+ RBTDB_RDATATYPE_BASE(header->type) == 0)
+ {
header_prev = header;
continue;
}
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
if (check_stale_header(node, header, &nlocktype, lock, &search,
- &header_prev)) {
+ &header_prev))
+ {
/* Do nothing. */
} else if (EXISTS(header) && !ANCIENT(header)) {
/*
*/
empty_node = false;
if (header->noqname != NULL &&
- header->trust == dns_trust_secure) {
+ header->trust == dns_trust_secure)
+ {
found_noqname = true;
}
if (!NEGATIVE(header)) {
*/
found = header;
if (header->type == dns_rdatatype_cname &&
- cname_ok && cnamesig != NULL) {
+ cname_ok && cnamesig != NULL)
+ {
/*
* If we've already got the
* CNAME RRSIG, use it.
*/
foundsig = header;
} else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
- header->type == negtype) {
+ header->type == negtype)
+ {
/*
* We've found a negative cache entry.
*/
} else if (header->type == RBTDB_RDATATYPE_SIGNSEC) {
nsecsig = header;
} else if (cname_ok &&
- header->type == RBTDB_RDATATYPE_SIGCNAME) {
+ header->type == RBTDB_RDATATYPE_SIGCNAME)
+ {
/*
* If we get a CNAME match, we'll also need
* its signature.
* Return covering NODATA NSEC record.
*/
if ((search.options & DNS_DBFIND_COVERINGNSEC) != 0 &&
- nsecheader != NULL) {
+ nsecheader != NULL)
+ {
if (nodep != NULL) {
new_reference(search.rbtdb, node, nlocktype);
*nodep = node;
node_exit:
if ((update != NULL || updatesig != NULL) &&
- nlocktype != isc_rwlocktype_write) {
+ nlocktype != isc_rwlocktype_write)
+ {
if (NODE_TRYUPGRADE(lock, &nlocktype) != ISC_R_SUCCESS) {
NODE_UNLOCK(lock, &nlocktype);
NODE_WRLOCK(lock, &nlocktype);
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
if (check_stale_header(node, header, &nlocktype, lock, &search,
- &header_prev)) {
+ &header_prev))
+ {
/*
* The function dns_rbt_findnode found us the a matching
* node for 'name' and stored the result in 'dcname'.
NODE_RDLOCK(&nodelock->lock, &nlocktype);
if (decrement_reference(rbtdb, node, 0, &nlocktype, &tlocktype, true,
- false)) {
+ false))
+ {
if (isc_refcount_current(&nodelock->references) == 0 &&
- nodelock->exiting) {
+ nodelock->exiting)
+ {
inactive = true;
}
}
for (header = rbtnode->data; header != NULL; header = header->next) {
if (header->rdh_ttl + STALE_TTL(header, rbtdb) <=
- now - RBTDB_VIRTUAL) {
+ now - RBTDB_VIRTUAL)
+ {
/*
* We don't check if refcurrent(rbtnode) == 0 and try
* to free like we do in cache_find(), because
rdatasetheader_t *current, *top_next;
for (current = rbtnode->data; current != NULL;
- current = top_next) {
+ current = top_next)
+ {
top_next = current->next;
first = true;
fprintf(out, "\ttype %u", current->type);
if (header->type == matchtype) {
found = header;
} else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
- header->type == negtype) {
+ header->type == negtype)
+ {
found = header;
} else if (header->type == sigmatchtype) {
foundsig = header;
*/
do {
if (header->serial <= serial &&
- !IGNORE(header)) {
+ !IGNORE(header))
+ {
/*
* Is this a "this rdataset
* doesn't exist" record?
*/
for (topheader = rbtnode->data;
topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
set_ttl(rbtdb, topheader, 0);
mark_header_ancient(rbtdb, topheader);
}
* type so they can be marked ancient later.
*/
for (topheader = rbtnode->data; topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
if (topheader->type == sigtype) {
sigheader = topheader;
}
* entry which covers the same type as the RRSIG.
*/
for (topheader = rbtnode->data; topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
if ((topheader->type ==
RBTDB_RDATATYPE_NCACHEANY) ||
(newheader->type == sigtype &&
}
}
if (topheader != NULL && EXISTS(topheader) &&
- ACTIVE(topheader, now)) {
+ ACTIVE(topheader, now))
+ {
/*
* Found one.
*/
}
for (topheader = rbtnode->data; topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
if (topheader->type == newheader->type ||
- topheader->type == negtype) {
+ topheader->type == negtype)
+ {
break;
}
topheader_prev = topheader;
set_ttl(rbtdb, header, newheader->rdh_ttl);
}
if (header->noqname == NULL &&
- newheader->noqname != NULL) {
+ newheader->noqname != NULL)
+ {
header->noqname = newheader->noqname;
newheader->noqname = NULL;
}
if (header->closest == NULL &&
- newheader->closest != NULL) {
+ newheader->closest != NULL)
+ {
header->closest = newheader->closest;
newheader->closest = NULL;
}
set_ttl(rbtdb, header, newheader->rdh_ttl);
}
if (header->noqname == NULL &&
- newheader->noqname != NULL) {
+ newheader->noqname != NULL)
+ {
header->noqname = newheader->noqname;
newheader->noqname = NULL;
}
if (header->closest == NULL &&
- newheader->closest != NULL) {
+ newheader->closest != NULL)
+ {
header->closest = newheader->closest;
newheader->closest = NULL;
}
* Check if the node now contains CNAME and other data.
*/
if (rbtversion != NULL &&
- cname_and_other_data(rbtnode, rbtversion->serial)) {
+ cname_and_other_data(rbtnode, rbtversion->serial))
+ {
return (DNS_R_CNAMEANDOTHER);
}
* SOA records are only allowed at top of zone.
*/
if (rdataset->type == dns_rdatatype_soa &&
- node != rbtdb->origin_node) {
+ node != rbtdb->origin_node)
+ {
return (DNS_R_NOTZONETOP);
}
TREE_RDLOCK(&rbtdb->tree_lock, &tlocktype);
* node lock.
*/
if (tlocktype == isc_rwlocktype_write && !delegating &&
- !newnsec) {
+ !newnsec)
+ {
TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
}
}
topheader_prev = NULL;
for (topheader = rbtnode->data; topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
if (topheader->type == newheader->type) {
break;
}
NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
if (result == ISC_R_SUCCESS &&
- delegating_type(rbtdb, node, rdataset->type)) {
+ delegating_type(rbtdb, node, rdataset->type))
+ {
node->find_callback = 1;
} else if (result == DNS_R_UNCHANGED) {
result = ISC_R_SUCCESS;
uint32_t newbits = oldbits;
while (newcount >= ISC_HASHSIZE(newbits) &&
- newbits <= ISC_HASH_MAX_BITS) {
+ newbits <= ISC_HASH_MAX_BITS)
+ {
newbits += 1;
}
rbtdb_glue_table_node_t *gluenode;
rbtdb_glue_table_node_t *nextgluenode;
for (gluenode = oldtable[i]; gluenode != NULL;
- gluenode = nextgluenode) {
+ gluenode = nextgluenode)
+ {
uint32_t hash = isc_hash32(
&gluenode->node, sizeof(gluenode->node), true);
uint32_t idx = isc_hash_bits32(hash, newbits);
int v;
if (!isdigit((unsigned char)source->base[0]) ||
- source->length > NUMBERSIZE - 1) {
+ source->length > NUMBERSIZE - 1)
+ {
return (ISC_R_BADNUMBER);
}
for (i = 0; i < sr->length; i += len) {
if (tctx != NULL &&
- (tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
+ (tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
+ {
RETERR(str_totext(tctx->linebreak, target));
first = true;
}
unknown = false;
if (token.type == isc_tokentype_string &&
- strcmp(DNS_AS_STR(token), "\\#") == 0) {
+ strcmp(DNS_AS_STR(token), "\\#") == 0)
+ {
/*
* If this is a TXT record '\#' could be a escaped '#'.
* Look to see if the next token is a number and if so
}
break;
} else if (token.type != isc_tokentype_eol &&
- token.type != isc_tokentype_eof) {
+ token.type != isc_tokentype_eof)
+ {
if (result == ISC_R_SUCCESS) {
result = DNS_R_EXTRATOKEN;
}
tctx->linebreak, target);
}
if (result == ISC_R_SUCCESS &&
- (tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0) {
+ (tctx->flags & DNS_STYLEFLAG_MULTILINE) != 0)
+ {
result = str_totext(" )", target);
}
}
bool
dns_rdatatype_notquestion(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_NOTQUESTION) !=
- 0) {
+ 0)
+ {
return (true);
}
return (false);
bool
dns_rdatatype_questiononly(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_QUESTIONONLY) !=
- 0) {
+ 0)
+ {
return (true);
}
return (false);
bool
dns_rdatatype_followadditional(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) &
- DNS_RDATATYPEATTR_FOLLOWADDITIONAL) != 0) {
+ DNS_RDATATYPEATTR_FOLLOWADDITIONAL) != 0)
+ {
return (true);
}
return (false);
bool
dns_rdatatype_iszonecutauth(dns_rdatatype_t type) {
if ((dns_rdatatype_attributes(type) & DNS_RDATATYPEATTR_ZONECUTAUTH) !=
- 0) {
+ 0)
+ {
return (true);
}
return (false);
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
false));
if (dns_tsigrcode_fromtext(&rcode, &token.value.as_textregion) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
i = strtol(DNS_AS_STR(token), &e, 10);
if (*e != 0) {
RETTOK(DNS_R_UNKNOWN);
dns_rdata_toregion(rdata2, ®ion2);
if (memcmp(region1.base, region2.base, 2) != 0 ||
- (region1.base[1] & 0x7f) != 3) {
+ (region1.base[1] & 0x7f) != 3)
+ {
return (isc_region_compare(®ion1, ®ion2));
}
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_qstring,
false));
if (token.type != isc_tokentype_qstring &&
- token.type != isc_tokentype_string) {
+ token.type != isc_tokentype_string)
+ {
RETERR(DNS_R_SYNTAX);
}
RETERR(multitxt_fromtext(&token.value.as_textregion, target));
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_qstring,
true));
if (token.type != isc_tokentype_string &&
- token.type != isc_tokentype_qstring) {
+ token.type != isc_tokentype_qstring)
+ {
isc_lex_ungettoken(lexer, &token);
return (ISC_R_SUCCESS);
}
if ((tctx->flags & DNS_STYLEFLAG_RRCOMMENT) != 0) {
if (rdata->type == dns_rdatatype_dnskey ||
- rdata->type == dns_rdatatype_cdnskey) {
+ rdata->type == dns_rdatatype_cdnskey)
+ {
RETERR(str_totext(" ; ", target));
RETERR(str_totext(keyinfo, target));
}
}
if (algorithm == DNS_KEYALG_PRIVATEDNS ||
- algorithm == DNS_KEYALG_PRIVATEOID) {
+ algorithm == DNS_KEYALG_PRIVATEOID)
+ {
isc_buffer_t b = *source;
RETERR(check_private(&b, algorithm));
}
RETERR(isc_lex_getmastertoken(lexer, token, isc_tokentype_string,
false));
if (DNS_AS_STR(*token)[0] == directions[1] &&
- DNS_AS_STR(*token)[1] == 0) {
+ DNS_AS_STR(*token)[1] == 0)
+ {
*direction = DNS_AS_STR(*token)[0];
return (ISC_R_SUCCESS);
}
if (DNS_AS_STR(*token)[0] == directions[0] &&
- DNS_AS_STR(*token)[1] == 0) {
+ DNS_AS_STR(*token)[1] == 0)
+ {
*direction = DNS_AS_STR(*token)[0];
return (ISC_R_SUCCESS);
}
c = sr.base[1];
if (c != 0) {
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
- ((c >> 4) & 0xf) == 0) {
+ ((c >> 4) & 0xf) == 0)
+ {
return (ISC_R_RANGE);
/*
c = sr.base[2];
if (c != 0) {
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
- ((c >> 4) & 0xf) == 0) {
+ ((c >> 4) & 0xf) == 0)
+ {
return (ISC_R_RANGE);
/*
c = sr.base[3];
if (c != 0) {
if ((c & 0xf) > 9 || ((c >> 4) & 0xf) > 9 ||
- ((c >> 4) & 0xf) == 0) {
+ ((c >> 4) & 0xf) == 0)
+ {
return (ISC_R_RANGE);
}
}
}
if (algorithm == DNS_KEYALG_PRIVATEDNS ||
- algorithm == DNS_KEYALG_PRIVATEOID) {
+ algorithm == DNS_KEYALG_PRIVATEOID)
+ {
isc_buffer_t b = *source;
RETERR(check_private(&b, algorithm));
}
}
if (algorithm == DNS_KEYALG_PRIVATEDNS ||
- algorithm == DNS_KEYALG_PRIVATEOID) {
+ algorithm == DNS_KEYALG_PRIVATEOID)
+ {
isc_buffer_t b = *source;
RETERR(check_private(&b, algorithm));
}
RETERR(isc_lex_getmastertoken(lexer, &token, isc_tokentype_string,
false));
if (dns_tsigrcode_fromtext(&rcode, &token.value.as_textregion) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
i = strtol(DNS_AS_STR(token), &e, 10);
if (*e != 0) {
RETTOK(DNS_R_UNKNOWN);
RETERR(isc_lex_getmastertoken(lexer, &token,
isc_tokentype_qstring, true));
if (token.type != isc_tokentype_qstring &&
- token.type != isc_tokentype_string) {
+ token.type != isc_tokentype_string)
+ {
break;
}
RETTOK(txt_fromtext(&token.value.as_textregion, target));
dns_name_init(&suffix, NULL);
dns_name_split(name, labels - 2, &prefix, &suffix);
if (dns_name_equal(&gc_msdcs, &prefix) &&
- dns_name_ishostname(&suffix, false)) {
+ dns_name_ishostname(&suffix, false))
+ {
return (true);
}
dns_name_split(name, dns_name_countlabels(name) - 2, &prefix,
&suffix);
if (dns_name_equal(&gc_msdcs, &prefix) &&
- dns_name_ishostname(&suffix, false)) {
+ dns_name_ishostname(&suffix, false))
+ {
return (true);
}
}
/* Reject duplicates. */
while (region.length >= 4) {
if (region.base[0] == region.base[2] &&
- region.base[1] == region.base[3]) {
+ region.base[1] == region.base[3])
+ {
return (DNS_R_SYNTAX);
}
isc_region_consume(®ion, 2);
break;
case sbpr_ipv4s:
if ((region->length % 4) != 0 ||
- region->length == 0) {
+ region->length == 0)
+ {
return (DNS_R_FORMERR);
}
break;
case sbpr_ipv6s:
if ((region->length % 16) != 0 ||
- region->length == 0) {
+ region->length == 0)
+ {
return (DNS_R_FORMERR);
}
break;
}
case sbpr_keylist: {
if ((region->length % 2) != 0 ||
- region->length == 0) {
+ region->length == 0)
+ {
return (DNS_R_FORMERR);
}
/* In order? */
}
/* MUST be UTF8 */
if (!isc_utf8_valid(region->base,
- region->length)) {
+ region->length))
+ {
return (DNS_R_FORMERR);
}
/* MUST contain "{?dns}" */
if (strnstr((char *)region->base, "{?dns}",
- region->length) == NULL) {
+ region->length) == NULL)
+ {
return (DNS_R_FORMERR);
}
break;
}
/* No zero padding. */
if (region->length > 1 && *region->base == '0' &&
- region->base[1] != sep) {
+ region->base[1] != sep)
+ {
return (DNS_R_SYNTAX);
}
ul = strtoul(region->base, &e, 10);
/* Lone mandatory field. */
return (DNS_R_DISALLOWED);
} else if (key1 == SVCB_NO_DEFAULT_ALPN_KEY &&
- !have_alpn) {
+ !have_alpn)
+ {
/* Missing required ALPN field. */
return (DNS_R_DISALLOWED);
}
RETERR(isc_lex_getmastertoken(lexer, &token,
isc_tokentype_qvpair, true));
if (token.type == isc_tokentype_eol ||
- token.type == isc_tokentype_eof) {
+ token.type == isc_tokentype_eof)
+ {
isc_lex_ungettoken(lexer, &token);
return (svcsortkeys(target, used));
}
continue;
}
if (rdset->type == dns_rdatatype_nsec ||
- rdset->type == dns_rdatatype_nsec3) {
+ rdset->type == dns_rdatatype_nsec3)
+ {
neg = rdset;
}
}
rdset = ISC_LIST_NEXT(rdset, link))
{
if (rdset->type == dns_rdatatype_rrsig &&
- rdset->covers == neg->type) {
+ rdset->covers == neg->type)
+ {
negsig = rdset;
}
}
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == dns_rdatatype_rrsig &&
- rdataset->covers == tneg->type) {
+ rdataset->covers == tneg->type)
+ {
tnegsig = rdataset;
}
}
continue;
}
if (rdset->type == dns_rdatatype_nsec ||
- rdset->type == dns_rdatatype_nsec3) {
+ rdset->type == dns_rdatatype_nsec3)
+ {
neg = rdset;
}
}
rdset = ISC_LIST_NEXT(rdset, link))
{
if (rdset->type == dns_rdatatype_rrsig &&
- rdset->covers == neg->type) {
+ rdset->covers == neg->type)
+ {
negsig = rdset;
}
}
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == dns_rdatatype_rrsig &&
- rdataset->covers == tneg->type) {
+ rdataset->covers == tneg->type)
+ {
tnegsig = rdataset;
}
}
}
if (want_cyclic &&
- (rdataset->count != DNS_RDATASET_COUNT_UNDEFINED)) {
+ (rdataset->count != DNS_RDATASET_COUNT_UNDEFINED))
+ {
j = rdataset->count % count;
}
#endif /* if DNS_RDATASET_FIXED */
if (length1 != length2 ||
- memcmp(current1, current2, length1) != 0) {
+ memcmp(current1, current2, length1) != 0)
+ {
return (false);
}
}
if (srcaddr != NULL &&
- isc_sockaddr_pf(srcaddr) != isc_sockaddr_pf(destaddr)) {
+ isc_sockaddr_pf(srcaddr) != isc_sockaddr_pf(destaddr))
+ {
return (ISC_R_FAMILYMISMATCH);
}
* RRsig from child?
*/
if (type == dns_rdatatype_rrsig &&
- rrsig_fromchildzone(fctx, rdataset)) {
+ rrsig_fromchildzone(fctx, rdataset))
+ {
return (false);
}
/*
* A NODATA response to a DS query?
*/
if (fctx->type == dns_rdatatype_ds &&
- message->counts[DNS_SECTION_ANSWER] == 0) {
+ message->counts[DNS_SECTION_ANSWER] == 0)
+ {
return (false);
}
{
type = rdataset->type;
if (type == dns_rdatatype_soa &&
- dns_name_equal(name, domain)) {
+ dns_name_equal(name, domain))
+ {
keep_auth = true;
}
* case.
*/
if (message->counts[DNS_SECTION_ANSWER] == 0 &&
- fctx->type == dns_rdatatype_any) {
+ fctx->type == dns_rdatatype_any)
+ {
return (false);
}
} else if (dns_name_issubdomain(name, domain)) {
* context.
*/
if (fctx->fwdpolicy == dns_fwdpolicy_first &&
- ISFORWARDER(query->addrinfo)) {
+ ISFORWARDER(query->addrinfo))
+ {
add_bad(fctx, query->rmessage, query->addrinfo,
ISC_R_TIMEDOUT, badns_forwarder);
}
* seen a EDNS response.
*/
if ((query->options & DNS_FETCHOPT_NOEDNS0) == 0 &&
- !EDNSOK(query->addrinfo)) {
+ !EDNSOK(query->addrinfo))
+ {
mask >>= 2;
}
fctx->find = NULL;
for (find = ISC_LIST_HEAD(fctx->altfinds); find != NULL;
- find = next_find) {
+ find = next_find)
+ {
next_find = ISC_LIST_NEXT(find, publink);
ISC_LIST_UNLINK(fctx->altfinds, find, publink);
dns_adb_destroyfind(&find);
fctx->altfind = NULL;
for (addr = ISC_LIST_HEAD(fctx->forwaddrs); addr != NULL;
- addr = next_addr) {
+ addr = next_addr)
+ {
next_addr = ISC_LIST_NEXT(addr, publink);
ISC_LIST_UNLINK(fctx->forwaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
}
for (addr = ISC_LIST_HEAD(fctx->altaddrs); addr != NULL;
- addr = next_addr) {
+ addr = next_addr)
+ {
next_addr = ISC_LIST_NEXT(addr, publink);
ISC_LIST_UNLINK(fctx->altaddrs, addr, publink);
dns_adb_freeaddrinfo(fctx->adb, &addr);
fctx->duration = isc_time_microdiff(&now, &fctx->start);
for (event = ISC_LIST_HEAD(fctx->events); event != NULL;
- event = next_event) {
+ event = next_event)
+ {
next_event = ISC_LIST_NEXT(event, ev_link);
ISC_LIST_UNLINK(fctx->events, event, ev_link);
if (event->ev_type == DNS_EVENT_TRYSTALE) {
* Negative results must be indicated in event->result.
*/
if (dns_rdataset_isassociated(event->rdataset) &&
- NEGATIVE(event->rdataset)) {
+ NEGATIVE(event->rdataset))
+ {
INSIST(event->result == DNS_R_NCACHENXDOMAIN ||
event->result == DNS_R_NCACHENXRRSET);
}
{
LOCK(&fctx->res->lock);
if (count == fctx->res->spillat &&
- !atomic_load_acquire(&fctx->res->exiting)) {
+ !atomic_load_acquire(&fctx->res->exiting))
+ {
old_spillat = fctx->res->spillat;
fctx->res->spillat += 5;
if (fctx->res->spillat > fctx->res->spillatmax &&
- fctx->res->spillatmax != 0) {
+ fctx->res->spillatmax != 0)
+ {
fctx->res->spillat = fctx->res->spillatmax;
}
new_spillat = fctx->res->spillat;
secure_domain = false;
}
if (secure_domain ||
- (ISFORWARDER(query->addrinfo) && ntacovered)) {
+ (ISFORWARDER(query->addrinfo) && ntacovered))
+ {
fctx->qmessage->flags |= DNS_MESSAGEFLAG_CD;
}
}
result = dns_peer_getednsversion(peer,
&ednsversion);
if (result == ISC_R_SUCCESS &&
- ednsversion < version) {
+ ednsversion < version)
+ {
version = ednsversion;
}
}
isc_sockaddr_t *sa;
for (sa = ISC_LIST_HEAD(fctx->bad); sa != NULL;
- sa = ISC_LIST_NEXT(sa, link)) {
+ sa = ISC_LIST_NEXT(sa, link))
+ {
if (isc_sockaddr_equal(sa, address)) {
return (true);
}
* Strip label to get the correct forwarder (if any).
*/
if (dns_rdatatype_atparent(fctx->type) &&
- dns_name_countlabels(name) > 1) {
+ dns_name_countlabels(name) > 1)
+ {
dns_name_init(&suffix, NULL);
labels = dns_name_countlabels(name);
dns_name_getlabelsequence(name, 1, labels - 1, &suffix);
alternate_t *a;
family = (res->dispatches6 != NULL) ? AF_INET6 : AF_INET;
for (a = ISC_LIST_HEAD(res->alternates); a != NULL;
- a = ISC_LIST_NEXT(a, link)) {
+ a = ISC_LIST_NEXT(a, link))
+ {
if (!a->isaddress) {
findname(fctx, &a->_u._n.name, a->_u._n.port,
stdoptions, FCTX_ADDRINFO_DUALSTACK,
}
if (peer != NULL && dns_peer_getbogus(peer, &bogus) == ISC_R_SUCCESS &&
- bogus) {
+ bogus)
+ {
aborted = true;
}
addrinfo = fctx_nextaddress(fctx);
while (addrinfo != NULL &&
- dns_adbentry_overquota(addrinfo->entry)) {
+ dns_adbentry_overquota(addrinfo->entry))
+ {
addrinfo = fctx_nextaddress(fctx);
}
* the forwarder).
*/
if (dns_rdatatype_atparent(fctx->type) &&
- dns_name_countlabels(name) > 1) {
+ dns_name_countlabels(name) > 1)
+ {
dns_name_init(&suffix, NULL);
labels = dns_name_countlabels(name);
dns_name_getlabelsequence(name, 1, labels - 1, &suffix);
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdataset_current(&rdataset, &rdata);
if (rdata.length > 1 && rdata.data[0] == 1 &&
- rdata.data[1] == 0) {
+ rdata.data[1] == 0)
+ {
dns_rdataset_disassociate(&rdataset);
return (true);
}
0);
}
if (result == ISC_R_SUCCESS &&
- vevent->sigrdataset != NULL) {
+ vevent->sigrdataset != NULL)
+ {
(void)dns_db_deleterdataset(
fctx->cache, node, NULL,
dns_rdatatype_rrsig, vevent->type);
vevent->rdataset, 0, NULL);
}
if (result == ISC_R_SUCCESS &&
- vevent->sigrdataset != NULL) {
+ vevent->sigrdataset != NULL)
+ {
(void)dns_db_addrdataset(
fctx->cache, node, NULL, now,
vevent->sigrdataset, 0, NULL);
* Cache DS NXDOMAIN separately to other types.
*/
if (message->rcode == dns_rcode_nxdomain &&
- fctx->type != dns_rdatatype_ds) {
+ fctx->type != dns_rdatatype_ds)
+ {
covers = dns_rdatatype_any;
} else {
covers = fctx->type;
break;
}
if (sigrdataset == NULL ||
- sigrdataset->trust != dns_trust_secure) {
+ sigrdataset->trust != dns_trust_secure)
+ {
continue;
}
* Check SOA and DNSKEY consistency.
*/
if (rdataset->type == dns_rdatatype_nsec &&
- !check_soa_and_dnskey(rdataset)) {
+ !check_soa_and_dnskey(rdataset))
+ {
continue;
}
* Look for \000 label in next name.
*/
if (rdataset->type == dns_rdatatype_nsec &&
- has_000_label(rdataset)) {
+ has_000_label(rdataset))
+ {
continue;
}
*/
INSIST(hevent->rdataset != NULL);
if (dns_rdataset_isassociated(hevent->rdataset) &&
- NEGATIVE(hevent->rdataset)) {
+ NEGATIVE(hevent->rdataset))
+ {
INSIST(eresult == DNS_R_NCACHENXDOMAIN ||
eresult == DNS_R_NCACHENXRRSET);
}
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
if (sigrdataset->type == dns_rdatatype_rrsig &&
- sigrdataset->covers == type) {
+ sigrdataset->covers == type)
+ {
break;
}
}
dns_name_t *nsec = NULL;
dns_message_currentname(message, section, &nsec);
for (nrdataset = ISC_LIST_HEAD(nsec->list); nrdataset != NULL;
- nrdataset = next) {
+ nrdataset = next)
+ {
bool data = false, exists = false;
bool optout = false, unknown = false;
bool setclosest = false;
sigrdataset = ISC_LIST_NEXT(sigrdataset, link))
{
if (sigrdataset->type == dns_rdatatype_rrsig &&
- sigrdataset->covers == found) {
+ sigrdataset->covers == found)
+ {
break;
}
}
* query to the domain that owns them.)
*/
if (secure_domain && rdataset->trust != dns_trust_glue &&
- !EXTERNAL(rdataset)) {
+ !EXTERNAL(rdataset))
+ {
dns_trust_t trust;
/*
}
if (sigrdataset == NULL && need_validation &&
- !ANSWER(rdataset)) {
+ !ANSWER(rdataset))
+ {
/*
* Ignore unrelated non-answer
* rdatasets that are missing
if (!need_validation || !ANSWER(rdataset)) {
options = 0;
if (ANSWER(rdataset) &&
- rdataset->type != dns_rdatatype_rrsig) {
+ rdataset->type != dns_rdatatype_rrsig)
+ {
isc_result_t tresult;
dns_name_t *noqname = NULL;
tresult = findnoqname(
fctx, message, name,
rdataset->type, &noqname);
if (tresult == ISC_R_SUCCESS &&
- noqname != NULL) {
+ noqname != NULL)
+ {
(void)dns_rdataset_addnoqname(
rdataset, noqname);
}
}
if ((fctx->options & DNS_FETCHOPT_PREFETCH) !=
- 0) {
+ 0)
+ {
options = DNS_DBADD_PREFETCH;
}
if ((fctx->options & DNS_FETCHOPT_NOCACHED) !=
- 0) {
+ 0)
+ {
options |= DNS_DBADD_FORCE;
}
addedrdataset = ardataset;
result = ISC_R_SUCCESS;
if (!need_validation &&
ardataset != NULL &&
- NEGATIVE(ardataset)) {
+ NEGATIVE(ardataset))
+ {
/*
* The answer in the
* cache is better than
}
if (ANSWER(rdataset) &&
- rdataset->type != dns_rdatatype_rrsig) {
+ rdataset->type != dns_rdatatype_rrsig)
+ {
isc_result_t tresult;
dns_name_t *noqname = NULL;
tresult = findnoqname(fctx, message, name,
if (result == DNS_R_UNCHANGED) {
if (ANSWER(rdataset) && ardataset != NULL &&
- NEGATIVE(ardataset)) {
+ NEGATIVE(ardataset))
+ {
/*
* The answer in the cache is
* better than the answer we
* event->result.
*/
if (dns_rdataset_isassociated(event->rdataset) &&
- NEGATIVE(event->rdataset)) {
+ NEGATIVE(event->rdataset))
+ {
INSIST(eresult == DNS_R_NCACHENXDOMAIN ||
eresult == DNS_R_NCACHENXRRSET);
}
LOCK(&fctx->bucket->lock);
for (section = DNS_SECTION_ANSWER; section <= DNS_SECTION_ADDITIONAL;
- section++) {
+ section++)
+ {
result = dns_message_firstname(message, section);
while (result == ISC_R_SUCCESS) {
name = NULL;
rtype = rdataset->type;
}
if (rtype == dns_rdatatype_a ||
- rtype == dns_rdatatype_aaaa) {
+ rtype == dns_rdatatype_aaaa)
+ {
mark_related(name, rdataset, external,
gluing);
}
*/
dns_rdataset_init(&nameservers);
if (dns_rdataset_isassociated(
- &fctx->nsfetch->private->nameservers)) {
+ &fctx->nsfetch->private->nameservers))
+ {
dns_rdataset_clone(&fctx->nsfetch->private->nameservers,
&nameservers);
nsrdataset = &nameservers;
if (result != ISC_R_SUCCESS) {
FCTXTRACE3("signature check failed", result);
if (result == DNS_R_UNEXPECTEDTSIG ||
- result == DNS_R_EXPECTEDTSIG) {
+ result == DNS_R_EXPECTEDTSIG)
+ {
rctx.nextitem = true;
}
rctx_done(&rctx, result);
&required);
if (result == ISC_R_SUCCESS && required) {
if (isc_log_wouldlog(dns_lctx,
- ISC_LOG_INFO)) {
+ ISC_LOG_INFO))
+ {
char addrbuf
[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(
*/
rctx->type = fctx->type;
if (rctx->type == dns_rdatatype_rrsig ||
- rctx->type == dns_rdatatype_sig) {
+ rctx->type == dns_rdatatype_sig)
+ {
rctx->type = dns_rdatatype_any;
}
rdataset = ISC_LIST_NEXT(rdataset, link))
{
if (rdataset->type == rctx->type ||
- rctx->type == dns_rdatatype_any) {
+ rctx->type == dns_rdatatype_any)
+ {
rctx->aname = name;
if (rctx->type != dns_rdatatype_any) {
rctx->ardataset = rdataset;
* and any previously found dname.
*/
if (nlabels >= rctx->dname_labels ||
- nlabels < rctx->domain_labels) {
+ nlabels < rctx->domain_labels)
+ {
continue;
}
*/
if (rdataset->type == dns_rdatatype_ns) {
if (rctx->ns_name != NULL &&
- name != rctx->ns_name) {
+ name != rctx->ns_name)
+ {
log_formerr(fctx, "multiple NS "
"RRsets "
"in "
*/
if (rdataset->type == dns_rdatatype_soa) {
if (rctx->soa_name != NULL &&
- name != rctx->soa_name) {
+ name != rctx->soa_name)
+ {
log_formerr(fctx, "multiple "
"SOA RRs "
"in "
if (rdataset->type == dns_rdatatype_ds) {
if (rctx->ds_name != NULL &&
- name != rctx->ds_name) {
+ name != rctx->ds_name)
+ {
log_formerr(fctx, "DS doesn't "
"match "
"referral "
* Record that we got a good EDNS response.
*/
if (query->ednsversion > (int)version &&
- !EDNSOK(query->addrinfo)) {
+ !EDNSOK(query->addrinfo))
+ {
dns_adb_changeflags(fctx->adb, query->addrinfo,
FCTX_ADDRINFO_EDNSOK,
FCTX_ADDRINFO_EDNSOK);
if (fctx->state != fetchstate_done) {
dns_fetchevent_t *next_event = NULL;
for (event = ISC_LIST_HEAD(fctx->events); event != NULL;
- event = next_event) {
+ event = next_event)
+ {
next_event = ISC_LIST_NEXT(event, ev_link);
if (event->fetch == fetch) {
ISC_LIST_UNLINK(fctx->events, event, ev_link);
if (fctx->state != fetchstate_done) {
dns_fetchevent_t *event = NULL, *next_event = NULL;
for (event = ISC_LIST_HEAD(fctx->events); event != NULL;
- event = next_event) {
+ event = next_event)
+ {
next_event = ISC_LIST_NEXT(event, ev_link);
RUNTIME_CHECK(event->fetch != fetch);
}
isc_result_t result;
if (strcmp(view->name, "_bind") != 0 &&
- strcmp(view->name, "_default") != 0) {
+ strcmp(view->name, "_default") != 0)
+ {
viewname = view->name;
sep = ": view ";
}
isc_stdtime_get(&now);
if (strcmp(view->name, "_bind") != 0 &&
- strcmp(view->name, "_default") != 0) {
+ strcmp(view->name, "_default") != 0)
+ {
viewname = view->name;
sep = ": view ";
}
*/
*tgt_prefix = (dns_rpz_prefix_t)prefix_num;
for (i = 0; ip_labels > 0 && i < DNS_RPZ_CIDR_WORDS * 2;
- ip_labels--) {
+ ip_labels--)
+ {
if (cp[0] == 'z' && cp[1] == 'z' &&
- (cp[2] == '.' || cp[2] == '\0') && i <= 6) {
+ (cp[2] == '.' || cp[2] == '\0') && i <= 6)
+ {
do {
if ((i & 1) == 0) {
tgt_ip->w[3 - i / 2] = 0;
} else {
l = strtoul(cp, &cp2, 16);
if (l > 0xffffu ||
- (*cp2 != '.' && *cp2 != '\0')) {
+ (*cp2 != '.' && *cp2 != '\0'))
+ {
if (*cp2 == '.') {
*cp2 = '\0';
}
* Complain about bad names but be generous and accept them.
*/
if (log_level < DNS_RPZ_DEBUG_QUIET &&
- isc_log_wouldlog(dns_lctx, log_level)) {
+ isc_log_wouldlog(dns_lctx, log_level))
+ {
/*
* Convert the address back to a canonical domain name
* to ensure that the original name is in canonical form.
result = ip2name(tgt_ip, (dns_rpz_prefix_t)prefix_num, NULL,
ip_name2);
if (result != ISC_R_SUCCESS ||
- !dns_name_equal(&ip_name, ip_name2)) {
+ !dns_name_equal(&ip_name, ip_name2))
+ {
char ip2_str[DNS_NAME_FORMATSIZE];
dns_name_format(ip_name2, ip2_str, sizeof(ip2_str));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
*/
LOCK(&rpzs->maint_lock);
for (dns_rpz_num_t rpz_num = 0; rpz_num < DNS_RPZ_MAX_ZONES;
- ++rpz_num) {
+ ++rpz_num)
+ {
if (rpzs->zones[rpz_num] != NULL) {
rpz_detach(&rpzs->zones[rpz_num]);
}
child = tgt->child[1];
}
if (tgt->set.client_ip != 0 || tgt->set.ip != 0 ||
- tgt->set.nsip != 0) {
+ tgt->set.nsip != 0)
+ {
break;
}
int i;
if (rrl->num_entries + newsize >= rrl->max_entries &&
- rrl->max_entries != 0) {
+ rrl->max_entries != 0)
+ {
newsize = rrl->max_entries - rrl->num_entries;
if (newsize <= 0) {
return (ISC_R_SUCCESS);
rrl->probes += probes;
++rrl->searches;
if (rrl->searches > 100 &&
- delta_rrl_time(rrl->hash->check_time, now) > 1) {
+ delta_rrl_time(rrl->hash->check_time, now) > 1)
+ {
if (rrl->probes / rrl->searches > 2) {
expand_rrl_hash(rrl, now);
}
key->s.qtype = qtype;
key->s.qclass = qclass & 0xff;
} else if (rtype == DNS_RRL_RTYPE_REFERRAL ||
- rtype == DNS_RRL_RTYPE_NODATA) {
+ rtype == DNS_RRL_RTYPE_NODATA)
+ {
/*
* Because there is no qtype in the empty answer sections of
* referral and NODATA responses, count them as the same.
{
qbuf = get_qname(rrl, e);
if (save_qname && qbuf == NULL && qname != NULL &&
- dns_name_isabsolute(qname)) {
+ dns_name_isabsolute(qname))
+ {
/*
* Capture the qname for the "stop limiting" message.
*/
if (now != 0) {
age = get_age(rrl, e, now);
if (age < DNS_RRL_STOP_LOG_SECS ||
- response_balance(rrl, e, age) < 0) {
+ response_balance(rrl, e, age) < 0)
+ {
break;
}
}
qps = (1.0 * rrl->qps_responses) / secs;
if (secs >= rrl->window) {
if (isc_log_wouldlog(dns_lctx,
- DNS_RRL_LOG_DEBUG3)) {
+ DNS_RRL_LOG_DEBUG3))
+ {
isc_log_write(dns_lctx,
DNS_LOGCATEGORY_RRL,
DNS_LOGMODULE_REQUEST,
dns_name_dup(newname, mctx, sdbnode->name);
ISC_LIST_PREPEND(allnodes->nodelist, sdbnode, link);
if (allnodes->origin == NULL &&
- dns_name_equal(newname, &sdb->common.origin)) {
+ dns_name_equal(newname, &sdb->common.origin))
+ {
allnodes->origin = sdbnode;
}
}
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
dns_rdataset_isassociated(
- sigrdataset)) {
+ sigrdataset))
+ {
dns_rdataset_disassociate(
sigrdataset);
}
}
if ((options & DNS_DB_NSEC3ONLY) != 0 ||
- (options & DNS_DB_NONSEC3) != 0) {
+ (options & DNS_DB_NONSEC3) != 0)
+ {
return (ISC_R_NOTIMPLEMENTED);
}
* for wildcards at each level.
*/
if (result == ISC_R_NOTFOUND && !create &&
- (options & DNS_DBFIND_NOWILD) == 0) {
+ (options & DNS_DBFIND_NOWILD) == 0)
+ {
unsigned int i, dlabels, nlabels;
nlabels = dns_name_countlabels(name);
}
if ((options & DNS_DB_NSEC3ONLY) != 0 ||
- (options & DNS_DB_NONSEC3) != 0) {
+ (options & DNS_DB_NONSEC3) != 0)
+ {
return (ISC_R_NOTIMPLEMENTED);
}
rdataset, sigrdataset);
if (result == ISC_R_SUCCESS && i == nlabels &&
- type == dns_rdatatype_any) {
+ type == dns_rdatatype_any)
+ {
result = DNS_R_ZONECUT;
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
break;
dns_name_dup(newname, mctx, sdlznode->name);
ISC_LIST_PREPEND(allnodes->nodelist, sdlznode, link);
if (allnodes->origin == NULL &&
- dns_name_equal(newname, &sdlz->common.origin)) {
+ dns_name_equal(newname, &sdlz->common.origin))
+ {
allnodes->origin = sdlznode;
}
}
}
if (dns_name_iswildcard(rule->identity)) {
if (!dns_name_matcheswildcard(signer,
- rule->identity)) {
+ rule->identity))
+ {
continue;
}
} else {
break;
case dns_ssumatchtype_selfkrb5:
if (dst_gssapi_identitymatchesrealmkrb5(
- signer, name, rule->identity, false)) {
+ signer, name, rule->identity, false))
+ {
break;
}
continue;
case dns_ssumatchtype_selfms:
if (dst_gssapi_identitymatchesrealmms(
- signer, name, rule->identity, false)) {
+ signer, name, rule->identity, false))
+ {
break;
}
continue;
case dns_ssumatchtype_selfsubkrb5:
if (dst_gssapi_identitymatchesrealmkrb5(
- signer, name, rule->identity, true)) {
+ signer, name, rule->identity, true))
+ {
break;
}
continue;
case dns_ssumatchtype_selfsubms:
if (dst_gssapi_identitymatchesrealmms(
- signer, name, rule->identity, true)) {
+ signer, name, rule->identity, true))
+ {
break;
}
continue;
break;
}
if (dst_gssapi_identitymatchesrealmkrb5(
- signer, tname, rule->identity, false)) {
+ signer, tname, rule->identity, false))
+ {
break;
}
continue;
break;
}
if (dst_gssapi_identitymatchesrealmms(
- signer, tname, rule->identity, false)) {
+ signer, tname, rule->identity, false))
+ {
break;
}
continue;
reverse_from_address(tcpself, addr);
if (dns_name_iswildcard(rule->identity)) {
if (!dns_name_matcheswildcard(tcpself,
- rule->identity)) {
+ rule->identity))
+ {
continue;
}
} else {
stf_from_address(stfself, addr);
if (dns_name_iswildcard(rule->identity)) {
if (!dns_name_matcheswildcard(stfself,
- rule->identity)) {
+ rule->identity))
+ {
continue;
}
} else {
break;
case dns_ssumatchtype_dlz:
if (!dns_dlz_ssumatch(table->dlzdatabase, signer, name,
- addr, type, key)) {
+ addr, type, key))
+ {
continue;
}
break;
* checks will have already checked the type.
*/
if (rule->matchtype != dns_ssumatchtype_dlz &&
- !isusertype(type)) {
+ !isusertype(type))
+ {
continue;
}
} else {
for (i = 0; i < rule->ntypes; i++) {
if (rule->types[i].type == dns_rdatatype_any ||
- rule->types[i].type == type) {
+ rule->types[i].type == type)
+ {
break;
}
}
* (active, stale, or ancient) value in the RRtype part.
*/
if ((DNS_RDATASTATSTYPE_ATTR(rrsettype) &
- DNS_RDATASTATSTYPE_ATTR_ANCIENT) != 0) {
+ DNS_RDATASTATSTYPE_ATTR_ANCIENT) != 0)
+ {
counter |= RDTYPECOUNTER_NXDOMAIN_ANCIENT;
} else if ((DNS_RDATASTATSTYPE_ATTR(rrsettype) &
DNS_RDATASTATSTYPE_ATTR_STALE) != 0)
counter = rdatatype2counter(DNS_RDATASTATSTYPE_BASE(rrsettype));
if ((DNS_RDATASTATSTYPE_ATTR(rrsettype) &
- DNS_RDATASTATSTYPE_ATTR_NXRRSET) != 0) {
+ DNS_RDATASTATSTYPE_ATTR_NXRRSET) != 0)
+ {
counter |= RDTYPECOUNTER_NXRRSET;
}
if ((DNS_RDATASTATSTYPE_ATTR(rrsettype) &
- DNS_RDATASTATSTYPE_ATTR_ANCIENT) != 0) {
+ DNS_RDATASTATSTYPE_ATTR_ANCIENT) != 0)
+ {
counter |= RDTYPECOUNTER_ANCIENT;
} else if ((DNS_RDATASTATSTYPE_ATTR(rrsettype) &
DNS_RDATASTATSTYPE_ATTR_STALE) != 0)
* expiry value (active, stale, or ancient).
*/
if ((counter & RDTYPECOUNTER_MAXTYPE) ==
- RDTYPECOUNTER_NXDOMAIN_STALE) {
+ RDTYPECOUNTER_NXDOMAIN_STALE)
+ {
attributes |= DNS_RDATASTATSTYPE_ATTR_STALE;
} else if ((counter & RDTYPECOUNTER_MAXTYPE) ==
- RDTYPECOUNTER_NXDOMAIN_ANCIENT) {
+ RDTYPECOUNTER_NXDOMAIN_ANCIENT)
+ {
attributes |= DNS_RDATASTATSTYPE_ATTR_ANCIENT;
}
} else {
result = dns_message_signer(msg, &tsigner);
if (result != ISC_R_SUCCESS) {
if (tkeyin.mode == DNS_TKEYMODE_GSSAPI &&
- result == ISC_R_NOTFOUND) {
+ result == ISC_R_NOTFOUND)
+ {
signer = NULL;
} else {
tkey_log("dns_tkey_processquery: query was not "
}
if (dns_transport_get_prefer_server_ciphers(
- transport, &prefer_server_ciphers)) {
+ transport, &prefer_server_ciphers))
+ {
isc_tlsctx_prefer_server_ciphers(tlsctx,
prefer_server_ciphers);
}
* Ignore this if it's a GSS key, since the key size is meaningless.
*/
if (dstkey != NULL && dst_key_size(dstkey) < 64 &&
- dstalg != DST_ALG_GSSAPI) {
+ dstalg != DST_ALG_GSSAPI)
+ {
char namestr[DNS_NAME_FORMATSIZE];
dns_name_format(name, namestr, sizeof(namestr));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
}
isc_buffer_putuint16(&databuf, querytsig.siglen);
if (isc_buffer_availablelength(&databuf) <
- querytsig.siglen) {
+ querytsig.siglen)
+ {
ret = ISC_R_NOSPACE;
goto cleanup_context;
}
return (DNS_R_FORMERR);
}
if (tsig.siglen > 0 &&
- (tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2))) {
+ (tsig.siglen < 10 || tsig.siglen < ((siglen + 1) / 2)))
+ {
tsig_log(msg->tsigkey, 2,
"signature length below minimum");
return (DNS_R_FORMERR);
uint16_t digestbits = dst_key_getbits(key);
if (tsig.siglen > 0 && digestbits != 0 &&
- tsig.siglen < ((digestbits + 7) / 8)) {
+ tsig.siglen < ((digestbits + 7) / 8))
+ {
msg->tsigstatus = dns_tsigerror_badtrunc;
tsig_log(msg->tsigkey, 2,
"truncated signature length too small");
}
if (tsig.siglen > 0 &&
(tsig.siglen < 10 ||
- tsig.siglen < ((siglen + 1) / 2))) {
+ tsig.siglen < ((siglen + 1) / 2)))
+ {
tsig_log(tsigkey, 2,
"signature length below minimum");
ret = DNS_R_FORMERR;
uint16_t digestbits = dst_key_getbits(key);
if (tsig.siglen > 0 && digestbits != 0 &&
- tsig.siglen < ((digestbits + 7) / 8)) {
+ tsig.siglen < ((digestbits + 7) / 8))
+ {
msg->tsigstatus = dns_tsigerror_badtrunc;
tsig_log(msg->tsigkey, 2,
"truncated signature length "
goto cleanup_context;
}
if (tsig.siglen > 0 && digestbits == 0 &&
- tsig.siglen < siglen) {
+ tsig.siglen < siglen)
+ {
msg->tsigstatus = dns_tsigerror_badtrunc;
tsig_log(msg->tsigkey, 2,
"signature length too small");
continue;
} else if (zsk &&
!dst_key_is_signing(keys[i], DST_BOOL_ZSK,
- inception, &when)) {
+ inception, &when))
+ {
/*
* This key is not active for zone-signing.
*/
if (rrsig.keyid == dst_key_id(keys[i])) {
found = true;
if (!dst_key_isprivate(keys[i]) &&
- !dst_key_inactive(keys[i])) {
+ !dst_key_inactive(keys[i]))
+ {
/*
* The re-signing code in zone.c
* will mark this as offline.
* as they are handled elsewhere.
*/
if ((type == dns_rdatatype_rrsig) ||
- (cut && type != dns_rdatatype_ds)) {
+ (cut && type != dns_rdatatype_ds))
+ {
continue;
}
result = rrset_exists(db, ver, name, dns_rdatatype_rrsig, type,
/* Skip any other updates to the same RRset. */
while (t != NULL &&
dns_name_equal(&t->name, name) &&
- t->rdata.type == type) {
+ t->rdata.type == type)
+ {
next = ISC_LIST_NEXT(t, link);
ISC_LIST_UNLINK(diff->tuples, t, link);
ISC_LIST_APPEND(state->work.tuples, t,
dns_rdatatype_dname, 0,
&dname_exists));
if ((ns_exists || dname_exists) ==
- (ns_existed || dname_existed)) {
+ (ns_existed || dname_existed))
+ {
continue;
}
/*
bool exists, existed;
if (t->rdata.type == dns_rdatatype_nsec ||
- t->rdata.type == dns_rdatatype_rrsig) {
+ t->rdata.type == dns_rdatatype_rrsig)
+ {
t = ISC_LIST_NEXT(t, link);
continue;
}
* Only extract the dst key if the keyset exists and is secure.
*/
if (eresult == ISC_R_SUCCESS &&
- rdataset->trust >= dns_trust_secure) {
+ rdataset->trust >= dns_trust_secure)
+ {
result = select_signing_key(val, rdataset);
if (result == ISC_R_SUCCESS) {
val->keyset = &val->frdataset;
}
result = validate_answer(val, true);
if (result == DNS_R_NOVALIDSIG &&
- (val->attributes & VALATTR_TRIEDVERIFY) == 0) {
+ (val->attributes & VALATTR_TRIEDVERIFY) == 0)
+ {
saved_result = result;
validator_log(val, ISC_LOG_DEBUG(3),
"falling back to insecurity proof");
}
result = validate_answer(val, true);
if (result == DNS_R_NOVALIDSIG &&
- (val->attributes & VALATTR_TRIEDVERIFY) == 0) {
+ (val->attributes & VALATTR_TRIEDVERIFY) == 0)
+ {
saved_result = result;
validator_log(val, ISC_LOG_DEBUG(3),
"falling back to insecurity proof");
* the wildcard used to generate the response.
*/
if (clabels == 0 ||
- dns_name_countlabels(wild) == clabels + 1) {
+ dns_name_countlabels(wild) == clabels + 1)
+ {
val->attributes |= VALATTR_FOUNDCLOSEST;
}
/*
namereln = dns_name_fullcompare(val->event->name, &siginfo->signer,
&order, &nlabels);
if (namereln != dns_namereln_subdomain &&
- namereln != dns_namereln_equal) {
+ namereln != dns_namereln_equal)
+ {
return (DNS_R_CONTINUE);
}
}
for (; result == ISC_R_SUCCESS;
- result = dns_rdataset_next(event->sigrdataset)) {
+ result = dns_rdataset_next(event->sigrdataset))
+ {
dns_rdata_reset(&rdata);
dns_rdataset_current(event->sigrdataset, &rdata);
if (val->siginfo == NULL) {
result = val_rdataset_next(val, &name, &rdataset))
{
if (rdataset->type != type ||
- rdataset->trust != dns_trust_secure) {
+ rdataset->trust != dns_trust_secure)
+ {
continue;
}
* which proof. Just populate them.
*/
if (NEEDNOQNAME(val) &&
- proofs[DNS_VALIDATOR_NOQNAMEPROOF] == NULL) {
+ proofs[DNS_VALIDATOR_NOQNAMEPROOF] == NULL)
+ {
proofs[DNS_VALIDATOR_NOQNAMEPROOF] = name;
} else if (setclosest) {
proofs[DNS_VALIDATOR_CLOSESTENCLOSER] = name;
} else if (NEEDNODATA(val) &&
- proofs[DNS_VALIDATOR_NODATAPROOF] == NULL) {
+ proofs[DNS_VALIDATOR_NODATAPROOF] == NULL)
+ {
proofs[DNS_VALIDATOR_NODATAPROOF] = name;
} else if (NEEDNOWILDCARD(val) &&
proofs[DNS_VALIDATOR_NOWILDCARDPROOF] ==
- NULL) {
+ NULL)
+ {
proofs[DNS_VALIDATOR_NOWILDCARDPROOF] = name;
}
return (result);
}
for (; rdataset != NULL;
- rdataset = ISC_LIST_NEXT(rdataset, link)) {
+ rdataset = ISC_LIST_NEXT(rdataset, link))
+ {
if (rdataset->type == dns_rdatatype_rrsig) {
continue;
}
result = validate_answer(val, false);
}
if (result == DNS_R_NOVALIDSIG &&
- (val->attributes & VALATTR_TRIEDVERIFY) == 0) {
+ (val->attributes & VALATTR_TRIEDVERIFY) == 0)
+ {
saved_result = result;
validator_log(val, ISC_LOG_DEBUG(3),
"falling back to insecurity proof");
}
}
} else if (val->event->rdataset != NULL &&
- val->event->rdataset->type != 0) {
+ val->event->rdataset->type != 0)
+ {
/*
* This is either an unsecure subdomain or a response
* from a broken server.
"parent indicates it should be secure");
}
} else if ((val->event->rdataset == NULL &&
- val->event->sigrdataset == NULL)) {
+ val->event->sigrdataset == NULL))
+ {
/*
* This is a validation of a negative response.
*/
result = validate_nx(val, false);
} else if ((val->event->rdataset != NULL &&
- NEGATIVE(val->event->rdataset))) {
+ NEGATIVE(val->event->rdataset)))
+ {
/*
* This is a delayed validation of a negative cache entry.
*/
dns_rdataset_disassociate(rdataset);
}
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
if (node != NULL) {
if (dns_rdataset_isassociated(&zrdataset)) {
dns_rdataset_clone(&zrdataset, rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(&zsigrdataset)) {
+ dns_rdataset_isassociated(&zsigrdataset))
+ {
dns_rdataset_clone(&zsigrdataset,
sigrdataset);
}
dns_rdataset_clone(rdataset, &zrdataset);
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_clone(sigrdataset, &zsigrdataset);
dns_rdataset_disassociate(sigrdataset);
}
dns_rdataset_disassociate(rdataset);
}
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
if (db != NULL) {
dns_rdataset_disassociate(rdataset);
}
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
} else if (result != ISC_R_SUCCESS && result != DNS_R_GLUE &&
dns_rdataset_disassociate(rdataset);
}
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
result = ISC_R_NOTFOUND;
dns_rdataset_clone(rdataset, &zrdataset);
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_clone(sigrdataset, &zsigrdataset);
dns_rdataset_disassociate(sigrdataset);
}
if (dns_rdataset_isassociated(rdataset)) {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
}
}
dns_rdataset_clone(&zrdataset, rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(&zrdataset)) {
+ dns_rdataset_isassociated(&zrdataset))
+ {
dns_rdataset_clone(&zsigrdataset, sigrdataset);
}
} else if (try_hints) {
CHECK(isc_lex_gettoken(lex, options, &token));
if (token.type != isc_tokentype_eol &&
- token.type != isc_tokentype_eof) {
+ token.type != isc_tokentype_eof)
+ {
CHECK(ISC_R_UNEXPECTEDTOKEN);
}
xfr->nrecs++;
if (rdata->type == dns_rdatatype_none ||
- dns_rdatatype_ismeta(rdata->type)) {
+ dns_rdatatype_ismeta(rdata->type))
+ {
FAIL(DNS_R_FORMERR);
}
* apex.
*/
if (rdata->type == dns_rdatatype_soa &&
- !dns_name_equal(&xfr->name, name)) {
+ !dns_name_equal(&xfr->name, name))
+ {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(name, namebuf, sizeof(namebuf));
xfrin_log(xfr, ISC_LOG_DEBUG(3), "SOA name mismatch: '%s'",
}
}
if (rdata->type == dns_rdatatype_ns &&
- dns_name_iswildcard(name)) {
+ dns_name_iswildcard(name))
+ {
FAIL(DNS_R_INVALIDNS);
}
CHECK(ixfr_putdata(xfr, DNS_DIFFOP_ADD, name, ttl, rdata));
xfrin_fail(dns_xfrin_ctx_t *xfr, isc_result_t result, const char *msg) {
/* Make sure only the first xfrin_fail() trumps */
if (atomic_compare_exchange_strong(&xfr->shuttingdown, &(bool){ false },
- true)) {
+ true))
+ {
if (result != DNS_R_UPTODATE && result != DNS_R_TOOMANYRECORDS)
{
xfrin_log(xfr, ISC_LOG_ERROR, "%s: %s", msg,
{
result = dns_result_fromrcode(msg->rcode);
} else if (result == ISC_R_SUCCESS &&
- msg->opcode != dns_opcode_query) {
+ msg->opcode != dns_opcode_query)
+ {
result = DNS_R_UNEXPECTEDOPCODE;
} else if (result == ISC_R_SUCCESS &&
- msg->rdclass != xfr->rdclass) {
+ msg->rdclass != xfr->rdclass)
+ {
result = DNS_R_BADCLASS;
} else if (result == ISC_R_SUCCESS || result == DNS_R_NOERROR) {
result = DNS_R_UNEXPECTEDID;
}
if (xfr->reqtype == dns_rdatatype_axfr ||
- xfr->reqtype == dns_rdatatype_soa) {
+ xfr->reqtype == dns_rdatatype_soa)
+ {
goto failure;
}
}
if (xfr->reqtype == dns_rdatatype_soa &&
- (msg->flags & DNS_MESSAGEFLAG_AA) == 0) {
+ (msg->flags & DNS_MESSAGEFLAG_AA) == 0)
+ {
FAIL(DNS_R_NOTAUTHORITATIVE);
}
result = isc_file_getmodtime(zone->masterfile, &modtime);
if (result != ISC_R_SUCCESS ||
- isc_time_compare(&modtime, &zone->loadtime) > 0) {
+ isc_time_compare(&modtime, &zone->loadtime) > 0)
+ {
return (true);
}
}
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) &&
- !zone_touched(zone)) {
+ !zone_touched(zone))
+ {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_DEBUG(1),
"skipping load: master file "
*/
result = isc_file_getmodtime(zone->masterfile, &filetime);
if (result == ISC_R_SUCCESS &&
- isc_time_compare(&loadtime, &filetime) > 0) {
+ isc_time_compare(&loadtime, &filetime) > 0)
+ {
loadtime = filetime;
}
}
* fermat number).
*/
if (dnskey.datalen > 1 && dnskey.data[0] == 1 &&
- dnskey.data[1] == 3) {
+ dnskey.data[1] == 3)
+ {
const char *algorithm = "";
isc_region_t r;
bool logit = true;
{
dns_rdataset_current(&rdataset, &rdata);
if (rdata.length != 5 || rdata.data[0] == 0 ||
- rdata.data[4] != 0) {
+ rdata.data[4] != 0)
+ {
dns_rdata_reset(&rdata);
continue;
}
* represent an NSEC3PARAM record, so skip it.
*/
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
result = dns_rdata_tostruct(&rdata, &nsec3param, NULL);
} else {
int level = ISC_LOG_ERROR;
if (zone->type == dns_zone_key &&
- result == ISC_R_FILENOTFOUND) {
+ result == ISC_R_FILENOTFOUND)
+ {
level = ISC_LOG_DEBUG(1);
}
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD, level,
goto cleanup;
}
if (zone->type != dns_zone_stub &&
- zone->type != dns_zone_redirect) {
+ zone->type != dns_zone_redirect)
+ {
result = check_nsec3param(zone, db);
if (result != ISC_R_SUCCESS) {
goto cleanup;
INSIST(zone->raw == NULL);
if (serial == oldserial &&
- zone_unchanged(zone->db, db, zone->mctx)) {
+ zone_unchanged(zone->db, db, zone->mctx))
+ {
dns_zone_logc(zone,
DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_INFO,
isc_random_uniform((zone->retry * 3) / 4));
DNS_ZONE_TIME_ADD(&now, delay, &zone->refreshtime);
if (isc_time_compare(&zone->refreshtime,
- &zone->expiretime) >= 0) {
+ &zone->expiretime) >= 0)
+ {
zone->refreshtime = now;
}
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_LOADED |
DNS_ZONEFLG_NEEDSTARTUPNOTIFY);
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_SENDSECURE) &&
- inline_raw(zone)) {
+ inline_raw(zone))
+ {
if (zone->secure->db == NULL) {
zone_send_securedb(zone, db);
} else {
}
result = ISC_R_SUCCESS;
} else if (zone->type == dns_zone_primary ||
- zone->type == dns_zone_redirect) {
+ zone->type == dns_zone_redirect)
+ {
if (!(inline_secure(zone) && result == ISC_R_FILENOTFOUND)) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_ERROR,
/* Add new 'dnskeys' to 'keys'. */
for (dns_dnsseckey_t *k1 = ISC_LIST_HEAD(dnskeys); k1 != NULL;
- k1 = key_next) {
+ k1 = key_next)
+ {
dns_dnsseckey_t *k2 = NULL;
key_next = ISC_LIST_NEXT(k1, link);
for (k2 = ISC_LIST_HEAD(*keys); k2 != NULL;
- k2 = ISC_LIST_NEXT(k2, link)) {
+ k2 = ISC_LIST_NEXT(k2, link))
+ {
if (dst_key_compare(k1->key, k2->key)) {
break;
}
* iff there is a new offline signature.
*/
if (!dst_key_inactive(keys[i]) &&
- !dst_key_isprivate(keys[i])) {
+ !dst_key_isprivate(keys[i]))
+ {
int64_t timeexpire = dns_time64_from32(
rrsig.timeexpire);
if (timewarn != 0 &&
- timewarn > timeexpire) {
+ timewarn > timeexpire)
+ {
timewarn = timeexpire;
}
if (rdata.flags & DNS_RDATA_OFFLINE) {
if (timemaybe == 0 ||
- timemaybe > timeexpire) {
+ timemaybe > timeexpire)
+ {
timemaybe = timeexpire;
}
break;
timewarn = timemaybe;
}
if (timewarn == 0 ||
- timewarn > timeexpire) {
+ timewarn > timeexpire)
+ {
timewarn = timeexpire;
}
result = offline(db, ver, zonediff,
* Other RRsets are signed with ZSK.
*/
if (type != dns_rdatatype_soa &&
- type != zone->privatetype) {
+ type != zone->privatetype)
+ {
continue;
}
if (have_zsk) {
continue;
}
} else if (!dst_key_is_signing(keys[i], DST_BOOL_ZSK,
- inception, &when)) {
+ inception, &when))
+ {
/*
* This key is not active for zone-signing.
*/
* Pause for 5 minutes.
*/
if (zone->update_disabled ||
- DNS_ZONEKEY_OPTION(zone, DNS_ZONEKEY_NORESIGN)) {
+ DNS_ZONEKEY_OPTION(zone, DNS_ZONEKEY_NORESIGN))
+ {
result = ISC_R_FAILURE;
goto failure;
}
result = dns_rdata_tostruct(&rdata, &rrsig, NULL);
INSIST(result == ISC_R_SUCCESS);
if (rrsig.algorithm == dst_key_alg(key) &&
- rrsig.keyid == dst_key_id(key)) {
+ rrsig.keyid == dst_key_id(key))
+ {
dns_rdataset_disassociate(&rdataset);
return (true);
}
dns_rdatasetiter_current(iterator, &rdataset);
if (rdataset.type == dns_rdatatype_soa ||
- rdataset.type == dns_rdatatype_rrsig) {
+ rdataset.type == dns_rdatatype_rrsig)
+ {
goto next_rdataset;
}
if (rdataset.type == dns_rdatatype_dnskey ||
} else if (!is_zsk) {
goto next_rdataset;
} else if (is_zsk && !dst_key_is_signing(key, DST_BOOL_ZSK,
- inception, &when)) {
+ inception, &when))
+ {
/* Only applies to dnssec-policy. */
if (dns_zone_getkasp(zone) != NULL) {
goto next_rdataset;
goto next_rdataset;
}
if (signed_with_good_key(zone, db, node, version, rdataset.type,
- key)) {
+ key))
+ {
goto next_rdataset;
}
dns_rdataset_current(&rdataset, &private);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
CHECK(dns_rdata_tostruct(&rdata, &nsec3param, NULL));
dns_rdataset_current(&rdataset, &rdata);
CHECK(dns_rdata_tostruct(&rdata, &rrsig, NULL));
if (nkeys != 0 && (rrsig.algorithm != algorithm ||
- rrsig.keyid != keyid)) {
+ rrsig.keyid != keyid))
+ {
if (rrsig.algorithm == algorithm) {
has_alg = true;
}
* with the algorithm that was being removed.
*/
if (signing->deleteit &&
- ALG(zone_keys[i]) != signing->algorithm) {
+ ALG(zone_keys[i]) != signing->algorithm)
+ {
continue;
}
}
for (j = 0; j < nkeys; j++) {
if (j == i || (ALG(zone_keys[i]) !=
- ALG(zone_keys[j]))) {
+ ALG(zone_keys[j])))
+ {
continue;
}
/*
if (KSK(zone_keys[j])) {
have_ksk = true;
} else if (dst_key_isprivate(
- zone_keys[j])) {
+ zone_keys[j]))
+ {
have_nonksk = true;
}
both = have_ksk && have_nonksk;
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (dst_key_alg(dstkey) == sig.algorithm &&
- dst_key_rid(dstkey) == sig.keyid) {
+ dst_key_rid(dstkey) == sig.keyid)
+ {
result = dns_dnssec_verify(
keyname, &kfetch->dnskeyset, dstkey, false, 0,
mctx, &sigrr, dns_fixedname_name(&fixed));
RUNTIME_CHECK(tresult == ISC_R_SUCCESS);
if (ds.key_tag != sig.keyid ||
- ds.algorithm != sig.algorithm) {
+ ds.algorithm != sig.algorithm)
+ {
continue;
}
if (!secure) {
if (keydata.removehd != 0 &&
- keydata.removehd <= now) {
+ keydata.removehd <= now)
+ {
deletekey = true;
}
} else if (keydata.addhd == 0) {
LOCK_ZONE(zone);
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_FLUSH);
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP) &&
- zone->masterfile != NULL) {
+ zone->masterfile != NULL)
+ {
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDCOMPACT);
result = ISC_R_ALREADYRUNNING;
dumping = was_dumping(zone);
* Do we have a place to dump to and are we loaded?
*/
if (zone->masterfile == NULL ||
- DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) == 0) {
+ DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) == 0)
+ {
return;
}
mresult = dns_db_getsoaserial(zone->secure->db,
NULL, &sserial);
if (mresult == ISC_R_SUCCESS &&
- isc_serial_lt(sserial, serial)) {
+ isc_serial_lt(sserial, serial))
+ {
serial = sserial;
}
}
{
dst = ai->sockaddr;
if (notify_isqueued(notify->zone, notify->flags, NULL, &dst,
- NULL, NULL)) {
+ NULL, NULL))
+ {
continue;
}
if (notify_isself(notify->zone, &dst)) {
}
if (notifytype == dns_notifytype_masteronly &&
- zone->type != dns_zone_primary) {
+ zone->type != dns_zone_primary)
+ {
return;
}
dns_view_t *view = dns_zone_getview(zone);
if ((zone->notifykeynames != NULL) &&
- (zone->notifykeynames[i] != NULL)) {
+ (zone->notifykeynames[i] != NULL))
+ {
dns_name_t *keyname = zone->notifykeynames[i];
(void)dns_view_gettsig(view, keyname, &key);
}
if ((zone->notifytlsnames != NULL) &&
- (zone->notifytlsnames[i] != NULL)) {
+ (zone->notifytlsnames[i] != NULL))
+ {
dns_name_t *tlsname = zone->notifytlsnames[i];
(void)dns_view_gettransport(view, DNS_TRANSPORT_TLS,
tlsname, &transport);
goto same_primary;
}
if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOEDNS) &&
- msg->rcode == dns_rcode_badvers) {
+ msg->rcode == dns_rcode_badvers)
+ {
dns_zone_log(zone, ISC_LOG_DEBUG(1),
"refresh: rcode (%.*s) retrying without "
"EDNS EXPIRE OPTION primary %s "
case PF_INET:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
if (isc_sockaddr_equal(&zone->altxfrsource4,
- &zone->xfrsource4)) {
+ &zone->xfrsource4))
+ {
goto skip_primary;
}
zone->sourceaddr = zone->altxfrsource4;
case PF_INET6:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
if (isc_sockaddr_equal(&zone->altxfrsource6,
- &zone->xfrsource6)) {
+ &zone->xfrsource6))
+ {
goto skip_primary;
}
zone->sourceaddr = zone->altxfrsource6;
{
INSIST(!isc_time_isepoch(&zone->dumptime));
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->dumptime, &next) < 0) {
+ isc_time_compare(&zone->dumptime, &next) < 0)
+ {
next = zone->dumptime;
}
}
}
if (!isc_time_isepoch(&zone->resigntime)) {
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->resigntime, &next) < 0) {
+ isc_time_compare(&zone->resigntime, &next) < 0)
+ {
next = zone->resigntime;
}
}
if (!isc_time_isepoch(&zone->keywarntime)) {
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->keywarntime, &next) < 0) {
+ isc_time_compare(&zone->keywarntime, &next) < 0)
+ {
next = zone->keywarntime;
}
}
if (!isc_time_isepoch(&zone->signingtime)) {
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->signingtime, &next) < 0) {
+ isc_time_compare(&zone->signingtime, &next) < 0)
+ {
next = zone->signingtime;
}
}
!isc_time_isepoch(&zone->expiretime))
{
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->expiretime, &next) < 0) {
+ isc_time_compare(&zone->expiretime, &next) < 0)
+ {
next = zone->expiretime;
}
}
{
INSIST(!isc_time_isepoch(&zone->dumptime));
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->dumptime, &next) < 0) {
+ isc_time_compare(&zone->dumptime, &next) < 0)
+ {
next = zone->dumptime;
}
}
{
INSIST(!isc_time_isepoch(&zone->dumptime));
if (isc_time_isepoch(&next) ||
- isc_time_compare(&zone->dumptime, &next) < 0) {
+ isc_time_compare(&zone->dumptime, &next) < 0)
+ {
next = zone->dumptime;
}
}
if (zone->view == NULL) {
isc_buffer_putstr(&buffer, "_none");
} else if (strlen(zone->view->name) <
- isc_buffer_availablelength(&buffer)) {
+ isc_buffer_availablelength(&buffer))
+ {
isc_buffer_putstr(&buffer, zone->view->name);
} else {
isc_buffer_putstr(&buffer, "_toolong");
* Do we have a valid private record?
*/
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
rdata.data[1] = 0;
for (nsec3p = ISC_LIST_HEAD(*nsec3list); nsec3p != NULL;
- nsec3p = next) {
+ nsec3p = next)
+ {
next = ISC_LIST_NEXT(nsec3p, link);
if (nsec3p->length == rdata.length + 1 &&
* Let any other zones waiting for quota have it.
*/
if (zone->zmgr != NULL &&
- zone->statelist == &zone->zmgr->xfrin_in_progress) {
+ zone->statelist == &zone->zmgr->xfrin_in_progress)
+ {
UNLOCK_ZONE(zone);
RWLOCK(&zone->zmgr->rwlock, isc_rwlocktype_write);
ISC_LIST_UNLINK(zone->zmgr->xfrin_in_progress, zone, statelink);
RWLOCK(&mgmt->lock, isc_rwlocktype_write);
size = ISC_HASHSIZE(mgmt->bits);
for (unsigned int i = 0;
- atomic_load_relaxed(&mgmt->count) > 0 && i < size; i++) {
+ atomic_load_relaxed(&mgmt->count) > 0 && i < size; i++)
+ {
for (curr = mgmt->table[i]; curr != NULL; curr = next) {
next = curr->next;
isc_mutex_destroy(&curr->lock);
dns_zone_t *next;
for (zone = ISC_LIST_HEAD(zmgr->waiting_for_xfrin); zone != NULL;
- zone = next) {
+ zone = next)
+ {
isc_result_t result;
next = ISC_LIST_NEXT(zone, statelink);
result = zmgr_start_xfrin_ifquota(zmgr, zone);
for (i = 0; i <= DST_MAX_TIMES; i++) {
result = dst_key_gettime(key, i, &event);
if (result == ISC_R_SUCCESS && event > now &&
- (then == 0 || event < then)) {
+ (then == 0 || event < then))
+ {
then = event;
}
}
tuple = ISC_LIST_NEXT(tuple, link))
{
if (tuple->rdata.type == rrtype &&
- dns_name_equal(&tuple->name, &zone->origin)) {
+ dns_name_equal(&tuple->name, &zone->origin))
+ {
break;
}
}
if (ds_state == DST_KEY_STATE_RUMOURED && published == 0) {
checkdspub = true;
} else if (ds_state == DST_KEY_STATE_UNRETENTIVE &&
- withdrawn == 0) {
+ withdrawn == 0)
+ {
checkdsdel = true;
}
if (!checkdspub && !checkdsdel) {
dns_checkds_t *checkds = NULL;
if ((zone->parentalkeynames != NULL) &&
- (zone->parentalkeynames[i] != NULL)) {
+ (zone->parentalkeynames[i] != NULL))
+ {
dns_name_t *keyname = zone->parentalkeynames[i];
(void)dns_view_gettsig(view, keyname, &key);
}
if ((zone->parentaltlsnames != NULL) &&
- (zone->parentaltlsnames[i] != NULL)) {
+ (zone->parentaltlsnames[i] != NULL))
+ {
dns_name_t *tlsname = zone->parentaltlsnames[i];
(void)dns_view_gettransport(view, DNS_TRANSPORT_TLS,
tlsname, &transport);
dst_key_setnum(key->key, DST_NUM_DSPUBCOUNT, 0);
cdscheck = true;
} else if (ds_state == DST_KEY_STATE_UNRETENTIVE &&
- withdrawn == 0) {
+ withdrawn == 0)
+ {
dst_key_setnum(key->key, DST_NUM_DSDELCOUNT, 0);
cdscheck = true;
}
*/
bool allow = false;
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
dst_key_t *dstk = key->key;
if (dst_key_is_published(dstk, now, &when) &&
* the zone signing can be handled incrementally.)
*/
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (!key->first_sign) {
continue;
}
/* Remove any signatures from removed keys. */
if (!ISC_LIST_EMPTY(rmkeys)) {
for (key = ISC_LIST_HEAD(rmkeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
result = zone_signwithkey(
zone, dst_key_alg(key->key),
dst_key_id(key->key), true);
* with all active keys, whether they're new or not.
*/
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (!key->force_sign && !key->hint_sign) {
continue;
}
* keys.
*/
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
if (!key->first_sign) {
continue;
}
dns_rdata_nsec3param_t nsec3param;
if (tuple->rdata.type != zone->privatetype ||
- tuple->op != DNS_DIFFOP_ADD) {
+ tuple->op != DNS_DIFFOP_ADD)
+ {
continue;
}
if (!dns_nsec3param_fromprivate(&tuple->rdata, &rdata,
- buf, sizeof(buf))) {
+ buf, sizeof(buf)))
+ {
continue;
}
zone->refreshkeytime = timethen;
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
then = now;
result = next_keyevent(key->key, &then);
if (result != ISC_R_SUCCESS) {
DNS_ZONE_TIME_ADD(&timenow, then - now, &timethen);
if (isc_time_compare(&timethen, &zone->refreshkeytime) <
- 0) {
+ 0)
+ {
zone->refreshkeytime = timethen;
}
}
if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
for (key = ISC_LIST_HEAD(dnskeys); key != NULL;
- key = ISC_LIST_NEXT(key, link)) {
+ key = ISC_LIST_NEXT(key, link))
+ {
/* This debug log is used in the kasp system test */
char algbuf[DNS_SECALG_FORMATSIZE];
dns_secalg_format(dst_key_alg(key->key), algbuf,
}
if (!dns_rdataset_isassociated(&cds) &&
- !dns_rdataset_isassociated(&cdnskey)) {
+ !dns_rdataset_isassociated(&cdnskey))
+ {
result = ISC_R_SUCCESS;
goto failure;
}
NULL));
if (structdnskey.algorithm ==
- structcds.algorithm) {
+ structcds.algorithm)
+ {
algorithms[structcds.algorithm] = found;
}
}
NULL));
if (structdnskey.algorithm ==
- structcdnskey.algorithm) {
+ structcdnskey.algorithm)
+ {
algorithms[structcdnskey.algorithm] =
found;
}
{
found = true;
} else if (rdata.data[0] == 0 &&
- (rdata.data[2] & PENDINGFLAGS) != 0) {
+ (rdata.data[2] & PENDINGFLAGS) != 0)
+ {
found = true;
clear_pending = true;
}
} else if (rdata.length == 5 &&
- memcmp(rdata.data, kd->data, 5) == 0) {
+ memcmp(rdata.data, kd->data, 5) == 0)
+ {
found = true;
}
dns_rdataset_current(&prdataset, &rdata);
if (np->length == rdata.length &&
- memcmp(rdata.data, np->data, np->length) == 0) {
+ memcmp(rdata.data, np->data, np->length) == 0)
+ {
exists = true;
break;
}
}
if (lookup->salt != NULL) {
if (memcmp(nsec3param.salt, lookup->salt,
- lookup->salt_length) != 0) {
+ lookup->salt_length) != 0)
+ {
continue;
}
}
iszonekey = false;
}
if (key.protocol != DNS_KEYPROTO_DNSSEC &&
- key.protocol != DNS_KEYPROTO_ANY) {
+ key.protocol != DNS_KEYPROTO_ANY)
+ {
iszonekey = false;
}
result = ISC_R_SUCCESS;
if (memcmp(set_algorithms, vctx->act_algorithms,
- sizeof(set_algorithms)) != 0) {
+ sizeof(set_algorithms)) != 0)
+ {
dns_name_format(name, namebuf, sizeof(namebuf));
dns_rdatatype_format(rdataset->type, typebuf, sizeof(typebuf));
for (size_t i = 0; i < ARRAY_SIZE(set_algorithms); i++) {
if ((vctx->act_algorithms[i] != 0) &&
- (set_algorithms[i] == 0)) {
+ (set_algorithms[i] == 0))
+ {
dns_secalg_format(i, algbuf, sizeof(algbuf));
zoneverify_log_error(vctx,
"No correct %s signature "
nlabels = dns_name_countlabels(name);
if (reln == dns_namereln_commonancestor ||
- reln == dns_namereln_contains) {
+ reln == dns_namereln_contains)
+ {
dns_name_init(&suffix, NULL);
for (i = labels + 1; i < nlabels; i++) {
dns_name_getlabelsequence(name, nlabels - i, i,
&suffix);
if (nsec3paramset != NULL &&
- dns_rdataset_isassociated(nsec3paramset)) {
+ dns_rdataset_isassociated(nsec3paramset))
+ {
result = verifynsec3s(
vctx, &suffix, nsec3paramset,
isdelegation, true, NULL, 0, &tvresult);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (ds.key_tag != dst_key_id(key) ||
- ds.algorithm != dst_key_alg(key)) {
+ ds.algorithm != dst_key_alg(key))
+ {
continue;
}
* the algorithm as bad if this is not met.
*/
if ((vctx->ksk_algorithms[i] != 0) ==
- (vctx->zsk_algorithms[i] != 0)) {
+ (vctx->zsk_algorithms[i] != 0))
+ {
continue;
}
dns_secalg_format(i, algbuf, sizeof(algbuf));
result = dns_dbiterator_current(dbiter, &nextnode,
nextname);
if (result != ISC_R_SUCCESS &&
- result != DNS_R_NEWORIGIN) {
+ result != DNS_R_NEWORIGIN)
+ {
zoneverify_log_error(vctx,
"dns_dbiterator_current():"
" %s",
if (frozen) {
result = dns_zone_loadandthaw(zone);
if (result == DNS_R_CONTINUE ||
- result == DNS_R_UPTODATE) {
+ result == DNS_R_UPTODATE)
+ {
result = ISC_R_SUCCESS;
}
}
tresult = result;
goto cleanup; /* don't break */
} else if (result != ISC_R_SUCCESS &&
- tresult == ISC_R_SUCCESS) {
+ tresult == ISC_R_SUCCESS)
+ {
tresult = result;
}
}
* Here is the real check for the high bit being set.
*/
if ((times[0].tv_sec &
- (1ULL << (sizeof(times[0].tv_sec) * CHAR_BIT - 1))) != 0) {
+ (1ULL << (sizeof(times[0].tv_sec) * CHAR_BIT - 1))) != 0)
+ {
return (ISC_R_RANGE);
}
}
if (hashmap_match(node, hashval, key, keysize,
- hashmap->case_sensitive)) {
+ hashmap->case_sensitive))
+ {
*pslp = psl;
*idxp = idx;
return (node);
}
if (hashmap_match(current, hashval, key, keysize,
- hashmap->case_sensitive)) {
+ hashmap->case_sensitive))
+ {
return (ISC_R_EXISTS);
}
/* Found rich node */
/* Find the smallest of the (at most) two children. */
j = heap_left(i);
if (j < size &&
- heap->compare(heap->array[j + 1], heap->array[j])) {
+ heap->compare(heap->array[j + 1], heap->array[j]))
+ {
j++;
}
if (heap->compare(elt, heap->array[j])) {
isc_ht_t *ht = it->ht;
while (it->i < ht->size[it->hindex] &&
- ht->table[it->hindex][it->i] == NULL) {
+ ht->table[it->hindex][it->i] == NULL)
+ {
it->i++;
}
if (isc_buffer_remaininglength(source->pushback) == 0 && source->at_eof)
{
if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 &&
- lex->paren_count != 0) {
+ lex->paren_count != 0)
+ {
lex->paren_count = 0;
return (ISC_R_UNBALANCED);
}
no_comments = true;
continue;
} else if (c == '#' && ((lex->comments &
- ISC_LEXCOMMENT_SHELL) != 0)) {
+ ISC_LEXCOMMENT_SHELL) != 0))
+ {
saved_state = state;
state = lexstate_eatline;
no_comments = true;
if (c == EOF) {
lex->last_was_eol = false;
if ((options & ISC_LEXOPT_DNSMULTILINE) != 0 &&
- lex->paren_count != 0) {
+ lex->paren_count != 0)
+ {
lex->paren_count = 0;
result = ISC_R_UNBALANCED;
goto done;
}
if ((options & ISC_LEXOPT_BTEXT) != 0 &&
- lex->brace_count != 0) {
+ lex->brace_count != 0)
+ {
lex->brace_count = 0;
result = ISC_R_UNBALANCED;
goto done;
done = true;
} else if (c == ' ' || c == '\t') {
if (lex->last_was_eol &&
- (options & ISC_LEXOPT_INITIALWS) != 0) {
+ (options & ISC_LEXOPT_INITIALWS) != 0)
+ {
lex->last_was_eol = false;
tokenp->type = isc_tokentype_initialws;
tokenp->value.as_char = c;
state = lexstate_crlf;
}
} else if (c == '"' &&
- (options & ISC_LEXOPT_QSTRING) != 0) {
+ (options & ISC_LEXOPT_QSTRING) != 0)
+ {
lex->last_was_eol = false;
no_comments = true;
state = lexstate_qstring;
} else if (lex->specials[c]) {
lex->last_was_eol = false;
if ((c == '(' || c == ')') &&
- (options & ISC_LEXOPT_DNSMULTILINE) != 0) {
+ (options & ISC_LEXOPT_DNSMULTILINE) != 0)
+ {
if (c == '(') {
if (lex->paren_count == 0) {
options &= ~IWSEOL;
}
continue;
} else if (c == '{' &&
- (options & ISC_LEXOPT_BTEXT) != 0) {
+ (options & ISC_LEXOPT_BTEXT) != 0)
+ {
if (lex->brace_count != 0) {
result = ISC_R_UNBALANCED;
goto done;
tokenp->value.as_char = c;
done = true;
} else if (isdigit((unsigned char)c) &&
- (options & ISC_LEXOPT_NUMBER) != 0) {
+ (options & ISC_LEXOPT_NUMBER) != 0)
+ {
lex->last_was_eol = false;
if ((options & ISC_LEXOPT_OCTAL) != 0 &&
- (c == '8' || c == '9')) {
+ (c == '8' || c == '9'))
+ {
state = lexstate_string;
} else {
state = lexstate_number;
if ((options & ISC_LEXOPT_OCTAL) != 0) {
base = 8;
} else if ((options &
- ISC_LEXOPT_CNUMBER) != 0) {
+ ISC_LEXOPT_CNUMBER) != 0)
+ {
base = 0;
} else {
base = 10;
state = lexstate_string;
}
} else if ((options & ISC_LEXOPT_OCTAL) != 0 &&
- (c == '8' || c == '9')) {
+ (c == '8' || c == '9'))
+ {
state = lexstate_string;
}
if (remaining == 0U) {
break;
case lexstate_string:
if (!escaped && c == '=' &&
- (options & ISC_LEXOPT_VPAIR) != 0) {
+ (options & ISC_LEXOPT_VPAIR) != 0)
+ {
if (remaining == 0U) {
result = grow_data(lex, &remaining,
&curr, &prev);
case lexstate_vpairstart:
if (state == lexstate_vpairstart) {
if (c == '"' &&
- (options & ISC_LEXOPT_QVPAIR) != 0) {
+ (options & ISC_LEXOPT_QVPAIR) != 0)
+ {
no_comments = true;
state = lexstate_qvpair;
break;
} else {
if (c == '\n' && !escaped &&
(options & ISC_LEXOPT_QSTRINGMULTILINE) ==
- 0) {
+ 0)
+ {
pushback(source, c);
result = ISC_R_UNBALANCEDQUOTES;
goto done;
return (ISC_R_SUCCESS);
}
if (token->type == isc_tokentype_vpair &&
- expect == isc_tokentype_qvpair) {
+ expect == isc_tokentype_qvpair)
+ {
return (ISC_R_SUCCESS);
}
if (token->type != expect) {
isc_lex_ungettoken(lex, token);
if (token->type == isc_tokentype_eol ||
- token->type == isc_tokentype_eof) {
+ token->type == isc_tokentype_eof)
+ {
return (ISC_R_UNEXPECTEDEND);
}
if (expect == isc_tokentype_number) {
if (token->type != isc_tokentype_number) {
isc_lex_ungettoken(lex, token);
if (token->type == isc_tokentype_eol ||
- token->type == isc_tokentype_eof) {
+ token->type == isc_tokentype_eof)
+ {
return (ISC_R_UNEXPECTEDEND);
}
return (ISC_R_BADNUMBER);
channel != NULL; channel = ISC_LIST_NEXT(channel, link))
{
if (channel->type == ISC_LOG_TOFILE &&
- FILE_STREAM(channel) != NULL) {
+ FILE_STREAM(channel) != NULL)
+ {
(void)fclose(FILE_STREAM(channel));
FILE_STREAM(channel) = NULL;
}
if (*digit_end == '\0' && version >= versions) {
result = isc_file_remove(dir.entry.name);
if (result != ISC_R_SUCCESS &&
- result != ISC_R_FILENOTFOUND) {
+ result != ISC_R_FILENOTFOUND)
+ {
syslog(LOG_ERR,
"unable to remove "
"log file '%s': %s",
if (*digit_end == '\0' && version < last) {
result = isc_file_remove(dir.entry.name);
if (result != ISC_R_SUCCESS &&
- result != ISC_R_FILENOTFOUND) {
+ result != ISC_R_FILENOTFOUND)
+ {
syslog(LOG_ERR,
"unable to remove "
"log file '%s': %s",
n = snprintf(current, sizeof(current), "%s.%u", path,
(unsigned int)greatest);
if (n >= (int)sizeof(current) || n < 0 ||
- !isc_file_exists(current)) {
+ !isc_file_exists(current))
+ {
break;
}
}
}
if (category_channels->module != NULL &&
- category_channels->module != module) {
+ category_channels->module != module)
+ {
category_channels = ISC_LIST_NEXT(category_channels,
link);
continue;
if (!forcelog) {
dlevel = atomic_load_acquire(&lctx->debug_level);
if (((channel->flags & ISC_LOG_DEBUGONLY) != 0) &&
- dlevel == 0) {
+ dlevel == 0)
+ {
continue;
}
}
if ((channel->flags & ISC_LOG_PRINTTIME) != 0 &&
- local_time[0] == '\0') {
+ local_time[0] == '\0')
+ {
isc_time_t isctime;
TIME_NOW(&isctime);
}
if ((channel->flags & ISC_LOG_PRINTLEVEL) != 0 &&
- level_string[0] == '\0') {
+ level_string[0] == '\0')
+ {
if (level < ISC_LOG_CRITICAL) {
snprintf(level_string, sizeof(level_string),
"level %d: ", level);
while (message != NULL) {
if (isc_time_compare(&message->time,
- &oldest) < 0) {
+ &oldest) < 0)
+ {
/*
* This message is older
* than the
* ...
*/
if (strcmp(lctx->buffer,
- message->text) == 0) {
+ message->text) == 0)
+ {
/*
* ... and it is a
* duplicate. Unlock the
isc_mem_t *ctx;
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
- ctx = ISC_LIST_NEXT(ctx, link)) {
+ ctx = ISC_LIST_NEXT(ctx, link))
+ {
fprintf(file, "context: %p (%s): %" PRIuFAST32 " references\n",
ctx, ctx->name[0] == 0 ? "<unknown>" : ctx->name,
isc_refcount_current(&ctx->references));
LOCK(&contextslock);
lost = totallost;
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
- ctx = ISC_LIST_NEXT(ctx, link)) {
+ ctx = ISC_LIST_NEXT(ctx, link))
+ {
xmlrc = xml_renderctx(ctx, &summary, writer);
if (xmlrc < 0) {
UNLOCK(&contextslock);
LOCK(&contextslock);
lost = totallost;
for (ctx = ISC_LIST_HEAD(contexts); ctx != NULL;
- ctx = ISC_LIST_NEXT(ctx, link)) {
+ ctx = ISC_LIST_NEXT(ctx, link))
+ {
result = json_renderctx(ctx, &summary, ctxarray);
if (result != ISC_R_SUCCESS) {
UNLOCK(&contextslock);
nbytes++;
}
if (nbytes < ipbytes &&
- memcmp(p + nbytes, zeros, ipbytes - nbytes) != 0) {
+ memcmp(p + nbytes, zeros, ipbytes - nbytes) != 0)
+ {
return (ISC_R_FAILURE);
}
return (ISC_R_SUCCESS);
size_t new_bufsize = isc_buffer_usedlength(&h2->rbuf) +
len;
if (new_bufsize <= MAX_DNS_MESSAGE_SIZE &&
- new_bufsize <= h2->content_length) {
+ new_bufsize <= h2->content_length)
+ {
isc_buffer_putmem(&h2->rbuf, data, len);
break;
}
size_t dns_value_len = 0;
if (isc__nm_parse_httpquery((const char *)qstr, &dns_value,
- &dns_value_len)) {
+ &dns_value_len))
+ {
const size_t decoded_size = dns_value_len / 4 * 3;
if (decoded_size <= MAX_DNS_MESSAGE_SIZE) {
if (socket->h2.query_data != NULL) {
isc_nm_cb_t cb = req->cb.send;
void *cbarg = req->cbarg;
if (isc__nmsocket_closing(sock) ||
- !http_session_active(handle->httpsession)) {
+ !http_session_active(handle->httpsession))
+ {
failed_send_cb(sock, req, ISC_R_CANCELED);
return;
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
}
if (sock->type == isc_nm_httplistener ||
- sock->type == isc_nm_httpsocket) {
+ sock->type == isc_nm_httpsocket)
+ {
if (sock->type == isc_nm_httplistener &&
- sock->h2.listener_endpoints != NULL) {
+ sock->h2.listener_endpoints != NULL)
+ {
/* Delete all handlers */
http_cleanup_listener_endpoints(sock);
}
* wrap it between [ and ].
*/
if (inet_pton(AF_INET6, hostname, &sa6) == 1 &&
- hostname[0] != '[') {
+ hostname[0] != '[')
+ {
ipv6_addr = true;
}
host = hostname;
static bool
rule_unreserved_char(isc_httpparser_state_t *st) {
if (MATCH_ALNUM() || MATCH('_') || MATCH('.') || MATCH('-') ||
- MATCH('~')) {
+ MATCH('~'))
+ {
ADVANCE();
return (true);
}
for (size_t i = 0; i < sock->nchildren; i++) {
REQUIRE(!atomic_load(&sock->children[i].destroying));
if (isc_refcount_decrement(
- &sock->children[i].references)) {
+ &sock->children[i].references))
+ {
nmsocket_cleanup(&sock->children[i],
false FLARG_PASS);
}
#if !__SANITIZE_ADDRESS__ && !__SANITIZE_THREAD__
if (!isc__nmsocket_active(sock) ||
- !isc_astack_trypush(sock->inactivereqs, req)) {
+ !isc_astack_trypush(sock->inactivereqs, req))
+ {
isc_mem_put(sock->worker->mctx, req, sizeof(*req));
}
#else /* !__SANITIZE_ADDRESS__ && !__SANITIZE_THREAD__ */
REQUIRE(listener->tid == 0);
if (!atomic_compare_exchange_strong(&listener->closing,
- &(bool){ false }, true)) {
+ &(bool){ false }, true))
+ {
UNREACHABLE();
}
isc__nm_socket_tcp_maxseg(uv_os_sock_t fd, int size) {
#ifdef TCP_MAXSEG
if (setsockopt(fd, IPPROTO_TCP, TCP_MAXSEG, (void *)&size,
- sizeof(size))) {
+ sizeof(size)))
+ {
return (ISC_R_FAILURE);
} else {
return (ISC_R_SUCCESS);
}
#elif defined(IPV6_MTU)
if (setsockopt(fd, IPPROTO_IPV6, IPV6_MTU, &(int){ 1280 },
- sizeof(int)) == -1) {
+ sizeof(int)) == -1)
+ {
return (ISC_R_FAILURE);
}
#else
uv_handle_set_data(handle, NULL);
if (!atomic_compare_exchange_strong(&sock->closed, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(atomic_load(&sock->closing));
if (!atomic_compare_exchange_strong(&sock->closed, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
switch (err) {
case SSL_ERROR_WANT_READ:
if (sock->tls.state == TLS_STATE_NONE &&
- !SSL_is_init_finished(sock->tls.tls)) {
+ !SSL_is_init_finished(sock->tls.tls))
+ {
sock->tls.state = TLS_STATE_HANDSHAKE;
result = isc__nm_process_sock_buffer(sock);
if (result != ISC_R_SUCCESS) {
int r;
if (sock->tls.senddata.base != NULL ||
- sock->tls.senddata.length > 0) {
+ sock->tls.senddata.length > 0)
+ {
break;
}
uv_handle_set_data(handle, NULL);
if (!atomic_compare_exchange_strong(&sock->closed, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(atomic_load(&sock->closing));
if (!atomic_compare_exchange_strong(&sock->closed, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
void
isc__nm_tlsdns_cleanup_data(isc_nmsocket_t *sock) {
if (sock->type == isc_nm_tlsdnslistener ||
- sock->type == isc_nm_tlsdnssocket) {
+ sock->type == isc_nm_tlsdnssocket)
+ {
if (sock->tls.client_sess_cache != NULL) {
INSIST(atomic_load(&sock->client));
INSIST(sock->type == isc_nm_tlsdnssocket);
isc_result_t hs_result = ISC_R_UNSET;
rv = tls_try_handshake(sock, &hs_result);
if (sock->tlsstream.state == TLS_IO &&
- hs_result != ISC_R_SUCCESS) {
+ hs_result != ISC_R_SUCCESS)
+ {
/*
* The accept callback has been called
* unsuccessfully. Let's try to shut
return;
case SSL_ERROR_WANT_READ:
if (tls_try_to_close_unused_socket(sock) ||
- sock->outerhandle == NULL) {
+ sock->outerhandle == NULL)
+ {
return;
}
REQUIRE(sock->type == isc_nm_tlssocket);
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
void
isc__nm_tls_cleanup_data(isc_nmsocket_t *sock) {
if (sock->type == isc_nm_tcplistener &&
- sock->tlsstream.tlslistener != NULL) {
+ sock->tlsstream.tlslistener != NULL)
+ {
isc__nmsocket_detach(&sock->tlsstream.tlslistener);
} else if (sock->type == isc_nm_tlslistener) {
tls_cleanup_listener_tlsctx(sock);
&sock->tlsstream.client_sess_cache);
}
} else if (sock->type == isc_nm_tcpsocket &&
- sock->tlsstream.tlssocket != NULL) {
+ sock->tlsstream.tlssocket != NULL)
+ {
/*
* The TLS socket can't be destroyed until its underlying TCP
* socket is, to avoid possible use-after-free errors.
REQUIRE(atomic_load(&sock->closing));
if (!atomic_compare_exchange_strong(&sock->closed, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(sock->tid == isc_tid());
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
break; \
} else if (unlikely(!IS_PRINTABLE_ASCII(*buf))) { \
if ((unsigned char)*buf < '\040' || \
- *buf == '\177') { \
+ *buf == '\177') \
+ { \
*ret = -1; \
return NULL; \
} \
const char *value;
size_t value_len;
if ((buf = get_token_to_eol(buf, buf_end, &value, &value_len,
- ret)) == NULL) {
+ ret)) == NULL)
+ {
return NULL;
}
/* remove trailing SPs and HTABs */
/* parse request line */
if ((buf = parse_token(buf, buf_end, method, method_len, ' ', ret)) ==
- NULL) {
+ NULL)
+ {
return NULL;
}
do {
return NULL;
}
if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
- NULL) {
+ NULL)
+ {
return NULL;
}
if (*buf == '\015') {
size_t max_headers, int *ret) {
/* parse "HTTP/1.x" */
if ((buf = parse_http_version(buf, buf_end, minor_version, ret)) ==
- NULL) {
+ NULL)
+ {
return NULL;
}
/* skip space */
u_int m = ((~0U) << (8 - (mask % 8)));
if ((mask % 8) == 0 ||
- (((u_char *)addr)[n] & m) == (((u_char *)dest)[n] & m)) {
+ (((u_char *)addr)[n] & m) == (((u_char *)dest)[n] & m))
+ {
return (1);
}
}
/* Merging nodes */
for (i = 0; i < RADIX_FAMILIES; i++) {
if (node->node_num[i] == -1 &&
- source->node_num[i] != -1) {
+ source->node_num[i] != -1)
+ {
node->node_num[i] =
radix->num_added_node +
source->node_num[i];
POST(cntflag);
while (1) {
if ((atomic_load_acquire(&rwl->cnt_and_flag) &
- WRITER_ACTIVE) == 0) {
+ WRITER_ACTIVE) == 0)
+ {
break;
}
LOCK(&rwl->lock);
rwl->readers_waiting++;
if ((atomic_load_acquire(&rwl->cnt_and_flag) &
- WRITER_ACTIVE) != 0) {
+ WRITER_ACTIVE) != 0)
+ {
WAIT(&rwl->readable, &rwl->lock);
}
rwl->readers_waiting--;
/* enter the waiting queue, and wait for our turn */
prev_writer = atomic_fetch_add_release(&rwl->write_requests, 1);
while (atomic_load_acquire(&rwl->write_completions) !=
- prev_writer) {
+ prev_writer)
+ {
LOCK(&rwl->lock);
if (atomic_load_acquire(&rwl->write_completions) !=
- prev_writer) {
+ prev_writer)
+ {
WAIT(&rwl->writeable, &rwl->lock);
UNLOCK(&rwl->lock);
continue;
found_client_sess_cache =
entry->client_sess_cache[tr_offset][ipv6];
if (pfound_client_sess_cache != NULL &&
- found_client_sess_cache != NULL) {
+ found_client_sess_cache != NULL)
+ {
INSIST(*pfound_client_sess_cache == NULL);
*pfound_client_sess_cache = found_client_sess_cache;
}
result = ISC_R_EXISTS;
} else if (result == ISC_R_SUCCESS &&
- entry->ctx[tr_offset][ipv6] == NULL) {
+ entry->ctx[tr_offset][ipv6] == NULL)
+ {
/*
* The hash table entry exists, but is not filled for this
* particular transport/IP type combination.
(void **)&entry);
if (result == ISC_R_SUCCESS && pstore != NULL &&
- entry->ca_store != NULL) {
+ entry->ca_store != NULL)
+ {
*pstore = entry->ca_store;
}
*pctx = entry->ctx[tr_offset][ipv6];
if (pfound_client_sess_cache != NULL &&
- found_client_sess_cache != NULL) {
+ found_client_sess_cache != NULL)
+ {
INSIST(*pfound_client_sess_cache == NULL);
*pfound_client_sess_cache = found_client_sess_cache;
}
} else if (result == ISC_R_SUCCESS &&
- entry->ctx[tr_offset][ipv6] == NULL) {
+ entry->ctx[tr_offset][ipv6] == NULL)
+ {
result = ISC_R_NOTFOUND;
} else {
INSIST(result != ISC_R_SUCCESS);
/* CONNECT requests can only contain "hostname:port" */
if (is_connect &&
- up->field_set != ((1 << ISC_UF_HOST) | (1 << ISC_UF_PORT))) {
+ up->field_set != ((1 << ISC_UF_HOST) | (1 << ISC_UF_PORT)))
+ {
return (ISC_R_FAILURE);
}
continue;
}
if ((i + 1) < len && (buf[i] & 0xe0) == 0xc0 &&
- (buf[i + 1] & 0xc0) == 0x80) {
+ (buf[i + 1] & 0xc0) == 0x80)
+ {
unsigned int w;
w = (buf[i] & 0x1f) << 6;
w |= (buf[++i] & 0x3f);
fprintf(stream, "{\n");
indent += 4;
for (elt = isccc_alist_first(sexpr); elt != NULL;
- elt = CDR(elt)) {
+ elt = CDR(elt))
+ {
kv = CAR(elt);
INSIST(isccc_sexpr_listp(kv));
k = CAR(kv);
unsigned int len;
for (elt = isccc_alist_first(alist); elt != NULL;
- elt = ISCCC_SEXPR_CDR(elt)) {
+ elt = ISCCC_SEXPR_CDR(elt))
+ {
kv = ISCCC_SEXPR_CAR(elt);
k = ISCCC_SEXPR_CAR(kv);
ks = isccc_sexpr_tostring(k);
value = region->rstart;
GET8(valalg, value);
if ((valalg != algorithm) ||
- !isc_safe_memequal(value, digestb64, HSHA_LENGTH)) {
+ !isc_safe_memequal(value, digestb64, HSHA_LENGTH))
+ {
return (ISCCC_R_BADAUTH);
}
}
for (i = 0; i < symtab->size; i++) {
for (elt = ISC_LIST_HEAD(symtab->table[i]); elt != NULL;
- elt = nelt) {
+ elt = nelt)
+ {
nelt = ISC_LIST_NEXT(elt, link);
free_elt(symtab, i, elt);
}
b = hash((k), (s)->case_sensitive) % (s)->size; \
if ((s)->case_sensitive) { \
for (e = ISC_LIST_HEAD((s)->table[b]); e != NULL; \
- e = ISC_LIST_NEXT(e, link)) { \
+ e = ISC_LIST_NEXT(e, link)) \
+ { \
if (((t) == 0 || e->type == (t)) && \
strcmp(e->key, (k)) == 0) \
break; \
} \
} else { \
for (e = ISC_LIST_HEAD((s)->table[b]); e != NULL; \
- e = ISC_LIST_NEXT(e, link)) { \
+ e = ISC_LIST_NEXT(e, link)) \
+ { \
if (((t) == 0 || e->type == (t)) && \
strcasecmp(e->key, (k)) == 0) \
break; \
for (i = 0; i < symtab->size; i++) {
for (elt = ISC_LIST_HEAD(symtab->table[i]); elt != NULL;
- elt = nelt) {
+ elt = nelt)
+ {
nelt = ISC_LIST_NEXT(elt, link);
if ((action)(elt->key, elt->type, elt->value, arg)) {
free_elt(symtab, i, elt);
dns_acl_t *dacl, *next;
isc_refcount_destroy(&actx->references);
for (dacl = ISC_LIST_HEAD(actx->named_acl_cache); dacl != NULL;
- dacl = next) {
+ dacl = next)
+ {
next = ISC_LIST_NEXT(dacl, nextincache);
ISC_LIST_UNLINK(actx->named_acl_cache, dacl,
nextincache);
}
#if defined(HAVE_GEOIP2)
} else if (cfg_obj_istuple(ce) &&
- cfg_obj_isvoid(cfg_tuple_get(ce, "negated"))) {
+ cfg_obj_isvoid(cfg_tuple_get(ce, "negated")))
+ {
n++;
#endif /* HAVE_GEOIP2 */
} else if (cfg_obj_isstring(ce)) {
subtype = dns_geoip_city_metrocode;
de.geoip_elem.as_int = atoi(search);
} else if (strcasecmp(stype, "tz") == 0 ||
- strcasecmp(stype, "timezone") == 0) {
+ strcasecmp(stype, "timezone") == 0)
+ {
subtype = dns_geoip_city_timezonecode;
strlcpy(de.geoip_elem.as_string, search,
sizeof(de.geoip_elem.as_string));
if (obj_transport != NULL && cfg_obj_isstring(obj_transport)) {
if (strcasecmp(cfg_obj_asstring(obj_transport),
- "udp") == 0) {
+ "udp") == 0)
+ {
transports = isc_nm_udpsocket;
encrypted = false;
} else if (strcasecmp(cfg_obj_asstring(obj_transport),
- "tcp") == 0) {
+ "tcp") == 0)
+ {
transports = isc_nm_tcpdnssocket;
encrypted = false;
} else if (strcasecmp(cfg_obj_asstring(obj_transport),
- "udp-tcp") == 0) {
+ "udp-tcp") == 0)
+ {
/* Good ol' DNS over port 53 */
transports = isc_nm_tcpdnssocket |
isc_nm_udpsocket;
encrypted = false;
} else if (strcasecmp(cfg_obj_asstring(obj_transport),
- "tls") == 0) {
+ "tls") == 0)
+ {
transports = isc_nm_tlsdnssocket;
encrypted = true;
} else if (strcasecmp(cfg_obj_asstring(obj_transport),
- "http") == 0) {
+ "http") == 0)
+ {
transports = isc_nm_httpsocket;
encrypted = true;
} else if (strcasecmp(cfg_obj_asstring(obj_transport),
- "http-plain") == 0) {
+ "http-plain") == 0)
+ {
transports = isc_nm_httpsocket;
encrypted = false;
} else {
}
#if defined(HAVE_GEOIP2)
} else if (cfg_obj_istuple(ce) &&
- cfg_obj_isvoid(cfg_tuple_get(ce, "negated"))) {
+ cfg_obj_isvoid(cfg_tuple_get(ce, "negated")))
+ {
INSIST(dacl->length < dacl->alloc);
result = parse_geoip_element(ce, lctx, ctx, de);
if (result != ISC_R_SUCCESS) {
* nonzero (i.e., in sortlists).
*/
if (de->nestedacl != NULL &&
- de->type != dns_aclelementtype_nestedacl) {
+ de->type != dns_aclelementtype_nestedacl)
+ {
dns_acl_detach(&de->nestedacl);
}
continue;
}
if (role[i] !=
- (DNS_KASP_KEY_ROLE_ZSK | DNS_KASP_KEY_ROLE_KSK)) {
+ (DNS_KASP_KEY_ROLE_ZSK | DNS_KASP_KEY_ROLE_KSK))
+ {
cfg_obj_log(keys, logctx, ISC_LOG_ERROR,
"dnssec-policy: algorithm %zu "
"requires both KSK and ZSK roles",
CHECK(parse_port(pctx, &obj->value.tuple[0]));
CHECK(parse_port(pctx, &obj->value.tuple[1]));
if (obj->value.tuple[0]->value.uint32 >
- obj->value.tuple[1]->value.uint32) {
+ obj->value.tuple[1]->value.uint32)
+ {
cfg_parser_error(pctx, CFG_LOG_NOPREP,
"low port '%u' must not be larger "
"than high port",
if (pctx->token.type == isc_tokentype_string) {
CHECK(cfg_gettoken(pctx, 0));
if (strcasecmp(TOKEN_STRING(pctx), "size") == 0 &&
- obj->value.tuple[2] == NULL) {
+ obj->value.tuple[2] == NULL)
+ {
CHECK(cfg_parse_obj(pctx, fields[2].type,
&obj->value.tuple[2]));
} else if (strcasecmp(TOKEN_STRING(pctx), "versions") ==
CHECK(cfg_parse_dscp(pctx, &dscp));
have_dscp++;
} else if (have_port == 0 && have_dscp == 0 &&
- have_address == 0) {
+ have_address == 0)
+ {
return (cfg_parse_sockaddr(pctx, type, ret));
} else {
cfg_parser_error(pctx, CFG_LOG_NEAR,
for (clause = zone_clauses; clause->name != NULL; clause++) {
if ((clause->flags & ztype) == 0 ||
- strcmp(clause->name, name) != 0) {
+ strcmp(clause->name, name) != 0)
+ {
continue;
}
valid = true;
}
for (clause = zone_only_clauses; clause->name != NULL; clause++) {
if ((clause->flags & ztype) == 0 ||
- strcmp(clause->name, name) != 0) {
+ strcmp(clause->name, name) != 0)
+ {
continue;
}
valid = true;
}
if ((clause->flags & zonetype) == 0 ||
- strcasecmp(clause->name, "type") == 0) {
+ strcasecmp(clause->name, "type") == 0)
+ {
continue;
}
cfg_print_indent(&pctx);
* case this function will print "PT0S".
*/
if (duration.parts[6] > 0 ||
- (!D && !duration.parts[4] && !duration.parts[5])) {
+ (!D && !duration.parts[4] && !duration.parts[5]))
+ {
durationlen[6] = 1 + numlen(duration.parts[6]);
T = true;
count += durationlen[6];
}
/* Special case for seconds. */
if (duration.parts[6] > 0 ||
- (!D && !duration.parts[4] && !duration.parts[5])) {
+ (!D && !duration.parts[4] && !duration.parts[5]))
+ {
snprintf(str, durationlen[6] + 2, "%u%c",
(uint32_t)duration.parts[6], indicators[6]);
}
if (pctx->token.type == isc_tokentype_string) {
CHECK(cfg_gettoken(pctx, 0));
if (strcasecmp(TOKEN_STRING(pctx), "db") == 0 &&
- obj->value.tuple[1] == NULL) {
+ obj->value.tuple[1] == NULL)
+ {
CHECK(cfg_parse_obj(pctx, fields[1].type,
&obj->value.tuple[1]));
} else {
const cfg_listelt_t *elt;
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
- elt = ISC_LIST_NEXT(elt, link)) {
+ elt = ISC_LIST_NEXT(elt, link))
+ {
if ((pctx->flags & CFG_PRINTER_ONELINE) != 0) {
cfg_print_obj(pctx, elt->obj);
cfg_print_cstr(pctx, "; ");
list = &obj->value.list;
for (elt = ISC_LIST_HEAD(*list); elt != NULL;
- elt = ISC_LIST_NEXT(elt, link)) {
+ elt = ISC_LIST_NEXT(elt, link))
+ {
cfg_print_obj(pctx, elt->obj);
if (ISC_LIST_NEXT(elt, link) != NULL) {
cfg_print_cstr(pctx, " ");
clause = NULL;
for (clauseset = clausesets; *clauseset != NULL; clauseset++) {
for (clause = *clauseset; clause->name != NULL;
- clause++) {
+ clause++)
+ {
if (strcasecmp(TOKEN_STRING(pctx),
- clause->name) == 0) {
+ clause->name) == 0)
+ {
goto done;
}
}
REQUIRE(obj != NULL);
for (clauseset = obj->value.map.clausesets; *clauseset != NULL;
- clauseset++) {
+ clauseset++)
+ {
isc_symvalue_t symval;
const cfg_clausedef_t *clause;
cfg_listelt_t *elt;
for (elt = ISC_LIST_HEAD(*list);
elt != NULL;
- elt = ISC_LIST_NEXT(elt, link)) {
+ elt = ISC_LIST_NEXT(elt, link))
+ {
print_symval(pctx, clause->name,
elt->obj);
}
int loglevel;
if ((client->manager->sctx->options & NS_SERVER_LOGQUERIES) !=
- 0) {
+ 0)
+ {
loglevel = DNS_RRL_LOG_DROP;
} else {
loglevel = ISC_LOG_DEBUG(1);
* Simulate a STD13 compliant server.
*/
if ((client->manager->sctx->options & NS_SERVER_EDNSFORMERR) !=
- 0) {
+ 0)
+ {
ns_client_error(client, DNS_R_FORMERR);
return;
}
* Are returning NOTIMP to all EDNS queries?
*/
if ((client->manager->sctx->options & NS_SERVER_EDNSNOTIMP) !=
- 0) {
+ 0)
+ {
ns_client_error(client, DNS_R_NOTIMP);
return;
}
* Are returning REFUSED to all EDNS queries?
*/
if ((client->manager->sctx->options & NS_SERVER_EDNSREFUSED) !=
- 0) {
+ 0)
+ {
ns_client_error(client, DNS_R_REFUSED);
return;
}
for (i = 0; i < NS_HOOKPOINTS_COUNT; i++) {
for (hook = ISC_LIST_HEAD((*table)[i]); hook != NULL;
- hook = next) {
+ hook = next)
+ {
next = ISC_LIST_NEXT(hook, link);
ISC_LIST_UNLINK((*table)[i], hook, link);
if (hook->mctx != NULL) {
* state changes.
*/
if (rth->rta_type == IFA_ADDRESS &&
- ifa->ifa_family == AF_INET6) {
+ ifa->ifa_family == AF_INET6)
+ {
bool existed = false;
bool was_listening = false;
isc_netaddr_t addr = { 0 };
return (true);
}
} else if (rth->rta_type == IFA_ADDRESS &&
- ifa->ifa_family == AF_INET) {
+ ifa->ifa_family == AF_INET)
+ {
/*
* It seems that the IPv4 P2P link state
* has changed.
result = ns_interface_listentcp(ifp);
if (result != ISC_R_SUCCESS) {
if ((result == ISC_R_ADDRINUSE) &&
- (addr_in_use != NULL)) {
+ (addr_in_use != NULL))
+ {
*addr_in_use = true;
}
* a temporary media glitch at rescan time.
*/
if (family == AF_INET &&
- isc_netaddr_equal(&interface.address, &zero_address)) {
+ isc_netaddr_equal(&interface.address, &zero_address))
+ {
continue;
}
if (family == AF_INET6 &&
- isc_netaddr_equal(&interface.address, &zero_address6)) {
+ isc_netaddr_equal(&interface.address, &zero_address6))
+ {
continue;
}
ll = (family == AF_INET) ? mgr->listenon4 : mgr->listenon6;
dolistenon = true;
for (le = ISC_LIST_HEAD(ll->elts); le != NULL;
- le = ISC_LIST_NEXT(le, link)) {
+ le = ISC_LIST_NEXT(le, link))
+ {
int match;
bool addr_in_use = false;
bool ipv6_wildcard = false;
* special considerations later, so remember it.
*/
if (family == AF_INET6 && ipv6only && ipv6pktinfo &&
- listenon_is_ip6_any(le)) {
+ listenon_is_ip6_any(le))
+ {
ipv6_wildcard = true;
}
}
if (log_explicit && family == AF_INET6 &&
- listenon_is_ip6_any(le)) {
+ listenon_is_ip6_any(le))
+ {
isc_log_write(IFMGR_COMMON_LOGARGS,
verbose ? ISC_LOG_INFO
: ISC_LOG_DEBUG(1),
if (tls_params->dhparam_file != NULL) {
if (!isc_tlsctx_load_dhparams(
- sslctx, tls_params->dhparam_file)) {
+ sslctx, tls_params->dhparam_file))
+ {
result = ISC_R_FAILURE;
goto tls_error;
}
* and should not be disclosed.
*/
if (dns_zone_gettype(zone) == dns_zone_staticstub &&
- !RECURSIONOK(client)) {
+ !RECURSIONOK(client))
+ {
return (DNS_R_REFUSED);
}
*/
dbversion->acl_checked = true;
if ((client->query.attributes & NS_QUERYATTR_QUERYOK) ==
- 0) {
+ 0)
+ {
dbversion->queryok = false;
return (DNS_R_REFUSED);
}
* logging is disabled for some policy zones.
*/
if (st->popt.no_log == 0 &&
- isc_log_wouldlog(ns_lctx, DNS_RPZ_DEBUG_LEVEL2)) {
+ isc_log_wouldlog(ns_lctx, DNS_RPZ_DEBUG_LEVEL2))
+ {
dns_name_format(client->query.qname, qnamebuf,
sizeof(qnamebuf));
dns_name_format(p_name, p_namebuf, sizeof(p_namebuf));
* Only try if DLZ drivers are loaded for this view
*/
if (zonelabels < namelabels &&
- !ISC_LIST_EMPTY(client->view->dlz_searched)) {
+ !ISC_LIST_EMPTY(client->view->dlz_searched))
+ {
dns_clientinfomethods_t cm;
dns_clientinfo_t ci;
dns_db_t *tdbp;
CTRACE(ISC_LOG_DEBUG(3), "query_isduplicate");
for (section = DNS_SECTION_ANSWER; section <= DNS_SECTION_ADDITIONAL;
- section++) {
+ section++)
+ {
result = dns_message_findname(client->message, section, name,
type, 0, &mname, NULL);
if (result == ISC_R_SUCCESS) {
}
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
client->now, &node, fname, &cm, &ci, rdataset,
sigrdataset);
if (result != ISC_R_SUCCESS && result != DNS_R_ZONECUT &&
- result != DNS_R_GLUE) {
+ result != DNS_R_GLUE)
+ {
goto cleanup;
}
* in the response.
*/
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
ISC_LIST_APPEND(fname->list, sigrdataset, link);
sigrdataset = NULL;
}
} else if (result == DNS_R_NCACHENXRRSET) {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
} else if (result == ISC_R_SUCCESS) {
if (invalid && DNS_TRUST_PENDING(rdataset->trust)) {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
} else if (!query_isduplicate(client, fname,
ISC_LIST_APPEND(fname->list, rdataset, link);
added_something = true;
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
ISC_LIST_APPEND(fname->list,
sigrdataset, link);
sigrdataset =
} else {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
}
} else if (result == DNS_R_NCACHENXRRSET) {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
} else if (result == ISC_R_SUCCESS) {
if (invalid && DNS_TRUST_PENDING(rdataset->trust)) {
dns_rdataset_disassociate(rdataset);
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
dns_rdataset_disassociate(sigrdataset);
}
} else if (!query_isduplicate(client, fname,
dns_rdatatype_aaaa,
- &mname)) {
+ &mname))
+ {
if (mname != fname) {
if (mname != NULL) {
ns_client_releasename(client,
ISC_LIST_APPEND(fname->list, rdataset, link);
added_something = true;
if (sigrdataset != NULL &&
- dns_rdataset_isassociated(sigrdataset)) {
+ dns_rdataset_isassociated(sigrdataset))
+ {
ISC_LIST_APPEND(fname->list,
sigrdataset, link);
sigrdataset = NULL;
return (DNS_R_SERVFAIL);
}
if (qtype == dns_rdatatype_aaaa &&
- !ISC_LIST_EMPTY(client->view->dns64)) {
+ !ISC_LIST_EMPTY(client->view->dns64))
+ {
for (result = dns_rdatasetiter_first(rdsiter);
result == ISC_R_SUCCESS;
result = dns_rdatasetiter_next(rdsiter))
{
dns_rdatasetiter_current(rdsiter, *rdatasetp);
if ((*rdatasetp)->type == dns_rdatatype_cname ||
- (*rdatasetp)->type == qtype) {
+ (*rdatasetp)->type == qtype)
+ {
break;
}
dns_rdataset_disassociate(*rdatasetp);
dns_db_detachnode(*dbp, nodep);
if (qtype == dns_rdatatype_rrsig ||
- qtype == dns_rdatatype_sig) {
+ qtype == dns_rdatatype_sig)
+ {
result = DNS_R_NXRRSET;
} else {
result = dns_db_findext(*dbp, p_name, *versionp,
if (result == ISC_R_SUCCESS) {
if (searchtype == dns_rdatatype_cname &&
- qtype != dns_rdatatype_cname) {
+ qtype != dns_rdatatype_cname)
+ {
result = DNS_R_CNAME;
}
} else if (result == DNS_R_NXRRSET) {
return (ISC_R_SUCCESS);
default:
if (client->query.rpz_st->m.policy !=
- DNS_RPZ_POLICY_ERROR) {
+ DNS_RPZ_POLICY_ERROR)
+ {
client->query.rpz_st->m.policy =
DNS_RPZ_POLICY_ERROR;
rpz_log_fail(client, DNS_RPZ_ERROR_LEVEL, name,
DNS_RPZ_TYPE_NSDNAME, str, result);
}
if (st->r.ns_rdataset != NULL &&
- dns_rdataset_isassociated(st->r.ns_rdataset)) {
+ dns_rdataset_isassociated(st->r.ns_rdataset))
+ {
dns_rdataset_disassociate(st->r.ns_rdataset);
}
dns_rpz_zbits_t allowed;
if (!st->popt.dnsrps_enabled &&
- qresult_type == qresult_type_recurse) {
+ qresult_type == qresult_type_recurse)
+ {
/*
* This request needs recursion that has not been done.
* Get bits for the policy zones that do not need
nsname);
}
if (st->r.ns_rdataset == NULL ||
- !dns_rdataset_isassociated(st->r.ns_rdataset)) {
+ !dns_rdataset_isassociated(st->r.ns_rdataset))
+ {
dns_db_t *db = NULL;
result = rpz_rrset_find(client, nsname,
dns_rdatatype_ns, options,
st->m.policy == DNS_RPZ_POLICY_ERROR)
{
if (st->m.policy == DNS_RPZ_POLICY_PASSTHRU &&
- result != DNS_R_DELEGATION) {
+ result != DNS_R_DELEGATION)
+ {
rpz_log_rewrite(client, false, st->m.policy, st->m.type,
st->m.zone, st->p_name, NULL,
st->m.rpz->num);
dns_rdata_reset(&rdata);
optout = ((nsec3.flags & DNS_NSEC3FLAG_OPTOUT) != 0);
if (found != NULL && optout &&
- dns_name_issubdomain(&name, dns_db_origin(db))) {
+ dns_name_issubdomain(&name, dns_db_origin(db)))
+ {
dns_rdataset_disassociate(rdataset);
if (dns_rdataset_isassociated(sigrdataset)) {
dns_rdataset_disassociate(sigrdataset);
dns_rdataset_disassociate(qctx->rdataset);
}
if (qctx->sigrdataset != NULL &&
- dns_rdataset_isassociated(qctx->sigrdataset)) {
+ dns_rdataset_isassociated(qctx->sigrdataset))
+ {
dns_rdataset_disassociate(qctx->sigrdataset);
}
if (qctx->db != NULL && qctx->node != NULL) {
* If it's a SIG query, we'll iterate the node.
*/
if (qctx.qtype == dns_rdatatype_rrsig ||
- qctx.qtype == dns_rdatatype_sig) {
+ qctx.qtype == dns_rdatatype_sig)
+ {
qctx.type = dns_rdatatype_any;
}
(void)dns_db_getservestalerefresh(qctx->client->view->cachedb,
&stale_refresh);
if (stale_refresh > 0 &&
- dns_view_staleanswerenabled(qctx->client->view)) {
+ dns_view_staleanswerenabled(qctx->client->view))
+ {
dboptions |= DNS_DBFIND_STALEENABLED;
}
if (qctx->dns64 && qctx->rpz) {
dns_name_copy(qctx->client->query.qname, qctx->fname);
if (qctx->sigrdataset != NULL &&
- dns_rdataset_isassociated(qctx->sigrdataset)) {
+ dns_rdataset_isassociated(qctx->sigrdataset))
+ {
dns_rdataset_disassociate(qctx->sigrdataset);
}
}
{
stale_found = true;
if (result == DNS_R_NCACHENXDOMAIN ||
- result == DNS_R_NXDOMAIN) {
+ result == DNS_R_NXDOMAIN)
+ {
ede = DNS_EDE_STALENXANSWER;
} else {
ede = DNS_EDE_STALEANSWER;
qctx->rpz_st = qctx->client->query.rpz_st;
if (qctx->rpz_st != NULL &&
- (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0) {
+ (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0)
+ {
CCTRACE(ISC_LOG_DEBUG(3), "resume from RPZ recursion");
#ifdef WANT_QUERYTRACE
{
INSIST(qctx->rdataset != NULL);
if (qctx->qtype == dns_rdatatype_rrsig ||
- qctx->qtype == dns_rdatatype_sig) {
+ qctx->qtype == dns_rdatatype_sig)
+ {
qctx->type = dns_rdatatype_any;
} else {
qctx->type = qctx->qtype;
}
if (qctx->rpz_st != NULL &&
- (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0) {
+ (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0)
+ {
/*
* Has response policy changed out from under us?
*/
qctx->fname = ns_client_newname(qctx->client, qctx->dbuf, &b);
if (qctx->rpz_st != NULL &&
- (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0) {
+ (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0)
+ {
tname = qctx->rpz_st->fname;
} else if (REDIRECT(qctx->client)) {
tname = qctx->client->query.redirect.fname;
dns_name_copy(tname, qctx->fname);
if (qctx->rpz_st != NULL &&
- (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0) {
+ (qctx->rpz_st->state & DNS_RPZ_RECURSING) != 0)
+ {
qctx->rpz_st->r.r_result = qctx->event->result;
result = qctx->rpz_st->q.result;
free_devent(qctx->client, ISC_EVENT_PTR(&qctx->event),
qctx->client->message->flags |=
DNS_MESSAGEFLAG_TC;
if (resp_result ==
- DNS_R_NXDOMAIN) {
+ DNS_R_NXDOMAIN)
+ {
qctx->client->message
->rcode =
dns_rcode_nxdomain;
case DNS_RPZ_POLICY_TCP_ONLY:
qctx->client->message->flags |= DNS_MESSAGEFLAG_TC;
if (result == DNS_R_NXDOMAIN ||
- result == DNS_R_NCACHENXDOMAIN) {
+ result == DNS_R_NCACHENXDOMAIN)
+ {
qctx->client->message->rcode =
dns_rcode_nxdomain;
}
case DNS_RPZ_POLICY_RECORD:
result = qctx->rpz_st->m.result;
if (qctx->qtype == dns_rdatatype_any &&
- result != DNS_R_CNAME) {
+ result != DNS_R_CNAME)
+ {
/*
* We will add all of the rdatasets of
* the node by iterating later,
}
if (qctx->rpz_st->m.rpz->ede != 0 &&
- qctx->rpz_st->m.rpz->ede != UINT16_MAX) {
+ qctx->rpz_st->m.rpz->ede != UINT16_MAX)
+ {
ns_client_extendederror(qctx->client,
qctx->rpz_st->m.rpz->ede, NULL);
}
}
if (qctx->qtype == dns_rdatatype_rrsig &&
- dns_db_issecure(qctx->db)) {
+ dns_db_issecure(qctx->db))
+ {
char namebuf[DNS_NAME_FORMATSIZE];
dns_name_format(qctx->client->query.qname, namebuf,
sizeof(namebuf));
* the authority section
*/
if (dns_name_equal(qctx->client->query.qname,
- dns_db_origin(qctx->db))) {
+ dns_db_origin(qctx->db)))
+ {
qctx->answer_has_ns = true;
}
return (ns_query_done(qctx));
}
if (!dns_rdataset_isassociated(qctx->rdataset) &&
- WANTDNSSEC(qctx->client)) {
+ WANTDNSSEC(qctx->client))
+ {
if (!qctx->fname->attributes.wildcard) {
dns_name_t *found;
dns_name_t *qname;
fixrdataset(qctx->client, &qctx->sigrdataset);
if (qctx->fname == NULL ||
qctx->rdataset == NULL ||
- qctx->sigrdataset == NULL) {
+ qctx->sigrdataset == NULL)
+ {
CCTRACE(ISC_LOG_ERROR, "query_sign_"
"nodata: "
"failure "
* Add NSEC record if we found one.
*/
if (WANTDNSSEC(qctx->client) &&
- dns_rdataset_isassociated(qctx->rdataset)) {
+ dns_rdataset_isassociated(qctx->rdataset))
+ {
query_addnxrrsetnsec(qctx);
}
}
if (qctx->sigrdataset == NULL ||
- !dns_rdataset_isassociated(qctx->sigrdataset)) {
+ !dns_rdataset_isassociated(qctx->sigrdataset))
+ {
return;
}
ttl = 0;
}
if (!qctx->nxrewrite ||
- (qctx->rpz_st != NULL && qctx->rpz_st->m.rpz->addsoa)) {
+ (qctx->rpz_st != NULL && qctx->rpz_st->m.rpz->addsoa))
+ {
result = query_addsoa(qctx, ttl, section);
if (result != ISC_R_SUCCESS) {
QUERY_ERROR(qctx, result);
&rdataset, &sigrdataset);
if (rdataset.trust != dns_trust_secure ||
- sigrdataset.trust != dns_trust_secure) {
+ sigrdataset.trust != dns_trust_secure)
+ {
goto cleanup;
}
* CNAME.
*/
if (qctx->qtype != dns_rdatatype_cname &&
- qctx->qtype != dns_rdatatype_any) {
+ qctx->qtype != dns_rdatatype_any)
+ {
/*
* Switch to the new qname and restart.
*/
client->now, &node, fname, NULL, rdataset, sigrdataset);
if (result == ISC_R_SUCCESS) {
if (zfname != NULL &&
- !dns_name_issubdomain(fname, zfname)) {
+ !dns_name_issubdomain(fname, zfname))
+ {
/*
* We found a zonecut in the cache, but our
* zone delegation is better.
(void)query_addns(qctx);
}
} else if (!qctx->answer_has_ns &&
- qctx->qtype != dns_rdatatype_ns) {
+ qctx->qtype != dns_rdatatype_ns)
+ {
if (qctx->fname != NULL) {
ns_client_releasename(qctx->client,
&qctx->fname);
isc_netaddr_fromsockaddr(&netaddr, &client->peeraddr);
switch (ns_sortlist_setup(client->view->sortlist, env, &netaddr,
- &order_arg)) {
+ &order_arg))
+ {
case NS_SORTLISTTYPE_1ELEMENT:
elt = order_arg;
dns_message_setsortorder(client->message,
*/
qctx->rpz_st = qctx->client->query.rpz_st;
if (qctx->rpz_st != NULL &&
- (qctx->rpz_st->state & DNS_RPZ_RECURSING) == 0) {
+ (qctx->rpz_st->state & DNS_RPZ_RECURSING) == 0)
+ {
rpz_match_clear(qctx->rpz_st);
qctx->rpz_st->state &= ~DNS_RPZ_DONE_QNAME;
}
qctx->result == DNS_R_DROP))
{
if (qctx->result == DNS_R_DUPLICATE ||
- qctx->result == DNS_R_DROP) {
+ qctx->result == DNS_R_DROP)
+ {
/*
* This was a duplicate query that we are
* recursing on or the result of rate limiting.
* Maybe turn on minimal responses for ANY queries.
*/
if (qtype == dns_rdatatype_any && client->view->minimal_any &&
- !TCP(client)) {
+ !TCP(client))
+ {
client->query.attributes |= (NS_QUERYATTR_NOAUTHORITY |
NS_QUERYATTR_NOADDITIONAL);
}
* disabled as there will be no pending data.
*/
if ((message->flags & DNS_MESSAGEFLAG_CD) != 0 ||
- qtype == dns_rdatatype_rrsig) {
+ qtype == dns_rdatatype_rrsig)
+ {
client->query.dboptions |= DNS_DBFIND_PENDINGOK;
client->query.fetchoptions |= DNS_FETCHOPT_NOVALIDATE;
} else if (!client->view->enablevalidation) {
cname_compatibility_action(void *data, dns_rdataset_t *rrset) {
UNUSED(data);
if (rrset->type != dns_rdatatype_cname &&
- !dns_rdatatype_atcname(rrset->type)) {
+ !dns_rdatatype_atcname(rrset->type))
+ {
return (ISC_R_EXISTS);
}
return (ISC_R_SUCCESS);
* if we're normally not allowed to.
*/
if (rrset->type == dns_rdatatype_rrsig ||
- rrset->type == dns_rdatatype_nsec) {
+ rrset->type == dns_rdatatype_nsec)
+ {
return (ISC_R_SUCCESS);
}
*typep = type = t->rdata.type;
if (type == dns_rdatatype_rrsig ||
- type == dns_rdatatype_sig) {
+ type == dns_rdatatype_sig)
+ {
covers = dns_rdata_covers(&t->rdata);
} else if (type == dns_rdatatype_any) {
dns_db_detachnode(db, &node);
* they are already sorted.
*/
while (t != NULL && dns_name_equal(&t->name, name) &&
- t->rdata.type == type) {
+ t->rdata.type == type)
+ {
dns_difftuple_t *next = ISC_LIST_NEXT(t, link);
ISC_LIST_UNLINK(temp->tuples, t, link);
ISC_LIST_APPEND(u_rrs.tuples, t, link);
CHECK(rrset_exists(db, newver, &tuple->name, dns_rdatatype_ns,
0, &ns_exists));
if (ns_exists &&
- !dns_name_equal(&tuple->name, dns_db_origin(db))) {
+ !dns_name_equal(&tuple->name, dns_db_origin(db)))
+ {
continue;
}
CHECK(delete_if(true_p, db, newver, &tuple->name,
options = dns_zone_getoptions(zone);
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
- t = ISC_LIST_NEXT(t, link)) {
+ t = ISC_LIST_NEXT(t, link))
+ {
if (t->op != DNS_DIFFOP_ADD ||
- t->rdata.type != dns_rdatatype_mx) {
+ t->rdata.type != dns_rdatatype_mx)
+ {
continue;
}
dns_rdataset_current(&rdataset, &rdata);
if (!dns_nsec3param_fromprivate(&private, &rdata, buf,
- sizeof(buf))) {
+ sizeof(buf)))
+ {
continue;
}
CHECK(dns_rdata_tostruct(&rdata, &nsec3param, NULL));
* delayed changes.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
- tuple = next) {
+ tuple = next)
+ {
if (tuple->op == DNS_DIFFOP_ADD) {
if (!ttl_good) {
/*
* taking into account any TTL change of the NSEC3PARAM RRset.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
- tuple = next) {
+ tuple = next)
+ {
next = ISC_LIST_NEXT(tuple, link);
if ((tuple->rdata.data[1] & ~DNS_NSEC3FLAG_OPTOUT) != 0) {
/*
* deletions.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
- tuple = next) {
+ tuple = next)
+ {
/*
* If we haven't had any adds then the tuple->ttl must be the
* original ttl and should be used for any future changes.
}
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
- tuple = next) {
+ tuple = next)
+ {
INSIST(ttl_good);
next = ISC_LIST_NEXT(tuple, link);
next = ISC_LIST_NEXT(tuple, link);
if (tuple->rdata.type != privatetype ||
- !dns_name_equal(name, &tuple->name)) {
+ !dns_name_equal(name, &tuple->name))
+ {
continue;
}
* Extract TTL changes pairs, we don't need signing records for these.
*/
for (tuple = ISC_LIST_HEAD(temp_diff.tuples); tuple != NULL;
- tuple = next) {
+ tuple = next)
+ {
if (tuple->op == DNS_DIFFOP_ADD) {
/*
* Walk the temp_diff list looking for the
FAIL(DNS_R_REFUSED);
}
if ((options & DNS_ZONEOPT_CHECKSVCB) != 0 &&
- rdata.type == dns_rdatatype_svcb) {
+ rdata.type == dns_rdatatype_svcb)
+ {
result = dns_rdata_checksvcb(name, &rdata);
if (result != ISC_R_SUCCESS) {
const char *reason =
"allowed "
"in secure zones");
} else if (rdata.type == dns_rdatatype_rrsig &&
- !dns_name_equal(name, zonename)) {
+ !dns_name_equal(name, zonename))
+ {
FAILC(DNS_R_REFUSED, "explicit RRSIG updates are "
"currently "
"not supported in secure zones "
"rejected by secure update");
}
} else if (target != NULL &&
- update_class == dns_rdataclass_none) {
+ update_class == dns_rdataclass_none)
+ {
bool flag;
CHECK(rr_exists(db, ver, name, &rdata, &flag));
if (flag &&
* RFC1123 doesn't allow MF and MD in master files.
*/
if (rdata.type == dns_rdatatype_md ||
- rdata.type == dns_rdatatype_mf) {
+ rdata.type == dns_rdatatype_mf)
+ {
char typebuf[DNS_RDATATYPE_FORMATSIZE];
dns_rdatatype_format(rdata.type, typebuf,
}
if (dns_rdatatype_atparent(rdata.type) &&
- dns_name_equal(name, zonename)) {
+ dns_name_equal(name, zonename))
+ {
char typebuf[DNS_RDATATYPE_FORMATSIZE];
dns_rdatatype_format(rdata.type, typebuf,
* with any flags other than OPTOUT.
*/
if ((rdata.data[1] & ~DNS_NSEC3FLAG_OPTOUT) !=
- 0) {
+ 0)
+ {
update_log(client, zone,
LOGLEVEL_PROTOCOL,
"attempt to add NSEC3PARAM "
} else if (update_class == dns_rdataclass_any) {
if (rdata.type == dns_rdatatype_any) {
if (isc_log_wouldlog(ns_lctx,
- LOGLEVEL_PROTOCOL)) {
+ LOGLEVEL_PROTOCOL))
+ {
char namestr[DNS_NAME_FORMATSIZE];
dns_name_format(name, namestr,
sizeof(namestr));
continue;
} else {
if (isc_log_wouldlog(ns_lctx,
- LOGLEVEL_PROTOCOL)) {
+ LOGLEVEL_PROTOCOL))
+ {
char namestr[DNS_NAME_FORMATSIZE];
char typestr[DNS_RDATATYPE_FORMATSIZE];
dns_name_format(name, namestr,
rdl.rdclass = rdata->rdclass;
rdl.ttl = ttl;
if (rdata->type == dns_rdatatype_sig ||
- rdata->type == dns_rdatatype_rrsig) {
+ rdata->type == dns_rdatatype_rrsig)
+ {
rdl.covers = dns_rdata_covers(rdata);
} else {
rdl.covers = dns_rdatatype_none;
msgrdl->rdclass = rdata->rdclass;
msgrdl->ttl = ttl;
if (rdata->type == dns_rdatatype_sig ||
- rdata->type == dns_rdatatype_rrsig) {
+ rdata->type == dns_rdatatype_rrsig)
+ {
msgrdl->covers = dns_rdata_covers(rdata);
} else {
msgrdl->covers = dns_rdatatype_none;
tls_tlsctx_client_cache = isc_tlsctx_cache_new(mctx);
if (isc_tlsctx_createserver(NULL, NULL, &tls_listen_tlsctx) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
return (-1);
}
noanswer = false;
if (isc_tlsctx_createserver(NULL, NULL, &tcp_listen_tlsctx) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
return (-1);
}
if (isc_tlsctx_createclient(&tcp_connect_tlsctx) != ISC_R_SUCCESS) {
uniform_values = (uint16_t *)values;
for (i = 0;
i < (sizeof(values) / (sizeof(*uniform_values)));
- i++) {
+ i++)
+ {
uniform_values[i] =
isc_random_uniform(UINT16_MAX);
}
switch (eresult) {
case ISC_R_SUCCESS:
if (have_expected_cconnects(atomic_fetch_add(&cconnects, 1) +
- 1)) {
+ 1))
+ {
do_cconnects_shutdown(loopmgr);
} else if (do_send) {
isc_job_run(loopmgr, udp__connect, cbarg);
break;
}
if (*rp != ' ' && *rp != '\t' && *rp != '\r' &&
- *rp != '\n') {
+ *rp != '\n')
+ {
*wp++ = *rp;
len++;
}
break;
}
if (*rp != ' ' && *rp != '\t' && *rp != '\r' &&
- *rp != '\n') {
+ *rp != '\n')
+ {
*wp++ = *rp;
len++;
}
* query_error.
*/
if (test->start_result != ISC_R_SUCCESS || !test->quota_ok ||
- test->do_cancel) {
+ test->do_cancel)
+ {
expect_servfail = true;
isc_nmhandle_attach(qctx->client->handle,
&qctx->client->reqhandle);
projects / thirdparty / bind9.git / commitdiff
