*/
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);
}
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;
}
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;
debug("check_if_done()");
debug("list %s", ISC_LIST_EMPTY(lookup_list) ? "empty" : "full");
if (ISC_LIST_EMPTY(lookup_list) && current_lookup == NULL &&
- sendcount == 0) {
+ sendcount == 0)
+ {
INSIST(sockcount == 0);
INSIST(recvcount == 0);
debug("shutting down");
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;
l = query->lookup;
if (l == current_lookup && l->ns_search_only && !l->trace_root &&
- !l->tcp_mode) {
+ !l->tcp_mode)
+ {
debug("sending next, since searching");
next = query->pending_free ? query->saved_next
: ISC_LIST_NEXT(query, link);
isc_event_free(&event);
l = query->lookup;
if ((l->current_query != NULL) &&
- (ISC_LINK_LINKED(l->current_query, link))) {
+ (ISC_LINK_LINKED(l->current_query, link)))
+ {
next = ISC_LIST_NEXT(l->current_query, link);
} else {
next = NULL;
* 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");
return;
}
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);
}
* through to print the message.
*/
if ((ISC_LIST_HEAD(l->q) != query) ||
- (ISC_LIST_NEXT(query, link) != NULL)) {
+ (ISC_LIST_NEXT(query, link) != NULL))
+ {
dighost_comments(l,
"Got %s from %s, trying next "
"server",
}
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(query->lookup) || showsearch) {
dighost_printmessage(query, &b, msg, true);
dighost_received(isc_buffer_usedlength(&b),
query->lookup->pending = false;
}
if (!query->lookup->ns_search_only ||
- query->lookup->trace_root || docancel) {
+ query->lookup->trace_root || docancel)
+ {
dns_message_detach(&msg);
cancel_lookup(l);
}
}
}
for (q = ISC_LIST_HEAD(current_lookup->connecting); q != NULL;
- q = nq) {
+ q = nq)
+ {
nq = ISC_LIST_NEXT(q, clink);
debug("canceling connecting query %p, belonging to %p",
q, current_lookup);
}
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",
* 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));
} else if (strcmp(argv[0], "id") == 0) {
*dbdata = &id_builtin;
} else if (strcmp(argv[0], "empty") == 0 ||
- strcmp(argv[0], "dns64") == 0) {
+ strcmp(argv[0], "dns64") == 0)
+ {
builtin_t *empty;
char *server;
char *contact;
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);
}
}
for (conn = ISC_LIST_HEAD(listener->connections); conn != NULL;
- conn = next) {
+ conn = next)
+ {
next = ISC_LIST_NEXT(conn, link);
maybe_free_connection(conn);
}
if (conn->ccmsg.result != ISC_R_SUCCESS) {
if (conn->ccmsg.result != ISC_R_CANCELED &&
- conn->ccmsg.result != ISC_R_EOF) {
+ conn->ccmsg.result != ISC_R_EOF)
+ {
log_invalid(&conn->ccmsg, conn->ccmsg.result);
}
goto cleanup;
* Expire messages that are too old.
*/
if (isccc_cc_lookupuint32(_ctrl, "_exp", &exp) == ISC_R_SUCCESS &&
- now > exp) {
+ now > exp)
+ {
log_invalid(&conn->ccmsg, ISCCC_R_EXPIRED);
goto cleanup_request;
}
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) {
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;
}
}
}
for (unsigned char *s = isc_buffer_used(&sb); s != isc_buffer_used(b);
- s++) {
+ s++)
+ {
*s = toupper(*s);
}
}
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->resolver, 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)
nameb);
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 (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;
}
result = dns_fwdtable_find(view->fwdtable, name, NULL,
&dnsforwarders);
if (result == ISC_R_SUCCESS &&
- dnsforwarders->fwdpolicy == dns_fwdpolicy_only) {
+ dnsforwarders->fwdpolicy == dns_fwdpolicy_only)
+ {
continue;
}
}
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_nm,
cfg_obj_asboolean(obj));
} else if (loadbalancesockets !=
- isc_nm_getloadbalancesockets(named_g_nm)) {
+ isc_nm_getloadbalancesockets(named_g_nm))
+ {
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;
}
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));
(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);
if (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);
}
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))
+ {
TRY0(xmlTextWriterStartElement(writer, ISC_XMLCHAR "view"));
TRY0(xmlTextWriterWriteAttribute(writer, ISC_XMLCHAR "name",
ISC_XMLCHAR view->name));
}
if (json_object_get_object(refresh_counters)->count !=
- 0) {
+ 0)
+ {
json_object_object_add(zoneobj,
"dnssec-refresh",
refresh_counters);
line = strtok_r(NULL, "\n", &saveptr))
{
if (strncasecmp(line, if_modified_since,
- strlen(if_modified_since)) == 0) {
+ strlen(if_modified_since)) == 0)
+ {
time_t t1, t2;
line += strlen(if_modified_since);
result = isc_time_parsehttptimestamp(line,
*/
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;
}
* 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) {
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, "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 (strncasecmp(name, "rsa", 3) == 0 ||
- strncasecmp(name, "nsec3rsa", 8) == 0) {
+ strncasecmp(name, "nsec3rsa", 8) == 0)
+ {
return (key_rsa);
} else if (strncasecmp(name, "ecc", 3) == 0 ||
strncasecmp(name, "ecdsa", 5) == 0)
{
return (key_ecc);
} else if (strncasecmp(name, "ecx", 3) == 0 ||
- strncasecmp(name, "ed", 2) == 0) {
+ strncasecmp(name, "ed", 2) == 0)
+ {
return (key_ecx);
} else {
return (key_unknown);
}
if (section == DNS_SECTION_ANSWER ||
- section == DNS_SECTION_AUTHORITY) {
+ section == DNS_SECTION_AUTHORITY)
+ {
message->flags &= ~DNS_MESSAGEFLAG_AD;
}
}
isc_event_free(&event);
isccc_sexpr_free(&response);
if (atomic_load_acquire(&sends) == 0 &&
- atomic_load_acquire(&recvs) == 0) {
+ atomic_load_acquire(&recvs) == 0)
+ {
isc_socket_detach(&sock);
isc_task_detach(&task);
isc_app_shutdown();
isc_sockaddr_format(&serveraddrs[currentaddr], socktext,
sizeof(socktext));
if (sevent->result != ISC_R_CANCELED &&
- ++currentaddr < nserveraddrs) {
+ ++currentaddr < nserveraddrs)
+ {
notify("connection failed: %s: %s", socktext,
isc_result_totext(sevent->result));
isc_socket_detach(&sock);
(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;
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))
+ {
key = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(key)),
- keyname) == 0) {
+ keyname) == 0)
+ {
break;
}
}
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;
}
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], "seconary") == 0) {
+ strcmp(argv[1], "seconary") == 0)
+ {
zonetype = CFG_ZONE_SECONDARY;
} else if (strcmp(argv[1], "mirror") == 0) {
zonetype = CFG_ZONE_MIRROR;
printf("address = %s\n", argv[isc_commandline_index]);
na.family = AF_INET;
if (inet_pton(AF_INET, argv[isc_commandline_index],
- (char *)&na.type.in) != 1) {
+ (char *)&na.type.in) != 1)
+ {
na.family = AF_INET6;
if (inet_pton(AF_INET6, argv[isc_commandline_index],
- (char *)&na.type.in6) != 1) {
+ (char *)&na.type.in6) != 1)
+ {
printf("unknown address format\n");
exit(1);
}
}
for (dbi = ISC_LIST_HEAD(dbs); dbi != NULL;
- dbi = ISC_LIST_NEXT(dbi, link)) {
+ dbi = ISC_LIST_NEXT(dbi, link))
+ {
if (dns_name_compare(dns_db_origin(dbi->db), origin) == 0) {
break;
}
snprintf(dbtype, sizeof(dbtype), "rbt");
while ((ch = isc_commandline_parse(argc, argv, "c:d:t:z:P:Q:glpqvT")) !=
- -1) {
+ -1)
+ {
switch (ch) {
case 'c':
result = load(isc_commandline_argument, ".", true);
result = dns_dbtable_find(dbtable, &name, zcoptions,
&db);
if (result != ISC_R_SUCCESS &&
- result != DNS_R_PARTIALMATCH) {
+ result != DNS_R_PARTIALMATCH)
+ {
if (!quiet) {
printf("\n");
print_result("", result);
name = dns_fixedname_name(&wname2);
if (result == ISC_R_SUCCESS) {
if (check_absolute &&
- dns_name_countlabels(name) > 0) {
+ dns_name_countlabels(name) > 0)
+ {
if (dns_name_isabsolute(name)) {
printf("absolute\n");
} else {
}
}
if (check_wildcard &&
- dns_name_countlabels(name) > 0) {
+ dns_name_countlabels(name) > 0)
+ {
if (dns_name_iswildcard(name)) {
printf("wildcard\n");
} else {
break;
}
if (namereln != dns_namereln_none &&
- namereln != dns_namereln_equal) {
+ namereln != dns_namereln_equal)
+ {
printf(", nlabels = %u", nlabels);
}
printf("\n");
}
if (result == ISC_R_SUCCESS ||
- result == DNS_R_NEWORIGIN) {
+ result == DNS_R_NEWORIGIN)
+ {
print_name(&foundname);
printf("\n");
} else {
memset(&addr, 0, sizeof(addr));
addr.type.sin.sin_family = AF_INET;
if (inet_pton(AF_INET, isc_commandline_argument,
- &addr.type.sin.sin_addr) != 1) {
+ &addr.type.sin.sin_addr) != 1)
+ {
fprintf(stderr, "bad master address '%s'\n",
isc_commandline_argument);
exit(1);
}
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));
isc_sockaddr_t *addr4 = NULL, *addr6 = NULL;
while ((ch = isc_commandline_parse(argc, argv, "a:b:es:t:k:K:p:S:")) !=
- -1) {
+ -1)
+ {
switch (ch) {
case 't':
tr.base = isc_commandline_argument;
break;
case 'b':
if (inet_pton(AF_INET, isc_commandline_argument,
- &in4) == 1) {
+ &in4) == 1)
+ {
if (addr4 != NULL) {
fprintf(stderr, "only one local "
"address per family "
isc_sockaddr_fromin(&a4, &in4, 0);
addr4 = &a4;
} else if (inet_pton(AF_INET6, isc_commandline_argument,
- &in6) == 1) {
+ &in6) == 1)
+ {
if (addr6 != NULL) {
fprintf(stderr, "only one local "
"address per family "
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++;
}
if ((data_type != 'u' &&
isc_buffer_usedlength(&buf) > 0) ||
- data_type == 'b') {
+ data_type == 'b')
+ {
/* perform insert operation */
if (data_type == 'd' || data_type == 'D') {
/* add string terminator to buffer */
/* Dump database in "dlzbdb" bulk format */
if (list_everything) {
if (bulk_write('c', db.client, db.cursor, &bdbkey, &bdbdata) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
return;
}
memset(&bdbkey, 0, sizeof(bdbkey));
/* use the ISC commandline parser to get all the program arguments */
while ((ch = isc_commandline_parse(argc, argv,
- "ldesna:f:k:z:h:c:i:")) != -1) {
+ "ldesna:f:k:z:h:c:i:")) != -1)
+ {
switch (ch) {
case 'n':
create_allowed = true;
flags = DB_SET;
while ((bdbres = zone_cursor->c_get(zone_cursor, &key, &data, flags)) ==
- 0) {
+ 0)
+ {
flags = DB_NEXT_DUP;
tmp = realloc(tmp, data.size + 1);
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) >
- NAME_MAX) {
+ NAME_MAX)
+ {
continue;
}
strcat(host, tmpPtr + 1);
tmpPtr[0] = '\0';
}
if ((strlen(host) + strlen(tmpString) +
- 1) <= NAME_MAX) {
+ 1) <= NAME_MAX)
+ {
strcat(host, tmpString);
}
}
*/
while (isc_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)
+ {
strlcpy(host, "*",
sizeof(host));
} else {
*data = isc_mem_allocate(named_g_mctx, size + 1);
if (data != NULL) {
if (sqlOK(SQLGetData(stmnt, field, SQL_C_CHAR, *data,
- size + 1, &size))) {
+ size + 1, &size)))
+ {
return (ISC_R_SUCCESS);
}
isc_mem_free(named_g_mctx, *data);
/* get the data and concat all fields into a large string */
for (i = startField; i <= endField; i++) {
if (sqlOK(SQLGetData(stmnt, i, SQL_C_CHAR, &(data[j]),
- totSize - j, &size))) {
+ totSize - j, &size)))
+ {
if (size > 0) {
j += size;
data[j++] = ' ';
* about it.
*/
if ((result = odbc_getField(stmnt, 1, &data)) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
result = dns_sdlz_putrr(lookup, "a", 86400,
data);
}
/* if we cannot connect the first time, try 3 more times. */
for (j = 0;
PQstatus((PGconn *)dbi->dbconn) != CONNECTION_OK && j < 3;
- j++) {
+ j++)
+ {
PQreset((PGconn *)dbi->dbconn);
}
/* 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++;
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) {
}
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);
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");
/* 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 '.'");
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 slave zone");
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 slave zone");
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 slave zone");
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) {
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;
}
}
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;
}
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;
}
dns_adbnamehook_t *nh;
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(&adb->entrylocks[bucket]);
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) {
* lookups.
*/
if (lookups > 0 && size < addr->entry->udpsize &&
- addr->entry->udpsize < 4096) {
+ addr->entry->udpsize < 4096)
+ {
size = addr->entry->udpsize;
}
UNLOCK(&adb->entrylocks[bucket]);
bool ret;
nextname = ISC_LIST_NEXT(adbname, plink);
if (!NAME_DEAD(adbname) &&
- dns_name_issubdomain(&adbname->name, name)) {
+ dns_name_issubdomain(&adbname->name, name))
+ {
ret = kill_name(&adbname,
DNS_EVENT_ADBCANCELED);
RUNTIME_CHECK(!ret);
bc->table[hash] = bad;
unsigned 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 {
bevent = (dns_byaddrevent_t *)event;
for (name = ISC_LIST_HEAD(bevent->names); name != NULL;
- name = next_name) {
+ name = next_name)
+ {
next_name = ISC_LIST_NEXT(name, link);
ISC_LIST_UNLINK(bevent->names, name, link);
dns_name_free(name, mctx);
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);
}
}
/* 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);
}
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);
catz_opt_cmp(const dns_label_t *option, const char *opt) {
unsigned int l = strlen(opt);
if (option->length - 1 == l &&
- memcmp(opt, option->base + 1, l - 1) == 0) {
+ memcmp(opt, option->base + 1, l - 1) == 0)
+ {
return (true);
} else {
return (false);
REQUIRE(DNS_RDATASET_VALID(value));
if (value->rdclass != dns_rdataclass_in ||
- value->type != dns_rdatatype_txt) {
+ value->type != dns_rdatatype_txt)
+ {
return (ISC_R_FAILURE);
}
*/
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;
}
}
REQUIRE(dns_rdataset_isassociated(value));
if (value->rdclass != dns_rdataclass_in ||
- value->type != dns_rdatatype_apl) {
+ value->type != dns_rdatatype_apl)
+ {
return (ISC_R_FAILURE);
}
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);
}
ch = p[1];
i = tableindex[ch];
if (ISC_LIKELY((cctx->allowed & DNS_COMPRESS_CASESENSITIVE) !=
- 0)) {
+ 0))
+ {
for (node = cctx->table[i]; node != NULL;
- node = node->next) {
+ node = node->next)
+ {
if (ISC_UNLIKELY(node->name.length != length)) {
continue;
}
if (ISC_LIKELY(memcmp(node->name.ndata, p,
- length) == 0)) {
+ length) == 0))
+ {
goto found;
}
}
} else {
for (node = cctx->table[i]; node != NULL;
- node = node->next) {
+ node = node->next)
+ {
unsigned int l, count;
unsigned char c;
unsigned char *label1, *label2;
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->host) &&
- res->port == port) {
+ res->port == port)
+ {
return (res);
}
res = ISC_LIST_NEXT(res, link);
(resp == NULL ? "not found" : "found"));
} else if (resp->id != id ||
- !isc_sockaddr_equal(&ev->address, &resp->host)) {
+ !isc_sockaddr_equal(&ev->address, &resp->host))
+ {
dispatch_log(disp, LVL(90),
"response to an exclusive socket doesn't match");
inc_stats(mgr, dns_resstatscounter_mismatch);
}
if ((disp->attributes & DNS_DISPATCHATTR_EXCLUSIVE) != 0 &&
- dispsock == NULL) {
+ dispsock == NULL)
+ {
return (ISC_R_SUCCESS);
}
return (result);
}
} else if (dup_socket != NULL &&
- (!isc_socket_hasreuseport() || duponly)) {
+ (!isc_socket_hasreuseport() || duponly))
+ {
result = isc_socket_dup(dup_socket, &sock);
if (result != ISC_R_SUCCESS) {
return (result);
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;
int 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 = dns_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 ||
- count != msg->counts[sectionid] - 1) {
+ count != msg->counts[sectionid] - 1)
+ {
DO_ERROR(DNS_R_BADSIG0);
} else {
skip_name_search = true;
}
} 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;
}
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;
* Ordinary 14-bit pointer.
*/
if ((dctx->allowed & DNS_COMPRESS_GLOBAL14) ==
- 0) {
+ 0)
+ {
return (DNS_R_DISALLOWED);
}
new_current = c & 0x3F;
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);
}
}
RUNTIME_CHECK(result == ISC_R_SUCCESS);
if (dnskey.algorithm == DST_ALG_RSAMD5 ||
- dnskey.algorithm == DST_ALG_RSASHA1) {
+ dnskey.algorithm == DST_ALG_RSASHA1)
+ {
break;
}
}
* 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_copynf(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 (generator == 0) {
if (key->key_size == 768 || key->key_size == 1024 ||
- key->key_size == 1536) {
+ key->key_size == 1536)
+ {
BIGNUM *p, *g;
dh = DH_new();
if (key->key_size == 768) {
}
if (!DH_generate_parameters_ex(dh, key->key_size, generator,
- cb)) {
+ cb))
+ {
DH_free(dh);
BN_GENCB_free(cb);
return (dst__openssl_toresult2("DH_generate_parameters_"
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) {
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;
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if ((dctx->key->key_size < 1024) ||
- (dctx->key->key_size > 4096)) {
+ (dctx->key->key_size > 4096))
+ {
return (ISC_R_FAILURE);
}
break;
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;
}
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if ((dctx->key->key_size < 1024) ||
- (dctx->key->key_size > 4096)) {
+ (dctx->key->key_size > 4096))
+ {
return (ISC_R_FAILURE);
}
break;
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if ((dctx->key->key_size < 1024) ||
- (dctx->key->key_size > 4096)) {
+ (dctx->key->key_size > 4096))
+ {
return (ISC_R_FAILURE);
}
break;
ret = pk11_numbits(attr->pValue, attr->ulValueLen,
&bits);
if (ret != ISC_R_SUCCESS ||
- (bits > maxbits && maxbits != 0)) {
+ (bits > maxbits && maxbits != 0))
+ {
DST_RET(DST_R_VERIFYFAILURE);
}
break;
if (pk11_ctx != NULL) {
if (!pk11_ctx->ontoken &&
- (pk11_ctx->object != CK_INVALID_HANDLE)) {
+ (pk11_ctx->object != CK_INVALID_HANDLE))
+ {
(void)pkcs_C_DestroyObject(pk11_ctx->session,
pk11_ctx->object);
}
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if ((dctx->key->key_size < 1024) ||
- (dctx->key->key_size > 4096)) {
+ (dctx->key->key_size > 4096))
+ {
return (ISC_R_FAILURE);
}
break;
case DST_ALG_RSASHA512:
/* From RFC 5702 */
if ((dctx->key->key_size < 1024) ||
- (dctx->key->key_size > 4096)) {
+ (dctx->key->key_size > 4096))
+ {
return (ISC_R_FAILURE);
}
break;
if (!rsa1->ontoken && !rsa2->ontoken) {
return (true);
} else if (rsa1->ontoken || rsa2->ontoken ||
- (rsa1->object != rsa2->object)) {
+ (rsa1->object != rsa2->object))
+ {
return (false);
}
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 && DATA(node) == NULL)) {
+ (result == ISC_R_EXISTS && DATA(node) == NULL))
+ {
DATA(node) = data;
result = ISC_R_SUCCESS;
}
* subdomain.
*/
if (ISC_LIKELY(get_upper_node(hnode) !=
- up_current)) {
+ up_current))
+ {
continue;
}
dns_name_init(&hnode_name, NULL);
NODENAME(hnode, &hnode_name);
if (ISC_LIKELY(dns_name_equal(&hnode_name,
- &hash_name))) {
+ &hash_name)))
+ {
break;
}
}
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) {
/*
/* cppcheck-suppress nullPointerRedundantCheck
* symbolName=sibling */
if (IS_BLACK(LEFT(sibling)) &&
- IS_BLACK(RIGHT(sibling))) {
+ IS_BLACK(RIGHT(sibling)))
+ {
MAKE_RED(sibling);
child = parent;
} else {
/* cppcheck-suppress nullPointerRedundantCheck
* symbolName=sibling */
if (IS_BLACK(LEFT(sibling)) &&
- IS_BLACK(RIGHT(sibling))) {
+ IS_BLACK(RIGHT(sibling)))
+ {
MAKE_RED(sibling);
child = parent;
} else {
* a subtree root and must have the flag set.
*/
if (((!PARENT(node)) || (DOWN(PARENT(node)) == node)) &&
- (!IS_ROOT(node))) {
+ (!IS_ROOT(node)))
+ {
return (false);
}
* for the second level tree.
*/
if (origin != NULL &&
- (chain->level_count > 0 || OFFSETLEN(predecessor) > 1)) {
+ (chain->level_count > 0 || OFFSETLEN(predecessor) > 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;
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_LIST_UNLINK(resigned_list, header, link);
}
for (changed = HEAD(cleanup_list); changed != NULL;
- changed = next_changed) {
+ changed = next_changed)
+ {
nodelock_t *lock;
next_changed = NEXT(changed, link);
{
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_LOCK(lock, isc_rwlocktype_read);
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, isc_rwlocktype_read);
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, isc_rwlocktype_read);
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, &locktype, 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, &locktype, 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;
search->now);
}
if (foundsig != NULL &&
- need_headerupdate(foundsig, search->now)) {
+ need_headerupdate(foundsig, search->now))
+ {
update_header(search->rbtdb, foundsig,
search->now);
}
{
header_next = header->next;
if (check_stale_header(node, header, &locktype, lock,
- search, &header_prev)) {
+ search, &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, &locktype, lock, &search,
- &header_prev)) {
+ &header_prev))
+ {
/* Do nothing. */
} else if (EXISTS(header) && !ANCIENT(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, locktype);
*nodep = node;
node_exit:
if ((update != NULL || updatesig != NULL) &&
- locktype != isc_rwlocktype_write) {
+ locktype != isc_rwlocktype_write)
+ {
NODE_UNLOCK(lock, locktype);
NODE_LOCK(lock, isc_rwlocktype_write);
locktype = isc_rwlocktype_write;
for (header = node->data; header != NULL; header = header_next) {
header_next = header->next;
if (check_stale_header(node, header, &locktype, 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'.
isc_rwlocktype_none, 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 + rbtdb->serve_stale_ttl <=
- 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);
}
RWLOCK(&rbtdb->tree_lock, isc_rwlocktype_read);
topheader_prev = NULL;
for (topheader = rbtnode->data; topheader != NULL;
- topheader = topheader->next) {
+ topheader = topheader->next)
+ {
if (topheader->type == newheader->type) {
break;
}
isc_rwlocktype_write);
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;
header->node_is_relative = 0;
if (RESIGN(header) &&
- (header->resign != 0 || header->resign_lsb != 0)) {
+ (header->resign != 0 || header->resign_lsb != 0))
+ {
int idx = header->node->locknum;
isc_heap_insert(rbtdb->heaps[idx], header);
}
if (header->next != NULL) {
size_t cooked = dns_rbt_serialize_align(size);
if ((uintptr_t)header->next !=
- (p - (unsigned char *)base) + cooked) {
+ (p - (unsigned char *)base) + cooked)
+ {
return (ISC_R_INVALIDFILE);
}
header->next = (rdatasetheader_t *)(p + cooked);
uint32_t newbits = oldbits;
while (newcount >= HASHSIZE(newbits) &&
- newbits <= RBTDB_GLUE_TABLE_MAX_BITS) {
+ newbits <= RBTDB_GLUE_TABLE_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 = hash_32(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));
}
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);
}
}
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;
}
}
#endif /* if DNS_RDATASET_FIXED */
if (length1 != length2 ||
- memcmp(current1, current2, length1) != 0) {
+ memcmp(current1, current2, length1) != 0)
+ {
return (false);
}
req_log(ISC_LOG_DEBUG(3), "dns_request_createvia");
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;
}
FCTXTRACE("cancelqueries");
for (query = ISC_LIST_HEAD(fctx->queries); query != NULL;
- query = next_query) {
+ query = next_query)
+ {
next_query = ISC_LIST_NEXT(query, link);
fctx_cancelquery(&query, NULL, NULL, no_response, age_untried);
}
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
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);
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
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);
REQUIRE(ISC_LIST_EMPTY(fctx->queries));
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;
}
}
attrs |= DNS_DISPATCHATTR_PRIVATE;
attrs |= DNS_DISPATCHATTR_CONNECTED;
if (isc_sockaddr_pf(&query->addrinfo->sockaddr) ==
- AF_INET) {
+ AF_INET)
+ {
attrs |= DNS_DISPATCHATTR_IPV4;
} else {
attrs |= DNS_DISPATCHATTR_IPV6;
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);
}
}
fctx->quotacount++; /* quota exceeded */
} else if ((find->options & DNS_ADBFIND_LAMEPRUNED) !=
- 0) {
+ 0)
+ {
fctx->lamecount++; /* cached lame server */
} else {
fctx->adberr++; /* unreachable server, etc. */
* 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);
}
*/
query = ISC_LIST_HEAD(fctx->queries);
if (query != NULL &&
- isc_time_compare(&tevent->due, &query->start) >= 0) {
+ isc_time_compare(&tevent->due, &query->start) >= 0)
+ {
FCTXTRACE("query timed out; no response");
fctx_cancelquery(&query, NULL, NULL, true, false);
}
* 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);
* 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;
}
result = dns_db_findnode(fctx->cache, name, true,
*/
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;
}
}
}
if (((name->attributes & DNS_NAMEATTR_ANSWER) != 0) &&
- (!need_validation)) {
+ (!need_validation))
+ {
have_answer = true;
event = ISC_LIST_HEAD(fctx->events);
* 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 signatures.
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 the answer we
}
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 found, and is
* Negative results must be indicated in 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->res->buckets[fctx->bucketnum].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);
}
goto cleanup;
}
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);
*/
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);
event = NULL;
if (fctx->state != fetchstate_done) {
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);
event = NULL;
if (fctx->state != fetchstate_done) {
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))
+ {
dns_name_format(ip_name2, ip2_str, sizeof(ip2_str));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RPZ,
DNS_LOGMODULE_RBTDB, log_level,
nodecount = dns_db_nodecount(rpz->updb);
hashsize = 1;
while (nodecount != 0 &&
- hashsize <= (DNS_RPZ_HTSIZE_MAX + DNS_RPZ_HTSIZE_DIV)) {
+ hashsize <= (DNS_RPZ_HTSIZE_MAX + DNS_RPZ_HTSIZE_DIV))
+ {
hashsize++;
nodecount >>= 1;
}
* the last reference.
*/
for (dns_rpz_num_t rpz_num = 0; rpz_num < DNS_RPZ_MAX_ZONES;
- ++rpz_num) {
+ ++rpz_num)
+ {
dns_rpz_zone_t *rpz = rpzs->zones[rpz_num];
rpzs->zones[rpz_num] = NULL;
if (rpz != NULL) {
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;
continue;
}
if (dst_gssapi_identitymatchesrealmkrb5(
- signer, NULL, rule->identity, false)) {
+ signer, NULL, rule->identity, false))
+ {
break;
}
continue;
continue;
}
if (dst_gssapi_identitymatchesrealmms(
- signer, NULL, rule->identity, false)) {
+ signer, NULL, 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;
* 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] == dns_rdatatype_any ||
- rule->types[i] == type) {
+ rule->types[i] == 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 {
break;
}
if (*rp != ' ' && *rp != '\t' && *rp != '\r' &&
- *rp != '\n') {
+ *rp != '\n')
+ {
*wp++ = *rp;
len++;
}
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 "
* 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));
{
result = ISC_RESULTCLASS_DNSRCODE + msg->rcode; /*XXX*/
} 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;
}
xfrin_log(xfr, ISC_LOG_DEBUG(3), "got %s, retrying with AXFR",
}
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;
}
}
rbt)
{
if (zone->masterfile == NULL ||
- !isc_file_exists(zone->masterfile)) {
+ !isc_file_exists(zone->masterfile))
+ {
if (zone->masterfile != NULL) {
dns_zone_logc(zone, DNS_LOGCATEGORY_ZONELOAD,
ISC_LOG_DEBUG(1),
* 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))
+ {
continue;
}
if (notify_isself(notify->zone, &dst)) {
}
if (notifytype == dns_notifytype_masteronly &&
- zone->type != dns_zone_primary) {
+ zone->type != dns_zone_primary)
+ {
return;
}
dns_notify_t *notify = NULL;
if ((zone->notifykeynames != NULL) &&
- (zone->notifykeynames[i] != NULL)) {
+ (zone->notifykeynames[i] != NULL))
+ {
dns_view_t *view = dns_zone_getview(zone);
dns_name_t *keyname = zone->notifykeynames[i];
(void)dns_view_gettsig(view, keyname, &key);
* Find the next failed master.
*/
while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
+ zone->mastersok[zone->curmaster])
+ {
zone->curmaster++;
}
DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_USEALTXFRSRC);
goto same_master;
}
if (revent->result == ISC_R_TIMEDOUT &&
- !dns_request_usedtcp(revent->request)) {
+ !dns_request_usedtcp(revent->request))
+ {
dns_zone_log(zone, ISC_LOG_INFO,
"refresh: retry limit for "
"master %s exceeded (source %s)",
goto same_master;
}
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 master %s (source %s)",
* Find the next failed master.
*/
while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
+ zone->mastersok[zone->curmaster])
+ {
zone->curmaster++;
}
goto requeue;
case PF_INET:
if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEALTXFRSRC)) {
if (isc_sockaddr_equal(&zone->altxfrsource4,
- &zone->xfrsource4)) {
+ &zone->xfrsource4))
+ {
goto skip_master;
}
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_master;
}
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 &&
DNS_ZONE_SETFLAG(zone,
DNS_ZONEFLG_USEALTXFRSRC);
while (zone->curmaster < zone->masterscnt &&
- zone->mastersok[zone->curmaster]) {
+ zone->mastersok[zone->curmaster])
+ {
zone->curmaster++;
}
again = true;
* 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 = 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);
RWLOCK(&zmgr->rwlock, isc_rwlocktype_read);
for (p = ISC_LIST_HEAD(zmgr->zones); p != NULL;
- p = ISC_LIST_NEXT(p, link)) {
+ p = ISC_LIST_NEXT(p, link))
+ {
dns_zone_maintenance(p);
}
RWUNLOCK(&zmgr->rwlock, isc_rwlocktype_read);
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;
}
}
{
uint8_t alg;
if (tuple->rdata.type != dns_rdatatype_dnskey ||
- tuple->op != DNS_DIFFOP_ADD) {
+ tuple->op != DNS_DIFFOP_ADD)
+ {
continue;
}
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);
}
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;
}
}
family = AF_INET;
goto common;
} else if (ntmp[0] != '\0' &&
- inet_pton(AF_INET6, ntmp, abuf) == 1) {
+ inet_pton(AF_INET6, ntmp, abuf) == 1)
+ {
if (family && family != AF_INET6) {
return (EAI_NONAME);
}
* original name and the 'ndots' configuration parameter.
*/
if (dns_name_countlabels(resstate0->qname) >
- irs_resconf_getndots(resconf) + 1) {
+ irs_resconf_getndots(resconf) + 1)
+ {
ISC_LIST_PREPEND(head->resstates, resstate0, link);
} else {
ISC_LIST_APPEND(head->resstates, resstate0, link);
rest = ISC_LIST_NEXT(rest, link))
{
if (rest->trans4 != NULL &&
- rest->trans4->xid != NULL) {
+ rest->trans4->xid != NULL)
+ {
dns_client_cancelresolve(
rest->trans4->xid);
}
if (rest->trans6 != NULL &&
- rest->trans6->xid != NULL) {
+ rest->trans6->xid != NULL)
+ {
dns_client_cancelresolve(
rest->trans6->xid);
}
if (order != NULL) {
last = NULL;
for (tok = strtok_r(order, ":", &last); tok;
- tok = strtok_r(NULL, ":", &last)) {
+ tok = strtok_r(NULL, ":", &last))
+ {
if (strcasecmp(tok, "inet6") == 0) {
if ((found & FOUND_IPV6) == 0) {
*net_order++ = add_ipv6;
}
found |= FOUND_IPV6;
} else if (strcasecmp(tok, "inet") == 0 ||
- strcasecmp(tok, "inet4") == 0) {
+ strcasecmp(tok, "inet4") == 0)
+ {
if ((found & FOUND_IPV4) == 0) {
*net_order++ = add_ipv4;
}
*/
} else if ((flags & NI_NUMERICHOST) != 0) {
if (inet_ntop(afd->a_af, addr, numaddr, sizeof(numaddr)) ==
- NULL) {
+ NULL)
+ {
ERR(EAI_SYSTEM);
}
#if defined(IRS_HAVE_SIN6_SCOPE_ID)
if (afd->a_af == AF_INET6 &&
- ((const struct sockaddr_in6 *)sa)->sin6_scope_id) {
+ ((const struct sockaddr_in6 *)sa)->sin6_scope_id)
+ {
char *p = numaddr + strlen(numaddr);
const char *stringscope = NULL;
#ifdef VENDOR_SPECIFIC
ERR(EAI_NONAME);
}
if (inet_ntop(afd->a_af, addr, numaddr,
- sizeof(numaddr)) == NULL) {
+ sizeof(numaddr)) == NULL)
+ {
ERR(EAI_SYSTEM);
}
if ((strlen(numaddr) + 1) > hostlen) {
}
if (ISC_LIST_EMPTY(conf->searchlist) &&
- strlen(FixedInfo->DomainName) > 0) {
+ strlen(FixedInfo->DomainName) > 0)
+ {
result = add_search(conf, FixedInfo->DomainName);
if (result != ISC_R_SUCCESS) {
goto cleanup;
*/
LOCK(&ctx->lock);
for (event = ISC_LIST_HEAD(ctx->on_run); event != NULL;
- event = next_event) {
+ event = next_event)
+ {
next_event = ISC_LIST_NEXT(event, ev_link);
ISC_LIST_UNLINK(ctx->on_run, event, ev_link);
task = event->ev_sender;
/* 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])) {
node = ht->table[hash & ht->mask];
while (node != NULL) {
if (keysize == node->keysize &&
- memcmp(key, node->key, keysize) == 0) {
+ memcmp(key, node->key, keysize) == 0)
+ {
return (ISC_R_EXISTS);
}
node = node->next;
node = ht->table[hash & ht->mask];
while (node != NULL) {
if (keysize == node->keysize &&
- memcmp(key, node->key, keysize) == 0) {
+ memcmp(key, node->key, keysize) == 0)
+ {
if (valuep != NULL) {
*valuep = node->value;
}
node = ht->table[hash & ht->mask];
while (node != NULL) {
if (keysize == node->keysize &&
- memcmp(key, node->key, keysize) == 0) {
+ memcmp(key, node->key, keysize) == 0)
+ {
if (prev == NULL) {
ht->table[hash & ht->mask] = node->next;
} else {
* HTTP/1.0 or HTTP/1.1 for now.
*/
while (LENGTHOK(s) && BUFLENOK(s) &&
- (*s != '\n' && *s != '\r' && *s != '\0')) {
+ (*s != '\n' && *s != '\r' && *s != '\0'))
+ {
s++;
}
if (!LENGTHOK(s)) {
}
*s = 0;
if ((strncmp(p, "HTTP/1.0", 8) != 0) &&
- (strncmp(p, "HTTP/1.1", 8) != 0)) {
+ (strncmp(p, "HTTP/1.1", 8) != 0))
+ {
return (ISC_R_RANGE);
}
httpd->protocol = p;
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)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 ((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
ADD_TRACE(ctx, si, si[-1].u.size, file, line);
if (ctx->hi_water != 0U && ctx->inuse > ctx->hi_water &&
- !ctx->is_overmem) {
+ !ctx->is_overmem)
+ {
ctx->is_overmem = true;
}
if (ctx->hi_water != 0U && !ctx->hi_called &&
- ctx->inuse > ctx->hi_water) {
+ ctx->inuse > ctx->hi_water)
+ {
ctx->hi_called = true;
call_water = true;
}
INSIST(oldsize >= ALIGNMENT_SIZE);
oldsize -= ALIGNMENT_SIZE;
if (ISC_UNLIKELY((isc_mem_debugging &
- ISC_MEM_DEBUGCTX) != 0)) {
+ ISC_MEM_DEBUGCTX) != 0))
+ {
INSIST(oldsize >= ALIGNMENT_SIZE);
oldsize -= ALIGNMENT_SIZE;
}
* isc_mem_setwater() called with 0 for hi_water and lo_water.
*/
if (ctx->is_overmem &&
- (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U)) {
+ (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U))
+ {
ctx->is_overmem = false;
}
if (ctx->hi_called &&
- (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U)) {
+ (ctx->inuse < ctx->lo_water || ctx->lo_water == 0U))
+ {
ctx->hi_called = false;
if (ctx->water != NULL) {
out:
#if ISC_MEM_TRACKLINES
if (ISC_UNLIKELY(((isc_mem_debugging & TRACE_OR_RECORD) != 0) &&
- item != NULL)) {
+ item != NULL))
+ {
MCTXLOCK(mctx);
ADD_TRACE(mctx, item, mpctx->size, file, line);
MCTXUNLOCK(mctx);
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);
#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->mgr->mctx, req, sizeof(*req));
}
#else /* !__SANITIZE_ADDRESS__ && !__SANITIZE_THREAD__ */
REQUIRE(sock->type == isc_nm_tcplistener);
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(VALID_NMSOCK(sock));
if (!atomic_compare_exchange_strong(&sock->readpaused, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
}
if (!atomic_compare_exchange_strong(&sock->readpaused, &(bool){ true },
- false)) {
+ false))
+ {
return;
}
REQUIRE(atomic_load(&sock->closing));
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(sock->tid == isc_nm_tid());
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
REQUIRE(sock->type == isc_nm_tcpdnslistener);
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
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(sock->tid == isc_nm_tid());
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
REQUIRE(sock->type == isc_nm_udplistener);
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
UNREACHABLE();
}
REQUIRE(atomic_load(&sock->closing));
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(sock->tid == isc_nm_tid());
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
REQUIRE(!isc__nmsocket_active(sock));
if (!atomic_compare_exchange_strong(&sock->closing, &(bool){ false },
- true)) {
+ true))
+ {
return;
}
rv = pkcs_C_GetMechanismInfo(slot, CKM_RSA_PKCS_KEY_PAIR_GEN,
&mechInfo);
if ((rv != CKR_OK) ||
- ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0)) {
+ ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0))
+ {
bad = true;
PK11_TRACEM(CKM_RSA_PKCS_KEY_PAIR_GEN);
}
rv = pkcs_C_GetMechanismInfo(slot, CKM_EC_KEY_PAIR_GEN,
&mechInfo);
if ((rv != CKR_OK) ||
- ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0)) {
+ ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0))
+ {
bad = true;
PK11_TRACEM(CKM_EC_KEY_PAIR_GEN);
}
rv = pkcs_C_GetMechanismInfo(slot, CKM_EC_EDWARDS_KEY_PAIR_GEN,
&mechInfo);
if ((rv != CKR_OK) ||
- ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0)) {
+ ((mechInfo.flags & CKF_GENERATE_KEY_PAIR) == 0))
+ {
bad = true;
PK11_TRACEM(CKM_EC_EDWARDS_KEY_PAIR_GEN);
}
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;
XTRACE("task_shutdown");
if (atomic_compare_exchange_strong(&task->shuttingdown,
- &(bool){ false }, true)) {
+ &(bool){ false }, true))
+ {
XTRACE("shutting down");
if (task->state == task_state_idle) {
INSIST(EMPTY(task->events));
* Note that we post shutdown events LIFO.
*/
for (event = TAIL(task->on_shutdown); event != NULL;
- event = prev) {
+ event = prev)
+ {
prev = PREV(event, ev_link);
DEQUEUE(task->on_shutdown, event, ev_link);
ENQUEUE(task->events, event, ev_link);
*/
XTRACE("empty");
if (isc_refcount_current(&task->references) == 0 &&
- TASK_SHUTTINGDOWN(task)) {
+ TASK_SHUTTINGDOWN(task))
+ {
/*
* The task is done.
*/
#ifdef ISC_TASK_TRACE
int counter = 0;
while (isc_refcount_current(&(*managerp)->references) > 1 &&
- counter++ < 1000) {
+ counter++ < 1000)
+ {
usleep(10 * 1000);
}
INSIST(counter < 1000);
uniform_values = (uint16_t *)values;
for (i = 0;
i < (sizeof(values) / (sizeof(*uniform_values)));
- i++) {
+ i++)
+ {
uniform_values[i] =
isc_random_uniform(UINT16_MAX);
}
int i = 0;
while (!(atomic_load(&c1->done) && atomic_load(&c2->done)) &&
- i++ < 5000) {
+ i++ < 5000)
+ {
waitbody();
}
if (atomic_load(&c1->done) && atomic_load(&c2->done)) {
if (testrange) {
if ((purge_type_first <= event->ev_type) &&
- (event->ev_type <= purge_type_last)) {
+ (event->ev_type <= purge_type_last))
+ {
type_match = true;
}
} else {
*/
if (((sender_cnt % 2) != 0) &&
((type_cnt % 2) != 0) &&
- ((tag_cnt % 2) != 0)) {
+ ((tag_cnt % 2) != 0))
+ {
eventtab[event_cnt]->ev_attributes |=
ISC_EVENTATTR_NOPURGE;
}
LOCK(&timer->lock);
if (!isc_time_isepoch(&timer->idle) &&
- isc_time_compare(now, &timer->idle) >= 0) {
+ isc_time_compare(now, &timer->idle) >= 0)
+ {
idle = true;
}
UNLOCK(&timer->lock);
* 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);
}
socket_log(sock, NULL, TRACE, "processing cmsg %p", cmsgp);
if (cmsgp->cmsg_level == IPPROTO_IPV6 &&
- cmsgp->cmsg_type == IPV6_PKTINFO) {
+ cmsgp->cmsg_type == IPV6_PKTINFO)
+ {
pktinfop = (struct in6_pktinfo *)CMSG_DATA(cmsgp);
memmove(&dev->pktinfo, pktinfop,
sizeof(struct in6_pktinfo));
#ifdef SO_TIMESTAMP
if (cmsgp->cmsg_level == SOL_SOCKET &&
- cmsgp->cmsg_type == SCM_TIMESTAMP) {
+ cmsgp->cmsg_type == SCM_TIMESTAMP)
+ {
struct timeval tv;
timevalp = CMSG_DATA(cmsgp);
memmove(&tv, timevalp, sizeof(tv));
#ifdef IPV6_TCLASS
if (cmsgp->cmsg_level == IPPROTO_IPV6 &&
- cmsgp->cmsg_type == IPV6_TCLASS) {
+ cmsgp->cmsg_type == IPV6_TCLASS)
+ {
dev->dscp = *(int *)CMSG_DATA(cmsgp);
dev->dscp >>= 2;
dev->attributes |= ISC_SOCKEVENTATTR_DSCP;
*(unsigned char *)CMSG_DATA(cmsgp) = dscp;
} else if (sock->pf == AF_INET && sock->dscp != dev->dscp) {
if (setsockopt(sock->fd, IPPROTO_IP, IP_TOS,
- (void *)&dscp, sizeof(int)) < 0) {
+ (void *)&dscp, sizeof(int)) < 0)
+ {
char strbuf[ISC_STRERRORSIZE];
strerror_r(errno, strbuf, sizeof(strbuf));
UNEXPECTED_ERROR(__FILE__, __LINE__,
}
#endif /* if defined(IPPROTO_IPV6) && defined(IPV6_TCLASS) */
if (msg->msg_controllen != 0 &&
- msg->msg_controllen < SENDCMSGBUFLEN) {
+ msg->msg_controllen < SENDCMSGBUFLEN)
+ {
memset(cmsgbuf + msg->msg_controllen, 0,
SENDCMSGBUFLEN - msg->msg_controllen);
}
* 'maxudp' bytes.
*/
if (sock->manager->maxudp != 0 &&
- cc > (int)sock->manager->maxudp) {
+ cc > (int)sock->manager->maxudp)
+ {
return (DOIO_SOFT);
}
}
#ifdef SO_NOSIGPIPE
if (setsockopt(sock->fd, SOL_SOCKET, SO_NOSIGPIPE, (void *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
strerror_r(errno, strbuf, sizeof(strbuf));
UNEXPECTED_ERROR(__FILE__, __LINE__,
"setsockopt(%d, SO_NOSIGPIPE) failed: %s",
(void)close(fd);
goto soft_error;
} else if (NEWCONNSOCK(dev)->peer_address.type.sa.sa_family !=
- sock->pf) {
+ sock->pf)
+ {
UNEXPECTED_ERROR(
__FILE__, __LINE__,
"internal_accept(): "
continue;
}
if ((events[i].events & EPOLLERR) != 0 ||
- (events[i].events & EPOLLHUP) != 0) {
+ (events[i].events & EPOLLHUP) != 0)
+ {
/*
* epoll does not set IN/OUT bits on an erroneous
* condition, so we need to try both anyway. This is a
isc_sockaddr_getport(sockaddr) != (in_port_t)0)
{
if (setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"setsockopt(%d) failed", sock->fd);
}
}
#elif defined(__linux__) && defined(SO_REUSEPORT)
if (setsockopt(sock->fd, SOL_SOCKET, SO_REUSEPORT, (void *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"setsockopt(%d) failed", sock->fd);
}
bzero(&afa, sizeof(afa));
strlcpy(afa.af_name, filter, sizeof(afa.af_name));
if (setsockopt(sock->fd, SOL_SOCKET, SO_ACCEPTFILTER, &afa,
- sizeof(afa)) == -1) {
+ sizeof(afa)) == -1)
+ {
strerror_r(errno, strbuf, sizeof(strbuf));
socket_log(sock, NULL, CREATION,
"setsockopt(SO_ACCEPTFILTER): %s", strbuf);
* o Reset any state needed.
*/
if (((how & ISC_SOCKCANCEL_RECV) != 0) &&
- !ISC_LIST_EMPTY(sock->recv_list)) {
+ !ISC_LIST_EMPTY(sock->recv_list))
+ {
isc_socketevent_t *dev;
isc_socketevent_t *next;
isc_task_t *current_task;
}
if (((how & ISC_SOCKCANCEL_SEND) != 0) &&
- !ISC_LIST_EMPTY(sock->send_list)) {
+ !ISC_LIST_EMPTY(sock->send_list))
+ {
isc_socketevent_t *dev;
isc_socketevent_t *next;
isc_task_t *current_task;
}
if (((how & ISC_SOCKCANCEL_ACCEPT) != 0) &&
- !ISC_LIST_EMPTY(sock->accept_list)) {
+ !ISC_LIST_EMPTY(sock->accept_list))
+ {
isc_socket_newconnev_t *dev;
isc_socket_newconnev_t *next;
isc_task_t *current_task;
#ifdef IP_TOS
if (sock->pf == AF_INET) {
if (setsockopt(sock->fd, IPPROTO_IP, IP_TOS, (void *)&value,
- sizeof(value)) < 0) {
+ sizeof(value)) < 0)
+ {
char strbuf[ISC_STRERRORSIZE];
strerror_r(errno, strbuf, sizeof(strbuf));
UNEXPECTED_ERROR(__FILE__, __LINE__,
}
}
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&yes,
- sizeof(yes)) < 0) {
+ sizeof(yes)) < 0)
+ {
close(sock);
return;
#if defined(__FreeBSD_kernel__)
/* 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);
* Fetch next file in directory.
*/
if (FindNextFile(dir->search_handle, &dir->entry.find_data) ==
- FALSE) {
+ FALSE)
+ {
/*
* Either the last file has been processed or
* an error has occurred. The former is not
for (;;) {
if (doopen) {
if ((*doopen = open(path, flags,
- _S_IREAD | _S_IWRITE)) >= 0) {
+ _S_IREAD | _S_IWRITE)) >= 0)
+ {
return (1);
}
if (errno != EEXIST) {
}
if (!GetFileTime((HANDLE)_get_osfhandle(fh), NULL, NULL,
- &time->absolute)) {
+ &time->absolute))
+ {
close(fh);
errno = EINVAL;
return (isc__errno2result(errno));
HANDLE hImpersonatedToken = NULL;
if (DuplicateToken(hToken, SecurityImpersonation,
- &hImpersonatedToken)) {
+ &hImpersonatedToken))
+ {
GENERIC_MAPPING mapping;
PRIVILEGE_SET privileges = { 0 };
DWORD grantedAccess = 0;
REQUIRE(filename != NULL);
if (isc_file_absolutepath(file, filename, sizeof(filename)) !=
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
return (FALSE);
}
}
if (NTFSbits ==
- (FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE)) {
+ (FILE_GENERIC_READ | FILE_GENERIC_WRITE | FILE_GENERIC_EXECUTE))
+ {
NTFSbits |= FILE_ALL_ACCESS;
}
/*
if (((fd_set FAR *)(set))->fd_array[__i] == \
(SOCKET)fd) { \
while (__i < \
- ((fd_set FAR *)(set))->fd_count - 1) { \
+ ((fd_set FAR *)(set))->fd_count - 1) \
+ { \
((fd_set FAR *)(set))->fd_array[__i] = \
((fd_set FAR *)(set)) \
->fd_array[__i + 1]; \
u_int __i; \
for (__i = 0; __i < ((fd_set FAR *)(set))->fd_count; __i++) { \
if (((fd_set FAR *)(set))->fd_array[__i] == \
- (SOCKET)(fd)) { \
+ (SOCKET)(fd)) \
+ { \
break; \
} \
} \
* case and retry.
*/
if (bytesReturned > 0 &&
- (bytesReturned < iter->buf4size)) {
+ (bytesReturned < iter->buf4size))
+ {
break;
}
}
on = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
ipv6only_result = ISC_R_NOTFOUND;
goto close;
}
on = 1;
if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, (const char *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
ipv6only_result = ISC_R_NOTFOUND;
goto close;
}
#endif /* ifdef IPV6_RECVPKTINFO */
on = 1;
if (setsockopt(s, IPPROTO_IPV6, optname, (const char *)&on,
- sizeof(on)) < 0) {
+ sizeof(on)) < 0)
+ {
ipv6pktinfo_result = ISC_R_NOTFOUND;
goto close;
}
* Loop through the entries
*/
for (i = 0; (i < dwEntriesRead && *totalGroups < maxgroups);
- i++) {
+ i++)
+ {
assert(pTmpLBuf != NULL);
if (pTmpLBuf == NULL) {
break;
* Loop through the entries
*/
for (i = 0; (i < dwEntriesRead && *totalGroups < maxgroups);
- i++) {
+ i++)
+ {
assert(pTmpBuf != NULL);
if (pTmpBuf == NULL) {
REQUIRE(VALID_MANAGER(manager));
for (i = 0; i < manager->maxIOCPThreads; i++) {
if (!PostQueuedCompletionStatus(manager->hIoCompletionPort, 0,
- 0, 0)) {
+ 0, 0))
+ {
errval = GetLastError();
strerror_r(errval, strbuf, sizeof(strbuf));
FATAL_ERROR(__FILE__, __LINE__,
* fd and pretend nothing strange happened.
*/
if (SOFT_ERROR(connect_errno) ||
- connect_errno == WSAEINPROGRESS) {
+ connect_errno == WSAEINPROGRESS)
+ {
sock->pending_connect = 1;
CONSISTENT(sock);
UNLOCK(&sock->lock);
* higher than the timer sync thread.
*/
if (!SetThreadPriority(GetCurrentThread(),
- THREAD_PRIORITY_ABOVE_NORMAL)) {
+ THREAD_PRIORITY_ABOVE_NORMAL))
+ {
errval = GetLastError();
strerror_r(errval, strbuf, sizeof(strbuf));
FATAL_ERROR(__FILE__, __LINE__, "Can't set thread priority: %s",
if (acceptdone_is_active(sock, lpo->adev)) {
if (restart_accept(sock, lpo) ==
- ISC_R_SUCCESS) {
+ ISC_R_SUCCESS)
+ {
UNLOCK(&sock->lock);
goto wait_again;
} else {
* queue it unless ISC_SOCKFLAG_NORETRY is set.
*/
if ((flags & ISC_SOCKFLAG_NORETRY) == 0 ||
- io_state == DOIO_PENDING) {
+ io_state == DOIO_PENDING)
+ {
isc_task_attach(task, &ntask);
dev->attributes |= ISC_SOCKEVENTATTR_ATTACHED;
#if defined(ENABLE_TCP_FASTOPEN) && defined(TCP_FASTOPEN)
if (setsockopt(sock->fd, IPPROTO_TCP, TCP_FASTOPEN, &on, sizeof(on)) <
- 0) {
+ 0)
+ {
strerror_r(errno, strbuf, sizeof(strbuf));
UNEXPECTED_ERROR(__FILE__, __LINE__,
"setsockopt(%d, TCP_FASTOPEN) failed with %s",
how &= ~ISC_SOCKCANCEL_SEND;
if (((how & ISC_SOCKCANCEL_ACCEPT) != 0) &&
- !ISC_LIST_EMPTY(sock->accept_list)) {
+ !ISC_LIST_EMPTY(sock->accept_list))
+ {
isc_socket_newconnev_t *dev;
isc_socket_newconnev_t *next;
isc_task_t *current_task;
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 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);
}
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;
continue;
}
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);
}
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) {
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 ipv6_wildcard = false;
isc_netaddr_t listen_netaddr;
* 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
* 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));
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_copynf(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);
}
}
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?
*/
}
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_copynf(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->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 & DNS_NAMEATTR_WILDCARD) == 0) {
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;
}
&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:
dns_message_setsortorder(client->message,
query_sortlist_order_1element, env,
*/
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) {
}
if (dns_aclelement_match(clientaddr, NULL, try_elt, env,
- &matched_elt)) {
+ &matched_elt))
+ {
if (order_elt != NULL) {
if (order_elt->type ==
- dns_aclelementtype_nestedacl) {
+ dns_aclelementtype_nestedacl)
+ {
*argp = order_elt->nestedacl;
return (NS_SORTLISTTYPE_2ELEMENT);
} else if (order_elt->type ==
break;
}
if (*rp != ' ' && *rp != '\t' && *rp != '\r' &&
- *rp != '\n') {
+ *rp != '\n')
+ {
*wp++ = *rp;
len++;
}
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
"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 "
* RFC1123 doesn't allow MF and MD in master zones.
*/
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,
dns_rdata_nsec3param_t nsec3param;
if (tuple->rdata.type != 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;
}
dns_rdata_tostruct(&rdata, &nsec3param, NULL);
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;
projects / thirdparty / bind9.git / commitdiff
